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   fprintf (stderr, "warning: \"guestfs_readdir\" has no tests\n");
 161 }
 162
 163 static int test_mknod_c_0_skip (void)
 164 {
 165   const char *str;
 166
 167   str = getenv ("TEST_ONLY");
 168   if (str)
 169     return strstr (str, "mknod_c") == NULL;
 170   str = getenv ("SKIP_TEST_MKNOD_C_0");
 171   if (str && strcmp (str, "1") == 0) return 1;
 172   str = getenv ("SKIP_TEST_MKNOD_C");
 173   if (str && strcmp (str, "1") == 0) return 1;
 174   return 0;
 175 }
 176
 177 static int test_mknod_c_0 (void)
 178 {
 179   if (test_mknod_c_0_skip ()) {
 180     printf ("        %s skipped (reason: environment variable set)\n", "test_mknod_c_0");
 181     return 0;
 182   }
 183
 184   /* InitBasicFS for test_mknod_c_0: create ext2 on /dev/sda1 */
 185   {
 186     char device[] = "/dev/sda";
 187     int r;
 188     suppress_error = 0;
 189     r = guestfs_blockdev_setrw (g, device);
 190     if (r == -1)
 191       return -1;
 192   }
 193   {
 194     int r;
 195     suppress_error = 0;
 196     r = guestfs_umount_all (g);
 197     if (r == -1)
 198       return -1;
 199   }
 200   {
 201     int r;
 202     suppress_error = 0;
 203     r = guestfs_lvm_remove_all (g);
 204     if (r == -1)
 205       return -1;
 206   }
 207   {
 208     char device[] = "/dev/sda";
 209     char lines_0[] = ",";
 210     char *lines[] = {
 211       lines_0,
 212       NULL
 213     };
 214     int r;
 215     suppress_error = 0;
 216     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 217     if (r == -1)
 218       return -1;
 219   }
 220   {
 221     char fstype[] = "ext2";
 222     char device[] = "/dev/sda1";
 223     int r;
 224     suppress_error = 0;
 225     r = guestfs_mkfs (g, fstype, device);
 226     if (r == -1)
 227       return -1;
 228   }
 229   {
 230     char device[] = "/dev/sda1";
 231     char mountpoint[] = "/";
 232     int r;
 233     suppress_error = 0;
 234     r = guestfs_mount (g, device, mountpoint);
 235     if (r == -1)
 236       return -1;
 237   }
 238   /* TestOutputStruct for mknod_c (0) */
 239   {
 240     char path[] = "/node";
 241     int r;
 242     suppress_error = 0;
 243     r = guestfs_mknod_c (g, 511, 99, 66, path);
 244     if (r == -1)
 245       return -1;
 246   }
 247   {
 248     char path[] = "/node";
 249     struct guestfs_stat *r;
 250     suppress_error = 0;
 251     r = guestfs_stat (g, path);
 252     if (r == NULL)
 253       return -1;
 254     if (r->mode != 8685) {
 255       fprintf (stderr, "test_mknod_c_0: mode was %d, expected 8685\n",
 256                (int) r->mode);
 257       return -1;
 258     }
 259     free (r);
 260   }
 261   return 0;
 262 }
 263
 264 static int test_mknod_b_0_skip (void)
 265 {
 266   const char *str;
 267
 268   str = getenv ("TEST_ONLY");
 269   if (str)
 270     return strstr (str, "mknod_b") == NULL;
 271   str = getenv ("SKIP_TEST_MKNOD_B_0");
 272   if (str && strcmp (str, "1") == 0) return 1;
 273   str = getenv ("SKIP_TEST_MKNOD_B");
 274   if (str && strcmp (str, "1") == 0) return 1;
 275   return 0;
 276 }
 277
 278 static int test_mknod_b_0 (void)
 279 {
 280   if (test_mknod_b_0_skip ()) {
 281     printf ("        %s skipped (reason: environment variable set)\n", "test_mknod_b_0");
 282     return 0;
 283   }
 284
 285   /* InitBasicFS for test_mknod_b_0: create ext2 on /dev/sda1 */
 286   {
 287     char device[] = "/dev/sda";
 288     int r;
 289     suppress_error = 0;
 290     r = guestfs_blockdev_setrw (g, device);
 291     if (r == -1)
 292       return -1;
 293   }
 294   {
 295     int r;
 296     suppress_error = 0;
 297     r = guestfs_umount_all (g);
 298     if (r == -1)
 299       return -1;
 300   }
 301   {
 302     int r;
 303     suppress_error = 0;
 304     r = guestfs_lvm_remove_all (g);
 305     if (r == -1)
 306       return -1;
 307   }
 308   {
 309     char device[] = "/dev/sda";
 310     char lines_0[] = ",";
 311     char *lines[] = {
 312       lines_0,
 313       NULL
 314     };
 315     int r;
 316     suppress_error = 0;
 317     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 318     if (r == -1)
 319       return -1;
 320   }
 321   {
 322     char fstype[] = "ext2";
 323     char device[] = "/dev/sda1";
 324     int r;
 325     suppress_error = 0;
 326     r = guestfs_mkfs (g, fstype, device);
 327     if (r == -1)
 328       return -1;
 329   }
 330   {
 331     char device[] = "/dev/sda1";
 332     char mountpoint[] = "/";
 333     int r;
 334     suppress_error = 0;
 335     r = guestfs_mount (g, device, mountpoint);
 336     if (r == -1)
 337       return -1;
 338   }
 339   /* TestOutputStruct for mknod_b (0) */
 340   {
 341     char path[] = "/node";
 342     int r;
 343     suppress_error = 0;
 344     r = guestfs_mknod_b (g, 511, 99, 66, path);
 345     if (r == -1)
 346       return -1;
 347   }
 348   {
 349     char path[] = "/node";
 350     struct guestfs_stat *r;
 351     suppress_error = 0;
 352     r = guestfs_stat (g, path);
 353     if (r == NULL)
 354       return -1;
 355     if (r->mode != 25069) {
 356       fprintf (stderr, "test_mknod_b_0: mode was %d, expected 25069\n",
 357                (int) r->mode);
 358       return -1;
 359     }
 360     free (r);
 361   }
 362   return 0;
 363 }
 364
 365 static int test_mkfifo_0_skip (void)
 366 {
 367   const char *str;
 368
 369   str = getenv ("TEST_ONLY");
 370   if (str)
 371     return strstr (str, "mkfifo") == NULL;
 372   str = getenv ("SKIP_TEST_MKFIFO_0");
 373   if (str && strcmp (str, "1") == 0) return 1;
 374   str = getenv ("SKIP_TEST_MKFIFO");
 375   if (str && strcmp (str, "1") == 0) return 1;
 376   return 0;
 377 }
 378
 379 static int test_mkfifo_0 (void)
 380 {
 381   if (test_mkfifo_0_skip ()) {
 382     printf ("        %s skipped (reason: environment variable set)\n", "test_mkfifo_0");
 383     return 0;
 384   }
 385
 386   /* InitBasicFS for test_mkfifo_0: create ext2 on /dev/sda1 */
 387   {
 388     char device[] = "/dev/sda";
 389     int r;
 390     suppress_error = 0;
 391     r = guestfs_blockdev_setrw (g, device);
 392     if (r == -1)
 393       return -1;
 394   }
 395   {
 396     int r;
 397     suppress_error = 0;
 398     r = guestfs_umount_all (g);
 399     if (r == -1)
 400       return -1;
 401   }
 402   {
 403     int r;
 404     suppress_error = 0;
 405     r = guestfs_lvm_remove_all (g);
 406     if (r == -1)
 407       return -1;
 408   }
 409   {
 410     char device[] = "/dev/sda";
 411     char lines_0[] = ",";
 412     char *lines[] = {
 413       lines_0,
 414       NULL
 415     };
 416     int r;
 417     suppress_error = 0;
 418     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 419     if (r == -1)
 420       return -1;
 421   }
 422   {
 423     char fstype[] = "ext2";
 424     char device[] = "/dev/sda1";
 425     int r;
 426     suppress_error = 0;
 427     r = guestfs_mkfs (g, fstype, device);
 428     if (r == -1)
 429       return -1;
 430   }
 431   {
 432     char device[] = "/dev/sda1";
 433     char mountpoint[] = "/";
 434     int r;
 435     suppress_error = 0;
 436     r = guestfs_mount (g, device, mountpoint);
 437     if (r == -1)
 438       return -1;
 439   }
 440   /* TestOutputStruct for mkfifo (0) */
 441   {
 442     char path[] = "/node";
 443     int r;
 444     suppress_error = 0;
 445     r = guestfs_mkfifo (g, 511, path);
 446     if (r == -1)
 447       return -1;
 448   }
 449   {
 450     char path[] = "/node";
 451     struct guestfs_stat *r;
 452     suppress_error = 0;
 453     r = guestfs_stat (g, path);
 454     if (r == NULL)
 455       return -1;
 456     if (r->mode != 4589) {
 457       fprintf (stderr, "test_mkfifo_0: mode was %d, expected 4589\n",
 458                (int) r->mode);
 459       return -1;
 460     }
 461     free (r);
 462   }
 463   return 0;
 464 }
 465
 466 static int test_mknod_0_skip (void)
 467 {
 468   const char *str;
 469
 470   str = getenv ("TEST_ONLY");
 471   if (str)
 472     return strstr (str, "mknod") == NULL;
 473   str = getenv ("SKIP_TEST_MKNOD_0");
 474   if (str && strcmp (str, "1") == 0) return 1;
 475   str = getenv ("SKIP_TEST_MKNOD");
 476   if (str && strcmp (str, "1") == 0) return 1;
 477   return 0;
 478 }
 479
 480 static int test_mknod_0 (void)
 481 {
 482   if (test_mknod_0_skip ()) {
 483     printf ("        %s skipped (reason: environment variable set)\n", "test_mknod_0");
 484     return 0;
 485   }
 486
 487   /* InitBasicFS for test_mknod_0: create ext2 on /dev/sda1 */
 488   {
 489     char device[] = "/dev/sda";
 490     int r;
 491     suppress_error = 0;
 492     r = guestfs_blockdev_setrw (g, device);
 493     if (r == -1)
 494       return -1;
 495   }
 496   {
 497     int r;
 498     suppress_error = 0;
 499     r = guestfs_umount_all (g);
 500     if (r == -1)
 501       return -1;
 502   }
 503   {
 504     int r;
 505     suppress_error = 0;
 506     r = guestfs_lvm_remove_all (g);
 507     if (r == -1)
 508       return -1;
 509   }
 510   {
 511     char device[] = "/dev/sda";
 512     char lines_0[] = ",";
 513     char *lines[] = {
 514       lines_0,
 515       NULL
 516     };
 517     int r;
 518     suppress_error = 0;
 519     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 520     if (r == -1)
 521       return -1;
 522   }
 523   {
 524     char fstype[] = "ext2";
 525     char device[] = "/dev/sda1";
 526     int r;
 527     suppress_error = 0;
 528     r = guestfs_mkfs (g, fstype, device);
 529     if (r == -1)
 530       return -1;
 531   }
 532   {
 533     char device[] = "/dev/sda1";
 534     char mountpoint[] = "/";
 535     int r;
 536     suppress_error = 0;
 537     r = guestfs_mount (g, device, mountpoint);
 538     if (r == -1)
 539       return -1;
 540   }
 541   /* TestOutputStruct for mknod (0) */
 542   {
 543     char path[] = "/node";
 544     int r;
 545     suppress_error = 0;
 546     r = guestfs_mknod (g, 4607, 0, 0, path);
 547     if (r == -1)
 548       return -1;
 549   }
 550   {
 551     char path[] = "/node";
 552     struct guestfs_stat *r;
 553     suppress_error = 0;
 554     r = guestfs_stat (g, path);
 555     if (r == NULL)
 556       return -1;
 557     if (r->mode != 4589) {
 558       fprintf (stderr, "test_mknod_0: mode was %d, expected 4589\n",
 559                (int) r->mode);
 560       return -1;
 561     }
 562     free (r);
 563   }
 564   return 0;
 565 }
 566
 567 static int test_mknod_1_skip (void)
 568 {
 569   const char *str;
 570
 571   str = getenv ("TEST_ONLY");
 572   if (str)
 573     return strstr (str, "mknod") == NULL;
 574   str = getenv ("SKIP_TEST_MKNOD_1");
 575   if (str && strcmp (str, "1") == 0) return 1;
 576   str = getenv ("SKIP_TEST_MKNOD");
 577   if (str && strcmp (str, "1") == 0) return 1;
 578   return 0;
 579 }
 580
 581 static int test_mknod_1 (void)
 582 {
 583   if (test_mknod_1_skip ()) {
 584     printf ("        %s skipped (reason: environment variable set)\n", "test_mknod_1");
 585     return 0;
 586   }
 587
 588   /* InitBasicFS for test_mknod_1: create ext2 on /dev/sda1 */
 589   {
 590     char device[] = "/dev/sda";
 591     int r;
 592     suppress_error = 0;
 593     r = guestfs_blockdev_setrw (g, device);
 594     if (r == -1)
 595       return -1;
 596   }
 597   {
 598     int r;
 599     suppress_error = 0;
 600     r = guestfs_umount_all (g);
 601     if (r == -1)
 602       return -1;
 603   }
 604   {
 605     int r;
 606     suppress_error = 0;
 607     r = guestfs_lvm_remove_all (g);
 608     if (r == -1)
 609       return -1;
 610   }
 611   {
 612     char device[] = "/dev/sda";
 613     char lines_0[] = ",";
 614     char *lines[] = {
 615       lines_0,
 616       NULL
 617     };
 618     int r;
 619     suppress_error = 0;
 620     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 621     if (r == -1)
 622       return -1;
 623   }
 624   {
 625     char fstype[] = "ext2";
 626     char device[] = "/dev/sda1";
 627     int r;
 628     suppress_error = 0;
 629     r = guestfs_mkfs (g, fstype, device);
 630     if (r == -1)
 631       return -1;
 632   }
 633   {
 634     char device[] = "/dev/sda1";
 635     char mountpoint[] = "/";
 636     int r;
 637     suppress_error = 0;
 638     r = guestfs_mount (g, device, mountpoint);
 639     if (r == -1)
 640       return -1;
 641   }
 642   /* TestOutputStruct for mknod (1) */
 643   {
 644     char path[] = "/node";
 645     int r;
 646     suppress_error = 0;
 647     r = guestfs_mknod (g, 25087, 66, 99, path);
 648     if (r == -1)
 649       return -1;
 650   }
 651   {
 652     char path[] = "/node";
 653     struct guestfs_stat *r;
 654     suppress_error = 0;
 655     r = guestfs_stat (g, path);
 656     if (r == NULL)
 657       return -1;
 658     if (r->mode != 25069) {
 659       fprintf (stderr, "test_mknod_1: mode was %d, expected 25069\n",
 660                (int) r->mode);
 661       return -1;
 662     }
 663     free (r);
 664   }
 665   return 0;
 666 }
 667
 668 static int test_mkswap_U_0_skip (void)
 669 {
 670   const char *str;
 671
 672   str = getenv ("TEST_ONLY");
 673   if (str)
 674     return strstr (str, "mkswap_U") == NULL;
 675   str = getenv ("SKIP_TEST_MKSWAP_U_0");
 676   if (str && strcmp (str, "1") == 0) return 1;
 677   str = getenv ("SKIP_TEST_MKSWAP_U");
 678   if (str && strcmp (str, "1") == 0) return 1;
 679   return 0;
 680 }
 681
 682 static int test_mkswap_U_0 (void)
 683 {
 684   if (test_mkswap_U_0_skip ()) {
 685     printf ("        %s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
 686     return 0;
 687   }
 688
 689   /* InitNone|InitEmpty for test_mkswap_U_0 */
 690   {
 691     char device[] = "/dev/sda";
 692     int r;
 693     suppress_error = 0;
 694     r = guestfs_blockdev_setrw (g, device);
 695     if (r == -1)
 696       return -1;
 697   }
 698   {
 699     int r;
 700     suppress_error = 0;
 701     r = guestfs_umount_all (g);
 702     if (r == -1)
 703       return -1;
 704   }
 705   {
 706     int r;
 707     suppress_error = 0;
 708     r = guestfs_lvm_remove_all (g);
 709     if (r == -1)
 710       return -1;
 711   }
 712   /* TestRun for mkswap_U (0) */
 713   {
 714     char device[] = "/dev/sda";
 715     char lines_0[] = ",";
 716     char *lines[] = {
 717       lines_0,
 718       NULL
 719     };
 720     int r;
 721     suppress_error = 0;
 722     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 723     if (r == -1)
 724       return -1;
 725   }
 726   {
 727     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
 728     char device[] = "/dev/sda1";
 729     int r;
 730     suppress_error = 0;
 731     r = guestfs_mkswap_U (g, uuid, device);
 732     if (r == -1)
 733       return -1;
 734   }
 735   return 0;
 736 }
 737
 738 static int test_mkswap_L_0_skip (void)
 739 {
 740   const char *str;
 741
 742   str = getenv ("TEST_ONLY");
 743   if (str)
 744     return strstr (str, "mkswap_L") == NULL;
 745   str = getenv ("SKIP_TEST_MKSWAP_L_0");
 746   if (str && strcmp (str, "1") == 0) return 1;
 747   str = getenv ("SKIP_TEST_MKSWAP_L");
 748   if (str && strcmp (str, "1") == 0) return 1;
 749   return 0;
 750 }
 751
 752 static int test_mkswap_L_0 (void)
 753 {
 754   if (test_mkswap_L_0_skip ()) {
 755     printf ("        %s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
 756     return 0;
 757   }
 758
 759   /* InitNone|InitEmpty for test_mkswap_L_0 */
 760   {
 761     char device[] = "/dev/sda";
 762     int r;
 763     suppress_error = 0;
 764     r = guestfs_blockdev_setrw (g, device);
 765     if (r == -1)
 766       return -1;
 767   }
 768   {
 769     int r;
 770     suppress_error = 0;
 771     r = guestfs_umount_all (g);
 772     if (r == -1)
 773       return -1;
 774   }
 775   {
 776     int r;
 777     suppress_error = 0;
 778     r = guestfs_lvm_remove_all (g);
 779     if (r == -1)
 780       return -1;
 781   }
 782   /* TestRun for mkswap_L (0) */
 783   {
 784     char device[] = "/dev/sda";
 785     char lines_0[] = ",";
 786     char *lines[] = {
 787       lines_0,
 788       NULL
 789     };
 790     int r;
 791     suppress_error = 0;
 792     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 793     if (r == -1)
 794       return -1;
 795   }
 796   {
 797     char label[] = "hello";
 798     char device[] = "/dev/sda1";
 799     int r;
 800     suppress_error = 0;
 801     r = guestfs_mkswap_L (g, label, device);
 802     if (r == -1)
 803       return -1;
 804   }
 805   return 0;
 806 }
 807
 808 static int test_mkswap_0_skip (void)
 809 {
 810   const char *str;
 811
 812   str = getenv ("TEST_ONLY");
 813   if (str)
 814     return strstr (str, "mkswap") == NULL;
 815   str = getenv ("SKIP_TEST_MKSWAP_0");
 816   if (str && strcmp (str, "1") == 0) return 1;
 817   str = getenv ("SKIP_TEST_MKSWAP");
 818   if (str && strcmp (str, "1") == 0) return 1;
 819   return 0;
 820 }
 821
 822 static int test_mkswap_0 (void)
 823 {
 824   if (test_mkswap_0_skip ()) {
 825     printf ("        %s skipped (reason: environment variable set)\n", "test_mkswap_0");
 826     return 0;
 827   }
 828
 829   /* InitNone|InitEmpty for test_mkswap_0 */
 830   {
 831     char device[] = "/dev/sda";
 832     int r;
 833     suppress_error = 0;
 834     r = guestfs_blockdev_setrw (g, device);
 835     if (r == -1)
 836       return -1;
 837   }
 838   {
 839     int r;
 840     suppress_error = 0;
 841     r = guestfs_umount_all (g);
 842     if (r == -1)
 843       return -1;
 844   }
 845   {
 846     int r;
 847     suppress_error = 0;
 848     r = guestfs_lvm_remove_all (g);
 849     if (r == -1)
 850       return -1;
 851   }
 852   /* TestRun for mkswap (0) */
 853   {
 854     char device[] = "/dev/sda";
 855     char lines_0[] = ",";
 856     char *lines[] = {
 857       lines_0,
 858       NULL
 859     };
 860     int r;
 861     suppress_error = 0;
 862     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 863     if (r == -1)
 864       return -1;
 865   }
 866   {
 867     char device[] = "/dev/sda1";
 868     int r;
 869     suppress_error = 0;
 870     r = guestfs_mkswap (g, device);
 871     if (r == -1)
 872       return -1;
 873   }
 874   return 0;
 875 }
 876
 877 static int test_initrd_list_0_skip (void)
 878 {
 879   const char *str;
 880
 881   str = getenv ("TEST_ONLY");
 882   if (str)
 883     return strstr (str, "initrd_list") == NULL;
 884   str = getenv ("SKIP_TEST_INITRD_LIST_0");
 885   if (str && strcmp (str, "1") == 0) return 1;
 886   str = getenv ("SKIP_TEST_INITRD_LIST");
 887   if (str && strcmp (str, "1") == 0) return 1;
 888   return 0;
 889 }
 890
 891 static int test_initrd_list_0 (void)
 892 {
 893   if (test_initrd_list_0_skip ()) {
 894     printf ("        %s skipped (reason: environment variable set)\n", "test_initrd_list_0");
 895     return 0;
 896   }
 897
 898   /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
 899   {
 900     char device[] = "/dev/sda";
 901     int r;
 902     suppress_error = 0;
 903     r = guestfs_blockdev_setrw (g, device);
 904     if (r == -1)
 905       return -1;
 906   }
 907   {
 908     int r;
 909     suppress_error = 0;
 910     r = guestfs_umount_all (g);
 911     if (r == -1)
 912       return -1;
 913   }
 914   {
 915     int r;
 916     suppress_error = 0;
 917     r = guestfs_lvm_remove_all (g);
 918     if (r == -1)
 919       return -1;
 920   }
 921   {
 922     char device[] = "/dev/sda";
 923     char lines_0[] = ",";
 924     char *lines[] = {
 925       lines_0,
 926       NULL
 927     };
 928     int r;
 929     suppress_error = 0;
 930     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 931     if (r == -1)
 932       return -1;
 933   }
 934   {
 935     char fstype[] = "ext2";
 936     char device[] = "/dev/sda1";
 937     int r;
 938     suppress_error = 0;
 939     r = guestfs_mkfs (g, fstype, device);
 940     if (r == -1)
 941       return -1;
 942   }
 943   {
 944     char device[] = "/dev/sda1";
 945     char mountpoint[] = "/";
 946     int r;
 947     suppress_error = 0;
 948     r = guestfs_mount (g, device, mountpoint);
 949     if (r == -1)
 950       return -1;
 951   }
 952   /* TestOutputList for initrd_list (0) */
 953   {
 954     char options[] = "ro";
 955     char vfstype[] = "squashfs";
 956     char device[] = "/dev/sdd";
 957     char mountpoint[] = "/";
 958     int r;
 959     suppress_error = 0;
 960     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 961     if (r == -1)
 962       return -1;
 963   }
 964   {
 965     char path[] = "/initrd";
 966     char **r;
 967     int i;
 968     suppress_error = 0;
 969     r = guestfs_initrd_list (g, path);
 970     if (r == NULL)
 971       return -1;
 972     if (!r[0]) {
 973       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 974       print_strings (r);
 975       return -1;
 976     }
 977     {
 978       char expected[] = "empty";
 979       if (strcmp (r[0], expected) != 0) {
 980         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 981         return -1;
 982       }
 983     }
 984     if (!r[1]) {
 985       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 986       print_strings (r);
 987       return -1;
 988     }
 989     {
 990       char expected[] = "known-1";
 991       if (strcmp (r[1], expected) != 0) {
 992         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 993         return -1;
 994       }
 995     }
 996     if (!r[2]) {
 997       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 998       print_strings (r);
 999       return -1;
1000     }
1001     {
1002       char expected[] = "known-2";
1003       if (strcmp (r[2], expected) != 0) {
1004         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1005         return -1;
1006       }
1007     }
1008     if (!r[3]) {
1009       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
1010       print_strings (r);
1011       return -1;
1012     }
1013     {
1014       char expected[] = "known-3";
1015       if (strcmp (r[3], expected) != 0) {
1016         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1017         return -1;
1018       }
1019     }
1020     if (r[4] != NULL) {
1021       fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
1022       print_strings (r);
1023       return -1;
1024     }
1025     for (i = 0; r[i] != NULL; ++i)
1026       free (r[i]);
1027     free (r);
1028   }
1029   return 0;
1030 }
1031
1032 static int test_du_0_skip (void)
1033 {
1034   const char *str;
1035
1036   str = getenv ("TEST_ONLY");
1037   if (str)
1038     return strstr (str, "du") == NULL;
1039   str = getenv ("SKIP_TEST_DU_0");
1040   if (str && strcmp (str, "1") == 0) return 1;
1041   str = getenv ("SKIP_TEST_DU");
1042   if (str && strcmp (str, "1") == 0) return 1;
1043   return 0;
1044 }
1045
1046 static int test_du_0 (void)
1047 {
1048   if (test_du_0_skip ()) {
1049     printf ("        %s skipped (reason: environment variable set)\n", "test_du_0");
1050     return 0;
1051   }
1052
1053   /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
1054   {
1055     char device[] = "/dev/sda";
1056     int r;
1057     suppress_error = 0;
1058     r = guestfs_blockdev_setrw (g, device);
1059     if (r == -1)
1060       return -1;
1061   }
1062   {
1063     int r;
1064     suppress_error = 0;
1065     r = guestfs_umount_all (g);
1066     if (r == -1)
1067       return -1;
1068   }
1069   {
1070     int r;
1071     suppress_error = 0;
1072     r = guestfs_lvm_remove_all (g);
1073     if (r == -1)
1074       return -1;
1075   }
1076   {
1077     char device[] = "/dev/sda";
1078     char lines_0[] = ",";
1079     char *lines[] = {
1080       lines_0,
1081       NULL
1082     };
1083     int r;
1084     suppress_error = 0;
1085     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1086     if (r == -1)
1087       return -1;
1088   }
1089   {
1090     char fstype[] = "ext2";
1091     char device[] = "/dev/sda1";
1092     int r;
1093     suppress_error = 0;
1094     r = guestfs_mkfs (g, fstype, device);
1095     if (r == -1)
1096       return -1;
1097   }
1098   {
1099     char device[] = "/dev/sda1";
1100     char mountpoint[] = "/";
1101     int r;
1102     suppress_error = 0;
1103     r = guestfs_mount (g, device, mountpoint);
1104     if (r == -1)
1105       return -1;
1106   }
1107   /* TestOutputInt for du (0) */
1108   {
1109     char path[] = "/p";
1110     int r;
1111     suppress_error = 0;
1112     r = guestfs_mkdir (g, path);
1113     if (r == -1)
1114       return -1;
1115   }
1116   {
1117     char path[] = "/p";
1118     int64_t r;
1119     suppress_error = 0;
1120     r = guestfs_du (g, path);
1121     if (r == -1)
1122       return -1;
1123     if (r != 1) {
1124       fprintf (stderr, "test_du_0: expected 1 but got %d\n",               (int) r);
1125       return -1;
1126     }
1127   }
1128   return 0;
1129 }
1130
1131 static int test_tail_n_0_skip (void)
1132 {
1133   const char *str;
1134
1135   str = getenv ("TEST_ONLY");
1136   if (str)
1137     return strstr (str, "tail_n") == NULL;
1138   str = getenv ("SKIP_TEST_TAIL_N_0");
1139   if (str && strcmp (str, "1") == 0) return 1;
1140   str = getenv ("SKIP_TEST_TAIL_N");
1141   if (str && strcmp (str, "1") == 0) return 1;
1142   return 0;
1143 }
1144
1145 static int test_tail_n_0 (void)
1146 {
1147   if (test_tail_n_0_skip ()) {
1148     printf ("        %s skipped (reason: environment variable set)\n", "test_tail_n_0");
1149     return 0;
1150   }
1151
1152   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
1153   {
1154     char device[] = "/dev/sda";
1155     int r;
1156     suppress_error = 0;
1157     r = guestfs_blockdev_setrw (g, device);
1158     if (r == -1)
1159       return -1;
1160   }
1161   {
1162     int r;
1163     suppress_error = 0;
1164     r = guestfs_umount_all (g);
1165     if (r == -1)
1166       return -1;
1167   }
1168   {
1169     int r;
1170     suppress_error = 0;
1171     r = guestfs_lvm_remove_all (g);
1172     if (r == -1)
1173       return -1;
1174   }
1175   {
1176     char device[] = "/dev/sda";
1177     char lines_0[] = ",";
1178     char *lines[] = {
1179       lines_0,
1180       NULL
1181     };
1182     int r;
1183     suppress_error = 0;
1184     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1185     if (r == -1)
1186       return -1;
1187   }
1188   {
1189     char fstype[] = "ext2";
1190     char device[] = "/dev/sda1";
1191     int r;
1192     suppress_error = 0;
1193     r = guestfs_mkfs (g, fstype, device);
1194     if (r == -1)
1195       return -1;
1196   }
1197   {
1198     char device[] = "/dev/sda1";
1199     char mountpoint[] = "/";
1200     int r;
1201     suppress_error = 0;
1202     r = guestfs_mount (g, device, mountpoint);
1203     if (r == -1)
1204       return -1;
1205   }
1206   /* TestOutputList for tail_n (0) */
1207   {
1208     char options[] = "ro";
1209     char vfstype[] = "squashfs";
1210     char device[] = "/dev/sdd";
1211     char mountpoint[] = "/";
1212     int r;
1213     suppress_error = 0;
1214     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1215     if (r == -1)
1216       return -1;
1217   }
1218   {
1219     char path[] = "/10klines";
1220     char **r;
1221     int i;
1222     suppress_error = 0;
1223     r = guestfs_tail_n (g, 3, path);
1224     if (r == NULL)
1225       return -1;
1226     if (!r[0]) {
1227       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1228       print_strings (r);
1229       return -1;
1230     }
1231     {
1232       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1233       if (strcmp (r[0], expected) != 0) {
1234         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1235         return -1;
1236       }
1237     }
1238     if (!r[1]) {
1239       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1240       print_strings (r);
1241       return -1;
1242     }
1243     {
1244       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1245       if (strcmp (r[1], expected) != 0) {
1246         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1247         return -1;
1248       }
1249     }
1250     if (!r[2]) {
1251       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1252       print_strings (r);
1253       return -1;
1254     }
1255     {
1256       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1257       if (strcmp (r[2], expected) != 0) {
1258         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1259         return -1;
1260       }
1261     }
1262     if (r[3] != NULL) {
1263       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
1264       print_strings (r);
1265       return -1;
1266     }
1267     for (i = 0; r[i] != NULL; ++i)
1268       free (r[i]);
1269     free (r);
1270   }
1271   return 0;
1272 }
1273
1274 static int test_tail_n_1_skip (void)
1275 {
1276   const char *str;
1277
1278   str = getenv ("TEST_ONLY");
1279   if (str)
1280     return strstr (str, "tail_n") == NULL;
1281   str = getenv ("SKIP_TEST_TAIL_N_1");
1282   if (str && strcmp (str, "1") == 0) return 1;
1283   str = getenv ("SKIP_TEST_TAIL_N");
1284   if (str && strcmp (str, "1") == 0) return 1;
1285   return 0;
1286 }
1287
1288 static int test_tail_n_1 (void)
1289 {
1290   if (test_tail_n_1_skip ()) {
1291     printf ("        %s skipped (reason: environment variable set)\n", "test_tail_n_1");
1292     return 0;
1293   }
1294
1295   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
1296   {
1297     char device[] = "/dev/sda";
1298     int r;
1299     suppress_error = 0;
1300     r = guestfs_blockdev_setrw (g, device);
1301     if (r == -1)
1302       return -1;
1303   }
1304   {
1305     int r;
1306     suppress_error = 0;
1307     r = guestfs_umount_all (g);
1308     if (r == -1)
1309       return -1;
1310   }
1311   {
1312     int r;
1313     suppress_error = 0;
1314     r = guestfs_lvm_remove_all (g);
1315     if (r == -1)
1316       return -1;
1317   }
1318   {
1319     char device[] = "/dev/sda";
1320     char lines_0[] = ",";
1321     char *lines[] = {
1322       lines_0,
1323       NULL
1324     };
1325     int r;
1326     suppress_error = 0;
1327     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1328     if (r == -1)
1329       return -1;
1330   }
1331   {
1332     char fstype[] = "ext2";
1333     char device[] = "/dev/sda1";
1334     int r;
1335     suppress_error = 0;
1336     r = guestfs_mkfs (g, fstype, device);
1337     if (r == -1)
1338       return -1;
1339   }
1340   {
1341     char device[] = "/dev/sda1";
1342     char mountpoint[] = "/";
1343     int r;
1344     suppress_error = 0;
1345     r = guestfs_mount (g, device, mountpoint);
1346     if (r == -1)
1347       return -1;
1348   }
1349   /* TestOutputList for tail_n (1) */
1350   {
1351     char options[] = "ro";
1352     char vfstype[] = "squashfs";
1353     char device[] = "/dev/sdd";
1354     char mountpoint[] = "/";
1355     int r;
1356     suppress_error = 0;
1357     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1358     if (r == -1)
1359       return -1;
1360   }
1361   {
1362     char path[] = "/10klines";
1363     char **r;
1364     int i;
1365     suppress_error = 0;
1366     r = guestfs_tail_n (g, -9998, path);
1367     if (r == NULL)
1368       return -1;
1369     if (!r[0]) {
1370       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1371       print_strings (r);
1372       return -1;
1373     }
1374     {
1375       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1376       if (strcmp (r[0], expected) != 0) {
1377         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1378         return -1;
1379       }
1380     }
1381     if (!r[1]) {
1382       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1383       print_strings (r);
1384       return -1;
1385     }
1386     {
1387       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1388       if (strcmp (r[1], expected) != 0) {
1389         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1390         return -1;
1391       }
1392     }
1393     if (!r[2]) {
1394       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1395       print_strings (r);
1396       return -1;
1397     }
1398     {
1399       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1400       if (strcmp (r[2], expected) != 0) {
1401         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1402         return -1;
1403       }
1404     }
1405     if (r[3] != NULL) {
1406       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
1407       print_strings (r);
1408       return -1;
1409     }
1410     for (i = 0; r[i] != NULL; ++i)
1411       free (r[i]);
1412     free (r);
1413   }
1414   return 0;
1415 }
1416
1417 static int test_tail_n_2_skip (void)
1418 {
1419   const char *str;
1420
1421   str = getenv ("TEST_ONLY");
1422   if (str)
1423     return strstr (str, "tail_n") == NULL;
1424   str = getenv ("SKIP_TEST_TAIL_N_2");
1425   if (str && strcmp (str, "1") == 0) return 1;
1426   str = getenv ("SKIP_TEST_TAIL_N");
1427   if (str && strcmp (str, "1") == 0) return 1;
1428   return 0;
1429 }
1430
1431 static int test_tail_n_2 (void)
1432 {
1433   if (test_tail_n_2_skip ()) {
1434     printf ("        %s skipped (reason: environment variable set)\n", "test_tail_n_2");
1435     return 0;
1436   }
1437
1438   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
1439   {
1440     char device[] = "/dev/sda";
1441     int r;
1442     suppress_error = 0;
1443     r = guestfs_blockdev_setrw (g, device);
1444     if (r == -1)
1445       return -1;
1446   }
1447   {
1448     int r;
1449     suppress_error = 0;
1450     r = guestfs_umount_all (g);
1451     if (r == -1)
1452       return -1;
1453   }
1454   {
1455     int r;
1456     suppress_error = 0;
1457     r = guestfs_lvm_remove_all (g);
1458     if (r == -1)
1459       return -1;
1460   }
1461   {
1462     char device[] = "/dev/sda";
1463     char lines_0[] = ",";
1464     char *lines[] = {
1465       lines_0,
1466       NULL
1467     };
1468     int r;
1469     suppress_error = 0;
1470     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1471     if (r == -1)
1472       return -1;
1473   }
1474   {
1475     char fstype[] = "ext2";
1476     char device[] = "/dev/sda1";
1477     int r;
1478     suppress_error = 0;
1479     r = guestfs_mkfs (g, fstype, device);
1480     if (r == -1)
1481       return -1;
1482   }
1483   {
1484     char device[] = "/dev/sda1";
1485     char mountpoint[] = "/";
1486     int r;
1487     suppress_error = 0;
1488     r = guestfs_mount (g, device, mountpoint);
1489     if (r == -1)
1490       return -1;
1491   }
1492   /* TestOutputList for tail_n (2) */
1493   {
1494     char options[] = "ro";
1495     char vfstype[] = "squashfs";
1496     char device[] = "/dev/sdd";
1497     char mountpoint[] = "/";
1498     int r;
1499     suppress_error = 0;
1500     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1501     if (r == -1)
1502       return -1;
1503   }
1504   {
1505     char path[] = "/10klines";
1506     char **r;
1507     int i;
1508     suppress_error = 0;
1509     r = guestfs_tail_n (g, 0, path);
1510     if (r == NULL)
1511       return -1;
1512     if (r[0] != NULL) {
1513       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1514       print_strings (r);
1515       return -1;
1516     }
1517     for (i = 0; r[i] != NULL; ++i)
1518       free (r[i]);
1519     free (r);
1520   }
1521   return 0;
1522 }
1523
1524 static int test_tail_0_skip (void)
1525 {
1526   const char *str;
1527
1528   str = getenv ("TEST_ONLY");
1529   if (str)
1530     return strstr (str, "tail") == NULL;
1531   str = getenv ("SKIP_TEST_TAIL_0");
1532   if (str && strcmp (str, "1") == 0) return 1;
1533   str = getenv ("SKIP_TEST_TAIL");
1534   if (str && strcmp (str, "1") == 0) return 1;
1535   return 0;
1536 }
1537
1538 static int test_tail_0 (void)
1539 {
1540   if (test_tail_0_skip ()) {
1541     printf ("        %s skipped (reason: environment variable set)\n", "test_tail_0");
1542     return 0;
1543   }
1544
1545   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1546   {
1547     char device[] = "/dev/sda";
1548     int r;
1549     suppress_error = 0;
1550     r = guestfs_blockdev_setrw (g, device);
1551     if (r == -1)
1552       return -1;
1553   }
1554   {
1555     int r;
1556     suppress_error = 0;
1557     r = guestfs_umount_all (g);
1558     if (r == -1)
1559       return -1;
1560   }
1561   {
1562     int r;
1563     suppress_error = 0;
1564     r = guestfs_lvm_remove_all (g);
1565     if (r == -1)
1566       return -1;
1567   }
1568   {
1569     char device[] = "/dev/sda";
1570     char lines_0[] = ",";
1571     char *lines[] = {
1572       lines_0,
1573       NULL
1574     };
1575     int r;
1576     suppress_error = 0;
1577     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1578     if (r == -1)
1579       return -1;
1580   }
1581   {
1582     char fstype[] = "ext2";
1583     char device[] = "/dev/sda1";
1584     int r;
1585     suppress_error = 0;
1586     r = guestfs_mkfs (g, fstype, device);
1587     if (r == -1)
1588       return -1;
1589   }
1590   {
1591     char device[] = "/dev/sda1";
1592     char mountpoint[] = "/";
1593     int r;
1594     suppress_error = 0;
1595     r = guestfs_mount (g, device, mountpoint);
1596     if (r == -1)
1597       return -1;
1598   }
1599   /* TestOutputList for tail (0) */
1600   {
1601     char options[] = "ro";
1602     char vfstype[] = "squashfs";
1603     char device[] = "/dev/sdd";
1604     char mountpoint[] = "/";
1605     int r;
1606     suppress_error = 0;
1607     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1608     if (r == -1)
1609       return -1;
1610   }
1611   {
1612     char path[] = "/10klines";
1613     char **r;
1614     int i;
1615     suppress_error = 0;
1616     r = guestfs_tail (g, path);
1617     if (r == NULL)
1618       return -1;
1619     if (!r[0]) {
1620       fprintf (stderr, "test_tail_0: short list returned from command\n");
1621       print_strings (r);
1622       return -1;
1623     }
1624     {
1625       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1626       if (strcmp (r[0], expected) != 0) {
1627         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1628         return -1;
1629       }
1630     }
1631     if (!r[1]) {
1632       fprintf (stderr, "test_tail_0: short list returned from command\n");
1633       print_strings (r);
1634       return -1;
1635     }
1636     {
1637       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1638       if (strcmp (r[1], expected) != 0) {
1639         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1640         return -1;
1641       }
1642     }
1643     if (!r[2]) {
1644       fprintf (stderr, "test_tail_0: short list returned from command\n");
1645       print_strings (r);
1646       return -1;
1647     }
1648     {
1649       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1650       if (strcmp (r[2], expected) != 0) {
1651         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1652         return -1;
1653       }
1654     }
1655     if (!r[3]) {
1656       fprintf (stderr, "test_tail_0: short list returned from command\n");
1657       print_strings (r);
1658       return -1;
1659     }
1660     {
1661       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1662       if (strcmp (r[3], expected) != 0) {
1663         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1664         return -1;
1665       }
1666     }
1667     if (!r[4]) {
1668       fprintf (stderr, "test_tail_0: short list returned from command\n");
1669       print_strings (r);
1670       return -1;
1671     }
1672     {
1673       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1674       if (strcmp (r[4], expected) != 0) {
1675         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1676         return -1;
1677       }
1678     }
1679     if (!r[5]) {
1680       fprintf (stderr, "test_tail_0: short list returned from command\n");
1681       print_strings (r);
1682       return -1;
1683     }
1684     {
1685       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1686       if (strcmp (r[5], expected) != 0) {
1687         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1688         return -1;
1689       }
1690     }
1691     if (!r[6]) {
1692       fprintf (stderr, "test_tail_0: short list returned from command\n");
1693       print_strings (r);
1694       return -1;
1695     }
1696     {
1697       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1698       if (strcmp (r[6], expected) != 0) {
1699         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1700         return -1;
1701       }
1702     }
1703     if (!r[7]) {
1704       fprintf (stderr, "test_tail_0: short list returned from command\n");
1705       print_strings (r);
1706       return -1;
1707     }
1708     {
1709       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1710       if (strcmp (r[7], expected) != 0) {
1711         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1712         return -1;
1713       }
1714     }
1715     if (!r[8]) {
1716       fprintf (stderr, "test_tail_0: short list returned from command\n");
1717       print_strings (r);
1718       return -1;
1719     }
1720     {
1721       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1722       if (strcmp (r[8], expected) != 0) {
1723         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1724         return -1;
1725       }
1726     }
1727     if (!r[9]) {
1728       fprintf (stderr, "test_tail_0: short list returned from command\n");
1729       print_strings (r);
1730       return -1;
1731     }
1732     {
1733       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1734       if (strcmp (r[9], expected) != 0) {
1735         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1736         return -1;
1737       }
1738     }
1739     if (r[10] != NULL) {
1740       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1741       print_strings (r);
1742       return -1;
1743     }
1744     for (i = 0; r[i] != NULL; ++i)
1745       free (r[i]);
1746     free (r);
1747   }
1748   return 0;
1749 }
1750
1751 static int test_head_n_0_skip (void)
1752 {
1753   const char *str;
1754
1755   str = getenv ("TEST_ONLY");
1756   if (str)
1757     return strstr (str, "head_n") == NULL;
1758   str = getenv ("SKIP_TEST_HEAD_N_0");
1759   if (str && strcmp (str, "1") == 0) return 1;
1760   str = getenv ("SKIP_TEST_HEAD_N");
1761   if (str && strcmp (str, "1") == 0) return 1;
1762   return 0;
1763 }
1764
1765 static int test_head_n_0 (void)
1766 {
1767   if (test_head_n_0_skip ()) {
1768     printf ("        %s skipped (reason: environment variable set)\n", "test_head_n_0");
1769     return 0;
1770   }
1771
1772   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1773   {
1774     char device[] = "/dev/sda";
1775     int r;
1776     suppress_error = 0;
1777     r = guestfs_blockdev_setrw (g, device);
1778     if (r == -1)
1779       return -1;
1780   }
1781   {
1782     int r;
1783     suppress_error = 0;
1784     r = guestfs_umount_all (g);
1785     if (r == -1)
1786       return -1;
1787   }
1788   {
1789     int r;
1790     suppress_error = 0;
1791     r = guestfs_lvm_remove_all (g);
1792     if (r == -1)
1793       return -1;
1794   }
1795   {
1796     char device[] = "/dev/sda";
1797     char lines_0[] = ",";
1798     char *lines[] = {
1799       lines_0,
1800       NULL
1801     };
1802     int r;
1803     suppress_error = 0;
1804     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1805     if (r == -1)
1806       return -1;
1807   }
1808   {
1809     char fstype[] = "ext2";
1810     char device[] = "/dev/sda1";
1811     int r;
1812     suppress_error = 0;
1813     r = guestfs_mkfs (g, fstype, device);
1814     if (r == -1)
1815       return -1;
1816   }
1817   {
1818     char device[] = "/dev/sda1";
1819     char mountpoint[] = "/";
1820     int r;
1821     suppress_error = 0;
1822     r = guestfs_mount (g, device, mountpoint);
1823     if (r == -1)
1824       return -1;
1825   }
1826   /* TestOutputList for head_n (0) */
1827   {
1828     char options[] = "ro";
1829     char vfstype[] = "squashfs";
1830     char device[] = "/dev/sdd";
1831     char mountpoint[] = "/";
1832     int r;
1833     suppress_error = 0;
1834     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1835     if (r == -1)
1836       return -1;
1837   }
1838   {
1839     char path[] = "/10klines";
1840     char **r;
1841     int i;
1842     suppress_error = 0;
1843     r = guestfs_head_n (g, 3, path);
1844     if (r == NULL)
1845       return -1;
1846     if (!r[0]) {
1847       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1848       print_strings (r);
1849       return -1;
1850     }
1851     {
1852       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1853       if (strcmp (r[0], expected) != 0) {
1854         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1855         return -1;
1856       }
1857     }
1858     if (!r[1]) {
1859       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1860       print_strings (r);
1861       return -1;
1862     }
1863     {
1864       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1865       if (strcmp (r[1], expected) != 0) {
1866         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1867         return -1;
1868       }
1869     }
1870     if (!r[2]) {
1871       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1872       print_strings (r);
1873       return -1;
1874     }
1875     {
1876       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1877       if (strcmp (r[2], expected) != 0) {
1878         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1879         return -1;
1880       }
1881     }
1882     if (r[3] != NULL) {
1883       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1884       print_strings (r);
1885       return -1;
1886     }
1887     for (i = 0; r[i] != NULL; ++i)
1888       free (r[i]);
1889     free (r);
1890   }
1891   return 0;
1892 }
1893
1894 static int test_head_n_1_skip (void)
1895 {
1896   const char *str;
1897
1898   str = getenv ("TEST_ONLY");
1899   if (str)
1900     return strstr (str, "head_n") == NULL;
1901   str = getenv ("SKIP_TEST_HEAD_N_1");
1902   if (str && strcmp (str, "1") == 0) return 1;
1903   str = getenv ("SKIP_TEST_HEAD_N");
1904   if (str && strcmp (str, "1") == 0) return 1;
1905   return 0;
1906 }
1907
1908 static int test_head_n_1 (void)
1909 {
1910   if (test_head_n_1_skip ()) {
1911     printf ("        %s skipped (reason: environment variable set)\n", "test_head_n_1");
1912     return 0;
1913   }
1914
1915   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1916   {
1917     char device[] = "/dev/sda";
1918     int r;
1919     suppress_error = 0;
1920     r = guestfs_blockdev_setrw (g, device);
1921     if (r == -1)
1922       return -1;
1923   }
1924   {
1925     int r;
1926     suppress_error = 0;
1927     r = guestfs_umount_all (g);
1928     if (r == -1)
1929       return -1;
1930   }
1931   {
1932     int r;
1933     suppress_error = 0;
1934     r = guestfs_lvm_remove_all (g);
1935     if (r == -1)
1936       return -1;
1937   }
1938   {
1939     char device[] = "/dev/sda";
1940     char lines_0[] = ",";
1941     char *lines[] = {
1942       lines_0,
1943       NULL
1944     };
1945     int r;
1946     suppress_error = 0;
1947     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1948     if (r == -1)
1949       return -1;
1950   }
1951   {
1952     char fstype[] = "ext2";
1953     char device[] = "/dev/sda1";
1954     int r;
1955     suppress_error = 0;
1956     r = guestfs_mkfs (g, fstype, device);
1957     if (r == -1)
1958       return -1;
1959   }
1960   {
1961     char device[] = "/dev/sda1";
1962     char mountpoint[] = "/";
1963     int r;
1964     suppress_error = 0;
1965     r = guestfs_mount (g, device, mountpoint);
1966     if (r == -1)
1967       return -1;
1968   }
1969   /* TestOutputList for head_n (1) */
1970   {
1971     char options[] = "ro";
1972     char vfstype[] = "squashfs";
1973     char device[] = "/dev/sdd";
1974     char mountpoint[] = "/";
1975     int r;
1976     suppress_error = 0;
1977     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1978     if (r == -1)
1979       return -1;
1980   }
1981   {
1982     char path[] = "/10klines";
1983     char **r;
1984     int i;
1985     suppress_error = 0;
1986     r = guestfs_head_n (g, -9997, path);
1987     if (r == NULL)
1988       return -1;
1989     if (!r[0]) {
1990       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1991       print_strings (r);
1992       return -1;
1993     }
1994     {
1995       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1996       if (strcmp (r[0], expected) != 0) {
1997         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1998         return -1;
1999       }
2000     }
2001     if (!r[1]) {
2002       fprintf (stderr, "test_head_n_1: short list returned from command\n");
2003       print_strings (r);
2004       return -1;
2005     }
2006     {
2007       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2008       if (strcmp (r[1], expected) != 0) {
2009         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2010         return -1;
2011       }
2012     }
2013     if (!r[2]) {
2014       fprintf (stderr, "test_head_n_1: short list returned from command\n");
2015       print_strings (r);
2016       return -1;
2017     }
2018     {
2019       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2020       if (strcmp (r[2], expected) != 0) {
2021         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2022         return -1;
2023       }
2024     }
2025     if (r[3] != NULL) {
2026       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
2027       print_strings (r);
2028       return -1;
2029     }
2030     for (i = 0; r[i] != NULL; ++i)
2031       free (r[i]);
2032     free (r);
2033   }
2034   return 0;
2035 }
2036
2037 static int test_head_n_2_skip (void)
2038 {
2039   const char *str;
2040
2041   str = getenv ("TEST_ONLY");
2042   if (str)
2043     return strstr (str, "head_n") == NULL;
2044   str = getenv ("SKIP_TEST_HEAD_N_2");
2045   if (str && strcmp (str, "1") == 0) return 1;
2046   str = getenv ("SKIP_TEST_HEAD_N");
2047   if (str && strcmp (str, "1") == 0) return 1;
2048   return 0;
2049 }
2050
2051 static int test_head_n_2 (void)
2052 {
2053   if (test_head_n_2_skip ()) {
2054     printf ("        %s skipped (reason: environment variable set)\n", "test_head_n_2");
2055     return 0;
2056   }
2057
2058   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
2059   {
2060     char device[] = "/dev/sda";
2061     int r;
2062     suppress_error = 0;
2063     r = guestfs_blockdev_setrw (g, device);
2064     if (r == -1)
2065       return -1;
2066   }
2067   {
2068     int r;
2069     suppress_error = 0;
2070     r = guestfs_umount_all (g);
2071     if (r == -1)
2072       return -1;
2073   }
2074   {
2075     int r;
2076     suppress_error = 0;
2077     r = guestfs_lvm_remove_all (g);
2078     if (r == -1)
2079       return -1;
2080   }
2081   {
2082     char device[] = "/dev/sda";
2083     char lines_0[] = ",";
2084     char *lines[] = {
2085       lines_0,
2086       NULL
2087     };
2088     int r;
2089     suppress_error = 0;
2090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2091     if (r == -1)
2092       return -1;
2093   }
2094   {
2095     char fstype[] = "ext2";
2096     char device[] = "/dev/sda1";
2097     int r;
2098     suppress_error = 0;
2099     r = guestfs_mkfs (g, fstype, device);
2100     if (r == -1)
2101       return -1;
2102   }
2103   {
2104     char device[] = "/dev/sda1";
2105     char mountpoint[] = "/";
2106     int r;
2107     suppress_error = 0;
2108     r = guestfs_mount (g, device, mountpoint);
2109     if (r == -1)
2110       return -1;
2111   }
2112   /* TestOutputList for head_n (2) */
2113   {
2114     char options[] = "ro";
2115     char vfstype[] = "squashfs";
2116     char device[] = "/dev/sdd";
2117     char mountpoint[] = "/";
2118     int r;
2119     suppress_error = 0;
2120     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2121     if (r == -1)
2122       return -1;
2123   }
2124   {
2125     char path[] = "/10klines";
2126     char **r;
2127     int i;
2128     suppress_error = 0;
2129     r = guestfs_head_n (g, 0, path);
2130     if (r == NULL)
2131       return -1;
2132     if (r[0] != NULL) {
2133       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
2134       print_strings (r);
2135       return -1;
2136     }
2137     for (i = 0; r[i] != NULL; ++i)
2138       free (r[i]);
2139     free (r);
2140   }
2141   return 0;
2142 }
2143
2144 static int test_head_0_skip (void)
2145 {
2146   const char *str;
2147
2148   str = getenv ("TEST_ONLY");
2149   if (str)
2150     return strstr (str, "head") == NULL;
2151   str = getenv ("SKIP_TEST_HEAD_0");
2152   if (str && strcmp (str, "1") == 0) return 1;
2153   str = getenv ("SKIP_TEST_HEAD");
2154   if (str && strcmp (str, "1") == 0) return 1;
2155   return 0;
2156 }
2157
2158 static int test_head_0 (void)
2159 {
2160   if (test_head_0_skip ()) {
2161     printf ("        %s skipped (reason: environment variable set)\n", "test_head_0");
2162     return 0;
2163   }
2164
2165   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
2166   {
2167     char device[] = "/dev/sda";
2168     int r;
2169     suppress_error = 0;
2170     r = guestfs_blockdev_setrw (g, device);
2171     if (r == -1)
2172       return -1;
2173   }
2174   {
2175     int r;
2176     suppress_error = 0;
2177     r = guestfs_umount_all (g);
2178     if (r == -1)
2179       return -1;
2180   }
2181   {
2182     int r;
2183     suppress_error = 0;
2184     r = guestfs_lvm_remove_all (g);
2185     if (r == -1)
2186       return -1;
2187   }
2188   {
2189     char device[] = "/dev/sda";
2190     char lines_0[] = ",";
2191     char *lines[] = {
2192       lines_0,
2193       NULL
2194     };
2195     int r;
2196     suppress_error = 0;
2197     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2198     if (r == -1)
2199       return -1;
2200   }
2201   {
2202     char fstype[] = "ext2";
2203     char device[] = "/dev/sda1";
2204     int r;
2205     suppress_error = 0;
2206     r = guestfs_mkfs (g, fstype, device);
2207     if (r == -1)
2208       return -1;
2209   }
2210   {
2211     char device[] = "/dev/sda1";
2212     char mountpoint[] = "/";
2213     int r;
2214     suppress_error = 0;
2215     r = guestfs_mount (g, device, mountpoint);
2216     if (r == -1)
2217       return -1;
2218   }
2219   /* TestOutputList for head (0) */
2220   {
2221     char options[] = "ro";
2222     char vfstype[] = "squashfs";
2223     char device[] = "/dev/sdd";
2224     char mountpoint[] = "/";
2225     int r;
2226     suppress_error = 0;
2227     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2228     if (r == -1)
2229       return -1;
2230   }
2231   {
2232     char path[] = "/10klines";
2233     char **r;
2234     int i;
2235     suppress_error = 0;
2236     r = guestfs_head (g, path);
2237     if (r == NULL)
2238       return -1;
2239     if (!r[0]) {
2240       fprintf (stderr, "test_head_0: short list returned from command\n");
2241       print_strings (r);
2242       return -1;
2243     }
2244     {
2245       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
2246       if (strcmp (r[0], expected) != 0) {
2247         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2248         return -1;
2249       }
2250     }
2251     if (!r[1]) {
2252       fprintf (stderr, "test_head_0: short list returned from command\n");
2253       print_strings (r);
2254       return -1;
2255     }
2256     {
2257       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2258       if (strcmp (r[1], expected) != 0) {
2259         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2260         return -1;
2261       }
2262     }
2263     if (!r[2]) {
2264       fprintf (stderr, "test_head_0: short list returned from command\n");
2265       print_strings (r);
2266       return -1;
2267     }
2268     {
2269       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2270       if (strcmp (r[2], expected) != 0) {
2271         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2272         return -1;
2273       }
2274     }
2275     if (!r[3]) {
2276       fprintf (stderr, "test_head_0: short list returned from command\n");
2277       print_strings (r);
2278       return -1;
2279     }
2280     {
2281       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
2282       if (strcmp (r[3], expected) != 0) {
2283         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2284         return -1;
2285       }
2286     }
2287     if (!r[4]) {
2288       fprintf (stderr, "test_head_0: short list returned from command\n");
2289       print_strings (r);
2290       return -1;
2291     }
2292     {
2293       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
2294       if (strcmp (r[4], expected) != 0) {
2295         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
2296         return -1;
2297       }
2298     }
2299     if (!r[5]) {
2300       fprintf (stderr, "test_head_0: short list returned from command\n");
2301       print_strings (r);
2302       return -1;
2303     }
2304     {
2305       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
2306       if (strcmp (r[5], expected) != 0) {
2307         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
2308         return -1;
2309       }
2310     }
2311     if (!r[6]) {
2312       fprintf (stderr, "test_head_0: short list returned from command\n");
2313       print_strings (r);
2314       return -1;
2315     }
2316     {
2317       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
2318       if (strcmp (r[6], expected) != 0) {
2319         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
2320         return -1;
2321       }
2322     }
2323     if (!r[7]) {
2324       fprintf (stderr, "test_head_0: short list returned from command\n");
2325       print_strings (r);
2326       return -1;
2327     }
2328     {
2329       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
2330       if (strcmp (r[7], expected) != 0) {
2331         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
2332         return -1;
2333       }
2334     }
2335     if (!r[8]) {
2336       fprintf (stderr, "test_head_0: short list returned from command\n");
2337       print_strings (r);
2338       return -1;
2339     }
2340     {
2341       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
2342       if (strcmp (r[8], expected) != 0) {
2343         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
2344         return -1;
2345       }
2346     }
2347     if (!r[9]) {
2348       fprintf (stderr, "test_head_0: short list returned from command\n");
2349       print_strings (r);
2350       return -1;
2351     }
2352     {
2353       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
2354       if (strcmp (r[9], expected) != 0) {
2355         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
2356         return -1;
2357       }
2358     }
2359     if (r[10] != NULL) {
2360       fprintf (stderr, "test_head_0: extra elements returned from command\n");
2361       print_strings (r);
2362       return -1;
2363     }
2364     for (i = 0; r[i] != NULL; ++i)
2365       free (r[i]);
2366     free (r);
2367   }
2368   return 0;
2369 }
2370
2371 static int test_wc_c_0_skip (void)
2372 {
2373   const char *str;
2374
2375   str = getenv ("TEST_ONLY");
2376   if (str)
2377     return strstr (str, "wc_c") == NULL;
2378   str = getenv ("SKIP_TEST_WC_C_0");
2379   if (str && strcmp (str, "1") == 0) return 1;
2380   str = getenv ("SKIP_TEST_WC_C");
2381   if (str && strcmp (str, "1") == 0) return 1;
2382   return 0;
2383 }
2384
2385 static int test_wc_c_0 (void)
2386 {
2387   if (test_wc_c_0_skip ()) {
2388     printf ("        %s skipped (reason: environment variable set)\n", "test_wc_c_0");
2389     return 0;
2390   }
2391
2392   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
2393   {
2394     char device[] = "/dev/sda";
2395     int r;
2396     suppress_error = 0;
2397     r = guestfs_blockdev_setrw (g, device);
2398     if (r == -1)
2399       return -1;
2400   }
2401   {
2402     int r;
2403     suppress_error = 0;
2404     r = guestfs_umount_all (g);
2405     if (r == -1)
2406       return -1;
2407   }
2408   {
2409     int r;
2410     suppress_error = 0;
2411     r = guestfs_lvm_remove_all (g);
2412     if (r == -1)
2413       return -1;
2414   }
2415   {
2416     char device[] = "/dev/sda";
2417     char lines_0[] = ",";
2418     char *lines[] = {
2419       lines_0,
2420       NULL
2421     };
2422     int r;
2423     suppress_error = 0;
2424     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2425     if (r == -1)
2426       return -1;
2427   }
2428   {
2429     char fstype[] = "ext2";
2430     char device[] = "/dev/sda1";
2431     int r;
2432     suppress_error = 0;
2433     r = guestfs_mkfs (g, fstype, device);
2434     if (r == -1)
2435       return -1;
2436   }
2437   {
2438     char device[] = "/dev/sda1";
2439     char mountpoint[] = "/";
2440     int r;
2441     suppress_error = 0;
2442     r = guestfs_mount (g, device, mountpoint);
2443     if (r == -1)
2444       return -1;
2445   }
2446   /* TestOutputInt for wc_c (0) */
2447   {
2448     char options[] = "ro";
2449     char vfstype[] = "squashfs";
2450     char device[] = "/dev/sdd";
2451     char mountpoint[] = "/";
2452     int r;
2453     suppress_error = 0;
2454     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2455     if (r == -1)
2456       return -1;
2457   }
2458   {
2459     char path[] = "/100kallspaces";
2460     int r;
2461     suppress_error = 0;
2462     r = guestfs_wc_c (g, path);
2463     if (r == -1)
2464       return -1;
2465     if (r != 102400) {
2466       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
2467       return -1;
2468     }
2469   }
2470   return 0;
2471 }
2472
2473 static int test_wc_w_0_skip (void)
2474 {
2475   const char *str;
2476
2477   str = getenv ("TEST_ONLY");
2478   if (str)
2479     return strstr (str, "wc_w") == NULL;
2480   str = getenv ("SKIP_TEST_WC_W_0");
2481   if (str && strcmp (str, "1") == 0) return 1;
2482   str = getenv ("SKIP_TEST_WC_W");
2483   if (str && strcmp (str, "1") == 0) return 1;
2484   return 0;
2485 }
2486
2487 static int test_wc_w_0 (void)
2488 {
2489   if (test_wc_w_0_skip ()) {
2490     printf ("        %s skipped (reason: environment variable set)\n", "test_wc_w_0");
2491     return 0;
2492   }
2493
2494   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
2495   {
2496     char device[] = "/dev/sda";
2497     int r;
2498     suppress_error = 0;
2499     r = guestfs_blockdev_setrw (g, device);
2500     if (r == -1)
2501       return -1;
2502   }
2503   {
2504     int r;
2505     suppress_error = 0;
2506     r = guestfs_umount_all (g);
2507     if (r == -1)
2508       return -1;
2509   }
2510   {
2511     int r;
2512     suppress_error = 0;
2513     r = guestfs_lvm_remove_all (g);
2514     if (r == -1)
2515       return -1;
2516   }
2517   {
2518     char device[] = "/dev/sda";
2519     char lines_0[] = ",";
2520     char *lines[] = {
2521       lines_0,
2522       NULL
2523     };
2524     int r;
2525     suppress_error = 0;
2526     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2527     if (r == -1)
2528       return -1;
2529   }
2530   {
2531     char fstype[] = "ext2";
2532     char device[] = "/dev/sda1";
2533     int r;
2534     suppress_error = 0;
2535     r = guestfs_mkfs (g, fstype, device);
2536     if (r == -1)
2537       return -1;
2538   }
2539   {
2540     char device[] = "/dev/sda1";
2541     char mountpoint[] = "/";
2542     int r;
2543     suppress_error = 0;
2544     r = guestfs_mount (g, device, mountpoint);
2545     if (r == -1)
2546       return -1;
2547   }
2548   /* TestOutputInt for wc_w (0) */
2549   {
2550     char options[] = "ro";
2551     char vfstype[] = "squashfs";
2552     char device[] = "/dev/sdd";
2553     char mountpoint[] = "/";
2554     int r;
2555     suppress_error = 0;
2556     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2557     if (r == -1)
2558       return -1;
2559   }
2560   {
2561     char path[] = "/10klines";
2562     int r;
2563     suppress_error = 0;
2564     r = guestfs_wc_w (g, path);
2565     if (r == -1)
2566       return -1;
2567     if (r != 10000) {
2568       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
2569       return -1;
2570     }
2571   }
2572   return 0;
2573 }
2574
2575 static int test_wc_l_0_skip (void)
2576 {
2577   const char *str;
2578
2579   str = getenv ("TEST_ONLY");
2580   if (str)
2581     return strstr (str, "wc_l") == NULL;
2582   str = getenv ("SKIP_TEST_WC_L_0");
2583   if (str && strcmp (str, "1") == 0) return 1;
2584   str = getenv ("SKIP_TEST_WC_L");
2585   if (str && strcmp (str, "1") == 0) return 1;
2586   return 0;
2587 }
2588
2589 static int test_wc_l_0 (void)
2590 {
2591   if (test_wc_l_0_skip ()) {
2592     printf ("        %s skipped (reason: environment variable set)\n", "test_wc_l_0");
2593     return 0;
2594   }
2595
2596   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2597   {
2598     char device[] = "/dev/sda";
2599     int r;
2600     suppress_error = 0;
2601     r = guestfs_blockdev_setrw (g, device);
2602     if (r == -1)
2603       return -1;
2604   }
2605   {
2606     int r;
2607     suppress_error = 0;
2608     r = guestfs_umount_all (g);
2609     if (r == -1)
2610       return -1;
2611   }
2612   {
2613     int r;
2614     suppress_error = 0;
2615     r = guestfs_lvm_remove_all (g);
2616     if (r == -1)
2617       return -1;
2618   }
2619   {
2620     char device[] = "/dev/sda";
2621     char lines_0[] = ",";
2622     char *lines[] = {
2623       lines_0,
2624       NULL
2625     };
2626     int r;
2627     suppress_error = 0;
2628     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2629     if (r == -1)
2630       return -1;
2631   }
2632   {
2633     char fstype[] = "ext2";
2634     char device[] = "/dev/sda1";
2635     int r;
2636     suppress_error = 0;
2637     r = guestfs_mkfs (g, fstype, device);
2638     if (r == -1)
2639       return -1;
2640   }
2641   {
2642     char device[] = "/dev/sda1";
2643     char mountpoint[] = "/";
2644     int r;
2645     suppress_error = 0;
2646     r = guestfs_mount (g, device, mountpoint);
2647     if (r == -1)
2648       return -1;
2649   }
2650   /* TestOutputInt for wc_l (0) */
2651   {
2652     char options[] = "ro";
2653     char vfstype[] = "squashfs";
2654     char device[] = "/dev/sdd";
2655     char mountpoint[] = "/";
2656     int r;
2657     suppress_error = 0;
2658     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2659     if (r == -1)
2660       return -1;
2661   }
2662   {
2663     char path[] = "/10klines";
2664     int r;
2665     suppress_error = 0;
2666     r = guestfs_wc_l (g, path);
2667     if (r == -1)
2668       return -1;
2669     if (r != 10000) {
2670       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
2671       return -1;
2672     }
2673   }
2674   return 0;
2675 }
2676
2677 static int test_mkdtemp_0_skip (void)
2678 {
2679   const char *str;
2680
2681   str = getenv ("TEST_ONLY");
2682   if (str)
2683     return strstr (str, "mkdtemp") == NULL;
2684   str = getenv ("SKIP_TEST_MKDTEMP_0");
2685   if (str && strcmp (str, "1") == 0) return 1;
2686   str = getenv ("SKIP_TEST_MKDTEMP");
2687   if (str && strcmp (str, "1") == 0) return 1;
2688   return 0;
2689 }
2690
2691 static int test_mkdtemp_0 (void)
2692 {
2693   if (test_mkdtemp_0_skip ()) {
2694     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2695     return 0;
2696   }
2697
2698   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2699   {
2700     char device[] = "/dev/sda";
2701     int r;
2702     suppress_error = 0;
2703     r = guestfs_blockdev_setrw (g, device);
2704     if (r == -1)
2705       return -1;
2706   }
2707   {
2708     int r;
2709     suppress_error = 0;
2710     r = guestfs_umount_all (g);
2711     if (r == -1)
2712       return -1;
2713   }
2714   {
2715     int r;
2716     suppress_error = 0;
2717     r = guestfs_lvm_remove_all (g);
2718     if (r == -1)
2719       return -1;
2720   }
2721   {
2722     char device[] = "/dev/sda";
2723     char lines_0[] = ",";
2724     char *lines[] = {
2725       lines_0,
2726       NULL
2727     };
2728     int r;
2729     suppress_error = 0;
2730     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2731     if (r == -1)
2732       return -1;
2733   }
2734   {
2735     char fstype[] = "ext2";
2736     char device[] = "/dev/sda1";
2737     int r;
2738     suppress_error = 0;
2739     r = guestfs_mkfs (g, fstype, device);
2740     if (r == -1)
2741       return -1;
2742   }
2743   {
2744     char device[] = "/dev/sda1";
2745     char mountpoint[] = "/";
2746     int r;
2747     suppress_error = 0;
2748     r = guestfs_mount (g, device, mountpoint);
2749     if (r == -1)
2750       return -1;
2751   }
2752   /* TestRun for mkdtemp (0) */
2753   {
2754     char path[] = "/tmp";
2755     int r;
2756     suppress_error = 0;
2757     r = guestfs_mkdir (g, path);
2758     if (r == -1)
2759       return -1;
2760   }
2761   {
2762     char template[] = "/tmp/tmpXXXXXX";
2763     char *r;
2764     suppress_error = 0;
2765     r = guestfs_mkdtemp (g, template);
2766     if (r == NULL)
2767       return -1;
2768     free (r);
2769   }
2770   return 0;
2771 }
2772
2773 static int test_scrub_file_0_skip (void)
2774 {
2775   const char *str;
2776
2777   str = getenv ("TEST_ONLY");
2778   if (str)
2779     return strstr (str, "scrub_file") == NULL;
2780   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2781   if (str && strcmp (str, "1") == 0) return 1;
2782   str = getenv ("SKIP_TEST_SCRUB_FILE");
2783   if (str && strcmp (str, "1") == 0) return 1;
2784   return 0;
2785 }
2786
2787 static int test_scrub_file_0 (void)
2788 {
2789   if (test_scrub_file_0_skip ()) {
2790     printf ("        %s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2791     return 0;
2792   }
2793
2794   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2795   {
2796     char device[] = "/dev/sda";
2797     int r;
2798     suppress_error = 0;
2799     r = guestfs_blockdev_setrw (g, device);
2800     if (r == -1)
2801       return -1;
2802   }
2803   {
2804     int r;
2805     suppress_error = 0;
2806     r = guestfs_umount_all (g);
2807     if (r == -1)
2808       return -1;
2809   }
2810   {
2811     int r;
2812     suppress_error = 0;
2813     r = guestfs_lvm_remove_all (g);
2814     if (r == -1)
2815       return -1;
2816   }
2817   {
2818     char device[] = "/dev/sda";
2819     char lines_0[] = ",";
2820     char *lines[] = {
2821       lines_0,
2822       NULL
2823     };
2824     int r;
2825     suppress_error = 0;
2826     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2827     if (r == -1)
2828       return -1;
2829   }
2830   {
2831     char fstype[] = "ext2";
2832     char device[] = "/dev/sda1";
2833     int r;
2834     suppress_error = 0;
2835     r = guestfs_mkfs (g, fstype, device);
2836     if (r == -1)
2837       return -1;
2838   }
2839   {
2840     char device[] = "/dev/sda1";
2841     char mountpoint[] = "/";
2842     int r;
2843     suppress_error = 0;
2844     r = guestfs_mount (g, device, mountpoint);
2845     if (r == -1)
2846       return -1;
2847   }
2848   /* TestRun for scrub_file (0) */
2849   {
2850     char path[] = "/file";
2851     char content[] = "content";
2852     int r;
2853     suppress_error = 0;
2854     r = guestfs_write_file (g, path, content, 0);
2855     if (r == -1)
2856       return -1;
2857   }
2858   {
2859     char file[] = "/file";
2860     int r;
2861     suppress_error = 0;
2862     r = guestfs_scrub_file (g, file);
2863     if (r == -1)
2864       return -1;
2865   }
2866   return 0;
2867 }
2868
2869 static int test_scrub_device_0_skip (void)
2870 {
2871   const char *str;
2872
2873   str = getenv ("TEST_ONLY");
2874   if (str)
2875     return strstr (str, "scrub_device") == NULL;
2876   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2877   if (str && strcmp (str, "1") == 0) return 1;
2878   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2879   if (str && strcmp (str, "1") == 0) return 1;
2880   return 0;
2881 }
2882
2883 static int test_scrub_device_0 (void)
2884 {
2885   if (test_scrub_device_0_skip ()) {
2886     printf ("        %s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2887     return 0;
2888   }
2889
2890   /* InitNone|InitEmpty for test_scrub_device_0 */
2891   {
2892     char device[] = "/dev/sda";
2893     int r;
2894     suppress_error = 0;
2895     r = guestfs_blockdev_setrw (g, device);
2896     if (r == -1)
2897       return -1;
2898   }
2899   {
2900     int r;
2901     suppress_error = 0;
2902     r = guestfs_umount_all (g);
2903     if (r == -1)
2904       return -1;
2905   }
2906   {
2907     int r;
2908     suppress_error = 0;
2909     r = guestfs_lvm_remove_all (g);
2910     if (r == -1)
2911       return -1;
2912   }
2913   /* TestRun for scrub_device (0) */
2914   {
2915     char device[] = "/dev/sdc";
2916     int r;
2917     suppress_error = 0;
2918     r = guestfs_scrub_device (g, device);
2919     if (r == -1)
2920       return -1;
2921   }
2922   return 0;
2923 }
2924
2925 static int test_glob_expand_0_skip (void)
2926 {
2927   const char *str;
2928
2929   str = getenv ("TEST_ONLY");
2930   if (str)
2931     return strstr (str, "glob_expand") == NULL;
2932   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2933   if (str && strcmp (str, "1") == 0) return 1;
2934   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2935   if (str && strcmp (str, "1") == 0) return 1;
2936   return 0;
2937 }
2938
2939 static int test_glob_expand_0 (void)
2940 {
2941   if (test_glob_expand_0_skip ()) {
2942     printf ("        %s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2943     return 0;
2944   }
2945
2946   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2947   {
2948     char device[] = "/dev/sda";
2949     int r;
2950     suppress_error = 0;
2951     r = guestfs_blockdev_setrw (g, device);
2952     if (r == -1)
2953       return -1;
2954   }
2955   {
2956     int r;
2957     suppress_error = 0;
2958     r = guestfs_umount_all (g);
2959     if (r == -1)
2960       return -1;
2961   }
2962   {
2963     int r;
2964     suppress_error = 0;
2965     r = guestfs_lvm_remove_all (g);
2966     if (r == -1)
2967       return -1;
2968   }
2969   {
2970     char device[] = "/dev/sda";
2971     char lines_0[] = ",";
2972     char *lines[] = {
2973       lines_0,
2974       NULL
2975     };
2976     int r;
2977     suppress_error = 0;
2978     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2979     if (r == -1)
2980       return -1;
2981   }
2982   {
2983     char fstype[] = "ext2";
2984     char device[] = "/dev/sda1";
2985     int r;
2986     suppress_error = 0;
2987     r = guestfs_mkfs (g, fstype, device);
2988     if (r == -1)
2989       return -1;
2990   }
2991   {
2992     char device[] = "/dev/sda1";
2993     char mountpoint[] = "/";
2994     int r;
2995     suppress_error = 0;
2996     r = guestfs_mount (g, device, mountpoint);
2997     if (r == -1)
2998       return -1;
2999   }
3000   /* TestOutputList for glob_expand (0) */
3001   {
3002     char path[] = "/a/b/c";
3003     int r;
3004     suppress_error = 0;
3005     r = guestfs_mkdir_p (g, path);
3006     if (r == -1)
3007       return -1;
3008   }
3009   {
3010     char path[] = "/a/b/c/d";
3011     int r;
3012     suppress_error = 0;
3013     r = guestfs_touch (g, path);
3014     if (r == -1)
3015       return -1;
3016   }
3017   {
3018     char path[] = "/a/b/c/e";
3019     int r;
3020     suppress_error = 0;
3021     r = guestfs_touch (g, path);
3022     if (r == -1)
3023       return -1;
3024   }
3025   {
3026     char pattern[] = "/a/b/c/*";
3027     char **r;
3028     int i;
3029     suppress_error = 0;
3030     r = guestfs_glob_expand (g, pattern);
3031     if (r == NULL)
3032       return -1;
3033     if (!r[0]) {
3034       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3035       print_strings (r);
3036       return -1;
3037     }
3038     {
3039       char expected[] = "/a/b/c/d";
3040       if (strcmp (r[0], expected) != 0) {
3041         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3042         return -1;
3043       }
3044     }
3045     if (!r[1]) {
3046       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3047       print_strings (r);
3048       return -1;
3049     }
3050     {
3051       char expected[] = "/a/b/c/e";
3052       if (strcmp (r[1], expected) != 0) {
3053         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3054         return -1;
3055       }
3056     }
3057     if (r[2] != NULL) {
3058       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
3059       print_strings (r);
3060       return -1;
3061     }
3062     for (i = 0; r[i] != NULL; ++i)
3063       free (r[i]);
3064     free (r);
3065   }
3066   return 0;
3067 }
3068
3069 static int test_glob_expand_1_skip (void)
3070 {
3071   const char *str;
3072
3073   str = getenv ("TEST_ONLY");
3074   if (str)
3075     return strstr (str, "glob_expand") == NULL;
3076   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
3077   if (str && strcmp (str, "1") == 0) return 1;
3078   str = getenv ("SKIP_TEST_GLOB_EXPAND");
3079   if (str && strcmp (str, "1") == 0) return 1;
3080   return 0;
3081 }
3082
3083 static int test_glob_expand_1 (void)
3084 {
3085   if (test_glob_expand_1_skip ()) {
3086     printf ("        %s skipped (reason: environment variable set)\n", "test_glob_expand_1");
3087     return 0;
3088   }
3089
3090   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
3091   {
3092     char device[] = "/dev/sda";
3093     int r;
3094     suppress_error = 0;
3095     r = guestfs_blockdev_setrw (g, device);
3096     if (r == -1)
3097       return -1;
3098   }
3099   {
3100     int r;
3101     suppress_error = 0;
3102     r = guestfs_umount_all (g);
3103     if (r == -1)
3104       return -1;
3105   }
3106   {
3107     int r;
3108     suppress_error = 0;
3109     r = guestfs_lvm_remove_all (g);
3110     if (r == -1)
3111       return -1;
3112   }
3113   {
3114     char device[] = "/dev/sda";
3115     char lines_0[] = ",";
3116     char *lines[] = {
3117       lines_0,
3118       NULL
3119     };
3120     int r;
3121     suppress_error = 0;
3122     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3123     if (r == -1)
3124       return -1;
3125   }
3126   {
3127     char fstype[] = "ext2";
3128     char device[] = "/dev/sda1";
3129     int r;
3130     suppress_error = 0;
3131     r = guestfs_mkfs (g, fstype, device);
3132     if (r == -1)
3133       return -1;
3134   }
3135   {
3136     char device[] = "/dev/sda1";
3137     char mountpoint[] = "/";
3138     int r;
3139     suppress_error = 0;
3140     r = guestfs_mount (g, device, mountpoint);
3141     if (r == -1)
3142       return -1;
3143   }
3144   /* TestOutputList for glob_expand (1) */
3145   {
3146     char path[] = "/a/b/c";
3147     int r;
3148     suppress_error = 0;
3149     r = guestfs_mkdir_p (g, path);
3150     if (r == -1)
3151       return -1;
3152   }
3153   {
3154     char path[] = "/a/b/c/d";
3155     int r;
3156     suppress_error = 0;
3157     r = guestfs_touch (g, path);
3158     if (r == -1)
3159       return -1;
3160   }
3161   {
3162     char path[] = "/a/b/c/e";
3163     int r;
3164     suppress_error = 0;
3165     r = guestfs_touch (g, path);
3166     if (r == -1)
3167       return -1;
3168   }
3169   {
3170     char pattern[] = "/a/*/c/*";
3171     char **r;
3172     int i;
3173     suppress_error = 0;
3174     r = guestfs_glob_expand (g, pattern);
3175     if (r == NULL)
3176       return -1;
3177     if (!r[0]) {
3178       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3179       print_strings (r);
3180       return -1;
3181     }
3182     {
3183       char expected[] = "/a/b/c/d";
3184       if (strcmp (r[0], expected) != 0) {
3185         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3186         return -1;
3187       }
3188     }
3189     if (!r[1]) {
3190       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3191       print_strings (r);
3192       return -1;
3193     }
3194     {
3195       char expected[] = "/a/b/c/e";
3196       if (strcmp (r[1], expected) != 0) {
3197         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3198         return -1;
3199       }
3200     }
3201     if (r[2] != NULL) {
3202       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
3203       print_strings (r);
3204       return -1;
3205     }
3206     for (i = 0; r[i] != NULL; ++i)
3207       free (r[i]);
3208     free (r);
3209   }
3210   return 0;
3211 }
3212
3213 static int test_glob_expand_2_skip (void)
3214 {
3215   const char *str;
3216
3217   str = getenv ("TEST_ONLY");
3218   if (str)
3219     return strstr (str, "glob_expand") == NULL;
3220   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
3221   if (str && strcmp (str, "1") == 0) return 1;
3222   str = getenv ("SKIP_TEST_GLOB_EXPAND");
3223   if (str && strcmp (str, "1") == 0) return 1;
3224   return 0;
3225 }
3226
3227 static int test_glob_expand_2 (void)
3228 {
3229   if (test_glob_expand_2_skip ()) {
3230     printf ("        %s skipped (reason: environment variable set)\n", "test_glob_expand_2");
3231     return 0;
3232   }
3233
3234   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
3235   {
3236     char device[] = "/dev/sda";
3237     int r;
3238     suppress_error = 0;
3239     r = guestfs_blockdev_setrw (g, device);
3240     if (r == -1)
3241       return -1;
3242   }
3243   {
3244     int r;
3245     suppress_error = 0;
3246     r = guestfs_umount_all (g);
3247     if (r == -1)
3248       return -1;
3249   }
3250   {
3251     int r;
3252     suppress_error = 0;
3253     r = guestfs_lvm_remove_all (g);
3254     if (r == -1)
3255       return -1;
3256   }
3257   {
3258     char device[] = "/dev/sda";
3259     char lines_0[] = ",";
3260     char *lines[] = {
3261       lines_0,
3262       NULL
3263     };
3264     int r;
3265     suppress_error = 0;
3266     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3267     if (r == -1)
3268       return -1;
3269   }
3270   {
3271     char fstype[] = "ext2";
3272     char device[] = "/dev/sda1";
3273     int r;
3274     suppress_error = 0;
3275     r = guestfs_mkfs (g, fstype, device);
3276     if (r == -1)
3277       return -1;
3278   }
3279   {
3280     char device[] = "/dev/sda1";
3281     char mountpoint[] = "/";
3282     int r;
3283     suppress_error = 0;
3284     r = guestfs_mount (g, device, mountpoint);
3285     if (r == -1)
3286       return -1;
3287   }
3288   /* TestOutputList for glob_expand (2) */
3289   {
3290     char path[] = "/a/b/c";
3291     int r;
3292     suppress_error = 0;
3293     r = guestfs_mkdir_p (g, path);
3294     if (r == -1)
3295       return -1;
3296   }
3297   {
3298     char path[] = "/a/b/c/d";
3299     int r;
3300     suppress_error = 0;
3301     r = guestfs_touch (g, path);
3302     if (r == -1)
3303       return -1;
3304   }
3305   {
3306     char path[] = "/a/b/c/e";
3307     int r;
3308     suppress_error = 0;
3309     r = guestfs_touch (g, path);
3310     if (r == -1)
3311       return -1;
3312   }
3313   {
3314     char pattern[] = "/a/*/x/*";
3315     char **r;
3316     int i;
3317     suppress_error = 0;
3318     r = guestfs_glob_expand (g, pattern);
3319     if (r == NULL)
3320       return -1;
3321     if (r[0] != NULL) {
3322       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
3323       print_strings (r);
3324       return -1;
3325     }
3326     for (i = 0; r[i] != NULL; ++i)
3327       free (r[i]);
3328     free (r);
3329   }
3330   return 0;
3331 }
3332
3333 static int test_ntfs_3g_probe_0_skip (void)
3334 {
3335   const char *str;
3336
3337   str = getenv ("TEST_ONLY");
3338   if (str)
3339     return strstr (str, "ntfs_3g_probe") == NULL;
3340   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
3341   if (str && strcmp (str, "1") == 0) return 1;
3342   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3343   if (str && strcmp (str, "1") == 0) return 1;
3344   return 0;
3345 }
3346
3347 static int test_ntfs_3g_probe_0 (void)
3348 {
3349   if (test_ntfs_3g_probe_0_skip ()) {
3350     printf ("        %s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
3351     return 0;
3352   }
3353
3354   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
3355   {
3356     char device[] = "/dev/sda";
3357     int r;
3358     suppress_error = 0;
3359     r = guestfs_blockdev_setrw (g, device);
3360     if (r == -1)
3361       return -1;
3362   }
3363   {
3364     int r;
3365     suppress_error = 0;
3366     r = guestfs_umount_all (g);
3367     if (r == -1)
3368       return -1;
3369   }
3370   {
3371     int r;
3372     suppress_error = 0;
3373     r = guestfs_lvm_remove_all (g);
3374     if (r == -1)
3375       return -1;
3376   }
3377   /* TestOutputInt for ntfs_3g_probe (0) */
3378   {
3379     char device[] = "/dev/sda";
3380     char lines_0[] = ",";
3381     char *lines[] = {
3382       lines_0,
3383       NULL
3384     };
3385     int r;
3386     suppress_error = 0;
3387     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3388     if (r == -1)
3389       return -1;
3390   }
3391   {
3392     char fstype[] = "ntfs";
3393     char device[] = "/dev/sda1";
3394     int r;
3395     suppress_error = 0;
3396     r = guestfs_mkfs (g, fstype, device);
3397     if (r == -1)
3398       return -1;
3399   }
3400   {
3401     char device[] = "/dev/sda1";
3402     int r;
3403     suppress_error = 0;
3404     r = guestfs_ntfs_3g_probe (g, 1, device);
3405     if (r == -1)
3406       return -1;
3407     if (r != 0) {
3408       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
3409       return -1;
3410     }
3411   }
3412   return 0;
3413 }
3414
3415 static int test_ntfs_3g_probe_1_skip (void)
3416 {
3417   const char *str;
3418
3419   str = getenv ("TEST_ONLY");
3420   if (str)
3421     return strstr (str, "ntfs_3g_probe") == NULL;
3422   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
3423   if (str && strcmp (str, "1") == 0) return 1;
3424   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3425   if (str && strcmp (str, "1") == 0) return 1;
3426   return 0;
3427 }
3428
3429 static int test_ntfs_3g_probe_1 (void)
3430 {
3431   if (test_ntfs_3g_probe_1_skip ()) {
3432     printf ("        %s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
3433     return 0;
3434   }
3435
3436   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
3437   {
3438     char device[] = "/dev/sda";
3439     int r;
3440     suppress_error = 0;
3441     r = guestfs_blockdev_setrw (g, device);
3442     if (r == -1)
3443       return -1;
3444   }
3445   {
3446     int r;
3447     suppress_error = 0;
3448     r = guestfs_umount_all (g);
3449     if (r == -1)
3450       return -1;
3451   }
3452   {
3453     int r;
3454     suppress_error = 0;
3455     r = guestfs_lvm_remove_all (g);
3456     if (r == -1)
3457       return -1;
3458   }
3459   /* TestOutputInt for ntfs_3g_probe (1) */
3460   {
3461     char device[] = "/dev/sda";
3462     char lines_0[] = ",";
3463     char *lines[] = {
3464       lines_0,
3465       NULL
3466     };
3467     int r;
3468     suppress_error = 0;
3469     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3470     if (r == -1)
3471       return -1;
3472   }
3473   {
3474     char fstype[] = "ext2";
3475     char device[] = "/dev/sda1";
3476     int r;
3477     suppress_error = 0;
3478     r = guestfs_mkfs (g, fstype, device);
3479     if (r == -1)
3480       return -1;
3481   }
3482   {
3483     char device[] = "/dev/sda1";
3484     int r;
3485     suppress_error = 0;
3486     r = guestfs_ntfs_3g_probe (g, 1, device);
3487     if (r == -1)
3488       return -1;
3489     if (r != 12) {
3490       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
3491       return -1;
3492     }
3493   }
3494   return 0;
3495 }
3496
3497 static int test_sleep_0_skip (void)
3498 {
3499   const char *str;
3500
3501   str = getenv ("TEST_ONLY");
3502   if (str)
3503     return strstr (str, "sleep") == NULL;
3504   str = getenv ("SKIP_TEST_SLEEP_0");
3505   if (str && strcmp (str, "1") == 0) return 1;
3506   str = getenv ("SKIP_TEST_SLEEP");
3507   if (str && strcmp (str, "1") == 0) return 1;
3508   return 0;
3509 }
3510
3511 static int test_sleep_0 (void)
3512 {
3513   if (test_sleep_0_skip ()) {
3514     printf ("        %s skipped (reason: environment variable set)\n", "test_sleep_0");
3515     return 0;
3516   }
3517
3518   /* InitNone|InitEmpty for test_sleep_0 */
3519   {
3520     char device[] = "/dev/sda";
3521     int r;
3522     suppress_error = 0;
3523     r = guestfs_blockdev_setrw (g, device);
3524     if (r == -1)
3525       return -1;
3526   }
3527   {
3528     int r;
3529     suppress_error = 0;
3530     r = guestfs_umount_all (g);
3531     if (r == -1)
3532       return -1;
3533   }
3534   {
3535     int r;
3536     suppress_error = 0;
3537     r = guestfs_lvm_remove_all (g);
3538     if (r == -1)
3539       return -1;
3540   }
3541   /* TestRun for sleep (0) */
3542   {
3543     int r;
3544     suppress_error = 0;
3545     r = guestfs_sleep (g, 1);
3546     if (r == -1)
3547       return -1;
3548   }
3549   return 0;
3550 }
3551
3552 static int test_find_0_skip (void)
3553 {
3554   const char *str;
3555
3556   str = getenv ("TEST_ONLY");
3557   if (str)
3558     return strstr (str, "find") == NULL;
3559   str = getenv ("SKIP_TEST_FIND_0");
3560   if (str && strcmp (str, "1") == 0) return 1;
3561   str = getenv ("SKIP_TEST_FIND");
3562   if (str && strcmp (str, "1") == 0) return 1;
3563   return 0;
3564 }
3565
3566 static int test_find_0 (void)
3567 {
3568   if (test_find_0_skip ()) {
3569     printf ("        %s skipped (reason: environment variable set)\n", "test_find_0");
3570     return 0;
3571   }
3572
3573   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3574   {
3575     char device[] = "/dev/sda";
3576     int r;
3577     suppress_error = 0;
3578     r = guestfs_blockdev_setrw (g, device);
3579     if (r == -1)
3580       return -1;
3581   }
3582   {
3583     int r;
3584     suppress_error = 0;
3585     r = guestfs_umount_all (g);
3586     if (r == -1)
3587       return -1;
3588   }
3589   {
3590     int r;
3591     suppress_error = 0;
3592     r = guestfs_lvm_remove_all (g);
3593     if (r == -1)
3594       return -1;
3595   }
3596   {
3597     char device[] = "/dev/sda";
3598     char lines_0[] = ",";
3599     char *lines[] = {
3600       lines_0,
3601       NULL
3602     };
3603     int r;
3604     suppress_error = 0;
3605     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3606     if (r == -1)
3607       return -1;
3608   }
3609   {
3610     char fstype[] = "ext2";
3611     char device[] = "/dev/sda1";
3612     int r;
3613     suppress_error = 0;
3614     r = guestfs_mkfs (g, fstype, device);
3615     if (r == -1)
3616       return -1;
3617   }
3618   {
3619     char device[] = "/dev/sda1";
3620     char mountpoint[] = "/";
3621     int r;
3622     suppress_error = 0;
3623     r = guestfs_mount (g, device, mountpoint);
3624     if (r == -1)
3625       return -1;
3626   }
3627   /* TestOutputList for find (0) */
3628   {
3629     char directory[] = "/";
3630     char **r;
3631     int i;
3632     suppress_error = 0;
3633     r = guestfs_find (g, directory);
3634     if (r == NULL)
3635       return -1;
3636     if (!r[0]) {
3637       fprintf (stderr, "test_find_0: short list returned from command\n");
3638       print_strings (r);
3639       return -1;
3640     }
3641     {
3642       char expected[] = "lost+found";
3643       if (strcmp (r[0], expected) != 0) {
3644         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3645         return -1;
3646       }
3647     }
3648     if (r[1] != NULL) {
3649       fprintf (stderr, "test_find_0: extra elements returned from command\n");
3650       print_strings (r);
3651       return -1;
3652     }
3653     for (i = 0; r[i] != NULL; ++i)
3654       free (r[i]);
3655     free (r);
3656   }
3657   return 0;
3658 }
3659
3660 static int test_find_1_skip (void)
3661 {
3662   const char *str;
3663
3664   str = getenv ("TEST_ONLY");
3665   if (str)
3666     return strstr (str, "find") == NULL;
3667   str = getenv ("SKIP_TEST_FIND_1");
3668   if (str && strcmp (str, "1") == 0) return 1;
3669   str = getenv ("SKIP_TEST_FIND");
3670   if (str && strcmp (str, "1") == 0) return 1;
3671   return 0;
3672 }
3673
3674 static int test_find_1 (void)
3675 {
3676   if (test_find_1_skip ()) {
3677     printf ("        %s skipped (reason: environment variable set)\n", "test_find_1");
3678     return 0;
3679   }
3680
3681   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3682   {
3683     char device[] = "/dev/sda";
3684     int r;
3685     suppress_error = 0;
3686     r = guestfs_blockdev_setrw (g, device);
3687     if (r == -1)
3688       return -1;
3689   }
3690   {
3691     int r;
3692     suppress_error = 0;
3693     r = guestfs_umount_all (g);
3694     if (r == -1)
3695       return -1;
3696   }
3697   {
3698     int r;
3699     suppress_error = 0;
3700     r = guestfs_lvm_remove_all (g);
3701     if (r == -1)
3702       return -1;
3703   }
3704   {
3705     char device[] = "/dev/sda";
3706     char lines_0[] = ",";
3707     char *lines[] = {
3708       lines_0,
3709       NULL
3710     };
3711     int r;
3712     suppress_error = 0;
3713     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3714     if (r == -1)
3715       return -1;
3716   }
3717   {
3718     char fstype[] = "ext2";
3719     char device[] = "/dev/sda1";
3720     int r;
3721     suppress_error = 0;
3722     r = guestfs_mkfs (g, fstype, device);
3723     if (r == -1)
3724       return -1;
3725   }
3726   {
3727     char device[] = "/dev/sda1";
3728     char mountpoint[] = "/";
3729     int r;
3730     suppress_error = 0;
3731     r = guestfs_mount (g, device, mountpoint);
3732     if (r == -1)
3733       return -1;
3734   }
3735   /* TestOutputList for find (1) */
3736   {
3737     char path[] = "/a";
3738     int r;
3739     suppress_error = 0;
3740     r = guestfs_touch (g, path);
3741     if (r == -1)
3742       return -1;
3743   }
3744   {
3745     char path[] = "/b";
3746     int r;
3747     suppress_error = 0;
3748     r = guestfs_mkdir (g, path);
3749     if (r == -1)
3750       return -1;
3751   }
3752   {
3753     char path[] = "/b/c";
3754     int r;
3755     suppress_error = 0;
3756     r = guestfs_touch (g, path);
3757     if (r == -1)
3758       return -1;
3759   }
3760   {
3761     char directory[] = "/";
3762     char **r;
3763     int i;
3764     suppress_error = 0;
3765     r = guestfs_find (g, directory);
3766     if (r == NULL)
3767       return -1;
3768     if (!r[0]) {
3769       fprintf (stderr, "test_find_1: short list returned from command\n");
3770       print_strings (r);
3771       return -1;
3772     }
3773     {
3774       char expected[] = "a";
3775       if (strcmp (r[0], expected) != 0) {
3776         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3777         return -1;
3778       }
3779     }
3780     if (!r[1]) {
3781       fprintf (stderr, "test_find_1: short list returned from command\n");
3782       print_strings (r);
3783       return -1;
3784     }
3785     {
3786       char expected[] = "b";
3787       if (strcmp (r[1], expected) != 0) {
3788         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3789         return -1;
3790       }
3791     }
3792     if (!r[2]) {
3793       fprintf (stderr, "test_find_1: short list returned from command\n");
3794       print_strings (r);
3795       return -1;
3796     }
3797     {
3798       char expected[] = "b/c";
3799       if (strcmp (r[2], expected) != 0) {
3800         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3801         return -1;
3802       }
3803     }
3804     if (!r[3]) {
3805       fprintf (stderr, "test_find_1: short list returned from command\n");
3806       print_strings (r);
3807       return -1;
3808     }
3809     {
3810       char expected[] = "lost+found";
3811       if (strcmp (r[3], expected) != 0) {
3812         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3813         return -1;
3814       }
3815     }
3816     if (r[4] != NULL) {
3817       fprintf (stderr, "test_find_1: extra elements returned from command\n");
3818       print_strings (r);
3819       return -1;
3820     }
3821     for (i = 0; r[i] != NULL; ++i)
3822       free (r[i]);
3823     free (r);
3824   }
3825   return 0;
3826 }
3827
3828 static int test_find_2_skip (void)
3829 {
3830   const char *str;
3831
3832   str = getenv ("TEST_ONLY");
3833   if (str)
3834     return strstr (str, "find") == NULL;
3835   str = getenv ("SKIP_TEST_FIND_2");
3836   if (str && strcmp (str, "1") == 0) return 1;
3837   str = getenv ("SKIP_TEST_FIND");
3838   if (str && strcmp (str, "1") == 0) return 1;
3839   return 0;
3840 }
3841
3842 static int test_find_2 (void)
3843 {
3844   if (test_find_2_skip ()) {
3845     printf ("        %s skipped (reason: environment variable set)\n", "test_find_2");
3846     return 0;
3847   }
3848
3849   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3850   {
3851     char device[] = "/dev/sda";
3852     int r;
3853     suppress_error = 0;
3854     r = guestfs_blockdev_setrw (g, device);
3855     if (r == -1)
3856       return -1;
3857   }
3858   {
3859     int r;
3860     suppress_error = 0;
3861     r = guestfs_umount_all (g);
3862     if (r == -1)
3863       return -1;
3864   }
3865   {
3866     int r;
3867     suppress_error = 0;
3868     r = guestfs_lvm_remove_all (g);
3869     if (r == -1)
3870       return -1;
3871   }
3872   {
3873     char device[] = "/dev/sda";
3874     char lines_0[] = ",";
3875     char *lines[] = {
3876       lines_0,
3877       NULL
3878     };
3879     int r;
3880     suppress_error = 0;
3881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3882     if (r == -1)
3883       return -1;
3884   }
3885   {
3886     char fstype[] = "ext2";
3887     char device[] = "/dev/sda1";
3888     int r;
3889     suppress_error = 0;
3890     r = guestfs_mkfs (g, fstype, device);
3891     if (r == -1)
3892       return -1;
3893   }
3894   {
3895     char device[] = "/dev/sda1";
3896     char mountpoint[] = "/";
3897     int r;
3898     suppress_error = 0;
3899     r = guestfs_mount (g, device, mountpoint);
3900     if (r == -1)
3901       return -1;
3902   }
3903   /* TestOutputList for find (2) */
3904   {
3905     char path[] = "/a/b/c";
3906     int r;
3907     suppress_error = 0;
3908     r = guestfs_mkdir_p (g, path);
3909     if (r == -1)
3910       return -1;
3911   }
3912   {
3913     char path[] = "/a/b/c/d";
3914     int r;
3915     suppress_error = 0;
3916     r = guestfs_touch (g, path);
3917     if (r == -1)
3918       return -1;
3919   }
3920   {
3921     char directory[] = "/a/b/";
3922     char **r;
3923     int i;
3924     suppress_error = 0;
3925     r = guestfs_find (g, directory);
3926     if (r == NULL)
3927       return -1;
3928     if (!r[0]) {
3929       fprintf (stderr, "test_find_2: short list returned from command\n");
3930       print_strings (r);
3931       return -1;
3932     }
3933     {
3934       char expected[] = "c";
3935       if (strcmp (r[0], expected) != 0) {
3936         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3937         return -1;
3938       }
3939     }
3940     if (!r[1]) {
3941       fprintf (stderr, "test_find_2: short list returned from command\n");
3942       print_strings (r);
3943       return -1;
3944     }
3945     {
3946       char expected[] = "c/d";
3947       if (strcmp (r[1], expected) != 0) {
3948         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3949         return -1;
3950       }
3951     }
3952     if (r[2] != NULL) {
3953       fprintf (stderr, "test_find_2: extra elements returned from command\n");
3954       print_strings (r);
3955       return -1;
3956     }
3957     for (i = 0; r[i] != NULL; ++i)
3958       free (r[i]);
3959     free (r);
3960   }
3961   return 0;
3962 }
3963
3964 static int test_lvresize_0_skip (void)
3965 {
3966   const char *str;
3967
3968   str = getenv ("TEST_ONLY");
3969   if (str)
3970     return strstr (str, "lvresize") == NULL;
3971   str = getenv ("SKIP_TEST_LVRESIZE_0");
3972   if (str && strcmp (str, "1") == 0) return 1;
3973   str = getenv ("SKIP_TEST_LVRESIZE");
3974   if (str && strcmp (str, "1") == 0) return 1;
3975   return 0;
3976 }
3977
3978 static int test_lvresize_0 (void)
3979 {
3980   if (test_lvresize_0_skip ()) {
3981     printf ("        %s skipped (reason: environment variable set)\n", "test_lvresize_0");
3982     return 0;
3983   }
3984
3985   /* InitNone|InitEmpty for test_lvresize_0 */
3986   {
3987     char device[] = "/dev/sda";
3988     int r;
3989     suppress_error = 0;
3990     r = guestfs_blockdev_setrw (g, device);
3991     if (r == -1)
3992       return -1;
3993   }
3994   {
3995     int r;
3996     suppress_error = 0;
3997     r = guestfs_umount_all (g);
3998     if (r == -1)
3999       return -1;
4000   }
4001   {
4002     int r;
4003     suppress_error = 0;
4004     r = guestfs_lvm_remove_all (g);
4005     if (r == -1)
4006       return -1;
4007   }
4008   /* TestOutput for lvresize (0) */
4009   char expected[] = "test content";
4010   {
4011     char device[] = "/dev/sda";
4012     char lines_0[] = ",";
4013     char *lines[] = {
4014       lines_0,
4015       NULL
4016     };
4017     int r;
4018     suppress_error = 0;
4019     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4020     if (r == -1)
4021       return -1;
4022   }
4023   {
4024     char device[] = "/dev/sda1";
4025     int r;
4026     suppress_error = 0;
4027     r = guestfs_pvcreate (g, device);
4028     if (r == -1)
4029       return -1;
4030   }
4031   {
4032     char volgroup[] = "VG";
4033     char physvols_0[] = "/dev/sda1";
4034     char *physvols[] = {
4035       physvols_0,
4036       NULL
4037     };
4038     int r;
4039     suppress_error = 0;
4040     r = guestfs_vgcreate (g, volgroup, physvols);
4041     if (r == -1)
4042       return -1;
4043   }
4044   {
4045     char logvol[] = "LV";
4046     char volgroup[] = "VG";
4047     int r;
4048     suppress_error = 0;
4049     r = guestfs_lvcreate (g, logvol, volgroup, 10);
4050     if (r == -1)
4051       return -1;
4052   }
4053   {
4054     char fstype[] = "ext2";
4055     char device[] = "/dev/VG/LV";
4056     int r;
4057     suppress_error = 0;
4058     r = guestfs_mkfs (g, fstype, device);
4059     if (r == -1)
4060       return -1;
4061   }
4062   {
4063     char device[] = "/dev/VG/LV";
4064     char mountpoint[] = "/";
4065     int r;
4066     suppress_error = 0;
4067     r = guestfs_mount (g, device, mountpoint);
4068     if (r == -1)
4069       return -1;
4070   }
4071   {
4072     char path[] = "/new";
4073     char content[] = "test content";
4074     int r;
4075     suppress_error = 0;
4076     r = guestfs_write_file (g, path, content, 0);
4077     if (r == -1)
4078       return -1;
4079   }
4080   {
4081     char pathordevice[] = "/";
4082     int r;
4083     suppress_error = 0;
4084     r = guestfs_umount (g, pathordevice);
4085     if (r == -1)
4086       return -1;
4087   }
4088   {
4089     char device[] = "/dev/VG/LV";
4090     int r;
4091     suppress_error = 0;
4092     r = guestfs_lvresize (g, device, 20);
4093     if (r == -1)
4094       return -1;
4095   }
4096   {
4097     char device[] = "/dev/VG/LV";
4098     int r;
4099     suppress_error = 0;
4100     r = guestfs_e2fsck_f (g, device);
4101     if (r == -1)
4102       return -1;
4103   }
4104   {
4105     char device[] = "/dev/VG/LV";
4106     int r;
4107     suppress_error = 0;
4108     r = guestfs_resize2fs (g, device);
4109     if (r == -1)
4110       return -1;
4111   }
4112   {
4113     char device[] = "/dev/VG/LV";
4114     char mountpoint[] = "/";
4115     int r;
4116     suppress_error = 0;
4117     r = guestfs_mount (g, device, mountpoint);
4118     if (r == -1)
4119       return -1;
4120   }
4121   {
4122     char path[] = "/new";
4123     char *r;
4124     suppress_error = 0;
4125     r = guestfs_cat (g, path);
4126     if (r == NULL)
4127       return -1;
4128     if (strcmp (r, expected) != 0) {
4129       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
4130       return -1;
4131     }
4132     free (r);
4133   }
4134   return 0;
4135 }
4136
4137 static int test_zerofree_0_skip (void)
4138 {
4139   const char *str;
4140
4141   str = getenv ("TEST_ONLY");
4142   if (str)
4143     return strstr (str, "zerofree") == NULL;
4144   str = getenv ("SKIP_TEST_ZEROFREE_0");
4145   if (str && strcmp (str, "1") == 0) return 1;
4146   str = getenv ("SKIP_TEST_ZEROFREE");
4147   if (str && strcmp (str, "1") == 0) return 1;
4148   return 0;
4149 }
4150
4151 static int test_zerofree_0 (void)
4152 {
4153   if (test_zerofree_0_skip ()) {
4154     printf ("        %s skipped (reason: environment variable set)\n", "test_zerofree_0");
4155     return 0;
4156   }
4157
4158   /* InitNone|InitEmpty for test_zerofree_0 */
4159   {
4160     char device[] = "/dev/sda";
4161     int r;
4162     suppress_error = 0;
4163     r = guestfs_blockdev_setrw (g, device);
4164     if (r == -1)
4165       return -1;
4166   }
4167   {
4168     int r;
4169     suppress_error = 0;
4170     r = guestfs_umount_all (g);
4171     if (r == -1)
4172       return -1;
4173   }
4174   {
4175     int r;
4176     suppress_error = 0;
4177     r = guestfs_lvm_remove_all (g);
4178     if (r == -1)
4179       return -1;
4180   }
4181   /* TestOutput for zerofree (0) */
4182   char expected[] = "test file";
4183   {
4184     char device[] = "/dev/sda";
4185     char lines_0[] = ",";
4186     char *lines[] = {
4187       lines_0,
4188       NULL
4189     };
4190     int r;
4191     suppress_error = 0;
4192     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4193     if (r == -1)
4194       return -1;
4195   }
4196   {
4197     char fstype[] = "ext3";
4198     char device[] = "/dev/sda1";
4199     int r;
4200     suppress_error = 0;
4201     r = guestfs_mkfs (g, fstype, device);
4202     if (r == -1)
4203       return -1;
4204   }
4205   {
4206     char device[] = "/dev/sda1";
4207     char mountpoint[] = "/";
4208     int r;
4209     suppress_error = 0;
4210     r = guestfs_mount (g, device, mountpoint);
4211     if (r == -1)
4212       return -1;
4213   }
4214   {
4215     char path[] = "/new";
4216     char content[] = "test file";
4217     int r;
4218     suppress_error = 0;
4219     r = guestfs_write_file (g, path, content, 0);
4220     if (r == -1)
4221       return -1;
4222   }
4223   {
4224     char pathordevice[] = "/dev/sda1";
4225     int r;
4226     suppress_error = 0;
4227     r = guestfs_umount (g, pathordevice);
4228     if (r == -1)
4229       return -1;
4230   }
4231   {
4232     char device[] = "/dev/sda1";
4233     int r;
4234     suppress_error = 0;
4235     r = guestfs_zerofree (g, device);
4236     if (r == -1)
4237       return -1;
4238   }
4239   {
4240     char device[] = "/dev/sda1";
4241     char mountpoint[] = "/";
4242     int r;
4243     suppress_error = 0;
4244     r = guestfs_mount (g, device, mountpoint);
4245     if (r == -1)
4246       return -1;
4247   }
4248   {
4249     char path[] = "/new";
4250     char *r;
4251     suppress_error = 0;
4252     r = guestfs_cat (g, path);
4253     if (r == NULL)
4254       return -1;
4255     if (strcmp (r, expected) != 0) {
4256       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
4257       return -1;
4258     }
4259     free (r);
4260   }
4261   return 0;
4262 }
4263
4264 static int test_hexdump_0_skip (void)
4265 {
4266   const char *str;
4267
4268   str = getenv ("TEST_ONLY");
4269   if (str)
4270     return strstr (str, "hexdump") == NULL;
4271   str = getenv ("SKIP_TEST_HEXDUMP_0");
4272   if (str && strcmp (str, "1") == 0) return 1;
4273   str = getenv ("SKIP_TEST_HEXDUMP");
4274   if (str && strcmp (str, "1") == 0) return 1;
4275   return 0;
4276 }
4277
4278 static int test_hexdump_0 (void)
4279 {
4280   if (test_hexdump_0_skip ()) {
4281     printf ("        %s skipped (reason: environment variable set)\n", "test_hexdump_0");
4282     return 0;
4283   }
4284
4285   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
4286   {
4287     char device[] = "/dev/sda";
4288     int r;
4289     suppress_error = 0;
4290     r = guestfs_blockdev_setrw (g, device);
4291     if (r == -1)
4292       return -1;
4293   }
4294   {
4295     int r;
4296     suppress_error = 0;
4297     r = guestfs_umount_all (g);
4298     if (r == -1)
4299       return -1;
4300   }
4301   {
4302     int r;
4303     suppress_error = 0;
4304     r = guestfs_lvm_remove_all (g);
4305     if (r == -1)
4306       return -1;
4307   }
4308   {
4309     char device[] = "/dev/sda";
4310     char lines_0[] = ",";
4311     char *lines[] = {
4312       lines_0,
4313       NULL
4314     };
4315     int r;
4316     suppress_error = 0;
4317     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4318     if (r == -1)
4319       return -1;
4320   }
4321   {
4322     char fstype[] = "ext2";
4323     char device[] = "/dev/sda1";
4324     int r;
4325     suppress_error = 0;
4326     r = guestfs_mkfs (g, fstype, device);
4327     if (r == -1)
4328       return -1;
4329   }
4330   {
4331     char device[] = "/dev/sda1";
4332     char mountpoint[] = "/";
4333     int r;
4334     suppress_error = 0;
4335     r = guestfs_mount (g, device, mountpoint);
4336     if (r == -1)
4337       return -1;
4338   }
4339   /* TestOutput for hexdump (0) */
4340   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
4341   {
4342     char path[] = "/new";
4343     char content[] = "hello\nworld\n";
4344     int r;
4345     suppress_error = 0;
4346     r = guestfs_write_file (g, path, content, 12);
4347     if (r == -1)
4348       return -1;
4349   }
4350   {
4351     char path[] = "/new";
4352     char *r;
4353     suppress_error = 0;
4354     r = guestfs_hexdump (g, path);
4355     if (r == NULL)
4356       return -1;
4357     if (strcmp (r, expected) != 0) {
4358       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
4359       return -1;
4360     }
4361     free (r);
4362   }
4363   return 0;
4364 }
4365
4366 static int test_hexdump_1_skip (void)
4367 {
4368   const char *str;
4369
4370   str = getenv ("TEST_ONLY");
4371   if (str)
4372     return strstr (str, "hexdump") == NULL;
4373   str = getenv ("SKIP_TEST_HEXDUMP_1");
4374   if (str && strcmp (str, "1") == 0) return 1;
4375   str = getenv ("SKIP_TEST_HEXDUMP");
4376   if (str && strcmp (str, "1") == 0) return 1;
4377   return 0;
4378 }
4379
4380 static int test_hexdump_1 (void)
4381 {
4382   if (test_hexdump_1_skip ()) {
4383     printf ("        %s skipped (reason: environment variable set)\n", "test_hexdump_1");
4384     return 0;
4385   }
4386
4387   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
4388   {
4389     char device[] = "/dev/sda";
4390     int r;
4391     suppress_error = 0;
4392     r = guestfs_blockdev_setrw (g, device);
4393     if (r == -1)
4394       return -1;
4395   }
4396   {
4397     int r;
4398     suppress_error = 0;
4399     r = guestfs_umount_all (g);
4400     if (r == -1)
4401       return -1;
4402   }
4403   {
4404     int r;
4405     suppress_error = 0;
4406     r = guestfs_lvm_remove_all (g);
4407     if (r == -1)
4408       return -1;
4409   }
4410   {
4411     char device[] = "/dev/sda";
4412     char lines_0[] = ",";
4413     char *lines[] = {
4414       lines_0,
4415       NULL
4416     };
4417     int r;
4418     suppress_error = 0;
4419     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4420     if (r == -1)
4421       return -1;
4422   }
4423   {
4424     char fstype[] = "ext2";
4425     char device[] = "/dev/sda1";
4426     int r;
4427     suppress_error = 0;
4428     r = guestfs_mkfs (g, fstype, device);
4429     if (r == -1)
4430       return -1;
4431   }
4432   {
4433     char device[] = "/dev/sda1";
4434     char mountpoint[] = "/";
4435     int r;
4436     suppress_error = 0;
4437     r = guestfs_mount (g, device, mountpoint);
4438     if (r == -1)
4439       return -1;
4440   }
4441   /* TestRun for hexdump (1) */
4442   {
4443     char options[] = "ro";
4444     char vfstype[] = "squashfs";
4445     char device[] = "/dev/sdd";
4446     char mountpoint[] = "/";
4447     int r;
4448     suppress_error = 0;
4449     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
4450     if (r == -1)
4451       return -1;
4452   }
4453   {
4454     char path[] = "/100krandom";
4455     char *r;
4456     suppress_error = 0;
4457     r = guestfs_hexdump (g, path);
4458     if (r == NULL)
4459       return -1;
4460     free (r);
4461   }
4462   return 0;
4463 }
4464
4465 static int test_strings_e_0_skip (void)
4466 {
4467   const char *str;
4468
4469   str = getenv ("TEST_ONLY");
4470   if (str)
4471     return strstr (str, "strings_e") == NULL;
4472   str = getenv ("SKIP_TEST_STRINGS_E_0");
4473   if (str && strcmp (str, "1") == 0) return 1;
4474   str = getenv ("SKIP_TEST_STRINGS_E");
4475   if (str && strcmp (str, "1") == 0) return 1;
4476   return 0;
4477 }
4478
4479 static int test_strings_e_0 (void)
4480 {
4481   if (test_strings_e_0_skip ()) {
4482     printf ("        %s skipped (reason: environment variable set)\n", "test_strings_e_0");
4483     return 0;
4484   }
4485
4486   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
4487   {
4488     char device[] = "/dev/sda";
4489     int r;
4490     suppress_error = 0;
4491     r = guestfs_blockdev_setrw (g, device);
4492     if (r == -1)
4493       return -1;
4494   }
4495   {
4496     int r;
4497     suppress_error = 0;
4498     r = guestfs_umount_all (g);
4499     if (r == -1)
4500       return -1;
4501   }
4502   {
4503     int r;
4504     suppress_error = 0;
4505     r = guestfs_lvm_remove_all (g);
4506     if (r == -1)
4507       return -1;
4508   }
4509   {
4510     char device[] = "/dev/sda";
4511     char lines_0[] = ",";
4512     char *lines[] = {
4513       lines_0,
4514       NULL
4515     };
4516     int r;
4517     suppress_error = 0;
4518     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4519     if (r == -1)
4520       return -1;
4521   }
4522   {
4523     char fstype[] = "ext2";
4524     char device[] = "/dev/sda1";
4525     int r;
4526     suppress_error = 0;
4527     r = guestfs_mkfs (g, fstype, device);
4528     if (r == -1)
4529       return -1;
4530   }
4531   {
4532     char device[] = "/dev/sda1";
4533     char mountpoint[] = "/";
4534     int r;
4535     suppress_error = 0;
4536     r = guestfs_mount (g, device, mountpoint);
4537     if (r == -1)
4538       return -1;
4539   }
4540   /* TestOutputList for strings_e (0) */
4541   {
4542     char path[] = "/new";
4543     char content[] = "hello\nworld\n";
4544     int r;
4545     suppress_error = 0;
4546     r = guestfs_write_file (g, path, content, 0);
4547     if (r == -1)
4548       return -1;
4549   }
4550   {
4551     char encoding[] = "b";
4552     char path[] = "/new";
4553     char **r;
4554     int i;
4555     suppress_error = 0;
4556     r = guestfs_strings_e (g, encoding, path);
4557     if (r == NULL)
4558       return -1;
4559     if (r[0] != NULL) {
4560       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
4561       print_strings (r);
4562       return -1;
4563     }
4564     for (i = 0; r[i] != NULL; ++i)
4565       free (r[i]);
4566     free (r);
4567   }
4568   return 0;
4569 }
4570
4571 static int test_strings_e_1_skip (void)
4572 {
4573   const char *str;
4574
4575   str = getenv ("TEST_ONLY");
4576   if (str)
4577     return strstr (str, "strings_e") == NULL;
4578   str = getenv ("SKIP_TEST_STRINGS_E_1");
4579   if (str && strcmp (str, "1") == 0) return 1;
4580   str = getenv ("SKIP_TEST_STRINGS_E");
4581   if (str && strcmp (str, "1") == 0) return 1;
4582   return 0;
4583 }
4584
4585 static int test_strings_e_1 (void)
4586 {
4587   if (test_strings_e_1_skip ()) {
4588     printf ("        %s skipped (reason: environment variable set)\n", "test_strings_e_1");
4589     return 0;
4590   }
4591
4592   printf ("        %s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
4593   return 0;
4594 }
4595
4596 static int test_strings_0_skip (void)
4597 {
4598   const char *str;
4599
4600   str = getenv ("TEST_ONLY");
4601   if (str)
4602     return strstr (str, "strings") == NULL;
4603   str = getenv ("SKIP_TEST_STRINGS_0");
4604   if (str && strcmp (str, "1") == 0) return 1;
4605   str = getenv ("SKIP_TEST_STRINGS");
4606   if (str && strcmp (str, "1") == 0) return 1;
4607   return 0;
4608 }
4609
4610 static int test_strings_0 (void)
4611 {
4612   if (test_strings_0_skip ()) {
4613     printf ("        %s skipped (reason: environment variable set)\n", "test_strings_0");
4614     return 0;
4615   }
4616
4617   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
4618   {
4619     char device[] = "/dev/sda";
4620     int r;
4621     suppress_error = 0;
4622     r = guestfs_blockdev_setrw (g, device);
4623     if (r == -1)
4624       return -1;
4625   }
4626   {
4627     int r;
4628     suppress_error = 0;
4629     r = guestfs_umount_all (g);
4630     if (r == -1)
4631       return -1;
4632   }
4633   {
4634     int r;
4635     suppress_error = 0;
4636     r = guestfs_lvm_remove_all (g);
4637     if (r == -1)
4638       return -1;
4639   }
4640   {
4641     char device[] = "/dev/sda";
4642     char lines_0[] = ",";
4643     char *lines[] = {
4644       lines_0,
4645       NULL
4646     };
4647     int r;
4648     suppress_error = 0;
4649     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4650     if (r == -1)
4651       return -1;
4652   }
4653   {
4654     char fstype[] = "ext2";
4655     char device[] = "/dev/sda1";
4656     int r;
4657     suppress_error = 0;
4658     r = guestfs_mkfs (g, fstype, device);
4659     if (r == -1)
4660       return -1;
4661   }
4662   {
4663     char device[] = "/dev/sda1";
4664     char mountpoint[] = "/";
4665     int r;
4666     suppress_error = 0;
4667     r = guestfs_mount (g, device, mountpoint);
4668     if (r == -1)
4669       return -1;
4670   }
4671   /* TestOutputList for strings (0) */
4672   {
4673     char path[] = "/new";
4674     char content[] = "hello\nworld\n";
4675     int r;
4676     suppress_error = 0;
4677     r = guestfs_write_file (g, path, content, 0);
4678     if (r == -1)
4679       return -1;
4680   }
4681   {
4682     char path[] = "/new";
4683     char **r;
4684     int i;
4685     suppress_error = 0;
4686     r = guestfs_strings (g, path);
4687     if (r == NULL)
4688       return -1;
4689     if (!r[0]) {
4690       fprintf (stderr, "test_strings_0: short list returned from command\n");
4691       print_strings (r);
4692       return -1;
4693     }
4694     {
4695       char expected[] = "hello";
4696       if (strcmp (r[0], expected) != 0) {
4697         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4698         return -1;
4699       }
4700     }
4701     if (!r[1]) {
4702       fprintf (stderr, "test_strings_0: short list returned from command\n");
4703       print_strings (r);
4704       return -1;
4705     }
4706     {
4707       char expected[] = "world";
4708       if (strcmp (r[1], expected) != 0) {
4709         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
4710         return -1;
4711       }
4712     }
4713     if (r[2] != NULL) {
4714       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4715       print_strings (r);
4716       return -1;
4717     }
4718     for (i = 0; r[i] != NULL; ++i)
4719       free (r[i]);
4720     free (r);
4721   }
4722   return 0;
4723 }
4724
4725 static int test_strings_1_skip (void)
4726 {
4727   const char *str;
4728
4729   str = getenv ("TEST_ONLY");
4730   if (str)
4731     return strstr (str, "strings") == NULL;
4732   str = getenv ("SKIP_TEST_STRINGS_1");
4733   if (str && strcmp (str, "1") == 0) return 1;
4734   str = getenv ("SKIP_TEST_STRINGS");
4735   if (str && strcmp (str, "1") == 0) return 1;
4736   return 0;
4737 }
4738
4739 static int test_strings_1 (void)
4740 {
4741   if (test_strings_1_skip ()) {
4742     printf ("        %s skipped (reason: environment variable set)\n", "test_strings_1");
4743     return 0;
4744   }
4745
4746   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4747   {
4748     char device[] = "/dev/sda";
4749     int r;
4750     suppress_error = 0;
4751     r = guestfs_blockdev_setrw (g, device);
4752     if (r == -1)
4753       return -1;
4754   }
4755   {
4756     int r;
4757     suppress_error = 0;
4758     r = guestfs_umount_all (g);
4759     if (r == -1)
4760       return -1;
4761   }
4762   {
4763     int r;
4764     suppress_error = 0;
4765     r = guestfs_lvm_remove_all (g);
4766     if (r == -1)
4767       return -1;
4768   }
4769   {
4770     char device[] = "/dev/sda";
4771     char lines_0[] = ",";
4772     char *lines[] = {
4773       lines_0,
4774       NULL
4775     };
4776     int r;
4777     suppress_error = 0;
4778     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4779     if (r == -1)
4780       return -1;
4781   }
4782   {
4783     char fstype[] = "ext2";
4784     char device[] = "/dev/sda1";
4785     int r;
4786     suppress_error = 0;
4787     r = guestfs_mkfs (g, fstype, device);
4788     if (r == -1)
4789       return -1;
4790   }
4791   {
4792     char device[] = "/dev/sda1";
4793     char mountpoint[] = "/";
4794     int r;
4795     suppress_error = 0;
4796     r = guestfs_mount (g, device, mountpoint);
4797     if (r == -1)
4798       return -1;
4799   }
4800   /* TestOutputList for strings (1) */
4801   {
4802     char path[] = "/new";
4803     int r;
4804     suppress_error = 0;
4805     r = guestfs_touch (g, path);
4806     if (r == -1)
4807       return -1;
4808   }
4809   {
4810     char path[] = "/new";
4811     char **r;
4812     int i;
4813     suppress_error = 0;
4814     r = guestfs_strings (g, path);
4815     if (r == NULL)
4816       return -1;
4817     if (r[0] != NULL) {
4818       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4819       print_strings (r);
4820       return -1;
4821     }
4822     for (i = 0; r[i] != NULL; ++i)
4823       free (r[i]);
4824     free (r);
4825   }
4826   return 0;
4827 }
4828
4829 static int test_equal_0_skip (void)
4830 {
4831   const char *str;
4832
4833   str = getenv ("TEST_ONLY");
4834   if (str)
4835     return strstr (str, "equal") == NULL;
4836   str = getenv ("SKIP_TEST_EQUAL_0");
4837   if (str && strcmp (str, "1") == 0) return 1;
4838   str = getenv ("SKIP_TEST_EQUAL");
4839   if (str && strcmp (str, "1") == 0) return 1;
4840   return 0;
4841 }
4842
4843 static int test_equal_0 (void)
4844 {
4845   if (test_equal_0_skip ()) {
4846     printf ("        %s skipped (reason: environment variable set)\n", "test_equal_0");
4847     return 0;
4848   }
4849
4850   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4851   {
4852     char device[] = "/dev/sda";
4853     int r;
4854     suppress_error = 0;
4855     r = guestfs_blockdev_setrw (g, device);
4856     if (r == -1)
4857       return -1;
4858   }
4859   {
4860     int r;
4861     suppress_error = 0;
4862     r = guestfs_umount_all (g);
4863     if (r == -1)
4864       return -1;
4865   }
4866   {
4867     int r;
4868     suppress_error = 0;
4869     r = guestfs_lvm_remove_all (g);
4870     if (r == -1)
4871       return -1;
4872   }
4873   {
4874     char device[] = "/dev/sda";
4875     char lines_0[] = ",";
4876     char *lines[] = {
4877       lines_0,
4878       NULL
4879     };
4880     int r;
4881     suppress_error = 0;
4882     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4883     if (r == -1)
4884       return -1;
4885   }
4886   {
4887     char fstype[] = "ext2";
4888     char device[] = "/dev/sda1";
4889     int r;
4890     suppress_error = 0;
4891     r = guestfs_mkfs (g, fstype, device);
4892     if (r == -1)
4893       return -1;
4894   }
4895   {
4896     char device[] = "/dev/sda1";
4897     char mountpoint[] = "/";
4898     int r;
4899     suppress_error = 0;
4900     r = guestfs_mount (g, device, mountpoint);
4901     if (r == -1)
4902       return -1;
4903   }
4904   /* TestOutputTrue for equal (0) */
4905   {
4906     char path[] = "/file1";
4907     char content[] = "contents of a file";
4908     int r;
4909     suppress_error = 0;
4910     r = guestfs_write_file (g, path, content, 0);
4911     if (r == -1)
4912       return -1;
4913   }
4914   {
4915     char src[] = "/file1";
4916     char dest[] = "/file2";
4917     int r;
4918     suppress_error = 0;
4919     r = guestfs_cp (g, src, dest);
4920     if (r == -1)
4921       return -1;
4922   }
4923   {
4924     char file1[] = "/file1";
4925     char file2[] = "/file2";
4926     int r;
4927     suppress_error = 0;
4928     r = guestfs_equal (g, file1, file2);
4929     if (r == -1)
4930       return -1;
4931     if (!r) {
4932       fprintf (stderr, "test_equal_0: expected true, got false\n");
4933       return -1;
4934     }
4935   }
4936   return 0;
4937 }
4938
4939 static int test_equal_1_skip (void)
4940 {
4941   const char *str;
4942
4943   str = getenv ("TEST_ONLY");
4944   if (str)
4945     return strstr (str, "equal") == NULL;
4946   str = getenv ("SKIP_TEST_EQUAL_1");
4947   if (str && strcmp (str, "1") == 0) return 1;
4948   str = getenv ("SKIP_TEST_EQUAL");
4949   if (str && strcmp (str, "1") == 0) return 1;
4950   return 0;
4951 }
4952
4953 static int test_equal_1 (void)
4954 {
4955   if (test_equal_1_skip ()) {
4956     printf ("        %s skipped (reason: environment variable set)\n", "test_equal_1");
4957     return 0;
4958   }
4959
4960   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4961   {
4962     char device[] = "/dev/sda";
4963     int r;
4964     suppress_error = 0;
4965     r = guestfs_blockdev_setrw (g, device);
4966     if (r == -1)
4967       return -1;
4968   }
4969   {
4970     int r;
4971     suppress_error = 0;
4972     r = guestfs_umount_all (g);
4973     if (r == -1)
4974       return -1;
4975   }
4976   {
4977     int r;
4978     suppress_error = 0;
4979     r = guestfs_lvm_remove_all (g);
4980     if (r == -1)
4981       return -1;
4982   }
4983   {
4984     char device[] = "/dev/sda";
4985     char lines_0[] = ",";
4986     char *lines[] = {
4987       lines_0,
4988       NULL
4989     };
4990     int r;
4991     suppress_error = 0;
4992     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4993     if (r == -1)
4994       return -1;
4995   }
4996   {
4997     char fstype[] = "ext2";
4998     char device[] = "/dev/sda1";
4999     int r;
5000     suppress_error = 0;
5001     r = guestfs_mkfs (g, fstype, device);
5002     if (r == -1)
5003       return -1;
5004   }
5005   {
5006     char device[] = "/dev/sda1";
5007     char mountpoint[] = "/";
5008     int r;
5009     suppress_error = 0;
5010     r = guestfs_mount (g, device, mountpoint);
5011     if (r == -1)
5012       return -1;
5013   }
5014   /* TestOutputFalse for equal (1) */
5015   {
5016     char path[] = "/file1";
5017     char content[] = "contents of a file";
5018     int r;
5019     suppress_error = 0;
5020     r = guestfs_write_file (g, path, content, 0);
5021     if (r == -1)
5022       return -1;
5023   }
5024   {
5025     char path[] = "/file2";
5026     char content[] = "contents of another file";
5027     int r;
5028     suppress_error = 0;
5029     r = guestfs_write_file (g, path, content, 0);
5030     if (r == -1)
5031       return -1;
5032   }
5033   {
5034     char file1[] = "/file1";
5035     char file2[] = "/file2";
5036     int r;
5037     suppress_error = 0;
5038     r = guestfs_equal (g, file1, file2);
5039     if (r == -1)
5040       return -1;
5041     if (r) {
5042       fprintf (stderr, "test_equal_1: expected false, got true\n");
5043       return -1;
5044     }
5045   }
5046   return 0;
5047 }
5048
5049 static int test_equal_2_skip (void)
5050 {
5051   const char *str;
5052
5053   str = getenv ("TEST_ONLY");
5054   if (str)
5055     return strstr (str, "equal") == NULL;
5056   str = getenv ("SKIP_TEST_EQUAL_2");
5057   if (str && strcmp (str, "1") == 0) return 1;
5058   str = getenv ("SKIP_TEST_EQUAL");
5059   if (str && strcmp (str, "1") == 0) return 1;
5060   return 0;
5061 }
5062
5063 static int test_equal_2 (void)
5064 {
5065   if (test_equal_2_skip ()) {
5066     printf ("        %s skipped (reason: environment variable set)\n", "test_equal_2");
5067     return 0;
5068   }
5069
5070   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
5071   {
5072     char device[] = "/dev/sda";
5073     int r;
5074     suppress_error = 0;
5075     r = guestfs_blockdev_setrw (g, device);
5076     if (r == -1)
5077       return -1;
5078   }
5079   {
5080     int r;
5081     suppress_error = 0;
5082     r = guestfs_umount_all (g);
5083     if (r == -1)
5084       return -1;
5085   }
5086   {
5087     int r;
5088     suppress_error = 0;
5089     r = guestfs_lvm_remove_all (g);
5090     if (r == -1)
5091       return -1;
5092   }
5093   {
5094     char device[] = "/dev/sda";
5095     char lines_0[] = ",";
5096     char *lines[] = {
5097       lines_0,
5098       NULL
5099     };
5100     int r;
5101     suppress_error = 0;
5102     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5103     if (r == -1)
5104       return -1;
5105   }
5106   {
5107     char fstype[] = "ext2";
5108     char device[] = "/dev/sda1";
5109     int r;
5110     suppress_error = 0;
5111     r = guestfs_mkfs (g, fstype, device);
5112     if (r == -1)
5113       return -1;
5114   }
5115   {
5116     char device[] = "/dev/sda1";
5117     char mountpoint[] = "/";
5118     int r;
5119     suppress_error = 0;
5120     r = guestfs_mount (g, device, mountpoint);
5121     if (r == -1)
5122       return -1;
5123   }
5124   /* TestLastFail for equal (2) */
5125   {
5126     char file1[] = "/file1";
5127     char file2[] = "/file2";
5128     int r;
5129     suppress_error = 1;
5130     r = guestfs_equal (g, file1, file2);
5131     if (r != -1)
5132       return -1;
5133   }
5134   return 0;
5135 }
5136
5137 static int test_ping_daemon_0_skip (void)
5138 {
5139   const char *str;
5140
5141   str = getenv ("TEST_ONLY");
5142   if (str)
5143     return strstr (str, "ping_daemon") == NULL;
5144   str = getenv ("SKIP_TEST_PING_DAEMON_0");
5145   if (str && strcmp (str, "1") == 0) return 1;
5146   str = getenv ("SKIP_TEST_PING_DAEMON");
5147   if (str && strcmp (str, "1") == 0) return 1;
5148   return 0;
5149 }
5150
5151 static int test_ping_daemon_0 (void)
5152 {
5153   if (test_ping_daemon_0_skip ()) {
5154     printf ("        %s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
5155     return 0;
5156   }
5157
5158   /* InitNone|InitEmpty for test_ping_daemon_0 */
5159   {
5160     char device[] = "/dev/sda";
5161     int r;
5162     suppress_error = 0;
5163     r = guestfs_blockdev_setrw (g, device);
5164     if (r == -1)
5165       return -1;
5166   }
5167   {
5168     int r;
5169     suppress_error = 0;
5170     r = guestfs_umount_all (g);
5171     if (r == -1)
5172       return -1;
5173   }
5174   {
5175     int r;
5176     suppress_error = 0;
5177     r = guestfs_lvm_remove_all (g);
5178     if (r == -1)
5179       return -1;
5180   }
5181   /* TestRun for ping_daemon (0) */
5182   {
5183     int r;
5184     suppress_error = 0;
5185     r = guestfs_ping_daemon (g);
5186     if (r == -1)
5187       return -1;
5188   }
5189   return 0;
5190 }
5191
5192 static int test_dmesg_0_skip (void)
5193 {
5194   const char *str;
5195
5196   str = getenv ("TEST_ONLY");
5197   if (str)
5198     return strstr (str, "dmesg") == NULL;
5199   str = getenv ("SKIP_TEST_DMESG_0");
5200   if (str && strcmp (str, "1") == 0) return 1;
5201   str = getenv ("SKIP_TEST_DMESG");
5202   if (str && strcmp (str, "1") == 0) return 1;
5203   return 0;
5204 }
5205
5206 static int test_dmesg_0 (void)
5207 {
5208   if (test_dmesg_0_skip ()) {
5209     printf ("        %s skipped (reason: environment variable set)\n", "test_dmesg_0");
5210     return 0;
5211   }
5212
5213   /* InitNone|InitEmpty for test_dmesg_0 */
5214   {
5215     char device[] = "/dev/sda";
5216     int r;
5217     suppress_error = 0;
5218     r = guestfs_blockdev_setrw (g, device);
5219     if (r == -1)
5220       return -1;
5221   }
5222   {
5223     int r;
5224     suppress_error = 0;
5225     r = guestfs_umount_all (g);
5226     if (r == -1)
5227       return -1;
5228   }
5229   {
5230     int r;
5231     suppress_error = 0;
5232     r = guestfs_lvm_remove_all (g);
5233     if (r == -1)
5234       return -1;
5235   }
5236   /* TestRun for dmesg (0) */
5237   {
5238     char *r;
5239     suppress_error = 0;
5240     r = guestfs_dmesg (g);
5241     if (r == NULL)
5242       return -1;
5243     free (r);
5244   }
5245   return 0;
5246 }
5247
5248 static int test_drop_caches_0_skip (void)
5249 {
5250   const char *str;
5251
5252   str = getenv ("TEST_ONLY");
5253   if (str)
5254     return strstr (str, "drop_caches") == NULL;
5255   str = getenv ("SKIP_TEST_DROP_CACHES_0");
5256   if (str && strcmp (str, "1") == 0) return 1;
5257   str = getenv ("SKIP_TEST_DROP_CACHES");
5258   if (str && strcmp (str, "1") == 0) return 1;
5259   return 0;
5260 }
5261
5262 static int test_drop_caches_0 (void)
5263 {
5264   if (test_drop_caches_0_skip ()) {
5265     printf ("        %s skipped (reason: environment variable set)\n", "test_drop_caches_0");
5266     return 0;
5267   }
5268
5269   /* InitNone|InitEmpty for test_drop_caches_0 */
5270   {
5271     char device[] = "/dev/sda";
5272     int r;
5273     suppress_error = 0;
5274     r = guestfs_blockdev_setrw (g, device);
5275     if (r == -1)
5276       return -1;
5277   }
5278   {
5279     int r;
5280     suppress_error = 0;
5281     r = guestfs_umount_all (g);
5282     if (r == -1)
5283       return -1;
5284   }
5285   {
5286     int r;
5287     suppress_error = 0;
5288     r = guestfs_lvm_remove_all (g);
5289     if (r == -1)
5290       return -1;
5291   }
5292   /* TestRun for drop_caches (0) */
5293   {
5294     int r;
5295     suppress_error = 0;
5296     r = guestfs_drop_caches (g, 3);
5297     if (r == -1)
5298       return -1;
5299   }
5300   return 0;
5301 }
5302
5303 static int test_mv_0_skip (void)
5304 {
5305   const char *str;
5306
5307   str = getenv ("TEST_ONLY");
5308   if (str)
5309     return strstr (str, "mv") == NULL;
5310   str = getenv ("SKIP_TEST_MV_0");
5311   if (str && strcmp (str, "1") == 0) return 1;
5312   str = getenv ("SKIP_TEST_MV");
5313   if (str && strcmp (str, "1") == 0) return 1;
5314   return 0;
5315 }
5316
5317 static int test_mv_0 (void)
5318 {
5319   if (test_mv_0_skip ()) {
5320     printf ("        %s skipped (reason: environment variable set)\n", "test_mv_0");
5321     return 0;
5322   }
5323
5324   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
5325   {
5326     char device[] = "/dev/sda";
5327     int r;
5328     suppress_error = 0;
5329     r = guestfs_blockdev_setrw (g, device);
5330     if (r == -1)
5331       return -1;
5332   }
5333   {
5334     int r;
5335     suppress_error = 0;
5336     r = guestfs_umount_all (g);
5337     if (r == -1)
5338       return -1;
5339   }
5340   {
5341     int r;
5342     suppress_error = 0;
5343     r = guestfs_lvm_remove_all (g);
5344     if (r == -1)
5345       return -1;
5346   }
5347   {
5348     char device[] = "/dev/sda";
5349     char lines_0[] = ",";
5350     char *lines[] = {
5351       lines_0,
5352       NULL
5353     };
5354     int r;
5355     suppress_error = 0;
5356     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5357     if (r == -1)
5358       return -1;
5359   }
5360   {
5361     char fstype[] = "ext2";
5362     char device[] = "/dev/sda1";
5363     int r;
5364     suppress_error = 0;
5365     r = guestfs_mkfs (g, fstype, device);
5366     if (r == -1)
5367       return -1;
5368   }
5369   {
5370     char device[] = "/dev/sda1";
5371     char mountpoint[] = "/";
5372     int r;
5373     suppress_error = 0;
5374     r = guestfs_mount (g, device, mountpoint);
5375     if (r == -1)
5376       return -1;
5377   }
5378   /* TestOutput for mv (0) */
5379   char expected[] = "file content";
5380   {
5381     char path[] = "/old";
5382     char content[] = "file content";
5383     int r;
5384     suppress_error = 0;
5385     r = guestfs_write_file (g, path, content, 0);
5386     if (r == -1)
5387       return -1;
5388   }
5389   {
5390     char src[] = "/old";
5391     char dest[] = "/new";
5392     int r;
5393     suppress_error = 0;
5394     r = guestfs_mv (g, src, dest);
5395     if (r == -1)
5396       return -1;
5397   }
5398   {
5399     char path[] = "/new";
5400     char *r;
5401     suppress_error = 0;
5402     r = guestfs_cat (g, path);
5403     if (r == NULL)
5404       return -1;
5405     if (strcmp (r, expected) != 0) {
5406       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
5407       return -1;
5408     }
5409     free (r);
5410   }
5411   return 0;
5412 }
5413
5414 static int test_mv_1_skip (void)
5415 {
5416   const char *str;
5417
5418   str = getenv ("TEST_ONLY");
5419   if (str)
5420     return strstr (str, "mv") == NULL;
5421   str = getenv ("SKIP_TEST_MV_1");
5422   if (str && strcmp (str, "1") == 0) return 1;
5423   str = getenv ("SKIP_TEST_MV");
5424   if (str && strcmp (str, "1") == 0) return 1;
5425   return 0;
5426 }
5427
5428 static int test_mv_1 (void)
5429 {
5430   if (test_mv_1_skip ()) {
5431     printf ("        %s skipped (reason: environment variable set)\n", "test_mv_1");
5432     return 0;
5433   }
5434
5435   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
5436   {
5437     char device[] = "/dev/sda";
5438     int r;
5439     suppress_error = 0;
5440     r = guestfs_blockdev_setrw (g, device);
5441     if (r == -1)
5442       return -1;
5443   }
5444   {
5445     int r;
5446     suppress_error = 0;
5447     r = guestfs_umount_all (g);
5448     if (r == -1)
5449       return -1;
5450   }
5451   {
5452     int r;
5453     suppress_error = 0;
5454     r = guestfs_lvm_remove_all (g);
5455     if (r == -1)
5456       return -1;
5457   }
5458   {
5459     char device[] = "/dev/sda";
5460     char lines_0[] = ",";
5461     char *lines[] = {
5462       lines_0,
5463       NULL
5464     };
5465     int r;
5466     suppress_error = 0;
5467     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5468     if (r == -1)
5469       return -1;
5470   }
5471   {
5472     char fstype[] = "ext2";
5473     char device[] = "/dev/sda1";
5474     int r;
5475     suppress_error = 0;
5476     r = guestfs_mkfs (g, fstype, device);
5477     if (r == -1)
5478       return -1;
5479   }
5480   {
5481     char device[] = "/dev/sda1";
5482     char mountpoint[] = "/";
5483     int r;
5484     suppress_error = 0;
5485     r = guestfs_mount (g, device, mountpoint);
5486     if (r == -1)
5487       return -1;
5488   }
5489   /* TestOutputFalse for mv (1) */
5490   {
5491     char path[] = "/old";
5492     char content[] = "file content";
5493     int r;
5494     suppress_error = 0;
5495     r = guestfs_write_file (g, path, content, 0);
5496     if (r == -1)
5497       return -1;
5498   }
5499   {
5500     char src[] = "/old";
5501     char dest[] = "/new";
5502     int r;
5503     suppress_error = 0;
5504     r = guestfs_mv (g, src, dest);
5505     if (r == -1)
5506       return -1;
5507   }
5508   {
5509     char path[] = "/old";
5510     int r;
5511     suppress_error = 0;
5512     r = guestfs_is_file (g, path);
5513     if (r == -1)
5514       return -1;
5515     if (r) {
5516       fprintf (stderr, "test_mv_1: expected false, got true\n");
5517       return -1;
5518     }
5519   }
5520   return 0;
5521 }
5522
5523 static int test_cp_a_0_skip (void)
5524 {
5525   const char *str;
5526
5527   str = getenv ("TEST_ONLY");
5528   if (str)
5529     return strstr (str, "cp_a") == NULL;
5530   str = getenv ("SKIP_TEST_CP_A_0");
5531   if (str && strcmp (str, "1") == 0) return 1;
5532   str = getenv ("SKIP_TEST_CP_A");
5533   if (str && strcmp (str, "1") == 0) return 1;
5534   return 0;
5535 }
5536
5537 static int test_cp_a_0 (void)
5538 {
5539   if (test_cp_a_0_skip ()) {
5540     printf ("        %s skipped (reason: environment variable set)\n", "test_cp_a_0");
5541     return 0;
5542   }
5543
5544   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
5545   {
5546     char device[] = "/dev/sda";
5547     int r;
5548     suppress_error = 0;
5549     r = guestfs_blockdev_setrw (g, device);
5550     if (r == -1)
5551       return -1;
5552   }
5553   {
5554     int r;
5555     suppress_error = 0;
5556     r = guestfs_umount_all (g);
5557     if (r == -1)
5558       return -1;
5559   }
5560   {
5561     int r;
5562     suppress_error = 0;
5563     r = guestfs_lvm_remove_all (g);
5564     if (r == -1)
5565       return -1;
5566   }
5567   {
5568     char device[] = "/dev/sda";
5569     char lines_0[] = ",";
5570     char *lines[] = {
5571       lines_0,
5572       NULL
5573     };
5574     int r;
5575     suppress_error = 0;
5576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5577     if (r == -1)
5578       return -1;
5579   }
5580   {
5581     char fstype[] = "ext2";
5582     char device[] = "/dev/sda1";
5583     int r;
5584     suppress_error = 0;
5585     r = guestfs_mkfs (g, fstype, device);
5586     if (r == -1)
5587       return -1;
5588   }
5589   {
5590     char device[] = "/dev/sda1";
5591     char mountpoint[] = "/";
5592     int r;
5593     suppress_error = 0;
5594     r = guestfs_mount (g, device, mountpoint);
5595     if (r == -1)
5596       return -1;
5597   }
5598   /* TestOutput for cp_a (0) */
5599   char expected[] = "file content";
5600   {
5601     char path[] = "/olddir";
5602     int r;
5603     suppress_error = 0;
5604     r = guestfs_mkdir (g, path);
5605     if (r == -1)
5606       return -1;
5607   }
5608   {
5609     char path[] = "/newdir";
5610     int r;
5611     suppress_error = 0;
5612     r = guestfs_mkdir (g, path);
5613     if (r == -1)
5614       return -1;
5615   }
5616   {
5617     char path[] = "/olddir/file";
5618     char content[] = "file content";
5619     int r;
5620     suppress_error = 0;
5621     r = guestfs_write_file (g, path, content, 0);
5622     if (r == -1)
5623       return -1;
5624   }
5625   {
5626     char src[] = "/olddir";
5627     char dest[] = "/newdir";
5628     int r;
5629     suppress_error = 0;
5630     r = guestfs_cp_a (g, src, dest);
5631     if (r == -1)
5632       return -1;
5633   }
5634   {
5635     char path[] = "/newdir/olddir/file";
5636     char *r;
5637     suppress_error = 0;
5638     r = guestfs_cat (g, path);
5639     if (r == NULL)
5640       return -1;
5641     if (strcmp (r, expected) != 0) {
5642       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
5643       return -1;
5644     }
5645     free (r);
5646   }
5647   return 0;
5648 }
5649
5650 static int test_cp_0_skip (void)
5651 {
5652   const char *str;
5653
5654   str = getenv ("TEST_ONLY");
5655   if (str)
5656     return strstr (str, "cp") == NULL;
5657   str = getenv ("SKIP_TEST_CP_0");
5658   if (str && strcmp (str, "1") == 0) return 1;
5659   str = getenv ("SKIP_TEST_CP");
5660   if (str && strcmp (str, "1") == 0) return 1;
5661   return 0;
5662 }
5663
5664 static int test_cp_0 (void)
5665 {
5666   if (test_cp_0_skip ()) {
5667     printf ("        %s skipped (reason: environment variable set)\n", "test_cp_0");
5668     return 0;
5669   }
5670
5671   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
5672   {
5673     char device[] = "/dev/sda";
5674     int r;
5675     suppress_error = 0;
5676     r = guestfs_blockdev_setrw (g, device);
5677     if (r == -1)
5678       return -1;
5679   }
5680   {
5681     int r;
5682     suppress_error = 0;
5683     r = guestfs_umount_all (g);
5684     if (r == -1)
5685       return -1;
5686   }
5687   {
5688     int r;
5689     suppress_error = 0;
5690     r = guestfs_lvm_remove_all (g);
5691     if (r == -1)
5692       return -1;
5693   }
5694   {
5695     char device[] = "/dev/sda";
5696     char lines_0[] = ",";
5697     char *lines[] = {
5698       lines_0,
5699       NULL
5700     };
5701     int r;
5702     suppress_error = 0;
5703     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5704     if (r == -1)
5705       return -1;
5706   }
5707   {
5708     char fstype[] = "ext2";
5709     char device[] = "/dev/sda1";
5710     int r;
5711     suppress_error = 0;
5712     r = guestfs_mkfs (g, fstype, device);
5713     if (r == -1)
5714       return -1;
5715   }
5716   {
5717     char device[] = "/dev/sda1";
5718     char mountpoint[] = "/";
5719     int r;
5720     suppress_error = 0;
5721     r = guestfs_mount (g, device, mountpoint);
5722     if (r == -1)
5723       return -1;
5724   }
5725   /* TestOutput for cp (0) */
5726   char expected[] = "file content";
5727   {
5728     char path[] = "/old";
5729     char content[] = "file content";
5730     int r;
5731     suppress_error = 0;
5732     r = guestfs_write_file (g, path, content, 0);
5733     if (r == -1)
5734       return -1;
5735   }
5736   {
5737     char src[] = "/old";
5738     char dest[] = "/new";
5739     int r;
5740     suppress_error = 0;
5741     r = guestfs_cp (g, src, dest);
5742     if (r == -1)
5743       return -1;
5744   }
5745   {
5746     char path[] = "/new";
5747     char *r;
5748     suppress_error = 0;
5749     r = guestfs_cat (g, path);
5750     if (r == NULL)
5751       return -1;
5752     if (strcmp (r, expected) != 0) {
5753       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5754       return -1;
5755     }
5756     free (r);
5757   }
5758   return 0;
5759 }
5760
5761 static int test_cp_1_skip (void)
5762 {
5763   const char *str;
5764
5765   str = getenv ("TEST_ONLY");
5766   if (str)
5767     return strstr (str, "cp") == NULL;
5768   str = getenv ("SKIP_TEST_CP_1");
5769   if (str && strcmp (str, "1") == 0) return 1;
5770   str = getenv ("SKIP_TEST_CP");
5771   if (str && strcmp (str, "1") == 0) return 1;
5772   return 0;
5773 }
5774
5775 static int test_cp_1 (void)
5776 {
5777   if (test_cp_1_skip ()) {
5778     printf ("        %s skipped (reason: environment variable set)\n", "test_cp_1");
5779     return 0;
5780   }
5781
5782   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5783   {
5784     char device[] = "/dev/sda";
5785     int r;
5786     suppress_error = 0;
5787     r = guestfs_blockdev_setrw (g, device);
5788     if (r == -1)
5789       return -1;
5790   }
5791   {
5792     int r;
5793     suppress_error = 0;
5794     r = guestfs_umount_all (g);
5795     if (r == -1)
5796       return -1;
5797   }
5798   {
5799     int r;
5800     suppress_error = 0;
5801     r = guestfs_lvm_remove_all (g);
5802     if (r == -1)
5803       return -1;
5804   }
5805   {
5806     char device[] = "/dev/sda";
5807     char lines_0[] = ",";
5808     char *lines[] = {
5809       lines_0,
5810       NULL
5811     };
5812     int r;
5813     suppress_error = 0;
5814     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5815     if (r == -1)
5816       return -1;
5817   }
5818   {
5819     char fstype[] = "ext2";
5820     char device[] = "/dev/sda1";
5821     int r;
5822     suppress_error = 0;
5823     r = guestfs_mkfs (g, fstype, device);
5824     if (r == -1)
5825       return -1;
5826   }
5827   {
5828     char device[] = "/dev/sda1";
5829     char mountpoint[] = "/";
5830     int r;
5831     suppress_error = 0;
5832     r = guestfs_mount (g, device, mountpoint);
5833     if (r == -1)
5834       return -1;
5835   }
5836   /* TestOutputTrue for cp (1) */
5837   {
5838     char path[] = "/old";
5839     char content[] = "file content";
5840     int r;
5841     suppress_error = 0;
5842     r = guestfs_write_file (g, path, content, 0);
5843     if (r == -1)
5844       return -1;
5845   }
5846   {
5847     char src[] = "/old";
5848     char dest[] = "/new";
5849     int r;
5850     suppress_error = 0;
5851     r = guestfs_cp (g, src, dest);
5852     if (r == -1)
5853       return -1;
5854   }
5855   {
5856     char path[] = "/old";
5857     int r;
5858     suppress_error = 0;
5859     r = guestfs_is_file (g, path);
5860     if (r == -1)
5861       return -1;
5862     if (!r) {
5863       fprintf (stderr, "test_cp_1: expected true, got false\n");
5864       return -1;
5865     }
5866   }
5867   return 0;
5868 }
5869
5870 static int test_cp_2_skip (void)
5871 {
5872   const char *str;
5873
5874   str = getenv ("TEST_ONLY");
5875   if (str)
5876     return strstr (str, "cp") == NULL;
5877   str = getenv ("SKIP_TEST_CP_2");
5878   if (str && strcmp (str, "1") == 0) return 1;
5879   str = getenv ("SKIP_TEST_CP");
5880   if (str && strcmp (str, "1") == 0) return 1;
5881   return 0;
5882 }
5883
5884 static int test_cp_2 (void)
5885 {
5886   if (test_cp_2_skip ()) {
5887     printf ("        %s skipped (reason: environment variable set)\n", "test_cp_2");
5888     return 0;
5889   }
5890
5891   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5892   {
5893     char device[] = "/dev/sda";
5894     int r;
5895     suppress_error = 0;
5896     r = guestfs_blockdev_setrw (g, device);
5897     if (r == -1)
5898       return -1;
5899   }
5900   {
5901     int r;
5902     suppress_error = 0;
5903     r = guestfs_umount_all (g);
5904     if (r == -1)
5905       return -1;
5906   }
5907   {
5908     int r;
5909     suppress_error = 0;
5910     r = guestfs_lvm_remove_all (g);
5911     if (r == -1)
5912       return -1;
5913   }
5914   {
5915     char device[] = "/dev/sda";
5916     char lines_0[] = ",";
5917     char *lines[] = {
5918       lines_0,
5919       NULL
5920     };
5921     int r;
5922     suppress_error = 0;
5923     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5924     if (r == -1)
5925       return -1;
5926   }
5927   {
5928     char fstype[] = "ext2";
5929     char device[] = "/dev/sda1";
5930     int r;
5931     suppress_error = 0;
5932     r = guestfs_mkfs (g, fstype, device);
5933     if (r == -1)
5934       return -1;
5935   }
5936   {
5937     char device[] = "/dev/sda1";
5938     char mountpoint[] = "/";
5939     int r;
5940     suppress_error = 0;
5941     r = guestfs_mount (g, device, mountpoint);
5942     if (r == -1)
5943       return -1;
5944   }
5945   /* TestOutput for cp (2) */
5946   char expected[] = "file content";
5947   {
5948     char path[] = "/old";
5949     char content[] = "file content";
5950     int r;
5951     suppress_error = 0;
5952     r = guestfs_write_file (g, path, content, 0);
5953     if (r == -1)
5954       return -1;
5955   }
5956   {
5957     char path[] = "/dir";
5958     int r;
5959     suppress_error = 0;
5960     r = guestfs_mkdir (g, path);
5961     if (r == -1)
5962       return -1;
5963   }
5964   {
5965     char src[] = "/old";
5966     char dest[] = "/dir/new";
5967     int r;
5968     suppress_error = 0;
5969     r = guestfs_cp (g, src, dest);
5970     if (r == -1)
5971       return -1;
5972   }
5973   {
5974     char path[] = "/dir/new";
5975     char *r;
5976     suppress_error = 0;
5977     r = guestfs_cat (g, path);
5978     if (r == NULL)
5979       return -1;
5980     if (strcmp (r, expected) != 0) {
5981       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5982       return -1;
5983     }
5984     free (r);
5985   }
5986   return 0;
5987 }
5988
5989 static int test_grub_install_0_skip (void)
5990 {
5991   const char *str;
5992
5993   str = getenv ("TEST_ONLY");
5994   if (str)
5995     return strstr (str, "grub_install") == NULL;
5996   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5997   if (str && strcmp (str, "1") == 0) return 1;
5998   str = getenv ("SKIP_TEST_GRUB_INSTALL");
5999   if (str && strcmp (str, "1") == 0) return 1;
6000   return 0;
6001 }
6002
6003 static int test_grub_install_0 (void)
6004 {
6005   if (test_grub_install_0_skip ()) {
6006     printf ("        %s skipped (reason: environment variable set)\n", "test_grub_install_0");
6007     return 0;
6008   }
6009
6010   printf ("        %s skipped (reason: test disabled in generator)\n", "test_grub_install_0");
6011   return 0;
6012 }
6013
6014 static int test_zero_0_skip (void)
6015 {
6016   const char *str;
6017
6018   str = getenv ("TEST_ONLY");
6019   if (str)
6020     return strstr (str, "zero") == NULL;
6021   str = getenv ("SKIP_TEST_ZERO_0");
6022   if (str && strcmp (str, "1") == 0) return 1;
6023   str = getenv ("SKIP_TEST_ZERO");
6024   if (str && strcmp (str, "1") == 0) return 1;
6025   return 0;
6026 }
6027
6028 static int test_zero_0 (void)
6029 {
6030   if (test_zero_0_skip ()) {
6031     printf ("        %s skipped (reason: environment variable set)\n", "test_zero_0");
6032     return 0;
6033   }
6034
6035   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
6036   {
6037     char device[] = "/dev/sda";
6038     int r;
6039     suppress_error = 0;
6040     r = guestfs_blockdev_setrw (g, device);
6041     if (r == -1)
6042       return -1;
6043   }
6044   {
6045     int r;
6046     suppress_error = 0;
6047     r = guestfs_umount_all (g);
6048     if (r == -1)
6049       return -1;
6050   }
6051   {
6052     int r;
6053     suppress_error = 0;
6054     r = guestfs_lvm_remove_all (g);
6055     if (r == -1)
6056       return -1;
6057   }
6058   {
6059     char device[] = "/dev/sda";
6060     char lines_0[] = ",";
6061     char *lines[] = {
6062       lines_0,
6063       NULL
6064     };
6065     int r;
6066     suppress_error = 0;
6067     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6068     if (r == -1)
6069       return -1;
6070   }
6071   {
6072     char fstype[] = "ext2";
6073     char device[] = "/dev/sda1";
6074     int r;
6075     suppress_error = 0;
6076     r = guestfs_mkfs (g, fstype, device);
6077     if (r == -1)
6078       return -1;
6079   }
6080   {
6081     char device[] = "/dev/sda1";
6082     char mountpoint[] = "/";
6083     int r;
6084     suppress_error = 0;
6085     r = guestfs_mount (g, device, mountpoint);
6086     if (r == -1)
6087       return -1;
6088   }
6089   /* TestOutput for zero (0) */
6090   char expected[] = "data";
6091   {
6092     char pathordevice[] = "/dev/sda1";
6093     int r;
6094     suppress_error = 0;
6095     r = guestfs_umount (g, pathordevice);
6096     if (r == -1)
6097       return -1;
6098   }
6099   {
6100     char device[] = "/dev/sda1";
6101     int r;
6102     suppress_error = 0;
6103     r = guestfs_zero (g, device);
6104     if (r == -1)
6105       return -1;
6106   }
6107   {
6108     char path[] = "/dev/sda1";
6109     char *r;
6110     suppress_error = 0;
6111     r = guestfs_file (g, path);
6112     if (r == NULL)
6113       return -1;
6114     if (strcmp (r, expected) != 0) {
6115       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
6116       return -1;
6117     }
6118     free (r);
6119   }
6120   return 0;
6121 }
6122
6123 static int test_fsck_0_skip (void)
6124 {
6125   const char *str;
6126
6127   str = getenv ("TEST_ONLY");
6128   if (str)
6129     return strstr (str, "fsck") == NULL;
6130   str = getenv ("SKIP_TEST_FSCK_0");
6131   if (str && strcmp (str, "1") == 0) return 1;
6132   str = getenv ("SKIP_TEST_FSCK");
6133   if (str && strcmp (str, "1") == 0) return 1;
6134   return 0;
6135 }
6136
6137 static int test_fsck_0 (void)
6138 {
6139   if (test_fsck_0_skip ()) {
6140     printf ("        %s skipped (reason: environment variable set)\n", "test_fsck_0");
6141     return 0;
6142   }
6143
6144   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
6145   {
6146     char device[] = "/dev/sda";
6147     int r;
6148     suppress_error = 0;
6149     r = guestfs_blockdev_setrw (g, device);
6150     if (r == -1)
6151       return -1;
6152   }
6153   {
6154     int r;
6155     suppress_error = 0;
6156     r = guestfs_umount_all (g);
6157     if (r == -1)
6158       return -1;
6159   }
6160   {
6161     int r;
6162     suppress_error = 0;
6163     r = guestfs_lvm_remove_all (g);
6164     if (r == -1)
6165       return -1;
6166   }
6167   {
6168     char device[] = "/dev/sda";
6169     char lines_0[] = ",";
6170     char *lines[] = {
6171       lines_0,
6172       NULL
6173     };
6174     int r;
6175     suppress_error = 0;
6176     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6177     if (r == -1)
6178       return -1;
6179   }
6180   {
6181     char fstype[] = "ext2";
6182     char device[] = "/dev/sda1";
6183     int r;
6184     suppress_error = 0;
6185     r = guestfs_mkfs (g, fstype, device);
6186     if (r == -1)
6187       return -1;
6188   }
6189   {
6190     char device[] = "/dev/sda1";
6191     char mountpoint[] = "/";
6192     int r;
6193     suppress_error = 0;
6194     r = guestfs_mount (g, device, mountpoint);
6195     if (r == -1)
6196       return -1;
6197   }
6198   /* TestOutputInt for fsck (0) */
6199   {
6200     char pathordevice[] = "/dev/sda1";
6201     int r;
6202     suppress_error = 0;
6203     r = guestfs_umount (g, pathordevice);
6204     if (r == -1)
6205       return -1;
6206   }
6207   {
6208     char fstype[] = "ext2";
6209     char device[] = "/dev/sda1";
6210     int r;
6211     suppress_error = 0;
6212     r = guestfs_fsck (g, fstype, device);
6213     if (r == -1)
6214       return -1;
6215     if (r != 0) {
6216       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
6217       return -1;
6218     }
6219   }
6220   return 0;
6221 }
6222
6223 static int test_fsck_1_skip (void)
6224 {
6225   const char *str;
6226
6227   str = getenv ("TEST_ONLY");
6228   if (str)
6229     return strstr (str, "fsck") == NULL;
6230   str = getenv ("SKIP_TEST_FSCK_1");
6231   if (str && strcmp (str, "1") == 0) return 1;
6232   str = getenv ("SKIP_TEST_FSCK");
6233   if (str && strcmp (str, "1") == 0) return 1;
6234   return 0;
6235 }
6236
6237 static int test_fsck_1 (void)
6238 {
6239   if (test_fsck_1_skip ()) {
6240     printf ("        %s skipped (reason: environment variable set)\n", "test_fsck_1");
6241     return 0;
6242   }
6243
6244   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
6245   {
6246     char device[] = "/dev/sda";
6247     int r;
6248     suppress_error = 0;
6249     r = guestfs_blockdev_setrw (g, device);
6250     if (r == -1)
6251       return -1;
6252   }
6253   {
6254     int r;
6255     suppress_error = 0;
6256     r = guestfs_umount_all (g);
6257     if (r == -1)
6258       return -1;
6259   }
6260   {
6261     int r;
6262     suppress_error = 0;
6263     r = guestfs_lvm_remove_all (g);
6264     if (r == -1)
6265       return -1;
6266   }
6267   {
6268     char device[] = "/dev/sda";
6269     char lines_0[] = ",";
6270     char *lines[] = {
6271       lines_0,
6272       NULL
6273     };
6274     int r;
6275     suppress_error = 0;
6276     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6277     if (r == -1)
6278       return -1;
6279   }
6280   {
6281     char fstype[] = "ext2";
6282     char device[] = "/dev/sda1";
6283     int r;
6284     suppress_error = 0;
6285     r = guestfs_mkfs (g, fstype, device);
6286     if (r == -1)
6287       return -1;
6288   }
6289   {
6290     char device[] = "/dev/sda1";
6291     char mountpoint[] = "/";
6292     int r;
6293     suppress_error = 0;
6294     r = guestfs_mount (g, device, mountpoint);
6295     if (r == -1)
6296       return -1;
6297   }
6298   /* TestOutputInt for fsck (1) */
6299   {
6300     char pathordevice[] = "/dev/sda1";
6301     int r;
6302     suppress_error = 0;
6303     r = guestfs_umount (g, pathordevice);
6304     if (r == -1)
6305       return -1;
6306   }
6307   {
6308     char device[] = "/dev/sda1";
6309     int r;
6310     suppress_error = 0;
6311     r = guestfs_zero (g, device);
6312     if (r == -1)
6313       return -1;
6314   }
6315   {
6316     char fstype[] = "ext2";
6317     char device[] = "/dev/sda1";
6318     int r;
6319     suppress_error = 0;
6320     r = guestfs_fsck (g, fstype, device);
6321     if (r == -1)
6322       return -1;
6323     if (r != 8) {
6324       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
6325       return -1;
6326     }
6327   }
6328   return 0;
6329 }
6330
6331 static int test_set_e2uuid_0_skip (void)
6332 {
6333   const char *str;
6334
6335   str = getenv ("TEST_ONLY");
6336   if (str)
6337     return strstr (str, "set_e2uuid") == NULL;
6338   str = getenv ("SKIP_TEST_SET_E2UUID_0");
6339   if (str && strcmp (str, "1") == 0) return 1;
6340   str = getenv ("SKIP_TEST_SET_E2UUID");
6341   if (str && strcmp (str, "1") == 0) return 1;
6342   return 0;
6343 }
6344
6345 static int test_set_e2uuid_0 (void)
6346 {
6347   if (test_set_e2uuid_0_skip ()) {
6348     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
6349     return 0;
6350   }
6351
6352   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
6353   {
6354     char device[] = "/dev/sda";
6355     int r;
6356     suppress_error = 0;
6357     r = guestfs_blockdev_setrw (g, device);
6358     if (r == -1)
6359       return -1;
6360   }
6361   {
6362     int r;
6363     suppress_error = 0;
6364     r = guestfs_umount_all (g);
6365     if (r == -1)
6366       return -1;
6367   }
6368   {
6369     int r;
6370     suppress_error = 0;
6371     r = guestfs_lvm_remove_all (g);
6372     if (r == -1)
6373       return -1;
6374   }
6375   {
6376     char device[] = "/dev/sda";
6377     char lines_0[] = ",";
6378     char *lines[] = {
6379       lines_0,
6380       NULL
6381     };
6382     int r;
6383     suppress_error = 0;
6384     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6385     if (r == -1)
6386       return -1;
6387   }
6388   {
6389     char fstype[] = "ext2";
6390     char device[] = "/dev/sda1";
6391     int r;
6392     suppress_error = 0;
6393     r = guestfs_mkfs (g, fstype, device);
6394     if (r == -1)
6395       return -1;
6396   }
6397   {
6398     char device[] = "/dev/sda1";
6399     char mountpoint[] = "/";
6400     int r;
6401     suppress_error = 0;
6402     r = guestfs_mount (g, device, mountpoint);
6403     if (r == -1)
6404       return -1;
6405   }
6406   /* TestOutput for set_e2uuid (0) */
6407   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6408   {
6409     char device[] = "/dev/sda1";
6410     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6411     int r;
6412     suppress_error = 0;
6413     r = guestfs_set_e2uuid (g, device, uuid);
6414     if (r == -1)
6415       return -1;
6416   }
6417   {
6418     char device[] = "/dev/sda1";
6419     char *r;
6420     suppress_error = 0;
6421     r = guestfs_get_e2uuid (g, device);
6422     if (r == NULL)
6423       return -1;
6424     if (strcmp (r, expected) != 0) {
6425       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
6426       return -1;
6427     }
6428     free (r);
6429   }
6430   return 0;
6431 }
6432
6433 static int test_set_e2uuid_1_skip (void)
6434 {
6435   const char *str;
6436
6437   str = getenv ("TEST_ONLY");
6438   if (str)
6439     return strstr (str, "set_e2uuid") == NULL;
6440   str = getenv ("SKIP_TEST_SET_E2UUID_1");
6441   if (str && strcmp (str, "1") == 0) return 1;
6442   str = getenv ("SKIP_TEST_SET_E2UUID");
6443   if (str && strcmp (str, "1") == 0) return 1;
6444   return 0;
6445 }
6446
6447 static int test_set_e2uuid_1 (void)
6448 {
6449   if (test_set_e2uuid_1_skip ()) {
6450     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
6451     return 0;
6452   }
6453
6454   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
6455   {
6456     char device[] = "/dev/sda";
6457     int r;
6458     suppress_error = 0;
6459     r = guestfs_blockdev_setrw (g, device);
6460     if (r == -1)
6461       return -1;
6462   }
6463   {
6464     int r;
6465     suppress_error = 0;
6466     r = guestfs_umount_all (g);
6467     if (r == -1)
6468       return -1;
6469   }
6470   {
6471     int r;
6472     suppress_error = 0;
6473     r = guestfs_lvm_remove_all (g);
6474     if (r == -1)
6475       return -1;
6476   }
6477   {
6478     char device[] = "/dev/sda";
6479     char lines_0[] = ",";
6480     char *lines[] = {
6481       lines_0,
6482       NULL
6483     };
6484     int r;
6485     suppress_error = 0;
6486     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6487     if (r == -1)
6488       return -1;
6489   }
6490   {
6491     char fstype[] = "ext2";
6492     char device[] = "/dev/sda1";
6493     int r;
6494     suppress_error = 0;
6495     r = guestfs_mkfs (g, fstype, device);
6496     if (r == -1)
6497       return -1;
6498   }
6499   {
6500     char device[] = "/dev/sda1";
6501     char mountpoint[] = "/";
6502     int r;
6503     suppress_error = 0;
6504     r = guestfs_mount (g, device, mountpoint);
6505     if (r == -1)
6506       return -1;
6507   }
6508   /* TestOutput for set_e2uuid (1) */
6509   char expected[] = "";
6510   {
6511     char device[] = "/dev/sda1";
6512     char uuid[] = "clear";
6513     int r;
6514     suppress_error = 0;
6515     r = guestfs_set_e2uuid (g, device, uuid);
6516     if (r == -1)
6517       return -1;
6518   }
6519   {
6520     char device[] = "/dev/sda1";
6521     char *r;
6522     suppress_error = 0;
6523     r = guestfs_get_e2uuid (g, device);
6524     if (r == NULL)
6525       return -1;
6526     if (strcmp (r, expected) != 0) {
6527       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
6528       return -1;
6529     }
6530     free (r);
6531   }
6532   return 0;
6533 }
6534
6535 static int test_set_e2uuid_2_skip (void)
6536 {
6537   const char *str;
6538
6539   str = getenv ("TEST_ONLY");
6540   if (str)
6541     return strstr (str, "set_e2uuid") == NULL;
6542   str = getenv ("SKIP_TEST_SET_E2UUID_2");
6543   if (str && strcmp (str, "1") == 0) return 1;
6544   str = getenv ("SKIP_TEST_SET_E2UUID");
6545   if (str && strcmp (str, "1") == 0) return 1;
6546   return 0;
6547 }
6548
6549 static int test_set_e2uuid_2 (void)
6550 {
6551   if (test_set_e2uuid_2_skip ()) {
6552     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
6553     return 0;
6554   }
6555
6556   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
6557   {
6558     char device[] = "/dev/sda";
6559     int r;
6560     suppress_error = 0;
6561     r = guestfs_blockdev_setrw (g, device);
6562     if (r == -1)
6563       return -1;
6564   }
6565   {
6566     int r;
6567     suppress_error = 0;
6568     r = guestfs_umount_all (g);
6569     if (r == -1)
6570       return -1;
6571   }
6572   {
6573     int r;
6574     suppress_error = 0;
6575     r = guestfs_lvm_remove_all (g);
6576     if (r == -1)
6577       return -1;
6578   }
6579   {
6580     char device[] = "/dev/sda";
6581     char lines_0[] = ",";
6582     char *lines[] = {
6583       lines_0,
6584       NULL
6585     };
6586     int r;
6587     suppress_error = 0;
6588     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6589     if (r == -1)
6590       return -1;
6591   }
6592   {
6593     char fstype[] = "ext2";
6594     char device[] = "/dev/sda1";
6595     int r;
6596     suppress_error = 0;
6597     r = guestfs_mkfs (g, fstype, device);
6598     if (r == -1)
6599       return -1;
6600   }
6601   {
6602     char device[] = "/dev/sda1";
6603     char mountpoint[] = "/";
6604     int r;
6605     suppress_error = 0;
6606     r = guestfs_mount (g, device, mountpoint);
6607     if (r == -1)
6608       return -1;
6609   }
6610   /* TestRun for set_e2uuid (2) */
6611   {
6612     char device[] = "/dev/sda1";
6613     char uuid[] = "random";
6614     int r;
6615     suppress_error = 0;
6616     r = guestfs_set_e2uuid (g, device, uuid);
6617     if (r == -1)
6618       return -1;
6619   }
6620   return 0;
6621 }
6622
6623 static int test_set_e2uuid_3_skip (void)
6624 {
6625   const char *str;
6626
6627   str = getenv ("TEST_ONLY");
6628   if (str)
6629     return strstr (str, "set_e2uuid") == NULL;
6630   str = getenv ("SKIP_TEST_SET_E2UUID_3");
6631   if (str && strcmp (str, "1") == 0) return 1;
6632   str = getenv ("SKIP_TEST_SET_E2UUID");
6633   if (str && strcmp (str, "1") == 0) return 1;
6634   return 0;
6635 }
6636
6637 static int test_set_e2uuid_3 (void)
6638 {
6639   if (test_set_e2uuid_3_skip ()) {
6640     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6641     return 0;
6642   }
6643
6644   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6645   {
6646     char device[] = "/dev/sda";
6647     int r;
6648     suppress_error = 0;
6649     r = guestfs_blockdev_setrw (g, device);
6650     if (r == -1)
6651       return -1;
6652   }
6653   {
6654     int r;
6655     suppress_error = 0;
6656     r = guestfs_umount_all (g);
6657     if (r == -1)
6658       return -1;
6659   }
6660   {
6661     int r;
6662     suppress_error = 0;
6663     r = guestfs_lvm_remove_all (g);
6664     if (r == -1)
6665       return -1;
6666   }
6667   {
6668     char device[] = "/dev/sda";
6669     char lines_0[] = ",";
6670     char *lines[] = {
6671       lines_0,
6672       NULL
6673     };
6674     int r;
6675     suppress_error = 0;
6676     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6677     if (r == -1)
6678       return -1;
6679   }
6680   {
6681     char fstype[] = "ext2";
6682     char device[] = "/dev/sda1";
6683     int r;
6684     suppress_error = 0;
6685     r = guestfs_mkfs (g, fstype, device);
6686     if (r == -1)
6687       return -1;
6688   }
6689   {
6690     char device[] = "/dev/sda1";
6691     char mountpoint[] = "/";
6692     int r;
6693     suppress_error = 0;
6694     r = guestfs_mount (g, device, mountpoint);
6695     if (r == -1)
6696       return -1;
6697   }
6698   /* TestRun for set_e2uuid (3) */
6699   {
6700     char device[] = "/dev/sda1";
6701     char uuid[] = "time";
6702     int r;
6703     suppress_error = 0;
6704     r = guestfs_set_e2uuid (g, device, uuid);
6705     if (r == -1)
6706       return -1;
6707   }
6708   return 0;
6709 }
6710
6711 static int test_set_e2label_0_skip (void)
6712 {
6713   const char *str;
6714
6715   str = getenv ("TEST_ONLY");
6716   if (str)
6717     return strstr (str, "set_e2label") == NULL;
6718   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6719   if (str && strcmp (str, "1") == 0) return 1;
6720   str = getenv ("SKIP_TEST_SET_E2LABEL");
6721   if (str && strcmp (str, "1") == 0) return 1;
6722   return 0;
6723 }
6724
6725 static int test_set_e2label_0 (void)
6726 {
6727   if (test_set_e2label_0_skip ()) {
6728     printf ("        %s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6729     return 0;
6730   }
6731
6732   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6733   {
6734     char device[] = "/dev/sda";
6735     int r;
6736     suppress_error = 0;
6737     r = guestfs_blockdev_setrw (g, device);
6738     if (r == -1)
6739       return -1;
6740   }
6741   {
6742     int r;
6743     suppress_error = 0;
6744     r = guestfs_umount_all (g);
6745     if (r == -1)
6746       return -1;
6747   }
6748   {
6749     int r;
6750     suppress_error = 0;
6751     r = guestfs_lvm_remove_all (g);
6752     if (r == -1)
6753       return -1;
6754   }
6755   {
6756     char device[] = "/dev/sda";
6757     char lines_0[] = ",";
6758     char *lines[] = {
6759       lines_0,
6760       NULL
6761     };
6762     int r;
6763     suppress_error = 0;
6764     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6765     if (r == -1)
6766       return -1;
6767   }
6768   {
6769     char fstype[] = "ext2";
6770     char device[] = "/dev/sda1";
6771     int r;
6772     suppress_error = 0;
6773     r = guestfs_mkfs (g, fstype, device);
6774     if (r == -1)
6775       return -1;
6776   }
6777   {
6778     char device[] = "/dev/sda1";
6779     char mountpoint[] = "/";
6780     int r;
6781     suppress_error = 0;
6782     r = guestfs_mount (g, device, mountpoint);
6783     if (r == -1)
6784       return -1;
6785   }
6786   /* TestOutput for set_e2label (0) */
6787   char expected[] = "testlabel";
6788   {
6789     char device[] = "/dev/sda1";
6790     char label[] = "testlabel";
6791     int r;
6792     suppress_error = 0;
6793     r = guestfs_set_e2label (g, device, label);
6794     if (r == -1)
6795       return -1;
6796   }
6797   {
6798     char device[] = "/dev/sda1";
6799     char *r;
6800     suppress_error = 0;
6801     r = guestfs_get_e2label (g, device);
6802     if (r == NULL)
6803       return -1;
6804     if (strcmp (r, expected) != 0) {
6805       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6806       return -1;
6807     }
6808     free (r);
6809   }
6810   return 0;
6811 }
6812
6813 static int test_pvremove_0_skip (void)
6814 {
6815   const char *str;
6816
6817   str = getenv ("TEST_ONLY");
6818   if (str)
6819     return strstr (str, "pvremove") == NULL;
6820   str = getenv ("SKIP_TEST_PVREMOVE_0");
6821   if (str && strcmp (str, "1") == 0) return 1;
6822   str = getenv ("SKIP_TEST_PVREMOVE");
6823   if (str && strcmp (str, "1") == 0) return 1;
6824   return 0;
6825 }
6826
6827 static int test_pvremove_0 (void)
6828 {
6829   if (test_pvremove_0_skip ()) {
6830     printf ("        %s skipped (reason: environment variable set)\n", "test_pvremove_0");
6831     return 0;
6832   }
6833
6834   /* InitNone|InitEmpty for test_pvremove_0 */
6835   {
6836     char device[] = "/dev/sda";
6837     int r;
6838     suppress_error = 0;
6839     r = guestfs_blockdev_setrw (g, device);
6840     if (r == -1)
6841       return -1;
6842   }
6843   {
6844     int r;
6845     suppress_error = 0;
6846     r = guestfs_umount_all (g);
6847     if (r == -1)
6848       return -1;
6849   }
6850   {
6851     int r;
6852     suppress_error = 0;
6853     r = guestfs_lvm_remove_all (g);
6854     if (r == -1)
6855       return -1;
6856   }
6857   /* TestOutputListOfDevices for pvremove (0) */
6858   {
6859     char device[] = "/dev/sda";
6860     char lines_0[] = ",";
6861     char *lines[] = {
6862       lines_0,
6863       NULL
6864     };
6865     int r;
6866     suppress_error = 0;
6867     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6868     if (r == -1)
6869       return -1;
6870   }
6871   {
6872     char device[] = "/dev/sda1";
6873     int r;
6874     suppress_error = 0;
6875     r = guestfs_pvcreate (g, device);
6876     if (r == -1)
6877       return -1;
6878   }
6879   {
6880     char volgroup[] = "VG";
6881     char physvols_0[] = "/dev/sda1";
6882     char *physvols[] = {
6883       physvols_0,
6884       NULL
6885     };
6886     int r;
6887     suppress_error = 0;
6888     r = guestfs_vgcreate (g, volgroup, physvols);
6889     if (r == -1)
6890       return -1;
6891   }
6892   {
6893     char logvol[] = "LV1";
6894     char volgroup[] = "VG";
6895     int r;
6896     suppress_error = 0;
6897     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6898     if (r == -1)
6899       return -1;
6900   }
6901   {
6902     char logvol[] = "LV2";
6903     char volgroup[] = "VG";
6904     int r;
6905     suppress_error = 0;
6906     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6907     if (r == -1)
6908       return -1;
6909   }
6910   {
6911     char vgname[] = "VG";
6912     int r;
6913     suppress_error = 0;
6914     r = guestfs_vgremove (g, vgname);
6915     if (r == -1)
6916       return -1;
6917   }
6918   {
6919     char device[] = "/dev/sda1";
6920     int r;
6921     suppress_error = 0;
6922     r = guestfs_pvremove (g, device);
6923     if (r == -1)
6924       return -1;
6925   }
6926   {
6927     char **r;
6928     int i;
6929     suppress_error = 0;
6930     r = guestfs_lvs (g);
6931     if (r == NULL)
6932       return -1;
6933     if (r[0] != NULL) {
6934       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6935       print_strings (r);
6936       return -1;
6937     }
6938     for (i = 0; r[i] != NULL; ++i)
6939       free (r[i]);
6940     free (r);
6941   }
6942   return 0;
6943 }
6944
6945 static int test_pvremove_1_skip (void)
6946 {
6947   const char *str;
6948
6949   str = getenv ("TEST_ONLY");
6950   if (str)
6951     return strstr (str, "pvremove") == NULL;
6952   str = getenv ("SKIP_TEST_PVREMOVE_1");
6953   if (str && strcmp (str, "1") == 0) return 1;
6954   str = getenv ("SKIP_TEST_PVREMOVE");
6955   if (str && strcmp (str, "1") == 0) return 1;
6956   return 0;
6957 }
6958
6959 static int test_pvremove_1 (void)
6960 {
6961   if (test_pvremove_1_skip ()) {
6962     printf ("        %s skipped (reason: environment variable set)\n", "test_pvremove_1");
6963     return 0;
6964   }
6965
6966   /* InitNone|InitEmpty for test_pvremove_1 */
6967   {
6968     char device[] = "/dev/sda";
6969     int r;
6970     suppress_error = 0;
6971     r = guestfs_blockdev_setrw (g, device);
6972     if (r == -1)
6973       return -1;
6974   }
6975   {
6976     int r;
6977     suppress_error = 0;
6978     r = guestfs_umount_all (g);
6979     if (r == -1)
6980       return -1;
6981   }
6982   {
6983     int r;
6984     suppress_error = 0;
6985     r = guestfs_lvm_remove_all (g);
6986     if (r == -1)
6987       return -1;
6988   }
6989   /* TestOutputListOfDevices for pvremove (1) */
6990   {
6991     char device[] = "/dev/sda";
6992     char lines_0[] = ",";
6993     char *lines[] = {
6994       lines_0,
6995       NULL
6996     };
6997     int r;
6998     suppress_error = 0;
6999     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7000     if (r == -1)
7001       return -1;
7002   }
7003   {
7004     char device[] = "/dev/sda1";
7005     int r;
7006     suppress_error = 0;
7007     r = guestfs_pvcreate (g, device);
7008     if (r == -1)
7009       return -1;
7010   }
7011   {
7012     char volgroup[] = "VG";
7013     char physvols_0[] = "/dev/sda1";
7014     char *physvols[] = {
7015       physvols_0,
7016       NULL
7017     };
7018     int r;
7019     suppress_error = 0;
7020     r = guestfs_vgcreate (g, volgroup, physvols);
7021     if (r == -1)
7022       return -1;
7023   }
7024   {
7025     char logvol[] = "LV1";
7026     char volgroup[] = "VG";
7027     int r;
7028     suppress_error = 0;
7029     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7030     if (r == -1)
7031       return -1;
7032   }
7033   {
7034     char logvol[] = "LV2";
7035     char volgroup[] = "VG";
7036     int r;
7037     suppress_error = 0;
7038     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7039     if (r == -1)
7040       return -1;
7041   }
7042   {
7043     char vgname[] = "VG";
7044     int r;
7045     suppress_error = 0;
7046     r = guestfs_vgremove (g, vgname);
7047     if (r == -1)
7048       return -1;
7049   }
7050   {
7051     char device[] = "/dev/sda1";
7052     int r;
7053     suppress_error = 0;
7054     r = guestfs_pvremove (g, device);
7055     if (r == -1)
7056       return -1;
7057   }
7058   {
7059     char **r;
7060     int i;
7061     suppress_error = 0;
7062     r = guestfs_vgs (g);
7063     if (r == NULL)
7064       return -1;
7065     if (r[0] != NULL) {
7066       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
7067       print_strings (r);
7068       return -1;
7069     }
7070     for (i = 0; r[i] != NULL; ++i)
7071       free (r[i]);
7072     free (r);
7073   }
7074   return 0;
7075 }
7076
7077 static int test_pvremove_2_skip (void)
7078 {
7079   const char *str;
7080
7081   str = getenv ("TEST_ONLY");
7082   if (str)
7083     return strstr (str, "pvremove") == NULL;
7084   str = getenv ("SKIP_TEST_PVREMOVE_2");
7085   if (str && strcmp (str, "1") == 0) return 1;
7086   str = getenv ("SKIP_TEST_PVREMOVE");
7087   if (str && strcmp (str, "1") == 0) return 1;
7088   return 0;
7089 }
7090
7091 static int test_pvremove_2 (void)
7092 {
7093   if (test_pvremove_2_skip ()) {
7094     printf ("        %s skipped (reason: environment variable set)\n", "test_pvremove_2");
7095     return 0;
7096   }
7097
7098   /* InitNone|InitEmpty for test_pvremove_2 */
7099   {
7100     char device[] = "/dev/sda";
7101     int r;
7102     suppress_error = 0;
7103     r = guestfs_blockdev_setrw (g, device);
7104     if (r == -1)
7105       return -1;
7106   }
7107   {
7108     int r;
7109     suppress_error = 0;
7110     r = guestfs_umount_all (g);
7111     if (r == -1)
7112       return -1;
7113   }
7114   {
7115     int r;
7116     suppress_error = 0;
7117     r = guestfs_lvm_remove_all (g);
7118     if (r == -1)
7119       return -1;
7120   }
7121   /* TestOutputListOfDevices for pvremove (2) */
7122   {
7123     char device[] = "/dev/sda";
7124     char lines_0[] = ",";
7125     char *lines[] = {
7126       lines_0,
7127       NULL
7128     };
7129     int r;
7130     suppress_error = 0;
7131     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7132     if (r == -1)
7133       return -1;
7134   }
7135   {
7136     char device[] = "/dev/sda1";
7137     int r;
7138     suppress_error = 0;
7139     r = guestfs_pvcreate (g, device);
7140     if (r == -1)
7141       return -1;
7142   }
7143   {
7144     char volgroup[] = "VG";
7145     char physvols_0[] = "/dev/sda1";
7146     char *physvols[] = {
7147       physvols_0,
7148       NULL
7149     };
7150     int r;
7151     suppress_error = 0;
7152     r = guestfs_vgcreate (g, volgroup, physvols);
7153     if (r == -1)
7154       return -1;
7155   }
7156   {
7157     char logvol[] = "LV1";
7158     char volgroup[] = "VG";
7159     int r;
7160     suppress_error = 0;
7161     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7162     if (r == -1)
7163       return -1;
7164   }
7165   {
7166     char logvol[] = "LV2";
7167     char volgroup[] = "VG";
7168     int r;
7169     suppress_error = 0;
7170     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7171     if (r == -1)
7172       return -1;
7173   }
7174   {
7175     char vgname[] = "VG";
7176     int r;
7177     suppress_error = 0;
7178     r = guestfs_vgremove (g, vgname);
7179     if (r == -1)
7180       return -1;
7181   }
7182   {
7183     char device[] = "/dev/sda1";
7184     int r;
7185     suppress_error = 0;
7186     r = guestfs_pvremove (g, device);
7187     if (r == -1)
7188       return -1;
7189   }
7190   {
7191     char **r;
7192     int i;
7193     suppress_error = 0;
7194     r = guestfs_pvs (g);
7195     if (r == NULL)
7196       return -1;
7197     if (r[0] != NULL) {
7198       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
7199       print_strings (r);
7200       return -1;
7201     }
7202     for (i = 0; r[i] != NULL; ++i)
7203       free (r[i]);
7204     free (r);
7205   }
7206   return 0;
7207 }
7208
7209 static int test_vgremove_0_skip (void)
7210 {
7211   const char *str;
7212
7213   str = getenv ("TEST_ONLY");
7214   if (str)
7215     return strstr (str, "vgremove") == NULL;
7216   str = getenv ("SKIP_TEST_VGREMOVE_0");
7217   if (str && strcmp (str, "1") == 0) return 1;
7218   str = getenv ("SKIP_TEST_VGREMOVE");
7219   if (str && strcmp (str, "1") == 0) return 1;
7220   return 0;
7221 }
7222
7223 static int test_vgremove_0 (void)
7224 {
7225   if (test_vgremove_0_skip ()) {
7226     printf ("        %s skipped (reason: environment variable set)\n", "test_vgremove_0");
7227     return 0;
7228   }
7229
7230   /* InitNone|InitEmpty for test_vgremove_0 */
7231   {
7232     char device[] = "/dev/sda";
7233     int r;
7234     suppress_error = 0;
7235     r = guestfs_blockdev_setrw (g, device);
7236     if (r == -1)
7237       return -1;
7238   }
7239   {
7240     int r;
7241     suppress_error = 0;
7242     r = guestfs_umount_all (g);
7243     if (r == -1)
7244       return -1;
7245   }
7246   {
7247     int r;
7248     suppress_error = 0;
7249     r = guestfs_lvm_remove_all (g);
7250     if (r == -1)
7251       return -1;
7252   }
7253   /* TestOutputList for vgremove (0) */
7254   {
7255     char device[] = "/dev/sda";
7256     char lines_0[] = ",";
7257     char *lines[] = {
7258       lines_0,
7259       NULL
7260     };
7261     int r;
7262     suppress_error = 0;
7263     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7264     if (r == -1)
7265       return -1;
7266   }
7267   {
7268     char device[] = "/dev/sda1";
7269     int r;
7270     suppress_error = 0;
7271     r = guestfs_pvcreate (g, device);
7272     if (r == -1)
7273       return -1;
7274   }
7275   {
7276     char volgroup[] = "VG";
7277     char physvols_0[] = "/dev/sda1";
7278     char *physvols[] = {
7279       physvols_0,
7280       NULL
7281     };
7282     int r;
7283     suppress_error = 0;
7284     r = guestfs_vgcreate (g, volgroup, physvols);
7285     if (r == -1)
7286       return -1;
7287   }
7288   {
7289     char logvol[] = "LV1";
7290     char volgroup[] = "VG";
7291     int r;
7292     suppress_error = 0;
7293     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7294     if (r == -1)
7295       return -1;
7296   }
7297   {
7298     char logvol[] = "LV2";
7299     char volgroup[] = "VG";
7300     int r;
7301     suppress_error = 0;
7302     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7303     if (r == -1)
7304       return -1;
7305   }
7306   {
7307     char vgname[] = "VG";
7308     int r;
7309     suppress_error = 0;
7310     r = guestfs_vgremove (g, vgname);
7311     if (r == -1)
7312       return -1;
7313   }
7314   {
7315     char **r;
7316     int i;
7317     suppress_error = 0;
7318     r = guestfs_lvs (g);
7319     if (r == NULL)
7320       return -1;
7321     if (r[0] != NULL) {
7322       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
7323       print_strings (r);
7324       return -1;
7325     }
7326     for (i = 0; r[i] != NULL; ++i)
7327       free (r[i]);
7328     free (r);
7329   }
7330   return 0;
7331 }
7332
7333 static int test_vgremove_1_skip (void)
7334 {
7335   const char *str;
7336
7337   str = getenv ("TEST_ONLY");
7338   if (str)
7339     return strstr (str, "vgremove") == NULL;
7340   str = getenv ("SKIP_TEST_VGREMOVE_1");
7341   if (str && strcmp (str, "1") == 0) return 1;
7342   str = getenv ("SKIP_TEST_VGREMOVE");
7343   if (str && strcmp (str, "1") == 0) return 1;
7344   return 0;
7345 }
7346
7347 static int test_vgremove_1 (void)
7348 {
7349   if (test_vgremove_1_skip ()) {
7350     printf ("        %s skipped (reason: environment variable set)\n", "test_vgremove_1");
7351     return 0;
7352   }
7353
7354   /* InitNone|InitEmpty for test_vgremove_1 */
7355   {
7356     char device[] = "/dev/sda";
7357     int r;
7358     suppress_error = 0;
7359     r = guestfs_blockdev_setrw (g, device);
7360     if (r == -1)
7361       return -1;
7362   }
7363   {
7364     int r;
7365     suppress_error = 0;
7366     r = guestfs_umount_all (g);
7367     if (r == -1)
7368       return -1;
7369   }
7370   {
7371     int r;
7372     suppress_error = 0;
7373     r = guestfs_lvm_remove_all (g);
7374     if (r == -1)
7375       return -1;
7376   }
7377   /* TestOutputList for vgremove (1) */
7378   {
7379     char device[] = "/dev/sda";
7380     char lines_0[] = ",";
7381     char *lines[] = {
7382       lines_0,
7383       NULL
7384     };
7385     int r;
7386     suppress_error = 0;
7387     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7388     if (r == -1)
7389       return -1;
7390   }
7391   {
7392     char device[] = "/dev/sda1";
7393     int r;
7394     suppress_error = 0;
7395     r = guestfs_pvcreate (g, device);
7396     if (r == -1)
7397       return -1;
7398   }
7399   {
7400     char volgroup[] = "VG";
7401     char physvols_0[] = "/dev/sda1";
7402     char *physvols[] = {
7403       physvols_0,
7404       NULL
7405     };
7406     int r;
7407     suppress_error = 0;
7408     r = guestfs_vgcreate (g, volgroup, physvols);
7409     if (r == -1)
7410       return -1;
7411   }
7412   {
7413     char logvol[] = "LV1";
7414     char volgroup[] = "VG";
7415     int r;
7416     suppress_error = 0;
7417     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7418     if (r == -1)
7419       return -1;
7420   }
7421   {
7422     char logvol[] = "LV2";
7423     char volgroup[] = "VG";
7424     int r;
7425     suppress_error = 0;
7426     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7427     if (r == -1)
7428       return -1;
7429   }
7430   {
7431     char vgname[] = "VG";
7432     int r;
7433     suppress_error = 0;
7434     r = guestfs_vgremove (g, vgname);
7435     if (r == -1)
7436       return -1;
7437   }
7438   {
7439     char **r;
7440     int i;
7441     suppress_error = 0;
7442     r = guestfs_vgs (g);
7443     if (r == NULL)
7444       return -1;
7445     if (r[0] != NULL) {
7446       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
7447       print_strings (r);
7448       return -1;
7449     }
7450     for (i = 0; r[i] != NULL; ++i)
7451       free (r[i]);
7452     free (r);
7453   }
7454   return 0;
7455 }
7456
7457 static int test_lvremove_0_skip (void)
7458 {
7459   const char *str;
7460
7461   str = getenv ("TEST_ONLY");
7462   if (str)
7463     return strstr (str, "lvremove") == NULL;
7464   str = getenv ("SKIP_TEST_LVREMOVE_0");
7465   if (str && strcmp (str, "1") == 0) return 1;
7466   str = getenv ("SKIP_TEST_LVREMOVE");
7467   if (str && strcmp (str, "1") == 0) return 1;
7468   return 0;
7469 }
7470
7471 static int test_lvremove_0 (void)
7472 {
7473   if (test_lvremove_0_skip ()) {
7474     printf ("        %s skipped (reason: environment variable set)\n", "test_lvremove_0");
7475     return 0;
7476   }
7477
7478   /* InitNone|InitEmpty for test_lvremove_0 */
7479   {
7480     char device[] = "/dev/sda";
7481     int r;
7482     suppress_error = 0;
7483     r = guestfs_blockdev_setrw (g, device);
7484     if (r == -1)
7485       return -1;
7486   }
7487   {
7488     int r;
7489     suppress_error = 0;
7490     r = guestfs_umount_all (g);
7491     if (r == -1)
7492       return -1;
7493   }
7494   {
7495     int r;
7496     suppress_error = 0;
7497     r = guestfs_lvm_remove_all (g);
7498     if (r == -1)
7499       return -1;
7500   }
7501   /* TestOutputList for lvremove (0) */
7502   {
7503     char device[] = "/dev/sda";
7504     char lines_0[] = ",";
7505     char *lines[] = {
7506       lines_0,
7507       NULL
7508     };
7509     int r;
7510     suppress_error = 0;
7511     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7512     if (r == -1)
7513       return -1;
7514   }
7515   {
7516     char device[] = "/dev/sda1";
7517     int r;
7518     suppress_error = 0;
7519     r = guestfs_pvcreate (g, device);
7520     if (r == -1)
7521       return -1;
7522   }
7523   {
7524     char volgroup[] = "VG";
7525     char physvols_0[] = "/dev/sda1";
7526     char *physvols[] = {
7527       physvols_0,
7528       NULL
7529     };
7530     int r;
7531     suppress_error = 0;
7532     r = guestfs_vgcreate (g, volgroup, physvols);
7533     if (r == -1)
7534       return -1;
7535   }
7536   {
7537     char logvol[] = "LV1";
7538     char volgroup[] = "VG";
7539     int r;
7540     suppress_error = 0;
7541     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7542     if (r == -1)
7543       return -1;
7544   }
7545   {
7546     char logvol[] = "LV2";
7547     char volgroup[] = "VG";
7548     int r;
7549     suppress_error = 0;
7550     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7551     if (r == -1)
7552       return -1;
7553   }
7554   {
7555     char device[] = "/dev/VG/LV1";
7556     int r;
7557     suppress_error = 0;
7558     r = guestfs_lvremove (g, device);
7559     if (r == -1)
7560       return -1;
7561   }
7562   {
7563     char **r;
7564     int i;
7565     suppress_error = 0;
7566     r = guestfs_lvs (g);
7567     if (r == NULL)
7568       return -1;
7569     if (!r[0]) {
7570       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
7571       print_strings (r);
7572       return -1;
7573     }
7574     {
7575       char expected[] = "/dev/VG/LV2";
7576       if (strcmp (r[0], expected) != 0) {
7577         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7578         return -1;
7579       }
7580     }
7581     if (r[1] != NULL) {
7582       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
7583       print_strings (r);
7584       return -1;
7585     }
7586     for (i = 0; r[i] != NULL; ++i)
7587       free (r[i]);
7588     free (r);
7589   }
7590   return 0;
7591 }
7592
7593 static int test_lvremove_1_skip (void)
7594 {
7595   const char *str;
7596
7597   str = getenv ("TEST_ONLY");
7598   if (str)
7599     return strstr (str, "lvremove") == NULL;
7600   str = getenv ("SKIP_TEST_LVREMOVE_1");
7601   if (str && strcmp (str, "1") == 0) return 1;
7602   str = getenv ("SKIP_TEST_LVREMOVE");
7603   if (str && strcmp (str, "1") == 0) return 1;
7604   return 0;
7605 }
7606
7607 static int test_lvremove_1 (void)
7608 {
7609   if (test_lvremove_1_skip ()) {
7610     printf ("        %s skipped (reason: environment variable set)\n", "test_lvremove_1");
7611     return 0;
7612   }
7613
7614   /* InitNone|InitEmpty for test_lvremove_1 */
7615   {
7616     char device[] = "/dev/sda";
7617     int r;
7618     suppress_error = 0;
7619     r = guestfs_blockdev_setrw (g, device);
7620     if (r == -1)
7621       return -1;
7622   }
7623   {
7624     int r;
7625     suppress_error = 0;
7626     r = guestfs_umount_all (g);
7627     if (r == -1)
7628       return -1;
7629   }
7630   {
7631     int r;
7632     suppress_error = 0;
7633     r = guestfs_lvm_remove_all (g);
7634     if (r == -1)
7635       return -1;
7636   }
7637   /* TestOutputList for lvremove (1) */
7638   {
7639     char device[] = "/dev/sda";
7640     char lines_0[] = ",";
7641     char *lines[] = {
7642       lines_0,
7643       NULL
7644     };
7645     int r;
7646     suppress_error = 0;
7647     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7648     if (r == -1)
7649       return -1;
7650   }
7651   {
7652     char device[] = "/dev/sda1";
7653     int r;
7654     suppress_error = 0;
7655     r = guestfs_pvcreate (g, device);
7656     if (r == -1)
7657       return -1;
7658   }
7659   {
7660     char volgroup[] = "VG";
7661     char physvols_0[] = "/dev/sda1";
7662     char *physvols[] = {
7663       physvols_0,
7664       NULL
7665     };
7666     int r;
7667     suppress_error = 0;
7668     r = guestfs_vgcreate (g, volgroup, physvols);
7669     if (r == -1)
7670       return -1;
7671   }
7672   {
7673     char logvol[] = "LV1";
7674     char volgroup[] = "VG";
7675     int r;
7676     suppress_error = 0;
7677     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7678     if (r == -1)
7679       return -1;
7680   }
7681   {
7682     char logvol[] = "LV2";
7683     char volgroup[] = "VG";
7684     int r;
7685     suppress_error = 0;
7686     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7687     if (r == -1)
7688       return -1;
7689   }
7690   {
7691     char device[] = "/dev/VG";
7692     int r;
7693     suppress_error = 0;
7694     r = guestfs_lvremove (g, device);
7695     if (r == -1)
7696       return -1;
7697   }
7698   {
7699     char **r;
7700     int i;
7701     suppress_error = 0;
7702     r = guestfs_lvs (g);
7703     if (r == NULL)
7704       return -1;
7705     if (r[0] != NULL) {
7706       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7707       print_strings (r);
7708       return -1;
7709     }
7710     for (i = 0; r[i] != NULL; ++i)
7711       free (r[i]);
7712     free (r);
7713   }
7714   return 0;
7715 }
7716
7717 static int test_lvremove_2_skip (void)
7718 {
7719   const char *str;
7720
7721   str = getenv ("TEST_ONLY");
7722   if (str)
7723     return strstr (str, "lvremove") == NULL;
7724   str = getenv ("SKIP_TEST_LVREMOVE_2");
7725   if (str && strcmp (str, "1") == 0) return 1;
7726   str = getenv ("SKIP_TEST_LVREMOVE");
7727   if (str && strcmp (str, "1") == 0) return 1;
7728   return 0;
7729 }
7730
7731 static int test_lvremove_2 (void)
7732 {
7733   if (test_lvremove_2_skip ()) {
7734     printf ("        %s skipped (reason: environment variable set)\n", "test_lvremove_2");
7735     return 0;
7736   }
7737
7738   /* InitNone|InitEmpty for test_lvremove_2 */
7739   {
7740     char device[] = "/dev/sda";
7741     int r;
7742     suppress_error = 0;
7743     r = guestfs_blockdev_setrw (g, device);
7744     if (r == -1)
7745       return -1;
7746   }
7747   {
7748     int r;
7749     suppress_error = 0;
7750     r = guestfs_umount_all (g);
7751     if (r == -1)
7752       return -1;
7753   }
7754   {
7755     int r;
7756     suppress_error = 0;
7757     r = guestfs_lvm_remove_all (g);
7758     if (r == -1)
7759       return -1;
7760   }
7761   /* TestOutputList for lvremove (2) */
7762   {
7763     char device[] = "/dev/sda";
7764     char lines_0[] = ",";
7765     char *lines[] = {
7766       lines_0,
7767       NULL
7768     };
7769     int r;
7770     suppress_error = 0;
7771     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7772     if (r == -1)
7773       return -1;
7774   }
7775   {
7776     char device[] = "/dev/sda1";
7777     int r;
7778     suppress_error = 0;
7779     r = guestfs_pvcreate (g, device);
7780     if (r == -1)
7781       return -1;
7782   }
7783   {
7784     char volgroup[] = "VG";
7785     char physvols_0[] = "/dev/sda1";
7786     char *physvols[] = {
7787       physvols_0,
7788       NULL
7789     };
7790     int r;
7791     suppress_error = 0;
7792     r = guestfs_vgcreate (g, volgroup, physvols);
7793     if (r == -1)
7794       return -1;
7795   }
7796   {
7797     char logvol[] = "LV1";
7798     char volgroup[] = "VG";
7799     int r;
7800     suppress_error = 0;
7801     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7802     if (r == -1)
7803       return -1;
7804   }
7805   {
7806     char logvol[] = "LV2";
7807     char volgroup[] = "VG";
7808     int r;
7809     suppress_error = 0;
7810     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7811     if (r == -1)
7812       return -1;
7813   }
7814   {
7815     char device[] = "/dev/VG";
7816     int r;
7817     suppress_error = 0;
7818     r = guestfs_lvremove (g, device);
7819     if (r == -1)
7820       return -1;
7821   }
7822   {
7823     char **r;
7824     int i;
7825     suppress_error = 0;
7826     r = guestfs_vgs (g);
7827     if (r == NULL)
7828       return -1;
7829     if (!r[0]) {
7830       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7831       print_strings (r);
7832       return -1;
7833     }
7834     {
7835       char expected[] = "VG";
7836       if (strcmp (r[0], expected) != 0) {
7837         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7838         return -1;
7839       }
7840     }
7841     if (r[1] != NULL) {
7842       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7843       print_strings (r);
7844       return -1;
7845     }
7846     for (i = 0; r[i] != NULL; ++i)
7847       free (r[i]);
7848     free (r);
7849   }
7850   return 0;
7851 }
7852
7853 static int test_mount_ro_0_skip (void)
7854 {
7855   const char *str;
7856
7857   str = getenv ("TEST_ONLY");
7858   if (str)
7859     return strstr (str, "mount_ro") == NULL;
7860   str = getenv ("SKIP_TEST_MOUNT_RO_0");
7861   if (str && strcmp (str, "1") == 0) return 1;
7862   str = getenv ("SKIP_TEST_MOUNT_RO");
7863   if (str && strcmp (str, "1") == 0) return 1;
7864   return 0;
7865 }
7866
7867 static int test_mount_ro_0 (void)
7868 {
7869   if (test_mount_ro_0_skip ()) {
7870     printf ("        %s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7871     return 0;
7872   }
7873
7874   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7875   {
7876     char device[] = "/dev/sda";
7877     int r;
7878     suppress_error = 0;
7879     r = guestfs_blockdev_setrw (g, device);
7880     if (r == -1)
7881       return -1;
7882   }
7883   {
7884     int r;
7885     suppress_error = 0;
7886     r = guestfs_umount_all (g);
7887     if (r == -1)
7888       return -1;
7889   }
7890   {
7891     int r;
7892     suppress_error = 0;
7893     r = guestfs_lvm_remove_all (g);
7894     if (r == -1)
7895       return -1;
7896   }
7897   {
7898     char device[] = "/dev/sda";
7899     char lines_0[] = ",";
7900     char *lines[] = {
7901       lines_0,
7902       NULL
7903     };
7904     int r;
7905     suppress_error = 0;
7906     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7907     if (r == -1)
7908       return -1;
7909   }
7910   {
7911     char fstype[] = "ext2";
7912     char device[] = "/dev/sda1";
7913     int r;
7914     suppress_error = 0;
7915     r = guestfs_mkfs (g, fstype, device);
7916     if (r == -1)
7917       return -1;
7918   }
7919   {
7920     char device[] = "/dev/sda1";
7921     char mountpoint[] = "/";
7922     int r;
7923     suppress_error = 0;
7924     r = guestfs_mount (g, device, mountpoint);
7925     if (r == -1)
7926       return -1;
7927   }
7928   /* TestLastFail for mount_ro (0) */
7929   {
7930     char pathordevice[] = "/";
7931     int r;
7932     suppress_error = 0;
7933     r = guestfs_umount (g, pathordevice);
7934     if (r == -1)
7935       return -1;
7936   }
7937   {
7938     char device[] = "/dev/sda1";
7939     char mountpoint[] = "/";
7940     int r;
7941     suppress_error = 0;
7942     r = guestfs_mount_ro (g, device, mountpoint);
7943     if (r == -1)
7944       return -1;
7945   }
7946   {
7947     char path[] = "/new";
7948     int r;
7949     suppress_error = 1;
7950     r = guestfs_touch (g, path);
7951     if (r != -1)
7952       return -1;
7953   }
7954   return 0;
7955 }
7956
7957 static int test_mount_ro_1_skip (void)
7958 {
7959   const char *str;
7960
7961   str = getenv ("TEST_ONLY");
7962   if (str)
7963     return strstr (str, "mount_ro") == NULL;
7964   str = getenv ("SKIP_TEST_MOUNT_RO_1");
7965   if (str && strcmp (str, "1") == 0) return 1;
7966   str = getenv ("SKIP_TEST_MOUNT_RO");
7967   if (str && strcmp (str, "1") == 0) return 1;
7968   return 0;
7969 }
7970
7971 static int test_mount_ro_1 (void)
7972 {
7973   if (test_mount_ro_1_skip ()) {
7974     printf ("        %s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7975     return 0;
7976   }
7977
7978   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7979   {
7980     char device[] = "/dev/sda";
7981     int r;
7982     suppress_error = 0;
7983     r = guestfs_blockdev_setrw (g, device);
7984     if (r == -1)
7985       return -1;
7986   }
7987   {
7988     int r;
7989     suppress_error = 0;
7990     r = guestfs_umount_all (g);
7991     if (r == -1)
7992       return -1;
7993   }
7994   {
7995     int r;
7996     suppress_error = 0;
7997     r = guestfs_lvm_remove_all (g);
7998     if (r == -1)
7999       return -1;
8000   }
8001   {
8002     char device[] = "/dev/sda";
8003     char lines_0[] = ",";
8004     char *lines[] = {
8005       lines_0,
8006       NULL
8007     };
8008     int r;
8009     suppress_error = 0;
8010     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8011     if (r == -1)
8012       return -1;
8013   }
8014   {
8015     char fstype[] = "ext2";
8016     char device[] = "/dev/sda1";
8017     int r;
8018     suppress_error = 0;
8019     r = guestfs_mkfs (g, fstype, device);
8020     if (r == -1)
8021       return -1;
8022   }
8023   {
8024     char device[] = "/dev/sda1";
8025     char mountpoint[] = "/";
8026     int r;
8027     suppress_error = 0;
8028     r = guestfs_mount (g, device, mountpoint);
8029     if (r == -1)
8030       return -1;
8031   }
8032   /* TestOutput for mount_ro (1) */
8033   char expected[] = "data";
8034   {
8035     char path[] = "/new";
8036     char content[] = "data";
8037     int r;
8038     suppress_error = 0;
8039     r = guestfs_write_file (g, path, content, 0);
8040     if (r == -1)
8041       return -1;
8042   }
8043   {
8044     char pathordevice[] = "/";
8045     int r;
8046     suppress_error = 0;
8047     r = guestfs_umount (g, pathordevice);
8048     if (r == -1)
8049       return -1;
8050   }
8051   {
8052     char device[] = "/dev/sda1";
8053     char mountpoint[] = "/";
8054     int r;
8055     suppress_error = 0;
8056     r = guestfs_mount_ro (g, device, mountpoint);
8057     if (r == -1)
8058       return -1;
8059   }
8060   {
8061     char path[] = "/new";
8062     char *r;
8063     suppress_error = 0;
8064     r = guestfs_cat (g, path);
8065     if (r == NULL)
8066       return -1;
8067     if (strcmp (r, expected) != 0) {
8068       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
8069       return -1;
8070     }
8071     free (r);
8072   }
8073   return 0;
8074 }
8075
8076 static int test_tgz_in_0_skip (void)
8077 {
8078   const char *str;
8079
8080   str = getenv ("TEST_ONLY");
8081   if (str)
8082     return strstr (str, "tgz_in") == NULL;
8083   str = getenv ("SKIP_TEST_TGZ_IN_0");
8084   if (str && strcmp (str, "1") == 0) return 1;
8085   str = getenv ("SKIP_TEST_TGZ_IN");
8086   if (str && strcmp (str, "1") == 0) return 1;
8087   return 0;
8088 }
8089
8090 static int test_tgz_in_0 (void)
8091 {
8092   if (test_tgz_in_0_skip ()) {
8093     printf ("        %s skipped (reason: environment variable set)\n", "test_tgz_in_0");
8094     return 0;
8095   }
8096
8097   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
8098   {
8099     char device[] = "/dev/sda";
8100     int r;
8101     suppress_error = 0;
8102     r = guestfs_blockdev_setrw (g, device);
8103     if (r == -1)
8104       return -1;
8105   }
8106   {
8107     int r;
8108     suppress_error = 0;
8109     r = guestfs_umount_all (g);
8110     if (r == -1)
8111       return -1;
8112   }
8113   {
8114     int r;
8115     suppress_error = 0;
8116     r = guestfs_lvm_remove_all (g);
8117     if (r == -1)
8118       return -1;
8119   }
8120   {
8121     char device[] = "/dev/sda";
8122     char lines_0[] = ",";
8123     char *lines[] = {
8124       lines_0,
8125       NULL
8126     };
8127     int r;
8128     suppress_error = 0;
8129     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8130     if (r == -1)
8131       return -1;
8132   }
8133   {
8134     char fstype[] = "ext2";
8135     char device[] = "/dev/sda1";
8136     int r;
8137     suppress_error = 0;
8138     r = guestfs_mkfs (g, fstype, device);
8139     if (r == -1)
8140       return -1;
8141   }
8142   {
8143     char device[] = "/dev/sda1";
8144     char mountpoint[] = "/";
8145     int r;
8146     suppress_error = 0;
8147     r = guestfs_mount (g, device, mountpoint);
8148     if (r == -1)
8149       return -1;
8150   }
8151   /* TestOutput for tgz_in (0) */
8152   char expected[] = "hello\n";
8153   {
8154     char directory[] = "/";
8155     int r;
8156     suppress_error = 0;
8157     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
8158     if (r == -1)
8159       return -1;
8160   }
8161   {
8162     char path[] = "/hello";
8163     char *r;
8164     suppress_error = 0;
8165     r = guestfs_cat (g, path);
8166     if (r == NULL)
8167       return -1;
8168     if (strcmp (r, expected) != 0) {
8169       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8170       return -1;
8171     }
8172     free (r);
8173   }
8174   return 0;
8175 }
8176
8177 static int test_tar_in_0_skip (void)
8178 {
8179   const char *str;
8180
8181   str = getenv ("TEST_ONLY");
8182   if (str)
8183     return strstr (str, "tar_in") == NULL;
8184   str = getenv ("SKIP_TEST_TAR_IN_0");
8185   if (str && strcmp (str, "1") == 0) return 1;
8186   str = getenv ("SKIP_TEST_TAR_IN");
8187   if (str && strcmp (str, "1") == 0) return 1;
8188   return 0;
8189 }
8190
8191 static int test_tar_in_0 (void)
8192 {
8193   if (test_tar_in_0_skip ()) {
8194     printf ("        %s skipped (reason: environment variable set)\n", "test_tar_in_0");
8195     return 0;
8196   }
8197
8198   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
8199   {
8200     char device[] = "/dev/sda";
8201     int r;
8202     suppress_error = 0;
8203     r = guestfs_blockdev_setrw (g, device);
8204     if (r == -1)
8205       return -1;
8206   }
8207   {
8208     int r;
8209     suppress_error = 0;
8210     r = guestfs_umount_all (g);
8211     if (r == -1)
8212       return -1;
8213   }
8214   {
8215     int r;
8216     suppress_error = 0;
8217     r = guestfs_lvm_remove_all (g);
8218     if (r == -1)
8219       return -1;
8220   }
8221   {
8222     char device[] = "/dev/sda";
8223     char lines_0[] = ",";
8224     char *lines[] = {
8225       lines_0,
8226       NULL
8227     };
8228     int r;
8229     suppress_error = 0;
8230     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8231     if (r == -1)
8232       return -1;
8233   }
8234   {
8235     char fstype[] = "ext2";
8236     char device[] = "/dev/sda1";
8237     int r;
8238     suppress_error = 0;
8239     r = guestfs_mkfs (g, fstype, device);
8240     if (r == -1)
8241       return -1;
8242   }
8243   {
8244     char device[] = "/dev/sda1";
8245     char mountpoint[] = "/";
8246     int r;
8247     suppress_error = 0;
8248     r = guestfs_mount (g, device, mountpoint);
8249     if (r == -1)
8250       return -1;
8251   }
8252   /* TestOutput for tar_in (0) */
8253   char expected[] = "hello\n";
8254   {
8255     char directory[] = "/";
8256     int r;
8257     suppress_error = 0;
8258     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
8259     if (r == -1)
8260       return -1;
8261   }
8262   {
8263     char path[] = "/hello";
8264     char *r;
8265     suppress_error = 0;
8266     r = guestfs_cat (g, path);
8267     if (r == NULL)
8268       return -1;
8269     if (strcmp (r, expected) != 0) {
8270       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8271       return -1;
8272     }
8273     free (r);
8274   }
8275   return 0;
8276 }
8277
8278 static int test_checksum_0_skip (void)
8279 {
8280   const char *str;
8281
8282   str = getenv ("TEST_ONLY");
8283   if (str)
8284     return strstr (str, "checksum") == NULL;
8285   str = getenv ("SKIP_TEST_CHECKSUM_0");
8286   if (str && strcmp (str, "1") == 0) return 1;
8287   str = getenv ("SKIP_TEST_CHECKSUM");
8288   if (str && strcmp (str, "1") == 0) return 1;
8289   return 0;
8290 }
8291
8292 static int test_checksum_0 (void)
8293 {
8294   if (test_checksum_0_skip ()) {
8295     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_0");
8296     return 0;
8297   }
8298
8299   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
8300   {
8301     char device[] = "/dev/sda";
8302     int r;
8303     suppress_error = 0;
8304     r = guestfs_blockdev_setrw (g, device);
8305     if (r == -1)
8306       return -1;
8307   }
8308   {
8309     int r;
8310     suppress_error = 0;
8311     r = guestfs_umount_all (g);
8312     if (r == -1)
8313       return -1;
8314   }
8315   {
8316     int r;
8317     suppress_error = 0;
8318     r = guestfs_lvm_remove_all (g);
8319     if (r == -1)
8320       return -1;
8321   }
8322   {
8323     char device[] = "/dev/sda";
8324     char lines_0[] = ",";
8325     char *lines[] = {
8326       lines_0,
8327       NULL
8328     };
8329     int r;
8330     suppress_error = 0;
8331     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8332     if (r == -1)
8333       return -1;
8334   }
8335   {
8336     char fstype[] = "ext2";
8337     char device[] = "/dev/sda1";
8338     int r;
8339     suppress_error = 0;
8340     r = guestfs_mkfs (g, fstype, device);
8341     if (r == -1)
8342       return -1;
8343   }
8344   {
8345     char device[] = "/dev/sda1";
8346     char mountpoint[] = "/";
8347     int r;
8348     suppress_error = 0;
8349     r = guestfs_mount (g, device, mountpoint);
8350     if (r == -1)
8351       return -1;
8352   }
8353   /* TestOutput for checksum (0) */
8354   char expected[] = "935282863";
8355   {
8356     char path[] = "/new";
8357     char content[] = "test\n";
8358     int r;
8359     suppress_error = 0;
8360     r = guestfs_write_file (g, path, content, 0);
8361     if (r == -1)
8362       return -1;
8363   }
8364   {
8365     char csumtype[] = "crc";
8366     char path[] = "/new";
8367     char *r;
8368     suppress_error = 0;
8369     r = guestfs_checksum (g, csumtype, path);
8370     if (r == NULL)
8371       return -1;
8372     if (strcmp (r, expected) != 0) {
8373       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
8374       return -1;
8375     }
8376     free (r);
8377   }
8378   return 0;
8379 }
8380
8381 static int test_checksum_1_skip (void)
8382 {
8383   const char *str;
8384
8385   str = getenv ("TEST_ONLY");
8386   if (str)
8387     return strstr (str, "checksum") == NULL;
8388   str = getenv ("SKIP_TEST_CHECKSUM_1");
8389   if (str && strcmp (str, "1") == 0) return 1;
8390   str = getenv ("SKIP_TEST_CHECKSUM");
8391   if (str && strcmp (str, "1") == 0) return 1;
8392   return 0;
8393 }
8394
8395 static int test_checksum_1 (void)
8396 {
8397   if (test_checksum_1_skip ()) {
8398     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_1");
8399     return 0;
8400   }
8401
8402   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
8403   {
8404     char device[] = "/dev/sda";
8405     int r;
8406     suppress_error = 0;
8407     r = guestfs_blockdev_setrw (g, device);
8408     if (r == -1)
8409       return -1;
8410   }
8411   {
8412     int r;
8413     suppress_error = 0;
8414     r = guestfs_umount_all (g);
8415     if (r == -1)
8416       return -1;
8417   }
8418   {
8419     int r;
8420     suppress_error = 0;
8421     r = guestfs_lvm_remove_all (g);
8422     if (r == -1)
8423       return -1;
8424   }
8425   {
8426     char device[] = "/dev/sda";
8427     char lines_0[] = ",";
8428     char *lines[] = {
8429       lines_0,
8430       NULL
8431     };
8432     int r;
8433     suppress_error = 0;
8434     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8435     if (r == -1)
8436       return -1;
8437   }
8438   {
8439     char fstype[] = "ext2";
8440     char device[] = "/dev/sda1";
8441     int r;
8442     suppress_error = 0;
8443     r = guestfs_mkfs (g, fstype, device);
8444     if (r == -1)
8445       return -1;
8446   }
8447   {
8448     char device[] = "/dev/sda1";
8449     char mountpoint[] = "/";
8450     int r;
8451     suppress_error = 0;
8452     r = guestfs_mount (g, device, mountpoint);
8453     if (r == -1)
8454       return -1;
8455   }
8456   /* TestLastFail for checksum (1) */
8457   {
8458     char csumtype[] = "crc";
8459     char path[] = "/new";
8460     char *r;
8461     suppress_error = 1;
8462     r = guestfs_checksum (g, csumtype, path);
8463     if (r != NULL)
8464       return -1;
8465     free (r);
8466   }
8467   return 0;
8468 }
8469
8470 static int test_checksum_2_skip (void)
8471 {
8472   const char *str;
8473
8474   str = getenv ("TEST_ONLY");
8475   if (str)
8476     return strstr (str, "checksum") == NULL;
8477   str = getenv ("SKIP_TEST_CHECKSUM_2");
8478   if (str && strcmp (str, "1") == 0) return 1;
8479   str = getenv ("SKIP_TEST_CHECKSUM");
8480   if (str && strcmp (str, "1") == 0) return 1;
8481   return 0;
8482 }
8483
8484 static int test_checksum_2 (void)
8485 {
8486   if (test_checksum_2_skip ()) {
8487     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_2");
8488     return 0;
8489   }
8490
8491   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
8492   {
8493     char device[] = "/dev/sda";
8494     int r;
8495     suppress_error = 0;
8496     r = guestfs_blockdev_setrw (g, device);
8497     if (r == -1)
8498       return -1;
8499   }
8500   {
8501     int r;
8502     suppress_error = 0;
8503     r = guestfs_umount_all (g);
8504     if (r == -1)
8505       return -1;
8506   }
8507   {
8508     int r;
8509     suppress_error = 0;
8510     r = guestfs_lvm_remove_all (g);
8511     if (r == -1)
8512       return -1;
8513   }
8514   {
8515     char device[] = "/dev/sda";
8516     char lines_0[] = ",";
8517     char *lines[] = {
8518       lines_0,
8519       NULL
8520     };
8521     int r;
8522     suppress_error = 0;
8523     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8524     if (r == -1)
8525       return -1;
8526   }
8527   {
8528     char fstype[] = "ext2";
8529     char device[] = "/dev/sda1";
8530     int r;
8531     suppress_error = 0;
8532     r = guestfs_mkfs (g, fstype, device);
8533     if (r == -1)
8534       return -1;
8535   }
8536   {
8537     char device[] = "/dev/sda1";
8538     char mountpoint[] = "/";
8539     int r;
8540     suppress_error = 0;
8541     r = guestfs_mount (g, device, mountpoint);
8542     if (r == -1)
8543       return -1;
8544   }
8545   /* TestOutput for checksum (2) */
8546   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
8547   {
8548     char path[] = "/new";
8549     char content[] = "test\n";
8550     int r;
8551     suppress_error = 0;
8552     r = guestfs_write_file (g, path, content, 0);
8553     if (r == -1)
8554       return -1;
8555   }
8556   {
8557     char csumtype[] = "md5";
8558     char path[] = "/new";
8559     char *r;
8560     suppress_error = 0;
8561     r = guestfs_checksum (g, csumtype, path);
8562     if (r == NULL)
8563       return -1;
8564     if (strcmp (r, expected) != 0) {
8565       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
8566       return -1;
8567     }
8568     free (r);
8569   }
8570   return 0;
8571 }
8572
8573 static int test_checksum_3_skip (void)
8574 {
8575   const char *str;
8576
8577   str = getenv ("TEST_ONLY");
8578   if (str)
8579     return strstr (str, "checksum") == NULL;
8580   str = getenv ("SKIP_TEST_CHECKSUM_3");
8581   if (str && strcmp (str, "1") == 0) return 1;
8582   str = getenv ("SKIP_TEST_CHECKSUM");
8583   if (str && strcmp (str, "1") == 0) return 1;
8584   return 0;
8585 }
8586
8587 static int test_checksum_3 (void)
8588 {
8589   if (test_checksum_3_skip ()) {
8590     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_3");
8591     return 0;
8592   }
8593
8594   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
8595   {
8596     char device[] = "/dev/sda";
8597     int r;
8598     suppress_error = 0;
8599     r = guestfs_blockdev_setrw (g, device);
8600     if (r == -1)
8601       return -1;
8602   }
8603   {
8604     int r;
8605     suppress_error = 0;
8606     r = guestfs_umount_all (g);
8607     if (r == -1)
8608       return -1;
8609   }
8610   {
8611     int r;
8612     suppress_error = 0;
8613     r = guestfs_lvm_remove_all (g);
8614     if (r == -1)
8615       return -1;
8616   }
8617   {
8618     char device[] = "/dev/sda";
8619     char lines_0[] = ",";
8620     char *lines[] = {
8621       lines_0,
8622       NULL
8623     };
8624     int r;
8625     suppress_error = 0;
8626     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8627     if (r == -1)
8628       return -1;
8629   }
8630   {
8631     char fstype[] = "ext2";
8632     char device[] = "/dev/sda1";
8633     int r;
8634     suppress_error = 0;
8635     r = guestfs_mkfs (g, fstype, device);
8636     if (r == -1)
8637       return -1;
8638   }
8639   {
8640     char device[] = "/dev/sda1";
8641     char mountpoint[] = "/";
8642     int r;
8643     suppress_error = 0;
8644     r = guestfs_mount (g, device, mountpoint);
8645     if (r == -1)
8646       return -1;
8647   }
8648   /* TestOutput for checksum (3) */
8649   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8650   {
8651     char path[] = "/new";
8652     char content[] = "test\n";
8653     int r;
8654     suppress_error = 0;
8655     r = guestfs_write_file (g, path, content, 0);
8656     if (r == -1)
8657       return -1;
8658   }
8659   {
8660     char csumtype[] = "sha1";
8661     char path[] = "/new";
8662     char *r;
8663     suppress_error = 0;
8664     r = guestfs_checksum (g, csumtype, path);
8665     if (r == NULL)
8666       return -1;
8667     if (strcmp (r, expected) != 0) {
8668       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8669       return -1;
8670     }
8671     free (r);
8672   }
8673   return 0;
8674 }
8675
8676 static int test_checksum_4_skip (void)
8677 {
8678   const char *str;
8679
8680   str = getenv ("TEST_ONLY");
8681   if (str)
8682     return strstr (str, "checksum") == NULL;
8683   str = getenv ("SKIP_TEST_CHECKSUM_4");
8684   if (str && strcmp (str, "1") == 0) return 1;
8685   str = getenv ("SKIP_TEST_CHECKSUM");
8686   if (str && strcmp (str, "1") == 0) return 1;
8687   return 0;
8688 }
8689
8690 static int test_checksum_4 (void)
8691 {
8692   if (test_checksum_4_skip ()) {
8693     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_4");
8694     return 0;
8695   }
8696
8697   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8698   {
8699     char device[] = "/dev/sda";
8700     int r;
8701     suppress_error = 0;
8702     r = guestfs_blockdev_setrw (g, device);
8703     if (r == -1)
8704       return -1;
8705   }
8706   {
8707     int r;
8708     suppress_error = 0;
8709     r = guestfs_umount_all (g);
8710     if (r == -1)
8711       return -1;
8712   }
8713   {
8714     int r;
8715     suppress_error = 0;
8716     r = guestfs_lvm_remove_all (g);
8717     if (r == -1)
8718       return -1;
8719   }
8720   {
8721     char device[] = "/dev/sda";
8722     char lines_0[] = ",";
8723     char *lines[] = {
8724       lines_0,
8725       NULL
8726     };
8727     int r;
8728     suppress_error = 0;
8729     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8730     if (r == -1)
8731       return -1;
8732   }
8733   {
8734     char fstype[] = "ext2";
8735     char device[] = "/dev/sda1";
8736     int r;
8737     suppress_error = 0;
8738     r = guestfs_mkfs (g, fstype, device);
8739     if (r == -1)
8740       return -1;
8741   }
8742   {
8743     char device[] = "/dev/sda1";
8744     char mountpoint[] = "/";
8745     int r;
8746     suppress_error = 0;
8747     r = guestfs_mount (g, device, mountpoint);
8748     if (r == -1)
8749       return -1;
8750   }
8751   /* TestOutput for checksum (4) */
8752   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8753   {
8754     char path[] = "/new";
8755     char content[] = "test\n";
8756     int r;
8757     suppress_error = 0;
8758     r = guestfs_write_file (g, path, content, 0);
8759     if (r == -1)
8760       return -1;
8761   }
8762   {
8763     char csumtype[] = "sha224";
8764     char path[] = "/new";
8765     char *r;
8766     suppress_error = 0;
8767     r = guestfs_checksum (g, csumtype, path);
8768     if (r == NULL)
8769       return -1;
8770     if (strcmp (r, expected) != 0) {
8771       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8772       return -1;
8773     }
8774     free (r);
8775   }
8776   return 0;
8777 }
8778
8779 static int test_checksum_5_skip (void)
8780 {
8781   const char *str;
8782
8783   str = getenv ("TEST_ONLY");
8784   if (str)
8785     return strstr (str, "checksum") == NULL;
8786   str = getenv ("SKIP_TEST_CHECKSUM_5");
8787   if (str && strcmp (str, "1") == 0) return 1;
8788   str = getenv ("SKIP_TEST_CHECKSUM");
8789   if (str && strcmp (str, "1") == 0) return 1;
8790   return 0;
8791 }
8792
8793 static int test_checksum_5 (void)
8794 {
8795   if (test_checksum_5_skip ()) {
8796     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_5");
8797     return 0;
8798   }
8799
8800   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8801   {
8802     char device[] = "/dev/sda";
8803     int r;
8804     suppress_error = 0;
8805     r = guestfs_blockdev_setrw (g, device);
8806     if (r == -1)
8807       return -1;
8808   }
8809   {
8810     int r;
8811     suppress_error = 0;
8812     r = guestfs_umount_all (g);
8813     if (r == -1)
8814       return -1;
8815   }
8816   {
8817     int r;
8818     suppress_error = 0;
8819     r = guestfs_lvm_remove_all (g);
8820     if (r == -1)
8821       return -1;
8822   }
8823   {
8824     char device[] = "/dev/sda";
8825     char lines_0[] = ",";
8826     char *lines[] = {
8827       lines_0,
8828       NULL
8829     };
8830     int r;
8831     suppress_error = 0;
8832     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8833     if (r == -1)
8834       return -1;
8835   }
8836   {
8837     char fstype[] = "ext2";
8838     char device[] = "/dev/sda1";
8839     int r;
8840     suppress_error = 0;
8841     r = guestfs_mkfs (g, fstype, device);
8842     if (r == -1)
8843       return -1;
8844   }
8845   {
8846     char device[] = "/dev/sda1";
8847     char mountpoint[] = "/";
8848     int r;
8849     suppress_error = 0;
8850     r = guestfs_mount (g, device, mountpoint);
8851     if (r == -1)
8852       return -1;
8853   }
8854   /* TestOutput for checksum (5) */
8855   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8856   {
8857     char path[] = "/new";
8858     char content[] = "test\n";
8859     int r;
8860     suppress_error = 0;
8861     r = guestfs_write_file (g, path, content, 0);
8862     if (r == -1)
8863       return -1;
8864   }
8865   {
8866     char csumtype[] = "sha256";
8867     char path[] = "/new";
8868     char *r;
8869     suppress_error = 0;
8870     r = guestfs_checksum (g, csumtype, path);
8871     if (r == NULL)
8872       return -1;
8873     if (strcmp (r, expected) != 0) {
8874       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8875       return -1;
8876     }
8877     free (r);
8878   }
8879   return 0;
8880 }
8881
8882 static int test_checksum_6_skip (void)
8883 {
8884   const char *str;
8885
8886   str = getenv ("TEST_ONLY");
8887   if (str)
8888     return strstr (str, "checksum") == NULL;
8889   str = getenv ("SKIP_TEST_CHECKSUM_6");
8890   if (str && strcmp (str, "1") == 0) return 1;
8891   str = getenv ("SKIP_TEST_CHECKSUM");
8892   if (str && strcmp (str, "1") == 0) return 1;
8893   return 0;
8894 }
8895
8896 static int test_checksum_6 (void)
8897 {
8898   if (test_checksum_6_skip ()) {
8899     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_6");
8900     return 0;
8901   }
8902
8903   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8904   {
8905     char device[] = "/dev/sda";
8906     int r;
8907     suppress_error = 0;
8908     r = guestfs_blockdev_setrw (g, device);
8909     if (r == -1)
8910       return -1;
8911   }
8912   {
8913     int r;
8914     suppress_error = 0;
8915     r = guestfs_umount_all (g);
8916     if (r == -1)
8917       return -1;
8918   }
8919   {
8920     int r;
8921     suppress_error = 0;
8922     r = guestfs_lvm_remove_all (g);
8923     if (r == -1)
8924       return -1;
8925   }
8926   {
8927     char device[] = "/dev/sda";
8928     char lines_0[] = ",";
8929     char *lines[] = {
8930       lines_0,
8931       NULL
8932     };
8933     int r;
8934     suppress_error = 0;
8935     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8936     if (r == -1)
8937       return -1;
8938   }
8939   {
8940     char fstype[] = "ext2";
8941     char device[] = "/dev/sda1";
8942     int r;
8943     suppress_error = 0;
8944     r = guestfs_mkfs (g, fstype, device);
8945     if (r == -1)
8946       return -1;
8947   }
8948   {
8949     char device[] = "/dev/sda1";
8950     char mountpoint[] = "/";
8951     int r;
8952     suppress_error = 0;
8953     r = guestfs_mount (g, device, mountpoint);
8954     if (r == -1)
8955       return -1;
8956   }
8957   /* TestOutput for checksum (6) */
8958   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8959   {
8960     char path[] = "/new";
8961     char content[] = "test\n";
8962     int r;
8963     suppress_error = 0;
8964     r = guestfs_write_file (g, path, content, 0);
8965     if (r == -1)
8966       return -1;
8967   }
8968   {
8969     char csumtype[] = "sha384";
8970     char path[] = "/new";
8971     char *r;
8972     suppress_error = 0;
8973     r = guestfs_checksum (g, csumtype, path);
8974     if (r == NULL)
8975       return -1;
8976     if (strcmp (r, expected) != 0) {
8977       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8978       return -1;
8979     }
8980     free (r);
8981   }
8982   return 0;
8983 }
8984
8985 static int test_checksum_7_skip (void)
8986 {
8987   const char *str;
8988
8989   str = getenv ("TEST_ONLY");
8990   if (str)
8991     return strstr (str, "checksum") == NULL;
8992   str = getenv ("SKIP_TEST_CHECKSUM_7");
8993   if (str && strcmp (str, "1") == 0) return 1;
8994   str = getenv ("SKIP_TEST_CHECKSUM");
8995   if (str && strcmp (str, "1") == 0) return 1;
8996   return 0;
8997 }
8998
8999 static int test_checksum_7 (void)
9000 {
9001   if (test_checksum_7_skip ()) {
9002     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_7");
9003     return 0;
9004   }
9005
9006   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
9007   {
9008     char device[] = "/dev/sda";
9009     int r;
9010     suppress_error = 0;
9011     r = guestfs_blockdev_setrw (g, device);
9012     if (r == -1)
9013       return -1;
9014   }
9015   {
9016     int r;
9017     suppress_error = 0;
9018     r = guestfs_umount_all (g);
9019     if (r == -1)
9020       return -1;
9021   }
9022   {
9023     int r;
9024     suppress_error = 0;
9025     r = guestfs_lvm_remove_all (g);
9026     if (r == -1)
9027       return -1;
9028   }
9029   {
9030     char device[] = "/dev/sda";
9031     char lines_0[] = ",";
9032     char *lines[] = {
9033       lines_0,
9034       NULL
9035     };
9036     int r;
9037     suppress_error = 0;
9038     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9039     if (r == -1)
9040       return -1;
9041   }
9042   {
9043     char fstype[] = "ext2";
9044     char device[] = "/dev/sda1";
9045     int r;
9046     suppress_error = 0;
9047     r = guestfs_mkfs (g, fstype, device);
9048     if (r == -1)
9049       return -1;
9050   }
9051   {
9052     char device[] = "/dev/sda1";
9053     char mountpoint[] = "/";
9054     int r;
9055     suppress_error = 0;
9056     r = guestfs_mount (g, device, mountpoint);
9057     if (r == -1)
9058       return -1;
9059   }
9060   /* TestOutput for checksum (7) */
9061   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
9062   {
9063     char path[] = "/new";
9064     char content[] = "test\n";
9065     int r;
9066     suppress_error = 0;
9067     r = guestfs_write_file (g, path, content, 0);
9068     if (r == -1)
9069       return -1;
9070   }
9071   {
9072     char csumtype[] = "sha512";
9073     char path[] = "/new";
9074     char *r;
9075     suppress_error = 0;
9076     r = guestfs_checksum (g, csumtype, path);
9077     if (r == NULL)
9078       return -1;
9079     if (strcmp (r, expected) != 0) {
9080       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
9081       return -1;
9082     }
9083     free (r);
9084   }
9085   return 0;
9086 }
9087
9088 static int test_checksum_8_skip (void)
9089 {
9090   const char *str;
9091
9092   str = getenv ("TEST_ONLY");
9093   if (str)
9094     return strstr (str, "checksum") == NULL;
9095   str = getenv ("SKIP_TEST_CHECKSUM_8");
9096   if (str && strcmp (str, "1") == 0) return 1;
9097   str = getenv ("SKIP_TEST_CHECKSUM");
9098   if (str && strcmp (str, "1") == 0) return 1;
9099   return 0;
9100 }
9101
9102 static int test_checksum_8 (void)
9103 {
9104   if (test_checksum_8_skip ()) {
9105     printf ("        %s skipped (reason: environment variable set)\n", "test_checksum_8");
9106     return 0;
9107   }
9108
9109   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
9110   {
9111     char device[] = "/dev/sda";
9112     int r;
9113     suppress_error = 0;
9114     r = guestfs_blockdev_setrw (g, device);
9115     if (r == -1)
9116       return -1;
9117   }
9118   {
9119     int r;
9120     suppress_error = 0;
9121     r = guestfs_umount_all (g);
9122     if (r == -1)
9123       return -1;
9124   }
9125   {
9126     int r;
9127     suppress_error = 0;
9128     r = guestfs_lvm_remove_all (g);
9129     if (r == -1)
9130       return -1;
9131   }
9132   {
9133     char device[] = "/dev/sda";
9134     char lines_0[] = ",";
9135     char *lines[] = {
9136       lines_0,
9137       NULL
9138     };
9139     int r;
9140     suppress_error = 0;
9141     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9142     if (r == -1)
9143       return -1;
9144   }
9145   {
9146     char fstype[] = "ext2";
9147     char device[] = "/dev/sda1";
9148     int r;
9149     suppress_error = 0;
9150     r = guestfs_mkfs (g, fstype, device);
9151     if (r == -1)
9152       return -1;
9153   }
9154   {
9155     char device[] = "/dev/sda1";
9156     char mountpoint[] = "/";
9157     int r;
9158     suppress_error = 0;
9159     r = guestfs_mount (g, device, mountpoint);
9160     if (r == -1)
9161       return -1;
9162   }
9163   /* TestOutput for checksum (8) */
9164   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
9165   {
9166     char options[] = "ro";
9167     char vfstype[] = "squashfs";
9168     char device[] = "/dev/sdd";
9169     char mountpoint[] = "/";
9170     int r;
9171     suppress_error = 0;
9172     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
9173     if (r == -1)
9174       return -1;
9175   }
9176   {
9177     char csumtype[] = "md5";
9178     char path[] = "/known-3";
9179     char *r;
9180     suppress_error = 0;
9181     r = guestfs_checksum (g, csumtype, path);
9182     if (r == NULL)
9183       return -1;
9184     if (strcmp (r, expected) != 0) {
9185       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
9186       return -1;
9187     }
9188     free (r);
9189   }
9190   return 0;
9191 }
9192
9193 static int test_download_0_skip (void)
9194 {
9195   const char *str;
9196
9197   str = getenv ("TEST_ONLY");
9198   if (str)
9199     return strstr (str, "download") == NULL;
9200   str = getenv ("SKIP_TEST_DOWNLOAD_0");
9201   if (str && strcmp (str, "1") == 0) return 1;
9202   str = getenv ("SKIP_TEST_DOWNLOAD");
9203   if (str && strcmp (str, "1") == 0) return 1;
9204   return 0;
9205 }
9206
9207 static int test_download_0 (void)
9208 {
9209   if (test_download_0_skip ()) {
9210     printf ("        %s skipped (reason: environment variable set)\n", "test_download_0");
9211     return 0;
9212   }
9213
9214   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
9215   {
9216     char device[] = "/dev/sda";
9217     int r;
9218     suppress_error = 0;
9219     r = guestfs_blockdev_setrw (g, device);
9220     if (r == -1)
9221       return -1;
9222   }
9223   {
9224     int r;
9225     suppress_error = 0;
9226     r = guestfs_umount_all (g);
9227     if (r == -1)
9228       return -1;
9229   }
9230   {
9231     int r;
9232     suppress_error = 0;
9233     r = guestfs_lvm_remove_all (g);
9234     if (r == -1)
9235       return -1;
9236   }
9237   {
9238     char device[] = "/dev/sda";
9239     char lines_0[] = ",";
9240     char *lines[] = {
9241       lines_0,
9242       NULL
9243     };
9244     int r;
9245     suppress_error = 0;
9246     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9247     if (r == -1)
9248       return -1;
9249   }
9250   {
9251     char fstype[] = "ext2";
9252     char device[] = "/dev/sda1";
9253     int r;
9254     suppress_error = 0;
9255     r = guestfs_mkfs (g, fstype, device);
9256     if (r == -1)
9257       return -1;
9258   }
9259   {
9260     char device[] = "/dev/sda1";
9261     char mountpoint[] = "/";
9262     int r;
9263     suppress_error = 0;
9264     r = guestfs_mount (g, device, mountpoint);
9265     if (r == -1)
9266       return -1;
9267   }
9268   /* TestOutput for download (0) */
9269   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9270   {
9271     char remotefilename[] = "/COPYING.LIB";
9272     int r;
9273     suppress_error = 0;
9274     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9275     if (r == -1)
9276       return -1;
9277   }
9278   {
9279     char remotefilename[] = "/COPYING.LIB";
9280     int r;
9281     suppress_error = 0;
9282     r = guestfs_download (g, remotefilename, "testdownload.tmp");
9283     if (r == -1)
9284       return -1;
9285   }
9286   {
9287     char remotefilename[] = "/upload";
9288     int r;
9289     suppress_error = 0;
9290     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
9291     if (r == -1)
9292       return -1;
9293   }
9294   {
9295     char csumtype[] = "md5";
9296     char path[] = "/upload";
9297     char *r;
9298     suppress_error = 0;
9299     r = guestfs_checksum (g, csumtype, path);
9300     if (r == NULL)
9301       return -1;
9302     if (strcmp (r, expected) != 0) {
9303       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
9304       return -1;
9305     }
9306     free (r);
9307   }
9308   return 0;
9309 }
9310
9311 static int test_upload_0_skip (void)
9312 {
9313   const char *str;
9314
9315   str = getenv ("TEST_ONLY");
9316   if (str)
9317     return strstr (str, "upload") == NULL;
9318   str = getenv ("SKIP_TEST_UPLOAD_0");
9319   if (str && strcmp (str, "1") == 0) return 1;
9320   str = getenv ("SKIP_TEST_UPLOAD");
9321   if (str && strcmp (str, "1") == 0) return 1;
9322   return 0;
9323 }
9324
9325 static int test_upload_0 (void)
9326 {
9327   if (test_upload_0_skip ()) {
9328     printf ("        %s skipped (reason: environment variable set)\n", "test_upload_0");
9329     return 0;
9330   }
9331
9332   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
9333   {
9334     char device[] = "/dev/sda";
9335     int r;
9336     suppress_error = 0;
9337     r = guestfs_blockdev_setrw (g, device);
9338     if (r == -1)
9339       return -1;
9340   }
9341   {
9342     int r;
9343     suppress_error = 0;
9344     r = guestfs_umount_all (g);
9345     if (r == -1)
9346       return -1;
9347   }
9348   {
9349     int r;
9350     suppress_error = 0;
9351     r = guestfs_lvm_remove_all (g);
9352     if (r == -1)
9353       return -1;
9354   }
9355   {
9356     char device[] = "/dev/sda";
9357     char lines_0[] = ",";
9358     char *lines[] = {
9359       lines_0,
9360       NULL
9361     };
9362     int r;
9363     suppress_error = 0;
9364     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9365     if (r == -1)
9366       return -1;
9367   }
9368   {
9369     char fstype[] = "ext2";
9370     char device[] = "/dev/sda1";
9371     int r;
9372     suppress_error = 0;
9373     r = guestfs_mkfs (g, fstype, device);
9374     if (r == -1)
9375       return -1;
9376   }
9377   {
9378     char device[] = "/dev/sda1";
9379     char mountpoint[] = "/";
9380     int r;
9381     suppress_error = 0;
9382     r = guestfs_mount (g, device, mountpoint);
9383     if (r == -1)
9384       return -1;
9385   }
9386   /* TestOutput for upload (0) */
9387   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9388   {
9389     char remotefilename[] = "/COPYING.LIB";
9390     int r;
9391     suppress_error = 0;
9392     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9393     if (r == -1)
9394       return -1;
9395   }
9396   {
9397     char csumtype[] = "md5";
9398     char path[] = "/COPYING.LIB";
9399     char *r;
9400     suppress_error = 0;
9401     r = guestfs_checksum (g, csumtype, path);
9402     if (r == NULL)
9403       return -1;
9404     if (strcmp (r, expected) != 0) {
9405       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
9406       return -1;
9407     }
9408     free (r);
9409   }
9410   return 0;
9411 }
9412
9413 static int test_blockdev_rereadpt_0_skip (void)
9414 {
9415   const char *str;
9416
9417   str = getenv ("TEST_ONLY");
9418   if (str)
9419     return strstr (str, "blockdev_rereadpt") == NULL;
9420   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
9421   if (str && strcmp (str, "1") == 0) return 1;
9422   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
9423   if (str && strcmp (str, "1") == 0) return 1;
9424   return 0;
9425 }
9426
9427 static int test_blockdev_rereadpt_0 (void)
9428 {
9429   if (test_blockdev_rereadpt_0_skip ()) {
9430     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
9431     return 0;
9432   }
9433
9434   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
9435   {
9436     char device[] = "/dev/sda";
9437     int r;
9438     suppress_error = 0;
9439     r = guestfs_blockdev_setrw (g, device);
9440     if (r == -1)
9441       return -1;
9442   }
9443   {
9444     int r;
9445     suppress_error = 0;
9446     r = guestfs_umount_all (g);
9447     if (r == -1)
9448       return -1;
9449   }
9450   {
9451     int r;
9452     suppress_error = 0;
9453     r = guestfs_lvm_remove_all (g);
9454     if (r == -1)
9455       return -1;
9456   }
9457   /* TestRun for blockdev_rereadpt (0) */
9458   {
9459     char device[] = "/dev/sda";
9460     int r;
9461     suppress_error = 0;
9462     r = guestfs_blockdev_rereadpt (g, device);
9463     if (r == -1)
9464       return -1;
9465   }
9466   return 0;
9467 }
9468
9469 static int test_blockdev_flushbufs_0_skip (void)
9470 {
9471   const char *str;
9472
9473   str = getenv ("TEST_ONLY");
9474   if (str)
9475     return strstr (str, "blockdev_flushbufs") == NULL;
9476   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
9477   if (str && strcmp (str, "1") == 0) return 1;
9478   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
9479   if (str && strcmp (str, "1") == 0) return 1;
9480   return 0;
9481 }
9482
9483 static int test_blockdev_flushbufs_0 (void)
9484 {
9485   if (test_blockdev_flushbufs_0_skip ()) {
9486     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
9487     return 0;
9488   }
9489
9490   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
9491   {
9492     char device[] = "/dev/sda";
9493     int r;
9494     suppress_error = 0;
9495     r = guestfs_blockdev_setrw (g, device);
9496     if (r == -1)
9497       return -1;
9498   }
9499   {
9500     int r;
9501     suppress_error = 0;
9502     r = guestfs_umount_all (g);
9503     if (r == -1)
9504       return -1;
9505   }
9506   {
9507     int r;
9508     suppress_error = 0;
9509     r = guestfs_lvm_remove_all (g);
9510     if (r == -1)
9511       return -1;
9512   }
9513   /* TestRun for blockdev_flushbufs (0) */
9514   {
9515     char device[] = "/dev/sda";
9516     int r;
9517     suppress_error = 0;
9518     r = guestfs_blockdev_flushbufs (g, device);
9519     if (r == -1)
9520       return -1;
9521   }
9522   return 0;
9523 }
9524
9525 static int test_blockdev_getsize64_0_skip (void)
9526 {
9527   const char *str;
9528
9529   str = getenv ("TEST_ONLY");
9530   if (str)
9531     return strstr (str, "blockdev_getsize64") == NULL;
9532   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
9533   if (str && strcmp (str, "1") == 0) return 1;
9534   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
9535   if (str && strcmp (str, "1") == 0) return 1;
9536   return 0;
9537 }
9538
9539 static int test_blockdev_getsize64_0 (void)
9540 {
9541   if (test_blockdev_getsize64_0_skip ()) {
9542     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
9543     return 0;
9544   }
9545
9546   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
9547   {
9548     char device[] = "/dev/sda";
9549     int r;
9550     suppress_error = 0;
9551     r = guestfs_blockdev_setrw (g, device);
9552     if (r == -1)
9553       return -1;
9554   }
9555   {
9556     int r;
9557     suppress_error = 0;
9558     r = guestfs_umount_all (g);
9559     if (r == -1)
9560       return -1;
9561   }
9562   {
9563     int r;
9564     suppress_error = 0;
9565     r = guestfs_lvm_remove_all (g);
9566     if (r == -1)
9567       return -1;
9568   }
9569   /* TestOutputInt for blockdev_getsize64 (0) */
9570   {
9571     char device[] = "/dev/sda";
9572     int64_t r;
9573     suppress_error = 0;
9574     r = guestfs_blockdev_getsize64 (g, device);
9575     if (r == -1)
9576       return -1;
9577     if (r != 524288000) {
9578       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
9579       return -1;
9580     }
9581   }
9582   return 0;
9583 }
9584
9585 static int test_blockdev_getsz_0_skip (void)
9586 {
9587   const char *str;
9588
9589   str = getenv ("TEST_ONLY");
9590   if (str)
9591     return strstr (str, "blockdev_getsz") == NULL;
9592   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
9593   if (str && strcmp (str, "1") == 0) return 1;
9594   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
9595   if (str && strcmp (str, "1") == 0) return 1;
9596   return 0;
9597 }
9598
9599 static int test_blockdev_getsz_0 (void)
9600 {
9601   if (test_blockdev_getsz_0_skip ()) {
9602     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
9603     return 0;
9604   }
9605
9606   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
9607   {
9608     char device[] = "/dev/sda";
9609     int r;
9610     suppress_error = 0;
9611     r = guestfs_blockdev_setrw (g, device);
9612     if (r == -1)
9613       return -1;
9614   }
9615   {
9616     int r;
9617     suppress_error = 0;
9618     r = guestfs_umount_all (g);
9619     if (r == -1)
9620       return -1;
9621   }
9622   {
9623     int r;
9624     suppress_error = 0;
9625     r = guestfs_lvm_remove_all (g);
9626     if (r == -1)
9627       return -1;
9628   }
9629   /* TestOutputInt for blockdev_getsz (0) */
9630   {
9631     char device[] = "/dev/sda";
9632     int64_t r;
9633     suppress_error = 0;
9634     r = guestfs_blockdev_getsz (g, device);
9635     if (r == -1)
9636       return -1;
9637     if (r != 1024000) {
9638       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
9639       return -1;
9640     }
9641   }
9642   return 0;
9643 }
9644
9645 static int test_blockdev_getbsz_0_skip (void)
9646 {
9647   const char *str;
9648
9649   str = getenv ("TEST_ONLY");
9650   if (str)
9651     return strstr (str, "blockdev_getbsz") == NULL;
9652   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9653   if (str && strcmp (str, "1") == 0) return 1;
9654   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9655   if (str && strcmp (str, "1") == 0) return 1;
9656   return 0;
9657 }
9658
9659 static int test_blockdev_getbsz_0 (void)
9660 {
9661   if (test_blockdev_getbsz_0_skip ()) {
9662     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9663     return 0;
9664   }
9665
9666   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9667   {
9668     char device[] = "/dev/sda";
9669     int r;
9670     suppress_error = 0;
9671     r = guestfs_blockdev_setrw (g, device);
9672     if (r == -1)
9673       return -1;
9674   }
9675   {
9676     int r;
9677     suppress_error = 0;
9678     r = guestfs_umount_all (g);
9679     if (r == -1)
9680       return -1;
9681   }
9682   {
9683     int r;
9684     suppress_error = 0;
9685     r = guestfs_lvm_remove_all (g);
9686     if (r == -1)
9687       return -1;
9688   }
9689   /* TestOutputInt for blockdev_getbsz (0) */
9690   {
9691     char device[] = "/dev/sda";
9692     int r;
9693     suppress_error = 0;
9694     r = guestfs_blockdev_getbsz (g, device);
9695     if (r == -1)
9696       return -1;
9697     if (r != 4096) {
9698       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
9699       return -1;
9700     }
9701   }
9702   return 0;
9703 }
9704
9705 static int test_blockdev_getss_0_skip (void)
9706 {
9707   const char *str;
9708
9709   str = getenv ("TEST_ONLY");
9710   if (str)
9711     return strstr (str, "blockdev_getss") == NULL;
9712   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9713   if (str && strcmp (str, "1") == 0) return 1;
9714   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9715   if (str && strcmp (str, "1") == 0) return 1;
9716   return 0;
9717 }
9718
9719 static int test_blockdev_getss_0 (void)
9720 {
9721   if (test_blockdev_getss_0_skip ()) {
9722     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9723     return 0;
9724   }
9725
9726   /* InitNone|InitEmpty for test_blockdev_getss_0 */
9727   {
9728     char device[] = "/dev/sda";
9729     int r;
9730     suppress_error = 0;
9731     r = guestfs_blockdev_setrw (g, device);
9732     if (r == -1)
9733       return -1;
9734   }
9735   {
9736     int r;
9737     suppress_error = 0;
9738     r = guestfs_umount_all (g);
9739     if (r == -1)
9740       return -1;
9741   }
9742   {
9743     int r;
9744     suppress_error = 0;
9745     r = guestfs_lvm_remove_all (g);
9746     if (r == -1)
9747       return -1;
9748   }
9749   /* TestOutputInt for blockdev_getss (0) */
9750   {
9751     char device[] = "/dev/sda";
9752     int r;
9753     suppress_error = 0;
9754     r = guestfs_blockdev_getss (g, device);
9755     if (r == -1)
9756       return -1;
9757     if (r != 512) {
9758       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
9759       return -1;
9760     }
9761   }
9762   return 0;
9763 }
9764
9765 static int test_blockdev_getro_0_skip (void)
9766 {
9767   const char *str;
9768
9769   str = getenv ("TEST_ONLY");
9770   if (str)
9771     return strstr (str, "blockdev_getro") == NULL;
9772   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9773   if (str && strcmp (str, "1") == 0) return 1;
9774   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9775   if (str && strcmp (str, "1") == 0) return 1;
9776   return 0;
9777 }
9778
9779 static int test_blockdev_getro_0 (void)
9780 {
9781   if (test_blockdev_getro_0_skip ()) {
9782     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9783     return 0;
9784   }
9785
9786   /* InitNone|InitEmpty for test_blockdev_getro_0 */
9787   {
9788     char device[] = "/dev/sda";
9789     int r;
9790     suppress_error = 0;
9791     r = guestfs_blockdev_setrw (g, device);
9792     if (r == -1)
9793       return -1;
9794   }
9795   {
9796     int r;
9797     suppress_error = 0;
9798     r = guestfs_umount_all (g);
9799     if (r == -1)
9800       return -1;
9801   }
9802   {
9803     int r;
9804     suppress_error = 0;
9805     r = guestfs_lvm_remove_all (g);
9806     if (r == -1)
9807       return -1;
9808   }
9809   /* TestOutputTrue for blockdev_getro (0) */
9810   {
9811     char device[] = "/dev/sda";
9812     int r;
9813     suppress_error = 0;
9814     r = guestfs_blockdev_setro (g, device);
9815     if (r == -1)
9816       return -1;
9817   }
9818   {
9819     char device[] = "/dev/sda";
9820     int r;
9821     suppress_error = 0;
9822     r = guestfs_blockdev_getro (g, device);
9823     if (r == -1)
9824       return -1;
9825     if (!r) {
9826       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9827       return -1;
9828     }
9829   }
9830   return 0;
9831 }
9832
9833 static int test_blockdev_setrw_0_skip (void)
9834 {
9835   const char *str;
9836
9837   str = getenv ("TEST_ONLY");
9838   if (str)
9839     return strstr (str, "blockdev_setrw") == NULL;
9840   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9841   if (str && strcmp (str, "1") == 0) return 1;
9842   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9843   if (str && strcmp (str, "1") == 0) return 1;
9844   return 0;
9845 }
9846
9847 static int test_blockdev_setrw_0 (void)
9848 {
9849   if (test_blockdev_setrw_0_skip ()) {
9850     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9851     return 0;
9852   }
9853
9854   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9855   {
9856     char device[] = "/dev/sda";
9857     int r;
9858     suppress_error = 0;
9859     r = guestfs_blockdev_setrw (g, device);
9860     if (r == -1)
9861       return -1;
9862   }
9863   {
9864     int r;
9865     suppress_error = 0;
9866     r = guestfs_umount_all (g);
9867     if (r == -1)
9868       return -1;
9869   }
9870   {
9871     int r;
9872     suppress_error = 0;
9873     r = guestfs_lvm_remove_all (g);
9874     if (r == -1)
9875       return -1;
9876   }
9877   /* TestOutputFalse for blockdev_setrw (0) */
9878   {
9879     char device[] = "/dev/sda";
9880     int r;
9881     suppress_error = 0;
9882     r = guestfs_blockdev_setrw (g, device);
9883     if (r == -1)
9884       return -1;
9885   }
9886   {
9887     char device[] = "/dev/sda";
9888     int r;
9889     suppress_error = 0;
9890     r = guestfs_blockdev_getro (g, device);
9891     if (r == -1)
9892       return -1;
9893     if (r) {
9894       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9895       return -1;
9896     }
9897   }
9898   return 0;
9899 }
9900
9901 static int test_blockdev_setro_0_skip (void)
9902 {
9903   const char *str;
9904
9905   str = getenv ("TEST_ONLY");
9906   if (str)
9907     return strstr (str, "blockdev_setro") == NULL;
9908   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9909   if (str && strcmp (str, "1") == 0) return 1;
9910   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9911   if (str && strcmp (str, "1") == 0) return 1;
9912   return 0;
9913 }
9914
9915 static int test_blockdev_setro_0 (void)
9916 {
9917   if (test_blockdev_setro_0_skip ()) {
9918     printf ("        %s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9919     return 0;
9920   }
9921
9922   /* InitNone|InitEmpty for test_blockdev_setro_0 */
9923   {
9924     char device[] = "/dev/sda";
9925     int r;
9926     suppress_error = 0;
9927     r = guestfs_blockdev_setrw (g, device);
9928     if (r == -1)
9929       return -1;
9930   }
9931   {
9932     int r;
9933     suppress_error = 0;
9934     r = guestfs_umount_all (g);
9935     if (r == -1)
9936       return -1;
9937   }
9938   {
9939     int r;
9940     suppress_error = 0;
9941     r = guestfs_lvm_remove_all (g);
9942     if (r == -1)
9943       return -1;
9944   }
9945   /* TestOutputTrue for blockdev_setro (0) */
9946   {
9947     char device[] = "/dev/sda";
9948     int r;
9949     suppress_error = 0;
9950     r = guestfs_blockdev_setro (g, device);
9951     if (r == -1)
9952       return -1;
9953   }
9954   {
9955     char device[] = "/dev/sda";
9956     int r;
9957     suppress_error = 0;
9958     r = guestfs_blockdev_getro (g, device);
9959     if (r == -1)
9960       return -1;
9961     if (!r) {
9962       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9963       return -1;
9964     }
9965   }
9966   return 0;
9967 }
9968
9969 static int test_statvfs_0_skip (void)
9970 {
9971   const char *str;
9972
9973   str = getenv ("TEST_ONLY");
9974   if (str)
9975     return strstr (str, "statvfs") == NULL;
9976   str = getenv ("SKIP_TEST_STATVFS_0");
9977   if (str && strcmp (str, "1") == 0) return 1;
9978   str = getenv ("SKIP_TEST_STATVFS");
9979   if (str && strcmp (str, "1") == 0) return 1;
9980   return 0;
9981 }
9982
9983 static int test_statvfs_0 (void)
9984 {
9985   if (test_statvfs_0_skip ()) {
9986     printf ("        %s skipped (reason: environment variable set)\n", "test_statvfs_0");
9987     return 0;
9988   }
9989
9990   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9991   {
9992     char device[] = "/dev/sda";
9993     int r;
9994     suppress_error = 0;
9995     r = guestfs_blockdev_setrw (g, device);
9996     if (r == -1)
9997       return -1;
9998   }
9999   {
10000     int r;
10001     suppress_error = 0;
10002     r = guestfs_umount_all (g);
10003     if (r == -1)
10004       return -1;
10005   }
10006   {
10007     int r;
10008     suppress_error = 0;
10009     r = guestfs_lvm_remove_all (g);
10010     if (r == -1)
10011       return -1;
10012   }
10013   {
10014     char device[] = "/dev/sda";
10015     char lines_0[] = ",";
10016     char *lines[] = {
10017       lines_0,
10018       NULL
10019     };
10020     int r;
10021     suppress_error = 0;
10022     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10023     if (r == -1)
10024       return -1;
10025   }
10026   {
10027     char fstype[] = "ext2";
10028     char device[] = "/dev/sda1";
10029     int r;
10030     suppress_error = 0;
10031     r = guestfs_mkfs (g, fstype, device);
10032     if (r == -1)
10033       return -1;
10034   }
10035   {
10036     char device[] = "/dev/sda1";
10037     char mountpoint[] = "/";
10038     int r;
10039     suppress_error = 0;
10040     r = guestfs_mount (g, device, mountpoint);
10041     if (r == -1)
10042       return -1;
10043   }
10044   /* TestOutputStruct for statvfs (0) */
10045   {
10046     char path[] = "/";
10047     struct guestfs_statvfs *r;
10048     suppress_error = 0;
10049     r = guestfs_statvfs (g, path);
10050     if (r == NULL)
10051       return -1;
10052     if (r->namemax != 255) {
10053       fprintf (stderr, "test_statvfs_0: namemax was %d, expected 255\n",
10054                (int) r->namemax);
10055       return -1;
10056     }
10057     if (r->bsize != 1024) {
10058       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
10059                (int) r->bsize);
10060       return -1;
10061     }
10062     free (r);
10063   }
10064   return 0;
10065 }
10066
10067 static int test_lstat_0_skip (void)
10068 {
10069   const char *str;
10070
10071   str = getenv ("TEST_ONLY");
10072   if (str)
10073     return strstr (str, "lstat") == NULL;
10074   str = getenv ("SKIP_TEST_LSTAT_0");
10075   if (str && strcmp (str, "1") == 0) return 1;
10076   str = getenv ("SKIP_TEST_LSTAT");
10077   if (str && strcmp (str, "1") == 0) return 1;
10078   return 0;
10079 }
10080
10081 static int test_lstat_0 (void)
10082 {
10083   if (test_lstat_0_skip ()) {
10084     printf ("        %s skipped (reason: environment variable set)\n", "test_lstat_0");
10085     return 0;
10086   }
10087
10088   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
10089   {
10090     char device[] = "/dev/sda";
10091     int r;
10092     suppress_error = 0;
10093     r = guestfs_blockdev_setrw (g, device);
10094     if (r == -1)
10095       return -1;
10096   }
10097   {
10098     int r;
10099     suppress_error = 0;
10100     r = guestfs_umount_all (g);
10101     if (r == -1)
10102       return -1;
10103   }
10104   {
10105     int r;
10106     suppress_error = 0;
10107     r = guestfs_lvm_remove_all (g);
10108     if (r == -1)
10109       return -1;
10110   }
10111   {
10112     char device[] = "/dev/sda";
10113     char lines_0[] = ",";
10114     char *lines[] = {
10115       lines_0,
10116       NULL
10117     };
10118     int r;
10119     suppress_error = 0;
10120     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10121     if (r == -1)
10122       return -1;
10123   }
10124   {
10125     char fstype[] = "ext2";
10126     char device[] = "/dev/sda1";
10127     int r;
10128     suppress_error = 0;
10129     r = guestfs_mkfs (g, fstype, device);
10130     if (r == -1)
10131       return -1;
10132   }
10133   {
10134     char device[] = "/dev/sda1";
10135     char mountpoint[] = "/";
10136     int r;
10137     suppress_error = 0;
10138     r = guestfs_mount (g, device, mountpoint);
10139     if (r == -1)
10140       return -1;
10141   }
10142   /* TestOutputStruct for lstat (0) */
10143   {
10144     char path[] = "/new";
10145     int r;
10146     suppress_error = 0;
10147     r = guestfs_touch (g, path);
10148     if (r == -1)
10149       return -1;
10150   }
10151   {
10152     char path[] = "/new";
10153     struct guestfs_stat *r;
10154     suppress_error = 0;
10155     r = guestfs_lstat (g, path);
10156     if (r == NULL)
10157       return -1;
10158     if (r->size != 0) {
10159       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
10160                (int) r->size);
10161       return -1;
10162     }
10163     free (r);
10164   }
10165   return 0;
10166 }
10167
10168 static int test_stat_0_skip (void)
10169 {
10170   const char *str;
10171
10172   str = getenv ("TEST_ONLY");
10173   if (str)
10174     return strstr (str, "stat") == NULL;
10175   str = getenv ("SKIP_TEST_STAT_0");
10176   if (str && strcmp (str, "1") == 0) return 1;
10177   str = getenv ("SKIP_TEST_STAT");
10178   if (str && strcmp (str, "1") == 0) return 1;
10179   return 0;
10180 }
10181
10182 static int test_stat_0 (void)
10183 {
10184   if (test_stat_0_skip ()) {
10185     printf ("        %s skipped (reason: environment variable set)\n", "test_stat_0");
10186     return 0;
10187   }
10188
10189   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
10190   {
10191     char device[] = "/dev/sda";
10192     int r;
10193     suppress_error = 0;
10194     r = guestfs_blockdev_setrw (g, device);
10195     if (r == -1)
10196       return -1;
10197   }
10198   {
10199     int r;
10200     suppress_error = 0;
10201     r = guestfs_umount_all (g);
10202     if (r == -1)
10203       return -1;
10204   }
10205   {
10206     int r;
10207     suppress_error = 0;
10208     r = guestfs_lvm_remove_all (g);
10209     if (r == -1)
10210       return -1;
10211   }
10212   {
10213     char device[] = "/dev/sda";
10214     char lines_0[] = ",";
10215     char *lines[] = {
10216       lines_0,
10217       NULL
10218     };
10219     int r;
10220     suppress_error = 0;
10221     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10222     if (r == -1)
10223       return -1;
10224   }
10225   {
10226     char fstype[] = "ext2";
10227     char device[] = "/dev/sda1";
10228     int r;
10229     suppress_error = 0;
10230     r = guestfs_mkfs (g, fstype, device);
10231     if (r == -1)
10232       return -1;
10233   }
10234   {
10235     char device[] = "/dev/sda1";
10236     char mountpoint[] = "/";
10237     int r;
10238     suppress_error = 0;
10239     r = guestfs_mount (g, device, mountpoint);
10240     if (r == -1)
10241       return -1;
10242   }
10243   /* TestOutputStruct for stat (0) */
10244   {
10245     char path[] = "/new";
10246     int r;
10247     suppress_error = 0;
10248     r = guestfs_touch (g, path);
10249     if (r == -1)
10250       return -1;
10251   }
10252   {
10253     char path[] = "/new";
10254     struct guestfs_stat *r;
10255     suppress_error = 0;
10256     r = guestfs_stat (g, path);
10257     if (r == NULL)
10258       return -1;
10259     if (r->size != 0) {
10260       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
10261                (int) r->size);
10262       return -1;
10263     }
10264     free (r);
10265   }
10266   return 0;
10267 }
10268
10269 static int test_command_lines_0_skip (void)
10270 {
10271   const char *str;
10272
10273   str = getenv ("TEST_ONLY");
10274   if (str)
10275     return strstr (str, "command_lines") == NULL;
10276   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
10277   if (str && strcmp (str, "1") == 0) return 1;
10278   str = getenv ("SKIP_TEST_COMMAND_LINES");
10279   if (str && strcmp (str, "1") == 0) return 1;
10280   return 0;
10281 }
10282
10283 static int test_command_lines_0 (void)
10284 {
10285   if (test_command_lines_0_skip ()) {
10286     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_0");
10287     return 0;
10288   }
10289
10290   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
10291   {
10292     char device[] = "/dev/sda";
10293     int r;
10294     suppress_error = 0;
10295     r = guestfs_blockdev_setrw (g, device);
10296     if (r == -1)
10297       return -1;
10298   }
10299   {
10300     int r;
10301     suppress_error = 0;
10302     r = guestfs_umount_all (g);
10303     if (r == -1)
10304       return -1;
10305   }
10306   {
10307     int r;
10308     suppress_error = 0;
10309     r = guestfs_lvm_remove_all (g);
10310     if (r == -1)
10311       return -1;
10312   }
10313   {
10314     char device[] = "/dev/sda";
10315     char lines_0[] = ",";
10316     char *lines[] = {
10317       lines_0,
10318       NULL
10319     };
10320     int r;
10321     suppress_error = 0;
10322     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10323     if (r == -1)
10324       return -1;
10325   }
10326   {
10327     char fstype[] = "ext2";
10328     char device[] = "/dev/sda1";
10329     int r;
10330     suppress_error = 0;
10331     r = guestfs_mkfs (g, fstype, device);
10332     if (r == -1)
10333       return -1;
10334   }
10335   {
10336     char device[] = "/dev/sda1";
10337     char mountpoint[] = "/";
10338     int r;
10339     suppress_error = 0;
10340     r = guestfs_mount (g, device, mountpoint);
10341     if (r == -1)
10342       return -1;
10343   }
10344   /* TestOutputList for command_lines (0) */
10345   {
10346     char remotefilename[] = "/test-command";
10347     int r;
10348     suppress_error = 0;
10349     r = guestfs_upload (g, "test-command", remotefilename);
10350     if (r == -1)
10351       return -1;
10352   }
10353   {
10354     char path[] = "/test-command";
10355     int r;
10356     suppress_error = 0;
10357     r = guestfs_chmod (g, 493, path);
10358     if (r == -1)
10359       return -1;
10360   }
10361   {
10362     char arguments_0[] = "/test-command";
10363     char arguments_1[] = "1";
10364     char *arguments[] = {
10365       arguments_0,
10366       arguments_1,
10367       NULL
10368     };
10369     char **r;
10370     int i;
10371     suppress_error = 0;
10372     r = guestfs_command_lines (g, arguments);
10373     if (r == NULL)
10374       return -1;
10375     if (!r[0]) {
10376       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
10377       print_strings (r);
10378       return -1;
10379     }
10380     {
10381       char expected[] = "Result1";
10382       if (strcmp (r[0], expected) != 0) {
10383         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10384         return -1;
10385       }
10386     }
10387     if (r[1] != NULL) {
10388       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
10389       print_strings (r);
10390       return -1;
10391     }
10392     for (i = 0; r[i] != NULL; ++i)
10393       free (r[i]);
10394     free (r);
10395   }
10396   return 0;
10397 }
10398
10399 static int test_command_lines_1_skip (void)
10400 {
10401   const char *str;
10402
10403   str = getenv ("TEST_ONLY");
10404   if (str)
10405     return strstr (str, "command_lines") == NULL;
10406   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
10407   if (str && strcmp (str, "1") == 0) return 1;
10408   str = getenv ("SKIP_TEST_COMMAND_LINES");
10409   if (str && strcmp (str, "1") == 0) return 1;
10410   return 0;
10411 }
10412
10413 static int test_command_lines_1 (void)
10414 {
10415   if (test_command_lines_1_skip ()) {
10416     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_1");
10417     return 0;
10418   }
10419
10420   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
10421   {
10422     char device[] = "/dev/sda";
10423     int r;
10424     suppress_error = 0;
10425     r = guestfs_blockdev_setrw (g, device);
10426     if (r == -1)
10427       return -1;
10428   }
10429   {
10430     int r;
10431     suppress_error = 0;
10432     r = guestfs_umount_all (g);
10433     if (r == -1)
10434       return -1;
10435   }
10436   {
10437     int r;
10438     suppress_error = 0;
10439     r = guestfs_lvm_remove_all (g);
10440     if (r == -1)
10441       return -1;
10442   }
10443   {
10444     char device[] = "/dev/sda";
10445     char lines_0[] = ",";
10446     char *lines[] = {
10447       lines_0,
10448       NULL
10449     };
10450     int r;
10451     suppress_error = 0;
10452     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10453     if (r == -1)
10454       return -1;
10455   }
10456   {
10457     char fstype[] = "ext2";
10458     char device[] = "/dev/sda1";
10459     int r;
10460     suppress_error = 0;
10461     r = guestfs_mkfs (g, fstype, device);
10462     if (r == -1)
10463       return -1;
10464   }
10465   {
10466     char device[] = "/dev/sda1";
10467     char mountpoint[] = "/";
10468     int r;
10469     suppress_error = 0;
10470     r = guestfs_mount (g, device, mountpoint);
10471     if (r == -1)
10472       return -1;
10473   }
10474   /* TestOutputList for command_lines (1) */
10475   {
10476     char remotefilename[] = "/test-command";
10477     int r;
10478     suppress_error = 0;
10479     r = guestfs_upload (g, "test-command", remotefilename);
10480     if (r == -1)
10481       return -1;
10482   }
10483   {
10484     char path[] = "/test-command";
10485     int r;
10486     suppress_error = 0;
10487     r = guestfs_chmod (g, 493, path);
10488     if (r == -1)
10489       return -1;
10490   }
10491   {
10492     char arguments_0[] = "/test-command";
10493     char arguments_1[] = "2";
10494     char *arguments[] = {
10495       arguments_0,
10496       arguments_1,
10497       NULL
10498     };
10499     char **r;
10500     int i;
10501     suppress_error = 0;
10502     r = guestfs_command_lines (g, arguments);
10503     if (r == NULL)
10504       return -1;
10505     if (!r[0]) {
10506       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
10507       print_strings (r);
10508       return -1;
10509     }
10510     {
10511       char expected[] = "Result2";
10512       if (strcmp (r[0], expected) != 0) {
10513         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10514         return -1;
10515       }
10516     }
10517     if (r[1] != NULL) {
10518       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
10519       print_strings (r);
10520       return -1;
10521     }
10522     for (i = 0; r[i] != NULL; ++i)
10523       free (r[i]);
10524     free (r);
10525   }
10526   return 0;
10527 }
10528
10529 static int test_command_lines_2_skip (void)
10530 {
10531   const char *str;
10532
10533   str = getenv ("TEST_ONLY");
10534   if (str)
10535     return strstr (str, "command_lines") == NULL;
10536   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
10537   if (str && strcmp (str, "1") == 0) return 1;
10538   str = getenv ("SKIP_TEST_COMMAND_LINES");
10539   if (str && strcmp (str, "1") == 0) return 1;
10540   return 0;
10541 }
10542
10543 static int test_command_lines_2 (void)
10544 {
10545   if (test_command_lines_2_skip ()) {
10546     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_2");
10547     return 0;
10548   }
10549
10550   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
10551   {
10552     char device[] = "/dev/sda";
10553     int r;
10554     suppress_error = 0;
10555     r = guestfs_blockdev_setrw (g, device);
10556     if (r == -1)
10557       return -1;
10558   }
10559   {
10560     int r;
10561     suppress_error = 0;
10562     r = guestfs_umount_all (g);
10563     if (r == -1)
10564       return -1;
10565   }
10566   {
10567     int r;
10568     suppress_error = 0;
10569     r = guestfs_lvm_remove_all (g);
10570     if (r == -1)
10571       return -1;
10572   }
10573   {
10574     char device[] = "/dev/sda";
10575     char lines_0[] = ",";
10576     char *lines[] = {
10577       lines_0,
10578       NULL
10579     };
10580     int r;
10581     suppress_error = 0;
10582     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10583     if (r == -1)
10584       return -1;
10585   }
10586   {
10587     char fstype[] = "ext2";
10588     char device[] = "/dev/sda1";
10589     int r;
10590     suppress_error = 0;
10591     r = guestfs_mkfs (g, fstype, device);
10592     if (r == -1)
10593       return -1;
10594   }
10595   {
10596     char device[] = "/dev/sda1";
10597     char mountpoint[] = "/";
10598     int r;
10599     suppress_error = 0;
10600     r = guestfs_mount (g, device, mountpoint);
10601     if (r == -1)
10602       return -1;
10603   }
10604   /* TestOutputList for command_lines (2) */
10605   {
10606     char remotefilename[] = "/test-command";
10607     int r;
10608     suppress_error = 0;
10609     r = guestfs_upload (g, "test-command", remotefilename);
10610     if (r == -1)
10611       return -1;
10612   }
10613   {
10614     char path[] = "/test-command";
10615     int r;
10616     suppress_error = 0;
10617     r = guestfs_chmod (g, 493, path);
10618     if (r == -1)
10619       return -1;
10620   }
10621   {
10622     char arguments_0[] = "/test-command";
10623     char arguments_1[] = "3";
10624     char *arguments[] = {
10625       arguments_0,
10626       arguments_1,
10627       NULL
10628     };
10629     char **r;
10630     int i;
10631     suppress_error = 0;
10632     r = guestfs_command_lines (g, arguments);
10633     if (r == NULL)
10634       return -1;
10635     if (!r[0]) {
10636       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10637       print_strings (r);
10638       return -1;
10639     }
10640     {
10641       char expected[] = "";
10642       if (strcmp (r[0], expected) != 0) {
10643         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10644         return -1;
10645       }
10646     }
10647     if (!r[1]) {
10648       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10649       print_strings (r);
10650       return -1;
10651     }
10652     {
10653       char expected[] = "Result3";
10654       if (strcmp (r[1], expected) != 0) {
10655         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10656         return -1;
10657       }
10658     }
10659     if (r[2] != NULL) {
10660       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10661       print_strings (r);
10662       return -1;
10663     }
10664     for (i = 0; r[i] != NULL; ++i)
10665       free (r[i]);
10666     free (r);
10667   }
10668   return 0;
10669 }
10670
10671 static int test_command_lines_3_skip (void)
10672 {
10673   const char *str;
10674
10675   str = getenv ("TEST_ONLY");
10676   if (str)
10677     return strstr (str, "command_lines") == NULL;
10678   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10679   if (str && strcmp (str, "1") == 0) return 1;
10680   str = getenv ("SKIP_TEST_COMMAND_LINES");
10681   if (str && strcmp (str, "1") == 0) return 1;
10682   return 0;
10683 }
10684
10685 static int test_command_lines_3 (void)
10686 {
10687   if (test_command_lines_3_skip ()) {
10688     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_3");
10689     return 0;
10690   }
10691
10692   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10693   {
10694     char device[] = "/dev/sda";
10695     int r;
10696     suppress_error = 0;
10697     r = guestfs_blockdev_setrw (g, device);
10698     if (r == -1)
10699       return -1;
10700   }
10701   {
10702     int r;
10703     suppress_error = 0;
10704     r = guestfs_umount_all (g);
10705     if (r == -1)
10706       return -1;
10707   }
10708   {
10709     int r;
10710     suppress_error = 0;
10711     r = guestfs_lvm_remove_all (g);
10712     if (r == -1)
10713       return -1;
10714   }
10715   {
10716     char device[] = "/dev/sda";
10717     char lines_0[] = ",";
10718     char *lines[] = {
10719       lines_0,
10720       NULL
10721     };
10722     int r;
10723     suppress_error = 0;
10724     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10725     if (r == -1)
10726       return -1;
10727   }
10728   {
10729     char fstype[] = "ext2";
10730     char device[] = "/dev/sda1";
10731     int r;
10732     suppress_error = 0;
10733     r = guestfs_mkfs (g, fstype, device);
10734     if (r == -1)
10735       return -1;
10736   }
10737   {
10738     char device[] = "/dev/sda1";
10739     char mountpoint[] = "/";
10740     int r;
10741     suppress_error = 0;
10742     r = guestfs_mount (g, device, mountpoint);
10743     if (r == -1)
10744       return -1;
10745   }
10746   /* TestOutputList for command_lines (3) */
10747   {
10748     char remotefilename[] = "/test-command";
10749     int r;
10750     suppress_error = 0;
10751     r = guestfs_upload (g, "test-command", remotefilename);
10752     if (r == -1)
10753       return -1;
10754   }
10755   {
10756     char path[] = "/test-command";
10757     int r;
10758     suppress_error = 0;
10759     r = guestfs_chmod (g, 493, path);
10760     if (r == -1)
10761       return -1;
10762   }
10763   {
10764     char arguments_0[] = "/test-command";
10765     char arguments_1[] = "4";
10766     char *arguments[] = {
10767       arguments_0,
10768       arguments_1,
10769       NULL
10770     };
10771     char **r;
10772     int i;
10773     suppress_error = 0;
10774     r = guestfs_command_lines (g, arguments);
10775     if (r == NULL)
10776       return -1;
10777     if (!r[0]) {
10778       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10779       print_strings (r);
10780       return -1;
10781     }
10782     {
10783       char expected[] = "";
10784       if (strcmp (r[0], expected) != 0) {
10785         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10786         return -1;
10787       }
10788     }
10789     if (!r[1]) {
10790       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10791       print_strings (r);
10792       return -1;
10793     }
10794     {
10795       char expected[] = "Result4";
10796       if (strcmp (r[1], expected) != 0) {
10797         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10798         return -1;
10799       }
10800     }
10801     if (r[2] != NULL) {
10802       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10803       print_strings (r);
10804       return -1;
10805     }
10806     for (i = 0; r[i] != NULL; ++i)
10807       free (r[i]);
10808     free (r);
10809   }
10810   return 0;
10811 }
10812
10813 static int test_command_lines_4_skip (void)
10814 {
10815   const char *str;
10816
10817   str = getenv ("TEST_ONLY");
10818   if (str)
10819     return strstr (str, "command_lines") == NULL;
10820   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10821   if (str && strcmp (str, "1") == 0) return 1;
10822   str = getenv ("SKIP_TEST_COMMAND_LINES");
10823   if (str && strcmp (str, "1") == 0) return 1;
10824   return 0;
10825 }
10826
10827 static int test_command_lines_4 (void)
10828 {
10829   if (test_command_lines_4_skip ()) {
10830     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_4");
10831     return 0;
10832   }
10833
10834   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10835   {
10836     char device[] = "/dev/sda";
10837     int r;
10838     suppress_error = 0;
10839     r = guestfs_blockdev_setrw (g, device);
10840     if (r == -1)
10841       return -1;
10842   }
10843   {
10844     int r;
10845     suppress_error = 0;
10846     r = guestfs_umount_all (g);
10847     if (r == -1)
10848       return -1;
10849   }
10850   {
10851     int r;
10852     suppress_error = 0;
10853     r = guestfs_lvm_remove_all (g);
10854     if (r == -1)
10855       return -1;
10856   }
10857   {
10858     char device[] = "/dev/sda";
10859     char lines_0[] = ",";
10860     char *lines[] = {
10861       lines_0,
10862       NULL
10863     };
10864     int r;
10865     suppress_error = 0;
10866     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10867     if (r == -1)
10868       return -1;
10869   }
10870   {
10871     char fstype[] = "ext2";
10872     char device[] = "/dev/sda1";
10873     int r;
10874     suppress_error = 0;
10875     r = guestfs_mkfs (g, fstype, device);
10876     if (r == -1)
10877       return -1;
10878   }
10879   {
10880     char device[] = "/dev/sda1";
10881     char mountpoint[] = "/";
10882     int r;
10883     suppress_error = 0;
10884     r = guestfs_mount (g, device, mountpoint);
10885     if (r == -1)
10886       return -1;
10887   }
10888   /* TestOutputList for command_lines (4) */
10889   {
10890     char remotefilename[] = "/test-command";
10891     int r;
10892     suppress_error = 0;
10893     r = guestfs_upload (g, "test-command", remotefilename);
10894     if (r == -1)
10895       return -1;
10896   }
10897   {
10898     char path[] = "/test-command";
10899     int r;
10900     suppress_error = 0;
10901     r = guestfs_chmod (g, 493, path);
10902     if (r == -1)
10903       return -1;
10904   }
10905   {
10906     char arguments_0[] = "/test-command";
10907     char arguments_1[] = "5";
10908     char *arguments[] = {
10909       arguments_0,
10910       arguments_1,
10911       NULL
10912     };
10913     char **r;
10914     int i;
10915     suppress_error = 0;
10916     r = guestfs_command_lines (g, arguments);
10917     if (r == NULL)
10918       return -1;
10919     if (!r[0]) {
10920       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10921       print_strings (r);
10922       return -1;
10923     }
10924     {
10925       char expected[] = "";
10926       if (strcmp (r[0], expected) != 0) {
10927         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10928         return -1;
10929       }
10930     }
10931     if (!r[1]) {
10932       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10933       print_strings (r);
10934       return -1;
10935     }
10936     {
10937       char expected[] = "Result5";
10938       if (strcmp (r[1], expected) != 0) {
10939         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10940         return -1;
10941       }
10942     }
10943     if (!r[2]) {
10944       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10945       print_strings (r);
10946       return -1;
10947     }
10948     {
10949       char expected[] = "";
10950       if (strcmp (r[2], expected) != 0) {
10951         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10952         return -1;
10953       }
10954     }
10955     if (r[3] != NULL) {
10956       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10957       print_strings (r);
10958       return -1;
10959     }
10960     for (i = 0; r[i] != NULL; ++i)
10961       free (r[i]);
10962     free (r);
10963   }
10964   return 0;
10965 }
10966
10967 static int test_command_lines_5_skip (void)
10968 {
10969   const char *str;
10970
10971   str = getenv ("TEST_ONLY");
10972   if (str)
10973     return strstr (str, "command_lines") == NULL;
10974   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10975   if (str && strcmp (str, "1") == 0) return 1;
10976   str = getenv ("SKIP_TEST_COMMAND_LINES");
10977   if (str && strcmp (str, "1") == 0) return 1;
10978   return 0;
10979 }
10980
10981 static int test_command_lines_5 (void)
10982 {
10983   if (test_command_lines_5_skip ()) {
10984     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_5");
10985     return 0;
10986   }
10987
10988   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10989   {
10990     char device[] = "/dev/sda";
10991     int r;
10992     suppress_error = 0;
10993     r = guestfs_blockdev_setrw (g, device);
10994     if (r == -1)
10995       return -1;
10996   }
10997   {
10998     int r;
10999     suppress_error = 0;
11000     r = guestfs_umount_all (g);
11001     if (r == -1)
11002       return -1;
11003   }
11004   {
11005     int r;
11006     suppress_error = 0;
11007     r = guestfs_lvm_remove_all (g);
11008     if (r == -1)
11009       return -1;
11010   }
11011   {
11012     char device[] = "/dev/sda";
11013     char lines_0[] = ",";
11014     char *lines[] = {
11015       lines_0,
11016       NULL
11017     };
11018     int r;
11019     suppress_error = 0;
11020     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11021     if (r == -1)
11022       return -1;
11023   }
11024   {
11025     char fstype[] = "ext2";
11026     char device[] = "/dev/sda1";
11027     int r;
11028     suppress_error = 0;
11029     r = guestfs_mkfs (g, fstype, device);
11030     if (r == -1)
11031       return -1;
11032   }
11033   {
11034     char device[] = "/dev/sda1";
11035     char mountpoint[] = "/";
11036     int r;
11037     suppress_error = 0;
11038     r = guestfs_mount (g, device, mountpoint);
11039     if (r == -1)
11040       return -1;
11041   }
11042   /* TestOutputList for command_lines (5) */
11043   {
11044     char remotefilename[] = "/test-command";
11045     int r;
11046     suppress_error = 0;
11047     r = guestfs_upload (g, "test-command", remotefilename);
11048     if (r == -1)
11049       return -1;
11050   }
11051   {
11052     char path[] = "/test-command";
11053     int r;
11054     suppress_error = 0;
11055     r = guestfs_chmod (g, 493, path);
11056     if (r == -1)
11057       return -1;
11058   }
11059   {
11060     char arguments_0[] = "/test-command";
11061     char arguments_1[] = "6";
11062     char *arguments[] = {
11063       arguments_0,
11064       arguments_1,
11065       NULL
11066     };
11067     char **r;
11068     int i;
11069     suppress_error = 0;
11070     r = guestfs_command_lines (g, arguments);
11071     if (r == NULL)
11072       return -1;
11073     if (!r[0]) {
11074       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11075       print_strings (r);
11076       return -1;
11077     }
11078     {
11079       char expected[] = "";
11080       if (strcmp (r[0], expected) != 0) {
11081         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11082         return -1;
11083       }
11084     }
11085     if (!r[1]) {
11086       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11087       print_strings (r);
11088       return -1;
11089     }
11090     {
11091       char expected[] = "";
11092       if (strcmp (r[1], expected) != 0) {
11093         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11094         return -1;
11095       }
11096     }
11097     if (!r[2]) {
11098       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11099       print_strings (r);
11100       return -1;
11101     }
11102     {
11103       char expected[] = "Result6";
11104       if (strcmp (r[2], expected) != 0) {
11105         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11106         return -1;
11107       }
11108     }
11109     if (!r[3]) {
11110       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11111       print_strings (r);
11112       return -1;
11113     }
11114     {
11115       char expected[] = "";
11116       if (strcmp (r[3], expected) != 0) {
11117         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11118         return -1;
11119       }
11120     }
11121     if (r[4] != NULL) {
11122       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
11123       print_strings (r);
11124       return -1;
11125     }
11126     for (i = 0; r[i] != NULL; ++i)
11127       free (r[i]);
11128     free (r);
11129   }
11130   return 0;
11131 }
11132
11133 static int test_command_lines_6_skip (void)
11134 {
11135   const char *str;
11136
11137   str = getenv ("TEST_ONLY");
11138   if (str)
11139     return strstr (str, "command_lines") == NULL;
11140   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
11141   if (str && strcmp (str, "1") == 0) return 1;
11142   str = getenv ("SKIP_TEST_COMMAND_LINES");
11143   if (str && strcmp (str, "1") == 0) return 1;
11144   return 0;
11145 }
11146
11147 static int test_command_lines_6 (void)
11148 {
11149   if (test_command_lines_6_skip ()) {
11150     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_6");
11151     return 0;
11152   }
11153
11154   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
11155   {
11156     char device[] = "/dev/sda";
11157     int r;
11158     suppress_error = 0;
11159     r = guestfs_blockdev_setrw (g, device);
11160     if (r == -1)
11161       return -1;
11162   }
11163   {
11164     int r;
11165     suppress_error = 0;
11166     r = guestfs_umount_all (g);
11167     if (r == -1)
11168       return -1;
11169   }
11170   {
11171     int r;
11172     suppress_error = 0;
11173     r = guestfs_lvm_remove_all (g);
11174     if (r == -1)
11175       return -1;
11176   }
11177   {
11178     char device[] = "/dev/sda";
11179     char lines_0[] = ",";
11180     char *lines[] = {
11181       lines_0,
11182       NULL
11183     };
11184     int r;
11185     suppress_error = 0;
11186     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11187     if (r == -1)
11188       return -1;
11189   }
11190   {
11191     char fstype[] = "ext2";
11192     char device[] = "/dev/sda1";
11193     int r;
11194     suppress_error = 0;
11195     r = guestfs_mkfs (g, fstype, device);
11196     if (r == -1)
11197       return -1;
11198   }
11199   {
11200     char device[] = "/dev/sda1";
11201     char mountpoint[] = "/";
11202     int r;
11203     suppress_error = 0;
11204     r = guestfs_mount (g, device, mountpoint);
11205     if (r == -1)
11206       return -1;
11207   }
11208   /* TestOutputList for command_lines (6) */
11209   {
11210     char remotefilename[] = "/test-command";
11211     int r;
11212     suppress_error = 0;
11213     r = guestfs_upload (g, "test-command", remotefilename);
11214     if (r == -1)
11215       return -1;
11216   }
11217   {
11218     char path[] = "/test-command";
11219     int r;
11220     suppress_error = 0;
11221     r = guestfs_chmod (g, 493, path);
11222     if (r == -1)
11223       return -1;
11224   }
11225   {
11226     char arguments_0[] = "/test-command";
11227     char arguments_1[] = "7";
11228     char *arguments[] = {
11229       arguments_0,
11230       arguments_1,
11231       NULL
11232     };
11233     char **r;
11234     int i;
11235     suppress_error = 0;
11236     r = guestfs_command_lines (g, arguments);
11237     if (r == NULL)
11238       return -1;
11239     if (r[0] != NULL) {
11240       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
11241       print_strings (r);
11242       return -1;
11243     }
11244     for (i = 0; r[i] != NULL; ++i)
11245       free (r[i]);
11246     free (r);
11247   }
11248   return 0;
11249 }
11250
11251 static int test_command_lines_7_skip (void)
11252 {
11253   const char *str;
11254
11255   str = getenv ("TEST_ONLY");
11256   if (str)
11257     return strstr (str, "command_lines") == NULL;
11258   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
11259   if (str && strcmp (str, "1") == 0) return 1;
11260   str = getenv ("SKIP_TEST_COMMAND_LINES");
11261   if (str && strcmp (str, "1") == 0) return 1;
11262   return 0;
11263 }
11264
11265 static int test_command_lines_7 (void)
11266 {
11267   if (test_command_lines_7_skip ()) {
11268     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_7");
11269     return 0;
11270   }
11271
11272   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
11273   {
11274     char device[] = "/dev/sda";
11275     int r;
11276     suppress_error = 0;
11277     r = guestfs_blockdev_setrw (g, device);
11278     if (r == -1)
11279       return -1;
11280   }
11281   {
11282     int r;
11283     suppress_error = 0;
11284     r = guestfs_umount_all (g);
11285     if (r == -1)
11286       return -1;
11287   }
11288   {
11289     int r;
11290     suppress_error = 0;
11291     r = guestfs_lvm_remove_all (g);
11292     if (r == -1)
11293       return -1;
11294   }
11295   {
11296     char device[] = "/dev/sda";
11297     char lines_0[] = ",";
11298     char *lines[] = {
11299       lines_0,
11300       NULL
11301     };
11302     int r;
11303     suppress_error = 0;
11304     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11305     if (r == -1)
11306       return -1;
11307   }
11308   {
11309     char fstype[] = "ext2";
11310     char device[] = "/dev/sda1";
11311     int r;
11312     suppress_error = 0;
11313     r = guestfs_mkfs (g, fstype, device);
11314     if (r == -1)
11315       return -1;
11316   }
11317   {
11318     char device[] = "/dev/sda1";
11319     char mountpoint[] = "/";
11320     int r;
11321     suppress_error = 0;
11322     r = guestfs_mount (g, device, mountpoint);
11323     if (r == -1)
11324       return -1;
11325   }
11326   /* TestOutputList for command_lines (7) */
11327   {
11328     char remotefilename[] = "/test-command";
11329     int r;
11330     suppress_error = 0;
11331     r = guestfs_upload (g, "test-command", remotefilename);
11332     if (r == -1)
11333       return -1;
11334   }
11335   {
11336     char path[] = "/test-command";
11337     int r;
11338     suppress_error = 0;
11339     r = guestfs_chmod (g, 493, path);
11340     if (r == -1)
11341       return -1;
11342   }
11343   {
11344     char arguments_0[] = "/test-command";
11345     char arguments_1[] = "8";
11346     char *arguments[] = {
11347       arguments_0,
11348       arguments_1,
11349       NULL
11350     };
11351     char **r;
11352     int i;
11353     suppress_error = 0;
11354     r = guestfs_command_lines (g, arguments);
11355     if (r == NULL)
11356       return -1;
11357     if (!r[0]) {
11358       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
11359       print_strings (r);
11360       return -1;
11361     }
11362     {
11363       char expected[] = "";
11364       if (strcmp (r[0], expected) != 0) {
11365         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11366         return -1;
11367       }
11368     }
11369     if (r[1] != NULL) {
11370       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
11371       print_strings (r);
11372       return -1;
11373     }
11374     for (i = 0; r[i] != NULL; ++i)
11375       free (r[i]);
11376     free (r);
11377   }
11378   return 0;
11379 }
11380
11381 static int test_command_lines_8_skip (void)
11382 {
11383   const char *str;
11384
11385   str = getenv ("TEST_ONLY");
11386   if (str)
11387     return strstr (str, "command_lines") == NULL;
11388   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
11389   if (str && strcmp (str, "1") == 0) return 1;
11390   str = getenv ("SKIP_TEST_COMMAND_LINES");
11391   if (str && strcmp (str, "1") == 0) return 1;
11392   return 0;
11393 }
11394
11395 static int test_command_lines_8 (void)
11396 {
11397   if (test_command_lines_8_skip ()) {
11398     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_8");
11399     return 0;
11400   }
11401
11402   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
11403   {
11404     char device[] = "/dev/sda";
11405     int r;
11406     suppress_error = 0;
11407     r = guestfs_blockdev_setrw (g, device);
11408     if (r == -1)
11409       return -1;
11410   }
11411   {
11412     int r;
11413     suppress_error = 0;
11414     r = guestfs_umount_all (g);
11415     if (r == -1)
11416       return -1;
11417   }
11418   {
11419     int r;
11420     suppress_error = 0;
11421     r = guestfs_lvm_remove_all (g);
11422     if (r == -1)
11423       return -1;
11424   }
11425   {
11426     char device[] = "/dev/sda";
11427     char lines_0[] = ",";
11428     char *lines[] = {
11429       lines_0,
11430       NULL
11431     };
11432     int r;
11433     suppress_error = 0;
11434     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11435     if (r == -1)
11436       return -1;
11437   }
11438   {
11439     char fstype[] = "ext2";
11440     char device[] = "/dev/sda1";
11441     int r;
11442     suppress_error = 0;
11443     r = guestfs_mkfs (g, fstype, device);
11444     if (r == -1)
11445       return -1;
11446   }
11447   {
11448     char device[] = "/dev/sda1";
11449     char mountpoint[] = "/";
11450     int r;
11451     suppress_error = 0;
11452     r = guestfs_mount (g, device, mountpoint);
11453     if (r == -1)
11454       return -1;
11455   }
11456   /* TestOutputList for command_lines (8) */
11457   {
11458     char remotefilename[] = "/test-command";
11459     int r;
11460     suppress_error = 0;
11461     r = guestfs_upload (g, "test-command", remotefilename);
11462     if (r == -1)
11463       return -1;
11464   }
11465   {
11466     char path[] = "/test-command";
11467     int r;
11468     suppress_error = 0;
11469     r = guestfs_chmod (g, 493, path);
11470     if (r == -1)
11471       return -1;
11472   }
11473   {
11474     char arguments_0[] = "/test-command";
11475     char arguments_1[] = "9";
11476     char *arguments[] = {
11477       arguments_0,
11478       arguments_1,
11479       NULL
11480     };
11481     char **r;
11482     int i;
11483     suppress_error = 0;
11484     r = guestfs_command_lines (g, arguments);
11485     if (r == NULL)
11486       return -1;
11487     if (!r[0]) {
11488       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11489       print_strings (r);
11490       return -1;
11491     }
11492     {
11493       char expected[] = "";
11494       if (strcmp (r[0], expected) != 0) {
11495         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11496         return -1;
11497       }
11498     }
11499     if (!r[1]) {
11500       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11501       print_strings (r);
11502       return -1;
11503     }
11504     {
11505       char expected[] = "";
11506       if (strcmp (r[1], expected) != 0) {
11507         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11508         return -1;
11509       }
11510     }
11511     if (r[2] != NULL) {
11512       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
11513       print_strings (r);
11514       return -1;
11515     }
11516     for (i = 0; r[i] != NULL; ++i)
11517       free (r[i]);
11518     free (r);
11519   }
11520   return 0;
11521 }
11522
11523 static int test_command_lines_9_skip (void)
11524 {
11525   const char *str;
11526
11527   str = getenv ("TEST_ONLY");
11528   if (str)
11529     return strstr (str, "command_lines") == NULL;
11530   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
11531   if (str && strcmp (str, "1") == 0) return 1;
11532   str = getenv ("SKIP_TEST_COMMAND_LINES");
11533   if (str && strcmp (str, "1") == 0) return 1;
11534   return 0;
11535 }
11536
11537 static int test_command_lines_9 (void)
11538 {
11539   if (test_command_lines_9_skip ()) {
11540     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_9");
11541     return 0;
11542   }
11543
11544   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
11545   {
11546     char device[] = "/dev/sda";
11547     int r;
11548     suppress_error = 0;
11549     r = guestfs_blockdev_setrw (g, device);
11550     if (r == -1)
11551       return -1;
11552   }
11553   {
11554     int r;
11555     suppress_error = 0;
11556     r = guestfs_umount_all (g);
11557     if (r == -1)
11558       return -1;
11559   }
11560   {
11561     int r;
11562     suppress_error = 0;
11563     r = guestfs_lvm_remove_all (g);
11564     if (r == -1)
11565       return -1;
11566   }
11567   {
11568     char device[] = "/dev/sda";
11569     char lines_0[] = ",";
11570     char *lines[] = {
11571       lines_0,
11572       NULL
11573     };
11574     int r;
11575     suppress_error = 0;
11576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11577     if (r == -1)
11578       return -1;
11579   }
11580   {
11581     char fstype[] = "ext2";
11582     char device[] = "/dev/sda1";
11583     int r;
11584     suppress_error = 0;
11585     r = guestfs_mkfs (g, fstype, device);
11586     if (r == -1)
11587       return -1;
11588   }
11589   {
11590     char device[] = "/dev/sda1";
11591     char mountpoint[] = "/";
11592     int r;
11593     suppress_error = 0;
11594     r = guestfs_mount (g, device, mountpoint);
11595     if (r == -1)
11596       return -1;
11597   }
11598   /* TestOutputList for command_lines (9) */
11599   {
11600     char remotefilename[] = "/test-command";
11601     int r;
11602     suppress_error = 0;
11603     r = guestfs_upload (g, "test-command", remotefilename);
11604     if (r == -1)
11605       return -1;
11606   }
11607   {
11608     char path[] = "/test-command";
11609     int r;
11610     suppress_error = 0;
11611     r = guestfs_chmod (g, 493, path);
11612     if (r == -1)
11613       return -1;
11614   }
11615   {
11616     char arguments_0[] = "/test-command";
11617     char arguments_1[] = "10";
11618     char *arguments[] = {
11619       arguments_0,
11620       arguments_1,
11621       NULL
11622     };
11623     char **r;
11624     int i;
11625     suppress_error = 0;
11626     r = guestfs_command_lines (g, arguments);
11627     if (r == NULL)
11628       return -1;
11629     if (!r[0]) {
11630       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11631       print_strings (r);
11632       return -1;
11633     }
11634     {
11635       char expected[] = "Result10-1";
11636       if (strcmp (r[0], expected) != 0) {
11637         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11638         return -1;
11639       }
11640     }
11641     if (!r[1]) {
11642       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11643       print_strings (r);
11644       return -1;
11645     }
11646     {
11647       char expected[] = "Result10-2";
11648       if (strcmp (r[1], expected) != 0) {
11649         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11650         return -1;
11651       }
11652     }
11653     if (r[2] != NULL) {
11654       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11655       print_strings (r);
11656       return -1;
11657     }
11658     for (i = 0; r[i] != NULL; ++i)
11659       free (r[i]);
11660     free (r);
11661   }
11662   return 0;
11663 }
11664
11665 static int test_command_lines_10_skip (void)
11666 {
11667   const char *str;
11668
11669   str = getenv ("TEST_ONLY");
11670   if (str)
11671     return strstr (str, "command_lines") == NULL;
11672   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11673   if (str && strcmp (str, "1") == 0) return 1;
11674   str = getenv ("SKIP_TEST_COMMAND_LINES");
11675   if (str && strcmp (str, "1") == 0) return 1;
11676   return 0;
11677 }
11678
11679 static int test_command_lines_10 (void)
11680 {
11681   if (test_command_lines_10_skip ()) {
11682     printf ("        %s skipped (reason: environment variable set)\n", "test_command_lines_10");
11683     return 0;
11684   }
11685
11686   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11687   {
11688     char device[] = "/dev/sda";
11689     int r;
11690     suppress_error = 0;
11691     r = guestfs_blockdev_setrw (g, device);
11692     if (r == -1)
11693       return -1;
11694   }
11695   {
11696     int r;
11697     suppress_error = 0;
11698     r = guestfs_umount_all (g);
11699     if (r == -1)
11700       return -1;
11701   }
11702   {
11703     int r;
11704     suppress_error = 0;
11705     r = guestfs_lvm_remove_all (g);
11706     if (r == -1)
11707       return -1;
11708   }
11709   {
11710     char device[] = "/dev/sda";
11711     char lines_0[] = ",";
11712     char *lines[] = {
11713       lines_0,
11714       NULL
11715     };
11716     int r;
11717     suppress_error = 0;
11718     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11719     if (r == -1)
11720       return -1;
11721   }
11722   {
11723     char fstype[] = "ext2";
11724     char device[] = "/dev/sda1";
11725     int r;
11726     suppress_error = 0;
11727     r = guestfs_mkfs (g, fstype, device);
11728     if (r == -1)
11729       return -1;
11730   }
11731   {
11732     char device[] = "/dev/sda1";
11733     char mountpoint[] = "/";
11734     int r;
11735     suppress_error = 0;
11736     r = guestfs_mount (g, device, mountpoint);
11737     if (r == -1)
11738       return -1;
11739   }
11740   /* TestOutputList for command_lines (10) */
11741   {
11742     char remotefilename[] = "/test-command";
11743     int r;
11744     suppress_error = 0;
11745     r = guestfs_upload (g, "test-command", remotefilename);
11746     if (r == -1)
11747       return -1;
11748   }
11749   {
11750     char path[] = "/test-command";
11751     int r;
11752     suppress_error = 0;
11753     r = guestfs_chmod (g, 493, path);
11754     if (r == -1)
11755       return -1;
11756   }
11757   {
11758     char arguments_0[] = "/test-command";
11759     char arguments_1[] = "11";
11760     char *arguments[] = {
11761       arguments_0,
11762       arguments_1,
11763       NULL
11764     };
11765     char **r;
11766     int i;
11767     suppress_error = 0;
11768     r = guestfs_command_lines (g, arguments);
11769     if (r == NULL)
11770       return -1;
11771     if (!r[0]) {
11772       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11773       print_strings (r);
11774       return -1;
11775     }
11776     {
11777       char expected[] = "Result11-1";
11778       if (strcmp (r[0], expected) != 0) {
11779         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11780         return -1;
11781       }
11782     }
11783     if (!r[1]) {
11784       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11785       print_strings (r);
11786       return -1;
11787     }
11788     {
11789       char expected[] = "Result11-2";
11790       if (strcmp (r[1], expected) != 0) {
11791         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11792         return -1;
11793       }
11794     }
11795     if (r[2] != NULL) {
11796       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11797       print_strings (r);
11798       return -1;
11799     }
11800     for (i = 0; r[i] != NULL; ++i)
11801       free (r[i]);
11802     free (r);
11803   }
11804   return 0;
11805 }
11806
11807 static int test_command_0_skip (void)
11808 {
11809   const char *str;
11810
11811   str = getenv ("TEST_ONLY");
11812   if (str)
11813     return strstr (str, "command") == NULL;
11814   str = getenv ("SKIP_TEST_COMMAND_0");
11815   if (str && strcmp (str, "1") == 0) return 1;
11816   str = getenv ("SKIP_TEST_COMMAND");
11817   if (str && strcmp (str, "1") == 0) return 1;
11818   return 0;
11819 }
11820
11821 static int test_command_0 (void)
11822 {
11823   if (test_command_0_skip ()) {
11824     printf ("        %s skipped (reason: environment variable set)\n", "test_command_0");
11825     return 0;
11826   }
11827
11828   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11829   {
11830     char device[] = "/dev/sda";
11831     int r;
11832     suppress_error = 0;
11833     r = guestfs_blockdev_setrw (g, device);
11834     if (r == -1)
11835       return -1;
11836   }
11837   {
11838     int r;
11839     suppress_error = 0;
11840     r = guestfs_umount_all (g);
11841     if (r == -1)
11842       return -1;
11843   }
11844   {
11845     int r;
11846     suppress_error = 0;
11847     r = guestfs_lvm_remove_all (g);
11848     if (r == -1)
11849       return -1;
11850   }
11851   {
11852     char device[] = "/dev/sda";
11853     char lines_0[] = ",";
11854     char *lines[] = {
11855       lines_0,
11856       NULL
11857     };
11858     int r;
11859     suppress_error = 0;
11860     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11861     if (r == -1)
11862       return -1;
11863   }
11864   {
11865     char fstype[] = "ext2";
11866     char device[] = "/dev/sda1";
11867     int r;
11868     suppress_error = 0;
11869     r = guestfs_mkfs (g, fstype, device);
11870     if (r == -1)
11871       return -1;
11872   }
11873   {
11874     char device[] = "/dev/sda1";
11875     char mountpoint[] = "/";
11876     int r;
11877     suppress_error = 0;
11878     r = guestfs_mount (g, device, mountpoint);
11879     if (r == -1)
11880       return -1;
11881   }
11882   /* TestOutput for command (0) */
11883   char expected[] = "Result1";
11884   {
11885     char remotefilename[] = "/test-command";
11886     int r;
11887     suppress_error = 0;
11888     r = guestfs_upload (g, "test-command", remotefilename);
11889     if (r == -1)
11890       return -1;
11891   }
11892   {
11893     char path[] = "/test-command";
11894     int r;
11895     suppress_error = 0;
11896     r = guestfs_chmod (g, 493, path);
11897     if (r == -1)
11898       return -1;
11899   }
11900   {
11901     char arguments_0[] = "/test-command";
11902     char arguments_1[] = "1";
11903     char *arguments[] = {
11904       arguments_0,
11905       arguments_1,
11906       NULL
11907     };
11908     char *r;
11909     suppress_error = 0;
11910     r = guestfs_command (g, arguments);
11911     if (r == NULL)
11912       return -1;
11913     if (strcmp (r, expected) != 0) {
11914       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11915       return -1;
11916     }
11917     free (r);
11918   }
11919   return 0;
11920 }
11921
11922 static int test_command_1_skip (void)
11923 {
11924   const char *str;
11925
11926   str = getenv ("TEST_ONLY");
11927   if (str)
11928     return strstr (str, "command") == NULL;
11929   str = getenv ("SKIP_TEST_COMMAND_1");
11930   if (str && strcmp (str, "1") == 0) return 1;
11931   str = getenv ("SKIP_TEST_COMMAND");
11932   if (str && strcmp (str, "1") == 0) return 1;
11933   return 0;
11934 }
11935
11936 static int test_command_1 (void)
11937 {
11938   if (test_command_1_skip ()) {
11939     printf ("        %s skipped (reason: environment variable set)\n", "test_command_1");
11940     return 0;
11941   }
11942
11943   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11944   {
11945     char device[] = "/dev/sda";
11946     int r;
11947     suppress_error = 0;
11948     r = guestfs_blockdev_setrw (g, device);
11949     if (r == -1)
11950       return -1;
11951   }
11952   {
11953     int r;
11954     suppress_error = 0;
11955     r = guestfs_umount_all (g);
11956     if (r == -1)
11957       return -1;
11958   }
11959   {
11960     int r;
11961     suppress_error = 0;
11962     r = guestfs_lvm_remove_all (g);
11963     if (r == -1)
11964       return -1;
11965   }
11966   {
11967     char device[] = "/dev/sda";
11968     char lines_0[] = ",";
11969     char *lines[] = {
11970       lines_0,
11971       NULL
11972     };
11973     int r;
11974     suppress_error = 0;
11975     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11976     if (r == -1)
11977       return -1;
11978   }
11979   {
11980     char fstype[] = "ext2";
11981     char device[] = "/dev/sda1";
11982     int r;
11983     suppress_error = 0;
11984     r = guestfs_mkfs (g, fstype, device);
11985     if (r == -1)
11986       return -1;
11987   }
11988   {
11989     char device[] = "/dev/sda1";
11990     char mountpoint[] = "/";
11991     int r;
11992     suppress_error = 0;
11993     r = guestfs_mount (g, device, mountpoint);
11994     if (r == -1)
11995       return -1;
11996   }
11997   /* TestOutput for command (1) */
11998   char expected[] = "Result2\n";
11999   {
12000     char remotefilename[] = "/test-command";
12001     int r;
12002     suppress_error = 0;
12003     r = guestfs_upload (g, "test-command", remotefilename);
12004     if (r == -1)
12005       return -1;
12006   }
12007   {
12008     char path[] = "/test-command";
12009     int r;
12010     suppress_error = 0;
12011     r = guestfs_chmod (g, 493, path);
12012     if (r == -1)
12013       return -1;
12014   }
12015   {
12016     char arguments_0[] = "/test-command";
12017     char arguments_1[] = "2";
12018     char *arguments[] = {
12019       arguments_0,
12020       arguments_1,
12021       NULL
12022     };
12023     char *r;
12024     suppress_error = 0;
12025     r = guestfs_command (g, arguments);
12026     if (r == NULL)
12027       return -1;
12028     if (strcmp (r, expected) != 0) {
12029       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
12030       return -1;
12031     }
12032     free (r);
12033   }
12034   return 0;
12035 }
12036
12037 static int test_command_2_skip (void)
12038 {
12039   const char *str;
12040
12041   str = getenv ("TEST_ONLY");
12042   if (str)
12043     return strstr (str, "command") == NULL;
12044   str = getenv ("SKIP_TEST_COMMAND_2");
12045   if (str && strcmp (str, "1") == 0) return 1;
12046   str = getenv ("SKIP_TEST_COMMAND");
12047   if (str && strcmp (str, "1") == 0) return 1;
12048   return 0;
12049 }
12050
12051 static int test_command_2 (void)
12052 {
12053   if (test_command_2_skip ()) {
12054     printf ("        %s skipped (reason: environment variable set)\n", "test_command_2");
12055     return 0;
12056   }
12057
12058   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
12059   {
12060     char device[] = "/dev/sda";
12061     int r;
12062     suppress_error = 0;
12063     r = guestfs_blockdev_setrw (g, device);
12064     if (r == -1)
12065       return -1;
12066   }
12067   {
12068     int r;
12069     suppress_error = 0;
12070     r = guestfs_umount_all (g);
12071     if (r == -1)
12072       return -1;
12073   }
12074   {
12075     int r;
12076     suppress_error = 0;
12077     r = guestfs_lvm_remove_all (g);
12078     if (r == -1)
12079       return -1;
12080   }
12081   {
12082     char device[] = "/dev/sda";
12083     char lines_0[] = ",";
12084     char *lines[] = {
12085       lines_0,
12086       NULL
12087     };
12088     int r;
12089     suppress_error = 0;
12090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12091     if (r == -1)
12092       return -1;
12093   }
12094   {
12095     char fstype[] = "ext2";
12096     char device[] = "/dev/sda1";
12097     int r;
12098     suppress_error = 0;
12099     r = guestfs_mkfs (g, fstype, device);
12100     if (r == -1)
12101       return -1;
12102   }
12103   {
12104     char device[] = "/dev/sda1";
12105     char mountpoint[] = "/";
12106     int r;
12107     suppress_error = 0;
12108     r = guestfs_mount (g, device, mountpoint);
12109     if (r == -1)
12110       return -1;
12111   }
12112   /* TestOutput for command (2) */
12113   char expected[] = "\nResult3";
12114   {
12115     char remotefilename[] = "/test-command";
12116     int r;
12117     suppress_error = 0;
12118     r = guestfs_upload (g, "test-command", remotefilename);
12119     if (r == -1)
12120       return -1;
12121   }
12122   {
12123     char path[] = "/test-command";
12124     int r;
12125     suppress_error = 0;
12126     r = guestfs_chmod (g, 493, path);
12127     if (r == -1)
12128       return -1;
12129   }
12130   {
12131     char arguments_0[] = "/test-command";
12132     char arguments_1[] = "3";
12133     char *arguments[] = {
12134       arguments_0,
12135       arguments_1,
12136       NULL
12137     };
12138     char *r;
12139     suppress_error = 0;
12140     r = guestfs_command (g, arguments);
12141     if (r == NULL)
12142       return -1;
12143     if (strcmp (r, expected) != 0) {
12144       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
12145       return -1;
12146     }
12147     free (r);
12148   }
12149   return 0;
12150 }
12151
12152 static int test_command_3_skip (void)
12153 {
12154   const char *str;
12155
12156   str = getenv ("TEST_ONLY");
12157   if (str)
12158     return strstr (str, "command") == NULL;
12159   str = getenv ("SKIP_TEST_COMMAND_3");
12160   if (str && strcmp (str, "1") == 0) return 1;
12161   str = getenv ("SKIP_TEST_COMMAND");
12162   if (str && strcmp (str, "1") == 0) return 1;
12163   return 0;
12164 }
12165
12166 static int test_command_3 (void)
12167 {
12168   if (test_command_3_skip ()) {
12169     printf ("        %s skipped (reason: environment variable set)\n", "test_command_3");
12170     return 0;
12171   }
12172
12173   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
12174   {
12175     char device[] = "/dev/sda";
12176     int r;
12177     suppress_error = 0;
12178     r = guestfs_blockdev_setrw (g, device);
12179     if (r == -1)
12180       return -1;
12181   }
12182   {
12183     int r;
12184     suppress_error = 0;
12185     r = guestfs_umount_all (g);
12186     if (r == -1)
12187       return -1;
12188   }
12189   {
12190     int r;
12191     suppress_error = 0;
12192     r = guestfs_lvm_remove_all (g);
12193     if (r == -1)
12194       return -1;
12195   }
12196   {
12197     char device[] = "/dev/sda";
12198     char lines_0[] = ",";
12199     char *lines[] = {
12200       lines_0,
12201       NULL
12202     };
12203     int r;
12204     suppress_error = 0;
12205     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12206     if (r == -1)
12207       return -1;
12208   }
12209   {
12210     char fstype[] = "ext2";
12211     char device[] = "/dev/sda1";
12212     int r;
12213     suppress_error = 0;
12214     r = guestfs_mkfs (g, fstype, device);
12215     if (r == -1)
12216       return -1;
12217   }
12218   {
12219     char device[] = "/dev/sda1";
12220     char mountpoint[] = "/";
12221     int r;
12222     suppress_error = 0;
12223     r = guestfs_mount (g, device, mountpoint);
12224     if (r == -1)
12225       return -1;
12226   }
12227   /* TestOutput for command (3) */
12228   char expected[] = "\nResult4\n";
12229   {
12230     char remotefilename[] = "/test-command";
12231     int r;
12232     suppress_error = 0;
12233     r = guestfs_upload (g, "test-command", remotefilename);
12234     if (r == -1)
12235       return -1;
12236   }
12237   {
12238     char path[] = "/test-command";
12239     int r;
12240     suppress_error = 0;
12241     r = guestfs_chmod (g, 493, path);
12242     if (r == -1)
12243       return -1;
12244   }
12245   {
12246     char arguments_0[] = "/test-command";
12247     char arguments_1[] = "4";
12248     char *arguments[] = {
12249       arguments_0,
12250       arguments_1,
12251       NULL
12252     };
12253     char *r;
12254     suppress_error = 0;
12255     r = guestfs_command (g, arguments);
12256     if (r == NULL)
12257       return -1;
12258     if (strcmp (r, expected) != 0) {
12259       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
12260       return -1;
12261     }
12262     free (r);
12263   }
12264   return 0;
12265 }
12266
12267 static int test_command_4_skip (void)
12268 {
12269   const char *str;
12270
12271   str = getenv ("TEST_ONLY");
12272   if (str)
12273     return strstr (str, "command") == NULL;
12274   str = getenv ("SKIP_TEST_COMMAND_4");
12275   if (str && strcmp (str, "1") == 0) return 1;
12276   str = getenv ("SKIP_TEST_COMMAND");
12277   if (str && strcmp (str, "1") == 0) return 1;
12278   return 0;
12279 }
12280
12281 static int test_command_4 (void)
12282 {
12283   if (test_command_4_skip ()) {
12284     printf ("        %s skipped (reason: environment variable set)\n", "test_command_4");
12285     return 0;
12286   }
12287
12288   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
12289   {
12290     char device[] = "/dev/sda";
12291     int r;
12292     suppress_error = 0;
12293     r = guestfs_blockdev_setrw (g, device);
12294     if (r == -1)
12295       return -1;
12296   }
12297   {
12298     int r;
12299     suppress_error = 0;
12300     r = guestfs_umount_all (g);
12301     if (r == -1)
12302       return -1;
12303   }
12304   {
12305     int r;
12306     suppress_error = 0;
12307     r = guestfs_lvm_remove_all (g);
12308     if (r == -1)
12309       return -1;
12310   }
12311   {
12312     char device[] = "/dev/sda";
12313     char lines_0[] = ",";
12314     char *lines[] = {
12315       lines_0,
12316       NULL
12317     };
12318     int r;
12319     suppress_error = 0;
12320     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12321     if (r == -1)
12322       return -1;
12323   }
12324   {
12325     char fstype[] = "ext2";
12326     char device[] = "/dev/sda1";
12327     int r;
12328     suppress_error = 0;
12329     r = guestfs_mkfs (g, fstype, device);
12330     if (r == -1)
12331       return -1;
12332   }
12333   {
12334     char device[] = "/dev/sda1";
12335     char mountpoint[] = "/";
12336     int r;
12337     suppress_error = 0;
12338     r = guestfs_mount (g, device, mountpoint);
12339     if (r == -1)
12340       return -1;
12341   }
12342   /* TestOutput for command (4) */
12343   char expected[] = "\nResult5\n\n";
12344   {
12345     char remotefilename[] = "/test-command";
12346     int r;
12347     suppress_error = 0;
12348     r = guestfs_upload (g, "test-command", remotefilename);
12349     if (r == -1)
12350       return -1;
12351   }
12352   {
12353     char path[] = "/test-command";
12354     int r;
12355     suppress_error = 0;
12356     r = guestfs_chmod (g, 493, path);
12357     if (r == -1)
12358       return -1;
12359   }
12360   {
12361     char arguments_0[] = "/test-command";
12362     char arguments_1[] = "5";
12363     char *arguments[] = {
12364       arguments_0,
12365       arguments_1,
12366       NULL
12367     };
12368     char *r;
12369     suppress_error = 0;
12370     r = guestfs_command (g, arguments);
12371     if (r == NULL)
12372       return -1;
12373     if (strcmp (r, expected) != 0) {
12374       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
12375       return -1;
12376     }
12377     free (r);
12378   }
12379   return 0;
12380 }
12381
12382 static int test_command_5_skip (void)
12383 {
12384   const char *str;
12385
12386   str = getenv ("TEST_ONLY");
12387   if (str)
12388     return strstr (str, "command") == NULL;
12389   str = getenv ("SKIP_TEST_COMMAND_5");
12390   if (str && strcmp (str, "1") == 0) return 1;
12391   str = getenv ("SKIP_TEST_COMMAND");
12392   if (str && strcmp (str, "1") == 0) return 1;
12393   return 0;
12394 }
12395
12396 static int test_command_5 (void)
12397 {
12398   if (test_command_5_skip ()) {
12399     printf ("        %s skipped (reason: environment variable set)\n", "test_command_5");
12400     return 0;
12401   }
12402
12403   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
12404   {
12405     char device[] = "/dev/sda";
12406     int r;
12407     suppress_error = 0;
12408     r = guestfs_blockdev_setrw (g, device);
12409     if (r == -1)
12410       return -1;
12411   }
12412   {
12413     int r;
12414     suppress_error = 0;
12415     r = guestfs_umount_all (g);
12416     if (r == -1)
12417       return -1;
12418   }
12419   {
12420     int r;
12421     suppress_error = 0;
12422     r = guestfs_lvm_remove_all (g);
12423     if (r == -1)
12424       return -1;
12425   }
12426   {
12427     char device[] = "/dev/sda";
12428     char lines_0[] = ",";
12429     char *lines[] = {
12430       lines_0,
12431       NULL
12432     };
12433     int r;
12434     suppress_error = 0;
12435     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12436     if (r == -1)
12437       return -1;
12438   }
12439   {
12440     char fstype[] = "ext2";
12441     char device[] = "/dev/sda1";
12442     int r;
12443     suppress_error = 0;
12444     r = guestfs_mkfs (g, fstype, device);
12445     if (r == -1)
12446       return -1;
12447   }
12448   {
12449     char device[] = "/dev/sda1";
12450     char mountpoint[] = "/";
12451     int r;
12452     suppress_error = 0;
12453     r = guestfs_mount (g, device, mountpoint);
12454     if (r == -1)
12455       return -1;
12456   }
12457   /* TestOutput for command (5) */
12458   char expected[] = "\n\nResult6\n\n";
12459   {
12460     char remotefilename[] = "/test-command";
12461     int r;
12462     suppress_error = 0;
12463     r = guestfs_upload (g, "test-command", remotefilename);
12464     if (r == -1)
12465       return -1;
12466   }
12467   {
12468     char path[] = "/test-command";
12469     int r;
12470     suppress_error = 0;
12471     r = guestfs_chmod (g, 493, path);
12472     if (r == -1)
12473       return -1;
12474   }
12475   {
12476     char arguments_0[] = "/test-command";
12477     char arguments_1[] = "6";
12478     char *arguments[] = {
12479       arguments_0,
12480       arguments_1,
12481       NULL
12482     };
12483     char *r;
12484     suppress_error = 0;
12485     r = guestfs_command (g, arguments);
12486     if (r == NULL)
12487       return -1;
12488     if (strcmp (r, expected) != 0) {
12489       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
12490       return -1;
12491     }
12492     free (r);
12493   }
12494   return 0;
12495 }
12496
12497 static int test_command_6_skip (void)
12498 {
12499   const char *str;
12500
12501   str = getenv ("TEST_ONLY");
12502   if (str)
12503     return strstr (str, "command") == NULL;
12504   str = getenv ("SKIP_TEST_COMMAND_6");
12505   if (str && strcmp (str, "1") == 0) return 1;
12506   str = getenv ("SKIP_TEST_COMMAND");
12507   if (str && strcmp (str, "1") == 0) return 1;
12508   return 0;
12509 }
12510
12511 static int test_command_6 (void)
12512 {
12513   if (test_command_6_skip ()) {
12514     printf ("        %s skipped (reason: environment variable set)\n", "test_command_6");
12515     return 0;
12516   }
12517
12518   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
12519   {
12520     char device[] = "/dev/sda";
12521     int r;
12522     suppress_error = 0;
12523     r = guestfs_blockdev_setrw (g, device);
12524     if (r == -1)
12525       return -1;
12526   }
12527   {
12528     int r;
12529     suppress_error = 0;
12530     r = guestfs_umount_all (g);
12531     if (r == -1)
12532       return -1;
12533   }
12534   {
12535     int r;
12536     suppress_error = 0;
12537     r = guestfs_lvm_remove_all (g);
12538     if (r == -1)
12539       return -1;
12540   }
12541   {
12542     char device[] = "/dev/sda";
12543     char lines_0[] = ",";
12544     char *lines[] = {
12545       lines_0,
12546       NULL
12547     };
12548     int r;
12549     suppress_error = 0;
12550     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12551     if (r == -1)
12552       return -1;
12553   }
12554   {
12555     char fstype[] = "ext2";
12556     char device[] = "/dev/sda1";
12557     int r;
12558     suppress_error = 0;
12559     r = guestfs_mkfs (g, fstype, device);
12560     if (r == -1)
12561       return -1;
12562   }
12563   {
12564     char device[] = "/dev/sda1";
12565     char mountpoint[] = "/";
12566     int r;
12567     suppress_error = 0;
12568     r = guestfs_mount (g, device, mountpoint);
12569     if (r == -1)
12570       return -1;
12571   }
12572   /* TestOutput for command (6) */
12573   char expected[] = "";
12574   {
12575     char remotefilename[] = "/test-command";
12576     int r;
12577     suppress_error = 0;
12578     r = guestfs_upload (g, "test-command", remotefilename);
12579     if (r == -1)
12580       return -1;
12581   }
12582   {
12583     char path[] = "/test-command";
12584     int r;
12585     suppress_error = 0;
12586     r = guestfs_chmod (g, 493, path);
12587     if (r == -1)
12588       return -1;
12589   }
12590   {
12591     char arguments_0[] = "/test-command";
12592     char arguments_1[] = "7";
12593     char *arguments[] = {
12594       arguments_0,
12595       arguments_1,
12596       NULL
12597     };
12598     char *r;
12599     suppress_error = 0;
12600     r = guestfs_command (g, arguments);
12601     if (r == NULL)
12602       return -1;
12603     if (strcmp (r, expected) != 0) {
12604       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
12605       return -1;
12606     }
12607     free (r);
12608   }
12609   return 0;
12610 }
12611
12612 static int test_command_7_skip (void)
12613 {
12614   const char *str;
12615
12616   str = getenv ("TEST_ONLY");
12617   if (str)
12618     return strstr (str, "command") == NULL;
12619   str = getenv ("SKIP_TEST_COMMAND_7");
12620   if (str && strcmp (str, "1") == 0) return 1;
12621   str = getenv ("SKIP_TEST_COMMAND");
12622   if (str && strcmp (str, "1") == 0) return 1;
12623   return 0;
12624 }
12625
12626 static int test_command_7 (void)
12627 {
12628   if (test_command_7_skip ()) {
12629     printf ("        %s skipped (reason: environment variable set)\n", "test_command_7");
12630     return 0;
12631   }
12632
12633   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
12634   {
12635     char device[] = "/dev/sda";
12636     int r;
12637     suppress_error = 0;
12638     r = guestfs_blockdev_setrw (g, device);
12639     if (r == -1)
12640       return -1;
12641   }
12642   {
12643     int r;
12644     suppress_error = 0;
12645     r = guestfs_umount_all (g);
12646     if (r == -1)
12647       return -1;
12648   }
12649   {
12650     int r;
12651     suppress_error = 0;
12652     r = guestfs_lvm_remove_all (g);
12653     if (r == -1)
12654       return -1;
12655   }
12656   {
12657     char device[] = "/dev/sda";
12658     char lines_0[] = ",";
12659     char *lines[] = {
12660       lines_0,
12661       NULL
12662     };
12663     int r;
12664     suppress_error = 0;
12665     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12666     if (r == -1)
12667       return -1;
12668   }
12669   {
12670     char fstype[] = "ext2";
12671     char device[] = "/dev/sda1";
12672     int r;
12673     suppress_error = 0;
12674     r = guestfs_mkfs (g, fstype, device);
12675     if (r == -1)
12676       return -1;
12677   }
12678   {
12679     char device[] = "/dev/sda1";
12680     char mountpoint[] = "/";
12681     int r;
12682     suppress_error = 0;
12683     r = guestfs_mount (g, device, mountpoint);
12684     if (r == -1)
12685       return -1;
12686   }
12687   /* TestOutput for command (7) */
12688   char expected[] = "\n";
12689   {
12690     char remotefilename[] = "/test-command";
12691     int r;
12692     suppress_error = 0;
12693     r = guestfs_upload (g, "test-command", remotefilename);
12694     if (r == -1)
12695       return -1;
12696   }
12697   {
12698     char path[] = "/test-command";
12699     int r;
12700     suppress_error = 0;
12701     r = guestfs_chmod (g, 493, path);
12702     if (r == -1)
12703       return -1;
12704   }
12705   {
12706     char arguments_0[] = "/test-command";
12707     char arguments_1[] = "8";
12708     char *arguments[] = {
12709       arguments_0,
12710       arguments_1,
12711       NULL
12712     };
12713     char *r;
12714     suppress_error = 0;
12715     r = guestfs_command (g, arguments);
12716     if (r == NULL)
12717       return -1;
12718     if (strcmp (r, expected) != 0) {
12719       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12720       return -1;
12721     }
12722     free (r);
12723   }
12724   return 0;
12725 }
12726
12727 static int test_command_8_skip (void)
12728 {
12729   const char *str;
12730
12731   str = getenv ("TEST_ONLY");
12732   if (str)
12733     return strstr (str, "command") == NULL;
12734   str = getenv ("SKIP_TEST_COMMAND_8");
12735   if (str && strcmp (str, "1") == 0) return 1;
12736   str = getenv ("SKIP_TEST_COMMAND");
12737   if (str && strcmp (str, "1") == 0) return 1;
12738   return 0;
12739 }
12740
12741 static int test_command_8 (void)
12742 {
12743   if (test_command_8_skip ()) {
12744     printf ("        %s skipped (reason: environment variable set)\n", "test_command_8");
12745     return 0;
12746   }
12747
12748   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12749   {
12750     char device[] = "/dev/sda";
12751     int r;
12752     suppress_error = 0;
12753     r = guestfs_blockdev_setrw (g, device);
12754     if (r == -1)
12755       return -1;
12756   }
12757   {
12758     int r;
12759     suppress_error = 0;
12760     r = guestfs_umount_all (g);
12761     if (r == -1)
12762       return -1;
12763   }
12764   {
12765     int r;
12766     suppress_error = 0;
12767     r = guestfs_lvm_remove_all (g);
12768     if (r == -1)
12769       return -1;
12770   }
12771   {
12772     char device[] = "/dev/sda";
12773     char lines_0[] = ",";
12774     char *lines[] = {
12775       lines_0,
12776       NULL
12777     };
12778     int r;
12779     suppress_error = 0;
12780     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12781     if (r == -1)
12782       return -1;
12783   }
12784   {
12785     char fstype[] = "ext2";
12786     char device[] = "/dev/sda1";
12787     int r;
12788     suppress_error = 0;
12789     r = guestfs_mkfs (g, fstype, device);
12790     if (r == -1)
12791       return -1;
12792   }
12793   {
12794     char device[] = "/dev/sda1";
12795     char mountpoint[] = "/";
12796     int r;
12797     suppress_error = 0;
12798     r = guestfs_mount (g, device, mountpoint);
12799     if (r == -1)
12800       return -1;
12801   }
12802   /* TestOutput for command (8) */
12803   char expected[] = "\n\n";
12804   {
12805     char remotefilename[] = "/test-command";
12806     int r;
12807     suppress_error = 0;
12808     r = guestfs_upload (g, "test-command", remotefilename);
12809     if (r == -1)
12810       return -1;
12811   }
12812   {
12813     char path[] = "/test-command";
12814     int r;
12815     suppress_error = 0;
12816     r = guestfs_chmod (g, 493, path);
12817     if (r == -1)
12818       return -1;
12819   }
12820   {
12821     char arguments_0[] = "/test-command";
12822     char arguments_1[] = "9";
12823     char *arguments[] = {
12824       arguments_0,
12825       arguments_1,
12826       NULL
12827     };
12828     char *r;
12829     suppress_error = 0;
12830     r = guestfs_command (g, arguments);
12831     if (r == NULL)
12832       return -1;
12833     if (strcmp (r, expected) != 0) {
12834       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12835       return -1;
12836     }
12837     free (r);
12838   }
12839   return 0;
12840 }
12841
12842 static int test_command_9_skip (void)
12843 {
12844   const char *str;
12845
12846   str = getenv ("TEST_ONLY");
12847   if (str)
12848     return strstr (str, "command") == NULL;
12849   str = getenv ("SKIP_TEST_COMMAND_9");
12850   if (str && strcmp (str, "1") == 0) return 1;
12851   str = getenv ("SKIP_TEST_COMMAND");
12852   if (str && strcmp (str, "1") == 0) return 1;
12853   return 0;
12854 }
12855
12856 static int test_command_9 (void)
12857 {
12858   if (test_command_9_skip ()) {
12859     printf ("        %s skipped (reason: environment variable set)\n", "test_command_9");
12860     return 0;
12861   }
12862
12863   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12864   {
12865     char device[] = "/dev/sda";
12866     int r;
12867     suppress_error = 0;
12868     r = guestfs_blockdev_setrw (g, device);
12869     if (r == -1)
12870       return -1;
12871   }
12872   {
12873     int r;
12874     suppress_error = 0;
12875     r = guestfs_umount_all (g);
12876     if (r == -1)
12877       return -1;
12878   }
12879   {
12880     int r;
12881     suppress_error = 0;
12882     r = guestfs_lvm_remove_all (g);
12883     if (r == -1)
12884       return -1;
12885   }
12886   {
12887     char device[] = "/dev/sda";
12888     char lines_0[] = ",";
12889     char *lines[] = {
12890       lines_0,
12891       NULL
12892     };
12893     int r;
12894     suppress_error = 0;
12895     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12896     if (r == -1)
12897       return -1;
12898   }
12899   {
12900     char fstype[] = "ext2";
12901     char device[] = "/dev/sda1";
12902     int r;
12903     suppress_error = 0;
12904     r = guestfs_mkfs (g, fstype, device);
12905     if (r == -1)
12906       return -1;
12907   }
12908   {
12909     char device[] = "/dev/sda1";
12910     char mountpoint[] = "/";
12911     int r;
12912     suppress_error = 0;
12913     r = guestfs_mount (g, device, mountpoint);
12914     if (r == -1)
12915       return -1;
12916   }
12917   /* TestOutput for command (9) */
12918   char expected[] = "Result10-1\nResult10-2\n";
12919   {
12920     char remotefilename[] = "/test-command";
12921     int r;
12922     suppress_error = 0;
12923     r = guestfs_upload (g, "test-command", remotefilename);
12924     if (r == -1)
12925       return -1;
12926   }
12927   {
12928     char path[] = "/test-command";
12929     int r;
12930     suppress_error = 0;
12931     r = guestfs_chmod (g, 493, path);
12932     if (r == -1)
12933       return -1;
12934   }
12935   {
12936     char arguments_0[] = "/test-command";
12937     char arguments_1[] = "10";
12938     char *arguments[] = {
12939       arguments_0,
12940       arguments_1,
12941       NULL
12942     };
12943     char *r;
12944     suppress_error = 0;
12945     r = guestfs_command (g, arguments);
12946     if (r == NULL)
12947       return -1;
12948     if (strcmp (r, expected) != 0) {
12949       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12950       return -1;
12951     }
12952     free (r);
12953   }
12954   return 0;
12955 }
12956
12957 static int test_command_10_skip (void)
12958 {
12959   const char *str;
12960
12961   str = getenv ("TEST_ONLY");
12962   if (str)
12963     return strstr (str, "command") == NULL;
12964   str = getenv ("SKIP_TEST_COMMAND_10");
12965   if (str && strcmp (str, "1") == 0) return 1;
12966   str = getenv ("SKIP_TEST_COMMAND");
12967   if (str && strcmp (str, "1") == 0) return 1;
12968   return 0;
12969 }
12970
12971 static int test_command_10 (void)
12972 {
12973   if (test_command_10_skip ()) {
12974     printf ("        %s skipped (reason: environment variable set)\n", "test_command_10");
12975     return 0;
12976   }
12977
12978   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12979   {
12980     char device[] = "/dev/sda";
12981     int r;
12982     suppress_error = 0;
12983     r = guestfs_blockdev_setrw (g, device);
12984     if (r == -1)
12985       return -1;
12986   }
12987   {
12988     int r;
12989     suppress_error = 0;
12990     r = guestfs_umount_all (g);
12991     if (r == -1)
12992       return -1;
12993   }
12994   {
12995     int r;
12996     suppress_error = 0;
12997     r = guestfs_lvm_remove_all (g);
12998     if (r == -1)
12999       return -1;
13000   }
13001   {
13002     char device[] = "/dev/sda";
13003     char lines_0[] = ",";
13004     char *lines[] = {
13005       lines_0,
13006       NULL
13007     };
13008     int r;
13009     suppress_error = 0;
13010     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13011     if (r == -1)
13012       return -1;
13013   }
13014   {
13015     char fstype[] = "ext2";
13016     char device[] = "/dev/sda1";
13017     int r;
13018     suppress_error = 0;
13019     r = guestfs_mkfs (g, fstype, device);
13020     if (r == -1)
13021       return -1;
13022   }
13023   {
13024     char device[] = "/dev/sda1";
13025     char mountpoint[] = "/";
13026     int r;
13027     suppress_error = 0;
13028     r = guestfs_mount (g, device, mountpoint);
13029     if (r == -1)
13030       return -1;
13031   }
13032   /* TestOutput for command (10) */
13033   char expected[] = "Result11-1\nResult11-2";
13034   {
13035     char remotefilename[] = "/test-command";
13036     int r;
13037     suppress_error = 0;
13038     r = guestfs_upload (g, "test-command", remotefilename);
13039     if (r == -1)
13040       return -1;
13041   }
13042   {
13043     char path[] = "/test-command";
13044     int r;
13045     suppress_error = 0;
13046     r = guestfs_chmod (g, 493, path);
13047     if (r == -1)
13048       return -1;
13049   }
13050   {
13051     char arguments_0[] = "/test-command";
13052     char arguments_1[] = "11";
13053     char *arguments[] = {
13054       arguments_0,
13055       arguments_1,
13056       NULL
13057     };
13058     char *r;
13059     suppress_error = 0;
13060     r = guestfs_command (g, arguments);
13061     if (r == NULL)
13062       return -1;
13063     if (strcmp (r, expected) != 0) {
13064       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
13065       return -1;
13066     }
13067     free (r);
13068   }
13069   return 0;
13070 }
13071
13072 static int test_command_11_skip (void)
13073 {
13074   const char *str;
13075
13076   str = getenv ("TEST_ONLY");
13077   if (str)
13078     return strstr (str, "command") == NULL;
13079   str = getenv ("SKIP_TEST_COMMAND_11");
13080   if (str && strcmp (str, "1") == 0) return 1;
13081   str = getenv ("SKIP_TEST_COMMAND");
13082   if (str && strcmp (str, "1") == 0) return 1;
13083   return 0;
13084 }
13085
13086 static int test_command_11 (void)
13087 {
13088   if (test_command_11_skip ()) {
13089     printf ("        %s skipped (reason: environment variable set)\n", "test_command_11");
13090     return 0;
13091   }
13092
13093   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
13094   {
13095     char device[] = "/dev/sda";
13096     int r;
13097     suppress_error = 0;
13098     r = guestfs_blockdev_setrw (g, device);
13099     if (r == -1)
13100       return -1;
13101   }
13102   {
13103     int r;
13104     suppress_error = 0;
13105     r = guestfs_umount_all (g);
13106     if (r == -1)
13107       return -1;
13108   }
13109   {
13110     int r;
13111     suppress_error = 0;
13112     r = guestfs_lvm_remove_all (g);
13113     if (r == -1)
13114       return -1;
13115   }
13116   {
13117     char device[] = "/dev/sda";
13118     char lines_0[] = ",";
13119     char *lines[] = {
13120       lines_0,
13121       NULL
13122     };
13123     int r;
13124     suppress_error = 0;
13125     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13126     if (r == -1)
13127       return -1;
13128   }
13129   {
13130     char fstype[] = "ext2";
13131     char device[] = "/dev/sda1";
13132     int r;
13133     suppress_error = 0;
13134     r = guestfs_mkfs (g, fstype, device);
13135     if (r == -1)
13136       return -1;
13137   }
13138   {
13139     char device[] = "/dev/sda1";
13140     char mountpoint[] = "/";
13141     int r;
13142     suppress_error = 0;
13143     r = guestfs_mount (g, device, mountpoint);
13144     if (r == -1)
13145       return -1;
13146   }
13147   /* TestLastFail for command (11) */
13148   {
13149     char remotefilename[] = "/test-command";
13150     int r;
13151     suppress_error = 0;
13152     r = guestfs_upload (g, "test-command", remotefilename);
13153     if (r == -1)
13154       return -1;
13155   }
13156   {
13157     char path[] = "/test-command";
13158     int r;
13159     suppress_error = 0;
13160     r = guestfs_chmod (g, 493, path);
13161     if (r == -1)
13162       return -1;
13163   }
13164   {
13165     char arguments_0[] = "/test-command";
13166     char *arguments[] = {
13167       arguments_0,
13168       NULL
13169     };
13170     char *r;
13171     suppress_error = 1;
13172     r = guestfs_command (g, arguments);
13173     if (r != NULL)
13174       return -1;
13175     free (r);
13176   }
13177   return 0;
13178 }
13179
13180 static int test_file_0_skip (void)
13181 {
13182   const char *str;
13183
13184   str = getenv ("TEST_ONLY");
13185   if (str)
13186     return strstr (str, "file") == NULL;
13187   str = getenv ("SKIP_TEST_FILE_0");
13188   if (str && strcmp (str, "1") == 0) return 1;
13189   str = getenv ("SKIP_TEST_FILE");
13190   if (str && strcmp (str, "1") == 0) return 1;
13191   return 0;
13192 }
13193
13194 static int test_file_0 (void)
13195 {
13196   if (test_file_0_skip ()) {
13197     printf ("        %s skipped (reason: environment variable set)\n", "test_file_0");
13198     return 0;
13199   }
13200
13201   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
13202   {
13203     char device[] = "/dev/sda";
13204     int r;
13205     suppress_error = 0;
13206     r = guestfs_blockdev_setrw (g, device);
13207     if (r == -1)
13208       return -1;
13209   }
13210   {
13211     int r;
13212     suppress_error = 0;
13213     r = guestfs_umount_all (g);
13214     if (r == -1)
13215       return -1;
13216   }
13217   {
13218     int r;
13219     suppress_error = 0;
13220     r = guestfs_lvm_remove_all (g);
13221     if (r == -1)
13222       return -1;
13223   }
13224   {
13225     char device[] = "/dev/sda";
13226     char lines_0[] = ",";
13227     char *lines[] = {
13228       lines_0,
13229       NULL
13230     };
13231     int r;
13232     suppress_error = 0;
13233     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13234     if (r == -1)
13235       return -1;
13236   }
13237   {
13238     char fstype[] = "ext2";
13239     char device[] = "/dev/sda1";
13240     int r;
13241     suppress_error = 0;
13242     r = guestfs_mkfs (g, fstype, device);
13243     if (r == -1)
13244       return -1;
13245   }
13246   {
13247     char device[] = "/dev/sda1";
13248     char mountpoint[] = "/";
13249     int r;
13250     suppress_error = 0;
13251     r = guestfs_mount (g, device, mountpoint);
13252     if (r == -1)
13253       return -1;
13254   }
13255   /* TestOutput for file (0) */
13256   char expected[] = "empty";
13257   {
13258     char path[] = "/new";
13259     int r;
13260     suppress_error = 0;
13261     r = guestfs_touch (g, path);
13262     if (r == -1)
13263       return -1;
13264   }
13265   {
13266     char path[] = "/new";
13267     char *r;
13268     suppress_error = 0;
13269     r = guestfs_file (g, path);
13270     if (r == NULL)
13271       return -1;
13272     if (strcmp (r, expected) != 0) {
13273       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13274       return -1;
13275     }
13276     free (r);
13277   }
13278   return 0;
13279 }
13280
13281 static int test_file_1_skip (void)
13282 {
13283   const char *str;
13284
13285   str = getenv ("TEST_ONLY");
13286   if (str)
13287     return strstr (str, "file") == NULL;
13288   str = getenv ("SKIP_TEST_FILE_1");
13289   if (str && strcmp (str, "1") == 0) return 1;
13290   str = getenv ("SKIP_TEST_FILE");
13291   if (str && strcmp (str, "1") == 0) return 1;
13292   return 0;
13293 }
13294
13295 static int test_file_1 (void)
13296 {
13297   if (test_file_1_skip ()) {
13298     printf ("        %s skipped (reason: environment variable set)\n", "test_file_1");
13299     return 0;
13300   }
13301
13302   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
13303   {
13304     char device[] = "/dev/sda";
13305     int r;
13306     suppress_error = 0;
13307     r = guestfs_blockdev_setrw (g, device);
13308     if (r == -1)
13309       return -1;
13310   }
13311   {
13312     int r;
13313     suppress_error = 0;
13314     r = guestfs_umount_all (g);
13315     if (r == -1)
13316       return -1;
13317   }
13318   {
13319     int r;
13320     suppress_error = 0;
13321     r = guestfs_lvm_remove_all (g);
13322     if (r == -1)
13323       return -1;
13324   }
13325   {
13326     char device[] = "/dev/sda";
13327     char lines_0[] = ",";
13328     char *lines[] = {
13329       lines_0,
13330       NULL
13331     };
13332     int r;
13333     suppress_error = 0;
13334     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13335     if (r == -1)
13336       return -1;
13337   }
13338   {
13339     char fstype[] = "ext2";
13340     char device[] = "/dev/sda1";
13341     int r;
13342     suppress_error = 0;
13343     r = guestfs_mkfs (g, fstype, device);
13344     if (r == -1)
13345       return -1;
13346   }
13347   {
13348     char device[] = "/dev/sda1";
13349     char mountpoint[] = "/";
13350     int r;
13351     suppress_error = 0;
13352     r = guestfs_mount (g, device, mountpoint);
13353     if (r == -1)
13354       return -1;
13355   }
13356   /* TestOutput for file (1) */
13357   char expected[] = "ASCII text";
13358   {
13359     char path[] = "/new";
13360     char content[] = "some content\n";
13361     int r;
13362     suppress_error = 0;
13363     r = guestfs_write_file (g, path, content, 0);
13364     if (r == -1)
13365       return -1;
13366   }
13367   {
13368     char path[] = "/new";
13369     char *r;
13370     suppress_error = 0;
13371     r = guestfs_file (g, path);
13372     if (r == NULL)
13373       return -1;
13374     if (strcmp (r, expected) != 0) {
13375       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13376       return -1;
13377     }
13378     free (r);
13379   }
13380   return 0;
13381 }
13382
13383 static int test_file_2_skip (void)
13384 {
13385   const char *str;
13386
13387   str = getenv ("TEST_ONLY");
13388   if (str)
13389     return strstr (str, "file") == NULL;
13390   str = getenv ("SKIP_TEST_FILE_2");
13391   if (str && strcmp (str, "1") == 0) return 1;
13392   str = getenv ("SKIP_TEST_FILE");
13393   if (str && strcmp (str, "1") == 0) return 1;
13394   return 0;
13395 }
13396
13397 static int test_file_2 (void)
13398 {
13399   if (test_file_2_skip ()) {
13400     printf ("        %s skipped (reason: environment variable set)\n", "test_file_2");
13401     return 0;
13402   }
13403
13404   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
13405   {
13406     char device[] = "/dev/sda";
13407     int r;
13408     suppress_error = 0;
13409     r = guestfs_blockdev_setrw (g, device);
13410     if (r == -1)
13411       return -1;
13412   }
13413   {
13414     int r;
13415     suppress_error = 0;
13416     r = guestfs_umount_all (g);
13417     if (r == -1)
13418       return -1;
13419   }
13420   {
13421     int r;
13422     suppress_error = 0;
13423     r = guestfs_lvm_remove_all (g);
13424     if (r == -1)
13425       return -1;
13426   }
13427   {
13428     char device[] = "/dev/sda";
13429     char lines_0[] = ",";
13430     char *lines[] = {
13431       lines_0,
13432       NULL
13433     };
13434     int r;
13435     suppress_error = 0;
13436     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13437     if (r == -1)
13438       return -1;
13439   }
13440   {
13441     char fstype[] = "ext2";
13442     char device[] = "/dev/sda1";
13443     int r;
13444     suppress_error = 0;
13445     r = guestfs_mkfs (g, fstype, device);
13446     if (r == -1)
13447       return -1;
13448   }
13449   {
13450     char device[] = "/dev/sda1";
13451     char mountpoint[] = "/";
13452     int r;
13453     suppress_error = 0;
13454     r = guestfs_mount (g, device, mountpoint);
13455     if (r == -1)
13456       return -1;
13457   }
13458   /* TestLastFail for file (2) */
13459   {
13460     char path[] = "/nofile";
13461     char *r;
13462     suppress_error = 1;
13463     r = guestfs_file (g, path);
13464     if (r != NULL)
13465       return -1;
13466     free (r);
13467   }
13468   return 0;
13469 }
13470
13471 static int test_umount_all_0_skip (void)
13472 {
13473   const char *str;
13474
13475   str = getenv ("TEST_ONLY");
13476   if (str)
13477     return strstr (str, "umount_all") == NULL;
13478   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
13479   if (str && strcmp (str, "1") == 0) return 1;
13480   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13481   if (str && strcmp (str, "1") == 0) return 1;
13482   return 0;
13483 }
13484
13485 static int test_umount_all_0 (void)
13486 {
13487   if (test_umount_all_0_skip ()) {
13488     printf ("        %s skipped (reason: environment variable set)\n", "test_umount_all_0");
13489     return 0;
13490   }
13491
13492   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
13493   {
13494     char device[] = "/dev/sda";
13495     int r;
13496     suppress_error = 0;
13497     r = guestfs_blockdev_setrw (g, device);
13498     if (r == -1)
13499       return -1;
13500   }
13501   {
13502     int r;
13503     suppress_error = 0;
13504     r = guestfs_umount_all (g);
13505     if (r == -1)
13506       return -1;
13507   }
13508   {
13509     int r;
13510     suppress_error = 0;
13511     r = guestfs_lvm_remove_all (g);
13512     if (r == -1)
13513       return -1;
13514   }
13515   {
13516     char device[] = "/dev/sda";
13517     char lines_0[] = ",";
13518     char *lines[] = {
13519       lines_0,
13520       NULL
13521     };
13522     int r;
13523     suppress_error = 0;
13524     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13525     if (r == -1)
13526       return -1;
13527   }
13528   {
13529     char fstype[] = "ext2";
13530     char device[] = "/dev/sda1";
13531     int r;
13532     suppress_error = 0;
13533     r = guestfs_mkfs (g, fstype, device);
13534     if (r == -1)
13535       return -1;
13536   }
13537   {
13538     char device[] = "/dev/sda1";
13539     char mountpoint[] = "/";
13540     int r;
13541     suppress_error = 0;
13542     r = guestfs_mount (g, device, mountpoint);
13543     if (r == -1)
13544       return -1;
13545   }
13546   /* TestOutputList for umount_all (0) */
13547   {
13548     int r;
13549     suppress_error = 0;
13550     r = guestfs_umount_all (g);
13551     if (r == -1)
13552       return -1;
13553   }
13554   {
13555     char **r;
13556     int i;
13557     suppress_error = 0;
13558     r = guestfs_mounts (g);
13559     if (r == NULL)
13560       return -1;
13561     if (r[0] != NULL) {
13562       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
13563       print_strings (r);
13564       return -1;
13565     }
13566     for (i = 0; r[i] != NULL; ++i)
13567       free (r[i]);
13568     free (r);
13569   }
13570   return 0;
13571 }
13572
13573 static int test_umount_all_1_skip (void)
13574 {
13575   const char *str;
13576
13577   str = getenv ("TEST_ONLY");
13578   if (str)
13579     return strstr (str, "umount_all") == NULL;
13580   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
13581   if (str && strcmp (str, "1") == 0) return 1;
13582   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13583   if (str && strcmp (str, "1") == 0) return 1;
13584   return 0;
13585 }
13586
13587 static int test_umount_all_1 (void)
13588 {
13589   if (test_umount_all_1_skip ()) {
13590     printf ("        %s skipped (reason: environment variable set)\n", "test_umount_all_1");
13591     return 0;
13592   }
13593
13594   /* InitNone|InitEmpty for test_umount_all_1 */
13595   {
13596     char device[] = "/dev/sda";
13597     int r;
13598     suppress_error = 0;
13599     r = guestfs_blockdev_setrw (g, device);
13600     if (r == -1)
13601       return -1;
13602   }
13603   {
13604     int r;
13605     suppress_error = 0;
13606     r = guestfs_umount_all (g);
13607     if (r == -1)
13608       return -1;
13609   }
13610   {
13611     int r;
13612     suppress_error = 0;
13613     r = guestfs_lvm_remove_all (g);
13614     if (r == -1)
13615       return -1;
13616   }
13617   /* TestOutputList for umount_all (1) */
13618   {
13619     char device[] = "/dev/sda";
13620     char lines_0[] = ",200";
13621     char lines_1[] = ",400";
13622     char lines_2[] = ",";
13623     char *lines[] = {
13624       lines_0,
13625       lines_1,
13626       lines_2,
13627       NULL
13628     };
13629     int r;
13630     suppress_error = 0;
13631     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13632     if (r == -1)
13633       return -1;
13634   }
13635   {
13636     char fstype[] = "ext2";
13637     char device[] = "/dev/sda1";
13638     int r;
13639     suppress_error = 0;
13640     r = guestfs_mkfs (g, fstype, device);
13641     if (r == -1)
13642       return -1;
13643   }
13644   {
13645     char fstype[] = "ext2";
13646     char device[] = "/dev/sda2";
13647     int r;
13648     suppress_error = 0;
13649     r = guestfs_mkfs (g, fstype, device);
13650     if (r == -1)
13651       return -1;
13652   }
13653   {
13654     char fstype[] = "ext2";
13655     char device[] = "/dev/sda3";
13656     int r;
13657     suppress_error = 0;
13658     r = guestfs_mkfs (g, fstype, device);
13659     if (r == -1)
13660       return -1;
13661   }
13662   {
13663     char device[] = "/dev/sda1";
13664     char mountpoint[] = "/";
13665     int r;
13666     suppress_error = 0;
13667     r = guestfs_mount (g, device, mountpoint);
13668     if (r == -1)
13669       return -1;
13670   }
13671   {
13672     char path[] = "/mp1";
13673     int r;
13674     suppress_error = 0;
13675     r = guestfs_mkdir (g, path);
13676     if (r == -1)
13677       return -1;
13678   }
13679   {
13680     char device[] = "/dev/sda2";
13681     char mountpoint[] = "/mp1";
13682     int r;
13683     suppress_error = 0;
13684     r = guestfs_mount (g, device, mountpoint);
13685     if (r == -1)
13686       return -1;
13687   }
13688   {
13689     char path[] = "/mp1/mp2";
13690     int r;
13691     suppress_error = 0;
13692     r = guestfs_mkdir (g, path);
13693     if (r == -1)
13694       return -1;
13695   }
13696   {
13697     char device[] = "/dev/sda3";
13698     char mountpoint[] = "/mp1/mp2";
13699     int r;
13700     suppress_error = 0;
13701     r = guestfs_mount (g, device, mountpoint);
13702     if (r == -1)
13703       return -1;
13704   }
13705   {
13706     char path[] = "/mp1/mp2/mp3";
13707     int r;
13708     suppress_error = 0;
13709     r = guestfs_mkdir (g, path);
13710     if (r == -1)
13711       return -1;
13712   }
13713   {
13714     int r;
13715     suppress_error = 0;
13716     r = guestfs_umount_all (g);
13717     if (r == -1)
13718       return -1;
13719   }
13720   {
13721     char **r;
13722     int i;
13723     suppress_error = 0;
13724     r = guestfs_mounts (g);
13725     if (r == NULL)
13726       return -1;
13727     if (r[0] != NULL) {
13728       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13729       print_strings (r);
13730       return -1;
13731     }
13732     for (i = 0; r[i] != NULL; ++i)
13733       free (r[i]);
13734     free (r);
13735   }
13736   return 0;
13737 }
13738
13739 static int test_mounts_0_skip (void)
13740 {
13741   const char *str;
13742
13743   str = getenv ("TEST_ONLY");
13744   if (str)
13745     return strstr (str, "mounts") == NULL;
13746   str = getenv ("SKIP_TEST_MOUNTS_0");
13747   if (str && strcmp (str, "1") == 0) return 1;
13748   str = getenv ("SKIP_TEST_MOUNTS");
13749   if (str && strcmp (str, "1") == 0) return 1;
13750   return 0;
13751 }
13752
13753 static int test_mounts_0 (void)
13754 {
13755   if (test_mounts_0_skip ()) {
13756     printf ("        %s skipped (reason: environment variable set)\n", "test_mounts_0");
13757     return 0;
13758   }
13759
13760   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13761   {
13762     char device[] = "/dev/sda";
13763     int r;
13764     suppress_error = 0;
13765     r = guestfs_blockdev_setrw (g, device);
13766     if (r == -1)
13767       return -1;
13768   }
13769   {
13770     int r;
13771     suppress_error = 0;
13772     r = guestfs_umount_all (g);
13773     if (r == -1)
13774       return -1;
13775   }
13776   {
13777     int r;
13778     suppress_error = 0;
13779     r = guestfs_lvm_remove_all (g);
13780     if (r == -1)
13781       return -1;
13782   }
13783   {
13784     char device[] = "/dev/sda";
13785     char lines_0[] = ",";
13786     char *lines[] = {
13787       lines_0,
13788       NULL
13789     };
13790     int r;
13791     suppress_error = 0;
13792     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13793     if (r == -1)
13794       return -1;
13795   }
13796   {
13797     char fstype[] = "ext2";
13798     char device[] = "/dev/sda1";
13799     int r;
13800     suppress_error = 0;
13801     r = guestfs_mkfs (g, fstype, device);
13802     if (r == -1)
13803       return -1;
13804   }
13805   {
13806     char device[] = "/dev/sda1";
13807     char mountpoint[] = "/";
13808     int r;
13809     suppress_error = 0;
13810     r = guestfs_mount (g, device, mountpoint);
13811     if (r == -1)
13812       return -1;
13813   }
13814   /* TestOutputListOfDevices for mounts (0) */
13815   {
13816     char **r;
13817     int i;
13818     suppress_error = 0;
13819     r = guestfs_mounts (g);
13820     if (r == NULL)
13821       return -1;
13822     if (!r[0]) {
13823       fprintf (stderr, "test_mounts_0: short list returned from command\n");
13824       print_strings (r);
13825       return -1;
13826     }
13827     {
13828       char expected[] = "/dev/sda1";
13829       r[0][5] = 's';
13830       if (strcmp (r[0], expected) != 0) {
13831         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13832         return -1;
13833       }
13834     }
13835     if (r[1] != NULL) {
13836       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13837       print_strings (r);
13838       return -1;
13839     }
13840     for (i = 0; r[i] != NULL; ++i)
13841       free (r[i]);
13842     free (r);
13843   }
13844   return 0;
13845 }
13846
13847 static int test_umount_0_skip (void)
13848 {
13849   const char *str;
13850
13851   str = getenv ("TEST_ONLY");
13852   if (str)
13853     return strstr (str, "umount") == NULL;
13854   str = getenv ("SKIP_TEST_UMOUNT_0");
13855   if (str && strcmp (str, "1") == 0) return 1;
13856   str = getenv ("SKIP_TEST_UMOUNT");
13857   if (str && strcmp (str, "1") == 0) return 1;
13858   return 0;
13859 }
13860
13861 static int test_umount_0 (void)
13862 {
13863   if (test_umount_0_skip ()) {
13864     printf ("        %s skipped (reason: environment variable set)\n", "test_umount_0");
13865     return 0;
13866   }
13867
13868   /* InitNone|InitEmpty for test_umount_0 */
13869   {
13870     char device[] = "/dev/sda";
13871     int r;
13872     suppress_error = 0;
13873     r = guestfs_blockdev_setrw (g, device);
13874     if (r == -1)
13875       return -1;
13876   }
13877   {
13878     int r;
13879     suppress_error = 0;
13880     r = guestfs_umount_all (g);
13881     if (r == -1)
13882       return -1;
13883   }
13884   {
13885     int r;
13886     suppress_error = 0;
13887     r = guestfs_lvm_remove_all (g);
13888     if (r == -1)
13889       return -1;
13890   }
13891   /* TestOutputListOfDevices for umount (0) */
13892   {
13893     char device[] = "/dev/sda";
13894     char lines_0[] = ",";
13895     char *lines[] = {
13896       lines_0,
13897       NULL
13898     };
13899     int r;
13900     suppress_error = 0;
13901     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13902     if (r == -1)
13903       return -1;
13904   }
13905   {
13906     char fstype[] = "ext2";
13907     char device[] = "/dev/sda1";
13908     int r;
13909     suppress_error = 0;
13910     r = guestfs_mkfs (g, fstype, device);
13911     if (r == -1)
13912       return -1;
13913   }
13914   {
13915     char device[] = "/dev/sda1";
13916     char mountpoint[] = "/";
13917     int r;
13918     suppress_error = 0;
13919     r = guestfs_mount (g, device, mountpoint);
13920     if (r == -1)
13921       return -1;
13922   }
13923   {
13924     char **r;
13925     int i;
13926     suppress_error = 0;
13927     r = guestfs_mounts (g);
13928     if (r == NULL)
13929       return -1;
13930     if (!r[0]) {
13931       fprintf (stderr, "test_umount_0: short list returned from command\n");
13932       print_strings (r);
13933       return -1;
13934     }
13935     {
13936       char expected[] = "/dev/sda1";
13937       r[0][5] = 's';
13938       if (strcmp (r[0], expected) != 0) {
13939         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13940         return -1;
13941       }
13942     }
13943     if (r[1] != NULL) {
13944       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13945       print_strings (r);
13946       return -1;
13947     }
13948     for (i = 0; r[i] != NULL; ++i)
13949       free (r[i]);
13950     free (r);
13951   }
13952   return 0;
13953 }
13954
13955 static int test_umount_1_skip (void)
13956 {
13957   const char *str;
13958
13959   str = getenv ("TEST_ONLY");
13960   if (str)
13961     return strstr (str, "umount") == NULL;
13962   str = getenv ("SKIP_TEST_UMOUNT_1");
13963   if (str && strcmp (str, "1") == 0) return 1;
13964   str = getenv ("SKIP_TEST_UMOUNT");
13965   if (str && strcmp (str, "1") == 0) return 1;
13966   return 0;
13967 }
13968
13969 static int test_umount_1 (void)
13970 {
13971   if (test_umount_1_skip ()) {
13972     printf ("        %s skipped (reason: environment variable set)\n", "test_umount_1");
13973     return 0;
13974   }
13975
13976   /* InitNone|InitEmpty for test_umount_1 */
13977   {
13978     char device[] = "/dev/sda";
13979     int r;
13980     suppress_error = 0;
13981     r = guestfs_blockdev_setrw (g, device);
13982     if (r == -1)
13983       return -1;
13984   }
13985   {
13986     int r;
13987     suppress_error = 0;
13988     r = guestfs_umount_all (g);
13989     if (r == -1)
13990       return -1;
13991   }
13992   {
13993     int r;
13994     suppress_error = 0;
13995     r = guestfs_lvm_remove_all (g);
13996     if (r == -1)
13997       return -1;
13998   }
13999   /* TestOutputList for umount (1) */
14000   {
14001     char device[] = "/dev/sda";
14002     char lines_0[] = ",";
14003     char *lines[] = {
14004       lines_0,
14005       NULL
14006     };
14007     int r;
14008     suppress_error = 0;
14009     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14010     if (r == -1)
14011       return -1;
14012   }
14013   {
14014     char fstype[] = "ext2";
14015     char device[] = "/dev/sda1";
14016     int r;
14017     suppress_error = 0;
14018     r = guestfs_mkfs (g, fstype, device);
14019     if (r == -1)
14020       return -1;
14021   }
14022   {
14023     char device[] = "/dev/sda1";
14024     char mountpoint[] = "/";
14025     int r;
14026     suppress_error = 0;
14027     r = guestfs_mount (g, device, mountpoint);
14028     if (r == -1)
14029       return -1;
14030   }
14031   {
14032     char pathordevice[] = "/";
14033     int r;
14034     suppress_error = 0;
14035     r = guestfs_umount (g, pathordevice);
14036     if (r == -1)
14037       return -1;
14038   }
14039   {
14040     char **r;
14041     int i;
14042     suppress_error = 0;
14043     r = guestfs_mounts (g);
14044     if (r == NULL)
14045       return -1;
14046     if (r[0] != NULL) {
14047       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
14048       print_strings (r);
14049       return -1;
14050     }
14051     for (i = 0; r[i] != NULL; ++i)
14052       free (r[i]);
14053     free (r);
14054   }
14055   return 0;
14056 }
14057
14058 static int test_write_file_0_skip (void)
14059 {
14060   const char *str;
14061
14062   str = getenv ("TEST_ONLY");
14063   if (str)
14064     return strstr (str, "write_file") == NULL;
14065   str = getenv ("SKIP_TEST_WRITE_FILE_0");
14066   if (str && strcmp (str, "1") == 0) return 1;
14067   str = getenv ("SKIP_TEST_WRITE_FILE");
14068   if (str && strcmp (str, "1") == 0) return 1;
14069   return 0;
14070 }
14071
14072 static int test_write_file_0 (void)
14073 {
14074   if (test_write_file_0_skip ()) {
14075     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_0");
14076     return 0;
14077   }
14078
14079   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
14080   {
14081     char device[] = "/dev/sda";
14082     int r;
14083     suppress_error = 0;
14084     r = guestfs_blockdev_setrw (g, device);
14085     if (r == -1)
14086       return -1;
14087   }
14088   {
14089     int r;
14090     suppress_error = 0;
14091     r = guestfs_umount_all (g);
14092     if (r == -1)
14093       return -1;
14094   }
14095   {
14096     int r;
14097     suppress_error = 0;
14098     r = guestfs_lvm_remove_all (g);
14099     if (r == -1)
14100       return -1;
14101   }
14102   {
14103     char device[] = "/dev/sda";
14104     char lines_0[] = ",";
14105     char *lines[] = {
14106       lines_0,
14107       NULL
14108     };
14109     int r;
14110     suppress_error = 0;
14111     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14112     if (r == -1)
14113       return -1;
14114   }
14115   {
14116     char fstype[] = "ext2";
14117     char device[] = "/dev/sda1";
14118     int r;
14119     suppress_error = 0;
14120     r = guestfs_mkfs (g, fstype, device);
14121     if (r == -1)
14122       return -1;
14123   }
14124   {
14125     char device[] = "/dev/sda1";
14126     char mountpoint[] = "/";
14127     int r;
14128     suppress_error = 0;
14129     r = guestfs_mount (g, device, mountpoint);
14130     if (r == -1)
14131       return -1;
14132   }
14133   /* TestOutput for write_file (0) */
14134   char expected[] = "new file contents";
14135   {
14136     char path[] = "/new";
14137     char content[] = "new file contents";
14138     int r;
14139     suppress_error = 0;
14140     r = guestfs_write_file (g, path, content, 0);
14141     if (r == -1)
14142       return -1;
14143   }
14144   {
14145     char path[] = "/new";
14146     char *r;
14147     suppress_error = 0;
14148     r = guestfs_cat (g, path);
14149     if (r == NULL)
14150       return -1;
14151     if (strcmp (r, expected) != 0) {
14152       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
14153       return -1;
14154     }
14155     free (r);
14156   }
14157   return 0;
14158 }
14159
14160 static int test_write_file_1_skip (void)
14161 {
14162   const char *str;
14163
14164   str = getenv ("TEST_ONLY");
14165   if (str)
14166     return strstr (str, "write_file") == NULL;
14167   str = getenv ("SKIP_TEST_WRITE_FILE_1");
14168   if (str && strcmp (str, "1") == 0) return 1;
14169   str = getenv ("SKIP_TEST_WRITE_FILE");
14170   if (str && strcmp (str, "1") == 0) return 1;
14171   return 0;
14172 }
14173
14174 static int test_write_file_1 (void)
14175 {
14176   if (test_write_file_1_skip ()) {
14177     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_1");
14178     return 0;
14179   }
14180
14181   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
14182   {
14183     char device[] = "/dev/sda";
14184     int r;
14185     suppress_error = 0;
14186     r = guestfs_blockdev_setrw (g, device);
14187     if (r == -1)
14188       return -1;
14189   }
14190   {
14191     int r;
14192     suppress_error = 0;
14193     r = guestfs_umount_all (g);
14194     if (r == -1)
14195       return -1;
14196   }
14197   {
14198     int r;
14199     suppress_error = 0;
14200     r = guestfs_lvm_remove_all (g);
14201     if (r == -1)
14202       return -1;
14203   }
14204   {
14205     char device[] = "/dev/sda";
14206     char lines_0[] = ",";
14207     char *lines[] = {
14208       lines_0,
14209       NULL
14210     };
14211     int r;
14212     suppress_error = 0;
14213     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14214     if (r == -1)
14215       return -1;
14216   }
14217   {
14218     char fstype[] = "ext2";
14219     char device[] = "/dev/sda1";
14220     int r;
14221     suppress_error = 0;
14222     r = guestfs_mkfs (g, fstype, device);
14223     if (r == -1)
14224       return -1;
14225   }
14226   {
14227     char device[] = "/dev/sda1";
14228     char mountpoint[] = "/";
14229     int r;
14230     suppress_error = 0;
14231     r = guestfs_mount (g, device, mountpoint);
14232     if (r == -1)
14233       return -1;
14234   }
14235   /* TestOutput for write_file (1) */
14236   char expected[] = "\nnew file contents\n";
14237   {
14238     char path[] = "/new";
14239     char content[] = "\nnew file contents\n";
14240     int r;
14241     suppress_error = 0;
14242     r = guestfs_write_file (g, path, content, 0);
14243     if (r == -1)
14244       return -1;
14245   }
14246   {
14247     char path[] = "/new";
14248     char *r;
14249     suppress_error = 0;
14250     r = guestfs_cat (g, path);
14251     if (r == NULL)
14252       return -1;
14253     if (strcmp (r, expected) != 0) {
14254       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
14255       return -1;
14256     }
14257     free (r);
14258   }
14259   return 0;
14260 }
14261
14262 static int test_write_file_2_skip (void)
14263 {
14264   const char *str;
14265
14266   str = getenv ("TEST_ONLY");
14267   if (str)
14268     return strstr (str, "write_file") == NULL;
14269   str = getenv ("SKIP_TEST_WRITE_FILE_2");
14270   if (str && strcmp (str, "1") == 0) return 1;
14271   str = getenv ("SKIP_TEST_WRITE_FILE");
14272   if (str && strcmp (str, "1") == 0) return 1;
14273   return 0;
14274 }
14275
14276 static int test_write_file_2 (void)
14277 {
14278   if (test_write_file_2_skip ()) {
14279     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_2");
14280     return 0;
14281   }
14282
14283   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
14284   {
14285     char device[] = "/dev/sda";
14286     int r;
14287     suppress_error = 0;
14288     r = guestfs_blockdev_setrw (g, device);
14289     if (r == -1)
14290       return -1;
14291   }
14292   {
14293     int r;
14294     suppress_error = 0;
14295     r = guestfs_umount_all (g);
14296     if (r == -1)
14297       return -1;
14298   }
14299   {
14300     int r;
14301     suppress_error = 0;
14302     r = guestfs_lvm_remove_all (g);
14303     if (r == -1)
14304       return -1;
14305   }
14306   {
14307     char device[] = "/dev/sda";
14308     char lines_0[] = ",";
14309     char *lines[] = {
14310       lines_0,
14311       NULL
14312     };
14313     int r;
14314     suppress_error = 0;
14315     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14316     if (r == -1)
14317       return -1;
14318   }
14319   {
14320     char fstype[] = "ext2";
14321     char device[] = "/dev/sda1";
14322     int r;
14323     suppress_error = 0;
14324     r = guestfs_mkfs (g, fstype, device);
14325     if (r == -1)
14326       return -1;
14327   }
14328   {
14329     char device[] = "/dev/sda1";
14330     char mountpoint[] = "/";
14331     int r;
14332     suppress_error = 0;
14333     r = guestfs_mount (g, device, mountpoint);
14334     if (r == -1)
14335       return -1;
14336   }
14337   /* TestOutput for write_file (2) */
14338   char expected[] = "\n\n";
14339   {
14340     char path[] = "/new";
14341     char content[] = "\n\n";
14342     int r;
14343     suppress_error = 0;
14344     r = guestfs_write_file (g, path, content, 0);
14345     if (r == -1)
14346       return -1;
14347   }
14348   {
14349     char path[] = "/new";
14350     char *r;
14351     suppress_error = 0;
14352     r = guestfs_cat (g, path);
14353     if (r == NULL)
14354       return -1;
14355     if (strcmp (r, expected) != 0) {
14356       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
14357       return -1;
14358     }
14359     free (r);
14360   }
14361   return 0;
14362 }
14363
14364 static int test_write_file_3_skip (void)
14365 {
14366   const char *str;
14367
14368   str = getenv ("TEST_ONLY");
14369   if (str)
14370     return strstr (str, "write_file") == NULL;
14371   str = getenv ("SKIP_TEST_WRITE_FILE_3");
14372   if (str && strcmp (str, "1") == 0) return 1;
14373   str = getenv ("SKIP_TEST_WRITE_FILE");
14374   if (str && strcmp (str, "1") == 0) return 1;
14375   return 0;
14376 }
14377
14378 static int test_write_file_3 (void)
14379 {
14380   if (test_write_file_3_skip ()) {
14381     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_3");
14382     return 0;
14383   }
14384
14385   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
14386   {
14387     char device[] = "/dev/sda";
14388     int r;
14389     suppress_error = 0;
14390     r = guestfs_blockdev_setrw (g, device);
14391     if (r == -1)
14392       return -1;
14393   }
14394   {
14395     int r;
14396     suppress_error = 0;
14397     r = guestfs_umount_all (g);
14398     if (r == -1)
14399       return -1;
14400   }
14401   {
14402     int r;
14403     suppress_error = 0;
14404     r = guestfs_lvm_remove_all (g);
14405     if (r == -1)
14406       return -1;
14407   }
14408   {
14409     char device[] = "/dev/sda";
14410     char lines_0[] = ",";
14411     char *lines[] = {
14412       lines_0,
14413       NULL
14414     };
14415     int r;
14416     suppress_error = 0;
14417     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14418     if (r == -1)
14419       return -1;
14420   }
14421   {
14422     char fstype[] = "ext2";
14423     char device[] = "/dev/sda1";
14424     int r;
14425     suppress_error = 0;
14426     r = guestfs_mkfs (g, fstype, device);
14427     if (r == -1)
14428       return -1;
14429   }
14430   {
14431     char device[] = "/dev/sda1";
14432     char mountpoint[] = "/";
14433     int r;
14434     suppress_error = 0;
14435     r = guestfs_mount (g, device, mountpoint);
14436     if (r == -1)
14437       return -1;
14438   }
14439   /* TestOutput for write_file (3) */
14440   char expected[] = "";
14441   {
14442     char path[] = "/new";
14443     char content[] = "";
14444     int r;
14445     suppress_error = 0;
14446     r = guestfs_write_file (g, path, content, 0);
14447     if (r == -1)
14448       return -1;
14449   }
14450   {
14451     char path[] = "/new";
14452     char *r;
14453     suppress_error = 0;
14454     r = guestfs_cat (g, path);
14455     if (r == NULL)
14456       return -1;
14457     if (strcmp (r, expected) != 0) {
14458       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
14459       return -1;
14460     }
14461     free (r);
14462   }
14463   return 0;
14464 }
14465
14466 static int test_write_file_4_skip (void)
14467 {
14468   const char *str;
14469
14470   str = getenv ("TEST_ONLY");
14471   if (str)
14472     return strstr (str, "write_file") == NULL;
14473   str = getenv ("SKIP_TEST_WRITE_FILE_4");
14474   if (str && strcmp (str, "1") == 0) return 1;
14475   str = getenv ("SKIP_TEST_WRITE_FILE");
14476   if (str && strcmp (str, "1") == 0) return 1;
14477   return 0;
14478 }
14479
14480 static int test_write_file_4 (void)
14481 {
14482   if (test_write_file_4_skip ()) {
14483     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_4");
14484     return 0;
14485   }
14486
14487   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
14488   {
14489     char device[] = "/dev/sda";
14490     int r;
14491     suppress_error = 0;
14492     r = guestfs_blockdev_setrw (g, device);
14493     if (r == -1)
14494       return -1;
14495   }
14496   {
14497     int r;
14498     suppress_error = 0;
14499     r = guestfs_umount_all (g);
14500     if (r == -1)
14501       return -1;
14502   }
14503   {
14504     int r;
14505     suppress_error = 0;
14506     r = guestfs_lvm_remove_all (g);
14507     if (r == -1)
14508       return -1;
14509   }
14510   {
14511     char device[] = "/dev/sda";
14512     char lines_0[] = ",";
14513     char *lines[] = {
14514       lines_0,
14515       NULL
14516     };
14517     int r;
14518     suppress_error = 0;
14519     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14520     if (r == -1)
14521       return -1;
14522   }
14523   {
14524     char fstype[] = "ext2";
14525     char device[] = "/dev/sda1";
14526     int r;
14527     suppress_error = 0;
14528     r = guestfs_mkfs (g, fstype, device);
14529     if (r == -1)
14530       return -1;
14531   }
14532   {
14533     char device[] = "/dev/sda1";
14534     char mountpoint[] = "/";
14535     int r;
14536     suppress_error = 0;
14537     r = guestfs_mount (g, device, mountpoint);
14538     if (r == -1)
14539       return -1;
14540   }
14541   /* TestOutput for write_file (4) */
14542   char expected[] = "\n\n\n";
14543   {
14544     char path[] = "/new";
14545     char content[] = "\n\n\n";
14546     int r;
14547     suppress_error = 0;
14548     r = guestfs_write_file (g, path, content, 0);
14549     if (r == -1)
14550       return -1;
14551   }
14552   {
14553     char path[] = "/new";
14554     char *r;
14555     suppress_error = 0;
14556     r = guestfs_cat (g, path);
14557     if (r == NULL)
14558       return -1;
14559     if (strcmp (r, expected) != 0) {
14560       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
14561       return -1;
14562     }
14563     free (r);
14564   }
14565   return 0;
14566 }
14567
14568 static int test_write_file_5_skip (void)
14569 {
14570   const char *str;
14571
14572   str = getenv ("TEST_ONLY");
14573   if (str)
14574     return strstr (str, "write_file") == NULL;
14575   str = getenv ("SKIP_TEST_WRITE_FILE_5");
14576   if (str && strcmp (str, "1") == 0) return 1;
14577   str = getenv ("SKIP_TEST_WRITE_FILE");
14578   if (str && strcmp (str, "1") == 0) return 1;
14579   return 0;
14580 }
14581
14582 static int test_write_file_5 (void)
14583 {
14584   if (test_write_file_5_skip ()) {
14585     printf ("        %s skipped (reason: environment variable set)\n", "test_write_file_5");
14586     return 0;
14587   }
14588
14589   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
14590   {
14591     char device[] = "/dev/sda";
14592     int r;
14593     suppress_error = 0;
14594     r = guestfs_blockdev_setrw (g, device);
14595     if (r == -1)
14596       return -1;
14597   }
14598   {
14599     int r;
14600     suppress_error = 0;
14601     r = guestfs_umount_all (g);
14602     if (r == -1)
14603       return -1;
14604   }
14605   {
14606     int r;
14607     suppress_error = 0;
14608     r = guestfs_lvm_remove_all (g);
14609     if (r == -1)
14610       return -1;
14611   }
14612   {
14613     char device[] = "/dev/sda";
14614     char lines_0[] = ",";
14615     char *lines[] = {
14616       lines_0,
14617       NULL
14618     };
14619     int r;
14620     suppress_error = 0;
14621     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14622     if (r == -1)
14623       return -1;
14624   }
14625   {
14626     char fstype[] = "ext2";
14627     char device[] = "/dev/sda1";
14628     int r;
14629     suppress_error = 0;
14630     r = guestfs_mkfs (g, fstype, device);
14631     if (r == -1)
14632       return -1;
14633   }
14634   {
14635     char device[] = "/dev/sda1";
14636     char mountpoint[] = "/";
14637     int r;
14638     suppress_error = 0;
14639     r = guestfs_mount (g, device, mountpoint);
14640     if (r == -1)
14641       return -1;
14642   }
14643   /* TestOutput for write_file (5) */
14644   char expected[] = "\n";
14645   {
14646     char path[] = "/new";
14647     char content[] = "\n";
14648     int r;
14649     suppress_error = 0;
14650     r = guestfs_write_file (g, path, content, 0);
14651     if (r == -1)
14652       return -1;
14653   }
14654   {
14655     char path[] = "/new";
14656     char *r;
14657     suppress_error = 0;
14658     r = guestfs_cat (g, path);
14659     if (r == NULL)
14660       return -1;
14661     if (strcmp (r, expected) != 0) {
14662       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14663       return -1;
14664     }
14665     free (r);
14666   }
14667   return 0;
14668 }
14669
14670 static int test_mkfs_0_skip (void)
14671 {
14672   const char *str;
14673
14674   str = getenv ("TEST_ONLY");
14675   if (str)
14676     return strstr (str, "mkfs") == NULL;
14677   str = getenv ("SKIP_TEST_MKFS_0");
14678   if (str && strcmp (str, "1") == 0) return 1;
14679   str = getenv ("SKIP_TEST_MKFS");
14680   if (str && strcmp (str, "1") == 0) return 1;
14681   return 0;
14682 }
14683
14684 static int test_mkfs_0 (void)
14685 {
14686   if (test_mkfs_0_skip ()) {
14687     printf ("        %s skipped (reason: environment variable set)\n", "test_mkfs_0");
14688     return 0;
14689   }
14690
14691   /* InitNone|InitEmpty for test_mkfs_0 */
14692   {
14693     char device[] = "/dev/sda";
14694     int r;
14695     suppress_error = 0;
14696     r = guestfs_blockdev_setrw (g, device);
14697     if (r == -1)
14698       return -1;
14699   }
14700   {
14701     int r;
14702     suppress_error = 0;
14703     r = guestfs_umount_all (g);
14704     if (r == -1)
14705       return -1;
14706   }
14707   {
14708     int r;
14709     suppress_error = 0;
14710     r = guestfs_lvm_remove_all (g);
14711     if (r == -1)
14712       return -1;
14713   }
14714   /* TestOutput for mkfs (0) */
14715   char expected[] = "new file contents";
14716   {
14717     char device[] = "/dev/sda";
14718     char lines_0[] = ",";
14719     char *lines[] = {
14720       lines_0,
14721       NULL
14722     };
14723     int r;
14724     suppress_error = 0;
14725     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14726     if (r == -1)
14727       return -1;
14728   }
14729   {
14730     char fstype[] = "ext2";
14731     char device[] = "/dev/sda1";
14732     int r;
14733     suppress_error = 0;
14734     r = guestfs_mkfs (g, fstype, device);
14735     if (r == -1)
14736       return -1;
14737   }
14738   {
14739     char device[] = "/dev/sda1";
14740     char mountpoint[] = "/";
14741     int r;
14742     suppress_error = 0;
14743     r = guestfs_mount (g, device, mountpoint);
14744     if (r == -1)
14745       return -1;
14746   }
14747   {
14748     char path[] = "/new";
14749     char content[] = "new file contents";
14750     int r;
14751     suppress_error = 0;
14752     r = guestfs_write_file (g, path, content, 0);
14753     if (r == -1)
14754       return -1;
14755   }
14756   {
14757     char path[] = "/new";
14758     char *r;
14759     suppress_error = 0;
14760     r = guestfs_cat (g, path);
14761     if (r == NULL)
14762       return -1;
14763     if (strcmp (r, expected) != 0) {
14764       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14765       return -1;
14766     }
14767     free (r);
14768   }
14769   return 0;
14770 }
14771
14772 static int test_lvcreate_0_skip (void)
14773 {
14774   const char *str;
14775
14776   str = getenv ("TEST_ONLY");
14777   if (str)
14778     return strstr (str, "lvcreate") == NULL;
14779   str = getenv ("SKIP_TEST_LVCREATE_0");
14780   if (str && strcmp (str, "1") == 0) return 1;
14781   str = getenv ("SKIP_TEST_LVCREATE");
14782   if (str && strcmp (str, "1") == 0) return 1;
14783   return 0;
14784 }
14785
14786 static int test_lvcreate_0 (void)
14787 {
14788   if (test_lvcreate_0_skip ()) {
14789     printf ("        %s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14790     return 0;
14791   }
14792
14793   /* InitNone|InitEmpty for test_lvcreate_0 */
14794   {
14795     char device[] = "/dev/sda";
14796     int r;
14797     suppress_error = 0;
14798     r = guestfs_blockdev_setrw (g, device);
14799     if (r == -1)
14800       return -1;
14801   }
14802   {
14803     int r;
14804     suppress_error = 0;
14805     r = guestfs_umount_all (g);
14806     if (r == -1)
14807       return -1;
14808   }
14809   {
14810     int r;
14811     suppress_error = 0;
14812     r = guestfs_lvm_remove_all (g);
14813     if (r == -1)
14814       return -1;
14815   }
14816   /* TestOutputList for lvcreate (0) */
14817   {
14818     char device[] = "/dev/sda";
14819     char lines_0[] = ",200";
14820     char lines_1[] = ",400";
14821     char lines_2[] = ",";
14822     char *lines[] = {
14823       lines_0,
14824       lines_1,
14825       lines_2,
14826       NULL
14827     };
14828     int r;
14829     suppress_error = 0;
14830     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14831     if (r == -1)
14832       return -1;
14833   }
14834   {
14835     char device[] = "/dev/sda1";
14836     int r;
14837     suppress_error = 0;
14838     r = guestfs_pvcreate (g, device);
14839     if (r == -1)
14840       return -1;
14841   }
14842   {
14843     char device[] = "/dev/sda2";
14844     int r;
14845     suppress_error = 0;
14846     r = guestfs_pvcreate (g, device);
14847     if (r == -1)
14848       return -1;
14849   }
14850   {
14851     char device[] = "/dev/sda3";
14852     int r;
14853     suppress_error = 0;
14854     r = guestfs_pvcreate (g, device);
14855     if (r == -1)
14856       return -1;
14857   }
14858   {
14859     char volgroup[] = "VG1";
14860     char physvols_0[] = "/dev/sda1";
14861     char physvols_1[] = "/dev/sda2";
14862     char *physvols[] = {
14863       physvols_0,
14864       physvols_1,
14865       NULL
14866     };
14867     int r;
14868     suppress_error = 0;
14869     r = guestfs_vgcreate (g, volgroup, physvols);
14870     if (r == -1)
14871       return -1;
14872   }
14873   {
14874     char volgroup[] = "VG2";
14875     char physvols_0[] = "/dev/sda3";
14876     char *physvols[] = {
14877       physvols_0,
14878       NULL
14879     };
14880     int r;
14881     suppress_error = 0;
14882     r = guestfs_vgcreate (g, volgroup, physvols);
14883     if (r == -1)
14884       return -1;
14885   }
14886   {
14887     char logvol[] = "LV1";
14888     char volgroup[] = "VG1";
14889     int r;
14890     suppress_error = 0;
14891     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14892     if (r == -1)
14893       return -1;
14894   }
14895   {
14896     char logvol[] = "LV2";
14897     char volgroup[] = "VG1";
14898     int r;
14899     suppress_error = 0;
14900     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14901     if (r == -1)
14902       return -1;
14903   }
14904   {
14905     char logvol[] = "LV3";
14906     char volgroup[] = "VG2";
14907     int r;
14908     suppress_error = 0;
14909     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14910     if (r == -1)
14911       return -1;
14912   }
14913   {
14914     char logvol[] = "LV4";
14915     char volgroup[] = "VG2";
14916     int r;
14917     suppress_error = 0;
14918     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14919     if (r == -1)
14920       return -1;
14921   }
14922   {
14923     char logvol[] = "LV5";
14924     char volgroup[] = "VG2";
14925     int r;
14926     suppress_error = 0;
14927     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14928     if (r == -1)
14929       return -1;
14930   }
14931   {
14932     char **r;
14933     int i;
14934     suppress_error = 0;
14935     r = guestfs_lvs (g);
14936     if (r == NULL)
14937       return -1;
14938     if (!r[0]) {
14939       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14940       print_strings (r);
14941       return -1;
14942     }
14943     {
14944       char expected[] = "/dev/VG1/LV1";
14945       if (strcmp (r[0], expected) != 0) {
14946         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14947         return -1;
14948       }
14949     }
14950     if (!r[1]) {
14951       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14952       print_strings (r);
14953       return -1;
14954     }
14955     {
14956       char expected[] = "/dev/VG1/LV2";
14957       if (strcmp (r[1], expected) != 0) {
14958         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14959         return -1;
14960       }
14961     }
14962     if (!r[2]) {
14963       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14964       print_strings (r);
14965       return -1;
14966     }
14967     {
14968       char expected[] = "/dev/VG2/LV3";
14969       if (strcmp (r[2], expected) != 0) {
14970         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14971         return -1;
14972       }
14973     }
14974     if (!r[3]) {
14975       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14976       print_strings (r);
14977       return -1;
14978     }
14979     {
14980       char expected[] = "/dev/VG2/LV4";
14981       if (strcmp (r[3], expected) != 0) {
14982         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14983         return -1;
14984       }
14985     }
14986     if (!r[4]) {
14987       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14988       print_strings (r);
14989       return -1;
14990     }
14991     {
14992       char expected[] = "/dev/VG2/LV5";
14993       if (strcmp (r[4], expected) != 0) {
14994         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14995         return -1;
14996       }
14997     }
14998     if (r[5] != NULL) {
14999       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
15000       print_strings (r);
15001       return -1;
15002     }
15003     for (i = 0; r[i] != NULL; ++i)
15004       free (r[i]);
15005     free (r);
15006   }
15007   return 0;
15008 }
15009
15010 static int test_vgcreate_0_skip (void)
15011 {
15012   const char *str;
15013
15014   str = getenv ("TEST_ONLY");
15015   if (str)
15016     return strstr (str, "vgcreate") == NULL;
15017   str = getenv ("SKIP_TEST_VGCREATE_0");
15018   if (str && strcmp (str, "1") == 0) return 1;
15019   str = getenv ("SKIP_TEST_VGCREATE");
15020   if (str && strcmp (str, "1") == 0) return 1;
15021   return 0;
15022 }
15023
15024 static int test_vgcreate_0 (void)
15025 {
15026   if (test_vgcreate_0_skip ()) {
15027     printf ("        %s skipped (reason: environment variable set)\n", "test_vgcreate_0");
15028     return 0;
15029   }
15030
15031   /* InitNone|InitEmpty for test_vgcreate_0 */
15032   {
15033     char device[] = "/dev/sda";
15034     int r;
15035     suppress_error = 0;
15036     r = guestfs_blockdev_setrw (g, device);
15037     if (r == -1)
15038       return -1;
15039   }
15040   {
15041     int r;
15042     suppress_error = 0;
15043     r = guestfs_umount_all (g);
15044     if (r == -1)
15045       return -1;
15046   }
15047   {
15048     int r;
15049     suppress_error = 0;
15050     r = guestfs_lvm_remove_all (g);
15051     if (r == -1)
15052       return -1;
15053   }
15054   /* TestOutputList for vgcreate (0) */
15055   {
15056     char device[] = "/dev/sda";
15057     char lines_0[] = ",200";
15058     char lines_1[] = ",400";
15059     char lines_2[] = ",";
15060     char *lines[] = {
15061       lines_0,
15062       lines_1,
15063       lines_2,
15064       NULL
15065     };
15066     int r;
15067     suppress_error = 0;
15068     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15069     if (r == -1)
15070       return -1;
15071   }
15072   {
15073     char device[] = "/dev/sda1";
15074     int r;
15075     suppress_error = 0;
15076     r = guestfs_pvcreate (g, device);
15077     if (r == -1)
15078       return -1;
15079   }
15080   {
15081     char device[] = "/dev/sda2";
15082     int r;
15083     suppress_error = 0;
15084     r = guestfs_pvcreate (g, device);
15085     if (r == -1)
15086       return -1;
15087   }
15088   {
15089     char device[] = "/dev/sda3";
15090     int r;
15091     suppress_error = 0;
15092     r = guestfs_pvcreate (g, device);
15093     if (r == -1)
15094       return -1;
15095   }
15096   {
15097     char volgroup[] = "VG1";
15098     char physvols_0[] = "/dev/sda1";
15099     char physvols_1[] = "/dev/sda2";
15100     char *physvols[] = {
15101       physvols_0,
15102       physvols_1,
15103       NULL
15104     };
15105     int r;
15106     suppress_error = 0;
15107     r = guestfs_vgcreate (g, volgroup, physvols);
15108     if (r == -1)
15109       return -1;
15110   }
15111   {
15112     char volgroup[] = "VG2";
15113     char physvols_0[] = "/dev/sda3";
15114     char *physvols[] = {
15115       physvols_0,
15116       NULL
15117     };
15118     int r;
15119     suppress_error = 0;
15120     r = guestfs_vgcreate (g, volgroup, physvols);
15121     if (r == -1)
15122       return -1;
15123   }
15124   {
15125     char **r;
15126     int i;
15127     suppress_error = 0;
15128     r = guestfs_vgs (g);
15129     if (r == NULL)
15130       return -1;
15131     if (!r[0]) {
15132       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15133       print_strings (r);
15134       return -1;
15135     }
15136     {
15137       char expected[] = "VG1";
15138       if (strcmp (r[0], expected) != 0) {
15139         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15140         return -1;
15141       }
15142     }
15143     if (!r[1]) {
15144       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15145       print_strings (r);
15146       return -1;
15147     }
15148     {
15149       char expected[] = "VG2";
15150       if (strcmp (r[1], expected) != 0) {
15151         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15152         return -1;
15153       }
15154     }
15155     if (r[2] != NULL) {
15156       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
15157       print_strings (r);
15158       return -1;
15159     }
15160     for (i = 0; r[i] != NULL; ++i)
15161       free (r[i]);
15162     free (r);
15163   }
15164   return 0;
15165 }
15166
15167 static int test_pvcreate_0_skip (void)
15168 {
15169   const char *str;
15170
15171   str = getenv ("TEST_ONLY");
15172   if (str)
15173     return strstr (str, "pvcreate") == NULL;
15174   str = getenv ("SKIP_TEST_PVCREATE_0");
15175   if (str && strcmp (str, "1") == 0) return 1;
15176   str = getenv ("SKIP_TEST_PVCREATE");
15177   if (str && strcmp (str, "1") == 0) return 1;
15178   return 0;
15179 }
15180
15181 static int test_pvcreate_0 (void)
15182 {
15183   if (test_pvcreate_0_skip ()) {
15184     printf ("        %s skipped (reason: environment variable set)\n", "test_pvcreate_0");
15185     return 0;
15186   }
15187
15188   /* InitNone|InitEmpty for test_pvcreate_0 */
15189   {
15190     char device[] = "/dev/sda";
15191     int r;
15192     suppress_error = 0;
15193     r = guestfs_blockdev_setrw (g, device);
15194     if (r == -1)
15195       return -1;
15196   }
15197   {
15198     int r;
15199     suppress_error = 0;
15200     r = guestfs_umount_all (g);
15201     if (r == -1)
15202       return -1;
15203   }
15204   {
15205     int r;
15206     suppress_error = 0;
15207     r = guestfs_lvm_remove_all (g);
15208     if (r == -1)
15209       return -1;
15210   }
15211   /* TestOutputListOfDevices for pvcreate (0) */
15212   {
15213     char device[] = "/dev/sda";
15214     char lines_0[] = ",200";
15215     char lines_1[] = ",400";
15216     char lines_2[] = ",";
15217     char *lines[] = {
15218       lines_0,
15219       lines_1,
15220       lines_2,
15221       NULL
15222     };
15223     int r;
15224     suppress_error = 0;
15225     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15226     if (r == -1)
15227       return -1;
15228   }
15229   {
15230     char device[] = "/dev/sda1";
15231     int r;
15232     suppress_error = 0;
15233     r = guestfs_pvcreate (g, device);
15234     if (r == -1)
15235       return -1;
15236   }
15237   {
15238     char device[] = "/dev/sda2";
15239     int r;
15240     suppress_error = 0;
15241     r = guestfs_pvcreate (g, device);
15242     if (r == -1)
15243       return -1;
15244   }
15245   {
15246     char device[] = "/dev/sda3";
15247     int r;
15248     suppress_error = 0;
15249     r = guestfs_pvcreate (g, device);
15250     if (r == -1)
15251       return -1;
15252   }
15253   {
15254     char **r;
15255     int i;
15256     suppress_error = 0;
15257     r = guestfs_pvs (g);
15258     if (r == NULL)
15259       return -1;
15260     if (!r[0]) {
15261       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15262       print_strings (r);
15263       return -1;
15264     }
15265     {
15266       char expected[] = "/dev/sda1";
15267       r[0][5] = 's';
15268       if (strcmp (r[0], expected) != 0) {
15269         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15270         return -1;
15271       }
15272     }
15273     if (!r[1]) {
15274       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15275       print_strings (r);
15276       return -1;
15277     }
15278     {
15279       char expected[] = "/dev/sda2";
15280       r[1][5] = 's';
15281       if (strcmp (r[1], expected) != 0) {
15282         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15283         return -1;
15284       }
15285     }
15286     if (!r[2]) {
15287       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15288       print_strings (r);
15289       return -1;
15290     }
15291     {
15292       char expected[] = "/dev/sda3";
15293       r[2][5] = 's';
15294       if (strcmp (r[2], expected) != 0) {
15295         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15296         return -1;
15297       }
15298     }
15299     if (r[3] != NULL) {
15300       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
15301       print_strings (r);
15302       return -1;
15303     }
15304     for (i = 0; r[i] != NULL; ++i)
15305       free (r[i]);
15306     free (r);
15307   }
15308   return 0;
15309 }
15310
15311 static int test_is_dir_0_skip (void)
15312 {
15313   const char *str;
15314
15315   str = getenv ("TEST_ONLY");
15316   if (str)
15317     return strstr (str, "is_dir") == NULL;
15318   str = getenv ("SKIP_TEST_IS_DIR_0");
15319   if (str && strcmp (str, "1") == 0) return 1;
15320   str = getenv ("SKIP_TEST_IS_DIR");
15321   if (str && strcmp (str, "1") == 0) return 1;
15322   return 0;
15323 }
15324
15325 static int test_is_dir_0 (void)
15326 {
15327   if (test_is_dir_0_skip ()) {
15328     printf ("        %s skipped (reason: environment variable set)\n", "test_is_dir_0");
15329     return 0;
15330   }
15331
15332   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
15333   {
15334     char device[] = "/dev/sda";
15335     int r;
15336     suppress_error = 0;
15337     r = guestfs_blockdev_setrw (g, device);
15338     if (r == -1)
15339       return -1;
15340   }
15341   {
15342     int r;
15343     suppress_error = 0;
15344     r = guestfs_umount_all (g);
15345     if (r == -1)
15346       return -1;
15347   }
15348   {
15349     int r;
15350     suppress_error = 0;
15351     r = guestfs_lvm_remove_all (g);
15352     if (r == -1)
15353       return -1;
15354   }
15355   {
15356     char device[] = "/dev/sda";
15357     char lines_0[] = ",";
15358     char *lines[] = {
15359       lines_0,
15360       NULL
15361     };
15362     int r;
15363     suppress_error = 0;
15364     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15365     if (r == -1)
15366       return -1;
15367   }
15368   {
15369     char fstype[] = "ext2";
15370     char device[] = "/dev/sda1";
15371     int r;
15372     suppress_error = 0;
15373     r = guestfs_mkfs (g, fstype, device);
15374     if (r == -1)
15375       return -1;
15376   }
15377   {
15378     char device[] = "/dev/sda1";
15379     char mountpoint[] = "/";
15380     int r;
15381     suppress_error = 0;
15382     r = guestfs_mount (g, device, mountpoint);
15383     if (r == -1)
15384       return -1;
15385   }
15386   /* TestOutputFalse for is_dir (0) */
15387   {
15388     char path[] = "/new";
15389     int r;
15390     suppress_error = 0;
15391     r = guestfs_touch (g, path);
15392     if (r == -1)
15393       return -1;
15394   }
15395   {
15396     char path[] = "/new";
15397     int r;
15398     suppress_error = 0;
15399     r = guestfs_is_dir (g, path);
15400     if (r == -1)
15401       return -1;
15402     if (r) {
15403       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
15404       return -1;
15405     }
15406   }
15407   return 0;
15408 }
15409
15410 static int test_is_dir_1_skip (void)
15411 {
15412   const char *str;
15413
15414   str = getenv ("TEST_ONLY");
15415   if (str)
15416     return strstr (str, "is_dir") == NULL;
15417   str = getenv ("SKIP_TEST_IS_DIR_1");
15418   if (str && strcmp (str, "1") == 0) return 1;
15419   str = getenv ("SKIP_TEST_IS_DIR");
15420   if (str && strcmp (str, "1") == 0) return 1;
15421   return 0;
15422 }
15423
15424 static int test_is_dir_1 (void)
15425 {
15426   if (test_is_dir_1_skip ()) {
15427     printf ("        %s skipped (reason: environment variable set)\n", "test_is_dir_1");
15428     return 0;
15429   }
15430
15431   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
15432   {
15433     char device[] = "/dev/sda";
15434     int r;
15435     suppress_error = 0;
15436     r = guestfs_blockdev_setrw (g, device);
15437     if (r == -1)
15438       return -1;
15439   }
15440   {
15441     int r;
15442     suppress_error = 0;
15443     r = guestfs_umount_all (g);
15444     if (r == -1)
15445       return -1;
15446   }
15447   {
15448     int r;
15449     suppress_error = 0;
15450     r = guestfs_lvm_remove_all (g);
15451     if (r == -1)
15452       return -1;
15453   }
15454   {
15455     char device[] = "/dev/sda";
15456     char lines_0[] = ",";
15457     char *lines[] = {
15458       lines_0,
15459       NULL
15460     };
15461     int r;
15462     suppress_error = 0;
15463     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15464     if (r == -1)
15465       return -1;
15466   }
15467   {
15468     char fstype[] = "ext2";
15469     char device[] = "/dev/sda1";
15470     int r;
15471     suppress_error = 0;
15472     r = guestfs_mkfs (g, fstype, device);
15473     if (r == -1)
15474       return -1;
15475   }
15476   {
15477     char device[] = "/dev/sda1";
15478     char mountpoint[] = "/";
15479     int r;
15480     suppress_error = 0;
15481     r = guestfs_mount (g, device, mountpoint);
15482     if (r == -1)
15483       return -1;
15484   }
15485   /* TestOutputTrue for is_dir (1) */
15486   {
15487     char path[] = "/new";
15488     int r;
15489     suppress_error = 0;
15490     r = guestfs_mkdir (g, path);
15491     if (r == -1)
15492       return -1;
15493   }
15494   {
15495     char path[] = "/new";
15496     int r;
15497     suppress_error = 0;
15498     r = guestfs_is_dir (g, path);
15499     if (r == -1)
15500       return -1;
15501     if (!r) {
15502       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
15503       return -1;
15504     }
15505   }
15506   return 0;
15507 }
15508
15509 static int test_is_file_0_skip (void)
15510 {
15511   const char *str;
15512
15513   str = getenv ("TEST_ONLY");
15514   if (str)
15515     return strstr (str, "is_file") == NULL;
15516   str = getenv ("SKIP_TEST_IS_FILE_0");
15517   if (str && strcmp (str, "1") == 0) return 1;
15518   str = getenv ("SKIP_TEST_IS_FILE");
15519   if (str && strcmp (str, "1") == 0) return 1;
15520   return 0;
15521 }
15522
15523 static int test_is_file_0 (void)
15524 {
15525   if (test_is_file_0_skip ()) {
15526     printf ("        %s skipped (reason: environment variable set)\n", "test_is_file_0");
15527     return 0;
15528   }
15529
15530   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
15531   {
15532     char device[] = "/dev/sda";
15533     int r;
15534     suppress_error = 0;
15535     r = guestfs_blockdev_setrw (g, device);
15536     if (r == -1)
15537       return -1;
15538   }
15539   {
15540     int r;
15541     suppress_error = 0;
15542     r = guestfs_umount_all (g);
15543     if (r == -1)
15544       return -1;
15545   }
15546   {
15547     int r;
15548     suppress_error = 0;
15549     r = guestfs_lvm_remove_all (g);
15550     if (r == -1)
15551       return -1;
15552   }
15553   {
15554     char device[] = "/dev/sda";
15555     char lines_0[] = ",";
15556     char *lines[] = {
15557       lines_0,
15558       NULL
15559     };
15560     int r;
15561     suppress_error = 0;
15562     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15563     if (r == -1)
15564       return -1;
15565   }
15566   {
15567     char fstype[] = "ext2";
15568     char device[] = "/dev/sda1";
15569     int r;
15570     suppress_error = 0;
15571     r = guestfs_mkfs (g, fstype, device);
15572     if (r == -1)
15573       return -1;
15574   }
15575   {
15576     char device[] = "/dev/sda1";
15577     char mountpoint[] = "/";
15578     int r;
15579     suppress_error = 0;
15580     r = guestfs_mount (g, device, mountpoint);
15581     if (r == -1)
15582       return -1;
15583   }
15584   /* TestOutputTrue for is_file (0) */
15585   {
15586     char path[] = "/new";
15587     int r;
15588     suppress_error = 0;
15589     r = guestfs_touch (g, path);
15590     if (r == -1)
15591       return -1;
15592   }
15593   {
15594     char path[] = "/new";
15595     int r;
15596     suppress_error = 0;
15597     r = guestfs_is_file (g, path);
15598     if (r == -1)
15599       return -1;
15600     if (!r) {
15601       fprintf (stderr, "test_is_file_0: expected true, got false\n");
15602       return -1;
15603     }
15604   }
15605   return 0;
15606 }
15607
15608 static int test_is_file_1_skip (void)
15609 {
15610   const char *str;
15611
15612   str = getenv ("TEST_ONLY");
15613   if (str)
15614     return strstr (str, "is_file") == NULL;
15615   str = getenv ("SKIP_TEST_IS_FILE_1");
15616   if (str && strcmp (str, "1") == 0) return 1;
15617   str = getenv ("SKIP_TEST_IS_FILE");
15618   if (str && strcmp (str, "1") == 0) return 1;
15619   return 0;
15620 }
15621
15622 static int test_is_file_1 (void)
15623 {
15624   if (test_is_file_1_skip ()) {
15625     printf ("        %s skipped (reason: environment variable set)\n", "test_is_file_1");
15626     return 0;
15627   }
15628
15629   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
15630   {
15631     char device[] = "/dev/sda";
15632     int r;
15633     suppress_error = 0;
15634     r = guestfs_blockdev_setrw (g, device);
15635     if (r == -1)
15636       return -1;
15637   }
15638   {
15639     int r;
15640     suppress_error = 0;
15641     r = guestfs_umount_all (g);
15642     if (r == -1)
15643       return -1;
15644   }
15645   {
15646     int r;
15647     suppress_error = 0;
15648     r = guestfs_lvm_remove_all (g);
15649     if (r == -1)
15650       return -1;
15651   }
15652   {
15653     char device[] = "/dev/sda";
15654     char lines_0[] = ",";
15655     char *lines[] = {
15656       lines_0,
15657       NULL
15658     };
15659     int r;
15660     suppress_error = 0;
15661     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15662     if (r == -1)
15663       return -1;
15664   }
15665   {
15666     char fstype[] = "ext2";
15667     char device[] = "/dev/sda1";
15668     int r;
15669     suppress_error = 0;
15670     r = guestfs_mkfs (g, fstype, device);
15671     if (r == -1)
15672       return -1;
15673   }
15674   {
15675     char device[] = "/dev/sda1";
15676     char mountpoint[] = "/";
15677     int r;
15678     suppress_error = 0;
15679     r = guestfs_mount (g, device, mountpoint);
15680     if (r == -1)
15681       return -1;
15682   }
15683   /* TestOutputFalse for is_file (1) */
15684   {
15685     char path[] = "/new";
15686     int r;
15687     suppress_error = 0;
15688     r = guestfs_mkdir (g, path);
15689     if (r == -1)
15690       return -1;
15691   }
15692   {
15693     char path[] = "/new";
15694     int r;
15695     suppress_error = 0;
15696     r = guestfs_is_file (g, path);
15697     if (r == -1)
15698       return -1;
15699     if (r) {
15700       fprintf (stderr, "test_is_file_1: expected false, got true\n");
15701       return -1;
15702     }
15703   }
15704   return 0;
15705 }
15706
15707 static int test_exists_0_skip (void)
15708 {
15709   const char *str;
15710
15711   str = getenv ("TEST_ONLY");
15712   if (str)
15713     return strstr (str, "exists") == NULL;
15714   str = getenv ("SKIP_TEST_EXISTS_0");
15715   if (str && strcmp (str, "1") == 0) return 1;
15716   str = getenv ("SKIP_TEST_EXISTS");
15717   if (str && strcmp (str, "1") == 0) return 1;
15718   return 0;
15719 }
15720
15721 static int test_exists_0 (void)
15722 {
15723   if (test_exists_0_skip ()) {
15724     printf ("        %s skipped (reason: environment variable set)\n", "test_exists_0");
15725     return 0;
15726   }
15727
15728   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15729   {
15730     char device[] = "/dev/sda";
15731     int r;
15732     suppress_error = 0;
15733     r = guestfs_blockdev_setrw (g, device);
15734     if (r == -1)
15735       return -1;
15736   }
15737   {
15738     int r;
15739     suppress_error = 0;
15740     r = guestfs_umount_all (g);
15741     if (r == -1)
15742       return -1;
15743   }
15744   {
15745     int r;
15746     suppress_error = 0;
15747     r = guestfs_lvm_remove_all (g);
15748     if (r == -1)
15749       return -1;
15750   }
15751   {
15752     char device[] = "/dev/sda";
15753     char lines_0[] = ",";
15754     char *lines[] = {
15755       lines_0,
15756       NULL
15757     };
15758     int r;
15759     suppress_error = 0;
15760     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15761     if (r == -1)
15762       return -1;
15763   }
15764   {
15765     char fstype[] = "ext2";
15766     char device[] = "/dev/sda1";
15767     int r;
15768     suppress_error = 0;
15769     r = guestfs_mkfs (g, fstype, device);
15770     if (r == -1)
15771       return -1;
15772   }
15773   {
15774     char device[] = "/dev/sda1";
15775     char mountpoint[] = "/";
15776     int r;
15777     suppress_error = 0;
15778     r = guestfs_mount (g, device, mountpoint);
15779     if (r == -1)
15780       return -1;
15781   }
15782   /* TestOutputTrue for exists (0) */
15783   {
15784     char path[] = "/new";
15785     int r;
15786     suppress_error = 0;
15787     r = guestfs_touch (g, path);
15788     if (r == -1)
15789       return -1;
15790   }
15791   {
15792     char path[] = "/new";
15793     int r;
15794     suppress_error = 0;
15795     r = guestfs_exists (g, path);
15796     if (r == -1)
15797       return -1;
15798     if (!r) {
15799       fprintf (stderr, "test_exists_0: expected true, got false\n");
15800       return -1;
15801     }
15802   }
15803   return 0;
15804 }
15805
15806 static int test_exists_1_skip (void)
15807 {
15808   const char *str;
15809
15810   str = getenv ("TEST_ONLY");
15811   if (str)
15812     return strstr (str, "exists") == NULL;
15813   str = getenv ("SKIP_TEST_EXISTS_1");
15814   if (str && strcmp (str, "1") == 0) return 1;
15815   str = getenv ("SKIP_TEST_EXISTS");
15816   if (str && strcmp (str, "1") == 0) return 1;
15817   return 0;
15818 }
15819
15820 static int test_exists_1 (void)
15821 {
15822   if (test_exists_1_skip ()) {
15823     printf ("        %s skipped (reason: environment variable set)\n", "test_exists_1");
15824     return 0;
15825   }
15826
15827   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15828   {
15829     char device[] = "/dev/sda";
15830     int r;
15831     suppress_error = 0;
15832     r = guestfs_blockdev_setrw (g, device);
15833     if (r == -1)
15834       return -1;
15835   }
15836   {
15837     int r;
15838     suppress_error = 0;
15839     r = guestfs_umount_all (g);
15840     if (r == -1)
15841       return -1;
15842   }
15843   {
15844     int r;
15845     suppress_error = 0;
15846     r = guestfs_lvm_remove_all (g);
15847     if (r == -1)
15848       return -1;
15849   }
15850   {
15851     char device[] = "/dev/sda";
15852     char lines_0[] = ",";
15853     char *lines[] = {
15854       lines_0,
15855       NULL
15856     };
15857     int r;
15858     suppress_error = 0;
15859     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15860     if (r == -1)
15861       return -1;
15862   }
15863   {
15864     char fstype[] = "ext2";
15865     char device[] = "/dev/sda1";
15866     int r;
15867     suppress_error = 0;
15868     r = guestfs_mkfs (g, fstype, device);
15869     if (r == -1)
15870       return -1;
15871   }
15872   {
15873     char device[] = "/dev/sda1";
15874     char mountpoint[] = "/";
15875     int r;
15876     suppress_error = 0;
15877     r = guestfs_mount (g, device, mountpoint);
15878     if (r == -1)
15879       return -1;
15880   }
15881   /* TestOutputTrue for exists (1) */
15882   {
15883     char path[] = "/new";
15884     int r;
15885     suppress_error = 0;
15886     r = guestfs_mkdir (g, path);
15887     if (r == -1)
15888       return -1;
15889   }
15890   {
15891     char path[] = "/new";
15892     int r;
15893     suppress_error = 0;
15894     r = guestfs_exists (g, path);
15895     if (r == -1)
15896       return -1;
15897     if (!r) {
15898       fprintf (stderr, "test_exists_1: expected true, got false\n");
15899       return -1;
15900     }
15901   }
15902   return 0;
15903 }
15904
15905 static int test_mkdir_p_0_skip (void)
15906 {
15907   const char *str;
15908
15909   str = getenv ("TEST_ONLY");
15910   if (str)
15911     return strstr (str, "mkdir_p") == NULL;
15912   str = getenv ("SKIP_TEST_MKDIR_P_0");
15913   if (str && strcmp (str, "1") == 0) return 1;
15914   str = getenv ("SKIP_TEST_MKDIR_P");
15915   if (str && strcmp (str, "1") == 0) return 1;
15916   return 0;
15917 }
15918
15919 static int test_mkdir_p_0 (void)
15920 {
15921   if (test_mkdir_p_0_skip ()) {
15922     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15923     return 0;
15924   }
15925
15926   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15927   {
15928     char device[] = "/dev/sda";
15929     int r;
15930     suppress_error = 0;
15931     r = guestfs_blockdev_setrw (g, device);
15932     if (r == -1)
15933       return -1;
15934   }
15935   {
15936     int r;
15937     suppress_error = 0;
15938     r = guestfs_umount_all (g);
15939     if (r == -1)
15940       return -1;
15941   }
15942   {
15943     int r;
15944     suppress_error = 0;
15945     r = guestfs_lvm_remove_all (g);
15946     if (r == -1)
15947       return -1;
15948   }
15949   {
15950     char device[] = "/dev/sda";
15951     char lines_0[] = ",";
15952     char *lines[] = {
15953       lines_0,
15954       NULL
15955     };
15956     int r;
15957     suppress_error = 0;
15958     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15959     if (r == -1)
15960       return -1;
15961   }
15962   {
15963     char fstype[] = "ext2";
15964     char device[] = "/dev/sda1";
15965     int r;
15966     suppress_error = 0;
15967     r = guestfs_mkfs (g, fstype, device);
15968     if (r == -1)
15969       return -1;
15970   }
15971   {
15972     char device[] = "/dev/sda1";
15973     char mountpoint[] = "/";
15974     int r;
15975     suppress_error = 0;
15976     r = guestfs_mount (g, device, mountpoint);
15977     if (r == -1)
15978       return -1;
15979   }
15980   /* TestOutputTrue for mkdir_p (0) */
15981   {
15982     char path[] = "/new/foo/bar";
15983     int r;
15984     suppress_error = 0;
15985     r = guestfs_mkdir_p (g, path);
15986     if (r == -1)
15987       return -1;
15988   }
15989   {
15990     char path[] = "/new/foo/bar";
15991     int r;
15992     suppress_error = 0;
15993     r = guestfs_is_dir (g, path);
15994     if (r == -1)
15995       return -1;
15996     if (!r) {
15997       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15998       return -1;
15999     }
16000   }
16001   return 0;
16002 }
16003
16004 static int test_mkdir_p_1_skip (void)
16005 {
16006   const char *str;
16007
16008   str = getenv ("TEST_ONLY");
16009   if (str)
16010     return strstr (str, "mkdir_p") == NULL;
16011   str = getenv ("SKIP_TEST_MKDIR_P_1");
16012   if (str && strcmp (str, "1") == 0) return 1;
16013   str = getenv ("SKIP_TEST_MKDIR_P");
16014   if (str && strcmp (str, "1") == 0) return 1;
16015   return 0;
16016 }
16017
16018 static int test_mkdir_p_1 (void)
16019 {
16020   if (test_mkdir_p_1_skip ()) {
16021     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
16022     return 0;
16023   }
16024
16025   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
16026   {
16027     char device[] = "/dev/sda";
16028     int r;
16029     suppress_error = 0;
16030     r = guestfs_blockdev_setrw (g, device);
16031     if (r == -1)
16032       return -1;
16033   }
16034   {
16035     int r;
16036     suppress_error = 0;
16037     r = guestfs_umount_all (g);
16038     if (r == -1)
16039       return -1;
16040   }
16041   {
16042     int r;
16043     suppress_error = 0;
16044     r = guestfs_lvm_remove_all (g);
16045     if (r == -1)
16046       return -1;
16047   }
16048   {
16049     char device[] = "/dev/sda";
16050     char lines_0[] = ",";
16051     char *lines[] = {
16052       lines_0,
16053       NULL
16054     };
16055     int r;
16056     suppress_error = 0;
16057     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16058     if (r == -1)
16059       return -1;
16060   }
16061   {
16062     char fstype[] = "ext2";
16063     char device[] = "/dev/sda1";
16064     int r;
16065     suppress_error = 0;
16066     r = guestfs_mkfs (g, fstype, device);
16067     if (r == -1)
16068       return -1;
16069   }
16070   {
16071     char device[] = "/dev/sda1";
16072     char mountpoint[] = "/";
16073     int r;
16074     suppress_error = 0;
16075     r = guestfs_mount (g, device, mountpoint);
16076     if (r == -1)
16077       return -1;
16078   }
16079   /* TestOutputTrue for mkdir_p (1) */
16080   {
16081     char path[] = "/new/foo/bar";
16082     int r;
16083     suppress_error = 0;
16084     r = guestfs_mkdir_p (g, path);
16085     if (r == -1)
16086       return -1;
16087   }
16088   {
16089     char path[] = "/new/foo";
16090     int r;
16091     suppress_error = 0;
16092     r = guestfs_is_dir (g, path);
16093     if (r == -1)
16094       return -1;
16095     if (!r) {
16096       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
16097       return -1;
16098     }
16099   }
16100   return 0;
16101 }
16102
16103 static int test_mkdir_p_2_skip (void)
16104 {
16105   const char *str;
16106
16107   str = getenv ("TEST_ONLY");
16108   if (str)
16109     return strstr (str, "mkdir_p") == NULL;
16110   str = getenv ("SKIP_TEST_MKDIR_P_2");
16111   if (str && strcmp (str, "1") == 0) return 1;
16112   str = getenv ("SKIP_TEST_MKDIR_P");
16113   if (str && strcmp (str, "1") == 0) return 1;
16114   return 0;
16115 }
16116
16117 static int test_mkdir_p_2 (void)
16118 {
16119   if (test_mkdir_p_2_skip ()) {
16120     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
16121     return 0;
16122   }
16123
16124   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
16125   {
16126     char device[] = "/dev/sda";
16127     int r;
16128     suppress_error = 0;
16129     r = guestfs_blockdev_setrw (g, device);
16130     if (r == -1)
16131       return -1;
16132   }
16133   {
16134     int r;
16135     suppress_error = 0;
16136     r = guestfs_umount_all (g);
16137     if (r == -1)
16138       return -1;
16139   }
16140   {
16141     int r;
16142     suppress_error = 0;
16143     r = guestfs_lvm_remove_all (g);
16144     if (r == -1)
16145       return -1;
16146   }
16147   {
16148     char device[] = "/dev/sda";
16149     char lines_0[] = ",";
16150     char *lines[] = {
16151       lines_0,
16152       NULL
16153     };
16154     int r;
16155     suppress_error = 0;
16156     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16157     if (r == -1)
16158       return -1;
16159   }
16160   {
16161     char fstype[] = "ext2";
16162     char device[] = "/dev/sda1";
16163     int r;
16164     suppress_error = 0;
16165     r = guestfs_mkfs (g, fstype, device);
16166     if (r == -1)
16167       return -1;
16168   }
16169   {
16170     char device[] = "/dev/sda1";
16171     char mountpoint[] = "/";
16172     int r;
16173     suppress_error = 0;
16174     r = guestfs_mount (g, device, mountpoint);
16175     if (r == -1)
16176       return -1;
16177   }
16178   /* TestOutputTrue for mkdir_p (2) */
16179   {
16180     char path[] = "/new/foo/bar";
16181     int r;
16182     suppress_error = 0;
16183     r = guestfs_mkdir_p (g, path);
16184     if (r == -1)
16185       return -1;
16186   }
16187   {
16188     char path[] = "/new";
16189     int r;
16190     suppress_error = 0;
16191     r = guestfs_is_dir (g, path);
16192     if (r == -1)
16193       return -1;
16194     if (!r) {
16195       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
16196       return -1;
16197     }
16198   }
16199   return 0;
16200 }
16201
16202 static int test_mkdir_p_3_skip (void)
16203 {
16204   const char *str;
16205
16206   str = getenv ("TEST_ONLY");
16207   if (str)
16208     return strstr (str, "mkdir_p") == NULL;
16209   str = getenv ("SKIP_TEST_MKDIR_P_3");
16210   if (str && strcmp (str, "1") == 0) return 1;
16211   str = getenv ("SKIP_TEST_MKDIR_P");
16212   if (str && strcmp (str, "1") == 0) return 1;
16213   return 0;
16214 }
16215
16216 static int test_mkdir_p_3 (void)
16217 {
16218   if (test_mkdir_p_3_skip ()) {
16219     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
16220     return 0;
16221   }
16222
16223   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
16224   {
16225     char device[] = "/dev/sda";
16226     int r;
16227     suppress_error = 0;
16228     r = guestfs_blockdev_setrw (g, device);
16229     if (r == -1)
16230       return -1;
16231   }
16232   {
16233     int r;
16234     suppress_error = 0;
16235     r = guestfs_umount_all (g);
16236     if (r == -1)
16237       return -1;
16238   }
16239   {
16240     int r;
16241     suppress_error = 0;
16242     r = guestfs_lvm_remove_all (g);
16243     if (r == -1)
16244       return -1;
16245   }
16246   {
16247     char device[] = "/dev/sda";
16248     char lines_0[] = ",";
16249     char *lines[] = {
16250       lines_0,
16251       NULL
16252     };
16253     int r;
16254     suppress_error = 0;
16255     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16256     if (r == -1)
16257       return -1;
16258   }
16259   {
16260     char fstype[] = "ext2";
16261     char device[] = "/dev/sda1";
16262     int r;
16263     suppress_error = 0;
16264     r = guestfs_mkfs (g, fstype, device);
16265     if (r == -1)
16266       return -1;
16267   }
16268   {
16269     char device[] = "/dev/sda1";
16270     char mountpoint[] = "/";
16271     int r;
16272     suppress_error = 0;
16273     r = guestfs_mount (g, device, mountpoint);
16274     if (r == -1)
16275       return -1;
16276   }
16277   /* TestRun for mkdir_p (3) */
16278   {
16279     char path[] = "/new";
16280     int r;
16281     suppress_error = 0;
16282     r = guestfs_mkdir (g, path);
16283     if (r == -1)
16284       return -1;
16285   }
16286   {
16287     char path[] = "/new";
16288     int r;
16289     suppress_error = 0;
16290     r = guestfs_mkdir_p (g, path);
16291     if (r == -1)
16292       return -1;
16293   }
16294   return 0;
16295 }
16296
16297 static int test_mkdir_p_4_skip (void)
16298 {
16299   const char *str;
16300
16301   str = getenv ("TEST_ONLY");
16302   if (str)
16303     return strstr (str, "mkdir_p") == NULL;
16304   str = getenv ("SKIP_TEST_MKDIR_P_4");
16305   if (str && strcmp (str, "1") == 0) return 1;
16306   str = getenv ("SKIP_TEST_MKDIR_P");
16307   if (str && strcmp (str, "1") == 0) return 1;
16308   return 0;
16309 }
16310
16311 static int test_mkdir_p_4 (void)
16312 {
16313   if (test_mkdir_p_4_skip ()) {
16314     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
16315     return 0;
16316   }
16317
16318   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
16319   {
16320     char device[] = "/dev/sda";
16321     int r;
16322     suppress_error = 0;
16323     r = guestfs_blockdev_setrw (g, device);
16324     if (r == -1)
16325       return -1;
16326   }
16327   {
16328     int r;
16329     suppress_error = 0;
16330     r = guestfs_umount_all (g);
16331     if (r == -1)
16332       return -1;
16333   }
16334   {
16335     int r;
16336     suppress_error = 0;
16337     r = guestfs_lvm_remove_all (g);
16338     if (r == -1)
16339       return -1;
16340   }
16341   {
16342     char device[] = "/dev/sda";
16343     char lines_0[] = ",";
16344     char *lines[] = {
16345       lines_0,
16346       NULL
16347     };
16348     int r;
16349     suppress_error = 0;
16350     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16351     if (r == -1)
16352       return -1;
16353   }
16354   {
16355     char fstype[] = "ext2";
16356     char device[] = "/dev/sda1";
16357     int r;
16358     suppress_error = 0;
16359     r = guestfs_mkfs (g, fstype, device);
16360     if (r == -1)
16361       return -1;
16362   }
16363   {
16364     char device[] = "/dev/sda1";
16365     char mountpoint[] = "/";
16366     int r;
16367     suppress_error = 0;
16368     r = guestfs_mount (g, device, mountpoint);
16369     if (r == -1)
16370       return -1;
16371   }
16372   /* TestLastFail for mkdir_p (4) */
16373   {
16374     char path[] = "/new";
16375     int r;
16376     suppress_error = 0;
16377     r = guestfs_touch (g, path);
16378     if (r == -1)
16379       return -1;
16380   }
16381   {
16382     char path[] = "/new";
16383     int r;
16384     suppress_error = 1;
16385     r = guestfs_mkdir_p (g, path);
16386     if (r != -1)
16387       return -1;
16388   }
16389   return 0;
16390 }
16391
16392 static int test_mkdir_0_skip (void)
16393 {
16394   const char *str;
16395
16396   str = getenv ("TEST_ONLY");
16397   if (str)
16398     return strstr (str, "mkdir") == NULL;
16399   str = getenv ("SKIP_TEST_MKDIR_0");
16400   if (str && strcmp (str, "1") == 0) return 1;
16401   str = getenv ("SKIP_TEST_MKDIR");
16402   if (str && strcmp (str, "1") == 0) return 1;
16403   return 0;
16404 }
16405
16406 static int test_mkdir_0 (void)
16407 {
16408   if (test_mkdir_0_skip ()) {
16409     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_0");
16410     return 0;
16411   }
16412
16413   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
16414   {
16415     char device[] = "/dev/sda";
16416     int r;
16417     suppress_error = 0;
16418     r = guestfs_blockdev_setrw (g, device);
16419     if (r == -1)
16420       return -1;
16421   }
16422   {
16423     int r;
16424     suppress_error = 0;
16425     r = guestfs_umount_all (g);
16426     if (r == -1)
16427       return -1;
16428   }
16429   {
16430     int r;
16431     suppress_error = 0;
16432     r = guestfs_lvm_remove_all (g);
16433     if (r == -1)
16434       return -1;
16435   }
16436   {
16437     char device[] = "/dev/sda";
16438     char lines_0[] = ",";
16439     char *lines[] = {
16440       lines_0,
16441       NULL
16442     };
16443     int r;
16444     suppress_error = 0;
16445     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16446     if (r == -1)
16447       return -1;
16448   }
16449   {
16450     char fstype[] = "ext2";
16451     char device[] = "/dev/sda1";
16452     int r;
16453     suppress_error = 0;
16454     r = guestfs_mkfs (g, fstype, device);
16455     if (r == -1)
16456       return -1;
16457   }
16458   {
16459     char device[] = "/dev/sda1";
16460     char mountpoint[] = "/";
16461     int r;
16462     suppress_error = 0;
16463     r = guestfs_mount (g, device, mountpoint);
16464     if (r == -1)
16465       return -1;
16466   }
16467   /* TestOutputTrue for mkdir (0) */
16468   {
16469     char path[] = "/new";
16470     int r;
16471     suppress_error = 0;
16472     r = guestfs_mkdir (g, path);
16473     if (r == -1)
16474       return -1;
16475   }
16476   {
16477     char path[] = "/new";
16478     int r;
16479     suppress_error = 0;
16480     r = guestfs_is_dir (g, path);
16481     if (r == -1)
16482       return -1;
16483     if (!r) {
16484       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
16485       return -1;
16486     }
16487   }
16488   return 0;
16489 }
16490
16491 static int test_mkdir_1_skip (void)
16492 {
16493   const char *str;
16494
16495   str = getenv ("TEST_ONLY");
16496   if (str)
16497     return strstr (str, "mkdir") == NULL;
16498   str = getenv ("SKIP_TEST_MKDIR_1");
16499   if (str && strcmp (str, "1") == 0) return 1;
16500   str = getenv ("SKIP_TEST_MKDIR");
16501   if (str && strcmp (str, "1") == 0) return 1;
16502   return 0;
16503 }
16504
16505 static int test_mkdir_1 (void)
16506 {
16507   if (test_mkdir_1_skip ()) {
16508     printf ("        %s skipped (reason: environment variable set)\n", "test_mkdir_1");
16509     return 0;
16510   }
16511
16512   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
16513   {
16514     char device[] = "/dev/sda";
16515     int r;
16516     suppress_error = 0;
16517     r = guestfs_blockdev_setrw (g, device);
16518     if (r == -1)
16519       return -1;
16520   }
16521   {
16522     int r;
16523     suppress_error = 0;
16524     r = guestfs_umount_all (g);
16525     if (r == -1)
16526       return -1;
16527   }
16528   {
16529     int r;
16530     suppress_error = 0;
16531     r = guestfs_lvm_remove_all (g);
16532     if (r == -1)
16533       return -1;
16534   }
16535   {
16536     char device[] = "/dev/sda";
16537     char lines_0[] = ",";
16538     char *lines[] = {
16539       lines_0,
16540       NULL
16541     };
16542     int r;
16543     suppress_error = 0;
16544     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16545     if (r == -1)
16546       return -1;
16547   }
16548   {
16549     char fstype[] = "ext2";
16550     char device[] = "/dev/sda1";
16551     int r;
16552     suppress_error = 0;
16553     r = guestfs_mkfs (g, fstype, device);
16554     if (r == -1)
16555       return -1;
16556   }
16557   {
16558     char device[] = "/dev/sda1";
16559     char mountpoint[] = "/";
16560     int r;
16561     suppress_error = 0;
16562     r = guestfs_mount (g, device, mountpoint);
16563     if (r == -1)
16564       return -1;
16565   }
16566   /* TestLastFail for mkdir (1) */
16567   {
16568     char path[] = "/new/foo/bar";
16569     int r;
16570     suppress_error = 1;
16571     r = guestfs_mkdir (g, path);
16572     if (r != -1)
16573       return -1;
16574   }
16575   return 0;
16576 }
16577
16578 static int test_rm_rf_0_skip (void)
16579 {
16580   const char *str;
16581
16582   str = getenv ("TEST_ONLY");
16583   if (str)
16584     return strstr (str, "rm_rf") == NULL;
16585   str = getenv ("SKIP_TEST_RM_RF_0");
16586   if (str && strcmp (str, "1") == 0) return 1;
16587   str = getenv ("SKIP_TEST_RM_RF");
16588   if (str && strcmp (str, "1") == 0) return 1;
16589   return 0;
16590 }
16591
16592 static int test_rm_rf_0 (void)
16593 {
16594   if (test_rm_rf_0_skip ()) {
16595     printf ("        %s skipped (reason: environment variable set)\n", "test_rm_rf_0");
16596     return 0;
16597   }
16598
16599   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
16600   {
16601     char device[] = "/dev/sda";
16602     int r;
16603     suppress_error = 0;
16604     r = guestfs_blockdev_setrw (g, device);
16605     if (r == -1)
16606       return -1;
16607   }
16608   {
16609     int r;
16610     suppress_error = 0;
16611     r = guestfs_umount_all (g);
16612     if (r == -1)
16613       return -1;
16614   }
16615   {
16616     int r;
16617     suppress_error = 0;
16618     r = guestfs_lvm_remove_all (g);
16619     if (r == -1)
16620       return -1;
16621   }
16622   {
16623     char device[] = "/dev/sda";
16624     char lines_0[] = ",";
16625     char *lines[] = {
16626       lines_0,
16627       NULL
16628     };
16629     int r;
16630     suppress_error = 0;
16631     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16632     if (r == -1)
16633       return -1;
16634   }
16635   {
16636     char fstype[] = "ext2";
16637     char device[] = "/dev/sda1";
16638     int r;
16639     suppress_error = 0;
16640     r = guestfs_mkfs (g, fstype, device);
16641     if (r == -1)
16642       return -1;
16643   }
16644   {
16645     char device[] = "/dev/sda1";
16646     char mountpoint[] = "/";
16647     int r;
16648     suppress_error = 0;
16649     r = guestfs_mount (g, device, mountpoint);
16650     if (r == -1)
16651       return -1;
16652   }
16653   /* TestOutputFalse for rm_rf (0) */
16654   {
16655     char path[] = "/new";
16656     int r;
16657     suppress_error = 0;
16658     r = guestfs_mkdir (g, path);
16659     if (r == -1)
16660       return -1;
16661   }
16662   {
16663     char path[] = "/new/foo";
16664     int r;
16665     suppress_error = 0;
16666     r = guestfs_mkdir (g, path);
16667     if (r == -1)
16668       return -1;
16669   }
16670   {
16671     char path[] = "/new/foo/bar";
16672     int r;
16673     suppress_error = 0;
16674     r = guestfs_touch (g, path);
16675     if (r == -1)
16676       return -1;
16677   }
16678   {
16679     char path[] = "/new";
16680     int r;
16681     suppress_error = 0;
16682     r = guestfs_rm_rf (g, path);
16683     if (r == -1)
16684       return -1;
16685   }
16686   {
16687     char path[] = "/new";
16688     int r;
16689     suppress_error = 0;
16690     r = guestfs_exists (g, path);
16691     if (r == -1)
16692       return -1;
16693     if (r) {
16694       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16695       return -1;
16696     }
16697   }
16698   return 0;
16699 }
16700
16701 static int test_rmdir_0_skip (void)
16702 {
16703   const char *str;
16704
16705   str = getenv ("TEST_ONLY");
16706   if (str)
16707     return strstr (str, "rmdir") == NULL;
16708   str = getenv ("SKIP_TEST_RMDIR_0");
16709   if (str && strcmp (str, "1") == 0) return 1;
16710   str = getenv ("SKIP_TEST_RMDIR");
16711   if (str && strcmp (str, "1") == 0) return 1;
16712   return 0;
16713 }
16714
16715 static int test_rmdir_0 (void)
16716 {
16717   if (test_rmdir_0_skip ()) {
16718     printf ("        %s skipped (reason: environment variable set)\n", "test_rmdir_0");
16719     return 0;
16720   }
16721
16722   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16723   {
16724     char device[] = "/dev/sda";
16725     int r;
16726     suppress_error = 0;
16727     r = guestfs_blockdev_setrw (g, device);
16728     if (r == -1)
16729       return -1;
16730   }
16731   {
16732     int r;
16733     suppress_error = 0;
16734     r = guestfs_umount_all (g);
16735     if (r == -1)
16736       return -1;
16737   }
16738   {
16739     int r;
16740     suppress_error = 0;
16741     r = guestfs_lvm_remove_all (g);
16742     if (r == -1)
16743       return -1;
16744   }
16745   {
16746     char device[] = "/dev/sda";
16747     char lines_0[] = ",";
16748     char *lines[] = {
16749       lines_0,
16750       NULL
16751     };
16752     int r;
16753     suppress_error = 0;
16754     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16755     if (r == -1)
16756       return -1;
16757   }
16758   {
16759     char fstype[] = "ext2";
16760     char device[] = "/dev/sda1";
16761     int r;
16762     suppress_error = 0;
16763     r = guestfs_mkfs (g, fstype, device);
16764     if (r == -1)
16765       return -1;
16766   }
16767   {
16768     char device[] = "/dev/sda1";
16769     char mountpoint[] = "/";
16770     int r;
16771     suppress_error = 0;
16772     r = guestfs_mount (g, device, mountpoint);
16773     if (r == -1)
16774       return -1;
16775   }
16776   /* TestRun for rmdir (0) */
16777   {
16778     char path[] = "/new";
16779     int r;
16780     suppress_error = 0;
16781     r = guestfs_mkdir (g, path);
16782     if (r == -1)
16783       return -1;
16784   }
16785   {
16786     char path[] = "/new";
16787     int r;
16788     suppress_error = 0;
16789     r = guestfs_rmdir (g, path);
16790     if (r == -1)
16791       return -1;
16792   }
16793   return 0;
16794 }
16795
16796 static int test_rmdir_1_skip (void)
16797 {
16798   const char *str;
16799
16800   str = getenv ("TEST_ONLY");
16801   if (str)
16802     return strstr (str, "rmdir") == NULL;
16803   str = getenv ("SKIP_TEST_RMDIR_1");
16804   if (str && strcmp (str, "1") == 0) return 1;
16805   str = getenv ("SKIP_TEST_RMDIR");
16806   if (str && strcmp (str, "1") == 0) return 1;
16807   return 0;
16808 }
16809
16810 static int test_rmdir_1 (void)
16811 {
16812   if (test_rmdir_1_skip ()) {
16813     printf ("        %s skipped (reason: environment variable set)\n", "test_rmdir_1");
16814     return 0;
16815   }
16816
16817   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16818   {
16819     char device[] = "/dev/sda";
16820     int r;
16821     suppress_error = 0;
16822     r = guestfs_blockdev_setrw (g, device);
16823     if (r == -1)
16824       return -1;
16825   }
16826   {
16827     int r;
16828     suppress_error = 0;
16829     r = guestfs_umount_all (g);
16830     if (r == -1)
16831       return -1;
16832   }
16833   {
16834     int r;
16835     suppress_error = 0;
16836     r = guestfs_lvm_remove_all (g);
16837     if (r == -1)
16838       return -1;
16839   }
16840   {
16841     char device[] = "/dev/sda";
16842     char lines_0[] = ",";
16843     char *lines[] = {
16844       lines_0,
16845       NULL
16846     };
16847     int r;
16848     suppress_error = 0;
16849     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16850     if (r == -1)
16851       return -1;
16852   }
16853   {
16854     char fstype[] = "ext2";
16855     char device[] = "/dev/sda1";
16856     int r;
16857     suppress_error = 0;
16858     r = guestfs_mkfs (g, fstype, device);
16859     if (r == -1)
16860       return -1;
16861   }
16862   {
16863     char device[] = "/dev/sda1";
16864     char mountpoint[] = "/";
16865     int r;
16866     suppress_error = 0;
16867     r = guestfs_mount (g, device, mountpoint);
16868     if (r == -1)
16869       return -1;
16870   }
16871   /* TestLastFail for rmdir (1) */
16872   {
16873     char path[] = "/new";
16874     int r;
16875     suppress_error = 1;
16876     r = guestfs_rmdir (g, path);
16877     if (r != -1)
16878       return -1;
16879   }
16880   return 0;
16881 }
16882
16883 static int test_rmdir_2_skip (void)
16884 {
16885   const char *str;
16886
16887   str = getenv ("TEST_ONLY");
16888   if (str)
16889     return strstr (str, "rmdir") == NULL;
16890   str = getenv ("SKIP_TEST_RMDIR_2");
16891   if (str && strcmp (str, "1") == 0) return 1;
16892   str = getenv ("SKIP_TEST_RMDIR");
16893   if (str && strcmp (str, "1") == 0) return 1;
16894   return 0;
16895 }
16896
16897 static int test_rmdir_2 (void)
16898 {
16899   if (test_rmdir_2_skip ()) {
16900     printf ("        %s skipped (reason: environment variable set)\n", "test_rmdir_2");
16901     return 0;
16902   }
16903
16904   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16905   {
16906     char device[] = "/dev/sda";
16907     int r;
16908     suppress_error = 0;
16909     r = guestfs_blockdev_setrw (g, device);
16910     if (r == -1)
16911       return -1;
16912   }
16913   {
16914     int r;
16915     suppress_error = 0;
16916     r = guestfs_umount_all (g);
16917     if (r == -1)
16918       return -1;
16919   }
16920   {
16921     int r;
16922     suppress_error = 0;
16923     r = guestfs_lvm_remove_all (g);
16924     if (r == -1)
16925       return -1;
16926   }
16927   {
16928     char device[] = "/dev/sda";
16929     char lines_0[] = ",";
16930     char *lines[] = {
16931       lines_0,
16932       NULL
16933     };
16934     int r;
16935     suppress_error = 0;
16936     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16937     if (r == -1)
16938       return -1;
16939   }
16940   {
16941     char fstype[] = "ext2";
16942     char device[] = "/dev/sda1";
16943     int r;
16944     suppress_error = 0;
16945     r = guestfs_mkfs (g, fstype, device);
16946     if (r == -1)
16947       return -1;
16948   }
16949   {
16950     char device[] = "/dev/sda1";
16951     char mountpoint[] = "/";
16952     int r;
16953     suppress_error = 0;
16954     r = guestfs_mount (g, device, mountpoint);
16955     if (r == -1)
16956       return -1;
16957   }
16958   /* TestLastFail for rmdir (2) */
16959   {
16960     char path[] = "/new";
16961     int r;
16962     suppress_error = 0;
16963     r = guestfs_touch (g, path);
16964     if (r == -1)
16965       return -1;
16966   }
16967   {
16968     char path[] = "/new";
16969     int r;
16970     suppress_error = 1;
16971     r = guestfs_rmdir (g, path);
16972     if (r != -1)
16973       return -1;
16974   }
16975   return 0;
16976 }
16977
16978 static int test_rm_0_skip (void)
16979 {
16980   const char *str;
16981
16982   str = getenv ("TEST_ONLY");
16983   if (str)
16984     return strstr (str, "rm") == NULL;
16985   str = getenv ("SKIP_TEST_RM_0");
16986   if (str && strcmp (str, "1") == 0) return 1;
16987   str = getenv ("SKIP_TEST_RM");
16988   if (str && strcmp (str, "1") == 0) return 1;
16989   return 0;
16990 }
16991
16992 static int test_rm_0 (void)
16993 {
16994   if (test_rm_0_skip ()) {
16995     printf ("        %s skipped (reason: environment variable set)\n", "test_rm_0");
16996     return 0;
16997   }
16998
16999   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
17000   {
17001     char device[] = "/dev/sda";
17002     int r;
17003     suppress_error = 0;
17004     r = guestfs_blockdev_setrw (g, device);
17005     if (r == -1)
17006       return -1;
17007   }
17008   {
17009     int r;
17010     suppress_error = 0;
17011     r = guestfs_umount_all (g);
17012     if (r == -1)
17013       return -1;
17014   }
17015   {
17016     int r;
17017     suppress_error = 0;
17018     r = guestfs_lvm_remove_all (g);
17019     if (r == -1)
17020       return -1;
17021   }
17022   {
17023     char device[] = "/dev/sda";
17024     char lines_0[] = ",";
17025     char *lines[] = {
17026       lines_0,
17027       NULL
17028     };
17029     int r;
17030     suppress_error = 0;
17031     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17032     if (r == -1)
17033       return -1;
17034   }
17035   {
17036     char fstype[] = "ext2";
17037     char device[] = "/dev/sda1";
17038     int r;
17039     suppress_error = 0;
17040     r = guestfs_mkfs (g, fstype, device);
17041     if (r == -1)
17042       return -1;
17043   }
17044   {
17045     char device[] = "/dev/sda1";
17046     char mountpoint[] = "/";
17047     int r;
17048     suppress_error = 0;
17049     r = guestfs_mount (g, device, mountpoint);
17050     if (r == -1)
17051       return -1;
17052   }
17053   /* TestRun for rm (0) */
17054   {
17055     char path[] = "/new";
17056     int r;
17057     suppress_error = 0;
17058     r = guestfs_touch (g, path);
17059     if (r == -1)
17060       return -1;
17061   }
17062   {
17063     char path[] = "/new";
17064     int r;
17065     suppress_error = 0;
17066     r = guestfs_rm (g, path);
17067     if (r == -1)
17068       return -1;
17069   }
17070   return 0;
17071 }
17072
17073 static int test_rm_1_skip (void)
17074 {
17075   const char *str;
17076
17077   str = getenv ("TEST_ONLY");
17078   if (str)
17079     return strstr (str, "rm") == NULL;
17080   str = getenv ("SKIP_TEST_RM_1");
17081   if (str && strcmp (str, "1") == 0) return 1;
17082   str = getenv ("SKIP_TEST_RM");
17083   if (str && strcmp (str, "1") == 0) return 1;
17084   return 0;
17085 }
17086
17087 static int test_rm_1 (void)
17088 {
17089   if (test_rm_1_skip ()) {
17090     printf ("        %s skipped (reason: environment variable set)\n", "test_rm_1");
17091     return 0;
17092   }
17093
17094   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
17095   {
17096     char device[] = "/dev/sda";
17097     int r;
17098     suppress_error = 0;
17099     r = guestfs_blockdev_setrw (g, device);
17100     if (r == -1)
17101       return -1;
17102   }
17103   {
17104     int r;
17105     suppress_error = 0;
17106     r = guestfs_umount_all (g);
17107     if (r == -1)
17108       return -1;
17109   }
17110   {
17111     int r;
17112     suppress_error = 0;
17113     r = guestfs_lvm_remove_all (g);
17114     if (r == -1)
17115       return -1;
17116   }
17117   {
17118     char device[] = "/dev/sda";
17119     char lines_0[] = ",";
17120     char *lines[] = {
17121       lines_0,
17122       NULL
17123     };
17124     int r;
17125     suppress_error = 0;
17126     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17127     if (r == -1)
17128       return -1;
17129   }
17130   {
17131     char fstype[] = "ext2";
17132     char device[] = "/dev/sda1";
17133     int r;
17134     suppress_error = 0;
17135     r = guestfs_mkfs (g, fstype, device);
17136     if (r == -1)
17137       return -1;
17138   }
17139   {
17140     char device[] = "/dev/sda1";
17141     char mountpoint[] = "/";
17142     int r;
17143     suppress_error = 0;
17144     r = guestfs_mount (g, device, mountpoint);
17145     if (r == -1)
17146       return -1;
17147   }
17148   /* TestLastFail for rm (1) */
17149   {
17150     char path[] = "/new";
17151     int r;
17152     suppress_error = 1;
17153     r = guestfs_rm (g, path);
17154     if (r != -1)
17155       return -1;
17156   }
17157   return 0;
17158 }
17159
17160 static int test_rm_2_skip (void)
17161 {
17162   const char *str;
17163
17164   str = getenv ("TEST_ONLY");
17165   if (str)
17166     return strstr (str, "rm") == NULL;
17167   str = getenv ("SKIP_TEST_RM_2");
17168   if (str && strcmp (str, "1") == 0) return 1;
17169   str = getenv ("SKIP_TEST_RM");
17170   if (str && strcmp (str, "1") == 0) return 1;
17171   return 0;
17172 }
17173
17174 static int test_rm_2 (void)
17175 {
17176   if (test_rm_2_skip ()) {
17177     printf ("        %s skipped (reason: environment variable set)\n", "test_rm_2");
17178     return 0;
17179   }
17180
17181   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
17182   {
17183     char device[] = "/dev/sda";
17184     int r;
17185     suppress_error = 0;
17186     r = guestfs_blockdev_setrw (g, device);
17187     if (r == -1)
17188       return -1;
17189   }
17190   {
17191     int r;
17192     suppress_error = 0;
17193     r = guestfs_umount_all (g);
17194     if (r == -1)
17195       return -1;
17196   }
17197   {
17198     int r;
17199     suppress_error = 0;
17200     r = guestfs_lvm_remove_all (g);
17201     if (r == -1)
17202       return -1;
17203   }
17204   {
17205     char device[] = "/dev/sda";
17206     char lines_0[] = ",";
17207     char *lines[] = {
17208       lines_0,
17209       NULL
17210     };
17211     int r;
17212     suppress_error = 0;
17213     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17214     if (r == -1)
17215       return -1;
17216   }
17217   {
17218     char fstype[] = "ext2";
17219     char device[] = "/dev/sda1";
17220     int r;
17221     suppress_error = 0;
17222     r = guestfs_mkfs (g, fstype, device);
17223     if (r == -1)
17224       return -1;
17225   }
17226   {
17227     char device[] = "/dev/sda1";
17228     char mountpoint[] = "/";
17229     int r;
17230     suppress_error = 0;
17231     r = guestfs_mount (g, device, mountpoint);
17232     if (r == -1)
17233       return -1;
17234   }
17235   /* TestLastFail for rm (2) */
17236   {
17237     char path[] = "/new";
17238     int r;
17239     suppress_error = 0;
17240     r = guestfs_mkdir (g, path);
17241     if (r == -1)
17242       return -1;
17243   }
17244   {
17245     char path[] = "/new";
17246     int r;
17247     suppress_error = 1;
17248     r = guestfs_rm (g, path);
17249     if (r != -1)
17250       return -1;
17251   }
17252   return 0;
17253 }
17254
17255 static int test_read_lines_0_skip (void)
17256 {
17257   const char *str;
17258
17259   str = getenv ("TEST_ONLY");
17260   if (str)
17261     return strstr (str, "read_lines") == NULL;
17262   str = getenv ("SKIP_TEST_READ_LINES_0");
17263   if (str && strcmp (str, "1") == 0) return 1;
17264   str = getenv ("SKIP_TEST_READ_LINES");
17265   if (str && strcmp (str, "1") == 0) return 1;
17266   return 0;
17267 }
17268
17269 static int test_read_lines_0 (void)
17270 {
17271   if (test_read_lines_0_skip ()) {
17272     printf ("        %s skipped (reason: environment variable set)\n", "test_read_lines_0");
17273     return 0;
17274   }
17275
17276   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
17277   {
17278     char device[] = "/dev/sda";
17279     int r;
17280     suppress_error = 0;
17281     r = guestfs_blockdev_setrw (g, device);
17282     if (r == -1)
17283       return -1;
17284   }
17285   {
17286     int r;
17287     suppress_error = 0;
17288     r = guestfs_umount_all (g);
17289     if (r == -1)
17290       return -1;
17291   }
17292   {
17293     int r;
17294     suppress_error = 0;
17295     r = guestfs_lvm_remove_all (g);
17296     if (r == -1)
17297       return -1;
17298   }
17299   {
17300     char device[] = "/dev/sda";
17301     char lines_0[] = ",";
17302     char *lines[] = {
17303       lines_0,
17304       NULL
17305     };
17306     int r;
17307     suppress_error = 0;
17308     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17309     if (r == -1)
17310       return -1;
17311   }
17312   {
17313     char fstype[] = "ext2";
17314     char device[] = "/dev/sda1";
17315     int r;
17316     suppress_error = 0;
17317     r = guestfs_mkfs (g, fstype, device);
17318     if (r == -1)
17319       return -1;
17320   }
17321   {
17322     char device[] = "/dev/sda1";
17323     char mountpoint[] = "/";
17324     int r;
17325     suppress_error = 0;
17326     r = guestfs_mount (g, device, mountpoint);
17327     if (r == -1)
17328       return -1;
17329   }
17330   /* TestOutputList for read_lines (0) */
17331   {
17332     char path[] = "/new";
17333     char content[] = "line1\r\nline2\nline3";
17334     int r;
17335     suppress_error = 0;
17336     r = guestfs_write_file (g, path, content, 0);
17337     if (r == -1)
17338       return -1;
17339   }
17340   {
17341     char path[] = "/new";
17342     char **r;
17343     int i;
17344     suppress_error = 0;
17345     r = guestfs_read_lines (g, path);
17346     if (r == NULL)
17347       return -1;
17348     if (!r[0]) {
17349       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17350       print_strings (r);
17351       return -1;
17352     }
17353     {
17354       char expected[] = "line1";
17355       if (strcmp (r[0], expected) != 0) {
17356         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17357         return -1;
17358       }
17359     }
17360     if (!r[1]) {
17361       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17362       print_strings (r);
17363       return -1;
17364     }
17365     {
17366       char expected[] = "line2";
17367       if (strcmp (r[1], expected) != 0) {
17368         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17369         return -1;
17370       }
17371     }
17372     if (!r[2]) {
17373       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17374       print_strings (r);
17375       return -1;
17376     }
17377     {
17378       char expected[] = "line3";
17379       if (strcmp (r[2], expected) != 0) {
17380         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17381         return -1;
17382       }
17383     }
17384     if (r[3] != NULL) {
17385       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
17386       print_strings (r);
17387       return -1;
17388     }
17389     for (i = 0; r[i] != NULL; ++i)
17390       free (r[i]);
17391     free (r);
17392   }
17393   return 0;
17394 }
17395
17396 static int test_read_lines_1_skip (void)
17397 {
17398   const char *str;
17399
17400   str = getenv ("TEST_ONLY");
17401   if (str)
17402     return strstr (str, "read_lines") == NULL;
17403   str = getenv ("SKIP_TEST_READ_LINES_1");
17404   if (str && strcmp (str, "1") == 0) return 1;
17405   str = getenv ("SKIP_TEST_READ_LINES");
17406   if (str && strcmp (str, "1") == 0) return 1;
17407   return 0;
17408 }
17409
17410 static int test_read_lines_1 (void)
17411 {
17412   if (test_read_lines_1_skip ()) {
17413     printf ("        %s skipped (reason: environment variable set)\n", "test_read_lines_1");
17414     return 0;
17415   }
17416
17417   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
17418   {
17419     char device[] = "/dev/sda";
17420     int r;
17421     suppress_error = 0;
17422     r = guestfs_blockdev_setrw (g, device);
17423     if (r == -1)
17424       return -1;
17425   }
17426   {
17427     int r;
17428     suppress_error = 0;
17429     r = guestfs_umount_all (g);
17430     if (r == -1)
17431       return -1;
17432   }
17433   {
17434     int r;
17435     suppress_error = 0;
17436     r = guestfs_lvm_remove_all (g);
17437     if (r == -1)
17438       return -1;
17439   }
17440   {
17441     char device[] = "/dev/sda";
17442     char lines_0[] = ",";
17443     char *lines[] = {
17444       lines_0,
17445       NULL
17446     };
17447     int r;
17448     suppress_error = 0;
17449     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17450     if (r == -1)
17451       return -1;
17452   }
17453   {
17454     char fstype[] = "ext2";
17455     char device[] = "/dev/sda1";
17456     int r;
17457     suppress_error = 0;
17458     r = guestfs_mkfs (g, fstype, device);
17459     if (r == -1)
17460       return -1;
17461   }
17462   {
17463     char device[] = "/dev/sda1";
17464     char mountpoint[] = "/";
17465     int r;
17466     suppress_error = 0;
17467     r = guestfs_mount (g, device, mountpoint);
17468     if (r == -1)
17469       return -1;
17470   }
17471   /* TestOutputList for read_lines (1) */
17472   {
17473     char path[] = "/new";
17474     char content[] = "";
17475     int r;
17476     suppress_error = 0;
17477     r = guestfs_write_file (g, path, content, 0);
17478     if (r == -1)
17479       return -1;
17480   }
17481   {
17482     char path[] = "/new";
17483     char **r;
17484     int i;
17485     suppress_error = 0;
17486     r = guestfs_read_lines (g, path);
17487     if (r == NULL)
17488       return -1;
17489     if (r[0] != NULL) {
17490       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
17491       print_strings (r);
17492       return -1;
17493     }
17494     for (i = 0; r[i] != NULL; ++i)
17495       free (r[i]);
17496     free (r);
17497   }
17498   return 0;
17499 }
17500
17501 static int test_lvs_0_skip (void)
17502 {
17503   const char *str;
17504
17505   str = getenv ("TEST_ONLY");
17506   if (str)
17507     return strstr (str, "lvs") == NULL;
17508   str = getenv ("SKIP_TEST_LVS_0");
17509   if (str && strcmp (str, "1") == 0) return 1;
17510   str = getenv ("SKIP_TEST_LVS");
17511   if (str && strcmp (str, "1") == 0) return 1;
17512   return 0;
17513 }
17514
17515 static int test_lvs_0 (void)
17516 {
17517   if (test_lvs_0_skip ()) {
17518     printf ("        %s skipped (reason: environment variable set)\n", "test_lvs_0");
17519     return 0;
17520   }
17521
17522   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
17523   {
17524     char device[] = "/dev/sda";
17525     int r;
17526     suppress_error = 0;
17527     r = guestfs_blockdev_setrw (g, device);
17528     if (r == -1)
17529       return -1;
17530   }
17531   {
17532     int r;
17533     suppress_error = 0;
17534     r = guestfs_umount_all (g);
17535     if (r == -1)
17536       return -1;
17537   }
17538   {
17539     int r;
17540     suppress_error = 0;
17541     r = guestfs_lvm_remove_all (g);
17542     if (r == -1)
17543       return -1;
17544   }
17545   {
17546     char device[] = "/dev/sda";
17547     char lines_0[] = ",";
17548     char *lines[] = {
17549       lines_0,
17550       NULL
17551     };
17552     int r;
17553     suppress_error = 0;
17554     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17555     if (r == -1)
17556       return -1;
17557   }
17558   {
17559     char device[] = "/dev/sda1";
17560     int r;
17561     suppress_error = 0;
17562     r = guestfs_pvcreate (g, device);
17563     if (r == -1)
17564       return -1;
17565   }
17566   {
17567     char volgroup[] = "VG";
17568     char physvols_0[] = "/dev/sda1";
17569     char *physvols[] = {
17570       physvols_0,
17571       NULL
17572     };
17573     int r;
17574     suppress_error = 0;
17575     r = guestfs_vgcreate (g, volgroup, physvols);
17576     if (r == -1)
17577       return -1;
17578   }
17579   {
17580     char logvol[] = "LV";
17581     char volgroup[] = "VG";
17582     int r;
17583     suppress_error = 0;
17584     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17585     if (r == -1)
17586       return -1;
17587   }
17588   {
17589     char fstype[] = "ext2";
17590     char device[] = "/dev/VG/LV";
17591     int r;
17592     suppress_error = 0;
17593     r = guestfs_mkfs (g, fstype, device);
17594     if (r == -1)
17595       return -1;
17596   }
17597   {
17598     char device[] = "/dev/VG/LV";
17599     char mountpoint[] = "/";
17600     int r;
17601     suppress_error = 0;
17602     r = guestfs_mount (g, device, mountpoint);
17603     if (r == -1)
17604       return -1;
17605   }
17606   /* TestOutputList for lvs (0) */
17607   {
17608     char **r;
17609     int i;
17610     suppress_error = 0;
17611     r = guestfs_lvs (g);
17612     if (r == NULL)
17613       return -1;
17614     if (!r[0]) {
17615       fprintf (stderr, "test_lvs_0: short list returned from command\n");
17616       print_strings (r);
17617       return -1;
17618     }
17619     {
17620       char expected[] = "/dev/VG/LV";
17621       if (strcmp (r[0], expected) != 0) {
17622         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17623         return -1;
17624       }
17625     }
17626     if (r[1] != NULL) {
17627       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
17628       print_strings (r);
17629       return -1;
17630     }
17631     for (i = 0; r[i] != NULL; ++i)
17632       free (r[i]);
17633     free (r);
17634   }
17635   return 0;
17636 }
17637
17638 static int test_lvs_1_skip (void)
17639 {
17640   const char *str;
17641
17642   str = getenv ("TEST_ONLY");
17643   if (str)
17644     return strstr (str, "lvs") == NULL;
17645   str = getenv ("SKIP_TEST_LVS_1");
17646   if (str && strcmp (str, "1") == 0) return 1;
17647   str = getenv ("SKIP_TEST_LVS");
17648   if (str && strcmp (str, "1") == 0) return 1;
17649   return 0;
17650 }
17651
17652 static int test_lvs_1 (void)
17653 {
17654   if (test_lvs_1_skip ()) {
17655     printf ("        %s skipped (reason: environment variable set)\n", "test_lvs_1");
17656     return 0;
17657   }
17658
17659   /* InitNone|InitEmpty for test_lvs_1 */
17660   {
17661     char device[] = "/dev/sda";
17662     int r;
17663     suppress_error = 0;
17664     r = guestfs_blockdev_setrw (g, device);
17665     if (r == -1)
17666       return -1;
17667   }
17668   {
17669     int r;
17670     suppress_error = 0;
17671     r = guestfs_umount_all (g);
17672     if (r == -1)
17673       return -1;
17674   }
17675   {
17676     int r;
17677     suppress_error = 0;
17678     r = guestfs_lvm_remove_all (g);
17679     if (r == -1)
17680       return -1;
17681   }
17682   /* TestOutputList for lvs (1) */
17683   {
17684     char device[] = "/dev/sda";
17685     char lines_0[] = ",200";
17686     char lines_1[] = ",400";
17687     char lines_2[] = ",";
17688     char *lines[] = {
17689       lines_0,
17690       lines_1,
17691       lines_2,
17692       NULL
17693     };
17694     int r;
17695     suppress_error = 0;
17696     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17697     if (r == -1)
17698       return -1;
17699   }
17700   {
17701     char device[] = "/dev/sda1";
17702     int r;
17703     suppress_error = 0;
17704     r = guestfs_pvcreate (g, device);
17705     if (r == -1)
17706       return -1;
17707   }
17708   {
17709     char device[] = "/dev/sda2";
17710     int r;
17711     suppress_error = 0;
17712     r = guestfs_pvcreate (g, device);
17713     if (r == -1)
17714       return -1;
17715   }
17716   {
17717     char device[] = "/dev/sda3";
17718     int r;
17719     suppress_error = 0;
17720     r = guestfs_pvcreate (g, device);
17721     if (r == -1)
17722       return -1;
17723   }
17724   {
17725     char volgroup[] = "VG1";
17726     char physvols_0[] = "/dev/sda1";
17727     char physvols_1[] = "/dev/sda2";
17728     char *physvols[] = {
17729       physvols_0,
17730       physvols_1,
17731       NULL
17732     };
17733     int r;
17734     suppress_error = 0;
17735     r = guestfs_vgcreate (g, volgroup, physvols);
17736     if (r == -1)
17737       return -1;
17738   }
17739   {
17740     char volgroup[] = "VG2";
17741     char physvols_0[] = "/dev/sda3";
17742     char *physvols[] = {
17743       physvols_0,
17744       NULL
17745     };
17746     int r;
17747     suppress_error = 0;
17748     r = guestfs_vgcreate (g, volgroup, physvols);
17749     if (r == -1)
17750       return -1;
17751   }
17752   {
17753     char logvol[] = "LV1";
17754     char volgroup[] = "VG1";
17755     int r;
17756     suppress_error = 0;
17757     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17758     if (r == -1)
17759       return -1;
17760   }
17761   {
17762     char logvol[] = "LV2";
17763     char volgroup[] = "VG1";
17764     int r;
17765     suppress_error = 0;
17766     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17767     if (r == -1)
17768       return -1;
17769   }
17770   {
17771     char logvol[] = "LV3";
17772     char volgroup[] = "VG2";
17773     int r;
17774     suppress_error = 0;
17775     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17776     if (r == -1)
17777       return -1;
17778   }
17779   {
17780     char **r;
17781     int i;
17782     suppress_error = 0;
17783     r = guestfs_lvs (g);
17784     if (r == NULL)
17785       return -1;
17786     if (!r[0]) {
17787       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17788       print_strings (r);
17789       return -1;
17790     }
17791     {
17792       char expected[] = "/dev/VG1/LV1";
17793       if (strcmp (r[0], expected) != 0) {
17794         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17795         return -1;
17796       }
17797     }
17798     if (!r[1]) {
17799       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17800       print_strings (r);
17801       return -1;
17802     }
17803     {
17804       char expected[] = "/dev/VG1/LV2";
17805       if (strcmp (r[1], expected) != 0) {
17806         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17807         return -1;
17808       }
17809     }
17810     if (!r[2]) {
17811       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17812       print_strings (r);
17813       return -1;
17814     }
17815     {
17816       char expected[] = "/dev/VG2/LV3";
17817       if (strcmp (r[2], expected) != 0) {
17818         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17819         return -1;
17820       }
17821     }
17822     if (r[3] != NULL) {
17823       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17824       print_strings (r);
17825       return -1;
17826     }
17827     for (i = 0; r[i] != NULL; ++i)
17828       free (r[i]);
17829     free (r);
17830   }
17831   return 0;
17832 }
17833
17834 static int test_vgs_0_skip (void)
17835 {
17836   const char *str;
17837
17838   str = getenv ("TEST_ONLY");
17839   if (str)
17840     return strstr (str, "vgs") == NULL;
17841   str = getenv ("SKIP_TEST_VGS_0");
17842   if (str && strcmp (str, "1") == 0) return 1;
17843   str = getenv ("SKIP_TEST_VGS");
17844   if (str && strcmp (str, "1") == 0) return 1;
17845   return 0;
17846 }
17847
17848 static int test_vgs_0 (void)
17849 {
17850   if (test_vgs_0_skip ()) {
17851     printf ("        %s skipped (reason: environment variable set)\n", "test_vgs_0");
17852     return 0;
17853   }
17854
17855   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17856   {
17857     char device[] = "/dev/sda";
17858     int r;
17859     suppress_error = 0;
17860     r = guestfs_blockdev_setrw (g, device);
17861     if (r == -1)
17862       return -1;
17863   }
17864   {
17865     int r;
17866     suppress_error = 0;
17867     r = guestfs_umount_all (g);
17868     if (r == -1)
17869       return -1;
17870   }
17871   {
17872     int r;
17873     suppress_error = 0;
17874     r = guestfs_lvm_remove_all (g);
17875     if (r == -1)
17876       return -1;
17877   }
17878   {
17879     char device[] = "/dev/sda";
17880     char lines_0[] = ",";
17881     char *lines[] = {
17882       lines_0,
17883       NULL
17884     };
17885     int r;
17886     suppress_error = 0;
17887     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17888     if (r == -1)
17889       return -1;
17890   }
17891   {
17892     char device[] = "/dev/sda1";
17893     int r;
17894     suppress_error = 0;
17895     r = guestfs_pvcreate (g, device);
17896     if (r == -1)
17897       return -1;
17898   }
17899   {
17900     char volgroup[] = "VG";
17901     char physvols_0[] = "/dev/sda1";
17902     char *physvols[] = {
17903       physvols_0,
17904       NULL
17905     };
17906     int r;
17907     suppress_error = 0;
17908     r = guestfs_vgcreate (g, volgroup, physvols);
17909     if (r == -1)
17910       return -1;
17911   }
17912   {
17913     char logvol[] = "LV";
17914     char volgroup[] = "VG";
17915     int r;
17916     suppress_error = 0;
17917     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17918     if (r == -1)
17919       return -1;
17920   }
17921   {
17922     char fstype[] = "ext2";
17923     char device[] = "/dev/VG/LV";
17924     int r;
17925     suppress_error = 0;
17926     r = guestfs_mkfs (g, fstype, device);
17927     if (r == -1)
17928       return -1;
17929   }
17930   {
17931     char device[] = "/dev/VG/LV";
17932     char mountpoint[] = "/";
17933     int r;
17934     suppress_error = 0;
17935     r = guestfs_mount (g, device, mountpoint);
17936     if (r == -1)
17937       return -1;
17938   }
17939   /* TestOutputList for vgs (0) */
17940   {
17941     char **r;
17942     int i;
17943     suppress_error = 0;
17944     r = guestfs_vgs (g);
17945     if (r == NULL)
17946       return -1;
17947     if (!r[0]) {
17948       fprintf (stderr, "test_vgs_0: short list returned from command\n");
17949       print_strings (r);
17950       return -1;
17951     }
17952     {
17953       char expected[] = "VG";
17954       if (strcmp (r[0], expected) != 0) {
17955         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17956         return -1;
17957       }
17958     }
17959     if (r[1] != NULL) {
17960       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17961       print_strings (r);
17962       return -1;
17963     }
17964     for (i = 0; r[i] != NULL; ++i)
17965       free (r[i]);
17966     free (r);
17967   }
17968   return 0;
17969 }
17970
17971 static int test_vgs_1_skip (void)
17972 {
17973   const char *str;
17974
17975   str = getenv ("TEST_ONLY");
17976   if (str)
17977     return strstr (str, "vgs") == NULL;
17978   str = getenv ("SKIP_TEST_VGS_1");
17979   if (str && strcmp (str, "1") == 0) return 1;
17980   str = getenv ("SKIP_TEST_VGS");
17981   if (str && strcmp (str, "1") == 0) return 1;
17982   return 0;
17983 }
17984
17985 static int test_vgs_1 (void)
17986 {
17987   if (test_vgs_1_skip ()) {
17988     printf ("        %s skipped (reason: environment variable set)\n", "test_vgs_1");
17989     return 0;
17990   }
17991
17992   /* InitNone|InitEmpty for test_vgs_1 */
17993   {
17994     char device[] = "/dev/sda";
17995     int r;
17996     suppress_error = 0;
17997     r = guestfs_blockdev_setrw (g, device);
17998     if (r == -1)
17999       return -1;
18000   }
18001   {
18002     int r;
18003     suppress_error = 0;
18004     r = guestfs_umount_all (g);
18005     if (r == -1)
18006       return -1;
18007   }
18008   {
18009     int r;
18010     suppress_error = 0;
18011     r = guestfs_lvm_remove_all (g);
18012     if (r == -1)
18013       return -1;
18014   }
18015   /* TestOutputList for vgs (1) */
18016   {
18017     char device[] = "/dev/sda";
18018     char lines_0[] = ",200";
18019     char lines_1[] = ",400";
18020     char lines_2[] = ",";
18021     char *lines[] = {
18022       lines_0,
18023       lines_1,
18024       lines_2,
18025       NULL
18026     };
18027     int r;
18028     suppress_error = 0;
18029     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18030     if (r == -1)
18031       return -1;
18032   }
18033   {
18034     char device[] = "/dev/sda1";
18035     int r;
18036     suppress_error = 0;
18037     r = guestfs_pvcreate (g, device);
18038     if (r == -1)
18039       return -1;
18040   }
18041   {
18042     char device[] = "/dev/sda2";
18043     int r;
18044     suppress_error = 0;
18045     r = guestfs_pvcreate (g, device);
18046     if (r == -1)
18047       return -1;
18048   }
18049   {
18050     char device[] = "/dev/sda3";
18051     int r;
18052     suppress_error = 0;
18053     r = guestfs_pvcreate (g, device);
18054     if (r == -1)
18055       return -1;
18056   }
18057   {
18058     char volgroup[] = "VG1";
18059     char physvols_0[] = "/dev/sda1";
18060     char physvols_1[] = "/dev/sda2";
18061     char *physvols[] = {
18062       physvols_0,
18063       physvols_1,
18064       NULL
18065     };
18066     int r;
18067     suppress_error = 0;
18068     r = guestfs_vgcreate (g, volgroup, physvols);
18069     if (r == -1)
18070       return -1;
18071   }
18072   {
18073     char volgroup[] = "VG2";
18074     char physvols_0[] = "/dev/sda3";
18075     char *physvols[] = {
18076       physvols_0,
18077       NULL
18078     };
18079     int r;
18080     suppress_error = 0;
18081     r = guestfs_vgcreate (g, volgroup, physvols);
18082     if (r == -1)
18083       return -1;
18084   }
18085   {
18086     char **r;
18087     int i;
18088     suppress_error = 0;
18089     r = guestfs_vgs (g);
18090     if (r == NULL)
18091       return -1;
18092     if (!r[0]) {
18093       fprintf (stderr, "test_vgs_1: short list returned from command\n");
18094       print_strings (r);
18095       return -1;
18096     }
18097     {
18098       char expected[] = "VG1";
18099       if (strcmp (r[0], expected) != 0) {
18100         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18101         return -1;
18102       }
18103     }
18104     if (!r[1]) {
18105       fprintf (stderr, "test_vgs_1: short list returned from command\n");
18106       print_strings (r);
18107       return -1;
18108     }
18109     {
18110       char expected[] = "VG2";
18111       if (strcmp (r[1], expected) != 0) {
18112         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18113         return -1;
18114       }
18115     }
18116     if (r[2] != NULL) {
18117       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
18118       print_strings (r);
18119       return -1;
18120     }
18121     for (i = 0; r[i] != NULL; ++i)
18122       free (r[i]);
18123     free (r);
18124   }
18125   return 0;
18126 }
18127
18128 static int test_pvs_0_skip (void)
18129 {
18130   const char *str;
18131
18132   str = getenv ("TEST_ONLY");
18133   if (str)
18134     return strstr (str, "pvs") == NULL;
18135   str = getenv ("SKIP_TEST_PVS_0");
18136   if (str && strcmp (str, "1") == 0) return 1;
18137   str = getenv ("SKIP_TEST_PVS");
18138   if (str && strcmp (str, "1") == 0) return 1;
18139   return 0;
18140 }
18141
18142 static int test_pvs_0 (void)
18143 {
18144   if (test_pvs_0_skip ()) {
18145     printf ("        %s skipped (reason: environment variable set)\n", "test_pvs_0");
18146     return 0;
18147   }
18148
18149   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
18150   {
18151     char device[] = "/dev/sda";
18152     int r;
18153     suppress_error = 0;
18154     r = guestfs_blockdev_setrw (g, device);
18155     if (r == -1)
18156       return -1;
18157   }
18158   {
18159     int r;
18160     suppress_error = 0;
18161     r = guestfs_umount_all (g);
18162     if (r == -1)
18163       return -1;
18164   }
18165   {
18166     int r;
18167     suppress_error = 0;
18168     r = guestfs_lvm_remove_all (g);
18169     if (r == -1)
18170       return -1;
18171   }
18172   {
18173     char device[] = "/dev/sda";
18174     char lines_0[] = ",";
18175     char *lines[] = {
18176       lines_0,
18177       NULL
18178     };
18179     int r;
18180     suppress_error = 0;
18181     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18182     if (r == -1)
18183       return -1;
18184   }
18185   {
18186     char device[] = "/dev/sda1";
18187     int r;
18188     suppress_error = 0;
18189     r = guestfs_pvcreate (g, device);
18190     if (r == -1)
18191       return -1;
18192   }
18193   {
18194     char volgroup[] = "VG";
18195     char physvols_0[] = "/dev/sda1";
18196     char *physvols[] = {
18197       physvols_0,
18198       NULL
18199     };
18200     int r;
18201     suppress_error = 0;
18202     r = guestfs_vgcreate (g, volgroup, physvols);
18203     if (r == -1)
18204       return -1;
18205   }
18206   {
18207     char logvol[] = "LV";
18208     char volgroup[] = "VG";
18209     int r;
18210     suppress_error = 0;
18211     r = guestfs_lvcreate (g, logvol, volgroup, 8);
18212     if (r == -1)
18213       return -1;
18214   }
18215   {
18216     char fstype[] = "ext2";
18217     char device[] = "/dev/VG/LV";
18218     int r;
18219     suppress_error = 0;
18220     r = guestfs_mkfs (g, fstype, device);
18221     if (r == -1)
18222       return -1;
18223   }
18224   {
18225     char device[] = "/dev/VG/LV";
18226     char mountpoint[] = "/";
18227     int r;
18228     suppress_error = 0;
18229     r = guestfs_mount (g, device, mountpoint);
18230     if (r == -1)
18231       return -1;
18232   }
18233   /* TestOutputListOfDevices for pvs (0) */
18234   {
18235     char **r;
18236     int i;
18237     suppress_error = 0;
18238     r = guestfs_pvs (g);
18239     if (r == NULL)
18240       return -1;
18241     if (!r[0]) {
18242       fprintf (stderr, "test_pvs_0: short list returned from command\n");
18243       print_strings (r);
18244       return -1;
18245     }
18246     {
18247       char expected[] = "/dev/sda1";
18248       r[0][5] = 's';
18249       if (strcmp (r[0], expected) != 0) {
18250         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18251         return -1;
18252       }
18253     }
18254     if (r[1] != NULL) {
18255       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
18256       print_strings (r);
18257       return -1;
18258     }
18259     for (i = 0; r[i] != NULL; ++i)
18260       free (r[i]);
18261     free (r);
18262   }
18263   return 0;
18264 }
18265
18266 static int test_pvs_1_skip (void)
18267 {
18268   const char *str;
18269
18270   str = getenv ("TEST_ONLY");
18271   if (str)
18272     return strstr (str, "pvs") == NULL;
18273   str = getenv ("SKIP_TEST_PVS_1");
18274   if (str && strcmp (str, "1") == 0) return 1;
18275   str = getenv ("SKIP_TEST_PVS");
18276   if (str && strcmp (str, "1") == 0) return 1;
18277   return 0;
18278 }
18279
18280 static int test_pvs_1 (void)
18281 {
18282   if (test_pvs_1_skip ()) {
18283     printf ("        %s skipped (reason: environment variable set)\n", "test_pvs_1");
18284     return 0;
18285   }
18286
18287   /* InitNone|InitEmpty for test_pvs_1 */
18288   {
18289     char device[] = "/dev/sda";
18290     int r;
18291     suppress_error = 0;
18292     r = guestfs_blockdev_setrw (g, device);
18293     if (r == -1)
18294       return -1;
18295   }
18296   {
18297     int r;
18298     suppress_error = 0;
18299     r = guestfs_umount_all (g);
18300     if (r == -1)
18301       return -1;
18302   }
18303   {
18304     int r;
18305     suppress_error = 0;
18306     r = guestfs_lvm_remove_all (g);
18307     if (r == -1)
18308       return -1;
18309   }
18310   /* TestOutputListOfDevices for pvs (1) */
18311   {
18312     char device[] = "/dev/sda";
18313     char lines_0[] = ",200";
18314     char lines_1[] = ",400";
18315     char lines_2[] = ",";
18316     char *lines[] = {
18317       lines_0,
18318       lines_1,
18319       lines_2,
18320       NULL
18321     };
18322     int r;
18323     suppress_error = 0;
18324     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18325     if (r == -1)
18326       return -1;
18327   }
18328   {
18329     char device[] = "/dev/sda1";
18330     int r;
18331     suppress_error = 0;
18332     r = guestfs_pvcreate (g, device);
18333     if (r == -1)
18334       return -1;
18335   }
18336   {
18337     char device[] = "/dev/sda2";
18338     int r;
18339     suppress_error = 0;
18340     r = guestfs_pvcreate (g, device);
18341     if (r == -1)
18342       return -1;
18343   }
18344   {
18345     char device[] = "/dev/sda3";
18346     int r;
18347     suppress_error = 0;
18348     r = guestfs_pvcreate (g, device);
18349     if (r == -1)
18350       return -1;
18351   }
18352   {
18353     char **r;
18354     int i;
18355     suppress_error = 0;
18356     r = guestfs_pvs (g);
18357     if (r == NULL)
18358       return -1;
18359     if (!r[0]) {
18360       fprintf (stderr, "test_pvs_1: short list returned from command\n");
18361       print_strings (r);
18362       return -1;
18363     }
18364     {
18365       char expected[] = "/dev/sda1";
18366       r[0][5] = 's';
18367       if (strcmp (r[0], expected) != 0) {
18368         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18369         return -1;
18370       }
18371     }
18372     if (!r[1]) {
18373       fprintf (stderr, "test_pvs_1: short list returned from command\n");
18374       print_strings (r);
18375       return -1;
18376     }
18377     {
18378       char expected[] = "/dev/sda2";
18379       r[1][5] = 's';
18380       if (strcmp (r[1], expected) != 0) {
18381         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18382         return -1;
18383       }
18384     }
18385     if (!r[2]) {
18386       fprintf (stderr, "test_pvs_1: short list returned from command\n");
18387       print_strings (r);
18388       return -1;
18389     }
18390     {
18391       char expected[] = "/dev/sda3";
18392       r[2][5] = 's';
18393       if (strcmp (r[2], expected) != 0) {
18394         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18395         return -1;
18396       }
18397     }
18398     if (r[3] != NULL) {
18399       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
18400       print_strings (r);
18401       return -1;
18402     }
18403     for (i = 0; r[i] != NULL; ++i)
18404       free (r[i]);
18405     free (r);
18406   }
18407   return 0;
18408 }
18409
18410 static int test_list_partitions_0_skip (void)
18411 {
18412   const char *str;
18413
18414   str = getenv ("TEST_ONLY");
18415   if (str)
18416     return strstr (str, "list_partitions") == NULL;
18417   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
18418   if (str && strcmp (str, "1") == 0) return 1;
18419   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18420   if (str && strcmp (str, "1") == 0) return 1;
18421   return 0;
18422 }
18423
18424 static int test_list_partitions_0 (void)
18425 {
18426   if (test_list_partitions_0_skip ()) {
18427     printf ("        %s skipped (reason: environment variable set)\n", "test_list_partitions_0");
18428     return 0;
18429   }
18430
18431   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
18432   {
18433     char device[] = "/dev/sda";
18434     int r;
18435     suppress_error = 0;
18436     r = guestfs_blockdev_setrw (g, device);
18437     if (r == -1)
18438       return -1;
18439   }
18440   {
18441     int r;
18442     suppress_error = 0;
18443     r = guestfs_umount_all (g);
18444     if (r == -1)
18445       return -1;
18446   }
18447   {
18448     int r;
18449     suppress_error = 0;
18450     r = guestfs_lvm_remove_all (g);
18451     if (r == -1)
18452       return -1;
18453   }
18454   {
18455     char device[] = "/dev/sda";
18456     char lines_0[] = ",";
18457     char *lines[] = {
18458       lines_0,
18459       NULL
18460     };
18461     int r;
18462     suppress_error = 0;
18463     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18464     if (r == -1)
18465       return -1;
18466   }
18467   {
18468     char fstype[] = "ext2";
18469     char device[] = "/dev/sda1";
18470     int r;
18471     suppress_error = 0;
18472     r = guestfs_mkfs (g, fstype, device);
18473     if (r == -1)
18474       return -1;
18475   }
18476   {
18477     char device[] = "/dev/sda1";
18478     char mountpoint[] = "/";
18479     int r;
18480     suppress_error = 0;
18481     r = guestfs_mount (g, device, mountpoint);
18482     if (r == -1)
18483       return -1;
18484   }
18485   /* TestOutputListOfDevices for list_partitions (0) */
18486   {
18487     char **r;
18488     int i;
18489     suppress_error = 0;
18490     r = guestfs_list_partitions (g);
18491     if (r == NULL)
18492       return -1;
18493     if (!r[0]) {
18494       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
18495       print_strings (r);
18496       return -1;
18497     }
18498     {
18499       char expected[] = "/dev/sda1";
18500       r[0][5] = 's';
18501       if (strcmp (r[0], expected) != 0) {
18502         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18503         return -1;
18504       }
18505     }
18506     if (r[1] != NULL) {
18507       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
18508       print_strings (r);
18509       return -1;
18510     }
18511     for (i = 0; r[i] != NULL; ++i)
18512       free (r[i]);
18513     free (r);
18514   }
18515   return 0;
18516 }
18517
18518 static int test_list_partitions_1_skip (void)
18519 {
18520   const char *str;
18521
18522   str = getenv ("TEST_ONLY");
18523   if (str)
18524     return strstr (str, "list_partitions") == NULL;
18525   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
18526   if (str && strcmp (str, "1") == 0) return 1;
18527   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18528   if (str && strcmp (str, "1") == 0) return 1;
18529   return 0;
18530 }
18531
18532 static int test_list_partitions_1 (void)
18533 {
18534   if (test_list_partitions_1_skip ()) {
18535     printf ("        %s skipped (reason: environment variable set)\n", "test_list_partitions_1");
18536     return 0;
18537   }
18538
18539   /* InitNone|InitEmpty for test_list_partitions_1 */
18540   {
18541     char device[] = "/dev/sda";
18542     int r;
18543     suppress_error = 0;
18544     r = guestfs_blockdev_setrw (g, device);
18545     if (r == -1)
18546       return -1;
18547   }
18548   {
18549     int r;
18550     suppress_error = 0;
18551     r = guestfs_umount_all (g);
18552     if (r == -1)
18553       return -1;
18554   }
18555   {
18556     int r;
18557     suppress_error = 0;
18558     r = guestfs_lvm_remove_all (g);
18559     if (r == -1)
18560       return -1;
18561   }
18562   /* TestOutputListOfDevices for list_partitions (1) */
18563   {
18564     char device[] = "/dev/sda";
18565     char lines_0[] = ",200";
18566     char lines_1[] = ",400";
18567     char lines_2[] = ",";
18568     char *lines[] = {
18569       lines_0,
18570       lines_1,
18571       lines_2,
18572       NULL
18573     };
18574     int r;
18575     suppress_error = 0;
18576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18577     if (r == -1)
18578       return -1;
18579   }
18580   {
18581     char **r;
18582     int i;
18583     suppress_error = 0;
18584     r = guestfs_list_partitions (g);
18585     if (r == NULL)
18586       return -1;
18587     if (!r[0]) {
18588       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18589       print_strings (r);
18590       return -1;
18591     }
18592     {
18593       char expected[] = "/dev/sda1";
18594       r[0][5] = 's';
18595       if (strcmp (r[0], expected) != 0) {
18596         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18597         return -1;
18598       }
18599     }
18600     if (!r[1]) {
18601       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18602       print_strings (r);
18603       return -1;
18604     }
18605     {
18606       char expected[] = "/dev/sda2";
18607       r[1][5] = 's';
18608       if (strcmp (r[1], expected) != 0) {
18609         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18610         return -1;
18611       }
18612     }
18613     if (!r[2]) {
18614       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18615       print_strings (r);
18616       return -1;
18617     }
18618     {
18619       char expected[] = "/dev/sda3";
18620       r[2][5] = 's';
18621       if (strcmp (r[2], expected) != 0) {
18622         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18623         return -1;
18624       }
18625     }
18626     if (r[3] != NULL) {
18627       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
18628       print_strings (r);
18629       return -1;
18630     }
18631     for (i = 0; r[i] != NULL; ++i)
18632       free (r[i]);
18633     free (r);
18634   }
18635   return 0;
18636 }
18637
18638 static int test_list_devices_0_skip (void)
18639 {
18640   const char *str;
18641
18642   str = getenv ("TEST_ONLY");
18643   if (str)
18644     return strstr (str, "list_devices") == NULL;
18645   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18646   if (str && strcmp (str, "1") == 0) return 1;
18647   str = getenv ("SKIP_TEST_LIST_DEVICES");
18648   if (str && strcmp (str, "1") == 0) return 1;
18649   return 0;
18650 }
18651
18652 static int test_list_devices_0 (void)
18653 {
18654   if (test_list_devices_0_skip ()) {
18655     printf ("        %s skipped (reason: environment variable set)\n", "test_list_devices_0");
18656     return 0;
18657   }
18658
18659   /* InitNone|InitEmpty for test_list_devices_0 */
18660   {
18661     char device[] = "/dev/sda";
18662     int r;
18663     suppress_error = 0;
18664     r = guestfs_blockdev_setrw (g, device);
18665     if (r == -1)
18666       return -1;
18667   }
18668   {
18669     int r;
18670     suppress_error = 0;
18671     r = guestfs_umount_all (g);
18672     if (r == -1)
18673       return -1;
18674   }
18675   {
18676     int r;
18677     suppress_error = 0;
18678     r = guestfs_lvm_remove_all (g);
18679     if (r == -1)
18680       return -1;
18681   }
18682   /* TestOutputListOfDevices for list_devices (0) */
18683   {
18684     char **r;
18685     int i;
18686     suppress_error = 0;
18687     r = guestfs_list_devices (g);
18688     if (r == NULL)
18689       return -1;
18690     if (!r[0]) {
18691       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18692       print_strings (r);
18693       return -1;
18694     }
18695     {
18696       char expected[] = "/dev/sda";
18697       r[0][5] = 's';
18698       if (strcmp (r[0], expected) != 0) {
18699         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18700         return -1;
18701       }
18702     }
18703     if (!r[1]) {
18704       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18705       print_strings (r);
18706       return -1;
18707     }
18708     {
18709       char expected[] = "/dev/sdb";
18710       r[1][5] = 's';
18711       if (strcmp (r[1], expected) != 0) {
18712         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18713         return -1;
18714       }
18715     }
18716     if (!r[2]) {
18717       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18718       print_strings (r);
18719       return -1;
18720     }
18721     {
18722       char expected[] = "/dev/sdc";
18723       r[2][5] = 's';
18724       if (strcmp (r[2], expected) != 0) {
18725         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18726         return -1;
18727       }
18728     }
18729     if (!r[3]) {
18730       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18731       print_strings (r);
18732       return -1;
18733     }
18734     {
18735       char expected[] = "/dev/sdd";
18736       r[3][5] = 's';
18737       if (strcmp (r[3], expected) != 0) {
18738         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18739         return -1;
18740       }
18741     }
18742     if (r[4] != NULL) {
18743       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18744       print_strings (r);
18745       return -1;
18746     }
18747     for (i = 0; r[i] != NULL; ++i)
18748       free (r[i]);
18749     free (r);
18750   }
18751   return 0;
18752 }
18753
18754 static int test_ls_0_skip (void)
18755 {
18756   const char *str;
18757
18758   str = getenv ("TEST_ONLY");
18759   if (str)
18760     return strstr (str, "ls") == NULL;
18761   str = getenv ("SKIP_TEST_LS_0");
18762   if (str && strcmp (str, "1") == 0) return 1;
18763   str = getenv ("SKIP_TEST_LS");
18764   if (str && strcmp (str, "1") == 0) return 1;
18765   return 0;
18766 }
18767
18768 static int test_ls_0 (void)
18769 {
18770   if (test_ls_0_skip ()) {
18771     printf ("        %s skipped (reason: environment variable set)\n", "test_ls_0");
18772     return 0;
18773   }
18774
18775   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18776   {
18777     char device[] = "/dev/sda";
18778     int r;
18779     suppress_error = 0;
18780     r = guestfs_blockdev_setrw (g, device);
18781     if (r == -1)
18782       return -1;
18783   }
18784   {
18785     int r;
18786     suppress_error = 0;
18787     r = guestfs_umount_all (g);
18788     if (r == -1)
18789       return -1;
18790   }
18791   {
18792     int r;
18793     suppress_error = 0;
18794     r = guestfs_lvm_remove_all (g);
18795     if (r == -1)
18796       return -1;
18797   }
18798   {
18799     char device[] = "/dev/sda";
18800     char lines_0[] = ",";
18801     char *lines[] = {
18802       lines_0,
18803       NULL
18804     };
18805     int r;
18806     suppress_error = 0;
18807     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18808     if (r == -1)
18809       return -1;
18810   }
18811   {
18812     char fstype[] = "ext2";
18813     char device[] = "/dev/sda1";
18814     int r;
18815     suppress_error = 0;
18816     r = guestfs_mkfs (g, fstype, device);
18817     if (r == -1)
18818       return -1;
18819   }
18820   {
18821     char device[] = "/dev/sda1";
18822     char mountpoint[] = "/";
18823     int r;
18824     suppress_error = 0;
18825     r = guestfs_mount (g, device, mountpoint);
18826     if (r == -1)
18827       return -1;
18828   }
18829   /* TestOutputList for ls (0) */
18830   {
18831     char path[] = "/new";
18832     int r;
18833     suppress_error = 0;
18834     r = guestfs_touch (g, path);
18835     if (r == -1)
18836       return -1;
18837   }
18838   {
18839     char path[] = "/newer";
18840     int r;
18841     suppress_error = 0;
18842     r = guestfs_touch (g, path);
18843     if (r == -1)
18844       return -1;
18845   }
18846   {
18847     char path[] = "/newest";
18848     int r;
18849     suppress_error = 0;
18850     r = guestfs_touch (g, path);
18851     if (r == -1)
18852       return -1;
18853   }
18854   {
18855     char directory[] = "/";
18856     char **r;
18857     int i;
18858     suppress_error = 0;
18859     r = guestfs_ls (g, directory);
18860     if (r == NULL)
18861       return -1;
18862     if (!r[0]) {
18863       fprintf (stderr, "test_ls_0: short list returned from command\n");
18864       print_strings (r);
18865       return -1;
18866     }
18867     {
18868       char expected[] = "lost+found";
18869       if (strcmp (r[0], expected) != 0) {
18870         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18871         return -1;
18872       }
18873     }
18874     if (!r[1]) {
18875       fprintf (stderr, "test_ls_0: short list returned from command\n");
18876       print_strings (r);
18877       return -1;
18878     }
18879     {
18880       char expected[] = "new";
18881       if (strcmp (r[1], expected) != 0) {
18882         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18883         return -1;
18884       }
18885     }
18886     if (!r[2]) {
18887       fprintf (stderr, "test_ls_0: short list returned from command\n");
18888       print_strings (r);
18889       return -1;
18890     }
18891     {
18892       char expected[] = "newer";
18893       if (strcmp (r[2], expected) != 0) {
18894         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18895         return -1;
18896       }
18897     }
18898     if (!r[3]) {
18899       fprintf (stderr, "test_ls_0: short list returned from command\n");
18900       print_strings (r);
18901       return -1;
18902     }
18903     {
18904       char expected[] = "newest";
18905       if (strcmp (r[3], expected) != 0) {
18906         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18907         return -1;
18908       }
18909     }
18910     if (r[4] != NULL) {
18911       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18912       print_strings (r);
18913       return -1;
18914     }
18915     for (i = 0; r[i] != NULL; ++i)
18916       free (r[i]);
18917     free (r);
18918   }
18919   return 0;
18920 }
18921
18922 static int test_cat_0_skip (void)
18923 {
18924   const char *str;
18925
18926   str = getenv ("TEST_ONLY");
18927   if (str)
18928     return strstr (str, "cat") == NULL;
18929   str = getenv ("SKIP_TEST_CAT_0");
18930   if (str && strcmp (str, "1") == 0) return 1;
18931   str = getenv ("SKIP_TEST_CAT");
18932   if (str && strcmp (str, "1") == 0) return 1;
18933   return 0;
18934 }
18935
18936 static int test_cat_0 (void)
18937 {
18938   if (test_cat_0_skip ()) {
18939     printf ("        %s skipped (reason: environment variable set)\n", "test_cat_0");
18940     return 0;
18941   }
18942
18943   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18944   {
18945     char device[] = "/dev/sda";
18946     int r;
18947     suppress_error = 0;
18948     r = guestfs_blockdev_setrw (g, device);
18949     if (r == -1)
18950       return -1;
18951   }
18952   {
18953     int r;
18954     suppress_error = 0;
18955     r = guestfs_umount_all (g);
18956     if (r == -1)
18957       return -1;
18958   }
18959   {
18960     int r;
18961     suppress_error = 0;
18962     r = guestfs_lvm_remove_all (g);
18963     if (r == -1)
18964       return -1;
18965   }
18966   {
18967     char device[] = "/dev/sda";
18968     char lines_0[] = ",";
18969     char *lines[] = {
18970       lines_0,
18971       NULL
18972     };
18973     int r;
18974     suppress_error = 0;
18975     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18976     if (r == -1)
18977       return -1;
18978   }
18979   {
18980     char fstype[] = "ext2";
18981     char device[] = "/dev/sda1";
18982     int r;
18983     suppress_error = 0;
18984     r = guestfs_mkfs (g, fstype, device);
18985     if (r == -1)
18986       return -1;
18987   }
18988   {
18989     char device[] = "/dev/sda1";
18990     char mountpoint[] = "/";
18991     int r;
18992     suppress_error = 0;
18993     r = guestfs_mount (g, device, mountpoint);
18994     if (r == -1)
18995       return -1;
18996   }
18997   /* TestOutput for cat (0) */
18998   char expected[] = "new file contents";
18999   {
19000     char path[] = "/new";
19001     char content[] = "new file contents";
19002     int r;
19003     suppress_error = 0;
19004     r = guestfs_write_file (g, path, content, 0);
19005     if (r == -1)
19006       return -1;
19007   }
19008   {
19009     char path[] = "/new";
19010     char *r;
19011     suppress_error = 0;
19012     r = guestfs_cat (g, path);
19013     if (r == NULL)
19014       return -1;
19015     if (strcmp (r, expected) != 0) {
19016       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
19017       return -1;
19018     }
19019     free (r);
19020   }
19021   return 0;
19022 }
19023
19024 static int test_touch_0_skip (void)
19025 {
19026   const char *str;
19027
19028   str = getenv ("TEST_ONLY");
19029   if (str)
19030     return strstr (str, "touch") == NULL;
19031   str = getenv ("SKIP_TEST_TOUCH_0");
19032   if (str && strcmp (str, "1") == 0) return 1;
19033   str = getenv ("SKIP_TEST_TOUCH");
19034   if (str && strcmp (str, "1") == 0) return 1;
19035   return 0;
19036 }
19037
19038 static int test_touch_0 (void)
19039 {
19040   if (test_touch_0_skip ()) {
19041     printf ("        %s skipped (reason: environment variable set)\n", "test_touch_0");
19042     return 0;
19043   }
19044
19045   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
19046   {
19047     char device[] = "/dev/sda";
19048     int r;
19049     suppress_error = 0;
19050     r = guestfs_blockdev_setrw (g, device);
19051     if (r == -1)
19052       return -1;
19053   }
19054   {
19055     int r;
19056     suppress_error = 0;
19057     r = guestfs_umount_all (g);
19058     if (r == -1)
19059       return -1;
19060   }
19061   {
19062     int r;
19063     suppress_error = 0;
19064     r = guestfs_lvm_remove_all (g);
19065     if (r == -1)
19066       return -1;
19067   }
19068   {
19069     char device[] = "/dev/sda";
19070     char lines_0[] = ",";
19071     char *lines[] = {
19072       lines_0,
19073       NULL
19074     };
19075     int r;
19076     suppress_error = 0;
19077     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19078     if (r == -1)
19079       return -1;
19080   }
19081   {
19082     char fstype[] = "ext2";
19083     char device[] = "/dev/sda1";
19084     int r;
19085     suppress_error = 0;
19086     r = guestfs_mkfs (g, fstype, device);
19087     if (r == -1)
19088       return -1;
19089   }
19090   {
19091     char device[] = "/dev/sda1";
19092     char mountpoint[] = "/";
19093     int r;
19094     suppress_error = 0;
19095     r = guestfs_mount (g, device, mountpoint);
19096     if (r == -1)
19097       return -1;
19098   }
19099   /* TestOutputTrue for touch (0) */
19100   {
19101     char path[] = "/new";
19102     int r;
19103     suppress_error = 0;
19104     r = guestfs_touch (g, path);
19105     if (r == -1)
19106       return -1;
19107   }
19108   {
19109     char path[] = "/new";
19110     int r;
19111     suppress_error = 0;
19112     r = guestfs_exists (g, path);
19113     if (r == -1)
19114       return -1;
19115     if (!r) {
19116       fprintf (stderr, "test_touch_0: expected true, got false\n");
19117       return -1;
19118     }
19119   }
19120   return 0;
19121 }
19122
19123 static int test_sync_0_skip (void)
19124 {
19125   const char *str;
19126
19127   str = getenv ("TEST_ONLY");
19128   if (str)
19129     return strstr (str, "sync") == NULL;
19130   str = getenv ("SKIP_TEST_SYNC_0");
19131   if (str && strcmp (str, "1") == 0) return 1;
19132   str = getenv ("SKIP_TEST_SYNC");
19133   if (str && strcmp (str, "1") == 0) return 1;
19134   return 0;
19135 }
19136
19137 static int test_sync_0 (void)
19138 {
19139   if (test_sync_0_skip ()) {
19140     printf ("        %s skipped (reason: environment variable set)\n", "test_sync_0");
19141     return 0;
19142   }
19143
19144   /* InitNone|InitEmpty for test_sync_0 */
19145   {
19146     char device[] = "/dev/sda";
19147     int r;
19148     suppress_error = 0;
19149     r = guestfs_blockdev_setrw (g, device);
19150     if (r == -1)
19151       return -1;
19152   }
19153   {
19154     int r;
19155     suppress_error = 0;
19156     r = guestfs_umount_all (g);
19157     if (r == -1)
19158       return -1;
19159   }
19160   {
19161     int r;
19162     suppress_error = 0;
19163     r = guestfs_lvm_remove_all (g);
19164     if (r == -1)
19165       return -1;
19166   }
19167   /* TestRun for sync (0) */
19168   {
19169     int r;
19170     suppress_error = 0;
19171     r = guestfs_sync (g);
19172     if (r == -1)
19173       return -1;
19174   }
19175   return 0;
19176 }
19177
19178 static int test_mount_0_skip (void)
19179 {
19180   const char *str;
19181
19182   str = getenv ("TEST_ONLY");
19183   if (str)
19184     return strstr (str, "mount") == NULL;
19185   str = getenv ("SKIP_TEST_MOUNT_0");
19186   if (str && strcmp (str, "1") == 0) return 1;
19187   str = getenv ("SKIP_TEST_MOUNT");
19188   if (str && strcmp (str, "1") == 0) return 1;
19189   return 0;
19190 }
19191
19192 static int test_mount_0 (void)
19193 {
19194   if (test_mount_0_skip ()) {
19195     printf ("        %s skipped (reason: environment variable set)\n", "test_mount_0");
19196     return 0;
19197   }
19198
19199   /* InitNone|InitEmpty for test_mount_0 */
19200   {
19201     char device[] = "/dev/sda";
19202     int r;
19203     suppress_error = 0;
19204     r = guestfs_blockdev_setrw (g, device);
19205     if (r == -1)
19206       return -1;
19207   }
19208   {
19209     int r;
19210     suppress_error = 0;
19211     r = guestfs_umount_all (g);
19212     if (r == -1)
19213       return -1;
19214   }
19215   {
19216     int r;
19217     suppress_error = 0;
19218     r = guestfs_lvm_remove_all (g);
19219     if (r == -1)
19220       return -1;
19221   }
19222   /* TestOutput for mount (0) */
19223   char expected[] = "new file contents";
19224   {
19225     char device[] = "/dev/sda";
19226     char lines_0[] = ",";
19227     char *lines[] = {
19228       lines_0,
19229       NULL
19230     };
19231     int r;
19232     suppress_error = 0;
19233     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19234     if (r == -1)
19235       return -1;
19236   }
19237   {
19238     char fstype[] = "ext2";
19239     char device[] = "/dev/sda1";
19240     int r;
19241     suppress_error = 0;
19242     r = guestfs_mkfs (g, fstype, device);
19243     if (r == -1)
19244       return -1;
19245   }
19246   {
19247     char device[] = "/dev/sda1";
19248     char mountpoint[] = "/";
19249     int r;
19250     suppress_error = 0;
19251     r = guestfs_mount (g, device, mountpoint);
19252     if (r == -1)
19253       return -1;
19254   }
19255   {
19256     char path[] = "/new";
19257     char content[] = "new file contents";
19258     int r;
19259     suppress_error = 0;
19260     r = guestfs_write_file (g, path, content, 0);
19261     if (r == -1)
19262       return -1;
19263   }
19264   {
19265     char path[] = "/new";
19266     char *r;
19267     suppress_error = 0;
19268     r = guestfs_cat (g, path);
19269     if (r == NULL)
19270       return -1;
19271     if (strcmp (r, expected) != 0) {
19272       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
19273       return -1;
19274     }
19275     free (r);
19276   }
19277   return 0;
19278 }
19279
19280 int main (int argc, char *argv[])
19281 {
19282   char c = 0;
19283   int failed = 0;
19284   const char *filename;
19285   int fd;
19286   int nr_tests, test_num = 0;
19287
19288   setbuf (stdout, NULL);
19289
19290   no_test_warnings ();
19291
19292   g = guestfs_create ();
19293   if (g == NULL) {
19294     printf ("guestfs_create FAILED\n");
19295     exit (1);
19296   }
19297
19298   guestfs_set_error_handler (g, print_error, NULL);
19299
19300   guestfs_set_path (g, "../appliance");
19301
19302   filename = "test1.img";
19303   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19304   if (fd == -1) {
19305     perror (filename);
19306     exit (1);
19307   }
19308   if (lseek (fd, 524288000, SEEK_SET) == -1) {
19309     perror ("lseek");
19310     close (fd);
19311     unlink (filename);
19312     exit (1);
19313   }
19314   if (write (fd, &c, 1) == -1) {
19315     perror ("write");
19316     close (fd);
19317     unlink (filename);
19318     exit (1);
19319   }
19320   if (close (fd) == -1) {
19321     perror (filename);
19322     unlink (filename);
19323     exit (1);
19324   }
19325   if (guestfs_add_drive (g, filename) == -1) {
19326     printf ("guestfs_add_drive %s FAILED\n", filename);
19327     exit (1);
19328   }
19329
19330   filename = "test2.img";
19331   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19332   if (fd == -1) {
19333     perror (filename);
19334     exit (1);
19335   }
19336   if (lseek (fd, 52428800, SEEK_SET) == -1) {
19337     perror ("lseek");
19338     close (fd);
19339     unlink (filename);
19340     exit (1);
19341   }
19342   if (write (fd, &c, 1) == -1) {
19343     perror ("write");
19344     close (fd);
19345     unlink (filename);
19346     exit (1);
19347   }
19348   if (close (fd) == -1) {
19349     perror (filename);
19350     unlink (filename);
19351     exit (1);
19352   }
19353   if (guestfs_add_drive (g, filename) == -1) {
19354     printf ("guestfs_add_drive %s FAILED\n", filename);
19355     exit (1);
19356   }
19357
19358   filename = "test3.img";
19359   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19360   if (fd == -1) {
19361     perror (filename);
19362     exit (1);
19363   }
19364   if (lseek (fd, 10485760, SEEK_SET) == -1) {
19365     perror ("lseek");
19366     close (fd);
19367     unlink (filename);
19368     exit (1);
19369   }
19370   if (write (fd, &c, 1) == -1) {
19371     perror ("write");
19372     close (fd);
19373     unlink (filename);
19374     exit (1);
19375   }
19376   if (close (fd) == -1) {
19377     perror (filename);
19378     unlink (filename);
19379     exit (1);
19380   }
19381   if (guestfs_add_drive (g, filename) == -1) {
19382     printf ("guestfs_add_drive %s FAILED\n", filename);
19383     exit (1);
19384   }
19385
19386   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
19387     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
19388     exit (1);
19389   }
19390
19391   if (guestfs_launch (g) == -1) {
19392     printf ("guestfs_launch FAILED\n");
19393     exit (1);
19394   }
19395
19396   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
19397   alarm (600);
19398
19399   if (guestfs_wait_ready (g) == -1) {
19400     printf ("guestfs_wait_ready FAILED\n");
19401     exit (1);
19402   }
19403
19404   /* Cancel previous alarm. */
19405   alarm (0);
19406
19407   nr_tests = 174;
19408
19409   test_num++;
19410   printf ("%3d/%3d test_mknod_c_0\n", test_num, nr_tests);
19411   if (test_mknod_c_0 () == -1) {
19412     printf ("test_mknod_c_0 FAILED\n");
19413     failed++;
19414   }
19415   test_num++;
19416   printf ("%3d/%3d test_mknod_b_0\n", test_num, nr_tests);
19417   if (test_mknod_b_0 () == -1) {
19418     printf ("test_mknod_b_0 FAILED\n");
19419     failed++;
19420   }
19421   test_num++;
19422   printf ("%3d/%3d test_mkfifo_0\n", test_num, nr_tests);
19423   if (test_mkfifo_0 () == -1) {
19424     printf ("test_mkfifo_0 FAILED\n");
19425     failed++;
19426   }
19427   test_num++;
19428   printf ("%3d/%3d test_mknod_0\n", test_num, nr_tests);
19429   if (test_mknod_0 () == -1) {
19430     printf ("test_mknod_0 FAILED\n");
19431     failed++;
19432   }
19433   test_num++;
19434   printf ("%3d/%3d test_mknod_1\n", test_num, nr_tests);
19435   if (test_mknod_1 () == -1) {
19436     printf ("test_mknod_1 FAILED\n");
19437     failed++;
19438   }
19439   test_num++;
19440   printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests);
19441   if (test_mkswap_U_0 () == -1) {
19442     printf ("test_mkswap_U_0 FAILED\n");
19443     failed++;
19444   }
19445   test_num++;
19446   printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests);
19447   if (test_mkswap_L_0 () == -1) {
19448     printf ("test_mkswap_L_0 FAILED\n");
19449     failed++;
19450   }
19451   test_num++;
19452   printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests);
19453   if (test_mkswap_0 () == -1) {
19454     printf ("test_mkswap_0 FAILED\n");
19455     failed++;
19456   }
19457   test_num++;
19458   printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
19459   if (test_initrd_list_0 () == -1) {
19460     printf ("test_initrd_list_0 FAILED\n");
19461     failed++;
19462   }
19463   test_num++;
19464   printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
19465   if (test_du_0 () == -1) {
19466     printf ("test_du_0 FAILED\n");
19467     failed++;
19468   }
19469   test_num++;
19470   printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
19471   if (test_tail_n_0 () == -1) {
19472     printf ("test_tail_n_0 FAILED\n");
19473     failed++;
19474   }
19475   test_num++;
19476   printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
19477   if (test_tail_n_1 () == -1) {
19478     printf ("test_tail_n_1 FAILED\n");
19479     failed++;
19480   }
19481   test_num++;
19482   printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
19483   if (test_tail_n_2 () == -1) {
19484     printf ("test_tail_n_2 FAILED\n");
19485     failed++;
19486   }
19487   test_num++;
19488   printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
19489   if (test_tail_0 () == -1) {
19490     printf ("test_tail_0 FAILED\n");
19491     failed++;
19492   }
19493   test_num++;
19494   printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
19495   if (test_head_n_0 () == -1) {
19496     printf ("test_head_n_0 FAILED\n");
19497     failed++;
19498   }
19499   test_num++;
19500   printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
19501   if (test_head_n_1 () == -1) {
19502     printf ("test_head_n_1 FAILED\n");
19503     failed++;
19504   }
19505   test_num++;
19506   printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
19507   if (test_head_n_2 () == -1) {
19508     printf ("test_head_n_2 FAILED\n");
19509     failed++;
19510   }
19511   test_num++;
19512   printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
19513   if (test_head_0 () == -1) {
19514     printf ("test_head_0 FAILED\n");
19515     failed++;
19516   }
19517   test_num++;
19518   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
19519   if (test_wc_c_0 () == -1) {
19520     printf ("test_wc_c_0 FAILED\n");
19521     failed++;
19522   }
19523   test_num++;
19524   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
19525   if (test_wc_w_0 () == -1) {
19526     printf ("test_wc_w_0 FAILED\n");
19527     failed++;
19528   }
19529   test_num++;
19530   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
19531   if (test_wc_l_0 () == -1) {
19532     printf ("test_wc_l_0 FAILED\n");
19533     failed++;
19534   }
19535   test_num++;
19536   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
19537   if (test_mkdtemp_0 () == -1) {
19538     printf ("test_mkdtemp_0 FAILED\n");
19539     failed++;
19540   }
19541   test_num++;
19542   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
19543   if (test_scrub_file_0 () == -1) {
19544     printf ("test_scrub_file_0 FAILED\n");
19545     failed++;
19546   }
19547   test_num++;
19548   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
19549   if (test_scrub_device_0 () == -1) {
19550     printf ("test_scrub_device_0 FAILED\n");
19551     failed++;
19552   }
19553   test_num++;
19554   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
19555   if (test_glob_expand_0 () == -1) {
19556     printf ("test_glob_expand_0 FAILED\n");
19557     failed++;
19558   }
19559   test_num++;
19560   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
19561   if (test_glob_expand_1 () == -1) {
19562     printf ("test_glob_expand_1 FAILED\n");
19563     failed++;
19564   }
19565   test_num++;
19566   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
19567   if (test_glob_expand_2 () == -1) {
19568     printf ("test_glob_expand_2 FAILED\n");
19569     failed++;
19570   }
19571   test_num++;
19572   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
19573   if (test_ntfs_3g_probe_0 () == -1) {
19574     printf ("test_ntfs_3g_probe_0 FAILED\n");
19575     failed++;
19576   }
19577   test_num++;
19578   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
19579   if (test_ntfs_3g_probe_1 () == -1) {
19580     printf ("test_ntfs_3g_probe_1 FAILED\n");
19581     failed++;
19582   }
19583   test_num++;
19584   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
19585   if (test_sleep_0 () == -1) {
19586     printf ("test_sleep_0 FAILED\n");
19587     failed++;
19588   }
19589   test_num++;
19590   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
19591   if (test_find_0 () == -1) {
19592     printf ("test_find_0 FAILED\n");
19593     failed++;
19594   }
19595   test_num++;
19596   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
19597   if (test_find_1 () == -1) {
19598     printf ("test_find_1 FAILED\n");
19599     failed++;
19600   }
19601   test_num++;
19602   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
19603   if (test_find_2 () == -1) {
19604     printf ("test_find_2 FAILED\n");
19605     failed++;
19606   }
19607   test_num++;
19608   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
19609   if (test_lvresize_0 () == -1) {
19610     printf ("test_lvresize_0 FAILED\n");
19611     failed++;
19612   }
19613   test_num++;
19614   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
19615   if (test_zerofree_0 () == -1) {
19616     printf ("test_zerofree_0 FAILED\n");
19617     failed++;
19618   }
19619   test_num++;
19620   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
19621   if (test_hexdump_0 () == -1) {
19622     printf ("test_hexdump_0 FAILED\n");
19623     failed++;
19624   }
19625   test_num++;
19626   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
19627   if (test_hexdump_1 () == -1) {
19628     printf ("test_hexdump_1 FAILED\n");
19629     failed++;
19630   }
19631   test_num++;
19632   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
19633   if (test_strings_e_0 () == -1) {
19634     printf ("test_strings_e_0 FAILED\n");
19635     failed++;
19636   }
19637   test_num++;
19638   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
19639   if (test_strings_e_1 () == -1) {
19640     printf ("test_strings_e_1 FAILED\n");
19641     failed++;
19642   }
19643   test_num++;
19644   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
19645   if (test_strings_0 () == -1) {
19646     printf ("test_strings_0 FAILED\n");
19647     failed++;
19648   }
19649   test_num++;
19650   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
19651   if (test_strings_1 () == -1) {
19652     printf ("test_strings_1 FAILED\n");
19653     failed++;
19654   }
19655   test_num++;
19656   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
19657   if (test_equal_0 () == -1) {
19658     printf ("test_equal_0 FAILED\n");
19659     failed++;
19660   }
19661   test_num++;
19662   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
19663   if (test_equal_1 () == -1) {
19664     printf ("test_equal_1 FAILED\n");
19665     failed++;
19666   }
19667   test_num++;
19668   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
19669   if (test_equal_2 () == -1) {
19670     printf ("test_equal_2 FAILED\n");
19671     failed++;
19672   }
19673   test_num++;
19674   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
19675   if (test_ping_daemon_0 () == -1) {
19676     printf ("test_ping_daemon_0 FAILED\n");
19677     failed++;
19678   }
19679   test_num++;
19680   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
19681   if (test_dmesg_0 () == -1) {
19682     printf ("test_dmesg_0 FAILED\n");
19683     failed++;
19684   }
19685   test_num++;
19686   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
19687   if (test_drop_caches_0 () == -1) {
19688     printf ("test_drop_caches_0 FAILED\n");
19689     failed++;
19690   }
19691   test_num++;
19692   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19693   if (test_mv_0 () == -1) {
19694     printf ("test_mv_0 FAILED\n");
19695     failed++;
19696   }
19697   test_num++;
19698   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19699   if (test_mv_1 () == -1) {
19700     printf ("test_mv_1 FAILED\n");
19701     failed++;
19702   }
19703   test_num++;
19704   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19705   if (test_cp_a_0 () == -1) {
19706     printf ("test_cp_a_0 FAILED\n");
19707     failed++;
19708   }
19709   test_num++;
19710   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19711   if (test_cp_0 () == -1) {
19712     printf ("test_cp_0 FAILED\n");
19713     failed++;
19714   }
19715   test_num++;
19716   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19717   if (test_cp_1 () == -1) {
19718     printf ("test_cp_1 FAILED\n");
19719     failed++;
19720   }
19721   test_num++;
19722   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19723   if (test_cp_2 () == -1) {
19724     printf ("test_cp_2 FAILED\n");
19725     failed++;
19726   }
19727   test_num++;
19728   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19729   if (test_grub_install_0 () == -1) {
19730     printf ("test_grub_install_0 FAILED\n");
19731     failed++;
19732   }
19733   test_num++;
19734   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19735   if (test_zero_0 () == -1) {
19736     printf ("test_zero_0 FAILED\n");
19737     failed++;
19738   }
19739   test_num++;
19740   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19741   if (test_fsck_0 () == -1) {
19742     printf ("test_fsck_0 FAILED\n");
19743     failed++;
19744   }
19745   test_num++;
19746   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19747   if (test_fsck_1 () == -1) {
19748     printf ("test_fsck_1 FAILED\n");
19749     failed++;
19750   }
19751   test_num++;
19752   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19753   if (test_set_e2uuid_0 () == -1) {
19754     printf ("test_set_e2uuid_0 FAILED\n");
19755     failed++;
19756   }
19757   test_num++;
19758   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19759   if (test_set_e2uuid_1 () == -1) {
19760     printf ("test_set_e2uuid_1 FAILED\n");
19761     failed++;
19762   }
19763   test_num++;
19764   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19765   if (test_set_e2uuid_2 () == -1) {
19766     printf ("test_set_e2uuid_2 FAILED\n");
19767     failed++;
19768   }
19769   test_num++;
19770   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19771   if (test_set_e2uuid_3 () == -1) {
19772     printf ("test_set_e2uuid_3 FAILED\n");
19773     failed++;
19774   }
19775   test_num++;
19776   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19777   if (test_set_e2label_0 () == -1) {
19778     printf ("test_set_e2label_0 FAILED\n");
19779     failed++;
19780   }
19781   test_num++;
19782   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19783   if (test_pvremove_0 () == -1) {
19784     printf ("test_pvremove_0 FAILED\n");
19785     failed++;
19786   }
19787   test_num++;
19788   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19789   if (test_pvremove_1 () == -1) {
19790     printf ("test_pvremove_1 FAILED\n");
19791     failed++;
19792   }
19793   test_num++;
19794   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19795   if (test_pvremove_2 () == -1) {
19796     printf ("test_pvremove_2 FAILED\n");
19797     failed++;
19798   }
19799   test_num++;
19800   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19801   if (test_vgremove_0 () == -1) {
19802     printf ("test_vgremove_0 FAILED\n");
19803     failed++;
19804   }
19805   test_num++;
19806   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19807   if (test_vgremove_1 () == -1) {
19808     printf ("test_vgremove_1 FAILED\n");
19809     failed++;
19810   }
19811   test_num++;
19812   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19813   if (test_lvremove_0 () == -1) {
19814     printf ("test_lvremove_0 FAILED\n");
19815     failed++;
19816   }
19817   test_num++;
19818   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19819   if (test_lvremove_1 () == -1) {
19820     printf ("test_lvremove_1 FAILED\n");
19821     failed++;
19822   }
19823   test_num++;
19824   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19825   if (test_lvremove_2 () == -1) {
19826     printf ("test_lvremove_2 FAILED\n");
19827     failed++;
19828   }
19829   test_num++;
19830   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19831   if (test_mount_ro_0 () == -1) {
19832     printf ("test_mount_ro_0 FAILED\n");
19833     failed++;
19834   }
19835   test_num++;
19836   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19837   if (test_mount_ro_1 () == -1) {
19838     printf ("test_mount_ro_1 FAILED\n");
19839     failed++;
19840   }
19841   test_num++;
19842   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19843   if (test_tgz_in_0 () == -1) {
19844     printf ("test_tgz_in_0 FAILED\n");
19845     failed++;
19846   }
19847   test_num++;
19848   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19849   if (test_tar_in_0 () == -1) {
19850     printf ("test_tar_in_0 FAILED\n");
19851     failed++;
19852   }
19853   test_num++;
19854   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19855   if (test_checksum_0 () == -1) {
19856     printf ("test_checksum_0 FAILED\n");
19857     failed++;
19858   }
19859   test_num++;
19860   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19861   if (test_checksum_1 () == -1) {
19862     printf ("test_checksum_1 FAILED\n");
19863     failed++;
19864   }
19865   test_num++;
19866   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19867   if (test_checksum_2 () == -1) {
19868     printf ("test_checksum_2 FAILED\n");
19869     failed++;
19870   }
19871   test_num++;
19872   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19873   if (test_checksum_3 () == -1) {
19874     printf ("test_checksum_3 FAILED\n");
19875     failed++;
19876   }
19877   test_num++;
19878   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19879   if (test_checksum_4 () == -1) {
19880     printf ("test_checksum_4 FAILED\n");
19881     failed++;
19882   }
19883   test_num++;
19884   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19885   if (test_checksum_5 () == -1) {
19886     printf ("test_checksum_5 FAILED\n");
19887     failed++;
19888   }
19889   test_num++;
19890   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19891   if (test_checksum_6 () == -1) {
19892     printf ("test_checksum_6 FAILED\n");
19893     failed++;
19894   }
19895   test_num++;
19896   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19897   if (test_checksum_7 () == -1) {
19898     printf ("test_checksum_7 FAILED\n");
19899     failed++;
19900   }
19901   test_num++;
19902   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19903   if (test_checksum_8 () == -1) {
19904     printf ("test_checksum_8 FAILED\n");
19905     failed++;
19906   }
19907   test_num++;
19908   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19909   if (test_download_0 () == -1) {
19910     printf ("test_download_0 FAILED\n");
19911     failed++;
19912   }
19913   test_num++;
19914   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19915   if (test_upload_0 () == -1) {
19916     printf ("test_upload_0 FAILED\n");
19917     failed++;
19918   }
19919   test_num++;
19920   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19921   if (test_blockdev_rereadpt_0 () == -1) {
19922     printf ("test_blockdev_rereadpt_0 FAILED\n");
19923     failed++;
19924   }
19925   test_num++;
19926   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19927   if (test_blockdev_flushbufs_0 () == -1) {
19928     printf ("test_blockdev_flushbufs_0 FAILED\n");
19929     failed++;
19930   }
19931   test_num++;
19932   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19933   if (test_blockdev_getsize64_0 () == -1) {
19934     printf ("test_blockdev_getsize64_0 FAILED\n");
19935     failed++;
19936   }
19937   test_num++;
19938   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19939   if (test_blockdev_getsz_0 () == -1) {
19940     printf ("test_blockdev_getsz_0 FAILED\n");
19941     failed++;
19942   }
19943   test_num++;
19944   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19945   if (test_blockdev_getbsz_0 () == -1) {
19946     printf ("test_blockdev_getbsz_0 FAILED\n");
19947     failed++;
19948   }
19949   test_num++;
19950   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19951   if (test_blockdev_getss_0 () == -1) {
19952     printf ("test_blockdev_getss_0 FAILED\n");
19953     failed++;
19954   }
19955   test_num++;
19956   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19957   if (test_blockdev_getro_0 () == -1) {
19958     printf ("test_blockdev_getro_0 FAILED\n");
19959     failed++;
19960   }
19961   test_num++;
19962   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19963   if (test_blockdev_setrw_0 () == -1) {
19964     printf ("test_blockdev_setrw_0 FAILED\n");
19965     failed++;
19966   }
19967   test_num++;
19968   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19969   if (test_blockdev_setro_0 () == -1) {
19970     printf ("test_blockdev_setro_0 FAILED\n");
19971     failed++;
19972   }
19973   test_num++;
19974   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19975   if (test_statvfs_0 () == -1) {
19976     printf ("test_statvfs_0 FAILED\n");
19977     failed++;
19978   }
19979   test_num++;
19980   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19981   if (test_lstat_0 () == -1) {
19982     printf ("test_lstat_0 FAILED\n");
19983     failed++;
19984   }
19985   test_num++;
19986   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19987   if (test_stat_0 () == -1) {
19988     printf ("test_stat_0 FAILED\n");
19989     failed++;
19990   }
19991   test_num++;
19992   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19993   if (test_command_lines_0 () == -1) {
19994     printf ("test_command_lines_0 FAILED\n");
19995     failed++;
19996   }
19997   test_num++;
19998   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19999   if (test_command_lines_1 () == -1) {
20000     printf ("test_command_lines_1 FAILED\n");
20001     failed++;
20002   }
20003   test_num++;
20004   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
20005   if (test_command_lines_2 () == -1) {
20006     printf ("test_command_lines_2 FAILED\n");
20007     failed++;
20008   }
20009   test_num++;
20010   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
20011   if (test_command_lines_3 () == -1) {
20012     printf ("test_command_lines_3 FAILED\n");
20013     failed++;
20014   }
20015   test_num++;
20016   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
20017   if (test_command_lines_4 () == -1) {
20018     printf ("test_command_lines_4 FAILED\n");
20019     failed++;
20020   }
20021   test_num++;
20022   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
20023   if (test_command_lines_5 () == -1) {
20024     printf ("test_command_lines_5 FAILED\n");
20025     failed++;
20026   }
20027   test_num++;
20028   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
20029   if (test_command_lines_6 () == -1) {
20030     printf ("test_command_lines_6 FAILED\n");
20031     failed++;
20032   }
20033   test_num++;
20034   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
20035   if (test_command_lines_7 () == -1) {
20036     printf ("test_command_lines_7 FAILED\n");
20037     failed++;
20038   }
20039   test_num++;
20040   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
20041   if (test_command_lines_8 () == -1) {
20042     printf ("test_command_lines_8 FAILED\n");
20043     failed++;
20044   }
20045   test_num++;
20046   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
20047   if (test_command_lines_9 () == -1) {
20048     printf ("test_command_lines_9 FAILED\n");
20049     failed++;
20050   }
20051   test_num++;
20052   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
20053   if (test_command_lines_10 () == -1) {
20054     printf ("test_command_lines_10 FAILED\n");
20055     failed++;
20056   }
20057   test_num++;
20058   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
20059   if (test_command_0 () == -1) {
20060     printf ("test_command_0 FAILED\n");
20061     failed++;
20062   }
20063   test_num++;
20064   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
20065   if (test_command_1 () == -1) {
20066     printf ("test_command_1 FAILED\n");
20067     failed++;
20068   }
20069   test_num++;
20070   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
20071   if (test_command_2 () == -1) {
20072     printf ("test_command_2 FAILED\n");
20073     failed++;
20074   }
20075   test_num++;
20076   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
20077   if (test_command_3 () == -1) {
20078     printf ("test_command_3 FAILED\n");
20079     failed++;
20080   }
20081   test_num++;
20082   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
20083   if (test_command_4 () == -1) {
20084     printf ("test_command_4 FAILED\n");
20085     failed++;
20086   }
20087   test_num++;
20088   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
20089   if (test_command_5 () == -1) {
20090     printf ("test_command_5 FAILED\n");
20091     failed++;
20092   }
20093   test_num++;
20094   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
20095   if (test_command_6 () == -1) {
20096     printf ("test_command_6 FAILED\n");
20097     failed++;
20098   }
20099   test_num++;
20100   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
20101   if (test_command_7 () == -1) {
20102     printf ("test_command_7 FAILED\n");
20103     failed++;
20104   }
20105   test_num++;
20106   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
20107   if (test_command_8 () == -1) {
20108     printf ("test_command_8 FAILED\n");
20109     failed++;
20110   }
20111   test_num++;
20112   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
20113   if (test_command_9 () == -1) {
20114     printf ("test_command_9 FAILED\n");
20115     failed++;
20116   }
20117   test_num++;
20118   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
20119   if (test_command_10 () == -1) {
20120     printf ("test_command_10 FAILED\n");
20121     failed++;
20122   }
20123   test_num++;
20124   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
20125   if (test_command_11 () == -1) {
20126     printf ("test_command_11 FAILED\n");
20127     failed++;
20128   }
20129   test_num++;
20130   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
20131   if (test_file_0 () == -1) {
20132     printf ("test_file_0 FAILED\n");
20133     failed++;
20134   }
20135   test_num++;
20136   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
20137   if (test_file_1 () == -1) {
20138     printf ("test_file_1 FAILED\n");
20139     failed++;
20140   }
20141   test_num++;
20142   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
20143   if (test_file_2 () == -1) {
20144     printf ("test_file_2 FAILED\n");
20145     failed++;
20146   }
20147   test_num++;
20148   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
20149   if (test_umount_all_0 () == -1) {
20150     printf ("test_umount_all_0 FAILED\n");
20151     failed++;
20152   }
20153   test_num++;
20154   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
20155   if (test_umount_all_1 () == -1) {
20156     printf ("test_umount_all_1 FAILED\n");
20157     failed++;
20158   }
20159   test_num++;
20160   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
20161   if (test_mounts_0 () == -1) {
20162     printf ("test_mounts_0 FAILED\n");
20163     failed++;
20164   }
20165   test_num++;
20166   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
20167   if (test_umount_0 () == -1) {
20168     printf ("test_umount_0 FAILED\n");
20169     failed++;
20170   }
20171   test_num++;
20172   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
20173   if (test_umount_1 () == -1) {
20174     printf ("test_umount_1 FAILED\n");
20175     failed++;
20176   }
20177   test_num++;
20178   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
20179   if (test_write_file_0 () == -1) {
20180     printf ("test_write_file_0 FAILED\n");
20181     failed++;
20182   }
20183   test_num++;
20184   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
20185   if (test_write_file_1 () == -1) {
20186     printf ("test_write_file_1 FAILED\n");
20187     failed++;
20188   }
20189   test_num++;
20190   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
20191   if (test_write_file_2 () == -1) {
20192     printf ("test_write_file_2 FAILED\n");
20193     failed++;
20194   }
20195   test_num++;
20196   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
20197   if (test_write_file_3 () == -1) {
20198     printf ("test_write_file_3 FAILED\n");
20199     failed++;
20200   }
20201   test_num++;
20202   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
20203   if (test_write_file_4 () == -1) {
20204     printf ("test_write_file_4 FAILED\n");
20205     failed++;
20206   }
20207   test_num++;
20208   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
20209   if (test_write_file_5 () == -1) {
20210     printf ("test_write_file_5 FAILED\n");
20211     failed++;
20212   }
20213   test_num++;
20214   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
20215   if (test_mkfs_0 () == -1) {
20216     printf ("test_mkfs_0 FAILED\n");
20217     failed++;
20218   }
20219   test_num++;
20220   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
20221   if (test_lvcreate_0 () == -1) {
20222     printf ("test_lvcreate_0 FAILED\n");
20223     failed++;
20224   }
20225   test_num++;
20226   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
20227   if (test_vgcreate_0 () == -1) {
20228     printf ("test_vgcreate_0 FAILED\n");
20229     failed++;
20230   }
20231   test_num++;
20232   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
20233   if (test_pvcreate_0 () == -1) {
20234     printf ("test_pvcreate_0 FAILED\n");
20235     failed++;
20236   }
20237   test_num++;
20238   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
20239   if (test_is_dir_0 () == -1) {
20240     printf ("test_is_dir_0 FAILED\n");
20241     failed++;
20242   }
20243   test_num++;
20244   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
20245   if (test_is_dir_1 () == -1) {
20246     printf ("test_is_dir_1 FAILED\n");
20247     failed++;
20248   }
20249   test_num++;
20250   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
20251   if (test_is_file_0 () == -1) {
20252     printf ("test_is_file_0 FAILED\n");
20253     failed++;
20254   }
20255   test_num++;
20256   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
20257   if (test_is_file_1 () == -1) {
20258     printf ("test_is_file_1 FAILED\n");
20259     failed++;
20260   }
20261   test_num++;
20262   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
20263   if (test_exists_0 () == -1) {
20264     printf ("test_exists_0 FAILED\n");
20265     failed++;
20266   }
20267   test_num++;
20268   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
20269   if (test_exists_1 () == -1) {
20270     printf ("test_exists_1 FAILED\n");
20271     failed++;
20272   }
20273   test_num++;
20274   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
20275   if (test_mkdir_p_0 () == -1) {
20276     printf ("test_mkdir_p_0 FAILED\n");
20277     failed++;
20278   }
20279   test_num++;
20280   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
20281   if (test_mkdir_p_1 () == -1) {
20282     printf ("test_mkdir_p_1 FAILED\n");
20283     failed++;
20284   }
20285   test_num++;
20286   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
20287   if (test_mkdir_p_2 () == -1) {
20288     printf ("test_mkdir_p_2 FAILED\n");
20289     failed++;
20290   }
20291   test_num++;
20292   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
20293   if (test_mkdir_p_3 () == -1) {
20294     printf ("test_mkdir_p_3 FAILED\n");
20295     failed++;
20296   }
20297   test_num++;
20298   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
20299   if (test_mkdir_p_4 () == -1) {
20300     printf ("test_mkdir_p_4 FAILED\n");
20301     failed++;
20302   }
20303   test_num++;
20304   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
20305   if (test_mkdir_0 () == -1) {
20306     printf ("test_mkdir_0 FAILED\n");
20307     failed++;
20308   }
20309   test_num++;
20310   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
20311   if (test_mkdir_1 () == -1) {
20312     printf ("test_mkdir_1 FAILED\n");
20313     failed++;
20314   }
20315   test_num++;
20316   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
20317   if (test_rm_rf_0 () == -1) {
20318     printf ("test_rm_rf_0 FAILED\n");
20319     failed++;
20320   }
20321   test_num++;
20322   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
20323   if (test_rmdir_0 () == -1) {
20324     printf ("test_rmdir_0 FAILED\n");
20325     failed++;
20326   }
20327   test_num++;
20328   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
20329   if (test_rmdir_1 () == -1) {
20330     printf ("test_rmdir_1 FAILED\n");
20331     failed++;
20332   }
20333   test_num++;
20334   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
20335   if (test_rmdir_2 () == -1) {
20336     printf ("test_rmdir_2 FAILED\n");
20337     failed++;
20338   }
20339   test_num++;
20340   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
20341   if (test_rm_0 () == -1) {
20342     printf ("test_rm_0 FAILED\n");
20343     failed++;
20344   }
20345   test_num++;
20346   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
20347   if (test_rm_1 () == -1) {
20348     printf ("test_rm_1 FAILED\n");
20349     failed++;
20350   }
20351   test_num++;
20352   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
20353   if (test_rm_2 () == -1) {
20354     printf ("test_rm_2 FAILED\n");
20355     failed++;
20356   }
20357   test_num++;
20358   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
20359   if (test_read_lines_0 () == -1) {
20360     printf ("test_read_lines_0 FAILED\n");
20361     failed++;
20362   }
20363   test_num++;
20364   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
20365   if (test_read_lines_1 () == -1) {
20366     printf ("test_read_lines_1 FAILED\n");
20367     failed++;
20368   }
20369   test_num++;
20370   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
20371   if (test_lvs_0 () == -1) {
20372     printf ("test_lvs_0 FAILED\n");
20373     failed++;
20374   }
20375   test_num++;
20376   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
20377   if (test_lvs_1 () == -1) {
20378     printf ("test_lvs_1 FAILED\n");
20379     failed++;
20380   }
20381   test_num++;
20382   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
20383   if (test_vgs_0 () == -1) {
20384     printf ("test_vgs_0 FAILED\n");
20385     failed++;
20386   }
20387   test_num++;
20388   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
20389   if (test_vgs_1 () == -1) {
20390     printf ("test_vgs_1 FAILED\n");
20391     failed++;
20392   }
20393   test_num++;
20394   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
20395   if (test_pvs_0 () == -1) {
20396     printf ("test_pvs_0 FAILED\n");
20397     failed++;
20398   }
20399   test_num++;
20400   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
20401   if (test_pvs_1 () == -1) {
20402     printf ("test_pvs_1 FAILED\n");
20403     failed++;
20404   }
20405   test_num++;
20406   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
20407   if (test_list_partitions_0 () == -1) {
20408     printf ("test_list_partitions_0 FAILED\n");
20409     failed++;
20410   }
20411   test_num++;
20412   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
20413   if (test_list_partitions_1 () == -1) {
20414     printf ("test_list_partitions_1 FAILED\n");
20415     failed++;
20416   }
20417   test_num++;
20418   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
20419   if (test_list_devices_0 () == -1) {
20420     printf ("test_list_devices_0 FAILED\n");
20421     failed++;
20422   }
20423   test_num++;
20424   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
20425   if (test_ls_0 () == -1) {
20426     printf ("test_ls_0 FAILED\n");
20427     failed++;
20428   }
20429   test_num++;
20430   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
20431   if (test_cat_0 () == -1) {
20432     printf ("test_cat_0 FAILED\n");
20433     failed++;
20434   }
20435   test_num++;
20436   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
20437   if (test_touch_0 () == -1) {
20438     printf ("test_touch_0 FAILED\n");
20439     failed++;
20440   }
20441   test_num++;
20442   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
20443   if (test_sync_0 () == -1) {
20444     printf ("test_sync_0 FAILED\n");
20445     failed++;
20446   }
20447   test_num++;
20448   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
20449   if (test_mount_0 () == -1) {
20450     printf ("test_mount_0 FAILED\n");
20451     failed++;
20452   }
20453
20454   guestfs_close (g);
20455   unlink ("test1.img");
20456   unlink ("test2.img");
20457   unlink ("test3.img");
20458
20459   if (failed > 0) {
20460     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
20461     exit (1);
20462   }
20463
20464   exit (0);
20465 }