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_set_memsize\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_get_memsize\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 156   fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
 157   fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
 158   fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
 159   fprintf (stderr, "warning: \"guestfs_umask\" has no tests\n");
 160 }
 161
 162 static int test_mknod_c_0_skip (void)
 163 {
 164   const char *str;
 165
 166   str = getenv ("TEST_ONLY");
 167   if (str)
 168     return strstr (str, "mknod_c") == NULL;
 169   str = getenv ("SKIP_TEST_MKNOD_C_0");
 170   if (str && strcmp (str, "1") == 0) return 1;
 171   str = getenv ("SKIP_TEST_MKNOD_C");
 172   if (str && strcmp (str, "1") == 0) return 1;
 173   return 0;
 174 }
 175
 176 static int test_mknod_c_0 (void)
 177 {
 178   if (test_mknod_c_0_skip ()) {
 179     printf ("%s skipped (reason: environment variable set)\n", "test_mknod_c_0");
 180     return 0;
 181   }
 182
 183   /* InitBasicFS for test_mknod_c_0: create ext2 on /dev/sda1 */
 184   {
 185     char device[] = "/dev/sda";
 186     int r;
 187     suppress_error = 0;
 188     r = guestfs_blockdev_setrw (g, device);
 189     if (r == -1)
 190       return -1;
 191   }
 192   {
 193     int r;
 194     suppress_error = 0;
 195     r = guestfs_umount_all (g);
 196     if (r == -1)
 197       return -1;
 198   }
 199   {
 200     int r;
 201     suppress_error = 0;
 202     r = guestfs_lvm_remove_all (g);
 203     if (r == -1)
 204       return -1;
 205   }
 206   {
 207     char device[] = "/dev/sda";
 208     char lines_0[] = ",";
 209     char *lines[] = {
 210       lines_0,
 211       NULL
 212     };
 213     int r;
 214     suppress_error = 0;
 215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 216     if (r == -1)
 217       return -1;
 218   }
 219   {
 220     char fstype[] = "ext2";
 221     char device[] = "/dev/sda1";
 222     int r;
 223     suppress_error = 0;
 224     r = guestfs_mkfs (g, fstype, device);
 225     if (r == -1)
 226       return -1;
 227   }
 228   {
 229     char device[] = "/dev/sda1";
 230     char mountpoint[] = "/";
 231     int r;
 232     suppress_error = 0;
 233     r = guestfs_mount (g, device, mountpoint);
 234     if (r == -1)
 235       return -1;
 236   }
 237   /* TestOutputStruct for mknod_c (0) */
 238   {
 239     char path[] = "/node";
 240     int r;
 241     suppress_error = 0;
 242     r = guestfs_mknod_c (g, 511, 99, 66, path);
 243     if (r == -1)
 244       return -1;
 245   }
 246   {
 247     char path[] = "/node";
 248     struct guestfs_stat *r;
 249     suppress_error = 0;
 250     r = guestfs_stat (g, path);
 251     if (r == NULL)
 252       return -1;
 253     if (r->mode != 8685) {
 254       fprintf (stderr, "test_mknod_c_0: mode was %d, expected 8685\n",
 255                (int) r->mode);
 256       return -1;
 257     }
 258     free (r);
 259   }
 260   return 0;
 261 }
 262
 263 static int test_mknod_b_0_skip (void)
 264 {
 265   const char *str;
 266
 267   str = getenv ("TEST_ONLY");
 268   if (str)
 269     return strstr (str, "mknod_b") == NULL;
 270   str = getenv ("SKIP_TEST_MKNOD_B_0");
 271   if (str && strcmp (str, "1") == 0) return 1;
 272   str = getenv ("SKIP_TEST_MKNOD_B");
 273   if (str && strcmp (str, "1") == 0) return 1;
 274   return 0;
 275 }
 276
 277 static int test_mknod_b_0 (void)
 278 {
 279   if (test_mknod_b_0_skip ()) {
 280     printf ("%s skipped (reason: environment variable set)\n", "test_mknod_b_0");
 281     return 0;
 282   }
 283
 284   /* InitBasicFS for test_mknod_b_0: create ext2 on /dev/sda1 */
 285   {
 286     char device[] = "/dev/sda";
 287     int r;
 288     suppress_error = 0;
 289     r = guestfs_blockdev_setrw (g, device);
 290     if (r == -1)
 291       return -1;
 292   }
 293   {
 294     int r;
 295     suppress_error = 0;
 296     r = guestfs_umount_all (g);
 297     if (r == -1)
 298       return -1;
 299   }
 300   {
 301     int r;
 302     suppress_error = 0;
 303     r = guestfs_lvm_remove_all (g);
 304     if (r == -1)
 305       return -1;
 306   }
 307   {
 308     char device[] = "/dev/sda";
 309     char lines_0[] = ",";
 310     char *lines[] = {
 311       lines_0,
 312       NULL
 313     };
 314     int r;
 315     suppress_error = 0;
 316     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 317     if (r == -1)
 318       return -1;
 319   }
 320   {
 321     char fstype[] = "ext2";
 322     char device[] = "/dev/sda1";
 323     int r;
 324     suppress_error = 0;
 325     r = guestfs_mkfs (g, fstype, device);
 326     if (r == -1)
 327       return -1;
 328   }
 329   {
 330     char device[] = "/dev/sda1";
 331     char mountpoint[] = "/";
 332     int r;
 333     suppress_error = 0;
 334     r = guestfs_mount (g, device, mountpoint);
 335     if (r == -1)
 336       return -1;
 337   }
 338   /* TestOutputStruct for mknod_b (0) */
 339   {
 340     char path[] = "/node";
 341     int r;
 342     suppress_error = 0;
 343     r = guestfs_mknod_b (g, 511, 99, 66, path);
 344     if (r == -1)
 345       return -1;
 346   }
 347   {
 348     char path[] = "/node";
 349     struct guestfs_stat *r;
 350     suppress_error = 0;
 351     r = guestfs_stat (g, path);
 352     if (r == NULL)
 353       return -1;
 354     if (r->mode != 25069) {
 355       fprintf (stderr, "test_mknod_b_0: mode was %d, expected 25069\n",
 356                (int) r->mode);
 357       return -1;
 358     }
 359     free (r);
 360   }
 361   return 0;
 362 }
 363
 364 static int test_mkfifo_0_skip (void)
 365 {
 366   const char *str;
 367
 368   str = getenv ("TEST_ONLY");
 369   if (str)
 370     return strstr (str, "mkfifo") == NULL;
 371   str = getenv ("SKIP_TEST_MKFIFO_0");
 372   if (str && strcmp (str, "1") == 0) return 1;
 373   str = getenv ("SKIP_TEST_MKFIFO");
 374   if (str && strcmp (str, "1") == 0) return 1;
 375   return 0;
 376 }
 377
 378 static int test_mkfifo_0 (void)
 379 {
 380   if (test_mkfifo_0_skip ()) {
 381     printf ("%s skipped (reason: environment variable set)\n", "test_mkfifo_0");
 382     return 0;
 383   }
 384
 385   /* InitBasicFS for test_mkfifo_0: create ext2 on /dev/sda1 */
 386   {
 387     char device[] = "/dev/sda";
 388     int r;
 389     suppress_error = 0;
 390     r = guestfs_blockdev_setrw (g, device);
 391     if (r == -1)
 392       return -1;
 393   }
 394   {
 395     int r;
 396     suppress_error = 0;
 397     r = guestfs_umount_all (g);
 398     if (r == -1)
 399       return -1;
 400   }
 401   {
 402     int r;
 403     suppress_error = 0;
 404     r = guestfs_lvm_remove_all (g);
 405     if (r == -1)
 406       return -1;
 407   }
 408   {
 409     char device[] = "/dev/sda";
 410     char lines_0[] = ",";
 411     char *lines[] = {
 412       lines_0,
 413       NULL
 414     };
 415     int r;
 416     suppress_error = 0;
 417     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 418     if (r == -1)
 419       return -1;
 420   }
 421   {
 422     char fstype[] = "ext2";
 423     char device[] = "/dev/sda1";
 424     int r;
 425     suppress_error = 0;
 426     r = guestfs_mkfs (g, fstype, device);
 427     if (r == -1)
 428       return -1;
 429   }
 430   {
 431     char device[] = "/dev/sda1";
 432     char mountpoint[] = "/";
 433     int r;
 434     suppress_error = 0;
 435     r = guestfs_mount (g, device, mountpoint);
 436     if (r == -1)
 437       return -1;
 438   }
 439   /* TestOutputStruct for mkfifo (0) */
 440   {
 441     char path[] = "/node";
 442     int r;
 443     suppress_error = 0;
 444     r = guestfs_mkfifo (g, 511, path);
 445     if (r == -1)
 446       return -1;
 447   }
 448   {
 449     char path[] = "/node";
 450     struct guestfs_stat *r;
 451     suppress_error = 0;
 452     r = guestfs_stat (g, path);
 453     if (r == NULL)
 454       return -1;
 455     if (r->mode != 4589) {
 456       fprintf (stderr, "test_mkfifo_0: mode was %d, expected 4589\n",
 457                (int) r->mode);
 458       return -1;
 459     }
 460     free (r);
 461   }
 462   return 0;
 463 }
 464
 465 static int test_mknod_0_skip (void)
 466 {
 467   const char *str;
 468
 469   str = getenv ("TEST_ONLY");
 470   if (str)
 471     return strstr (str, "mknod") == NULL;
 472   str = getenv ("SKIP_TEST_MKNOD_0");
 473   if (str && strcmp (str, "1") == 0) return 1;
 474   str = getenv ("SKIP_TEST_MKNOD");
 475   if (str && strcmp (str, "1") == 0) return 1;
 476   return 0;
 477 }
 478
 479 static int test_mknod_0 (void)
 480 {
 481   if (test_mknod_0_skip ()) {
 482     printf ("%s skipped (reason: environment variable set)\n", "test_mknod_0");
 483     return 0;
 484   }
 485
 486   /* InitBasicFS for test_mknod_0: create ext2 on /dev/sda1 */
 487   {
 488     char device[] = "/dev/sda";
 489     int r;
 490     suppress_error = 0;
 491     r = guestfs_blockdev_setrw (g, device);
 492     if (r == -1)
 493       return -1;
 494   }
 495   {
 496     int r;
 497     suppress_error = 0;
 498     r = guestfs_umount_all (g);
 499     if (r == -1)
 500       return -1;
 501   }
 502   {
 503     int r;
 504     suppress_error = 0;
 505     r = guestfs_lvm_remove_all (g);
 506     if (r == -1)
 507       return -1;
 508   }
 509   {
 510     char device[] = "/dev/sda";
 511     char lines_0[] = ",";
 512     char *lines[] = {
 513       lines_0,
 514       NULL
 515     };
 516     int r;
 517     suppress_error = 0;
 518     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 519     if (r == -1)
 520       return -1;
 521   }
 522   {
 523     char fstype[] = "ext2";
 524     char device[] = "/dev/sda1";
 525     int r;
 526     suppress_error = 0;
 527     r = guestfs_mkfs (g, fstype, device);
 528     if (r == -1)
 529       return -1;
 530   }
 531   {
 532     char device[] = "/dev/sda1";
 533     char mountpoint[] = "/";
 534     int r;
 535     suppress_error = 0;
 536     r = guestfs_mount (g, device, mountpoint);
 537     if (r == -1)
 538       return -1;
 539   }
 540   /* TestOutputStruct for mknod (0) */
 541   {
 542     char path[] = "/node";
 543     int r;
 544     suppress_error = 0;
 545     r = guestfs_mknod (g, 4607, 0, 0, path);
 546     if (r == -1)
 547       return -1;
 548   }
 549   {
 550     char path[] = "/node";
 551     struct guestfs_stat *r;
 552     suppress_error = 0;
 553     r = guestfs_stat (g, path);
 554     if (r == NULL)
 555       return -1;
 556     if (r->mode != 4589) {
 557       fprintf (stderr, "test_mknod_0: mode was %d, expected 4589\n",
 558                (int) r->mode);
 559       return -1;
 560     }
 561     free (r);
 562   }
 563   return 0;
 564 }
 565
 566 static int test_mknod_1_skip (void)
 567 {
 568   const char *str;
 569
 570   str = getenv ("TEST_ONLY");
 571   if (str)
 572     return strstr (str, "mknod") == NULL;
 573   str = getenv ("SKIP_TEST_MKNOD_1");
 574   if (str && strcmp (str, "1") == 0) return 1;
 575   str = getenv ("SKIP_TEST_MKNOD");
 576   if (str && strcmp (str, "1") == 0) return 1;
 577   return 0;
 578 }
 579
 580 static int test_mknod_1 (void)
 581 {
 582   if (test_mknod_1_skip ()) {
 583     printf ("%s skipped (reason: environment variable set)\n", "test_mknod_1");
 584     return 0;
 585   }
 586
 587   /* InitBasicFS for test_mknod_1: create ext2 on /dev/sda1 */
 588   {
 589     char device[] = "/dev/sda";
 590     int r;
 591     suppress_error = 0;
 592     r = guestfs_blockdev_setrw (g, device);
 593     if (r == -1)
 594       return -1;
 595   }
 596   {
 597     int r;
 598     suppress_error = 0;
 599     r = guestfs_umount_all (g);
 600     if (r == -1)
 601       return -1;
 602   }
 603   {
 604     int r;
 605     suppress_error = 0;
 606     r = guestfs_lvm_remove_all (g);
 607     if (r == -1)
 608       return -1;
 609   }
 610   {
 611     char device[] = "/dev/sda";
 612     char lines_0[] = ",";
 613     char *lines[] = {
 614       lines_0,
 615       NULL
 616     };
 617     int r;
 618     suppress_error = 0;
 619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 620     if (r == -1)
 621       return -1;
 622   }
 623   {
 624     char fstype[] = "ext2";
 625     char device[] = "/dev/sda1";
 626     int r;
 627     suppress_error = 0;
 628     r = guestfs_mkfs (g, fstype, device);
 629     if (r == -1)
 630       return -1;
 631   }
 632   {
 633     char device[] = "/dev/sda1";
 634     char mountpoint[] = "/";
 635     int r;
 636     suppress_error = 0;
 637     r = guestfs_mount (g, device, mountpoint);
 638     if (r == -1)
 639       return -1;
 640   }
 641   /* TestOutputStruct for mknod (1) */
 642   {
 643     char path[] = "/node";
 644     int r;
 645     suppress_error = 0;
 646     r = guestfs_mknod (g, 25087, 66, 99, path);
 647     if (r == -1)
 648       return -1;
 649   }
 650   {
 651     char path[] = "/node";
 652     struct guestfs_stat *r;
 653     suppress_error = 0;
 654     r = guestfs_stat (g, path);
 655     if (r == NULL)
 656       return -1;
 657     if (r->mode != 25069) {
 658       fprintf (stderr, "test_mknod_1: mode was %d, expected 25069\n",
 659                (int) r->mode);
 660       return -1;
 661     }
 662     free (r);
 663   }
 664   return 0;
 665 }
 666
 667 static int test_mkswap_U_0_skip (void)
 668 {
 669   const char *str;
 670
 671   str = getenv ("TEST_ONLY");
 672   if (str)
 673     return strstr (str, "mkswap_U") == NULL;
 674   str = getenv ("SKIP_TEST_MKSWAP_U_0");
 675   if (str && strcmp (str, "1") == 0) return 1;
 676   str = getenv ("SKIP_TEST_MKSWAP_U");
 677   if (str && strcmp (str, "1") == 0) return 1;
 678   return 0;
 679 }
 680
 681 static int test_mkswap_U_0 (void)
 682 {
 683   if (test_mkswap_U_0_skip ()) {
 684     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
 685     return 0;
 686   }
 687
 688   /* InitNone|InitEmpty for test_mkswap_U_0 */
 689   {
 690     char device[] = "/dev/sda";
 691     int r;
 692     suppress_error = 0;
 693     r = guestfs_blockdev_setrw (g, device);
 694     if (r == -1)
 695       return -1;
 696   }
 697   {
 698     int r;
 699     suppress_error = 0;
 700     r = guestfs_umount_all (g);
 701     if (r == -1)
 702       return -1;
 703   }
 704   {
 705     int r;
 706     suppress_error = 0;
 707     r = guestfs_lvm_remove_all (g);
 708     if (r == -1)
 709       return -1;
 710   }
 711   /* TestRun for mkswap_U (0) */
 712   {
 713     char device[] = "/dev/sda";
 714     char lines_0[] = ",";
 715     char *lines[] = {
 716       lines_0,
 717       NULL
 718     };
 719     int r;
 720     suppress_error = 0;
 721     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 722     if (r == -1)
 723       return -1;
 724   }
 725   {
 726     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
 727     char device[] = "/dev/sda1";
 728     int r;
 729     suppress_error = 0;
 730     r = guestfs_mkswap_U (g, uuid, device);
 731     if (r == -1)
 732       return -1;
 733   }
 734   return 0;
 735 }
 736
 737 static int test_mkswap_L_0_skip (void)
 738 {
 739   const char *str;
 740
 741   str = getenv ("TEST_ONLY");
 742   if (str)
 743     return strstr (str, "mkswap_L") == NULL;
 744   str = getenv ("SKIP_TEST_MKSWAP_L_0");
 745   if (str && strcmp (str, "1") == 0) return 1;
 746   str = getenv ("SKIP_TEST_MKSWAP_L");
 747   if (str && strcmp (str, "1") == 0) return 1;
 748   return 0;
 749 }
 750
 751 static int test_mkswap_L_0 (void)
 752 {
 753   if (test_mkswap_L_0_skip ()) {
 754     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
 755     return 0;
 756   }
 757
 758   /* InitNone|InitEmpty for test_mkswap_L_0 */
 759   {
 760     char device[] = "/dev/sda";
 761     int r;
 762     suppress_error = 0;
 763     r = guestfs_blockdev_setrw (g, device);
 764     if (r == -1)
 765       return -1;
 766   }
 767   {
 768     int r;
 769     suppress_error = 0;
 770     r = guestfs_umount_all (g);
 771     if (r == -1)
 772       return -1;
 773   }
 774   {
 775     int r;
 776     suppress_error = 0;
 777     r = guestfs_lvm_remove_all (g);
 778     if (r == -1)
 779       return -1;
 780   }
 781   /* TestRun for mkswap_L (0) */
 782   {
 783     char device[] = "/dev/sda";
 784     char lines_0[] = ",";
 785     char *lines[] = {
 786       lines_0,
 787       NULL
 788     };
 789     int r;
 790     suppress_error = 0;
 791     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 792     if (r == -1)
 793       return -1;
 794   }
 795   {
 796     char label[] = "hello";
 797     char device[] = "/dev/sda1";
 798     int r;
 799     suppress_error = 0;
 800     r = guestfs_mkswap_L (g, label, device);
 801     if (r == -1)
 802       return -1;
 803   }
 804   return 0;
 805 }
 806
 807 static int test_mkswap_0_skip (void)
 808 {
 809   const char *str;
 810
 811   str = getenv ("TEST_ONLY");
 812   if (str)
 813     return strstr (str, "mkswap") == NULL;
 814   str = getenv ("SKIP_TEST_MKSWAP_0");
 815   if (str && strcmp (str, "1") == 0) return 1;
 816   str = getenv ("SKIP_TEST_MKSWAP");
 817   if (str && strcmp (str, "1") == 0) return 1;
 818   return 0;
 819 }
 820
 821 static int test_mkswap_0 (void)
 822 {
 823   if (test_mkswap_0_skip ()) {
 824     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_0");
 825     return 0;
 826   }
 827
 828   /* InitNone|InitEmpty for test_mkswap_0 */
 829   {
 830     char device[] = "/dev/sda";
 831     int r;
 832     suppress_error = 0;
 833     r = guestfs_blockdev_setrw (g, device);
 834     if (r == -1)
 835       return -1;
 836   }
 837   {
 838     int r;
 839     suppress_error = 0;
 840     r = guestfs_umount_all (g);
 841     if (r == -1)
 842       return -1;
 843   }
 844   {
 845     int r;
 846     suppress_error = 0;
 847     r = guestfs_lvm_remove_all (g);
 848     if (r == -1)
 849       return -1;
 850   }
 851   /* TestRun for mkswap (0) */
 852   {
 853     char device[] = "/dev/sda";
 854     char lines_0[] = ",";
 855     char *lines[] = {
 856       lines_0,
 857       NULL
 858     };
 859     int r;
 860     suppress_error = 0;
 861     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 862     if (r == -1)
 863       return -1;
 864   }
 865   {
 866     char device[] = "/dev/sda1";
 867     int r;
 868     suppress_error = 0;
 869     r = guestfs_mkswap (g, device);
 870     if (r == -1)
 871       return -1;
 872   }
 873   return 0;
 874 }
 875
 876 static int test_initrd_list_0_skip (void)
 877 {
 878   const char *str;
 879
 880   str = getenv ("TEST_ONLY");
 881   if (str)
 882     return strstr (str, "initrd_list") == NULL;
 883   str = getenv ("SKIP_TEST_INITRD_LIST_0");
 884   if (str && strcmp (str, "1") == 0) return 1;
 885   str = getenv ("SKIP_TEST_INITRD_LIST");
 886   if (str && strcmp (str, "1") == 0) return 1;
 887   return 0;
 888 }
 889
 890 static int test_initrd_list_0 (void)
 891 {
 892   if (test_initrd_list_0_skip ()) {
 893     printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
 894     return 0;
 895   }
 896
 897   /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
 898   {
 899     char device[] = "/dev/sda";
 900     int r;
 901     suppress_error = 0;
 902     r = guestfs_blockdev_setrw (g, device);
 903     if (r == -1)
 904       return -1;
 905   }
 906   {
 907     int r;
 908     suppress_error = 0;
 909     r = guestfs_umount_all (g);
 910     if (r == -1)
 911       return -1;
 912   }
 913   {
 914     int r;
 915     suppress_error = 0;
 916     r = guestfs_lvm_remove_all (g);
 917     if (r == -1)
 918       return -1;
 919   }
 920   {
 921     char device[] = "/dev/sda";
 922     char lines_0[] = ",";
 923     char *lines[] = {
 924       lines_0,
 925       NULL
 926     };
 927     int r;
 928     suppress_error = 0;
 929     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 930     if (r == -1)
 931       return -1;
 932   }
 933   {
 934     char fstype[] = "ext2";
 935     char device[] = "/dev/sda1";
 936     int r;
 937     suppress_error = 0;
 938     r = guestfs_mkfs (g, fstype, device);
 939     if (r == -1)
 940       return -1;
 941   }
 942   {
 943     char device[] = "/dev/sda1";
 944     char mountpoint[] = "/";
 945     int r;
 946     suppress_error = 0;
 947     r = guestfs_mount (g, device, mountpoint);
 948     if (r == -1)
 949       return -1;
 950   }
 951   /* TestOutputList for initrd_list (0) */
 952   {
 953     char options[] = "ro";
 954     char vfstype[] = "squashfs";
 955     char device[] = "/dev/sdd";
 956     char mountpoint[] = "/";
 957     int r;
 958     suppress_error = 0;
 959     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 960     if (r == -1)
 961       return -1;
 962   }
 963   {
 964     char path[] = "/initrd";
 965     char **r;
 966     int i;
 967     suppress_error = 0;
 968     r = guestfs_initrd_list (g, path);
 969     if (r == NULL)
 970       return -1;
 971     if (!r[0]) {
 972       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 973       print_strings (r);
 974       return -1;
 975     }
 976     {
 977       char expected[] = "empty";
 978       if (strcmp (r[0], expected) != 0) {
 979         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 980         return -1;
 981       }
 982     }
 983     if (!r[1]) {
 984       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 985       print_strings (r);
 986       return -1;
 987     }
 988     {
 989       char expected[] = "known-1";
 990       if (strcmp (r[1], expected) != 0) {
 991         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 992         return -1;
 993       }
 994     }
 995     if (!r[2]) {
 996       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 997       print_strings (r);
 998       return -1;
 999     }
1000     {
1001       char expected[] = "known-2";
1002       if (strcmp (r[2], expected) != 0) {
1003         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1004         return -1;
1005       }
1006     }
1007     if (!r[3]) {
1008       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
1009       print_strings (r);
1010       return -1;
1011     }
1012     {
1013       char expected[] = "known-3";
1014       if (strcmp (r[3], expected) != 0) {
1015         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1016         return -1;
1017       }
1018     }
1019     if (r[4] != NULL) {
1020       fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
1021       print_strings (r);
1022       return -1;
1023     }
1024     for (i = 0; r[i] != NULL; ++i)
1025       free (r[i]);
1026     free (r);
1027   }
1028   return 0;
1029 }
1030
1031 static int test_du_0_skip (void)
1032 {
1033   const char *str;
1034
1035   str = getenv ("TEST_ONLY");
1036   if (str)
1037     return strstr (str, "du") == NULL;
1038   str = getenv ("SKIP_TEST_DU_0");
1039   if (str && strcmp (str, "1") == 0) return 1;
1040   str = getenv ("SKIP_TEST_DU");
1041   if (str && strcmp (str, "1") == 0) return 1;
1042   return 0;
1043 }
1044
1045 static int test_du_0 (void)
1046 {
1047   if (test_du_0_skip ()) {
1048     printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
1049     return 0;
1050   }
1051
1052   /* InitBasicFS for test_du_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   /* TestOutputInt for du (0) */
1107   {
1108     char path[] = "/p";
1109     int r;
1110     suppress_error = 0;
1111     r = guestfs_mkdir (g, path);
1112     if (r == -1)
1113       return -1;
1114   }
1115   {
1116     char path[] = "/p";
1117     int64_t r;
1118     suppress_error = 0;
1119     r = guestfs_du (g, path);
1120     if (r == -1)
1121       return -1;
1122     if (r != 1) {
1123       fprintf (stderr, "test_du_0: expected 1 but got %d\n",               (int) r);
1124       return -1;
1125     }
1126   }
1127   return 0;
1128 }
1129
1130 static int test_tail_n_0_skip (void)
1131 {
1132   const char *str;
1133
1134   str = getenv ("TEST_ONLY");
1135   if (str)
1136     return strstr (str, "tail_n") == NULL;
1137   str = getenv ("SKIP_TEST_TAIL_N_0");
1138   if (str && strcmp (str, "1") == 0) return 1;
1139   str = getenv ("SKIP_TEST_TAIL_N");
1140   if (str && strcmp (str, "1") == 0) return 1;
1141   return 0;
1142 }
1143
1144 static int test_tail_n_0 (void)
1145 {
1146   if (test_tail_n_0_skip ()) {
1147     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
1148     return 0;
1149   }
1150
1151   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
1152   {
1153     char device[] = "/dev/sda";
1154     int r;
1155     suppress_error = 0;
1156     r = guestfs_blockdev_setrw (g, device);
1157     if (r == -1)
1158       return -1;
1159   }
1160   {
1161     int r;
1162     suppress_error = 0;
1163     r = guestfs_umount_all (g);
1164     if (r == -1)
1165       return -1;
1166   }
1167   {
1168     int r;
1169     suppress_error = 0;
1170     r = guestfs_lvm_remove_all (g);
1171     if (r == -1)
1172       return -1;
1173   }
1174   {
1175     char device[] = "/dev/sda";
1176     char lines_0[] = ",";
1177     char *lines[] = {
1178       lines_0,
1179       NULL
1180     };
1181     int r;
1182     suppress_error = 0;
1183     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1184     if (r == -1)
1185       return -1;
1186   }
1187   {
1188     char fstype[] = "ext2";
1189     char device[] = "/dev/sda1";
1190     int r;
1191     suppress_error = 0;
1192     r = guestfs_mkfs (g, fstype, device);
1193     if (r == -1)
1194       return -1;
1195   }
1196   {
1197     char device[] = "/dev/sda1";
1198     char mountpoint[] = "/";
1199     int r;
1200     suppress_error = 0;
1201     r = guestfs_mount (g, device, mountpoint);
1202     if (r == -1)
1203       return -1;
1204   }
1205   /* TestOutputList for tail_n (0) */
1206   {
1207     char options[] = "ro";
1208     char vfstype[] = "squashfs";
1209     char device[] = "/dev/sdd";
1210     char mountpoint[] = "/";
1211     int r;
1212     suppress_error = 0;
1213     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1214     if (r == -1)
1215       return -1;
1216   }
1217   {
1218     char path[] = "/10klines";
1219     char **r;
1220     int i;
1221     suppress_error = 0;
1222     r = guestfs_tail_n (g, 3, path);
1223     if (r == NULL)
1224       return -1;
1225     if (!r[0]) {
1226       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1227       print_strings (r);
1228       return -1;
1229     }
1230     {
1231       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1232       if (strcmp (r[0], expected) != 0) {
1233         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1234         return -1;
1235       }
1236     }
1237     if (!r[1]) {
1238       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1239       print_strings (r);
1240       return -1;
1241     }
1242     {
1243       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1244       if (strcmp (r[1], expected) != 0) {
1245         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1246         return -1;
1247       }
1248     }
1249     if (!r[2]) {
1250       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1251       print_strings (r);
1252       return -1;
1253     }
1254     {
1255       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1256       if (strcmp (r[2], expected) != 0) {
1257         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1258         return -1;
1259       }
1260     }
1261     if (r[3] != NULL) {
1262       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
1263       print_strings (r);
1264       return -1;
1265     }
1266     for (i = 0; r[i] != NULL; ++i)
1267       free (r[i]);
1268     free (r);
1269   }
1270   return 0;
1271 }
1272
1273 static int test_tail_n_1_skip (void)
1274 {
1275   const char *str;
1276
1277   str = getenv ("TEST_ONLY");
1278   if (str)
1279     return strstr (str, "tail_n") == NULL;
1280   str = getenv ("SKIP_TEST_TAIL_N_1");
1281   if (str && strcmp (str, "1") == 0) return 1;
1282   str = getenv ("SKIP_TEST_TAIL_N");
1283   if (str && strcmp (str, "1") == 0) return 1;
1284   return 0;
1285 }
1286
1287 static int test_tail_n_1 (void)
1288 {
1289   if (test_tail_n_1_skip ()) {
1290     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
1291     return 0;
1292   }
1293
1294   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
1295   {
1296     char device[] = "/dev/sda";
1297     int r;
1298     suppress_error = 0;
1299     r = guestfs_blockdev_setrw (g, device);
1300     if (r == -1)
1301       return -1;
1302   }
1303   {
1304     int r;
1305     suppress_error = 0;
1306     r = guestfs_umount_all (g);
1307     if (r == -1)
1308       return -1;
1309   }
1310   {
1311     int r;
1312     suppress_error = 0;
1313     r = guestfs_lvm_remove_all (g);
1314     if (r == -1)
1315       return -1;
1316   }
1317   {
1318     char device[] = "/dev/sda";
1319     char lines_0[] = ",";
1320     char *lines[] = {
1321       lines_0,
1322       NULL
1323     };
1324     int r;
1325     suppress_error = 0;
1326     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1327     if (r == -1)
1328       return -1;
1329   }
1330   {
1331     char fstype[] = "ext2";
1332     char device[] = "/dev/sda1";
1333     int r;
1334     suppress_error = 0;
1335     r = guestfs_mkfs (g, fstype, device);
1336     if (r == -1)
1337       return -1;
1338   }
1339   {
1340     char device[] = "/dev/sda1";
1341     char mountpoint[] = "/";
1342     int r;
1343     suppress_error = 0;
1344     r = guestfs_mount (g, device, mountpoint);
1345     if (r == -1)
1346       return -1;
1347   }
1348   /* TestOutputList for tail_n (1) */
1349   {
1350     char options[] = "ro";
1351     char vfstype[] = "squashfs";
1352     char device[] = "/dev/sdd";
1353     char mountpoint[] = "/";
1354     int r;
1355     suppress_error = 0;
1356     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1357     if (r == -1)
1358       return -1;
1359   }
1360   {
1361     char path[] = "/10klines";
1362     char **r;
1363     int i;
1364     suppress_error = 0;
1365     r = guestfs_tail_n (g, -9998, path);
1366     if (r == NULL)
1367       return -1;
1368     if (!r[0]) {
1369       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1370       print_strings (r);
1371       return -1;
1372     }
1373     {
1374       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1375       if (strcmp (r[0], expected) != 0) {
1376         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1377         return -1;
1378       }
1379     }
1380     if (!r[1]) {
1381       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1382       print_strings (r);
1383       return -1;
1384     }
1385     {
1386       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1387       if (strcmp (r[1], expected) != 0) {
1388         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1389         return -1;
1390       }
1391     }
1392     if (!r[2]) {
1393       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1394       print_strings (r);
1395       return -1;
1396     }
1397     {
1398       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1399       if (strcmp (r[2], expected) != 0) {
1400         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1401         return -1;
1402       }
1403     }
1404     if (r[3] != NULL) {
1405       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
1406       print_strings (r);
1407       return -1;
1408     }
1409     for (i = 0; r[i] != NULL; ++i)
1410       free (r[i]);
1411     free (r);
1412   }
1413   return 0;
1414 }
1415
1416 static int test_tail_n_2_skip (void)
1417 {
1418   const char *str;
1419
1420   str = getenv ("TEST_ONLY");
1421   if (str)
1422     return strstr (str, "tail_n") == NULL;
1423   str = getenv ("SKIP_TEST_TAIL_N_2");
1424   if (str && strcmp (str, "1") == 0) return 1;
1425   str = getenv ("SKIP_TEST_TAIL_N");
1426   if (str && strcmp (str, "1") == 0) return 1;
1427   return 0;
1428 }
1429
1430 static int test_tail_n_2 (void)
1431 {
1432   if (test_tail_n_2_skip ()) {
1433     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
1434     return 0;
1435   }
1436
1437   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
1438   {
1439     char device[] = "/dev/sda";
1440     int r;
1441     suppress_error = 0;
1442     r = guestfs_blockdev_setrw (g, device);
1443     if (r == -1)
1444       return -1;
1445   }
1446   {
1447     int r;
1448     suppress_error = 0;
1449     r = guestfs_umount_all (g);
1450     if (r == -1)
1451       return -1;
1452   }
1453   {
1454     int r;
1455     suppress_error = 0;
1456     r = guestfs_lvm_remove_all (g);
1457     if (r == -1)
1458       return -1;
1459   }
1460   {
1461     char device[] = "/dev/sda";
1462     char lines_0[] = ",";
1463     char *lines[] = {
1464       lines_0,
1465       NULL
1466     };
1467     int r;
1468     suppress_error = 0;
1469     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1470     if (r == -1)
1471       return -1;
1472   }
1473   {
1474     char fstype[] = "ext2";
1475     char device[] = "/dev/sda1";
1476     int r;
1477     suppress_error = 0;
1478     r = guestfs_mkfs (g, fstype, device);
1479     if (r == -1)
1480       return -1;
1481   }
1482   {
1483     char device[] = "/dev/sda1";
1484     char mountpoint[] = "/";
1485     int r;
1486     suppress_error = 0;
1487     r = guestfs_mount (g, device, mountpoint);
1488     if (r == -1)
1489       return -1;
1490   }
1491   /* TestOutputList for tail_n (2) */
1492   {
1493     char options[] = "ro";
1494     char vfstype[] = "squashfs";
1495     char device[] = "/dev/sdd";
1496     char mountpoint[] = "/";
1497     int r;
1498     suppress_error = 0;
1499     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1500     if (r == -1)
1501       return -1;
1502   }
1503   {
1504     char path[] = "/10klines";
1505     char **r;
1506     int i;
1507     suppress_error = 0;
1508     r = guestfs_tail_n (g, 0, path);
1509     if (r == NULL)
1510       return -1;
1511     if (r[0] != NULL) {
1512       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1513       print_strings (r);
1514       return -1;
1515     }
1516     for (i = 0; r[i] != NULL; ++i)
1517       free (r[i]);
1518     free (r);
1519   }
1520   return 0;
1521 }
1522
1523 static int test_tail_0_skip (void)
1524 {
1525   const char *str;
1526
1527   str = getenv ("TEST_ONLY");
1528   if (str)
1529     return strstr (str, "tail") == NULL;
1530   str = getenv ("SKIP_TEST_TAIL_0");
1531   if (str && strcmp (str, "1") == 0) return 1;
1532   str = getenv ("SKIP_TEST_TAIL");
1533   if (str && strcmp (str, "1") == 0) return 1;
1534   return 0;
1535 }
1536
1537 static int test_tail_0 (void)
1538 {
1539   if (test_tail_0_skip ()) {
1540     printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
1541     return 0;
1542   }
1543
1544   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1545   {
1546     char device[] = "/dev/sda";
1547     int r;
1548     suppress_error = 0;
1549     r = guestfs_blockdev_setrw (g, device);
1550     if (r == -1)
1551       return -1;
1552   }
1553   {
1554     int r;
1555     suppress_error = 0;
1556     r = guestfs_umount_all (g);
1557     if (r == -1)
1558       return -1;
1559   }
1560   {
1561     int r;
1562     suppress_error = 0;
1563     r = guestfs_lvm_remove_all (g);
1564     if (r == -1)
1565       return -1;
1566   }
1567   {
1568     char device[] = "/dev/sda";
1569     char lines_0[] = ",";
1570     char *lines[] = {
1571       lines_0,
1572       NULL
1573     };
1574     int r;
1575     suppress_error = 0;
1576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1577     if (r == -1)
1578       return -1;
1579   }
1580   {
1581     char fstype[] = "ext2";
1582     char device[] = "/dev/sda1";
1583     int r;
1584     suppress_error = 0;
1585     r = guestfs_mkfs (g, fstype, device);
1586     if (r == -1)
1587       return -1;
1588   }
1589   {
1590     char device[] = "/dev/sda1";
1591     char mountpoint[] = "/";
1592     int r;
1593     suppress_error = 0;
1594     r = guestfs_mount (g, device, mountpoint);
1595     if (r == -1)
1596       return -1;
1597   }
1598   /* TestOutputList for tail (0) */
1599   {
1600     char options[] = "ro";
1601     char vfstype[] = "squashfs";
1602     char device[] = "/dev/sdd";
1603     char mountpoint[] = "/";
1604     int r;
1605     suppress_error = 0;
1606     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1607     if (r == -1)
1608       return -1;
1609   }
1610   {
1611     char path[] = "/10klines";
1612     char **r;
1613     int i;
1614     suppress_error = 0;
1615     r = guestfs_tail (g, path);
1616     if (r == NULL)
1617       return -1;
1618     if (!r[0]) {
1619       fprintf (stderr, "test_tail_0: short list returned from command\n");
1620       print_strings (r);
1621       return -1;
1622     }
1623     {
1624       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1625       if (strcmp (r[0], expected) != 0) {
1626         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1627         return -1;
1628       }
1629     }
1630     if (!r[1]) {
1631       fprintf (stderr, "test_tail_0: short list returned from command\n");
1632       print_strings (r);
1633       return -1;
1634     }
1635     {
1636       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1637       if (strcmp (r[1], expected) != 0) {
1638         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1639         return -1;
1640       }
1641     }
1642     if (!r[2]) {
1643       fprintf (stderr, "test_tail_0: short list returned from command\n");
1644       print_strings (r);
1645       return -1;
1646     }
1647     {
1648       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1649       if (strcmp (r[2], expected) != 0) {
1650         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1651         return -1;
1652       }
1653     }
1654     if (!r[3]) {
1655       fprintf (stderr, "test_tail_0: short list returned from command\n");
1656       print_strings (r);
1657       return -1;
1658     }
1659     {
1660       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1661       if (strcmp (r[3], expected) != 0) {
1662         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1663         return -1;
1664       }
1665     }
1666     if (!r[4]) {
1667       fprintf (stderr, "test_tail_0: short list returned from command\n");
1668       print_strings (r);
1669       return -1;
1670     }
1671     {
1672       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1673       if (strcmp (r[4], expected) != 0) {
1674         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1675         return -1;
1676       }
1677     }
1678     if (!r[5]) {
1679       fprintf (stderr, "test_tail_0: short list returned from command\n");
1680       print_strings (r);
1681       return -1;
1682     }
1683     {
1684       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1685       if (strcmp (r[5], expected) != 0) {
1686         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1687         return -1;
1688       }
1689     }
1690     if (!r[6]) {
1691       fprintf (stderr, "test_tail_0: short list returned from command\n");
1692       print_strings (r);
1693       return -1;
1694     }
1695     {
1696       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1697       if (strcmp (r[6], expected) != 0) {
1698         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1699         return -1;
1700       }
1701     }
1702     if (!r[7]) {
1703       fprintf (stderr, "test_tail_0: short list returned from command\n");
1704       print_strings (r);
1705       return -1;
1706     }
1707     {
1708       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1709       if (strcmp (r[7], expected) != 0) {
1710         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1711         return -1;
1712       }
1713     }
1714     if (!r[8]) {
1715       fprintf (stderr, "test_tail_0: short list returned from command\n");
1716       print_strings (r);
1717       return -1;
1718     }
1719     {
1720       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1721       if (strcmp (r[8], expected) != 0) {
1722         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1723         return -1;
1724       }
1725     }
1726     if (!r[9]) {
1727       fprintf (stderr, "test_tail_0: short list returned from command\n");
1728       print_strings (r);
1729       return -1;
1730     }
1731     {
1732       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1733       if (strcmp (r[9], expected) != 0) {
1734         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1735         return -1;
1736       }
1737     }
1738     if (r[10] != NULL) {
1739       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1740       print_strings (r);
1741       return -1;
1742     }
1743     for (i = 0; r[i] != NULL; ++i)
1744       free (r[i]);
1745     free (r);
1746   }
1747   return 0;
1748 }
1749
1750 static int test_head_n_0_skip (void)
1751 {
1752   const char *str;
1753
1754   str = getenv ("TEST_ONLY");
1755   if (str)
1756     return strstr (str, "head_n") == NULL;
1757   str = getenv ("SKIP_TEST_HEAD_N_0");
1758   if (str && strcmp (str, "1") == 0) return 1;
1759   str = getenv ("SKIP_TEST_HEAD_N");
1760   if (str && strcmp (str, "1") == 0) return 1;
1761   return 0;
1762 }
1763
1764 static int test_head_n_0 (void)
1765 {
1766   if (test_head_n_0_skip ()) {
1767     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1768     return 0;
1769   }
1770
1771   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1772   {
1773     char device[] = "/dev/sda";
1774     int r;
1775     suppress_error = 0;
1776     r = guestfs_blockdev_setrw (g, device);
1777     if (r == -1)
1778       return -1;
1779   }
1780   {
1781     int r;
1782     suppress_error = 0;
1783     r = guestfs_umount_all (g);
1784     if (r == -1)
1785       return -1;
1786   }
1787   {
1788     int r;
1789     suppress_error = 0;
1790     r = guestfs_lvm_remove_all (g);
1791     if (r == -1)
1792       return -1;
1793   }
1794   {
1795     char device[] = "/dev/sda";
1796     char lines_0[] = ",";
1797     char *lines[] = {
1798       lines_0,
1799       NULL
1800     };
1801     int r;
1802     suppress_error = 0;
1803     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1804     if (r == -1)
1805       return -1;
1806   }
1807   {
1808     char fstype[] = "ext2";
1809     char device[] = "/dev/sda1";
1810     int r;
1811     suppress_error = 0;
1812     r = guestfs_mkfs (g, fstype, device);
1813     if (r == -1)
1814       return -1;
1815   }
1816   {
1817     char device[] = "/dev/sda1";
1818     char mountpoint[] = "/";
1819     int r;
1820     suppress_error = 0;
1821     r = guestfs_mount (g, device, mountpoint);
1822     if (r == -1)
1823       return -1;
1824   }
1825   /* TestOutputList for head_n (0) */
1826   {
1827     char options[] = "ro";
1828     char vfstype[] = "squashfs";
1829     char device[] = "/dev/sdd";
1830     char mountpoint[] = "/";
1831     int r;
1832     suppress_error = 0;
1833     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1834     if (r == -1)
1835       return -1;
1836   }
1837   {
1838     char path[] = "/10klines";
1839     char **r;
1840     int i;
1841     suppress_error = 0;
1842     r = guestfs_head_n (g, 3, path);
1843     if (r == NULL)
1844       return -1;
1845     if (!r[0]) {
1846       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1847       print_strings (r);
1848       return -1;
1849     }
1850     {
1851       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1852       if (strcmp (r[0], expected) != 0) {
1853         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1854         return -1;
1855       }
1856     }
1857     if (!r[1]) {
1858       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1859       print_strings (r);
1860       return -1;
1861     }
1862     {
1863       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1864       if (strcmp (r[1], expected) != 0) {
1865         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1866         return -1;
1867       }
1868     }
1869     if (!r[2]) {
1870       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1871       print_strings (r);
1872       return -1;
1873     }
1874     {
1875       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1876       if (strcmp (r[2], expected) != 0) {
1877         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1878         return -1;
1879       }
1880     }
1881     if (r[3] != NULL) {
1882       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1883       print_strings (r);
1884       return -1;
1885     }
1886     for (i = 0; r[i] != NULL; ++i)
1887       free (r[i]);
1888     free (r);
1889   }
1890   return 0;
1891 }
1892
1893 static int test_head_n_1_skip (void)
1894 {
1895   const char *str;
1896
1897   str = getenv ("TEST_ONLY");
1898   if (str)
1899     return strstr (str, "head_n") == NULL;
1900   str = getenv ("SKIP_TEST_HEAD_N_1");
1901   if (str && strcmp (str, "1") == 0) return 1;
1902   str = getenv ("SKIP_TEST_HEAD_N");
1903   if (str && strcmp (str, "1") == 0) return 1;
1904   return 0;
1905 }
1906
1907 static int test_head_n_1 (void)
1908 {
1909   if (test_head_n_1_skip ()) {
1910     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1911     return 0;
1912   }
1913
1914   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1915   {
1916     char device[] = "/dev/sda";
1917     int r;
1918     suppress_error = 0;
1919     r = guestfs_blockdev_setrw (g, device);
1920     if (r == -1)
1921       return -1;
1922   }
1923   {
1924     int r;
1925     suppress_error = 0;
1926     r = guestfs_umount_all (g);
1927     if (r == -1)
1928       return -1;
1929   }
1930   {
1931     int r;
1932     suppress_error = 0;
1933     r = guestfs_lvm_remove_all (g);
1934     if (r == -1)
1935       return -1;
1936   }
1937   {
1938     char device[] = "/dev/sda";
1939     char lines_0[] = ",";
1940     char *lines[] = {
1941       lines_0,
1942       NULL
1943     };
1944     int r;
1945     suppress_error = 0;
1946     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1947     if (r == -1)
1948       return -1;
1949   }
1950   {
1951     char fstype[] = "ext2";
1952     char device[] = "/dev/sda1";
1953     int r;
1954     suppress_error = 0;
1955     r = guestfs_mkfs (g, fstype, device);
1956     if (r == -1)
1957       return -1;
1958   }
1959   {
1960     char device[] = "/dev/sda1";
1961     char mountpoint[] = "/";
1962     int r;
1963     suppress_error = 0;
1964     r = guestfs_mount (g, device, mountpoint);
1965     if (r == -1)
1966       return -1;
1967   }
1968   /* TestOutputList for head_n (1) */
1969   {
1970     char options[] = "ro";
1971     char vfstype[] = "squashfs";
1972     char device[] = "/dev/sdd";
1973     char mountpoint[] = "/";
1974     int r;
1975     suppress_error = 0;
1976     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1977     if (r == -1)
1978       return -1;
1979   }
1980   {
1981     char path[] = "/10klines";
1982     char **r;
1983     int i;
1984     suppress_error = 0;
1985     r = guestfs_head_n (g, -9997, path);
1986     if (r == NULL)
1987       return -1;
1988     if (!r[0]) {
1989       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1990       print_strings (r);
1991       return -1;
1992     }
1993     {
1994       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1995       if (strcmp (r[0], expected) != 0) {
1996         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1997         return -1;
1998       }
1999     }
2000     if (!r[1]) {
2001       fprintf (stderr, "test_head_n_1: short list returned from command\n");
2002       print_strings (r);
2003       return -1;
2004     }
2005     {
2006       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2007       if (strcmp (r[1], expected) != 0) {
2008         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2009         return -1;
2010       }
2011     }
2012     if (!r[2]) {
2013       fprintf (stderr, "test_head_n_1: short list returned from command\n");
2014       print_strings (r);
2015       return -1;
2016     }
2017     {
2018       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2019       if (strcmp (r[2], expected) != 0) {
2020         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2021         return -1;
2022       }
2023     }
2024     if (r[3] != NULL) {
2025       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
2026       print_strings (r);
2027       return -1;
2028     }
2029     for (i = 0; r[i] != NULL; ++i)
2030       free (r[i]);
2031     free (r);
2032   }
2033   return 0;
2034 }
2035
2036 static int test_head_n_2_skip (void)
2037 {
2038   const char *str;
2039
2040   str = getenv ("TEST_ONLY");
2041   if (str)
2042     return strstr (str, "head_n") == NULL;
2043   str = getenv ("SKIP_TEST_HEAD_N_2");
2044   if (str && strcmp (str, "1") == 0) return 1;
2045   str = getenv ("SKIP_TEST_HEAD_N");
2046   if (str && strcmp (str, "1") == 0) return 1;
2047   return 0;
2048 }
2049
2050 static int test_head_n_2 (void)
2051 {
2052   if (test_head_n_2_skip ()) {
2053     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
2054     return 0;
2055   }
2056
2057   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
2058   {
2059     char device[] = "/dev/sda";
2060     int r;
2061     suppress_error = 0;
2062     r = guestfs_blockdev_setrw (g, device);
2063     if (r == -1)
2064       return -1;
2065   }
2066   {
2067     int r;
2068     suppress_error = 0;
2069     r = guestfs_umount_all (g);
2070     if (r == -1)
2071       return -1;
2072   }
2073   {
2074     int r;
2075     suppress_error = 0;
2076     r = guestfs_lvm_remove_all (g);
2077     if (r == -1)
2078       return -1;
2079   }
2080   {
2081     char device[] = "/dev/sda";
2082     char lines_0[] = ",";
2083     char *lines[] = {
2084       lines_0,
2085       NULL
2086     };
2087     int r;
2088     suppress_error = 0;
2089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2090     if (r == -1)
2091       return -1;
2092   }
2093   {
2094     char fstype[] = "ext2";
2095     char device[] = "/dev/sda1";
2096     int r;
2097     suppress_error = 0;
2098     r = guestfs_mkfs (g, fstype, device);
2099     if (r == -1)
2100       return -1;
2101   }
2102   {
2103     char device[] = "/dev/sda1";
2104     char mountpoint[] = "/";
2105     int r;
2106     suppress_error = 0;
2107     r = guestfs_mount (g, device, mountpoint);
2108     if (r == -1)
2109       return -1;
2110   }
2111   /* TestOutputList for head_n (2) */
2112   {
2113     char options[] = "ro";
2114     char vfstype[] = "squashfs";
2115     char device[] = "/dev/sdd";
2116     char mountpoint[] = "/";
2117     int r;
2118     suppress_error = 0;
2119     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2120     if (r == -1)
2121       return -1;
2122   }
2123   {
2124     char path[] = "/10klines";
2125     char **r;
2126     int i;
2127     suppress_error = 0;
2128     r = guestfs_head_n (g, 0, path);
2129     if (r == NULL)
2130       return -1;
2131     if (r[0] != NULL) {
2132       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
2133       print_strings (r);
2134       return -1;
2135     }
2136     for (i = 0; r[i] != NULL; ++i)
2137       free (r[i]);
2138     free (r);
2139   }
2140   return 0;
2141 }
2142
2143 static int test_head_0_skip (void)
2144 {
2145   const char *str;
2146
2147   str = getenv ("TEST_ONLY");
2148   if (str)
2149     return strstr (str, "head") == NULL;
2150   str = getenv ("SKIP_TEST_HEAD_0");
2151   if (str && strcmp (str, "1") == 0) return 1;
2152   str = getenv ("SKIP_TEST_HEAD");
2153   if (str && strcmp (str, "1") == 0) return 1;
2154   return 0;
2155 }
2156
2157 static int test_head_0 (void)
2158 {
2159   if (test_head_0_skip ()) {
2160     printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
2161     return 0;
2162   }
2163
2164   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
2165   {
2166     char device[] = "/dev/sda";
2167     int r;
2168     suppress_error = 0;
2169     r = guestfs_blockdev_setrw (g, device);
2170     if (r == -1)
2171       return -1;
2172   }
2173   {
2174     int r;
2175     suppress_error = 0;
2176     r = guestfs_umount_all (g);
2177     if (r == -1)
2178       return -1;
2179   }
2180   {
2181     int r;
2182     suppress_error = 0;
2183     r = guestfs_lvm_remove_all (g);
2184     if (r == -1)
2185       return -1;
2186   }
2187   {
2188     char device[] = "/dev/sda";
2189     char lines_0[] = ",";
2190     char *lines[] = {
2191       lines_0,
2192       NULL
2193     };
2194     int r;
2195     suppress_error = 0;
2196     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2197     if (r == -1)
2198       return -1;
2199   }
2200   {
2201     char fstype[] = "ext2";
2202     char device[] = "/dev/sda1";
2203     int r;
2204     suppress_error = 0;
2205     r = guestfs_mkfs (g, fstype, device);
2206     if (r == -1)
2207       return -1;
2208   }
2209   {
2210     char device[] = "/dev/sda1";
2211     char mountpoint[] = "/";
2212     int r;
2213     suppress_error = 0;
2214     r = guestfs_mount (g, device, mountpoint);
2215     if (r == -1)
2216       return -1;
2217   }
2218   /* TestOutputList for head (0) */
2219   {
2220     char options[] = "ro";
2221     char vfstype[] = "squashfs";
2222     char device[] = "/dev/sdd";
2223     char mountpoint[] = "/";
2224     int r;
2225     suppress_error = 0;
2226     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2227     if (r == -1)
2228       return -1;
2229   }
2230   {
2231     char path[] = "/10klines";
2232     char **r;
2233     int i;
2234     suppress_error = 0;
2235     r = guestfs_head (g, path);
2236     if (r == NULL)
2237       return -1;
2238     if (!r[0]) {
2239       fprintf (stderr, "test_head_0: short list returned from command\n");
2240       print_strings (r);
2241       return -1;
2242     }
2243     {
2244       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
2245       if (strcmp (r[0], expected) != 0) {
2246         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2247         return -1;
2248       }
2249     }
2250     if (!r[1]) {
2251       fprintf (stderr, "test_head_0: short list returned from command\n");
2252       print_strings (r);
2253       return -1;
2254     }
2255     {
2256       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2257       if (strcmp (r[1], expected) != 0) {
2258         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2259         return -1;
2260       }
2261     }
2262     if (!r[2]) {
2263       fprintf (stderr, "test_head_0: short list returned from command\n");
2264       print_strings (r);
2265       return -1;
2266     }
2267     {
2268       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2269       if (strcmp (r[2], expected) != 0) {
2270         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2271         return -1;
2272       }
2273     }
2274     if (!r[3]) {
2275       fprintf (stderr, "test_head_0: short list returned from command\n");
2276       print_strings (r);
2277       return -1;
2278     }
2279     {
2280       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
2281       if (strcmp (r[3], expected) != 0) {
2282         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2283         return -1;
2284       }
2285     }
2286     if (!r[4]) {
2287       fprintf (stderr, "test_head_0: short list returned from command\n");
2288       print_strings (r);
2289       return -1;
2290     }
2291     {
2292       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
2293       if (strcmp (r[4], expected) != 0) {
2294         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
2295         return -1;
2296       }
2297     }
2298     if (!r[5]) {
2299       fprintf (stderr, "test_head_0: short list returned from command\n");
2300       print_strings (r);
2301       return -1;
2302     }
2303     {
2304       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
2305       if (strcmp (r[5], expected) != 0) {
2306         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
2307         return -1;
2308       }
2309     }
2310     if (!r[6]) {
2311       fprintf (stderr, "test_head_0: short list returned from command\n");
2312       print_strings (r);
2313       return -1;
2314     }
2315     {
2316       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
2317       if (strcmp (r[6], expected) != 0) {
2318         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
2319         return -1;
2320       }
2321     }
2322     if (!r[7]) {
2323       fprintf (stderr, "test_head_0: short list returned from command\n");
2324       print_strings (r);
2325       return -1;
2326     }
2327     {
2328       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
2329       if (strcmp (r[7], expected) != 0) {
2330         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
2331         return -1;
2332       }
2333     }
2334     if (!r[8]) {
2335       fprintf (stderr, "test_head_0: short list returned from command\n");
2336       print_strings (r);
2337       return -1;
2338     }
2339     {
2340       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
2341       if (strcmp (r[8], expected) != 0) {
2342         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
2343         return -1;
2344       }
2345     }
2346     if (!r[9]) {
2347       fprintf (stderr, "test_head_0: short list returned from command\n");
2348       print_strings (r);
2349       return -1;
2350     }
2351     {
2352       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
2353       if (strcmp (r[9], expected) != 0) {
2354         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
2355         return -1;
2356       }
2357     }
2358     if (r[10] != NULL) {
2359       fprintf (stderr, "test_head_0: extra elements returned from command\n");
2360       print_strings (r);
2361       return -1;
2362     }
2363     for (i = 0; r[i] != NULL; ++i)
2364       free (r[i]);
2365     free (r);
2366   }
2367   return 0;
2368 }
2369
2370 static int test_wc_c_0_skip (void)
2371 {
2372   const char *str;
2373
2374   str = getenv ("TEST_ONLY");
2375   if (str)
2376     return strstr (str, "wc_c") == NULL;
2377   str = getenv ("SKIP_TEST_WC_C_0");
2378   if (str && strcmp (str, "1") == 0) return 1;
2379   str = getenv ("SKIP_TEST_WC_C");
2380   if (str && strcmp (str, "1") == 0) return 1;
2381   return 0;
2382 }
2383
2384 static int test_wc_c_0 (void)
2385 {
2386   if (test_wc_c_0_skip ()) {
2387     printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
2388     return 0;
2389   }
2390
2391   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
2392   {
2393     char device[] = "/dev/sda";
2394     int r;
2395     suppress_error = 0;
2396     r = guestfs_blockdev_setrw (g, device);
2397     if (r == -1)
2398       return -1;
2399   }
2400   {
2401     int r;
2402     suppress_error = 0;
2403     r = guestfs_umount_all (g);
2404     if (r == -1)
2405       return -1;
2406   }
2407   {
2408     int r;
2409     suppress_error = 0;
2410     r = guestfs_lvm_remove_all (g);
2411     if (r == -1)
2412       return -1;
2413   }
2414   {
2415     char device[] = "/dev/sda";
2416     char lines_0[] = ",";
2417     char *lines[] = {
2418       lines_0,
2419       NULL
2420     };
2421     int r;
2422     suppress_error = 0;
2423     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2424     if (r == -1)
2425       return -1;
2426   }
2427   {
2428     char fstype[] = "ext2";
2429     char device[] = "/dev/sda1";
2430     int r;
2431     suppress_error = 0;
2432     r = guestfs_mkfs (g, fstype, device);
2433     if (r == -1)
2434       return -1;
2435   }
2436   {
2437     char device[] = "/dev/sda1";
2438     char mountpoint[] = "/";
2439     int r;
2440     suppress_error = 0;
2441     r = guestfs_mount (g, device, mountpoint);
2442     if (r == -1)
2443       return -1;
2444   }
2445   /* TestOutputInt for wc_c (0) */
2446   {
2447     char options[] = "ro";
2448     char vfstype[] = "squashfs";
2449     char device[] = "/dev/sdd";
2450     char mountpoint[] = "/";
2451     int r;
2452     suppress_error = 0;
2453     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2454     if (r == -1)
2455       return -1;
2456   }
2457   {
2458     char path[] = "/100kallspaces";
2459     int r;
2460     suppress_error = 0;
2461     r = guestfs_wc_c (g, path);
2462     if (r == -1)
2463       return -1;
2464     if (r != 102400) {
2465       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
2466       return -1;
2467     }
2468   }
2469   return 0;
2470 }
2471
2472 static int test_wc_w_0_skip (void)
2473 {
2474   const char *str;
2475
2476   str = getenv ("TEST_ONLY");
2477   if (str)
2478     return strstr (str, "wc_w") == NULL;
2479   str = getenv ("SKIP_TEST_WC_W_0");
2480   if (str && strcmp (str, "1") == 0) return 1;
2481   str = getenv ("SKIP_TEST_WC_W");
2482   if (str && strcmp (str, "1") == 0) return 1;
2483   return 0;
2484 }
2485
2486 static int test_wc_w_0 (void)
2487 {
2488   if (test_wc_w_0_skip ()) {
2489     printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
2490     return 0;
2491   }
2492
2493   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
2494   {
2495     char device[] = "/dev/sda";
2496     int r;
2497     suppress_error = 0;
2498     r = guestfs_blockdev_setrw (g, device);
2499     if (r == -1)
2500       return -1;
2501   }
2502   {
2503     int r;
2504     suppress_error = 0;
2505     r = guestfs_umount_all (g);
2506     if (r == -1)
2507       return -1;
2508   }
2509   {
2510     int r;
2511     suppress_error = 0;
2512     r = guestfs_lvm_remove_all (g);
2513     if (r == -1)
2514       return -1;
2515   }
2516   {
2517     char device[] = "/dev/sda";
2518     char lines_0[] = ",";
2519     char *lines[] = {
2520       lines_0,
2521       NULL
2522     };
2523     int r;
2524     suppress_error = 0;
2525     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2526     if (r == -1)
2527       return -1;
2528   }
2529   {
2530     char fstype[] = "ext2";
2531     char device[] = "/dev/sda1";
2532     int r;
2533     suppress_error = 0;
2534     r = guestfs_mkfs (g, fstype, device);
2535     if (r == -1)
2536       return -1;
2537   }
2538   {
2539     char device[] = "/dev/sda1";
2540     char mountpoint[] = "/";
2541     int r;
2542     suppress_error = 0;
2543     r = guestfs_mount (g, device, mountpoint);
2544     if (r == -1)
2545       return -1;
2546   }
2547   /* TestOutputInt for wc_w (0) */
2548   {
2549     char options[] = "ro";
2550     char vfstype[] = "squashfs";
2551     char device[] = "/dev/sdd";
2552     char mountpoint[] = "/";
2553     int r;
2554     suppress_error = 0;
2555     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2556     if (r == -1)
2557       return -1;
2558   }
2559   {
2560     char path[] = "/10klines";
2561     int r;
2562     suppress_error = 0;
2563     r = guestfs_wc_w (g, path);
2564     if (r == -1)
2565       return -1;
2566     if (r != 10000) {
2567       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
2568       return -1;
2569     }
2570   }
2571   return 0;
2572 }
2573
2574 static int test_wc_l_0_skip (void)
2575 {
2576   const char *str;
2577
2578   str = getenv ("TEST_ONLY");
2579   if (str)
2580     return strstr (str, "wc_l") == NULL;
2581   str = getenv ("SKIP_TEST_WC_L_0");
2582   if (str && strcmp (str, "1") == 0) return 1;
2583   str = getenv ("SKIP_TEST_WC_L");
2584   if (str && strcmp (str, "1") == 0) return 1;
2585   return 0;
2586 }
2587
2588 static int test_wc_l_0 (void)
2589 {
2590   if (test_wc_l_0_skip ()) {
2591     printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
2592     return 0;
2593   }
2594
2595   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2596   {
2597     char device[] = "/dev/sda";
2598     int r;
2599     suppress_error = 0;
2600     r = guestfs_blockdev_setrw (g, device);
2601     if (r == -1)
2602       return -1;
2603   }
2604   {
2605     int r;
2606     suppress_error = 0;
2607     r = guestfs_umount_all (g);
2608     if (r == -1)
2609       return -1;
2610   }
2611   {
2612     int r;
2613     suppress_error = 0;
2614     r = guestfs_lvm_remove_all (g);
2615     if (r == -1)
2616       return -1;
2617   }
2618   {
2619     char device[] = "/dev/sda";
2620     char lines_0[] = ",";
2621     char *lines[] = {
2622       lines_0,
2623       NULL
2624     };
2625     int r;
2626     suppress_error = 0;
2627     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2628     if (r == -1)
2629       return -1;
2630   }
2631   {
2632     char fstype[] = "ext2";
2633     char device[] = "/dev/sda1";
2634     int r;
2635     suppress_error = 0;
2636     r = guestfs_mkfs (g, fstype, device);
2637     if (r == -1)
2638       return -1;
2639   }
2640   {
2641     char device[] = "/dev/sda1";
2642     char mountpoint[] = "/";
2643     int r;
2644     suppress_error = 0;
2645     r = guestfs_mount (g, device, mountpoint);
2646     if (r == -1)
2647       return -1;
2648   }
2649   /* TestOutputInt for wc_l (0) */
2650   {
2651     char options[] = "ro";
2652     char vfstype[] = "squashfs";
2653     char device[] = "/dev/sdd";
2654     char mountpoint[] = "/";
2655     int r;
2656     suppress_error = 0;
2657     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2658     if (r == -1)
2659       return -1;
2660   }
2661   {
2662     char path[] = "/10klines";
2663     int r;
2664     suppress_error = 0;
2665     r = guestfs_wc_l (g, path);
2666     if (r == -1)
2667       return -1;
2668     if (r != 10000) {
2669       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
2670       return -1;
2671     }
2672   }
2673   return 0;
2674 }
2675
2676 static int test_mkdtemp_0_skip (void)
2677 {
2678   const char *str;
2679
2680   str = getenv ("TEST_ONLY");
2681   if (str)
2682     return strstr (str, "mkdtemp") == NULL;
2683   str = getenv ("SKIP_TEST_MKDTEMP_0");
2684   if (str && strcmp (str, "1") == 0) return 1;
2685   str = getenv ("SKIP_TEST_MKDTEMP");
2686   if (str && strcmp (str, "1") == 0) return 1;
2687   return 0;
2688 }
2689
2690 static int test_mkdtemp_0 (void)
2691 {
2692   if (test_mkdtemp_0_skip ()) {
2693     printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2694     return 0;
2695   }
2696
2697   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2698   {
2699     char device[] = "/dev/sda";
2700     int r;
2701     suppress_error = 0;
2702     r = guestfs_blockdev_setrw (g, device);
2703     if (r == -1)
2704       return -1;
2705   }
2706   {
2707     int r;
2708     suppress_error = 0;
2709     r = guestfs_umount_all (g);
2710     if (r == -1)
2711       return -1;
2712   }
2713   {
2714     int r;
2715     suppress_error = 0;
2716     r = guestfs_lvm_remove_all (g);
2717     if (r == -1)
2718       return -1;
2719   }
2720   {
2721     char device[] = "/dev/sda";
2722     char lines_0[] = ",";
2723     char *lines[] = {
2724       lines_0,
2725       NULL
2726     };
2727     int r;
2728     suppress_error = 0;
2729     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2730     if (r == -1)
2731       return -1;
2732   }
2733   {
2734     char fstype[] = "ext2";
2735     char device[] = "/dev/sda1";
2736     int r;
2737     suppress_error = 0;
2738     r = guestfs_mkfs (g, fstype, device);
2739     if (r == -1)
2740       return -1;
2741   }
2742   {
2743     char device[] = "/dev/sda1";
2744     char mountpoint[] = "/";
2745     int r;
2746     suppress_error = 0;
2747     r = guestfs_mount (g, device, mountpoint);
2748     if (r == -1)
2749       return -1;
2750   }
2751   /* TestRun for mkdtemp (0) */
2752   {
2753     char path[] = "/tmp";
2754     int r;
2755     suppress_error = 0;
2756     r = guestfs_mkdir (g, path);
2757     if (r == -1)
2758       return -1;
2759   }
2760   {
2761     char template[] = "/tmp/tmpXXXXXX";
2762     char *r;
2763     suppress_error = 0;
2764     r = guestfs_mkdtemp (g, template);
2765     if (r == NULL)
2766       return -1;
2767     free (r);
2768   }
2769   return 0;
2770 }
2771
2772 static int test_scrub_file_0_skip (void)
2773 {
2774   const char *str;
2775
2776   str = getenv ("TEST_ONLY");
2777   if (str)
2778     return strstr (str, "scrub_file") == NULL;
2779   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2780   if (str && strcmp (str, "1") == 0) return 1;
2781   str = getenv ("SKIP_TEST_SCRUB_FILE");
2782   if (str && strcmp (str, "1") == 0) return 1;
2783   return 0;
2784 }
2785
2786 static int test_scrub_file_0 (void)
2787 {
2788   if (test_scrub_file_0_skip ()) {
2789     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2790     return 0;
2791   }
2792
2793   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2794   {
2795     char device[] = "/dev/sda";
2796     int r;
2797     suppress_error = 0;
2798     r = guestfs_blockdev_setrw (g, device);
2799     if (r == -1)
2800       return -1;
2801   }
2802   {
2803     int r;
2804     suppress_error = 0;
2805     r = guestfs_umount_all (g);
2806     if (r == -1)
2807       return -1;
2808   }
2809   {
2810     int r;
2811     suppress_error = 0;
2812     r = guestfs_lvm_remove_all (g);
2813     if (r == -1)
2814       return -1;
2815   }
2816   {
2817     char device[] = "/dev/sda";
2818     char lines_0[] = ",";
2819     char *lines[] = {
2820       lines_0,
2821       NULL
2822     };
2823     int r;
2824     suppress_error = 0;
2825     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2826     if (r == -1)
2827       return -1;
2828   }
2829   {
2830     char fstype[] = "ext2";
2831     char device[] = "/dev/sda1";
2832     int r;
2833     suppress_error = 0;
2834     r = guestfs_mkfs (g, fstype, device);
2835     if (r == -1)
2836       return -1;
2837   }
2838   {
2839     char device[] = "/dev/sda1";
2840     char mountpoint[] = "/";
2841     int r;
2842     suppress_error = 0;
2843     r = guestfs_mount (g, device, mountpoint);
2844     if (r == -1)
2845       return -1;
2846   }
2847   /* TestRun for scrub_file (0) */
2848   {
2849     char path[] = "/file";
2850     char content[] = "content";
2851     int r;
2852     suppress_error = 0;
2853     r = guestfs_write_file (g, path, content, 0);
2854     if (r == -1)
2855       return -1;
2856   }
2857   {
2858     char file[] = "/file";
2859     int r;
2860     suppress_error = 0;
2861     r = guestfs_scrub_file (g, file);
2862     if (r == -1)
2863       return -1;
2864   }
2865   return 0;
2866 }
2867
2868 static int test_scrub_device_0_skip (void)
2869 {
2870   const char *str;
2871
2872   str = getenv ("TEST_ONLY");
2873   if (str)
2874     return strstr (str, "scrub_device") == NULL;
2875   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2876   if (str && strcmp (str, "1") == 0) return 1;
2877   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2878   if (str && strcmp (str, "1") == 0) return 1;
2879   return 0;
2880 }
2881
2882 static int test_scrub_device_0 (void)
2883 {
2884   if (test_scrub_device_0_skip ()) {
2885     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2886     return 0;
2887   }
2888
2889   /* InitNone|InitEmpty for test_scrub_device_0 */
2890   {
2891     char device[] = "/dev/sda";
2892     int r;
2893     suppress_error = 0;
2894     r = guestfs_blockdev_setrw (g, device);
2895     if (r == -1)
2896       return -1;
2897   }
2898   {
2899     int r;
2900     suppress_error = 0;
2901     r = guestfs_umount_all (g);
2902     if (r == -1)
2903       return -1;
2904   }
2905   {
2906     int r;
2907     suppress_error = 0;
2908     r = guestfs_lvm_remove_all (g);
2909     if (r == -1)
2910       return -1;
2911   }
2912   /* TestRun for scrub_device (0) */
2913   {
2914     char device[] = "/dev/sdc";
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_scrub_device (g, device);
2918     if (r == -1)
2919       return -1;
2920   }
2921   return 0;
2922 }
2923
2924 static int test_glob_expand_0_skip (void)
2925 {
2926   const char *str;
2927
2928   str = getenv ("TEST_ONLY");
2929   if (str)
2930     return strstr (str, "glob_expand") == NULL;
2931   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2932   if (str && strcmp (str, "1") == 0) return 1;
2933   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2934   if (str && strcmp (str, "1") == 0) return 1;
2935   return 0;
2936 }
2937
2938 static int test_glob_expand_0 (void)
2939 {
2940   if (test_glob_expand_0_skip ()) {
2941     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2942     return 0;
2943   }
2944
2945   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2946   {
2947     char device[] = "/dev/sda";
2948     int r;
2949     suppress_error = 0;
2950     r = guestfs_blockdev_setrw (g, device);
2951     if (r == -1)
2952       return -1;
2953   }
2954   {
2955     int r;
2956     suppress_error = 0;
2957     r = guestfs_umount_all (g);
2958     if (r == -1)
2959       return -1;
2960   }
2961   {
2962     int r;
2963     suppress_error = 0;
2964     r = guestfs_lvm_remove_all (g);
2965     if (r == -1)
2966       return -1;
2967   }
2968   {
2969     char device[] = "/dev/sda";
2970     char lines_0[] = ",";
2971     char *lines[] = {
2972       lines_0,
2973       NULL
2974     };
2975     int r;
2976     suppress_error = 0;
2977     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2978     if (r == -1)
2979       return -1;
2980   }
2981   {
2982     char fstype[] = "ext2";
2983     char device[] = "/dev/sda1";
2984     int r;
2985     suppress_error = 0;
2986     r = guestfs_mkfs (g, fstype, device);
2987     if (r == -1)
2988       return -1;
2989   }
2990   {
2991     char device[] = "/dev/sda1";
2992     char mountpoint[] = "/";
2993     int r;
2994     suppress_error = 0;
2995     r = guestfs_mount (g, device, mountpoint);
2996     if (r == -1)
2997       return -1;
2998   }
2999   /* TestOutputList for glob_expand (0) */
3000   {
3001     char path[] = "/a/b/c";
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_mkdir_p (g, path);
3005     if (r == -1)
3006       return -1;
3007   }
3008   {
3009     char path[] = "/a/b/c/d";
3010     int r;
3011     suppress_error = 0;
3012     r = guestfs_touch (g, path);
3013     if (r == -1)
3014       return -1;
3015   }
3016   {
3017     char path[] = "/a/b/c/e";
3018     int r;
3019     suppress_error = 0;
3020     r = guestfs_touch (g, path);
3021     if (r == -1)
3022       return -1;
3023   }
3024   {
3025     char pattern[] = "/a/b/c/*";
3026     char **r;
3027     int i;
3028     suppress_error = 0;
3029     r = guestfs_glob_expand (g, pattern);
3030     if (r == NULL)
3031       return -1;
3032     if (!r[0]) {
3033       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3034       print_strings (r);
3035       return -1;
3036     }
3037     {
3038       char expected[] = "/a/b/c/d";
3039       if (strcmp (r[0], expected) != 0) {
3040         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3041         return -1;
3042       }
3043     }
3044     if (!r[1]) {
3045       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3046       print_strings (r);
3047       return -1;
3048     }
3049     {
3050       char expected[] = "/a/b/c/e";
3051       if (strcmp (r[1], expected) != 0) {
3052         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3053         return -1;
3054       }
3055     }
3056     if (r[2] != NULL) {
3057       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
3058       print_strings (r);
3059       return -1;
3060     }
3061     for (i = 0; r[i] != NULL; ++i)
3062       free (r[i]);
3063     free (r);
3064   }
3065   return 0;
3066 }
3067
3068 static int test_glob_expand_1_skip (void)
3069 {
3070   const char *str;
3071
3072   str = getenv ("TEST_ONLY");
3073   if (str)
3074     return strstr (str, "glob_expand") == NULL;
3075   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
3076   if (str && strcmp (str, "1") == 0) return 1;
3077   str = getenv ("SKIP_TEST_GLOB_EXPAND");
3078   if (str && strcmp (str, "1") == 0) return 1;
3079   return 0;
3080 }
3081
3082 static int test_glob_expand_1 (void)
3083 {
3084   if (test_glob_expand_1_skip ()) {
3085     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
3086     return 0;
3087   }
3088
3089   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
3090   {
3091     char device[] = "/dev/sda";
3092     int r;
3093     suppress_error = 0;
3094     r = guestfs_blockdev_setrw (g, device);
3095     if (r == -1)
3096       return -1;
3097   }
3098   {
3099     int r;
3100     suppress_error = 0;
3101     r = guestfs_umount_all (g);
3102     if (r == -1)
3103       return -1;
3104   }
3105   {
3106     int r;
3107     suppress_error = 0;
3108     r = guestfs_lvm_remove_all (g);
3109     if (r == -1)
3110       return -1;
3111   }
3112   {
3113     char device[] = "/dev/sda";
3114     char lines_0[] = ",";
3115     char *lines[] = {
3116       lines_0,
3117       NULL
3118     };
3119     int r;
3120     suppress_error = 0;
3121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3122     if (r == -1)
3123       return -1;
3124   }
3125   {
3126     char fstype[] = "ext2";
3127     char device[] = "/dev/sda1";
3128     int r;
3129     suppress_error = 0;
3130     r = guestfs_mkfs (g, fstype, device);
3131     if (r == -1)
3132       return -1;
3133   }
3134   {
3135     char device[] = "/dev/sda1";
3136     char mountpoint[] = "/";
3137     int r;
3138     suppress_error = 0;
3139     r = guestfs_mount (g, device, mountpoint);
3140     if (r == -1)
3141       return -1;
3142   }
3143   /* TestOutputList for glob_expand (1) */
3144   {
3145     char path[] = "/a/b/c";
3146     int r;
3147     suppress_error = 0;
3148     r = guestfs_mkdir_p (g, path);
3149     if (r == -1)
3150       return -1;
3151   }
3152   {
3153     char path[] = "/a/b/c/d";
3154     int r;
3155     suppress_error = 0;
3156     r = guestfs_touch (g, path);
3157     if (r == -1)
3158       return -1;
3159   }
3160   {
3161     char path[] = "/a/b/c/e";
3162     int r;
3163     suppress_error = 0;
3164     r = guestfs_touch (g, path);
3165     if (r == -1)
3166       return -1;
3167   }
3168   {
3169     char pattern[] = "/a/*/c/*";
3170     char **r;
3171     int i;
3172     suppress_error = 0;
3173     r = guestfs_glob_expand (g, pattern);
3174     if (r == NULL)
3175       return -1;
3176     if (!r[0]) {
3177       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3178       print_strings (r);
3179       return -1;
3180     }
3181     {
3182       char expected[] = "/a/b/c/d";
3183       if (strcmp (r[0], expected) != 0) {
3184         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3185         return -1;
3186       }
3187     }
3188     if (!r[1]) {
3189       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3190       print_strings (r);
3191       return -1;
3192     }
3193     {
3194       char expected[] = "/a/b/c/e";
3195       if (strcmp (r[1], expected) != 0) {
3196         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3197         return -1;
3198       }
3199     }
3200     if (r[2] != NULL) {
3201       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
3202       print_strings (r);
3203       return -1;
3204     }
3205     for (i = 0; r[i] != NULL; ++i)
3206       free (r[i]);
3207     free (r);
3208   }
3209   return 0;
3210 }
3211
3212 static int test_glob_expand_2_skip (void)
3213 {
3214   const char *str;
3215
3216   str = getenv ("TEST_ONLY");
3217   if (str)
3218     return strstr (str, "glob_expand") == NULL;
3219   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
3220   if (str && strcmp (str, "1") == 0) return 1;
3221   str = getenv ("SKIP_TEST_GLOB_EXPAND");
3222   if (str && strcmp (str, "1") == 0) return 1;
3223   return 0;
3224 }
3225
3226 static int test_glob_expand_2 (void)
3227 {
3228   if (test_glob_expand_2_skip ()) {
3229     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
3230     return 0;
3231   }
3232
3233   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
3234   {
3235     char device[] = "/dev/sda";
3236     int r;
3237     suppress_error = 0;
3238     r = guestfs_blockdev_setrw (g, device);
3239     if (r == -1)
3240       return -1;
3241   }
3242   {
3243     int r;
3244     suppress_error = 0;
3245     r = guestfs_umount_all (g);
3246     if (r == -1)
3247       return -1;
3248   }
3249   {
3250     int r;
3251     suppress_error = 0;
3252     r = guestfs_lvm_remove_all (g);
3253     if (r == -1)
3254       return -1;
3255   }
3256   {
3257     char device[] = "/dev/sda";
3258     char lines_0[] = ",";
3259     char *lines[] = {
3260       lines_0,
3261       NULL
3262     };
3263     int r;
3264     suppress_error = 0;
3265     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3266     if (r == -1)
3267       return -1;
3268   }
3269   {
3270     char fstype[] = "ext2";
3271     char device[] = "/dev/sda1";
3272     int r;
3273     suppress_error = 0;
3274     r = guestfs_mkfs (g, fstype, device);
3275     if (r == -1)
3276       return -1;
3277   }
3278   {
3279     char device[] = "/dev/sda1";
3280     char mountpoint[] = "/";
3281     int r;
3282     suppress_error = 0;
3283     r = guestfs_mount (g, device, mountpoint);
3284     if (r == -1)
3285       return -1;
3286   }
3287   /* TestOutputList for glob_expand (2) */
3288   {
3289     char path[] = "/a/b/c";
3290     int r;
3291     suppress_error = 0;
3292     r = guestfs_mkdir_p (g, path);
3293     if (r == -1)
3294       return -1;
3295   }
3296   {
3297     char path[] = "/a/b/c/d";
3298     int r;
3299     suppress_error = 0;
3300     r = guestfs_touch (g, path);
3301     if (r == -1)
3302       return -1;
3303   }
3304   {
3305     char path[] = "/a/b/c/e";
3306     int r;
3307     suppress_error = 0;
3308     r = guestfs_touch (g, path);
3309     if (r == -1)
3310       return -1;
3311   }
3312   {
3313     char pattern[] = "/a/*/x/*";
3314     char **r;
3315     int i;
3316     suppress_error = 0;
3317     r = guestfs_glob_expand (g, pattern);
3318     if (r == NULL)
3319       return -1;
3320     if (r[0] != NULL) {
3321       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
3322       print_strings (r);
3323       return -1;
3324     }
3325     for (i = 0; r[i] != NULL; ++i)
3326       free (r[i]);
3327     free (r);
3328   }
3329   return 0;
3330 }
3331
3332 static int test_ntfs_3g_probe_0_skip (void)
3333 {
3334   const char *str;
3335
3336   str = getenv ("TEST_ONLY");
3337   if (str)
3338     return strstr (str, "ntfs_3g_probe") == NULL;
3339   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
3340   if (str && strcmp (str, "1") == 0) return 1;
3341   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3342   if (str && strcmp (str, "1") == 0) return 1;
3343   return 0;
3344 }
3345
3346 static int test_ntfs_3g_probe_0 (void)
3347 {
3348   if (test_ntfs_3g_probe_0_skip ()) {
3349     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
3350     return 0;
3351   }
3352
3353   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
3354   {
3355     char device[] = "/dev/sda";
3356     int r;
3357     suppress_error = 0;
3358     r = guestfs_blockdev_setrw (g, device);
3359     if (r == -1)
3360       return -1;
3361   }
3362   {
3363     int r;
3364     suppress_error = 0;
3365     r = guestfs_umount_all (g);
3366     if (r == -1)
3367       return -1;
3368   }
3369   {
3370     int r;
3371     suppress_error = 0;
3372     r = guestfs_lvm_remove_all (g);
3373     if (r == -1)
3374       return -1;
3375   }
3376   /* TestOutputInt for ntfs_3g_probe (0) */
3377   {
3378     char device[] = "/dev/sda";
3379     char lines_0[] = ",";
3380     char *lines[] = {
3381       lines_0,
3382       NULL
3383     };
3384     int r;
3385     suppress_error = 0;
3386     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3387     if (r == -1)
3388       return -1;
3389   }
3390   {
3391     char fstype[] = "ntfs";
3392     char device[] = "/dev/sda1";
3393     int r;
3394     suppress_error = 0;
3395     r = guestfs_mkfs (g, fstype, device);
3396     if (r == -1)
3397       return -1;
3398   }
3399   {
3400     char device[] = "/dev/sda1";
3401     int r;
3402     suppress_error = 0;
3403     r = guestfs_ntfs_3g_probe (g, 1, device);
3404     if (r == -1)
3405       return -1;
3406     if (r != 0) {
3407       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
3408       return -1;
3409     }
3410   }
3411   return 0;
3412 }
3413
3414 static int test_ntfs_3g_probe_1_skip (void)
3415 {
3416   const char *str;
3417
3418   str = getenv ("TEST_ONLY");
3419   if (str)
3420     return strstr (str, "ntfs_3g_probe") == NULL;
3421   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
3422   if (str && strcmp (str, "1") == 0) return 1;
3423   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3424   if (str && strcmp (str, "1") == 0) return 1;
3425   return 0;
3426 }
3427
3428 static int test_ntfs_3g_probe_1 (void)
3429 {
3430   if (test_ntfs_3g_probe_1_skip ()) {
3431     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
3432     return 0;
3433   }
3434
3435   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
3436   {
3437     char device[] = "/dev/sda";
3438     int r;
3439     suppress_error = 0;
3440     r = guestfs_blockdev_setrw (g, device);
3441     if (r == -1)
3442       return -1;
3443   }
3444   {
3445     int r;
3446     suppress_error = 0;
3447     r = guestfs_umount_all (g);
3448     if (r == -1)
3449       return -1;
3450   }
3451   {
3452     int r;
3453     suppress_error = 0;
3454     r = guestfs_lvm_remove_all (g);
3455     if (r == -1)
3456       return -1;
3457   }
3458   /* TestOutputInt for ntfs_3g_probe (1) */
3459   {
3460     char device[] = "/dev/sda";
3461     char lines_0[] = ",";
3462     char *lines[] = {
3463       lines_0,
3464       NULL
3465     };
3466     int r;
3467     suppress_error = 0;
3468     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3469     if (r == -1)
3470       return -1;
3471   }
3472   {
3473     char fstype[] = "ext2";
3474     char device[] = "/dev/sda1";
3475     int r;
3476     suppress_error = 0;
3477     r = guestfs_mkfs (g, fstype, device);
3478     if (r == -1)
3479       return -1;
3480   }
3481   {
3482     char device[] = "/dev/sda1";
3483     int r;
3484     suppress_error = 0;
3485     r = guestfs_ntfs_3g_probe (g, 1, device);
3486     if (r == -1)
3487       return -1;
3488     if (r != 12) {
3489       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
3490       return -1;
3491     }
3492   }
3493   return 0;
3494 }
3495
3496 static int test_sleep_0_skip (void)
3497 {
3498   const char *str;
3499
3500   str = getenv ("TEST_ONLY");
3501   if (str)
3502     return strstr (str, "sleep") == NULL;
3503   str = getenv ("SKIP_TEST_SLEEP_0");
3504   if (str && strcmp (str, "1") == 0) return 1;
3505   str = getenv ("SKIP_TEST_SLEEP");
3506   if (str && strcmp (str, "1") == 0) return 1;
3507   return 0;
3508 }
3509
3510 static int test_sleep_0 (void)
3511 {
3512   if (test_sleep_0_skip ()) {
3513     printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
3514     return 0;
3515   }
3516
3517   /* InitNone|InitEmpty for test_sleep_0 */
3518   {
3519     char device[] = "/dev/sda";
3520     int r;
3521     suppress_error = 0;
3522     r = guestfs_blockdev_setrw (g, device);
3523     if (r == -1)
3524       return -1;
3525   }
3526   {
3527     int r;
3528     suppress_error = 0;
3529     r = guestfs_umount_all (g);
3530     if (r == -1)
3531       return -1;
3532   }
3533   {
3534     int r;
3535     suppress_error = 0;
3536     r = guestfs_lvm_remove_all (g);
3537     if (r == -1)
3538       return -1;
3539   }
3540   /* TestRun for sleep (0) */
3541   {
3542     int r;
3543     suppress_error = 0;
3544     r = guestfs_sleep (g, 1);
3545     if (r == -1)
3546       return -1;
3547   }
3548   return 0;
3549 }
3550
3551 static int test_find_0_skip (void)
3552 {
3553   const char *str;
3554
3555   str = getenv ("TEST_ONLY");
3556   if (str)
3557     return strstr (str, "find") == NULL;
3558   str = getenv ("SKIP_TEST_FIND_0");
3559   if (str && strcmp (str, "1") == 0) return 1;
3560   str = getenv ("SKIP_TEST_FIND");
3561   if (str && strcmp (str, "1") == 0) return 1;
3562   return 0;
3563 }
3564
3565 static int test_find_0 (void)
3566 {
3567   if (test_find_0_skip ()) {
3568     printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
3569     return 0;
3570   }
3571
3572   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3573   {
3574     char device[] = "/dev/sda";
3575     int r;
3576     suppress_error = 0;
3577     r = guestfs_blockdev_setrw (g, device);
3578     if (r == -1)
3579       return -1;
3580   }
3581   {
3582     int r;
3583     suppress_error = 0;
3584     r = guestfs_umount_all (g);
3585     if (r == -1)
3586       return -1;
3587   }
3588   {
3589     int r;
3590     suppress_error = 0;
3591     r = guestfs_lvm_remove_all (g);
3592     if (r == -1)
3593       return -1;
3594   }
3595   {
3596     char device[] = "/dev/sda";
3597     char lines_0[] = ",";
3598     char *lines[] = {
3599       lines_0,
3600       NULL
3601     };
3602     int r;
3603     suppress_error = 0;
3604     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3605     if (r == -1)
3606       return -1;
3607   }
3608   {
3609     char fstype[] = "ext2";
3610     char device[] = "/dev/sda1";
3611     int r;
3612     suppress_error = 0;
3613     r = guestfs_mkfs (g, fstype, device);
3614     if (r == -1)
3615       return -1;
3616   }
3617   {
3618     char device[] = "/dev/sda1";
3619     char mountpoint[] = "/";
3620     int r;
3621     suppress_error = 0;
3622     r = guestfs_mount (g, device, mountpoint);
3623     if (r == -1)
3624       return -1;
3625   }
3626   /* TestOutputList for find (0) */
3627   {
3628     char directory[] = "/";
3629     char **r;
3630     int i;
3631     suppress_error = 0;
3632     r = guestfs_find (g, directory);
3633     if (r == NULL)
3634       return -1;
3635     if (!r[0]) {
3636       fprintf (stderr, "test_find_0: short list returned from command\n");
3637       print_strings (r);
3638       return -1;
3639     }
3640     {
3641       char expected[] = "lost+found";
3642       if (strcmp (r[0], expected) != 0) {
3643         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3644         return -1;
3645       }
3646     }
3647     if (r[1] != NULL) {
3648       fprintf (stderr, "test_find_0: extra elements returned from command\n");
3649       print_strings (r);
3650       return -1;
3651     }
3652     for (i = 0; r[i] != NULL; ++i)
3653       free (r[i]);
3654     free (r);
3655   }
3656   return 0;
3657 }
3658
3659 static int test_find_1_skip (void)
3660 {
3661   const char *str;
3662
3663   str = getenv ("TEST_ONLY");
3664   if (str)
3665     return strstr (str, "find") == NULL;
3666   str = getenv ("SKIP_TEST_FIND_1");
3667   if (str && strcmp (str, "1") == 0) return 1;
3668   str = getenv ("SKIP_TEST_FIND");
3669   if (str && strcmp (str, "1") == 0) return 1;
3670   return 0;
3671 }
3672
3673 static int test_find_1 (void)
3674 {
3675   if (test_find_1_skip ()) {
3676     printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
3677     return 0;
3678   }
3679
3680   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3681   {
3682     char device[] = "/dev/sda";
3683     int r;
3684     suppress_error = 0;
3685     r = guestfs_blockdev_setrw (g, device);
3686     if (r == -1)
3687       return -1;
3688   }
3689   {
3690     int r;
3691     suppress_error = 0;
3692     r = guestfs_umount_all (g);
3693     if (r == -1)
3694       return -1;
3695   }
3696   {
3697     int r;
3698     suppress_error = 0;
3699     r = guestfs_lvm_remove_all (g);
3700     if (r == -1)
3701       return -1;
3702   }
3703   {
3704     char device[] = "/dev/sda";
3705     char lines_0[] = ",";
3706     char *lines[] = {
3707       lines_0,
3708       NULL
3709     };
3710     int r;
3711     suppress_error = 0;
3712     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3713     if (r == -1)
3714       return -1;
3715   }
3716   {
3717     char fstype[] = "ext2";
3718     char device[] = "/dev/sda1";
3719     int r;
3720     suppress_error = 0;
3721     r = guestfs_mkfs (g, fstype, device);
3722     if (r == -1)
3723       return -1;
3724   }
3725   {
3726     char device[] = "/dev/sda1";
3727     char mountpoint[] = "/";
3728     int r;
3729     suppress_error = 0;
3730     r = guestfs_mount (g, device, mountpoint);
3731     if (r == -1)
3732       return -1;
3733   }
3734   /* TestOutputList for find (1) */
3735   {
3736     char path[] = "/a";
3737     int r;
3738     suppress_error = 0;
3739     r = guestfs_touch (g, path);
3740     if (r == -1)
3741       return -1;
3742   }
3743   {
3744     char path[] = "/b";
3745     int r;
3746     suppress_error = 0;
3747     r = guestfs_mkdir (g, path);
3748     if (r == -1)
3749       return -1;
3750   }
3751   {
3752     char path[] = "/b/c";
3753     int r;
3754     suppress_error = 0;
3755     r = guestfs_touch (g, path);
3756     if (r == -1)
3757       return -1;
3758   }
3759   {
3760     char directory[] = "/";
3761     char **r;
3762     int i;
3763     suppress_error = 0;
3764     r = guestfs_find (g, directory);
3765     if (r == NULL)
3766       return -1;
3767     if (!r[0]) {
3768       fprintf (stderr, "test_find_1: short list returned from command\n");
3769       print_strings (r);
3770       return -1;
3771     }
3772     {
3773       char expected[] = "a";
3774       if (strcmp (r[0], expected) != 0) {
3775         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3776         return -1;
3777       }
3778     }
3779     if (!r[1]) {
3780       fprintf (stderr, "test_find_1: short list returned from command\n");
3781       print_strings (r);
3782       return -1;
3783     }
3784     {
3785       char expected[] = "b";
3786       if (strcmp (r[1], expected) != 0) {
3787         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3788         return -1;
3789       }
3790     }
3791     if (!r[2]) {
3792       fprintf (stderr, "test_find_1: short list returned from command\n");
3793       print_strings (r);
3794       return -1;
3795     }
3796     {
3797       char expected[] = "b/c";
3798       if (strcmp (r[2], expected) != 0) {
3799         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3800         return -1;
3801       }
3802     }
3803     if (!r[3]) {
3804       fprintf (stderr, "test_find_1: short list returned from command\n");
3805       print_strings (r);
3806       return -1;
3807     }
3808     {
3809       char expected[] = "lost+found";
3810       if (strcmp (r[3], expected) != 0) {
3811         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3812         return -1;
3813       }
3814     }
3815     if (r[4] != NULL) {
3816       fprintf (stderr, "test_find_1: extra elements returned from command\n");
3817       print_strings (r);
3818       return -1;
3819     }
3820     for (i = 0; r[i] != NULL; ++i)
3821       free (r[i]);
3822     free (r);
3823   }
3824   return 0;
3825 }
3826
3827 static int test_find_2_skip (void)
3828 {
3829   const char *str;
3830
3831   str = getenv ("TEST_ONLY");
3832   if (str)
3833     return strstr (str, "find") == NULL;
3834   str = getenv ("SKIP_TEST_FIND_2");
3835   if (str && strcmp (str, "1") == 0) return 1;
3836   str = getenv ("SKIP_TEST_FIND");
3837   if (str && strcmp (str, "1") == 0) return 1;
3838   return 0;
3839 }
3840
3841 static int test_find_2 (void)
3842 {
3843   if (test_find_2_skip ()) {
3844     printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3845     return 0;
3846   }
3847
3848   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3849   {
3850     char device[] = "/dev/sda";
3851     int r;
3852     suppress_error = 0;
3853     r = guestfs_blockdev_setrw (g, device);
3854     if (r == -1)
3855       return -1;
3856   }
3857   {
3858     int r;
3859     suppress_error = 0;
3860     r = guestfs_umount_all (g);
3861     if (r == -1)
3862       return -1;
3863   }
3864   {
3865     int r;
3866     suppress_error = 0;
3867     r = guestfs_lvm_remove_all (g);
3868     if (r == -1)
3869       return -1;
3870   }
3871   {
3872     char device[] = "/dev/sda";
3873     char lines_0[] = ",";
3874     char *lines[] = {
3875       lines_0,
3876       NULL
3877     };
3878     int r;
3879     suppress_error = 0;
3880     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3881     if (r == -1)
3882       return -1;
3883   }
3884   {
3885     char fstype[] = "ext2";
3886     char device[] = "/dev/sda1";
3887     int r;
3888     suppress_error = 0;
3889     r = guestfs_mkfs (g, fstype, device);
3890     if (r == -1)
3891       return -1;
3892   }
3893   {
3894     char device[] = "/dev/sda1";
3895     char mountpoint[] = "/";
3896     int r;
3897     suppress_error = 0;
3898     r = guestfs_mount (g, device, mountpoint);
3899     if (r == -1)
3900       return -1;
3901   }
3902   /* TestOutputList for find (2) */
3903   {
3904     char path[] = "/a/b/c";
3905     int r;
3906     suppress_error = 0;
3907     r = guestfs_mkdir_p (g, path);
3908     if (r == -1)
3909       return -1;
3910   }
3911   {
3912     char path[] = "/a/b/c/d";
3913     int r;
3914     suppress_error = 0;
3915     r = guestfs_touch (g, path);
3916     if (r == -1)
3917       return -1;
3918   }
3919   {
3920     char directory[] = "/a/b/";
3921     char **r;
3922     int i;
3923     suppress_error = 0;
3924     r = guestfs_find (g, directory);
3925     if (r == NULL)
3926       return -1;
3927     if (!r[0]) {
3928       fprintf (stderr, "test_find_2: short list returned from command\n");
3929       print_strings (r);
3930       return -1;
3931     }
3932     {
3933       char expected[] = "c";
3934       if (strcmp (r[0], expected) != 0) {
3935         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3936         return -1;
3937       }
3938     }
3939     if (!r[1]) {
3940       fprintf (stderr, "test_find_2: short list returned from command\n");
3941       print_strings (r);
3942       return -1;
3943     }
3944     {
3945       char expected[] = "c/d";
3946       if (strcmp (r[1], expected) != 0) {
3947         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3948         return -1;
3949       }
3950     }
3951     if (r[2] != NULL) {
3952       fprintf (stderr, "test_find_2: extra elements returned from command\n");
3953       print_strings (r);
3954       return -1;
3955     }
3956     for (i = 0; r[i] != NULL; ++i)
3957       free (r[i]);
3958     free (r);
3959   }
3960   return 0;
3961 }
3962
3963 static int test_lvresize_0_skip (void)
3964 {
3965   const char *str;
3966
3967   str = getenv ("TEST_ONLY");
3968   if (str)
3969     return strstr (str, "lvresize") == NULL;
3970   str = getenv ("SKIP_TEST_LVRESIZE_0");
3971   if (str && strcmp (str, "1") == 0) return 1;
3972   str = getenv ("SKIP_TEST_LVRESIZE");
3973   if (str && strcmp (str, "1") == 0) return 1;
3974   return 0;
3975 }
3976
3977 static int test_lvresize_0 (void)
3978 {
3979   if (test_lvresize_0_skip ()) {
3980     printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3981     return 0;
3982   }
3983
3984   /* InitNone|InitEmpty for test_lvresize_0 */
3985   {
3986     char device[] = "/dev/sda";
3987     int r;
3988     suppress_error = 0;
3989     r = guestfs_blockdev_setrw (g, device);
3990     if (r == -1)
3991       return -1;
3992   }
3993   {
3994     int r;
3995     suppress_error = 0;
3996     r = guestfs_umount_all (g);
3997     if (r == -1)
3998       return -1;
3999   }
4000   {
4001     int r;
4002     suppress_error = 0;
4003     r = guestfs_lvm_remove_all (g);
4004     if (r == -1)
4005       return -1;
4006   }
4007   /* TestOutput for lvresize (0) */
4008   char expected[] = "test content";
4009   {
4010     char device[] = "/dev/sda";
4011     char lines_0[] = ",";
4012     char *lines[] = {
4013       lines_0,
4014       NULL
4015     };
4016     int r;
4017     suppress_error = 0;
4018     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4019     if (r == -1)
4020       return -1;
4021   }
4022   {
4023     char device[] = "/dev/sda1";
4024     int r;
4025     suppress_error = 0;
4026     r = guestfs_pvcreate (g, device);
4027     if (r == -1)
4028       return -1;
4029   }
4030   {
4031     char volgroup[] = "VG";
4032     char physvols_0[] = "/dev/sda1";
4033     char *physvols[] = {
4034       physvols_0,
4035       NULL
4036     };
4037     int r;
4038     suppress_error = 0;
4039     r = guestfs_vgcreate (g, volgroup, physvols);
4040     if (r == -1)
4041       return -1;
4042   }
4043   {
4044     char logvol[] = "LV";
4045     char volgroup[] = "VG";
4046     int r;
4047     suppress_error = 0;
4048     r = guestfs_lvcreate (g, logvol, volgroup, 10);
4049     if (r == -1)
4050       return -1;
4051   }
4052   {
4053     char fstype[] = "ext2";
4054     char device[] = "/dev/VG/LV";
4055     int r;
4056     suppress_error = 0;
4057     r = guestfs_mkfs (g, fstype, device);
4058     if (r == -1)
4059       return -1;
4060   }
4061   {
4062     char device[] = "/dev/VG/LV";
4063     char mountpoint[] = "/";
4064     int r;
4065     suppress_error = 0;
4066     r = guestfs_mount (g, device, mountpoint);
4067     if (r == -1)
4068       return -1;
4069   }
4070   {
4071     char path[] = "/new";
4072     char content[] = "test content";
4073     int r;
4074     suppress_error = 0;
4075     r = guestfs_write_file (g, path, content, 0);
4076     if (r == -1)
4077       return -1;
4078   }
4079   {
4080     char pathordevice[] = "/";
4081     int r;
4082     suppress_error = 0;
4083     r = guestfs_umount (g, pathordevice);
4084     if (r == -1)
4085       return -1;
4086   }
4087   {
4088     char device[] = "/dev/VG/LV";
4089     int r;
4090     suppress_error = 0;
4091     r = guestfs_lvresize (g, device, 20);
4092     if (r == -1)
4093       return -1;
4094   }
4095   {
4096     char device[] = "/dev/VG/LV";
4097     int r;
4098     suppress_error = 0;
4099     r = guestfs_e2fsck_f (g, device);
4100     if (r == -1)
4101       return -1;
4102   }
4103   {
4104     char device[] = "/dev/VG/LV";
4105     int r;
4106     suppress_error = 0;
4107     r = guestfs_resize2fs (g, device);
4108     if (r == -1)
4109       return -1;
4110   }
4111   {
4112     char device[] = "/dev/VG/LV";
4113     char mountpoint[] = "/";
4114     int r;
4115     suppress_error = 0;
4116     r = guestfs_mount (g, device, mountpoint);
4117     if (r == -1)
4118       return -1;
4119   }
4120   {
4121     char path[] = "/new";
4122     char *r;
4123     suppress_error = 0;
4124     r = guestfs_cat (g, path);
4125     if (r == NULL)
4126       return -1;
4127     if (strcmp (r, expected) != 0) {
4128       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
4129       return -1;
4130     }
4131     free (r);
4132   }
4133   return 0;
4134 }
4135
4136 static int test_zerofree_0_skip (void)
4137 {
4138   const char *str;
4139
4140   str = getenv ("TEST_ONLY");
4141   if (str)
4142     return strstr (str, "zerofree") == NULL;
4143   str = getenv ("SKIP_TEST_ZEROFREE_0");
4144   if (str && strcmp (str, "1") == 0) return 1;
4145   str = getenv ("SKIP_TEST_ZEROFREE");
4146   if (str && strcmp (str, "1") == 0) return 1;
4147   return 0;
4148 }
4149
4150 static int test_zerofree_0 (void)
4151 {
4152   if (test_zerofree_0_skip ()) {
4153     printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
4154     return 0;
4155   }
4156
4157   /* InitNone|InitEmpty for test_zerofree_0 */
4158   {
4159     char device[] = "/dev/sda";
4160     int r;
4161     suppress_error = 0;
4162     r = guestfs_blockdev_setrw (g, device);
4163     if (r == -1)
4164       return -1;
4165   }
4166   {
4167     int r;
4168     suppress_error = 0;
4169     r = guestfs_umount_all (g);
4170     if (r == -1)
4171       return -1;
4172   }
4173   {
4174     int r;
4175     suppress_error = 0;
4176     r = guestfs_lvm_remove_all (g);
4177     if (r == -1)
4178       return -1;
4179   }
4180   /* TestOutput for zerofree (0) */
4181   char expected[] = "test file";
4182   {
4183     char device[] = "/dev/sda";
4184     char lines_0[] = ",";
4185     char *lines[] = {
4186       lines_0,
4187       NULL
4188     };
4189     int r;
4190     suppress_error = 0;
4191     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4192     if (r == -1)
4193       return -1;
4194   }
4195   {
4196     char fstype[] = "ext3";
4197     char device[] = "/dev/sda1";
4198     int r;
4199     suppress_error = 0;
4200     r = guestfs_mkfs (g, fstype, device);
4201     if (r == -1)
4202       return -1;
4203   }
4204   {
4205     char device[] = "/dev/sda1";
4206     char mountpoint[] = "/";
4207     int r;
4208     suppress_error = 0;
4209     r = guestfs_mount (g, device, mountpoint);
4210     if (r == -1)
4211       return -1;
4212   }
4213   {
4214     char path[] = "/new";
4215     char content[] = "test file";
4216     int r;
4217     suppress_error = 0;
4218     r = guestfs_write_file (g, path, content, 0);
4219     if (r == -1)
4220       return -1;
4221   }
4222   {
4223     char pathordevice[] = "/dev/sda1";
4224     int r;
4225     suppress_error = 0;
4226     r = guestfs_umount (g, pathordevice);
4227     if (r == -1)
4228       return -1;
4229   }
4230   {
4231     char device[] = "/dev/sda1";
4232     int r;
4233     suppress_error = 0;
4234     r = guestfs_zerofree (g, device);
4235     if (r == -1)
4236       return -1;
4237   }
4238   {
4239     char device[] = "/dev/sda1";
4240     char mountpoint[] = "/";
4241     int r;
4242     suppress_error = 0;
4243     r = guestfs_mount (g, device, mountpoint);
4244     if (r == -1)
4245       return -1;
4246   }
4247   {
4248     char path[] = "/new";
4249     char *r;
4250     suppress_error = 0;
4251     r = guestfs_cat (g, path);
4252     if (r == NULL)
4253       return -1;
4254     if (strcmp (r, expected) != 0) {
4255       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
4256       return -1;
4257     }
4258     free (r);
4259   }
4260   return 0;
4261 }
4262
4263 static int test_hexdump_0_skip (void)
4264 {
4265   const char *str;
4266
4267   str = getenv ("TEST_ONLY");
4268   if (str)
4269     return strstr (str, "hexdump") == NULL;
4270   str = getenv ("SKIP_TEST_HEXDUMP_0");
4271   if (str && strcmp (str, "1") == 0) return 1;
4272   str = getenv ("SKIP_TEST_HEXDUMP");
4273   if (str && strcmp (str, "1") == 0) return 1;
4274   return 0;
4275 }
4276
4277 static int test_hexdump_0 (void)
4278 {
4279   if (test_hexdump_0_skip ()) {
4280     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
4281     return 0;
4282   }
4283
4284   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
4285   {
4286     char device[] = "/dev/sda";
4287     int r;
4288     suppress_error = 0;
4289     r = guestfs_blockdev_setrw (g, device);
4290     if (r == -1)
4291       return -1;
4292   }
4293   {
4294     int r;
4295     suppress_error = 0;
4296     r = guestfs_umount_all (g);
4297     if (r == -1)
4298       return -1;
4299   }
4300   {
4301     int r;
4302     suppress_error = 0;
4303     r = guestfs_lvm_remove_all (g);
4304     if (r == -1)
4305       return -1;
4306   }
4307   {
4308     char device[] = "/dev/sda";
4309     char lines_0[] = ",";
4310     char *lines[] = {
4311       lines_0,
4312       NULL
4313     };
4314     int r;
4315     suppress_error = 0;
4316     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4317     if (r == -1)
4318       return -1;
4319   }
4320   {
4321     char fstype[] = "ext2";
4322     char device[] = "/dev/sda1";
4323     int r;
4324     suppress_error = 0;
4325     r = guestfs_mkfs (g, fstype, device);
4326     if (r == -1)
4327       return -1;
4328   }
4329   {
4330     char device[] = "/dev/sda1";
4331     char mountpoint[] = "/";
4332     int r;
4333     suppress_error = 0;
4334     r = guestfs_mount (g, device, mountpoint);
4335     if (r == -1)
4336       return -1;
4337   }
4338   /* TestOutput for hexdump (0) */
4339   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
4340   {
4341     char path[] = "/new";
4342     char content[] = "hello\nworld\n";
4343     int r;
4344     suppress_error = 0;
4345     r = guestfs_write_file (g, path, content, 12);
4346     if (r == -1)
4347       return -1;
4348   }
4349   {
4350     char path[] = "/new";
4351     char *r;
4352     suppress_error = 0;
4353     r = guestfs_hexdump (g, path);
4354     if (r == NULL)
4355       return -1;
4356     if (strcmp (r, expected) != 0) {
4357       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
4358       return -1;
4359     }
4360     free (r);
4361   }
4362   return 0;
4363 }
4364
4365 static int test_hexdump_1_skip (void)
4366 {
4367   const char *str;
4368
4369   str = getenv ("TEST_ONLY");
4370   if (str)
4371     return strstr (str, "hexdump") == NULL;
4372   str = getenv ("SKIP_TEST_HEXDUMP_1");
4373   if (str && strcmp (str, "1") == 0) return 1;
4374   str = getenv ("SKIP_TEST_HEXDUMP");
4375   if (str && strcmp (str, "1") == 0) return 1;
4376   return 0;
4377 }
4378
4379 static int test_hexdump_1 (void)
4380 {
4381   if (test_hexdump_1_skip ()) {
4382     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
4383     return 0;
4384   }
4385
4386   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
4387   {
4388     char device[] = "/dev/sda";
4389     int r;
4390     suppress_error = 0;
4391     r = guestfs_blockdev_setrw (g, device);
4392     if (r == -1)
4393       return -1;
4394   }
4395   {
4396     int r;
4397     suppress_error = 0;
4398     r = guestfs_umount_all (g);
4399     if (r == -1)
4400       return -1;
4401   }
4402   {
4403     int r;
4404     suppress_error = 0;
4405     r = guestfs_lvm_remove_all (g);
4406     if (r == -1)
4407       return -1;
4408   }
4409   {
4410     char device[] = "/dev/sda";
4411     char lines_0[] = ",";
4412     char *lines[] = {
4413       lines_0,
4414       NULL
4415     };
4416     int r;
4417     suppress_error = 0;
4418     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4419     if (r == -1)
4420       return -1;
4421   }
4422   {
4423     char fstype[] = "ext2";
4424     char device[] = "/dev/sda1";
4425     int r;
4426     suppress_error = 0;
4427     r = guestfs_mkfs (g, fstype, device);
4428     if (r == -1)
4429       return -1;
4430   }
4431   {
4432     char device[] = "/dev/sda1";
4433     char mountpoint[] = "/";
4434     int r;
4435     suppress_error = 0;
4436     r = guestfs_mount (g, device, mountpoint);
4437     if (r == -1)
4438       return -1;
4439   }
4440   /* TestRun for hexdump (1) */
4441   {
4442     char options[] = "ro";
4443     char vfstype[] = "squashfs";
4444     char device[] = "/dev/sdd";
4445     char mountpoint[] = "/";
4446     int r;
4447     suppress_error = 0;
4448     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
4449     if (r == -1)
4450       return -1;
4451   }
4452   {
4453     char path[] = "/100krandom";
4454     char *r;
4455     suppress_error = 0;
4456     r = guestfs_hexdump (g, path);
4457     if (r == NULL)
4458       return -1;
4459     free (r);
4460   }
4461   return 0;
4462 }
4463
4464 static int test_strings_e_0_skip (void)
4465 {
4466   const char *str;
4467
4468   str = getenv ("TEST_ONLY");
4469   if (str)
4470     return strstr (str, "strings_e") == NULL;
4471   str = getenv ("SKIP_TEST_STRINGS_E_0");
4472   if (str && strcmp (str, "1") == 0) return 1;
4473   str = getenv ("SKIP_TEST_STRINGS_E");
4474   if (str && strcmp (str, "1") == 0) return 1;
4475   return 0;
4476 }
4477
4478 static int test_strings_e_0 (void)
4479 {
4480   if (test_strings_e_0_skip ()) {
4481     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
4482     return 0;
4483   }
4484
4485   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
4486   {
4487     char device[] = "/dev/sda";
4488     int r;
4489     suppress_error = 0;
4490     r = guestfs_blockdev_setrw (g, device);
4491     if (r == -1)
4492       return -1;
4493   }
4494   {
4495     int r;
4496     suppress_error = 0;
4497     r = guestfs_umount_all (g);
4498     if (r == -1)
4499       return -1;
4500   }
4501   {
4502     int r;
4503     suppress_error = 0;
4504     r = guestfs_lvm_remove_all (g);
4505     if (r == -1)
4506       return -1;
4507   }
4508   {
4509     char device[] = "/dev/sda";
4510     char lines_0[] = ",";
4511     char *lines[] = {
4512       lines_0,
4513       NULL
4514     };
4515     int r;
4516     suppress_error = 0;
4517     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4518     if (r == -1)
4519       return -1;
4520   }
4521   {
4522     char fstype[] = "ext2";
4523     char device[] = "/dev/sda1";
4524     int r;
4525     suppress_error = 0;
4526     r = guestfs_mkfs (g, fstype, device);
4527     if (r == -1)
4528       return -1;
4529   }
4530   {
4531     char device[] = "/dev/sda1";
4532     char mountpoint[] = "/";
4533     int r;
4534     suppress_error = 0;
4535     r = guestfs_mount (g, device, mountpoint);
4536     if (r == -1)
4537       return -1;
4538   }
4539   /* TestOutputList for strings_e (0) */
4540   {
4541     char path[] = "/new";
4542     char content[] = "hello\nworld\n";
4543     int r;
4544     suppress_error = 0;
4545     r = guestfs_write_file (g, path, content, 0);
4546     if (r == -1)
4547       return -1;
4548   }
4549   {
4550     char encoding[] = "b";
4551     char path[] = "/new";
4552     char **r;
4553     int i;
4554     suppress_error = 0;
4555     r = guestfs_strings_e (g, encoding, path);
4556     if (r == NULL)
4557       return -1;
4558     if (r[0] != NULL) {
4559       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
4560       print_strings (r);
4561       return -1;
4562     }
4563     for (i = 0; r[i] != NULL; ++i)
4564       free (r[i]);
4565     free (r);
4566   }
4567   return 0;
4568 }
4569
4570 static int test_strings_e_1_skip (void)
4571 {
4572   const char *str;
4573
4574   str = getenv ("TEST_ONLY");
4575   if (str)
4576     return strstr (str, "strings_e") == NULL;
4577   str = getenv ("SKIP_TEST_STRINGS_E_1");
4578   if (str && strcmp (str, "1") == 0) return 1;
4579   str = getenv ("SKIP_TEST_STRINGS_E");
4580   if (str && strcmp (str, "1") == 0) return 1;
4581   return 0;
4582 }
4583
4584 static int test_strings_e_1 (void)
4585 {
4586   if (test_strings_e_1_skip ()) {
4587     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
4588     return 0;
4589   }
4590
4591   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
4592   return 0;
4593 }
4594
4595 static int test_strings_0_skip (void)
4596 {
4597   const char *str;
4598
4599   str = getenv ("TEST_ONLY");
4600   if (str)
4601     return strstr (str, "strings") == NULL;
4602   str = getenv ("SKIP_TEST_STRINGS_0");
4603   if (str && strcmp (str, "1") == 0) return 1;
4604   str = getenv ("SKIP_TEST_STRINGS");
4605   if (str && strcmp (str, "1") == 0) return 1;
4606   return 0;
4607 }
4608
4609 static int test_strings_0 (void)
4610 {
4611   if (test_strings_0_skip ()) {
4612     printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
4613     return 0;
4614   }
4615
4616   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
4617   {
4618     char device[] = "/dev/sda";
4619     int r;
4620     suppress_error = 0;
4621     r = guestfs_blockdev_setrw (g, device);
4622     if (r == -1)
4623       return -1;
4624   }
4625   {
4626     int r;
4627     suppress_error = 0;
4628     r = guestfs_umount_all (g);
4629     if (r == -1)
4630       return -1;
4631   }
4632   {
4633     int r;
4634     suppress_error = 0;
4635     r = guestfs_lvm_remove_all (g);
4636     if (r == -1)
4637       return -1;
4638   }
4639   {
4640     char device[] = "/dev/sda";
4641     char lines_0[] = ",";
4642     char *lines[] = {
4643       lines_0,
4644       NULL
4645     };
4646     int r;
4647     suppress_error = 0;
4648     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4649     if (r == -1)
4650       return -1;
4651   }
4652   {
4653     char fstype[] = "ext2";
4654     char device[] = "/dev/sda1";
4655     int r;
4656     suppress_error = 0;
4657     r = guestfs_mkfs (g, fstype, device);
4658     if (r == -1)
4659       return -1;
4660   }
4661   {
4662     char device[] = "/dev/sda1";
4663     char mountpoint[] = "/";
4664     int r;
4665     suppress_error = 0;
4666     r = guestfs_mount (g, device, mountpoint);
4667     if (r == -1)
4668       return -1;
4669   }
4670   /* TestOutputList for strings (0) */
4671   {
4672     char path[] = "/new";
4673     char content[] = "hello\nworld\n";
4674     int r;
4675     suppress_error = 0;
4676     r = guestfs_write_file (g, path, content, 0);
4677     if (r == -1)
4678       return -1;
4679   }
4680   {
4681     char path[] = "/new";
4682     char **r;
4683     int i;
4684     suppress_error = 0;
4685     r = guestfs_strings (g, path);
4686     if (r == NULL)
4687       return -1;
4688     if (!r[0]) {
4689       fprintf (stderr, "test_strings_0: short list returned from command\n");
4690       print_strings (r);
4691       return -1;
4692     }
4693     {
4694       char expected[] = "hello";
4695       if (strcmp (r[0], expected) != 0) {
4696         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4697         return -1;
4698       }
4699     }
4700     if (!r[1]) {
4701       fprintf (stderr, "test_strings_0: short list returned from command\n");
4702       print_strings (r);
4703       return -1;
4704     }
4705     {
4706       char expected[] = "world";
4707       if (strcmp (r[1], expected) != 0) {
4708         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
4709         return -1;
4710       }
4711     }
4712     if (r[2] != NULL) {
4713       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4714       print_strings (r);
4715       return -1;
4716     }
4717     for (i = 0; r[i] != NULL; ++i)
4718       free (r[i]);
4719     free (r);
4720   }
4721   return 0;
4722 }
4723
4724 static int test_strings_1_skip (void)
4725 {
4726   const char *str;
4727
4728   str = getenv ("TEST_ONLY");
4729   if (str)
4730     return strstr (str, "strings") == NULL;
4731   str = getenv ("SKIP_TEST_STRINGS_1");
4732   if (str && strcmp (str, "1") == 0) return 1;
4733   str = getenv ("SKIP_TEST_STRINGS");
4734   if (str && strcmp (str, "1") == 0) return 1;
4735   return 0;
4736 }
4737
4738 static int test_strings_1 (void)
4739 {
4740   if (test_strings_1_skip ()) {
4741     printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
4742     return 0;
4743   }
4744
4745   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4746   {
4747     char device[] = "/dev/sda";
4748     int r;
4749     suppress_error = 0;
4750     r = guestfs_blockdev_setrw (g, device);
4751     if (r == -1)
4752       return -1;
4753   }
4754   {
4755     int r;
4756     suppress_error = 0;
4757     r = guestfs_umount_all (g);
4758     if (r == -1)
4759       return -1;
4760   }
4761   {
4762     int r;
4763     suppress_error = 0;
4764     r = guestfs_lvm_remove_all (g);
4765     if (r == -1)
4766       return -1;
4767   }
4768   {
4769     char device[] = "/dev/sda";
4770     char lines_0[] = ",";
4771     char *lines[] = {
4772       lines_0,
4773       NULL
4774     };
4775     int r;
4776     suppress_error = 0;
4777     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4778     if (r == -1)
4779       return -1;
4780   }
4781   {
4782     char fstype[] = "ext2";
4783     char device[] = "/dev/sda1";
4784     int r;
4785     suppress_error = 0;
4786     r = guestfs_mkfs (g, fstype, device);
4787     if (r == -1)
4788       return -1;
4789   }
4790   {
4791     char device[] = "/dev/sda1";
4792     char mountpoint[] = "/";
4793     int r;
4794     suppress_error = 0;
4795     r = guestfs_mount (g, device, mountpoint);
4796     if (r == -1)
4797       return -1;
4798   }
4799   /* TestOutputList for strings (1) */
4800   {
4801     char path[] = "/new";
4802     int r;
4803     suppress_error = 0;
4804     r = guestfs_touch (g, path);
4805     if (r == -1)
4806       return -1;
4807   }
4808   {
4809     char path[] = "/new";
4810     char **r;
4811     int i;
4812     suppress_error = 0;
4813     r = guestfs_strings (g, path);
4814     if (r == NULL)
4815       return -1;
4816     if (r[0] != NULL) {
4817       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4818       print_strings (r);
4819       return -1;
4820     }
4821     for (i = 0; r[i] != NULL; ++i)
4822       free (r[i]);
4823     free (r);
4824   }
4825   return 0;
4826 }
4827
4828 static int test_equal_0_skip (void)
4829 {
4830   const char *str;
4831
4832   str = getenv ("TEST_ONLY");
4833   if (str)
4834     return strstr (str, "equal") == NULL;
4835   str = getenv ("SKIP_TEST_EQUAL_0");
4836   if (str && strcmp (str, "1") == 0) return 1;
4837   str = getenv ("SKIP_TEST_EQUAL");
4838   if (str && strcmp (str, "1") == 0) return 1;
4839   return 0;
4840 }
4841
4842 static int test_equal_0 (void)
4843 {
4844   if (test_equal_0_skip ()) {
4845     printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
4846     return 0;
4847   }
4848
4849   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4850   {
4851     char device[] = "/dev/sda";
4852     int r;
4853     suppress_error = 0;
4854     r = guestfs_blockdev_setrw (g, device);
4855     if (r == -1)
4856       return -1;
4857   }
4858   {
4859     int r;
4860     suppress_error = 0;
4861     r = guestfs_umount_all (g);
4862     if (r == -1)
4863       return -1;
4864   }
4865   {
4866     int r;
4867     suppress_error = 0;
4868     r = guestfs_lvm_remove_all (g);
4869     if (r == -1)
4870       return -1;
4871   }
4872   {
4873     char device[] = "/dev/sda";
4874     char lines_0[] = ",";
4875     char *lines[] = {
4876       lines_0,
4877       NULL
4878     };
4879     int r;
4880     suppress_error = 0;
4881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4882     if (r == -1)
4883       return -1;
4884   }
4885   {
4886     char fstype[] = "ext2";
4887     char device[] = "/dev/sda1";
4888     int r;
4889     suppress_error = 0;
4890     r = guestfs_mkfs (g, fstype, device);
4891     if (r == -1)
4892       return -1;
4893   }
4894   {
4895     char device[] = "/dev/sda1";
4896     char mountpoint[] = "/";
4897     int r;
4898     suppress_error = 0;
4899     r = guestfs_mount (g, device, mountpoint);
4900     if (r == -1)
4901       return -1;
4902   }
4903   /* TestOutputTrue for equal (0) */
4904   {
4905     char path[] = "/file1";
4906     char content[] = "contents of a file";
4907     int r;
4908     suppress_error = 0;
4909     r = guestfs_write_file (g, path, content, 0);
4910     if (r == -1)
4911       return -1;
4912   }
4913   {
4914     char src[] = "/file1";
4915     char dest[] = "/file2";
4916     int r;
4917     suppress_error = 0;
4918     r = guestfs_cp (g, src, dest);
4919     if (r == -1)
4920       return -1;
4921   }
4922   {
4923     char file1[] = "/file1";
4924     char file2[] = "/file2";
4925     int r;
4926     suppress_error = 0;
4927     r = guestfs_equal (g, file1, file2);
4928     if (r == -1)
4929       return -1;
4930     if (!r) {
4931       fprintf (stderr, "test_equal_0: expected true, got false\n");
4932       return -1;
4933     }
4934   }
4935   return 0;
4936 }
4937
4938 static int test_equal_1_skip (void)
4939 {
4940   const char *str;
4941
4942   str = getenv ("TEST_ONLY");
4943   if (str)
4944     return strstr (str, "equal") == NULL;
4945   str = getenv ("SKIP_TEST_EQUAL_1");
4946   if (str && strcmp (str, "1") == 0) return 1;
4947   str = getenv ("SKIP_TEST_EQUAL");
4948   if (str && strcmp (str, "1") == 0) return 1;
4949   return 0;
4950 }
4951
4952 static int test_equal_1 (void)
4953 {
4954   if (test_equal_1_skip ()) {
4955     printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4956     return 0;
4957   }
4958
4959   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4960   {
4961     char device[] = "/dev/sda";
4962     int r;
4963     suppress_error = 0;
4964     r = guestfs_blockdev_setrw (g, device);
4965     if (r == -1)
4966       return -1;
4967   }
4968   {
4969     int r;
4970     suppress_error = 0;
4971     r = guestfs_umount_all (g);
4972     if (r == -1)
4973       return -1;
4974   }
4975   {
4976     int r;
4977     suppress_error = 0;
4978     r = guestfs_lvm_remove_all (g);
4979     if (r == -1)
4980       return -1;
4981   }
4982   {
4983     char device[] = "/dev/sda";
4984     char lines_0[] = ",";
4985     char *lines[] = {
4986       lines_0,
4987       NULL
4988     };
4989     int r;
4990     suppress_error = 0;
4991     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4992     if (r == -1)
4993       return -1;
4994   }
4995   {
4996     char fstype[] = "ext2";
4997     char device[] = "/dev/sda1";
4998     int r;
4999     suppress_error = 0;
5000     r = guestfs_mkfs (g, fstype, device);
5001     if (r == -1)
5002       return -1;
5003   }
5004   {
5005     char device[] = "/dev/sda1";
5006     char mountpoint[] = "/";
5007     int r;
5008     suppress_error = 0;
5009     r = guestfs_mount (g, device, mountpoint);
5010     if (r == -1)
5011       return -1;
5012   }
5013   /* TestOutputFalse for equal (1) */
5014   {
5015     char path[] = "/file1";
5016     char content[] = "contents of a file";
5017     int r;
5018     suppress_error = 0;
5019     r = guestfs_write_file (g, path, content, 0);
5020     if (r == -1)
5021       return -1;
5022   }
5023   {
5024     char path[] = "/file2";
5025     char content[] = "contents of another file";
5026     int r;
5027     suppress_error = 0;
5028     r = guestfs_write_file (g, path, content, 0);
5029     if (r == -1)
5030       return -1;
5031   }
5032   {
5033     char file1[] = "/file1";
5034     char file2[] = "/file2";
5035     int r;
5036     suppress_error = 0;
5037     r = guestfs_equal (g, file1, file2);
5038     if (r == -1)
5039       return -1;
5040     if (r) {
5041       fprintf (stderr, "test_equal_1: expected false, got true\n");
5042       return -1;
5043     }
5044   }
5045   return 0;
5046 }
5047
5048 static int test_equal_2_skip (void)
5049 {
5050   const char *str;
5051
5052   str = getenv ("TEST_ONLY");
5053   if (str)
5054     return strstr (str, "equal") == NULL;
5055   str = getenv ("SKIP_TEST_EQUAL_2");
5056   if (str && strcmp (str, "1") == 0) return 1;
5057   str = getenv ("SKIP_TEST_EQUAL");
5058   if (str && strcmp (str, "1") == 0) return 1;
5059   return 0;
5060 }
5061
5062 static int test_equal_2 (void)
5063 {
5064   if (test_equal_2_skip ()) {
5065     printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
5066     return 0;
5067   }
5068
5069   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
5070   {
5071     char device[] = "/dev/sda";
5072     int r;
5073     suppress_error = 0;
5074     r = guestfs_blockdev_setrw (g, device);
5075     if (r == -1)
5076       return -1;
5077   }
5078   {
5079     int r;
5080     suppress_error = 0;
5081     r = guestfs_umount_all (g);
5082     if (r == -1)
5083       return -1;
5084   }
5085   {
5086     int r;
5087     suppress_error = 0;
5088     r = guestfs_lvm_remove_all (g);
5089     if (r == -1)
5090       return -1;
5091   }
5092   {
5093     char device[] = "/dev/sda";
5094     char lines_0[] = ",";
5095     char *lines[] = {
5096       lines_0,
5097       NULL
5098     };
5099     int r;
5100     suppress_error = 0;
5101     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5102     if (r == -1)
5103       return -1;
5104   }
5105   {
5106     char fstype[] = "ext2";
5107     char device[] = "/dev/sda1";
5108     int r;
5109     suppress_error = 0;
5110     r = guestfs_mkfs (g, fstype, device);
5111     if (r == -1)
5112       return -1;
5113   }
5114   {
5115     char device[] = "/dev/sda1";
5116     char mountpoint[] = "/";
5117     int r;
5118     suppress_error = 0;
5119     r = guestfs_mount (g, device, mountpoint);
5120     if (r == -1)
5121       return -1;
5122   }
5123   /* TestLastFail for equal (2) */
5124   {
5125     char file1[] = "/file1";
5126     char file2[] = "/file2";
5127     int r;
5128     suppress_error = 1;
5129     r = guestfs_equal (g, file1, file2);
5130     if (r != -1)
5131       return -1;
5132   }
5133   return 0;
5134 }
5135
5136 static int test_ping_daemon_0_skip (void)
5137 {
5138   const char *str;
5139
5140   str = getenv ("TEST_ONLY");
5141   if (str)
5142     return strstr (str, "ping_daemon") == NULL;
5143   str = getenv ("SKIP_TEST_PING_DAEMON_0");
5144   if (str && strcmp (str, "1") == 0) return 1;
5145   str = getenv ("SKIP_TEST_PING_DAEMON");
5146   if (str && strcmp (str, "1") == 0) return 1;
5147   return 0;
5148 }
5149
5150 static int test_ping_daemon_0 (void)
5151 {
5152   if (test_ping_daemon_0_skip ()) {
5153     printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
5154     return 0;
5155   }
5156
5157   /* InitNone|InitEmpty for test_ping_daemon_0 */
5158   {
5159     char device[] = "/dev/sda";
5160     int r;
5161     suppress_error = 0;
5162     r = guestfs_blockdev_setrw (g, device);
5163     if (r == -1)
5164       return -1;
5165   }
5166   {
5167     int r;
5168     suppress_error = 0;
5169     r = guestfs_umount_all (g);
5170     if (r == -1)
5171       return -1;
5172   }
5173   {
5174     int r;
5175     suppress_error = 0;
5176     r = guestfs_lvm_remove_all (g);
5177     if (r == -1)
5178       return -1;
5179   }
5180   /* TestRun for ping_daemon (0) */
5181   {
5182     int r;
5183     suppress_error = 0;
5184     r = guestfs_ping_daemon (g);
5185     if (r == -1)
5186       return -1;
5187   }
5188   return 0;
5189 }
5190
5191 static int test_dmesg_0_skip (void)
5192 {
5193   const char *str;
5194
5195   str = getenv ("TEST_ONLY");
5196   if (str)
5197     return strstr (str, "dmesg") == NULL;
5198   str = getenv ("SKIP_TEST_DMESG_0");
5199   if (str && strcmp (str, "1") == 0) return 1;
5200   str = getenv ("SKIP_TEST_DMESG");
5201   if (str && strcmp (str, "1") == 0) return 1;
5202   return 0;
5203 }
5204
5205 static int test_dmesg_0 (void)
5206 {
5207   if (test_dmesg_0_skip ()) {
5208     printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
5209     return 0;
5210   }
5211
5212   /* InitNone|InitEmpty for test_dmesg_0 */
5213   {
5214     char device[] = "/dev/sda";
5215     int r;
5216     suppress_error = 0;
5217     r = guestfs_blockdev_setrw (g, device);
5218     if (r == -1)
5219       return -1;
5220   }
5221   {
5222     int r;
5223     suppress_error = 0;
5224     r = guestfs_umount_all (g);
5225     if (r == -1)
5226       return -1;
5227   }
5228   {
5229     int r;
5230     suppress_error = 0;
5231     r = guestfs_lvm_remove_all (g);
5232     if (r == -1)
5233       return -1;
5234   }
5235   /* TestRun for dmesg (0) */
5236   {
5237     char *r;
5238     suppress_error = 0;
5239     r = guestfs_dmesg (g);
5240     if (r == NULL)
5241       return -1;
5242     free (r);
5243   }
5244   return 0;
5245 }
5246
5247 static int test_drop_caches_0_skip (void)
5248 {
5249   const char *str;
5250
5251   str = getenv ("TEST_ONLY");
5252   if (str)
5253     return strstr (str, "drop_caches") == NULL;
5254   str = getenv ("SKIP_TEST_DROP_CACHES_0");
5255   if (str && strcmp (str, "1") == 0) return 1;
5256   str = getenv ("SKIP_TEST_DROP_CACHES");
5257   if (str && strcmp (str, "1") == 0) return 1;
5258   return 0;
5259 }
5260
5261 static int test_drop_caches_0 (void)
5262 {
5263   if (test_drop_caches_0_skip ()) {
5264     printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
5265     return 0;
5266   }
5267
5268   /* InitNone|InitEmpty for test_drop_caches_0 */
5269   {
5270     char device[] = "/dev/sda";
5271     int r;
5272     suppress_error = 0;
5273     r = guestfs_blockdev_setrw (g, device);
5274     if (r == -1)
5275       return -1;
5276   }
5277   {
5278     int r;
5279     suppress_error = 0;
5280     r = guestfs_umount_all (g);
5281     if (r == -1)
5282       return -1;
5283   }
5284   {
5285     int r;
5286     suppress_error = 0;
5287     r = guestfs_lvm_remove_all (g);
5288     if (r == -1)
5289       return -1;
5290   }
5291   /* TestRun for drop_caches (0) */
5292   {
5293     int r;
5294     suppress_error = 0;
5295     r = guestfs_drop_caches (g, 3);
5296     if (r == -1)
5297       return -1;
5298   }
5299   return 0;
5300 }
5301
5302 static int test_mv_0_skip (void)
5303 {
5304   const char *str;
5305
5306   str = getenv ("TEST_ONLY");
5307   if (str)
5308     return strstr (str, "mv") == NULL;
5309   str = getenv ("SKIP_TEST_MV_0");
5310   if (str && strcmp (str, "1") == 0) return 1;
5311   str = getenv ("SKIP_TEST_MV");
5312   if (str && strcmp (str, "1") == 0) return 1;
5313   return 0;
5314 }
5315
5316 static int test_mv_0 (void)
5317 {
5318   if (test_mv_0_skip ()) {
5319     printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
5320     return 0;
5321   }
5322
5323   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
5324   {
5325     char device[] = "/dev/sda";
5326     int r;
5327     suppress_error = 0;
5328     r = guestfs_blockdev_setrw (g, device);
5329     if (r == -1)
5330       return -1;
5331   }
5332   {
5333     int r;
5334     suppress_error = 0;
5335     r = guestfs_umount_all (g);
5336     if (r == -1)
5337       return -1;
5338   }
5339   {
5340     int r;
5341     suppress_error = 0;
5342     r = guestfs_lvm_remove_all (g);
5343     if (r == -1)
5344       return -1;
5345   }
5346   {
5347     char device[] = "/dev/sda";
5348     char lines_0[] = ",";
5349     char *lines[] = {
5350       lines_0,
5351       NULL
5352     };
5353     int r;
5354     suppress_error = 0;
5355     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5356     if (r == -1)
5357       return -1;
5358   }
5359   {
5360     char fstype[] = "ext2";
5361     char device[] = "/dev/sda1";
5362     int r;
5363     suppress_error = 0;
5364     r = guestfs_mkfs (g, fstype, device);
5365     if (r == -1)
5366       return -1;
5367   }
5368   {
5369     char device[] = "/dev/sda1";
5370     char mountpoint[] = "/";
5371     int r;
5372     suppress_error = 0;
5373     r = guestfs_mount (g, device, mountpoint);
5374     if (r == -1)
5375       return -1;
5376   }
5377   /* TestOutput for mv (0) */
5378   char expected[] = "file content";
5379   {
5380     char path[] = "/old";
5381     char content[] = "file content";
5382     int r;
5383     suppress_error = 0;
5384     r = guestfs_write_file (g, path, content, 0);
5385     if (r == -1)
5386       return -1;
5387   }
5388   {
5389     char src[] = "/old";
5390     char dest[] = "/new";
5391     int r;
5392     suppress_error = 0;
5393     r = guestfs_mv (g, src, dest);
5394     if (r == -1)
5395       return -1;
5396   }
5397   {
5398     char path[] = "/new";
5399     char *r;
5400     suppress_error = 0;
5401     r = guestfs_cat (g, path);
5402     if (r == NULL)
5403       return -1;
5404     if (strcmp (r, expected) != 0) {
5405       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
5406       return -1;
5407     }
5408     free (r);
5409   }
5410   return 0;
5411 }
5412
5413 static int test_mv_1_skip (void)
5414 {
5415   const char *str;
5416
5417   str = getenv ("TEST_ONLY");
5418   if (str)
5419     return strstr (str, "mv") == NULL;
5420   str = getenv ("SKIP_TEST_MV_1");
5421   if (str && strcmp (str, "1") == 0) return 1;
5422   str = getenv ("SKIP_TEST_MV");
5423   if (str && strcmp (str, "1") == 0) return 1;
5424   return 0;
5425 }
5426
5427 static int test_mv_1 (void)
5428 {
5429   if (test_mv_1_skip ()) {
5430     printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
5431     return 0;
5432   }
5433
5434   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
5435   {
5436     char device[] = "/dev/sda";
5437     int r;
5438     suppress_error = 0;
5439     r = guestfs_blockdev_setrw (g, device);
5440     if (r == -1)
5441       return -1;
5442   }
5443   {
5444     int r;
5445     suppress_error = 0;
5446     r = guestfs_umount_all (g);
5447     if (r == -1)
5448       return -1;
5449   }
5450   {
5451     int r;
5452     suppress_error = 0;
5453     r = guestfs_lvm_remove_all (g);
5454     if (r == -1)
5455       return -1;
5456   }
5457   {
5458     char device[] = "/dev/sda";
5459     char lines_0[] = ",";
5460     char *lines[] = {
5461       lines_0,
5462       NULL
5463     };
5464     int r;
5465     suppress_error = 0;
5466     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5467     if (r == -1)
5468       return -1;
5469   }
5470   {
5471     char fstype[] = "ext2";
5472     char device[] = "/dev/sda1";
5473     int r;
5474     suppress_error = 0;
5475     r = guestfs_mkfs (g, fstype, device);
5476     if (r == -1)
5477       return -1;
5478   }
5479   {
5480     char device[] = "/dev/sda1";
5481     char mountpoint[] = "/";
5482     int r;
5483     suppress_error = 0;
5484     r = guestfs_mount (g, device, mountpoint);
5485     if (r == -1)
5486       return -1;
5487   }
5488   /* TestOutputFalse for mv (1) */
5489   {
5490     char path[] = "/old";
5491     char content[] = "file content";
5492     int r;
5493     suppress_error = 0;
5494     r = guestfs_write_file (g, path, content, 0);
5495     if (r == -1)
5496       return -1;
5497   }
5498   {
5499     char src[] = "/old";
5500     char dest[] = "/new";
5501     int r;
5502     suppress_error = 0;
5503     r = guestfs_mv (g, src, dest);
5504     if (r == -1)
5505       return -1;
5506   }
5507   {
5508     char path[] = "/old";
5509     int r;
5510     suppress_error = 0;
5511     r = guestfs_is_file (g, path);
5512     if (r == -1)
5513       return -1;
5514     if (r) {
5515       fprintf (stderr, "test_mv_1: expected false, got true\n");
5516       return -1;
5517     }
5518   }
5519   return 0;
5520 }
5521
5522 static int test_cp_a_0_skip (void)
5523 {
5524   const char *str;
5525
5526   str = getenv ("TEST_ONLY");
5527   if (str)
5528     return strstr (str, "cp_a") == NULL;
5529   str = getenv ("SKIP_TEST_CP_A_0");
5530   if (str && strcmp (str, "1") == 0) return 1;
5531   str = getenv ("SKIP_TEST_CP_A");
5532   if (str && strcmp (str, "1") == 0) return 1;
5533   return 0;
5534 }
5535
5536 static int test_cp_a_0 (void)
5537 {
5538   if (test_cp_a_0_skip ()) {
5539     printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
5540     return 0;
5541   }
5542
5543   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
5544   {
5545     char device[] = "/dev/sda";
5546     int r;
5547     suppress_error = 0;
5548     r = guestfs_blockdev_setrw (g, device);
5549     if (r == -1)
5550       return -1;
5551   }
5552   {
5553     int r;
5554     suppress_error = 0;
5555     r = guestfs_umount_all (g);
5556     if (r == -1)
5557       return -1;
5558   }
5559   {
5560     int r;
5561     suppress_error = 0;
5562     r = guestfs_lvm_remove_all (g);
5563     if (r == -1)
5564       return -1;
5565   }
5566   {
5567     char device[] = "/dev/sda";
5568     char lines_0[] = ",";
5569     char *lines[] = {
5570       lines_0,
5571       NULL
5572     };
5573     int r;
5574     suppress_error = 0;
5575     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5576     if (r == -1)
5577       return -1;
5578   }
5579   {
5580     char fstype[] = "ext2";
5581     char device[] = "/dev/sda1";
5582     int r;
5583     suppress_error = 0;
5584     r = guestfs_mkfs (g, fstype, device);
5585     if (r == -1)
5586       return -1;
5587   }
5588   {
5589     char device[] = "/dev/sda1";
5590     char mountpoint[] = "/";
5591     int r;
5592     suppress_error = 0;
5593     r = guestfs_mount (g, device, mountpoint);
5594     if (r == -1)
5595       return -1;
5596   }
5597   /* TestOutput for cp_a (0) */
5598   char expected[] = "file content";
5599   {
5600     char path[] = "/olddir";
5601     int r;
5602     suppress_error = 0;
5603     r = guestfs_mkdir (g, path);
5604     if (r == -1)
5605       return -1;
5606   }
5607   {
5608     char path[] = "/newdir";
5609     int r;
5610     suppress_error = 0;
5611     r = guestfs_mkdir (g, path);
5612     if (r == -1)
5613       return -1;
5614   }
5615   {
5616     char path[] = "/olddir/file";
5617     char content[] = "file content";
5618     int r;
5619     suppress_error = 0;
5620     r = guestfs_write_file (g, path, content, 0);
5621     if (r == -1)
5622       return -1;
5623   }
5624   {
5625     char src[] = "/olddir";
5626     char dest[] = "/newdir";
5627     int r;
5628     suppress_error = 0;
5629     r = guestfs_cp_a (g, src, dest);
5630     if (r == -1)
5631       return -1;
5632   }
5633   {
5634     char path[] = "/newdir/olddir/file";
5635     char *r;
5636     suppress_error = 0;
5637     r = guestfs_cat (g, path);
5638     if (r == NULL)
5639       return -1;
5640     if (strcmp (r, expected) != 0) {
5641       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
5642       return -1;
5643     }
5644     free (r);
5645   }
5646   return 0;
5647 }
5648
5649 static int test_cp_0_skip (void)
5650 {
5651   const char *str;
5652
5653   str = getenv ("TEST_ONLY");
5654   if (str)
5655     return strstr (str, "cp") == NULL;
5656   str = getenv ("SKIP_TEST_CP_0");
5657   if (str && strcmp (str, "1") == 0) return 1;
5658   str = getenv ("SKIP_TEST_CP");
5659   if (str && strcmp (str, "1") == 0) return 1;
5660   return 0;
5661 }
5662
5663 static int test_cp_0 (void)
5664 {
5665   if (test_cp_0_skip ()) {
5666     printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
5667     return 0;
5668   }
5669
5670   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
5671   {
5672     char device[] = "/dev/sda";
5673     int r;
5674     suppress_error = 0;
5675     r = guestfs_blockdev_setrw (g, device);
5676     if (r == -1)
5677       return -1;
5678   }
5679   {
5680     int r;
5681     suppress_error = 0;
5682     r = guestfs_umount_all (g);
5683     if (r == -1)
5684       return -1;
5685   }
5686   {
5687     int r;
5688     suppress_error = 0;
5689     r = guestfs_lvm_remove_all (g);
5690     if (r == -1)
5691       return -1;
5692   }
5693   {
5694     char device[] = "/dev/sda";
5695     char lines_0[] = ",";
5696     char *lines[] = {
5697       lines_0,
5698       NULL
5699     };
5700     int r;
5701     suppress_error = 0;
5702     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5703     if (r == -1)
5704       return -1;
5705   }
5706   {
5707     char fstype[] = "ext2";
5708     char device[] = "/dev/sda1";
5709     int r;
5710     suppress_error = 0;
5711     r = guestfs_mkfs (g, fstype, device);
5712     if (r == -1)
5713       return -1;
5714   }
5715   {
5716     char device[] = "/dev/sda1";
5717     char mountpoint[] = "/";
5718     int r;
5719     suppress_error = 0;
5720     r = guestfs_mount (g, device, mountpoint);
5721     if (r == -1)
5722       return -1;
5723   }
5724   /* TestOutput for cp (0) */
5725   char expected[] = "file content";
5726   {
5727     char path[] = "/old";
5728     char content[] = "file content";
5729     int r;
5730     suppress_error = 0;
5731     r = guestfs_write_file (g, path, content, 0);
5732     if (r == -1)
5733       return -1;
5734   }
5735   {
5736     char src[] = "/old";
5737     char dest[] = "/new";
5738     int r;
5739     suppress_error = 0;
5740     r = guestfs_cp (g, src, dest);
5741     if (r == -1)
5742       return -1;
5743   }
5744   {
5745     char path[] = "/new";
5746     char *r;
5747     suppress_error = 0;
5748     r = guestfs_cat (g, path);
5749     if (r == NULL)
5750       return -1;
5751     if (strcmp (r, expected) != 0) {
5752       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5753       return -1;
5754     }
5755     free (r);
5756   }
5757   return 0;
5758 }
5759
5760 static int test_cp_1_skip (void)
5761 {
5762   const char *str;
5763
5764   str = getenv ("TEST_ONLY");
5765   if (str)
5766     return strstr (str, "cp") == NULL;
5767   str = getenv ("SKIP_TEST_CP_1");
5768   if (str && strcmp (str, "1") == 0) return 1;
5769   str = getenv ("SKIP_TEST_CP");
5770   if (str && strcmp (str, "1") == 0) return 1;
5771   return 0;
5772 }
5773
5774 static int test_cp_1 (void)
5775 {
5776   if (test_cp_1_skip ()) {
5777     printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
5778     return 0;
5779   }
5780
5781   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5782   {
5783     char device[] = "/dev/sda";
5784     int r;
5785     suppress_error = 0;
5786     r = guestfs_blockdev_setrw (g, device);
5787     if (r == -1)
5788       return -1;
5789   }
5790   {
5791     int r;
5792     suppress_error = 0;
5793     r = guestfs_umount_all (g);
5794     if (r == -1)
5795       return -1;
5796   }
5797   {
5798     int r;
5799     suppress_error = 0;
5800     r = guestfs_lvm_remove_all (g);
5801     if (r == -1)
5802       return -1;
5803   }
5804   {
5805     char device[] = "/dev/sda";
5806     char lines_0[] = ",";
5807     char *lines[] = {
5808       lines_0,
5809       NULL
5810     };
5811     int r;
5812     suppress_error = 0;
5813     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5814     if (r == -1)
5815       return -1;
5816   }
5817   {
5818     char fstype[] = "ext2";
5819     char device[] = "/dev/sda1";
5820     int r;
5821     suppress_error = 0;
5822     r = guestfs_mkfs (g, fstype, device);
5823     if (r == -1)
5824       return -1;
5825   }
5826   {
5827     char device[] = "/dev/sda1";
5828     char mountpoint[] = "/";
5829     int r;
5830     suppress_error = 0;
5831     r = guestfs_mount (g, device, mountpoint);
5832     if (r == -1)
5833       return -1;
5834   }
5835   /* TestOutputTrue for cp (1) */
5836   {
5837     char path[] = "/old";
5838     char content[] = "file content";
5839     int r;
5840     suppress_error = 0;
5841     r = guestfs_write_file (g, path, content, 0);
5842     if (r == -1)
5843       return -1;
5844   }
5845   {
5846     char src[] = "/old";
5847     char dest[] = "/new";
5848     int r;
5849     suppress_error = 0;
5850     r = guestfs_cp (g, src, dest);
5851     if (r == -1)
5852       return -1;
5853   }
5854   {
5855     char path[] = "/old";
5856     int r;
5857     suppress_error = 0;
5858     r = guestfs_is_file (g, path);
5859     if (r == -1)
5860       return -1;
5861     if (!r) {
5862       fprintf (stderr, "test_cp_1: expected true, got false\n");
5863       return -1;
5864     }
5865   }
5866   return 0;
5867 }
5868
5869 static int test_cp_2_skip (void)
5870 {
5871   const char *str;
5872
5873   str = getenv ("TEST_ONLY");
5874   if (str)
5875     return strstr (str, "cp") == NULL;
5876   str = getenv ("SKIP_TEST_CP_2");
5877   if (str && strcmp (str, "1") == 0) return 1;
5878   str = getenv ("SKIP_TEST_CP");
5879   if (str && strcmp (str, "1") == 0) return 1;
5880   return 0;
5881 }
5882
5883 static int test_cp_2 (void)
5884 {
5885   if (test_cp_2_skip ()) {
5886     printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5887     return 0;
5888   }
5889
5890   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5891   {
5892     char device[] = "/dev/sda";
5893     int r;
5894     suppress_error = 0;
5895     r = guestfs_blockdev_setrw (g, device);
5896     if (r == -1)
5897       return -1;
5898   }
5899   {
5900     int r;
5901     suppress_error = 0;
5902     r = guestfs_umount_all (g);
5903     if (r == -1)
5904       return -1;
5905   }
5906   {
5907     int r;
5908     suppress_error = 0;
5909     r = guestfs_lvm_remove_all (g);
5910     if (r == -1)
5911       return -1;
5912   }
5913   {
5914     char device[] = "/dev/sda";
5915     char lines_0[] = ",";
5916     char *lines[] = {
5917       lines_0,
5918       NULL
5919     };
5920     int r;
5921     suppress_error = 0;
5922     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5923     if (r == -1)
5924       return -1;
5925   }
5926   {
5927     char fstype[] = "ext2";
5928     char device[] = "/dev/sda1";
5929     int r;
5930     suppress_error = 0;
5931     r = guestfs_mkfs (g, fstype, device);
5932     if (r == -1)
5933       return -1;
5934   }
5935   {
5936     char device[] = "/dev/sda1";
5937     char mountpoint[] = "/";
5938     int r;
5939     suppress_error = 0;
5940     r = guestfs_mount (g, device, mountpoint);
5941     if (r == -1)
5942       return -1;
5943   }
5944   /* TestOutput for cp (2) */
5945   char expected[] = "file content";
5946   {
5947     char path[] = "/old";
5948     char content[] = "file content";
5949     int r;
5950     suppress_error = 0;
5951     r = guestfs_write_file (g, path, content, 0);
5952     if (r == -1)
5953       return -1;
5954   }
5955   {
5956     char path[] = "/dir";
5957     int r;
5958     suppress_error = 0;
5959     r = guestfs_mkdir (g, path);
5960     if (r == -1)
5961       return -1;
5962   }
5963   {
5964     char src[] = "/old";
5965     char dest[] = "/dir/new";
5966     int r;
5967     suppress_error = 0;
5968     r = guestfs_cp (g, src, dest);
5969     if (r == -1)
5970       return -1;
5971   }
5972   {
5973     char path[] = "/dir/new";
5974     char *r;
5975     suppress_error = 0;
5976     r = guestfs_cat (g, path);
5977     if (r == NULL)
5978       return -1;
5979     if (strcmp (r, expected) != 0) {
5980       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5981       return -1;
5982     }
5983     free (r);
5984   }
5985   return 0;
5986 }
5987
5988 static int test_grub_install_0_skip (void)
5989 {
5990   const char *str;
5991
5992   str = getenv ("TEST_ONLY");
5993   if (str)
5994     return strstr (str, "grub_install") == NULL;
5995   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5996   if (str && strcmp (str, "1") == 0) return 1;
5997   str = getenv ("SKIP_TEST_GRUB_INSTALL");
5998   if (str && strcmp (str, "1") == 0) return 1;
5999   return 0;
6000 }
6001
6002 static int test_grub_install_0 (void)
6003 {
6004   if (test_grub_install_0_skip ()) {
6005     printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
6006     return 0;
6007   }
6008
6009   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
6010   {
6011     char device[] = "/dev/sda";
6012     int r;
6013     suppress_error = 0;
6014     r = guestfs_blockdev_setrw (g, device);
6015     if (r == -1)
6016       return -1;
6017   }
6018   {
6019     int r;
6020     suppress_error = 0;
6021     r = guestfs_umount_all (g);
6022     if (r == -1)
6023       return -1;
6024   }
6025   {
6026     int r;
6027     suppress_error = 0;
6028     r = guestfs_lvm_remove_all (g);
6029     if (r == -1)
6030       return -1;
6031   }
6032   {
6033     char device[] = "/dev/sda";
6034     char lines_0[] = ",";
6035     char *lines[] = {
6036       lines_0,
6037       NULL
6038     };
6039     int r;
6040     suppress_error = 0;
6041     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6042     if (r == -1)
6043       return -1;
6044   }
6045   {
6046     char fstype[] = "ext2";
6047     char device[] = "/dev/sda1";
6048     int r;
6049     suppress_error = 0;
6050     r = guestfs_mkfs (g, fstype, device);
6051     if (r == -1)
6052       return -1;
6053   }
6054   {
6055     char device[] = "/dev/sda1";
6056     char mountpoint[] = "/";
6057     int r;
6058     suppress_error = 0;
6059     r = guestfs_mount (g, device, mountpoint);
6060     if (r == -1)
6061       return -1;
6062   }
6063   /* TestOutputTrue for grub_install (0) */
6064   {
6065     char root[] = "/";
6066     char device[] = "/dev/sda1";
6067     int r;
6068     suppress_error = 0;
6069     r = guestfs_grub_install (g, root, device);
6070     if (r == -1)
6071       return -1;
6072   }
6073   {
6074     char path[] = "/boot";
6075     int r;
6076     suppress_error = 0;
6077     r = guestfs_is_dir (g, path);
6078     if (r == -1)
6079       return -1;
6080     if (!r) {
6081       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
6082       return -1;
6083     }
6084   }
6085   return 0;
6086 }
6087
6088 static int test_zero_0_skip (void)
6089 {
6090   const char *str;
6091
6092   str = getenv ("TEST_ONLY");
6093   if (str)
6094     return strstr (str, "zero") == NULL;
6095   str = getenv ("SKIP_TEST_ZERO_0");
6096   if (str && strcmp (str, "1") == 0) return 1;
6097   str = getenv ("SKIP_TEST_ZERO");
6098   if (str && strcmp (str, "1") == 0) return 1;
6099   return 0;
6100 }
6101
6102 static int test_zero_0 (void)
6103 {
6104   if (test_zero_0_skip ()) {
6105     printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
6106     return 0;
6107   }
6108
6109   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
6110   {
6111     char device[] = "/dev/sda";
6112     int r;
6113     suppress_error = 0;
6114     r = guestfs_blockdev_setrw (g, device);
6115     if (r == -1)
6116       return -1;
6117   }
6118   {
6119     int r;
6120     suppress_error = 0;
6121     r = guestfs_umount_all (g);
6122     if (r == -1)
6123       return -1;
6124   }
6125   {
6126     int r;
6127     suppress_error = 0;
6128     r = guestfs_lvm_remove_all (g);
6129     if (r == -1)
6130       return -1;
6131   }
6132   {
6133     char device[] = "/dev/sda";
6134     char lines_0[] = ",";
6135     char *lines[] = {
6136       lines_0,
6137       NULL
6138     };
6139     int r;
6140     suppress_error = 0;
6141     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6142     if (r == -1)
6143       return -1;
6144   }
6145   {
6146     char fstype[] = "ext2";
6147     char device[] = "/dev/sda1";
6148     int r;
6149     suppress_error = 0;
6150     r = guestfs_mkfs (g, fstype, device);
6151     if (r == -1)
6152       return -1;
6153   }
6154   {
6155     char device[] = "/dev/sda1";
6156     char mountpoint[] = "/";
6157     int r;
6158     suppress_error = 0;
6159     r = guestfs_mount (g, device, mountpoint);
6160     if (r == -1)
6161       return -1;
6162   }
6163   /* TestOutput for zero (0) */
6164   char expected[] = "data";
6165   {
6166     char pathordevice[] = "/dev/sda1";
6167     int r;
6168     suppress_error = 0;
6169     r = guestfs_umount (g, pathordevice);
6170     if (r == -1)
6171       return -1;
6172   }
6173   {
6174     char device[] = "/dev/sda1";
6175     int r;
6176     suppress_error = 0;
6177     r = guestfs_zero (g, device);
6178     if (r == -1)
6179       return -1;
6180   }
6181   {
6182     char path[] = "/dev/sda1";
6183     char *r;
6184     suppress_error = 0;
6185     r = guestfs_file (g, path);
6186     if (r == NULL)
6187       return -1;
6188     if (strcmp (r, expected) != 0) {
6189       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
6190       return -1;
6191     }
6192     free (r);
6193   }
6194   return 0;
6195 }
6196
6197 static int test_fsck_0_skip (void)
6198 {
6199   const char *str;
6200
6201   str = getenv ("TEST_ONLY");
6202   if (str)
6203     return strstr (str, "fsck") == NULL;
6204   str = getenv ("SKIP_TEST_FSCK_0");
6205   if (str && strcmp (str, "1") == 0) return 1;
6206   str = getenv ("SKIP_TEST_FSCK");
6207   if (str && strcmp (str, "1") == 0) return 1;
6208   return 0;
6209 }
6210
6211 static int test_fsck_0 (void)
6212 {
6213   if (test_fsck_0_skip ()) {
6214     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
6215     return 0;
6216   }
6217
6218   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
6219   {
6220     char device[] = "/dev/sda";
6221     int r;
6222     suppress_error = 0;
6223     r = guestfs_blockdev_setrw (g, device);
6224     if (r == -1)
6225       return -1;
6226   }
6227   {
6228     int r;
6229     suppress_error = 0;
6230     r = guestfs_umount_all (g);
6231     if (r == -1)
6232       return -1;
6233   }
6234   {
6235     int r;
6236     suppress_error = 0;
6237     r = guestfs_lvm_remove_all (g);
6238     if (r == -1)
6239       return -1;
6240   }
6241   {
6242     char device[] = "/dev/sda";
6243     char lines_0[] = ",";
6244     char *lines[] = {
6245       lines_0,
6246       NULL
6247     };
6248     int r;
6249     suppress_error = 0;
6250     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6251     if (r == -1)
6252       return -1;
6253   }
6254   {
6255     char fstype[] = "ext2";
6256     char device[] = "/dev/sda1";
6257     int r;
6258     suppress_error = 0;
6259     r = guestfs_mkfs (g, fstype, device);
6260     if (r == -1)
6261       return -1;
6262   }
6263   {
6264     char device[] = "/dev/sda1";
6265     char mountpoint[] = "/";
6266     int r;
6267     suppress_error = 0;
6268     r = guestfs_mount (g, device, mountpoint);
6269     if (r == -1)
6270       return -1;
6271   }
6272   /* TestOutputInt for fsck (0) */
6273   {
6274     char pathordevice[] = "/dev/sda1";
6275     int r;
6276     suppress_error = 0;
6277     r = guestfs_umount (g, pathordevice);
6278     if (r == -1)
6279       return -1;
6280   }
6281   {
6282     char fstype[] = "ext2";
6283     char device[] = "/dev/sda1";
6284     int r;
6285     suppress_error = 0;
6286     r = guestfs_fsck (g, fstype, device);
6287     if (r == -1)
6288       return -1;
6289     if (r != 0) {
6290       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
6291       return -1;
6292     }
6293   }
6294   return 0;
6295 }
6296
6297 static int test_fsck_1_skip (void)
6298 {
6299   const char *str;
6300
6301   str = getenv ("TEST_ONLY");
6302   if (str)
6303     return strstr (str, "fsck") == NULL;
6304   str = getenv ("SKIP_TEST_FSCK_1");
6305   if (str && strcmp (str, "1") == 0) return 1;
6306   str = getenv ("SKIP_TEST_FSCK");
6307   if (str && strcmp (str, "1") == 0) return 1;
6308   return 0;
6309 }
6310
6311 static int test_fsck_1 (void)
6312 {
6313   if (test_fsck_1_skip ()) {
6314     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
6315     return 0;
6316   }
6317
6318   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
6319   {
6320     char device[] = "/dev/sda";
6321     int r;
6322     suppress_error = 0;
6323     r = guestfs_blockdev_setrw (g, device);
6324     if (r == -1)
6325       return -1;
6326   }
6327   {
6328     int r;
6329     suppress_error = 0;
6330     r = guestfs_umount_all (g);
6331     if (r == -1)
6332       return -1;
6333   }
6334   {
6335     int r;
6336     suppress_error = 0;
6337     r = guestfs_lvm_remove_all (g);
6338     if (r == -1)
6339       return -1;
6340   }
6341   {
6342     char device[] = "/dev/sda";
6343     char lines_0[] = ",";
6344     char *lines[] = {
6345       lines_0,
6346       NULL
6347     };
6348     int r;
6349     suppress_error = 0;
6350     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6351     if (r == -1)
6352       return -1;
6353   }
6354   {
6355     char fstype[] = "ext2";
6356     char device[] = "/dev/sda1";
6357     int r;
6358     suppress_error = 0;
6359     r = guestfs_mkfs (g, fstype, device);
6360     if (r == -1)
6361       return -1;
6362   }
6363   {
6364     char device[] = "/dev/sda1";
6365     char mountpoint[] = "/";
6366     int r;
6367     suppress_error = 0;
6368     r = guestfs_mount (g, device, mountpoint);
6369     if (r == -1)
6370       return -1;
6371   }
6372   /* TestOutputInt for fsck (1) */
6373   {
6374     char pathordevice[] = "/dev/sda1";
6375     int r;
6376     suppress_error = 0;
6377     r = guestfs_umount (g, pathordevice);
6378     if (r == -1)
6379       return -1;
6380   }
6381   {
6382     char device[] = "/dev/sda1";
6383     int r;
6384     suppress_error = 0;
6385     r = guestfs_zero (g, device);
6386     if (r == -1)
6387       return -1;
6388   }
6389   {
6390     char fstype[] = "ext2";
6391     char device[] = "/dev/sda1";
6392     int r;
6393     suppress_error = 0;
6394     r = guestfs_fsck (g, fstype, device);
6395     if (r == -1)
6396       return -1;
6397     if (r != 8) {
6398       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
6399       return -1;
6400     }
6401   }
6402   return 0;
6403 }
6404
6405 static int test_set_e2uuid_0_skip (void)
6406 {
6407   const char *str;
6408
6409   str = getenv ("TEST_ONLY");
6410   if (str)
6411     return strstr (str, "set_e2uuid") == NULL;
6412   str = getenv ("SKIP_TEST_SET_E2UUID_0");
6413   if (str && strcmp (str, "1") == 0) return 1;
6414   str = getenv ("SKIP_TEST_SET_E2UUID");
6415   if (str && strcmp (str, "1") == 0) return 1;
6416   return 0;
6417 }
6418
6419 static int test_set_e2uuid_0 (void)
6420 {
6421   if (test_set_e2uuid_0_skip ()) {
6422     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
6423     return 0;
6424   }
6425
6426   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
6427   {
6428     char device[] = "/dev/sda";
6429     int r;
6430     suppress_error = 0;
6431     r = guestfs_blockdev_setrw (g, device);
6432     if (r == -1)
6433       return -1;
6434   }
6435   {
6436     int r;
6437     suppress_error = 0;
6438     r = guestfs_umount_all (g);
6439     if (r == -1)
6440       return -1;
6441   }
6442   {
6443     int r;
6444     suppress_error = 0;
6445     r = guestfs_lvm_remove_all (g);
6446     if (r == -1)
6447       return -1;
6448   }
6449   {
6450     char device[] = "/dev/sda";
6451     char lines_0[] = ",";
6452     char *lines[] = {
6453       lines_0,
6454       NULL
6455     };
6456     int r;
6457     suppress_error = 0;
6458     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6459     if (r == -1)
6460       return -1;
6461   }
6462   {
6463     char fstype[] = "ext2";
6464     char device[] = "/dev/sda1";
6465     int r;
6466     suppress_error = 0;
6467     r = guestfs_mkfs (g, fstype, device);
6468     if (r == -1)
6469       return -1;
6470   }
6471   {
6472     char device[] = "/dev/sda1";
6473     char mountpoint[] = "/";
6474     int r;
6475     suppress_error = 0;
6476     r = guestfs_mount (g, device, mountpoint);
6477     if (r == -1)
6478       return -1;
6479   }
6480   /* TestOutput for set_e2uuid (0) */
6481   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6482   {
6483     char device[] = "/dev/sda1";
6484     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6485     int r;
6486     suppress_error = 0;
6487     r = guestfs_set_e2uuid (g, device, uuid);
6488     if (r == -1)
6489       return -1;
6490   }
6491   {
6492     char device[] = "/dev/sda1";
6493     char *r;
6494     suppress_error = 0;
6495     r = guestfs_get_e2uuid (g, device);
6496     if (r == NULL)
6497       return -1;
6498     if (strcmp (r, expected) != 0) {
6499       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
6500       return -1;
6501     }
6502     free (r);
6503   }
6504   return 0;
6505 }
6506
6507 static int test_set_e2uuid_1_skip (void)
6508 {
6509   const char *str;
6510
6511   str = getenv ("TEST_ONLY");
6512   if (str)
6513     return strstr (str, "set_e2uuid") == NULL;
6514   str = getenv ("SKIP_TEST_SET_E2UUID_1");
6515   if (str && strcmp (str, "1") == 0) return 1;
6516   str = getenv ("SKIP_TEST_SET_E2UUID");
6517   if (str && strcmp (str, "1") == 0) return 1;
6518   return 0;
6519 }
6520
6521 static int test_set_e2uuid_1 (void)
6522 {
6523   if (test_set_e2uuid_1_skip ()) {
6524     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
6525     return 0;
6526   }
6527
6528   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
6529   {
6530     char device[] = "/dev/sda";
6531     int r;
6532     suppress_error = 0;
6533     r = guestfs_blockdev_setrw (g, device);
6534     if (r == -1)
6535       return -1;
6536   }
6537   {
6538     int r;
6539     suppress_error = 0;
6540     r = guestfs_umount_all (g);
6541     if (r == -1)
6542       return -1;
6543   }
6544   {
6545     int r;
6546     suppress_error = 0;
6547     r = guestfs_lvm_remove_all (g);
6548     if (r == -1)
6549       return -1;
6550   }
6551   {
6552     char device[] = "/dev/sda";
6553     char lines_0[] = ",";
6554     char *lines[] = {
6555       lines_0,
6556       NULL
6557     };
6558     int r;
6559     suppress_error = 0;
6560     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6561     if (r == -1)
6562       return -1;
6563   }
6564   {
6565     char fstype[] = "ext2";
6566     char device[] = "/dev/sda1";
6567     int r;
6568     suppress_error = 0;
6569     r = guestfs_mkfs (g, fstype, device);
6570     if (r == -1)
6571       return -1;
6572   }
6573   {
6574     char device[] = "/dev/sda1";
6575     char mountpoint[] = "/";
6576     int r;
6577     suppress_error = 0;
6578     r = guestfs_mount (g, device, mountpoint);
6579     if (r == -1)
6580       return -1;
6581   }
6582   /* TestOutput for set_e2uuid (1) */
6583   char expected[] = "";
6584   {
6585     char device[] = "/dev/sda1";
6586     char uuid[] = "clear";
6587     int r;
6588     suppress_error = 0;
6589     r = guestfs_set_e2uuid (g, device, uuid);
6590     if (r == -1)
6591       return -1;
6592   }
6593   {
6594     char device[] = "/dev/sda1";
6595     char *r;
6596     suppress_error = 0;
6597     r = guestfs_get_e2uuid (g, device);
6598     if (r == NULL)
6599       return -1;
6600     if (strcmp (r, expected) != 0) {
6601       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
6602       return -1;
6603     }
6604     free (r);
6605   }
6606   return 0;
6607 }
6608
6609 static int test_set_e2uuid_2_skip (void)
6610 {
6611   const char *str;
6612
6613   str = getenv ("TEST_ONLY");
6614   if (str)
6615     return strstr (str, "set_e2uuid") == NULL;
6616   str = getenv ("SKIP_TEST_SET_E2UUID_2");
6617   if (str && strcmp (str, "1") == 0) return 1;
6618   str = getenv ("SKIP_TEST_SET_E2UUID");
6619   if (str && strcmp (str, "1") == 0) return 1;
6620   return 0;
6621 }
6622
6623 static int test_set_e2uuid_2 (void)
6624 {
6625   if (test_set_e2uuid_2_skip ()) {
6626     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
6627     return 0;
6628   }
6629
6630   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
6631   {
6632     char device[] = "/dev/sda";
6633     int r;
6634     suppress_error = 0;
6635     r = guestfs_blockdev_setrw (g, device);
6636     if (r == -1)
6637       return -1;
6638   }
6639   {
6640     int r;
6641     suppress_error = 0;
6642     r = guestfs_umount_all (g);
6643     if (r == -1)
6644       return -1;
6645   }
6646   {
6647     int r;
6648     suppress_error = 0;
6649     r = guestfs_lvm_remove_all (g);
6650     if (r == -1)
6651       return -1;
6652   }
6653   {
6654     char device[] = "/dev/sda";
6655     char lines_0[] = ",";
6656     char *lines[] = {
6657       lines_0,
6658       NULL
6659     };
6660     int r;
6661     suppress_error = 0;
6662     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6663     if (r == -1)
6664       return -1;
6665   }
6666   {
6667     char fstype[] = "ext2";
6668     char device[] = "/dev/sda1";
6669     int r;
6670     suppress_error = 0;
6671     r = guestfs_mkfs (g, fstype, device);
6672     if (r == -1)
6673       return -1;
6674   }
6675   {
6676     char device[] = "/dev/sda1";
6677     char mountpoint[] = "/";
6678     int r;
6679     suppress_error = 0;
6680     r = guestfs_mount (g, device, mountpoint);
6681     if (r == -1)
6682       return -1;
6683   }
6684   /* TestRun for set_e2uuid (2) */
6685   {
6686     char device[] = "/dev/sda1";
6687     char uuid[] = "random";
6688     int r;
6689     suppress_error = 0;
6690     r = guestfs_set_e2uuid (g, device, uuid);
6691     if (r == -1)
6692       return -1;
6693   }
6694   return 0;
6695 }
6696
6697 static int test_set_e2uuid_3_skip (void)
6698 {
6699   const char *str;
6700
6701   str = getenv ("TEST_ONLY");
6702   if (str)
6703     return strstr (str, "set_e2uuid") == NULL;
6704   str = getenv ("SKIP_TEST_SET_E2UUID_3");
6705   if (str && strcmp (str, "1") == 0) return 1;
6706   str = getenv ("SKIP_TEST_SET_E2UUID");
6707   if (str && strcmp (str, "1") == 0) return 1;
6708   return 0;
6709 }
6710
6711 static int test_set_e2uuid_3 (void)
6712 {
6713   if (test_set_e2uuid_3_skip ()) {
6714     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6715     return 0;
6716   }
6717
6718   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6719   {
6720     char device[] = "/dev/sda";
6721     int r;
6722     suppress_error = 0;
6723     r = guestfs_blockdev_setrw (g, device);
6724     if (r == -1)
6725       return -1;
6726   }
6727   {
6728     int r;
6729     suppress_error = 0;
6730     r = guestfs_umount_all (g);
6731     if (r == -1)
6732       return -1;
6733   }
6734   {
6735     int r;
6736     suppress_error = 0;
6737     r = guestfs_lvm_remove_all (g);
6738     if (r == -1)
6739       return -1;
6740   }
6741   {
6742     char device[] = "/dev/sda";
6743     char lines_0[] = ",";
6744     char *lines[] = {
6745       lines_0,
6746       NULL
6747     };
6748     int r;
6749     suppress_error = 0;
6750     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6751     if (r == -1)
6752       return -1;
6753   }
6754   {
6755     char fstype[] = "ext2";
6756     char device[] = "/dev/sda1";
6757     int r;
6758     suppress_error = 0;
6759     r = guestfs_mkfs (g, fstype, device);
6760     if (r == -1)
6761       return -1;
6762   }
6763   {
6764     char device[] = "/dev/sda1";
6765     char mountpoint[] = "/";
6766     int r;
6767     suppress_error = 0;
6768     r = guestfs_mount (g, device, mountpoint);
6769     if (r == -1)
6770       return -1;
6771   }
6772   /* TestRun for set_e2uuid (3) */
6773   {
6774     char device[] = "/dev/sda1";
6775     char uuid[] = "time";
6776     int r;
6777     suppress_error = 0;
6778     r = guestfs_set_e2uuid (g, device, uuid);
6779     if (r == -1)
6780       return -1;
6781   }
6782   return 0;
6783 }
6784
6785 static int test_set_e2label_0_skip (void)
6786 {
6787   const char *str;
6788
6789   str = getenv ("TEST_ONLY");
6790   if (str)
6791     return strstr (str, "set_e2label") == NULL;
6792   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6793   if (str && strcmp (str, "1") == 0) return 1;
6794   str = getenv ("SKIP_TEST_SET_E2LABEL");
6795   if (str && strcmp (str, "1") == 0) return 1;
6796   return 0;
6797 }
6798
6799 static int test_set_e2label_0 (void)
6800 {
6801   if (test_set_e2label_0_skip ()) {
6802     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6803     return 0;
6804   }
6805
6806   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6807   {
6808     char device[] = "/dev/sda";
6809     int r;
6810     suppress_error = 0;
6811     r = guestfs_blockdev_setrw (g, device);
6812     if (r == -1)
6813       return -1;
6814   }
6815   {
6816     int r;
6817     suppress_error = 0;
6818     r = guestfs_umount_all (g);
6819     if (r == -1)
6820       return -1;
6821   }
6822   {
6823     int r;
6824     suppress_error = 0;
6825     r = guestfs_lvm_remove_all (g);
6826     if (r == -1)
6827       return -1;
6828   }
6829   {
6830     char device[] = "/dev/sda";
6831     char lines_0[] = ",";
6832     char *lines[] = {
6833       lines_0,
6834       NULL
6835     };
6836     int r;
6837     suppress_error = 0;
6838     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6839     if (r == -1)
6840       return -1;
6841   }
6842   {
6843     char fstype[] = "ext2";
6844     char device[] = "/dev/sda1";
6845     int r;
6846     suppress_error = 0;
6847     r = guestfs_mkfs (g, fstype, device);
6848     if (r == -1)
6849       return -1;
6850   }
6851   {
6852     char device[] = "/dev/sda1";
6853     char mountpoint[] = "/";
6854     int r;
6855     suppress_error = 0;
6856     r = guestfs_mount (g, device, mountpoint);
6857     if (r == -1)
6858       return -1;
6859   }
6860   /* TestOutput for set_e2label (0) */
6861   char expected[] = "testlabel";
6862   {
6863     char device[] = "/dev/sda1";
6864     char label[] = "testlabel";
6865     int r;
6866     suppress_error = 0;
6867     r = guestfs_set_e2label (g, device, label);
6868     if (r == -1)
6869       return -1;
6870   }
6871   {
6872     char device[] = "/dev/sda1";
6873     char *r;
6874     suppress_error = 0;
6875     r = guestfs_get_e2label (g, device);
6876     if (r == NULL)
6877       return -1;
6878     if (strcmp (r, expected) != 0) {
6879       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6880       return -1;
6881     }
6882     free (r);
6883   }
6884   return 0;
6885 }
6886
6887 static int test_pvremove_0_skip (void)
6888 {
6889   const char *str;
6890
6891   str = getenv ("TEST_ONLY");
6892   if (str)
6893     return strstr (str, "pvremove") == NULL;
6894   str = getenv ("SKIP_TEST_PVREMOVE_0");
6895   if (str && strcmp (str, "1") == 0) return 1;
6896   str = getenv ("SKIP_TEST_PVREMOVE");
6897   if (str && strcmp (str, "1") == 0) return 1;
6898   return 0;
6899 }
6900
6901 static int test_pvremove_0 (void)
6902 {
6903   if (test_pvremove_0_skip ()) {
6904     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6905     return 0;
6906   }
6907
6908   /* InitNone|InitEmpty for test_pvremove_0 */
6909   {
6910     char device[] = "/dev/sda";
6911     int r;
6912     suppress_error = 0;
6913     r = guestfs_blockdev_setrw (g, device);
6914     if (r == -1)
6915       return -1;
6916   }
6917   {
6918     int r;
6919     suppress_error = 0;
6920     r = guestfs_umount_all (g);
6921     if (r == -1)
6922       return -1;
6923   }
6924   {
6925     int r;
6926     suppress_error = 0;
6927     r = guestfs_lvm_remove_all (g);
6928     if (r == -1)
6929       return -1;
6930   }
6931   /* TestOutputListOfDevices for pvremove (0) */
6932   {
6933     char device[] = "/dev/sda";
6934     char lines_0[] = ",";
6935     char *lines[] = {
6936       lines_0,
6937       NULL
6938     };
6939     int r;
6940     suppress_error = 0;
6941     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6942     if (r == -1)
6943       return -1;
6944   }
6945   {
6946     char device[] = "/dev/sda1";
6947     int r;
6948     suppress_error = 0;
6949     r = guestfs_pvcreate (g, device);
6950     if (r == -1)
6951       return -1;
6952   }
6953   {
6954     char volgroup[] = "VG";
6955     char physvols_0[] = "/dev/sda1";
6956     char *physvols[] = {
6957       physvols_0,
6958       NULL
6959     };
6960     int r;
6961     suppress_error = 0;
6962     r = guestfs_vgcreate (g, volgroup, physvols);
6963     if (r == -1)
6964       return -1;
6965   }
6966   {
6967     char logvol[] = "LV1";
6968     char volgroup[] = "VG";
6969     int r;
6970     suppress_error = 0;
6971     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6972     if (r == -1)
6973       return -1;
6974   }
6975   {
6976     char logvol[] = "LV2";
6977     char volgroup[] = "VG";
6978     int r;
6979     suppress_error = 0;
6980     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6981     if (r == -1)
6982       return -1;
6983   }
6984   {
6985     char vgname[] = "VG";
6986     int r;
6987     suppress_error = 0;
6988     r = guestfs_vgremove (g, vgname);
6989     if (r == -1)
6990       return -1;
6991   }
6992   {
6993     char device[] = "/dev/sda1";
6994     int r;
6995     suppress_error = 0;
6996     r = guestfs_pvremove (g, device);
6997     if (r == -1)
6998       return -1;
6999   }
7000   {
7001     char **r;
7002     int i;
7003     suppress_error = 0;
7004     r = guestfs_lvs (g);
7005     if (r == NULL)
7006       return -1;
7007     if (r[0] != NULL) {
7008       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
7009       print_strings (r);
7010       return -1;
7011     }
7012     for (i = 0; r[i] != NULL; ++i)
7013       free (r[i]);
7014     free (r);
7015   }
7016   return 0;
7017 }
7018
7019 static int test_pvremove_1_skip (void)
7020 {
7021   const char *str;
7022
7023   str = getenv ("TEST_ONLY");
7024   if (str)
7025     return strstr (str, "pvremove") == NULL;
7026   str = getenv ("SKIP_TEST_PVREMOVE_1");
7027   if (str && strcmp (str, "1") == 0) return 1;
7028   str = getenv ("SKIP_TEST_PVREMOVE");
7029   if (str && strcmp (str, "1") == 0) return 1;
7030   return 0;
7031 }
7032
7033 static int test_pvremove_1 (void)
7034 {
7035   if (test_pvremove_1_skip ()) {
7036     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
7037     return 0;
7038   }
7039
7040   /* InitNone|InitEmpty for test_pvremove_1 */
7041   {
7042     char device[] = "/dev/sda";
7043     int r;
7044     suppress_error = 0;
7045     r = guestfs_blockdev_setrw (g, device);
7046     if (r == -1)
7047       return -1;
7048   }
7049   {
7050     int r;
7051     suppress_error = 0;
7052     r = guestfs_umount_all (g);
7053     if (r == -1)
7054       return -1;
7055   }
7056   {
7057     int r;
7058     suppress_error = 0;
7059     r = guestfs_lvm_remove_all (g);
7060     if (r == -1)
7061       return -1;
7062   }
7063   /* TestOutputListOfDevices for pvremove (1) */
7064   {
7065     char device[] = "/dev/sda";
7066     char lines_0[] = ",";
7067     char *lines[] = {
7068       lines_0,
7069       NULL
7070     };
7071     int r;
7072     suppress_error = 0;
7073     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7074     if (r == -1)
7075       return -1;
7076   }
7077   {
7078     char device[] = "/dev/sda1";
7079     int r;
7080     suppress_error = 0;
7081     r = guestfs_pvcreate (g, device);
7082     if (r == -1)
7083       return -1;
7084   }
7085   {
7086     char volgroup[] = "VG";
7087     char physvols_0[] = "/dev/sda1";
7088     char *physvols[] = {
7089       physvols_0,
7090       NULL
7091     };
7092     int r;
7093     suppress_error = 0;
7094     r = guestfs_vgcreate (g, volgroup, physvols);
7095     if (r == -1)
7096       return -1;
7097   }
7098   {
7099     char logvol[] = "LV1";
7100     char volgroup[] = "VG";
7101     int r;
7102     suppress_error = 0;
7103     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7104     if (r == -1)
7105       return -1;
7106   }
7107   {
7108     char logvol[] = "LV2";
7109     char volgroup[] = "VG";
7110     int r;
7111     suppress_error = 0;
7112     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7113     if (r == -1)
7114       return -1;
7115   }
7116   {
7117     char vgname[] = "VG";
7118     int r;
7119     suppress_error = 0;
7120     r = guestfs_vgremove (g, vgname);
7121     if (r == -1)
7122       return -1;
7123   }
7124   {
7125     char device[] = "/dev/sda1";
7126     int r;
7127     suppress_error = 0;
7128     r = guestfs_pvremove (g, device);
7129     if (r == -1)
7130       return -1;
7131   }
7132   {
7133     char **r;
7134     int i;
7135     suppress_error = 0;
7136     r = guestfs_vgs (g);
7137     if (r == NULL)
7138       return -1;
7139     if (r[0] != NULL) {
7140       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
7141       print_strings (r);
7142       return -1;
7143     }
7144     for (i = 0; r[i] != NULL; ++i)
7145       free (r[i]);
7146     free (r);
7147   }
7148   return 0;
7149 }
7150
7151 static int test_pvremove_2_skip (void)
7152 {
7153   const char *str;
7154
7155   str = getenv ("TEST_ONLY");
7156   if (str)
7157     return strstr (str, "pvremove") == NULL;
7158   str = getenv ("SKIP_TEST_PVREMOVE_2");
7159   if (str && strcmp (str, "1") == 0) return 1;
7160   str = getenv ("SKIP_TEST_PVREMOVE");
7161   if (str && strcmp (str, "1") == 0) return 1;
7162   return 0;
7163 }
7164
7165 static int test_pvremove_2 (void)
7166 {
7167   if (test_pvremove_2_skip ()) {
7168     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
7169     return 0;
7170   }
7171
7172   /* InitNone|InitEmpty for test_pvremove_2 */
7173   {
7174     char device[] = "/dev/sda";
7175     int r;
7176     suppress_error = 0;
7177     r = guestfs_blockdev_setrw (g, device);
7178     if (r == -1)
7179       return -1;
7180   }
7181   {
7182     int r;
7183     suppress_error = 0;
7184     r = guestfs_umount_all (g);
7185     if (r == -1)
7186       return -1;
7187   }
7188   {
7189     int r;
7190     suppress_error = 0;
7191     r = guestfs_lvm_remove_all (g);
7192     if (r == -1)
7193       return -1;
7194   }
7195   /* TestOutputListOfDevices for pvremove (2) */
7196   {
7197     char device[] = "/dev/sda";
7198     char lines_0[] = ",";
7199     char *lines[] = {
7200       lines_0,
7201       NULL
7202     };
7203     int r;
7204     suppress_error = 0;
7205     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7206     if (r == -1)
7207       return -1;
7208   }
7209   {
7210     char device[] = "/dev/sda1";
7211     int r;
7212     suppress_error = 0;
7213     r = guestfs_pvcreate (g, device);
7214     if (r == -1)
7215       return -1;
7216   }
7217   {
7218     char volgroup[] = "VG";
7219     char physvols_0[] = "/dev/sda1";
7220     char *physvols[] = {
7221       physvols_0,
7222       NULL
7223     };
7224     int r;
7225     suppress_error = 0;
7226     r = guestfs_vgcreate (g, volgroup, physvols);
7227     if (r == -1)
7228       return -1;
7229   }
7230   {
7231     char logvol[] = "LV1";
7232     char volgroup[] = "VG";
7233     int r;
7234     suppress_error = 0;
7235     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7236     if (r == -1)
7237       return -1;
7238   }
7239   {
7240     char logvol[] = "LV2";
7241     char volgroup[] = "VG";
7242     int r;
7243     suppress_error = 0;
7244     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7245     if (r == -1)
7246       return -1;
7247   }
7248   {
7249     char vgname[] = "VG";
7250     int r;
7251     suppress_error = 0;
7252     r = guestfs_vgremove (g, vgname);
7253     if (r == -1)
7254       return -1;
7255   }
7256   {
7257     char device[] = "/dev/sda1";
7258     int r;
7259     suppress_error = 0;
7260     r = guestfs_pvremove (g, device);
7261     if (r == -1)
7262       return -1;
7263   }
7264   {
7265     char **r;
7266     int i;
7267     suppress_error = 0;
7268     r = guestfs_pvs (g);
7269     if (r == NULL)
7270       return -1;
7271     if (r[0] != NULL) {
7272       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
7273       print_strings (r);
7274       return -1;
7275     }
7276     for (i = 0; r[i] != NULL; ++i)
7277       free (r[i]);
7278     free (r);
7279   }
7280   return 0;
7281 }
7282
7283 static int test_vgremove_0_skip (void)
7284 {
7285   const char *str;
7286
7287   str = getenv ("TEST_ONLY");
7288   if (str)
7289     return strstr (str, "vgremove") == NULL;
7290   str = getenv ("SKIP_TEST_VGREMOVE_0");
7291   if (str && strcmp (str, "1") == 0) return 1;
7292   str = getenv ("SKIP_TEST_VGREMOVE");
7293   if (str && strcmp (str, "1") == 0) return 1;
7294   return 0;
7295 }
7296
7297 static int test_vgremove_0 (void)
7298 {
7299   if (test_vgremove_0_skip ()) {
7300     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
7301     return 0;
7302   }
7303
7304   /* InitNone|InitEmpty for test_vgremove_0 */
7305   {
7306     char device[] = "/dev/sda";
7307     int r;
7308     suppress_error = 0;
7309     r = guestfs_blockdev_setrw (g, device);
7310     if (r == -1)
7311       return -1;
7312   }
7313   {
7314     int r;
7315     suppress_error = 0;
7316     r = guestfs_umount_all (g);
7317     if (r == -1)
7318       return -1;
7319   }
7320   {
7321     int r;
7322     suppress_error = 0;
7323     r = guestfs_lvm_remove_all (g);
7324     if (r == -1)
7325       return -1;
7326   }
7327   /* TestOutputList for vgremove (0) */
7328   {
7329     char device[] = "/dev/sda";
7330     char lines_0[] = ",";
7331     char *lines[] = {
7332       lines_0,
7333       NULL
7334     };
7335     int r;
7336     suppress_error = 0;
7337     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7338     if (r == -1)
7339       return -1;
7340   }
7341   {
7342     char device[] = "/dev/sda1";
7343     int r;
7344     suppress_error = 0;
7345     r = guestfs_pvcreate (g, device);
7346     if (r == -1)
7347       return -1;
7348   }
7349   {
7350     char volgroup[] = "VG";
7351     char physvols_0[] = "/dev/sda1";
7352     char *physvols[] = {
7353       physvols_0,
7354       NULL
7355     };
7356     int r;
7357     suppress_error = 0;
7358     r = guestfs_vgcreate (g, volgroup, physvols);
7359     if (r == -1)
7360       return -1;
7361   }
7362   {
7363     char logvol[] = "LV1";
7364     char volgroup[] = "VG";
7365     int r;
7366     suppress_error = 0;
7367     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7368     if (r == -1)
7369       return -1;
7370   }
7371   {
7372     char logvol[] = "LV2";
7373     char volgroup[] = "VG";
7374     int r;
7375     suppress_error = 0;
7376     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7377     if (r == -1)
7378       return -1;
7379   }
7380   {
7381     char vgname[] = "VG";
7382     int r;
7383     suppress_error = 0;
7384     r = guestfs_vgremove (g, vgname);
7385     if (r == -1)
7386       return -1;
7387   }
7388   {
7389     char **r;
7390     int i;
7391     suppress_error = 0;
7392     r = guestfs_lvs (g);
7393     if (r == NULL)
7394       return -1;
7395     if (r[0] != NULL) {
7396       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
7397       print_strings (r);
7398       return -1;
7399     }
7400     for (i = 0; r[i] != NULL; ++i)
7401       free (r[i]);
7402     free (r);
7403   }
7404   return 0;
7405 }
7406
7407 static int test_vgremove_1_skip (void)
7408 {
7409   const char *str;
7410
7411   str = getenv ("TEST_ONLY");
7412   if (str)
7413     return strstr (str, "vgremove") == NULL;
7414   str = getenv ("SKIP_TEST_VGREMOVE_1");
7415   if (str && strcmp (str, "1") == 0) return 1;
7416   str = getenv ("SKIP_TEST_VGREMOVE");
7417   if (str && strcmp (str, "1") == 0) return 1;
7418   return 0;
7419 }
7420
7421 static int test_vgremove_1 (void)
7422 {
7423   if (test_vgremove_1_skip ()) {
7424     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
7425     return 0;
7426   }
7427
7428   /* InitNone|InitEmpty for test_vgremove_1 */
7429   {
7430     char device[] = "/dev/sda";
7431     int r;
7432     suppress_error = 0;
7433     r = guestfs_blockdev_setrw (g, device);
7434     if (r == -1)
7435       return -1;
7436   }
7437   {
7438     int r;
7439     suppress_error = 0;
7440     r = guestfs_umount_all (g);
7441     if (r == -1)
7442       return -1;
7443   }
7444   {
7445     int r;
7446     suppress_error = 0;
7447     r = guestfs_lvm_remove_all (g);
7448     if (r == -1)
7449       return -1;
7450   }
7451   /* TestOutputList for vgremove (1) */
7452   {
7453     char device[] = "/dev/sda";
7454     char lines_0[] = ",";
7455     char *lines[] = {
7456       lines_0,
7457       NULL
7458     };
7459     int r;
7460     suppress_error = 0;
7461     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7462     if (r == -1)
7463       return -1;
7464   }
7465   {
7466     char device[] = "/dev/sda1";
7467     int r;
7468     suppress_error = 0;
7469     r = guestfs_pvcreate (g, device);
7470     if (r == -1)
7471       return -1;
7472   }
7473   {
7474     char volgroup[] = "VG";
7475     char physvols_0[] = "/dev/sda1";
7476     char *physvols[] = {
7477       physvols_0,
7478       NULL
7479     };
7480     int r;
7481     suppress_error = 0;
7482     r = guestfs_vgcreate (g, volgroup, physvols);
7483     if (r == -1)
7484       return -1;
7485   }
7486   {
7487     char logvol[] = "LV1";
7488     char volgroup[] = "VG";
7489     int r;
7490     suppress_error = 0;
7491     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7492     if (r == -1)
7493       return -1;
7494   }
7495   {
7496     char logvol[] = "LV2";
7497     char volgroup[] = "VG";
7498     int r;
7499     suppress_error = 0;
7500     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7501     if (r == -1)
7502       return -1;
7503   }
7504   {
7505     char vgname[] = "VG";
7506     int r;
7507     suppress_error = 0;
7508     r = guestfs_vgremove (g, vgname);
7509     if (r == -1)
7510       return -1;
7511   }
7512   {
7513     char **r;
7514     int i;
7515     suppress_error = 0;
7516     r = guestfs_vgs (g);
7517     if (r == NULL)
7518       return -1;
7519     if (r[0] != NULL) {
7520       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
7521       print_strings (r);
7522       return -1;
7523     }
7524     for (i = 0; r[i] != NULL; ++i)
7525       free (r[i]);
7526     free (r);
7527   }
7528   return 0;
7529 }
7530
7531 static int test_lvremove_0_skip (void)
7532 {
7533   const char *str;
7534
7535   str = getenv ("TEST_ONLY");
7536   if (str)
7537     return strstr (str, "lvremove") == NULL;
7538   str = getenv ("SKIP_TEST_LVREMOVE_0");
7539   if (str && strcmp (str, "1") == 0) return 1;
7540   str = getenv ("SKIP_TEST_LVREMOVE");
7541   if (str && strcmp (str, "1") == 0) return 1;
7542   return 0;
7543 }
7544
7545 static int test_lvremove_0 (void)
7546 {
7547   if (test_lvremove_0_skip ()) {
7548     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
7549     return 0;
7550   }
7551
7552   /* InitNone|InitEmpty for test_lvremove_0 */
7553   {
7554     char device[] = "/dev/sda";
7555     int r;
7556     suppress_error = 0;
7557     r = guestfs_blockdev_setrw (g, device);
7558     if (r == -1)
7559       return -1;
7560   }
7561   {
7562     int r;
7563     suppress_error = 0;
7564     r = guestfs_umount_all (g);
7565     if (r == -1)
7566       return -1;
7567   }
7568   {
7569     int r;
7570     suppress_error = 0;
7571     r = guestfs_lvm_remove_all (g);
7572     if (r == -1)
7573       return -1;
7574   }
7575   /* TestOutputList for lvremove (0) */
7576   {
7577     char device[] = "/dev/sda";
7578     char lines_0[] = ",";
7579     char *lines[] = {
7580       lines_0,
7581       NULL
7582     };
7583     int r;
7584     suppress_error = 0;
7585     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7586     if (r == -1)
7587       return -1;
7588   }
7589   {
7590     char device[] = "/dev/sda1";
7591     int r;
7592     suppress_error = 0;
7593     r = guestfs_pvcreate (g, device);
7594     if (r == -1)
7595       return -1;
7596   }
7597   {
7598     char volgroup[] = "VG";
7599     char physvols_0[] = "/dev/sda1";
7600     char *physvols[] = {
7601       physvols_0,
7602       NULL
7603     };
7604     int r;
7605     suppress_error = 0;
7606     r = guestfs_vgcreate (g, volgroup, physvols);
7607     if (r == -1)
7608       return -1;
7609   }
7610   {
7611     char logvol[] = "LV1";
7612     char volgroup[] = "VG";
7613     int r;
7614     suppress_error = 0;
7615     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7616     if (r == -1)
7617       return -1;
7618   }
7619   {
7620     char logvol[] = "LV2";
7621     char volgroup[] = "VG";
7622     int r;
7623     suppress_error = 0;
7624     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7625     if (r == -1)
7626       return -1;
7627   }
7628   {
7629     char device[] = "/dev/VG/LV1";
7630     int r;
7631     suppress_error = 0;
7632     r = guestfs_lvremove (g, device);
7633     if (r == -1)
7634       return -1;
7635   }
7636   {
7637     char **r;
7638     int i;
7639     suppress_error = 0;
7640     r = guestfs_lvs (g);
7641     if (r == NULL)
7642       return -1;
7643     if (!r[0]) {
7644       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
7645       print_strings (r);
7646       return -1;
7647     }
7648     {
7649       char expected[] = "/dev/VG/LV2";
7650       if (strcmp (r[0], expected) != 0) {
7651         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7652         return -1;
7653       }
7654     }
7655     if (r[1] != NULL) {
7656       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
7657       print_strings (r);
7658       return -1;
7659     }
7660     for (i = 0; r[i] != NULL; ++i)
7661       free (r[i]);
7662     free (r);
7663   }
7664   return 0;
7665 }
7666
7667 static int test_lvremove_1_skip (void)
7668 {
7669   const char *str;
7670
7671   str = getenv ("TEST_ONLY");
7672   if (str)
7673     return strstr (str, "lvremove") == NULL;
7674   str = getenv ("SKIP_TEST_LVREMOVE_1");
7675   if (str && strcmp (str, "1") == 0) return 1;
7676   str = getenv ("SKIP_TEST_LVREMOVE");
7677   if (str && strcmp (str, "1") == 0) return 1;
7678   return 0;
7679 }
7680
7681 static int test_lvremove_1 (void)
7682 {
7683   if (test_lvremove_1_skip ()) {
7684     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
7685     return 0;
7686   }
7687
7688   /* InitNone|InitEmpty for test_lvremove_1 */
7689   {
7690     char device[] = "/dev/sda";
7691     int r;
7692     suppress_error = 0;
7693     r = guestfs_blockdev_setrw (g, device);
7694     if (r == -1)
7695       return -1;
7696   }
7697   {
7698     int r;
7699     suppress_error = 0;
7700     r = guestfs_umount_all (g);
7701     if (r == -1)
7702       return -1;
7703   }
7704   {
7705     int r;
7706     suppress_error = 0;
7707     r = guestfs_lvm_remove_all (g);
7708     if (r == -1)
7709       return -1;
7710   }
7711   /* TestOutputList for lvremove (1) */
7712   {
7713     char device[] = "/dev/sda";
7714     char lines_0[] = ",";
7715     char *lines[] = {
7716       lines_0,
7717       NULL
7718     };
7719     int r;
7720     suppress_error = 0;
7721     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7722     if (r == -1)
7723       return -1;
7724   }
7725   {
7726     char device[] = "/dev/sda1";
7727     int r;
7728     suppress_error = 0;
7729     r = guestfs_pvcreate (g, device);
7730     if (r == -1)
7731       return -1;
7732   }
7733   {
7734     char volgroup[] = "VG";
7735     char physvols_0[] = "/dev/sda1";
7736     char *physvols[] = {
7737       physvols_0,
7738       NULL
7739     };
7740     int r;
7741     suppress_error = 0;
7742     r = guestfs_vgcreate (g, volgroup, physvols);
7743     if (r == -1)
7744       return -1;
7745   }
7746   {
7747     char logvol[] = "LV1";
7748     char volgroup[] = "VG";
7749     int r;
7750     suppress_error = 0;
7751     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7752     if (r == -1)
7753       return -1;
7754   }
7755   {
7756     char logvol[] = "LV2";
7757     char volgroup[] = "VG";
7758     int r;
7759     suppress_error = 0;
7760     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7761     if (r == -1)
7762       return -1;
7763   }
7764   {
7765     char device[] = "/dev/VG";
7766     int r;
7767     suppress_error = 0;
7768     r = guestfs_lvremove (g, device);
7769     if (r == -1)
7770       return -1;
7771   }
7772   {
7773     char **r;
7774     int i;
7775     suppress_error = 0;
7776     r = guestfs_lvs (g);
7777     if (r == NULL)
7778       return -1;
7779     if (r[0] != NULL) {
7780       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7781       print_strings (r);
7782       return -1;
7783     }
7784     for (i = 0; r[i] != NULL; ++i)
7785       free (r[i]);
7786     free (r);
7787   }
7788   return 0;
7789 }
7790
7791 static int test_lvremove_2_skip (void)
7792 {
7793   const char *str;
7794
7795   str = getenv ("TEST_ONLY");
7796   if (str)
7797     return strstr (str, "lvremove") == NULL;
7798   str = getenv ("SKIP_TEST_LVREMOVE_2");
7799   if (str && strcmp (str, "1") == 0) return 1;
7800   str = getenv ("SKIP_TEST_LVREMOVE");
7801   if (str && strcmp (str, "1") == 0) return 1;
7802   return 0;
7803 }
7804
7805 static int test_lvremove_2 (void)
7806 {
7807   if (test_lvremove_2_skip ()) {
7808     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
7809     return 0;
7810   }
7811
7812   /* InitNone|InitEmpty for test_lvremove_2 */
7813   {
7814     char device[] = "/dev/sda";
7815     int r;
7816     suppress_error = 0;
7817     r = guestfs_blockdev_setrw (g, device);
7818     if (r == -1)
7819       return -1;
7820   }
7821   {
7822     int r;
7823     suppress_error = 0;
7824     r = guestfs_umount_all (g);
7825     if (r == -1)
7826       return -1;
7827   }
7828   {
7829     int r;
7830     suppress_error = 0;
7831     r = guestfs_lvm_remove_all (g);
7832     if (r == -1)
7833       return -1;
7834   }
7835   /* TestOutputList for lvremove (2) */
7836   {
7837     char device[] = "/dev/sda";
7838     char lines_0[] = ",";
7839     char *lines[] = {
7840       lines_0,
7841       NULL
7842     };
7843     int r;
7844     suppress_error = 0;
7845     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7846     if (r == -1)
7847       return -1;
7848   }
7849   {
7850     char device[] = "/dev/sda1";
7851     int r;
7852     suppress_error = 0;
7853     r = guestfs_pvcreate (g, device);
7854     if (r == -1)
7855       return -1;
7856   }
7857   {
7858     char volgroup[] = "VG";
7859     char physvols_0[] = "/dev/sda1";
7860     char *physvols[] = {
7861       physvols_0,
7862       NULL
7863     };
7864     int r;
7865     suppress_error = 0;
7866     r = guestfs_vgcreate (g, volgroup, physvols);
7867     if (r == -1)
7868       return -1;
7869   }
7870   {
7871     char logvol[] = "LV1";
7872     char volgroup[] = "VG";
7873     int r;
7874     suppress_error = 0;
7875     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7876     if (r == -1)
7877       return -1;
7878   }
7879   {
7880     char logvol[] = "LV2";
7881     char volgroup[] = "VG";
7882     int r;
7883     suppress_error = 0;
7884     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7885     if (r == -1)
7886       return -1;
7887   }
7888   {
7889     char device[] = "/dev/VG";
7890     int r;
7891     suppress_error = 0;
7892     r = guestfs_lvremove (g, device);
7893     if (r == -1)
7894       return -1;
7895   }
7896   {
7897     char **r;
7898     int i;
7899     suppress_error = 0;
7900     r = guestfs_vgs (g);
7901     if (r == NULL)
7902       return -1;
7903     if (!r[0]) {
7904       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7905       print_strings (r);
7906       return -1;
7907     }
7908     {
7909       char expected[] = "VG";
7910       if (strcmp (r[0], expected) != 0) {
7911         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7912         return -1;
7913       }
7914     }
7915     if (r[1] != NULL) {
7916       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7917       print_strings (r);
7918       return -1;
7919     }
7920     for (i = 0; r[i] != NULL; ++i)
7921       free (r[i]);
7922     free (r);
7923   }
7924   return 0;
7925 }
7926
7927 static int test_mount_ro_0_skip (void)
7928 {
7929   const char *str;
7930
7931   str = getenv ("TEST_ONLY");
7932   if (str)
7933     return strstr (str, "mount_ro") == NULL;
7934   str = getenv ("SKIP_TEST_MOUNT_RO_0");
7935   if (str && strcmp (str, "1") == 0) return 1;
7936   str = getenv ("SKIP_TEST_MOUNT_RO");
7937   if (str && strcmp (str, "1") == 0) return 1;
7938   return 0;
7939 }
7940
7941 static int test_mount_ro_0 (void)
7942 {
7943   if (test_mount_ro_0_skip ()) {
7944     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7945     return 0;
7946   }
7947
7948   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7949   {
7950     char device[] = "/dev/sda";
7951     int r;
7952     suppress_error = 0;
7953     r = guestfs_blockdev_setrw (g, device);
7954     if (r == -1)
7955       return -1;
7956   }
7957   {
7958     int r;
7959     suppress_error = 0;
7960     r = guestfs_umount_all (g);
7961     if (r == -1)
7962       return -1;
7963   }
7964   {
7965     int r;
7966     suppress_error = 0;
7967     r = guestfs_lvm_remove_all (g);
7968     if (r == -1)
7969       return -1;
7970   }
7971   {
7972     char device[] = "/dev/sda";
7973     char lines_0[] = ",";
7974     char *lines[] = {
7975       lines_0,
7976       NULL
7977     };
7978     int r;
7979     suppress_error = 0;
7980     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7981     if (r == -1)
7982       return -1;
7983   }
7984   {
7985     char fstype[] = "ext2";
7986     char device[] = "/dev/sda1";
7987     int r;
7988     suppress_error = 0;
7989     r = guestfs_mkfs (g, fstype, device);
7990     if (r == -1)
7991       return -1;
7992   }
7993   {
7994     char device[] = "/dev/sda1";
7995     char mountpoint[] = "/";
7996     int r;
7997     suppress_error = 0;
7998     r = guestfs_mount (g, device, mountpoint);
7999     if (r == -1)
8000       return -1;
8001   }
8002   /* TestLastFail for mount_ro (0) */
8003   {
8004     char pathordevice[] = "/";
8005     int r;
8006     suppress_error = 0;
8007     r = guestfs_umount (g, pathordevice);
8008     if (r == -1)
8009       return -1;
8010   }
8011   {
8012     char device[] = "/dev/sda1";
8013     char mountpoint[] = "/";
8014     int r;
8015     suppress_error = 0;
8016     r = guestfs_mount_ro (g, device, mountpoint);
8017     if (r == -1)
8018       return -1;
8019   }
8020   {
8021     char path[] = "/new";
8022     int r;
8023     suppress_error = 1;
8024     r = guestfs_touch (g, path);
8025     if (r != -1)
8026       return -1;
8027   }
8028   return 0;
8029 }
8030
8031 static int test_mount_ro_1_skip (void)
8032 {
8033   const char *str;
8034
8035   str = getenv ("TEST_ONLY");
8036   if (str)
8037     return strstr (str, "mount_ro") == NULL;
8038   str = getenv ("SKIP_TEST_MOUNT_RO_1");
8039   if (str && strcmp (str, "1") == 0) return 1;
8040   str = getenv ("SKIP_TEST_MOUNT_RO");
8041   if (str && strcmp (str, "1") == 0) return 1;
8042   return 0;
8043 }
8044
8045 static int test_mount_ro_1 (void)
8046 {
8047   if (test_mount_ro_1_skip ()) {
8048     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
8049     return 0;
8050   }
8051
8052   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
8053   {
8054     char device[] = "/dev/sda";
8055     int r;
8056     suppress_error = 0;
8057     r = guestfs_blockdev_setrw (g, device);
8058     if (r == -1)
8059       return -1;
8060   }
8061   {
8062     int r;
8063     suppress_error = 0;
8064     r = guestfs_umount_all (g);
8065     if (r == -1)
8066       return -1;
8067   }
8068   {
8069     int r;
8070     suppress_error = 0;
8071     r = guestfs_lvm_remove_all (g);
8072     if (r == -1)
8073       return -1;
8074   }
8075   {
8076     char device[] = "/dev/sda";
8077     char lines_0[] = ",";
8078     char *lines[] = {
8079       lines_0,
8080       NULL
8081     };
8082     int r;
8083     suppress_error = 0;
8084     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8085     if (r == -1)
8086       return -1;
8087   }
8088   {
8089     char fstype[] = "ext2";
8090     char device[] = "/dev/sda1";
8091     int r;
8092     suppress_error = 0;
8093     r = guestfs_mkfs (g, fstype, device);
8094     if (r == -1)
8095       return -1;
8096   }
8097   {
8098     char device[] = "/dev/sda1";
8099     char mountpoint[] = "/";
8100     int r;
8101     suppress_error = 0;
8102     r = guestfs_mount (g, device, mountpoint);
8103     if (r == -1)
8104       return -1;
8105   }
8106   /* TestOutput for mount_ro (1) */
8107   char expected[] = "data";
8108   {
8109     char path[] = "/new";
8110     char content[] = "data";
8111     int r;
8112     suppress_error = 0;
8113     r = guestfs_write_file (g, path, content, 0);
8114     if (r == -1)
8115       return -1;
8116   }
8117   {
8118     char pathordevice[] = "/";
8119     int r;
8120     suppress_error = 0;
8121     r = guestfs_umount (g, pathordevice);
8122     if (r == -1)
8123       return -1;
8124   }
8125   {
8126     char device[] = "/dev/sda1";
8127     char mountpoint[] = "/";
8128     int r;
8129     suppress_error = 0;
8130     r = guestfs_mount_ro (g, device, mountpoint);
8131     if (r == -1)
8132       return -1;
8133   }
8134   {
8135     char path[] = "/new";
8136     char *r;
8137     suppress_error = 0;
8138     r = guestfs_cat (g, path);
8139     if (r == NULL)
8140       return -1;
8141     if (strcmp (r, expected) != 0) {
8142       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
8143       return -1;
8144     }
8145     free (r);
8146   }
8147   return 0;
8148 }
8149
8150 static int test_tgz_in_0_skip (void)
8151 {
8152   const char *str;
8153
8154   str = getenv ("TEST_ONLY");
8155   if (str)
8156     return strstr (str, "tgz_in") == NULL;
8157   str = getenv ("SKIP_TEST_TGZ_IN_0");
8158   if (str && strcmp (str, "1") == 0) return 1;
8159   str = getenv ("SKIP_TEST_TGZ_IN");
8160   if (str && strcmp (str, "1") == 0) return 1;
8161   return 0;
8162 }
8163
8164 static int test_tgz_in_0 (void)
8165 {
8166   if (test_tgz_in_0_skip ()) {
8167     printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
8168     return 0;
8169   }
8170
8171   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
8172   {
8173     char device[] = "/dev/sda";
8174     int r;
8175     suppress_error = 0;
8176     r = guestfs_blockdev_setrw (g, device);
8177     if (r == -1)
8178       return -1;
8179   }
8180   {
8181     int r;
8182     suppress_error = 0;
8183     r = guestfs_umount_all (g);
8184     if (r == -1)
8185       return -1;
8186   }
8187   {
8188     int r;
8189     suppress_error = 0;
8190     r = guestfs_lvm_remove_all (g);
8191     if (r == -1)
8192       return -1;
8193   }
8194   {
8195     char device[] = "/dev/sda";
8196     char lines_0[] = ",";
8197     char *lines[] = {
8198       lines_0,
8199       NULL
8200     };
8201     int r;
8202     suppress_error = 0;
8203     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8204     if (r == -1)
8205       return -1;
8206   }
8207   {
8208     char fstype[] = "ext2";
8209     char device[] = "/dev/sda1";
8210     int r;
8211     suppress_error = 0;
8212     r = guestfs_mkfs (g, fstype, device);
8213     if (r == -1)
8214       return -1;
8215   }
8216   {
8217     char device[] = "/dev/sda1";
8218     char mountpoint[] = "/";
8219     int r;
8220     suppress_error = 0;
8221     r = guestfs_mount (g, device, mountpoint);
8222     if (r == -1)
8223       return -1;
8224   }
8225   /* TestOutput for tgz_in (0) */
8226   char expected[] = "hello\n";
8227   {
8228     char directory[] = "/";
8229     int r;
8230     suppress_error = 0;
8231     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
8232     if (r == -1)
8233       return -1;
8234   }
8235   {
8236     char path[] = "/hello";
8237     char *r;
8238     suppress_error = 0;
8239     r = guestfs_cat (g, path);
8240     if (r == NULL)
8241       return -1;
8242     if (strcmp (r, expected) != 0) {
8243       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8244       return -1;
8245     }
8246     free (r);
8247   }
8248   return 0;
8249 }
8250
8251 static int test_tar_in_0_skip (void)
8252 {
8253   const char *str;
8254
8255   str = getenv ("TEST_ONLY");
8256   if (str)
8257     return strstr (str, "tar_in") == NULL;
8258   str = getenv ("SKIP_TEST_TAR_IN_0");
8259   if (str && strcmp (str, "1") == 0) return 1;
8260   str = getenv ("SKIP_TEST_TAR_IN");
8261   if (str && strcmp (str, "1") == 0) return 1;
8262   return 0;
8263 }
8264
8265 static int test_tar_in_0 (void)
8266 {
8267   if (test_tar_in_0_skip ()) {
8268     printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
8269     return 0;
8270   }
8271
8272   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
8273   {
8274     char device[] = "/dev/sda";
8275     int r;
8276     suppress_error = 0;
8277     r = guestfs_blockdev_setrw (g, device);
8278     if (r == -1)
8279       return -1;
8280   }
8281   {
8282     int r;
8283     suppress_error = 0;
8284     r = guestfs_umount_all (g);
8285     if (r == -1)
8286       return -1;
8287   }
8288   {
8289     int r;
8290     suppress_error = 0;
8291     r = guestfs_lvm_remove_all (g);
8292     if (r == -1)
8293       return -1;
8294   }
8295   {
8296     char device[] = "/dev/sda";
8297     char lines_0[] = ",";
8298     char *lines[] = {
8299       lines_0,
8300       NULL
8301     };
8302     int r;
8303     suppress_error = 0;
8304     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8305     if (r == -1)
8306       return -1;
8307   }
8308   {
8309     char fstype[] = "ext2";
8310     char device[] = "/dev/sda1";
8311     int r;
8312     suppress_error = 0;
8313     r = guestfs_mkfs (g, fstype, device);
8314     if (r == -1)
8315       return -1;
8316   }
8317   {
8318     char device[] = "/dev/sda1";
8319     char mountpoint[] = "/";
8320     int r;
8321     suppress_error = 0;
8322     r = guestfs_mount (g, device, mountpoint);
8323     if (r == -1)
8324       return -1;
8325   }
8326   /* TestOutput for tar_in (0) */
8327   char expected[] = "hello\n";
8328   {
8329     char directory[] = "/";
8330     int r;
8331     suppress_error = 0;
8332     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
8333     if (r == -1)
8334       return -1;
8335   }
8336   {
8337     char path[] = "/hello";
8338     char *r;
8339     suppress_error = 0;
8340     r = guestfs_cat (g, path);
8341     if (r == NULL)
8342       return -1;
8343     if (strcmp (r, expected) != 0) {
8344       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8345       return -1;
8346     }
8347     free (r);
8348   }
8349   return 0;
8350 }
8351
8352 static int test_checksum_0_skip (void)
8353 {
8354   const char *str;
8355
8356   str = getenv ("TEST_ONLY");
8357   if (str)
8358     return strstr (str, "checksum") == NULL;
8359   str = getenv ("SKIP_TEST_CHECKSUM_0");
8360   if (str && strcmp (str, "1") == 0) return 1;
8361   str = getenv ("SKIP_TEST_CHECKSUM");
8362   if (str && strcmp (str, "1") == 0) return 1;
8363   return 0;
8364 }
8365
8366 static int test_checksum_0 (void)
8367 {
8368   if (test_checksum_0_skip ()) {
8369     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
8370     return 0;
8371   }
8372
8373   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
8374   {
8375     char device[] = "/dev/sda";
8376     int r;
8377     suppress_error = 0;
8378     r = guestfs_blockdev_setrw (g, device);
8379     if (r == -1)
8380       return -1;
8381   }
8382   {
8383     int r;
8384     suppress_error = 0;
8385     r = guestfs_umount_all (g);
8386     if (r == -1)
8387       return -1;
8388   }
8389   {
8390     int r;
8391     suppress_error = 0;
8392     r = guestfs_lvm_remove_all (g);
8393     if (r == -1)
8394       return -1;
8395   }
8396   {
8397     char device[] = "/dev/sda";
8398     char lines_0[] = ",";
8399     char *lines[] = {
8400       lines_0,
8401       NULL
8402     };
8403     int r;
8404     suppress_error = 0;
8405     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8406     if (r == -1)
8407       return -1;
8408   }
8409   {
8410     char fstype[] = "ext2";
8411     char device[] = "/dev/sda1";
8412     int r;
8413     suppress_error = 0;
8414     r = guestfs_mkfs (g, fstype, device);
8415     if (r == -1)
8416       return -1;
8417   }
8418   {
8419     char device[] = "/dev/sda1";
8420     char mountpoint[] = "/";
8421     int r;
8422     suppress_error = 0;
8423     r = guestfs_mount (g, device, mountpoint);
8424     if (r == -1)
8425       return -1;
8426   }
8427   /* TestOutput for checksum (0) */
8428   char expected[] = "935282863";
8429   {
8430     char path[] = "/new";
8431     char content[] = "test\n";
8432     int r;
8433     suppress_error = 0;
8434     r = guestfs_write_file (g, path, content, 0);
8435     if (r == -1)
8436       return -1;
8437   }
8438   {
8439     char csumtype[] = "crc";
8440     char path[] = "/new";
8441     char *r;
8442     suppress_error = 0;
8443     r = guestfs_checksum (g, csumtype, path);
8444     if (r == NULL)
8445       return -1;
8446     if (strcmp (r, expected) != 0) {
8447       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
8448       return -1;
8449     }
8450     free (r);
8451   }
8452   return 0;
8453 }
8454
8455 static int test_checksum_1_skip (void)
8456 {
8457   const char *str;
8458
8459   str = getenv ("TEST_ONLY");
8460   if (str)
8461     return strstr (str, "checksum") == NULL;
8462   str = getenv ("SKIP_TEST_CHECKSUM_1");
8463   if (str && strcmp (str, "1") == 0) return 1;
8464   str = getenv ("SKIP_TEST_CHECKSUM");
8465   if (str && strcmp (str, "1") == 0) return 1;
8466   return 0;
8467 }
8468
8469 static int test_checksum_1 (void)
8470 {
8471   if (test_checksum_1_skip ()) {
8472     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
8473     return 0;
8474   }
8475
8476   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
8477   {
8478     char device[] = "/dev/sda";
8479     int r;
8480     suppress_error = 0;
8481     r = guestfs_blockdev_setrw (g, device);
8482     if (r == -1)
8483       return -1;
8484   }
8485   {
8486     int r;
8487     suppress_error = 0;
8488     r = guestfs_umount_all (g);
8489     if (r == -1)
8490       return -1;
8491   }
8492   {
8493     int r;
8494     suppress_error = 0;
8495     r = guestfs_lvm_remove_all (g);
8496     if (r == -1)
8497       return -1;
8498   }
8499   {
8500     char device[] = "/dev/sda";
8501     char lines_0[] = ",";
8502     char *lines[] = {
8503       lines_0,
8504       NULL
8505     };
8506     int r;
8507     suppress_error = 0;
8508     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8509     if (r == -1)
8510       return -1;
8511   }
8512   {
8513     char fstype[] = "ext2";
8514     char device[] = "/dev/sda1";
8515     int r;
8516     suppress_error = 0;
8517     r = guestfs_mkfs (g, fstype, device);
8518     if (r == -1)
8519       return -1;
8520   }
8521   {
8522     char device[] = "/dev/sda1";
8523     char mountpoint[] = "/";
8524     int r;
8525     suppress_error = 0;
8526     r = guestfs_mount (g, device, mountpoint);
8527     if (r == -1)
8528       return -1;
8529   }
8530   /* TestLastFail for checksum (1) */
8531   {
8532     char csumtype[] = "crc";
8533     char path[] = "/new";
8534     char *r;
8535     suppress_error = 1;
8536     r = guestfs_checksum (g, csumtype, path);
8537     if (r != NULL)
8538       return -1;
8539     free (r);
8540   }
8541   return 0;
8542 }
8543
8544 static int test_checksum_2_skip (void)
8545 {
8546   const char *str;
8547
8548   str = getenv ("TEST_ONLY");
8549   if (str)
8550     return strstr (str, "checksum") == NULL;
8551   str = getenv ("SKIP_TEST_CHECKSUM_2");
8552   if (str && strcmp (str, "1") == 0) return 1;
8553   str = getenv ("SKIP_TEST_CHECKSUM");
8554   if (str && strcmp (str, "1") == 0) return 1;
8555   return 0;
8556 }
8557
8558 static int test_checksum_2 (void)
8559 {
8560   if (test_checksum_2_skip ()) {
8561     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
8562     return 0;
8563   }
8564
8565   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
8566   {
8567     char device[] = "/dev/sda";
8568     int r;
8569     suppress_error = 0;
8570     r = guestfs_blockdev_setrw (g, device);
8571     if (r == -1)
8572       return -1;
8573   }
8574   {
8575     int r;
8576     suppress_error = 0;
8577     r = guestfs_umount_all (g);
8578     if (r == -1)
8579       return -1;
8580   }
8581   {
8582     int r;
8583     suppress_error = 0;
8584     r = guestfs_lvm_remove_all (g);
8585     if (r == -1)
8586       return -1;
8587   }
8588   {
8589     char device[] = "/dev/sda";
8590     char lines_0[] = ",";
8591     char *lines[] = {
8592       lines_0,
8593       NULL
8594     };
8595     int r;
8596     suppress_error = 0;
8597     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8598     if (r == -1)
8599       return -1;
8600   }
8601   {
8602     char fstype[] = "ext2";
8603     char device[] = "/dev/sda1";
8604     int r;
8605     suppress_error = 0;
8606     r = guestfs_mkfs (g, fstype, device);
8607     if (r == -1)
8608       return -1;
8609   }
8610   {
8611     char device[] = "/dev/sda1";
8612     char mountpoint[] = "/";
8613     int r;
8614     suppress_error = 0;
8615     r = guestfs_mount (g, device, mountpoint);
8616     if (r == -1)
8617       return -1;
8618   }
8619   /* TestOutput for checksum (2) */
8620   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
8621   {
8622     char path[] = "/new";
8623     char content[] = "test\n";
8624     int r;
8625     suppress_error = 0;
8626     r = guestfs_write_file (g, path, content, 0);
8627     if (r == -1)
8628       return -1;
8629   }
8630   {
8631     char csumtype[] = "md5";
8632     char path[] = "/new";
8633     char *r;
8634     suppress_error = 0;
8635     r = guestfs_checksum (g, csumtype, path);
8636     if (r == NULL)
8637       return -1;
8638     if (strcmp (r, expected) != 0) {
8639       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
8640       return -1;
8641     }
8642     free (r);
8643   }
8644   return 0;
8645 }
8646
8647 static int test_checksum_3_skip (void)
8648 {
8649   const char *str;
8650
8651   str = getenv ("TEST_ONLY");
8652   if (str)
8653     return strstr (str, "checksum") == NULL;
8654   str = getenv ("SKIP_TEST_CHECKSUM_3");
8655   if (str && strcmp (str, "1") == 0) return 1;
8656   str = getenv ("SKIP_TEST_CHECKSUM");
8657   if (str && strcmp (str, "1") == 0) return 1;
8658   return 0;
8659 }
8660
8661 static int test_checksum_3 (void)
8662 {
8663   if (test_checksum_3_skip ()) {
8664     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
8665     return 0;
8666   }
8667
8668   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
8669   {
8670     char device[] = "/dev/sda";
8671     int r;
8672     suppress_error = 0;
8673     r = guestfs_blockdev_setrw (g, device);
8674     if (r == -1)
8675       return -1;
8676   }
8677   {
8678     int r;
8679     suppress_error = 0;
8680     r = guestfs_umount_all (g);
8681     if (r == -1)
8682       return -1;
8683   }
8684   {
8685     int r;
8686     suppress_error = 0;
8687     r = guestfs_lvm_remove_all (g);
8688     if (r == -1)
8689       return -1;
8690   }
8691   {
8692     char device[] = "/dev/sda";
8693     char lines_0[] = ",";
8694     char *lines[] = {
8695       lines_0,
8696       NULL
8697     };
8698     int r;
8699     suppress_error = 0;
8700     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8701     if (r == -1)
8702       return -1;
8703   }
8704   {
8705     char fstype[] = "ext2";
8706     char device[] = "/dev/sda1";
8707     int r;
8708     suppress_error = 0;
8709     r = guestfs_mkfs (g, fstype, device);
8710     if (r == -1)
8711       return -1;
8712   }
8713   {
8714     char device[] = "/dev/sda1";
8715     char mountpoint[] = "/";
8716     int r;
8717     suppress_error = 0;
8718     r = guestfs_mount (g, device, mountpoint);
8719     if (r == -1)
8720       return -1;
8721   }
8722   /* TestOutput for checksum (3) */
8723   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8724   {
8725     char path[] = "/new";
8726     char content[] = "test\n";
8727     int r;
8728     suppress_error = 0;
8729     r = guestfs_write_file (g, path, content, 0);
8730     if (r == -1)
8731       return -1;
8732   }
8733   {
8734     char csumtype[] = "sha1";
8735     char path[] = "/new";
8736     char *r;
8737     suppress_error = 0;
8738     r = guestfs_checksum (g, csumtype, path);
8739     if (r == NULL)
8740       return -1;
8741     if (strcmp (r, expected) != 0) {
8742       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8743       return -1;
8744     }
8745     free (r);
8746   }
8747   return 0;
8748 }
8749
8750 static int test_checksum_4_skip (void)
8751 {
8752   const char *str;
8753
8754   str = getenv ("TEST_ONLY");
8755   if (str)
8756     return strstr (str, "checksum") == NULL;
8757   str = getenv ("SKIP_TEST_CHECKSUM_4");
8758   if (str && strcmp (str, "1") == 0) return 1;
8759   str = getenv ("SKIP_TEST_CHECKSUM");
8760   if (str && strcmp (str, "1") == 0) return 1;
8761   return 0;
8762 }
8763
8764 static int test_checksum_4 (void)
8765 {
8766   if (test_checksum_4_skip ()) {
8767     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
8768     return 0;
8769   }
8770
8771   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8772   {
8773     char device[] = "/dev/sda";
8774     int r;
8775     suppress_error = 0;
8776     r = guestfs_blockdev_setrw (g, device);
8777     if (r == -1)
8778       return -1;
8779   }
8780   {
8781     int r;
8782     suppress_error = 0;
8783     r = guestfs_umount_all (g);
8784     if (r == -1)
8785       return -1;
8786   }
8787   {
8788     int r;
8789     suppress_error = 0;
8790     r = guestfs_lvm_remove_all (g);
8791     if (r == -1)
8792       return -1;
8793   }
8794   {
8795     char device[] = "/dev/sda";
8796     char lines_0[] = ",";
8797     char *lines[] = {
8798       lines_0,
8799       NULL
8800     };
8801     int r;
8802     suppress_error = 0;
8803     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8804     if (r == -1)
8805       return -1;
8806   }
8807   {
8808     char fstype[] = "ext2";
8809     char device[] = "/dev/sda1";
8810     int r;
8811     suppress_error = 0;
8812     r = guestfs_mkfs (g, fstype, device);
8813     if (r == -1)
8814       return -1;
8815   }
8816   {
8817     char device[] = "/dev/sda1";
8818     char mountpoint[] = "/";
8819     int r;
8820     suppress_error = 0;
8821     r = guestfs_mount (g, device, mountpoint);
8822     if (r == -1)
8823       return -1;
8824   }
8825   /* TestOutput for checksum (4) */
8826   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8827   {
8828     char path[] = "/new";
8829     char content[] = "test\n";
8830     int r;
8831     suppress_error = 0;
8832     r = guestfs_write_file (g, path, content, 0);
8833     if (r == -1)
8834       return -1;
8835   }
8836   {
8837     char csumtype[] = "sha224";
8838     char path[] = "/new";
8839     char *r;
8840     suppress_error = 0;
8841     r = guestfs_checksum (g, csumtype, path);
8842     if (r == NULL)
8843       return -1;
8844     if (strcmp (r, expected) != 0) {
8845       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8846       return -1;
8847     }
8848     free (r);
8849   }
8850   return 0;
8851 }
8852
8853 static int test_checksum_5_skip (void)
8854 {
8855   const char *str;
8856
8857   str = getenv ("TEST_ONLY");
8858   if (str)
8859     return strstr (str, "checksum") == NULL;
8860   str = getenv ("SKIP_TEST_CHECKSUM_5");
8861   if (str && strcmp (str, "1") == 0) return 1;
8862   str = getenv ("SKIP_TEST_CHECKSUM");
8863   if (str && strcmp (str, "1") == 0) return 1;
8864   return 0;
8865 }
8866
8867 static int test_checksum_5 (void)
8868 {
8869   if (test_checksum_5_skip ()) {
8870     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8871     return 0;
8872   }
8873
8874   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8875   {
8876     char device[] = "/dev/sda";
8877     int r;
8878     suppress_error = 0;
8879     r = guestfs_blockdev_setrw (g, device);
8880     if (r == -1)
8881       return -1;
8882   }
8883   {
8884     int r;
8885     suppress_error = 0;
8886     r = guestfs_umount_all (g);
8887     if (r == -1)
8888       return -1;
8889   }
8890   {
8891     int r;
8892     suppress_error = 0;
8893     r = guestfs_lvm_remove_all (g);
8894     if (r == -1)
8895       return -1;
8896   }
8897   {
8898     char device[] = "/dev/sda";
8899     char lines_0[] = ",";
8900     char *lines[] = {
8901       lines_0,
8902       NULL
8903     };
8904     int r;
8905     suppress_error = 0;
8906     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8907     if (r == -1)
8908       return -1;
8909   }
8910   {
8911     char fstype[] = "ext2";
8912     char device[] = "/dev/sda1";
8913     int r;
8914     suppress_error = 0;
8915     r = guestfs_mkfs (g, fstype, device);
8916     if (r == -1)
8917       return -1;
8918   }
8919   {
8920     char device[] = "/dev/sda1";
8921     char mountpoint[] = "/";
8922     int r;
8923     suppress_error = 0;
8924     r = guestfs_mount (g, device, mountpoint);
8925     if (r == -1)
8926       return -1;
8927   }
8928   /* TestOutput for checksum (5) */
8929   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8930   {
8931     char path[] = "/new";
8932     char content[] = "test\n";
8933     int r;
8934     suppress_error = 0;
8935     r = guestfs_write_file (g, path, content, 0);
8936     if (r == -1)
8937       return -1;
8938   }
8939   {
8940     char csumtype[] = "sha256";
8941     char path[] = "/new";
8942     char *r;
8943     suppress_error = 0;
8944     r = guestfs_checksum (g, csumtype, path);
8945     if (r == NULL)
8946       return -1;
8947     if (strcmp (r, expected) != 0) {
8948       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8949       return -1;
8950     }
8951     free (r);
8952   }
8953   return 0;
8954 }
8955
8956 static int test_checksum_6_skip (void)
8957 {
8958   const char *str;
8959
8960   str = getenv ("TEST_ONLY");
8961   if (str)
8962     return strstr (str, "checksum") == NULL;
8963   str = getenv ("SKIP_TEST_CHECKSUM_6");
8964   if (str && strcmp (str, "1") == 0) return 1;
8965   str = getenv ("SKIP_TEST_CHECKSUM");
8966   if (str && strcmp (str, "1") == 0) return 1;
8967   return 0;
8968 }
8969
8970 static int test_checksum_6 (void)
8971 {
8972   if (test_checksum_6_skip ()) {
8973     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8974     return 0;
8975   }
8976
8977   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8978   {
8979     char device[] = "/dev/sda";
8980     int r;
8981     suppress_error = 0;
8982     r = guestfs_blockdev_setrw (g, device);
8983     if (r == -1)
8984       return -1;
8985   }
8986   {
8987     int r;
8988     suppress_error = 0;
8989     r = guestfs_umount_all (g);
8990     if (r == -1)
8991       return -1;
8992   }
8993   {
8994     int r;
8995     suppress_error = 0;
8996     r = guestfs_lvm_remove_all (g);
8997     if (r == -1)
8998       return -1;
8999   }
9000   {
9001     char device[] = "/dev/sda";
9002     char lines_0[] = ",";
9003     char *lines[] = {
9004       lines_0,
9005       NULL
9006     };
9007     int r;
9008     suppress_error = 0;
9009     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9010     if (r == -1)
9011       return -1;
9012   }
9013   {
9014     char fstype[] = "ext2";
9015     char device[] = "/dev/sda1";
9016     int r;
9017     suppress_error = 0;
9018     r = guestfs_mkfs (g, fstype, device);
9019     if (r == -1)
9020       return -1;
9021   }
9022   {
9023     char device[] = "/dev/sda1";
9024     char mountpoint[] = "/";
9025     int r;
9026     suppress_error = 0;
9027     r = guestfs_mount (g, device, mountpoint);
9028     if (r == -1)
9029       return -1;
9030   }
9031   /* TestOutput for checksum (6) */
9032   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
9033   {
9034     char path[] = "/new";
9035     char content[] = "test\n";
9036     int r;
9037     suppress_error = 0;
9038     r = guestfs_write_file (g, path, content, 0);
9039     if (r == -1)
9040       return -1;
9041   }
9042   {
9043     char csumtype[] = "sha384";
9044     char path[] = "/new";
9045     char *r;
9046     suppress_error = 0;
9047     r = guestfs_checksum (g, csumtype, path);
9048     if (r == NULL)
9049       return -1;
9050     if (strcmp (r, expected) != 0) {
9051       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
9052       return -1;
9053     }
9054     free (r);
9055   }
9056   return 0;
9057 }
9058
9059 static int test_checksum_7_skip (void)
9060 {
9061   const char *str;
9062
9063   str = getenv ("TEST_ONLY");
9064   if (str)
9065     return strstr (str, "checksum") == NULL;
9066   str = getenv ("SKIP_TEST_CHECKSUM_7");
9067   if (str && strcmp (str, "1") == 0) return 1;
9068   str = getenv ("SKIP_TEST_CHECKSUM");
9069   if (str && strcmp (str, "1") == 0) return 1;
9070   return 0;
9071 }
9072
9073 static int test_checksum_7 (void)
9074 {
9075   if (test_checksum_7_skip ()) {
9076     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
9077     return 0;
9078   }
9079
9080   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
9081   {
9082     char device[] = "/dev/sda";
9083     int r;
9084     suppress_error = 0;
9085     r = guestfs_blockdev_setrw (g, device);
9086     if (r == -1)
9087       return -1;
9088   }
9089   {
9090     int r;
9091     suppress_error = 0;
9092     r = guestfs_umount_all (g);
9093     if (r == -1)
9094       return -1;
9095   }
9096   {
9097     int r;
9098     suppress_error = 0;
9099     r = guestfs_lvm_remove_all (g);
9100     if (r == -1)
9101       return -1;
9102   }
9103   {
9104     char device[] = "/dev/sda";
9105     char lines_0[] = ",";
9106     char *lines[] = {
9107       lines_0,
9108       NULL
9109     };
9110     int r;
9111     suppress_error = 0;
9112     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9113     if (r == -1)
9114       return -1;
9115   }
9116   {
9117     char fstype[] = "ext2";
9118     char device[] = "/dev/sda1";
9119     int r;
9120     suppress_error = 0;
9121     r = guestfs_mkfs (g, fstype, device);
9122     if (r == -1)
9123       return -1;
9124   }
9125   {
9126     char device[] = "/dev/sda1";
9127     char mountpoint[] = "/";
9128     int r;
9129     suppress_error = 0;
9130     r = guestfs_mount (g, device, mountpoint);
9131     if (r == -1)
9132       return -1;
9133   }
9134   /* TestOutput for checksum (7) */
9135   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
9136   {
9137     char path[] = "/new";
9138     char content[] = "test\n";
9139     int r;
9140     suppress_error = 0;
9141     r = guestfs_write_file (g, path, content, 0);
9142     if (r == -1)
9143       return -1;
9144   }
9145   {
9146     char csumtype[] = "sha512";
9147     char path[] = "/new";
9148     char *r;
9149     suppress_error = 0;
9150     r = guestfs_checksum (g, csumtype, path);
9151     if (r == NULL)
9152       return -1;
9153     if (strcmp (r, expected) != 0) {
9154       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
9155       return -1;
9156     }
9157     free (r);
9158   }
9159   return 0;
9160 }
9161
9162 static int test_checksum_8_skip (void)
9163 {
9164   const char *str;
9165
9166   str = getenv ("TEST_ONLY");
9167   if (str)
9168     return strstr (str, "checksum") == NULL;
9169   str = getenv ("SKIP_TEST_CHECKSUM_8");
9170   if (str && strcmp (str, "1") == 0) return 1;
9171   str = getenv ("SKIP_TEST_CHECKSUM");
9172   if (str && strcmp (str, "1") == 0) return 1;
9173   return 0;
9174 }
9175
9176 static int test_checksum_8 (void)
9177 {
9178   if (test_checksum_8_skip ()) {
9179     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
9180     return 0;
9181   }
9182
9183   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
9184   {
9185     char device[] = "/dev/sda";
9186     int r;
9187     suppress_error = 0;
9188     r = guestfs_blockdev_setrw (g, device);
9189     if (r == -1)
9190       return -1;
9191   }
9192   {
9193     int r;
9194     suppress_error = 0;
9195     r = guestfs_umount_all (g);
9196     if (r == -1)
9197       return -1;
9198   }
9199   {
9200     int r;
9201     suppress_error = 0;
9202     r = guestfs_lvm_remove_all (g);
9203     if (r == -1)
9204       return -1;
9205   }
9206   {
9207     char device[] = "/dev/sda";
9208     char lines_0[] = ",";
9209     char *lines[] = {
9210       lines_0,
9211       NULL
9212     };
9213     int r;
9214     suppress_error = 0;
9215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9216     if (r == -1)
9217       return -1;
9218   }
9219   {
9220     char fstype[] = "ext2";
9221     char device[] = "/dev/sda1";
9222     int r;
9223     suppress_error = 0;
9224     r = guestfs_mkfs (g, fstype, device);
9225     if (r == -1)
9226       return -1;
9227   }
9228   {
9229     char device[] = "/dev/sda1";
9230     char mountpoint[] = "/";
9231     int r;
9232     suppress_error = 0;
9233     r = guestfs_mount (g, device, mountpoint);
9234     if (r == -1)
9235       return -1;
9236   }
9237   /* TestOutput for checksum (8) */
9238   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
9239   {
9240     char options[] = "ro";
9241     char vfstype[] = "squashfs";
9242     char device[] = "/dev/sdd";
9243     char mountpoint[] = "/";
9244     int r;
9245     suppress_error = 0;
9246     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
9247     if (r == -1)
9248       return -1;
9249   }
9250   {
9251     char csumtype[] = "md5";
9252     char path[] = "/known-3";
9253     char *r;
9254     suppress_error = 0;
9255     r = guestfs_checksum (g, csumtype, path);
9256     if (r == NULL)
9257       return -1;
9258     if (strcmp (r, expected) != 0) {
9259       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
9260       return -1;
9261     }
9262     free (r);
9263   }
9264   return 0;
9265 }
9266
9267 static int test_download_0_skip (void)
9268 {
9269   const char *str;
9270
9271   str = getenv ("TEST_ONLY");
9272   if (str)
9273     return strstr (str, "download") == NULL;
9274   str = getenv ("SKIP_TEST_DOWNLOAD_0");
9275   if (str && strcmp (str, "1") == 0) return 1;
9276   str = getenv ("SKIP_TEST_DOWNLOAD");
9277   if (str && strcmp (str, "1") == 0) return 1;
9278   return 0;
9279 }
9280
9281 static int test_download_0 (void)
9282 {
9283   if (test_download_0_skip ()) {
9284     printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
9285     return 0;
9286   }
9287
9288   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
9289   {
9290     char device[] = "/dev/sda";
9291     int r;
9292     suppress_error = 0;
9293     r = guestfs_blockdev_setrw (g, device);
9294     if (r == -1)
9295       return -1;
9296   }
9297   {
9298     int r;
9299     suppress_error = 0;
9300     r = guestfs_umount_all (g);
9301     if (r == -1)
9302       return -1;
9303   }
9304   {
9305     int r;
9306     suppress_error = 0;
9307     r = guestfs_lvm_remove_all (g);
9308     if (r == -1)
9309       return -1;
9310   }
9311   {
9312     char device[] = "/dev/sda";
9313     char lines_0[] = ",";
9314     char *lines[] = {
9315       lines_0,
9316       NULL
9317     };
9318     int r;
9319     suppress_error = 0;
9320     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9321     if (r == -1)
9322       return -1;
9323   }
9324   {
9325     char fstype[] = "ext2";
9326     char device[] = "/dev/sda1";
9327     int r;
9328     suppress_error = 0;
9329     r = guestfs_mkfs (g, fstype, device);
9330     if (r == -1)
9331       return -1;
9332   }
9333   {
9334     char device[] = "/dev/sda1";
9335     char mountpoint[] = "/";
9336     int r;
9337     suppress_error = 0;
9338     r = guestfs_mount (g, device, mountpoint);
9339     if (r == -1)
9340       return -1;
9341   }
9342   /* TestOutput for download (0) */
9343   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9344   {
9345     char remotefilename[] = "/COPYING.LIB";
9346     int r;
9347     suppress_error = 0;
9348     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9349     if (r == -1)
9350       return -1;
9351   }
9352   {
9353     char remotefilename[] = "/COPYING.LIB";
9354     int r;
9355     suppress_error = 0;
9356     r = guestfs_download (g, remotefilename, "testdownload.tmp");
9357     if (r == -1)
9358       return -1;
9359   }
9360   {
9361     char remotefilename[] = "/upload";
9362     int r;
9363     suppress_error = 0;
9364     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
9365     if (r == -1)
9366       return -1;
9367   }
9368   {
9369     char csumtype[] = "md5";
9370     char path[] = "/upload";
9371     char *r;
9372     suppress_error = 0;
9373     r = guestfs_checksum (g, csumtype, path);
9374     if (r == NULL)
9375       return -1;
9376     if (strcmp (r, expected) != 0) {
9377       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
9378       return -1;
9379     }
9380     free (r);
9381   }
9382   return 0;
9383 }
9384
9385 static int test_upload_0_skip (void)
9386 {
9387   const char *str;
9388
9389   str = getenv ("TEST_ONLY");
9390   if (str)
9391     return strstr (str, "upload") == NULL;
9392   str = getenv ("SKIP_TEST_UPLOAD_0");
9393   if (str && strcmp (str, "1") == 0) return 1;
9394   str = getenv ("SKIP_TEST_UPLOAD");
9395   if (str && strcmp (str, "1") == 0) return 1;
9396   return 0;
9397 }
9398
9399 static int test_upload_0 (void)
9400 {
9401   if (test_upload_0_skip ()) {
9402     printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
9403     return 0;
9404   }
9405
9406   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
9407   {
9408     char device[] = "/dev/sda";
9409     int r;
9410     suppress_error = 0;
9411     r = guestfs_blockdev_setrw (g, device);
9412     if (r == -1)
9413       return -1;
9414   }
9415   {
9416     int r;
9417     suppress_error = 0;
9418     r = guestfs_umount_all (g);
9419     if (r == -1)
9420       return -1;
9421   }
9422   {
9423     int r;
9424     suppress_error = 0;
9425     r = guestfs_lvm_remove_all (g);
9426     if (r == -1)
9427       return -1;
9428   }
9429   {
9430     char device[] = "/dev/sda";
9431     char lines_0[] = ",";
9432     char *lines[] = {
9433       lines_0,
9434       NULL
9435     };
9436     int r;
9437     suppress_error = 0;
9438     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9439     if (r == -1)
9440       return -1;
9441   }
9442   {
9443     char fstype[] = "ext2";
9444     char device[] = "/dev/sda1";
9445     int r;
9446     suppress_error = 0;
9447     r = guestfs_mkfs (g, fstype, device);
9448     if (r == -1)
9449       return -1;
9450   }
9451   {
9452     char device[] = "/dev/sda1";
9453     char mountpoint[] = "/";
9454     int r;
9455     suppress_error = 0;
9456     r = guestfs_mount (g, device, mountpoint);
9457     if (r == -1)
9458       return -1;
9459   }
9460   /* TestOutput for upload (0) */
9461   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9462   {
9463     char remotefilename[] = "/COPYING.LIB";
9464     int r;
9465     suppress_error = 0;
9466     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9467     if (r == -1)
9468       return -1;
9469   }
9470   {
9471     char csumtype[] = "md5";
9472     char path[] = "/COPYING.LIB";
9473     char *r;
9474     suppress_error = 0;
9475     r = guestfs_checksum (g, csumtype, path);
9476     if (r == NULL)
9477       return -1;
9478     if (strcmp (r, expected) != 0) {
9479       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
9480       return -1;
9481     }
9482     free (r);
9483   }
9484   return 0;
9485 }
9486
9487 static int test_blockdev_rereadpt_0_skip (void)
9488 {
9489   const char *str;
9490
9491   str = getenv ("TEST_ONLY");
9492   if (str)
9493     return strstr (str, "blockdev_rereadpt") == NULL;
9494   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
9495   if (str && strcmp (str, "1") == 0) return 1;
9496   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
9497   if (str && strcmp (str, "1") == 0) return 1;
9498   return 0;
9499 }
9500
9501 static int test_blockdev_rereadpt_0 (void)
9502 {
9503   if (test_blockdev_rereadpt_0_skip ()) {
9504     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
9505     return 0;
9506   }
9507
9508   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
9509   {
9510     char device[] = "/dev/sda";
9511     int r;
9512     suppress_error = 0;
9513     r = guestfs_blockdev_setrw (g, device);
9514     if (r == -1)
9515       return -1;
9516   }
9517   {
9518     int r;
9519     suppress_error = 0;
9520     r = guestfs_umount_all (g);
9521     if (r == -1)
9522       return -1;
9523   }
9524   {
9525     int r;
9526     suppress_error = 0;
9527     r = guestfs_lvm_remove_all (g);
9528     if (r == -1)
9529       return -1;
9530   }
9531   /* TestRun for blockdev_rereadpt (0) */
9532   {
9533     char device[] = "/dev/sda";
9534     int r;
9535     suppress_error = 0;
9536     r = guestfs_blockdev_rereadpt (g, device);
9537     if (r == -1)
9538       return -1;
9539   }
9540   return 0;
9541 }
9542
9543 static int test_blockdev_flushbufs_0_skip (void)
9544 {
9545   const char *str;
9546
9547   str = getenv ("TEST_ONLY");
9548   if (str)
9549     return strstr (str, "blockdev_flushbufs") == NULL;
9550   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
9551   if (str && strcmp (str, "1") == 0) return 1;
9552   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
9553   if (str && strcmp (str, "1") == 0) return 1;
9554   return 0;
9555 }
9556
9557 static int test_blockdev_flushbufs_0 (void)
9558 {
9559   if (test_blockdev_flushbufs_0_skip ()) {
9560     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
9561     return 0;
9562   }
9563
9564   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
9565   {
9566     char device[] = "/dev/sda";
9567     int r;
9568     suppress_error = 0;
9569     r = guestfs_blockdev_setrw (g, device);
9570     if (r == -1)
9571       return -1;
9572   }
9573   {
9574     int r;
9575     suppress_error = 0;
9576     r = guestfs_umount_all (g);
9577     if (r == -1)
9578       return -1;
9579   }
9580   {
9581     int r;
9582     suppress_error = 0;
9583     r = guestfs_lvm_remove_all (g);
9584     if (r == -1)
9585       return -1;
9586   }
9587   /* TestRun for blockdev_flushbufs (0) */
9588   {
9589     char device[] = "/dev/sda";
9590     int r;
9591     suppress_error = 0;
9592     r = guestfs_blockdev_flushbufs (g, device);
9593     if (r == -1)
9594       return -1;
9595   }
9596   return 0;
9597 }
9598
9599 static int test_blockdev_getsize64_0_skip (void)
9600 {
9601   const char *str;
9602
9603   str = getenv ("TEST_ONLY");
9604   if (str)
9605     return strstr (str, "blockdev_getsize64") == NULL;
9606   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
9607   if (str && strcmp (str, "1") == 0) return 1;
9608   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
9609   if (str && strcmp (str, "1") == 0) return 1;
9610   return 0;
9611 }
9612
9613 static int test_blockdev_getsize64_0 (void)
9614 {
9615   if (test_blockdev_getsize64_0_skip ()) {
9616     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
9617     return 0;
9618   }
9619
9620   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
9621   {
9622     char device[] = "/dev/sda";
9623     int r;
9624     suppress_error = 0;
9625     r = guestfs_blockdev_setrw (g, device);
9626     if (r == -1)
9627       return -1;
9628   }
9629   {
9630     int r;
9631     suppress_error = 0;
9632     r = guestfs_umount_all (g);
9633     if (r == -1)
9634       return -1;
9635   }
9636   {
9637     int r;
9638     suppress_error = 0;
9639     r = guestfs_lvm_remove_all (g);
9640     if (r == -1)
9641       return -1;
9642   }
9643   /* TestOutputInt for blockdev_getsize64 (0) */
9644   {
9645     char device[] = "/dev/sda";
9646     int64_t r;
9647     suppress_error = 0;
9648     r = guestfs_blockdev_getsize64 (g, device);
9649     if (r == -1)
9650       return -1;
9651     if (r != 524288000) {
9652       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
9653       return -1;
9654     }
9655   }
9656   return 0;
9657 }
9658
9659 static int test_blockdev_getsz_0_skip (void)
9660 {
9661   const char *str;
9662
9663   str = getenv ("TEST_ONLY");
9664   if (str)
9665     return strstr (str, "blockdev_getsz") == NULL;
9666   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
9667   if (str && strcmp (str, "1") == 0) return 1;
9668   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
9669   if (str && strcmp (str, "1") == 0) return 1;
9670   return 0;
9671 }
9672
9673 static int test_blockdev_getsz_0 (void)
9674 {
9675   if (test_blockdev_getsz_0_skip ()) {
9676     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
9677     return 0;
9678   }
9679
9680   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
9681   {
9682     char device[] = "/dev/sda";
9683     int r;
9684     suppress_error = 0;
9685     r = guestfs_blockdev_setrw (g, device);
9686     if (r == -1)
9687       return -1;
9688   }
9689   {
9690     int r;
9691     suppress_error = 0;
9692     r = guestfs_umount_all (g);
9693     if (r == -1)
9694       return -1;
9695   }
9696   {
9697     int r;
9698     suppress_error = 0;
9699     r = guestfs_lvm_remove_all (g);
9700     if (r == -1)
9701       return -1;
9702   }
9703   /* TestOutputInt for blockdev_getsz (0) */
9704   {
9705     char device[] = "/dev/sda";
9706     int64_t r;
9707     suppress_error = 0;
9708     r = guestfs_blockdev_getsz (g, device);
9709     if (r == -1)
9710       return -1;
9711     if (r != 1024000) {
9712       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
9713       return -1;
9714     }
9715   }
9716   return 0;
9717 }
9718
9719 static int test_blockdev_getbsz_0_skip (void)
9720 {
9721   const char *str;
9722
9723   str = getenv ("TEST_ONLY");
9724   if (str)
9725     return strstr (str, "blockdev_getbsz") == NULL;
9726   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9727   if (str && strcmp (str, "1") == 0) return 1;
9728   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9729   if (str && strcmp (str, "1") == 0) return 1;
9730   return 0;
9731 }
9732
9733 static int test_blockdev_getbsz_0 (void)
9734 {
9735   if (test_blockdev_getbsz_0_skip ()) {
9736     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9737     return 0;
9738   }
9739
9740   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9741   {
9742     char device[] = "/dev/sda";
9743     int r;
9744     suppress_error = 0;
9745     r = guestfs_blockdev_setrw (g, device);
9746     if (r == -1)
9747       return -1;
9748   }
9749   {
9750     int r;
9751     suppress_error = 0;
9752     r = guestfs_umount_all (g);
9753     if (r == -1)
9754       return -1;
9755   }
9756   {
9757     int r;
9758     suppress_error = 0;
9759     r = guestfs_lvm_remove_all (g);
9760     if (r == -1)
9761       return -1;
9762   }
9763   /* TestOutputInt for blockdev_getbsz (0) */
9764   {
9765     char device[] = "/dev/sda";
9766     int r;
9767     suppress_error = 0;
9768     r = guestfs_blockdev_getbsz (g, device);
9769     if (r == -1)
9770       return -1;
9771     if (r != 4096) {
9772       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
9773       return -1;
9774     }
9775   }
9776   return 0;
9777 }
9778
9779 static int test_blockdev_getss_0_skip (void)
9780 {
9781   const char *str;
9782
9783   str = getenv ("TEST_ONLY");
9784   if (str)
9785     return strstr (str, "blockdev_getss") == NULL;
9786   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9787   if (str && strcmp (str, "1") == 0) return 1;
9788   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9789   if (str && strcmp (str, "1") == 0) return 1;
9790   return 0;
9791 }
9792
9793 static int test_blockdev_getss_0 (void)
9794 {
9795   if (test_blockdev_getss_0_skip ()) {
9796     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9797     return 0;
9798   }
9799
9800   /* InitNone|InitEmpty for test_blockdev_getss_0 */
9801   {
9802     char device[] = "/dev/sda";
9803     int r;
9804     suppress_error = 0;
9805     r = guestfs_blockdev_setrw (g, device);
9806     if (r == -1)
9807       return -1;
9808   }
9809   {
9810     int r;
9811     suppress_error = 0;
9812     r = guestfs_umount_all (g);
9813     if (r == -1)
9814       return -1;
9815   }
9816   {
9817     int r;
9818     suppress_error = 0;
9819     r = guestfs_lvm_remove_all (g);
9820     if (r == -1)
9821       return -1;
9822   }
9823   /* TestOutputInt for blockdev_getss (0) */
9824   {
9825     char device[] = "/dev/sda";
9826     int r;
9827     suppress_error = 0;
9828     r = guestfs_blockdev_getss (g, device);
9829     if (r == -1)
9830       return -1;
9831     if (r != 512) {
9832       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
9833       return -1;
9834     }
9835   }
9836   return 0;
9837 }
9838
9839 static int test_blockdev_getro_0_skip (void)
9840 {
9841   const char *str;
9842
9843   str = getenv ("TEST_ONLY");
9844   if (str)
9845     return strstr (str, "blockdev_getro") == NULL;
9846   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9847   if (str && strcmp (str, "1") == 0) return 1;
9848   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9849   if (str && strcmp (str, "1") == 0) return 1;
9850   return 0;
9851 }
9852
9853 static int test_blockdev_getro_0 (void)
9854 {
9855   if (test_blockdev_getro_0_skip ()) {
9856     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9857     return 0;
9858   }
9859
9860   /* InitNone|InitEmpty for test_blockdev_getro_0 */
9861   {
9862     char device[] = "/dev/sda";
9863     int r;
9864     suppress_error = 0;
9865     r = guestfs_blockdev_setrw (g, device);
9866     if (r == -1)
9867       return -1;
9868   }
9869   {
9870     int r;
9871     suppress_error = 0;
9872     r = guestfs_umount_all (g);
9873     if (r == -1)
9874       return -1;
9875   }
9876   {
9877     int r;
9878     suppress_error = 0;
9879     r = guestfs_lvm_remove_all (g);
9880     if (r == -1)
9881       return -1;
9882   }
9883   /* TestOutputTrue for blockdev_getro (0) */
9884   {
9885     char device[] = "/dev/sda";
9886     int r;
9887     suppress_error = 0;
9888     r = guestfs_blockdev_setro (g, device);
9889     if (r == -1)
9890       return -1;
9891   }
9892   {
9893     char device[] = "/dev/sda";
9894     int r;
9895     suppress_error = 0;
9896     r = guestfs_blockdev_getro (g, device);
9897     if (r == -1)
9898       return -1;
9899     if (!r) {
9900       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9901       return -1;
9902     }
9903   }
9904   return 0;
9905 }
9906
9907 static int test_blockdev_setrw_0_skip (void)
9908 {
9909   const char *str;
9910
9911   str = getenv ("TEST_ONLY");
9912   if (str)
9913     return strstr (str, "blockdev_setrw") == NULL;
9914   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9915   if (str && strcmp (str, "1") == 0) return 1;
9916   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9917   if (str && strcmp (str, "1") == 0) return 1;
9918   return 0;
9919 }
9920
9921 static int test_blockdev_setrw_0 (void)
9922 {
9923   if (test_blockdev_setrw_0_skip ()) {
9924     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9925     return 0;
9926   }
9927
9928   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9929   {
9930     char device[] = "/dev/sda";
9931     int r;
9932     suppress_error = 0;
9933     r = guestfs_blockdev_setrw (g, device);
9934     if (r == -1)
9935       return -1;
9936   }
9937   {
9938     int r;
9939     suppress_error = 0;
9940     r = guestfs_umount_all (g);
9941     if (r == -1)
9942       return -1;
9943   }
9944   {
9945     int r;
9946     suppress_error = 0;
9947     r = guestfs_lvm_remove_all (g);
9948     if (r == -1)
9949       return -1;
9950   }
9951   /* TestOutputFalse for blockdev_setrw (0) */
9952   {
9953     char device[] = "/dev/sda";
9954     int r;
9955     suppress_error = 0;
9956     r = guestfs_blockdev_setrw (g, device);
9957     if (r == -1)
9958       return -1;
9959   }
9960   {
9961     char device[] = "/dev/sda";
9962     int r;
9963     suppress_error = 0;
9964     r = guestfs_blockdev_getro (g, device);
9965     if (r == -1)
9966       return -1;
9967     if (r) {
9968       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9969       return -1;
9970     }
9971   }
9972   return 0;
9973 }
9974
9975 static int test_blockdev_setro_0_skip (void)
9976 {
9977   const char *str;
9978
9979   str = getenv ("TEST_ONLY");
9980   if (str)
9981     return strstr (str, "blockdev_setro") == NULL;
9982   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9983   if (str && strcmp (str, "1") == 0) return 1;
9984   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9985   if (str && strcmp (str, "1") == 0) return 1;
9986   return 0;
9987 }
9988
9989 static int test_blockdev_setro_0 (void)
9990 {
9991   if (test_blockdev_setro_0_skip ()) {
9992     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9993     return 0;
9994   }
9995
9996   /* InitNone|InitEmpty for test_blockdev_setro_0 */
9997   {
9998     char device[] = "/dev/sda";
9999     int r;
10000     suppress_error = 0;
10001     r = guestfs_blockdev_setrw (g, device);
10002     if (r == -1)
10003       return -1;
10004   }
10005   {
10006     int r;
10007     suppress_error = 0;
10008     r = guestfs_umount_all (g);
10009     if (r == -1)
10010       return -1;
10011   }
10012   {
10013     int r;
10014     suppress_error = 0;
10015     r = guestfs_lvm_remove_all (g);
10016     if (r == -1)
10017       return -1;
10018   }
10019   /* TestOutputTrue for blockdev_setro (0) */
10020   {
10021     char device[] = "/dev/sda";
10022     int r;
10023     suppress_error = 0;
10024     r = guestfs_blockdev_setro (g, device);
10025     if (r == -1)
10026       return -1;
10027   }
10028   {
10029     char device[] = "/dev/sda";
10030     int r;
10031     suppress_error = 0;
10032     r = guestfs_blockdev_getro (g, device);
10033     if (r == -1)
10034       return -1;
10035     if (!r) {
10036       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
10037       return -1;
10038     }
10039   }
10040   return 0;
10041 }
10042
10043 static int test_statvfs_0_skip (void)
10044 {
10045   const char *str;
10046
10047   str = getenv ("TEST_ONLY");
10048   if (str)
10049     return strstr (str, "statvfs") == NULL;
10050   str = getenv ("SKIP_TEST_STATVFS_0");
10051   if (str && strcmp (str, "1") == 0) return 1;
10052   str = getenv ("SKIP_TEST_STATVFS");
10053   if (str && strcmp (str, "1") == 0) return 1;
10054   return 0;
10055 }
10056
10057 static int test_statvfs_0 (void)
10058 {
10059   if (test_statvfs_0_skip ()) {
10060     printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
10061     return 0;
10062   }
10063
10064   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
10065   {
10066     char device[] = "/dev/sda";
10067     int r;
10068     suppress_error = 0;
10069     r = guestfs_blockdev_setrw (g, device);
10070     if (r == -1)
10071       return -1;
10072   }
10073   {
10074     int r;
10075     suppress_error = 0;
10076     r = guestfs_umount_all (g);
10077     if (r == -1)
10078       return -1;
10079   }
10080   {
10081     int r;
10082     suppress_error = 0;
10083     r = guestfs_lvm_remove_all (g);
10084     if (r == -1)
10085       return -1;
10086   }
10087   {
10088     char device[] = "/dev/sda";
10089     char lines_0[] = ",";
10090     char *lines[] = {
10091       lines_0,
10092       NULL
10093     };
10094     int r;
10095     suppress_error = 0;
10096     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10097     if (r == -1)
10098       return -1;
10099   }
10100   {
10101     char fstype[] = "ext2";
10102     char device[] = "/dev/sda1";
10103     int r;
10104     suppress_error = 0;
10105     r = guestfs_mkfs (g, fstype, device);
10106     if (r == -1)
10107       return -1;
10108   }
10109   {
10110     char device[] = "/dev/sda1";
10111     char mountpoint[] = "/";
10112     int r;
10113     suppress_error = 0;
10114     r = guestfs_mount (g, device, mountpoint);
10115     if (r == -1)
10116       return -1;
10117   }
10118   /* TestOutputStruct for statvfs (0) */
10119   {
10120     char path[] = "/";
10121     struct guestfs_statvfs *r;
10122     suppress_error = 0;
10123     r = guestfs_statvfs (g, path);
10124     if (r == NULL)
10125       return -1;
10126     if (r->bfree != 487702) {
10127       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
10128                (int) r->bfree);
10129       return -1;
10130     }
10131     if (r->blocks != 490020) {
10132       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
10133                (int) r->blocks);
10134       return -1;
10135     }
10136     if (r->bsize != 1024) {
10137       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
10138                (int) r->bsize);
10139       return -1;
10140     }
10141     free (r);
10142   }
10143   return 0;
10144 }
10145
10146 static int test_lstat_0_skip (void)
10147 {
10148   const char *str;
10149
10150   str = getenv ("TEST_ONLY");
10151   if (str)
10152     return strstr (str, "lstat") == NULL;
10153   str = getenv ("SKIP_TEST_LSTAT_0");
10154   if (str && strcmp (str, "1") == 0) return 1;
10155   str = getenv ("SKIP_TEST_LSTAT");
10156   if (str && strcmp (str, "1") == 0) return 1;
10157   return 0;
10158 }
10159
10160 static int test_lstat_0 (void)
10161 {
10162   if (test_lstat_0_skip ()) {
10163     printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
10164     return 0;
10165   }
10166
10167   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
10168   {
10169     char device[] = "/dev/sda";
10170     int r;
10171     suppress_error = 0;
10172     r = guestfs_blockdev_setrw (g, device);
10173     if (r == -1)
10174       return -1;
10175   }
10176   {
10177     int r;
10178     suppress_error = 0;
10179     r = guestfs_umount_all (g);
10180     if (r == -1)
10181       return -1;
10182   }
10183   {
10184     int r;
10185     suppress_error = 0;
10186     r = guestfs_lvm_remove_all (g);
10187     if (r == -1)
10188       return -1;
10189   }
10190   {
10191     char device[] = "/dev/sda";
10192     char lines_0[] = ",";
10193     char *lines[] = {
10194       lines_0,
10195       NULL
10196     };
10197     int r;
10198     suppress_error = 0;
10199     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10200     if (r == -1)
10201       return -1;
10202   }
10203   {
10204     char fstype[] = "ext2";
10205     char device[] = "/dev/sda1";
10206     int r;
10207     suppress_error = 0;
10208     r = guestfs_mkfs (g, fstype, device);
10209     if (r == -1)
10210       return -1;
10211   }
10212   {
10213     char device[] = "/dev/sda1";
10214     char mountpoint[] = "/";
10215     int r;
10216     suppress_error = 0;
10217     r = guestfs_mount (g, device, mountpoint);
10218     if (r == -1)
10219       return -1;
10220   }
10221   /* TestOutputStruct for lstat (0) */
10222   {
10223     char path[] = "/new";
10224     int r;
10225     suppress_error = 0;
10226     r = guestfs_touch (g, path);
10227     if (r == -1)
10228       return -1;
10229   }
10230   {
10231     char path[] = "/new";
10232     struct guestfs_stat *r;
10233     suppress_error = 0;
10234     r = guestfs_lstat (g, path);
10235     if (r == NULL)
10236       return -1;
10237     if (r->size != 0) {
10238       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
10239                (int) r->size);
10240       return -1;
10241     }
10242     free (r);
10243   }
10244   return 0;
10245 }
10246
10247 static int test_stat_0_skip (void)
10248 {
10249   const char *str;
10250
10251   str = getenv ("TEST_ONLY");
10252   if (str)
10253     return strstr (str, "stat") == NULL;
10254   str = getenv ("SKIP_TEST_STAT_0");
10255   if (str && strcmp (str, "1") == 0) return 1;
10256   str = getenv ("SKIP_TEST_STAT");
10257   if (str && strcmp (str, "1") == 0) return 1;
10258   return 0;
10259 }
10260
10261 static int test_stat_0 (void)
10262 {
10263   if (test_stat_0_skip ()) {
10264     printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
10265     return 0;
10266   }
10267
10268   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
10269   {
10270     char device[] = "/dev/sda";
10271     int r;
10272     suppress_error = 0;
10273     r = guestfs_blockdev_setrw (g, device);
10274     if (r == -1)
10275       return -1;
10276   }
10277   {
10278     int r;
10279     suppress_error = 0;
10280     r = guestfs_umount_all (g);
10281     if (r == -1)
10282       return -1;
10283   }
10284   {
10285     int r;
10286     suppress_error = 0;
10287     r = guestfs_lvm_remove_all (g);
10288     if (r == -1)
10289       return -1;
10290   }
10291   {
10292     char device[] = "/dev/sda";
10293     char lines_0[] = ",";
10294     char *lines[] = {
10295       lines_0,
10296       NULL
10297     };
10298     int r;
10299     suppress_error = 0;
10300     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10301     if (r == -1)
10302       return -1;
10303   }
10304   {
10305     char fstype[] = "ext2";
10306     char device[] = "/dev/sda1";
10307     int r;
10308     suppress_error = 0;
10309     r = guestfs_mkfs (g, fstype, device);
10310     if (r == -1)
10311       return -1;
10312   }
10313   {
10314     char device[] = "/dev/sda1";
10315     char mountpoint[] = "/";
10316     int r;
10317     suppress_error = 0;
10318     r = guestfs_mount (g, device, mountpoint);
10319     if (r == -1)
10320       return -1;
10321   }
10322   /* TestOutputStruct for stat (0) */
10323   {
10324     char path[] = "/new";
10325     int r;
10326     suppress_error = 0;
10327     r = guestfs_touch (g, path);
10328     if (r == -1)
10329       return -1;
10330   }
10331   {
10332     char path[] = "/new";
10333     struct guestfs_stat *r;
10334     suppress_error = 0;
10335     r = guestfs_stat (g, path);
10336     if (r == NULL)
10337       return -1;
10338     if (r->size != 0) {
10339       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
10340                (int) r->size);
10341       return -1;
10342     }
10343     free (r);
10344   }
10345   return 0;
10346 }
10347
10348 static int test_command_lines_0_skip (void)
10349 {
10350   const char *str;
10351
10352   str = getenv ("TEST_ONLY");
10353   if (str)
10354     return strstr (str, "command_lines") == NULL;
10355   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
10356   if (str && strcmp (str, "1") == 0) return 1;
10357   str = getenv ("SKIP_TEST_COMMAND_LINES");
10358   if (str && strcmp (str, "1") == 0) return 1;
10359   return 0;
10360 }
10361
10362 static int test_command_lines_0 (void)
10363 {
10364   if (test_command_lines_0_skip ()) {
10365     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
10366     return 0;
10367   }
10368
10369   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
10370   {
10371     char device[] = "/dev/sda";
10372     int r;
10373     suppress_error = 0;
10374     r = guestfs_blockdev_setrw (g, device);
10375     if (r == -1)
10376       return -1;
10377   }
10378   {
10379     int r;
10380     suppress_error = 0;
10381     r = guestfs_umount_all (g);
10382     if (r == -1)
10383       return -1;
10384   }
10385   {
10386     int r;
10387     suppress_error = 0;
10388     r = guestfs_lvm_remove_all (g);
10389     if (r == -1)
10390       return -1;
10391   }
10392   {
10393     char device[] = "/dev/sda";
10394     char lines_0[] = ",";
10395     char *lines[] = {
10396       lines_0,
10397       NULL
10398     };
10399     int r;
10400     suppress_error = 0;
10401     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10402     if (r == -1)
10403       return -1;
10404   }
10405   {
10406     char fstype[] = "ext2";
10407     char device[] = "/dev/sda1";
10408     int r;
10409     suppress_error = 0;
10410     r = guestfs_mkfs (g, fstype, device);
10411     if (r == -1)
10412       return -1;
10413   }
10414   {
10415     char device[] = "/dev/sda1";
10416     char mountpoint[] = "/";
10417     int r;
10418     suppress_error = 0;
10419     r = guestfs_mount (g, device, mountpoint);
10420     if (r == -1)
10421       return -1;
10422   }
10423   /* TestOutputList for command_lines (0) */
10424   {
10425     char remotefilename[] = "/test-command";
10426     int r;
10427     suppress_error = 0;
10428     r = guestfs_upload (g, "test-command", remotefilename);
10429     if (r == -1)
10430       return -1;
10431   }
10432   {
10433     char path[] = "/test-command";
10434     int r;
10435     suppress_error = 0;
10436     r = guestfs_chmod (g, 493, path);
10437     if (r == -1)
10438       return -1;
10439   }
10440   {
10441     char arguments_0[] = "/test-command";
10442     char arguments_1[] = "1";
10443     char *arguments[] = {
10444       arguments_0,
10445       arguments_1,
10446       NULL
10447     };
10448     char **r;
10449     int i;
10450     suppress_error = 0;
10451     r = guestfs_command_lines (g, arguments);
10452     if (r == NULL)
10453       return -1;
10454     if (!r[0]) {
10455       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
10456       print_strings (r);
10457       return -1;
10458     }
10459     {
10460       char expected[] = "Result1";
10461       if (strcmp (r[0], expected) != 0) {
10462         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10463         return -1;
10464       }
10465     }
10466     if (r[1] != NULL) {
10467       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
10468       print_strings (r);
10469       return -1;
10470     }
10471     for (i = 0; r[i] != NULL; ++i)
10472       free (r[i]);
10473     free (r);
10474   }
10475   return 0;
10476 }
10477
10478 static int test_command_lines_1_skip (void)
10479 {
10480   const char *str;
10481
10482   str = getenv ("TEST_ONLY");
10483   if (str)
10484     return strstr (str, "command_lines") == NULL;
10485   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
10486   if (str && strcmp (str, "1") == 0) return 1;
10487   str = getenv ("SKIP_TEST_COMMAND_LINES");
10488   if (str && strcmp (str, "1") == 0) return 1;
10489   return 0;
10490 }
10491
10492 static int test_command_lines_1 (void)
10493 {
10494   if (test_command_lines_1_skip ()) {
10495     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
10496     return 0;
10497   }
10498
10499   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
10500   {
10501     char device[] = "/dev/sda";
10502     int r;
10503     suppress_error = 0;
10504     r = guestfs_blockdev_setrw (g, device);
10505     if (r == -1)
10506       return -1;
10507   }
10508   {
10509     int r;
10510     suppress_error = 0;
10511     r = guestfs_umount_all (g);
10512     if (r == -1)
10513       return -1;
10514   }
10515   {
10516     int r;
10517     suppress_error = 0;
10518     r = guestfs_lvm_remove_all (g);
10519     if (r == -1)
10520       return -1;
10521   }
10522   {
10523     char device[] = "/dev/sda";
10524     char lines_0[] = ",";
10525     char *lines[] = {
10526       lines_0,
10527       NULL
10528     };
10529     int r;
10530     suppress_error = 0;
10531     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10532     if (r == -1)
10533       return -1;
10534   }
10535   {
10536     char fstype[] = "ext2";
10537     char device[] = "/dev/sda1";
10538     int r;
10539     suppress_error = 0;
10540     r = guestfs_mkfs (g, fstype, device);
10541     if (r == -1)
10542       return -1;
10543   }
10544   {
10545     char device[] = "/dev/sda1";
10546     char mountpoint[] = "/";
10547     int r;
10548     suppress_error = 0;
10549     r = guestfs_mount (g, device, mountpoint);
10550     if (r == -1)
10551       return -1;
10552   }
10553   /* TestOutputList for command_lines (1) */
10554   {
10555     char remotefilename[] = "/test-command";
10556     int r;
10557     suppress_error = 0;
10558     r = guestfs_upload (g, "test-command", remotefilename);
10559     if (r == -1)
10560       return -1;
10561   }
10562   {
10563     char path[] = "/test-command";
10564     int r;
10565     suppress_error = 0;
10566     r = guestfs_chmod (g, 493, path);
10567     if (r == -1)
10568       return -1;
10569   }
10570   {
10571     char arguments_0[] = "/test-command";
10572     char arguments_1[] = "2";
10573     char *arguments[] = {
10574       arguments_0,
10575       arguments_1,
10576       NULL
10577     };
10578     char **r;
10579     int i;
10580     suppress_error = 0;
10581     r = guestfs_command_lines (g, arguments);
10582     if (r == NULL)
10583       return -1;
10584     if (!r[0]) {
10585       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
10586       print_strings (r);
10587       return -1;
10588     }
10589     {
10590       char expected[] = "Result2";
10591       if (strcmp (r[0], expected) != 0) {
10592         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10593         return -1;
10594       }
10595     }
10596     if (r[1] != NULL) {
10597       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
10598       print_strings (r);
10599       return -1;
10600     }
10601     for (i = 0; r[i] != NULL; ++i)
10602       free (r[i]);
10603     free (r);
10604   }
10605   return 0;
10606 }
10607
10608 static int test_command_lines_2_skip (void)
10609 {
10610   const char *str;
10611
10612   str = getenv ("TEST_ONLY");
10613   if (str)
10614     return strstr (str, "command_lines") == NULL;
10615   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
10616   if (str && strcmp (str, "1") == 0) return 1;
10617   str = getenv ("SKIP_TEST_COMMAND_LINES");
10618   if (str && strcmp (str, "1") == 0) return 1;
10619   return 0;
10620 }
10621
10622 static int test_command_lines_2 (void)
10623 {
10624   if (test_command_lines_2_skip ()) {
10625     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
10626     return 0;
10627   }
10628
10629   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
10630   {
10631     char device[] = "/dev/sda";
10632     int r;
10633     suppress_error = 0;
10634     r = guestfs_blockdev_setrw (g, device);
10635     if (r == -1)
10636       return -1;
10637   }
10638   {
10639     int r;
10640     suppress_error = 0;
10641     r = guestfs_umount_all (g);
10642     if (r == -1)
10643       return -1;
10644   }
10645   {
10646     int r;
10647     suppress_error = 0;
10648     r = guestfs_lvm_remove_all (g);
10649     if (r == -1)
10650       return -1;
10651   }
10652   {
10653     char device[] = "/dev/sda";
10654     char lines_0[] = ",";
10655     char *lines[] = {
10656       lines_0,
10657       NULL
10658     };
10659     int r;
10660     suppress_error = 0;
10661     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10662     if (r == -1)
10663       return -1;
10664   }
10665   {
10666     char fstype[] = "ext2";
10667     char device[] = "/dev/sda1";
10668     int r;
10669     suppress_error = 0;
10670     r = guestfs_mkfs (g, fstype, device);
10671     if (r == -1)
10672       return -1;
10673   }
10674   {
10675     char device[] = "/dev/sda1";
10676     char mountpoint[] = "/";
10677     int r;
10678     suppress_error = 0;
10679     r = guestfs_mount (g, device, mountpoint);
10680     if (r == -1)
10681       return -1;
10682   }
10683   /* TestOutputList for command_lines (2) */
10684   {
10685     char remotefilename[] = "/test-command";
10686     int r;
10687     suppress_error = 0;
10688     r = guestfs_upload (g, "test-command", remotefilename);
10689     if (r == -1)
10690       return -1;
10691   }
10692   {
10693     char path[] = "/test-command";
10694     int r;
10695     suppress_error = 0;
10696     r = guestfs_chmod (g, 493, path);
10697     if (r == -1)
10698       return -1;
10699   }
10700   {
10701     char arguments_0[] = "/test-command";
10702     char arguments_1[] = "3";
10703     char *arguments[] = {
10704       arguments_0,
10705       arguments_1,
10706       NULL
10707     };
10708     char **r;
10709     int i;
10710     suppress_error = 0;
10711     r = guestfs_command_lines (g, arguments);
10712     if (r == NULL)
10713       return -1;
10714     if (!r[0]) {
10715       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10716       print_strings (r);
10717       return -1;
10718     }
10719     {
10720       char expected[] = "";
10721       if (strcmp (r[0], expected) != 0) {
10722         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10723         return -1;
10724       }
10725     }
10726     if (!r[1]) {
10727       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10728       print_strings (r);
10729       return -1;
10730     }
10731     {
10732       char expected[] = "Result3";
10733       if (strcmp (r[1], expected) != 0) {
10734         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10735         return -1;
10736       }
10737     }
10738     if (r[2] != NULL) {
10739       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10740       print_strings (r);
10741       return -1;
10742     }
10743     for (i = 0; r[i] != NULL; ++i)
10744       free (r[i]);
10745     free (r);
10746   }
10747   return 0;
10748 }
10749
10750 static int test_command_lines_3_skip (void)
10751 {
10752   const char *str;
10753
10754   str = getenv ("TEST_ONLY");
10755   if (str)
10756     return strstr (str, "command_lines") == NULL;
10757   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10758   if (str && strcmp (str, "1") == 0) return 1;
10759   str = getenv ("SKIP_TEST_COMMAND_LINES");
10760   if (str && strcmp (str, "1") == 0) return 1;
10761   return 0;
10762 }
10763
10764 static int test_command_lines_3 (void)
10765 {
10766   if (test_command_lines_3_skip ()) {
10767     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
10768     return 0;
10769   }
10770
10771   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10772   {
10773     char device[] = "/dev/sda";
10774     int r;
10775     suppress_error = 0;
10776     r = guestfs_blockdev_setrw (g, device);
10777     if (r == -1)
10778       return -1;
10779   }
10780   {
10781     int r;
10782     suppress_error = 0;
10783     r = guestfs_umount_all (g);
10784     if (r == -1)
10785       return -1;
10786   }
10787   {
10788     int r;
10789     suppress_error = 0;
10790     r = guestfs_lvm_remove_all (g);
10791     if (r == -1)
10792       return -1;
10793   }
10794   {
10795     char device[] = "/dev/sda";
10796     char lines_0[] = ",";
10797     char *lines[] = {
10798       lines_0,
10799       NULL
10800     };
10801     int r;
10802     suppress_error = 0;
10803     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10804     if (r == -1)
10805       return -1;
10806   }
10807   {
10808     char fstype[] = "ext2";
10809     char device[] = "/dev/sda1";
10810     int r;
10811     suppress_error = 0;
10812     r = guestfs_mkfs (g, fstype, device);
10813     if (r == -1)
10814       return -1;
10815   }
10816   {
10817     char device[] = "/dev/sda1";
10818     char mountpoint[] = "/";
10819     int r;
10820     suppress_error = 0;
10821     r = guestfs_mount (g, device, mountpoint);
10822     if (r == -1)
10823       return -1;
10824   }
10825   /* TestOutputList for command_lines (3) */
10826   {
10827     char remotefilename[] = "/test-command";
10828     int r;
10829     suppress_error = 0;
10830     r = guestfs_upload (g, "test-command", remotefilename);
10831     if (r == -1)
10832       return -1;
10833   }
10834   {
10835     char path[] = "/test-command";
10836     int r;
10837     suppress_error = 0;
10838     r = guestfs_chmod (g, 493, path);
10839     if (r == -1)
10840       return -1;
10841   }
10842   {
10843     char arguments_0[] = "/test-command";
10844     char arguments_1[] = "4";
10845     char *arguments[] = {
10846       arguments_0,
10847       arguments_1,
10848       NULL
10849     };
10850     char **r;
10851     int i;
10852     suppress_error = 0;
10853     r = guestfs_command_lines (g, arguments);
10854     if (r == NULL)
10855       return -1;
10856     if (!r[0]) {
10857       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10858       print_strings (r);
10859       return -1;
10860     }
10861     {
10862       char expected[] = "";
10863       if (strcmp (r[0], expected) != 0) {
10864         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10865         return -1;
10866       }
10867     }
10868     if (!r[1]) {
10869       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10870       print_strings (r);
10871       return -1;
10872     }
10873     {
10874       char expected[] = "Result4";
10875       if (strcmp (r[1], expected) != 0) {
10876         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10877         return -1;
10878       }
10879     }
10880     if (r[2] != NULL) {
10881       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10882       print_strings (r);
10883       return -1;
10884     }
10885     for (i = 0; r[i] != NULL; ++i)
10886       free (r[i]);
10887     free (r);
10888   }
10889   return 0;
10890 }
10891
10892 static int test_command_lines_4_skip (void)
10893 {
10894   const char *str;
10895
10896   str = getenv ("TEST_ONLY");
10897   if (str)
10898     return strstr (str, "command_lines") == NULL;
10899   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10900   if (str && strcmp (str, "1") == 0) return 1;
10901   str = getenv ("SKIP_TEST_COMMAND_LINES");
10902   if (str && strcmp (str, "1") == 0) return 1;
10903   return 0;
10904 }
10905
10906 static int test_command_lines_4 (void)
10907 {
10908   if (test_command_lines_4_skip ()) {
10909     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10910     return 0;
10911   }
10912
10913   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10914   {
10915     char device[] = "/dev/sda";
10916     int r;
10917     suppress_error = 0;
10918     r = guestfs_blockdev_setrw (g, device);
10919     if (r == -1)
10920       return -1;
10921   }
10922   {
10923     int r;
10924     suppress_error = 0;
10925     r = guestfs_umount_all (g);
10926     if (r == -1)
10927       return -1;
10928   }
10929   {
10930     int r;
10931     suppress_error = 0;
10932     r = guestfs_lvm_remove_all (g);
10933     if (r == -1)
10934       return -1;
10935   }
10936   {
10937     char device[] = "/dev/sda";
10938     char lines_0[] = ",";
10939     char *lines[] = {
10940       lines_0,
10941       NULL
10942     };
10943     int r;
10944     suppress_error = 0;
10945     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10946     if (r == -1)
10947       return -1;
10948   }
10949   {
10950     char fstype[] = "ext2";
10951     char device[] = "/dev/sda1";
10952     int r;
10953     suppress_error = 0;
10954     r = guestfs_mkfs (g, fstype, device);
10955     if (r == -1)
10956       return -1;
10957   }
10958   {
10959     char device[] = "/dev/sda1";
10960     char mountpoint[] = "/";
10961     int r;
10962     suppress_error = 0;
10963     r = guestfs_mount (g, device, mountpoint);
10964     if (r == -1)
10965       return -1;
10966   }
10967   /* TestOutputList for command_lines (4) */
10968   {
10969     char remotefilename[] = "/test-command";
10970     int r;
10971     suppress_error = 0;
10972     r = guestfs_upload (g, "test-command", remotefilename);
10973     if (r == -1)
10974       return -1;
10975   }
10976   {
10977     char path[] = "/test-command";
10978     int r;
10979     suppress_error = 0;
10980     r = guestfs_chmod (g, 493, path);
10981     if (r == -1)
10982       return -1;
10983   }
10984   {
10985     char arguments_0[] = "/test-command";
10986     char arguments_1[] = "5";
10987     char *arguments[] = {
10988       arguments_0,
10989       arguments_1,
10990       NULL
10991     };
10992     char **r;
10993     int i;
10994     suppress_error = 0;
10995     r = guestfs_command_lines (g, arguments);
10996     if (r == NULL)
10997       return -1;
10998     if (!r[0]) {
10999       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
11000       print_strings (r);
11001       return -1;
11002     }
11003     {
11004       char expected[] = "";
11005       if (strcmp (r[0], expected) != 0) {
11006         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11007         return -1;
11008       }
11009     }
11010     if (!r[1]) {
11011       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
11012       print_strings (r);
11013       return -1;
11014     }
11015     {
11016       char expected[] = "Result5";
11017       if (strcmp (r[1], expected) != 0) {
11018         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11019         return -1;
11020       }
11021     }
11022     if (!r[2]) {
11023       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
11024       print_strings (r);
11025       return -1;
11026     }
11027     {
11028       char expected[] = "";
11029       if (strcmp (r[2], expected) != 0) {
11030         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11031         return -1;
11032       }
11033     }
11034     if (r[3] != NULL) {
11035       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
11036       print_strings (r);
11037       return -1;
11038     }
11039     for (i = 0; r[i] != NULL; ++i)
11040       free (r[i]);
11041     free (r);
11042   }
11043   return 0;
11044 }
11045
11046 static int test_command_lines_5_skip (void)
11047 {
11048   const char *str;
11049
11050   str = getenv ("TEST_ONLY");
11051   if (str)
11052     return strstr (str, "command_lines") == NULL;
11053   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
11054   if (str && strcmp (str, "1") == 0) return 1;
11055   str = getenv ("SKIP_TEST_COMMAND_LINES");
11056   if (str && strcmp (str, "1") == 0) return 1;
11057   return 0;
11058 }
11059
11060 static int test_command_lines_5 (void)
11061 {
11062   if (test_command_lines_5_skip ()) {
11063     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
11064     return 0;
11065   }
11066
11067   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
11068   {
11069     char device[] = "/dev/sda";
11070     int r;
11071     suppress_error = 0;
11072     r = guestfs_blockdev_setrw (g, device);
11073     if (r == -1)
11074       return -1;
11075   }
11076   {
11077     int r;
11078     suppress_error = 0;
11079     r = guestfs_umount_all (g);
11080     if (r == -1)
11081       return -1;
11082   }
11083   {
11084     int r;
11085     suppress_error = 0;
11086     r = guestfs_lvm_remove_all (g);
11087     if (r == -1)
11088       return -1;
11089   }
11090   {
11091     char device[] = "/dev/sda";
11092     char lines_0[] = ",";
11093     char *lines[] = {
11094       lines_0,
11095       NULL
11096     };
11097     int r;
11098     suppress_error = 0;
11099     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11100     if (r == -1)
11101       return -1;
11102   }
11103   {
11104     char fstype[] = "ext2";
11105     char device[] = "/dev/sda1";
11106     int r;
11107     suppress_error = 0;
11108     r = guestfs_mkfs (g, fstype, device);
11109     if (r == -1)
11110       return -1;
11111   }
11112   {
11113     char device[] = "/dev/sda1";
11114     char mountpoint[] = "/";
11115     int r;
11116     suppress_error = 0;
11117     r = guestfs_mount (g, device, mountpoint);
11118     if (r == -1)
11119       return -1;
11120   }
11121   /* TestOutputList for command_lines (5) */
11122   {
11123     char remotefilename[] = "/test-command";
11124     int r;
11125     suppress_error = 0;
11126     r = guestfs_upload (g, "test-command", remotefilename);
11127     if (r == -1)
11128       return -1;
11129   }
11130   {
11131     char path[] = "/test-command";
11132     int r;
11133     suppress_error = 0;
11134     r = guestfs_chmod (g, 493, path);
11135     if (r == -1)
11136       return -1;
11137   }
11138   {
11139     char arguments_0[] = "/test-command";
11140     char arguments_1[] = "6";
11141     char *arguments[] = {
11142       arguments_0,
11143       arguments_1,
11144       NULL
11145     };
11146     char **r;
11147     int i;
11148     suppress_error = 0;
11149     r = guestfs_command_lines (g, arguments);
11150     if (r == NULL)
11151       return -1;
11152     if (!r[0]) {
11153       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11154       print_strings (r);
11155       return -1;
11156     }
11157     {
11158       char expected[] = "";
11159       if (strcmp (r[0], expected) != 0) {
11160         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11161         return -1;
11162       }
11163     }
11164     if (!r[1]) {
11165       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11166       print_strings (r);
11167       return -1;
11168     }
11169     {
11170       char expected[] = "";
11171       if (strcmp (r[1], expected) != 0) {
11172         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11173         return -1;
11174       }
11175     }
11176     if (!r[2]) {
11177       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11178       print_strings (r);
11179       return -1;
11180     }
11181     {
11182       char expected[] = "Result6";
11183       if (strcmp (r[2], expected) != 0) {
11184         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11185         return -1;
11186       }
11187     }
11188     if (!r[3]) {
11189       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11190       print_strings (r);
11191       return -1;
11192     }
11193     {
11194       char expected[] = "";
11195       if (strcmp (r[3], expected) != 0) {
11196         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11197         return -1;
11198       }
11199     }
11200     if (r[4] != NULL) {
11201       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
11202       print_strings (r);
11203       return -1;
11204     }
11205     for (i = 0; r[i] != NULL; ++i)
11206       free (r[i]);
11207     free (r);
11208   }
11209   return 0;
11210 }
11211
11212 static int test_command_lines_6_skip (void)
11213 {
11214   const char *str;
11215
11216   str = getenv ("TEST_ONLY");
11217   if (str)
11218     return strstr (str, "command_lines") == NULL;
11219   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
11220   if (str && strcmp (str, "1") == 0) return 1;
11221   str = getenv ("SKIP_TEST_COMMAND_LINES");
11222   if (str && strcmp (str, "1") == 0) return 1;
11223   return 0;
11224 }
11225
11226 static int test_command_lines_6 (void)
11227 {
11228   if (test_command_lines_6_skip ()) {
11229     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
11230     return 0;
11231   }
11232
11233   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
11234   {
11235     char device[] = "/dev/sda";
11236     int r;
11237     suppress_error = 0;
11238     r = guestfs_blockdev_setrw (g, device);
11239     if (r == -1)
11240       return -1;
11241   }
11242   {
11243     int r;
11244     suppress_error = 0;
11245     r = guestfs_umount_all (g);
11246     if (r == -1)
11247       return -1;
11248   }
11249   {
11250     int r;
11251     suppress_error = 0;
11252     r = guestfs_lvm_remove_all (g);
11253     if (r == -1)
11254       return -1;
11255   }
11256   {
11257     char device[] = "/dev/sda";
11258     char lines_0[] = ",";
11259     char *lines[] = {
11260       lines_0,
11261       NULL
11262     };
11263     int r;
11264     suppress_error = 0;
11265     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11266     if (r == -1)
11267       return -1;
11268   }
11269   {
11270     char fstype[] = "ext2";
11271     char device[] = "/dev/sda1";
11272     int r;
11273     suppress_error = 0;
11274     r = guestfs_mkfs (g, fstype, device);
11275     if (r == -1)
11276       return -1;
11277   }
11278   {
11279     char device[] = "/dev/sda1";
11280     char mountpoint[] = "/";
11281     int r;
11282     suppress_error = 0;
11283     r = guestfs_mount (g, device, mountpoint);
11284     if (r == -1)
11285       return -1;
11286   }
11287   /* TestOutputList for command_lines (6) */
11288   {
11289     char remotefilename[] = "/test-command";
11290     int r;
11291     suppress_error = 0;
11292     r = guestfs_upload (g, "test-command", remotefilename);
11293     if (r == -1)
11294       return -1;
11295   }
11296   {
11297     char path[] = "/test-command";
11298     int r;
11299     suppress_error = 0;
11300     r = guestfs_chmod (g, 493, path);
11301     if (r == -1)
11302       return -1;
11303   }
11304   {
11305     char arguments_0[] = "/test-command";
11306     char arguments_1[] = "7";
11307     char *arguments[] = {
11308       arguments_0,
11309       arguments_1,
11310       NULL
11311     };
11312     char **r;
11313     int i;
11314     suppress_error = 0;
11315     r = guestfs_command_lines (g, arguments);
11316     if (r == NULL)
11317       return -1;
11318     if (r[0] != NULL) {
11319       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
11320       print_strings (r);
11321       return -1;
11322     }
11323     for (i = 0; r[i] != NULL; ++i)
11324       free (r[i]);
11325     free (r);
11326   }
11327   return 0;
11328 }
11329
11330 static int test_command_lines_7_skip (void)
11331 {
11332   const char *str;
11333
11334   str = getenv ("TEST_ONLY");
11335   if (str)
11336     return strstr (str, "command_lines") == NULL;
11337   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
11338   if (str && strcmp (str, "1") == 0) return 1;
11339   str = getenv ("SKIP_TEST_COMMAND_LINES");
11340   if (str && strcmp (str, "1") == 0) return 1;
11341   return 0;
11342 }
11343
11344 static int test_command_lines_7 (void)
11345 {
11346   if (test_command_lines_7_skip ()) {
11347     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
11348     return 0;
11349   }
11350
11351   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
11352   {
11353     char device[] = "/dev/sda";
11354     int r;
11355     suppress_error = 0;
11356     r = guestfs_blockdev_setrw (g, device);
11357     if (r == -1)
11358       return -1;
11359   }
11360   {
11361     int r;
11362     suppress_error = 0;
11363     r = guestfs_umount_all (g);
11364     if (r == -1)
11365       return -1;
11366   }
11367   {
11368     int r;
11369     suppress_error = 0;
11370     r = guestfs_lvm_remove_all (g);
11371     if (r == -1)
11372       return -1;
11373   }
11374   {
11375     char device[] = "/dev/sda";
11376     char lines_0[] = ",";
11377     char *lines[] = {
11378       lines_0,
11379       NULL
11380     };
11381     int r;
11382     suppress_error = 0;
11383     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11384     if (r == -1)
11385       return -1;
11386   }
11387   {
11388     char fstype[] = "ext2";
11389     char device[] = "/dev/sda1";
11390     int r;
11391     suppress_error = 0;
11392     r = guestfs_mkfs (g, fstype, device);
11393     if (r == -1)
11394       return -1;
11395   }
11396   {
11397     char device[] = "/dev/sda1";
11398     char mountpoint[] = "/";
11399     int r;
11400     suppress_error = 0;
11401     r = guestfs_mount (g, device, mountpoint);
11402     if (r == -1)
11403       return -1;
11404   }
11405   /* TestOutputList for command_lines (7) */
11406   {
11407     char remotefilename[] = "/test-command";
11408     int r;
11409     suppress_error = 0;
11410     r = guestfs_upload (g, "test-command", remotefilename);
11411     if (r == -1)
11412       return -1;
11413   }
11414   {
11415     char path[] = "/test-command";
11416     int r;
11417     suppress_error = 0;
11418     r = guestfs_chmod (g, 493, path);
11419     if (r == -1)
11420       return -1;
11421   }
11422   {
11423     char arguments_0[] = "/test-command";
11424     char arguments_1[] = "8";
11425     char *arguments[] = {
11426       arguments_0,
11427       arguments_1,
11428       NULL
11429     };
11430     char **r;
11431     int i;
11432     suppress_error = 0;
11433     r = guestfs_command_lines (g, arguments);
11434     if (r == NULL)
11435       return -1;
11436     if (!r[0]) {
11437       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
11438       print_strings (r);
11439       return -1;
11440     }
11441     {
11442       char expected[] = "";
11443       if (strcmp (r[0], expected) != 0) {
11444         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11445         return -1;
11446       }
11447     }
11448     if (r[1] != NULL) {
11449       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
11450       print_strings (r);
11451       return -1;
11452     }
11453     for (i = 0; r[i] != NULL; ++i)
11454       free (r[i]);
11455     free (r);
11456   }
11457   return 0;
11458 }
11459
11460 static int test_command_lines_8_skip (void)
11461 {
11462   const char *str;
11463
11464   str = getenv ("TEST_ONLY");
11465   if (str)
11466     return strstr (str, "command_lines") == NULL;
11467   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
11468   if (str && strcmp (str, "1") == 0) return 1;
11469   str = getenv ("SKIP_TEST_COMMAND_LINES");
11470   if (str && strcmp (str, "1") == 0) return 1;
11471   return 0;
11472 }
11473
11474 static int test_command_lines_8 (void)
11475 {
11476   if (test_command_lines_8_skip ()) {
11477     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
11478     return 0;
11479   }
11480
11481   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
11482   {
11483     char device[] = "/dev/sda";
11484     int r;
11485     suppress_error = 0;
11486     r = guestfs_blockdev_setrw (g, device);
11487     if (r == -1)
11488       return -1;
11489   }
11490   {
11491     int r;
11492     suppress_error = 0;
11493     r = guestfs_umount_all (g);
11494     if (r == -1)
11495       return -1;
11496   }
11497   {
11498     int r;
11499     suppress_error = 0;
11500     r = guestfs_lvm_remove_all (g);
11501     if (r == -1)
11502       return -1;
11503   }
11504   {
11505     char device[] = "/dev/sda";
11506     char lines_0[] = ",";
11507     char *lines[] = {
11508       lines_0,
11509       NULL
11510     };
11511     int r;
11512     suppress_error = 0;
11513     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11514     if (r == -1)
11515       return -1;
11516   }
11517   {
11518     char fstype[] = "ext2";
11519     char device[] = "/dev/sda1";
11520     int r;
11521     suppress_error = 0;
11522     r = guestfs_mkfs (g, fstype, device);
11523     if (r == -1)
11524       return -1;
11525   }
11526   {
11527     char device[] = "/dev/sda1";
11528     char mountpoint[] = "/";
11529     int r;
11530     suppress_error = 0;
11531     r = guestfs_mount (g, device, mountpoint);
11532     if (r == -1)
11533       return -1;
11534   }
11535   /* TestOutputList for command_lines (8) */
11536   {
11537     char remotefilename[] = "/test-command";
11538     int r;
11539     suppress_error = 0;
11540     r = guestfs_upload (g, "test-command", remotefilename);
11541     if (r == -1)
11542       return -1;
11543   }
11544   {
11545     char path[] = "/test-command";
11546     int r;
11547     suppress_error = 0;
11548     r = guestfs_chmod (g, 493, path);
11549     if (r == -1)
11550       return -1;
11551   }
11552   {
11553     char arguments_0[] = "/test-command";
11554     char arguments_1[] = "9";
11555     char *arguments[] = {
11556       arguments_0,
11557       arguments_1,
11558       NULL
11559     };
11560     char **r;
11561     int i;
11562     suppress_error = 0;
11563     r = guestfs_command_lines (g, arguments);
11564     if (r == NULL)
11565       return -1;
11566     if (!r[0]) {
11567       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11568       print_strings (r);
11569       return -1;
11570     }
11571     {
11572       char expected[] = "";
11573       if (strcmp (r[0], expected) != 0) {
11574         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11575         return -1;
11576       }
11577     }
11578     if (!r[1]) {
11579       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11580       print_strings (r);
11581       return -1;
11582     }
11583     {
11584       char expected[] = "";
11585       if (strcmp (r[1], expected) != 0) {
11586         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11587         return -1;
11588       }
11589     }
11590     if (r[2] != NULL) {
11591       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
11592       print_strings (r);
11593       return -1;
11594     }
11595     for (i = 0; r[i] != NULL; ++i)
11596       free (r[i]);
11597     free (r);
11598   }
11599   return 0;
11600 }
11601
11602 static int test_command_lines_9_skip (void)
11603 {
11604   const char *str;
11605
11606   str = getenv ("TEST_ONLY");
11607   if (str)
11608     return strstr (str, "command_lines") == NULL;
11609   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
11610   if (str && strcmp (str, "1") == 0) return 1;
11611   str = getenv ("SKIP_TEST_COMMAND_LINES");
11612   if (str && strcmp (str, "1") == 0) return 1;
11613   return 0;
11614 }
11615
11616 static int test_command_lines_9 (void)
11617 {
11618   if (test_command_lines_9_skip ()) {
11619     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
11620     return 0;
11621   }
11622
11623   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
11624   {
11625     char device[] = "/dev/sda";
11626     int r;
11627     suppress_error = 0;
11628     r = guestfs_blockdev_setrw (g, device);
11629     if (r == -1)
11630       return -1;
11631   }
11632   {
11633     int r;
11634     suppress_error = 0;
11635     r = guestfs_umount_all (g);
11636     if (r == -1)
11637       return -1;
11638   }
11639   {
11640     int r;
11641     suppress_error = 0;
11642     r = guestfs_lvm_remove_all (g);
11643     if (r == -1)
11644       return -1;
11645   }
11646   {
11647     char device[] = "/dev/sda";
11648     char lines_0[] = ",";
11649     char *lines[] = {
11650       lines_0,
11651       NULL
11652     };
11653     int r;
11654     suppress_error = 0;
11655     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11656     if (r == -1)
11657       return -1;
11658   }
11659   {
11660     char fstype[] = "ext2";
11661     char device[] = "/dev/sda1";
11662     int r;
11663     suppress_error = 0;
11664     r = guestfs_mkfs (g, fstype, device);
11665     if (r == -1)
11666       return -1;
11667   }
11668   {
11669     char device[] = "/dev/sda1";
11670     char mountpoint[] = "/";
11671     int r;
11672     suppress_error = 0;
11673     r = guestfs_mount (g, device, mountpoint);
11674     if (r == -1)
11675       return -1;
11676   }
11677   /* TestOutputList for command_lines (9) */
11678   {
11679     char remotefilename[] = "/test-command";
11680     int r;
11681     suppress_error = 0;
11682     r = guestfs_upload (g, "test-command", remotefilename);
11683     if (r == -1)
11684       return -1;
11685   }
11686   {
11687     char path[] = "/test-command";
11688     int r;
11689     suppress_error = 0;
11690     r = guestfs_chmod (g, 493, path);
11691     if (r == -1)
11692       return -1;
11693   }
11694   {
11695     char arguments_0[] = "/test-command";
11696     char arguments_1[] = "10";
11697     char *arguments[] = {
11698       arguments_0,
11699       arguments_1,
11700       NULL
11701     };
11702     char **r;
11703     int i;
11704     suppress_error = 0;
11705     r = guestfs_command_lines (g, arguments);
11706     if (r == NULL)
11707       return -1;
11708     if (!r[0]) {
11709       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11710       print_strings (r);
11711       return -1;
11712     }
11713     {
11714       char expected[] = "Result10-1";
11715       if (strcmp (r[0], expected) != 0) {
11716         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11717         return -1;
11718       }
11719     }
11720     if (!r[1]) {
11721       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11722       print_strings (r);
11723       return -1;
11724     }
11725     {
11726       char expected[] = "Result10-2";
11727       if (strcmp (r[1], expected) != 0) {
11728         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11729         return -1;
11730       }
11731     }
11732     if (r[2] != NULL) {
11733       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11734       print_strings (r);
11735       return -1;
11736     }
11737     for (i = 0; r[i] != NULL; ++i)
11738       free (r[i]);
11739     free (r);
11740   }
11741   return 0;
11742 }
11743
11744 static int test_command_lines_10_skip (void)
11745 {
11746   const char *str;
11747
11748   str = getenv ("TEST_ONLY");
11749   if (str)
11750     return strstr (str, "command_lines") == NULL;
11751   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11752   if (str && strcmp (str, "1") == 0) return 1;
11753   str = getenv ("SKIP_TEST_COMMAND_LINES");
11754   if (str && strcmp (str, "1") == 0) return 1;
11755   return 0;
11756 }
11757
11758 static int test_command_lines_10 (void)
11759 {
11760   if (test_command_lines_10_skip ()) {
11761     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
11762     return 0;
11763   }
11764
11765   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11766   {
11767     char device[] = "/dev/sda";
11768     int r;
11769     suppress_error = 0;
11770     r = guestfs_blockdev_setrw (g, device);
11771     if (r == -1)
11772       return -1;
11773   }
11774   {
11775     int r;
11776     suppress_error = 0;
11777     r = guestfs_umount_all (g);
11778     if (r == -1)
11779       return -1;
11780   }
11781   {
11782     int r;
11783     suppress_error = 0;
11784     r = guestfs_lvm_remove_all (g);
11785     if (r == -1)
11786       return -1;
11787   }
11788   {
11789     char device[] = "/dev/sda";
11790     char lines_0[] = ",";
11791     char *lines[] = {
11792       lines_0,
11793       NULL
11794     };
11795     int r;
11796     suppress_error = 0;
11797     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11798     if (r == -1)
11799       return -1;
11800   }
11801   {
11802     char fstype[] = "ext2";
11803     char device[] = "/dev/sda1";
11804     int r;
11805     suppress_error = 0;
11806     r = guestfs_mkfs (g, fstype, device);
11807     if (r == -1)
11808       return -1;
11809   }
11810   {
11811     char device[] = "/dev/sda1";
11812     char mountpoint[] = "/";
11813     int r;
11814     suppress_error = 0;
11815     r = guestfs_mount (g, device, mountpoint);
11816     if (r == -1)
11817       return -1;
11818   }
11819   /* TestOutputList for command_lines (10) */
11820   {
11821     char remotefilename[] = "/test-command";
11822     int r;
11823     suppress_error = 0;
11824     r = guestfs_upload (g, "test-command", remotefilename);
11825     if (r == -1)
11826       return -1;
11827   }
11828   {
11829     char path[] = "/test-command";
11830     int r;
11831     suppress_error = 0;
11832     r = guestfs_chmod (g, 493, path);
11833     if (r == -1)
11834       return -1;
11835   }
11836   {
11837     char arguments_0[] = "/test-command";
11838     char arguments_1[] = "11";
11839     char *arguments[] = {
11840       arguments_0,
11841       arguments_1,
11842       NULL
11843     };
11844     char **r;
11845     int i;
11846     suppress_error = 0;
11847     r = guestfs_command_lines (g, arguments);
11848     if (r == NULL)
11849       return -1;
11850     if (!r[0]) {
11851       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11852       print_strings (r);
11853       return -1;
11854     }
11855     {
11856       char expected[] = "Result11-1";
11857       if (strcmp (r[0], expected) != 0) {
11858         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11859         return -1;
11860       }
11861     }
11862     if (!r[1]) {
11863       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11864       print_strings (r);
11865       return -1;
11866     }
11867     {
11868       char expected[] = "Result11-2";
11869       if (strcmp (r[1], expected) != 0) {
11870         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11871         return -1;
11872       }
11873     }
11874     if (r[2] != NULL) {
11875       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11876       print_strings (r);
11877       return -1;
11878     }
11879     for (i = 0; r[i] != NULL; ++i)
11880       free (r[i]);
11881     free (r);
11882   }
11883   return 0;
11884 }
11885
11886 static int test_command_0_skip (void)
11887 {
11888   const char *str;
11889
11890   str = getenv ("TEST_ONLY");
11891   if (str)
11892     return strstr (str, "command") == NULL;
11893   str = getenv ("SKIP_TEST_COMMAND_0");
11894   if (str && strcmp (str, "1") == 0) return 1;
11895   str = getenv ("SKIP_TEST_COMMAND");
11896   if (str && strcmp (str, "1") == 0) return 1;
11897   return 0;
11898 }
11899
11900 static int test_command_0 (void)
11901 {
11902   if (test_command_0_skip ()) {
11903     printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11904     return 0;
11905   }
11906
11907   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11908   {
11909     char device[] = "/dev/sda";
11910     int r;
11911     suppress_error = 0;
11912     r = guestfs_blockdev_setrw (g, device);
11913     if (r == -1)
11914       return -1;
11915   }
11916   {
11917     int r;
11918     suppress_error = 0;
11919     r = guestfs_umount_all (g);
11920     if (r == -1)
11921       return -1;
11922   }
11923   {
11924     int r;
11925     suppress_error = 0;
11926     r = guestfs_lvm_remove_all (g);
11927     if (r == -1)
11928       return -1;
11929   }
11930   {
11931     char device[] = "/dev/sda";
11932     char lines_0[] = ",";
11933     char *lines[] = {
11934       lines_0,
11935       NULL
11936     };
11937     int r;
11938     suppress_error = 0;
11939     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11940     if (r == -1)
11941       return -1;
11942   }
11943   {
11944     char fstype[] = "ext2";
11945     char device[] = "/dev/sda1";
11946     int r;
11947     suppress_error = 0;
11948     r = guestfs_mkfs (g, fstype, device);
11949     if (r == -1)
11950       return -1;
11951   }
11952   {
11953     char device[] = "/dev/sda1";
11954     char mountpoint[] = "/";
11955     int r;
11956     suppress_error = 0;
11957     r = guestfs_mount (g, device, mountpoint);
11958     if (r == -1)
11959       return -1;
11960   }
11961   /* TestOutput for command (0) */
11962   char expected[] = "Result1";
11963   {
11964     char remotefilename[] = "/test-command";
11965     int r;
11966     suppress_error = 0;
11967     r = guestfs_upload (g, "test-command", remotefilename);
11968     if (r == -1)
11969       return -1;
11970   }
11971   {
11972     char path[] = "/test-command";
11973     int r;
11974     suppress_error = 0;
11975     r = guestfs_chmod (g, 493, path);
11976     if (r == -1)
11977       return -1;
11978   }
11979   {
11980     char arguments_0[] = "/test-command";
11981     char arguments_1[] = "1";
11982     char *arguments[] = {
11983       arguments_0,
11984       arguments_1,
11985       NULL
11986     };
11987     char *r;
11988     suppress_error = 0;
11989     r = guestfs_command (g, arguments);
11990     if (r == NULL)
11991       return -1;
11992     if (strcmp (r, expected) != 0) {
11993       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11994       return -1;
11995     }
11996     free (r);
11997   }
11998   return 0;
11999 }
12000
12001 static int test_command_1_skip (void)
12002 {
12003   const char *str;
12004
12005   str = getenv ("TEST_ONLY");
12006   if (str)
12007     return strstr (str, "command") == NULL;
12008   str = getenv ("SKIP_TEST_COMMAND_1");
12009   if (str && strcmp (str, "1") == 0) return 1;
12010   str = getenv ("SKIP_TEST_COMMAND");
12011   if (str && strcmp (str, "1") == 0) return 1;
12012   return 0;
12013 }
12014
12015 static int test_command_1 (void)
12016 {
12017   if (test_command_1_skip ()) {
12018     printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
12019     return 0;
12020   }
12021
12022   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
12023   {
12024     char device[] = "/dev/sda";
12025     int r;
12026     suppress_error = 0;
12027     r = guestfs_blockdev_setrw (g, device);
12028     if (r == -1)
12029       return -1;
12030   }
12031   {
12032     int r;
12033     suppress_error = 0;
12034     r = guestfs_umount_all (g);
12035     if (r == -1)
12036       return -1;
12037   }
12038   {
12039     int r;
12040     suppress_error = 0;
12041     r = guestfs_lvm_remove_all (g);
12042     if (r == -1)
12043       return -1;
12044   }
12045   {
12046     char device[] = "/dev/sda";
12047     char lines_0[] = ",";
12048     char *lines[] = {
12049       lines_0,
12050       NULL
12051     };
12052     int r;
12053     suppress_error = 0;
12054     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12055     if (r == -1)
12056       return -1;
12057   }
12058   {
12059     char fstype[] = "ext2";
12060     char device[] = "/dev/sda1";
12061     int r;
12062     suppress_error = 0;
12063     r = guestfs_mkfs (g, fstype, device);
12064     if (r == -1)
12065       return -1;
12066   }
12067   {
12068     char device[] = "/dev/sda1";
12069     char mountpoint[] = "/";
12070     int r;
12071     suppress_error = 0;
12072     r = guestfs_mount (g, device, mountpoint);
12073     if (r == -1)
12074       return -1;
12075   }
12076   /* TestOutput for command (1) */
12077   char expected[] = "Result2\n";
12078   {
12079     char remotefilename[] = "/test-command";
12080     int r;
12081     suppress_error = 0;
12082     r = guestfs_upload (g, "test-command", remotefilename);
12083     if (r == -1)
12084       return -1;
12085   }
12086   {
12087     char path[] = "/test-command";
12088     int r;
12089     suppress_error = 0;
12090     r = guestfs_chmod (g, 493, path);
12091     if (r == -1)
12092       return -1;
12093   }
12094   {
12095     char arguments_0[] = "/test-command";
12096     char arguments_1[] = "2";
12097     char *arguments[] = {
12098       arguments_0,
12099       arguments_1,
12100       NULL
12101     };
12102     char *r;
12103     suppress_error = 0;
12104     r = guestfs_command (g, arguments);
12105     if (r == NULL)
12106       return -1;
12107     if (strcmp (r, expected) != 0) {
12108       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
12109       return -1;
12110     }
12111     free (r);
12112   }
12113   return 0;
12114 }
12115
12116 static int test_command_2_skip (void)
12117 {
12118   const char *str;
12119
12120   str = getenv ("TEST_ONLY");
12121   if (str)
12122     return strstr (str, "command") == NULL;
12123   str = getenv ("SKIP_TEST_COMMAND_2");
12124   if (str && strcmp (str, "1") == 0) return 1;
12125   str = getenv ("SKIP_TEST_COMMAND");
12126   if (str && strcmp (str, "1") == 0) return 1;
12127   return 0;
12128 }
12129
12130 static int test_command_2 (void)
12131 {
12132   if (test_command_2_skip ()) {
12133     printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
12134     return 0;
12135   }
12136
12137   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
12138   {
12139     char device[] = "/dev/sda";
12140     int r;
12141     suppress_error = 0;
12142     r = guestfs_blockdev_setrw (g, device);
12143     if (r == -1)
12144       return -1;
12145   }
12146   {
12147     int r;
12148     suppress_error = 0;
12149     r = guestfs_umount_all (g);
12150     if (r == -1)
12151       return -1;
12152   }
12153   {
12154     int r;
12155     suppress_error = 0;
12156     r = guestfs_lvm_remove_all (g);
12157     if (r == -1)
12158       return -1;
12159   }
12160   {
12161     char device[] = "/dev/sda";
12162     char lines_0[] = ",";
12163     char *lines[] = {
12164       lines_0,
12165       NULL
12166     };
12167     int r;
12168     suppress_error = 0;
12169     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12170     if (r == -1)
12171       return -1;
12172   }
12173   {
12174     char fstype[] = "ext2";
12175     char device[] = "/dev/sda1";
12176     int r;
12177     suppress_error = 0;
12178     r = guestfs_mkfs (g, fstype, device);
12179     if (r == -1)
12180       return -1;
12181   }
12182   {
12183     char device[] = "/dev/sda1";
12184     char mountpoint[] = "/";
12185     int r;
12186     suppress_error = 0;
12187     r = guestfs_mount (g, device, mountpoint);
12188     if (r == -1)
12189       return -1;
12190   }
12191   /* TestOutput for command (2) */
12192   char expected[] = "\nResult3";
12193   {
12194     char remotefilename[] = "/test-command";
12195     int r;
12196     suppress_error = 0;
12197     r = guestfs_upload (g, "test-command", remotefilename);
12198     if (r == -1)
12199       return -1;
12200   }
12201   {
12202     char path[] = "/test-command";
12203     int r;
12204     suppress_error = 0;
12205     r = guestfs_chmod (g, 493, path);
12206     if (r == -1)
12207       return -1;
12208   }
12209   {
12210     char arguments_0[] = "/test-command";
12211     char arguments_1[] = "3";
12212     char *arguments[] = {
12213       arguments_0,
12214       arguments_1,
12215       NULL
12216     };
12217     char *r;
12218     suppress_error = 0;
12219     r = guestfs_command (g, arguments);
12220     if (r == NULL)
12221       return -1;
12222     if (strcmp (r, expected) != 0) {
12223       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
12224       return -1;
12225     }
12226     free (r);
12227   }
12228   return 0;
12229 }
12230
12231 static int test_command_3_skip (void)
12232 {
12233   const char *str;
12234
12235   str = getenv ("TEST_ONLY");
12236   if (str)
12237     return strstr (str, "command") == NULL;
12238   str = getenv ("SKIP_TEST_COMMAND_3");
12239   if (str && strcmp (str, "1") == 0) return 1;
12240   str = getenv ("SKIP_TEST_COMMAND");
12241   if (str && strcmp (str, "1") == 0) return 1;
12242   return 0;
12243 }
12244
12245 static int test_command_3 (void)
12246 {
12247   if (test_command_3_skip ()) {
12248     printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
12249     return 0;
12250   }
12251
12252   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
12253   {
12254     char device[] = "/dev/sda";
12255     int r;
12256     suppress_error = 0;
12257     r = guestfs_blockdev_setrw (g, device);
12258     if (r == -1)
12259       return -1;
12260   }
12261   {
12262     int r;
12263     suppress_error = 0;
12264     r = guestfs_umount_all (g);
12265     if (r == -1)
12266       return -1;
12267   }
12268   {
12269     int r;
12270     suppress_error = 0;
12271     r = guestfs_lvm_remove_all (g);
12272     if (r == -1)
12273       return -1;
12274   }
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   /* TestOutput for command (3) */
12307   char expected[] = "\nResult4\n";
12308   {
12309     char remotefilename[] = "/test-command";
12310     int r;
12311     suppress_error = 0;
12312     r = guestfs_upload (g, "test-command", remotefilename);
12313     if (r == -1)
12314       return -1;
12315   }
12316   {
12317     char path[] = "/test-command";
12318     int r;
12319     suppress_error = 0;
12320     r = guestfs_chmod (g, 493, path);
12321     if (r == -1)
12322       return -1;
12323   }
12324   {
12325     char arguments_0[] = "/test-command";
12326     char arguments_1[] = "4";
12327     char *arguments[] = {
12328       arguments_0,
12329       arguments_1,
12330       NULL
12331     };
12332     char *r;
12333     suppress_error = 0;
12334     r = guestfs_command (g, arguments);
12335     if (r == NULL)
12336       return -1;
12337     if (strcmp (r, expected) != 0) {
12338       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
12339       return -1;
12340     }
12341     free (r);
12342   }
12343   return 0;
12344 }
12345
12346 static int test_command_4_skip (void)
12347 {
12348   const char *str;
12349
12350   str = getenv ("TEST_ONLY");
12351   if (str)
12352     return strstr (str, "command") == NULL;
12353   str = getenv ("SKIP_TEST_COMMAND_4");
12354   if (str && strcmp (str, "1") == 0) return 1;
12355   str = getenv ("SKIP_TEST_COMMAND");
12356   if (str && strcmp (str, "1") == 0) return 1;
12357   return 0;
12358 }
12359
12360 static int test_command_4 (void)
12361 {
12362   if (test_command_4_skip ()) {
12363     printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
12364     return 0;
12365   }
12366
12367   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
12368   {
12369     char device[] = "/dev/sda";
12370     int r;
12371     suppress_error = 0;
12372     r = guestfs_blockdev_setrw (g, device);
12373     if (r == -1)
12374       return -1;
12375   }
12376   {
12377     int r;
12378     suppress_error = 0;
12379     r = guestfs_umount_all (g);
12380     if (r == -1)
12381       return -1;
12382   }
12383   {
12384     int r;
12385     suppress_error = 0;
12386     r = guestfs_lvm_remove_all (g);
12387     if (r == -1)
12388       return -1;
12389   }
12390   {
12391     char device[] = "/dev/sda";
12392     char lines_0[] = ",";
12393     char *lines[] = {
12394       lines_0,
12395       NULL
12396     };
12397     int r;
12398     suppress_error = 0;
12399     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12400     if (r == -1)
12401       return -1;
12402   }
12403   {
12404     char fstype[] = "ext2";
12405     char device[] = "/dev/sda1";
12406     int r;
12407     suppress_error = 0;
12408     r = guestfs_mkfs (g, fstype, device);
12409     if (r == -1)
12410       return -1;
12411   }
12412   {
12413     char device[] = "/dev/sda1";
12414     char mountpoint[] = "/";
12415     int r;
12416     suppress_error = 0;
12417     r = guestfs_mount (g, device, mountpoint);
12418     if (r == -1)
12419       return -1;
12420   }
12421   /* TestOutput for command (4) */
12422   char expected[] = "\nResult5\n\n";
12423   {
12424     char remotefilename[] = "/test-command";
12425     int r;
12426     suppress_error = 0;
12427     r = guestfs_upload (g, "test-command", remotefilename);
12428     if (r == -1)
12429       return -1;
12430   }
12431   {
12432     char path[] = "/test-command";
12433     int r;
12434     suppress_error = 0;
12435     r = guestfs_chmod (g, 493, path);
12436     if (r == -1)
12437       return -1;
12438   }
12439   {
12440     char arguments_0[] = "/test-command";
12441     char arguments_1[] = "5";
12442     char *arguments[] = {
12443       arguments_0,
12444       arguments_1,
12445       NULL
12446     };
12447     char *r;
12448     suppress_error = 0;
12449     r = guestfs_command (g, arguments);
12450     if (r == NULL)
12451       return -1;
12452     if (strcmp (r, expected) != 0) {
12453       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
12454       return -1;
12455     }
12456     free (r);
12457   }
12458   return 0;
12459 }
12460
12461 static int test_command_5_skip (void)
12462 {
12463   const char *str;
12464
12465   str = getenv ("TEST_ONLY");
12466   if (str)
12467     return strstr (str, "command") == NULL;
12468   str = getenv ("SKIP_TEST_COMMAND_5");
12469   if (str && strcmp (str, "1") == 0) return 1;
12470   str = getenv ("SKIP_TEST_COMMAND");
12471   if (str && strcmp (str, "1") == 0) return 1;
12472   return 0;
12473 }
12474
12475 static int test_command_5 (void)
12476 {
12477   if (test_command_5_skip ()) {
12478     printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
12479     return 0;
12480   }
12481
12482   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
12483   {
12484     char device[] = "/dev/sda";
12485     int r;
12486     suppress_error = 0;
12487     r = guestfs_blockdev_setrw (g, device);
12488     if (r == -1)
12489       return -1;
12490   }
12491   {
12492     int r;
12493     suppress_error = 0;
12494     r = guestfs_umount_all (g);
12495     if (r == -1)
12496       return -1;
12497   }
12498   {
12499     int r;
12500     suppress_error = 0;
12501     r = guestfs_lvm_remove_all (g);
12502     if (r == -1)
12503       return -1;
12504   }
12505   {
12506     char device[] = "/dev/sda";
12507     char lines_0[] = ",";
12508     char *lines[] = {
12509       lines_0,
12510       NULL
12511     };
12512     int r;
12513     suppress_error = 0;
12514     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12515     if (r == -1)
12516       return -1;
12517   }
12518   {
12519     char fstype[] = "ext2";
12520     char device[] = "/dev/sda1";
12521     int r;
12522     suppress_error = 0;
12523     r = guestfs_mkfs (g, fstype, device);
12524     if (r == -1)
12525       return -1;
12526   }
12527   {
12528     char device[] = "/dev/sda1";
12529     char mountpoint[] = "/";
12530     int r;
12531     suppress_error = 0;
12532     r = guestfs_mount (g, device, mountpoint);
12533     if (r == -1)
12534       return -1;
12535   }
12536   /* TestOutput for command (5) */
12537   char expected[] = "\n\nResult6\n\n";
12538   {
12539     char remotefilename[] = "/test-command";
12540     int r;
12541     suppress_error = 0;
12542     r = guestfs_upload (g, "test-command", remotefilename);
12543     if (r == -1)
12544       return -1;
12545   }
12546   {
12547     char path[] = "/test-command";
12548     int r;
12549     suppress_error = 0;
12550     r = guestfs_chmod (g, 493, path);
12551     if (r == -1)
12552       return -1;
12553   }
12554   {
12555     char arguments_0[] = "/test-command";
12556     char arguments_1[] = "6";
12557     char *arguments[] = {
12558       arguments_0,
12559       arguments_1,
12560       NULL
12561     };
12562     char *r;
12563     suppress_error = 0;
12564     r = guestfs_command (g, arguments);
12565     if (r == NULL)
12566       return -1;
12567     if (strcmp (r, expected) != 0) {
12568       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
12569       return -1;
12570     }
12571     free (r);
12572   }
12573   return 0;
12574 }
12575
12576 static int test_command_6_skip (void)
12577 {
12578   const char *str;
12579
12580   str = getenv ("TEST_ONLY");
12581   if (str)
12582     return strstr (str, "command") == NULL;
12583   str = getenv ("SKIP_TEST_COMMAND_6");
12584   if (str && strcmp (str, "1") == 0) return 1;
12585   str = getenv ("SKIP_TEST_COMMAND");
12586   if (str && strcmp (str, "1") == 0) return 1;
12587   return 0;
12588 }
12589
12590 static int test_command_6 (void)
12591 {
12592   if (test_command_6_skip ()) {
12593     printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
12594     return 0;
12595   }
12596
12597   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
12598   {
12599     char device[] = "/dev/sda";
12600     int r;
12601     suppress_error = 0;
12602     r = guestfs_blockdev_setrw (g, device);
12603     if (r == -1)
12604       return -1;
12605   }
12606   {
12607     int r;
12608     suppress_error = 0;
12609     r = guestfs_umount_all (g);
12610     if (r == -1)
12611       return -1;
12612   }
12613   {
12614     int r;
12615     suppress_error = 0;
12616     r = guestfs_lvm_remove_all (g);
12617     if (r == -1)
12618       return -1;
12619   }
12620   {
12621     char device[] = "/dev/sda";
12622     char lines_0[] = ",";
12623     char *lines[] = {
12624       lines_0,
12625       NULL
12626     };
12627     int r;
12628     suppress_error = 0;
12629     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12630     if (r == -1)
12631       return -1;
12632   }
12633   {
12634     char fstype[] = "ext2";
12635     char device[] = "/dev/sda1";
12636     int r;
12637     suppress_error = 0;
12638     r = guestfs_mkfs (g, fstype, device);
12639     if (r == -1)
12640       return -1;
12641   }
12642   {
12643     char device[] = "/dev/sda1";
12644     char mountpoint[] = "/";
12645     int r;
12646     suppress_error = 0;
12647     r = guestfs_mount (g, device, mountpoint);
12648     if (r == -1)
12649       return -1;
12650   }
12651   /* TestOutput for command (6) */
12652   char expected[] = "";
12653   {
12654     char remotefilename[] = "/test-command";
12655     int r;
12656     suppress_error = 0;
12657     r = guestfs_upload (g, "test-command", remotefilename);
12658     if (r == -1)
12659       return -1;
12660   }
12661   {
12662     char path[] = "/test-command";
12663     int r;
12664     suppress_error = 0;
12665     r = guestfs_chmod (g, 493, path);
12666     if (r == -1)
12667       return -1;
12668   }
12669   {
12670     char arguments_0[] = "/test-command";
12671     char arguments_1[] = "7";
12672     char *arguments[] = {
12673       arguments_0,
12674       arguments_1,
12675       NULL
12676     };
12677     char *r;
12678     suppress_error = 0;
12679     r = guestfs_command (g, arguments);
12680     if (r == NULL)
12681       return -1;
12682     if (strcmp (r, expected) != 0) {
12683       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
12684       return -1;
12685     }
12686     free (r);
12687   }
12688   return 0;
12689 }
12690
12691 static int test_command_7_skip (void)
12692 {
12693   const char *str;
12694
12695   str = getenv ("TEST_ONLY");
12696   if (str)
12697     return strstr (str, "command") == NULL;
12698   str = getenv ("SKIP_TEST_COMMAND_7");
12699   if (str && strcmp (str, "1") == 0) return 1;
12700   str = getenv ("SKIP_TEST_COMMAND");
12701   if (str && strcmp (str, "1") == 0) return 1;
12702   return 0;
12703 }
12704
12705 static int test_command_7 (void)
12706 {
12707   if (test_command_7_skip ()) {
12708     printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
12709     return 0;
12710   }
12711
12712   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
12713   {
12714     char device[] = "/dev/sda";
12715     int r;
12716     suppress_error = 0;
12717     r = guestfs_blockdev_setrw (g, device);
12718     if (r == -1)
12719       return -1;
12720   }
12721   {
12722     int r;
12723     suppress_error = 0;
12724     r = guestfs_umount_all (g);
12725     if (r == -1)
12726       return -1;
12727   }
12728   {
12729     int r;
12730     suppress_error = 0;
12731     r = guestfs_lvm_remove_all (g);
12732     if (r == -1)
12733       return -1;
12734   }
12735   {
12736     char device[] = "/dev/sda";
12737     char lines_0[] = ",";
12738     char *lines[] = {
12739       lines_0,
12740       NULL
12741     };
12742     int r;
12743     suppress_error = 0;
12744     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12745     if (r == -1)
12746       return -1;
12747   }
12748   {
12749     char fstype[] = "ext2";
12750     char device[] = "/dev/sda1";
12751     int r;
12752     suppress_error = 0;
12753     r = guestfs_mkfs (g, fstype, device);
12754     if (r == -1)
12755       return -1;
12756   }
12757   {
12758     char device[] = "/dev/sda1";
12759     char mountpoint[] = "/";
12760     int r;
12761     suppress_error = 0;
12762     r = guestfs_mount (g, device, mountpoint);
12763     if (r == -1)
12764       return -1;
12765   }
12766   /* TestOutput for command (7) */
12767   char expected[] = "\n";
12768   {
12769     char remotefilename[] = "/test-command";
12770     int r;
12771     suppress_error = 0;
12772     r = guestfs_upload (g, "test-command", remotefilename);
12773     if (r == -1)
12774       return -1;
12775   }
12776   {
12777     char path[] = "/test-command";
12778     int r;
12779     suppress_error = 0;
12780     r = guestfs_chmod (g, 493, path);
12781     if (r == -1)
12782       return -1;
12783   }
12784   {
12785     char arguments_0[] = "/test-command";
12786     char arguments_1[] = "8";
12787     char *arguments[] = {
12788       arguments_0,
12789       arguments_1,
12790       NULL
12791     };
12792     char *r;
12793     suppress_error = 0;
12794     r = guestfs_command (g, arguments);
12795     if (r == NULL)
12796       return -1;
12797     if (strcmp (r, expected) != 0) {
12798       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12799       return -1;
12800     }
12801     free (r);
12802   }
12803   return 0;
12804 }
12805
12806 static int test_command_8_skip (void)
12807 {
12808   const char *str;
12809
12810   str = getenv ("TEST_ONLY");
12811   if (str)
12812     return strstr (str, "command") == NULL;
12813   str = getenv ("SKIP_TEST_COMMAND_8");
12814   if (str && strcmp (str, "1") == 0) return 1;
12815   str = getenv ("SKIP_TEST_COMMAND");
12816   if (str && strcmp (str, "1") == 0) return 1;
12817   return 0;
12818 }
12819
12820 static int test_command_8 (void)
12821 {
12822   if (test_command_8_skip ()) {
12823     printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
12824     return 0;
12825   }
12826
12827   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12828   {
12829     char device[] = "/dev/sda";
12830     int r;
12831     suppress_error = 0;
12832     r = guestfs_blockdev_setrw (g, device);
12833     if (r == -1)
12834       return -1;
12835   }
12836   {
12837     int r;
12838     suppress_error = 0;
12839     r = guestfs_umount_all (g);
12840     if (r == -1)
12841       return -1;
12842   }
12843   {
12844     int r;
12845     suppress_error = 0;
12846     r = guestfs_lvm_remove_all (g);
12847     if (r == -1)
12848       return -1;
12849   }
12850   {
12851     char device[] = "/dev/sda";
12852     char lines_0[] = ",";
12853     char *lines[] = {
12854       lines_0,
12855       NULL
12856     };
12857     int r;
12858     suppress_error = 0;
12859     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12860     if (r == -1)
12861       return -1;
12862   }
12863   {
12864     char fstype[] = "ext2";
12865     char device[] = "/dev/sda1";
12866     int r;
12867     suppress_error = 0;
12868     r = guestfs_mkfs (g, fstype, device);
12869     if (r == -1)
12870       return -1;
12871   }
12872   {
12873     char device[] = "/dev/sda1";
12874     char mountpoint[] = "/";
12875     int r;
12876     suppress_error = 0;
12877     r = guestfs_mount (g, device, mountpoint);
12878     if (r == -1)
12879       return -1;
12880   }
12881   /* TestOutput for command (8) */
12882   char expected[] = "\n\n";
12883   {
12884     char remotefilename[] = "/test-command";
12885     int r;
12886     suppress_error = 0;
12887     r = guestfs_upload (g, "test-command", remotefilename);
12888     if (r == -1)
12889       return -1;
12890   }
12891   {
12892     char path[] = "/test-command";
12893     int r;
12894     suppress_error = 0;
12895     r = guestfs_chmod (g, 493, path);
12896     if (r == -1)
12897       return -1;
12898   }
12899   {
12900     char arguments_0[] = "/test-command";
12901     char arguments_1[] = "9";
12902     char *arguments[] = {
12903       arguments_0,
12904       arguments_1,
12905       NULL
12906     };
12907     char *r;
12908     suppress_error = 0;
12909     r = guestfs_command (g, arguments);
12910     if (r == NULL)
12911       return -1;
12912     if (strcmp (r, expected) != 0) {
12913       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12914       return -1;
12915     }
12916     free (r);
12917   }
12918   return 0;
12919 }
12920
12921 static int test_command_9_skip (void)
12922 {
12923   const char *str;
12924
12925   str = getenv ("TEST_ONLY");
12926   if (str)
12927     return strstr (str, "command") == NULL;
12928   str = getenv ("SKIP_TEST_COMMAND_9");
12929   if (str && strcmp (str, "1") == 0) return 1;
12930   str = getenv ("SKIP_TEST_COMMAND");
12931   if (str && strcmp (str, "1") == 0) return 1;
12932   return 0;
12933 }
12934
12935 static int test_command_9 (void)
12936 {
12937   if (test_command_9_skip ()) {
12938     printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12939     return 0;
12940   }
12941
12942   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12943   {
12944     char device[] = "/dev/sda";
12945     int r;
12946     suppress_error = 0;
12947     r = guestfs_blockdev_setrw (g, device);
12948     if (r == -1)
12949       return -1;
12950   }
12951   {
12952     int r;
12953     suppress_error = 0;
12954     r = guestfs_umount_all (g);
12955     if (r == -1)
12956       return -1;
12957   }
12958   {
12959     int r;
12960     suppress_error = 0;
12961     r = guestfs_lvm_remove_all (g);
12962     if (r == -1)
12963       return -1;
12964   }
12965   {
12966     char device[] = "/dev/sda";
12967     char lines_0[] = ",";
12968     char *lines[] = {
12969       lines_0,
12970       NULL
12971     };
12972     int r;
12973     suppress_error = 0;
12974     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12975     if (r == -1)
12976       return -1;
12977   }
12978   {
12979     char fstype[] = "ext2";
12980     char device[] = "/dev/sda1";
12981     int r;
12982     suppress_error = 0;
12983     r = guestfs_mkfs (g, fstype, device);
12984     if (r == -1)
12985       return -1;
12986   }
12987   {
12988     char device[] = "/dev/sda1";
12989     char mountpoint[] = "/";
12990     int r;
12991     suppress_error = 0;
12992     r = guestfs_mount (g, device, mountpoint);
12993     if (r == -1)
12994       return -1;
12995   }
12996   /* TestOutput for command (9) */
12997   char expected[] = "Result10-1\nResult10-2\n";
12998   {
12999     char remotefilename[] = "/test-command";
13000     int r;
13001     suppress_error = 0;
13002     r = guestfs_upload (g, "test-command", remotefilename);
13003     if (r == -1)
13004       return -1;
13005   }
13006   {
13007     char path[] = "/test-command";
13008     int r;
13009     suppress_error = 0;
13010     r = guestfs_chmod (g, 493, path);
13011     if (r == -1)
13012       return -1;
13013   }
13014   {
13015     char arguments_0[] = "/test-command";
13016     char arguments_1[] = "10";
13017     char *arguments[] = {
13018       arguments_0,
13019       arguments_1,
13020       NULL
13021     };
13022     char *r;
13023     suppress_error = 0;
13024     r = guestfs_command (g, arguments);
13025     if (r == NULL)
13026       return -1;
13027     if (strcmp (r, expected) != 0) {
13028       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
13029       return -1;
13030     }
13031     free (r);
13032   }
13033   return 0;
13034 }
13035
13036 static int test_command_10_skip (void)
13037 {
13038   const char *str;
13039
13040   str = getenv ("TEST_ONLY");
13041   if (str)
13042     return strstr (str, "command") == NULL;
13043   str = getenv ("SKIP_TEST_COMMAND_10");
13044   if (str && strcmp (str, "1") == 0) return 1;
13045   str = getenv ("SKIP_TEST_COMMAND");
13046   if (str && strcmp (str, "1") == 0) return 1;
13047   return 0;
13048 }
13049
13050 static int test_command_10 (void)
13051 {
13052   if (test_command_10_skip ()) {
13053     printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
13054     return 0;
13055   }
13056
13057   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
13058   {
13059     char device[] = "/dev/sda";
13060     int r;
13061     suppress_error = 0;
13062     r = guestfs_blockdev_setrw (g, device);
13063     if (r == -1)
13064       return -1;
13065   }
13066   {
13067     int r;
13068     suppress_error = 0;
13069     r = guestfs_umount_all (g);
13070     if (r == -1)
13071       return -1;
13072   }
13073   {
13074     int r;
13075     suppress_error = 0;
13076     r = guestfs_lvm_remove_all (g);
13077     if (r == -1)
13078       return -1;
13079   }
13080   {
13081     char device[] = "/dev/sda";
13082     char lines_0[] = ",";
13083     char *lines[] = {
13084       lines_0,
13085       NULL
13086     };
13087     int r;
13088     suppress_error = 0;
13089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13090     if (r == -1)
13091       return -1;
13092   }
13093   {
13094     char fstype[] = "ext2";
13095     char device[] = "/dev/sda1";
13096     int r;
13097     suppress_error = 0;
13098     r = guestfs_mkfs (g, fstype, device);
13099     if (r == -1)
13100       return -1;
13101   }
13102   {
13103     char device[] = "/dev/sda1";
13104     char mountpoint[] = "/";
13105     int r;
13106     suppress_error = 0;
13107     r = guestfs_mount (g, device, mountpoint);
13108     if (r == -1)
13109       return -1;
13110   }
13111   /* TestOutput for command (10) */
13112   char expected[] = "Result11-1\nResult11-2";
13113   {
13114     char remotefilename[] = "/test-command";
13115     int r;
13116     suppress_error = 0;
13117     r = guestfs_upload (g, "test-command", remotefilename);
13118     if (r == -1)
13119       return -1;
13120   }
13121   {
13122     char path[] = "/test-command";
13123     int r;
13124     suppress_error = 0;
13125     r = guestfs_chmod (g, 493, path);
13126     if (r == -1)
13127       return -1;
13128   }
13129   {
13130     char arguments_0[] = "/test-command";
13131     char arguments_1[] = "11";
13132     char *arguments[] = {
13133       arguments_0,
13134       arguments_1,
13135       NULL
13136     };
13137     char *r;
13138     suppress_error = 0;
13139     r = guestfs_command (g, arguments);
13140     if (r == NULL)
13141       return -1;
13142     if (strcmp (r, expected) != 0) {
13143       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
13144       return -1;
13145     }
13146     free (r);
13147   }
13148   return 0;
13149 }
13150
13151 static int test_command_11_skip (void)
13152 {
13153   const char *str;
13154
13155   str = getenv ("TEST_ONLY");
13156   if (str)
13157     return strstr (str, "command") == NULL;
13158   str = getenv ("SKIP_TEST_COMMAND_11");
13159   if (str && strcmp (str, "1") == 0) return 1;
13160   str = getenv ("SKIP_TEST_COMMAND");
13161   if (str && strcmp (str, "1") == 0) return 1;
13162   return 0;
13163 }
13164
13165 static int test_command_11 (void)
13166 {
13167   if (test_command_11_skip ()) {
13168     printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
13169     return 0;
13170   }
13171
13172   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
13173   {
13174     char device[] = "/dev/sda";
13175     int r;
13176     suppress_error = 0;
13177     r = guestfs_blockdev_setrw (g, device);
13178     if (r == -1)
13179       return -1;
13180   }
13181   {
13182     int r;
13183     suppress_error = 0;
13184     r = guestfs_umount_all (g);
13185     if (r == -1)
13186       return -1;
13187   }
13188   {
13189     int r;
13190     suppress_error = 0;
13191     r = guestfs_lvm_remove_all (g);
13192     if (r == -1)
13193       return -1;
13194   }
13195   {
13196     char device[] = "/dev/sda";
13197     char lines_0[] = ",";
13198     char *lines[] = {
13199       lines_0,
13200       NULL
13201     };
13202     int r;
13203     suppress_error = 0;
13204     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13205     if (r == -1)
13206       return -1;
13207   }
13208   {
13209     char fstype[] = "ext2";
13210     char device[] = "/dev/sda1";
13211     int r;
13212     suppress_error = 0;
13213     r = guestfs_mkfs (g, fstype, device);
13214     if (r == -1)
13215       return -1;
13216   }
13217   {
13218     char device[] = "/dev/sda1";
13219     char mountpoint[] = "/";
13220     int r;
13221     suppress_error = 0;
13222     r = guestfs_mount (g, device, mountpoint);
13223     if (r == -1)
13224       return -1;
13225   }
13226   /* TestLastFail for command (11) */
13227   {
13228     char remotefilename[] = "/test-command";
13229     int r;
13230     suppress_error = 0;
13231     r = guestfs_upload (g, "test-command", remotefilename);
13232     if (r == -1)
13233       return -1;
13234   }
13235   {
13236     char path[] = "/test-command";
13237     int r;
13238     suppress_error = 0;
13239     r = guestfs_chmod (g, 493, path);
13240     if (r == -1)
13241       return -1;
13242   }
13243   {
13244     char arguments_0[] = "/test-command";
13245     char *arguments[] = {
13246       arguments_0,
13247       NULL
13248     };
13249     char *r;
13250     suppress_error = 1;
13251     r = guestfs_command (g, arguments);
13252     if (r != NULL)
13253       return -1;
13254     free (r);
13255   }
13256   return 0;
13257 }
13258
13259 static int test_file_0_skip (void)
13260 {
13261   const char *str;
13262
13263   str = getenv ("TEST_ONLY");
13264   if (str)
13265     return strstr (str, "file") == NULL;
13266   str = getenv ("SKIP_TEST_FILE_0");
13267   if (str && strcmp (str, "1") == 0) return 1;
13268   str = getenv ("SKIP_TEST_FILE");
13269   if (str && strcmp (str, "1") == 0) return 1;
13270   return 0;
13271 }
13272
13273 static int test_file_0 (void)
13274 {
13275   if (test_file_0_skip ()) {
13276     printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
13277     return 0;
13278   }
13279
13280   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
13281   {
13282     char device[] = "/dev/sda";
13283     int r;
13284     suppress_error = 0;
13285     r = guestfs_blockdev_setrw (g, device);
13286     if (r == -1)
13287       return -1;
13288   }
13289   {
13290     int r;
13291     suppress_error = 0;
13292     r = guestfs_umount_all (g);
13293     if (r == -1)
13294       return -1;
13295   }
13296   {
13297     int r;
13298     suppress_error = 0;
13299     r = guestfs_lvm_remove_all (g);
13300     if (r == -1)
13301       return -1;
13302   }
13303   {
13304     char device[] = "/dev/sda";
13305     char lines_0[] = ",";
13306     char *lines[] = {
13307       lines_0,
13308       NULL
13309     };
13310     int r;
13311     suppress_error = 0;
13312     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13313     if (r == -1)
13314       return -1;
13315   }
13316   {
13317     char fstype[] = "ext2";
13318     char device[] = "/dev/sda1";
13319     int r;
13320     suppress_error = 0;
13321     r = guestfs_mkfs (g, fstype, device);
13322     if (r == -1)
13323       return -1;
13324   }
13325   {
13326     char device[] = "/dev/sda1";
13327     char mountpoint[] = "/";
13328     int r;
13329     suppress_error = 0;
13330     r = guestfs_mount (g, device, mountpoint);
13331     if (r == -1)
13332       return -1;
13333   }
13334   /* TestOutput for file (0) */
13335   char expected[] = "empty";
13336   {
13337     char path[] = "/new";
13338     int r;
13339     suppress_error = 0;
13340     r = guestfs_touch (g, path);
13341     if (r == -1)
13342       return -1;
13343   }
13344   {
13345     char path[] = "/new";
13346     char *r;
13347     suppress_error = 0;
13348     r = guestfs_file (g, path);
13349     if (r == NULL)
13350       return -1;
13351     if (strcmp (r, expected) != 0) {
13352       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13353       return -1;
13354     }
13355     free (r);
13356   }
13357   return 0;
13358 }
13359
13360 static int test_file_1_skip (void)
13361 {
13362   const char *str;
13363
13364   str = getenv ("TEST_ONLY");
13365   if (str)
13366     return strstr (str, "file") == NULL;
13367   str = getenv ("SKIP_TEST_FILE_1");
13368   if (str && strcmp (str, "1") == 0) return 1;
13369   str = getenv ("SKIP_TEST_FILE");
13370   if (str && strcmp (str, "1") == 0) return 1;
13371   return 0;
13372 }
13373
13374 static int test_file_1 (void)
13375 {
13376   if (test_file_1_skip ()) {
13377     printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
13378     return 0;
13379   }
13380
13381   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
13382   {
13383     char device[] = "/dev/sda";
13384     int r;
13385     suppress_error = 0;
13386     r = guestfs_blockdev_setrw (g, device);
13387     if (r == -1)
13388       return -1;
13389   }
13390   {
13391     int r;
13392     suppress_error = 0;
13393     r = guestfs_umount_all (g);
13394     if (r == -1)
13395       return -1;
13396   }
13397   {
13398     int r;
13399     suppress_error = 0;
13400     r = guestfs_lvm_remove_all (g);
13401     if (r == -1)
13402       return -1;
13403   }
13404   {
13405     char device[] = "/dev/sda";
13406     char lines_0[] = ",";
13407     char *lines[] = {
13408       lines_0,
13409       NULL
13410     };
13411     int r;
13412     suppress_error = 0;
13413     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13414     if (r == -1)
13415       return -1;
13416   }
13417   {
13418     char fstype[] = "ext2";
13419     char device[] = "/dev/sda1";
13420     int r;
13421     suppress_error = 0;
13422     r = guestfs_mkfs (g, fstype, device);
13423     if (r == -1)
13424       return -1;
13425   }
13426   {
13427     char device[] = "/dev/sda1";
13428     char mountpoint[] = "/";
13429     int r;
13430     suppress_error = 0;
13431     r = guestfs_mount (g, device, mountpoint);
13432     if (r == -1)
13433       return -1;
13434   }
13435   /* TestOutput for file (1) */
13436   char expected[] = "ASCII text";
13437   {
13438     char path[] = "/new";
13439     char content[] = "some content\n";
13440     int r;
13441     suppress_error = 0;
13442     r = guestfs_write_file (g, path, content, 0);
13443     if (r == -1)
13444       return -1;
13445   }
13446   {
13447     char path[] = "/new";
13448     char *r;
13449     suppress_error = 0;
13450     r = guestfs_file (g, path);
13451     if (r == NULL)
13452       return -1;
13453     if (strcmp (r, expected) != 0) {
13454       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13455       return -1;
13456     }
13457     free (r);
13458   }
13459   return 0;
13460 }
13461
13462 static int test_file_2_skip (void)
13463 {
13464   const char *str;
13465
13466   str = getenv ("TEST_ONLY");
13467   if (str)
13468     return strstr (str, "file") == NULL;
13469   str = getenv ("SKIP_TEST_FILE_2");
13470   if (str && strcmp (str, "1") == 0) return 1;
13471   str = getenv ("SKIP_TEST_FILE");
13472   if (str && strcmp (str, "1") == 0) return 1;
13473   return 0;
13474 }
13475
13476 static int test_file_2 (void)
13477 {
13478   if (test_file_2_skip ()) {
13479     printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
13480     return 0;
13481   }
13482
13483   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
13484   {
13485     char device[] = "/dev/sda";
13486     int r;
13487     suppress_error = 0;
13488     r = guestfs_blockdev_setrw (g, device);
13489     if (r == -1)
13490       return -1;
13491   }
13492   {
13493     int r;
13494     suppress_error = 0;
13495     r = guestfs_umount_all (g);
13496     if (r == -1)
13497       return -1;
13498   }
13499   {
13500     int r;
13501     suppress_error = 0;
13502     r = guestfs_lvm_remove_all (g);
13503     if (r == -1)
13504       return -1;
13505   }
13506   {
13507     char device[] = "/dev/sda";
13508     char lines_0[] = ",";
13509     char *lines[] = {
13510       lines_0,
13511       NULL
13512     };
13513     int r;
13514     suppress_error = 0;
13515     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13516     if (r == -1)
13517       return -1;
13518   }
13519   {
13520     char fstype[] = "ext2";
13521     char device[] = "/dev/sda1";
13522     int r;
13523     suppress_error = 0;
13524     r = guestfs_mkfs (g, fstype, device);
13525     if (r == -1)
13526       return -1;
13527   }
13528   {
13529     char device[] = "/dev/sda1";
13530     char mountpoint[] = "/";
13531     int r;
13532     suppress_error = 0;
13533     r = guestfs_mount (g, device, mountpoint);
13534     if (r == -1)
13535       return -1;
13536   }
13537   /* TestLastFail for file (2) */
13538   {
13539     char path[] = "/nofile";
13540     char *r;
13541     suppress_error = 1;
13542     r = guestfs_file (g, path);
13543     if (r != NULL)
13544       return -1;
13545     free (r);
13546   }
13547   return 0;
13548 }
13549
13550 static int test_umount_all_0_skip (void)
13551 {
13552   const char *str;
13553
13554   str = getenv ("TEST_ONLY");
13555   if (str)
13556     return strstr (str, "umount_all") == NULL;
13557   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
13558   if (str && strcmp (str, "1") == 0) return 1;
13559   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13560   if (str && strcmp (str, "1") == 0) return 1;
13561   return 0;
13562 }
13563
13564 static int test_umount_all_0 (void)
13565 {
13566   if (test_umount_all_0_skip ()) {
13567     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
13568     return 0;
13569   }
13570
13571   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
13572   {
13573     char device[] = "/dev/sda";
13574     int r;
13575     suppress_error = 0;
13576     r = guestfs_blockdev_setrw (g, device);
13577     if (r == -1)
13578       return -1;
13579   }
13580   {
13581     int r;
13582     suppress_error = 0;
13583     r = guestfs_umount_all (g);
13584     if (r == -1)
13585       return -1;
13586   }
13587   {
13588     int r;
13589     suppress_error = 0;
13590     r = guestfs_lvm_remove_all (g);
13591     if (r == -1)
13592       return -1;
13593   }
13594   {
13595     char device[] = "/dev/sda";
13596     char lines_0[] = ",";
13597     char *lines[] = {
13598       lines_0,
13599       NULL
13600     };
13601     int r;
13602     suppress_error = 0;
13603     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13604     if (r == -1)
13605       return -1;
13606   }
13607   {
13608     char fstype[] = "ext2";
13609     char device[] = "/dev/sda1";
13610     int r;
13611     suppress_error = 0;
13612     r = guestfs_mkfs (g, fstype, device);
13613     if (r == -1)
13614       return -1;
13615   }
13616   {
13617     char device[] = "/dev/sda1";
13618     char mountpoint[] = "/";
13619     int r;
13620     suppress_error = 0;
13621     r = guestfs_mount (g, device, mountpoint);
13622     if (r == -1)
13623       return -1;
13624   }
13625   /* TestOutputList for umount_all (0) */
13626   {
13627     int r;
13628     suppress_error = 0;
13629     r = guestfs_umount_all (g);
13630     if (r == -1)
13631       return -1;
13632   }
13633   {
13634     char **r;
13635     int i;
13636     suppress_error = 0;
13637     r = guestfs_mounts (g);
13638     if (r == NULL)
13639       return -1;
13640     if (r[0] != NULL) {
13641       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
13642       print_strings (r);
13643       return -1;
13644     }
13645     for (i = 0; r[i] != NULL; ++i)
13646       free (r[i]);
13647     free (r);
13648   }
13649   return 0;
13650 }
13651
13652 static int test_umount_all_1_skip (void)
13653 {
13654   const char *str;
13655
13656   str = getenv ("TEST_ONLY");
13657   if (str)
13658     return strstr (str, "umount_all") == NULL;
13659   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
13660   if (str && strcmp (str, "1") == 0) return 1;
13661   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13662   if (str && strcmp (str, "1") == 0) return 1;
13663   return 0;
13664 }
13665
13666 static int test_umount_all_1 (void)
13667 {
13668   if (test_umount_all_1_skip ()) {
13669     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
13670     return 0;
13671   }
13672
13673   /* InitNone|InitEmpty for test_umount_all_1 */
13674   {
13675     char device[] = "/dev/sda";
13676     int r;
13677     suppress_error = 0;
13678     r = guestfs_blockdev_setrw (g, device);
13679     if (r == -1)
13680       return -1;
13681   }
13682   {
13683     int r;
13684     suppress_error = 0;
13685     r = guestfs_umount_all (g);
13686     if (r == -1)
13687       return -1;
13688   }
13689   {
13690     int r;
13691     suppress_error = 0;
13692     r = guestfs_lvm_remove_all (g);
13693     if (r == -1)
13694       return -1;
13695   }
13696   /* TestOutputList for umount_all (1) */
13697   {
13698     char device[] = "/dev/sda";
13699     char lines_0[] = ",10";
13700     char lines_1[] = ",20";
13701     char lines_2[] = ",";
13702     char *lines[] = {
13703       lines_0,
13704       lines_1,
13705       lines_2,
13706       NULL
13707     };
13708     int r;
13709     suppress_error = 0;
13710     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13711     if (r == -1)
13712       return -1;
13713   }
13714   {
13715     char fstype[] = "ext2";
13716     char device[] = "/dev/sda1";
13717     int r;
13718     suppress_error = 0;
13719     r = guestfs_mkfs (g, fstype, device);
13720     if (r == -1)
13721       return -1;
13722   }
13723   {
13724     char fstype[] = "ext2";
13725     char device[] = "/dev/sda2";
13726     int r;
13727     suppress_error = 0;
13728     r = guestfs_mkfs (g, fstype, device);
13729     if (r == -1)
13730       return -1;
13731   }
13732   {
13733     char fstype[] = "ext2";
13734     char device[] = "/dev/sda3";
13735     int r;
13736     suppress_error = 0;
13737     r = guestfs_mkfs (g, fstype, device);
13738     if (r == -1)
13739       return -1;
13740   }
13741   {
13742     char device[] = "/dev/sda1";
13743     char mountpoint[] = "/";
13744     int r;
13745     suppress_error = 0;
13746     r = guestfs_mount (g, device, mountpoint);
13747     if (r == -1)
13748       return -1;
13749   }
13750   {
13751     char path[] = "/mp1";
13752     int r;
13753     suppress_error = 0;
13754     r = guestfs_mkdir (g, path);
13755     if (r == -1)
13756       return -1;
13757   }
13758   {
13759     char device[] = "/dev/sda2";
13760     char mountpoint[] = "/mp1";
13761     int r;
13762     suppress_error = 0;
13763     r = guestfs_mount (g, device, mountpoint);
13764     if (r == -1)
13765       return -1;
13766   }
13767   {
13768     char path[] = "/mp1/mp2";
13769     int r;
13770     suppress_error = 0;
13771     r = guestfs_mkdir (g, path);
13772     if (r == -1)
13773       return -1;
13774   }
13775   {
13776     char device[] = "/dev/sda3";
13777     char mountpoint[] = "/mp1/mp2";
13778     int r;
13779     suppress_error = 0;
13780     r = guestfs_mount (g, device, mountpoint);
13781     if (r == -1)
13782       return -1;
13783   }
13784   {
13785     char path[] = "/mp1/mp2/mp3";
13786     int r;
13787     suppress_error = 0;
13788     r = guestfs_mkdir (g, path);
13789     if (r == -1)
13790       return -1;
13791   }
13792   {
13793     int r;
13794     suppress_error = 0;
13795     r = guestfs_umount_all (g);
13796     if (r == -1)
13797       return -1;
13798   }
13799   {
13800     char **r;
13801     int i;
13802     suppress_error = 0;
13803     r = guestfs_mounts (g);
13804     if (r == NULL)
13805       return -1;
13806     if (r[0] != NULL) {
13807       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13808       print_strings (r);
13809       return -1;
13810     }
13811     for (i = 0; r[i] != NULL; ++i)
13812       free (r[i]);
13813     free (r);
13814   }
13815   return 0;
13816 }
13817
13818 static int test_mounts_0_skip (void)
13819 {
13820   const char *str;
13821
13822   str = getenv ("TEST_ONLY");
13823   if (str)
13824     return strstr (str, "mounts") == NULL;
13825   str = getenv ("SKIP_TEST_MOUNTS_0");
13826   if (str && strcmp (str, "1") == 0) return 1;
13827   str = getenv ("SKIP_TEST_MOUNTS");
13828   if (str && strcmp (str, "1") == 0) return 1;
13829   return 0;
13830 }
13831
13832 static int test_mounts_0 (void)
13833 {
13834   if (test_mounts_0_skip ()) {
13835     printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
13836     return 0;
13837   }
13838
13839   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13840   {
13841     char device[] = "/dev/sda";
13842     int r;
13843     suppress_error = 0;
13844     r = guestfs_blockdev_setrw (g, device);
13845     if (r == -1)
13846       return -1;
13847   }
13848   {
13849     int r;
13850     suppress_error = 0;
13851     r = guestfs_umount_all (g);
13852     if (r == -1)
13853       return -1;
13854   }
13855   {
13856     int r;
13857     suppress_error = 0;
13858     r = guestfs_lvm_remove_all (g);
13859     if (r == -1)
13860       return -1;
13861   }
13862   {
13863     char device[] = "/dev/sda";
13864     char lines_0[] = ",";
13865     char *lines[] = {
13866       lines_0,
13867       NULL
13868     };
13869     int r;
13870     suppress_error = 0;
13871     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13872     if (r == -1)
13873       return -1;
13874   }
13875   {
13876     char fstype[] = "ext2";
13877     char device[] = "/dev/sda1";
13878     int r;
13879     suppress_error = 0;
13880     r = guestfs_mkfs (g, fstype, device);
13881     if (r == -1)
13882       return -1;
13883   }
13884   {
13885     char device[] = "/dev/sda1";
13886     char mountpoint[] = "/";
13887     int r;
13888     suppress_error = 0;
13889     r = guestfs_mount (g, device, mountpoint);
13890     if (r == -1)
13891       return -1;
13892   }
13893   /* TestOutputListOfDevices for mounts (0) */
13894   {
13895     char **r;
13896     int i;
13897     suppress_error = 0;
13898     r = guestfs_mounts (g);
13899     if (r == NULL)
13900       return -1;
13901     if (!r[0]) {
13902       fprintf (stderr, "test_mounts_0: short list returned from command\n");
13903       print_strings (r);
13904       return -1;
13905     }
13906     {
13907       char expected[] = "/dev/sda1";
13908       r[0][5] = 's';
13909       if (strcmp (r[0], expected) != 0) {
13910         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13911         return -1;
13912       }
13913     }
13914     if (r[1] != NULL) {
13915       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13916       print_strings (r);
13917       return -1;
13918     }
13919     for (i = 0; r[i] != NULL; ++i)
13920       free (r[i]);
13921     free (r);
13922   }
13923   return 0;
13924 }
13925
13926 static int test_umount_0_skip (void)
13927 {
13928   const char *str;
13929
13930   str = getenv ("TEST_ONLY");
13931   if (str)
13932     return strstr (str, "umount") == NULL;
13933   str = getenv ("SKIP_TEST_UMOUNT_0");
13934   if (str && strcmp (str, "1") == 0) return 1;
13935   str = getenv ("SKIP_TEST_UMOUNT");
13936   if (str && strcmp (str, "1") == 0) return 1;
13937   return 0;
13938 }
13939
13940 static int test_umount_0 (void)
13941 {
13942   if (test_umount_0_skip ()) {
13943     printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13944     return 0;
13945   }
13946
13947   /* InitNone|InitEmpty for test_umount_0 */
13948   {
13949     char device[] = "/dev/sda";
13950     int r;
13951     suppress_error = 0;
13952     r = guestfs_blockdev_setrw (g, device);
13953     if (r == -1)
13954       return -1;
13955   }
13956   {
13957     int r;
13958     suppress_error = 0;
13959     r = guestfs_umount_all (g);
13960     if (r == -1)
13961       return -1;
13962   }
13963   {
13964     int r;
13965     suppress_error = 0;
13966     r = guestfs_lvm_remove_all (g);
13967     if (r == -1)
13968       return -1;
13969   }
13970   /* TestOutputListOfDevices for umount (0) */
13971   {
13972     char device[] = "/dev/sda";
13973     char lines_0[] = ",";
13974     char *lines[] = {
13975       lines_0,
13976       NULL
13977     };
13978     int r;
13979     suppress_error = 0;
13980     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13981     if (r == -1)
13982       return -1;
13983   }
13984   {
13985     char fstype[] = "ext2";
13986     char device[] = "/dev/sda1";
13987     int r;
13988     suppress_error = 0;
13989     r = guestfs_mkfs (g, fstype, device);
13990     if (r == -1)
13991       return -1;
13992   }
13993   {
13994     char device[] = "/dev/sda1";
13995     char mountpoint[] = "/";
13996     int r;
13997     suppress_error = 0;
13998     r = guestfs_mount (g, device, mountpoint);
13999     if (r == -1)
14000       return -1;
14001   }
14002   {
14003     char **r;
14004     int i;
14005     suppress_error = 0;
14006     r = guestfs_mounts (g);
14007     if (r == NULL)
14008       return -1;
14009     if (!r[0]) {
14010       fprintf (stderr, "test_umount_0: short list returned from command\n");
14011       print_strings (r);
14012       return -1;
14013     }
14014     {
14015       char expected[] = "/dev/sda1";
14016       r[0][5] = 's';
14017       if (strcmp (r[0], expected) != 0) {
14018         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14019         return -1;
14020       }
14021     }
14022     if (r[1] != NULL) {
14023       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
14024       print_strings (r);
14025       return -1;
14026     }
14027     for (i = 0; r[i] != NULL; ++i)
14028       free (r[i]);
14029     free (r);
14030   }
14031   return 0;
14032 }
14033
14034 static int test_umount_1_skip (void)
14035 {
14036   const char *str;
14037
14038   str = getenv ("TEST_ONLY");
14039   if (str)
14040     return strstr (str, "umount") == NULL;
14041   str = getenv ("SKIP_TEST_UMOUNT_1");
14042   if (str && strcmp (str, "1") == 0) return 1;
14043   str = getenv ("SKIP_TEST_UMOUNT");
14044   if (str && strcmp (str, "1") == 0) return 1;
14045   return 0;
14046 }
14047
14048 static int test_umount_1 (void)
14049 {
14050   if (test_umount_1_skip ()) {
14051     printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
14052     return 0;
14053   }
14054
14055   /* InitNone|InitEmpty for test_umount_1 */
14056   {
14057     char device[] = "/dev/sda";
14058     int r;
14059     suppress_error = 0;
14060     r = guestfs_blockdev_setrw (g, device);
14061     if (r == -1)
14062       return -1;
14063   }
14064   {
14065     int r;
14066     suppress_error = 0;
14067     r = guestfs_umount_all (g);
14068     if (r == -1)
14069       return -1;
14070   }
14071   {
14072     int r;
14073     suppress_error = 0;
14074     r = guestfs_lvm_remove_all (g);
14075     if (r == -1)
14076       return -1;
14077   }
14078   /* TestOutputList for umount (1) */
14079   {
14080     char device[] = "/dev/sda";
14081     char lines_0[] = ",";
14082     char *lines[] = {
14083       lines_0,
14084       NULL
14085     };
14086     int r;
14087     suppress_error = 0;
14088     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14089     if (r == -1)
14090       return -1;
14091   }
14092   {
14093     char fstype[] = "ext2";
14094     char device[] = "/dev/sda1";
14095     int r;
14096     suppress_error = 0;
14097     r = guestfs_mkfs (g, fstype, device);
14098     if (r == -1)
14099       return -1;
14100   }
14101   {
14102     char device[] = "/dev/sda1";
14103     char mountpoint[] = "/";
14104     int r;
14105     suppress_error = 0;
14106     r = guestfs_mount (g, device, mountpoint);
14107     if (r == -1)
14108       return -1;
14109   }
14110   {
14111     char pathordevice[] = "/";
14112     int r;
14113     suppress_error = 0;
14114     r = guestfs_umount (g, pathordevice);
14115     if (r == -1)
14116       return -1;
14117   }
14118   {
14119     char **r;
14120     int i;
14121     suppress_error = 0;
14122     r = guestfs_mounts (g);
14123     if (r == NULL)
14124       return -1;
14125     if (r[0] != NULL) {
14126       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
14127       print_strings (r);
14128       return -1;
14129     }
14130     for (i = 0; r[i] != NULL; ++i)
14131       free (r[i]);
14132     free (r);
14133   }
14134   return 0;
14135 }
14136
14137 static int test_write_file_0_skip (void)
14138 {
14139   const char *str;
14140
14141   str = getenv ("TEST_ONLY");
14142   if (str)
14143     return strstr (str, "write_file") == NULL;
14144   str = getenv ("SKIP_TEST_WRITE_FILE_0");
14145   if (str && strcmp (str, "1") == 0) return 1;
14146   str = getenv ("SKIP_TEST_WRITE_FILE");
14147   if (str && strcmp (str, "1") == 0) return 1;
14148   return 0;
14149 }
14150
14151 static int test_write_file_0 (void)
14152 {
14153   if (test_write_file_0_skip ()) {
14154     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
14155     return 0;
14156   }
14157
14158   /* InitBasicFS for test_write_file_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   /* TestOutput for write_file (0) */
14213   char expected[] = "new file contents";
14214   {
14215     char path[] = "/new";
14216     char content[] = "new file contents";
14217     int r;
14218     suppress_error = 0;
14219     r = guestfs_write_file (g, path, content, 0);
14220     if (r == -1)
14221       return -1;
14222   }
14223   {
14224     char path[] = "/new";
14225     char *r;
14226     suppress_error = 0;
14227     r = guestfs_cat (g, path);
14228     if (r == NULL)
14229       return -1;
14230     if (strcmp (r, expected) != 0) {
14231       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
14232       return -1;
14233     }
14234     free (r);
14235   }
14236   return 0;
14237 }
14238
14239 static int test_write_file_1_skip (void)
14240 {
14241   const char *str;
14242
14243   str = getenv ("TEST_ONLY");
14244   if (str)
14245     return strstr (str, "write_file") == NULL;
14246   str = getenv ("SKIP_TEST_WRITE_FILE_1");
14247   if (str && strcmp (str, "1") == 0) return 1;
14248   str = getenv ("SKIP_TEST_WRITE_FILE");
14249   if (str && strcmp (str, "1") == 0) return 1;
14250   return 0;
14251 }
14252
14253 static int test_write_file_1 (void)
14254 {
14255   if (test_write_file_1_skip ()) {
14256     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
14257     return 0;
14258   }
14259
14260   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
14261   {
14262     char device[] = "/dev/sda";
14263     int r;
14264     suppress_error = 0;
14265     r = guestfs_blockdev_setrw (g, device);
14266     if (r == -1)
14267       return -1;
14268   }
14269   {
14270     int r;
14271     suppress_error = 0;
14272     r = guestfs_umount_all (g);
14273     if (r == -1)
14274       return -1;
14275   }
14276   {
14277     int r;
14278     suppress_error = 0;
14279     r = guestfs_lvm_remove_all (g);
14280     if (r == -1)
14281       return -1;
14282   }
14283   {
14284     char device[] = "/dev/sda";
14285     char lines_0[] = ",";
14286     char *lines[] = {
14287       lines_0,
14288       NULL
14289     };
14290     int r;
14291     suppress_error = 0;
14292     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14293     if (r == -1)
14294       return -1;
14295   }
14296   {
14297     char fstype[] = "ext2";
14298     char device[] = "/dev/sda1";
14299     int r;
14300     suppress_error = 0;
14301     r = guestfs_mkfs (g, fstype, device);
14302     if (r == -1)
14303       return -1;
14304   }
14305   {
14306     char device[] = "/dev/sda1";
14307     char mountpoint[] = "/";
14308     int r;
14309     suppress_error = 0;
14310     r = guestfs_mount (g, device, mountpoint);
14311     if (r == -1)
14312       return -1;
14313   }
14314   /* TestOutput for write_file (1) */
14315   char expected[] = "\nnew file contents\n";
14316   {
14317     char path[] = "/new";
14318     char content[] = "\nnew file contents\n";
14319     int r;
14320     suppress_error = 0;
14321     r = guestfs_write_file (g, path, content, 0);
14322     if (r == -1)
14323       return -1;
14324   }
14325   {
14326     char path[] = "/new";
14327     char *r;
14328     suppress_error = 0;
14329     r = guestfs_cat (g, path);
14330     if (r == NULL)
14331       return -1;
14332     if (strcmp (r, expected) != 0) {
14333       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
14334       return -1;
14335     }
14336     free (r);
14337   }
14338   return 0;
14339 }
14340
14341 static int test_write_file_2_skip (void)
14342 {
14343   const char *str;
14344
14345   str = getenv ("TEST_ONLY");
14346   if (str)
14347     return strstr (str, "write_file") == NULL;
14348   str = getenv ("SKIP_TEST_WRITE_FILE_2");
14349   if (str && strcmp (str, "1") == 0) return 1;
14350   str = getenv ("SKIP_TEST_WRITE_FILE");
14351   if (str && strcmp (str, "1") == 0) return 1;
14352   return 0;
14353 }
14354
14355 static int test_write_file_2 (void)
14356 {
14357   if (test_write_file_2_skip ()) {
14358     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
14359     return 0;
14360   }
14361
14362   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
14363   {
14364     char device[] = "/dev/sda";
14365     int r;
14366     suppress_error = 0;
14367     r = guestfs_blockdev_setrw (g, device);
14368     if (r == -1)
14369       return -1;
14370   }
14371   {
14372     int r;
14373     suppress_error = 0;
14374     r = guestfs_umount_all (g);
14375     if (r == -1)
14376       return -1;
14377   }
14378   {
14379     int r;
14380     suppress_error = 0;
14381     r = guestfs_lvm_remove_all (g);
14382     if (r == -1)
14383       return -1;
14384   }
14385   {
14386     char device[] = "/dev/sda";
14387     char lines_0[] = ",";
14388     char *lines[] = {
14389       lines_0,
14390       NULL
14391     };
14392     int r;
14393     suppress_error = 0;
14394     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14395     if (r == -1)
14396       return -1;
14397   }
14398   {
14399     char fstype[] = "ext2";
14400     char device[] = "/dev/sda1";
14401     int r;
14402     suppress_error = 0;
14403     r = guestfs_mkfs (g, fstype, device);
14404     if (r == -1)
14405       return -1;
14406   }
14407   {
14408     char device[] = "/dev/sda1";
14409     char mountpoint[] = "/";
14410     int r;
14411     suppress_error = 0;
14412     r = guestfs_mount (g, device, mountpoint);
14413     if (r == -1)
14414       return -1;
14415   }
14416   /* TestOutput for write_file (2) */
14417   char expected[] = "\n\n";
14418   {
14419     char path[] = "/new";
14420     char content[] = "\n\n";
14421     int r;
14422     suppress_error = 0;
14423     r = guestfs_write_file (g, path, content, 0);
14424     if (r == -1)
14425       return -1;
14426   }
14427   {
14428     char path[] = "/new";
14429     char *r;
14430     suppress_error = 0;
14431     r = guestfs_cat (g, path);
14432     if (r == NULL)
14433       return -1;
14434     if (strcmp (r, expected) != 0) {
14435       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
14436       return -1;
14437     }
14438     free (r);
14439   }
14440   return 0;
14441 }
14442
14443 static int test_write_file_3_skip (void)
14444 {
14445   const char *str;
14446
14447   str = getenv ("TEST_ONLY");
14448   if (str)
14449     return strstr (str, "write_file") == NULL;
14450   str = getenv ("SKIP_TEST_WRITE_FILE_3");
14451   if (str && strcmp (str, "1") == 0) return 1;
14452   str = getenv ("SKIP_TEST_WRITE_FILE");
14453   if (str && strcmp (str, "1") == 0) return 1;
14454   return 0;
14455 }
14456
14457 static int test_write_file_3 (void)
14458 {
14459   if (test_write_file_3_skip ()) {
14460     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
14461     return 0;
14462   }
14463
14464   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
14465   {
14466     char device[] = "/dev/sda";
14467     int r;
14468     suppress_error = 0;
14469     r = guestfs_blockdev_setrw (g, device);
14470     if (r == -1)
14471       return -1;
14472   }
14473   {
14474     int r;
14475     suppress_error = 0;
14476     r = guestfs_umount_all (g);
14477     if (r == -1)
14478       return -1;
14479   }
14480   {
14481     int r;
14482     suppress_error = 0;
14483     r = guestfs_lvm_remove_all (g);
14484     if (r == -1)
14485       return -1;
14486   }
14487   {
14488     char device[] = "/dev/sda";
14489     char lines_0[] = ",";
14490     char *lines[] = {
14491       lines_0,
14492       NULL
14493     };
14494     int r;
14495     suppress_error = 0;
14496     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14497     if (r == -1)
14498       return -1;
14499   }
14500   {
14501     char fstype[] = "ext2";
14502     char device[] = "/dev/sda1";
14503     int r;
14504     suppress_error = 0;
14505     r = guestfs_mkfs (g, fstype, device);
14506     if (r == -1)
14507       return -1;
14508   }
14509   {
14510     char device[] = "/dev/sda1";
14511     char mountpoint[] = "/";
14512     int r;
14513     suppress_error = 0;
14514     r = guestfs_mount (g, device, mountpoint);
14515     if (r == -1)
14516       return -1;
14517   }
14518   /* TestOutput for write_file (3) */
14519   char expected[] = "";
14520   {
14521     char path[] = "/new";
14522     char content[] = "";
14523     int r;
14524     suppress_error = 0;
14525     r = guestfs_write_file (g, path, content, 0);
14526     if (r == -1)
14527       return -1;
14528   }
14529   {
14530     char path[] = "/new";
14531     char *r;
14532     suppress_error = 0;
14533     r = guestfs_cat (g, path);
14534     if (r == NULL)
14535       return -1;
14536     if (strcmp (r, expected) != 0) {
14537       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
14538       return -1;
14539     }
14540     free (r);
14541   }
14542   return 0;
14543 }
14544
14545 static int test_write_file_4_skip (void)
14546 {
14547   const char *str;
14548
14549   str = getenv ("TEST_ONLY");
14550   if (str)
14551     return strstr (str, "write_file") == NULL;
14552   str = getenv ("SKIP_TEST_WRITE_FILE_4");
14553   if (str && strcmp (str, "1") == 0) return 1;
14554   str = getenv ("SKIP_TEST_WRITE_FILE");
14555   if (str && strcmp (str, "1") == 0) return 1;
14556   return 0;
14557 }
14558
14559 static int test_write_file_4 (void)
14560 {
14561   if (test_write_file_4_skip ()) {
14562     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
14563     return 0;
14564   }
14565
14566   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
14567   {
14568     char device[] = "/dev/sda";
14569     int r;
14570     suppress_error = 0;
14571     r = guestfs_blockdev_setrw (g, device);
14572     if (r == -1)
14573       return -1;
14574   }
14575   {
14576     int r;
14577     suppress_error = 0;
14578     r = guestfs_umount_all (g);
14579     if (r == -1)
14580       return -1;
14581   }
14582   {
14583     int r;
14584     suppress_error = 0;
14585     r = guestfs_lvm_remove_all (g);
14586     if (r == -1)
14587       return -1;
14588   }
14589   {
14590     char device[] = "/dev/sda";
14591     char lines_0[] = ",";
14592     char *lines[] = {
14593       lines_0,
14594       NULL
14595     };
14596     int r;
14597     suppress_error = 0;
14598     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14599     if (r == -1)
14600       return -1;
14601   }
14602   {
14603     char fstype[] = "ext2";
14604     char device[] = "/dev/sda1";
14605     int r;
14606     suppress_error = 0;
14607     r = guestfs_mkfs (g, fstype, device);
14608     if (r == -1)
14609       return -1;
14610   }
14611   {
14612     char device[] = "/dev/sda1";
14613     char mountpoint[] = "/";
14614     int r;
14615     suppress_error = 0;
14616     r = guestfs_mount (g, device, mountpoint);
14617     if (r == -1)
14618       return -1;
14619   }
14620   /* TestOutput for write_file (4) */
14621   char expected[] = "\n\n\n";
14622   {
14623     char path[] = "/new";
14624     char content[] = "\n\n\n";
14625     int r;
14626     suppress_error = 0;
14627     r = guestfs_write_file (g, path, content, 0);
14628     if (r == -1)
14629       return -1;
14630   }
14631   {
14632     char path[] = "/new";
14633     char *r;
14634     suppress_error = 0;
14635     r = guestfs_cat (g, path);
14636     if (r == NULL)
14637       return -1;
14638     if (strcmp (r, expected) != 0) {
14639       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
14640       return -1;
14641     }
14642     free (r);
14643   }
14644   return 0;
14645 }
14646
14647 static int test_write_file_5_skip (void)
14648 {
14649   const char *str;
14650
14651   str = getenv ("TEST_ONLY");
14652   if (str)
14653     return strstr (str, "write_file") == NULL;
14654   str = getenv ("SKIP_TEST_WRITE_FILE_5");
14655   if (str && strcmp (str, "1") == 0) return 1;
14656   str = getenv ("SKIP_TEST_WRITE_FILE");
14657   if (str && strcmp (str, "1") == 0) return 1;
14658   return 0;
14659 }
14660
14661 static int test_write_file_5 (void)
14662 {
14663   if (test_write_file_5_skip ()) {
14664     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
14665     return 0;
14666   }
14667
14668   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
14669   {
14670     char device[] = "/dev/sda";
14671     int r;
14672     suppress_error = 0;
14673     r = guestfs_blockdev_setrw (g, device);
14674     if (r == -1)
14675       return -1;
14676   }
14677   {
14678     int r;
14679     suppress_error = 0;
14680     r = guestfs_umount_all (g);
14681     if (r == -1)
14682       return -1;
14683   }
14684   {
14685     int r;
14686     suppress_error = 0;
14687     r = guestfs_lvm_remove_all (g);
14688     if (r == -1)
14689       return -1;
14690   }
14691   {
14692     char device[] = "/dev/sda";
14693     char lines_0[] = ",";
14694     char *lines[] = {
14695       lines_0,
14696       NULL
14697     };
14698     int r;
14699     suppress_error = 0;
14700     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14701     if (r == -1)
14702       return -1;
14703   }
14704   {
14705     char fstype[] = "ext2";
14706     char device[] = "/dev/sda1";
14707     int r;
14708     suppress_error = 0;
14709     r = guestfs_mkfs (g, fstype, device);
14710     if (r == -1)
14711       return -1;
14712   }
14713   {
14714     char device[] = "/dev/sda1";
14715     char mountpoint[] = "/";
14716     int r;
14717     suppress_error = 0;
14718     r = guestfs_mount (g, device, mountpoint);
14719     if (r == -1)
14720       return -1;
14721   }
14722   /* TestOutput for write_file (5) */
14723   char expected[] = "\n";
14724   {
14725     char path[] = "/new";
14726     char content[] = "\n";
14727     int r;
14728     suppress_error = 0;
14729     r = guestfs_write_file (g, path, content, 0);
14730     if (r == -1)
14731       return -1;
14732   }
14733   {
14734     char path[] = "/new";
14735     char *r;
14736     suppress_error = 0;
14737     r = guestfs_cat (g, path);
14738     if (r == NULL)
14739       return -1;
14740     if (strcmp (r, expected) != 0) {
14741       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14742       return -1;
14743     }
14744     free (r);
14745   }
14746   return 0;
14747 }
14748
14749 static int test_mkfs_0_skip (void)
14750 {
14751   const char *str;
14752
14753   str = getenv ("TEST_ONLY");
14754   if (str)
14755     return strstr (str, "mkfs") == NULL;
14756   str = getenv ("SKIP_TEST_MKFS_0");
14757   if (str && strcmp (str, "1") == 0) return 1;
14758   str = getenv ("SKIP_TEST_MKFS");
14759   if (str && strcmp (str, "1") == 0) return 1;
14760   return 0;
14761 }
14762
14763 static int test_mkfs_0 (void)
14764 {
14765   if (test_mkfs_0_skip ()) {
14766     printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
14767     return 0;
14768   }
14769
14770   /* InitNone|InitEmpty for test_mkfs_0 */
14771   {
14772     char device[] = "/dev/sda";
14773     int r;
14774     suppress_error = 0;
14775     r = guestfs_blockdev_setrw (g, device);
14776     if (r == -1)
14777       return -1;
14778   }
14779   {
14780     int r;
14781     suppress_error = 0;
14782     r = guestfs_umount_all (g);
14783     if (r == -1)
14784       return -1;
14785   }
14786   {
14787     int r;
14788     suppress_error = 0;
14789     r = guestfs_lvm_remove_all (g);
14790     if (r == -1)
14791       return -1;
14792   }
14793   /* TestOutput for mkfs (0) */
14794   char expected[] = "new file contents";
14795   {
14796     char device[] = "/dev/sda";
14797     char lines_0[] = ",";
14798     char *lines[] = {
14799       lines_0,
14800       NULL
14801     };
14802     int r;
14803     suppress_error = 0;
14804     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14805     if (r == -1)
14806       return -1;
14807   }
14808   {
14809     char fstype[] = "ext2";
14810     char device[] = "/dev/sda1";
14811     int r;
14812     suppress_error = 0;
14813     r = guestfs_mkfs (g, fstype, device);
14814     if (r == -1)
14815       return -1;
14816   }
14817   {
14818     char device[] = "/dev/sda1";
14819     char mountpoint[] = "/";
14820     int r;
14821     suppress_error = 0;
14822     r = guestfs_mount (g, device, mountpoint);
14823     if (r == -1)
14824       return -1;
14825   }
14826   {
14827     char path[] = "/new";
14828     char content[] = "new file contents";
14829     int r;
14830     suppress_error = 0;
14831     r = guestfs_write_file (g, path, content, 0);
14832     if (r == -1)
14833       return -1;
14834   }
14835   {
14836     char path[] = "/new";
14837     char *r;
14838     suppress_error = 0;
14839     r = guestfs_cat (g, path);
14840     if (r == NULL)
14841       return -1;
14842     if (strcmp (r, expected) != 0) {
14843       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14844       return -1;
14845     }
14846     free (r);
14847   }
14848   return 0;
14849 }
14850
14851 static int test_lvcreate_0_skip (void)
14852 {
14853   const char *str;
14854
14855   str = getenv ("TEST_ONLY");
14856   if (str)
14857     return strstr (str, "lvcreate") == NULL;
14858   str = getenv ("SKIP_TEST_LVCREATE_0");
14859   if (str && strcmp (str, "1") == 0) return 1;
14860   str = getenv ("SKIP_TEST_LVCREATE");
14861   if (str && strcmp (str, "1") == 0) return 1;
14862   return 0;
14863 }
14864
14865 static int test_lvcreate_0 (void)
14866 {
14867   if (test_lvcreate_0_skip ()) {
14868     printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14869     return 0;
14870   }
14871
14872   /* InitNone|InitEmpty for test_lvcreate_0 */
14873   {
14874     char device[] = "/dev/sda";
14875     int r;
14876     suppress_error = 0;
14877     r = guestfs_blockdev_setrw (g, device);
14878     if (r == -1)
14879       return -1;
14880   }
14881   {
14882     int r;
14883     suppress_error = 0;
14884     r = guestfs_umount_all (g);
14885     if (r == -1)
14886       return -1;
14887   }
14888   {
14889     int r;
14890     suppress_error = 0;
14891     r = guestfs_lvm_remove_all (g);
14892     if (r == -1)
14893       return -1;
14894   }
14895   /* TestOutputList for lvcreate (0) */
14896   {
14897     char device[] = "/dev/sda";
14898     char lines_0[] = ",10";
14899     char lines_1[] = ",20";
14900     char lines_2[] = ",";
14901     char *lines[] = {
14902       lines_0,
14903       lines_1,
14904       lines_2,
14905       NULL
14906     };
14907     int r;
14908     suppress_error = 0;
14909     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14910     if (r == -1)
14911       return -1;
14912   }
14913   {
14914     char device[] = "/dev/sda1";
14915     int r;
14916     suppress_error = 0;
14917     r = guestfs_pvcreate (g, device);
14918     if (r == -1)
14919       return -1;
14920   }
14921   {
14922     char device[] = "/dev/sda2";
14923     int r;
14924     suppress_error = 0;
14925     r = guestfs_pvcreate (g, device);
14926     if (r == -1)
14927       return -1;
14928   }
14929   {
14930     char device[] = "/dev/sda3";
14931     int r;
14932     suppress_error = 0;
14933     r = guestfs_pvcreate (g, device);
14934     if (r == -1)
14935       return -1;
14936   }
14937   {
14938     char volgroup[] = "VG1";
14939     char physvols_0[] = "/dev/sda1";
14940     char physvols_1[] = "/dev/sda2";
14941     char *physvols[] = {
14942       physvols_0,
14943       physvols_1,
14944       NULL
14945     };
14946     int r;
14947     suppress_error = 0;
14948     r = guestfs_vgcreate (g, volgroup, physvols);
14949     if (r == -1)
14950       return -1;
14951   }
14952   {
14953     char volgroup[] = "VG2";
14954     char physvols_0[] = "/dev/sda3";
14955     char *physvols[] = {
14956       physvols_0,
14957       NULL
14958     };
14959     int r;
14960     suppress_error = 0;
14961     r = guestfs_vgcreate (g, volgroup, physvols);
14962     if (r == -1)
14963       return -1;
14964   }
14965   {
14966     char logvol[] = "LV1";
14967     char volgroup[] = "VG1";
14968     int r;
14969     suppress_error = 0;
14970     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14971     if (r == -1)
14972       return -1;
14973   }
14974   {
14975     char logvol[] = "LV2";
14976     char volgroup[] = "VG1";
14977     int r;
14978     suppress_error = 0;
14979     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14980     if (r == -1)
14981       return -1;
14982   }
14983   {
14984     char logvol[] = "LV3";
14985     char volgroup[] = "VG2";
14986     int r;
14987     suppress_error = 0;
14988     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14989     if (r == -1)
14990       return -1;
14991   }
14992   {
14993     char logvol[] = "LV4";
14994     char volgroup[] = "VG2";
14995     int r;
14996     suppress_error = 0;
14997     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14998     if (r == -1)
14999       return -1;
15000   }
15001   {
15002     char logvol[] = "LV5";
15003     char volgroup[] = "VG2";
15004     int r;
15005     suppress_error = 0;
15006     r = guestfs_lvcreate (g, logvol, volgroup, 50);
15007     if (r == -1)
15008       return -1;
15009   }
15010   {
15011     char **r;
15012     int i;
15013     suppress_error = 0;
15014     r = guestfs_lvs (g);
15015     if (r == NULL)
15016       return -1;
15017     if (!r[0]) {
15018       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15019       print_strings (r);
15020       return -1;
15021     }
15022     {
15023       char expected[] = "/dev/VG1/LV1";
15024       if (strcmp (r[0], expected) != 0) {
15025         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15026         return -1;
15027       }
15028     }
15029     if (!r[1]) {
15030       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15031       print_strings (r);
15032       return -1;
15033     }
15034     {
15035       char expected[] = "/dev/VG1/LV2";
15036       if (strcmp (r[1], expected) != 0) {
15037         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15038         return -1;
15039       }
15040     }
15041     if (!r[2]) {
15042       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15043       print_strings (r);
15044       return -1;
15045     }
15046     {
15047       char expected[] = "/dev/VG2/LV3";
15048       if (strcmp (r[2], expected) != 0) {
15049         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15050         return -1;
15051       }
15052     }
15053     if (!r[3]) {
15054       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15055       print_strings (r);
15056       return -1;
15057     }
15058     {
15059       char expected[] = "/dev/VG2/LV4";
15060       if (strcmp (r[3], expected) != 0) {
15061         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15062         return -1;
15063       }
15064     }
15065     if (!r[4]) {
15066       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15067       print_strings (r);
15068       return -1;
15069     }
15070     {
15071       char expected[] = "/dev/VG2/LV5";
15072       if (strcmp (r[4], expected) != 0) {
15073         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
15074         return -1;
15075       }
15076     }
15077     if (r[5] != NULL) {
15078       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
15079       print_strings (r);
15080       return -1;
15081     }
15082     for (i = 0; r[i] != NULL; ++i)
15083       free (r[i]);
15084     free (r);
15085   }
15086   return 0;
15087 }
15088
15089 static int test_vgcreate_0_skip (void)
15090 {
15091   const char *str;
15092
15093   str = getenv ("TEST_ONLY");
15094   if (str)
15095     return strstr (str, "vgcreate") == NULL;
15096   str = getenv ("SKIP_TEST_VGCREATE_0");
15097   if (str && strcmp (str, "1") == 0) return 1;
15098   str = getenv ("SKIP_TEST_VGCREATE");
15099   if (str && strcmp (str, "1") == 0) return 1;
15100   return 0;
15101 }
15102
15103 static int test_vgcreate_0 (void)
15104 {
15105   if (test_vgcreate_0_skip ()) {
15106     printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
15107     return 0;
15108   }
15109
15110   /* InitNone|InitEmpty for test_vgcreate_0 */
15111   {
15112     char device[] = "/dev/sda";
15113     int r;
15114     suppress_error = 0;
15115     r = guestfs_blockdev_setrw (g, device);
15116     if (r == -1)
15117       return -1;
15118   }
15119   {
15120     int r;
15121     suppress_error = 0;
15122     r = guestfs_umount_all (g);
15123     if (r == -1)
15124       return -1;
15125   }
15126   {
15127     int r;
15128     suppress_error = 0;
15129     r = guestfs_lvm_remove_all (g);
15130     if (r == -1)
15131       return -1;
15132   }
15133   /* TestOutputList for vgcreate (0) */
15134   {
15135     char device[] = "/dev/sda";
15136     char lines_0[] = ",10";
15137     char lines_1[] = ",20";
15138     char lines_2[] = ",";
15139     char *lines[] = {
15140       lines_0,
15141       lines_1,
15142       lines_2,
15143       NULL
15144     };
15145     int r;
15146     suppress_error = 0;
15147     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15148     if (r == -1)
15149       return -1;
15150   }
15151   {
15152     char device[] = "/dev/sda1";
15153     int r;
15154     suppress_error = 0;
15155     r = guestfs_pvcreate (g, device);
15156     if (r == -1)
15157       return -1;
15158   }
15159   {
15160     char device[] = "/dev/sda2";
15161     int r;
15162     suppress_error = 0;
15163     r = guestfs_pvcreate (g, device);
15164     if (r == -1)
15165       return -1;
15166   }
15167   {
15168     char device[] = "/dev/sda3";
15169     int r;
15170     suppress_error = 0;
15171     r = guestfs_pvcreate (g, device);
15172     if (r == -1)
15173       return -1;
15174   }
15175   {
15176     char volgroup[] = "VG1";
15177     char physvols_0[] = "/dev/sda1";
15178     char physvols_1[] = "/dev/sda2";
15179     char *physvols[] = {
15180       physvols_0,
15181       physvols_1,
15182       NULL
15183     };
15184     int r;
15185     suppress_error = 0;
15186     r = guestfs_vgcreate (g, volgroup, physvols);
15187     if (r == -1)
15188       return -1;
15189   }
15190   {
15191     char volgroup[] = "VG2";
15192     char physvols_0[] = "/dev/sda3";
15193     char *physvols[] = {
15194       physvols_0,
15195       NULL
15196     };
15197     int r;
15198     suppress_error = 0;
15199     r = guestfs_vgcreate (g, volgroup, physvols);
15200     if (r == -1)
15201       return -1;
15202   }
15203   {
15204     char **r;
15205     int i;
15206     suppress_error = 0;
15207     r = guestfs_vgs (g);
15208     if (r == NULL)
15209       return -1;
15210     if (!r[0]) {
15211       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15212       print_strings (r);
15213       return -1;
15214     }
15215     {
15216       char expected[] = "VG1";
15217       if (strcmp (r[0], expected) != 0) {
15218         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15219         return -1;
15220       }
15221     }
15222     if (!r[1]) {
15223       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15224       print_strings (r);
15225       return -1;
15226     }
15227     {
15228       char expected[] = "VG2";
15229       if (strcmp (r[1], expected) != 0) {
15230         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15231         return -1;
15232       }
15233     }
15234     if (r[2] != NULL) {
15235       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
15236       print_strings (r);
15237       return -1;
15238     }
15239     for (i = 0; r[i] != NULL; ++i)
15240       free (r[i]);
15241     free (r);
15242   }
15243   return 0;
15244 }
15245
15246 static int test_pvcreate_0_skip (void)
15247 {
15248   const char *str;
15249
15250   str = getenv ("TEST_ONLY");
15251   if (str)
15252     return strstr (str, "pvcreate") == NULL;
15253   str = getenv ("SKIP_TEST_PVCREATE_0");
15254   if (str && strcmp (str, "1") == 0) return 1;
15255   str = getenv ("SKIP_TEST_PVCREATE");
15256   if (str && strcmp (str, "1") == 0) return 1;
15257   return 0;
15258 }
15259
15260 static int test_pvcreate_0 (void)
15261 {
15262   if (test_pvcreate_0_skip ()) {
15263     printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
15264     return 0;
15265   }
15266
15267   /* InitNone|InitEmpty for test_pvcreate_0 */
15268   {
15269     char device[] = "/dev/sda";
15270     int r;
15271     suppress_error = 0;
15272     r = guestfs_blockdev_setrw (g, device);
15273     if (r == -1)
15274       return -1;
15275   }
15276   {
15277     int r;
15278     suppress_error = 0;
15279     r = guestfs_umount_all (g);
15280     if (r == -1)
15281       return -1;
15282   }
15283   {
15284     int r;
15285     suppress_error = 0;
15286     r = guestfs_lvm_remove_all (g);
15287     if (r == -1)
15288       return -1;
15289   }
15290   /* TestOutputListOfDevices for pvcreate (0) */
15291   {
15292     char device[] = "/dev/sda";
15293     char lines_0[] = ",10";
15294     char lines_1[] = ",20";
15295     char lines_2[] = ",";
15296     char *lines[] = {
15297       lines_0,
15298       lines_1,
15299       lines_2,
15300       NULL
15301     };
15302     int r;
15303     suppress_error = 0;
15304     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15305     if (r == -1)
15306       return -1;
15307   }
15308   {
15309     char device[] = "/dev/sda1";
15310     int r;
15311     suppress_error = 0;
15312     r = guestfs_pvcreate (g, device);
15313     if (r == -1)
15314       return -1;
15315   }
15316   {
15317     char device[] = "/dev/sda2";
15318     int r;
15319     suppress_error = 0;
15320     r = guestfs_pvcreate (g, device);
15321     if (r == -1)
15322       return -1;
15323   }
15324   {
15325     char device[] = "/dev/sda3";
15326     int r;
15327     suppress_error = 0;
15328     r = guestfs_pvcreate (g, device);
15329     if (r == -1)
15330       return -1;
15331   }
15332   {
15333     char **r;
15334     int i;
15335     suppress_error = 0;
15336     r = guestfs_pvs (g);
15337     if (r == NULL)
15338       return -1;
15339     if (!r[0]) {
15340       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15341       print_strings (r);
15342       return -1;
15343     }
15344     {
15345       char expected[] = "/dev/sda1";
15346       r[0][5] = 's';
15347       if (strcmp (r[0], expected) != 0) {
15348         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15349         return -1;
15350       }
15351     }
15352     if (!r[1]) {
15353       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15354       print_strings (r);
15355       return -1;
15356     }
15357     {
15358       char expected[] = "/dev/sda2";
15359       r[1][5] = 's';
15360       if (strcmp (r[1], expected) != 0) {
15361         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15362         return -1;
15363       }
15364     }
15365     if (!r[2]) {
15366       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15367       print_strings (r);
15368       return -1;
15369     }
15370     {
15371       char expected[] = "/dev/sda3";
15372       r[2][5] = 's';
15373       if (strcmp (r[2], expected) != 0) {
15374         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15375         return -1;
15376       }
15377     }
15378     if (r[3] != NULL) {
15379       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
15380       print_strings (r);
15381       return -1;
15382     }
15383     for (i = 0; r[i] != NULL; ++i)
15384       free (r[i]);
15385     free (r);
15386   }
15387   return 0;
15388 }
15389
15390 static int test_is_dir_0_skip (void)
15391 {
15392   const char *str;
15393
15394   str = getenv ("TEST_ONLY");
15395   if (str)
15396     return strstr (str, "is_dir") == NULL;
15397   str = getenv ("SKIP_TEST_IS_DIR_0");
15398   if (str && strcmp (str, "1") == 0) return 1;
15399   str = getenv ("SKIP_TEST_IS_DIR");
15400   if (str && strcmp (str, "1") == 0) return 1;
15401   return 0;
15402 }
15403
15404 static int test_is_dir_0 (void)
15405 {
15406   if (test_is_dir_0_skip ()) {
15407     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
15408     return 0;
15409   }
15410
15411   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
15412   {
15413     char device[] = "/dev/sda";
15414     int r;
15415     suppress_error = 0;
15416     r = guestfs_blockdev_setrw (g, device);
15417     if (r == -1)
15418       return -1;
15419   }
15420   {
15421     int r;
15422     suppress_error = 0;
15423     r = guestfs_umount_all (g);
15424     if (r == -1)
15425       return -1;
15426   }
15427   {
15428     int r;
15429     suppress_error = 0;
15430     r = guestfs_lvm_remove_all (g);
15431     if (r == -1)
15432       return -1;
15433   }
15434   {
15435     char device[] = "/dev/sda";
15436     char lines_0[] = ",";
15437     char *lines[] = {
15438       lines_0,
15439       NULL
15440     };
15441     int r;
15442     suppress_error = 0;
15443     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15444     if (r == -1)
15445       return -1;
15446   }
15447   {
15448     char fstype[] = "ext2";
15449     char device[] = "/dev/sda1";
15450     int r;
15451     suppress_error = 0;
15452     r = guestfs_mkfs (g, fstype, device);
15453     if (r == -1)
15454       return -1;
15455   }
15456   {
15457     char device[] = "/dev/sda1";
15458     char mountpoint[] = "/";
15459     int r;
15460     suppress_error = 0;
15461     r = guestfs_mount (g, device, mountpoint);
15462     if (r == -1)
15463       return -1;
15464   }
15465   /* TestOutputFalse for is_dir (0) */
15466   {
15467     char path[] = "/new";
15468     int r;
15469     suppress_error = 0;
15470     r = guestfs_touch (g, path);
15471     if (r == -1)
15472       return -1;
15473   }
15474   {
15475     char path[] = "/new";
15476     int r;
15477     suppress_error = 0;
15478     r = guestfs_is_dir (g, path);
15479     if (r == -1)
15480       return -1;
15481     if (r) {
15482       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
15483       return -1;
15484     }
15485   }
15486   return 0;
15487 }
15488
15489 static int test_is_dir_1_skip (void)
15490 {
15491   const char *str;
15492
15493   str = getenv ("TEST_ONLY");
15494   if (str)
15495     return strstr (str, "is_dir") == NULL;
15496   str = getenv ("SKIP_TEST_IS_DIR_1");
15497   if (str && strcmp (str, "1") == 0) return 1;
15498   str = getenv ("SKIP_TEST_IS_DIR");
15499   if (str && strcmp (str, "1") == 0) return 1;
15500   return 0;
15501 }
15502
15503 static int test_is_dir_1 (void)
15504 {
15505   if (test_is_dir_1_skip ()) {
15506     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
15507     return 0;
15508   }
15509
15510   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
15511   {
15512     char device[] = "/dev/sda";
15513     int r;
15514     suppress_error = 0;
15515     r = guestfs_blockdev_setrw (g, device);
15516     if (r == -1)
15517       return -1;
15518   }
15519   {
15520     int r;
15521     suppress_error = 0;
15522     r = guestfs_umount_all (g);
15523     if (r == -1)
15524       return -1;
15525   }
15526   {
15527     int r;
15528     suppress_error = 0;
15529     r = guestfs_lvm_remove_all (g);
15530     if (r == -1)
15531       return -1;
15532   }
15533   {
15534     char device[] = "/dev/sda";
15535     char lines_0[] = ",";
15536     char *lines[] = {
15537       lines_0,
15538       NULL
15539     };
15540     int r;
15541     suppress_error = 0;
15542     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15543     if (r == -1)
15544       return -1;
15545   }
15546   {
15547     char fstype[] = "ext2";
15548     char device[] = "/dev/sda1";
15549     int r;
15550     suppress_error = 0;
15551     r = guestfs_mkfs (g, fstype, device);
15552     if (r == -1)
15553       return -1;
15554   }
15555   {
15556     char device[] = "/dev/sda1";
15557     char mountpoint[] = "/";
15558     int r;
15559     suppress_error = 0;
15560     r = guestfs_mount (g, device, mountpoint);
15561     if (r == -1)
15562       return -1;
15563   }
15564   /* TestOutputTrue for is_dir (1) */
15565   {
15566     char path[] = "/new";
15567     int r;
15568     suppress_error = 0;
15569     r = guestfs_mkdir (g, path);
15570     if (r == -1)
15571       return -1;
15572   }
15573   {
15574     char path[] = "/new";
15575     int r;
15576     suppress_error = 0;
15577     r = guestfs_is_dir (g, path);
15578     if (r == -1)
15579       return -1;
15580     if (!r) {
15581       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
15582       return -1;
15583     }
15584   }
15585   return 0;
15586 }
15587
15588 static int test_is_file_0_skip (void)
15589 {
15590   const char *str;
15591
15592   str = getenv ("TEST_ONLY");
15593   if (str)
15594     return strstr (str, "is_file") == NULL;
15595   str = getenv ("SKIP_TEST_IS_FILE_0");
15596   if (str && strcmp (str, "1") == 0) return 1;
15597   str = getenv ("SKIP_TEST_IS_FILE");
15598   if (str && strcmp (str, "1") == 0) return 1;
15599   return 0;
15600 }
15601
15602 static int test_is_file_0 (void)
15603 {
15604   if (test_is_file_0_skip ()) {
15605     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
15606     return 0;
15607   }
15608
15609   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
15610   {
15611     char device[] = "/dev/sda";
15612     int r;
15613     suppress_error = 0;
15614     r = guestfs_blockdev_setrw (g, device);
15615     if (r == -1)
15616       return -1;
15617   }
15618   {
15619     int r;
15620     suppress_error = 0;
15621     r = guestfs_umount_all (g);
15622     if (r == -1)
15623       return -1;
15624   }
15625   {
15626     int r;
15627     suppress_error = 0;
15628     r = guestfs_lvm_remove_all (g);
15629     if (r == -1)
15630       return -1;
15631   }
15632   {
15633     char device[] = "/dev/sda";
15634     char lines_0[] = ",";
15635     char *lines[] = {
15636       lines_0,
15637       NULL
15638     };
15639     int r;
15640     suppress_error = 0;
15641     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15642     if (r == -1)
15643       return -1;
15644   }
15645   {
15646     char fstype[] = "ext2";
15647     char device[] = "/dev/sda1";
15648     int r;
15649     suppress_error = 0;
15650     r = guestfs_mkfs (g, fstype, device);
15651     if (r == -1)
15652       return -1;
15653   }
15654   {
15655     char device[] = "/dev/sda1";
15656     char mountpoint[] = "/";
15657     int r;
15658     suppress_error = 0;
15659     r = guestfs_mount (g, device, mountpoint);
15660     if (r == -1)
15661       return -1;
15662   }
15663   /* TestOutputTrue for is_file (0) */
15664   {
15665     char path[] = "/new";
15666     int r;
15667     suppress_error = 0;
15668     r = guestfs_touch (g, path);
15669     if (r == -1)
15670       return -1;
15671   }
15672   {
15673     char path[] = "/new";
15674     int r;
15675     suppress_error = 0;
15676     r = guestfs_is_file (g, path);
15677     if (r == -1)
15678       return -1;
15679     if (!r) {
15680       fprintf (stderr, "test_is_file_0: expected true, got false\n");
15681       return -1;
15682     }
15683   }
15684   return 0;
15685 }
15686
15687 static int test_is_file_1_skip (void)
15688 {
15689   const char *str;
15690
15691   str = getenv ("TEST_ONLY");
15692   if (str)
15693     return strstr (str, "is_file") == NULL;
15694   str = getenv ("SKIP_TEST_IS_FILE_1");
15695   if (str && strcmp (str, "1") == 0) return 1;
15696   str = getenv ("SKIP_TEST_IS_FILE");
15697   if (str && strcmp (str, "1") == 0) return 1;
15698   return 0;
15699 }
15700
15701 static int test_is_file_1 (void)
15702 {
15703   if (test_is_file_1_skip ()) {
15704     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
15705     return 0;
15706   }
15707
15708   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
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 fstype[] = "ext2";
15746     char device[] = "/dev/sda1";
15747     int r;
15748     suppress_error = 0;
15749     r = guestfs_mkfs (g, fstype, device);
15750     if (r == -1)
15751       return -1;
15752   }
15753   {
15754     char device[] = "/dev/sda1";
15755     char mountpoint[] = "/";
15756     int r;
15757     suppress_error = 0;
15758     r = guestfs_mount (g, device, mountpoint);
15759     if (r == -1)
15760       return -1;
15761   }
15762   /* TestOutputFalse for is_file (1) */
15763   {
15764     char path[] = "/new";
15765     int r;
15766     suppress_error = 0;
15767     r = guestfs_mkdir (g, path);
15768     if (r == -1)
15769       return -1;
15770   }
15771   {
15772     char path[] = "/new";
15773     int r;
15774     suppress_error = 0;
15775     r = guestfs_is_file (g, path);
15776     if (r == -1)
15777       return -1;
15778     if (r) {
15779       fprintf (stderr, "test_is_file_1: expected false, got true\n");
15780       return -1;
15781     }
15782   }
15783   return 0;
15784 }
15785
15786 static int test_exists_0_skip (void)
15787 {
15788   const char *str;
15789
15790   str = getenv ("TEST_ONLY");
15791   if (str)
15792     return strstr (str, "exists") == NULL;
15793   str = getenv ("SKIP_TEST_EXISTS_0");
15794   if (str && strcmp (str, "1") == 0) return 1;
15795   str = getenv ("SKIP_TEST_EXISTS");
15796   if (str && strcmp (str, "1") == 0) return 1;
15797   return 0;
15798 }
15799
15800 static int test_exists_0 (void)
15801 {
15802   if (test_exists_0_skip ()) {
15803     printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
15804     return 0;
15805   }
15806
15807   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15808   {
15809     char device[] = "/dev/sda";
15810     int r;
15811     suppress_error = 0;
15812     r = guestfs_blockdev_setrw (g, device);
15813     if (r == -1)
15814       return -1;
15815   }
15816   {
15817     int r;
15818     suppress_error = 0;
15819     r = guestfs_umount_all (g);
15820     if (r == -1)
15821       return -1;
15822   }
15823   {
15824     int r;
15825     suppress_error = 0;
15826     r = guestfs_lvm_remove_all (g);
15827     if (r == -1)
15828       return -1;
15829   }
15830   {
15831     char device[] = "/dev/sda";
15832     char lines_0[] = ",";
15833     char *lines[] = {
15834       lines_0,
15835       NULL
15836     };
15837     int r;
15838     suppress_error = 0;
15839     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15840     if (r == -1)
15841       return -1;
15842   }
15843   {
15844     char fstype[] = "ext2";
15845     char device[] = "/dev/sda1";
15846     int r;
15847     suppress_error = 0;
15848     r = guestfs_mkfs (g, fstype, device);
15849     if (r == -1)
15850       return -1;
15851   }
15852   {
15853     char device[] = "/dev/sda1";
15854     char mountpoint[] = "/";
15855     int r;
15856     suppress_error = 0;
15857     r = guestfs_mount (g, device, mountpoint);
15858     if (r == -1)
15859       return -1;
15860   }
15861   /* TestOutputTrue for exists (0) */
15862   {
15863     char path[] = "/new";
15864     int r;
15865     suppress_error = 0;
15866     r = guestfs_touch (g, path);
15867     if (r == -1)
15868       return -1;
15869   }
15870   {
15871     char path[] = "/new";
15872     int r;
15873     suppress_error = 0;
15874     r = guestfs_exists (g, path);
15875     if (r == -1)
15876       return -1;
15877     if (!r) {
15878       fprintf (stderr, "test_exists_0: expected true, got false\n");
15879       return -1;
15880     }
15881   }
15882   return 0;
15883 }
15884
15885 static int test_exists_1_skip (void)
15886 {
15887   const char *str;
15888
15889   str = getenv ("TEST_ONLY");
15890   if (str)
15891     return strstr (str, "exists") == NULL;
15892   str = getenv ("SKIP_TEST_EXISTS_1");
15893   if (str && strcmp (str, "1") == 0) return 1;
15894   str = getenv ("SKIP_TEST_EXISTS");
15895   if (str && strcmp (str, "1") == 0) return 1;
15896   return 0;
15897 }
15898
15899 static int test_exists_1 (void)
15900 {
15901   if (test_exists_1_skip ()) {
15902     printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15903     return 0;
15904   }
15905
15906   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15907   {
15908     char device[] = "/dev/sda";
15909     int r;
15910     suppress_error = 0;
15911     r = guestfs_blockdev_setrw (g, device);
15912     if (r == -1)
15913       return -1;
15914   }
15915   {
15916     int r;
15917     suppress_error = 0;
15918     r = guestfs_umount_all (g);
15919     if (r == -1)
15920       return -1;
15921   }
15922   {
15923     int r;
15924     suppress_error = 0;
15925     r = guestfs_lvm_remove_all (g);
15926     if (r == -1)
15927       return -1;
15928   }
15929   {
15930     char device[] = "/dev/sda";
15931     char lines_0[] = ",";
15932     char *lines[] = {
15933       lines_0,
15934       NULL
15935     };
15936     int r;
15937     suppress_error = 0;
15938     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15939     if (r == -1)
15940       return -1;
15941   }
15942   {
15943     char fstype[] = "ext2";
15944     char device[] = "/dev/sda1";
15945     int r;
15946     suppress_error = 0;
15947     r = guestfs_mkfs (g, fstype, device);
15948     if (r == -1)
15949       return -1;
15950   }
15951   {
15952     char device[] = "/dev/sda1";
15953     char mountpoint[] = "/";
15954     int r;
15955     suppress_error = 0;
15956     r = guestfs_mount (g, device, mountpoint);
15957     if (r == -1)
15958       return -1;
15959   }
15960   /* TestOutputTrue for exists (1) */
15961   {
15962     char path[] = "/new";
15963     int r;
15964     suppress_error = 0;
15965     r = guestfs_mkdir (g, path);
15966     if (r == -1)
15967       return -1;
15968   }
15969   {
15970     char path[] = "/new";
15971     int r;
15972     suppress_error = 0;
15973     r = guestfs_exists (g, path);
15974     if (r == -1)
15975       return -1;
15976     if (!r) {
15977       fprintf (stderr, "test_exists_1: expected true, got false\n");
15978       return -1;
15979     }
15980   }
15981   return 0;
15982 }
15983
15984 static int test_mkdir_p_0_skip (void)
15985 {
15986   const char *str;
15987
15988   str = getenv ("TEST_ONLY");
15989   if (str)
15990     return strstr (str, "mkdir_p") == NULL;
15991   str = getenv ("SKIP_TEST_MKDIR_P_0");
15992   if (str && strcmp (str, "1") == 0) return 1;
15993   str = getenv ("SKIP_TEST_MKDIR_P");
15994   if (str && strcmp (str, "1") == 0) return 1;
15995   return 0;
15996 }
15997
15998 static int test_mkdir_p_0 (void)
15999 {
16000   if (test_mkdir_p_0_skip ()) {
16001     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
16002     return 0;
16003   }
16004
16005   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
16006   {
16007     char device[] = "/dev/sda";
16008     int r;
16009     suppress_error = 0;
16010     r = guestfs_blockdev_setrw (g, device);
16011     if (r == -1)
16012       return -1;
16013   }
16014   {
16015     int r;
16016     suppress_error = 0;
16017     r = guestfs_umount_all (g);
16018     if (r == -1)
16019       return -1;
16020   }
16021   {
16022     int r;
16023     suppress_error = 0;
16024     r = guestfs_lvm_remove_all (g);
16025     if (r == -1)
16026       return -1;
16027   }
16028   {
16029     char device[] = "/dev/sda";
16030     char lines_0[] = ",";
16031     char *lines[] = {
16032       lines_0,
16033       NULL
16034     };
16035     int r;
16036     suppress_error = 0;
16037     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16038     if (r == -1)
16039       return -1;
16040   }
16041   {
16042     char fstype[] = "ext2";
16043     char device[] = "/dev/sda1";
16044     int r;
16045     suppress_error = 0;
16046     r = guestfs_mkfs (g, fstype, device);
16047     if (r == -1)
16048       return -1;
16049   }
16050   {
16051     char device[] = "/dev/sda1";
16052     char mountpoint[] = "/";
16053     int r;
16054     suppress_error = 0;
16055     r = guestfs_mount (g, device, mountpoint);
16056     if (r == -1)
16057       return -1;
16058   }
16059   /* TestOutputTrue for mkdir_p (0) */
16060   {
16061     char path[] = "/new/foo/bar";
16062     int r;
16063     suppress_error = 0;
16064     r = guestfs_mkdir_p (g, path);
16065     if (r == -1)
16066       return -1;
16067   }
16068   {
16069     char path[] = "/new/foo/bar";
16070     int r;
16071     suppress_error = 0;
16072     r = guestfs_is_dir (g, path);
16073     if (r == -1)
16074       return -1;
16075     if (!r) {
16076       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
16077       return -1;
16078     }
16079   }
16080   return 0;
16081 }
16082
16083 static int test_mkdir_p_1_skip (void)
16084 {
16085   const char *str;
16086
16087   str = getenv ("TEST_ONLY");
16088   if (str)
16089     return strstr (str, "mkdir_p") == NULL;
16090   str = getenv ("SKIP_TEST_MKDIR_P_1");
16091   if (str && strcmp (str, "1") == 0) return 1;
16092   str = getenv ("SKIP_TEST_MKDIR_P");
16093   if (str && strcmp (str, "1") == 0) return 1;
16094   return 0;
16095 }
16096
16097 static int test_mkdir_p_1 (void)
16098 {
16099   if (test_mkdir_p_1_skip ()) {
16100     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
16101     return 0;
16102   }
16103
16104   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
16105   {
16106     char device[] = "/dev/sda";
16107     int r;
16108     suppress_error = 0;
16109     r = guestfs_blockdev_setrw (g, device);
16110     if (r == -1)
16111       return -1;
16112   }
16113   {
16114     int r;
16115     suppress_error = 0;
16116     r = guestfs_umount_all (g);
16117     if (r == -1)
16118       return -1;
16119   }
16120   {
16121     int r;
16122     suppress_error = 0;
16123     r = guestfs_lvm_remove_all (g);
16124     if (r == -1)
16125       return -1;
16126   }
16127   {
16128     char device[] = "/dev/sda";
16129     char lines_0[] = ",";
16130     char *lines[] = {
16131       lines_0,
16132       NULL
16133     };
16134     int r;
16135     suppress_error = 0;
16136     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16137     if (r == -1)
16138       return -1;
16139   }
16140   {
16141     char fstype[] = "ext2";
16142     char device[] = "/dev/sda1";
16143     int r;
16144     suppress_error = 0;
16145     r = guestfs_mkfs (g, fstype, device);
16146     if (r == -1)
16147       return -1;
16148   }
16149   {
16150     char device[] = "/dev/sda1";
16151     char mountpoint[] = "/";
16152     int r;
16153     suppress_error = 0;
16154     r = guestfs_mount (g, device, mountpoint);
16155     if (r == -1)
16156       return -1;
16157   }
16158   /* TestOutputTrue for mkdir_p (1) */
16159   {
16160     char path[] = "/new/foo/bar";
16161     int r;
16162     suppress_error = 0;
16163     r = guestfs_mkdir_p (g, path);
16164     if (r == -1)
16165       return -1;
16166   }
16167   {
16168     char path[] = "/new/foo";
16169     int r;
16170     suppress_error = 0;
16171     r = guestfs_is_dir (g, path);
16172     if (r == -1)
16173       return -1;
16174     if (!r) {
16175       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
16176       return -1;
16177     }
16178   }
16179   return 0;
16180 }
16181
16182 static int test_mkdir_p_2_skip (void)
16183 {
16184   const char *str;
16185
16186   str = getenv ("TEST_ONLY");
16187   if (str)
16188     return strstr (str, "mkdir_p") == NULL;
16189   str = getenv ("SKIP_TEST_MKDIR_P_2");
16190   if (str && strcmp (str, "1") == 0) return 1;
16191   str = getenv ("SKIP_TEST_MKDIR_P");
16192   if (str && strcmp (str, "1") == 0) return 1;
16193   return 0;
16194 }
16195
16196 static int test_mkdir_p_2 (void)
16197 {
16198   if (test_mkdir_p_2_skip ()) {
16199     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
16200     return 0;
16201   }
16202
16203   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
16204   {
16205     char device[] = "/dev/sda";
16206     int r;
16207     suppress_error = 0;
16208     r = guestfs_blockdev_setrw (g, device);
16209     if (r == -1)
16210       return -1;
16211   }
16212   {
16213     int r;
16214     suppress_error = 0;
16215     r = guestfs_umount_all (g);
16216     if (r == -1)
16217       return -1;
16218   }
16219   {
16220     int r;
16221     suppress_error = 0;
16222     r = guestfs_lvm_remove_all (g);
16223     if (r == -1)
16224       return -1;
16225   }
16226   {
16227     char device[] = "/dev/sda";
16228     char lines_0[] = ",";
16229     char *lines[] = {
16230       lines_0,
16231       NULL
16232     };
16233     int r;
16234     suppress_error = 0;
16235     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16236     if (r == -1)
16237       return -1;
16238   }
16239   {
16240     char fstype[] = "ext2";
16241     char device[] = "/dev/sda1";
16242     int r;
16243     suppress_error = 0;
16244     r = guestfs_mkfs (g, fstype, device);
16245     if (r == -1)
16246       return -1;
16247   }
16248   {
16249     char device[] = "/dev/sda1";
16250     char mountpoint[] = "/";
16251     int r;
16252     suppress_error = 0;
16253     r = guestfs_mount (g, device, mountpoint);
16254     if (r == -1)
16255       return -1;
16256   }
16257   /* TestOutputTrue for mkdir_p (2) */
16258   {
16259     char path[] = "/new/foo/bar";
16260     int r;
16261     suppress_error = 0;
16262     r = guestfs_mkdir_p (g, path);
16263     if (r == -1)
16264       return -1;
16265   }
16266   {
16267     char path[] = "/new";
16268     int r;
16269     suppress_error = 0;
16270     r = guestfs_is_dir (g, path);
16271     if (r == -1)
16272       return -1;
16273     if (!r) {
16274       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
16275       return -1;
16276     }
16277   }
16278   return 0;
16279 }
16280
16281 static int test_mkdir_p_3_skip (void)
16282 {
16283   const char *str;
16284
16285   str = getenv ("TEST_ONLY");
16286   if (str)
16287     return strstr (str, "mkdir_p") == NULL;
16288   str = getenv ("SKIP_TEST_MKDIR_P_3");
16289   if (str && strcmp (str, "1") == 0) return 1;
16290   str = getenv ("SKIP_TEST_MKDIR_P");
16291   if (str && strcmp (str, "1") == 0) return 1;
16292   return 0;
16293 }
16294
16295 static int test_mkdir_p_3 (void)
16296 {
16297   if (test_mkdir_p_3_skip ()) {
16298     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
16299     return 0;
16300   }
16301
16302   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
16303   {
16304     char device[] = "/dev/sda";
16305     int r;
16306     suppress_error = 0;
16307     r = guestfs_blockdev_setrw (g, device);
16308     if (r == -1)
16309       return -1;
16310   }
16311   {
16312     int r;
16313     suppress_error = 0;
16314     r = guestfs_umount_all (g);
16315     if (r == -1)
16316       return -1;
16317   }
16318   {
16319     int r;
16320     suppress_error = 0;
16321     r = guestfs_lvm_remove_all (g);
16322     if (r == -1)
16323       return -1;
16324   }
16325   {
16326     char device[] = "/dev/sda";
16327     char lines_0[] = ",";
16328     char *lines[] = {
16329       lines_0,
16330       NULL
16331     };
16332     int r;
16333     suppress_error = 0;
16334     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16335     if (r == -1)
16336       return -1;
16337   }
16338   {
16339     char fstype[] = "ext2";
16340     char device[] = "/dev/sda1";
16341     int r;
16342     suppress_error = 0;
16343     r = guestfs_mkfs (g, fstype, device);
16344     if (r == -1)
16345       return -1;
16346   }
16347   {
16348     char device[] = "/dev/sda1";
16349     char mountpoint[] = "/";
16350     int r;
16351     suppress_error = 0;
16352     r = guestfs_mount (g, device, mountpoint);
16353     if (r == -1)
16354       return -1;
16355   }
16356   /* TestRun for mkdir_p (3) */
16357   {
16358     char path[] = "/new";
16359     int r;
16360     suppress_error = 0;
16361     r = guestfs_mkdir (g, path);
16362     if (r == -1)
16363       return -1;
16364   }
16365   {
16366     char path[] = "/new";
16367     int r;
16368     suppress_error = 0;
16369     r = guestfs_mkdir_p (g, path);
16370     if (r == -1)
16371       return -1;
16372   }
16373   return 0;
16374 }
16375
16376 static int test_mkdir_p_4_skip (void)
16377 {
16378   const char *str;
16379
16380   str = getenv ("TEST_ONLY");
16381   if (str)
16382     return strstr (str, "mkdir_p") == NULL;
16383   str = getenv ("SKIP_TEST_MKDIR_P_4");
16384   if (str && strcmp (str, "1") == 0) return 1;
16385   str = getenv ("SKIP_TEST_MKDIR_P");
16386   if (str && strcmp (str, "1") == 0) return 1;
16387   return 0;
16388 }
16389
16390 static int test_mkdir_p_4 (void)
16391 {
16392   if (test_mkdir_p_4_skip ()) {
16393     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
16394     return 0;
16395   }
16396
16397   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
16398   {
16399     char device[] = "/dev/sda";
16400     int r;
16401     suppress_error = 0;
16402     r = guestfs_blockdev_setrw (g, device);
16403     if (r == -1)
16404       return -1;
16405   }
16406   {
16407     int r;
16408     suppress_error = 0;
16409     r = guestfs_umount_all (g);
16410     if (r == -1)
16411       return -1;
16412   }
16413   {
16414     int r;
16415     suppress_error = 0;
16416     r = guestfs_lvm_remove_all (g);
16417     if (r == -1)
16418       return -1;
16419   }
16420   {
16421     char device[] = "/dev/sda";
16422     char lines_0[] = ",";
16423     char *lines[] = {
16424       lines_0,
16425       NULL
16426     };
16427     int r;
16428     suppress_error = 0;
16429     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16430     if (r == -1)
16431       return -1;
16432   }
16433   {
16434     char fstype[] = "ext2";
16435     char device[] = "/dev/sda1";
16436     int r;
16437     suppress_error = 0;
16438     r = guestfs_mkfs (g, fstype, device);
16439     if (r == -1)
16440       return -1;
16441   }
16442   {
16443     char device[] = "/dev/sda1";
16444     char mountpoint[] = "/";
16445     int r;
16446     suppress_error = 0;
16447     r = guestfs_mount (g, device, mountpoint);
16448     if (r == -1)
16449       return -1;
16450   }
16451   /* TestLastFail for mkdir_p (4) */
16452   {
16453     char path[] = "/new";
16454     int r;
16455     suppress_error = 0;
16456     r = guestfs_touch (g, path);
16457     if (r == -1)
16458       return -1;
16459   }
16460   {
16461     char path[] = "/new";
16462     int r;
16463     suppress_error = 1;
16464     r = guestfs_mkdir_p (g, path);
16465     if (r != -1)
16466       return -1;
16467   }
16468   return 0;
16469 }
16470
16471 static int test_mkdir_0_skip (void)
16472 {
16473   const char *str;
16474
16475   str = getenv ("TEST_ONLY");
16476   if (str)
16477     return strstr (str, "mkdir") == NULL;
16478   str = getenv ("SKIP_TEST_MKDIR_0");
16479   if (str && strcmp (str, "1") == 0) return 1;
16480   str = getenv ("SKIP_TEST_MKDIR");
16481   if (str && strcmp (str, "1") == 0) return 1;
16482   return 0;
16483 }
16484
16485 static int test_mkdir_0 (void)
16486 {
16487   if (test_mkdir_0_skip ()) {
16488     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
16489     return 0;
16490   }
16491
16492   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
16493   {
16494     char device[] = "/dev/sda";
16495     int r;
16496     suppress_error = 0;
16497     r = guestfs_blockdev_setrw (g, device);
16498     if (r == -1)
16499       return -1;
16500   }
16501   {
16502     int r;
16503     suppress_error = 0;
16504     r = guestfs_umount_all (g);
16505     if (r == -1)
16506       return -1;
16507   }
16508   {
16509     int r;
16510     suppress_error = 0;
16511     r = guestfs_lvm_remove_all (g);
16512     if (r == -1)
16513       return -1;
16514   }
16515   {
16516     char device[] = "/dev/sda";
16517     char lines_0[] = ",";
16518     char *lines[] = {
16519       lines_0,
16520       NULL
16521     };
16522     int r;
16523     suppress_error = 0;
16524     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16525     if (r == -1)
16526       return -1;
16527   }
16528   {
16529     char fstype[] = "ext2";
16530     char device[] = "/dev/sda1";
16531     int r;
16532     suppress_error = 0;
16533     r = guestfs_mkfs (g, fstype, device);
16534     if (r == -1)
16535       return -1;
16536   }
16537   {
16538     char device[] = "/dev/sda1";
16539     char mountpoint[] = "/";
16540     int r;
16541     suppress_error = 0;
16542     r = guestfs_mount (g, device, mountpoint);
16543     if (r == -1)
16544       return -1;
16545   }
16546   /* TestOutputTrue for mkdir (0) */
16547   {
16548     char path[] = "/new";
16549     int r;
16550     suppress_error = 0;
16551     r = guestfs_mkdir (g, path);
16552     if (r == -1)
16553       return -1;
16554   }
16555   {
16556     char path[] = "/new";
16557     int r;
16558     suppress_error = 0;
16559     r = guestfs_is_dir (g, path);
16560     if (r == -1)
16561       return -1;
16562     if (!r) {
16563       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
16564       return -1;
16565     }
16566   }
16567   return 0;
16568 }
16569
16570 static int test_mkdir_1_skip (void)
16571 {
16572   const char *str;
16573
16574   str = getenv ("TEST_ONLY");
16575   if (str)
16576     return strstr (str, "mkdir") == NULL;
16577   str = getenv ("SKIP_TEST_MKDIR_1");
16578   if (str && strcmp (str, "1") == 0) return 1;
16579   str = getenv ("SKIP_TEST_MKDIR");
16580   if (str && strcmp (str, "1") == 0) return 1;
16581   return 0;
16582 }
16583
16584 static int test_mkdir_1 (void)
16585 {
16586   if (test_mkdir_1_skip ()) {
16587     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
16588     return 0;
16589   }
16590
16591   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
16592   {
16593     char device[] = "/dev/sda";
16594     int r;
16595     suppress_error = 0;
16596     r = guestfs_blockdev_setrw (g, device);
16597     if (r == -1)
16598       return -1;
16599   }
16600   {
16601     int r;
16602     suppress_error = 0;
16603     r = guestfs_umount_all (g);
16604     if (r == -1)
16605       return -1;
16606   }
16607   {
16608     int r;
16609     suppress_error = 0;
16610     r = guestfs_lvm_remove_all (g);
16611     if (r == -1)
16612       return -1;
16613   }
16614   {
16615     char device[] = "/dev/sda";
16616     char lines_0[] = ",";
16617     char *lines[] = {
16618       lines_0,
16619       NULL
16620     };
16621     int r;
16622     suppress_error = 0;
16623     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16624     if (r == -1)
16625       return -1;
16626   }
16627   {
16628     char fstype[] = "ext2";
16629     char device[] = "/dev/sda1";
16630     int r;
16631     suppress_error = 0;
16632     r = guestfs_mkfs (g, fstype, device);
16633     if (r == -1)
16634       return -1;
16635   }
16636   {
16637     char device[] = "/dev/sda1";
16638     char mountpoint[] = "/";
16639     int r;
16640     suppress_error = 0;
16641     r = guestfs_mount (g, device, mountpoint);
16642     if (r == -1)
16643       return -1;
16644   }
16645   /* TestLastFail for mkdir (1) */
16646   {
16647     char path[] = "/new/foo/bar";
16648     int r;
16649     suppress_error = 1;
16650     r = guestfs_mkdir (g, path);
16651     if (r != -1)
16652       return -1;
16653   }
16654   return 0;
16655 }
16656
16657 static int test_rm_rf_0_skip (void)
16658 {
16659   const char *str;
16660
16661   str = getenv ("TEST_ONLY");
16662   if (str)
16663     return strstr (str, "rm_rf") == NULL;
16664   str = getenv ("SKIP_TEST_RM_RF_0");
16665   if (str && strcmp (str, "1") == 0) return 1;
16666   str = getenv ("SKIP_TEST_RM_RF");
16667   if (str && strcmp (str, "1") == 0) return 1;
16668   return 0;
16669 }
16670
16671 static int test_rm_rf_0 (void)
16672 {
16673   if (test_rm_rf_0_skip ()) {
16674     printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
16675     return 0;
16676   }
16677
16678   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
16679   {
16680     char device[] = "/dev/sda";
16681     int r;
16682     suppress_error = 0;
16683     r = guestfs_blockdev_setrw (g, device);
16684     if (r == -1)
16685       return -1;
16686   }
16687   {
16688     int r;
16689     suppress_error = 0;
16690     r = guestfs_umount_all (g);
16691     if (r == -1)
16692       return -1;
16693   }
16694   {
16695     int r;
16696     suppress_error = 0;
16697     r = guestfs_lvm_remove_all (g);
16698     if (r == -1)
16699       return -1;
16700   }
16701   {
16702     char device[] = "/dev/sda";
16703     char lines_0[] = ",";
16704     char *lines[] = {
16705       lines_0,
16706       NULL
16707     };
16708     int r;
16709     suppress_error = 0;
16710     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16711     if (r == -1)
16712       return -1;
16713   }
16714   {
16715     char fstype[] = "ext2";
16716     char device[] = "/dev/sda1";
16717     int r;
16718     suppress_error = 0;
16719     r = guestfs_mkfs (g, fstype, device);
16720     if (r == -1)
16721       return -1;
16722   }
16723   {
16724     char device[] = "/dev/sda1";
16725     char mountpoint[] = "/";
16726     int r;
16727     suppress_error = 0;
16728     r = guestfs_mount (g, device, mountpoint);
16729     if (r == -1)
16730       return -1;
16731   }
16732   /* TestOutputFalse for rm_rf (0) */
16733   {
16734     char path[] = "/new";
16735     int r;
16736     suppress_error = 0;
16737     r = guestfs_mkdir (g, path);
16738     if (r == -1)
16739       return -1;
16740   }
16741   {
16742     char path[] = "/new/foo";
16743     int r;
16744     suppress_error = 0;
16745     r = guestfs_mkdir (g, path);
16746     if (r == -1)
16747       return -1;
16748   }
16749   {
16750     char path[] = "/new/foo/bar";
16751     int r;
16752     suppress_error = 0;
16753     r = guestfs_touch (g, path);
16754     if (r == -1)
16755       return -1;
16756   }
16757   {
16758     char path[] = "/new";
16759     int r;
16760     suppress_error = 0;
16761     r = guestfs_rm_rf (g, path);
16762     if (r == -1)
16763       return -1;
16764   }
16765   {
16766     char path[] = "/new";
16767     int r;
16768     suppress_error = 0;
16769     r = guestfs_exists (g, path);
16770     if (r == -1)
16771       return -1;
16772     if (r) {
16773       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16774       return -1;
16775     }
16776   }
16777   return 0;
16778 }
16779
16780 static int test_rmdir_0_skip (void)
16781 {
16782   const char *str;
16783
16784   str = getenv ("TEST_ONLY");
16785   if (str)
16786     return strstr (str, "rmdir") == NULL;
16787   str = getenv ("SKIP_TEST_RMDIR_0");
16788   if (str && strcmp (str, "1") == 0) return 1;
16789   str = getenv ("SKIP_TEST_RMDIR");
16790   if (str && strcmp (str, "1") == 0) return 1;
16791   return 0;
16792 }
16793
16794 static int test_rmdir_0 (void)
16795 {
16796   if (test_rmdir_0_skip ()) {
16797     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
16798     return 0;
16799   }
16800
16801   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16802   {
16803     char device[] = "/dev/sda";
16804     int r;
16805     suppress_error = 0;
16806     r = guestfs_blockdev_setrw (g, device);
16807     if (r == -1)
16808       return -1;
16809   }
16810   {
16811     int r;
16812     suppress_error = 0;
16813     r = guestfs_umount_all (g);
16814     if (r == -1)
16815       return -1;
16816   }
16817   {
16818     int r;
16819     suppress_error = 0;
16820     r = guestfs_lvm_remove_all (g);
16821     if (r == -1)
16822       return -1;
16823   }
16824   {
16825     char device[] = "/dev/sda";
16826     char lines_0[] = ",";
16827     char *lines[] = {
16828       lines_0,
16829       NULL
16830     };
16831     int r;
16832     suppress_error = 0;
16833     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16834     if (r == -1)
16835       return -1;
16836   }
16837   {
16838     char fstype[] = "ext2";
16839     char device[] = "/dev/sda1";
16840     int r;
16841     suppress_error = 0;
16842     r = guestfs_mkfs (g, fstype, device);
16843     if (r == -1)
16844       return -1;
16845   }
16846   {
16847     char device[] = "/dev/sda1";
16848     char mountpoint[] = "/";
16849     int r;
16850     suppress_error = 0;
16851     r = guestfs_mount (g, device, mountpoint);
16852     if (r == -1)
16853       return -1;
16854   }
16855   /* TestRun for rmdir (0) */
16856   {
16857     char path[] = "/new";
16858     int r;
16859     suppress_error = 0;
16860     r = guestfs_mkdir (g, path);
16861     if (r == -1)
16862       return -1;
16863   }
16864   {
16865     char path[] = "/new";
16866     int r;
16867     suppress_error = 0;
16868     r = guestfs_rmdir (g, path);
16869     if (r == -1)
16870       return -1;
16871   }
16872   return 0;
16873 }
16874
16875 static int test_rmdir_1_skip (void)
16876 {
16877   const char *str;
16878
16879   str = getenv ("TEST_ONLY");
16880   if (str)
16881     return strstr (str, "rmdir") == NULL;
16882   str = getenv ("SKIP_TEST_RMDIR_1");
16883   if (str && strcmp (str, "1") == 0) return 1;
16884   str = getenv ("SKIP_TEST_RMDIR");
16885   if (str && strcmp (str, "1") == 0) return 1;
16886   return 0;
16887 }
16888
16889 static int test_rmdir_1 (void)
16890 {
16891   if (test_rmdir_1_skip ()) {
16892     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16893     return 0;
16894   }
16895
16896   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16897   {
16898     char device[] = "/dev/sda";
16899     int r;
16900     suppress_error = 0;
16901     r = guestfs_blockdev_setrw (g, device);
16902     if (r == -1)
16903       return -1;
16904   }
16905   {
16906     int r;
16907     suppress_error = 0;
16908     r = guestfs_umount_all (g);
16909     if (r == -1)
16910       return -1;
16911   }
16912   {
16913     int r;
16914     suppress_error = 0;
16915     r = guestfs_lvm_remove_all (g);
16916     if (r == -1)
16917       return -1;
16918   }
16919   {
16920     char device[] = "/dev/sda";
16921     char lines_0[] = ",";
16922     char *lines[] = {
16923       lines_0,
16924       NULL
16925     };
16926     int r;
16927     suppress_error = 0;
16928     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16929     if (r == -1)
16930       return -1;
16931   }
16932   {
16933     char fstype[] = "ext2";
16934     char device[] = "/dev/sda1";
16935     int r;
16936     suppress_error = 0;
16937     r = guestfs_mkfs (g, fstype, device);
16938     if (r == -1)
16939       return -1;
16940   }
16941   {
16942     char device[] = "/dev/sda1";
16943     char mountpoint[] = "/";
16944     int r;
16945     suppress_error = 0;
16946     r = guestfs_mount (g, device, mountpoint);
16947     if (r == -1)
16948       return -1;
16949   }
16950   /* TestLastFail for rmdir (1) */
16951   {
16952     char path[] = "/new";
16953     int r;
16954     suppress_error = 1;
16955     r = guestfs_rmdir (g, path);
16956     if (r != -1)
16957       return -1;
16958   }
16959   return 0;
16960 }
16961
16962 static int test_rmdir_2_skip (void)
16963 {
16964   const char *str;
16965
16966   str = getenv ("TEST_ONLY");
16967   if (str)
16968     return strstr (str, "rmdir") == NULL;
16969   str = getenv ("SKIP_TEST_RMDIR_2");
16970   if (str && strcmp (str, "1") == 0) return 1;
16971   str = getenv ("SKIP_TEST_RMDIR");
16972   if (str && strcmp (str, "1") == 0) return 1;
16973   return 0;
16974 }
16975
16976 static int test_rmdir_2 (void)
16977 {
16978   if (test_rmdir_2_skip ()) {
16979     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16980     return 0;
16981   }
16982
16983   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16984   {
16985     char device[] = "/dev/sda";
16986     int r;
16987     suppress_error = 0;
16988     r = guestfs_blockdev_setrw (g, device);
16989     if (r == -1)
16990       return -1;
16991   }
16992   {
16993     int r;
16994     suppress_error = 0;
16995     r = guestfs_umount_all (g);
16996     if (r == -1)
16997       return -1;
16998   }
16999   {
17000     int r;
17001     suppress_error = 0;
17002     r = guestfs_lvm_remove_all (g);
17003     if (r == -1)
17004       return -1;
17005   }
17006   {
17007     char device[] = "/dev/sda";
17008     char lines_0[] = ",";
17009     char *lines[] = {
17010       lines_0,
17011       NULL
17012     };
17013     int r;
17014     suppress_error = 0;
17015     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17016     if (r == -1)
17017       return -1;
17018   }
17019   {
17020     char fstype[] = "ext2";
17021     char device[] = "/dev/sda1";
17022     int r;
17023     suppress_error = 0;
17024     r = guestfs_mkfs (g, fstype, device);
17025     if (r == -1)
17026       return -1;
17027   }
17028   {
17029     char device[] = "/dev/sda1";
17030     char mountpoint[] = "/";
17031     int r;
17032     suppress_error = 0;
17033     r = guestfs_mount (g, device, mountpoint);
17034     if (r == -1)
17035       return -1;
17036   }
17037   /* TestLastFail for rmdir (2) */
17038   {
17039     char path[] = "/new";
17040     int r;
17041     suppress_error = 0;
17042     r = guestfs_touch (g, path);
17043     if (r == -1)
17044       return -1;
17045   }
17046   {
17047     char path[] = "/new";
17048     int r;
17049     suppress_error = 1;
17050     r = guestfs_rmdir (g, path);
17051     if (r != -1)
17052       return -1;
17053   }
17054   return 0;
17055 }
17056
17057 static int test_rm_0_skip (void)
17058 {
17059   const char *str;
17060
17061   str = getenv ("TEST_ONLY");
17062   if (str)
17063     return strstr (str, "rm") == NULL;
17064   str = getenv ("SKIP_TEST_RM_0");
17065   if (str && strcmp (str, "1") == 0) return 1;
17066   str = getenv ("SKIP_TEST_RM");
17067   if (str && strcmp (str, "1") == 0) return 1;
17068   return 0;
17069 }
17070
17071 static int test_rm_0 (void)
17072 {
17073   if (test_rm_0_skip ()) {
17074     printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
17075     return 0;
17076   }
17077
17078   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
17079   {
17080     char device[] = "/dev/sda";
17081     int r;
17082     suppress_error = 0;
17083     r = guestfs_blockdev_setrw (g, device);
17084     if (r == -1)
17085       return -1;
17086   }
17087   {
17088     int r;
17089     suppress_error = 0;
17090     r = guestfs_umount_all (g);
17091     if (r == -1)
17092       return -1;
17093   }
17094   {
17095     int r;
17096     suppress_error = 0;
17097     r = guestfs_lvm_remove_all (g);
17098     if (r == -1)
17099       return -1;
17100   }
17101   {
17102     char device[] = "/dev/sda";
17103     char lines_0[] = ",";
17104     char *lines[] = {
17105       lines_0,
17106       NULL
17107     };
17108     int r;
17109     suppress_error = 0;
17110     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17111     if (r == -1)
17112       return -1;
17113   }
17114   {
17115     char fstype[] = "ext2";
17116     char device[] = "/dev/sda1";
17117     int r;
17118     suppress_error = 0;
17119     r = guestfs_mkfs (g, fstype, device);
17120     if (r == -1)
17121       return -1;
17122   }
17123   {
17124     char device[] = "/dev/sda1";
17125     char mountpoint[] = "/";
17126     int r;
17127     suppress_error = 0;
17128     r = guestfs_mount (g, device, mountpoint);
17129     if (r == -1)
17130       return -1;
17131   }
17132   /* TestRun for rm (0) */
17133   {
17134     char path[] = "/new";
17135     int r;
17136     suppress_error = 0;
17137     r = guestfs_touch (g, path);
17138     if (r == -1)
17139       return -1;
17140   }
17141   {
17142     char path[] = "/new";
17143     int r;
17144     suppress_error = 0;
17145     r = guestfs_rm (g, path);
17146     if (r == -1)
17147       return -1;
17148   }
17149   return 0;
17150 }
17151
17152 static int test_rm_1_skip (void)
17153 {
17154   const char *str;
17155
17156   str = getenv ("TEST_ONLY");
17157   if (str)
17158     return strstr (str, "rm") == NULL;
17159   str = getenv ("SKIP_TEST_RM_1");
17160   if (str && strcmp (str, "1") == 0) return 1;
17161   str = getenv ("SKIP_TEST_RM");
17162   if (str && strcmp (str, "1") == 0) return 1;
17163   return 0;
17164 }
17165
17166 static int test_rm_1 (void)
17167 {
17168   if (test_rm_1_skip ()) {
17169     printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
17170     return 0;
17171   }
17172
17173   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
17174   {
17175     char device[] = "/dev/sda";
17176     int r;
17177     suppress_error = 0;
17178     r = guestfs_blockdev_setrw (g, device);
17179     if (r == -1)
17180       return -1;
17181   }
17182   {
17183     int r;
17184     suppress_error = 0;
17185     r = guestfs_umount_all (g);
17186     if (r == -1)
17187       return -1;
17188   }
17189   {
17190     int r;
17191     suppress_error = 0;
17192     r = guestfs_lvm_remove_all (g);
17193     if (r == -1)
17194       return -1;
17195   }
17196   {
17197     char device[] = "/dev/sda";
17198     char lines_0[] = ",";
17199     char *lines[] = {
17200       lines_0,
17201       NULL
17202     };
17203     int r;
17204     suppress_error = 0;
17205     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17206     if (r == -1)
17207       return -1;
17208   }
17209   {
17210     char fstype[] = "ext2";
17211     char device[] = "/dev/sda1";
17212     int r;
17213     suppress_error = 0;
17214     r = guestfs_mkfs (g, fstype, device);
17215     if (r == -1)
17216       return -1;
17217   }
17218   {
17219     char device[] = "/dev/sda1";
17220     char mountpoint[] = "/";
17221     int r;
17222     suppress_error = 0;
17223     r = guestfs_mount (g, device, mountpoint);
17224     if (r == -1)
17225       return -1;
17226   }
17227   /* TestLastFail for rm (1) */
17228   {
17229     char path[] = "/new";
17230     int r;
17231     suppress_error = 1;
17232     r = guestfs_rm (g, path);
17233     if (r != -1)
17234       return -1;
17235   }
17236   return 0;
17237 }
17238
17239 static int test_rm_2_skip (void)
17240 {
17241   const char *str;
17242
17243   str = getenv ("TEST_ONLY");
17244   if (str)
17245     return strstr (str, "rm") == NULL;
17246   str = getenv ("SKIP_TEST_RM_2");
17247   if (str && strcmp (str, "1") == 0) return 1;
17248   str = getenv ("SKIP_TEST_RM");
17249   if (str && strcmp (str, "1") == 0) return 1;
17250   return 0;
17251 }
17252
17253 static int test_rm_2 (void)
17254 {
17255   if (test_rm_2_skip ()) {
17256     printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
17257     return 0;
17258   }
17259
17260   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
17261   {
17262     char device[] = "/dev/sda";
17263     int r;
17264     suppress_error = 0;
17265     r = guestfs_blockdev_setrw (g, device);
17266     if (r == -1)
17267       return -1;
17268   }
17269   {
17270     int r;
17271     suppress_error = 0;
17272     r = guestfs_umount_all (g);
17273     if (r == -1)
17274       return -1;
17275   }
17276   {
17277     int r;
17278     suppress_error = 0;
17279     r = guestfs_lvm_remove_all (g);
17280     if (r == -1)
17281       return -1;
17282   }
17283   {
17284     char device[] = "/dev/sda";
17285     char lines_0[] = ",";
17286     char *lines[] = {
17287       lines_0,
17288       NULL
17289     };
17290     int r;
17291     suppress_error = 0;
17292     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17293     if (r == -1)
17294       return -1;
17295   }
17296   {
17297     char fstype[] = "ext2";
17298     char device[] = "/dev/sda1";
17299     int r;
17300     suppress_error = 0;
17301     r = guestfs_mkfs (g, fstype, device);
17302     if (r == -1)
17303       return -1;
17304   }
17305   {
17306     char device[] = "/dev/sda1";
17307     char mountpoint[] = "/";
17308     int r;
17309     suppress_error = 0;
17310     r = guestfs_mount (g, device, mountpoint);
17311     if (r == -1)
17312       return -1;
17313   }
17314   /* TestLastFail for rm (2) */
17315   {
17316     char path[] = "/new";
17317     int r;
17318     suppress_error = 0;
17319     r = guestfs_mkdir (g, path);
17320     if (r == -1)
17321       return -1;
17322   }
17323   {
17324     char path[] = "/new";
17325     int r;
17326     suppress_error = 1;
17327     r = guestfs_rm (g, path);
17328     if (r != -1)
17329       return -1;
17330   }
17331   return 0;
17332 }
17333
17334 static int test_read_lines_0_skip (void)
17335 {
17336   const char *str;
17337
17338   str = getenv ("TEST_ONLY");
17339   if (str)
17340     return strstr (str, "read_lines") == NULL;
17341   str = getenv ("SKIP_TEST_READ_LINES_0");
17342   if (str && strcmp (str, "1") == 0) return 1;
17343   str = getenv ("SKIP_TEST_READ_LINES");
17344   if (str && strcmp (str, "1") == 0) return 1;
17345   return 0;
17346 }
17347
17348 static int test_read_lines_0 (void)
17349 {
17350   if (test_read_lines_0_skip ()) {
17351     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
17352     return 0;
17353   }
17354
17355   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
17356   {
17357     char device[] = "/dev/sda";
17358     int r;
17359     suppress_error = 0;
17360     r = guestfs_blockdev_setrw (g, device);
17361     if (r == -1)
17362       return -1;
17363   }
17364   {
17365     int r;
17366     suppress_error = 0;
17367     r = guestfs_umount_all (g);
17368     if (r == -1)
17369       return -1;
17370   }
17371   {
17372     int r;
17373     suppress_error = 0;
17374     r = guestfs_lvm_remove_all (g);
17375     if (r == -1)
17376       return -1;
17377   }
17378   {
17379     char device[] = "/dev/sda";
17380     char lines_0[] = ",";
17381     char *lines[] = {
17382       lines_0,
17383       NULL
17384     };
17385     int r;
17386     suppress_error = 0;
17387     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17388     if (r == -1)
17389       return -1;
17390   }
17391   {
17392     char fstype[] = "ext2";
17393     char device[] = "/dev/sda1";
17394     int r;
17395     suppress_error = 0;
17396     r = guestfs_mkfs (g, fstype, device);
17397     if (r == -1)
17398       return -1;
17399   }
17400   {
17401     char device[] = "/dev/sda1";
17402     char mountpoint[] = "/";
17403     int r;
17404     suppress_error = 0;
17405     r = guestfs_mount (g, device, mountpoint);
17406     if (r == -1)
17407       return -1;
17408   }
17409   /* TestOutputList for read_lines (0) */
17410   {
17411     char path[] = "/new";
17412     char content[] = "line1\r\nline2\nline3";
17413     int r;
17414     suppress_error = 0;
17415     r = guestfs_write_file (g, path, content, 0);
17416     if (r == -1)
17417       return -1;
17418   }
17419   {
17420     char path[] = "/new";
17421     char **r;
17422     int i;
17423     suppress_error = 0;
17424     r = guestfs_read_lines (g, path);
17425     if (r == NULL)
17426       return -1;
17427     if (!r[0]) {
17428       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17429       print_strings (r);
17430       return -1;
17431     }
17432     {
17433       char expected[] = "line1";
17434       if (strcmp (r[0], expected) != 0) {
17435         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17436         return -1;
17437       }
17438     }
17439     if (!r[1]) {
17440       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17441       print_strings (r);
17442       return -1;
17443     }
17444     {
17445       char expected[] = "line2";
17446       if (strcmp (r[1], expected) != 0) {
17447         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17448         return -1;
17449       }
17450     }
17451     if (!r[2]) {
17452       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17453       print_strings (r);
17454       return -1;
17455     }
17456     {
17457       char expected[] = "line3";
17458       if (strcmp (r[2], expected) != 0) {
17459         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17460         return -1;
17461       }
17462     }
17463     if (r[3] != NULL) {
17464       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
17465       print_strings (r);
17466       return -1;
17467     }
17468     for (i = 0; r[i] != NULL; ++i)
17469       free (r[i]);
17470     free (r);
17471   }
17472   return 0;
17473 }
17474
17475 static int test_read_lines_1_skip (void)
17476 {
17477   const char *str;
17478
17479   str = getenv ("TEST_ONLY");
17480   if (str)
17481     return strstr (str, "read_lines") == NULL;
17482   str = getenv ("SKIP_TEST_READ_LINES_1");
17483   if (str && strcmp (str, "1") == 0) return 1;
17484   str = getenv ("SKIP_TEST_READ_LINES");
17485   if (str && strcmp (str, "1") == 0) return 1;
17486   return 0;
17487 }
17488
17489 static int test_read_lines_1 (void)
17490 {
17491   if (test_read_lines_1_skip ()) {
17492     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
17493     return 0;
17494   }
17495
17496   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
17497   {
17498     char device[] = "/dev/sda";
17499     int r;
17500     suppress_error = 0;
17501     r = guestfs_blockdev_setrw (g, device);
17502     if (r == -1)
17503       return -1;
17504   }
17505   {
17506     int r;
17507     suppress_error = 0;
17508     r = guestfs_umount_all (g);
17509     if (r == -1)
17510       return -1;
17511   }
17512   {
17513     int r;
17514     suppress_error = 0;
17515     r = guestfs_lvm_remove_all (g);
17516     if (r == -1)
17517       return -1;
17518   }
17519   {
17520     char device[] = "/dev/sda";
17521     char lines_0[] = ",";
17522     char *lines[] = {
17523       lines_0,
17524       NULL
17525     };
17526     int r;
17527     suppress_error = 0;
17528     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17529     if (r == -1)
17530       return -1;
17531   }
17532   {
17533     char fstype[] = "ext2";
17534     char device[] = "/dev/sda1";
17535     int r;
17536     suppress_error = 0;
17537     r = guestfs_mkfs (g, fstype, device);
17538     if (r == -1)
17539       return -1;
17540   }
17541   {
17542     char device[] = "/dev/sda1";
17543     char mountpoint[] = "/";
17544     int r;
17545     suppress_error = 0;
17546     r = guestfs_mount (g, device, mountpoint);
17547     if (r == -1)
17548       return -1;
17549   }
17550   /* TestOutputList for read_lines (1) */
17551   {
17552     char path[] = "/new";
17553     char content[] = "";
17554     int r;
17555     suppress_error = 0;
17556     r = guestfs_write_file (g, path, content, 0);
17557     if (r == -1)
17558       return -1;
17559   }
17560   {
17561     char path[] = "/new";
17562     char **r;
17563     int i;
17564     suppress_error = 0;
17565     r = guestfs_read_lines (g, path);
17566     if (r == NULL)
17567       return -1;
17568     if (r[0] != NULL) {
17569       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
17570       print_strings (r);
17571       return -1;
17572     }
17573     for (i = 0; r[i] != NULL; ++i)
17574       free (r[i]);
17575     free (r);
17576   }
17577   return 0;
17578 }
17579
17580 static int test_lvs_0_skip (void)
17581 {
17582   const char *str;
17583
17584   str = getenv ("TEST_ONLY");
17585   if (str)
17586     return strstr (str, "lvs") == NULL;
17587   str = getenv ("SKIP_TEST_LVS_0");
17588   if (str && strcmp (str, "1") == 0) return 1;
17589   str = getenv ("SKIP_TEST_LVS");
17590   if (str && strcmp (str, "1") == 0) return 1;
17591   return 0;
17592 }
17593
17594 static int test_lvs_0 (void)
17595 {
17596   if (test_lvs_0_skip ()) {
17597     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
17598     return 0;
17599   }
17600
17601   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
17602   {
17603     char device[] = "/dev/sda";
17604     int r;
17605     suppress_error = 0;
17606     r = guestfs_blockdev_setrw (g, device);
17607     if (r == -1)
17608       return -1;
17609   }
17610   {
17611     int r;
17612     suppress_error = 0;
17613     r = guestfs_umount_all (g);
17614     if (r == -1)
17615       return -1;
17616   }
17617   {
17618     int r;
17619     suppress_error = 0;
17620     r = guestfs_lvm_remove_all (g);
17621     if (r == -1)
17622       return -1;
17623   }
17624   {
17625     char device[] = "/dev/sda";
17626     char lines_0[] = ",";
17627     char *lines[] = {
17628       lines_0,
17629       NULL
17630     };
17631     int r;
17632     suppress_error = 0;
17633     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17634     if (r == -1)
17635       return -1;
17636   }
17637   {
17638     char device[] = "/dev/sda1";
17639     int r;
17640     suppress_error = 0;
17641     r = guestfs_pvcreate (g, device);
17642     if (r == -1)
17643       return -1;
17644   }
17645   {
17646     char volgroup[] = "VG";
17647     char physvols_0[] = "/dev/sda1";
17648     char *physvols[] = {
17649       physvols_0,
17650       NULL
17651     };
17652     int r;
17653     suppress_error = 0;
17654     r = guestfs_vgcreate (g, volgroup, physvols);
17655     if (r == -1)
17656       return -1;
17657   }
17658   {
17659     char logvol[] = "LV";
17660     char volgroup[] = "VG";
17661     int r;
17662     suppress_error = 0;
17663     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17664     if (r == -1)
17665       return -1;
17666   }
17667   {
17668     char fstype[] = "ext2";
17669     char device[] = "/dev/VG/LV";
17670     int r;
17671     suppress_error = 0;
17672     r = guestfs_mkfs (g, fstype, device);
17673     if (r == -1)
17674       return -1;
17675   }
17676   {
17677     char device[] = "/dev/VG/LV";
17678     char mountpoint[] = "/";
17679     int r;
17680     suppress_error = 0;
17681     r = guestfs_mount (g, device, mountpoint);
17682     if (r == -1)
17683       return -1;
17684   }
17685   /* TestOutputList for lvs (0) */
17686   {
17687     char **r;
17688     int i;
17689     suppress_error = 0;
17690     r = guestfs_lvs (g);
17691     if (r == NULL)
17692       return -1;
17693     if (!r[0]) {
17694       fprintf (stderr, "test_lvs_0: short list returned from command\n");
17695       print_strings (r);
17696       return -1;
17697     }
17698     {
17699       char expected[] = "/dev/VG/LV";
17700       if (strcmp (r[0], expected) != 0) {
17701         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17702         return -1;
17703       }
17704     }
17705     if (r[1] != NULL) {
17706       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
17707       print_strings (r);
17708       return -1;
17709     }
17710     for (i = 0; r[i] != NULL; ++i)
17711       free (r[i]);
17712     free (r);
17713   }
17714   return 0;
17715 }
17716
17717 static int test_lvs_1_skip (void)
17718 {
17719   const char *str;
17720
17721   str = getenv ("TEST_ONLY");
17722   if (str)
17723     return strstr (str, "lvs") == NULL;
17724   str = getenv ("SKIP_TEST_LVS_1");
17725   if (str && strcmp (str, "1") == 0) return 1;
17726   str = getenv ("SKIP_TEST_LVS");
17727   if (str && strcmp (str, "1") == 0) return 1;
17728   return 0;
17729 }
17730
17731 static int test_lvs_1 (void)
17732 {
17733   if (test_lvs_1_skip ()) {
17734     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
17735     return 0;
17736   }
17737
17738   /* InitNone|InitEmpty for test_lvs_1 */
17739   {
17740     char device[] = "/dev/sda";
17741     int r;
17742     suppress_error = 0;
17743     r = guestfs_blockdev_setrw (g, device);
17744     if (r == -1)
17745       return -1;
17746   }
17747   {
17748     int r;
17749     suppress_error = 0;
17750     r = guestfs_umount_all (g);
17751     if (r == -1)
17752       return -1;
17753   }
17754   {
17755     int r;
17756     suppress_error = 0;
17757     r = guestfs_lvm_remove_all (g);
17758     if (r == -1)
17759       return -1;
17760   }
17761   /* TestOutputList for lvs (1) */
17762   {
17763     char device[] = "/dev/sda";
17764     char lines_0[] = ",10";
17765     char lines_1[] = ",20";
17766     char lines_2[] = ",";
17767     char *lines[] = {
17768       lines_0,
17769       lines_1,
17770       lines_2,
17771       NULL
17772     };
17773     int r;
17774     suppress_error = 0;
17775     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17776     if (r == -1)
17777       return -1;
17778   }
17779   {
17780     char device[] = "/dev/sda1";
17781     int r;
17782     suppress_error = 0;
17783     r = guestfs_pvcreate (g, device);
17784     if (r == -1)
17785       return -1;
17786   }
17787   {
17788     char device[] = "/dev/sda2";
17789     int r;
17790     suppress_error = 0;
17791     r = guestfs_pvcreate (g, device);
17792     if (r == -1)
17793       return -1;
17794   }
17795   {
17796     char device[] = "/dev/sda3";
17797     int r;
17798     suppress_error = 0;
17799     r = guestfs_pvcreate (g, device);
17800     if (r == -1)
17801       return -1;
17802   }
17803   {
17804     char volgroup[] = "VG1";
17805     char physvols_0[] = "/dev/sda1";
17806     char physvols_1[] = "/dev/sda2";
17807     char *physvols[] = {
17808       physvols_0,
17809       physvols_1,
17810       NULL
17811     };
17812     int r;
17813     suppress_error = 0;
17814     r = guestfs_vgcreate (g, volgroup, physvols);
17815     if (r == -1)
17816       return -1;
17817   }
17818   {
17819     char volgroup[] = "VG2";
17820     char physvols_0[] = "/dev/sda3";
17821     char *physvols[] = {
17822       physvols_0,
17823       NULL
17824     };
17825     int r;
17826     suppress_error = 0;
17827     r = guestfs_vgcreate (g, volgroup, physvols);
17828     if (r == -1)
17829       return -1;
17830   }
17831   {
17832     char logvol[] = "LV1";
17833     char volgroup[] = "VG1";
17834     int r;
17835     suppress_error = 0;
17836     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17837     if (r == -1)
17838       return -1;
17839   }
17840   {
17841     char logvol[] = "LV2";
17842     char volgroup[] = "VG1";
17843     int r;
17844     suppress_error = 0;
17845     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17846     if (r == -1)
17847       return -1;
17848   }
17849   {
17850     char logvol[] = "LV3";
17851     char volgroup[] = "VG2";
17852     int r;
17853     suppress_error = 0;
17854     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17855     if (r == -1)
17856       return -1;
17857   }
17858   {
17859     char **r;
17860     int i;
17861     suppress_error = 0;
17862     r = guestfs_lvs (g);
17863     if (r == NULL)
17864       return -1;
17865     if (!r[0]) {
17866       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17867       print_strings (r);
17868       return -1;
17869     }
17870     {
17871       char expected[] = "/dev/VG1/LV1";
17872       if (strcmp (r[0], expected) != 0) {
17873         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17874         return -1;
17875       }
17876     }
17877     if (!r[1]) {
17878       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17879       print_strings (r);
17880       return -1;
17881     }
17882     {
17883       char expected[] = "/dev/VG1/LV2";
17884       if (strcmp (r[1], expected) != 0) {
17885         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17886         return -1;
17887       }
17888     }
17889     if (!r[2]) {
17890       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17891       print_strings (r);
17892       return -1;
17893     }
17894     {
17895       char expected[] = "/dev/VG2/LV3";
17896       if (strcmp (r[2], expected) != 0) {
17897         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17898         return -1;
17899       }
17900     }
17901     if (r[3] != NULL) {
17902       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17903       print_strings (r);
17904       return -1;
17905     }
17906     for (i = 0; r[i] != NULL; ++i)
17907       free (r[i]);
17908     free (r);
17909   }
17910   return 0;
17911 }
17912
17913 static int test_vgs_0_skip (void)
17914 {
17915   const char *str;
17916
17917   str = getenv ("TEST_ONLY");
17918   if (str)
17919     return strstr (str, "vgs") == NULL;
17920   str = getenv ("SKIP_TEST_VGS_0");
17921   if (str && strcmp (str, "1") == 0) return 1;
17922   str = getenv ("SKIP_TEST_VGS");
17923   if (str && strcmp (str, "1") == 0) return 1;
17924   return 0;
17925 }
17926
17927 static int test_vgs_0 (void)
17928 {
17929   if (test_vgs_0_skip ()) {
17930     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17931     return 0;
17932   }
17933
17934   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17935   {
17936     char device[] = "/dev/sda";
17937     int r;
17938     suppress_error = 0;
17939     r = guestfs_blockdev_setrw (g, device);
17940     if (r == -1)
17941       return -1;
17942   }
17943   {
17944     int r;
17945     suppress_error = 0;
17946     r = guestfs_umount_all (g);
17947     if (r == -1)
17948       return -1;
17949   }
17950   {
17951     int r;
17952     suppress_error = 0;
17953     r = guestfs_lvm_remove_all (g);
17954     if (r == -1)
17955       return -1;
17956   }
17957   {
17958     char device[] = "/dev/sda";
17959     char lines_0[] = ",";
17960     char *lines[] = {
17961       lines_0,
17962       NULL
17963     };
17964     int r;
17965     suppress_error = 0;
17966     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17967     if (r == -1)
17968       return -1;
17969   }
17970   {
17971     char device[] = "/dev/sda1";
17972     int r;
17973     suppress_error = 0;
17974     r = guestfs_pvcreate (g, device);
17975     if (r == -1)
17976       return -1;
17977   }
17978   {
17979     char volgroup[] = "VG";
17980     char physvols_0[] = "/dev/sda1";
17981     char *physvols[] = {
17982       physvols_0,
17983       NULL
17984     };
17985     int r;
17986     suppress_error = 0;
17987     r = guestfs_vgcreate (g, volgroup, physvols);
17988     if (r == -1)
17989       return -1;
17990   }
17991   {
17992     char logvol[] = "LV";
17993     char volgroup[] = "VG";
17994     int r;
17995     suppress_error = 0;
17996     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17997     if (r == -1)
17998       return -1;
17999   }
18000   {
18001     char fstype[] = "ext2";
18002     char device[] = "/dev/VG/LV";
18003     int r;
18004     suppress_error = 0;
18005     r = guestfs_mkfs (g, fstype, device);
18006     if (r == -1)
18007       return -1;
18008   }
18009   {
18010     char device[] = "/dev/VG/LV";
18011     char mountpoint[] = "/";
18012     int r;
18013     suppress_error = 0;
18014     r = guestfs_mount (g, device, mountpoint);
18015     if (r == -1)
18016       return -1;
18017   }
18018   /* TestOutputList for vgs (0) */
18019   {
18020     char **r;
18021     int i;
18022     suppress_error = 0;
18023     r = guestfs_vgs (g);
18024     if (r == NULL)
18025       return -1;
18026     if (!r[0]) {
18027       fprintf (stderr, "test_vgs_0: short list returned from command\n");
18028       print_strings (r);
18029       return -1;
18030     }
18031     {
18032       char expected[] = "VG";
18033       if (strcmp (r[0], expected) != 0) {
18034         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18035         return -1;
18036       }
18037     }
18038     if (r[1] != NULL) {
18039       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
18040       print_strings (r);
18041       return -1;
18042     }
18043     for (i = 0; r[i] != NULL; ++i)
18044       free (r[i]);
18045     free (r);
18046   }
18047   return 0;
18048 }
18049
18050 static int test_vgs_1_skip (void)
18051 {
18052   const char *str;
18053
18054   str = getenv ("TEST_ONLY");
18055   if (str)
18056     return strstr (str, "vgs") == NULL;
18057   str = getenv ("SKIP_TEST_VGS_1");
18058   if (str && strcmp (str, "1") == 0) return 1;
18059   str = getenv ("SKIP_TEST_VGS");
18060   if (str && strcmp (str, "1") == 0) return 1;
18061   return 0;
18062 }
18063
18064 static int test_vgs_1 (void)
18065 {
18066   if (test_vgs_1_skip ()) {
18067     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
18068     return 0;
18069   }
18070
18071   /* InitNone|InitEmpty for test_vgs_1 */
18072   {
18073     char device[] = "/dev/sda";
18074     int r;
18075     suppress_error = 0;
18076     r = guestfs_blockdev_setrw (g, device);
18077     if (r == -1)
18078       return -1;
18079   }
18080   {
18081     int r;
18082     suppress_error = 0;
18083     r = guestfs_umount_all (g);
18084     if (r == -1)
18085       return -1;
18086   }
18087   {
18088     int r;
18089     suppress_error = 0;
18090     r = guestfs_lvm_remove_all (g);
18091     if (r == -1)
18092       return -1;
18093   }
18094   /* TestOutputList for vgs (1) */
18095   {
18096     char device[] = "/dev/sda";
18097     char lines_0[] = ",10";
18098     char lines_1[] = ",20";
18099     char lines_2[] = ",";
18100     char *lines[] = {
18101       lines_0,
18102       lines_1,
18103       lines_2,
18104       NULL
18105     };
18106     int r;
18107     suppress_error = 0;
18108     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18109     if (r == -1)
18110       return -1;
18111   }
18112   {
18113     char device[] = "/dev/sda1";
18114     int r;
18115     suppress_error = 0;
18116     r = guestfs_pvcreate (g, device);
18117     if (r == -1)
18118       return -1;
18119   }
18120   {
18121     char device[] = "/dev/sda2";
18122     int r;
18123     suppress_error = 0;
18124     r = guestfs_pvcreate (g, device);
18125     if (r == -1)
18126       return -1;
18127   }
18128   {
18129     char device[] = "/dev/sda3";
18130     int r;
18131     suppress_error = 0;
18132     r = guestfs_pvcreate (g, device);
18133     if (r == -1)
18134       return -1;
18135   }
18136   {
18137     char volgroup[] = "VG1";
18138     char physvols_0[] = "/dev/sda1";
18139     char physvols_1[] = "/dev/sda2";
18140     char *physvols[] = {
18141       physvols_0,
18142       physvols_1,
18143       NULL
18144     };
18145     int r;
18146     suppress_error = 0;
18147     r = guestfs_vgcreate (g, volgroup, physvols);
18148     if (r == -1)
18149       return -1;
18150   }
18151   {
18152     char volgroup[] = "VG2";
18153     char physvols_0[] = "/dev/sda3";
18154     char *physvols[] = {
18155       physvols_0,
18156       NULL
18157     };
18158     int r;
18159     suppress_error = 0;
18160     r = guestfs_vgcreate (g, volgroup, physvols);
18161     if (r == -1)
18162       return -1;
18163   }
18164   {
18165     char **r;
18166     int i;
18167     suppress_error = 0;
18168     r = guestfs_vgs (g);
18169     if (r == NULL)
18170       return -1;
18171     if (!r[0]) {
18172       fprintf (stderr, "test_vgs_1: short list returned from command\n");
18173       print_strings (r);
18174       return -1;
18175     }
18176     {
18177       char expected[] = "VG1";
18178       if (strcmp (r[0], expected) != 0) {
18179         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18180         return -1;
18181       }
18182     }
18183     if (!r[1]) {
18184       fprintf (stderr, "test_vgs_1: short list returned from command\n");
18185       print_strings (r);
18186       return -1;
18187     }
18188     {
18189       char expected[] = "VG2";
18190       if (strcmp (r[1], expected) != 0) {
18191         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18192         return -1;
18193       }
18194     }
18195     if (r[2] != NULL) {
18196       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
18197       print_strings (r);
18198       return -1;
18199     }
18200     for (i = 0; r[i] != NULL; ++i)
18201       free (r[i]);
18202     free (r);
18203   }
18204   return 0;
18205 }
18206
18207 static int test_pvs_0_skip (void)
18208 {
18209   const char *str;
18210
18211   str = getenv ("TEST_ONLY");
18212   if (str)
18213     return strstr (str, "pvs") == NULL;
18214   str = getenv ("SKIP_TEST_PVS_0");
18215   if (str && strcmp (str, "1") == 0) return 1;
18216   str = getenv ("SKIP_TEST_PVS");
18217   if (str && strcmp (str, "1") == 0) return 1;
18218   return 0;
18219 }
18220
18221 static int test_pvs_0 (void)
18222 {
18223   if (test_pvs_0_skip ()) {
18224     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
18225     return 0;
18226   }
18227
18228   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
18229   {
18230     char device[] = "/dev/sda";
18231     int r;
18232     suppress_error = 0;
18233     r = guestfs_blockdev_setrw (g, device);
18234     if (r == -1)
18235       return -1;
18236   }
18237   {
18238     int r;
18239     suppress_error = 0;
18240     r = guestfs_umount_all (g);
18241     if (r == -1)
18242       return -1;
18243   }
18244   {
18245     int r;
18246     suppress_error = 0;
18247     r = guestfs_lvm_remove_all (g);
18248     if (r == -1)
18249       return -1;
18250   }
18251   {
18252     char device[] = "/dev/sda";
18253     char lines_0[] = ",";
18254     char *lines[] = {
18255       lines_0,
18256       NULL
18257     };
18258     int r;
18259     suppress_error = 0;
18260     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18261     if (r == -1)
18262       return -1;
18263   }
18264   {
18265     char device[] = "/dev/sda1";
18266     int r;
18267     suppress_error = 0;
18268     r = guestfs_pvcreate (g, device);
18269     if (r == -1)
18270       return -1;
18271   }
18272   {
18273     char volgroup[] = "VG";
18274     char physvols_0[] = "/dev/sda1";
18275     char *physvols[] = {
18276       physvols_0,
18277       NULL
18278     };
18279     int r;
18280     suppress_error = 0;
18281     r = guestfs_vgcreate (g, volgroup, physvols);
18282     if (r == -1)
18283       return -1;
18284   }
18285   {
18286     char logvol[] = "LV";
18287     char volgroup[] = "VG";
18288     int r;
18289     suppress_error = 0;
18290     r = guestfs_lvcreate (g, logvol, volgroup, 8);
18291     if (r == -1)
18292       return -1;
18293   }
18294   {
18295     char fstype[] = "ext2";
18296     char device[] = "/dev/VG/LV";
18297     int r;
18298     suppress_error = 0;
18299     r = guestfs_mkfs (g, fstype, device);
18300     if (r == -1)
18301       return -1;
18302   }
18303   {
18304     char device[] = "/dev/VG/LV";
18305     char mountpoint[] = "/";
18306     int r;
18307     suppress_error = 0;
18308     r = guestfs_mount (g, device, mountpoint);
18309     if (r == -1)
18310       return -1;
18311   }
18312   /* TestOutputListOfDevices for pvs (0) */
18313   {
18314     char **r;
18315     int i;
18316     suppress_error = 0;
18317     r = guestfs_pvs (g);
18318     if (r == NULL)
18319       return -1;
18320     if (!r[0]) {
18321       fprintf (stderr, "test_pvs_0: short list returned from command\n");
18322       print_strings (r);
18323       return -1;
18324     }
18325     {
18326       char expected[] = "/dev/sda1";
18327       r[0][5] = 's';
18328       if (strcmp (r[0], expected) != 0) {
18329         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18330         return -1;
18331       }
18332     }
18333     if (r[1] != NULL) {
18334       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
18335       print_strings (r);
18336       return -1;
18337     }
18338     for (i = 0; r[i] != NULL; ++i)
18339       free (r[i]);
18340     free (r);
18341   }
18342   return 0;
18343 }
18344
18345 static int test_pvs_1_skip (void)
18346 {
18347   const char *str;
18348
18349   str = getenv ("TEST_ONLY");
18350   if (str)
18351     return strstr (str, "pvs") == NULL;
18352   str = getenv ("SKIP_TEST_PVS_1");
18353   if (str && strcmp (str, "1") == 0) return 1;
18354   str = getenv ("SKIP_TEST_PVS");
18355   if (str && strcmp (str, "1") == 0) return 1;
18356   return 0;
18357 }
18358
18359 static int test_pvs_1 (void)
18360 {
18361   if (test_pvs_1_skip ()) {
18362     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
18363     return 0;
18364   }
18365
18366   /* InitNone|InitEmpty for test_pvs_1 */
18367   {
18368     char device[] = "/dev/sda";
18369     int r;
18370     suppress_error = 0;
18371     r = guestfs_blockdev_setrw (g, device);
18372     if (r == -1)
18373       return -1;
18374   }
18375   {
18376     int r;
18377     suppress_error = 0;
18378     r = guestfs_umount_all (g);
18379     if (r == -1)
18380       return -1;
18381   }
18382   {
18383     int r;
18384     suppress_error = 0;
18385     r = guestfs_lvm_remove_all (g);
18386     if (r == -1)
18387       return -1;
18388   }
18389   /* TestOutputListOfDevices for pvs (1) */
18390   {
18391     char device[] = "/dev/sda";
18392     char lines_0[] = ",10";
18393     char lines_1[] = ",20";
18394     char lines_2[] = ",";
18395     char *lines[] = {
18396       lines_0,
18397       lines_1,
18398       lines_2,
18399       NULL
18400     };
18401     int r;
18402     suppress_error = 0;
18403     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18404     if (r == -1)
18405       return -1;
18406   }
18407   {
18408     char device[] = "/dev/sda1";
18409     int r;
18410     suppress_error = 0;
18411     r = guestfs_pvcreate (g, device);
18412     if (r == -1)
18413       return -1;
18414   }
18415   {
18416     char device[] = "/dev/sda2";
18417     int r;
18418     suppress_error = 0;
18419     r = guestfs_pvcreate (g, device);
18420     if (r == -1)
18421       return -1;
18422   }
18423   {
18424     char device[] = "/dev/sda3";
18425     int r;
18426     suppress_error = 0;
18427     r = guestfs_pvcreate (g, device);
18428     if (r == -1)
18429       return -1;
18430   }
18431   {
18432     char **r;
18433     int i;
18434     suppress_error = 0;
18435     r = guestfs_pvs (g);
18436     if (r == NULL)
18437       return -1;
18438     if (!r[0]) {
18439       fprintf (stderr, "test_pvs_1: short list returned from command\n");
18440       print_strings (r);
18441       return -1;
18442     }
18443     {
18444       char expected[] = "/dev/sda1";
18445       r[0][5] = 's';
18446       if (strcmp (r[0], expected) != 0) {
18447         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18448         return -1;
18449       }
18450     }
18451     if (!r[1]) {
18452       fprintf (stderr, "test_pvs_1: short list returned from command\n");
18453       print_strings (r);
18454       return -1;
18455     }
18456     {
18457       char expected[] = "/dev/sda2";
18458       r[1][5] = 's';
18459       if (strcmp (r[1], expected) != 0) {
18460         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18461         return -1;
18462       }
18463     }
18464     if (!r[2]) {
18465       fprintf (stderr, "test_pvs_1: short list returned from command\n");
18466       print_strings (r);
18467       return -1;
18468     }
18469     {
18470       char expected[] = "/dev/sda3";
18471       r[2][5] = 's';
18472       if (strcmp (r[2], expected) != 0) {
18473         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18474         return -1;
18475       }
18476     }
18477     if (r[3] != NULL) {
18478       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
18479       print_strings (r);
18480       return -1;
18481     }
18482     for (i = 0; r[i] != NULL; ++i)
18483       free (r[i]);
18484     free (r);
18485   }
18486   return 0;
18487 }
18488
18489 static int test_list_partitions_0_skip (void)
18490 {
18491   const char *str;
18492
18493   str = getenv ("TEST_ONLY");
18494   if (str)
18495     return strstr (str, "list_partitions") == NULL;
18496   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
18497   if (str && strcmp (str, "1") == 0) return 1;
18498   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18499   if (str && strcmp (str, "1") == 0) return 1;
18500   return 0;
18501 }
18502
18503 static int test_list_partitions_0 (void)
18504 {
18505   if (test_list_partitions_0_skip ()) {
18506     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
18507     return 0;
18508   }
18509
18510   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
18511   {
18512     char device[] = "/dev/sda";
18513     int r;
18514     suppress_error = 0;
18515     r = guestfs_blockdev_setrw (g, device);
18516     if (r == -1)
18517       return -1;
18518   }
18519   {
18520     int r;
18521     suppress_error = 0;
18522     r = guestfs_umount_all (g);
18523     if (r == -1)
18524       return -1;
18525   }
18526   {
18527     int r;
18528     suppress_error = 0;
18529     r = guestfs_lvm_remove_all (g);
18530     if (r == -1)
18531       return -1;
18532   }
18533   {
18534     char device[] = "/dev/sda";
18535     char lines_0[] = ",";
18536     char *lines[] = {
18537       lines_0,
18538       NULL
18539     };
18540     int r;
18541     suppress_error = 0;
18542     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18543     if (r == -1)
18544       return -1;
18545   }
18546   {
18547     char fstype[] = "ext2";
18548     char device[] = "/dev/sda1";
18549     int r;
18550     suppress_error = 0;
18551     r = guestfs_mkfs (g, fstype, device);
18552     if (r == -1)
18553       return -1;
18554   }
18555   {
18556     char device[] = "/dev/sda1";
18557     char mountpoint[] = "/";
18558     int r;
18559     suppress_error = 0;
18560     r = guestfs_mount (g, device, mountpoint);
18561     if (r == -1)
18562       return -1;
18563   }
18564   /* TestOutputListOfDevices for list_partitions (0) */
18565   {
18566     char **r;
18567     int i;
18568     suppress_error = 0;
18569     r = guestfs_list_partitions (g);
18570     if (r == NULL)
18571       return -1;
18572     if (!r[0]) {
18573       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
18574       print_strings (r);
18575       return -1;
18576     }
18577     {
18578       char expected[] = "/dev/sda1";
18579       r[0][5] = 's';
18580       if (strcmp (r[0], expected) != 0) {
18581         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18582         return -1;
18583       }
18584     }
18585     if (r[1] != NULL) {
18586       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
18587       print_strings (r);
18588       return -1;
18589     }
18590     for (i = 0; r[i] != NULL; ++i)
18591       free (r[i]);
18592     free (r);
18593   }
18594   return 0;
18595 }
18596
18597 static int test_list_partitions_1_skip (void)
18598 {
18599   const char *str;
18600
18601   str = getenv ("TEST_ONLY");
18602   if (str)
18603     return strstr (str, "list_partitions") == NULL;
18604   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
18605   if (str && strcmp (str, "1") == 0) return 1;
18606   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18607   if (str && strcmp (str, "1") == 0) return 1;
18608   return 0;
18609 }
18610
18611 static int test_list_partitions_1 (void)
18612 {
18613   if (test_list_partitions_1_skip ()) {
18614     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
18615     return 0;
18616   }
18617
18618   /* InitNone|InitEmpty for test_list_partitions_1 */
18619   {
18620     char device[] = "/dev/sda";
18621     int r;
18622     suppress_error = 0;
18623     r = guestfs_blockdev_setrw (g, device);
18624     if (r == -1)
18625       return -1;
18626   }
18627   {
18628     int r;
18629     suppress_error = 0;
18630     r = guestfs_umount_all (g);
18631     if (r == -1)
18632       return -1;
18633   }
18634   {
18635     int r;
18636     suppress_error = 0;
18637     r = guestfs_lvm_remove_all (g);
18638     if (r == -1)
18639       return -1;
18640   }
18641   /* TestOutputListOfDevices for list_partitions (1) */
18642   {
18643     char device[] = "/dev/sda";
18644     char lines_0[] = ",10";
18645     char lines_1[] = ",20";
18646     char lines_2[] = ",";
18647     char *lines[] = {
18648       lines_0,
18649       lines_1,
18650       lines_2,
18651       NULL
18652     };
18653     int r;
18654     suppress_error = 0;
18655     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18656     if (r == -1)
18657       return -1;
18658   }
18659   {
18660     char **r;
18661     int i;
18662     suppress_error = 0;
18663     r = guestfs_list_partitions (g);
18664     if (r == NULL)
18665       return -1;
18666     if (!r[0]) {
18667       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18668       print_strings (r);
18669       return -1;
18670     }
18671     {
18672       char expected[] = "/dev/sda1";
18673       r[0][5] = 's';
18674       if (strcmp (r[0], expected) != 0) {
18675         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18676         return -1;
18677       }
18678     }
18679     if (!r[1]) {
18680       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18681       print_strings (r);
18682       return -1;
18683     }
18684     {
18685       char expected[] = "/dev/sda2";
18686       r[1][5] = 's';
18687       if (strcmp (r[1], expected) != 0) {
18688         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18689         return -1;
18690       }
18691     }
18692     if (!r[2]) {
18693       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18694       print_strings (r);
18695       return -1;
18696     }
18697     {
18698       char expected[] = "/dev/sda3";
18699       r[2][5] = 's';
18700       if (strcmp (r[2], expected) != 0) {
18701         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18702         return -1;
18703       }
18704     }
18705     if (r[3] != NULL) {
18706       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
18707       print_strings (r);
18708       return -1;
18709     }
18710     for (i = 0; r[i] != NULL; ++i)
18711       free (r[i]);
18712     free (r);
18713   }
18714   return 0;
18715 }
18716
18717 static int test_list_devices_0_skip (void)
18718 {
18719   const char *str;
18720
18721   str = getenv ("TEST_ONLY");
18722   if (str)
18723     return strstr (str, "list_devices") == NULL;
18724   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18725   if (str && strcmp (str, "1") == 0) return 1;
18726   str = getenv ("SKIP_TEST_LIST_DEVICES");
18727   if (str && strcmp (str, "1") == 0) return 1;
18728   return 0;
18729 }
18730
18731 static int test_list_devices_0 (void)
18732 {
18733   if (test_list_devices_0_skip ()) {
18734     printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
18735     return 0;
18736   }
18737
18738   /* InitNone|InitEmpty for test_list_devices_0 */
18739   {
18740     char device[] = "/dev/sda";
18741     int r;
18742     suppress_error = 0;
18743     r = guestfs_blockdev_setrw (g, device);
18744     if (r == -1)
18745       return -1;
18746   }
18747   {
18748     int r;
18749     suppress_error = 0;
18750     r = guestfs_umount_all (g);
18751     if (r == -1)
18752       return -1;
18753   }
18754   {
18755     int r;
18756     suppress_error = 0;
18757     r = guestfs_lvm_remove_all (g);
18758     if (r == -1)
18759       return -1;
18760   }
18761   /* TestOutputListOfDevices for list_devices (0) */
18762   {
18763     char **r;
18764     int i;
18765     suppress_error = 0;
18766     r = guestfs_list_devices (g);
18767     if (r == NULL)
18768       return -1;
18769     if (!r[0]) {
18770       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18771       print_strings (r);
18772       return -1;
18773     }
18774     {
18775       char expected[] = "/dev/sda";
18776       r[0][5] = 's';
18777       if (strcmp (r[0], expected) != 0) {
18778         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18779         return -1;
18780       }
18781     }
18782     if (!r[1]) {
18783       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18784       print_strings (r);
18785       return -1;
18786     }
18787     {
18788       char expected[] = "/dev/sdb";
18789       r[1][5] = 's';
18790       if (strcmp (r[1], expected) != 0) {
18791         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18792         return -1;
18793       }
18794     }
18795     if (!r[2]) {
18796       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18797       print_strings (r);
18798       return -1;
18799     }
18800     {
18801       char expected[] = "/dev/sdc";
18802       r[2][5] = 's';
18803       if (strcmp (r[2], expected) != 0) {
18804         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18805         return -1;
18806       }
18807     }
18808     if (!r[3]) {
18809       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18810       print_strings (r);
18811       return -1;
18812     }
18813     {
18814       char expected[] = "/dev/sdd";
18815       r[3][5] = 's';
18816       if (strcmp (r[3], expected) != 0) {
18817         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18818         return -1;
18819       }
18820     }
18821     if (r[4] != NULL) {
18822       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18823       print_strings (r);
18824       return -1;
18825     }
18826     for (i = 0; r[i] != NULL; ++i)
18827       free (r[i]);
18828     free (r);
18829   }
18830   return 0;
18831 }
18832
18833 static int test_ls_0_skip (void)
18834 {
18835   const char *str;
18836
18837   str = getenv ("TEST_ONLY");
18838   if (str)
18839     return strstr (str, "ls") == NULL;
18840   str = getenv ("SKIP_TEST_LS_0");
18841   if (str && strcmp (str, "1") == 0) return 1;
18842   str = getenv ("SKIP_TEST_LS");
18843   if (str && strcmp (str, "1") == 0) return 1;
18844   return 0;
18845 }
18846
18847 static int test_ls_0 (void)
18848 {
18849   if (test_ls_0_skip ()) {
18850     printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
18851     return 0;
18852   }
18853
18854   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18855   {
18856     char device[] = "/dev/sda";
18857     int r;
18858     suppress_error = 0;
18859     r = guestfs_blockdev_setrw (g, device);
18860     if (r == -1)
18861       return -1;
18862   }
18863   {
18864     int r;
18865     suppress_error = 0;
18866     r = guestfs_umount_all (g);
18867     if (r == -1)
18868       return -1;
18869   }
18870   {
18871     int r;
18872     suppress_error = 0;
18873     r = guestfs_lvm_remove_all (g);
18874     if (r == -1)
18875       return -1;
18876   }
18877   {
18878     char device[] = "/dev/sda";
18879     char lines_0[] = ",";
18880     char *lines[] = {
18881       lines_0,
18882       NULL
18883     };
18884     int r;
18885     suppress_error = 0;
18886     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18887     if (r == -1)
18888       return -1;
18889   }
18890   {
18891     char fstype[] = "ext2";
18892     char device[] = "/dev/sda1";
18893     int r;
18894     suppress_error = 0;
18895     r = guestfs_mkfs (g, fstype, device);
18896     if (r == -1)
18897       return -1;
18898   }
18899   {
18900     char device[] = "/dev/sda1";
18901     char mountpoint[] = "/";
18902     int r;
18903     suppress_error = 0;
18904     r = guestfs_mount (g, device, mountpoint);
18905     if (r == -1)
18906       return -1;
18907   }
18908   /* TestOutputList for ls (0) */
18909   {
18910     char path[] = "/new";
18911     int r;
18912     suppress_error = 0;
18913     r = guestfs_touch (g, path);
18914     if (r == -1)
18915       return -1;
18916   }
18917   {
18918     char path[] = "/newer";
18919     int r;
18920     suppress_error = 0;
18921     r = guestfs_touch (g, path);
18922     if (r == -1)
18923       return -1;
18924   }
18925   {
18926     char path[] = "/newest";
18927     int r;
18928     suppress_error = 0;
18929     r = guestfs_touch (g, path);
18930     if (r == -1)
18931       return -1;
18932   }
18933   {
18934     char directory[] = "/";
18935     char **r;
18936     int i;
18937     suppress_error = 0;
18938     r = guestfs_ls (g, directory);
18939     if (r == NULL)
18940       return -1;
18941     if (!r[0]) {
18942       fprintf (stderr, "test_ls_0: short list returned from command\n");
18943       print_strings (r);
18944       return -1;
18945     }
18946     {
18947       char expected[] = "lost+found";
18948       if (strcmp (r[0], expected) != 0) {
18949         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18950         return -1;
18951       }
18952     }
18953     if (!r[1]) {
18954       fprintf (stderr, "test_ls_0: short list returned from command\n");
18955       print_strings (r);
18956       return -1;
18957     }
18958     {
18959       char expected[] = "new";
18960       if (strcmp (r[1], expected) != 0) {
18961         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18962         return -1;
18963       }
18964     }
18965     if (!r[2]) {
18966       fprintf (stderr, "test_ls_0: short list returned from command\n");
18967       print_strings (r);
18968       return -1;
18969     }
18970     {
18971       char expected[] = "newer";
18972       if (strcmp (r[2], expected) != 0) {
18973         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18974         return -1;
18975       }
18976     }
18977     if (!r[3]) {
18978       fprintf (stderr, "test_ls_0: short list returned from command\n");
18979       print_strings (r);
18980       return -1;
18981     }
18982     {
18983       char expected[] = "newest";
18984       if (strcmp (r[3], expected) != 0) {
18985         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18986         return -1;
18987       }
18988     }
18989     if (r[4] != NULL) {
18990       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18991       print_strings (r);
18992       return -1;
18993     }
18994     for (i = 0; r[i] != NULL; ++i)
18995       free (r[i]);
18996     free (r);
18997   }
18998   return 0;
18999 }
19000
19001 static int test_cat_0_skip (void)
19002 {
19003   const char *str;
19004
19005   str = getenv ("TEST_ONLY");
19006   if (str)
19007     return strstr (str, "cat") == NULL;
19008   str = getenv ("SKIP_TEST_CAT_0");
19009   if (str && strcmp (str, "1") == 0) return 1;
19010   str = getenv ("SKIP_TEST_CAT");
19011   if (str && strcmp (str, "1") == 0) return 1;
19012   return 0;
19013 }
19014
19015 static int test_cat_0 (void)
19016 {
19017   if (test_cat_0_skip ()) {
19018     printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
19019     return 0;
19020   }
19021
19022   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
19023   {
19024     char device[] = "/dev/sda";
19025     int r;
19026     suppress_error = 0;
19027     r = guestfs_blockdev_setrw (g, device);
19028     if (r == -1)
19029       return -1;
19030   }
19031   {
19032     int r;
19033     suppress_error = 0;
19034     r = guestfs_umount_all (g);
19035     if (r == -1)
19036       return -1;
19037   }
19038   {
19039     int r;
19040     suppress_error = 0;
19041     r = guestfs_lvm_remove_all (g);
19042     if (r == -1)
19043       return -1;
19044   }
19045   {
19046     char device[] = "/dev/sda";
19047     char lines_0[] = ",";
19048     char *lines[] = {
19049       lines_0,
19050       NULL
19051     };
19052     int r;
19053     suppress_error = 0;
19054     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19055     if (r == -1)
19056       return -1;
19057   }
19058   {
19059     char fstype[] = "ext2";
19060     char device[] = "/dev/sda1";
19061     int r;
19062     suppress_error = 0;
19063     r = guestfs_mkfs (g, fstype, device);
19064     if (r == -1)
19065       return -1;
19066   }
19067   {
19068     char device[] = "/dev/sda1";
19069     char mountpoint[] = "/";
19070     int r;
19071     suppress_error = 0;
19072     r = guestfs_mount (g, device, mountpoint);
19073     if (r == -1)
19074       return -1;
19075   }
19076   /* TestOutput for cat (0) */
19077   char expected[] = "new file contents";
19078   {
19079     char path[] = "/new";
19080     char content[] = "new file contents";
19081     int r;
19082     suppress_error = 0;
19083     r = guestfs_write_file (g, path, content, 0);
19084     if (r == -1)
19085       return -1;
19086   }
19087   {
19088     char path[] = "/new";
19089     char *r;
19090     suppress_error = 0;
19091     r = guestfs_cat (g, path);
19092     if (r == NULL)
19093       return -1;
19094     if (strcmp (r, expected) != 0) {
19095       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
19096       return -1;
19097     }
19098     free (r);
19099   }
19100   return 0;
19101 }
19102
19103 static int test_touch_0_skip (void)
19104 {
19105   const char *str;
19106
19107   str = getenv ("TEST_ONLY");
19108   if (str)
19109     return strstr (str, "touch") == NULL;
19110   str = getenv ("SKIP_TEST_TOUCH_0");
19111   if (str && strcmp (str, "1") == 0) return 1;
19112   str = getenv ("SKIP_TEST_TOUCH");
19113   if (str && strcmp (str, "1") == 0) return 1;
19114   return 0;
19115 }
19116
19117 static int test_touch_0 (void)
19118 {
19119   if (test_touch_0_skip ()) {
19120     printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
19121     return 0;
19122   }
19123
19124   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
19125   {
19126     char device[] = "/dev/sda";
19127     int r;
19128     suppress_error = 0;
19129     r = guestfs_blockdev_setrw (g, device);
19130     if (r == -1)
19131       return -1;
19132   }
19133   {
19134     int r;
19135     suppress_error = 0;
19136     r = guestfs_umount_all (g);
19137     if (r == -1)
19138       return -1;
19139   }
19140   {
19141     int r;
19142     suppress_error = 0;
19143     r = guestfs_lvm_remove_all (g);
19144     if (r == -1)
19145       return -1;
19146   }
19147   {
19148     char device[] = "/dev/sda";
19149     char lines_0[] = ",";
19150     char *lines[] = {
19151       lines_0,
19152       NULL
19153     };
19154     int r;
19155     suppress_error = 0;
19156     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19157     if (r == -1)
19158       return -1;
19159   }
19160   {
19161     char fstype[] = "ext2";
19162     char device[] = "/dev/sda1";
19163     int r;
19164     suppress_error = 0;
19165     r = guestfs_mkfs (g, fstype, device);
19166     if (r == -1)
19167       return -1;
19168   }
19169   {
19170     char device[] = "/dev/sda1";
19171     char mountpoint[] = "/";
19172     int r;
19173     suppress_error = 0;
19174     r = guestfs_mount (g, device, mountpoint);
19175     if (r == -1)
19176       return -1;
19177   }
19178   /* TestOutputTrue for touch (0) */
19179   {
19180     char path[] = "/new";
19181     int r;
19182     suppress_error = 0;
19183     r = guestfs_touch (g, path);
19184     if (r == -1)
19185       return -1;
19186   }
19187   {
19188     char path[] = "/new";
19189     int r;
19190     suppress_error = 0;
19191     r = guestfs_exists (g, path);
19192     if (r == -1)
19193       return -1;
19194     if (!r) {
19195       fprintf (stderr, "test_touch_0: expected true, got false\n");
19196       return -1;
19197     }
19198   }
19199   return 0;
19200 }
19201
19202 static int test_sync_0_skip (void)
19203 {
19204   const char *str;
19205
19206   str = getenv ("TEST_ONLY");
19207   if (str)
19208     return strstr (str, "sync") == NULL;
19209   str = getenv ("SKIP_TEST_SYNC_0");
19210   if (str && strcmp (str, "1") == 0) return 1;
19211   str = getenv ("SKIP_TEST_SYNC");
19212   if (str && strcmp (str, "1") == 0) return 1;
19213   return 0;
19214 }
19215
19216 static int test_sync_0 (void)
19217 {
19218   if (test_sync_0_skip ()) {
19219     printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
19220     return 0;
19221   }
19222
19223   /* InitNone|InitEmpty for test_sync_0 */
19224   {
19225     char device[] = "/dev/sda";
19226     int r;
19227     suppress_error = 0;
19228     r = guestfs_blockdev_setrw (g, device);
19229     if (r == -1)
19230       return -1;
19231   }
19232   {
19233     int r;
19234     suppress_error = 0;
19235     r = guestfs_umount_all (g);
19236     if (r == -1)
19237       return -1;
19238   }
19239   {
19240     int r;
19241     suppress_error = 0;
19242     r = guestfs_lvm_remove_all (g);
19243     if (r == -1)
19244       return -1;
19245   }
19246   /* TestRun for sync (0) */
19247   {
19248     int r;
19249     suppress_error = 0;
19250     r = guestfs_sync (g);
19251     if (r == -1)
19252       return -1;
19253   }
19254   return 0;
19255 }
19256
19257 static int test_mount_0_skip (void)
19258 {
19259   const char *str;
19260
19261   str = getenv ("TEST_ONLY");
19262   if (str)
19263     return strstr (str, "mount") == NULL;
19264   str = getenv ("SKIP_TEST_MOUNT_0");
19265   if (str && strcmp (str, "1") == 0) return 1;
19266   str = getenv ("SKIP_TEST_MOUNT");
19267   if (str && strcmp (str, "1") == 0) return 1;
19268   return 0;
19269 }
19270
19271 static int test_mount_0 (void)
19272 {
19273   if (test_mount_0_skip ()) {
19274     printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
19275     return 0;
19276   }
19277
19278   /* InitNone|InitEmpty for test_mount_0 */
19279   {
19280     char device[] = "/dev/sda";
19281     int r;
19282     suppress_error = 0;
19283     r = guestfs_blockdev_setrw (g, device);
19284     if (r == -1)
19285       return -1;
19286   }
19287   {
19288     int r;
19289     suppress_error = 0;
19290     r = guestfs_umount_all (g);
19291     if (r == -1)
19292       return -1;
19293   }
19294   {
19295     int r;
19296     suppress_error = 0;
19297     r = guestfs_lvm_remove_all (g);
19298     if (r == -1)
19299       return -1;
19300   }
19301   /* TestOutput for mount (0) */
19302   char expected[] = "new file contents";
19303   {
19304     char device[] = "/dev/sda";
19305     char lines_0[] = ",";
19306     char *lines[] = {
19307       lines_0,
19308       NULL
19309     };
19310     int r;
19311     suppress_error = 0;
19312     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19313     if (r == -1)
19314       return -1;
19315   }
19316   {
19317     char fstype[] = "ext2";
19318     char device[] = "/dev/sda1";
19319     int r;
19320     suppress_error = 0;
19321     r = guestfs_mkfs (g, fstype, device);
19322     if (r == -1)
19323       return -1;
19324   }
19325   {
19326     char device[] = "/dev/sda1";
19327     char mountpoint[] = "/";
19328     int r;
19329     suppress_error = 0;
19330     r = guestfs_mount (g, device, mountpoint);
19331     if (r == -1)
19332       return -1;
19333   }
19334   {
19335     char path[] = "/new";
19336     char content[] = "new file contents";
19337     int r;
19338     suppress_error = 0;
19339     r = guestfs_write_file (g, path, content, 0);
19340     if (r == -1)
19341       return -1;
19342   }
19343   {
19344     char path[] = "/new";
19345     char *r;
19346     suppress_error = 0;
19347     r = guestfs_cat (g, path);
19348     if (r == NULL)
19349       return -1;
19350     if (strcmp (r, expected) != 0) {
19351       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
19352       return -1;
19353     }
19354     free (r);
19355   }
19356   return 0;
19357 }
19358
19359 int main (int argc, char *argv[])
19360 {
19361   char c = 0;
19362   int failed = 0;
19363   const char *filename;
19364   int fd;
19365   int nr_tests, test_num = 0;
19366
19367   no_test_warnings ();
19368
19369   g = guestfs_create ();
19370   if (g == NULL) {
19371     printf ("guestfs_create FAILED\n");
19372     exit (1);
19373   }
19374
19375   guestfs_set_error_handler (g, print_error, NULL);
19376
19377   guestfs_set_path (g, "../appliance");
19378
19379   filename = "test1.img";
19380   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19381   if (fd == -1) {
19382     perror (filename);
19383     exit (1);
19384   }
19385   if (lseek (fd, 524288000, SEEK_SET) == -1) {
19386     perror ("lseek");
19387     close (fd);
19388     unlink (filename);
19389     exit (1);
19390   }
19391   if (write (fd, &c, 1) == -1) {
19392     perror ("write");
19393     close (fd);
19394     unlink (filename);
19395     exit (1);
19396   }
19397   if (close (fd) == -1) {
19398     perror (filename);
19399     unlink (filename);
19400     exit (1);
19401   }
19402   if (guestfs_add_drive (g, filename) == -1) {
19403     printf ("guestfs_add_drive %s FAILED\n", filename);
19404     exit (1);
19405   }
19406
19407   filename = "test2.img";
19408   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19409   if (fd == -1) {
19410     perror (filename);
19411     exit (1);
19412   }
19413   if (lseek (fd, 52428800, SEEK_SET) == -1) {
19414     perror ("lseek");
19415     close (fd);
19416     unlink (filename);
19417     exit (1);
19418   }
19419   if (write (fd, &c, 1) == -1) {
19420     perror ("write");
19421     close (fd);
19422     unlink (filename);
19423     exit (1);
19424   }
19425   if (close (fd) == -1) {
19426     perror (filename);
19427     unlink (filename);
19428     exit (1);
19429   }
19430   if (guestfs_add_drive (g, filename) == -1) {
19431     printf ("guestfs_add_drive %s FAILED\n", filename);
19432     exit (1);
19433   }
19434
19435   filename = "test3.img";
19436   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19437   if (fd == -1) {
19438     perror (filename);
19439     exit (1);
19440   }
19441   if (lseek (fd, 10485760, SEEK_SET) == -1) {
19442     perror ("lseek");
19443     close (fd);
19444     unlink (filename);
19445     exit (1);
19446   }
19447   if (write (fd, &c, 1) == -1) {
19448     perror ("write");
19449     close (fd);
19450     unlink (filename);
19451     exit (1);
19452   }
19453   if (close (fd) == -1) {
19454     perror (filename);
19455     unlink (filename);
19456     exit (1);
19457   }
19458   if (guestfs_add_drive (g, filename) == -1) {
19459     printf ("guestfs_add_drive %s FAILED\n", filename);
19460     exit (1);
19461   }
19462
19463   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
19464     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
19465     exit (1);
19466   }
19467
19468   if (guestfs_launch (g) == -1) {
19469     printf ("guestfs_launch FAILED\n");
19470     exit (1);
19471   }
19472
19473   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
19474   alarm (600);
19475
19476   if (guestfs_wait_ready (g) == -1) {
19477     printf ("guestfs_wait_ready FAILED\n");
19478     exit (1);
19479   }
19480
19481   /* Cancel previous alarm. */
19482   alarm (0);
19483
19484   nr_tests = 174;
19485
19486   test_num++;
19487   printf ("%3d/%3d test_mknod_c_0\n", test_num, nr_tests);
19488   if (test_mknod_c_0 () == -1) {
19489     printf ("test_mknod_c_0 FAILED\n");
19490     failed++;
19491   }
19492   test_num++;
19493   printf ("%3d/%3d test_mknod_b_0\n", test_num, nr_tests);
19494   if (test_mknod_b_0 () == -1) {
19495     printf ("test_mknod_b_0 FAILED\n");
19496     failed++;
19497   }
19498   test_num++;
19499   printf ("%3d/%3d test_mkfifo_0\n", test_num, nr_tests);
19500   if (test_mkfifo_0 () == -1) {
19501     printf ("test_mkfifo_0 FAILED\n");
19502     failed++;
19503   }
19504   test_num++;
19505   printf ("%3d/%3d test_mknod_0\n", test_num, nr_tests);
19506   if (test_mknod_0 () == -1) {
19507     printf ("test_mknod_0 FAILED\n");
19508     failed++;
19509   }
19510   test_num++;
19511   printf ("%3d/%3d test_mknod_1\n", test_num, nr_tests);
19512   if (test_mknod_1 () == -1) {
19513     printf ("test_mknod_1 FAILED\n");
19514     failed++;
19515   }
19516   test_num++;
19517   printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests);
19518   if (test_mkswap_U_0 () == -1) {
19519     printf ("test_mkswap_U_0 FAILED\n");
19520     failed++;
19521   }
19522   test_num++;
19523   printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests);
19524   if (test_mkswap_L_0 () == -1) {
19525     printf ("test_mkswap_L_0 FAILED\n");
19526     failed++;
19527   }
19528   test_num++;
19529   printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests);
19530   if (test_mkswap_0 () == -1) {
19531     printf ("test_mkswap_0 FAILED\n");
19532     failed++;
19533   }
19534   test_num++;
19535   printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
19536   if (test_initrd_list_0 () == -1) {
19537     printf ("test_initrd_list_0 FAILED\n");
19538     failed++;
19539   }
19540   test_num++;
19541   printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
19542   if (test_du_0 () == -1) {
19543     printf ("test_du_0 FAILED\n");
19544     failed++;
19545   }
19546   test_num++;
19547   printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
19548   if (test_tail_n_0 () == -1) {
19549     printf ("test_tail_n_0 FAILED\n");
19550     failed++;
19551   }
19552   test_num++;
19553   printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
19554   if (test_tail_n_1 () == -1) {
19555     printf ("test_tail_n_1 FAILED\n");
19556     failed++;
19557   }
19558   test_num++;
19559   printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
19560   if (test_tail_n_2 () == -1) {
19561     printf ("test_tail_n_2 FAILED\n");
19562     failed++;
19563   }
19564   test_num++;
19565   printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
19566   if (test_tail_0 () == -1) {
19567     printf ("test_tail_0 FAILED\n");
19568     failed++;
19569   }
19570   test_num++;
19571   printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
19572   if (test_head_n_0 () == -1) {
19573     printf ("test_head_n_0 FAILED\n");
19574     failed++;
19575   }
19576   test_num++;
19577   printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
19578   if (test_head_n_1 () == -1) {
19579     printf ("test_head_n_1 FAILED\n");
19580     failed++;
19581   }
19582   test_num++;
19583   printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
19584   if (test_head_n_2 () == -1) {
19585     printf ("test_head_n_2 FAILED\n");
19586     failed++;
19587   }
19588   test_num++;
19589   printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
19590   if (test_head_0 () == -1) {
19591     printf ("test_head_0 FAILED\n");
19592     failed++;
19593   }
19594   test_num++;
19595   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
19596   if (test_wc_c_0 () == -1) {
19597     printf ("test_wc_c_0 FAILED\n");
19598     failed++;
19599   }
19600   test_num++;
19601   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
19602   if (test_wc_w_0 () == -1) {
19603     printf ("test_wc_w_0 FAILED\n");
19604     failed++;
19605   }
19606   test_num++;
19607   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
19608   if (test_wc_l_0 () == -1) {
19609     printf ("test_wc_l_0 FAILED\n");
19610     failed++;
19611   }
19612   test_num++;
19613   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
19614   if (test_mkdtemp_0 () == -1) {
19615     printf ("test_mkdtemp_0 FAILED\n");
19616     failed++;
19617   }
19618   test_num++;
19619   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
19620   if (test_scrub_file_0 () == -1) {
19621     printf ("test_scrub_file_0 FAILED\n");
19622     failed++;
19623   }
19624   test_num++;
19625   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
19626   if (test_scrub_device_0 () == -1) {
19627     printf ("test_scrub_device_0 FAILED\n");
19628     failed++;
19629   }
19630   test_num++;
19631   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
19632   if (test_glob_expand_0 () == -1) {
19633     printf ("test_glob_expand_0 FAILED\n");
19634     failed++;
19635   }
19636   test_num++;
19637   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
19638   if (test_glob_expand_1 () == -1) {
19639     printf ("test_glob_expand_1 FAILED\n");
19640     failed++;
19641   }
19642   test_num++;
19643   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
19644   if (test_glob_expand_2 () == -1) {
19645     printf ("test_glob_expand_2 FAILED\n");
19646     failed++;
19647   }
19648   test_num++;
19649   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
19650   if (test_ntfs_3g_probe_0 () == -1) {
19651     printf ("test_ntfs_3g_probe_0 FAILED\n");
19652     failed++;
19653   }
19654   test_num++;
19655   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
19656   if (test_ntfs_3g_probe_1 () == -1) {
19657     printf ("test_ntfs_3g_probe_1 FAILED\n");
19658     failed++;
19659   }
19660   test_num++;
19661   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
19662   if (test_sleep_0 () == -1) {
19663     printf ("test_sleep_0 FAILED\n");
19664     failed++;
19665   }
19666   test_num++;
19667   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
19668   if (test_find_0 () == -1) {
19669     printf ("test_find_0 FAILED\n");
19670     failed++;
19671   }
19672   test_num++;
19673   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
19674   if (test_find_1 () == -1) {
19675     printf ("test_find_1 FAILED\n");
19676     failed++;
19677   }
19678   test_num++;
19679   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
19680   if (test_find_2 () == -1) {
19681     printf ("test_find_2 FAILED\n");
19682     failed++;
19683   }
19684   test_num++;
19685   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
19686   if (test_lvresize_0 () == -1) {
19687     printf ("test_lvresize_0 FAILED\n");
19688     failed++;
19689   }
19690   test_num++;
19691   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
19692   if (test_zerofree_0 () == -1) {
19693     printf ("test_zerofree_0 FAILED\n");
19694     failed++;
19695   }
19696   test_num++;
19697   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
19698   if (test_hexdump_0 () == -1) {
19699     printf ("test_hexdump_0 FAILED\n");
19700     failed++;
19701   }
19702   test_num++;
19703   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
19704   if (test_hexdump_1 () == -1) {
19705     printf ("test_hexdump_1 FAILED\n");
19706     failed++;
19707   }
19708   test_num++;
19709   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
19710   if (test_strings_e_0 () == -1) {
19711     printf ("test_strings_e_0 FAILED\n");
19712     failed++;
19713   }
19714   test_num++;
19715   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
19716   if (test_strings_e_1 () == -1) {
19717     printf ("test_strings_e_1 FAILED\n");
19718     failed++;
19719   }
19720   test_num++;
19721   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
19722   if (test_strings_0 () == -1) {
19723     printf ("test_strings_0 FAILED\n");
19724     failed++;
19725   }
19726   test_num++;
19727   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
19728   if (test_strings_1 () == -1) {
19729     printf ("test_strings_1 FAILED\n");
19730     failed++;
19731   }
19732   test_num++;
19733   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
19734   if (test_equal_0 () == -1) {
19735     printf ("test_equal_0 FAILED\n");
19736     failed++;
19737   }
19738   test_num++;
19739   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
19740   if (test_equal_1 () == -1) {
19741     printf ("test_equal_1 FAILED\n");
19742     failed++;
19743   }
19744   test_num++;
19745   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
19746   if (test_equal_2 () == -1) {
19747     printf ("test_equal_2 FAILED\n");
19748     failed++;
19749   }
19750   test_num++;
19751   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
19752   if (test_ping_daemon_0 () == -1) {
19753     printf ("test_ping_daemon_0 FAILED\n");
19754     failed++;
19755   }
19756   test_num++;
19757   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
19758   if (test_dmesg_0 () == -1) {
19759     printf ("test_dmesg_0 FAILED\n");
19760     failed++;
19761   }
19762   test_num++;
19763   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
19764   if (test_drop_caches_0 () == -1) {
19765     printf ("test_drop_caches_0 FAILED\n");
19766     failed++;
19767   }
19768   test_num++;
19769   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19770   if (test_mv_0 () == -1) {
19771     printf ("test_mv_0 FAILED\n");
19772     failed++;
19773   }
19774   test_num++;
19775   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19776   if (test_mv_1 () == -1) {
19777     printf ("test_mv_1 FAILED\n");
19778     failed++;
19779   }
19780   test_num++;
19781   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19782   if (test_cp_a_0 () == -1) {
19783     printf ("test_cp_a_0 FAILED\n");
19784     failed++;
19785   }
19786   test_num++;
19787   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19788   if (test_cp_0 () == -1) {
19789     printf ("test_cp_0 FAILED\n");
19790     failed++;
19791   }
19792   test_num++;
19793   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19794   if (test_cp_1 () == -1) {
19795     printf ("test_cp_1 FAILED\n");
19796     failed++;
19797   }
19798   test_num++;
19799   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19800   if (test_cp_2 () == -1) {
19801     printf ("test_cp_2 FAILED\n");
19802     failed++;
19803   }
19804   test_num++;
19805   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19806   if (test_grub_install_0 () == -1) {
19807     printf ("test_grub_install_0 FAILED\n");
19808     failed++;
19809   }
19810   test_num++;
19811   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19812   if (test_zero_0 () == -1) {
19813     printf ("test_zero_0 FAILED\n");
19814     failed++;
19815   }
19816   test_num++;
19817   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19818   if (test_fsck_0 () == -1) {
19819     printf ("test_fsck_0 FAILED\n");
19820     failed++;
19821   }
19822   test_num++;
19823   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19824   if (test_fsck_1 () == -1) {
19825     printf ("test_fsck_1 FAILED\n");
19826     failed++;
19827   }
19828   test_num++;
19829   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19830   if (test_set_e2uuid_0 () == -1) {
19831     printf ("test_set_e2uuid_0 FAILED\n");
19832     failed++;
19833   }
19834   test_num++;
19835   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19836   if (test_set_e2uuid_1 () == -1) {
19837     printf ("test_set_e2uuid_1 FAILED\n");
19838     failed++;
19839   }
19840   test_num++;
19841   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19842   if (test_set_e2uuid_2 () == -1) {
19843     printf ("test_set_e2uuid_2 FAILED\n");
19844     failed++;
19845   }
19846   test_num++;
19847   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19848   if (test_set_e2uuid_3 () == -1) {
19849     printf ("test_set_e2uuid_3 FAILED\n");
19850     failed++;
19851   }
19852   test_num++;
19853   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19854   if (test_set_e2label_0 () == -1) {
19855     printf ("test_set_e2label_0 FAILED\n");
19856     failed++;
19857   }
19858   test_num++;
19859   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19860   if (test_pvremove_0 () == -1) {
19861     printf ("test_pvremove_0 FAILED\n");
19862     failed++;
19863   }
19864   test_num++;
19865   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19866   if (test_pvremove_1 () == -1) {
19867     printf ("test_pvremove_1 FAILED\n");
19868     failed++;
19869   }
19870   test_num++;
19871   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19872   if (test_pvremove_2 () == -1) {
19873     printf ("test_pvremove_2 FAILED\n");
19874     failed++;
19875   }
19876   test_num++;
19877   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19878   if (test_vgremove_0 () == -1) {
19879     printf ("test_vgremove_0 FAILED\n");
19880     failed++;
19881   }
19882   test_num++;
19883   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19884   if (test_vgremove_1 () == -1) {
19885     printf ("test_vgremove_1 FAILED\n");
19886     failed++;
19887   }
19888   test_num++;
19889   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19890   if (test_lvremove_0 () == -1) {
19891     printf ("test_lvremove_0 FAILED\n");
19892     failed++;
19893   }
19894   test_num++;
19895   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19896   if (test_lvremove_1 () == -1) {
19897     printf ("test_lvremove_1 FAILED\n");
19898     failed++;
19899   }
19900   test_num++;
19901   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19902   if (test_lvremove_2 () == -1) {
19903     printf ("test_lvremove_2 FAILED\n");
19904     failed++;
19905   }
19906   test_num++;
19907   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19908   if (test_mount_ro_0 () == -1) {
19909     printf ("test_mount_ro_0 FAILED\n");
19910     failed++;
19911   }
19912   test_num++;
19913   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19914   if (test_mount_ro_1 () == -1) {
19915     printf ("test_mount_ro_1 FAILED\n");
19916     failed++;
19917   }
19918   test_num++;
19919   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19920   if (test_tgz_in_0 () == -1) {
19921     printf ("test_tgz_in_0 FAILED\n");
19922     failed++;
19923   }
19924   test_num++;
19925   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19926   if (test_tar_in_0 () == -1) {
19927     printf ("test_tar_in_0 FAILED\n");
19928     failed++;
19929   }
19930   test_num++;
19931   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19932   if (test_checksum_0 () == -1) {
19933     printf ("test_checksum_0 FAILED\n");
19934     failed++;
19935   }
19936   test_num++;
19937   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19938   if (test_checksum_1 () == -1) {
19939     printf ("test_checksum_1 FAILED\n");
19940     failed++;
19941   }
19942   test_num++;
19943   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19944   if (test_checksum_2 () == -1) {
19945     printf ("test_checksum_2 FAILED\n");
19946     failed++;
19947   }
19948   test_num++;
19949   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19950   if (test_checksum_3 () == -1) {
19951     printf ("test_checksum_3 FAILED\n");
19952     failed++;
19953   }
19954   test_num++;
19955   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19956   if (test_checksum_4 () == -1) {
19957     printf ("test_checksum_4 FAILED\n");
19958     failed++;
19959   }
19960   test_num++;
19961   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19962   if (test_checksum_5 () == -1) {
19963     printf ("test_checksum_5 FAILED\n");
19964     failed++;
19965   }
19966   test_num++;
19967   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19968   if (test_checksum_6 () == -1) {
19969     printf ("test_checksum_6 FAILED\n");
19970     failed++;
19971   }
19972   test_num++;
19973   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19974   if (test_checksum_7 () == -1) {
19975     printf ("test_checksum_7 FAILED\n");
19976     failed++;
19977   }
19978   test_num++;
19979   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19980   if (test_checksum_8 () == -1) {
19981     printf ("test_checksum_8 FAILED\n");
19982     failed++;
19983   }
19984   test_num++;
19985   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19986   if (test_download_0 () == -1) {
19987     printf ("test_download_0 FAILED\n");
19988     failed++;
19989   }
19990   test_num++;
19991   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19992   if (test_upload_0 () == -1) {
19993     printf ("test_upload_0 FAILED\n");
19994     failed++;
19995   }
19996   test_num++;
19997   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19998   if (test_blockdev_rereadpt_0 () == -1) {
19999     printf ("test_blockdev_rereadpt_0 FAILED\n");
20000     failed++;
20001   }
20002   test_num++;
20003   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
20004   if (test_blockdev_flushbufs_0 () == -1) {
20005     printf ("test_blockdev_flushbufs_0 FAILED\n");
20006     failed++;
20007   }
20008   test_num++;
20009   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
20010   if (test_blockdev_getsize64_0 () == -1) {
20011     printf ("test_blockdev_getsize64_0 FAILED\n");
20012     failed++;
20013   }
20014   test_num++;
20015   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
20016   if (test_blockdev_getsz_0 () == -1) {
20017     printf ("test_blockdev_getsz_0 FAILED\n");
20018     failed++;
20019   }
20020   test_num++;
20021   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
20022   if (test_blockdev_getbsz_0 () == -1) {
20023     printf ("test_blockdev_getbsz_0 FAILED\n");
20024     failed++;
20025   }
20026   test_num++;
20027   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
20028   if (test_blockdev_getss_0 () == -1) {
20029     printf ("test_blockdev_getss_0 FAILED\n");
20030     failed++;
20031   }
20032   test_num++;
20033   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
20034   if (test_blockdev_getro_0 () == -1) {
20035     printf ("test_blockdev_getro_0 FAILED\n");
20036     failed++;
20037   }
20038   test_num++;
20039   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
20040   if (test_blockdev_setrw_0 () == -1) {
20041     printf ("test_blockdev_setrw_0 FAILED\n");
20042     failed++;
20043   }
20044   test_num++;
20045   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
20046   if (test_blockdev_setro_0 () == -1) {
20047     printf ("test_blockdev_setro_0 FAILED\n");
20048     failed++;
20049   }
20050   test_num++;
20051   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
20052   if (test_statvfs_0 () == -1) {
20053     printf ("test_statvfs_0 FAILED\n");
20054     failed++;
20055   }
20056   test_num++;
20057   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
20058   if (test_lstat_0 () == -1) {
20059     printf ("test_lstat_0 FAILED\n");
20060     failed++;
20061   }
20062   test_num++;
20063   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
20064   if (test_stat_0 () == -1) {
20065     printf ("test_stat_0 FAILED\n");
20066     failed++;
20067   }
20068   test_num++;
20069   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
20070   if (test_command_lines_0 () == -1) {
20071     printf ("test_command_lines_0 FAILED\n");
20072     failed++;
20073   }
20074   test_num++;
20075   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
20076   if (test_command_lines_1 () == -1) {
20077     printf ("test_command_lines_1 FAILED\n");
20078     failed++;
20079   }
20080   test_num++;
20081   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
20082   if (test_command_lines_2 () == -1) {
20083     printf ("test_command_lines_2 FAILED\n");
20084     failed++;
20085   }
20086   test_num++;
20087   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
20088   if (test_command_lines_3 () == -1) {
20089     printf ("test_command_lines_3 FAILED\n");
20090     failed++;
20091   }
20092   test_num++;
20093   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
20094   if (test_command_lines_4 () == -1) {
20095     printf ("test_command_lines_4 FAILED\n");
20096     failed++;
20097   }
20098   test_num++;
20099   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
20100   if (test_command_lines_5 () == -1) {
20101     printf ("test_command_lines_5 FAILED\n");
20102     failed++;
20103   }
20104   test_num++;
20105   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
20106   if (test_command_lines_6 () == -1) {
20107     printf ("test_command_lines_6 FAILED\n");
20108     failed++;
20109   }
20110   test_num++;
20111   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
20112   if (test_command_lines_7 () == -1) {
20113     printf ("test_command_lines_7 FAILED\n");
20114     failed++;
20115   }
20116   test_num++;
20117   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
20118   if (test_command_lines_8 () == -1) {
20119     printf ("test_command_lines_8 FAILED\n");
20120     failed++;
20121   }
20122   test_num++;
20123   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
20124   if (test_command_lines_9 () == -1) {
20125     printf ("test_command_lines_9 FAILED\n");
20126     failed++;
20127   }
20128   test_num++;
20129   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
20130   if (test_command_lines_10 () == -1) {
20131     printf ("test_command_lines_10 FAILED\n");
20132     failed++;
20133   }
20134   test_num++;
20135   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
20136   if (test_command_0 () == -1) {
20137     printf ("test_command_0 FAILED\n");
20138     failed++;
20139   }
20140   test_num++;
20141   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
20142   if (test_command_1 () == -1) {
20143     printf ("test_command_1 FAILED\n");
20144     failed++;
20145   }
20146   test_num++;
20147   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
20148   if (test_command_2 () == -1) {
20149     printf ("test_command_2 FAILED\n");
20150     failed++;
20151   }
20152   test_num++;
20153   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
20154   if (test_command_3 () == -1) {
20155     printf ("test_command_3 FAILED\n");
20156     failed++;
20157   }
20158   test_num++;
20159   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
20160   if (test_command_4 () == -1) {
20161     printf ("test_command_4 FAILED\n");
20162     failed++;
20163   }
20164   test_num++;
20165   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
20166   if (test_command_5 () == -1) {
20167     printf ("test_command_5 FAILED\n");
20168     failed++;
20169   }
20170   test_num++;
20171   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
20172   if (test_command_6 () == -1) {
20173     printf ("test_command_6 FAILED\n");
20174     failed++;
20175   }
20176   test_num++;
20177   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
20178   if (test_command_7 () == -1) {
20179     printf ("test_command_7 FAILED\n");
20180     failed++;
20181   }
20182   test_num++;
20183   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
20184   if (test_command_8 () == -1) {
20185     printf ("test_command_8 FAILED\n");
20186     failed++;
20187   }
20188   test_num++;
20189   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
20190   if (test_command_9 () == -1) {
20191     printf ("test_command_9 FAILED\n");
20192     failed++;
20193   }
20194   test_num++;
20195   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
20196   if (test_command_10 () == -1) {
20197     printf ("test_command_10 FAILED\n");
20198     failed++;
20199   }
20200   test_num++;
20201   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
20202   if (test_command_11 () == -1) {
20203     printf ("test_command_11 FAILED\n");
20204     failed++;
20205   }
20206   test_num++;
20207   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
20208   if (test_file_0 () == -1) {
20209     printf ("test_file_0 FAILED\n");
20210     failed++;
20211   }
20212   test_num++;
20213   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
20214   if (test_file_1 () == -1) {
20215     printf ("test_file_1 FAILED\n");
20216     failed++;
20217   }
20218   test_num++;
20219   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
20220   if (test_file_2 () == -1) {
20221     printf ("test_file_2 FAILED\n");
20222     failed++;
20223   }
20224   test_num++;
20225   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
20226   if (test_umount_all_0 () == -1) {
20227     printf ("test_umount_all_0 FAILED\n");
20228     failed++;
20229   }
20230   test_num++;
20231   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
20232   if (test_umount_all_1 () == -1) {
20233     printf ("test_umount_all_1 FAILED\n");
20234     failed++;
20235   }
20236   test_num++;
20237   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
20238   if (test_mounts_0 () == -1) {
20239     printf ("test_mounts_0 FAILED\n");
20240     failed++;
20241   }
20242   test_num++;
20243   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
20244   if (test_umount_0 () == -1) {
20245     printf ("test_umount_0 FAILED\n");
20246     failed++;
20247   }
20248   test_num++;
20249   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
20250   if (test_umount_1 () == -1) {
20251     printf ("test_umount_1 FAILED\n");
20252     failed++;
20253   }
20254   test_num++;
20255   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
20256   if (test_write_file_0 () == -1) {
20257     printf ("test_write_file_0 FAILED\n");
20258     failed++;
20259   }
20260   test_num++;
20261   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
20262   if (test_write_file_1 () == -1) {
20263     printf ("test_write_file_1 FAILED\n");
20264     failed++;
20265   }
20266   test_num++;
20267   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
20268   if (test_write_file_2 () == -1) {
20269     printf ("test_write_file_2 FAILED\n");
20270     failed++;
20271   }
20272   test_num++;
20273   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
20274   if (test_write_file_3 () == -1) {
20275     printf ("test_write_file_3 FAILED\n");
20276     failed++;
20277   }
20278   test_num++;
20279   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
20280   if (test_write_file_4 () == -1) {
20281     printf ("test_write_file_4 FAILED\n");
20282     failed++;
20283   }
20284   test_num++;
20285   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
20286   if (test_write_file_5 () == -1) {
20287     printf ("test_write_file_5 FAILED\n");
20288     failed++;
20289   }
20290   test_num++;
20291   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
20292   if (test_mkfs_0 () == -1) {
20293     printf ("test_mkfs_0 FAILED\n");
20294     failed++;
20295   }
20296   test_num++;
20297   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
20298   if (test_lvcreate_0 () == -1) {
20299     printf ("test_lvcreate_0 FAILED\n");
20300     failed++;
20301   }
20302   test_num++;
20303   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
20304   if (test_vgcreate_0 () == -1) {
20305     printf ("test_vgcreate_0 FAILED\n");
20306     failed++;
20307   }
20308   test_num++;
20309   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
20310   if (test_pvcreate_0 () == -1) {
20311     printf ("test_pvcreate_0 FAILED\n");
20312     failed++;
20313   }
20314   test_num++;
20315   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
20316   if (test_is_dir_0 () == -1) {
20317     printf ("test_is_dir_0 FAILED\n");
20318     failed++;
20319   }
20320   test_num++;
20321   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
20322   if (test_is_dir_1 () == -1) {
20323     printf ("test_is_dir_1 FAILED\n");
20324     failed++;
20325   }
20326   test_num++;
20327   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
20328   if (test_is_file_0 () == -1) {
20329     printf ("test_is_file_0 FAILED\n");
20330     failed++;
20331   }
20332   test_num++;
20333   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
20334   if (test_is_file_1 () == -1) {
20335     printf ("test_is_file_1 FAILED\n");
20336     failed++;
20337   }
20338   test_num++;
20339   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
20340   if (test_exists_0 () == -1) {
20341     printf ("test_exists_0 FAILED\n");
20342     failed++;
20343   }
20344   test_num++;
20345   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
20346   if (test_exists_1 () == -1) {
20347     printf ("test_exists_1 FAILED\n");
20348     failed++;
20349   }
20350   test_num++;
20351   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
20352   if (test_mkdir_p_0 () == -1) {
20353     printf ("test_mkdir_p_0 FAILED\n");
20354     failed++;
20355   }
20356   test_num++;
20357   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
20358   if (test_mkdir_p_1 () == -1) {
20359     printf ("test_mkdir_p_1 FAILED\n");
20360     failed++;
20361   }
20362   test_num++;
20363   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
20364   if (test_mkdir_p_2 () == -1) {
20365     printf ("test_mkdir_p_2 FAILED\n");
20366     failed++;
20367   }
20368   test_num++;
20369   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
20370   if (test_mkdir_p_3 () == -1) {
20371     printf ("test_mkdir_p_3 FAILED\n");
20372     failed++;
20373   }
20374   test_num++;
20375   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
20376   if (test_mkdir_p_4 () == -1) {
20377     printf ("test_mkdir_p_4 FAILED\n");
20378     failed++;
20379   }
20380   test_num++;
20381   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
20382   if (test_mkdir_0 () == -1) {
20383     printf ("test_mkdir_0 FAILED\n");
20384     failed++;
20385   }
20386   test_num++;
20387   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
20388   if (test_mkdir_1 () == -1) {
20389     printf ("test_mkdir_1 FAILED\n");
20390     failed++;
20391   }
20392   test_num++;
20393   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
20394   if (test_rm_rf_0 () == -1) {
20395     printf ("test_rm_rf_0 FAILED\n");
20396     failed++;
20397   }
20398   test_num++;
20399   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
20400   if (test_rmdir_0 () == -1) {
20401     printf ("test_rmdir_0 FAILED\n");
20402     failed++;
20403   }
20404   test_num++;
20405   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
20406   if (test_rmdir_1 () == -1) {
20407     printf ("test_rmdir_1 FAILED\n");
20408     failed++;
20409   }
20410   test_num++;
20411   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
20412   if (test_rmdir_2 () == -1) {
20413     printf ("test_rmdir_2 FAILED\n");
20414     failed++;
20415   }
20416   test_num++;
20417   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
20418   if (test_rm_0 () == -1) {
20419     printf ("test_rm_0 FAILED\n");
20420     failed++;
20421   }
20422   test_num++;
20423   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
20424   if (test_rm_1 () == -1) {
20425     printf ("test_rm_1 FAILED\n");
20426     failed++;
20427   }
20428   test_num++;
20429   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
20430   if (test_rm_2 () == -1) {
20431     printf ("test_rm_2 FAILED\n");
20432     failed++;
20433   }
20434   test_num++;
20435   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
20436   if (test_read_lines_0 () == -1) {
20437     printf ("test_read_lines_0 FAILED\n");
20438     failed++;
20439   }
20440   test_num++;
20441   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
20442   if (test_read_lines_1 () == -1) {
20443     printf ("test_read_lines_1 FAILED\n");
20444     failed++;
20445   }
20446   test_num++;
20447   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
20448   if (test_lvs_0 () == -1) {
20449     printf ("test_lvs_0 FAILED\n");
20450     failed++;
20451   }
20452   test_num++;
20453   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
20454   if (test_lvs_1 () == -1) {
20455     printf ("test_lvs_1 FAILED\n");
20456     failed++;
20457   }
20458   test_num++;
20459   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
20460   if (test_vgs_0 () == -1) {
20461     printf ("test_vgs_0 FAILED\n");
20462     failed++;
20463   }
20464   test_num++;
20465   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
20466   if (test_vgs_1 () == -1) {
20467     printf ("test_vgs_1 FAILED\n");
20468     failed++;
20469   }
20470   test_num++;
20471   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
20472   if (test_pvs_0 () == -1) {
20473     printf ("test_pvs_0 FAILED\n");
20474     failed++;
20475   }
20476   test_num++;
20477   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
20478   if (test_pvs_1 () == -1) {
20479     printf ("test_pvs_1 FAILED\n");
20480     failed++;
20481   }
20482   test_num++;
20483   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
20484   if (test_list_partitions_0 () == -1) {
20485     printf ("test_list_partitions_0 FAILED\n");
20486     failed++;
20487   }
20488   test_num++;
20489   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
20490   if (test_list_partitions_1 () == -1) {
20491     printf ("test_list_partitions_1 FAILED\n");
20492     failed++;
20493   }
20494   test_num++;
20495   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
20496   if (test_list_devices_0 () == -1) {
20497     printf ("test_list_devices_0 FAILED\n");
20498     failed++;
20499   }
20500   test_num++;
20501   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
20502   if (test_ls_0 () == -1) {
20503     printf ("test_ls_0 FAILED\n");
20504     failed++;
20505   }
20506   test_num++;
20507   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
20508   if (test_cat_0 () == -1) {
20509     printf ("test_cat_0 FAILED\n");
20510     failed++;
20511   }
20512   test_num++;
20513   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
20514   if (test_touch_0 () == -1) {
20515     printf ("test_touch_0 FAILED\n");
20516     failed++;
20517   }
20518   test_num++;
20519   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
20520   if (test_sync_0 () == -1) {
20521     printf ("test_sync_0 FAILED\n");
20522     failed++;
20523   }
20524   test_num++;
20525   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
20526   if (test_mount_0 () == -1) {
20527     printf ("test_mount_0 FAILED\n");
20528     failed++;
20529   }
20530
20531   guestfs_close (g);
20532   unlink ("test1.img");
20533   unlink ("test2.img");
20534   unlink ("test3.img");
20535
20536   if (failed > 0) {
20537     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
20538     exit (1);
20539   }
20540
20541   exit (0);
20542 }