capitests/tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 static void print_error (guestfs_h *g, void *data, const char *msg)
  35 {
  36   if (!suppress_error)
  37     fprintf (stderr, "%s\n", msg);
  38 }
  39
  40 static void print_strings (char * const * const argv)
  41 {
  42   int argc;
  43
  44   for (argc = 0; argv[argc] != NULL; ++argc)
  45     printf ("\t%s\n", argv[argc]);
  46 }
  47
  48 /*
  49 static void print_table (char * const * const argv)
  50 {
  51   int i;
  52
  53   for (i = 0; argv[i] != NULL; i += 2)
  54     printf ("%s: %s\n", argv[i], argv[i+1]);
  55 }
  56 */
  57
  58 static void no_test_warnings (void)
  59 {
  60   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  61   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  62   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  63   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  64   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  65   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 154 }
 155
 156 static int test_tail_n_0_skip (void)
 157 {
 158   const char *str;
 159
 160   str = getenv ("TEST_ONLY");
 161   if (str)
 162     return strstr (str, "tail_n") == NULL;
 163   str = getenv ("SKIP_TEST_TAIL_N_0");
 164   if (str && strcmp (str, "1") == 0) return 1;
 165   str = getenv ("SKIP_TEST_TAIL_N");
 166   if (str && strcmp (str, "1") == 0) return 1;
 167   return 0;
 168 }
 169
 170 static int test_tail_n_0 (void)
 171 {
 172   if (test_tail_n_0_skip ()) {
 173     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
 174     return 0;
 175   }
 176
 177   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
 178   {
 179     char device[] = "/dev/sda";
 180     int r;
 181     suppress_error = 0;
 182     r = guestfs_blockdev_setrw (g, device);
 183     if (r == -1)
 184       return -1;
 185   }
 186   {
 187     int r;
 188     suppress_error = 0;
 189     r = guestfs_umount_all (g);
 190     if (r == -1)
 191       return -1;
 192   }
 193   {
 194     int r;
 195     suppress_error = 0;
 196     r = guestfs_lvm_remove_all (g);
 197     if (r == -1)
 198       return -1;
 199   }
 200   {
 201     char device[] = "/dev/sda";
 202     char lines_0[] = ",";
 203     char *lines[] = {
 204       lines_0,
 205       NULL
 206     };
 207     int r;
 208     suppress_error = 0;
 209     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 210     if (r == -1)
 211       return -1;
 212   }
 213   {
 214     char fstype[] = "ext2";
 215     char device[] = "/dev/sda1";
 216     int r;
 217     suppress_error = 0;
 218     r = guestfs_mkfs (g, fstype, device);
 219     if (r == -1)
 220       return -1;
 221   }
 222   {
 223     char device[] = "/dev/sda1";
 224     char mountpoint[] = "/";
 225     int r;
 226     suppress_error = 0;
 227     r = guestfs_mount (g, device, mountpoint);
 228     if (r == -1)
 229       return -1;
 230   }
 231   /* TestOutputList for tail_n (0) */
 232   {
 233     char options[] = "ro";
 234     char vfstype[] = "squashfs";
 235     char device[] = "/dev/sdd";
 236     char mountpoint[] = "/";
 237     int r;
 238     suppress_error = 0;
 239     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 240     if (r == -1)
 241       return -1;
 242   }
 243   {
 244     char path[] = "/10klines";
 245     char **r;
 246     int i;
 247     suppress_error = 0;
 248     r = guestfs_tail_n (g, 3, path);
 249     if (r == NULL)
 250       return -1;
 251     if (!r[0]) {
 252       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 253       print_strings (r);
 254       return -1;
 255     }
 256     {
 257       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 258       if (strcmp (r[0], expected) != 0) {
 259         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 260         return -1;
 261       }
 262     }
 263     if (!r[1]) {
 264       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 265       print_strings (r);
 266       return -1;
 267     }
 268     {
 269       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 270       if (strcmp (r[1], expected) != 0) {
 271         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 272         return -1;
 273       }
 274     }
 275     if (!r[2]) {
 276       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 277       print_strings (r);
 278       return -1;
 279     }
 280     {
 281       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 282       if (strcmp (r[2], expected) != 0) {
 283         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 284         return -1;
 285       }
 286     }
 287     if (r[3] != NULL) {
 288       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
 289       print_strings (r);
 290       return -1;
 291     }
 292     for (i = 0; r[i] != NULL; ++i)
 293       free (r[i]);
 294     free (r);
 295   }
 296   return 0;
 297 }
 298
 299 static int test_tail_n_1_skip (void)
 300 {
 301   const char *str;
 302
 303   str = getenv ("TEST_ONLY");
 304   if (str)
 305     return strstr (str, "tail_n") == NULL;
 306   str = getenv ("SKIP_TEST_TAIL_N_1");
 307   if (str && strcmp (str, "1") == 0) return 1;
 308   str = getenv ("SKIP_TEST_TAIL_N");
 309   if (str && strcmp (str, "1") == 0) return 1;
 310   return 0;
 311 }
 312
 313 static int test_tail_n_1 (void)
 314 {
 315   if (test_tail_n_1_skip ()) {
 316     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
 317     return 0;
 318   }
 319
 320   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
 321   {
 322     char device[] = "/dev/sda";
 323     int r;
 324     suppress_error = 0;
 325     r = guestfs_blockdev_setrw (g, device);
 326     if (r == -1)
 327       return -1;
 328   }
 329   {
 330     int r;
 331     suppress_error = 0;
 332     r = guestfs_umount_all (g);
 333     if (r == -1)
 334       return -1;
 335   }
 336   {
 337     int r;
 338     suppress_error = 0;
 339     r = guestfs_lvm_remove_all (g);
 340     if (r == -1)
 341       return -1;
 342   }
 343   {
 344     char device[] = "/dev/sda";
 345     char lines_0[] = ",";
 346     char *lines[] = {
 347       lines_0,
 348       NULL
 349     };
 350     int r;
 351     suppress_error = 0;
 352     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 353     if (r == -1)
 354       return -1;
 355   }
 356   {
 357     char fstype[] = "ext2";
 358     char device[] = "/dev/sda1";
 359     int r;
 360     suppress_error = 0;
 361     r = guestfs_mkfs (g, fstype, device);
 362     if (r == -1)
 363       return -1;
 364   }
 365   {
 366     char device[] = "/dev/sda1";
 367     char mountpoint[] = "/";
 368     int r;
 369     suppress_error = 0;
 370     r = guestfs_mount (g, device, mountpoint);
 371     if (r == -1)
 372       return -1;
 373   }
 374   /* TestOutputList for tail_n (1) */
 375   {
 376     char options[] = "ro";
 377     char vfstype[] = "squashfs";
 378     char device[] = "/dev/sdd";
 379     char mountpoint[] = "/";
 380     int r;
 381     suppress_error = 0;
 382     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 383     if (r == -1)
 384       return -1;
 385   }
 386   {
 387     char path[] = "/10klines";
 388     char **r;
 389     int i;
 390     suppress_error = 0;
 391     r = guestfs_tail_n (g, -9998, path);
 392     if (r == NULL)
 393       return -1;
 394     if (!r[0]) {
 395       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 396       print_strings (r);
 397       return -1;
 398     }
 399     {
 400       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 401       if (strcmp (r[0], expected) != 0) {
 402         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 403         return -1;
 404       }
 405     }
 406     if (!r[1]) {
 407       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 408       print_strings (r);
 409       return -1;
 410     }
 411     {
 412       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 413       if (strcmp (r[1], expected) != 0) {
 414         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 415         return -1;
 416       }
 417     }
 418     if (!r[2]) {
 419       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 420       print_strings (r);
 421       return -1;
 422     }
 423     {
 424       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 425       if (strcmp (r[2], expected) != 0) {
 426         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 427         return -1;
 428       }
 429     }
 430     if (r[3] != NULL) {
 431       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
 432       print_strings (r);
 433       return -1;
 434     }
 435     for (i = 0; r[i] != NULL; ++i)
 436       free (r[i]);
 437     free (r);
 438   }
 439   return 0;
 440 }
 441
 442 static int test_tail_n_2_skip (void)
 443 {
 444   const char *str;
 445
 446   str = getenv ("TEST_ONLY");
 447   if (str)
 448     return strstr (str, "tail_n") == NULL;
 449   str = getenv ("SKIP_TEST_TAIL_N_2");
 450   if (str && strcmp (str, "1") == 0) return 1;
 451   str = getenv ("SKIP_TEST_TAIL_N");
 452   if (str && strcmp (str, "1") == 0) return 1;
 453   return 0;
 454 }
 455
 456 static int test_tail_n_2 (void)
 457 {
 458   if (test_tail_n_2_skip ()) {
 459     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
 460     return 0;
 461   }
 462
 463   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
 464   {
 465     char device[] = "/dev/sda";
 466     int r;
 467     suppress_error = 0;
 468     r = guestfs_blockdev_setrw (g, device);
 469     if (r == -1)
 470       return -1;
 471   }
 472   {
 473     int r;
 474     suppress_error = 0;
 475     r = guestfs_umount_all (g);
 476     if (r == -1)
 477       return -1;
 478   }
 479   {
 480     int r;
 481     suppress_error = 0;
 482     r = guestfs_lvm_remove_all (g);
 483     if (r == -1)
 484       return -1;
 485   }
 486   {
 487     char device[] = "/dev/sda";
 488     char lines_0[] = ",";
 489     char *lines[] = {
 490       lines_0,
 491       NULL
 492     };
 493     int r;
 494     suppress_error = 0;
 495     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 496     if (r == -1)
 497       return -1;
 498   }
 499   {
 500     char fstype[] = "ext2";
 501     char device[] = "/dev/sda1";
 502     int r;
 503     suppress_error = 0;
 504     r = guestfs_mkfs (g, fstype, device);
 505     if (r == -1)
 506       return -1;
 507   }
 508   {
 509     char device[] = "/dev/sda1";
 510     char mountpoint[] = "/";
 511     int r;
 512     suppress_error = 0;
 513     r = guestfs_mount (g, device, mountpoint);
 514     if (r == -1)
 515       return -1;
 516   }
 517   /* TestOutputList for tail_n (2) */
 518   {
 519     char options[] = "ro";
 520     char vfstype[] = "squashfs";
 521     char device[] = "/dev/sdd";
 522     char mountpoint[] = "/";
 523     int r;
 524     suppress_error = 0;
 525     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 526     if (r == -1)
 527       return -1;
 528   }
 529   {
 530     char path[] = "/10klines";
 531     char **r;
 532     int i;
 533     suppress_error = 0;
 534     r = guestfs_tail_n (g, 0, path);
 535     if (r == NULL)
 536       return -1;
 537     if (r[0] != NULL) {
 538       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
 539       print_strings (r);
 540       return -1;
 541     }
 542     for (i = 0; r[i] != NULL; ++i)
 543       free (r[i]);
 544     free (r);
 545   }
 546   return 0;
 547 }
 548
 549 static int test_tail_0_skip (void)
 550 {
 551   const char *str;
 552
 553   str = getenv ("TEST_ONLY");
 554   if (str)
 555     return strstr (str, "tail") == NULL;
 556   str = getenv ("SKIP_TEST_TAIL_0");
 557   if (str && strcmp (str, "1") == 0) return 1;
 558   str = getenv ("SKIP_TEST_TAIL");
 559   if (str && strcmp (str, "1") == 0) return 1;
 560   return 0;
 561 }
 562
 563 static int test_tail_0 (void)
 564 {
 565   if (test_tail_0_skip ()) {
 566     printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
 567     return 0;
 568   }
 569
 570   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
 571   {
 572     char device[] = "/dev/sda";
 573     int r;
 574     suppress_error = 0;
 575     r = guestfs_blockdev_setrw (g, device);
 576     if (r == -1)
 577       return -1;
 578   }
 579   {
 580     int r;
 581     suppress_error = 0;
 582     r = guestfs_umount_all (g);
 583     if (r == -1)
 584       return -1;
 585   }
 586   {
 587     int r;
 588     suppress_error = 0;
 589     r = guestfs_lvm_remove_all (g);
 590     if (r == -1)
 591       return -1;
 592   }
 593   {
 594     char device[] = "/dev/sda";
 595     char lines_0[] = ",";
 596     char *lines[] = {
 597       lines_0,
 598       NULL
 599     };
 600     int r;
 601     suppress_error = 0;
 602     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 603     if (r == -1)
 604       return -1;
 605   }
 606   {
 607     char fstype[] = "ext2";
 608     char device[] = "/dev/sda1";
 609     int r;
 610     suppress_error = 0;
 611     r = guestfs_mkfs (g, fstype, device);
 612     if (r == -1)
 613       return -1;
 614   }
 615   {
 616     char device[] = "/dev/sda1";
 617     char mountpoint[] = "/";
 618     int r;
 619     suppress_error = 0;
 620     r = guestfs_mount (g, device, mountpoint);
 621     if (r == -1)
 622       return -1;
 623   }
 624   /* TestOutputList for tail (0) */
 625   {
 626     char options[] = "ro";
 627     char vfstype[] = "squashfs";
 628     char device[] = "/dev/sdd";
 629     char mountpoint[] = "/";
 630     int r;
 631     suppress_error = 0;
 632     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 633     if (r == -1)
 634       return -1;
 635   }
 636   {
 637     char path[] = "/10klines";
 638     char **r;
 639     int i;
 640     suppress_error = 0;
 641     r = guestfs_tail (g, path);
 642     if (r == NULL)
 643       return -1;
 644     if (!r[0]) {
 645       fprintf (stderr, "test_tail_0: short list returned from command\n");
 646       print_strings (r);
 647       return -1;
 648     }
 649     {
 650       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
 651       if (strcmp (r[0], expected) != 0) {
 652         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 653         return -1;
 654       }
 655     }
 656     if (!r[1]) {
 657       fprintf (stderr, "test_tail_0: short list returned from command\n");
 658       print_strings (r);
 659       return -1;
 660     }
 661     {
 662       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
 663       if (strcmp (r[1], expected) != 0) {
 664         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 665         return -1;
 666       }
 667     }
 668     if (!r[2]) {
 669       fprintf (stderr, "test_tail_0: short list returned from command\n");
 670       print_strings (r);
 671       return -1;
 672     }
 673     {
 674       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
 675       if (strcmp (r[2], expected) != 0) {
 676         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 677         return -1;
 678       }
 679     }
 680     if (!r[3]) {
 681       fprintf (stderr, "test_tail_0: short list returned from command\n");
 682       print_strings (r);
 683       return -1;
 684     }
 685     {
 686       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
 687       if (strcmp (r[3], expected) != 0) {
 688         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 689         return -1;
 690       }
 691     }
 692     if (!r[4]) {
 693       fprintf (stderr, "test_tail_0: short list returned from command\n");
 694       print_strings (r);
 695       return -1;
 696     }
 697     {
 698       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
 699       if (strcmp (r[4], expected) != 0) {
 700         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
 701         return -1;
 702       }
 703     }
 704     if (!r[5]) {
 705       fprintf (stderr, "test_tail_0: short list returned from command\n");
 706       print_strings (r);
 707       return -1;
 708     }
 709     {
 710       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
 711       if (strcmp (r[5], expected) != 0) {
 712         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
 713         return -1;
 714       }
 715     }
 716     if (!r[6]) {
 717       fprintf (stderr, "test_tail_0: short list returned from command\n");
 718       print_strings (r);
 719       return -1;
 720     }
 721     {
 722       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
 723       if (strcmp (r[6], expected) != 0) {
 724         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
 725         return -1;
 726       }
 727     }
 728     if (!r[7]) {
 729       fprintf (stderr, "test_tail_0: short list returned from command\n");
 730       print_strings (r);
 731       return -1;
 732     }
 733     {
 734       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 735       if (strcmp (r[7], expected) != 0) {
 736         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
 737         return -1;
 738       }
 739     }
 740     if (!r[8]) {
 741       fprintf (stderr, "test_tail_0: short list returned from command\n");
 742       print_strings (r);
 743       return -1;
 744     }
 745     {
 746       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 747       if (strcmp (r[8], expected) != 0) {
 748         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
 749         return -1;
 750       }
 751     }
 752     if (!r[9]) {
 753       fprintf (stderr, "test_tail_0: short list returned from command\n");
 754       print_strings (r);
 755       return -1;
 756     }
 757     {
 758       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 759       if (strcmp (r[9], expected) != 0) {
 760         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
 761         return -1;
 762       }
 763     }
 764     if (r[10] != NULL) {
 765       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
 766       print_strings (r);
 767       return -1;
 768     }
 769     for (i = 0; r[i] != NULL; ++i)
 770       free (r[i]);
 771     free (r);
 772   }
 773   return 0;
 774 }
 775
 776 static int test_head_n_0_skip (void)
 777 {
 778   const char *str;
 779
 780   str = getenv ("TEST_ONLY");
 781   if (str)
 782     return strstr (str, "head_n") == NULL;
 783   str = getenv ("SKIP_TEST_HEAD_N_0");
 784   if (str && strcmp (str, "1") == 0) return 1;
 785   str = getenv ("SKIP_TEST_HEAD_N");
 786   if (str && strcmp (str, "1") == 0) return 1;
 787   return 0;
 788 }
 789
 790 static int test_head_n_0 (void)
 791 {
 792   if (test_head_n_0_skip ()) {
 793     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
 794     return 0;
 795   }
 796
 797   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
 798   {
 799     char device[] = "/dev/sda";
 800     int r;
 801     suppress_error = 0;
 802     r = guestfs_blockdev_setrw (g, device);
 803     if (r == -1)
 804       return -1;
 805   }
 806   {
 807     int r;
 808     suppress_error = 0;
 809     r = guestfs_umount_all (g);
 810     if (r == -1)
 811       return -1;
 812   }
 813   {
 814     int r;
 815     suppress_error = 0;
 816     r = guestfs_lvm_remove_all (g);
 817     if (r == -1)
 818       return -1;
 819   }
 820   {
 821     char device[] = "/dev/sda";
 822     char lines_0[] = ",";
 823     char *lines[] = {
 824       lines_0,
 825       NULL
 826     };
 827     int r;
 828     suppress_error = 0;
 829     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 830     if (r == -1)
 831       return -1;
 832   }
 833   {
 834     char fstype[] = "ext2";
 835     char device[] = "/dev/sda1";
 836     int r;
 837     suppress_error = 0;
 838     r = guestfs_mkfs (g, fstype, device);
 839     if (r == -1)
 840       return -1;
 841   }
 842   {
 843     char device[] = "/dev/sda1";
 844     char mountpoint[] = "/";
 845     int r;
 846     suppress_error = 0;
 847     r = guestfs_mount (g, device, mountpoint);
 848     if (r == -1)
 849       return -1;
 850   }
 851   /* TestOutputList for head_n (0) */
 852   {
 853     char options[] = "ro";
 854     char vfstype[] = "squashfs";
 855     char device[] = "/dev/sdd";
 856     char mountpoint[] = "/";
 857     int r;
 858     suppress_error = 0;
 859     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 860     if (r == -1)
 861       return -1;
 862   }
 863   {
 864     char path[] = "/10klines";
 865     char **r;
 866     int i;
 867     suppress_error = 0;
 868     r = guestfs_head_n (g, 3, path);
 869     if (r == NULL)
 870       return -1;
 871     if (!r[0]) {
 872       fprintf (stderr, "test_head_n_0: short list returned from command\n");
 873       print_strings (r);
 874       return -1;
 875     }
 876     {
 877       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
 878       if (strcmp (r[0], expected) != 0) {
 879         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 880         return -1;
 881       }
 882     }
 883     if (!r[1]) {
 884       fprintf (stderr, "test_head_n_0: short list returned from command\n");
 885       print_strings (r);
 886       return -1;
 887     }
 888     {
 889       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
 890       if (strcmp (r[1], expected) != 0) {
 891         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 892         return -1;
 893       }
 894     }
 895     if (!r[2]) {
 896       fprintf (stderr, "test_head_n_0: short list returned from command\n");
 897       print_strings (r);
 898       return -1;
 899     }
 900     {
 901       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
 902       if (strcmp (r[2], expected) != 0) {
 903         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 904         return -1;
 905       }
 906     }
 907     if (r[3] != NULL) {
 908       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
 909       print_strings (r);
 910       return -1;
 911     }
 912     for (i = 0; r[i] != NULL; ++i)
 913       free (r[i]);
 914     free (r);
 915   }
 916   return 0;
 917 }
 918
 919 static int test_head_n_1_skip (void)
 920 {
 921   const char *str;
 922
 923   str = getenv ("TEST_ONLY");
 924   if (str)
 925     return strstr (str, "head_n") == NULL;
 926   str = getenv ("SKIP_TEST_HEAD_N_1");
 927   if (str && strcmp (str, "1") == 0) return 1;
 928   str = getenv ("SKIP_TEST_HEAD_N");
 929   if (str && strcmp (str, "1") == 0) return 1;
 930   return 0;
 931 }
 932
 933 static int test_head_n_1 (void)
 934 {
 935   if (test_head_n_1_skip ()) {
 936     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
 937     return 0;
 938   }
 939
 940   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
 941   {
 942     char device[] = "/dev/sda";
 943     int r;
 944     suppress_error = 0;
 945     r = guestfs_blockdev_setrw (g, device);
 946     if (r == -1)
 947       return -1;
 948   }
 949   {
 950     int r;
 951     suppress_error = 0;
 952     r = guestfs_umount_all (g);
 953     if (r == -1)
 954       return -1;
 955   }
 956   {
 957     int r;
 958     suppress_error = 0;
 959     r = guestfs_lvm_remove_all (g);
 960     if (r == -1)
 961       return -1;
 962   }
 963   {
 964     char device[] = "/dev/sda";
 965     char lines_0[] = ",";
 966     char *lines[] = {
 967       lines_0,
 968       NULL
 969     };
 970     int r;
 971     suppress_error = 0;
 972     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 973     if (r == -1)
 974       return -1;
 975   }
 976   {
 977     char fstype[] = "ext2";
 978     char device[] = "/dev/sda1";
 979     int r;
 980     suppress_error = 0;
 981     r = guestfs_mkfs (g, fstype, device);
 982     if (r == -1)
 983       return -1;
 984   }
 985   {
 986     char device[] = "/dev/sda1";
 987     char mountpoint[] = "/";
 988     int r;
 989     suppress_error = 0;
 990     r = guestfs_mount (g, device, mountpoint);
 991     if (r == -1)
 992       return -1;
 993   }
 994   /* TestOutputList for head_n (1) */
 995   {
 996     char options[] = "ro";
 997     char vfstype[] = "squashfs";
 998     char device[] = "/dev/sdd";
 999     char mountpoint[] = "/";
1000     int r;
1001     suppress_error = 0;
1002     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1003     if (r == -1)
1004       return -1;
1005   }
1006   {
1007     char path[] = "/10klines";
1008     char **r;
1009     int i;
1010     suppress_error = 0;
1011     r = guestfs_head_n (g, -9997, path);
1012     if (r == NULL)
1013       return -1;
1014     if (!r[0]) {
1015       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1016       print_strings (r);
1017       return -1;
1018     }
1019     {
1020       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1021       if (strcmp (r[0], expected) != 0) {
1022         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1023         return -1;
1024       }
1025     }
1026     if (!r[1]) {
1027       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1028       print_strings (r);
1029       return -1;
1030     }
1031     {
1032       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1033       if (strcmp (r[1], expected) != 0) {
1034         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1035         return -1;
1036       }
1037     }
1038     if (!r[2]) {
1039       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1040       print_strings (r);
1041       return -1;
1042     }
1043     {
1044       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1045       if (strcmp (r[2], expected) != 0) {
1046         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1047         return -1;
1048       }
1049     }
1050     if (r[3] != NULL) {
1051       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1052       print_strings (r);
1053       return -1;
1054     }
1055     for (i = 0; r[i] != NULL; ++i)
1056       free (r[i]);
1057     free (r);
1058   }
1059   return 0;
1060 }
1061
1062 static int test_head_n_2_skip (void)
1063 {
1064   const char *str;
1065
1066   str = getenv ("TEST_ONLY");
1067   if (str)
1068     return strstr (str, "head_n") == NULL;
1069   str = getenv ("SKIP_TEST_HEAD_N_2");
1070   if (str && strcmp (str, "1") == 0) return 1;
1071   str = getenv ("SKIP_TEST_HEAD_N");
1072   if (str && strcmp (str, "1") == 0) return 1;
1073   return 0;
1074 }
1075
1076 static int test_head_n_2 (void)
1077 {
1078   if (test_head_n_2_skip ()) {
1079     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1080     return 0;
1081   }
1082
1083   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1084   {
1085     char device[] = "/dev/sda";
1086     int r;
1087     suppress_error = 0;
1088     r = guestfs_blockdev_setrw (g, device);
1089     if (r == -1)
1090       return -1;
1091   }
1092   {
1093     int r;
1094     suppress_error = 0;
1095     r = guestfs_umount_all (g);
1096     if (r == -1)
1097       return -1;
1098   }
1099   {
1100     int r;
1101     suppress_error = 0;
1102     r = guestfs_lvm_remove_all (g);
1103     if (r == -1)
1104       return -1;
1105   }
1106   {
1107     char device[] = "/dev/sda";
1108     char lines_0[] = ",";
1109     char *lines[] = {
1110       lines_0,
1111       NULL
1112     };
1113     int r;
1114     suppress_error = 0;
1115     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1116     if (r == -1)
1117       return -1;
1118   }
1119   {
1120     char fstype[] = "ext2";
1121     char device[] = "/dev/sda1";
1122     int r;
1123     suppress_error = 0;
1124     r = guestfs_mkfs (g, fstype, device);
1125     if (r == -1)
1126       return -1;
1127   }
1128   {
1129     char device[] = "/dev/sda1";
1130     char mountpoint[] = "/";
1131     int r;
1132     suppress_error = 0;
1133     r = guestfs_mount (g, device, mountpoint);
1134     if (r == -1)
1135       return -1;
1136   }
1137   /* TestOutputList for head_n (2) */
1138   {
1139     char options[] = "ro";
1140     char vfstype[] = "squashfs";
1141     char device[] = "/dev/sdd";
1142     char mountpoint[] = "/";
1143     int r;
1144     suppress_error = 0;
1145     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1146     if (r == -1)
1147       return -1;
1148   }
1149   {
1150     char path[] = "/10klines";
1151     char **r;
1152     int i;
1153     suppress_error = 0;
1154     r = guestfs_head_n (g, 0, path);
1155     if (r == NULL)
1156       return -1;
1157     if (r[0] != NULL) {
1158       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1159       print_strings (r);
1160       return -1;
1161     }
1162     for (i = 0; r[i] != NULL; ++i)
1163       free (r[i]);
1164     free (r);
1165   }
1166   return 0;
1167 }
1168
1169 static int test_head_0_skip (void)
1170 {
1171   const char *str;
1172
1173   str = getenv ("TEST_ONLY");
1174   if (str)
1175     return strstr (str, "head") == NULL;
1176   str = getenv ("SKIP_TEST_HEAD_0");
1177   if (str && strcmp (str, "1") == 0) return 1;
1178   str = getenv ("SKIP_TEST_HEAD");
1179   if (str && strcmp (str, "1") == 0) return 1;
1180   return 0;
1181 }
1182
1183 static int test_head_0 (void)
1184 {
1185   if (test_head_0_skip ()) {
1186     printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1187     return 0;
1188   }
1189
1190   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1191   {
1192     char device[] = "/dev/sda";
1193     int r;
1194     suppress_error = 0;
1195     r = guestfs_blockdev_setrw (g, device);
1196     if (r == -1)
1197       return -1;
1198   }
1199   {
1200     int r;
1201     suppress_error = 0;
1202     r = guestfs_umount_all (g);
1203     if (r == -1)
1204       return -1;
1205   }
1206   {
1207     int r;
1208     suppress_error = 0;
1209     r = guestfs_lvm_remove_all (g);
1210     if (r == -1)
1211       return -1;
1212   }
1213   {
1214     char device[] = "/dev/sda";
1215     char lines_0[] = ",";
1216     char *lines[] = {
1217       lines_0,
1218       NULL
1219     };
1220     int r;
1221     suppress_error = 0;
1222     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1223     if (r == -1)
1224       return -1;
1225   }
1226   {
1227     char fstype[] = "ext2";
1228     char device[] = "/dev/sda1";
1229     int r;
1230     suppress_error = 0;
1231     r = guestfs_mkfs (g, fstype, device);
1232     if (r == -1)
1233       return -1;
1234   }
1235   {
1236     char device[] = "/dev/sda1";
1237     char mountpoint[] = "/";
1238     int r;
1239     suppress_error = 0;
1240     r = guestfs_mount (g, device, mountpoint);
1241     if (r == -1)
1242       return -1;
1243   }
1244   /* TestOutputList for head (0) */
1245   {
1246     char options[] = "ro";
1247     char vfstype[] = "squashfs";
1248     char device[] = "/dev/sdd";
1249     char mountpoint[] = "/";
1250     int r;
1251     suppress_error = 0;
1252     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1253     if (r == -1)
1254       return -1;
1255   }
1256   {
1257     char path[] = "/10klines";
1258     char **r;
1259     int i;
1260     suppress_error = 0;
1261     r = guestfs_head (g, path);
1262     if (r == NULL)
1263       return -1;
1264     if (!r[0]) {
1265       fprintf (stderr, "test_head_0: short list returned from command\n");
1266       print_strings (r);
1267       return -1;
1268     }
1269     {
1270       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1271       if (strcmp (r[0], expected) != 0) {
1272         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1273         return -1;
1274       }
1275     }
1276     if (!r[1]) {
1277       fprintf (stderr, "test_head_0: short list returned from command\n");
1278       print_strings (r);
1279       return -1;
1280     }
1281     {
1282       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1283       if (strcmp (r[1], expected) != 0) {
1284         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1285         return -1;
1286       }
1287     }
1288     if (!r[2]) {
1289       fprintf (stderr, "test_head_0: short list returned from command\n");
1290       print_strings (r);
1291       return -1;
1292     }
1293     {
1294       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1295       if (strcmp (r[2], expected) != 0) {
1296         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1297         return -1;
1298       }
1299     }
1300     if (!r[3]) {
1301       fprintf (stderr, "test_head_0: short list returned from command\n");
1302       print_strings (r);
1303       return -1;
1304     }
1305     {
1306       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1307       if (strcmp (r[3], expected) != 0) {
1308         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1309         return -1;
1310       }
1311     }
1312     if (!r[4]) {
1313       fprintf (stderr, "test_head_0: short list returned from command\n");
1314       print_strings (r);
1315       return -1;
1316     }
1317     {
1318       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1319       if (strcmp (r[4], expected) != 0) {
1320         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1321         return -1;
1322       }
1323     }
1324     if (!r[5]) {
1325       fprintf (stderr, "test_head_0: short list returned from command\n");
1326       print_strings (r);
1327       return -1;
1328     }
1329     {
1330       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1331       if (strcmp (r[5], expected) != 0) {
1332         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1333         return -1;
1334       }
1335     }
1336     if (!r[6]) {
1337       fprintf (stderr, "test_head_0: short list returned from command\n");
1338       print_strings (r);
1339       return -1;
1340     }
1341     {
1342       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1343       if (strcmp (r[6], expected) != 0) {
1344         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1345         return -1;
1346       }
1347     }
1348     if (!r[7]) {
1349       fprintf (stderr, "test_head_0: short list returned from command\n");
1350       print_strings (r);
1351       return -1;
1352     }
1353     {
1354       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1355       if (strcmp (r[7], expected) != 0) {
1356         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1357         return -1;
1358       }
1359     }
1360     if (!r[8]) {
1361       fprintf (stderr, "test_head_0: short list returned from command\n");
1362       print_strings (r);
1363       return -1;
1364     }
1365     {
1366       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1367       if (strcmp (r[8], expected) != 0) {
1368         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1369         return -1;
1370       }
1371     }
1372     if (!r[9]) {
1373       fprintf (stderr, "test_head_0: short list returned from command\n");
1374       print_strings (r);
1375       return -1;
1376     }
1377     {
1378       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1379       if (strcmp (r[9], expected) != 0) {
1380         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1381         return -1;
1382       }
1383     }
1384     if (r[10] != NULL) {
1385       fprintf (stderr, "test_head_0: extra elements returned from command\n");
1386       print_strings (r);
1387       return -1;
1388     }
1389     for (i = 0; r[i] != NULL; ++i)
1390       free (r[i]);
1391     free (r);
1392   }
1393   return 0;
1394 }
1395
1396 static int test_wc_c_0_skip (void)
1397 {
1398   const char *str;
1399
1400   str = getenv ("TEST_ONLY");
1401   if (str)
1402     return strstr (str, "wc_c") == NULL;
1403   str = getenv ("SKIP_TEST_WC_C_0");
1404   if (str && strcmp (str, "1") == 0) return 1;
1405   str = getenv ("SKIP_TEST_WC_C");
1406   if (str && strcmp (str, "1") == 0) return 1;
1407   return 0;
1408 }
1409
1410 static int test_wc_c_0 (void)
1411 {
1412   if (test_wc_c_0_skip ()) {
1413     printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1414     return 0;
1415   }
1416
1417   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1418   {
1419     char device[] = "/dev/sda";
1420     int r;
1421     suppress_error = 0;
1422     r = guestfs_blockdev_setrw (g, device);
1423     if (r == -1)
1424       return -1;
1425   }
1426   {
1427     int r;
1428     suppress_error = 0;
1429     r = guestfs_umount_all (g);
1430     if (r == -1)
1431       return -1;
1432   }
1433   {
1434     int r;
1435     suppress_error = 0;
1436     r = guestfs_lvm_remove_all (g);
1437     if (r == -1)
1438       return -1;
1439   }
1440   {
1441     char device[] = "/dev/sda";
1442     char lines_0[] = ",";
1443     char *lines[] = {
1444       lines_0,
1445       NULL
1446     };
1447     int r;
1448     suppress_error = 0;
1449     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1450     if (r == -1)
1451       return -1;
1452   }
1453   {
1454     char fstype[] = "ext2";
1455     char device[] = "/dev/sda1";
1456     int r;
1457     suppress_error = 0;
1458     r = guestfs_mkfs (g, fstype, device);
1459     if (r == -1)
1460       return -1;
1461   }
1462   {
1463     char device[] = "/dev/sda1";
1464     char mountpoint[] = "/";
1465     int r;
1466     suppress_error = 0;
1467     r = guestfs_mount (g, device, mountpoint);
1468     if (r == -1)
1469       return -1;
1470   }
1471   /* TestOutputInt for wc_c (0) */
1472   {
1473     char options[] = "ro";
1474     char vfstype[] = "squashfs";
1475     char device[] = "/dev/sdd";
1476     char mountpoint[] = "/";
1477     int r;
1478     suppress_error = 0;
1479     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1480     if (r == -1)
1481       return -1;
1482   }
1483   {
1484     char path[] = "/100kallspaces";
1485     int r;
1486     suppress_error = 0;
1487     r = guestfs_wc_c (g, path);
1488     if (r == -1)
1489       return -1;
1490     if (r != 102400) {
1491       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
1492       return -1;
1493     }
1494   }
1495   return 0;
1496 }
1497
1498 static int test_wc_w_0_skip (void)
1499 {
1500   const char *str;
1501
1502   str = getenv ("TEST_ONLY");
1503   if (str)
1504     return strstr (str, "wc_w") == NULL;
1505   str = getenv ("SKIP_TEST_WC_W_0");
1506   if (str && strcmp (str, "1") == 0) return 1;
1507   str = getenv ("SKIP_TEST_WC_W");
1508   if (str && strcmp (str, "1") == 0) return 1;
1509   return 0;
1510 }
1511
1512 static int test_wc_w_0 (void)
1513 {
1514   if (test_wc_w_0_skip ()) {
1515     printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1516     return 0;
1517   }
1518
1519   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1520   {
1521     char device[] = "/dev/sda";
1522     int r;
1523     suppress_error = 0;
1524     r = guestfs_blockdev_setrw (g, device);
1525     if (r == -1)
1526       return -1;
1527   }
1528   {
1529     int r;
1530     suppress_error = 0;
1531     r = guestfs_umount_all (g);
1532     if (r == -1)
1533       return -1;
1534   }
1535   {
1536     int r;
1537     suppress_error = 0;
1538     r = guestfs_lvm_remove_all (g);
1539     if (r == -1)
1540       return -1;
1541   }
1542   {
1543     char device[] = "/dev/sda";
1544     char lines_0[] = ",";
1545     char *lines[] = {
1546       lines_0,
1547       NULL
1548     };
1549     int r;
1550     suppress_error = 0;
1551     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1552     if (r == -1)
1553       return -1;
1554   }
1555   {
1556     char fstype[] = "ext2";
1557     char device[] = "/dev/sda1";
1558     int r;
1559     suppress_error = 0;
1560     r = guestfs_mkfs (g, fstype, device);
1561     if (r == -1)
1562       return -1;
1563   }
1564   {
1565     char device[] = "/dev/sda1";
1566     char mountpoint[] = "/";
1567     int r;
1568     suppress_error = 0;
1569     r = guestfs_mount (g, device, mountpoint);
1570     if (r == -1)
1571       return -1;
1572   }
1573   /* TestOutputInt for wc_w (0) */
1574   {
1575     char options[] = "ro";
1576     char vfstype[] = "squashfs";
1577     char device[] = "/dev/sdd";
1578     char mountpoint[] = "/";
1579     int r;
1580     suppress_error = 0;
1581     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1582     if (r == -1)
1583       return -1;
1584   }
1585   {
1586     char path[] = "/10klines";
1587     int r;
1588     suppress_error = 0;
1589     r = guestfs_wc_w (g, path);
1590     if (r == -1)
1591       return -1;
1592     if (r != 10000) {
1593       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
1594       return -1;
1595     }
1596   }
1597   return 0;
1598 }
1599
1600 static int test_wc_l_0_skip (void)
1601 {
1602   const char *str;
1603
1604   str = getenv ("TEST_ONLY");
1605   if (str)
1606     return strstr (str, "wc_l") == NULL;
1607   str = getenv ("SKIP_TEST_WC_L_0");
1608   if (str && strcmp (str, "1") == 0) return 1;
1609   str = getenv ("SKIP_TEST_WC_L");
1610   if (str && strcmp (str, "1") == 0) return 1;
1611   return 0;
1612 }
1613
1614 static int test_wc_l_0 (void)
1615 {
1616   if (test_wc_l_0_skip ()) {
1617     printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
1618     return 0;
1619   }
1620
1621   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
1622   {
1623     char device[] = "/dev/sda";
1624     int r;
1625     suppress_error = 0;
1626     r = guestfs_blockdev_setrw (g, device);
1627     if (r == -1)
1628       return -1;
1629   }
1630   {
1631     int r;
1632     suppress_error = 0;
1633     r = guestfs_umount_all (g);
1634     if (r == -1)
1635       return -1;
1636   }
1637   {
1638     int r;
1639     suppress_error = 0;
1640     r = guestfs_lvm_remove_all (g);
1641     if (r == -1)
1642       return -1;
1643   }
1644   {
1645     char device[] = "/dev/sda";
1646     char lines_0[] = ",";
1647     char *lines[] = {
1648       lines_0,
1649       NULL
1650     };
1651     int r;
1652     suppress_error = 0;
1653     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1654     if (r == -1)
1655       return -1;
1656   }
1657   {
1658     char fstype[] = "ext2";
1659     char device[] = "/dev/sda1";
1660     int r;
1661     suppress_error = 0;
1662     r = guestfs_mkfs (g, fstype, device);
1663     if (r == -1)
1664       return -1;
1665   }
1666   {
1667     char device[] = "/dev/sda1";
1668     char mountpoint[] = "/";
1669     int r;
1670     suppress_error = 0;
1671     r = guestfs_mount (g, device, mountpoint);
1672     if (r == -1)
1673       return -1;
1674   }
1675   /* TestOutputInt for wc_l (0) */
1676   {
1677     char options[] = "ro";
1678     char vfstype[] = "squashfs";
1679     char device[] = "/dev/sdd";
1680     char mountpoint[] = "/";
1681     int r;
1682     suppress_error = 0;
1683     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1684     if (r == -1)
1685       return -1;
1686   }
1687   {
1688     char path[] = "/10klines";
1689     int r;
1690     suppress_error = 0;
1691     r = guestfs_wc_l (g, path);
1692     if (r == -1)
1693       return -1;
1694     if (r != 10000) {
1695       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
1696       return -1;
1697     }
1698   }
1699   return 0;
1700 }
1701
1702 static int test_mkdtemp_0_skip (void)
1703 {
1704   const char *str;
1705
1706   str = getenv ("TEST_ONLY");
1707   if (str)
1708     return strstr (str, "mkdtemp") == NULL;
1709   str = getenv ("SKIP_TEST_MKDTEMP_0");
1710   if (str && strcmp (str, "1") == 0) return 1;
1711   str = getenv ("SKIP_TEST_MKDTEMP");
1712   if (str && strcmp (str, "1") == 0) return 1;
1713   return 0;
1714 }
1715
1716 static int test_mkdtemp_0 (void)
1717 {
1718   if (test_mkdtemp_0_skip ()) {
1719     printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
1720     return 0;
1721   }
1722
1723   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
1724   {
1725     char device[] = "/dev/sda";
1726     int r;
1727     suppress_error = 0;
1728     r = guestfs_blockdev_setrw (g, device);
1729     if (r == -1)
1730       return -1;
1731   }
1732   {
1733     int r;
1734     suppress_error = 0;
1735     r = guestfs_umount_all (g);
1736     if (r == -1)
1737       return -1;
1738   }
1739   {
1740     int r;
1741     suppress_error = 0;
1742     r = guestfs_lvm_remove_all (g);
1743     if (r == -1)
1744       return -1;
1745   }
1746   {
1747     char device[] = "/dev/sda";
1748     char lines_0[] = ",";
1749     char *lines[] = {
1750       lines_0,
1751       NULL
1752     };
1753     int r;
1754     suppress_error = 0;
1755     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1756     if (r == -1)
1757       return -1;
1758   }
1759   {
1760     char fstype[] = "ext2";
1761     char device[] = "/dev/sda1";
1762     int r;
1763     suppress_error = 0;
1764     r = guestfs_mkfs (g, fstype, device);
1765     if (r == -1)
1766       return -1;
1767   }
1768   {
1769     char device[] = "/dev/sda1";
1770     char mountpoint[] = "/";
1771     int r;
1772     suppress_error = 0;
1773     r = guestfs_mount (g, device, mountpoint);
1774     if (r == -1)
1775       return -1;
1776   }
1777   /* TestRun for mkdtemp (0) */
1778   {
1779     char path[] = "/tmp";
1780     int r;
1781     suppress_error = 0;
1782     r = guestfs_mkdir (g, path);
1783     if (r == -1)
1784       return -1;
1785   }
1786   {
1787     char template[] = "/tmp/tmpXXXXXX";
1788     char *r;
1789     suppress_error = 0;
1790     r = guestfs_mkdtemp (g, template);
1791     if (r == NULL)
1792       return -1;
1793     free (r);
1794   }
1795   return 0;
1796 }
1797
1798 static int test_scrub_file_0_skip (void)
1799 {
1800   const char *str;
1801
1802   str = getenv ("TEST_ONLY");
1803   if (str)
1804     return strstr (str, "scrub_file") == NULL;
1805   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
1806   if (str && strcmp (str, "1") == 0) return 1;
1807   str = getenv ("SKIP_TEST_SCRUB_FILE");
1808   if (str && strcmp (str, "1") == 0) return 1;
1809   return 0;
1810 }
1811
1812 static int test_scrub_file_0 (void)
1813 {
1814   if (test_scrub_file_0_skip ()) {
1815     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
1816     return 0;
1817   }
1818
1819   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
1820   {
1821     char device[] = "/dev/sda";
1822     int r;
1823     suppress_error = 0;
1824     r = guestfs_blockdev_setrw (g, device);
1825     if (r == -1)
1826       return -1;
1827   }
1828   {
1829     int r;
1830     suppress_error = 0;
1831     r = guestfs_umount_all (g);
1832     if (r == -1)
1833       return -1;
1834   }
1835   {
1836     int r;
1837     suppress_error = 0;
1838     r = guestfs_lvm_remove_all (g);
1839     if (r == -1)
1840       return -1;
1841   }
1842   {
1843     char device[] = "/dev/sda";
1844     char lines_0[] = ",";
1845     char *lines[] = {
1846       lines_0,
1847       NULL
1848     };
1849     int r;
1850     suppress_error = 0;
1851     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1852     if (r == -1)
1853       return -1;
1854   }
1855   {
1856     char fstype[] = "ext2";
1857     char device[] = "/dev/sda1";
1858     int r;
1859     suppress_error = 0;
1860     r = guestfs_mkfs (g, fstype, device);
1861     if (r == -1)
1862       return -1;
1863   }
1864   {
1865     char device[] = "/dev/sda1";
1866     char mountpoint[] = "/";
1867     int r;
1868     suppress_error = 0;
1869     r = guestfs_mount (g, device, mountpoint);
1870     if (r == -1)
1871       return -1;
1872   }
1873   /* TestRun for scrub_file (0) */
1874   {
1875     char path[] = "/file";
1876     char content[] = "content";
1877     int r;
1878     suppress_error = 0;
1879     r = guestfs_write_file (g, path, content, 0);
1880     if (r == -1)
1881       return -1;
1882   }
1883   {
1884     char file[] = "/file";
1885     int r;
1886     suppress_error = 0;
1887     r = guestfs_scrub_file (g, file);
1888     if (r == -1)
1889       return -1;
1890   }
1891   return 0;
1892 }
1893
1894 static int test_scrub_device_0_skip (void)
1895 {
1896   const char *str;
1897
1898   str = getenv ("TEST_ONLY");
1899   if (str)
1900     return strstr (str, "scrub_device") == NULL;
1901   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
1902   if (str && strcmp (str, "1") == 0) return 1;
1903   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
1904   if (str && strcmp (str, "1") == 0) return 1;
1905   return 0;
1906 }
1907
1908 static int test_scrub_device_0 (void)
1909 {
1910   if (test_scrub_device_0_skip ()) {
1911     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
1912     return 0;
1913   }
1914
1915   /* InitNone|InitEmpty for test_scrub_device_0 */
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   /* TestRun for scrub_device (0) */
1939   {
1940     char device[] = "/dev/sdc";
1941     int r;
1942     suppress_error = 0;
1943     r = guestfs_scrub_device (g, device);
1944     if (r == -1)
1945       return -1;
1946   }
1947   return 0;
1948 }
1949
1950 static int test_glob_expand_0_skip (void)
1951 {
1952   const char *str;
1953
1954   str = getenv ("TEST_ONLY");
1955   if (str)
1956     return strstr (str, "glob_expand") == NULL;
1957   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
1958   if (str && strcmp (str, "1") == 0) return 1;
1959   str = getenv ("SKIP_TEST_GLOB_EXPAND");
1960   if (str && strcmp (str, "1") == 0) return 1;
1961   return 0;
1962 }
1963
1964 static int test_glob_expand_0 (void)
1965 {
1966   if (test_glob_expand_0_skip ()) {
1967     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
1968     return 0;
1969   }
1970
1971   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
1972   {
1973     char device[] = "/dev/sda";
1974     int r;
1975     suppress_error = 0;
1976     r = guestfs_blockdev_setrw (g, device);
1977     if (r == -1)
1978       return -1;
1979   }
1980   {
1981     int r;
1982     suppress_error = 0;
1983     r = guestfs_umount_all (g);
1984     if (r == -1)
1985       return -1;
1986   }
1987   {
1988     int r;
1989     suppress_error = 0;
1990     r = guestfs_lvm_remove_all (g);
1991     if (r == -1)
1992       return -1;
1993   }
1994   {
1995     char device[] = "/dev/sda";
1996     char lines_0[] = ",";
1997     char *lines[] = {
1998       lines_0,
1999       NULL
2000     };
2001     int r;
2002     suppress_error = 0;
2003     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2004     if (r == -1)
2005       return -1;
2006   }
2007   {
2008     char fstype[] = "ext2";
2009     char device[] = "/dev/sda1";
2010     int r;
2011     suppress_error = 0;
2012     r = guestfs_mkfs (g, fstype, device);
2013     if (r == -1)
2014       return -1;
2015   }
2016   {
2017     char device[] = "/dev/sda1";
2018     char mountpoint[] = "/";
2019     int r;
2020     suppress_error = 0;
2021     r = guestfs_mount (g, device, mountpoint);
2022     if (r == -1)
2023       return -1;
2024   }
2025   /* TestOutputList for glob_expand (0) */
2026   {
2027     char path[] = "/a/b/c";
2028     int r;
2029     suppress_error = 0;
2030     r = guestfs_mkdir_p (g, path);
2031     if (r == -1)
2032       return -1;
2033   }
2034   {
2035     char path[] = "/a/b/c/d";
2036     int r;
2037     suppress_error = 0;
2038     r = guestfs_touch (g, path);
2039     if (r == -1)
2040       return -1;
2041   }
2042   {
2043     char path[] = "/a/b/c/e";
2044     int r;
2045     suppress_error = 0;
2046     r = guestfs_touch (g, path);
2047     if (r == -1)
2048       return -1;
2049   }
2050   {
2051     char pattern[] = "/a/b/c/*";
2052     char **r;
2053     int i;
2054     suppress_error = 0;
2055     r = guestfs_glob_expand (g, pattern);
2056     if (r == NULL)
2057       return -1;
2058     if (!r[0]) {
2059       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2060       print_strings (r);
2061       return -1;
2062     }
2063     {
2064       char expected[] = "/a/b/c/d";
2065       if (strcmp (r[0], expected) != 0) {
2066         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2067         return -1;
2068       }
2069     }
2070     if (!r[1]) {
2071       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2072       print_strings (r);
2073       return -1;
2074     }
2075     {
2076       char expected[] = "/a/b/c/e";
2077       if (strcmp (r[1], expected) != 0) {
2078         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2079         return -1;
2080       }
2081     }
2082     if (r[2] != NULL) {
2083       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2084       print_strings (r);
2085       return -1;
2086     }
2087     for (i = 0; r[i] != NULL; ++i)
2088       free (r[i]);
2089     free (r);
2090   }
2091   return 0;
2092 }
2093
2094 static int test_glob_expand_1_skip (void)
2095 {
2096   const char *str;
2097
2098   str = getenv ("TEST_ONLY");
2099   if (str)
2100     return strstr (str, "glob_expand") == NULL;
2101   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2102   if (str && strcmp (str, "1") == 0) return 1;
2103   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2104   if (str && strcmp (str, "1") == 0) return 1;
2105   return 0;
2106 }
2107
2108 static int test_glob_expand_1 (void)
2109 {
2110   if (test_glob_expand_1_skip ()) {
2111     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2112     return 0;
2113   }
2114
2115   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2116   {
2117     char device[] = "/dev/sda";
2118     int r;
2119     suppress_error = 0;
2120     r = guestfs_blockdev_setrw (g, device);
2121     if (r == -1)
2122       return -1;
2123   }
2124   {
2125     int r;
2126     suppress_error = 0;
2127     r = guestfs_umount_all (g);
2128     if (r == -1)
2129       return -1;
2130   }
2131   {
2132     int r;
2133     suppress_error = 0;
2134     r = guestfs_lvm_remove_all (g);
2135     if (r == -1)
2136       return -1;
2137   }
2138   {
2139     char device[] = "/dev/sda";
2140     char lines_0[] = ",";
2141     char *lines[] = {
2142       lines_0,
2143       NULL
2144     };
2145     int r;
2146     suppress_error = 0;
2147     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2148     if (r == -1)
2149       return -1;
2150   }
2151   {
2152     char fstype[] = "ext2";
2153     char device[] = "/dev/sda1";
2154     int r;
2155     suppress_error = 0;
2156     r = guestfs_mkfs (g, fstype, device);
2157     if (r == -1)
2158       return -1;
2159   }
2160   {
2161     char device[] = "/dev/sda1";
2162     char mountpoint[] = "/";
2163     int r;
2164     suppress_error = 0;
2165     r = guestfs_mount (g, device, mountpoint);
2166     if (r == -1)
2167       return -1;
2168   }
2169   /* TestOutputList for glob_expand (1) */
2170   {
2171     char path[] = "/a/b/c";
2172     int r;
2173     suppress_error = 0;
2174     r = guestfs_mkdir_p (g, path);
2175     if (r == -1)
2176       return -1;
2177   }
2178   {
2179     char path[] = "/a/b/c/d";
2180     int r;
2181     suppress_error = 0;
2182     r = guestfs_touch (g, path);
2183     if (r == -1)
2184       return -1;
2185   }
2186   {
2187     char path[] = "/a/b/c/e";
2188     int r;
2189     suppress_error = 0;
2190     r = guestfs_touch (g, path);
2191     if (r == -1)
2192       return -1;
2193   }
2194   {
2195     char pattern[] = "/a/*/c/*";
2196     char **r;
2197     int i;
2198     suppress_error = 0;
2199     r = guestfs_glob_expand (g, pattern);
2200     if (r == NULL)
2201       return -1;
2202     if (!r[0]) {
2203       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2204       print_strings (r);
2205       return -1;
2206     }
2207     {
2208       char expected[] = "/a/b/c/d";
2209       if (strcmp (r[0], expected) != 0) {
2210         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2211         return -1;
2212       }
2213     }
2214     if (!r[1]) {
2215       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2216       print_strings (r);
2217       return -1;
2218     }
2219     {
2220       char expected[] = "/a/b/c/e";
2221       if (strcmp (r[1], expected) != 0) {
2222         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2223         return -1;
2224       }
2225     }
2226     if (r[2] != NULL) {
2227       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2228       print_strings (r);
2229       return -1;
2230     }
2231     for (i = 0; r[i] != NULL; ++i)
2232       free (r[i]);
2233     free (r);
2234   }
2235   return 0;
2236 }
2237
2238 static int test_glob_expand_2_skip (void)
2239 {
2240   const char *str;
2241
2242   str = getenv ("TEST_ONLY");
2243   if (str)
2244     return strstr (str, "glob_expand") == NULL;
2245   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2246   if (str && strcmp (str, "1") == 0) return 1;
2247   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2248   if (str && strcmp (str, "1") == 0) return 1;
2249   return 0;
2250 }
2251
2252 static int test_glob_expand_2 (void)
2253 {
2254   if (test_glob_expand_2_skip ()) {
2255     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2256     return 0;
2257   }
2258
2259   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2260   {
2261     char device[] = "/dev/sda";
2262     int r;
2263     suppress_error = 0;
2264     r = guestfs_blockdev_setrw (g, device);
2265     if (r == -1)
2266       return -1;
2267   }
2268   {
2269     int r;
2270     suppress_error = 0;
2271     r = guestfs_umount_all (g);
2272     if (r == -1)
2273       return -1;
2274   }
2275   {
2276     int r;
2277     suppress_error = 0;
2278     r = guestfs_lvm_remove_all (g);
2279     if (r == -1)
2280       return -1;
2281   }
2282   {
2283     char device[] = "/dev/sda";
2284     char lines_0[] = ",";
2285     char *lines[] = {
2286       lines_0,
2287       NULL
2288     };
2289     int r;
2290     suppress_error = 0;
2291     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2292     if (r == -1)
2293       return -1;
2294   }
2295   {
2296     char fstype[] = "ext2";
2297     char device[] = "/dev/sda1";
2298     int r;
2299     suppress_error = 0;
2300     r = guestfs_mkfs (g, fstype, device);
2301     if (r == -1)
2302       return -1;
2303   }
2304   {
2305     char device[] = "/dev/sda1";
2306     char mountpoint[] = "/";
2307     int r;
2308     suppress_error = 0;
2309     r = guestfs_mount (g, device, mountpoint);
2310     if (r == -1)
2311       return -1;
2312   }
2313   /* TestOutputList for glob_expand (2) */
2314   {
2315     char path[] = "/a/b/c";
2316     int r;
2317     suppress_error = 0;
2318     r = guestfs_mkdir_p (g, path);
2319     if (r == -1)
2320       return -1;
2321   }
2322   {
2323     char path[] = "/a/b/c/d";
2324     int r;
2325     suppress_error = 0;
2326     r = guestfs_touch (g, path);
2327     if (r == -1)
2328       return -1;
2329   }
2330   {
2331     char path[] = "/a/b/c/e";
2332     int r;
2333     suppress_error = 0;
2334     r = guestfs_touch (g, path);
2335     if (r == -1)
2336       return -1;
2337   }
2338   {
2339     char pattern[] = "/a/*/x/*";
2340     char **r;
2341     int i;
2342     suppress_error = 0;
2343     r = guestfs_glob_expand (g, pattern);
2344     if (r == NULL)
2345       return -1;
2346     if (r[0] != NULL) {
2347       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2348       print_strings (r);
2349       return -1;
2350     }
2351     for (i = 0; r[i] != NULL; ++i)
2352       free (r[i]);
2353     free (r);
2354   }
2355   return 0;
2356 }
2357
2358 static int test_ntfs_3g_probe_0_skip (void)
2359 {
2360   const char *str;
2361
2362   str = getenv ("TEST_ONLY");
2363   if (str)
2364     return strstr (str, "ntfs_3g_probe") == NULL;
2365   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2366   if (str && strcmp (str, "1") == 0) return 1;
2367   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2368   if (str && strcmp (str, "1") == 0) return 1;
2369   return 0;
2370 }
2371
2372 static int test_ntfs_3g_probe_0 (void)
2373 {
2374   if (test_ntfs_3g_probe_0_skip ()) {
2375     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2376     return 0;
2377   }
2378
2379   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2380   {
2381     char device[] = "/dev/sda";
2382     int r;
2383     suppress_error = 0;
2384     r = guestfs_blockdev_setrw (g, device);
2385     if (r == -1)
2386       return -1;
2387   }
2388   {
2389     int r;
2390     suppress_error = 0;
2391     r = guestfs_umount_all (g);
2392     if (r == -1)
2393       return -1;
2394   }
2395   {
2396     int r;
2397     suppress_error = 0;
2398     r = guestfs_lvm_remove_all (g);
2399     if (r == -1)
2400       return -1;
2401   }
2402   /* TestOutputInt for ntfs_3g_probe (0) */
2403   {
2404     char device[] = "/dev/sda";
2405     char lines_0[] = ",";
2406     char *lines[] = {
2407       lines_0,
2408       NULL
2409     };
2410     int r;
2411     suppress_error = 0;
2412     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2413     if (r == -1)
2414       return -1;
2415   }
2416   {
2417     char fstype[] = "ntfs";
2418     char device[] = "/dev/sda1";
2419     int r;
2420     suppress_error = 0;
2421     r = guestfs_mkfs (g, fstype, device);
2422     if (r == -1)
2423       return -1;
2424   }
2425   {
2426     char device[] = "/dev/sda1";
2427     int r;
2428     suppress_error = 0;
2429     r = guestfs_ntfs_3g_probe (g, 1, device);
2430     if (r == -1)
2431       return -1;
2432     if (r != 0) {
2433       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
2434       return -1;
2435     }
2436   }
2437   return 0;
2438 }
2439
2440 static int test_ntfs_3g_probe_1_skip (void)
2441 {
2442   const char *str;
2443
2444   str = getenv ("TEST_ONLY");
2445   if (str)
2446     return strstr (str, "ntfs_3g_probe") == NULL;
2447   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2448   if (str && strcmp (str, "1") == 0) return 1;
2449   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2450   if (str && strcmp (str, "1") == 0) return 1;
2451   return 0;
2452 }
2453
2454 static int test_ntfs_3g_probe_1 (void)
2455 {
2456   if (test_ntfs_3g_probe_1_skip ()) {
2457     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2458     return 0;
2459   }
2460
2461   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2462   {
2463     char device[] = "/dev/sda";
2464     int r;
2465     suppress_error = 0;
2466     r = guestfs_blockdev_setrw (g, device);
2467     if (r == -1)
2468       return -1;
2469   }
2470   {
2471     int r;
2472     suppress_error = 0;
2473     r = guestfs_umount_all (g);
2474     if (r == -1)
2475       return -1;
2476   }
2477   {
2478     int r;
2479     suppress_error = 0;
2480     r = guestfs_lvm_remove_all (g);
2481     if (r == -1)
2482       return -1;
2483   }
2484   /* TestOutputInt for ntfs_3g_probe (1) */
2485   {
2486     char device[] = "/dev/sda";
2487     char lines_0[] = ",";
2488     char *lines[] = {
2489       lines_0,
2490       NULL
2491     };
2492     int r;
2493     suppress_error = 0;
2494     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2495     if (r == -1)
2496       return -1;
2497   }
2498   {
2499     char fstype[] = "ext2";
2500     char device[] = "/dev/sda1";
2501     int r;
2502     suppress_error = 0;
2503     r = guestfs_mkfs (g, fstype, device);
2504     if (r == -1)
2505       return -1;
2506   }
2507   {
2508     char device[] = "/dev/sda1";
2509     int r;
2510     suppress_error = 0;
2511     r = guestfs_ntfs_3g_probe (g, 1, device);
2512     if (r == -1)
2513       return -1;
2514     if (r != 12) {
2515       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
2516       return -1;
2517     }
2518   }
2519   return 0;
2520 }
2521
2522 static int test_sleep_0_skip (void)
2523 {
2524   const char *str;
2525
2526   str = getenv ("TEST_ONLY");
2527   if (str)
2528     return strstr (str, "sleep") == NULL;
2529   str = getenv ("SKIP_TEST_SLEEP_0");
2530   if (str && strcmp (str, "1") == 0) return 1;
2531   str = getenv ("SKIP_TEST_SLEEP");
2532   if (str && strcmp (str, "1") == 0) return 1;
2533   return 0;
2534 }
2535
2536 static int test_sleep_0 (void)
2537 {
2538   if (test_sleep_0_skip ()) {
2539     printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
2540     return 0;
2541   }
2542
2543   /* InitNone|InitEmpty for test_sleep_0 */
2544   {
2545     char device[] = "/dev/sda";
2546     int r;
2547     suppress_error = 0;
2548     r = guestfs_blockdev_setrw (g, device);
2549     if (r == -1)
2550       return -1;
2551   }
2552   {
2553     int r;
2554     suppress_error = 0;
2555     r = guestfs_umount_all (g);
2556     if (r == -1)
2557       return -1;
2558   }
2559   {
2560     int r;
2561     suppress_error = 0;
2562     r = guestfs_lvm_remove_all (g);
2563     if (r == -1)
2564       return -1;
2565   }
2566   /* TestRun for sleep (0) */
2567   {
2568     int r;
2569     suppress_error = 0;
2570     r = guestfs_sleep (g, 1);
2571     if (r == -1)
2572       return -1;
2573   }
2574   return 0;
2575 }
2576
2577 static int test_find_0_skip (void)
2578 {
2579   const char *str;
2580
2581   str = getenv ("TEST_ONLY");
2582   if (str)
2583     return strstr (str, "find") == NULL;
2584   str = getenv ("SKIP_TEST_FIND_0");
2585   if (str && strcmp (str, "1") == 0) return 1;
2586   str = getenv ("SKIP_TEST_FIND");
2587   if (str && strcmp (str, "1") == 0) return 1;
2588   return 0;
2589 }
2590
2591 static int test_find_0 (void)
2592 {
2593   if (test_find_0_skip ()) {
2594     printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
2595     return 0;
2596   }
2597
2598   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
2599   {
2600     char device[] = "/dev/sda";
2601     int r;
2602     suppress_error = 0;
2603     r = guestfs_blockdev_setrw (g, device);
2604     if (r == -1)
2605       return -1;
2606   }
2607   {
2608     int r;
2609     suppress_error = 0;
2610     r = guestfs_umount_all (g);
2611     if (r == -1)
2612       return -1;
2613   }
2614   {
2615     int r;
2616     suppress_error = 0;
2617     r = guestfs_lvm_remove_all (g);
2618     if (r == -1)
2619       return -1;
2620   }
2621   {
2622     char device[] = "/dev/sda";
2623     char lines_0[] = ",";
2624     char *lines[] = {
2625       lines_0,
2626       NULL
2627     };
2628     int r;
2629     suppress_error = 0;
2630     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2631     if (r == -1)
2632       return -1;
2633   }
2634   {
2635     char fstype[] = "ext2";
2636     char device[] = "/dev/sda1";
2637     int r;
2638     suppress_error = 0;
2639     r = guestfs_mkfs (g, fstype, device);
2640     if (r == -1)
2641       return -1;
2642   }
2643   {
2644     char device[] = "/dev/sda1";
2645     char mountpoint[] = "/";
2646     int r;
2647     suppress_error = 0;
2648     r = guestfs_mount (g, device, mountpoint);
2649     if (r == -1)
2650       return -1;
2651   }
2652   /* TestOutputList for find (0) */
2653   {
2654     char directory[] = "/";
2655     char **r;
2656     int i;
2657     suppress_error = 0;
2658     r = guestfs_find (g, directory);
2659     if (r == NULL)
2660       return -1;
2661     if (!r[0]) {
2662       fprintf (stderr, "test_find_0: short list returned from command\n");
2663       print_strings (r);
2664       return -1;
2665     }
2666     {
2667       char expected[] = "lost+found";
2668       if (strcmp (r[0], expected) != 0) {
2669         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2670         return -1;
2671       }
2672     }
2673     if (r[1] != NULL) {
2674       fprintf (stderr, "test_find_0: extra elements returned from command\n");
2675       print_strings (r);
2676       return -1;
2677     }
2678     for (i = 0; r[i] != NULL; ++i)
2679       free (r[i]);
2680     free (r);
2681   }
2682   return 0;
2683 }
2684
2685 static int test_find_1_skip (void)
2686 {
2687   const char *str;
2688
2689   str = getenv ("TEST_ONLY");
2690   if (str)
2691     return strstr (str, "find") == NULL;
2692   str = getenv ("SKIP_TEST_FIND_1");
2693   if (str && strcmp (str, "1") == 0) return 1;
2694   str = getenv ("SKIP_TEST_FIND");
2695   if (str && strcmp (str, "1") == 0) return 1;
2696   return 0;
2697 }
2698
2699 static int test_find_1 (void)
2700 {
2701   if (test_find_1_skip ()) {
2702     printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
2703     return 0;
2704   }
2705
2706   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
2707   {
2708     char device[] = "/dev/sda";
2709     int r;
2710     suppress_error = 0;
2711     r = guestfs_blockdev_setrw (g, device);
2712     if (r == -1)
2713       return -1;
2714   }
2715   {
2716     int r;
2717     suppress_error = 0;
2718     r = guestfs_umount_all (g);
2719     if (r == -1)
2720       return -1;
2721   }
2722   {
2723     int r;
2724     suppress_error = 0;
2725     r = guestfs_lvm_remove_all (g);
2726     if (r == -1)
2727       return -1;
2728   }
2729   {
2730     char device[] = "/dev/sda";
2731     char lines_0[] = ",";
2732     char *lines[] = {
2733       lines_0,
2734       NULL
2735     };
2736     int r;
2737     suppress_error = 0;
2738     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2739     if (r == -1)
2740       return -1;
2741   }
2742   {
2743     char fstype[] = "ext2";
2744     char device[] = "/dev/sda1";
2745     int r;
2746     suppress_error = 0;
2747     r = guestfs_mkfs (g, fstype, device);
2748     if (r == -1)
2749       return -1;
2750   }
2751   {
2752     char device[] = "/dev/sda1";
2753     char mountpoint[] = "/";
2754     int r;
2755     suppress_error = 0;
2756     r = guestfs_mount (g, device, mountpoint);
2757     if (r == -1)
2758       return -1;
2759   }
2760   /* TestOutputList for find (1) */
2761   {
2762     char path[] = "/a";
2763     int r;
2764     suppress_error = 0;
2765     r = guestfs_touch (g, path);
2766     if (r == -1)
2767       return -1;
2768   }
2769   {
2770     char path[] = "/b";
2771     int r;
2772     suppress_error = 0;
2773     r = guestfs_mkdir (g, path);
2774     if (r == -1)
2775       return -1;
2776   }
2777   {
2778     char path[] = "/b/c";
2779     int r;
2780     suppress_error = 0;
2781     r = guestfs_touch (g, path);
2782     if (r == -1)
2783       return -1;
2784   }
2785   {
2786     char directory[] = "/";
2787     char **r;
2788     int i;
2789     suppress_error = 0;
2790     r = guestfs_find (g, directory);
2791     if (r == NULL)
2792       return -1;
2793     if (!r[0]) {
2794       fprintf (stderr, "test_find_1: short list returned from command\n");
2795       print_strings (r);
2796       return -1;
2797     }
2798     {
2799       char expected[] = "a";
2800       if (strcmp (r[0], expected) != 0) {
2801         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2802         return -1;
2803       }
2804     }
2805     if (!r[1]) {
2806       fprintf (stderr, "test_find_1: short list returned from command\n");
2807       print_strings (r);
2808       return -1;
2809     }
2810     {
2811       char expected[] = "b";
2812       if (strcmp (r[1], expected) != 0) {
2813         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2814         return -1;
2815       }
2816     }
2817     if (!r[2]) {
2818       fprintf (stderr, "test_find_1: short list returned from command\n");
2819       print_strings (r);
2820       return -1;
2821     }
2822     {
2823       char expected[] = "b/c";
2824       if (strcmp (r[2], expected) != 0) {
2825         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2826         return -1;
2827       }
2828     }
2829     if (!r[3]) {
2830       fprintf (stderr, "test_find_1: short list returned from command\n");
2831       print_strings (r);
2832       return -1;
2833     }
2834     {
2835       char expected[] = "lost+found";
2836       if (strcmp (r[3], expected) != 0) {
2837         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2838         return -1;
2839       }
2840     }
2841     if (r[4] != NULL) {
2842       fprintf (stderr, "test_find_1: extra elements returned from command\n");
2843       print_strings (r);
2844       return -1;
2845     }
2846     for (i = 0; r[i] != NULL; ++i)
2847       free (r[i]);
2848     free (r);
2849   }
2850   return 0;
2851 }
2852
2853 static int test_find_2_skip (void)
2854 {
2855   const char *str;
2856
2857   str = getenv ("TEST_ONLY");
2858   if (str)
2859     return strstr (str, "find") == NULL;
2860   str = getenv ("SKIP_TEST_FIND_2");
2861   if (str && strcmp (str, "1") == 0) return 1;
2862   str = getenv ("SKIP_TEST_FIND");
2863   if (str && strcmp (str, "1") == 0) return 1;
2864   return 0;
2865 }
2866
2867 static int test_find_2 (void)
2868 {
2869   if (test_find_2_skip ()) {
2870     printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
2871     return 0;
2872   }
2873
2874   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
2875   {
2876     char device[] = "/dev/sda";
2877     int r;
2878     suppress_error = 0;
2879     r = guestfs_blockdev_setrw (g, device);
2880     if (r == -1)
2881       return -1;
2882   }
2883   {
2884     int r;
2885     suppress_error = 0;
2886     r = guestfs_umount_all (g);
2887     if (r == -1)
2888       return -1;
2889   }
2890   {
2891     int r;
2892     suppress_error = 0;
2893     r = guestfs_lvm_remove_all (g);
2894     if (r == -1)
2895       return -1;
2896   }
2897   {
2898     char device[] = "/dev/sda";
2899     char lines_0[] = ",";
2900     char *lines[] = {
2901       lines_0,
2902       NULL
2903     };
2904     int r;
2905     suppress_error = 0;
2906     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2907     if (r == -1)
2908       return -1;
2909   }
2910   {
2911     char fstype[] = "ext2";
2912     char device[] = "/dev/sda1";
2913     int r;
2914     suppress_error = 0;
2915     r = guestfs_mkfs (g, fstype, device);
2916     if (r == -1)
2917       return -1;
2918   }
2919   {
2920     char device[] = "/dev/sda1";
2921     char mountpoint[] = "/";
2922     int r;
2923     suppress_error = 0;
2924     r = guestfs_mount (g, device, mountpoint);
2925     if (r == -1)
2926       return -1;
2927   }
2928   /* TestOutputList for find (2) */
2929   {
2930     char path[] = "/a/b/c";
2931     int r;
2932     suppress_error = 0;
2933     r = guestfs_mkdir_p (g, path);
2934     if (r == -1)
2935       return -1;
2936   }
2937   {
2938     char path[] = "/a/b/c/d";
2939     int r;
2940     suppress_error = 0;
2941     r = guestfs_touch (g, path);
2942     if (r == -1)
2943       return -1;
2944   }
2945   {
2946     char directory[] = "/a/b/";
2947     char **r;
2948     int i;
2949     suppress_error = 0;
2950     r = guestfs_find (g, directory);
2951     if (r == NULL)
2952       return -1;
2953     if (!r[0]) {
2954       fprintf (stderr, "test_find_2: short list returned from command\n");
2955       print_strings (r);
2956       return -1;
2957     }
2958     {
2959       char expected[] = "c";
2960       if (strcmp (r[0], expected) != 0) {
2961         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2962         return -1;
2963       }
2964     }
2965     if (!r[1]) {
2966       fprintf (stderr, "test_find_2: short list returned from command\n");
2967       print_strings (r);
2968       return -1;
2969     }
2970     {
2971       char expected[] = "c/d";
2972       if (strcmp (r[1], expected) != 0) {
2973         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2974         return -1;
2975       }
2976     }
2977     if (r[2] != NULL) {
2978       fprintf (stderr, "test_find_2: extra elements returned from command\n");
2979       print_strings (r);
2980       return -1;
2981     }
2982     for (i = 0; r[i] != NULL; ++i)
2983       free (r[i]);
2984     free (r);
2985   }
2986   return 0;
2987 }
2988
2989 static int test_lvresize_0_skip (void)
2990 {
2991   const char *str;
2992
2993   str = getenv ("TEST_ONLY");
2994   if (str)
2995     return strstr (str, "lvresize") == NULL;
2996   str = getenv ("SKIP_TEST_LVRESIZE_0");
2997   if (str && strcmp (str, "1") == 0) return 1;
2998   str = getenv ("SKIP_TEST_LVRESIZE");
2999   if (str && strcmp (str, "1") == 0) return 1;
3000   return 0;
3001 }
3002
3003 static int test_lvresize_0 (void)
3004 {
3005   if (test_lvresize_0_skip ()) {
3006     printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3007     return 0;
3008   }
3009
3010   /* InitNone|InitEmpty for test_lvresize_0 */
3011   {
3012     char device[] = "/dev/sda";
3013     int r;
3014     suppress_error = 0;
3015     r = guestfs_blockdev_setrw (g, device);
3016     if (r == -1)
3017       return -1;
3018   }
3019   {
3020     int r;
3021     suppress_error = 0;
3022     r = guestfs_umount_all (g);
3023     if (r == -1)
3024       return -1;
3025   }
3026   {
3027     int r;
3028     suppress_error = 0;
3029     r = guestfs_lvm_remove_all (g);
3030     if (r == -1)
3031       return -1;
3032   }
3033   /* TestOutput for lvresize (0) */
3034   char expected[] = "test content";
3035   {
3036     char device[] = "/dev/sda";
3037     char lines_0[] = ",";
3038     char *lines[] = {
3039       lines_0,
3040       NULL
3041     };
3042     int r;
3043     suppress_error = 0;
3044     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3045     if (r == -1)
3046       return -1;
3047   }
3048   {
3049     char device[] = "/dev/sda1";
3050     int r;
3051     suppress_error = 0;
3052     r = guestfs_pvcreate (g, device);
3053     if (r == -1)
3054       return -1;
3055   }
3056   {
3057     char volgroup[] = "VG";
3058     char physvols_0[] = "/dev/sda1";
3059     char *physvols[] = {
3060       physvols_0,
3061       NULL
3062     };
3063     int r;
3064     suppress_error = 0;
3065     r = guestfs_vgcreate (g, volgroup, physvols);
3066     if (r == -1)
3067       return -1;
3068   }
3069   {
3070     char logvol[] = "LV";
3071     char volgroup[] = "VG";
3072     int r;
3073     suppress_error = 0;
3074     r = guestfs_lvcreate (g, logvol, volgroup, 10);
3075     if (r == -1)
3076       return -1;
3077   }
3078   {
3079     char fstype[] = "ext2";
3080     char device[] = "/dev/VG/LV";
3081     int r;
3082     suppress_error = 0;
3083     r = guestfs_mkfs (g, fstype, device);
3084     if (r == -1)
3085       return -1;
3086   }
3087   {
3088     char device[] = "/dev/VG/LV";
3089     char mountpoint[] = "/";
3090     int r;
3091     suppress_error = 0;
3092     r = guestfs_mount (g, device, mountpoint);
3093     if (r == -1)
3094       return -1;
3095   }
3096   {
3097     char path[] = "/new";
3098     char content[] = "test content";
3099     int r;
3100     suppress_error = 0;
3101     r = guestfs_write_file (g, path, content, 0);
3102     if (r == -1)
3103       return -1;
3104   }
3105   {
3106     char pathordevice[] = "/";
3107     int r;
3108     suppress_error = 0;
3109     r = guestfs_umount (g, pathordevice);
3110     if (r == -1)
3111       return -1;
3112   }
3113   {
3114     char device[] = "/dev/VG/LV";
3115     int r;
3116     suppress_error = 0;
3117     r = guestfs_lvresize (g, device, 20);
3118     if (r == -1)
3119       return -1;
3120   }
3121   {
3122     char device[] = "/dev/VG/LV";
3123     int r;
3124     suppress_error = 0;
3125     r = guestfs_e2fsck_f (g, device);
3126     if (r == -1)
3127       return -1;
3128   }
3129   {
3130     char device[] = "/dev/VG/LV";
3131     int r;
3132     suppress_error = 0;
3133     r = guestfs_resize2fs (g, device);
3134     if (r == -1)
3135       return -1;
3136   }
3137   {
3138     char device[] = "/dev/VG/LV";
3139     char mountpoint[] = "/";
3140     int r;
3141     suppress_error = 0;
3142     r = guestfs_mount (g, device, mountpoint);
3143     if (r == -1)
3144       return -1;
3145   }
3146   {
3147     char path[] = "/new";
3148     char *r;
3149     suppress_error = 0;
3150     r = guestfs_cat (g, path);
3151     if (r == NULL)
3152       return -1;
3153     if (strcmp (r, expected) != 0) {
3154       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3155       return -1;
3156     }
3157     free (r);
3158   }
3159   return 0;
3160 }
3161
3162 static int test_zerofree_0_skip (void)
3163 {
3164   const char *str;
3165
3166   str = getenv ("TEST_ONLY");
3167   if (str)
3168     return strstr (str, "zerofree") == NULL;
3169   str = getenv ("SKIP_TEST_ZEROFREE_0");
3170   if (str && strcmp (str, "1") == 0) return 1;
3171   str = getenv ("SKIP_TEST_ZEROFREE");
3172   if (str && strcmp (str, "1") == 0) return 1;
3173   return 0;
3174 }
3175
3176 static int test_zerofree_0 (void)
3177 {
3178   if (test_zerofree_0_skip ()) {
3179     printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3180     return 0;
3181   }
3182
3183   /* InitNone|InitEmpty for test_zerofree_0 */
3184   {
3185     char device[] = "/dev/sda";
3186     int r;
3187     suppress_error = 0;
3188     r = guestfs_blockdev_setrw (g, device);
3189     if (r == -1)
3190       return -1;
3191   }
3192   {
3193     int r;
3194     suppress_error = 0;
3195     r = guestfs_umount_all (g);
3196     if (r == -1)
3197       return -1;
3198   }
3199   {
3200     int r;
3201     suppress_error = 0;
3202     r = guestfs_lvm_remove_all (g);
3203     if (r == -1)
3204       return -1;
3205   }
3206   /* TestOutput for zerofree (0) */
3207   char expected[] = "test file";
3208   {
3209     char device[] = "/dev/sda";
3210     char lines_0[] = ",";
3211     char *lines[] = {
3212       lines_0,
3213       NULL
3214     };
3215     int r;
3216     suppress_error = 0;
3217     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3218     if (r == -1)
3219       return -1;
3220   }
3221   {
3222     char fstype[] = "ext3";
3223     char device[] = "/dev/sda1";
3224     int r;
3225     suppress_error = 0;
3226     r = guestfs_mkfs (g, fstype, device);
3227     if (r == -1)
3228       return -1;
3229   }
3230   {
3231     char device[] = "/dev/sda1";
3232     char mountpoint[] = "/";
3233     int r;
3234     suppress_error = 0;
3235     r = guestfs_mount (g, device, mountpoint);
3236     if (r == -1)
3237       return -1;
3238   }
3239   {
3240     char path[] = "/new";
3241     char content[] = "test file";
3242     int r;
3243     suppress_error = 0;
3244     r = guestfs_write_file (g, path, content, 0);
3245     if (r == -1)
3246       return -1;
3247   }
3248   {
3249     char pathordevice[] = "/dev/sda1";
3250     int r;
3251     suppress_error = 0;
3252     r = guestfs_umount (g, pathordevice);
3253     if (r == -1)
3254       return -1;
3255   }
3256   {
3257     char device[] = "/dev/sda1";
3258     int r;
3259     suppress_error = 0;
3260     r = guestfs_zerofree (g, device);
3261     if (r == -1)
3262       return -1;
3263   }
3264   {
3265     char device[] = "/dev/sda1";
3266     char mountpoint[] = "/";
3267     int r;
3268     suppress_error = 0;
3269     r = guestfs_mount (g, device, mountpoint);
3270     if (r == -1)
3271       return -1;
3272   }
3273   {
3274     char path[] = "/new";
3275     char *r;
3276     suppress_error = 0;
3277     r = guestfs_cat (g, path);
3278     if (r == NULL)
3279       return -1;
3280     if (strcmp (r, expected) != 0) {
3281       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3282       return -1;
3283     }
3284     free (r);
3285   }
3286   return 0;
3287 }
3288
3289 static int test_hexdump_0_skip (void)
3290 {
3291   const char *str;
3292
3293   str = getenv ("TEST_ONLY");
3294   if (str)
3295     return strstr (str, "hexdump") == NULL;
3296   str = getenv ("SKIP_TEST_HEXDUMP_0");
3297   if (str && strcmp (str, "1") == 0) return 1;
3298   str = getenv ("SKIP_TEST_HEXDUMP");
3299   if (str && strcmp (str, "1") == 0) return 1;
3300   return 0;
3301 }
3302
3303 static int test_hexdump_0 (void)
3304 {
3305   if (test_hexdump_0_skip ()) {
3306     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3307     return 0;
3308   }
3309
3310   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3311   {
3312     char device[] = "/dev/sda";
3313     int r;
3314     suppress_error = 0;
3315     r = guestfs_blockdev_setrw (g, device);
3316     if (r == -1)
3317       return -1;
3318   }
3319   {
3320     int r;
3321     suppress_error = 0;
3322     r = guestfs_umount_all (g);
3323     if (r == -1)
3324       return -1;
3325   }
3326   {
3327     int r;
3328     suppress_error = 0;
3329     r = guestfs_lvm_remove_all (g);
3330     if (r == -1)
3331       return -1;
3332   }
3333   {
3334     char device[] = "/dev/sda";
3335     char lines_0[] = ",";
3336     char *lines[] = {
3337       lines_0,
3338       NULL
3339     };
3340     int r;
3341     suppress_error = 0;
3342     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3343     if (r == -1)
3344       return -1;
3345   }
3346   {
3347     char fstype[] = "ext2";
3348     char device[] = "/dev/sda1";
3349     int r;
3350     suppress_error = 0;
3351     r = guestfs_mkfs (g, fstype, device);
3352     if (r == -1)
3353       return -1;
3354   }
3355   {
3356     char device[] = "/dev/sda1";
3357     char mountpoint[] = "/";
3358     int r;
3359     suppress_error = 0;
3360     r = guestfs_mount (g, device, mountpoint);
3361     if (r == -1)
3362       return -1;
3363   }
3364   /* TestOutput for hexdump (0) */
3365   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
3366   {
3367     char path[] = "/new";
3368     char content[] = "hello\nworld\n";
3369     int r;
3370     suppress_error = 0;
3371     r = guestfs_write_file (g, path, content, 12);
3372     if (r == -1)
3373       return -1;
3374   }
3375   {
3376     char path[] = "/new";
3377     char *r;
3378     suppress_error = 0;
3379     r = guestfs_hexdump (g, path);
3380     if (r == NULL)
3381       return -1;
3382     if (strcmp (r, expected) != 0) {
3383       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3384       return -1;
3385     }
3386     free (r);
3387   }
3388   return 0;
3389 }
3390
3391 static int test_hexdump_1_skip (void)
3392 {
3393   const char *str;
3394
3395   str = getenv ("TEST_ONLY");
3396   if (str)
3397     return strstr (str, "hexdump") == NULL;
3398   str = getenv ("SKIP_TEST_HEXDUMP_1");
3399   if (str && strcmp (str, "1") == 0) return 1;
3400   str = getenv ("SKIP_TEST_HEXDUMP");
3401   if (str && strcmp (str, "1") == 0) return 1;
3402   return 0;
3403 }
3404
3405 static int test_hexdump_1 (void)
3406 {
3407   if (test_hexdump_1_skip ()) {
3408     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3409     return 0;
3410   }
3411
3412   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3413   {
3414     char device[] = "/dev/sda";
3415     int r;
3416     suppress_error = 0;
3417     r = guestfs_blockdev_setrw (g, device);
3418     if (r == -1)
3419       return -1;
3420   }
3421   {
3422     int r;
3423     suppress_error = 0;
3424     r = guestfs_umount_all (g);
3425     if (r == -1)
3426       return -1;
3427   }
3428   {
3429     int r;
3430     suppress_error = 0;
3431     r = guestfs_lvm_remove_all (g);
3432     if (r == -1)
3433       return -1;
3434   }
3435   {
3436     char device[] = "/dev/sda";
3437     char lines_0[] = ",";
3438     char *lines[] = {
3439       lines_0,
3440       NULL
3441     };
3442     int r;
3443     suppress_error = 0;
3444     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3445     if (r == -1)
3446       return -1;
3447   }
3448   {
3449     char fstype[] = "ext2";
3450     char device[] = "/dev/sda1";
3451     int r;
3452     suppress_error = 0;
3453     r = guestfs_mkfs (g, fstype, device);
3454     if (r == -1)
3455       return -1;
3456   }
3457   {
3458     char device[] = "/dev/sda1";
3459     char mountpoint[] = "/";
3460     int r;
3461     suppress_error = 0;
3462     r = guestfs_mount (g, device, mountpoint);
3463     if (r == -1)
3464       return -1;
3465   }
3466   /* TestRun for hexdump (1) */
3467   {
3468     char options[] = "ro";
3469     char vfstype[] = "squashfs";
3470     char device[] = "/dev/sdd";
3471     char mountpoint[] = "/";
3472     int r;
3473     suppress_error = 0;
3474     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3475     if (r == -1)
3476       return -1;
3477   }
3478   {
3479     char path[] = "/100krandom";
3480     char *r;
3481     suppress_error = 0;
3482     r = guestfs_hexdump (g, path);
3483     if (r == NULL)
3484       return -1;
3485     free (r);
3486   }
3487   return 0;
3488 }
3489
3490 static int test_strings_e_0_skip (void)
3491 {
3492   const char *str;
3493
3494   str = getenv ("TEST_ONLY");
3495   if (str)
3496     return strstr (str, "strings_e") == NULL;
3497   str = getenv ("SKIP_TEST_STRINGS_E_0");
3498   if (str && strcmp (str, "1") == 0) return 1;
3499   str = getenv ("SKIP_TEST_STRINGS_E");
3500   if (str && strcmp (str, "1") == 0) return 1;
3501   return 0;
3502 }
3503
3504 static int test_strings_e_0 (void)
3505 {
3506   if (test_strings_e_0_skip ()) {
3507     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3508     return 0;
3509   }
3510
3511   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3512   {
3513     char device[] = "/dev/sda";
3514     int r;
3515     suppress_error = 0;
3516     r = guestfs_blockdev_setrw (g, device);
3517     if (r == -1)
3518       return -1;
3519   }
3520   {
3521     int r;
3522     suppress_error = 0;
3523     r = guestfs_umount_all (g);
3524     if (r == -1)
3525       return -1;
3526   }
3527   {
3528     int r;
3529     suppress_error = 0;
3530     r = guestfs_lvm_remove_all (g);
3531     if (r == -1)
3532       return -1;
3533   }
3534   {
3535     char device[] = "/dev/sda";
3536     char lines_0[] = ",";
3537     char *lines[] = {
3538       lines_0,
3539       NULL
3540     };
3541     int r;
3542     suppress_error = 0;
3543     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3544     if (r == -1)
3545       return -1;
3546   }
3547   {
3548     char fstype[] = "ext2";
3549     char device[] = "/dev/sda1";
3550     int r;
3551     suppress_error = 0;
3552     r = guestfs_mkfs (g, fstype, device);
3553     if (r == -1)
3554       return -1;
3555   }
3556   {
3557     char device[] = "/dev/sda1";
3558     char mountpoint[] = "/";
3559     int r;
3560     suppress_error = 0;
3561     r = guestfs_mount (g, device, mountpoint);
3562     if (r == -1)
3563       return -1;
3564   }
3565   /* TestOutputList for strings_e (0) */
3566   {
3567     char path[] = "/new";
3568     char content[] = "hello\nworld\n";
3569     int r;
3570     suppress_error = 0;
3571     r = guestfs_write_file (g, path, content, 0);
3572     if (r == -1)
3573       return -1;
3574   }
3575   {
3576     char encoding[] = "b";
3577     char path[] = "/new";
3578     char **r;
3579     int i;
3580     suppress_error = 0;
3581     r = guestfs_strings_e (g, encoding, path);
3582     if (r == NULL)
3583       return -1;
3584     if (r[0] != NULL) {
3585       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
3586       print_strings (r);
3587       return -1;
3588     }
3589     for (i = 0; r[i] != NULL; ++i)
3590       free (r[i]);
3591     free (r);
3592   }
3593   return 0;
3594 }
3595
3596 static int test_strings_e_1_skip (void)
3597 {
3598   const char *str;
3599
3600   str = getenv ("TEST_ONLY");
3601   if (str)
3602     return strstr (str, "strings_e") == NULL;
3603   str = getenv ("SKIP_TEST_STRINGS_E_1");
3604   if (str && strcmp (str, "1") == 0) return 1;
3605   str = getenv ("SKIP_TEST_STRINGS_E");
3606   if (str && strcmp (str, "1") == 0) return 1;
3607   return 0;
3608 }
3609
3610 static int test_strings_e_1 (void)
3611 {
3612   if (test_strings_e_1_skip ()) {
3613     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
3614     return 0;
3615   }
3616
3617   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
3618   return 0;
3619 }
3620
3621 static int test_strings_0_skip (void)
3622 {
3623   const char *str;
3624
3625   str = getenv ("TEST_ONLY");
3626   if (str)
3627     return strstr (str, "strings") == NULL;
3628   str = getenv ("SKIP_TEST_STRINGS_0");
3629   if (str && strcmp (str, "1") == 0) return 1;
3630   str = getenv ("SKIP_TEST_STRINGS");
3631   if (str && strcmp (str, "1") == 0) return 1;
3632   return 0;
3633 }
3634
3635 static int test_strings_0 (void)
3636 {
3637   if (test_strings_0_skip ()) {
3638     printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
3639     return 0;
3640   }
3641
3642   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
3643   {
3644     char device[] = "/dev/sda";
3645     int r;
3646     suppress_error = 0;
3647     r = guestfs_blockdev_setrw (g, device);
3648     if (r == -1)
3649       return -1;
3650   }
3651   {
3652     int r;
3653     suppress_error = 0;
3654     r = guestfs_umount_all (g);
3655     if (r == -1)
3656       return -1;
3657   }
3658   {
3659     int r;
3660     suppress_error = 0;
3661     r = guestfs_lvm_remove_all (g);
3662     if (r == -1)
3663       return -1;
3664   }
3665   {
3666     char device[] = "/dev/sda";
3667     char lines_0[] = ",";
3668     char *lines[] = {
3669       lines_0,
3670       NULL
3671     };
3672     int r;
3673     suppress_error = 0;
3674     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3675     if (r == -1)
3676       return -1;
3677   }
3678   {
3679     char fstype[] = "ext2";
3680     char device[] = "/dev/sda1";
3681     int r;
3682     suppress_error = 0;
3683     r = guestfs_mkfs (g, fstype, device);
3684     if (r == -1)
3685       return -1;
3686   }
3687   {
3688     char device[] = "/dev/sda1";
3689     char mountpoint[] = "/";
3690     int r;
3691     suppress_error = 0;
3692     r = guestfs_mount (g, device, mountpoint);
3693     if (r == -1)
3694       return -1;
3695   }
3696   /* TestOutputList for strings (0) */
3697   {
3698     char path[] = "/new";
3699     char content[] = "hello\nworld\n";
3700     int r;
3701     suppress_error = 0;
3702     r = guestfs_write_file (g, path, content, 0);
3703     if (r == -1)
3704       return -1;
3705   }
3706   {
3707     char path[] = "/new";
3708     char **r;
3709     int i;
3710     suppress_error = 0;
3711     r = guestfs_strings (g, path);
3712     if (r == NULL)
3713       return -1;
3714     if (!r[0]) {
3715       fprintf (stderr, "test_strings_0: short list returned from command\n");
3716       print_strings (r);
3717       return -1;
3718     }
3719     {
3720       char expected[] = "hello";
3721       if (strcmp (r[0], expected) != 0) {
3722         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3723         return -1;
3724       }
3725     }
3726     if (!r[1]) {
3727       fprintf (stderr, "test_strings_0: short list returned from command\n");
3728       print_strings (r);
3729       return -1;
3730     }
3731     {
3732       char expected[] = "world";
3733       if (strcmp (r[1], expected) != 0) {
3734         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3735         return -1;
3736       }
3737     }
3738     if (r[2] != NULL) {
3739       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
3740       print_strings (r);
3741       return -1;
3742     }
3743     for (i = 0; r[i] != NULL; ++i)
3744       free (r[i]);
3745     free (r);
3746   }
3747   return 0;
3748 }
3749
3750 static int test_strings_1_skip (void)
3751 {
3752   const char *str;
3753
3754   str = getenv ("TEST_ONLY");
3755   if (str)
3756     return strstr (str, "strings") == NULL;
3757   str = getenv ("SKIP_TEST_STRINGS_1");
3758   if (str && strcmp (str, "1") == 0) return 1;
3759   str = getenv ("SKIP_TEST_STRINGS");
3760   if (str && strcmp (str, "1") == 0) return 1;
3761   return 0;
3762 }
3763
3764 static int test_strings_1 (void)
3765 {
3766   if (test_strings_1_skip ()) {
3767     printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
3768     return 0;
3769   }
3770
3771   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
3772   {
3773     char device[] = "/dev/sda";
3774     int r;
3775     suppress_error = 0;
3776     r = guestfs_blockdev_setrw (g, device);
3777     if (r == -1)
3778       return -1;
3779   }
3780   {
3781     int r;
3782     suppress_error = 0;
3783     r = guestfs_umount_all (g);
3784     if (r == -1)
3785       return -1;
3786   }
3787   {
3788     int r;
3789     suppress_error = 0;
3790     r = guestfs_lvm_remove_all (g);
3791     if (r == -1)
3792       return -1;
3793   }
3794   {
3795     char device[] = "/dev/sda";
3796     char lines_0[] = ",";
3797     char *lines[] = {
3798       lines_0,
3799       NULL
3800     };
3801     int r;
3802     suppress_error = 0;
3803     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3804     if (r == -1)
3805       return -1;
3806   }
3807   {
3808     char fstype[] = "ext2";
3809     char device[] = "/dev/sda1";
3810     int r;
3811     suppress_error = 0;
3812     r = guestfs_mkfs (g, fstype, device);
3813     if (r == -1)
3814       return -1;
3815   }
3816   {
3817     char device[] = "/dev/sda1";
3818     char mountpoint[] = "/";
3819     int r;
3820     suppress_error = 0;
3821     r = guestfs_mount (g, device, mountpoint);
3822     if (r == -1)
3823       return -1;
3824   }
3825   /* TestOutputList for strings (1) */
3826   {
3827     char path[] = "/new";
3828     int r;
3829     suppress_error = 0;
3830     r = guestfs_touch (g, path);
3831     if (r == -1)
3832       return -1;
3833   }
3834   {
3835     char path[] = "/new";
3836     char **r;
3837     int i;
3838     suppress_error = 0;
3839     r = guestfs_strings (g, path);
3840     if (r == NULL)
3841       return -1;
3842     if (r[0] != NULL) {
3843       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
3844       print_strings (r);
3845       return -1;
3846     }
3847     for (i = 0; r[i] != NULL; ++i)
3848       free (r[i]);
3849     free (r);
3850   }
3851   return 0;
3852 }
3853
3854 static int test_equal_0_skip (void)
3855 {
3856   const char *str;
3857
3858   str = getenv ("TEST_ONLY");
3859   if (str)
3860     return strstr (str, "equal") == NULL;
3861   str = getenv ("SKIP_TEST_EQUAL_0");
3862   if (str && strcmp (str, "1") == 0) return 1;
3863   str = getenv ("SKIP_TEST_EQUAL");
3864   if (str && strcmp (str, "1") == 0) return 1;
3865   return 0;
3866 }
3867
3868 static int test_equal_0 (void)
3869 {
3870   if (test_equal_0_skip ()) {
3871     printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
3872     return 0;
3873   }
3874
3875   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
3876   {
3877     char device[] = "/dev/sda";
3878     int r;
3879     suppress_error = 0;
3880     r = guestfs_blockdev_setrw (g, device);
3881     if (r == -1)
3882       return -1;
3883   }
3884   {
3885     int r;
3886     suppress_error = 0;
3887     r = guestfs_umount_all (g);
3888     if (r == -1)
3889       return -1;
3890   }
3891   {
3892     int r;
3893     suppress_error = 0;
3894     r = guestfs_lvm_remove_all (g);
3895     if (r == -1)
3896       return -1;
3897   }
3898   {
3899     char device[] = "/dev/sda";
3900     char lines_0[] = ",";
3901     char *lines[] = {
3902       lines_0,
3903       NULL
3904     };
3905     int r;
3906     suppress_error = 0;
3907     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3908     if (r == -1)
3909       return -1;
3910   }
3911   {
3912     char fstype[] = "ext2";
3913     char device[] = "/dev/sda1";
3914     int r;
3915     suppress_error = 0;
3916     r = guestfs_mkfs (g, fstype, device);
3917     if (r == -1)
3918       return -1;
3919   }
3920   {
3921     char device[] = "/dev/sda1";
3922     char mountpoint[] = "/";
3923     int r;
3924     suppress_error = 0;
3925     r = guestfs_mount (g, device, mountpoint);
3926     if (r == -1)
3927       return -1;
3928   }
3929   /* TestOutputTrue for equal (0) */
3930   {
3931     char path[] = "/file1";
3932     char content[] = "contents of a file";
3933     int r;
3934     suppress_error = 0;
3935     r = guestfs_write_file (g, path, content, 0);
3936     if (r == -1)
3937       return -1;
3938   }
3939   {
3940     char src[] = "/file1";
3941     char dest[] = "/file2";
3942     int r;
3943     suppress_error = 0;
3944     r = guestfs_cp (g, src, dest);
3945     if (r == -1)
3946       return -1;
3947   }
3948   {
3949     char file1[] = "/file1";
3950     char file2[] = "/file2";
3951     int r;
3952     suppress_error = 0;
3953     r = guestfs_equal (g, file1, file2);
3954     if (r == -1)
3955       return -1;
3956     if (!r) {
3957       fprintf (stderr, "test_equal_0: expected true, got false\n");
3958       return -1;
3959     }
3960   }
3961   return 0;
3962 }
3963
3964 static int test_equal_1_skip (void)
3965 {
3966   const char *str;
3967
3968   str = getenv ("TEST_ONLY");
3969   if (str)
3970     return strstr (str, "equal") == NULL;
3971   str = getenv ("SKIP_TEST_EQUAL_1");
3972   if (str && strcmp (str, "1") == 0) return 1;
3973   str = getenv ("SKIP_TEST_EQUAL");
3974   if (str && strcmp (str, "1") == 0) return 1;
3975   return 0;
3976 }
3977
3978 static int test_equal_1 (void)
3979 {
3980   if (test_equal_1_skip ()) {
3981     printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
3982     return 0;
3983   }
3984
3985   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
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   {
4009     char device[] = "/dev/sda";
4010     char lines_0[] = ",";
4011     char *lines[] = {
4012       lines_0,
4013       NULL
4014     };
4015     int r;
4016     suppress_error = 0;
4017     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4018     if (r == -1)
4019       return -1;
4020   }
4021   {
4022     char fstype[] = "ext2";
4023     char device[] = "/dev/sda1";
4024     int r;
4025     suppress_error = 0;
4026     r = guestfs_mkfs (g, fstype, device);
4027     if (r == -1)
4028       return -1;
4029   }
4030   {
4031     char device[] = "/dev/sda1";
4032     char mountpoint[] = "/";
4033     int r;
4034     suppress_error = 0;
4035     r = guestfs_mount (g, device, mountpoint);
4036     if (r == -1)
4037       return -1;
4038   }
4039   /* TestOutputFalse for equal (1) */
4040   {
4041     char path[] = "/file1";
4042     char content[] = "contents of a file";
4043     int r;
4044     suppress_error = 0;
4045     r = guestfs_write_file (g, path, content, 0);
4046     if (r == -1)
4047       return -1;
4048   }
4049   {
4050     char path[] = "/file2";
4051     char content[] = "contents of another file";
4052     int r;
4053     suppress_error = 0;
4054     r = guestfs_write_file (g, path, content, 0);
4055     if (r == -1)
4056       return -1;
4057   }
4058   {
4059     char file1[] = "/file1";
4060     char file2[] = "/file2";
4061     int r;
4062     suppress_error = 0;
4063     r = guestfs_equal (g, file1, file2);
4064     if (r == -1)
4065       return -1;
4066     if (r) {
4067       fprintf (stderr, "test_equal_1: expected false, got true\n");
4068       return -1;
4069     }
4070   }
4071   return 0;
4072 }
4073
4074 static int test_equal_2_skip (void)
4075 {
4076   const char *str;
4077
4078   str = getenv ("TEST_ONLY");
4079   if (str)
4080     return strstr (str, "equal") == NULL;
4081   str = getenv ("SKIP_TEST_EQUAL_2");
4082   if (str && strcmp (str, "1") == 0) return 1;
4083   str = getenv ("SKIP_TEST_EQUAL");
4084   if (str && strcmp (str, "1") == 0) return 1;
4085   return 0;
4086 }
4087
4088 static int test_equal_2 (void)
4089 {
4090   if (test_equal_2_skip ()) {
4091     printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4092     return 0;
4093   }
4094
4095   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4096   {
4097     char device[] = "/dev/sda";
4098     int r;
4099     suppress_error = 0;
4100     r = guestfs_blockdev_setrw (g, device);
4101     if (r == -1)
4102       return -1;
4103   }
4104   {
4105     int r;
4106     suppress_error = 0;
4107     r = guestfs_umount_all (g);
4108     if (r == -1)
4109       return -1;
4110   }
4111   {
4112     int r;
4113     suppress_error = 0;
4114     r = guestfs_lvm_remove_all (g);
4115     if (r == -1)
4116       return -1;
4117   }
4118   {
4119     char device[] = "/dev/sda";
4120     char lines_0[] = ",";
4121     char *lines[] = {
4122       lines_0,
4123       NULL
4124     };
4125     int r;
4126     suppress_error = 0;
4127     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4128     if (r == -1)
4129       return -1;
4130   }
4131   {
4132     char fstype[] = "ext2";
4133     char device[] = "/dev/sda1";
4134     int r;
4135     suppress_error = 0;
4136     r = guestfs_mkfs (g, fstype, device);
4137     if (r == -1)
4138       return -1;
4139   }
4140   {
4141     char device[] = "/dev/sda1";
4142     char mountpoint[] = "/";
4143     int r;
4144     suppress_error = 0;
4145     r = guestfs_mount (g, device, mountpoint);
4146     if (r == -1)
4147       return -1;
4148   }
4149   /* TestLastFail for equal (2) */
4150   {
4151     char file1[] = "/file1";
4152     char file2[] = "/file2";
4153     int r;
4154     suppress_error = 1;
4155     r = guestfs_equal (g, file1, file2);
4156     if (r != -1)
4157       return -1;
4158   }
4159   return 0;
4160 }
4161
4162 static int test_ping_daemon_0_skip (void)
4163 {
4164   const char *str;
4165
4166   str = getenv ("TEST_ONLY");
4167   if (str)
4168     return strstr (str, "ping_daemon") == NULL;
4169   str = getenv ("SKIP_TEST_PING_DAEMON_0");
4170   if (str && strcmp (str, "1") == 0) return 1;
4171   str = getenv ("SKIP_TEST_PING_DAEMON");
4172   if (str && strcmp (str, "1") == 0) return 1;
4173   return 0;
4174 }
4175
4176 static int test_ping_daemon_0 (void)
4177 {
4178   if (test_ping_daemon_0_skip ()) {
4179     printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4180     return 0;
4181   }
4182
4183   /* InitNone|InitEmpty for test_ping_daemon_0 */
4184   {
4185     char device[] = "/dev/sda";
4186     int r;
4187     suppress_error = 0;
4188     r = guestfs_blockdev_setrw (g, device);
4189     if (r == -1)
4190       return -1;
4191   }
4192   {
4193     int r;
4194     suppress_error = 0;
4195     r = guestfs_umount_all (g);
4196     if (r == -1)
4197       return -1;
4198   }
4199   {
4200     int r;
4201     suppress_error = 0;
4202     r = guestfs_lvm_remove_all (g);
4203     if (r == -1)
4204       return -1;
4205   }
4206   /* TestRun for ping_daemon (0) */
4207   {
4208     int r;
4209     suppress_error = 0;
4210     r = guestfs_ping_daemon (g);
4211     if (r == -1)
4212       return -1;
4213   }
4214   return 0;
4215 }
4216
4217 static int test_dmesg_0_skip (void)
4218 {
4219   const char *str;
4220
4221   str = getenv ("TEST_ONLY");
4222   if (str)
4223     return strstr (str, "dmesg") == NULL;
4224   str = getenv ("SKIP_TEST_DMESG_0");
4225   if (str && strcmp (str, "1") == 0) return 1;
4226   str = getenv ("SKIP_TEST_DMESG");
4227   if (str && strcmp (str, "1") == 0) return 1;
4228   return 0;
4229 }
4230
4231 static int test_dmesg_0 (void)
4232 {
4233   if (test_dmesg_0_skip ()) {
4234     printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4235     return 0;
4236   }
4237
4238   /* InitNone|InitEmpty for test_dmesg_0 */
4239   {
4240     char device[] = "/dev/sda";
4241     int r;
4242     suppress_error = 0;
4243     r = guestfs_blockdev_setrw (g, device);
4244     if (r == -1)
4245       return -1;
4246   }
4247   {
4248     int r;
4249     suppress_error = 0;
4250     r = guestfs_umount_all (g);
4251     if (r == -1)
4252       return -1;
4253   }
4254   {
4255     int r;
4256     suppress_error = 0;
4257     r = guestfs_lvm_remove_all (g);
4258     if (r == -1)
4259       return -1;
4260   }
4261   /* TestRun for dmesg (0) */
4262   {
4263     char *r;
4264     suppress_error = 0;
4265     r = guestfs_dmesg (g);
4266     if (r == NULL)
4267       return -1;
4268     free (r);
4269   }
4270   return 0;
4271 }
4272
4273 static int test_drop_caches_0_skip (void)
4274 {
4275   const char *str;
4276
4277   str = getenv ("TEST_ONLY");
4278   if (str)
4279     return strstr (str, "drop_caches") == NULL;
4280   str = getenv ("SKIP_TEST_DROP_CACHES_0");
4281   if (str && strcmp (str, "1") == 0) return 1;
4282   str = getenv ("SKIP_TEST_DROP_CACHES");
4283   if (str && strcmp (str, "1") == 0) return 1;
4284   return 0;
4285 }
4286
4287 static int test_drop_caches_0 (void)
4288 {
4289   if (test_drop_caches_0_skip ()) {
4290     printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4291     return 0;
4292   }
4293
4294   /* InitNone|InitEmpty for test_drop_caches_0 */
4295   {
4296     char device[] = "/dev/sda";
4297     int r;
4298     suppress_error = 0;
4299     r = guestfs_blockdev_setrw (g, device);
4300     if (r == -1)
4301       return -1;
4302   }
4303   {
4304     int r;
4305     suppress_error = 0;
4306     r = guestfs_umount_all (g);
4307     if (r == -1)
4308       return -1;
4309   }
4310   {
4311     int r;
4312     suppress_error = 0;
4313     r = guestfs_lvm_remove_all (g);
4314     if (r == -1)
4315       return -1;
4316   }
4317   /* TestRun for drop_caches (0) */
4318   {
4319     int r;
4320     suppress_error = 0;
4321     r = guestfs_drop_caches (g, 3);
4322     if (r == -1)
4323       return -1;
4324   }
4325   return 0;
4326 }
4327
4328 static int test_mv_0_skip (void)
4329 {
4330   const char *str;
4331
4332   str = getenv ("TEST_ONLY");
4333   if (str)
4334     return strstr (str, "mv") == NULL;
4335   str = getenv ("SKIP_TEST_MV_0");
4336   if (str && strcmp (str, "1") == 0) return 1;
4337   str = getenv ("SKIP_TEST_MV");
4338   if (str && strcmp (str, "1") == 0) return 1;
4339   return 0;
4340 }
4341
4342 static int test_mv_0 (void)
4343 {
4344   if (test_mv_0_skip ()) {
4345     printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4346     return 0;
4347   }
4348
4349   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4350   {
4351     char device[] = "/dev/sda";
4352     int r;
4353     suppress_error = 0;
4354     r = guestfs_blockdev_setrw (g, device);
4355     if (r == -1)
4356       return -1;
4357   }
4358   {
4359     int r;
4360     suppress_error = 0;
4361     r = guestfs_umount_all (g);
4362     if (r == -1)
4363       return -1;
4364   }
4365   {
4366     int r;
4367     suppress_error = 0;
4368     r = guestfs_lvm_remove_all (g);
4369     if (r == -1)
4370       return -1;
4371   }
4372   {
4373     char device[] = "/dev/sda";
4374     char lines_0[] = ",";
4375     char *lines[] = {
4376       lines_0,
4377       NULL
4378     };
4379     int r;
4380     suppress_error = 0;
4381     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4382     if (r == -1)
4383       return -1;
4384   }
4385   {
4386     char fstype[] = "ext2";
4387     char device[] = "/dev/sda1";
4388     int r;
4389     suppress_error = 0;
4390     r = guestfs_mkfs (g, fstype, device);
4391     if (r == -1)
4392       return -1;
4393   }
4394   {
4395     char device[] = "/dev/sda1";
4396     char mountpoint[] = "/";
4397     int r;
4398     suppress_error = 0;
4399     r = guestfs_mount (g, device, mountpoint);
4400     if (r == -1)
4401       return -1;
4402   }
4403   /* TestOutput for mv (0) */
4404   char expected[] = "file content";
4405   {
4406     char path[] = "/old";
4407     char content[] = "file content";
4408     int r;
4409     suppress_error = 0;
4410     r = guestfs_write_file (g, path, content, 0);
4411     if (r == -1)
4412       return -1;
4413   }
4414   {
4415     char src[] = "/old";
4416     char dest[] = "/new";
4417     int r;
4418     suppress_error = 0;
4419     r = guestfs_mv (g, src, dest);
4420     if (r == -1)
4421       return -1;
4422   }
4423   {
4424     char path[] = "/new";
4425     char *r;
4426     suppress_error = 0;
4427     r = guestfs_cat (g, path);
4428     if (r == NULL)
4429       return -1;
4430     if (strcmp (r, expected) != 0) {
4431       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4432       return -1;
4433     }
4434     free (r);
4435   }
4436   return 0;
4437 }
4438
4439 static int test_mv_1_skip (void)
4440 {
4441   const char *str;
4442
4443   str = getenv ("TEST_ONLY");
4444   if (str)
4445     return strstr (str, "mv") == NULL;
4446   str = getenv ("SKIP_TEST_MV_1");
4447   if (str && strcmp (str, "1") == 0) return 1;
4448   str = getenv ("SKIP_TEST_MV");
4449   if (str && strcmp (str, "1") == 0) return 1;
4450   return 0;
4451 }
4452
4453 static int test_mv_1 (void)
4454 {
4455   if (test_mv_1_skip ()) {
4456     printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4457     return 0;
4458   }
4459
4460   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4461   {
4462     char device[] = "/dev/sda";
4463     int r;
4464     suppress_error = 0;
4465     r = guestfs_blockdev_setrw (g, device);
4466     if (r == -1)
4467       return -1;
4468   }
4469   {
4470     int r;
4471     suppress_error = 0;
4472     r = guestfs_umount_all (g);
4473     if (r == -1)
4474       return -1;
4475   }
4476   {
4477     int r;
4478     suppress_error = 0;
4479     r = guestfs_lvm_remove_all (g);
4480     if (r == -1)
4481       return -1;
4482   }
4483   {
4484     char device[] = "/dev/sda";
4485     char lines_0[] = ",";
4486     char *lines[] = {
4487       lines_0,
4488       NULL
4489     };
4490     int r;
4491     suppress_error = 0;
4492     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4493     if (r == -1)
4494       return -1;
4495   }
4496   {
4497     char fstype[] = "ext2";
4498     char device[] = "/dev/sda1";
4499     int r;
4500     suppress_error = 0;
4501     r = guestfs_mkfs (g, fstype, device);
4502     if (r == -1)
4503       return -1;
4504   }
4505   {
4506     char device[] = "/dev/sda1";
4507     char mountpoint[] = "/";
4508     int r;
4509     suppress_error = 0;
4510     r = guestfs_mount (g, device, mountpoint);
4511     if (r == -1)
4512       return -1;
4513   }
4514   /* TestOutputFalse for mv (1) */
4515   {
4516     char path[] = "/old";
4517     char content[] = "file content";
4518     int r;
4519     suppress_error = 0;
4520     r = guestfs_write_file (g, path, content, 0);
4521     if (r == -1)
4522       return -1;
4523   }
4524   {
4525     char src[] = "/old";
4526     char dest[] = "/new";
4527     int r;
4528     suppress_error = 0;
4529     r = guestfs_mv (g, src, dest);
4530     if (r == -1)
4531       return -1;
4532   }
4533   {
4534     char path[] = "/old";
4535     int r;
4536     suppress_error = 0;
4537     r = guestfs_is_file (g, path);
4538     if (r == -1)
4539       return -1;
4540     if (r) {
4541       fprintf (stderr, "test_mv_1: expected false, got true\n");
4542       return -1;
4543     }
4544   }
4545   return 0;
4546 }
4547
4548 static int test_cp_a_0_skip (void)
4549 {
4550   const char *str;
4551
4552   str = getenv ("TEST_ONLY");
4553   if (str)
4554     return strstr (str, "cp_a") == NULL;
4555   str = getenv ("SKIP_TEST_CP_A_0");
4556   if (str && strcmp (str, "1") == 0) return 1;
4557   str = getenv ("SKIP_TEST_CP_A");
4558   if (str && strcmp (str, "1") == 0) return 1;
4559   return 0;
4560 }
4561
4562 static int test_cp_a_0 (void)
4563 {
4564   if (test_cp_a_0_skip ()) {
4565     printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
4566     return 0;
4567   }
4568
4569   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
4570   {
4571     char device[] = "/dev/sda";
4572     int r;
4573     suppress_error = 0;
4574     r = guestfs_blockdev_setrw (g, device);
4575     if (r == -1)
4576       return -1;
4577   }
4578   {
4579     int r;
4580     suppress_error = 0;
4581     r = guestfs_umount_all (g);
4582     if (r == -1)
4583       return -1;
4584   }
4585   {
4586     int r;
4587     suppress_error = 0;
4588     r = guestfs_lvm_remove_all (g);
4589     if (r == -1)
4590       return -1;
4591   }
4592   {
4593     char device[] = "/dev/sda";
4594     char lines_0[] = ",";
4595     char *lines[] = {
4596       lines_0,
4597       NULL
4598     };
4599     int r;
4600     suppress_error = 0;
4601     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4602     if (r == -1)
4603       return -1;
4604   }
4605   {
4606     char fstype[] = "ext2";
4607     char device[] = "/dev/sda1";
4608     int r;
4609     suppress_error = 0;
4610     r = guestfs_mkfs (g, fstype, device);
4611     if (r == -1)
4612       return -1;
4613   }
4614   {
4615     char device[] = "/dev/sda1";
4616     char mountpoint[] = "/";
4617     int r;
4618     suppress_error = 0;
4619     r = guestfs_mount (g, device, mountpoint);
4620     if (r == -1)
4621       return -1;
4622   }
4623   /* TestOutput for cp_a (0) */
4624   char expected[] = "file content";
4625   {
4626     char path[] = "/olddir";
4627     int r;
4628     suppress_error = 0;
4629     r = guestfs_mkdir (g, path);
4630     if (r == -1)
4631       return -1;
4632   }
4633   {
4634     char path[] = "/newdir";
4635     int r;
4636     suppress_error = 0;
4637     r = guestfs_mkdir (g, path);
4638     if (r == -1)
4639       return -1;
4640   }
4641   {
4642     char path[] = "/olddir/file";
4643     char content[] = "file content";
4644     int r;
4645     suppress_error = 0;
4646     r = guestfs_write_file (g, path, content, 0);
4647     if (r == -1)
4648       return -1;
4649   }
4650   {
4651     char src[] = "/olddir";
4652     char dest[] = "/newdir";
4653     int r;
4654     suppress_error = 0;
4655     r = guestfs_cp_a (g, src, dest);
4656     if (r == -1)
4657       return -1;
4658   }
4659   {
4660     char path[] = "/newdir/olddir/file";
4661     char *r;
4662     suppress_error = 0;
4663     r = guestfs_cat (g, path);
4664     if (r == NULL)
4665       return -1;
4666     if (strcmp (r, expected) != 0) {
4667       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
4668       return -1;
4669     }
4670     free (r);
4671   }
4672   return 0;
4673 }
4674
4675 static int test_cp_0_skip (void)
4676 {
4677   const char *str;
4678
4679   str = getenv ("TEST_ONLY");
4680   if (str)
4681     return strstr (str, "cp") == NULL;
4682   str = getenv ("SKIP_TEST_CP_0");
4683   if (str && strcmp (str, "1") == 0) return 1;
4684   str = getenv ("SKIP_TEST_CP");
4685   if (str && strcmp (str, "1") == 0) return 1;
4686   return 0;
4687 }
4688
4689 static int test_cp_0 (void)
4690 {
4691   if (test_cp_0_skip ()) {
4692     printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
4693     return 0;
4694   }
4695
4696   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
4697   {
4698     char device[] = "/dev/sda";
4699     int r;
4700     suppress_error = 0;
4701     r = guestfs_blockdev_setrw (g, device);
4702     if (r == -1)
4703       return -1;
4704   }
4705   {
4706     int r;
4707     suppress_error = 0;
4708     r = guestfs_umount_all (g);
4709     if (r == -1)
4710       return -1;
4711   }
4712   {
4713     int r;
4714     suppress_error = 0;
4715     r = guestfs_lvm_remove_all (g);
4716     if (r == -1)
4717       return -1;
4718   }
4719   {
4720     char device[] = "/dev/sda";
4721     char lines_0[] = ",";
4722     char *lines[] = {
4723       lines_0,
4724       NULL
4725     };
4726     int r;
4727     suppress_error = 0;
4728     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4729     if (r == -1)
4730       return -1;
4731   }
4732   {
4733     char fstype[] = "ext2";
4734     char device[] = "/dev/sda1";
4735     int r;
4736     suppress_error = 0;
4737     r = guestfs_mkfs (g, fstype, device);
4738     if (r == -1)
4739       return -1;
4740   }
4741   {
4742     char device[] = "/dev/sda1";
4743     char mountpoint[] = "/";
4744     int r;
4745     suppress_error = 0;
4746     r = guestfs_mount (g, device, mountpoint);
4747     if (r == -1)
4748       return -1;
4749   }
4750   /* TestOutput for cp (0) */
4751   char expected[] = "file content";
4752   {
4753     char path[] = "/old";
4754     char content[] = "file content";
4755     int r;
4756     suppress_error = 0;
4757     r = guestfs_write_file (g, path, content, 0);
4758     if (r == -1)
4759       return -1;
4760   }
4761   {
4762     char src[] = "/old";
4763     char dest[] = "/new";
4764     int r;
4765     suppress_error = 0;
4766     r = guestfs_cp (g, src, dest);
4767     if (r == -1)
4768       return -1;
4769   }
4770   {
4771     char path[] = "/new";
4772     char *r;
4773     suppress_error = 0;
4774     r = guestfs_cat (g, path);
4775     if (r == NULL)
4776       return -1;
4777     if (strcmp (r, expected) != 0) {
4778       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
4779       return -1;
4780     }
4781     free (r);
4782   }
4783   return 0;
4784 }
4785
4786 static int test_cp_1_skip (void)
4787 {
4788   const char *str;
4789
4790   str = getenv ("TEST_ONLY");
4791   if (str)
4792     return strstr (str, "cp") == NULL;
4793   str = getenv ("SKIP_TEST_CP_1");
4794   if (str && strcmp (str, "1") == 0) return 1;
4795   str = getenv ("SKIP_TEST_CP");
4796   if (str && strcmp (str, "1") == 0) return 1;
4797   return 0;
4798 }
4799
4800 static int test_cp_1 (void)
4801 {
4802   if (test_cp_1_skip ()) {
4803     printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
4804     return 0;
4805   }
4806
4807   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
4808   {
4809     char device[] = "/dev/sda";
4810     int r;
4811     suppress_error = 0;
4812     r = guestfs_blockdev_setrw (g, device);
4813     if (r == -1)
4814       return -1;
4815   }
4816   {
4817     int r;
4818     suppress_error = 0;
4819     r = guestfs_umount_all (g);
4820     if (r == -1)
4821       return -1;
4822   }
4823   {
4824     int r;
4825     suppress_error = 0;
4826     r = guestfs_lvm_remove_all (g);
4827     if (r == -1)
4828       return -1;
4829   }
4830   {
4831     char device[] = "/dev/sda";
4832     char lines_0[] = ",";
4833     char *lines[] = {
4834       lines_0,
4835       NULL
4836     };
4837     int r;
4838     suppress_error = 0;
4839     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4840     if (r == -1)
4841       return -1;
4842   }
4843   {
4844     char fstype[] = "ext2";
4845     char device[] = "/dev/sda1";
4846     int r;
4847     suppress_error = 0;
4848     r = guestfs_mkfs (g, fstype, device);
4849     if (r == -1)
4850       return -1;
4851   }
4852   {
4853     char device[] = "/dev/sda1";
4854     char mountpoint[] = "/";
4855     int r;
4856     suppress_error = 0;
4857     r = guestfs_mount (g, device, mountpoint);
4858     if (r == -1)
4859       return -1;
4860   }
4861   /* TestOutputTrue for cp (1) */
4862   {
4863     char path[] = "/old";
4864     char content[] = "file content";
4865     int r;
4866     suppress_error = 0;
4867     r = guestfs_write_file (g, path, content, 0);
4868     if (r == -1)
4869       return -1;
4870   }
4871   {
4872     char src[] = "/old";
4873     char dest[] = "/new";
4874     int r;
4875     suppress_error = 0;
4876     r = guestfs_cp (g, src, dest);
4877     if (r == -1)
4878       return -1;
4879   }
4880   {
4881     char path[] = "/old";
4882     int r;
4883     suppress_error = 0;
4884     r = guestfs_is_file (g, path);
4885     if (r == -1)
4886       return -1;
4887     if (!r) {
4888       fprintf (stderr, "test_cp_1: expected true, got false\n");
4889       return -1;
4890     }
4891   }
4892   return 0;
4893 }
4894
4895 static int test_cp_2_skip (void)
4896 {
4897   const char *str;
4898
4899   str = getenv ("TEST_ONLY");
4900   if (str)
4901     return strstr (str, "cp") == NULL;
4902   str = getenv ("SKIP_TEST_CP_2");
4903   if (str && strcmp (str, "1") == 0) return 1;
4904   str = getenv ("SKIP_TEST_CP");
4905   if (str && strcmp (str, "1") == 0) return 1;
4906   return 0;
4907 }
4908
4909 static int test_cp_2 (void)
4910 {
4911   if (test_cp_2_skip ()) {
4912     printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
4913     return 0;
4914   }
4915
4916   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
4917   {
4918     char device[] = "/dev/sda";
4919     int r;
4920     suppress_error = 0;
4921     r = guestfs_blockdev_setrw (g, device);
4922     if (r == -1)
4923       return -1;
4924   }
4925   {
4926     int r;
4927     suppress_error = 0;
4928     r = guestfs_umount_all (g);
4929     if (r == -1)
4930       return -1;
4931   }
4932   {
4933     int r;
4934     suppress_error = 0;
4935     r = guestfs_lvm_remove_all (g);
4936     if (r == -1)
4937       return -1;
4938   }
4939   {
4940     char device[] = "/dev/sda";
4941     char lines_0[] = ",";
4942     char *lines[] = {
4943       lines_0,
4944       NULL
4945     };
4946     int r;
4947     suppress_error = 0;
4948     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4949     if (r == -1)
4950       return -1;
4951   }
4952   {
4953     char fstype[] = "ext2";
4954     char device[] = "/dev/sda1";
4955     int r;
4956     suppress_error = 0;
4957     r = guestfs_mkfs (g, fstype, device);
4958     if (r == -1)
4959       return -1;
4960   }
4961   {
4962     char device[] = "/dev/sda1";
4963     char mountpoint[] = "/";
4964     int r;
4965     suppress_error = 0;
4966     r = guestfs_mount (g, device, mountpoint);
4967     if (r == -1)
4968       return -1;
4969   }
4970   /* TestOutput for cp (2) */
4971   char expected[] = "file content";
4972   {
4973     char path[] = "/old";
4974     char content[] = "file content";
4975     int r;
4976     suppress_error = 0;
4977     r = guestfs_write_file (g, path, content, 0);
4978     if (r == -1)
4979       return -1;
4980   }
4981   {
4982     char path[] = "/dir";
4983     int r;
4984     suppress_error = 0;
4985     r = guestfs_mkdir (g, path);
4986     if (r == -1)
4987       return -1;
4988   }
4989   {
4990     char src[] = "/old";
4991     char dest[] = "/dir/new";
4992     int r;
4993     suppress_error = 0;
4994     r = guestfs_cp (g, src, dest);
4995     if (r == -1)
4996       return -1;
4997   }
4998   {
4999     char path[] = "/dir/new";
5000     char *r;
5001     suppress_error = 0;
5002     r = guestfs_cat (g, path);
5003     if (r == NULL)
5004       return -1;
5005     if (strcmp (r, expected) != 0) {
5006       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5007       return -1;
5008     }
5009     free (r);
5010   }
5011   return 0;
5012 }
5013
5014 static int test_grub_install_0_skip (void)
5015 {
5016   const char *str;
5017
5018   str = getenv ("TEST_ONLY");
5019   if (str)
5020     return strstr (str, "grub_install") == NULL;
5021   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5022   if (str && strcmp (str, "1") == 0) return 1;
5023   str = getenv ("SKIP_TEST_GRUB_INSTALL");
5024   if (str && strcmp (str, "1") == 0) return 1;
5025   return 0;
5026 }
5027
5028 static int test_grub_install_0 (void)
5029 {
5030   if (test_grub_install_0_skip ()) {
5031     printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5032     return 0;
5033   }
5034
5035   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5036   {
5037     char device[] = "/dev/sda";
5038     int r;
5039     suppress_error = 0;
5040     r = guestfs_blockdev_setrw (g, device);
5041     if (r == -1)
5042       return -1;
5043   }
5044   {
5045     int r;
5046     suppress_error = 0;
5047     r = guestfs_umount_all (g);
5048     if (r == -1)
5049       return -1;
5050   }
5051   {
5052     int r;
5053     suppress_error = 0;
5054     r = guestfs_lvm_remove_all (g);
5055     if (r == -1)
5056       return -1;
5057   }
5058   {
5059     char device[] = "/dev/sda";
5060     char lines_0[] = ",";
5061     char *lines[] = {
5062       lines_0,
5063       NULL
5064     };
5065     int r;
5066     suppress_error = 0;
5067     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5068     if (r == -1)
5069       return -1;
5070   }
5071   {
5072     char fstype[] = "ext2";
5073     char device[] = "/dev/sda1";
5074     int r;
5075     suppress_error = 0;
5076     r = guestfs_mkfs (g, fstype, device);
5077     if (r == -1)
5078       return -1;
5079   }
5080   {
5081     char device[] = "/dev/sda1";
5082     char mountpoint[] = "/";
5083     int r;
5084     suppress_error = 0;
5085     r = guestfs_mount (g, device, mountpoint);
5086     if (r == -1)
5087       return -1;
5088   }
5089   /* TestOutputTrue for grub_install (0) */
5090   {
5091     char root[] = "/";
5092     char device[] = "/dev/sda1";
5093     int r;
5094     suppress_error = 0;
5095     r = guestfs_grub_install (g, root, device);
5096     if (r == -1)
5097       return -1;
5098   }
5099   {
5100     char path[] = "/boot";
5101     int r;
5102     suppress_error = 0;
5103     r = guestfs_is_dir (g, path);
5104     if (r == -1)
5105       return -1;
5106     if (!r) {
5107       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5108       return -1;
5109     }
5110   }
5111   return 0;
5112 }
5113
5114 static int test_zero_0_skip (void)
5115 {
5116   const char *str;
5117
5118   str = getenv ("TEST_ONLY");
5119   if (str)
5120     return strstr (str, "zero") == NULL;
5121   str = getenv ("SKIP_TEST_ZERO_0");
5122   if (str && strcmp (str, "1") == 0) return 1;
5123   str = getenv ("SKIP_TEST_ZERO");
5124   if (str && strcmp (str, "1") == 0) return 1;
5125   return 0;
5126 }
5127
5128 static int test_zero_0 (void)
5129 {
5130   if (test_zero_0_skip ()) {
5131     printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5132     return 0;
5133   }
5134
5135   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5136   {
5137     char device[] = "/dev/sda";
5138     int r;
5139     suppress_error = 0;
5140     r = guestfs_blockdev_setrw (g, device);
5141     if (r == -1)
5142       return -1;
5143   }
5144   {
5145     int r;
5146     suppress_error = 0;
5147     r = guestfs_umount_all (g);
5148     if (r == -1)
5149       return -1;
5150   }
5151   {
5152     int r;
5153     suppress_error = 0;
5154     r = guestfs_lvm_remove_all (g);
5155     if (r == -1)
5156       return -1;
5157   }
5158   {
5159     char device[] = "/dev/sda";
5160     char lines_0[] = ",";
5161     char *lines[] = {
5162       lines_0,
5163       NULL
5164     };
5165     int r;
5166     suppress_error = 0;
5167     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5168     if (r == -1)
5169       return -1;
5170   }
5171   {
5172     char fstype[] = "ext2";
5173     char device[] = "/dev/sda1";
5174     int r;
5175     suppress_error = 0;
5176     r = guestfs_mkfs (g, fstype, device);
5177     if (r == -1)
5178       return -1;
5179   }
5180   {
5181     char device[] = "/dev/sda1";
5182     char mountpoint[] = "/";
5183     int r;
5184     suppress_error = 0;
5185     r = guestfs_mount (g, device, mountpoint);
5186     if (r == -1)
5187       return -1;
5188   }
5189   /* TestOutput for zero (0) */
5190   char expected[] = "data";
5191   {
5192     char pathordevice[] = "/dev/sda1";
5193     int r;
5194     suppress_error = 0;
5195     r = guestfs_umount (g, pathordevice);
5196     if (r == -1)
5197       return -1;
5198   }
5199   {
5200     char device[] = "/dev/sda1";
5201     int r;
5202     suppress_error = 0;
5203     r = guestfs_zero (g, device);
5204     if (r == -1)
5205       return -1;
5206   }
5207   {
5208     char path[] = "/dev/sda1";
5209     char *r;
5210     suppress_error = 0;
5211     r = guestfs_file (g, path);
5212     if (r == NULL)
5213       return -1;
5214     if (strcmp (r, expected) != 0) {
5215       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5216       return -1;
5217     }
5218     free (r);
5219   }
5220   return 0;
5221 }
5222
5223 static int test_fsck_0_skip (void)
5224 {
5225   const char *str;
5226
5227   str = getenv ("TEST_ONLY");
5228   if (str)
5229     return strstr (str, "fsck") == NULL;
5230   str = getenv ("SKIP_TEST_FSCK_0");
5231   if (str && strcmp (str, "1") == 0) return 1;
5232   str = getenv ("SKIP_TEST_FSCK");
5233   if (str && strcmp (str, "1") == 0) return 1;
5234   return 0;
5235 }
5236
5237 static int test_fsck_0 (void)
5238 {
5239   if (test_fsck_0_skip ()) {
5240     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5241     return 0;
5242   }
5243
5244   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5245   {
5246     char device[] = "/dev/sda";
5247     int r;
5248     suppress_error = 0;
5249     r = guestfs_blockdev_setrw (g, device);
5250     if (r == -1)
5251       return -1;
5252   }
5253   {
5254     int r;
5255     suppress_error = 0;
5256     r = guestfs_umount_all (g);
5257     if (r == -1)
5258       return -1;
5259   }
5260   {
5261     int r;
5262     suppress_error = 0;
5263     r = guestfs_lvm_remove_all (g);
5264     if (r == -1)
5265       return -1;
5266   }
5267   {
5268     char device[] = "/dev/sda";
5269     char lines_0[] = ",";
5270     char *lines[] = {
5271       lines_0,
5272       NULL
5273     };
5274     int r;
5275     suppress_error = 0;
5276     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5277     if (r == -1)
5278       return -1;
5279   }
5280   {
5281     char fstype[] = "ext2";
5282     char device[] = "/dev/sda1";
5283     int r;
5284     suppress_error = 0;
5285     r = guestfs_mkfs (g, fstype, device);
5286     if (r == -1)
5287       return -1;
5288   }
5289   {
5290     char device[] = "/dev/sda1";
5291     char mountpoint[] = "/";
5292     int r;
5293     suppress_error = 0;
5294     r = guestfs_mount (g, device, mountpoint);
5295     if (r == -1)
5296       return -1;
5297   }
5298   /* TestOutputInt for fsck (0) */
5299   {
5300     char pathordevice[] = "/dev/sda1";
5301     int r;
5302     suppress_error = 0;
5303     r = guestfs_umount (g, pathordevice);
5304     if (r == -1)
5305       return -1;
5306   }
5307   {
5308     char fstype[] = "ext2";
5309     char device[] = "/dev/sda1";
5310     int r;
5311     suppress_error = 0;
5312     r = guestfs_fsck (g, fstype, device);
5313     if (r == -1)
5314       return -1;
5315     if (r != 0) {
5316       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
5317       return -1;
5318     }
5319   }
5320   return 0;
5321 }
5322
5323 static int test_fsck_1_skip (void)
5324 {
5325   const char *str;
5326
5327   str = getenv ("TEST_ONLY");
5328   if (str)
5329     return strstr (str, "fsck") == NULL;
5330   str = getenv ("SKIP_TEST_FSCK_1");
5331   if (str && strcmp (str, "1") == 0) return 1;
5332   str = getenv ("SKIP_TEST_FSCK");
5333   if (str && strcmp (str, "1") == 0) return 1;
5334   return 0;
5335 }
5336
5337 static int test_fsck_1 (void)
5338 {
5339   if (test_fsck_1_skip ()) {
5340     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5341     return 0;
5342   }
5343
5344   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5345   {
5346     char device[] = "/dev/sda";
5347     int r;
5348     suppress_error = 0;
5349     r = guestfs_blockdev_setrw (g, device);
5350     if (r == -1)
5351       return -1;
5352   }
5353   {
5354     int r;
5355     suppress_error = 0;
5356     r = guestfs_umount_all (g);
5357     if (r == -1)
5358       return -1;
5359   }
5360   {
5361     int r;
5362     suppress_error = 0;
5363     r = guestfs_lvm_remove_all (g);
5364     if (r == -1)
5365       return -1;
5366   }
5367   {
5368     char device[] = "/dev/sda";
5369     char lines_0[] = ",";
5370     char *lines[] = {
5371       lines_0,
5372       NULL
5373     };
5374     int r;
5375     suppress_error = 0;
5376     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5377     if (r == -1)
5378       return -1;
5379   }
5380   {
5381     char fstype[] = "ext2";
5382     char device[] = "/dev/sda1";
5383     int r;
5384     suppress_error = 0;
5385     r = guestfs_mkfs (g, fstype, device);
5386     if (r == -1)
5387       return -1;
5388   }
5389   {
5390     char device[] = "/dev/sda1";
5391     char mountpoint[] = "/";
5392     int r;
5393     suppress_error = 0;
5394     r = guestfs_mount (g, device, mountpoint);
5395     if (r == -1)
5396       return -1;
5397   }
5398   /* TestOutputInt for fsck (1) */
5399   {
5400     char pathordevice[] = "/dev/sda1";
5401     int r;
5402     suppress_error = 0;
5403     r = guestfs_umount (g, pathordevice);
5404     if (r == -1)
5405       return -1;
5406   }
5407   {
5408     char device[] = "/dev/sda1";
5409     int r;
5410     suppress_error = 0;
5411     r = guestfs_zero (g, device);
5412     if (r == -1)
5413       return -1;
5414   }
5415   {
5416     char fstype[] = "ext2";
5417     char device[] = "/dev/sda1";
5418     int r;
5419     suppress_error = 0;
5420     r = guestfs_fsck (g, fstype, device);
5421     if (r == -1)
5422       return -1;
5423     if (r != 8) {
5424       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
5425       return -1;
5426     }
5427   }
5428   return 0;
5429 }
5430
5431 static int test_set_e2uuid_0_skip (void)
5432 {
5433   const char *str;
5434
5435   str = getenv ("TEST_ONLY");
5436   if (str)
5437     return strstr (str, "set_e2uuid") == NULL;
5438   str = getenv ("SKIP_TEST_SET_E2UUID_0");
5439   if (str && strcmp (str, "1") == 0) return 1;
5440   str = getenv ("SKIP_TEST_SET_E2UUID");
5441   if (str && strcmp (str, "1") == 0) return 1;
5442   return 0;
5443 }
5444
5445 static int test_set_e2uuid_0 (void)
5446 {
5447   if (test_set_e2uuid_0_skip ()) {
5448     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5449     return 0;
5450   }
5451
5452   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5453   {
5454     char device[] = "/dev/sda";
5455     int r;
5456     suppress_error = 0;
5457     r = guestfs_blockdev_setrw (g, device);
5458     if (r == -1)
5459       return -1;
5460   }
5461   {
5462     int r;
5463     suppress_error = 0;
5464     r = guestfs_umount_all (g);
5465     if (r == -1)
5466       return -1;
5467   }
5468   {
5469     int r;
5470     suppress_error = 0;
5471     r = guestfs_lvm_remove_all (g);
5472     if (r == -1)
5473       return -1;
5474   }
5475   {
5476     char device[] = "/dev/sda";
5477     char lines_0[] = ",";
5478     char *lines[] = {
5479       lines_0,
5480       NULL
5481     };
5482     int r;
5483     suppress_error = 0;
5484     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5485     if (r == -1)
5486       return -1;
5487   }
5488   {
5489     char fstype[] = "ext2";
5490     char device[] = "/dev/sda1";
5491     int r;
5492     suppress_error = 0;
5493     r = guestfs_mkfs (g, fstype, device);
5494     if (r == -1)
5495       return -1;
5496   }
5497   {
5498     char device[] = "/dev/sda1";
5499     char mountpoint[] = "/";
5500     int r;
5501     suppress_error = 0;
5502     r = guestfs_mount (g, device, mountpoint);
5503     if (r == -1)
5504       return -1;
5505   }
5506   /* TestOutput for set_e2uuid (0) */
5507   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5508   {
5509     char device[] = "/dev/sda1";
5510     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5511     int r;
5512     suppress_error = 0;
5513     r = guestfs_set_e2uuid (g, device, uuid);
5514     if (r == -1)
5515       return -1;
5516   }
5517   {
5518     char device[] = "/dev/sda1";
5519     char *r;
5520     suppress_error = 0;
5521     r = guestfs_get_e2uuid (g, device);
5522     if (r == NULL)
5523       return -1;
5524     if (strcmp (r, expected) != 0) {
5525       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5526       return -1;
5527     }
5528     free (r);
5529   }
5530   return 0;
5531 }
5532
5533 static int test_set_e2uuid_1_skip (void)
5534 {
5535   const char *str;
5536
5537   str = getenv ("TEST_ONLY");
5538   if (str)
5539     return strstr (str, "set_e2uuid") == NULL;
5540   str = getenv ("SKIP_TEST_SET_E2UUID_1");
5541   if (str && strcmp (str, "1") == 0) return 1;
5542   str = getenv ("SKIP_TEST_SET_E2UUID");
5543   if (str && strcmp (str, "1") == 0) return 1;
5544   return 0;
5545 }
5546
5547 static int test_set_e2uuid_1 (void)
5548 {
5549   if (test_set_e2uuid_1_skip ()) {
5550     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
5551     return 0;
5552   }
5553
5554   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
5555   {
5556     char device[] = "/dev/sda";
5557     int r;
5558     suppress_error = 0;
5559     r = guestfs_blockdev_setrw (g, device);
5560     if (r == -1)
5561       return -1;
5562   }
5563   {
5564     int r;
5565     suppress_error = 0;
5566     r = guestfs_umount_all (g);
5567     if (r == -1)
5568       return -1;
5569   }
5570   {
5571     int r;
5572     suppress_error = 0;
5573     r = guestfs_lvm_remove_all (g);
5574     if (r == -1)
5575       return -1;
5576   }
5577   {
5578     char device[] = "/dev/sda";
5579     char lines_0[] = ",";
5580     char *lines[] = {
5581       lines_0,
5582       NULL
5583     };
5584     int r;
5585     suppress_error = 0;
5586     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5587     if (r == -1)
5588       return -1;
5589   }
5590   {
5591     char fstype[] = "ext2";
5592     char device[] = "/dev/sda1";
5593     int r;
5594     suppress_error = 0;
5595     r = guestfs_mkfs (g, fstype, device);
5596     if (r == -1)
5597       return -1;
5598   }
5599   {
5600     char device[] = "/dev/sda1";
5601     char mountpoint[] = "/";
5602     int r;
5603     suppress_error = 0;
5604     r = guestfs_mount (g, device, mountpoint);
5605     if (r == -1)
5606       return -1;
5607   }
5608   /* TestOutput for set_e2uuid (1) */
5609   char expected[] = "";
5610   {
5611     char device[] = "/dev/sda1";
5612     char uuid[] = "clear";
5613     int r;
5614     suppress_error = 0;
5615     r = guestfs_set_e2uuid (g, device, uuid);
5616     if (r == -1)
5617       return -1;
5618   }
5619   {
5620     char device[] = "/dev/sda1";
5621     char *r;
5622     suppress_error = 0;
5623     r = guestfs_get_e2uuid (g, device);
5624     if (r == NULL)
5625       return -1;
5626     if (strcmp (r, expected) != 0) {
5627       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
5628       return -1;
5629     }
5630     free (r);
5631   }
5632   return 0;
5633 }
5634
5635 static int test_set_e2uuid_2_skip (void)
5636 {
5637   const char *str;
5638
5639   str = getenv ("TEST_ONLY");
5640   if (str)
5641     return strstr (str, "set_e2uuid") == NULL;
5642   str = getenv ("SKIP_TEST_SET_E2UUID_2");
5643   if (str && strcmp (str, "1") == 0) return 1;
5644   str = getenv ("SKIP_TEST_SET_E2UUID");
5645   if (str && strcmp (str, "1") == 0) return 1;
5646   return 0;
5647 }
5648
5649 static int test_set_e2uuid_2 (void)
5650 {
5651   if (test_set_e2uuid_2_skip ()) {
5652     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
5653     return 0;
5654   }
5655
5656   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
5657   {
5658     char device[] = "/dev/sda";
5659     int r;
5660     suppress_error = 0;
5661     r = guestfs_blockdev_setrw (g, device);
5662     if (r == -1)
5663       return -1;
5664   }
5665   {
5666     int r;
5667     suppress_error = 0;
5668     r = guestfs_umount_all (g);
5669     if (r == -1)
5670       return -1;
5671   }
5672   {
5673     int r;
5674     suppress_error = 0;
5675     r = guestfs_lvm_remove_all (g);
5676     if (r == -1)
5677       return -1;
5678   }
5679   {
5680     char device[] = "/dev/sda";
5681     char lines_0[] = ",";
5682     char *lines[] = {
5683       lines_0,
5684       NULL
5685     };
5686     int r;
5687     suppress_error = 0;
5688     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5689     if (r == -1)
5690       return -1;
5691   }
5692   {
5693     char fstype[] = "ext2";
5694     char device[] = "/dev/sda1";
5695     int r;
5696     suppress_error = 0;
5697     r = guestfs_mkfs (g, fstype, device);
5698     if (r == -1)
5699       return -1;
5700   }
5701   {
5702     char device[] = "/dev/sda1";
5703     char mountpoint[] = "/";
5704     int r;
5705     suppress_error = 0;
5706     r = guestfs_mount (g, device, mountpoint);
5707     if (r == -1)
5708       return -1;
5709   }
5710   /* TestRun for set_e2uuid (2) */
5711   {
5712     char device[] = "/dev/sda1";
5713     char uuid[] = "random";
5714     int r;
5715     suppress_error = 0;
5716     r = guestfs_set_e2uuid (g, device, uuid);
5717     if (r == -1)
5718       return -1;
5719   }
5720   return 0;
5721 }
5722
5723 static int test_set_e2uuid_3_skip (void)
5724 {
5725   const char *str;
5726
5727   str = getenv ("TEST_ONLY");
5728   if (str)
5729     return strstr (str, "set_e2uuid") == NULL;
5730   str = getenv ("SKIP_TEST_SET_E2UUID_3");
5731   if (str && strcmp (str, "1") == 0) return 1;
5732   str = getenv ("SKIP_TEST_SET_E2UUID");
5733   if (str && strcmp (str, "1") == 0) return 1;
5734   return 0;
5735 }
5736
5737 static int test_set_e2uuid_3 (void)
5738 {
5739   if (test_set_e2uuid_3_skip ()) {
5740     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
5741     return 0;
5742   }
5743
5744   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
5745   {
5746     char device[] = "/dev/sda";
5747     int r;
5748     suppress_error = 0;
5749     r = guestfs_blockdev_setrw (g, device);
5750     if (r == -1)
5751       return -1;
5752   }
5753   {
5754     int r;
5755     suppress_error = 0;
5756     r = guestfs_umount_all (g);
5757     if (r == -1)
5758       return -1;
5759   }
5760   {
5761     int r;
5762     suppress_error = 0;
5763     r = guestfs_lvm_remove_all (g);
5764     if (r == -1)
5765       return -1;
5766   }
5767   {
5768     char device[] = "/dev/sda";
5769     char lines_0[] = ",";
5770     char *lines[] = {
5771       lines_0,
5772       NULL
5773     };
5774     int r;
5775     suppress_error = 0;
5776     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5777     if (r == -1)
5778       return -1;
5779   }
5780   {
5781     char fstype[] = "ext2";
5782     char device[] = "/dev/sda1";
5783     int r;
5784     suppress_error = 0;
5785     r = guestfs_mkfs (g, fstype, device);
5786     if (r == -1)
5787       return -1;
5788   }
5789   {
5790     char device[] = "/dev/sda1";
5791     char mountpoint[] = "/";
5792     int r;
5793     suppress_error = 0;
5794     r = guestfs_mount (g, device, mountpoint);
5795     if (r == -1)
5796       return -1;
5797   }
5798   /* TestRun for set_e2uuid (3) */
5799   {
5800     char device[] = "/dev/sda1";
5801     char uuid[] = "time";
5802     int r;
5803     suppress_error = 0;
5804     r = guestfs_set_e2uuid (g, device, uuid);
5805     if (r == -1)
5806       return -1;
5807   }
5808   return 0;
5809 }
5810
5811 static int test_set_e2label_0_skip (void)
5812 {
5813   const char *str;
5814
5815   str = getenv ("TEST_ONLY");
5816   if (str)
5817     return strstr (str, "set_e2label") == NULL;
5818   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
5819   if (str && strcmp (str, "1") == 0) return 1;
5820   str = getenv ("SKIP_TEST_SET_E2LABEL");
5821   if (str && strcmp (str, "1") == 0) return 1;
5822   return 0;
5823 }
5824
5825 static int test_set_e2label_0 (void)
5826 {
5827   if (test_set_e2label_0_skip ()) {
5828     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
5829     return 0;
5830   }
5831
5832   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
5833   {
5834     char device[] = "/dev/sda";
5835     int r;
5836     suppress_error = 0;
5837     r = guestfs_blockdev_setrw (g, device);
5838     if (r == -1)
5839       return -1;
5840   }
5841   {
5842     int r;
5843     suppress_error = 0;
5844     r = guestfs_umount_all (g);
5845     if (r == -1)
5846       return -1;
5847   }
5848   {
5849     int r;
5850     suppress_error = 0;
5851     r = guestfs_lvm_remove_all (g);
5852     if (r == -1)
5853       return -1;
5854   }
5855   {
5856     char device[] = "/dev/sda";
5857     char lines_0[] = ",";
5858     char *lines[] = {
5859       lines_0,
5860       NULL
5861     };
5862     int r;
5863     suppress_error = 0;
5864     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5865     if (r == -1)
5866       return -1;
5867   }
5868   {
5869     char fstype[] = "ext2";
5870     char device[] = "/dev/sda1";
5871     int r;
5872     suppress_error = 0;
5873     r = guestfs_mkfs (g, fstype, device);
5874     if (r == -1)
5875       return -1;
5876   }
5877   {
5878     char device[] = "/dev/sda1";
5879     char mountpoint[] = "/";
5880     int r;
5881     suppress_error = 0;
5882     r = guestfs_mount (g, device, mountpoint);
5883     if (r == -1)
5884       return -1;
5885   }
5886   /* TestOutput for set_e2label (0) */
5887   char expected[] = "testlabel";
5888   {
5889     char device[] = "/dev/sda1";
5890     char label[] = "testlabel";
5891     int r;
5892     suppress_error = 0;
5893     r = guestfs_set_e2label (g, device, label);
5894     if (r == -1)
5895       return -1;
5896   }
5897   {
5898     char device[] = "/dev/sda1";
5899     char *r;
5900     suppress_error = 0;
5901     r = guestfs_get_e2label (g, device);
5902     if (r == NULL)
5903       return -1;
5904     if (strcmp (r, expected) != 0) {
5905       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
5906       return -1;
5907     }
5908     free (r);
5909   }
5910   return 0;
5911 }
5912
5913 static int test_pvremove_0_skip (void)
5914 {
5915   const char *str;
5916
5917   str = getenv ("TEST_ONLY");
5918   if (str)
5919     return strstr (str, "pvremove") == NULL;
5920   str = getenv ("SKIP_TEST_PVREMOVE_0");
5921   if (str && strcmp (str, "1") == 0) return 1;
5922   str = getenv ("SKIP_TEST_PVREMOVE");
5923   if (str && strcmp (str, "1") == 0) return 1;
5924   return 0;
5925 }
5926
5927 static int test_pvremove_0 (void)
5928 {
5929   if (test_pvremove_0_skip ()) {
5930     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
5931     return 0;
5932   }
5933
5934   /* InitNone|InitEmpty for test_pvremove_0 */
5935   {
5936     char device[] = "/dev/sda";
5937     int r;
5938     suppress_error = 0;
5939     r = guestfs_blockdev_setrw (g, device);
5940     if (r == -1)
5941       return -1;
5942   }
5943   {
5944     int r;
5945     suppress_error = 0;
5946     r = guestfs_umount_all (g);
5947     if (r == -1)
5948       return -1;
5949   }
5950   {
5951     int r;
5952     suppress_error = 0;
5953     r = guestfs_lvm_remove_all (g);
5954     if (r == -1)
5955       return -1;
5956   }
5957   /* TestOutputListOfDevices for pvremove (0) */
5958   {
5959     char device[] = "/dev/sda";
5960     char lines_0[] = ",";
5961     char *lines[] = {
5962       lines_0,
5963       NULL
5964     };
5965     int r;
5966     suppress_error = 0;
5967     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5968     if (r == -1)
5969       return -1;
5970   }
5971   {
5972     char device[] = "/dev/sda1";
5973     int r;
5974     suppress_error = 0;
5975     r = guestfs_pvcreate (g, device);
5976     if (r == -1)
5977       return -1;
5978   }
5979   {
5980     char volgroup[] = "VG";
5981     char physvols_0[] = "/dev/sda1";
5982     char *physvols[] = {
5983       physvols_0,
5984       NULL
5985     };
5986     int r;
5987     suppress_error = 0;
5988     r = guestfs_vgcreate (g, volgroup, physvols);
5989     if (r == -1)
5990       return -1;
5991   }
5992   {
5993     char logvol[] = "LV1";
5994     char volgroup[] = "VG";
5995     int r;
5996     suppress_error = 0;
5997     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5998     if (r == -1)
5999       return -1;
6000   }
6001   {
6002     char logvol[] = "LV2";
6003     char volgroup[] = "VG";
6004     int r;
6005     suppress_error = 0;
6006     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6007     if (r == -1)
6008       return -1;
6009   }
6010   {
6011     char vgname[] = "VG";
6012     int r;
6013     suppress_error = 0;
6014     r = guestfs_vgremove (g, vgname);
6015     if (r == -1)
6016       return -1;
6017   }
6018   {
6019     char device[] = "/dev/sda1";
6020     int r;
6021     suppress_error = 0;
6022     r = guestfs_pvremove (g, device);
6023     if (r == -1)
6024       return -1;
6025   }
6026   {
6027     char **r;
6028     int i;
6029     suppress_error = 0;
6030     r = guestfs_lvs (g);
6031     if (r == NULL)
6032       return -1;
6033     if (r[0] != NULL) {
6034       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6035       print_strings (r);
6036       return -1;
6037     }
6038     for (i = 0; r[i] != NULL; ++i)
6039       free (r[i]);
6040     free (r);
6041   }
6042   return 0;
6043 }
6044
6045 static int test_pvremove_1_skip (void)
6046 {
6047   const char *str;
6048
6049   str = getenv ("TEST_ONLY");
6050   if (str)
6051     return strstr (str, "pvremove") == NULL;
6052   str = getenv ("SKIP_TEST_PVREMOVE_1");
6053   if (str && strcmp (str, "1") == 0) return 1;
6054   str = getenv ("SKIP_TEST_PVREMOVE");
6055   if (str && strcmp (str, "1") == 0) return 1;
6056   return 0;
6057 }
6058
6059 static int test_pvremove_1 (void)
6060 {
6061   if (test_pvremove_1_skip ()) {
6062     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6063     return 0;
6064   }
6065
6066   /* InitNone|InitEmpty for test_pvremove_1 */
6067   {
6068     char device[] = "/dev/sda";
6069     int r;
6070     suppress_error = 0;
6071     r = guestfs_blockdev_setrw (g, device);
6072     if (r == -1)
6073       return -1;
6074   }
6075   {
6076     int r;
6077     suppress_error = 0;
6078     r = guestfs_umount_all (g);
6079     if (r == -1)
6080       return -1;
6081   }
6082   {
6083     int r;
6084     suppress_error = 0;
6085     r = guestfs_lvm_remove_all (g);
6086     if (r == -1)
6087       return -1;
6088   }
6089   /* TestOutputListOfDevices for pvremove (1) */
6090   {
6091     char device[] = "/dev/sda";
6092     char lines_0[] = ",";
6093     char *lines[] = {
6094       lines_0,
6095       NULL
6096     };
6097     int r;
6098     suppress_error = 0;
6099     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6100     if (r == -1)
6101       return -1;
6102   }
6103   {
6104     char device[] = "/dev/sda1";
6105     int r;
6106     suppress_error = 0;
6107     r = guestfs_pvcreate (g, device);
6108     if (r == -1)
6109       return -1;
6110   }
6111   {
6112     char volgroup[] = "VG";
6113     char physvols_0[] = "/dev/sda1";
6114     char *physvols[] = {
6115       physvols_0,
6116       NULL
6117     };
6118     int r;
6119     suppress_error = 0;
6120     r = guestfs_vgcreate (g, volgroup, physvols);
6121     if (r == -1)
6122       return -1;
6123   }
6124   {
6125     char logvol[] = "LV1";
6126     char volgroup[] = "VG";
6127     int r;
6128     suppress_error = 0;
6129     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6130     if (r == -1)
6131       return -1;
6132   }
6133   {
6134     char logvol[] = "LV2";
6135     char volgroup[] = "VG";
6136     int r;
6137     suppress_error = 0;
6138     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6139     if (r == -1)
6140       return -1;
6141   }
6142   {
6143     char vgname[] = "VG";
6144     int r;
6145     suppress_error = 0;
6146     r = guestfs_vgremove (g, vgname);
6147     if (r == -1)
6148       return -1;
6149   }
6150   {
6151     char device[] = "/dev/sda1";
6152     int r;
6153     suppress_error = 0;
6154     r = guestfs_pvremove (g, device);
6155     if (r == -1)
6156       return -1;
6157   }
6158   {
6159     char **r;
6160     int i;
6161     suppress_error = 0;
6162     r = guestfs_vgs (g);
6163     if (r == NULL)
6164       return -1;
6165     if (r[0] != NULL) {
6166       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6167       print_strings (r);
6168       return -1;
6169     }
6170     for (i = 0; r[i] != NULL; ++i)
6171       free (r[i]);
6172     free (r);
6173   }
6174   return 0;
6175 }
6176
6177 static int test_pvremove_2_skip (void)
6178 {
6179   const char *str;
6180
6181   str = getenv ("TEST_ONLY");
6182   if (str)
6183     return strstr (str, "pvremove") == NULL;
6184   str = getenv ("SKIP_TEST_PVREMOVE_2");
6185   if (str && strcmp (str, "1") == 0) return 1;
6186   str = getenv ("SKIP_TEST_PVREMOVE");
6187   if (str && strcmp (str, "1") == 0) return 1;
6188   return 0;
6189 }
6190
6191 static int test_pvremove_2 (void)
6192 {
6193   if (test_pvremove_2_skip ()) {
6194     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6195     return 0;
6196   }
6197
6198   /* InitNone|InitEmpty for test_pvremove_2 */
6199   {
6200     char device[] = "/dev/sda";
6201     int r;
6202     suppress_error = 0;
6203     r = guestfs_blockdev_setrw (g, device);
6204     if (r == -1)
6205       return -1;
6206   }
6207   {
6208     int r;
6209     suppress_error = 0;
6210     r = guestfs_umount_all (g);
6211     if (r == -1)
6212       return -1;
6213   }
6214   {
6215     int r;
6216     suppress_error = 0;
6217     r = guestfs_lvm_remove_all (g);
6218     if (r == -1)
6219       return -1;
6220   }
6221   /* TestOutputListOfDevices for pvremove (2) */
6222   {
6223     char device[] = "/dev/sda";
6224     char lines_0[] = ",";
6225     char *lines[] = {
6226       lines_0,
6227       NULL
6228     };
6229     int r;
6230     suppress_error = 0;
6231     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6232     if (r == -1)
6233       return -1;
6234   }
6235   {
6236     char device[] = "/dev/sda1";
6237     int r;
6238     suppress_error = 0;
6239     r = guestfs_pvcreate (g, device);
6240     if (r == -1)
6241       return -1;
6242   }
6243   {
6244     char volgroup[] = "VG";
6245     char physvols_0[] = "/dev/sda1";
6246     char *physvols[] = {
6247       physvols_0,
6248       NULL
6249     };
6250     int r;
6251     suppress_error = 0;
6252     r = guestfs_vgcreate (g, volgroup, physvols);
6253     if (r == -1)
6254       return -1;
6255   }
6256   {
6257     char logvol[] = "LV1";
6258     char volgroup[] = "VG";
6259     int r;
6260     suppress_error = 0;
6261     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6262     if (r == -1)
6263       return -1;
6264   }
6265   {
6266     char logvol[] = "LV2";
6267     char volgroup[] = "VG";
6268     int r;
6269     suppress_error = 0;
6270     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6271     if (r == -1)
6272       return -1;
6273   }
6274   {
6275     char vgname[] = "VG";
6276     int r;
6277     suppress_error = 0;
6278     r = guestfs_vgremove (g, vgname);
6279     if (r == -1)
6280       return -1;
6281   }
6282   {
6283     char device[] = "/dev/sda1";
6284     int r;
6285     suppress_error = 0;
6286     r = guestfs_pvremove (g, device);
6287     if (r == -1)
6288       return -1;
6289   }
6290   {
6291     char **r;
6292     int i;
6293     suppress_error = 0;
6294     r = guestfs_pvs (g);
6295     if (r == NULL)
6296       return -1;
6297     if (r[0] != NULL) {
6298       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6299       print_strings (r);
6300       return -1;
6301     }
6302     for (i = 0; r[i] != NULL; ++i)
6303       free (r[i]);
6304     free (r);
6305   }
6306   return 0;
6307 }
6308
6309 static int test_vgremove_0_skip (void)
6310 {
6311   const char *str;
6312
6313   str = getenv ("TEST_ONLY");
6314   if (str)
6315     return strstr (str, "vgremove") == NULL;
6316   str = getenv ("SKIP_TEST_VGREMOVE_0");
6317   if (str && strcmp (str, "1") == 0) return 1;
6318   str = getenv ("SKIP_TEST_VGREMOVE");
6319   if (str && strcmp (str, "1") == 0) return 1;
6320   return 0;
6321 }
6322
6323 static int test_vgremove_0 (void)
6324 {
6325   if (test_vgremove_0_skip ()) {
6326     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6327     return 0;
6328   }
6329
6330   /* InitNone|InitEmpty for test_vgremove_0 */
6331   {
6332     char device[] = "/dev/sda";
6333     int r;
6334     suppress_error = 0;
6335     r = guestfs_blockdev_setrw (g, device);
6336     if (r == -1)
6337       return -1;
6338   }
6339   {
6340     int r;
6341     suppress_error = 0;
6342     r = guestfs_umount_all (g);
6343     if (r == -1)
6344       return -1;
6345   }
6346   {
6347     int r;
6348     suppress_error = 0;
6349     r = guestfs_lvm_remove_all (g);
6350     if (r == -1)
6351       return -1;
6352   }
6353   /* TestOutputList for vgremove (0) */
6354   {
6355     char device[] = "/dev/sda";
6356     char lines_0[] = ",";
6357     char *lines[] = {
6358       lines_0,
6359       NULL
6360     };
6361     int r;
6362     suppress_error = 0;
6363     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6364     if (r == -1)
6365       return -1;
6366   }
6367   {
6368     char device[] = "/dev/sda1";
6369     int r;
6370     suppress_error = 0;
6371     r = guestfs_pvcreate (g, device);
6372     if (r == -1)
6373       return -1;
6374   }
6375   {
6376     char volgroup[] = "VG";
6377     char physvols_0[] = "/dev/sda1";
6378     char *physvols[] = {
6379       physvols_0,
6380       NULL
6381     };
6382     int r;
6383     suppress_error = 0;
6384     r = guestfs_vgcreate (g, volgroup, physvols);
6385     if (r == -1)
6386       return -1;
6387   }
6388   {
6389     char logvol[] = "LV1";
6390     char volgroup[] = "VG";
6391     int r;
6392     suppress_error = 0;
6393     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6394     if (r == -1)
6395       return -1;
6396   }
6397   {
6398     char logvol[] = "LV2";
6399     char volgroup[] = "VG";
6400     int r;
6401     suppress_error = 0;
6402     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6403     if (r == -1)
6404       return -1;
6405   }
6406   {
6407     char vgname[] = "VG";
6408     int r;
6409     suppress_error = 0;
6410     r = guestfs_vgremove (g, vgname);
6411     if (r == -1)
6412       return -1;
6413   }
6414   {
6415     char **r;
6416     int i;
6417     suppress_error = 0;
6418     r = guestfs_lvs (g);
6419     if (r == NULL)
6420       return -1;
6421     if (r[0] != NULL) {
6422       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6423       print_strings (r);
6424       return -1;
6425     }
6426     for (i = 0; r[i] != NULL; ++i)
6427       free (r[i]);
6428     free (r);
6429   }
6430   return 0;
6431 }
6432
6433 static int test_vgremove_1_skip (void)
6434 {
6435   const char *str;
6436
6437   str = getenv ("TEST_ONLY");
6438   if (str)
6439     return strstr (str, "vgremove") == NULL;
6440   str = getenv ("SKIP_TEST_VGREMOVE_1");
6441   if (str && strcmp (str, "1") == 0) return 1;
6442   str = getenv ("SKIP_TEST_VGREMOVE");
6443   if (str && strcmp (str, "1") == 0) return 1;
6444   return 0;
6445 }
6446
6447 static int test_vgremove_1 (void)
6448 {
6449   if (test_vgremove_1_skip ()) {
6450     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6451     return 0;
6452   }
6453
6454   /* InitNone|InitEmpty for test_vgremove_1 */
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   /* TestOutputList for vgremove (1) */
6478   {
6479     char device[] = "/dev/sda";
6480     char lines_0[] = ",";
6481     char *lines[] = {
6482       lines_0,
6483       NULL
6484     };
6485     int r;
6486     suppress_error = 0;
6487     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6488     if (r == -1)
6489       return -1;
6490   }
6491   {
6492     char device[] = "/dev/sda1";
6493     int r;
6494     suppress_error = 0;
6495     r = guestfs_pvcreate (g, device);
6496     if (r == -1)
6497       return -1;
6498   }
6499   {
6500     char volgroup[] = "VG";
6501     char physvols_0[] = "/dev/sda1";
6502     char *physvols[] = {
6503       physvols_0,
6504       NULL
6505     };
6506     int r;
6507     suppress_error = 0;
6508     r = guestfs_vgcreate (g, volgroup, physvols);
6509     if (r == -1)
6510       return -1;
6511   }
6512   {
6513     char logvol[] = "LV1";
6514     char volgroup[] = "VG";
6515     int r;
6516     suppress_error = 0;
6517     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6518     if (r == -1)
6519       return -1;
6520   }
6521   {
6522     char logvol[] = "LV2";
6523     char volgroup[] = "VG";
6524     int r;
6525     suppress_error = 0;
6526     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6527     if (r == -1)
6528       return -1;
6529   }
6530   {
6531     char vgname[] = "VG";
6532     int r;
6533     suppress_error = 0;
6534     r = guestfs_vgremove (g, vgname);
6535     if (r == -1)
6536       return -1;
6537   }
6538   {
6539     char **r;
6540     int i;
6541     suppress_error = 0;
6542     r = guestfs_vgs (g);
6543     if (r == NULL)
6544       return -1;
6545     if (r[0] != NULL) {
6546       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
6547       print_strings (r);
6548       return -1;
6549     }
6550     for (i = 0; r[i] != NULL; ++i)
6551       free (r[i]);
6552     free (r);
6553   }
6554   return 0;
6555 }
6556
6557 static int test_lvremove_0_skip (void)
6558 {
6559   const char *str;
6560
6561   str = getenv ("TEST_ONLY");
6562   if (str)
6563     return strstr (str, "lvremove") == NULL;
6564   str = getenv ("SKIP_TEST_LVREMOVE_0");
6565   if (str && strcmp (str, "1") == 0) return 1;
6566   str = getenv ("SKIP_TEST_LVREMOVE");
6567   if (str && strcmp (str, "1") == 0) return 1;
6568   return 0;
6569 }
6570
6571 static int test_lvremove_0 (void)
6572 {
6573   if (test_lvremove_0_skip ()) {
6574     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
6575     return 0;
6576   }
6577
6578   /* InitNone|InitEmpty for test_lvremove_0 */
6579   {
6580     char device[] = "/dev/sda";
6581     int r;
6582     suppress_error = 0;
6583     r = guestfs_blockdev_setrw (g, device);
6584     if (r == -1)
6585       return -1;
6586   }
6587   {
6588     int r;
6589     suppress_error = 0;
6590     r = guestfs_umount_all (g);
6591     if (r == -1)
6592       return -1;
6593   }
6594   {
6595     int r;
6596     suppress_error = 0;
6597     r = guestfs_lvm_remove_all (g);
6598     if (r == -1)
6599       return -1;
6600   }
6601   /* TestOutputList for lvremove (0) */
6602   {
6603     char device[] = "/dev/sda";
6604     char lines_0[] = ",";
6605     char *lines[] = {
6606       lines_0,
6607       NULL
6608     };
6609     int r;
6610     suppress_error = 0;
6611     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6612     if (r == -1)
6613       return -1;
6614   }
6615   {
6616     char device[] = "/dev/sda1";
6617     int r;
6618     suppress_error = 0;
6619     r = guestfs_pvcreate (g, device);
6620     if (r == -1)
6621       return -1;
6622   }
6623   {
6624     char volgroup[] = "VG";
6625     char physvols_0[] = "/dev/sda1";
6626     char *physvols[] = {
6627       physvols_0,
6628       NULL
6629     };
6630     int r;
6631     suppress_error = 0;
6632     r = guestfs_vgcreate (g, volgroup, physvols);
6633     if (r == -1)
6634       return -1;
6635   }
6636   {
6637     char logvol[] = "LV1";
6638     char volgroup[] = "VG";
6639     int r;
6640     suppress_error = 0;
6641     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6642     if (r == -1)
6643       return -1;
6644   }
6645   {
6646     char logvol[] = "LV2";
6647     char volgroup[] = "VG";
6648     int r;
6649     suppress_error = 0;
6650     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6651     if (r == -1)
6652       return -1;
6653   }
6654   {
6655     char device[] = "/dev/VG/LV1";
6656     int r;
6657     suppress_error = 0;
6658     r = guestfs_lvremove (g, device);
6659     if (r == -1)
6660       return -1;
6661   }
6662   {
6663     char **r;
6664     int i;
6665     suppress_error = 0;
6666     r = guestfs_lvs (g);
6667     if (r == NULL)
6668       return -1;
6669     if (!r[0]) {
6670       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
6671       print_strings (r);
6672       return -1;
6673     }
6674     {
6675       char expected[] = "/dev/VG/LV2";
6676       if (strcmp (r[0], expected) != 0) {
6677         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6678         return -1;
6679       }
6680     }
6681     if (r[1] != NULL) {
6682       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
6683       print_strings (r);
6684       return -1;
6685     }
6686     for (i = 0; r[i] != NULL; ++i)
6687       free (r[i]);
6688     free (r);
6689   }
6690   return 0;
6691 }
6692
6693 static int test_lvremove_1_skip (void)
6694 {
6695   const char *str;
6696
6697   str = getenv ("TEST_ONLY");
6698   if (str)
6699     return strstr (str, "lvremove") == NULL;
6700   str = getenv ("SKIP_TEST_LVREMOVE_1");
6701   if (str && strcmp (str, "1") == 0) return 1;
6702   str = getenv ("SKIP_TEST_LVREMOVE");
6703   if (str && strcmp (str, "1") == 0) return 1;
6704   return 0;
6705 }
6706
6707 static int test_lvremove_1 (void)
6708 {
6709   if (test_lvremove_1_skip ()) {
6710     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
6711     return 0;
6712   }
6713
6714   /* InitNone|InitEmpty for test_lvremove_1 */
6715   {
6716     char device[] = "/dev/sda";
6717     int r;
6718     suppress_error = 0;
6719     r = guestfs_blockdev_setrw (g, device);
6720     if (r == -1)
6721       return -1;
6722   }
6723   {
6724     int r;
6725     suppress_error = 0;
6726     r = guestfs_umount_all (g);
6727     if (r == -1)
6728       return -1;
6729   }
6730   {
6731     int r;
6732     suppress_error = 0;
6733     r = guestfs_lvm_remove_all (g);
6734     if (r == -1)
6735       return -1;
6736   }
6737   /* TestOutputList for lvremove (1) */
6738   {
6739     char device[] = "/dev/sda";
6740     char lines_0[] = ",";
6741     char *lines[] = {
6742       lines_0,
6743       NULL
6744     };
6745     int r;
6746     suppress_error = 0;
6747     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6748     if (r == -1)
6749       return -1;
6750   }
6751   {
6752     char device[] = "/dev/sda1";
6753     int r;
6754     suppress_error = 0;
6755     r = guestfs_pvcreate (g, device);
6756     if (r == -1)
6757       return -1;
6758   }
6759   {
6760     char volgroup[] = "VG";
6761     char physvols_0[] = "/dev/sda1";
6762     char *physvols[] = {
6763       physvols_0,
6764       NULL
6765     };
6766     int r;
6767     suppress_error = 0;
6768     r = guestfs_vgcreate (g, volgroup, physvols);
6769     if (r == -1)
6770       return -1;
6771   }
6772   {
6773     char logvol[] = "LV1";
6774     char volgroup[] = "VG";
6775     int r;
6776     suppress_error = 0;
6777     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6778     if (r == -1)
6779       return -1;
6780   }
6781   {
6782     char logvol[] = "LV2";
6783     char volgroup[] = "VG";
6784     int r;
6785     suppress_error = 0;
6786     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6787     if (r == -1)
6788       return -1;
6789   }
6790   {
6791     char device[] = "/dev/VG";
6792     int r;
6793     suppress_error = 0;
6794     r = guestfs_lvremove (g, device);
6795     if (r == -1)
6796       return -1;
6797   }
6798   {
6799     char **r;
6800     int i;
6801     suppress_error = 0;
6802     r = guestfs_lvs (g);
6803     if (r == NULL)
6804       return -1;
6805     if (r[0] != NULL) {
6806       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
6807       print_strings (r);
6808       return -1;
6809     }
6810     for (i = 0; r[i] != NULL; ++i)
6811       free (r[i]);
6812     free (r);
6813   }
6814   return 0;
6815 }
6816
6817 static int test_lvremove_2_skip (void)
6818 {
6819   const char *str;
6820
6821   str = getenv ("TEST_ONLY");
6822   if (str)
6823     return strstr (str, "lvremove") == NULL;
6824   str = getenv ("SKIP_TEST_LVREMOVE_2");
6825   if (str && strcmp (str, "1") == 0) return 1;
6826   str = getenv ("SKIP_TEST_LVREMOVE");
6827   if (str && strcmp (str, "1") == 0) return 1;
6828   return 0;
6829 }
6830
6831 static int test_lvremove_2 (void)
6832 {
6833   if (test_lvremove_2_skip ()) {
6834     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
6835     return 0;
6836   }
6837
6838   /* InitNone|InitEmpty for test_lvremove_2 */
6839   {
6840     char device[] = "/dev/sda";
6841     int r;
6842     suppress_error = 0;
6843     r = guestfs_blockdev_setrw (g, device);
6844     if (r == -1)
6845       return -1;
6846   }
6847   {
6848     int r;
6849     suppress_error = 0;
6850     r = guestfs_umount_all (g);
6851     if (r == -1)
6852       return -1;
6853   }
6854   {
6855     int r;
6856     suppress_error = 0;
6857     r = guestfs_lvm_remove_all (g);
6858     if (r == -1)
6859       return -1;
6860   }
6861   /* TestOutputList for lvremove (2) */
6862   {
6863     char device[] = "/dev/sda";
6864     char lines_0[] = ",";
6865     char *lines[] = {
6866       lines_0,
6867       NULL
6868     };
6869     int r;
6870     suppress_error = 0;
6871     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6872     if (r == -1)
6873       return -1;
6874   }
6875   {
6876     char device[] = "/dev/sda1";
6877     int r;
6878     suppress_error = 0;
6879     r = guestfs_pvcreate (g, device);
6880     if (r == -1)
6881       return -1;
6882   }
6883   {
6884     char volgroup[] = "VG";
6885     char physvols_0[] = "/dev/sda1";
6886     char *physvols[] = {
6887       physvols_0,
6888       NULL
6889     };
6890     int r;
6891     suppress_error = 0;
6892     r = guestfs_vgcreate (g, volgroup, physvols);
6893     if (r == -1)
6894       return -1;
6895   }
6896   {
6897     char logvol[] = "LV1";
6898     char volgroup[] = "VG";
6899     int r;
6900     suppress_error = 0;
6901     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6902     if (r == -1)
6903       return -1;
6904   }
6905   {
6906     char logvol[] = "LV2";
6907     char volgroup[] = "VG";
6908     int r;
6909     suppress_error = 0;
6910     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6911     if (r == -1)
6912       return -1;
6913   }
6914   {
6915     char device[] = "/dev/VG";
6916     int r;
6917     suppress_error = 0;
6918     r = guestfs_lvremove (g, device);
6919     if (r == -1)
6920       return -1;
6921   }
6922   {
6923     char **r;
6924     int i;
6925     suppress_error = 0;
6926     r = guestfs_vgs (g);
6927     if (r == NULL)
6928       return -1;
6929     if (!r[0]) {
6930       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
6931       print_strings (r);
6932       return -1;
6933     }
6934     {
6935       char expected[] = "VG";
6936       if (strcmp (r[0], expected) != 0) {
6937         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6938         return -1;
6939       }
6940     }
6941     if (r[1] != NULL) {
6942       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
6943       print_strings (r);
6944       return -1;
6945     }
6946     for (i = 0; r[i] != NULL; ++i)
6947       free (r[i]);
6948     free (r);
6949   }
6950   return 0;
6951 }
6952
6953 static int test_mount_ro_0_skip (void)
6954 {
6955   const char *str;
6956
6957   str = getenv ("TEST_ONLY");
6958   if (str)
6959     return strstr (str, "mount_ro") == NULL;
6960   str = getenv ("SKIP_TEST_MOUNT_RO_0");
6961   if (str && strcmp (str, "1") == 0) return 1;
6962   str = getenv ("SKIP_TEST_MOUNT_RO");
6963   if (str && strcmp (str, "1") == 0) return 1;
6964   return 0;
6965 }
6966
6967 static int test_mount_ro_0 (void)
6968 {
6969   if (test_mount_ro_0_skip ()) {
6970     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
6971     return 0;
6972   }
6973
6974   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
6975   {
6976     char device[] = "/dev/sda";
6977     int r;
6978     suppress_error = 0;
6979     r = guestfs_blockdev_setrw (g, device);
6980     if (r == -1)
6981       return -1;
6982   }
6983   {
6984     int r;
6985     suppress_error = 0;
6986     r = guestfs_umount_all (g);
6987     if (r == -1)
6988       return -1;
6989   }
6990   {
6991     int r;
6992     suppress_error = 0;
6993     r = guestfs_lvm_remove_all (g);
6994     if (r == -1)
6995       return -1;
6996   }
6997   {
6998     char device[] = "/dev/sda";
6999     char lines_0[] = ",";
7000     char *lines[] = {
7001       lines_0,
7002       NULL
7003     };
7004     int r;
7005     suppress_error = 0;
7006     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7007     if (r == -1)
7008       return -1;
7009   }
7010   {
7011     char fstype[] = "ext2";
7012     char device[] = "/dev/sda1";
7013     int r;
7014     suppress_error = 0;
7015     r = guestfs_mkfs (g, fstype, device);
7016     if (r == -1)
7017       return -1;
7018   }
7019   {
7020     char device[] = "/dev/sda1";
7021     char mountpoint[] = "/";
7022     int r;
7023     suppress_error = 0;
7024     r = guestfs_mount (g, device, mountpoint);
7025     if (r == -1)
7026       return -1;
7027   }
7028   /* TestLastFail for mount_ro (0) */
7029   {
7030     char pathordevice[] = "/";
7031     int r;
7032     suppress_error = 0;
7033     r = guestfs_umount (g, pathordevice);
7034     if (r == -1)
7035       return -1;
7036   }
7037   {
7038     char device[] = "/dev/sda1";
7039     char mountpoint[] = "/";
7040     int r;
7041     suppress_error = 0;
7042     r = guestfs_mount_ro (g, device, mountpoint);
7043     if (r == -1)
7044       return -1;
7045   }
7046   {
7047     char path[] = "/new";
7048     int r;
7049     suppress_error = 1;
7050     r = guestfs_touch (g, path);
7051     if (r != -1)
7052       return -1;
7053   }
7054   return 0;
7055 }
7056
7057 static int test_mount_ro_1_skip (void)
7058 {
7059   const char *str;
7060
7061   str = getenv ("TEST_ONLY");
7062   if (str)
7063     return strstr (str, "mount_ro") == NULL;
7064   str = getenv ("SKIP_TEST_MOUNT_RO_1");
7065   if (str && strcmp (str, "1") == 0) return 1;
7066   str = getenv ("SKIP_TEST_MOUNT_RO");
7067   if (str && strcmp (str, "1") == 0) return 1;
7068   return 0;
7069 }
7070
7071 static int test_mount_ro_1 (void)
7072 {
7073   if (test_mount_ro_1_skip ()) {
7074     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7075     return 0;
7076   }
7077
7078   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7079   {
7080     char device[] = "/dev/sda";
7081     int r;
7082     suppress_error = 0;
7083     r = guestfs_blockdev_setrw (g, device);
7084     if (r == -1)
7085       return -1;
7086   }
7087   {
7088     int r;
7089     suppress_error = 0;
7090     r = guestfs_umount_all (g);
7091     if (r == -1)
7092       return -1;
7093   }
7094   {
7095     int r;
7096     suppress_error = 0;
7097     r = guestfs_lvm_remove_all (g);
7098     if (r == -1)
7099       return -1;
7100   }
7101   {
7102     char device[] = "/dev/sda";
7103     char lines_0[] = ",";
7104     char *lines[] = {
7105       lines_0,
7106       NULL
7107     };
7108     int r;
7109     suppress_error = 0;
7110     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7111     if (r == -1)
7112       return -1;
7113   }
7114   {
7115     char fstype[] = "ext2";
7116     char device[] = "/dev/sda1";
7117     int r;
7118     suppress_error = 0;
7119     r = guestfs_mkfs (g, fstype, device);
7120     if (r == -1)
7121       return -1;
7122   }
7123   {
7124     char device[] = "/dev/sda1";
7125     char mountpoint[] = "/";
7126     int r;
7127     suppress_error = 0;
7128     r = guestfs_mount (g, device, mountpoint);
7129     if (r == -1)
7130       return -1;
7131   }
7132   /* TestOutput for mount_ro (1) */
7133   char expected[] = "data";
7134   {
7135     char path[] = "/new";
7136     char content[] = "data";
7137     int r;
7138     suppress_error = 0;
7139     r = guestfs_write_file (g, path, content, 0);
7140     if (r == -1)
7141       return -1;
7142   }
7143   {
7144     char pathordevice[] = "/";
7145     int r;
7146     suppress_error = 0;
7147     r = guestfs_umount (g, pathordevice);
7148     if (r == -1)
7149       return -1;
7150   }
7151   {
7152     char device[] = "/dev/sda1";
7153     char mountpoint[] = "/";
7154     int r;
7155     suppress_error = 0;
7156     r = guestfs_mount_ro (g, device, mountpoint);
7157     if (r == -1)
7158       return -1;
7159   }
7160   {
7161     char path[] = "/new";
7162     char *r;
7163     suppress_error = 0;
7164     r = guestfs_cat (g, path);
7165     if (r == NULL)
7166       return -1;
7167     if (strcmp (r, expected) != 0) {
7168       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7169       return -1;
7170     }
7171     free (r);
7172   }
7173   return 0;
7174 }
7175
7176 static int test_tgz_in_0_skip (void)
7177 {
7178   const char *str;
7179
7180   str = getenv ("TEST_ONLY");
7181   if (str)
7182     return strstr (str, "tgz_in") == NULL;
7183   str = getenv ("SKIP_TEST_TGZ_IN_0");
7184   if (str && strcmp (str, "1") == 0) return 1;
7185   str = getenv ("SKIP_TEST_TGZ_IN");
7186   if (str && strcmp (str, "1") == 0) return 1;
7187   return 0;
7188 }
7189
7190 static int test_tgz_in_0 (void)
7191 {
7192   if (test_tgz_in_0_skip ()) {
7193     printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7194     return 0;
7195   }
7196
7197   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7198   {
7199     char device[] = "/dev/sda";
7200     int r;
7201     suppress_error = 0;
7202     r = guestfs_blockdev_setrw (g, device);
7203     if (r == -1)
7204       return -1;
7205   }
7206   {
7207     int r;
7208     suppress_error = 0;
7209     r = guestfs_umount_all (g);
7210     if (r == -1)
7211       return -1;
7212   }
7213   {
7214     int r;
7215     suppress_error = 0;
7216     r = guestfs_lvm_remove_all (g);
7217     if (r == -1)
7218       return -1;
7219   }
7220   {
7221     char device[] = "/dev/sda";
7222     char lines_0[] = ",";
7223     char *lines[] = {
7224       lines_0,
7225       NULL
7226     };
7227     int r;
7228     suppress_error = 0;
7229     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7230     if (r == -1)
7231       return -1;
7232   }
7233   {
7234     char fstype[] = "ext2";
7235     char device[] = "/dev/sda1";
7236     int r;
7237     suppress_error = 0;
7238     r = guestfs_mkfs (g, fstype, device);
7239     if (r == -1)
7240       return -1;
7241   }
7242   {
7243     char device[] = "/dev/sda1";
7244     char mountpoint[] = "/";
7245     int r;
7246     suppress_error = 0;
7247     r = guestfs_mount (g, device, mountpoint);
7248     if (r == -1)
7249       return -1;
7250   }
7251   /* TestOutput for tgz_in (0) */
7252   char expected[] = "hello\n";
7253   {
7254     char directory[] = "/";
7255     int r;
7256     suppress_error = 0;
7257     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7258     if (r == -1)
7259       return -1;
7260   }
7261   {
7262     char path[] = "/hello";
7263     char *r;
7264     suppress_error = 0;
7265     r = guestfs_cat (g, path);
7266     if (r == NULL)
7267       return -1;
7268     if (strcmp (r, expected) != 0) {
7269       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7270       return -1;
7271     }
7272     free (r);
7273   }
7274   return 0;
7275 }
7276
7277 static int test_tar_in_0_skip (void)
7278 {
7279   const char *str;
7280
7281   str = getenv ("TEST_ONLY");
7282   if (str)
7283     return strstr (str, "tar_in") == NULL;
7284   str = getenv ("SKIP_TEST_TAR_IN_0");
7285   if (str && strcmp (str, "1") == 0) return 1;
7286   str = getenv ("SKIP_TEST_TAR_IN");
7287   if (str && strcmp (str, "1") == 0) return 1;
7288   return 0;
7289 }
7290
7291 static int test_tar_in_0 (void)
7292 {
7293   if (test_tar_in_0_skip ()) {
7294     printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7295     return 0;
7296   }
7297
7298   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7299   {
7300     char device[] = "/dev/sda";
7301     int r;
7302     suppress_error = 0;
7303     r = guestfs_blockdev_setrw (g, device);
7304     if (r == -1)
7305       return -1;
7306   }
7307   {
7308     int r;
7309     suppress_error = 0;
7310     r = guestfs_umount_all (g);
7311     if (r == -1)
7312       return -1;
7313   }
7314   {
7315     int r;
7316     suppress_error = 0;
7317     r = guestfs_lvm_remove_all (g);
7318     if (r == -1)
7319       return -1;
7320   }
7321   {
7322     char device[] = "/dev/sda";
7323     char lines_0[] = ",";
7324     char *lines[] = {
7325       lines_0,
7326       NULL
7327     };
7328     int r;
7329     suppress_error = 0;
7330     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7331     if (r == -1)
7332       return -1;
7333   }
7334   {
7335     char fstype[] = "ext2";
7336     char device[] = "/dev/sda1";
7337     int r;
7338     suppress_error = 0;
7339     r = guestfs_mkfs (g, fstype, device);
7340     if (r == -1)
7341       return -1;
7342   }
7343   {
7344     char device[] = "/dev/sda1";
7345     char mountpoint[] = "/";
7346     int r;
7347     suppress_error = 0;
7348     r = guestfs_mount (g, device, mountpoint);
7349     if (r == -1)
7350       return -1;
7351   }
7352   /* TestOutput for tar_in (0) */
7353   char expected[] = "hello\n";
7354   {
7355     char directory[] = "/";
7356     int r;
7357     suppress_error = 0;
7358     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7359     if (r == -1)
7360       return -1;
7361   }
7362   {
7363     char path[] = "/hello";
7364     char *r;
7365     suppress_error = 0;
7366     r = guestfs_cat (g, path);
7367     if (r == NULL)
7368       return -1;
7369     if (strcmp (r, expected) != 0) {
7370       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7371       return -1;
7372     }
7373     free (r);
7374   }
7375   return 0;
7376 }
7377
7378 static int test_checksum_0_skip (void)
7379 {
7380   const char *str;
7381
7382   str = getenv ("TEST_ONLY");
7383   if (str)
7384     return strstr (str, "checksum") == NULL;
7385   str = getenv ("SKIP_TEST_CHECKSUM_0");
7386   if (str && strcmp (str, "1") == 0) return 1;
7387   str = getenv ("SKIP_TEST_CHECKSUM");
7388   if (str && strcmp (str, "1") == 0) return 1;
7389   return 0;
7390 }
7391
7392 static int test_checksum_0 (void)
7393 {
7394   if (test_checksum_0_skip ()) {
7395     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7396     return 0;
7397   }
7398
7399   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7400   {
7401     char device[] = "/dev/sda";
7402     int r;
7403     suppress_error = 0;
7404     r = guestfs_blockdev_setrw (g, device);
7405     if (r == -1)
7406       return -1;
7407   }
7408   {
7409     int r;
7410     suppress_error = 0;
7411     r = guestfs_umount_all (g);
7412     if (r == -1)
7413       return -1;
7414   }
7415   {
7416     int r;
7417     suppress_error = 0;
7418     r = guestfs_lvm_remove_all (g);
7419     if (r == -1)
7420       return -1;
7421   }
7422   {
7423     char device[] = "/dev/sda";
7424     char lines_0[] = ",";
7425     char *lines[] = {
7426       lines_0,
7427       NULL
7428     };
7429     int r;
7430     suppress_error = 0;
7431     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7432     if (r == -1)
7433       return -1;
7434   }
7435   {
7436     char fstype[] = "ext2";
7437     char device[] = "/dev/sda1";
7438     int r;
7439     suppress_error = 0;
7440     r = guestfs_mkfs (g, fstype, device);
7441     if (r == -1)
7442       return -1;
7443   }
7444   {
7445     char device[] = "/dev/sda1";
7446     char mountpoint[] = "/";
7447     int r;
7448     suppress_error = 0;
7449     r = guestfs_mount (g, device, mountpoint);
7450     if (r == -1)
7451       return -1;
7452   }
7453   /* TestOutput for checksum (0) */
7454   char expected[] = "935282863";
7455   {
7456     char path[] = "/new";
7457     char content[] = "test\n";
7458     int r;
7459     suppress_error = 0;
7460     r = guestfs_write_file (g, path, content, 0);
7461     if (r == -1)
7462       return -1;
7463   }
7464   {
7465     char csumtype[] = "crc";
7466     char path[] = "/new";
7467     char *r;
7468     suppress_error = 0;
7469     r = guestfs_checksum (g, csumtype, path);
7470     if (r == NULL)
7471       return -1;
7472     if (strcmp (r, expected) != 0) {
7473       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7474       return -1;
7475     }
7476     free (r);
7477   }
7478   return 0;
7479 }
7480
7481 static int test_checksum_1_skip (void)
7482 {
7483   const char *str;
7484
7485   str = getenv ("TEST_ONLY");
7486   if (str)
7487     return strstr (str, "checksum") == NULL;
7488   str = getenv ("SKIP_TEST_CHECKSUM_1");
7489   if (str && strcmp (str, "1") == 0) return 1;
7490   str = getenv ("SKIP_TEST_CHECKSUM");
7491   if (str && strcmp (str, "1") == 0) return 1;
7492   return 0;
7493 }
7494
7495 static int test_checksum_1 (void)
7496 {
7497   if (test_checksum_1_skip ()) {
7498     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7499     return 0;
7500   }
7501
7502   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7503   {
7504     char device[] = "/dev/sda";
7505     int r;
7506     suppress_error = 0;
7507     r = guestfs_blockdev_setrw (g, device);
7508     if (r == -1)
7509       return -1;
7510   }
7511   {
7512     int r;
7513     suppress_error = 0;
7514     r = guestfs_umount_all (g);
7515     if (r == -1)
7516       return -1;
7517   }
7518   {
7519     int r;
7520     suppress_error = 0;
7521     r = guestfs_lvm_remove_all (g);
7522     if (r == -1)
7523       return -1;
7524   }
7525   {
7526     char device[] = "/dev/sda";
7527     char lines_0[] = ",";
7528     char *lines[] = {
7529       lines_0,
7530       NULL
7531     };
7532     int r;
7533     suppress_error = 0;
7534     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7535     if (r == -1)
7536       return -1;
7537   }
7538   {
7539     char fstype[] = "ext2";
7540     char device[] = "/dev/sda1";
7541     int r;
7542     suppress_error = 0;
7543     r = guestfs_mkfs (g, fstype, device);
7544     if (r == -1)
7545       return -1;
7546   }
7547   {
7548     char device[] = "/dev/sda1";
7549     char mountpoint[] = "/";
7550     int r;
7551     suppress_error = 0;
7552     r = guestfs_mount (g, device, mountpoint);
7553     if (r == -1)
7554       return -1;
7555   }
7556   /* TestLastFail for checksum (1) */
7557   {
7558     char csumtype[] = "crc";
7559     char path[] = "/new";
7560     char *r;
7561     suppress_error = 1;
7562     r = guestfs_checksum (g, csumtype, path);
7563     if (r != NULL)
7564       return -1;
7565     free (r);
7566   }
7567   return 0;
7568 }
7569
7570 static int test_checksum_2_skip (void)
7571 {
7572   const char *str;
7573
7574   str = getenv ("TEST_ONLY");
7575   if (str)
7576     return strstr (str, "checksum") == NULL;
7577   str = getenv ("SKIP_TEST_CHECKSUM_2");
7578   if (str && strcmp (str, "1") == 0) return 1;
7579   str = getenv ("SKIP_TEST_CHECKSUM");
7580   if (str && strcmp (str, "1") == 0) return 1;
7581   return 0;
7582 }
7583
7584 static int test_checksum_2 (void)
7585 {
7586   if (test_checksum_2_skip ()) {
7587     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
7588     return 0;
7589   }
7590
7591   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
7592   {
7593     char device[] = "/dev/sda";
7594     int r;
7595     suppress_error = 0;
7596     r = guestfs_blockdev_setrw (g, device);
7597     if (r == -1)
7598       return -1;
7599   }
7600   {
7601     int r;
7602     suppress_error = 0;
7603     r = guestfs_umount_all (g);
7604     if (r == -1)
7605       return -1;
7606   }
7607   {
7608     int r;
7609     suppress_error = 0;
7610     r = guestfs_lvm_remove_all (g);
7611     if (r == -1)
7612       return -1;
7613   }
7614   {
7615     char device[] = "/dev/sda";
7616     char lines_0[] = ",";
7617     char *lines[] = {
7618       lines_0,
7619       NULL
7620     };
7621     int r;
7622     suppress_error = 0;
7623     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7624     if (r == -1)
7625       return -1;
7626   }
7627   {
7628     char fstype[] = "ext2";
7629     char device[] = "/dev/sda1";
7630     int r;
7631     suppress_error = 0;
7632     r = guestfs_mkfs (g, fstype, device);
7633     if (r == -1)
7634       return -1;
7635   }
7636   {
7637     char device[] = "/dev/sda1";
7638     char mountpoint[] = "/";
7639     int r;
7640     suppress_error = 0;
7641     r = guestfs_mount (g, device, mountpoint);
7642     if (r == -1)
7643       return -1;
7644   }
7645   /* TestOutput for checksum (2) */
7646   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
7647   {
7648     char path[] = "/new";
7649     char content[] = "test\n";
7650     int r;
7651     suppress_error = 0;
7652     r = guestfs_write_file (g, path, content, 0);
7653     if (r == -1)
7654       return -1;
7655   }
7656   {
7657     char csumtype[] = "md5";
7658     char path[] = "/new";
7659     char *r;
7660     suppress_error = 0;
7661     r = guestfs_checksum (g, csumtype, path);
7662     if (r == NULL)
7663       return -1;
7664     if (strcmp (r, expected) != 0) {
7665       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
7666       return -1;
7667     }
7668     free (r);
7669   }
7670   return 0;
7671 }
7672
7673 static int test_checksum_3_skip (void)
7674 {
7675   const char *str;
7676
7677   str = getenv ("TEST_ONLY");
7678   if (str)
7679     return strstr (str, "checksum") == NULL;
7680   str = getenv ("SKIP_TEST_CHECKSUM_3");
7681   if (str && strcmp (str, "1") == 0) return 1;
7682   str = getenv ("SKIP_TEST_CHECKSUM");
7683   if (str && strcmp (str, "1") == 0) return 1;
7684   return 0;
7685 }
7686
7687 static int test_checksum_3 (void)
7688 {
7689   if (test_checksum_3_skip ()) {
7690     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
7691     return 0;
7692   }
7693
7694   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
7695   {
7696     char device[] = "/dev/sda";
7697     int r;
7698     suppress_error = 0;
7699     r = guestfs_blockdev_setrw (g, device);
7700     if (r == -1)
7701       return -1;
7702   }
7703   {
7704     int r;
7705     suppress_error = 0;
7706     r = guestfs_umount_all (g);
7707     if (r == -1)
7708       return -1;
7709   }
7710   {
7711     int r;
7712     suppress_error = 0;
7713     r = guestfs_lvm_remove_all (g);
7714     if (r == -1)
7715       return -1;
7716   }
7717   {
7718     char device[] = "/dev/sda";
7719     char lines_0[] = ",";
7720     char *lines[] = {
7721       lines_0,
7722       NULL
7723     };
7724     int r;
7725     suppress_error = 0;
7726     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7727     if (r == -1)
7728       return -1;
7729   }
7730   {
7731     char fstype[] = "ext2";
7732     char device[] = "/dev/sda1";
7733     int r;
7734     suppress_error = 0;
7735     r = guestfs_mkfs (g, fstype, device);
7736     if (r == -1)
7737       return -1;
7738   }
7739   {
7740     char device[] = "/dev/sda1";
7741     char mountpoint[] = "/";
7742     int r;
7743     suppress_error = 0;
7744     r = guestfs_mount (g, device, mountpoint);
7745     if (r == -1)
7746       return -1;
7747   }
7748   /* TestOutput for checksum (3) */
7749   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
7750   {
7751     char path[] = "/new";
7752     char content[] = "test\n";
7753     int r;
7754     suppress_error = 0;
7755     r = guestfs_write_file (g, path, content, 0);
7756     if (r == -1)
7757       return -1;
7758   }
7759   {
7760     char csumtype[] = "sha1";
7761     char path[] = "/new";
7762     char *r;
7763     suppress_error = 0;
7764     r = guestfs_checksum (g, csumtype, path);
7765     if (r == NULL)
7766       return -1;
7767     if (strcmp (r, expected) != 0) {
7768       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
7769       return -1;
7770     }
7771     free (r);
7772   }
7773   return 0;
7774 }
7775
7776 static int test_checksum_4_skip (void)
7777 {
7778   const char *str;
7779
7780   str = getenv ("TEST_ONLY");
7781   if (str)
7782     return strstr (str, "checksum") == NULL;
7783   str = getenv ("SKIP_TEST_CHECKSUM_4");
7784   if (str && strcmp (str, "1") == 0) return 1;
7785   str = getenv ("SKIP_TEST_CHECKSUM");
7786   if (str && strcmp (str, "1") == 0) return 1;
7787   return 0;
7788 }
7789
7790 static int test_checksum_4 (void)
7791 {
7792   if (test_checksum_4_skip ()) {
7793     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
7794     return 0;
7795   }
7796
7797   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
7798   {
7799     char device[] = "/dev/sda";
7800     int r;
7801     suppress_error = 0;
7802     r = guestfs_blockdev_setrw (g, device);
7803     if (r == -1)
7804       return -1;
7805   }
7806   {
7807     int r;
7808     suppress_error = 0;
7809     r = guestfs_umount_all (g);
7810     if (r == -1)
7811       return -1;
7812   }
7813   {
7814     int r;
7815     suppress_error = 0;
7816     r = guestfs_lvm_remove_all (g);
7817     if (r == -1)
7818       return -1;
7819   }
7820   {
7821     char device[] = "/dev/sda";
7822     char lines_0[] = ",";
7823     char *lines[] = {
7824       lines_0,
7825       NULL
7826     };
7827     int r;
7828     suppress_error = 0;
7829     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7830     if (r == -1)
7831       return -1;
7832   }
7833   {
7834     char fstype[] = "ext2";
7835     char device[] = "/dev/sda1";
7836     int r;
7837     suppress_error = 0;
7838     r = guestfs_mkfs (g, fstype, device);
7839     if (r == -1)
7840       return -1;
7841   }
7842   {
7843     char device[] = "/dev/sda1";
7844     char mountpoint[] = "/";
7845     int r;
7846     suppress_error = 0;
7847     r = guestfs_mount (g, device, mountpoint);
7848     if (r == -1)
7849       return -1;
7850   }
7851   /* TestOutput for checksum (4) */
7852   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
7853   {
7854     char path[] = "/new";
7855     char content[] = "test\n";
7856     int r;
7857     suppress_error = 0;
7858     r = guestfs_write_file (g, path, content, 0);
7859     if (r == -1)
7860       return -1;
7861   }
7862   {
7863     char csumtype[] = "sha224";
7864     char path[] = "/new";
7865     char *r;
7866     suppress_error = 0;
7867     r = guestfs_checksum (g, csumtype, path);
7868     if (r == NULL)
7869       return -1;
7870     if (strcmp (r, expected) != 0) {
7871       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
7872       return -1;
7873     }
7874     free (r);
7875   }
7876   return 0;
7877 }
7878
7879 static int test_checksum_5_skip (void)
7880 {
7881   const char *str;
7882
7883   str = getenv ("TEST_ONLY");
7884   if (str)
7885     return strstr (str, "checksum") == NULL;
7886   str = getenv ("SKIP_TEST_CHECKSUM_5");
7887   if (str && strcmp (str, "1") == 0) return 1;
7888   str = getenv ("SKIP_TEST_CHECKSUM");
7889   if (str && strcmp (str, "1") == 0) return 1;
7890   return 0;
7891 }
7892
7893 static int test_checksum_5 (void)
7894 {
7895   if (test_checksum_5_skip ()) {
7896     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
7897     return 0;
7898   }
7899
7900   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
7901   {
7902     char device[] = "/dev/sda";
7903     int r;
7904     suppress_error = 0;
7905     r = guestfs_blockdev_setrw (g, device);
7906     if (r == -1)
7907       return -1;
7908   }
7909   {
7910     int r;
7911     suppress_error = 0;
7912     r = guestfs_umount_all (g);
7913     if (r == -1)
7914       return -1;
7915   }
7916   {
7917     int r;
7918     suppress_error = 0;
7919     r = guestfs_lvm_remove_all (g);
7920     if (r == -1)
7921       return -1;
7922   }
7923   {
7924     char device[] = "/dev/sda";
7925     char lines_0[] = ",";
7926     char *lines[] = {
7927       lines_0,
7928       NULL
7929     };
7930     int r;
7931     suppress_error = 0;
7932     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7933     if (r == -1)
7934       return -1;
7935   }
7936   {
7937     char fstype[] = "ext2";
7938     char device[] = "/dev/sda1";
7939     int r;
7940     suppress_error = 0;
7941     r = guestfs_mkfs (g, fstype, device);
7942     if (r == -1)
7943       return -1;
7944   }
7945   {
7946     char device[] = "/dev/sda1";
7947     char mountpoint[] = "/";
7948     int r;
7949     suppress_error = 0;
7950     r = guestfs_mount (g, device, mountpoint);
7951     if (r == -1)
7952       return -1;
7953   }
7954   /* TestOutput for checksum (5) */
7955   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
7956   {
7957     char path[] = "/new";
7958     char content[] = "test\n";
7959     int r;
7960     suppress_error = 0;
7961     r = guestfs_write_file (g, path, content, 0);
7962     if (r == -1)
7963       return -1;
7964   }
7965   {
7966     char csumtype[] = "sha256";
7967     char path[] = "/new";
7968     char *r;
7969     suppress_error = 0;
7970     r = guestfs_checksum (g, csumtype, path);
7971     if (r == NULL)
7972       return -1;
7973     if (strcmp (r, expected) != 0) {
7974       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
7975       return -1;
7976     }
7977     free (r);
7978   }
7979   return 0;
7980 }
7981
7982 static int test_checksum_6_skip (void)
7983 {
7984   const char *str;
7985
7986   str = getenv ("TEST_ONLY");
7987   if (str)
7988     return strstr (str, "checksum") == NULL;
7989   str = getenv ("SKIP_TEST_CHECKSUM_6");
7990   if (str && strcmp (str, "1") == 0) return 1;
7991   str = getenv ("SKIP_TEST_CHECKSUM");
7992   if (str && strcmp (str, "1") == 0) return 1;
7993   return 0;
7994 }
7995
7996 static int test_checksum_6 (void)
7997 {
7998   if (test_checksum_6_skip ()) {
7999     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8000     return 0;
8001   }
8002
8003   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8004   {
8005     char device[] = "/dev/sda";
8006     int r;
8007     suppress_error = 0;
8008     r = guestfs_blockdev_setrw (g, device);
8009     if (r == -1)
8010       return -1;
8011   }
8012   {
8013     int r;
8014     suppress_error = 0;
8015     r = guestfs_umount_all (g);
8016     if (r == -1)
8017       return -1;
8018   }
8019   {
8020     int r;
8021     suppress_error = 0;
8022     r = guestfs_lvm_remove_all (g);
8023     if (r == -1)
8024       return -1;
8025   }
8026   {
8027     char device[] = "/dev/sda";
8028     char lines_0[] = ",";
8029     char *lines[] = {
8030       lines_0,
8031       NULL
8032     };
8033     int r;
8034     suppress_error = 0;
8035     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8036     if (r == -1)
8037       return -1;
8038   }
8039   {
8040     char fstype[] = "ext2";
8041     char device[] = "/dev/sda1";
8042     int r;
8043     suppress_error = 0;
8044     r = guestfs_mkfs (g, fstype, device);
8045     if (r == -1)
8046       return -1;
8047   }
8048   {
8049     char device[] = "/dev/sda1";
8050     char mountpoint[] = "/";
8051     int r;
8052     suppress_error = 0;
8053     r = guestfs_mount (g, device, mountpoint);
8054     if (r == -1)
8055       return -1;
8056   }
8057   /* TestOutput for checksum (6) */
8058   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8059   {
8060     char path[] = "/new";
8061     char content[] = "test\n";
8062     int r;
8063     suppress_error = 0;
8064     r = guestfs_write_file (g, path, content, 0);
8065     if (r == -1)
8066       return -1;
8067   }
8068   {
8069     char csumtype[] = "sha384";
8070     char path[] = "/new";
8071     char *r;
8072     suppress_error = 0;
8073     r = guestfs_checksum (g, csumtype, path);
8074     if (r == NULL)
8075       return -1;
8076     if (strcmp (r, expected) != 0) {
8077       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8078       return -1;
8079     }
8080     free (r);
8081   }
8082   return 0;
8083 }
8084
8085 static int test_checksum_7_skip (void)
8086 {
8087   const char *str;
8088
8089   str = getenv ("TEST_ONLY");
8090   if (str)
8091     return strstr (str, "checksum") == NULL;
8092   str = getenv ("SKIP_TEST_CHECKSUM_7");
8093   if (str && strcmp (str, "1") == 0) return 1;
8094   str = getenv ("SKIP_TEST_CHECKSUM");
8095   if (str && strcmp (str, "1") == 0) return 1;
8096   return 0;
8097 }
8098
8099 static int test_checksum_7 (void)
8100 {
8101   if (test_checksum_7_skip ()) {
8102     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8103     return 0;
8104   }
8105
8106   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8107   {
8108     char device[] = "/dev/sda";
8109     int r;
8110     suppress_error = 0;
8111     r = guestfs_blockdev_setrw (g, device);
8112     if (r == -1)
8113       return -1;
8114   }
8115   {
8116     int r;
8117     suppress_error = 0;
8118     r = guestfs_umount_all (g);
8119     if (r == -1)
8120       return -1;
8121   }
8122   {
8123     int r;
8124     suppress_error = 0;
8125     r = guestfs_lvm_remove_all (g);
8126     if (r == -1)
8127       return -1;
8128   }
8129   {
8130     char device[] = "/dev/sda";
8131     char lines_0[] = ",";
8132     char *lines[] = {
8133       lines_0,
8134       NULL
8135     };
8136     int r;
8137     suppress_error = 0;
8138     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8139     if (r == -1)
8140       return -1;
8141   }
8142   {
8143     char fstype[] = "ext2";
8144     char device[] = "/dev/sda1";
8145     int r;
8146     suppress_error = 0;
8147     r = guestfs_mkfs (g, fstype, device);
8148     if (r == -1)
8149       return -1;
8150   }
8151   {
8152     char device[] = "/dev/sda1";
8153     char mountpoint[] = "/";
8154     int r;
8155     suppress_error = 0;
8156     r = guestfs_mount (g, device, mountpoint);
8157     if (r == -1)
8158       return -1;
8159   }
8160   /* TestOutput for checksum (7) */
8161   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8162   {
8163     char path[] = "/new";
8164     char content[] = "test\n";
8165     int r;
8166     suppress_error = 0;
8167     r = guestfs_write_file (g, path, content, 0);
8168     if (r == -1)
8169       return -1;
8170   }
8171   {
8172     char csumtype[] = "sha512";
8173     char path[] = "/new";
8174     char *r;
8175     suppress_error = 0;
8176     r = guestfs_checksum (g, csumtype, path);
8177     if (r == NULL)
8178       return -1;
8179     if (strcmp (r, expected) != 0) {
8180       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8181       return -1;
8182     }
8183     free (r);
8184   }
8185   return 0;
8186 }
8187
8188 static int test_checksum_8_skip (void)
8189 {
8190   const char *str;
8191
8192   str = getenv ("TEST_ONLY");
8193   if (str)
8194     return strstr (str, "checksum") == NULL;
8195   str = getenv ("SKIP_TEST_CHECKSUM_8");
8196   if (str && strcmp (str, "1") == 0) return 1;
8197   str = getenv ("SKIP_TEST_CHECKSUM");
8198   if (str && strcmp (str, "1") == 0) return 1;
8199   return 0;
8200 }
8201
8202 static int test_checksum_8 (void)
8203 {
8204   if (test_checksum_8_skip ()) {
8205     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8206     return 0;
8207   }
8208
8209   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8210   {
8211     char device[] = "/dev/sda";
8212     int r;
8213     suppress_error = 0;
8214     r = guestfs_blockdev_setrw (g, device);
8215     if (r == -1)
8216       return -1;
8217   }
8218   {
8219     int r;
8220     suppress_error = 0;
8221     r = guestfs_umount_all (g);
8222     if (r == -1)
8223       return -1;
8224   }
8225   {
8226     int r;
8227     suppress_error = 0;
8228     r = guestfs_lvm_remove_all (g);
8229     if (r == -1)
8230       return -1;
8231   }
8232   {
8233     char device[] = "/dev/sda";
8234     char lines_0[] = ",";
8235     char *lines[] = {
8236       lines_0,
8237       NULL
8238     };
8239     int r;
8240     suppress_error = 0;
8241     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8242     if (r == -1)
8243       return -1;
8244   }
8245   {
8246     char fstype[] = "ext2";
8247     char device[] = "/dev/sda1";
8248     int r;
8249     suppress_error = 0;
8250     r = guestfs_mkfs (g, fstype, device);
8251     if (r == -1)
8252       return -1;
8253   }
8254   {
8255     char device[] = "/dev/sda1";
8256     char mountpoint[] = "/";
8257     int r;
8258     suppress_error = 0;
8259     r = guestfs_mount (g, device, mountpoint);
8260     if (r == -1)
8261       return -1;
8262   }
8263   /* TestOutput for checksum (8) */
8264   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8265   {
8266     char options[] = "ro";
8267     char vfstype[] = "squashfs";
8268     char device[] = "/dev/sdd";
8269     char mountpoint[] = "/";
8270     int r;
8271     suppress_error = 0;
8272     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8273     if (r == -1)
8274       return -1;
8275   }
8276   {
8277     char csumtype[] = "md5";
8278     char path[] = "/known-3";
8279     char *r;
8280     suppress_error = 0;
8281     r = guestfs_checksum (g, csumtype, path);
8282     if (r == NULL)
8283       return -1;
8284     if (strcmp (r, expected) != 0) {
8285       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8286       return -1;
8287     }
8288     free (r);
8289   }
8290   return 0;
8291 }
8292
8293 static int test_download_0_skip (void)
8294 {
8295   const char *str;
8296
8297   str = getenv ("TEST_ONLY");
8298   if (str)
8299     return strstr (str, "download") == NULL;
8300   str = getenv ("SKIP_TEST_DOWNLOAD_0");
8301   if (str && strcmp (str, "1") == 0) return 1;
8302   str = getenv ("SKIP_TEST_DOWNLOAD");
8303   if (str && strcmp (str, "1") == 0) return 1;
8304   return 0;
8305 }
8306
8307 static int test_download_0 (void)
8308 {
8309   if (test_download_0_skip ()) {
8310     printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8311     return 0;
8312   }
8313
8314   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8315   {
8316     char device[] = "/dev/sda";
8317     int r;
8318     suppress_error = 0;
8319     r = guestfs_blockdev_setrw (g, device);
8320     if (r == -1)
8321       return -1;
8322   }
8323   {
8324     int r;
8325     suppress_error = 0;
8326     r = guestfs_umount_all (g);
8327     if (r == -1)
8328       return -1;
8329   }
8330   {
8331     int r;
8332     suppress_error = 0;
8333     r = guestfs_lvm_remove_all (g);
8334     if (r == -1)
8335       return -1;
8336   }
8337   {
8338     char device[] = "/dev/sda";
8339     char lines_0[] = ",";
8340     char *lines[] = {
8341       lines_0,
8342       NULL
8343     };
8344     int r;
8345     suppress_error = 0;
8346     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8347     if (r == -1)
8348       return -1;
8349   }
8350   {
8351     char fstype[] = "ext2";
8352     char device[] = "/dev/sda1";
8353     int r;
8354     suppress_error = 0;
8355     r = guestfs_mkfs (g, fstype, device);
8356     if (r == -1)
8357       return -1;
8358   }
8359   {
8360     char device[] = "/dev/sda1";
8361     char mountpoint[] = "/";
8362     int r;
8363     suppress_error = 0;
8364     r = guestfs_mount (g, device, mountpoint);
8365     if (r == -1)
8366       return -1;
8367   }
8368   /* TestOutput for download (0) */
8369   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8370   {
8371     char remotefilename[] = "/COPYING.LIB";
8372     int r;
8373     suppress_error = 0;
8374     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8375     if (r == -1)
8376       return -1;
8377   }
8378   {
8379     char remotefilename[] = "/COPYING.LIB";
8380     int r;
8381     suppress_error = 0;
8382     r = guestfs_download (g, remotefilename, "testdownload.tmp");
8383     if (r == -1)
8384       return -1;
8385   }
8386   {
8387     char remotefilename[] = "/upload";
8388     int r;
8389     suppress_error = 0;
8390     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8391     if (r == -1)
8392       return -1;
8393   }
8394   {
8395     char csumtype[] = "md5";
8396     char path[] = "/upload";
8397     char *r;
8398     suppress_error = 0;
8399     r = guestfs_checksum (g, csumtype, path);
8400     if (r == NULL)
8401       return -1;
8402     if (strcmp (r, expected) != 0) {
8403       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8404       return -1;
8405     }
8406     free (r);
8407   }
8408   return 0;
8409 }
8410
8411 static int test_upload_0_skip (void)
8412 {
8413   const char *str;
8414
8415   str = getenv ("TEST_ONLY");
8416   if (str)
8417     return strstr (str, "upload") == NULL;
8418   str = getenv ("SKIP_TEST_UPLOAD_0");
8419   if (str && strcmp (str, "1") == 0) return 1;
8420   str = getenv ("SKIP_TEST_UPLOAD");
8421   if (str && strcmp (str, "1") == 0) return 1;
8422   return 0;
8423 }
8424
8425 static int test_upload_0 (void)
8426 {
8427   if (test_upload_0_skip ()) {
8428     printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8429     return 0;
8430   }
8431
8432   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8433   {
8434     char device[] = "/dev/sda";
8435     int r;
8436     suppress_error = 0;
8437     r = guestfs_blockdev_setrw (g, device);
8438     if (r == -1)
8439       return -1;
8440   }
8441   {
8442     int r;
8443     suppress_error = 0;
8444     r = guestfs_umount_all (g);
8445     if (r == -1)
8446       return -1;
8447   }
8448   {
8449     int r;
8450     suppress_error = 0;
8451     r = guestfs_lvm_remove_all (g);
8452     if (r == -1)
8453       return -1;
8454   }
8455   {
8456     char device[] = "/dev/sda";
8457     char lines_0[] = ",";
8458     char *lines[] = {
8459       lines_0,
8460       NULL
8461     };
8462     int r;
8463     suppress_error = 0;
8464     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8465     if (r == -1)
8466       return -1;
8467   }
8468   {
8469     char fstype[] = "ext2";
8470     char device[] = "/dev/sda1";
8471     int r;
8472     suppress_error = 0;
8473     r = guestfs_mkfs (g, fstype, device);
8474     if (r == -1)
8475       return -1;
8476   }
8477   {
8478     char device[] = "/dev/sda1";
8479     char mountpoint[] = "/";
8480     int r;
8481     suppress_error = 0;
8482     r = guestfs_mount (g, device, mountpoint);
8483     if (r == -1)
8484       return -1;
8485   }
8486   /* TestOutput for upload (0) */
8487   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8488   {
8489     char remotefilename[] = "/COPYING.LIB";
8490     int r;
8491     suppress_error = 0;
8492     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8493     if (r == -1)
8494       return -1;
8495   }
8496   {
8497     char csumtype[] = "md5";
8498     char path[] = "/COPYING.LIB";
8499     char *r;
8500     suppress_error = 0;
8501     r = guestfs_checksum (g, csumtype, path);
8502     if (r == NULL)
8503       return -1;
8504     if (strcmp (r, expected) != 0) {
8505       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8506       return -1;
8507     }
8508     free (r);
8509   }
8510   return 0;
8511 }
8512
8513 static int test_blockdev_rereadpt_0_skip (void)
8514 {
8515   const char *str;
8516
8517   str = getenv ("TEST_ONLY");
8518   if (str)
8519     return strstr (str, "blockdev_rereadpt") == NULL;
8520   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8521   if (str && strcmp (str, "1") == 0) return 1;
8522   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8523   if (str && strcmp (str, "1") == 0) return 1;
8524   return 0;
8525 }
8526
8527 static int test_blockdev_rereadpt_0 (void)
8528 {
8529   if (test_blockdev_rereadpt_0_skip ()) {
8530     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8531     return 0;
8532   }
8533
8534   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
8535   {
8536     char device[] = "/dev/sda";
8537     int r;
8538     suppress_error = 0;
8539     r = guestfs_blockdev_setrw (g, device);
8540     if (r == -1)
8541       return -1;
8542   }
8543   {
8544     int r;
8545     suppress_error = 0;
8546     r = guestfs_umount_all (g);
8547     if (r == -1)
8548       return -1;
8549   }
8550   {
8551     int r;
8552     suppress_error = 0;
8553     r = guestfs_lvm_remove_all (g);
8554     if (r == -1)
8555       return -1;
8556   }
8557   /* TestRun for blockdev_rereadpt (0) */
8558   {
8559     char device[] = "/dev/sda";
8560     int r;
8561     suppress_error = 0;
8562     r = guestfs_blockdev_rereadpt (g, device);
8563     if (r == -1)
8564       return -1;
8565   }
8566   return 0;
8567 }
8568
8569 static int test_blockdev_flushbufs_0_skip (void)
8570 {
8571   const char *str;
8572
8573   str = getenv ("TEST_ONLY");
8574   if (str)
8575     return strstr (str, "blockdev_flushbufs") == NULL;
8576   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
8577   if (str && strcmp (str, "1") == 0) return 1;
8578   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
8579   if (str && strcmp (str, "1") == 0) return 1;
8580   return 0;
8581 }
8582
8583 static int test_blockdev_flushbufs_0 (void)
8584 {
8585   if (test_blockdev_flushbufs_0_skip ()) {
8586     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
8587     return 0;
8588   }
8589
8590   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
8591   {
8592     char device[] = "/dev/sda";
8593     int r;
8594     suppress_error = 0;
8595     r = guestfs_blockdev_setrw (g, device);
8596     if (r == -1)
8597       return -1;
8598   }
8599   {
8600     int r;
8601     suppress_error = 0;
8602     r = guestfs_umount_all (g);
8603     if (r == -1)
8604       return -1;
8605   }
8606   {
8607     int r;
8608     suppress_error = 0;
8609     r = guestfs_lvm_remove_all (g);
8610     if (r == -1)
8611       return -1;
8612   }
8613   /* TestRun for blockdev_flushbufs (0) */
8614   {
8615     char device[] = "/dev/sda";
8616     int r;
8617     suppress_error = 0;
8618     r = guestfs_blockdev_flushbufs (g, device);
8619     if (r == -1)
8620       return -1;
8621   }
8622   return 0;
8623 }
8624
8625 static int test_blockdev_getsize64_0_skip (void)
8626 {
8627   const char *str;
8628
8629   str = getenv ("TEST_ONLY");
8630   if (str)
8631     return strstr (str, "blockdev_getsize64") == NULL;
8632   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
8633   if (str && strcmp (str, "1") == 0) return 1;
8634   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
8635   if (str && strcmp (str, "1") == 0) return 1;
8636   return 0;
8637 }
8638
8639 static int test_blockdev_getsize64_0 (void)
8640 {
8641   if (test_blockdev_getsize64_0_skip ()) {
8642     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
8643     return 0;
8644   }
8645
8646   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
8647   {
8648     char device[] = "/dev/sda";
8649     int r;
8650     suppress_error = 0;
8651     r = guestfs_blockdev_setrw (g, device);
8652     if (r == -1)
8653       return -1;
8654   }
8655   {
8656     int r;
8657     suppress_error = 0;
8658     r = guestfs_umount_all (g);
8659     if (r == -1)
8660       return -1;
8661   }
8662   {
8663     int r;
8664     suppress_error = 0;
8665     r = guestfs_lvm_remove_all (g);
8666     if (r == -1)
8667       return -1;
8668   }
8669   /* TestOutputInt for blockdev_getsize64 (0) */
8670   {
8671     char device[] = "/dev/sda";
8672     int64_t r;
8673     suppress_error = 0;
8674     r = guestfs_blockdev_getsize64 (g, device);
8675     if (r == -1)
8676       return -1;
8677     if (r != 524288000) {
8678       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
8679       return -1;
8680     }
8681   }
8682   return 0;
8683 }
8684
8685 static int test_blockdev_getsz_0_skip (void)
8686 {
8687   const char *str;
8688
8689   str = getenv ("TEST_ONLY");
8690   if (str)
8691     return strstr (str, "blockdev_getsz") == NULL;
8692   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
8693   if (str && strcmp (str, "1") == 0) return 1;
8694   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
8695   if (str && strcmp (str, "1") == 0) return 1;
8696   return 0;
8697 }
8698
8699 static int test_blockdev_getsz_0 (void)
8700 {
8701   if (test_blockdev_getsz_0_skip ()) {
8702     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
8703     return 0;
8704   }
8705
8706   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
8707   {
8708     char device[] = "/dev/sda";
8709     int r;
8710     suppress_error = 0;
8711     r = guestfs_blockdev_setrw (g, device);
8712     if (r == -1)
8713       return -1;
8714   }
8715   {
8716     int r;
8717     suppress_error = 0;
8718     r = guestfs_umount_all (g);
8719     if (r == -1)
8720       return -1;
8721   }
8722   {
8723     int r;
8724     suppress_error = 0;
8725     r = guestfs_lvm_remove_all (g);
8726     if (r == -1)
8727       return -1;
8728   }
8729   /* TestOutputInt for blockdev_getsz (0) */
8730   {
8731     char device[] = "/dev/sda";
8732     int64_t r;
8733     suppress_error = 0;
8734     r = guestfs_blockdev_getsz (g, device);
8735     if (r == -1)
8736       return -1;
8737     if (r != 1024000) {
8738       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
8739       return -1;
8740     }
8741   }
8742   return 0;
8743 }
8744
8745 static int test_blockdev_getbsz_0_skip (void)
8746 {
8747   const char *str;
8748
8749   str = getenv ("TEST_ONLY");
8750   if (str)
8751     return strstr (str, "blockdev_getbsz") == NULL;
8752   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
8753   if (str && strcmp (str, "1") == 0) return 1;
8754   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
8755   if (str && strcmp (str, "1") == 0) return 1;
8756   return 0;
8757 }
8758
8759 static int test_blockdev_getbsz_0 (void)
8760 {
8761   if (test_blockdev_getbsz_0_skip ()) {
8762     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
8763     return 0;
8764   }
8765
8766   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
8767   {
8768     char device[] = "/dev/sda";
8769     int r;
8770     suppress_error = 0;
8771     r = guestfs_blockdev_setrw (g, device);
8772     if (r == -1)
8773       return -1;
8774   }
8775   {
8776     int r;
8777     suppress_error = 0;
8778     r = guestfs_umount_all (g);
8779     if (r == -1)
8780       return -1;
8781   }
8782   {
8783     int r;
8784     suppress_error = 0;
8785     r = guestfs_lvm_remove_all (g);
8786     if (r == -1)
8787       return -1;
8788   }
8789   /* TestOutputInt for blockdev_getbsz (0) */
8790   {
8791     char device[] = "/dev/sda";
8792     int r;
8793     suppress_error = 0;
8794     r = guestfs_blockdev_getbsz (g, device);
8795     if (r == -1)
8796       return -1;
8797     if (r != 4096) {
8798       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
8799       return -1;
8800     }
8801   }
8802   return 0;
8803 }
8804
8805 static int test_blockdev_getss_0_skip (void)
8806 {
8807   const char *str;
8808
8809   str = getenv ("TEST_ONLY");
8810   if (str)
8811     return strstr (str, "blockdev_getss") == NULL;
8812   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
8813   if (str && strcmp (str, "1") == 0) return 1;
8814   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
8815   if (str && strcmp (str, "1") == 0) return 1;
8816   return 0;
8817 }
8818
8819 static int test_blockdev_getss_0 (void)
8820 {
8821   if (test_blockdev_getss_0_skip ()) {
8822     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
8823     return 0;
8824   }
8825
8826   /* InitNone|InitEmpty for test_blockdev_getss_0 */
8827   {
8828     char device[] = "/dev/sda";
8829     int r;
8830     suppress_error = 0;
8831     r = guestfs_blockdev_setrw (g, device);
8832     if (r == -1)
8833       return -1;
8834   }
8835   {
8836     int r;
8837     suppress_error = 0;
8838     r = guestfs_umount_all (g);
8839     if (r == -1)
8840       return -1;
8841   }
8842   {
8843     int r;
8844     suppress_error = 0;
8845     r = guestfs_lvm_remove_all (g);
8846     if (r == -1)
8847       return -1;
8848   }
8849   /* TestOutputInt for blockdev_getss (0) */
8850   {
8851     char device[] = "/dev/sda";
8852     int r;
8853     suppress_error = 0;
8854     r = guestfs_blockdev_getss (g, device);
8855     if (r == -1)
8856       return -1;
8857     if (r != 512) {
8858       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
8859       return -1;
8860     }
8861   }
8862   return 0;
8863 }
8864
8865 static int test_blockdev_getro_0_skip (void)
8866 {
8867   const char *str;
8868
8869   str = getenv ("TEST_ONLY");
8870   if (str)
8871     return strstr (str, "blockdev_getro") == NULL;
8872   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
8873   if (str && strcmp (str, "1") == 0) return 1;
8874   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
8875   if (str && strcmp (str, "1") == 0) return 1;
8876   return 0;
8877 }
8878
8879 static int test_blockdev_getro_0 (void)
8880 {
8881   if (test_blockdev_getro_0_skip ()) {
8882     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
8883     return 0;
8884   }
8885
8886   /* InitNone|InitEmpty for test_blockdev_getro_0 */
8887   {
8888     char device[] = "/dev/sda";
8889     int r;
8890     suppress_error = 0;
8891     r = guestfs_blockdev_setrw (g, device);
8892     if (r == -1)
8893       return -1;
8894   }
8895   {
8896     int r;
8897     suppress_error = 0;
8898     r = guestfs_umount_all (g);
8899     if (r == -1)
8900       return -1;
8901   }
8902   {
8903     int r;
8904     suppress_error = 0;
8905     r = guestfs_lvm_remove_all (g);
8906     if (r == -1)
8907       return -1;
8908   }
8909   /* TestOutputTrue for blockdev_getro (0) */
8910   {
8911     char device[] = "/dev/sda";
8912     int r;
8913     suppress_error = 0;
8914     r = guestfs_blockdev_setro (g, device);
8915     if (r == -1)
8916       return -1;
8917   }
8918   {
8919     char device[] = "/dev/sda";
8920     int r;
8921     suppress_error = 0;
8922     r = guestfs_blockdev_getro (g, device);
8923     if (r == -1)
8924       return -1;
8925     if (!r) {
8926       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
8927       return -1;
8928     }
8929   }
8930   return 0;
8931 }
8932
8933 static int test_blockdev_setrw_0_skip (void)
8934 {
8935   const char *str;
8936
8937   str = getenv ("TEST_ONLY");
8938   if (str)
8939     return strstr (str, "blockdev_setrw") == NULL;
8940   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
8941   if (str && strcmp (str, "1") == 0) return 1;
8942   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
8943   if (str && strcmp (str, "1") == 0) return 1;
8944   return 0;
8945 }
8946
8947 static int test_blockdev_setrw_0 (void)
8948 {
8949   if (test_blockdev_setrw_0_skip ()) {
8950     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
8951     return 0;
8952   }
8953
8954   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
8955   {
8956     char device[] = "/dev/sda";
8957     int r;
8958     suppress_error = 0;
8959     r = guestfs_blockdev_setrw (g, device);
8960     if (r == -1)
8961       return -1;
8962   }
8963   {
8964     int r;
8965     suppress_error = 0;
8966     r = guestfs_umount_all (g);
8967     if (r == -1)
8968       return -1;
8969   }
8970   {
8971     int r;
8972     suppress_error = 0;
8973     r = guestfs_lvm_remove_all (g);
8974     if (r == -1)
8975       return -1;
8976   }
8977   /* TestOutputFalse for blockdev_setrw (0) */
8978   {
8979     char device[] = "/dev/sda";
8980     int r;
8981     suppress_error = 0;
8982     r = guestfs_blockdev_setrw (g, device);
8983     if (r == -1)
8984       return -1;
8985   }
8986   {
8987     char device[] = "/dev/sda";
8988     int r;
8989     suppress_error = 0;
8990     r = guestfs_blockdev_getro (g, device);
8991     if (r == -1)
8992       return -1;
8993     if (r) {
8994       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
8995       return -1;
8996     }
8997   }
8998   return 0;
8999 }
9000
9001 static int test_blockdev_setro_0_skip (void)
9002 {
9003   const char *str;
9004
9005   str = getenv ("TEST_ONLY");
9006   if (str)
9007     return strstr (str, "blockdev_setro") == NULL;
9008   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9009   if (str && strcmp (str, "1") == 0) return 1;
9010   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9011   if (str && strcmp (str, "1") == 0) return 1;
9012   return 0;
9013 }
9014
9015 static int test_blockdev_setro_0 (void)
9016 {
9017   if (test_blockdev_setro_0_skip ()) {
9018     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9019     return 0;
9020   }
9021
9022   /* InitNone|InitEmpty for test_blockdev_setro_0 */
9023   {
9024     char device[] = "/dev/sda";
9025     int r;
9026     suppress_error = 0;
9027     r = guestfs_blockdev_setrw (g, device);
9028     if (r == -1)
9029       return -1;
9030   }
9031   {
9032     int r;
9033     suppress_error = 0;
9034     r = guestfs_umount_all (g);
9035     if (r == -1)
9036       return -1;
9037   }
9038   {
9039     int r;
9040     suppress_error = 0;
9041     r = guestfs_lvm_remove_all (g);
9042     if (r == -1)
9043       return -1;
9044   }
9045   /* TestOutputTrue for blockdev_setro (0) */
9046   {
9047     char device[] = "/dev/sda";
9048     int r;
9049     suppress_error = 0;
9050     r = guestfs_blockdev_setro (g, device);
9051     if (r == -1)
9052       return -1;
9053   }
9054   {
9055     char device[] = "/dev/sda";
9056     int r;
9057     suppress_error = 0;
9058     r = guestfs_blockdev_getro (g, device);
9059     if (r == -1)
9060       return -1;
9061     if (!r) {
9062       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9063       return -1;
9064     }
9065   }
9066   return 0;
9067 }
9068
9069 static int test_statvfs_0_skip (void)
9070 {
9071   const char *str;
9072
9073   str = getenv ("TEST_ONLY");
9074   if (str)
9075     return strstr (str, "statvfs") == NULL;
9076   str = getenv ("SKIP_TEST_STATVFS_0");
9077   if (str && strcmp (str, "1") == 0) return 1;
9078   str = getenv ("SKIP_TEST_STATVFS");
9079   if (str && strcmp (str, "1") == 0) return 1;
9080   return 0;
9081 }
9082
9083 static int test_statvfs_0 (void)
9084 {
9085   if (test_statvfs_0_skip ()) {
9086     printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9087     return 0;
9088   }
9089
9090   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9091   {
9092     char device[] = "/dev/sda";
9093     int r;
9094     suppress_error = 0;
9095     r = guestfs_blockdev_setrw (g, device);
9096     if (r == -1)
9097       return -1;
9098   }
9099   {
9100     int r;
9101     suppress_error = 0;
9102     r = guestfs_umount_all (g);
9103     if (r == -1)
9104       return -1;
9105   }
9106   {
9107     int r;
9108     suppress_error = 0;
9109     r = guestfs_lvm_remove_all (g);
9110     if (r == -1)
9111       return -1;
9112   }
9113   {
9114     char device[] = "/dev/sda";
9115     char lines_0[] = ",";
9116     char *lines[] = {
9117       lines_0,
9118       NULL
9119     };
9120     int r;
9121     suppress_error = 0;
9122     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9123     if (r == -1)
9124       return -1;
9125   }
9126   {
9127     char fstype[] = "ext2";
9128     char device[] = "/dev/sda1";
9129     int r;
9130     suppress_error = 0;
9131     r = guestfs_mkfs (g, fstype, device);
9132     if (r == -1)
9133       return -1;
9134   }
9135   {
9136     char device[] = "/dev/sda1";
9137     char mountpoint[] = "/";
9138     int r;
9139     suppress_error = 0;
9140     r = guestfs_mount (g, device, mountpoint);
9141     if (r == -1)
9142       return -1;
9143   }
9144   /* TestOutputStruct for statvfs (0) */
9145   {
9146     char path[] = "/";
9147     struct guestfs_statvfs *r;
9148     suppress_error = 0;
9149     r = guestfs_statvfs (g, path);
9150     if (r == NULL)
9151       return -1;
9152     if (r->bfree != 487702) {
9153       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9154                (int) r->bfree);
9155       return -1;
9156     }
9157     if (r->blocks != 490020) {
9158       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9159                (int) r->blocks);
9160       return -1;
9161     }
9162     if (r->bsize != 1024) {
9163       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9164                (int) r->bsize);
9165       return -1;
9166     }
9167     free (r);
9168   }
9169   return 0;
9170 }
9171
9172 static int test_lstat_0_skip (void)
9173 {
9174   const char *str;
9175
9176   str = getenv ("TEST_ONLY");
9177   if (str)
9178     return strstr (str, "lstat") == NULL;
9179   str = getenv ("SKIP_TEST_LSTAT_0");
9180   if (str && strcmp (str, "1") == 0) return 1;
9181   str = getenv ("SKIP_TEST_LSTAT");
9182   if (str && strcmp (str, "1") == 0) return 1;
9183   return 0;
9184 }
9185
9186 static int test_lstat_0 (void)
9187 {
9188   if (test_lstat_0_skip ()) {
9189     printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9190     return 0;
9191   }
9192
9193   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9194   {
9195     char device[] = "/dev/sda";
9196     int r;
9197     suppress_error = 0;
9198     r = guestfs_blockdev_setrw (g, device);
9199     if (r == -1)
9200       return -1;
9201   }
9202   {
9203     int r;
9204     suppress_error = 0;
9205     r = guestfs_umount_all (g);
9206     if (r == -1)
9207       return -1;
9208   }
9209   {
9210     int r;
9211     suppress_error = 0;
9212     r = guestfs_lvm_remove_all (g);
9213     if (r == -1)
9214       return -1;
9215   }
9216   {
9217     char device[] = "/dev/sda";
9218     char lines_0[] = ",";
9219     char *lines[] = {
9220       lines_0,
9221       NULL
9222     };
9223     int r;
9224     suppress_error = 0;
9225     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9226     if (r == -1)
9227       return -1;
9228   }
9229   {
9230     char fstype[] = "ext2";
9231     char device[] = "/dev/sda1";
9232     int r;
9233     suppress_error = 0;
9234     r = guestfs_mkfs (g, fstype, device);
9235     if (r == -1)
9236       return -1;
9237   }
9238   {
9239     char device[] = "/dev/sda1";
9240     char mountpoint[] = "/";
9241     int r;
9242     suppress_error = 0;
9243     r = guestfs_mount (g, device, mountpoint);
9244     if (r == -1)
9245       return -1;
9246   }
9247   /* TestOutputStruct for lstat (0) */
9248   {
9249     char path[] = "/new";
9250     int r;
9251     suppress_error = 0;
9252     r = guestfs_touch (g, path);
9253     if (r == -1)
9254       return -1;
9255   }
9256   {
9257     char path[] = "/new";
9258     struct guestfs_stat *r;
9259     suppress_error = 0;
9260     r = guestfs_lstat (g, path);
9261     if (r == NULL)
9262       return -1;
9263     if (r->size != 0) {
9264       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9265                (int) r->size);
9266       return -1;
9267     }
9268     free (r);
9269   }
9270   return 0;
9271 }
9272
9273 static int test_stat_0_skip (void)
9274 {
9275   const char *str;
9276
9277   str = getenv ("TEST_ONLY");
9278   if (str)
9279     return strstr (str, "stat") == NULL;
9280   str = getenv ("SKIP_TEST_STAT_0");
9281   if (str && strcmp (str, "1") == 0) return 1;
9282   str = getenv ("SKIP_TEST_STAT");
9283   if (str && strcmp (str, "1") == 0) return 1;
9284   return 0;
9285 }
9286
9287 static int test_stat_0 (void)
9288 {
9289   if (test_stat_0_skip ()) {
9290     printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9291     return 0;
9292   }
9293
9294   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9295   {
9296     char device[] = "/dev/sda";
9297     int r;
9298     suppress_error = 0;
9299     r = guestfs_blockdev_setrw (g, device);
9300     if (r == -1)
9301       return -1;
9302   }
9303   {
9304     int r;
9305     suppress_error = 0;
9306     r = guestfs_umount_all (g);
9307     if (r == -1)
9308       return -1;
9309   }
9310   {
9311     int r;
9312     suppress_error = 0;
9313     r = guestfs_lvm_remove_all (g);
9314     if (r == -1)
9315       return -1;
9316   }
9317   {
9318     char device[] = "/dev/sda";
9319     char lines_0[] = ",";
9320     char *lines[] = {
9321       lines_0,
9322       NULL
9323     };
9324     int r;
9325     suppress_error = 0;
9326     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9327     if (r == -1)
9328       return -1;
9329   }
9330   {
9331     char fstype[] = "ext2";
9332     char device[] = "/dev/sda1";
9333     int r;
9334     suppress_error = 0;
9335     r = guestfs_mkfs (g, fstype, device);
9336     if (r == -1)
9337       return -1;
9338   }
9339   {
9340     char device[] = "/dev/sda1";
9341     char mountpoint[] = "/";
9342     int r;
9343     suppress_error = 0;
9344     r = guestfs_mount (g, device, mountpoint);
9345     if (r == -1)
9346       return -1;
9347   }
9348   /* TestOutputStruct for stat (0) */
9349   {
9350     char path[] = "/new";
9351     int r;
9352     suppress_error = 0;
9353     r = guestfs_touch (g, path);
9354     if (r == -1)
9355       return -1;
9356   }
9357   {
9358     char path[] = "/new";
9359     struct guestfs_stat *r;
9360     suppress_error = 0;
9361     r = guestfs_stat (g, path);
9362     if (r == NULL)
9363       return -1;
9364     if (r->size != 0) {
9365       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9366                (int) r->size);
9367       return -1;
9368     }
9369     free (r);
9370   }
9371   return 0;
9372 }
9373
9374 static int test_command_lines_0_skip (void)
9375 {
9376   const char *str;
9377
9378   str = getenv ("TEST_ONLY");
9379   if (str)
9380     return strstr (str, "command_lines") == NULL;
9381   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9382   if (str && strcmp (str, "1") == 0) return 1;
9383   str = getenv ("SKIP_TEST_COMMAND_LINES");
9384   if (str && strcmp (str, "1") == 0) return 1;
9385   return 0;
9386 }
9387
9388 static int test_command_lines_0 (void)
9389 {
9390   if (test_command_lines_0_skip ()) {
9391     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9392     return 0;
9393   }
9394
9395   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9396   {
9397     char device[] = "/dev/sda";
9398     int r;
9399     suppress_error = 0;
9400     r = guestfs_blockdev_setrw (g, device);
9401     if (r == -1)
9402       return -1;
9403   }
9404   {
9405     int r;
9406     suppress_error = 0;
9407     r = guestfs_umount_all (g);
9408     if (r == -1)
9409       return -1;
9410   }
9411   {
9412     int r;
9413     suppress_error = 0;
9414     r = guestfs_lvm_remove_all (g);
9415     if (r == -1)
9416       return -1;
9417   }
9418   {
9419     char device[] = "/dev/sda";
9420     char lines_0[] = ",";
9421     char *lines[] = {
9422       lines_0,
9423       NULL
9424     };
9425     int r;
9426     suppress_error = 0;
9427     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9428     if (r == -1)
9429       return -1;
9430   }
9431   {
9432     char fstype[] = "ext2";
9433     char device[] = "/dev/sda1";
9434     int r;
9435     suppress_error = 0;
9436     r = guestfs_mkfs (g, fstype, device);
9437     if (r == -1)
9438       return -1;
9439   }
9440   {
9441     char device[] = "/dev/sda1";
9442     char mountpoint[] = "/";
9443     int r;
9444     suppress_error = 0;
9445     r = guestfs_mount (g, device, mountpoint);
9446     if (r == -1)
9447       return -1;
9448   }
9449   /* TestOutputList for command_lines (0) */
9450   {
9451     char remotefilename[] = "/test-command";
9452     int r;
9453     suppress_error = 0;
9454     r = guestfs_upload (g, "test-command", remotefilename);
9455     if (r == -1)
9456       return -1;
9457   }
9458   {
9459     char path[] = "/test-command";
9460     int r;
9461     suppress_error = 0;
9462     r = guestfs_chmod (g, 493, path);
9463     if (r == -1)
9464       return -1;
9465   }
9466   {
9467     char arguments_0[] = "/test-command";
9468     char arguments_1[] = "1";
9469     char *arguments[] = {
9470       arguments_0,
9471       arguments_1,
9472       NULL
9473     };
9474     char **r;
9475     int i;
9476     suppress_error = 0;
9477     r = guestfs_command_lines (g, arguments);
9478     if (r == NULL)
9479       return -1;
9480     if (!r[0]) {
9481       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9482       print_strings (r);
9483       return -1;
9484     }
9485     {
9486       char expected[] = "Result1";
9487       if (strcmp (r[0], expected) != 0) {
9488         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9489         return -1;
9490       }
9491     }
9492     if (r[1] != NULL) {
9493       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9494       print_strings (r);
9495       return -1;
9496     }
9497     for (i = 0; r[i] != NULL; ++i)
9498       free (r[i]);
9499     free (r);
9500   }
9501   return 0;
9502 }
9503
9504 static int test_command_lines_1_skip (void)
9505 {
9506   const char *str;
9507
9508   str = getenv ("TEST_ONLY");
9509   if (str)
9510     return strstr (str, "command_lines") == NULL;
9511   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9512   if (str && strcmp (str, "1") == 0) return 1;
9513   str = getenv ("SKIP_TEST_COMMAND_LINES");
9514   if (str && strcmp (str, "1") == 0) return 1;
9515   return 0;
9516 }
9517
9518 static int test_command_lines_1 (void)
9519 {
9520   if (test_command_lines_1_skip ()) {
9521     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9522     return 0;
9523   }
9524
9525   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9526   {
9527     char device[] = "/dev/sda";
9528     int r;
9529     suppress_error = 0;
9530     r = guestfs_blockdev_setrw (g, device);
9531     if (r == -1)
9532       return -1;
9533   }
9534   {
9535     int r;
9536     suppress_error = 0;
9537     r = guestfs_umount_all (g);
9538     if (r == -1)
9539       return -1;
9540   }
9541   {
9542     int r;
9543     suppress_error = 0;
9544     r = guestfs_lvm_remove_all (g);
9545     if (r == -1)
9546       return -1;
9547   }
9548   {
9549     char device[] = "/dev/sda";
9550     char lines_0[] = ",";
9551     char *lines[] = {
9552       lines_0,
9553       NULL
9554     };
9555     int r;
9556     suppress_error = 0;
9557     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9558     if (r == -1)
9559       return -1;
9560   }
9561   {
9562     char fstype[] = "ext2";
9563     char device[] = "/dev/sda1";
9564     int r;
9565     suppress_error = 0;
9566     r = guestfs_mkfs (g, fstype, device);
9567     if (r == -1)
9568       return -1;
9569   }
9570   {
9571     char device[] = "/dev/sda1";
9572     char mountpoint[] = "/";
9573     int r;
9574     suppress_error = 0;
9575     r = guestfs_mount (g, device, mountpoint);
9576     if (r == -1)
9577       return -1;
9578   }
9579   /* TestOutputList for command_lines (1) */
9580   {
9581     char remotefilename[] = "/test-command";
9582     int r;
9583     suppress_error = 0;
9584     r = guestfs_upload (g, "test-command", remotefilename);
9585     if (r == -1)
9586       return -1;
9587   }
9588   {
9589     char path[] = "/test-command";
9590     int r;
9591     suppress_error = 0;
9592     r = guestfs_chmod (g, 493, path);
9593     if (r == -1)
9594       return -1;
9595   }
9596   {
9597     char arguments_0[] = "/test-command";
9598     char arguments_1[] = "2";
9599     char *arguments[] = {
9600       arguments_0,
9601       arguments_1,
9602       NULL
9603     };
9604     char **r;
9605     int i;
9606     suppress_error = 0;
9607     r = guestfs_command_lines (g, arguments);
9608     if (r == NULL)
9609       return -1;
9610     if (!r[0]) {
9611       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
9612       print_strings (r);
9613       return -1;
9614     }
9615     {
9616       char expected[] = "Result2";
9617       if (strcmp (r[0], expected) != 0) {
9618         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9619         return -1;
9620       }
9621     }
9622     if (r[1] != NULL) {
9623       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
9624       print_strings (r);
9625       return -1;
9626     }
9627     for (i = 0; r[i] != NULL; ++i)
9628       free (r[i]);
9629     free (r);
9630   }
9631   return 0;
9632 }
9633
9634 static int test_command_lines_2_skip (void)
9635 {
9636   const char *str;
9637
9638   str = getenv ("TEST_ONLY");
9639   if (str)
9640     return strstr (str, "command_lines") == NULL;
9641   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
9642   if (str && strcmp (str, "1") == 0) return 1;
9643   str = getenv ("SKIP_TEST_COMMAND_LINES");
9644   if (str && strcmp (str, "1") == 0) return 1;
9645   return 0;
9646 }
9647
9648 static int test_command_lines_2 (void)
9649 {
9650   if (test_command_lines_2_skip ()) {
9651     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
9652     return 0;
9653   }
9654
9655   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
9656   {
9657     char device[] = "/dev/sda";
9658     int r;
9659     suppress_error = 0;
9660     r = guestfs_blockdev_setrw (g, device);
9661     if (r == -1)
9662       return -1;
9663   }
9664   {
9665     int r;
9666     suppress_error = 0;
9667     r = guestfs_umount_all (g);
9668     if (r == -1)
9669       return -1;
9670   }
9671   {
9672     int r;
9673     suppress_error = 0;
9674     r = guestfs_lvm_remove_all (g);
9675     if (r == -1)
9676       return -1;
9677   }
9678   {
9679     char device[] = "/dev/sda";
9680     char lines_0[] = ",";
9681     char *lines[] = {
9682       lines_0,
9683       NULL
9684     };
9685     int r;
9686     suppress_error = 0;
9687     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9688     if (r == -1)
9689       return -1;
9690   }
9691   {
9692     char fstype[] = "ext2";
9693     char device[] = "/dev/sda1";
9694     int r;
9695     suppress_error = 0;
9696     r = guestfs_mkfs (g, fstype, device);
9697     if (r == -1)
9698       return -1;
9699   }
9700   {
9701     char device[] = "/dev/sda1";
9702     char mountpoint[] = "/";
9703     int r;
9704     suppress_error = 0;
9705     r = guestfs_mount (g, device, mountpoint);
9706     if (r == -1)
9707       return -1;
9708   }
9709   /* TestOutputList for command_lines (2) */
9710   {
9711     char remotefilename[] = "/test-command";
9712     int r;
9713     suppress_error = 0;
9714     r = guestfs_upload (g, "test-command", remotefilename);
9715     if (r == -1)
9716       return -1;
9717   }
9718   {
9719     char path[] = "/test-command";
9720     int r;
9721     suppress_error = 0;
9722     r = guestfs_chmod (g, 493, path);
9723     if (r == -1)
9724       return -1;
9725   }
9726   {
9727     char arguments_0[] = "/test-command";
9728     char arguments_1[] = "3";
9729     char *arguments[] = {
9730       arguments_0,
9731       arguments_1,
9732       NULL
9733     };
9734     char **r;
9735     int i;
9736     suppress_error = 0;
9737     r = guestfs_command_lines (g, arguments);
9738     if (r == NULL)
9739       return -1;
9740     if (!r[0]) {
9741       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9742       print_strings (r);
9743       return -1;
9744     }
9745     {
9746       char expected[] = "";
9747       if (strcmp (r[0], expected) != 0) {
9748         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9749         return -1;
9750       }
9751     }
9752     if (!r[1]) {
9753       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9754       print_strings (r);
9755       return -1;
9756     }
9757     {
9758       char expected[] = "Result3";
9759       if (strcmp (r[1], expected) != 0) {
9760         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9761         return -1;
9762       }
9763     }
9764     if (r[2] != NULL) {
9765       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
9766       print_strings (r);
9767       return -1;
9768     }
9769     for (i = 0; r[i] != NULL; ++i)
9770       free (r[i]);
9771     free (r);
9772   }
9773   return 0;
9774 }
9775
9776 static int test_command_lines_3_skip (void)
9777 {
9778   const char *str;
9779
9780   str = getenv ("TEST_ONLY");
9781   if (str)
9782     return strstr (str, "command_lines") == NULL;
9783   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
9784   if (str && strcmp (str, "1") == 0) return 1;
9785   str = getenv ("SKIP_TEST_COMMAND_LINES");
9786   if (str && strcmp (str, "1") == 0) return 1;
9787   return 0;
9788 }
9789
9790 static int test_command_lines_3 (void)
9791 {
9792   if (test_command_lines_3_skip ()) {
9793     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
9794     return 0;
9795   }
9796
9797   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
9798   {
9799     char device[] = "/dev/sda";
9800     int r;
9801     suppress_error = 0;
9802     r = guestfs_blockdev_setrw (g, device);
9803     if (r == -1)
9804       return -1;
9805   }
9806   {
9807     int r;
9808     suppress_error = 0;
9809     r = guestfs_umount_all (g);
9810     if (r == -1)
9811       return -1;
9812   }
9813   {
9814     int r;
9815     suppress_error = 0;
9816     r = guestfs_lvm_remove_all (g);
9817     if (r == -1)
9818       return -1;
9819   }
9820   {
9821     char device[] = "/dev/sda";
9822     char lines_0[] = ",";
9823     char *lines[] = {
9824       lines_0,
9825       NULL
9826     };
9827     int r;
9828     suppress_error = 0;
9829     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9830     if (r == -1)
9831       return -1;
9832   }
9833   {
9834     char fstype[] = "ext2";
9835     char device[] = "/dev/sda1";
9836     int r;
9837     suppress_error = 0;
9838     r = guestfs_mkfs (g, fstype, device);
9839     if (r == -1)
9840       return -1;
9841   }
9842   {
9843     char device[] = "/dev/sda1";
9844     char mountpoint[] = "/";
9845     int r;
9846     suppress_error = 0;
9847     r = guestfs_mount (g, device, mountpoint);
9848     if (r == -1)
9849       return -1;
9850   }
9851   /* TestOutputList for command_lines (3) */
9852   {
9853     char remotefilename[] = "/test-command";
9854     int r;
9855     suppress_error = 0;
9856     r = guestfs_upload (g, "test-command", remotefilename);
9857     if (r == -1)
9858       return -1;
9859   }
9860   {
9861     char path[] = "/test-command";
9862     int r;
9863     suppress_error = 0;
9864     r = guestfs_chmod (g, 493, path);
9865     if (r == -1)
9866       return -1;
9867   }
9868   {
9869     char arguments_0[] = "/test-command";
9870     char arguments_1[] = "4";
9871     char *arguments[] = {
9872       arguments_0,
9873       arguments_1,
9874       NULL
9875     };
9876     char **r;
9877     int i;
9878     suppress_error = 0;
9879     r = guestfs_command_lines (g, arguments);
9880     if (r == NULL)
9881       return -1;
9882     if (!r[0]) {
9883       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
9884       print_strings (r);
9885       return -1;
9886     }
9887     {
9888       char expected[] = "";
9889       if (strcmp (r[0], expected) != 0) {
9890         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9891         return -1;
9892       }
9893     }
9894     if (!r[1]) {
9895       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
9896       print_strings (r);
9897       return -1;
9898     }
9899     {
9900       char expected[] = "Result4";
9901       if (strcmp (r[1], expected) != 0) {
9902         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9903         return -1;
9904       }
9905     }
9906     if (r[2] != NULL) {
9907       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
9908       print_strings (r);
9909       return -1;
9910     }
9911     for (i = 0; r[i] != NULL; ++i)
9912       free (r[i]);
9913     free (r);
9914   }
9915   return 0;
9916 }
9917
9918 static int test_command_lines_4_skip (void)
9919 {
9920   const char *str;
9921
9922   str = getenv ("TEST_ONLY");
9923   if (str)
9924     return strstr (str, "command_lines") == NULL;
9925   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
9926   if (str && strcmp (str, "1") == 0) return 1;
9927   str = getenv ("SKIP_TEST_COMMAND_LINES");
9928   if (str && strcmp (str, "1") == 0) return 1;
9929   return 0;
9930 }
9931
9932 static int test_command_lines_4 (void)
9933 {
9934   if (test_command_lines_4_skip ()) {
9935     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
9936     return 0;
9937   }
9938
9939   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
9940   {
9941     char device[] = "/dev/sda";
9942     int r;
9943     suppress_error = 0;
9944     r = guestfs_blockdev_setrw (g, device);
9945     if (r == -1)
9946       return -1;
9947   }
9948   {
9949     int r;
9950     suppress_error = 0;
9951     r = guestfs_umount_all (g);
9952     if (r == -1)
9953       return -1;
9954   }
9955   {
9956     int r;
9957     suppress_error = 0;
9958     r = guestfs_lvm_remove_all (g);
9959     if (r == -1)
9960       return -1;
9961   }
9962   {
9963     char device[] = "/dev/sda";
9964     char lines_0[] = ",";
9965     char *lines[] = {
9966       lines_0,
9967       NULL
9968     };
9969     int r;
9970     suppress_error = 0;
9971     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9972     if (r == -1)
9973       return -1;
9974   }
9975   {
9976     char fstype[] = "ext2";
9977     char device[] = "/dev/sda1";
9978     int r;
9979     suppress_error = 0;
9980     r = guestfs_mkfs (g, fstype, device);
9981     if (r == -1)
9982       return -1;
9983   }
9984   {
9985     char device[] = "/dev/sda1";
9986     char mountpoint[] = "/";
9987     int r;
9988     suppress_error = 0;
9989     r = guestfs_mount (g, device, mountpoint);
9990     if (r == -1)
9991       return -1;
9992   }
9993   /* TestOutputList for command_lines (4) */
9994   {
9995     char remotefilename[] = "/test-command";
9996     int r;
9997     suppress_error = 0;
9998     r = guestfs_upload (g, "test-command", remotefilename);
9999     if (r == -1)
10000       return -1;
10001   }
10002   {
10003     char path[] = "/test-command";
10004     int r;
10005     suppress_error = 0;
10006     r = guestfs_chmod (g, 493, path);
10007     if (r == -1)
10008       return -1;
10009   }
10010   {
10011     char arguments_0[] = "/test-command";
10012     char arguments_1[] = "5";
10013     char *arguments[] = {
10014       arguments_0,
10015       arguments_1,
10016       NULL
10017     };
10018     char **r;
10019     int i;
10020     suppress_error = 0;
10021     r = guestfs_command_lines (g, arguments);
10022     if (r == NULL)
10023       return -1;
10024     if (!r[0]) {
10025       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10026       print_strings (r);
10027       return -1;
10028     }
10029     {
10030       char expected[] = "";
10031       if (strcmp (r[0], expected) != 0) {
10032         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10033         return -1;
10034       }
10035     }
10036     if (!r[1]) {
10037       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10038       print_strings (r);
10039       return -1;
10040     }
10041     {
10042       char expected[] = "Result5";
10043       if (strcmp (r[1], expected) != 0) {
10044         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10045         return -1;
10046       }
10047     }
10048     if (!r[2]) {
10049       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10050       print_strings (r);
10051       return -1;
10052     }
10053     {
10054       char expected[] = "";
10055       if (strcmp (r[2], expected) != 0) {
10056         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10057         return -1;
10058       }
10059     }
10060     if (r[3] != NULL) {
10061       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10062       print_strings (r);
10063       return -1;
10064     }
10065     for (i = 0; r[i] != NULL; ++i)
10066       free (r[i]);
10067     free (r);
10068   }
10069   return 0;
10070 }
10071
10072 static int test_command_lines_5_skip (void)
10073 {
10074   const char *str;
10075
10076   str = getenv ("TEST_ONLY");
10077   if (str)
10078     return strstr (str, "command_lines") == NULL;
10079   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10080   if (str && strcmp (str, "1") == 0) return 1;
10081   str = getenv ("SKIP_TEST_COMMAND_LINES");
10082   if (str && strcmp (str, "1") == 0) return 1;
10083   return 0;
10084 }
10085
10086 static int test_command_lines_5 (void)
10087 {
10088   if (test_command_lines_5_skip ()) {
10089     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10090     return 0;
10091   }
10092
10093   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10094   {
10095     char device[] = "/dev/sda";
10096     int r;
10097     suppress_error = 0;
10098     r = guestfs_blockdev_setrw (g, device);
10099     if (r == -1)
10100       return -1;
10101   }
10102   {
10103     int r;
10104     suppress_error = 0;
10105     r = guestfs_umount_all (g);
10106     if (r == -1)
10107       return -1;
10108   }
10109   {
10110     int r;
10111     suppress_error = 0;
10112     r = guestfs_lvm_remove_all (g);
10113     if (r == -1)
10114       return -1;
10115   }
10116   {
10117     char device[] = "/dev/sda";
10118     char lines_0[] = ",";
10119     char *lines[] = {
10120       lines_0,
10121       NULL
10122     };
10123     int r;
10124     suppress_error = 0;
10125     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10126     if (r == -1)
10127       return -1;
10128   }
10129   {
10130     char fstype[] = "ext2";
10131     char device[] = "/dev/sda1";
10132     int r;
10133     suppress_error = 0;
10134     r = guestfs_mkfs (g, fstype, device);
10135     if (r == -1)
10136       return -1;
10137   }
10138   {
10139     char device[] = "/dev/sda1";
10140     char mountpoint[] = "/";
10141     int r;
10142     suppress_error = 0;
10143     r = guestfs_mount (g, device, mountpoint);
10144     if (r == -1)
10145       return -1;
10146   }
10147   /* TestOutputList for command_lines (5) */
10148   {
10149     char remotefilename[] = "/test-command";
10150     int r;
10151     suppress_error = 0;
10152     r = guestfs_upload (g, "test-command", remotefilename);
10153     if (r == -1)
10154       return -1;
10155   }
10156   {
10157     char path[] = "/test-command";
10158     int r;
10159     suppress_error = 0;
10160     r = guestfs_chmod (g, 493, path);
10161     if (r == -1)
10162       return -1;
10163   }
10164   {
10165     char arguments_0[] = "/test-command";
10166     char arguments_1[] = "6";
10167     char *arguments[] = {
10168       arguments_0,
10169       arguments_1,
10170       NULL
10171     };
10172     char **r;
10173     int i;
10174     suppress_error = 0;
10175     r = guestfs_command_lines (g, arguments);
10176     if (r == NULL)
10177       return -1;
10178     if (!r[0]) {
10179       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10180       print_strings (r);
10181       return -1;
10182     }
10183     {
10184       char expected[] = "";
10185       if (strcmp (r[0], expected) != 0) {
10186         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10187         return -1;
10188       }
10189     }
10190     if (!r[1]) {
10191       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10192       print_strings (r);
10193       return -1;
10194     }
10195     {
10196       char expected[] = "";
10197       if (strcmp (r[1], expected) != 0) {
10198         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10199         return -1;
10200       }
10201     }
10202     if (!r[2]) {
10203       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10204       print_strings (r);
10205       return -1;
10206     }
10207     {
10208       char expected[] = "Result6";
10209       if (strcmp (r[2], expected) != 0) {
10210         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10211         return -1;
10212       }
10213     }
10214     if (!r[3]) {
10215       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10216       print_strings (r);
10217       return -1;
10218     }
10219     {
10220       char expected[] = "";
10221       if (strcmp (r[3], expected) != 0) {
10222         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10223         return -1;
10224       }
10225     }
10226     if (r[4] != NULL) {
10227       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10228       print_strings (r);
10229       return -1;
10230     }
10231     for (i = 0; r[i] != NULL; ++i)
10232       free (r[i]);
10233     free (r);
10234   }
10235   return 0;
10236 }
10237
10238 static int test_command_lines_6_skip (void)
10239 {
10240   const char *str;
10241
10242   str = getenv ("TEST_ONLY");
10243   if (str)
10244     return strstr (str, "command_lines") == NULL;
10245   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10246   if (str && strcmp (str, "1") == 0) return 1;
10247   str = getenv ("SKIP_TEST_COMMAND_LINES");
10248   if (str && strcmp (str, "1") == 0) return 1;
10249   return 0;
10250 }
10251
10252 static int test_command_lines_6 (void)
10253 {
10254   if (test_command_lines_6_skip ()) {
10255     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10256     return 0;
10257   }
10258
10259   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10260   {
10261     char device[] = "/dev/sda";
10262     int r;
10263     suppress_error = 0;
10264     r = guestfs_blockdev_setrw (g, device);
10265     if (r == -1)
10266       return -1;
10267   }
10268   {
10269     int r;
10270     suppress_error = 0;
10271     r = guestfs_umount_all (g);
10272     if (r == -1)
10273       return -1;
10274   }
10275   {
10276     int r;
10277     suppress_error = 0;
10278     r = guestfs_lvm_remove_all (g);
10279     if (r == -1)
10280       return -1;
10281   }
10282   {
10283     char device[] = "/dev/sda";
10284     char lines_0[] = ",";
10285     char *lines[] = {
10286       lines_0,
10287       NULL
10288     };
10289     int r;
10290     suppress_error = 0;
10291     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10292     if (r == -1)
10293       return -1;
10294   }
10295   {
10296     char fstype[] = "ext2";
10297     char device[] = "/dev/sda1";
10298     int r;
10299     suppress_error = 0;
10300     r = guestfs_mkfs (g, fstype, device);
10301     if (r == -1)
10302       return -1;
10303   }
10304   {
10305     char device[] = "/dev/sda1";
10306     char mountpoint[] = "/";
10307     int r;
10308     suppress_error = 0;
10309     r = guestfs_mount (g, device, mountpoint);
10310     if (r == -1)
10311       return -1;
10312   }
10313   /* TestOutputList for command_lines (6) */
10314   {
10315     char remotefilename[] = "/test-command";
10316     int r;
10317     suppress_error = 0;
10318     r = guestfs_upload (g, "test-command", remotefilename);
10319     if (r == -1)
10320       return -1;
10321   }
10322   {
10323     char path[] = "/test-command";
10324     int r;
10325     suppress_error = 0;
10326     r = guestfs_chmod (g, 493, path);
10327     if (r == -1)
10328       return -1;
10329   }
10330   {
10331     char arguments_0[] = "/test-command";
10332     char arguments_1[] = "7";
10333     char *arguments[] = {
10334       arguments_0,
10335       arguments_1,
10336       NULL
10337     };
10338     char **r;
10339     int i;
10340     suppress_error = 0;
10341     r = guestfs_command_lines (g, arguments);
10342     if (r == NULL)
10343       return -1;
10344     if (r[0] != NULL) {
10345       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10346       print_strings (r);
10347       return -1;
10348     }
10349     for (i = 0; r[i] != NULL; ++i)
10350       free (r[i]);
10351     free (r);
10352   }
10353   return 0;
10354 }
10355
10356 static int test_command_lines_7_skip (void)
10357 {
10358   const char *str;
10359
10360   str = getenv ("TEST_ONLY");
10361   if (str)
10362     return strstr (str, "command_lines") == NULL;
10363   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10364   if (str && strcmp (str, "1") == 0) return 1;
10365   str = getenv ("SKIP_TEST_COMMAND_LINES");
10366   if (str && strcmp (str, "1") == 0) return 1;
10367   return 0;
10368 }
10369
10370 static int test_command_lines_7 (void)
10371 {
10372   if (test_command_lines_7_skip ()) {
10373     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10374     return 0;
10375   }
10376
10377   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10378   {
10379     char device[] = "/dev/sda";
10380     int r;
10381     suppress_error = 0;
10382     r = guestfs_blockdev_setrw (g, device);
10383     if (r == -1)
10384       return -1;
10385   }
10386   {
10387     int r;
10388     suppress_error = 0;
10389     r = guestfs_umount_all (g);
10390     if (r == -1)
10391       return -1;
10392   }
10393   {
10394     int r;
10395     suppress_error = 0;
10396     r = guestfs_lvm_remove_all (g);
10397     if (r == -1)
10398       return -1;
10399   }
10400   {
10401     char device[] = "/dev/sda";
10402     char lines_0[] = ",";
10403     char *lines[] = {
10404       lines_0,
10405       NULL
10406     };
10407     int r;
10408     suppress_error = 0;
10409     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10410     if (r == -1)
10411       return -1;
10412   }
10413   {
10414     char fstype[] = "ext2";
10415     char device[] = "/dev/sda1";
10416     int r;
10417     suppress_error = 0;
10418     r = guestfs_mkfs (g, fstype, device);
10419     if (r == -1)
10420       return -1;
10421   }
10422   {
10423     char device[] = "/dev/sda1";
10424     char mountpoint[] = "/";
10425     int r;
10426     suppress_error = 0;
10427     r = guestfs_mount (g, device, mountpoint);
10428     if (r == -1)
10429       return -1;
10430   }
10431   /* TestOutputList for command_lines (7) */
10432   {
10433     char remotefilename[] = "/test-command";
10434     int r;
10435     suppress_error = 0;
10436     r = guestfs_upload (g, "test-command", remotefilename);
10437     if (r == -1)
10438       return -1;
10439   }
10440   {
10441     char path[] = "/test-command";
10442     int r;
10443     suppress_error = 0;
10444     r = guestfs_chmod (g, 493, path);
10445     if (r == -1)
10446       return -1;
10447   }
10448   {
10449     char arguments_0[] = "/test-command";
10450     char arguments_1[] = "8";
10451     char *arguments[] = {
10452       arguments_0,
10453       arguments_1,
10454       NULL
10455     };
10456     char **r;
10457     int i;
10458     suppress_error = 0;
10459     r = guestfs_command_lines (g, arguments);
10460     if (r == NULL)
10461       return -1;
10462     if (!r[0]) {
10463       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10464       print_strings (r);
10465       return -1;
10466     }
10467     {
10468       char expected[] = "";
10469       if (strcmp (r[0], expected) != 0) {
10470         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10471         return -1;
10472       }
10473     }
10474     if (r[1] != NULL) {
10475       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10476       print_strings (r);
10477       return -1;
10478     }
10479     for (i = 0; r[i] != NULL; ++i)
10480       free (r[i]);
10481     free (r);
10482   }
10483   return 0;
10484 }
10485
10486 static int test_command_lines_8_skip (void)
10487 {
10488   const char *str;
10489
10490   str = getenv ("TEST_ONLY");
10491   if (str)
10492     return strstr (str, "command_lines") == NULL;
10493   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10494   if (str && strcmp (str, "1") == 0) return 1;
10495   str = getenv ("SKIP_TEST_COMMAND_LINES");
10496   if (str && strcmp (str, "1") == 0) return 1;
10497   return 0;
10498 }
10499
10500 static int test_command_lines_8 (void)
10501 {
10502   if (test_command_lines_8_skip ()) {
10503     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10504     return 0;
10505   }
10506
10507   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10508   {
10509     char device[] = "/dev/sda";
10510     int r;
10511     suppress_error = 0;
10512     r = guestfs_blockdev_setrw (g, device);
10513     if (r == -1)
10514       return -1;
10515   }
10516   {
10517     int r;
10518     suppress_error = 0;
10519     r = guestfs_umount_all (g);
10520     if (r == -1)
10521       return -1;
10522   }
10523   {
10524     int r;
10525     suppress_error = 0;
10526     r = guestfs_lvm_remove_all (g);
10527     if (r == -1)
10528       return -1;
10529   }
10530   {
10531     char device[] = "/dev/sda";
10532     char lines_0[] = ",";
10533     char *lines[] = {
10534       lines_0,
10535       NULL
10536     };
10537     int r;
10538     suppress_error = 0;
10539     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10540     if (r == -1)
10541       return -1;
10542   }
10543   {
10544     char fstype[] = "ext2";
10545     char device[] = "/dev/sda1";
10546     int r;
10547     suppress_error = 0;
10548     r = guestfs_mkfs (g, fstype, device);
10549     if (r == -1)
10550       return -1;
10551   }
10552   {
10553     char device[] = "/dev/sda1";
10554     char mountpoint[] = "/";
10555     int r;
10556     suppress_error = 0;
10557     r = guestfs_mount (g, device, mountpoint);
10558     if (r == -1)
10559       return -1;
10560   }
10561   /* TestOutputList for command_lines (8) */
10562   {
10563     char remotefilename[] = "/test-command";
10564     int r;
10565     suppress_error = 0;
10566     r = guestfs_upload (g, "test-command", remotefilename);
10567     if (r == -1)
10568       return -1;
10569   }
10570   {
10571     char path[] = "/test-command";
10572     int r;
10573     suppress_error = 0;
10574     r = guestfs_chmod (g, 493, path);
10575     if (r == -1)
10576       return -1;
10577   }
10578   {
10579     char arguments_0[] = "/test-command";
10580     char arguments_1[] = "9";
10581     char *arguments[] = {
10582       arguments_0,
10583       arguments_1,
10584       NULL
10585     };
10586     char **r;
10587     int i;
10588     suppress_error = 0;
10589     r = guestfs_command_lines (g, arguments);
10590     if (r == NULL)
10591       return -1;
10592     if (!r[0]) {
10593       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10594       print_strings (r);
10595       return -1;
10596     }
10597     {
10598       char expected[] = "";
10599       if (strcmp (r[0], expected) != 0) {
10600         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10601         return -1;
10602       }
10603     }
10604     if (!r[1]) {
10605       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10606       print_strings (r);
10607       return -1;
10608     }
10609     {
10610       char expected[] = "";
10611       if (strcmp (r[1], expected) != 0) {
10612         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10613         return -1;
10614       }
10615     }
10616     if (r[2] != NULL) {
10617       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
10618       print_strings (r);
10619       return -1;
10620     }
10621     for (i = 0; r[i] != NULL; ++i)
10622       free (r[i]);
10623     free (r);
10624   }
10625   return 0;
10626 }
10627
10628 static int test_command_lines_9_skip (void)
10629 {
10630   const char *str;
10631
10632   str = getenv ("TEST_ONLY");
10633   if (str)
10634     return strstr (str, "command_lines") == NULL;
10635   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
10636   if (str && strcmp (str, "1") == 0) return 1;
10637   str = getenv ("SKIP_TEST_COMMAND_LINES");
10638   if (str && strcmp (str, "1") == 0) return 1;
10639   return 0;
10640 }
10641
10642 static int test_command_lines_9 (void)
10643 {
10644   if (test_command_lines_9_skip ()) {
10645     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
10646     return 0;
10647   }
10648
10649   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
10650   {
10651     char device[] = "/dev/sda";
10652     int r;
10653     suppress_error = 0;
10654     r = guestfs_blockdev_setrw (g, device);
10655     if (r == -1)
10656       return -1;
10657   }
10658   {
10659     int r;
10660     suppress_error = 0;
10661     r = guestfs_umount_all (g);
10662     if (r == -1)
10663       return -1;
10664   }
10665   {
10666     int r;
10667     suppress_error = 0;
10668     r = guestfs_lvm_remove_all (g);
10669     if (r == -1)
10670       return -1;
10671   }
10672   {
10673     char device[] = "/dev/sda";
10674     char lines_0[] = ",";
10675     char *lines[] = {
10676       lines_0,
10677       NULL
10678     };
10679     int r;
10680     suppress_error = 0;
10681     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10682     if (r == -1)
10683       return -1;
10684   }
10685   {
10686     char fstype[] = "ext2";
10687     char device[] = "/dev/sda1";
10688     int r;
10689     suppress_error = 0;
10690     r = guestfs_mkfs (g, fstype, device);
10691     if (r == -1)
10692       return -1;
10693   }
10694   {
10695     char device[] = "/dev/sda1";
10696     char mountpoint[] = "/";
10697     int r;
10698     suppress_error = 0;
10699     r = guestfs_mount (g, device, mountpoint);
10700     if (r == -1)
10701       return -1;
10702   }
10703   /* TestOutputList for command_lines (9) */
10704   {
10705     char remotefilename[] = "/test-command";
10706     int r;
10707     suppress_error = 0;
10708     r = guestfs_upload (g, "test-command", remotefilename);
10709     if (r == -1)
10710       return -1;
10711   }
10712   {
10713     char path[] = "/test-command";
10714     int r;
10715     suppress_error = 0;
10716     r = guestfs_chmod (g, 493, path);
10717     if (r == -1)
10718       return -1;
10719   }
10720   {
10721     char arguments_0[] = "/test-command";
10722     char arguments_1[] = "10";
10723     char *arguments[] = {
10724       arguments_0,
10725       arguments_1,
10726       NULL
10727     };
10728     char **r;
10729     int i;
10730     suppress_error = 0;
10731     r = guestfs_command_lines (g, arguments);
10732     if (r == NULL)
10733       return -1;
10734     if (!r[0]) {
10735       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10736       print_strings (r);
10737       return -1;
10738     }
10739     {
10740       char expected[] = "Result10-1";
10741       if (strcmp (r[0], expected) != 0) {
10742         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10743         return -1;
10744       }
10745     }
10746     if (!r[1]) {
10747       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10748       print_strings (r);
10749       return -1;
10750     }
10751     {
10752       char expected[] = "Result10-2";
10753       if (strcmp (r[1], expected) != 0) {
10754         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10755         return -1;
10756       }
10757     }
10758     if (r[2] != NULL) {
10759       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
10760       print_strings (r);
10761       return -1;
10762     }
10763     for (i = 0; r[i] != NULL; ++i)
10764       free (r[i]);
10765     free (r);
10766   }
10767   return 0;
10768 }
10769
10770 static int test_command_lines_10_skip (void)
10771 {
10772   const char *str;
10773
10774   str = getenv ("TEST_ONLY");
10775   if (str)
10776     return strstr (str, "command_lines") == NULL;
10777   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
10778   if (str && strcmp (str, "1") == 0) return 1;
10779   str = getenv ("SKIP_TEST_COMMAND_LINES");
10780   if (str && strcmp (str, "1") == 0) return 1;
10781   return 0;
10782 }
10783
10784 static int test_command_lines_10 (void)
10785 {
10786   if (test_command_lines_10_skip ()) {
10787     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
10788     return 0;
10789   }
10790
10791   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
10792   {
10793     char device[] = "/dev/sda";
10794     int r;
10795     suppress_error = 0;
10796     r = guestfs_blockdev_setrw (g, device);
10797     if (r == -1)
10798       return -1;
10799   }
10800   {
10801     int r;
10802     suppress_error = 0;
10803     r = guestfs_umount_all (g);
10804     if (r == -1)
10805       return -1;
10806   }
10807   {
10808     int r;
10809     suppress_error = 0;
10810     r = guestfs_lvm_remove_all (g);
10811     if (r == -1)
10812       return -1;
10813   }
10814   {
10815     char device[] = "/dev/sda";
10816     char lines_0[] = ",";
10817     char *lines[] = {
10818       lines_0,
10819       NULL
10820     };
10821     int r;
10822     suppress_error = 0;
10823     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10824     if (r == -1)
10825       return -1;
10826   }
10827   {
10828     char fstype[] = "ext2";
10829     char device[] = "/dev/sda1";
10830     int r;
10831     suppress_error = 0;
10832     r = guestfs_mkfs (g, fstype, device);
10833     if (r == -1)
10834       return -1;
10835   }
10836   {
10837     char device[] = "/dev/sda1";
10838     char mountpoint[] = "/";
10839     int r;
10840     suppress_error = 0;
10841     r = guestfs_mount (g, device, mountpoint);
10842     if (r == -1)
10843       return -1;
10844   }
10845   /* TestOutputList for command_lines (10) */
10846   {
10847     char remotefilename[] = "/test-command";
10848     int r;
10849     suppress_error = 0;
10850     r = guestfs_upload (g, "test-command", remotefilename);
10851     if (r == -1)
10852       return -1;
10853   }
10854   {
10855     char path[] = "/test-command";
10856     int r;
10857     suppress_error = 0;
10858     r = guestfs_chmod (g, 493, path);
10859     if (r == -1)
10860       return -1;
10861   }
10862   {
10863     char arguments_0[] = "/test-command";
10864     char arguments_1[] = "11";
10865     char *arguments[] = {
10866       arguments_0,
10867       arguments_1,
10868       NULL
10869     };
10870     char **r;
10871     int i;
10872     suppress_error = 0;
10873     r = guestfs_command_lines (g, arguments);
10874     if (r == NULL)
10875       return -1;
10876     if (!r[0]) {
10877       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10878       print_strings (r);
10879       return -1;
10880     }
10881     {
10882       char expected[] = "Result11-1";
10883       if (strcmp (r[0], expected) != 0) {
10884         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10885         return -1;
10886       }
10887     }
10888     if (!r[1]) {
10889       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10890       print_strings (r);
10891       return -1;
10892     }
10893     {
10894       char expected[] = "Result11-2";
10895       if (strcmp (r[1], expected) != 0) {
10896         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10897         return -1;
10898       }
10899     }
10900     if (r[2] != NULL) {
10901       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
10902       print_strings (r);
10903       return -1;
10904     }
10905     for (i = 0; r[i] != NULL; ++i)
10906       free (r[i]);
10907     free (r);
10908   }
10909   return 0;
10910 }
10911
10912 static int test_command_0_skip (void)
10913 {
10914   const char *str;
10915
10916   str = getenv ("TEST_ONLY");
10917   if (str)
10918     return strstr (str, "command") == NULL;
10919   str = getenv ("SKIP_TEST_COMMAND_0");
10920   if (str && strcmp (str, "1") == 0) return 1;
10921   str = getenv ("SKIP_TEST_COMMAND");
10922   if (str && strcmp (str, "1") == 0) return 1;
10923   return 0;
10924 }
10925
10926 static int test_command_0 (void)
10927 {
10928   if (test_command_0_skip ()) {
10929     printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
10930     return 0;
10931   }
10932
10933   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
10934   {
10935     char device[] = "/dev/sda";
10936     int r;
10937     suppress_error = 0;
10938     r = guestfs_blockdev_setrw (g, device);
10939     if (r == -1)
10940       return -1;
10941   }
10942   {
10943     int r;
10944     suppress_error = 0;
10945     r = guestfs_umount_all (g);
10946     if (r == -1)
10947       return -1;
10948   }
10949   {
10950     int r;
10951     suppress_error = 0;
10952     r = guestfs_lvm_remove_all (g);
10953     if (r == -1)
10954       return -1;
10955   }
10956   {
10957     char device[] = "/dev/sda";
10958     char lines_0[] = ",";
10959     char *lines[] = {
10960       lines_0,
10961       NULL
10962     };
10963     int r;
10964     suppress_error = 0;
10965     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10966     if (r == -1)
10967       return -1;
10968   }
10969   {
10970     char fstype[] = "ext2";
10971     char device[] = "/dev/sda1";
10972     int r;
10973     suppress_error = 0;
10974     r = guestfs_mkfs (g, fstype, device);
10975     if (r == -1)
10976       return -1;
10977   }
10978   {
10979     char device[] = "/dev/sda1";
10980     char mountpoint[] = "/";
10981     int r;
10982     suppress_error = 0;
10983     r = guestfs_mount (g, device, mountpoint);
10984     if (r == -1)
10985       return -1;
10986   }
10987   /* TestOutput for command (0) */
10988   char expected[] = "Result1";
10989   {
10990     char remotefilename[] = "/test-command";
10991     int r;
10992     suppress_error = 0;
10993     r = guestfs_upload (g, "test-command", remotefilename);
10994     if (r == -1)
10995       return -1;
10996   }
10997   {
10998     char path[] = "/test-command";
10999     int r;
11000     suppress_error = 0;
11001     r = guestfs_chmod (g, 493, path);
11002     if (r == -1)
11003       return -1;
11004   }
11005   {
11006     char arguments_0[] = "/test-command";
11007     char arguments_1[] = "1";
11008     char *arguments[] = {
11009       arguments_0,
11010       arguments_1,
11011       NULL
11012     };
11013     char *r;
11014     suppress_error = 0;
11015     r = guestfs_command (g, arguments);
11016     if (r == NULL)
11017       return -1;
11018     if (strcmp (r, expected) != 0) {
11019       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11020       return -1;
11021     }
11022     free (r);
11023   }
11024   return 0;
11025 }
11026
11027 static int test_command_1_skip (void)
11028 {
11029   const char *str;
11030
11031   str = getenv ("TEST_ONLY");
11032   if (str)
11033     return strstr (str, "command") == NULL;
11034   str = getenv ("SKIP_TEST_COMMAND_1");
11035   if (str && strcmp (str, "1") == 0) return 1;
11036   str = getenv ("SKIP_TEST_COMMAND");
11037   if (str && strcmp (str, "1") == 0) return 1;
11038   return 0;
11039 }
11040
11041 static int test_command_1 (void)
11042 {
11043   if (test_command_1_skip ()) {
11044     printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11045     return 0;
11046   }
11047
11048   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11049   {
11050     char device[] = "/dev/sda";
11051     int r;
11052     suppress_error = 0;
11053     r = guestfs_blockdev_setrw (g, device);
11054     if (r == -1)
11055       return -1;
11056   }
11057   {
11058     int r;
11059     suppress_error = 0;
11060     r = guestfs_umount_all (g);
11061     if (r == -1)
11062       return -1;
11063   }
11064   {
11065     int r;
11066     suppress_error = 0;
11067     r = guestfs_lvm_remove_all (g);
11068     if (r == -1)
11069       return -1;
11070   }
11071   {
11072     char device[] = "/dev/sda";
11073     char lines_0[] = ",";
11074     char *lines[] = {
11075       lines_0,
11076       NULL
11077     };
11078     int r;
11079     suppress_error = 0;
11080     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11081     if (r == -1)
11082       return -1;
11083   }
11084   {
11085     char fstype[] = "ext2";
11086     char device[] = "/dev/sda1";
11087     int r;
11088     suppress_error = 0;
11089     r = guestfs_mkfs (g, fstype, device);
11090     if (r == -1)
11091       return -1;
11092   }
11093   {
11094     char device[] = "/dev/sda1";
11095     char mountpoint[] = "/";
11096     int r;
11097     suppress_error = 0;
11098     r = guestfs_mount (g, device, mountpoint);
11099     if (r == -1)
11100       return -1;
11101   }
11102   /* TestOutput for command (1) */
11103   char expected[] = "Result2\n";
11104   {
11105     char remotefilename[] = "/test-command";
11106     int r;
11107     suppress_error = 0;
11108     r = guestfs_upload (g, "test-command", remotefilename);
11109     if (r == -1)
11110       return -1;
11111   }
11112   {
11113     char path[] = "/test-command";
11114     int r;
11115     suppress_error = 0;
11116     r = guestfs_chmod (g, 493, path);
11117     if (r == -1)
11118       return -1;
11119   }
11120   {
11121     char arguments_0[] = "/test-command";
11122     char arguments_1[] = "2";
11123     char *arguments[] = {
11124       arguments_0,
11125       arguments_1,
11126       NULL
11127     };
11128     char *r;
11129     suppress_error = 0;
11130     r = guestfs_command (g, arguments);
11131     if (r == NULL)
11132       return -1;
11133     if (strcmp (r, expected) != 0) {
11134       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11135       return -1;
11136     }
11137     free (r);
11138   }
11139   return 0;
11140 }
11141
11142 static int test_command_2_skip (void)
11143 {
11144   const char *str;
11145
11146   str = getenv ("TEST_ONLY");
11147   if (str)
11148     return strstr (str, "command") == NULL;
11149   str = getenv ("SKIP_TEST_COMMAND_2");
11150   if (str && strcmp (str, "1") == 0) return 1;
11151   str = getenv ("SKIP_TEST_COMMAND");
11152   if (str && strcmp (str, "1") == 0) return 1;
11153   return 0;
11154 }
11155
11156 static int test_command_2 (void)
11157 {
11158   if (test_command_2_skip ()) {
11159     printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11160     return 0;
11161   }
11162
11163   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11164   {
11165     char device[] = "/dev/sda";
11166     int r;
11167     suppress_error = 0;
11168     r = guestfs_blockdev_setrw (g, device);
11169     if (r == -1)
11170       return -1;
11171   }
11172   {
11173     int r;
11174     suppress_error = 0;
11175     r = guestfs_umount_all (g);
11176     if (r == -1)
11177       return -1;
11178   }
11179   {
11180     int r;
11181     suppress_error = 0;
11182     r = guestfs_lvm_remove_all (g);
11183     if (r == -1)
11184       return -1;
11185   }
11186   {
11187     char device[] = "/dev/sda";
11188     char lines_0[] = ",";
11189     char *lines[] = {
11190       lines_0,
11191       NULL
11192     };
11193     int r;
11194     suppress_error = 0;
11195     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11196     if (r == -1)
11197       return -1;
11198   }
11199   {
11200     char fstype[] = "ext2";
11201     char device[] = "/dev/sda1";
11202     int r;
11203     suppress_error = 0;
11204     r = guestfs_mkfs (g, fstype, device);
11205     if (r == -1)
11206       return -1;
11207   }
11208   {
11209     char device[] = "/dev/sda1";
11210     char mountpoint[] = "/";
11211     int r;
11212     suppress_error = 0;
11213     r = guestfs_mount (g, device, mountpoint);
11214     if (r == -1)
11215       return -1;
11216   }
11217   /* TestOutput for command (2) */
11218   char expected[] = "\nResult3";
11219   {
11220     char remotefilename[] = "/test-command";
11221     int r;
11222     suppress_error = 0;
11223     r = guestfs_upload (g, "test-command", remotefilename);
11224     if (r == -1)
11225       return -1;
11226   }
11227   {
11228     char path[] = "/test-command";
11229     int r;
11230     suppress_error = 0;
11231     r = guestfs_chmod (g, 493, path);
11232     if (r == -1)
11233       return -1;
11234   }
11235   {
11236     char arguments_0[] = "/test-command";
11237     char arguments_1[] = "3";
11238     char *arguments[] = {
11239       arguments_0,
11240       arguments_1,
11241       NULL
11242     };
11243     char *r;
11244     suppress_error = 0;
11245     r = guestfs_command (g, arguments);
11246     if (r == NULL)
11247       return -1;
11248     if (strcmp (r, expected) != 0) {
11249       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11250       return -1;
11251     }
11252     free (r);
11253   }
11254   return 0;
11255 }
11256
11257 static int test_command_3_skip (void)
11258 {
11259   const char *str;
11260
11261   str = getenv ("TEST_ONLY");
11262   if (str)
11263     return strstr (str, "command") == NULL;
11264   str = getenv ("SKIP_TEST_COMMAND_3");
11265   if (str && strcmp (str, "1") == 0) return 1;
11266   str = getenv ("SKIP_TEST_COMMAND");
11267   if (str && strcmp (str, "1") == 0) return 1;
11268   return 0;
11269 }
11270
11271 static int test_command_3 (void)
11272 {
11273   if (test_command_3_skip ()) {
11274     printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11275     return 0;
11276   }
11277
11278   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11279   {
11280     char device[] = "/dev/sda";
11281     int r;
11282     suppress_error = 0;
11283     r = guestfs_blockdev_setrw (g, device);
11284     if (r == -1)
11285       return -1;
11286   }
11287   {
11288     int r;
11289     suppress_error = 0;
11290     r = guestfs_umount_all (g);
11291     if (r == -1)
11292       return -1;
11293   }
11294   {
11295     int r;
11296     suppress_error = 0;
11297     r = guestfs_lvm_remove_all (g);
11298     if (r == -1)
11299       return -1;
11300   }
11301   {
11302     char device[] = "/dev/sda";
11303     char lines_0[] = ",";
11304     char *lines[] = {
11305       lines_0,
11306       NULL
11307     };
11308     int r;
11309     suppress_error = 0;
11310     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11311     if (r == -1)
11312       return -1;
11313   }
11314   {
11315     char fstype[] = "ext2";
11316     char device[] = "/dev/sda1";
11317     int r;
11318     suppress_error = 0;
11319     r = guestfs_mkfs (g, fstype, device);
11320     if (r == -1)
11321       return -1;
11322   }
11323   {
11324     char device[] = "/dev/sda1";
11325     char mountpoint[] = "/";
11326     int r;
11327     suppress_error = 0;
11328     r = guestfs_mount (g, device, mountpoint);
11329     if (r == -1)
11330       return -1;
11331   }
11332   /* TestOutput for command (3) */
11333   char expected[] = "\nResult4\n";
11334   {
11335     char remotefilename[] = "/test-command";
11336     int r;
11337     suppress_error = 0;
11338     r = guestfs_upload (g, "test-command", remotefilename);
11339     if (r == -1)
11340       return -1;
11341   }
11342   {
11343     char path[] = "/test-command";
11344     int r;
11345     suppress_error = 0;
11346     r = guestfs_chmod (g, 493, path);
11347     if (r == -1)
11348       return -1;
11349   }
11350   {
11351     char arguments_0[] = "/test-command";
11352     char arguments_1[] = "4";
11353     char *arguments[] = {
11354       arguments_0,
11355       arguments_1,
11356       NULL
11357     };
11358     char *r;
11359     suppress_error = 0;
11360     r = guestfs_command (g, arguments);
11361     if (r == NULL)
11362       return -1;
11363     if (strcmp (r, expected) != 0) {
11364       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11365       return -1;
11366     }
11367     free (r);
11368   }
11369   return 0;
11370 }
11371
11372 static int test_command_4_skip (void)
11373 {
11374   const char *str;
11375
11376   str = getenv ("TEST_ONLY");
11377   if (str)
11378     return strstr (str, "command") == NULL;
11379   str = getenv ("SKIP_TEST_COMMAND_4");
11380   if (str && strcmp (str, "1") == 0) return 1;
11381   str = getenv ("SKIP_TEST_COMMAND");
11382   if (str && strcmp (str, "1") == 0) return 1;
11383   return 0;
11384 }
11385
11386 static int test_command_4 (void)
11387 {
11388   if (test_command_4_skip ()) {
11389     printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11390     return 0;
11391   }
11392
11393   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11394   {
11395     char device[] = "/dev/sda";
11396     int r;
11397     suppress_error = 0;
11398     r = guestfs_blockdev_setrw (g, device);
11399     if (r == -1)
11400       return -1;
11401   }
11402   {
11403     int r;
11404     suppress_error = 0;
11405     r = guestfs_umount_all (g);
11406     if (r == -1)
11407       return -1;
11408   }
11409   {
11410     int r;
11411     suppress_error = 0;
11412     r = guestfs_lvm_remove_all (g);
11413     if (r == -1)
11414       return -1;
11415   }
11416   {
11417     char device[] = "/dev/sda";
11418     char lines_0[] = ",";
11419     char *lines[] = {
11420       lines_0,
11421       NULL
11422     };
11423     int r;
11424     suppress_error = 0;
11425     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11426     if (r == -1)
11427       return -1;
11428   }
11429   {
11430     char fstype[] = "ext2";
11431     char device[] = "/dev/sda1";
11432     int r;
11433     suppress_error = 0;
11434     r = guestfs_mkfs (g, fstype, device);
11435     if (r == -1)
11436       return -1;
11437   }
11438   {
11439     char device[] = "/dev/sda1";
11440     char mountpoint[] = "/";
11441     int r;
11442     suppress_error = 0;
11443     r = guestfs_mount (g, device, mountpoint);
11444     if (r == -1)
11445       return -1;
11446   }
11447   /* TestOutput for command (4) */
11448   char expected[] = "\nResult5\n\n";
11449   {
11450     char remotefilename[] = "/test-command";
11451     int r;
11452     suppress_error = 0;
11453     r = guestfs_upload (g, "test-command", remotefilename);
11454     if (r == -1)
11455       return -1;
11456   }
11457   {
11458     char path[] = "/test-command";
11459     int r;
11460     suppress_error = 0;
11461     r = guestfs_chmod (g, 493, path);
11462     if (r == -1)
11463       return -1;
11464   }
11465   {
11466     char arguments_0[] = "/test-command";
11467     char arguments_1[] = "5";
11468     char *arguments[] = {
11469       arguments_0,
11470       arguments_1,
11471       NULL
11472     };
11473     char *r;
11474     suppress_error = 0;
11475     r = guestfs_command (g, arguments);
11476     if (r == NULL)
11477       return -1;
11478     if (strcmp (r, expected) != 0) {
11479       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11480       return -1;
11481     }
11482     free (r);
11483   }
11484   return 0;
11485 }
11486
11487 static int test_command_5_skip (void)
11488 {
11489   const char *str;
11490
11491   str = getenv ("TEST_ONLY");
11492   if (str)
11493     return strstr (str, "command") == NULL;
11494   str = getenv ("SKIP_TEST_COMMAND_5");
11495   if (str && strcmp (str, "1") == 0) return 1;
11496   str = getenv ("SKIP_TEST_COMMAND");
11497   if (str && strcmp (str, "1") == 0) return 1;
11498   return 0;
11499 }
11500
11501 static int test_command_5 (void)
11502 {
11503   if (test_command_5_skip ()) {
11504     printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11505     return 0;
11506   }
11507
11508   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11509   {
11510     char device[] = "/dev/sda";
11511     int r;
11512     suppress_error = 0;
11513     r = guestfs_blockdev_setrw (g, device);
11514     if (r == -1)
11515       return -1;
11516   }
11517   {
11518     int r;
11519     suppress_error = 0;
11520     r = guestfs_umount_all (g);
11521     if (r == -1)
11522       return -1;
11523   }
11524   {
11525     int r;
11526     suppress_error = 0;
11527     r = guestfs_lvm_remove_all (g);
11528     if (r == -1)
11529       return -1;
11530   }
11531   {
11532     char device[] = "/dev/sda";
11533     char lines_0[] = ",";
11534     char *lines[] = {
11535       lines_0,
11536       NULL
11537     };
11538     int r;
11539     suppress_error = 0;
11540     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11541     if (r == -1)
11542       return -1;
11543   }
11544   {
11545     char fstype[] = "ext2";
11546     char device[] = "/dev/sda1";
11547     int r;
11548     suppress_error = 0;
11549     r = guestfs_mkfs (g, fstype, device);
11550     if (r == -1)
11551       return -1;
11552   }
11553   {
11554     char device[] = "/dev/sda1";
11555     char mountpoint[] = "/";
11556     int r;
11557     suppress_error = 0;
11558     r = guestfs_mount (g, device, mountpoint);
11559     if (r == -1)
11560       return -1;
11561   }
11562   /* TestOutput for command (5) */
11563   char expected[] = "\n\nResult6\n\n";
11564   {
11565     char remotefilename[] = "/test-command";
11566     int r;
11567     suppress_error = 0;
11568     r = guestfs_upload (g, "test-command", remotefilename);
11569     if (r == -1)
11570       return -1;
11571   }
11572   {
11573     char path[] = "/test-command";
11574     int r;
11575     suppress_error = 0;
11576     r = guestfs_chmod (g, 493, path);
11577     if (r == -1)
11578       return -1;
11579   }
11580   {
11581     char arguments_0[] = "/test-command";
11582     char arguments_1[] = "6";
11583     char *arguments[] = {
11584       arguments_0,
11585       arguments_1,
11586       NULL
11587     };
11588     char *r;
11589     suppress_error = 0;
11590     r = guestfs_command (g, arguments);
11591     if (r == NULL)
11592       return -1;
11593     if (strcmp (r, expected) != 0) {
11594       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
11595       return -1;
11596     }
11597     free (r);
11598   }
11599   return 0;
11600 }
11601
11602 static int test_command_6_skip (void)
11603 {
11604   const char *str;
11605
11606   str = getenv ("TEST_ONLY");
11607   if (str)
11608     return strstr (str, "command") == NULL;
11609   str = getenv ("SKIP_TEST_COMMAND_6");
11610   if (str && strcmp (str, "1") == 0) return 1;
11611   str = getenv ("SKIP_TEST_COMMAND");
11612   if (str && strcmp (str, "1") == 0) return 1;
11613   return 0;
11614 }
11615
11616 static int test_command_6 (void)
11617 {
11618   if (test_command_6_skip ()) {
11619     printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
11620     return 0;
11621   }
11622
11623   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
11624   {
11625     char device[] = "/dev/sda";
11626     int r;
11627     suppress_error = 0;
11628     r = guestfs_blockdev_setrw (g, device);
11629     if (r == -1)
11630       return -1;
11631   }
11632   {
11633     int r;
11634     suppress_error = 0;
11635     r = guestfs_umount_all (g);
11636     if (r == -1)
11637       return -1;
11638   }
11639   {
11640     int r;
11641     suppress_error = 0;
11642     r = guestfs_lvm_remove_all (g);
11643     if (r == -1)
11644       return -1;
11645   }
11646   {
11647     char device[] = "/dev/sda";
11648     char lines_0[] = ",";
11649     char *lines[] = {
11650       lines_0,
11651       NULL
11652     };
11653     int r;
11654     suppress_error = 0;
11655     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11656     if (r == -1)
11657       return -1;
11658   }
11659   {
11660     char fstype[] = "ext2";
11661     char device[] = "/dev/sda1";
11662     int r;
11663     suppress_error = 0;
11664     r = guestfs_mkfs (g, fstype, device);
11665     if (r == -1)
11666       return -1;
11667   }
11668   {
11669     char device[] = "/dev/sda1";
11670     char mountpoint[] = "/";
11671     int r;
11672     suppress_error = 0;
11673     r = guestfs_mount (g, device, mountpoint);
11674     if (r == -1)
11675       return -1;
11676   }
11677   /* TestOutput for command (6) */
11678   char expected[] = "";
11679   {
11680     char remotefilename[] = "/test-command";
11681     int r;
11682     suppress_error = 0;
11683     r = guestfs_upload (g, "test-command", remotefilename);
11684     if (r == -1)
11685       return -1;
11686   }
11687   {
11688     char path[] = "/test-command";
11689     int r;
11690     suppress_error = 0;
11691     r = guestfs_chmod (g, 493, path);
11692     if (r == -1)
11693       return -1;
11694   }
11695   {
11696     char arguments_0[] = "/test-command";
11697     char arguments_1[] = "7";
11698     char *arguments[] = {
11699       arguments_0,
11700       arguments_1,
11701       NULL
11702     };
11703     char *r;
11704     suppress_error = 0;
11705     r = guestfs_command (g, arguments);
11706     if (r == NULL)
11707       return -1;
11708     if (strcmp (r, expected) != 0) {
11709       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
11710       return -1;
11711     }
11712     free (r);
11713   }
11714   return 0;
11715 }
11716
11717 static int test_command_7_skip (void)
11718 {
11719   const char *str;
11720
11721   str = getenv ("TEST_ONLY");
11722   if (str)
11723     return strstr (str, "command") == NULL;
11724   str = getenv ("SKIP_TEST_COMMAND_7");
11725   if (str && strcmp (str, "1") == 0) return 1;
11726   str = getenv ("SKIP_TEST_COMMAND");
11727   if (str && strcmp (str, "1") == 0) return 1;
11728   return 0;
11729 }
11730
11731 static int test_command_7 (void)
11732 {
11733   if (test_command_7_skip ()) {
11734     printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
11735     return 0;
11736   }
11737
11738   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
11739   {
11740     char device[] = "/dev/sda";
11741     int r;
11742     suppress_error = 0;
11743     r = guestfs_blockdev_setrw (g, device);
11744     if (r == -1)
11745       return -1;
11746   }
11747   {
11748     int r;
11749     suppress_error = 0;
11750     r = guestfs_umount_all (g);
11751     if (r == -1)
11752       return -1;
11753   }
11754   {
11755     int r;
11756     suppress_error = 0;
11757     r = guestfs_lvm_remove_all (g);
11758     if (r == -1)
11759       return -1;
11760   }
11761   {
11762     char device[] = "/dev/sda";
11763     char lines_0[] = ",";
11764     char *lines[] = {
11765       lines_0,
11766       NULL
11767     };
11768     int r;
11769     suppress_error = 0;
11770     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11771     if (r == -1)
11772       return -1;
11773   }
11774   {
11775     char fstype[] = "ext2";
11776     char device[] = "/dev/sda1";
11777     int r;
11778     suppress_error = 0;
11779     r = guestfs_mkfs (g, fstype, device);
11780     if (r == -1)
11781       return -1;
11782   }
11783   {
11784     char device[] = "/dev/sda1";
11785     char mountpoint[] = "/";
11786     int r;
11787     suppress_error = 0;
11788     r = guestfs_mount (g, device, mountpoint);
11789     if (r == -1)
11790       return -1;
11791   }
11792   /* TestOutput for command (7) */
11793   char expected[] = "\n";
11794   {
11795     char remotefilename[] = "/test-command";
11796     int r;
11797     suppress_error = 0;
11798     r = guestfs_upload (g, "test-command", remotefilename);
11799     if (r == -1)
11800       return -1;
11801   }
11802   {
11803     char path[] = "/test-command";
11804     int r;
11805     suppress_error = 0;
11806     r = guestfs_chmod (g, 493, path);
11807     if (r == -1)
11808       return -1;
11809   }
11810   {
11811     char arguments_0[] = "/test-command";
11812     char arguments_1[] = "8";
11813     char *arguments[] = {
11814       arguments_0,
11815       arguments_1,
11816       NULL
11817     };
11818     char *r;
11819     suppress_error = 0;
11820     r = guestfs_command (g, arguments);
11821     if (r == NULL)
11822       return -1;
11823     if (strcmp (r, expected) != 0) {
11824       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
11825       return -1;
11826     }
11827     free (r);
11828   }
11829   return 0;
11830 }
11831
11832 static int test_command_8_skip (void)
11833 {
11834   const char *str;
11835
11836   str = getenv ("TEST_ONLY");
11837   if (str)
11838     return strstr (str, "command") == NULL;
11839   str = getenv ("SKIP_TEST_COMMAND_8");
11840   if (str && strcmp (str, "1") == 0) return 1;
11841   str = getenv ("SKIP_TEST_COMMAND");
11842   if (str && strcmp (str, "1") == 0) return 1;
11843   return 0;
11844 }
11845
11846 static int test_command_8 (void)
11847 {
11848   if (test_command_8_skip ()) {
11849     printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
11850     return 0;
11851   }
11852
11853   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
11854   {
11855     char device[] = "/dev/sda";
11856     int r;
11857     suppress_error = 0;
11858     r = guestfs_blockdev_setrw (g, device);
11859     if (r == -1)
11860       return -1;
11861   }
11862   {
11863     int r;
11864     suppress_error = 0;
11865     r = guestfs_umount_all (g);
11866     if (r == -1)
11867       return -1;
11868   }
11869   {
11870     int r;
11871     suppress_error = 0;
11872     r = guestfs_lvm_remove_all (g);
11873     if (r == -1)
11874       return -1;
11875   }
11876   {
11877     char device[] = "/dev/sda";
11878     char lines_0[] = ",";
11879     char *lines[] = {
11880       lines_0,
11881       NULL
11882     };
11883     int r;
11884     suppress_error = 0;
11885     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11886     if (r == -1)
11887       return -1;
11888   }
11889   {
11890     char fstype[] = "ext2";
11891     char device[] = "/dev/sda1";
11892     int r;
11893     suppress_error = 0;
11894     r = guestfs_mkfs (g, fstype, device);
11895     if (r == -1)
11896       return -1;
11897   }
11898   {
11899     char device[] = "/dev/sda1";
11900     char mountpoint[] = "/";
11901     int r;
11902     suppress_error = 0;
11903     r = guestfs_mount (g, device, mountpoint);
11904     if (r == -1)
11905       return -1;
11906   }
11907   /* TestOutput for command (8) */
11908   char expected[] = "\n\n";
11909   {
11910     char remotefilename[] = "/test-command";
11911     int r;
11912     suppress_error = 0;
11913     r = guestfs_upload (g, "test-command", remotefilename);
11914     if (r == -1)
11915       return -1;
11916   }
11917   {
11918     char path[] = "/test-command";
11919     int r;
11920     suppress_error = 0;
11921     r = guestfs_chmod (g, 493, path);
11922     if (r == -1)
11923       return -1;
11924   }
11925   {
11926     char arguments_0[] = "/test-command";
11927     char arguments_1[] = "9";
11928     char *arguments[] = {
11929       arguments_0,
11930       arguments_1,
11931       NULL
11932     };
11933     char *r;
11934     suppress_error = 0;
11935     r = guestfs_command (g, arguments);
11936     if (r == NULL)
11937       return -1;
11938     if (strcmp (r, expected) != 0) {
11939       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
11940       return -1;
11941     }
11942     free (r);
11943   }
11944   return 0;
11945 }
11946
11947 static int test_command_9_skip (void)
11948 {
11949   const char *str;
11950
11951   str = getenv ("TEST_ONLY");
11952   if (str)
11953     return strstr (str, "command") == NULL;
11954   str = getenv ("SKIP_TEST_COMMAND_9");
11955   if (str && strcmp (str, "1") == 0) return 1;
11956   str = getenv ("SKIP_TEST_COMMAND");
11957   if (str && strcmp (str, "1") == 0) return 1;
11958   return 0;
11959 }
11960
11961 static int test_command_9 (void)
11962 {
11963   if (test_command_9_skip ()) {
11964     printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
11965     return 0;
11966   }
11967
11968   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
11969   {
11970     char device[] = "/dev/sda";
11971     int r;
11972     suppress_error = 0;
11973     r = guestfs_blockdev_setrw (g, device);
11974     if (r == -1)
11975       return -1;
11976   }
11977   {
11978     int r;
11979     suppress_error = 0;
11980     r = guestfs_umount_all (g);
11981     if (r == -1)
11982       return -1;
11983   }
11984   {
11985     int r;
11986     suppress_error = 0;
11987     r = guestfs_lvm_remove_all (g);
11988     if (r == -1)
11989       return -1;
11990   }
11991   {
11992     char device[] = "/dev/sda";
11993     char lines_0[] = ",";
11994     char *lines[] = {
11995       lines_0,
11996       NULL
11997     };
11998     int r;
11999     suppress_error = 0;
12000     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12001     if (r == -1)
12002       return -1;
12003   }
12004   {
12005     char fstype[] = "ext2";
12006     char device[] = "/dev/sda1";
12007     int r;
12008     suppress_error = 0;
12009     r = guestfs_mkfs (g, fstype, device);
12010     if (r == -1)
12011       return -1;
12012   }
12013   {
12014     char device[] = "/dev/sda1";
12015     char mountpoint[] = "/";
12016     int r;
12017     suppress_error = 0;
12018     r = guestfs_mount (g, device, mountpoint);
12019     if (r == -1)
12020       return -1;
12021   }
12022   /* TestOutput for command (9) */
12023   char expected[] = "Result10-1\nResult10-2\n";
12024   {
12025     char remotefilename[] = "/test-command";
12026     int r;
12027     suppress_error = 0;
12028     r = guestfs_upload (g, "test-command", remotefilename);
12029     if (r == -1)
12030       return -1;
12031   }
12032   {
12033     char path[] = "/test-command";
12034     int r;
12035     suppress_error = 0;
12036     r = guestfs_chmod (g, 493, path);
12037     if (r == -1)
12038       return -1;
12039   }
12040   {
12041     char arguments_0[] = "/test-command";
12042     char arguments_1[] = "10";
12043     char *arguments[] = {
12044       arguments_0,
12045       arguments_1,
12046       NULL
12047     };
12048     char *r;
12049     suppress_error = 0;
12050     r = guestfs_command (g, arguments);
12051     if (r == NULL)
12052       return -1;
12053     if (strcmp (r, expected) != 0) {
12054       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12055       return -1;
12056     }
12057     free (r);
12058   }
12059   return 0;
12060 }
12061
12062 static int test_command_10_skip (void)
12063 {
12064   const char *str;
12065
12066   str = getenv ("TEST_ONLY");
12067   if (str)
12068     return strstr (str, "command") == NULL;
12069   str = getenv ("SKIP_TEST_COMMAND_10");
12070   if (str && strcmp (str, "1") == 0) return 1;
12071   str = getenv ("SKIP_TEST_COMMAND");
12072   if (str && strcmp (str, "1") == 0) return 1;
12073   return 0;
12074 }
12075
12076 static int test_command_10 (void)
12077 {
12078   if (test_command_10_skip ()) {
12079     printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12080     return 0;
12081   }
12082
12083   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12084   {
12085     char device[] = "/dev/sda";
12086     int r;
12087     suppress_error = 0;
12088     r = guestfs_blockdev_setrw (g, device);
12089     if (r == -1)
12090       return -1;
12091   }
12092   {
12093     int r;
12094     suppress_error = 0;
12095     r = guestfs_umount_all (g);
12096     if (r == -1)
12097       return -1;
12098   }
12099   {
12100     int r;
12101     suppress_error = 0;
12102     r = guestfs_lvm_remove_all (g);
12103     if (r == -1)
12104       return -1;
12105   }
12106   {
12107     char device[] = "/dev/sda";
12108     char lines_0[] = ",";
12109     char *lines[] = {
12110       lines_0,
12111       NULL
12112     };
12113     int r;
12114     suppress_error = 0;
12115     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12116     if (r == -1)
12117       return -1;
12118   }
12119   {
12120     char fstype[] = "ext2";
12121     char device[] = "/dev/sda1";
12122     int r;
12123     suppress_error = 0;
12124     r = guestfs_mkfs (g, fstype, device);
12125     if (r == -1)
12126       return -1;
12127   }
12128   {
12129     char device[] = "/dev/sda1";
12130     char mountpoint[] = "/";
12131     int r;
12132     suppress_error = 0;
12133     r = guestfs_mount (g, device, mountpoint);
12134     if (r == -1)
12135       return -1;
12136   }
12137   /* TestOutput for command (10) */
12138   char expected[] = "Result11-1\nResult11-2";
12139   {
12140     char remotefilename[] = "/test-command";
12141     int r;
12142     suppress_error = 0;
12143     r = guestfs_upload (g, "test-command", remotefilename);
12144     if (r == -1)
12145       return -1;
12146   }
12147   {
12148     char path[] = "/test-command";
12149     int r;
12150     suppress_error = 0;
12151     r = guestfs_chmod (g, 493, path);
12152     if (r == -1)
12153       return -1;
12154   }
12155   {
12156     char arguments_0[] = "/test-command";
12157     char arguments_1[] = "11";
12158     char *arguments[] = {
12159       arguments_0,
12160       arguments_1,
12161       NULL
12162     };
12163     char *r;
12164     suppress_error = 0;
12165     r = guestfs_command (g, arguments);
12166     if (r == NULL)
12167       return -1;
12168     if (strcmp (r, expected) != 0) {
12169       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12170       return -1;
12171     }
12172     free (r);
12173   }
12174   return 0;
12175 }
12176
12177 static int test_command_11_skip (void)
12178 {
12179   const char *str;
12180
12181   str = getenv ("TEST_ONLY");
12182   if (str)
12183     return strstr (str, "command") == NULL;
12184   str = getenv ("SKIP_TEST_COMMAND_11");
12185   if (str && strcmp (str, "1") == 0) return 1;
12186   str = getenv ("SKIP_TEST_COMMAND");
12187   if (str && strcmp (str, "1") == 0) return 1;
12188   return 0;
12189 }
12190
12191 static int test_command_11 (void)
12192 {
12193   if (test_command_11_skip ()) {
12194     printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12195     return 0;
12196   }
12197
12198   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12199   {
12200     char device[] = "/dev/sda";
12201     int r;
12202     suppress_error = 0;
12203     r = guestfs_blockdev_setrw (g, device);
12204     if (r == -1)
12205       return -1;
12206   }
12207   {
12208     int r;
12209     suppress_error = 0;
12210     r = guestfs_umount_all (g);
12211     if (r == -1)
12212       return -1;
12213   }
12214   {
12215     int r;
12216     suppress_error = 0;
12217     r = guestfs_lvm_remove_all (g);
12218     if (r == -1)
12219       return -1;
12220   }
12221   {
12222     char device[] = "/dev/sda";
12223     char lines_0[] = ",";
12224     char *lines[] = {
12225       lines_0,
12226       NULL
12227     };
12228     int r;
12229     suppress_error = 0;
12230     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12231     if (r == -1)
12232       return -1;
12233   }
12234   {
12235     char fstype[] = "ext2";
12236     char device[] = "/dev/sda1";
12237     int r;
12238     suppress_error = 0;
12239     r = guestfs_mkfs (g, fstype, device);
12240     if (r == -1)
12241       return -1;
12242   }
12243   {
12244     char device[] = "/dev/sda1";
12245     char mountpoint[] = "/";
12246     int r;
12247     suppress_error = 0;
12248     r = guestfs_mount (g, device, mountpoint);
12249     if (r == -1)
12250       return -1;
12251   }
12252   /* TestLastFail for command (11) */
12253   {
12254     char remotefilename[] = "/test-command";
12255     int r;
12256     suppress_error = 0;
12257     r = guestfs_upload (g, "test-command", remotefilename);
12258     if (r == -1)
12259       return -1;
12260   }
12261   {
12262     char path[] = "/test-command";
12263     int r;
12264     suppress_error = 0;
12265     r = guestfs_chmod (g, 493, path);
12266     if (r == -1)
12267       return -1;
12268   }
12269   {
12270     char arguments_0[] = "/test-command";
12271     char *arguments[] = {
12272       arguments_0,
12273       NULL
12274     };
12275     char *r;
12276     suppress_error = 1;
12277     r = guestfs_command (g, arguments);
12278     if (r != NULL)
12279       return -1;
12280     free (r);
12281   }
12282   return 0;
12283 }
12284
12285 static int test_file_0_skip (void)
12286 {
12287   const char *str;
12288
12289   str = getenv ("TEST_ONLY");
12290   if (str)
12291     return strstr (str, "file") == NULL;
12292   str = getenv ("SKIP_TEST_FILE_0");
12293   if (str && strcmp (str, "1") == 0) return 1;
12294   str = getenv ("SKIP_TEST_FILE");
12295   if (str && strcmp (str, "1") == 0) return 1;
12296   return 0;
12297 }
12298
12299 static int test_file_0 (void)
12300 {
12301   if (test_file_0_skip ()) {
12302     printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12303     return 0;
12304   }
12305
12306   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12307   {
12308     char device[] = "/dev/sda";
12309     int r;
12310     suppress_error = 0;
12311     r = guestfs_blockdev_setrw (g, device);
12312     if (r == -1)
12313       return -1;
12314   }
12315   {
12316     int r;
12317     suppress_error = 0;
12318     r = guestfs_umount_all (g);
12319     if (r == -1)
12320       return -1;
12321   }
12322   {
12323     int r;
12324     suppress_error = 0;
12325     r = guestfs_lvm_remove_all (g);
12326     if (r == -1)
12327       return -1;
12328   }
12329   {
12330     char device[] = "/dev/sda";
12331     char lines_0[] = ",";
12332     char *lines[] = {
12333       lines_0,
12334       NULL
12335     };
12336     int r;
12337     suppress_error = 0;
12338     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12339     if (r == -1)
12340       return -1;
12341   }
12342   {
12343     char fstype[] = "ext2";
12344     char device[] = "/dev/sda1";
12345     int r;
12346     suppress_error = 0;
12347     r = guestfs_mkfs (g, fstype, device);
12348     if (r == -1)
12349       return -1;
12350   }
12351   {
12352     char device[] = "/dev/sda1";
12353     char mountpoint[] = "/";
12354     int r;
12355     suppress_error = 0;
12356     r = guestfs_mount (g, device, mountpoint);
12357     if (r == -1)
12358       return -1;
12359   }
12360   /* TestOutput for file (0) */
12361   char expected[] = "empty";
12362   {
12363     char path[] = "/new";
12364     int r;
12365     suppress_error = 0;
12366     r = guestfs_touch (g, path);
12367     if (r == -1)
12368       return -1;
12369   }
12370   {
12371     char path[] = "/new";
12372     char *r;
12373     suppress_error = 0;
12374     r = guestfs_file (g, path);
12375     if (r == NULL)
12376       return -1;
12377     if (strcmp (r, expected) != 0) {
12378       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12379       return -1;
12380     }
12381     free (r);
12382   }
12383   return 0;
12384 }
12385
12386 static int test_file_1_skip (void)
12387 {
12388   const char *str;
12389
12390   str = getenv ("TEST_ONLY");
12391   if (str)
12392     return strstr (str, "file") == NULL;
12393   str = getenv ("SKIP_TEST_FILE_1");
12394   if (str && strcmp (str, "1") == 0) return 1;
12395   str = getenv ("SKIP_TEST_FILE");
12396   if (str && strcmp (str, "1") == 0) return 1;
12397   return 0;
12398 }
12399
12400 static int test_file_1 (void)
12401 {
12402   if (test_file_1_skip ()) {
12403     printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12404     return 0;
12405   }
12406
12407   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12408   {
12409     char device[] = "/dev/sda";
12410     int r;
12411     suppress_error = 0;
12412     r = guestfs_blockdev_setrw (g, device);
12413     if (r == -1)
12414       return -1;
12415   }
12416   {
12417     int r;
12418     suppress_error = 0;
12419     r = guestfs_umount_all (g);
12420     if (r == -1)
12421       return -1;
12422   }
12423   {
12424     int r;
12425     suppress_error = 0;
12426     r = guestfs_lvm_remove_all (g);
12427     if (r == -1)
12428       return -1;
12429   }
12430   {
12431     char device[] = "/dev/sda";
12432     char lines_0[] = ",";
12433     char *lines[] = {
12434       lines_0,
12435       NULL
12436     };
12437     int r;
12438     suppress_error = 0;
12439     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12440     if (r == -1)
12441       return -1;
12442   }
12443   {
12444     char fstype[] = "ext2";
12445     char device[] = "/dev/sda1";
12446     int r;
12447     suppress_error = 0;
12448     r = guestfs_mkfs (g, fstype, device);
12449     if (r == -1)
12450       return -1;
12451   }
12452   {
12453     char device[] = "/dev/sda1";
12454     char mountpoint[] = "/";
12455     int r;
12456     suppress_error = 0;
12457     r = guestfs_mount (g, device, mountpoint);
12458     if (r == -1)
12459       return -1;
12460   }
12461   /* TestOutput for file (1) */
12462   char expected[] = "ASCII text";
12463   {
12464     char path[] = "/new";
12465     char content[] = "some content\n";
12466     int r;
12467     suppress_error = 0;
12468     r = guestfs_write_file (g, path, content, 0);
12469     if (r == -1)
12470       return -1;
12471   }
12472   {
12473     char path[] = "/new";
12474     char *r;
12475     suppress_error = 0;
12476     r = guestfs_file (g, path);
12477     if (r == NULL)
12478       return -1;
12479     if (strcmp (r, expected) != 0) {
12480       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12481       return -1;
12482     }
12483     free (r);
12484   }
12485   return 0;
12486 }
12487
12488 static int test_file_2_skip (void)
12489 {
12490   const char *str;
12491
12492   str = getenv ("TEST_ONLY");
12493   if (str)
12494     return strstr (str, "file") == NULL;
12495   str = getenv ("SKIP_TEST_FILE_2");
12496   if (str && strcmp (str, "1") == 0) return 1;
12497   str = getenv ("SKIP_TEST_FILE");
12498   if (str && strcmp (str, "1") == 0) return 1;
12499   return 0;
12500 }
12501
12502 static int test_file_2 (void)
12503 {
12504   if (test_file_2_skip ()) {
12505     printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12506     return 0;
12507   }
12508
12509   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12510   {
12511     char device[] = "/dev/sda";
12512     int r;
12513     suppress_error = 0;
12514     r = guestfs_blockdev_setrw (g, device);
12515     if (r == -1)
12516       return -1;
12517   }
12518   {
12519     int r;
12520     suppress_error = 0;
12521     r = guestfs_umount_all (g);
12522     if (r == -1)
12523       return -1;
12524   }
12525   {
12526     int r;
12527     suppress_error = 0;
12528     r = guestfs_lvm_remove_all (g);
12529     if (r == -1)
12530       return -1;
12531   }
12532   {
12533     char device[] = "/dev/sda";
12534     char lines_0[] = ",";
12535     char *lines[] = {
12536       lines_0,
12537       NULL
12538     };
12539     int r;
12540     suppress_error = 0;
12541     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12542     if (r == -1)
12543       return -1;
12544   }
12545   {
12546     char fstype[] = "ext2";
12547     char device[] = "/dev/sda1";
12548     int r;
12549     suppress_error = 0;
12550     r = guestfs_mkfs (g, fstype, device);
12551     if (r == -1)
12552       return -1;
12553   }
12554   {
12555     char device[] = "/dev/sda1";
12556     char mountpoint[] = "/";
12557     int r;
12558     suppress_error = 0;
12559     r = guestfs_mount (g, device, mountpoint);
12560     if (r == -1)
12561       return -1;
12562   }
12563   /* TestLastFail for file (2) */
12564   {
12565     char path[] = "/nofile";
12566     char *r;
12567     suppress_error = 1;
12568     r = guestfs_file (g, path);
12569     if (r != NULL)
12570       return -1;
12571     free (r);
12572   }
12573   return 0;
12574 }
12575
12576 static int test_umount_all_0_skip (void)
12577 {
12578   const char *str;
12579
12580   str = getenv ("TEST_ONLY");
12581   if (str)
12582     return strstr (str, "umount_all") == NULL;
12583   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
12584   if (str && strcmp (str, "1") == 0) return 1;
12585   str = getenv ("SKIP_TEST_UMOUNT_ALL");
12586   if (str && strcmp (str, "1") == 0) return 1;
12587   return 0;
12588 }
12589
12590 static int test_umount_all_0 (void)
12591 {
12592   if (test_umount_all_0_skip ()) {
12593     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
12594     return 0;
12595   }
12596
12597   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
12598   {
12599     char device[] = "/dev/sda";
12600     int r;
12601     suppress_error = 0;
12602     r = guestfs_blockdev_setrw (g, device);
12603     if (r == -1)
12604       return -1;
12605   }
12606   {
12607     int r;
12608     suppress_error = 0;
12609     r = guestfs_umount_all (g);
12610     if (r == -1)
12611       return -1;
12612   }
12613   {
12614     int r;
12615     suppress_error = 0;
12616     r = guestfs_lvm_remove_all (g);
12617     if (r == -1)
12618       return -1;
12619   }
12620   {
12621     char device[] = "/dev/sda";
12622     char lines_0[] = ",";
12623     char *lines[] = {
12624       lines_0,
12625       NULL
12626     };
12627     int r;
12628     suppress_error = 0;
12629     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12630     if (r == -1)
12631       return -1;
12632   }
12633   {
12634     char fstype[] = "ext2";
12635     char device[] = "/dev/sda1";
12636     int r;
12637     suppress_error = 0;
12638     r = guestfs_mkfs (g, fstype, device);
12639     if (r == -1)
12640       return -1;
12641   }
12642   {
12643     char device[] = "/dev/sda1";
12644     char mountpoint[] = "/";
12645     int r;
12646     suppress_error = 0;
12647     r = guestfs_mount (g, device, mountpoint);
12648     if (r == -1)
12649       return -1;
12650   }
12651   /* TestOutputList for umount_all (0) */
12652   {
12653     int r;
12654     suppress_error = 0;
12655     r = guestfs_umount_all (g);
12656     if (r == -1)
12657       return -1;
12658   }
12659   {
12660     char **r;
12661     int i;
12662     suppress_error = 0;
12663     r = guestfs_mounts (g);
12664     if (r == NULL)
12665       return -1;
12666     if (r[0] != NULL) {
12667       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
12668       print_strings (r);
12669       return -1;
12670     }
12671     for (i = 0; r[i] != NULL; ++i)
12672       free (r[i]);
12673     free (r);
12674   }
12675   return 0;
12676 }
12677
12678 static int test_umount_all_1_skip (void)
12679 {
12680   const char *str;
12681
12682   str = getenv ("TEST_ONLY");
12683   if (str)
12684     return strstr (str, "umount_all") == NULL;
12685   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
12686   if (str && strcmp (str, "1") == 0) return 1;
12687   str = getenv ("SKIP_TEST_UMOUNT_ALL");
12688   if (str && strcmp (str, "1") == 0) return 1;
12689   return 0;
12690 }
12691
12692 static int test_umount_all_1 (void)
12693 {
12694   if (test_umount_all_1_skip ()) {
12695     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
12696     return 0;
12697   }
12698
12699   /* InitNone|InitEmpty for test_umount_all_1 */
12700   {
12701     char device[] = "/dev/sda";
12702     int r;
12703     suppress_error = 0;
12704     r = guestfs_blockdev_setrw (g, device);
12705     if (r == -1)
12706       return -1;
12707   }
12708   {
12709     int r;
12710     suppress_error = 0;
12711     r = guestfs_umount_all (g);
12712     if (r == -1)
12713       return -1;
12714   }
12715   {
12716     int r;
12717     suppress_error = 0;
12718     r = guestfs_lvm_remove_all (g);
12719     if (r == -1)
12720       return -1;
12721   }
12722   /* TestOutputList for umount_all (1) */
12723   {
12724     char device[] = "/dev/sda";
12725     char lines_0[] = ",10";
12726     char lines_1[] = ",20";
12727     char lines_2[] = ",";
12728     char *lines[] = {
12729       lines_0,
12730       lines_1,
12731       lines_2,
12732       NULL
12733     };
12734     int r;
12735     suppress_error = 0;
12736     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12737     if (r == -1)
12738       return -1;
12739   }
12740   {
12741     char fstype[] = "ext2";
12742     char device[] = "/dev/sda1";
12743     int r;
12744     suppress_error = 0;
12745     r = guestfs_mkfs (g, fstype, device);
12746     if (r == -1)
12747       return -1;
12748   }
12749   {
12750     char fstype[] = "ext2";
12751     char device[] = "/dev/sda2";
12752     int r;
12753     suppress_error = 0;
12754     r = guestfs_mkfs (g, fstype, device);
12755     if (r == -1)
12756       return -1;
12757   }
12758   {
12759     char fstype[] = "ext2";
12760     char device[] = "/dev/sda3";
12761     int r;
12762     suppress_error = 0;
12763     r = guestfs_mkfs (g, fstype, device);
12764     if (r == -1)
12765       return -1;
12766   }
12767   {
12768     char device[] = "/dev/sda1";
12769     char mountpoint[] = "/";
12770     int r;
12771     suppress_error = 0;
12772     r = guestfs_mount (g, device, mountpoint);
12773     if (r == -1)
12774       return -1;
12775   }
12776   {
12777     char path[] = "/mp1";
12778     int r;
12779     suppress_error = 0;
12780     r = guestfs_mkdir (g, path);
12781     if (r == -1)
12782       return -1;
12783   }
12784   {
12785     char device[] = "/dev/sda2";
12786     char mountpoint[] = "/mp1";
12787     int r;
12788     suppress_error = 0;
12789     r = guestfs_mount (g, device, mountpoint);
12790     if (r == -1)
12791       return -1;
12792   }
12793   {
12794     char path[] = "/mp1/mp2";
12795     int r;
12796     suppress_error = 0;
12797     r = guestfs_mkdir (g, path);
12798     if (r == -1)
12799       return -1;
12800   }
12801   {
12802     char device[] = "/dev/sda3";
12803     char mountpoint[] = "/mp1/mp2";
12804     int r;
12805     suppress_error = 0;
12806     r = guestfs_mount (g, device, mountpoint);
12807     if (r == -1)
12808       return -1;
12809   }
12810   {
12811     char path[] = "/mp1/mp2/mp3";
12812     int r;
12813     suppress_error = 0;
12814     r = guestfs_mkdir (g, path);
12815     if (r == -1)
12816       return -1;
12817   }
12818   {
12819     int r;
12820     suppress_error = 0;
12821     r = guestfs_umount_all (g);
12822     if (r == -1)
12823       return -1;
12824   }
12825   {
12826     char **r;
12827     int i;
12828     suppress_error = 0;
12829     r = guestfs_mounts (g);
12830     if (r == NULL)
12831       return -1;
12832     if (r[0] != NULL) {
12833       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
12834       print_strings (r);
12835       return -1;
12836     }
12837     for (i = 0; r[i] != NULL; ++i)
12838       free (r[i]);
12839     free (r);
12840   }
12841   return 0;
12842 }
12843
12844 static int test_mounts_0_skip (void)
12845 {
12846   const char *str;
12847
12848   str = getenv ("TEST_ONLY");
12849   if (str)
12850     return strstr (str, "mounts") == NULL;
12851   str = getenv ("SKIP_TEST_MOUNTS_0");
12852   if (str && strcmp (str, "1") == 0) return 1;
12853   str = getenv ("SKIP_TEST_MOUNTS");
12854   if (str && strcmp (str, "1") == 0) return 1;
12855   return 0;
12856 }
12857
12858 static int test_mounts_0 (void)
12859 {
12860   if (test_mounts_0_skip ()) {
12861     printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
12862     return 0;
12863   }
12864
12865   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
12866   {
12867     char device[] = "/dev/sda";
12868     int r;
12869     suppress_error = 0;
12870     r = guestfs_blockdev_setrw (g, device);
12871     if (r == -1)
12872       return -1;
12873   }
12874   {
12875     int r;
12876     suppress_error = 0;
12877     r = guestfs_umount_all (g);
12878     if (r == -1)
12879       return -1;
12880   }
12881   {
12882     int r;
12883     suppress_error = 0;
12884     r = guestfs_lvm_remove_all (g);
12885     if (r == -1)
12886       return -1;
12887   }
12888   {
12889     char device[] = "/dev/sda";
12890     char lines_0[] = ",";
12891     char *lines[] = {
12892       lines_0,
12893       NULL
12894     };
12895     int r;
12896     suppress_error = 0;
12897     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12898     if (r == -1)
12899       return -1;
12900   }
12901   {
12902     char fstype[] = "ext2";
12903     char device[] = "/dev/sda1";
12904     int r;
12905     suppress_error = 0;
12906     r = guestfs_mkfs (g, fstype, device);
12907     if (r == -1)
12908       return -1;
12909   }
12910   {
12911     char device[] = "/dev/sda1";
12912     char mountpoint[] = "/";
12913     int r;
12914     suppress_error = 0;
12915     r = guestfs_mount (g, device, mountpoint);
12916     if (r == -1)
12917       return -1;
12918   }
12919   /* TestOutputListOfDevices for mounts (0) */
12920   {
12921     char **r;
12922     int i;
12923     suppress_error = 0;
12924     r = guestfs_mounts (g);
12925     if (r == NULL)
12926       return -1;
12927     if (!r[0]) {
12928       fprintf (stderr, "test_mounts_0: short list returned from command\n");
12929       print_strings (r);
12930       return -1;
12931     }
12932     {
12933       char expected[] = "/dev/sda1";
12934       r[0][5] = 's';
12935       if (strcmp (r[0], expected) != 0) {
12936         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12937         return -1;
12938       }
12939     }
12940     if (r[1] != NULL) {
12941       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
12942       print_strings (r);
12943       return -1;
12944     }
12945     for (i = 0; r[i] != NULL; ++i)
12946       free (r[i]);
12947     free (r);
12948   }
12949   return 0;
12950 }
12951
12952 static int test_umount_0_skip (void)
12953 {
12954   const char *str;
12955
12956   str = getenv ("TEST_ONLY");
12957   if (str)
12958     return strstr (str, "umount") == NULL;
12959   str = getenv ("SKIP_TEST_UMOUNT_0");
12960   if (str && strcmp (str, "1") == 0) return 1;
12961   str = getenv ("SKIP_TEST_UMOUNT");
12962   if (str && strcmp (str, "1") == 0) return 1;
12963   return 0;
12964 }
12965
12966 static int test_umount_0 (void)
12967 {
12968   if (test_umount_0_skip ()) {
12969     printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
12970     return 0;
12971   }
12972
12973   /* InitNone|InitEmpty for test_umount_0 */
12974   {
12975     char device[] = "/dev/sda";
12976     int r;
12977     suppress_error = 0;
12978     r = guestfs_blockdev_setrw (g, device);
12979     if (r == -1)
12980       return -1;
12981   }
12982   {
12983     int r;
12984     suppress_error = 0;
12985     r = guestfs_umount_all (g);
12986     if (r == -1)
12987       return -1;
12988   }
12989   {
12990     int r;
12991     suppress_error = 0;
12992     r = guestfs_lvm_remove_all (g);
12993     if (r == -1)
12994       return -1;
12995   }
12996   /* TestOutputListOfDevices for umount (0) */
12997   {
12998     char device[] = "/dev/sda";
12999     char lines_0[] = ",";
13000     char *lines[] = {
13001       lines_0,
13002       NULL
13003     };
13004     int r;
13005     suppress_error = 0;
13006     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13007     if (r == -1)
13008       return -1;
13009   }
13010   {
13011     char fstype[] = "ext2";
13012     char device[] = "/dev/sda1";
13013     int r;
13014     suppress_error = 0;
13015     r = guestfs_mkfs (g, fstype, device);
13016     if (r == -1)
13017       return -1;
13018   }
13019   {
13020     char device[] = "/dev/sda1";
13021     char mountpoint[] = "/";
13022     int r;
13023     suppress_error = 0;
13024     r = guestfs_mount (g, device, mountpoint);
13025     if (r == -1)
13026       return -1;
13027   }
13028   {
13029     char **r;
13030     int i;
13031     suppress_error = 0;
13032     r = guestfs_mounts (g);
13033     if (r == NULL)
13034       return -1;
13035     if (!r[0]) {
13036       fprintf (stderr, "test_umount_0: short list returned from command\n");
13037       print_strings (r);
13038       return -1;
13039     }
13040     {
13041       char expected[] = "/dev/sda1";
13042       r[0][5] = 's';
13043       if (strcmp (r[0], expected) != 0) {
13044         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13045         return -1;
13046       }
13047     }
13048     if (r[1] != NULL) {
13049       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13050       print_strings (r);
13051       return -1;
13052     }
13053     for (i = 0; r[i] != NULL; ++i)
13054       free (r[i]);
13055     free (r);
13056   }
13057   return 0;
13058 }
13059
13060 static int test_umount_1_skip (void)
13061 {
13062   const char *str;
13063
13064   str = getenv ("TEST_ONLY");
13065   if (str)
13066     return strstr (str, "umount") == NULL;
13067   str = getenv ("SKIP_TEST_UMOUNT_1");
13068   if (str && strcmp (str, "1") == 0) return 1;
13069   str = getenv ("SKIP_TEST_UMOUNT");
13070   if (str && strcmp (str, "1") == 0) return 1;
13071   return 0;
13072 }
13073
13074 static int test_umount_1 (void)
13075 {
13076   if (test_umount_1_skip ()) {
13077     printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13078     return 0;
13079   }
13080
13081   /* InitNone|InitEmpty for test_umount_1 */
13082   {
13083     char device[] = "/dev/sda";
13084     int r;
13085     suppress_error = 0;
13086     r = guestfs_blockdev_setrw (g, device);
13087     if (r == -1)
13088       return -1;
13089   }
13090   {
13091     int r;
13092     suppress_error = 0;
13093     r = guestfs_umount_all (g);
13094     if (r == -1)
13095       return -1;
13096   }
13097   {
13098     int r;
13099     suppress_error = 0;
13100     r = guestfs_lvm_remove_all (g);
13101     if (r == -1)
13102       return -1;
13103   }
13104   /* TestOutputList for umount (1) */
13105   {
13106     char device[] = "/dev/sda";
13107     char lines_0[] = ",";
13108     char *lines[] = {
13109       lines_0,
13110       NULL
13111     };
13112     int r;
13113     suppress_error = 0;
13114     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13115     if (r == -1)
13116       return -1;
13117   }
13118   {
13119     char fstype[] = "ext2";
13120     char device[] = "/dev/sda1";
13121     int r;
13122     suppress_error = 0;
13123     r = guestfs_mkfs (g, fstype, device);
13124     if (r == -1)
13125       return -1;
13126   }
13127   {
13128     char device[] = "/dev/sda1";
13129     char mountpoint[] = "/";
13130     int r;
13131     suppress_error = 0;
13132     r = guestfs_mount (g, device, mountpoint);
13133     if (r == -1)
13134       return -1;
13135   }
13136   {
13137     char pathordevice[] = "/";
13138     int r;
13139     suppress_error = 0;
13140     r = guestfs_umount (g, pathordevice);
13141     if (r == -1)
13142       return -1;
13143   }
13144   {
13145     char **r;
13146     int i;
13147     suppress_error = 0;
13148     r = guestfs_mounts (g);
13149     if (r == NULL)
13150       return -1;
13151     if (r[0] != NULL) {
13152       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13153       print_strings (r);
13154       return -1;
13155     }
13156     for (i = 0; r[i] != NULL; ++i)
13157       free (r[i]);
13158     free (r);
13159   }
13160   return 0;
13161 }
13162
13163 static int test_write_file_0_skip (void)
13164 {
13165   const char *str;
13166
13167   str = getenv ("TEST_ONLY");
13168   if (str)
13169     return strstr (str, "write_file") == NULL;
13170   str = getenv ("SKIP_TEST_WRITE_FILE_0");
13171   if (str && strcmp (str, "1") == 0) return 1;
13172   str = getenv ("SKIP_TEST_WRITE_FILE");
13173   if (str && strcmp (str, "1") == 0) return 1;
13174   return 0;
13175 }
13176
13177 static int test_write_file_0 (void)
13178 {
13179   if (test_write_file_0_skip ()) {
13180     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13181     return 0;
13182   }
13183
13184   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13185   {
13186     char device[] = "/dev/sda";
13187     int r;
13188     suppress_error = 0;
13189     r = guestfs_blockdev_setrw (g, device);
13190     if (r == -1)
13191       return -1;
13192   }
13193   {
13194     int r;
13195     suppress_error = 0;
13196     r = guestfs_umount_all (g);
13197     if (r == -1)
13198       return -1;
13199   }
13200   {
13201     int r;
13202     suppress_error = 0;
13203     r = guestfs_lvm_remove_all (g);
13204     if (r == -1)
13205       return -1;
13206   }
13207   {
13208     char device[] = "/dev/sda";
13209     char lines_0[] = ",";
13210     char *lines[] = {
13211       lines_0,
13212       NULL
13213     };
13214     int r;
13215     suppress_error = 0;
13216     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13217     if (r == -1)
13218       return -1;
13219   }
13220   {
13221     char fstype[] = "ext2";
13222     char device[] = "/dev/sda1";
13223     int r;
13224     suppress_error = 0;
13225     r = guestfs_mkfs (g, fstype, device);
13226     if (r == -1)
13227       return -1;
13228   }
13229   {
13230     char device[] = "/dev/sda1";
13231     char mountpoint[] = "/";
13232     int r;
13233     suppress_error = 0;
13234     r = guestfs_mount (g, device, mountpoint);
13235     if (r == -1)
13236       return -1;
13237   }
13238   /* TestOutput for write_file (0) */
13239   char expected[] = "new file contents";
13240   {
13241     char path[] = "/new";
13242     char content[] = "new file contents";
13243     int r;
13244     suppress_error = 0;
13245     r = guestfs_write_file (g, path, content, 0);
13246     if (r == -1)
13247       return -1;
13248   }
13249   {
13250     char path[] = "/new";
13251     char *r;
13252     suppress_error = 0;
13253     r = guestfs_cat (g, path);
13254     if (r == NULL)
13255       return -1;
13256     if (strcmp (r, expected) != 0) {
13257       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13258       return -1;
13259     }
13260     free (r);
13261   }
13262   return 0;
13263 }
13264
13265 static int test_write_file_1_skip (void)
13266 {
13267   const char *str;
13268
13269   str = getenv ("TEST_ONLY");
13270   if (str)
13271     return strstr (str, "write_file") == NULL;
13272   str = getenv ("SKIP_TEST_WRITE_FILE_1");
13273   if (str && strcmp (str, "1") == 0) return 1;
13274   str = getenv ("SKIP_TEST_WRITE_FILE");
13275   if (str && strcmp (str, "1") == 0) return 1;
13276   return 0;
13277 }
13278
13279 static int test_write_file_1 (void)
13280 {
13281   if (test_write_file_1_skip ()) {
13282     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13283     return 0;
13284   }
13285
13286   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13287   {
13288     char device[] = "/dev/sda";
13289     int r;
13290     suppress_error = 0;
13291     r = guestfs_blockdev_setrw (g, device);
13292     if (r == -1)
13293       return -1;
13294   }
13295   {
13296     int r;
13297     suppress_error = 0;
13298     r = guestfs_umount_all (g);
13299     if (r == -1)
13300       return -1;
13301   }
13302   {
13303     int r;
13304     suppress_error = 0;
13305     r = guestfs_lvm_remove_all (g);
13306     if (r == -1)
13307       return -1;
13308   }
13309   {
13310     char device[] = "/dev/sda";
13311     char lines_0[] = ",";
13312     char *lines[] = {
13313       lines_0,
13314       NULL
13315     };
13316     int r;
13317     suppress_error = 0;
13318     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13319     if (r == -1)
13320       return -1;
13321   }
13322   {
13323     char fstype[] = "ext2";
13324     char device[] = "/dev/sda1";
13325     int r;
13326     suppress_error = 0;
13327     r = guestfs_mkfs (g, fstype, device);
13328     if (r == -1)
13329       return -1;
13330   }
13331   {
13332     char device[] = "/dev/sda1";
13333     char mountpoint[] = "/";
13334     int r;
13335     suppress_error = 0;
13336     r = guestfs_mount (g, device, mountpoint);
13337     if (r == -1)
13338       return -1;
13339   }
13340   /* TestOutput for write_file (1) */
13341   char expected[] = "\nnew file contents\n";
13342   {
13343     char path[] = "/new";
13344     char content[] = "\nnew file contents\n";
13345     int r;
13346     suppress_error = 0;
13347     r = guestfs_write_file (g, path, content, 0);
13348     if (r == -1)
13349       return -1;
13350   }
13351   {
13352     char path[] = "/new";
13353     char *r;
13354     suppress_error = 0;
13355     r = guestfs_cat (g, path);
13356     if (r == NULL)
13357       return -1;
13358     if (strcmp (r, expected) != 0) {
13359       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13360       return -1;
13361     }
13362     free (r);
13363   }
13364   return 0;
13365 }
13366
13367 static int test_write_file_2_skip (void)
13368 {
13369   const char *str;
13370
13371   str = getenv ("TEST_ONLY");
13372   if (str)
13373     return strstr (str, "write_file") == NULL;
13374   str = getenv ("SKIP_TEST_WRITE_FILE_2");
13375   if (str && strcmp (str, "1") == 0) return 1;
13376   str = getenv ("SKIP_TEST_WRITE_FILE");
13377   if (str && strcmp (str, "1") == 0) return 1;
13378   return 0;
13379 }
13380
13381 static int test_write_file_2 (void)
13382 {
13383   if (test_write_file_2_skip ()) {
13384     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13385     return 0;
13386   }
13387
13388   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13389   {
13390     char device[] = "/dev/sda";
13391     int r;
13392     suppress_error = 0;
13393     r = guestfs_blockdev_setrw (g, device);
13394     if (r == -1)
13395       return -1;
13396   }
13397   {
13398     int r;
13399     suppress_error = 0;
13400     r = guestfs_umount_all (g);
13401     if (r == -1)
13402       return -1;
13403   }
13404   {
13405     int r;
13406     suppress_error = 0;
13407     r = guestfs_lvm_remove_all (g);
13408     if (r == -1)
13409       return -1;
13410   }
13411   {
13412     char device[] = "/dev/sda";
13413     char lines_0[] = ",";
13414     char *lines[] = {
13415       lines_0,
13416       NULL
13417     };
13418     int r;
13419     suppress_error = 0;
13420     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13421     if (r == -1)
13422       return -1;
13423   }
13424   {
13425     char fstype[] = "ext2";
13426     char device[] = "/dev/sda1";
13427     int r;
13428     suppress_error = 0;
13429     r = guestfs_mkfs (g, fstype, device);
13430     if (r == -1)
13431       return -1;
13432   }
13433   {
13434     char device[] = "/dev/sda1";
13435     char mountpoint[] = "/";
13436     int r;
13437     suppress_error = 0;
13438     r = guestfs_mount (g, device, mountpoint);
13439     if (r == -1)
13440       return -1;
13441   }
13442   /* TestOutput for write_file (2) */
13443   char expected[] = "\n\n";
13444   {
13445     char path[] = "/new";
13446     char content[] = "\n\n";
13447     int r;
13448     suppress_error = 0;
13449     r = guestfs_write_file (g, path, content, 0);
13450     if (r == -1)
13451       return -1;
13452   }
13453   {
13454     char path[] = "/new";
13455     char *r;
13456     suppress_error = 0;
13457     r = guestfs_cat (g, path);
13458     if (r == NULL)
13459       return -1;
13460     if (strcmp (r, expected) != 0) {
13461       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13462       return -1;
13463     }
13464     free (r);
13465   }
13466   return 0;
13467 }
13468
13469 static int test_write_file_3_skip (void)
13470 {
13471   const char *str;
13472
13473   str = getenv ("TEST_ONLY");
13474   if (str)
13475     return strstr (str, "write_file") == NULL;
13476   str = getenv ("SKIP_TEST_WRITE_FILE_3");
13477   if (str && strcmp (str, "1") == 0) return 1;
13478   str = getenv ("SKIP_TEST_WRITE_FILE");
13479   if (str && strcmp (str, "1") == 0) return 1;
13480   return 0;
13481 }
13482
13483 static int test_write_file_3 (void)
13484 {
13485   if (test_write_file_3_skip ()) {
13486     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13487     return 0;
13488   }
13489
13490   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13491   {
13492     char device[] = "/dev/sda";
13493     int r;
13494     suppress_error = 0;
13495     r = guestfs_blockdev_setrw (g, device);
13496     if (r == -1)
13497       return -1;
13498   }
13499   {
13500     int r;
13501     suppress_error = 0;
13502     r = guestfs_umount_all (g);
13503     if (r == -1)
13504       return -1;
13505   }
13506   {
13507     int r;
13508     suppress_error = 0;
13509     r = guestfs_lvm_remove_all (g);
13510     if (r == -1)
13511       return -1;
13512   }
13513   {
13514     char device[] = "/dev/sda";
13515     char lines_0[] = ",";
13516     char *lines[] = {
13517       lines_0,
13518       NULL
13519     };
13520     int r;
13521     suppress_error = 0;
13522     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13523     if (r == -1)
13524       return -1;
13525   }
13526   {
13527     char fstype[] = "ext2";
13528     char device[] = "/dev/sda1";
13529     int r;
13530     suppress_error = 0;
13531     r = guestfs_mkfs (g, fstype, device);
13532     if (r == -1)
13533       return -1;
13534   }
13535   {
13536     char device[] = "/dev/sda1";
13537     char mountpoint[] = "/";
13538     int r;
13539     suppress_error = 0;
13540     r = guestfs_mount (g, device, mountpoint);
13541     if (r == -1)
13542       return -1;
13543   }
13544   /* TestOutput for write_file (3) */
13545   char expected[] = "";
13546   {
13547     char path[] = "/new";
13548     char content[] = "";
13549     int r;
13550     suppress_error = 0;
13551     r = guestfs_write_file (g, path, content, 0);
13552     if (r == -1)
13553       return -1;
13554   }
13555   {
13556     char path[] = "/new";
13557     char *r;
13558     suppress_error = 0;
13559     r = guestfs_cat (g, path);
13560     if (r == NULL)
13561       return -1;
13562     if (strcmp (r, expected) != 0) {
13563       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
13564       return -1;
13565     }
13566     free (r);
13567   }
13568   return 0;
13569 }
13570
13571 static int test_write_file_4_skip (void)
13572 {
13573   const char *str;
13574
13575   str = getenv ("TEST_ONLY");
13576   if (str)
13577     return strstr (str, "write_file") == NULL;
13578   str = getenv ("SKIP_TEST_WRITE_FILE_4");
13579   if (str && strcmp (str, "1") == 0) return 1;
13580   str = getenv ("SKIP_TEST_WRITE_FILE");
13581   if (str && strcmp (str, "1") == 0) return 1;
13582   return 0;
13583 }
13584
13585 static int test_write_file_4 (void)
13586 {
13587   if (test_write_file_4_skip ()) {
13588     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
13589     return 0;
13590   }
13591
13592   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
13593   {
13594     char device[] = "/dev/sda";
13595     int r;
13596     suppress_error = 0;
13597     r = guestfs_blockdev_setrw (g, device);
13598     if (r == -1)
13599       return -1;
13600   }
13601   {
13602     int r;
13603     suppress_error = 0;
13604     r = guestfs_umount_all (g);
13605     if (r == -1)
13606       return -1;
13607   }
13608   {
13609     int r;
13610     suppress_error = 0;
13611     r = guestfs_lvm_remove_all (g);
13612     if (r == -1)
13613       return -1;
13614   }
13615   {
13616     char device[] = "/dev/sda";
13617     char lines_0[] = ",";
13618     char *lines[] = {
13619       lines_0,
13620       NULL
13621     };
13622     int r;
13623     suppress_error = 0;
13624     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13625     if (r == -1)
13626       return -1;
13627   }
13628   {
13629     char fstype[] = "ext2";
13630     char device[] = "/dev/sda1";
13631     int r;
13632     suppress_error = 0;
13633     r = guestfs_mkfs (g, fstype, device);
13634     if (r == -1)
13635       return -1;
13636   }
13637   {
13638     char device[] = "/dev/sda1";
13639     char mountpoint[] = "/";
13640     int r;
13641     suppress_error = 0;
13642     r = guestfs_mount (g, device, mountpoint);
13643     if (r == -1)
13644       return -1;
13645   }
13646   /* TestOutput for write_file (4) */
13647   char expected[] = "\n\n\n";
13648   {
13649     char path[] = "/new";
13650     char content[] = "\n\n\n";
13651     int r;
13652     suppress_error = 0;
13653     r = guestfs_write_file (g, path, content, 0);
13654     if (r == -1)
13655       return -1;
13656   }
13657   {
13658     char path[] = "/new";
13659     char *r;
13660     suppress_error = 0;
13661     r = guestfs_cat (g, path);
13662     if (r == NULL)
13663       return -1;
13664     if (strcmp (r, expected) != 0) {
13665       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
13666       return -1;
13667     }
13668     free (r);
13669   }
13670   return 0;
13671 }
13672
13673 static int test_write_file_5_skip (void)
13674 {
13675   const char *str;
13676
13677   str = getenv ("TEST_ONLY");
13678   if (str)
13679     return strstr (str, "write_file") == NULL;
13680   str = getenv ("SKIP_TEST_WRITE_FILE_5");
13681   if (str && strcmp (str, "1") == 0) return 1;
13682   str = getenv ("SKIP_TEST_WRITE_FILE");
13683   if (str && strcmp (str, "1") == 0) return 1;
13684   return 0;
13685 }
13686
13687 static int test_write_file_5 (void)
13688 {
13689   if (test_write_file_5_skip ()) {
13690     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
13691     return 0;
13692   }
13693
13694   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
13695   {
13696     char device[] = "/dev/sda";
13697     int r;
13698     suppress_error = 0;
13699     r = guestfs_blockdev_setrw (g, device);
13700     if (r == -1)
13701       return -1;
13702   }
13703   {
13704     int r;
13705     suppress_error = 0;
13706     r = guestfs_umount_all (g);
13707     if (r == -1)
13708       return -1;
13709   }
13710   {
13711     int r;
13712     suppress_error = 0;
13713     r = guestfs_lvm_remove_all (g);
13714     if (r == -1)
13715       return -1;
13716   }
13717   {
13718     char device[] = "/dev/sda";
13719     char lines_0[] = ",";
13720     char *lines[] = {
13721       lines_0,
13722       NULL
13723     };
13724     int r;
13725     suppress_error = 0;
13726     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13727     if (r == -1)
13728       return -1;
13729   }
13730   {
13731     char fstype[] = "ext2";
13732     char device[] = "/dev/sda1";
13733     int r;
13734     suppress_error = 0;
13735     r = guestfs_mkfs (g, fstype, device);
13736     if (r == -1)
13737       return -1;
13738   }
13739   {
13740     char device[] = "/dev/sda1";
13741     char mountpoint[] = "/";
13742     int r;
13743     suppress_error = 0;
13744     r = guestfs_mount (g, device, mountpoint);
13745     if (r == -1)
13746       return -1;
13747   }
13748   /* TestOutput for write_file (5) */
13749   char expected[] = "\n";
13750   {
13751     char path[] = "/new";
13752     char content[] = "\n";
13753     int r;
13754     suppress_error = 0;
13755     r = guestfs_write_file (g, path, content, 0);
13756     if (r == -1)
13757       return -1;
13758   }
13759   {
13760     char path[] = "/new";
13761     char *r;
13762     suppress_error = 0;
13763     r = guestfs_cat (g, path);
13764     if (r == NULL)
13765       return -1;
13766     if (strcmp (r, expected) != 0) {
13767       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
13768       return -1;
13769     }
13770     free (r);
13771   }
13772   return 0;
13773 }
13774
13775 static int test_mkfs_0_skip (void)
13776 {
13777   const char *str;
13778
13779   str = getenv ("TEST_ONLY");
13780   if (str)
13781     return strstr (str, "mkfs") == NULL;
13782   str = getenv ("SKIP_TEST_MKFS_0");
13783   if (str && strcmp (str, "1") == 0) return 1;
13784   str = getenv ("SKIP_TEST_MKFS");
13785   if (str && strcmp (str, "1") == 0) return 1;
13786   return 0;
13787 }
13788
13789 static int test_mkfs_0 (void)
13790 {
13791   if (test_mkfs_0_skip ()) {
13792     printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
13793     return 0;
13794   }
13795
13796   /* InitNone|InitEmpty for test_mkfs_0 */
13797   {
13798     char device[] = "/dev/sda";
13799     int r;
13800     suppress_error = 0;
13801     r = guestfs_blockdev_setrw (g, device);
13802     if (r == -1)
13803       return -1;
13804   }
13805   {
13806     int r;
13807     suppress_error = 0;
13808     r = guestfs_umount_all (g);
13809     if (r == -1)
13810       return -1;
13811   }
13812   {
13813     int r;
13814     suppress_error = 0;
13815     r = guestfs_lvm_remove_all (g);
13816     if (r == -1)
13817       return -1;
13818   }
13819   /* TestOutput for mkfs (0) */
13820   char expected[] = "new file contents";
13821   {
13822     char device[] = "/dev/sda";
13823     char lines_0[] = ",";
13824     char *lines[] = {
13825       lines_0,
13826       NULL
13827     };
13828     int r;
13829     suppress_error = 0;
13830     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13831     if (r == -1)
13832       return -1;
13833   }
13834   {
13835     char fstype[] = "ext2";
13836     char device[] = "/dev/sda1";
13837     int r;
13838     suppress_error = 0;
13839     r = guestfs_mkfs (g, fstype, device);
13840     if (r == -1)
13841       return -1;
13842   }
13843   {
13844     char device[] = "/dev/sda1";
13845     char mountpoint[] = "/";
13846     int r;
13847     suppress_error = 0;
13848     r = guestfs_mount (g, device, mountpoint);
13849     if (r == -1)
13850       return -1;
13851   }
13852   {
13853     char path[] = "/new";
13854     char content[] = "new file contents";
13855     int r;
13856     suppress_error = 0;
13857     r = guestfs_write_file (g, path, content, 0);
13858     if (r == -1)
13859       return -1;
13860   }
13861   {
13862     char path[] = "/new";
13863     char *r;
13864     suppress_error = 0;
13865     r = guestfs_cat (g, path);
13866     if (r == NULL)
13867       return -1;
13868     if (strcmp (r, expected) != 0) {
13869       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
13870       return -1;
13871     }
13872     free (r);
13873   }
13874   return 0;
13875 }
13876
13877 static int test_lvcreate_0_skip (void)
13878 {
13879   const char *str;
13880
13881   str = getenv ("TEST_ONLY");
13882   if (str)
13883     return strstr (str, "lvcreate") == NULL;
13884   str = getenv ("SKIP_TEST_LVCREATE_0");
13885   if (str && strcmp (str, "1") == 0) return 1;
13886   str = getenv ("SKIP_TEST_LVCREATE");
13887   if (str && strcmp (str, "1") == 0) return 1;
13888   return 0;
13889 }
13890
13891 static int test_lvcreate_0 (void)
13892 {
13893   if (test_lvcreate_0_skip ()) {
13894     printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
13895     return 0;
13896   }
13897
13898   /* InitNone|InitEmpty for test_lvcreate_0 */
13899   {
13900     char device[] = "/dev/sda";
13901     int r;
13902     suppress_error = 0;
13903     r = guestfs_blockdev_setrw (g, device);
13904     if (r == -1)
13905       return -1;
13906   }
13907   {
13908     int r;
13909     suppress_error = 0;
13910     r = guestfs_umount_all (g);
13911     if (r == -1)
13912       return -1;
13913   }
13914   {
13915     int r;
13916     suppress_error = 0;
13917     r = guestfs_lvm_remove_all (g);
13918     if (r == -1)
13919       return -1;
13920   }
13921   /* TestOutputList for lvcreate (0) */
13922   {
13923     char device[] = "/dev/sda";
13924     char lines_0[] = ",10";
13925     char lines_1[] = ",20";
13926     char lines_2[] = ",";
13927     char *lines[] = {
13928       lines_0,
13929       lines_1,
13930       lines_2,
13931       NULL
13932     };
13933     int r;
13934     suppress_error = 0;
13935     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13936     if (r == -1)
13937       return -1;
13938   }
13939   {
13940     char device[] = "/dev/sda1";
13941     int r;
13942     suppress_error = 0;
13943     r = guestfs_pvcreate (g, device);
13944     if (r == -1)
13945       return -1;
13946   }
13947   {
13948     char device[] = "/dev/sda2";
13949     int r;
13950     suppress_error = 0;
13951     r = guestfs_pvcreate (g, device);
13952     if (r == -1)
13953       return -1;
13954   }
13955   {
13956     char device[] = "/dev/sda3";
13957     int r;
13958     suppress_error = 0;
13959     r = guestfs_pvcreate (g, device);
13960     if (r == -1)
13961       return -1;
13962   }
13963   {
13964     char volgroup[] = "VG1";
13965     char physvols_0[] = "/dev/sda1";
13966     char physvols_1[] = "/dev/sda2";
13967     char *physvols[] = {
13968       physvols_0,
13969       physvols_1,
13970       NULL
13971     };
13972     int r;
13973     suppress_error = 0;
13974     r = guestfs_vgcreate (g, volgroup, physvols);
13975     if (r == -1)
13976       return -1;
13977   }
13978   {
13979     char volgroup[] = "VG2";
13980     char physvols_0[] = "/dev/sda3";
13981     char *physvols[] = {
13982       physvols_0,
13983       NULL
13984     };
13985     int r;
13986     suppress_error = 0;
13987     r = guestfs_vgcreate (g, volgroup, physvols);
13988     if (r == -1)
13989       return -1;
13990   }
13991   {
13992     char logvol[] = "LV1";
13993     char volgroup[] = "VG1";
13994     int r;
13995     suppress_error = 0;
13996     r = guestfs_lvcreate (g, logvol, volgroup, 50);
13997     if (r == -1)
13998       return -1;
13999   }
14000   {
14001     char logvol[] = "LV2";
14002     char volgroup[] = "VG1";
14003     int r;
14004     suppress_error = 0;
14005     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14006     if (r == -1)
14007       return -1;
14008   }
14009   {
14010     char logvol[] = "LV3";
14011     char volgroup[] = "VG2";
14012     int r;
14013     suppress_error = 0;
14014     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14015     if (r == -1)
14016       return -1;
14017   }
14018   {
14019     char logvol[] = "LV4";
14020     char volgroup[] = "VG2";
14021     int r;
14022     suppress_error = 0;
14023     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14024     if (r == -1)
14025       return -1;
14026   }
14027   {
14028     char logvol[] = "LV5";
14029     char volgroup[] = "VG2";
14030     int r;
14031     suppress_error = 0;
14032     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14033     if (r == -1)
14034       return -1;
14035   }
14036   {
14037     char **r;
14038     int i;
14039     suppress_error = 0;
14040     r = guestfs_lvs (g);
14041     if (r == NULL)
14042       return -1;
14043     if (!r[0]) {
14044       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14045       print_strings (r);
14046       return -1;
14047     }
14048     {
14049       char expected[] = "/dev/VG1/LV1";
14050       if (strcmp (r[0], expected) != 0) {
14051         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14052         return -1;
14053       }
14054     }
14055     if (!r[1]) {
14056       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14057       print_strings (r);
14058       return -1;
14059     }
14060     {
14061       char expected[] = "/dev/VG1/LV2";
14062       if (strcmp (r[1], expected) != 0) {
14063         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14064         return -1;
14065       }
14066     }
14067     if (!r[2]) {
14068       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14069       print_strings (r);
14070       return -1;
14071     }
14072     {
14073       char expected[] = "/dev/VG2/LV3";
14074       if (strcmp (r[2], expected) != 0) {
14075         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14076         return -1;
14077       }
14078     }
14079     if (!r[3]) {
14080       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14081       print_strings (r);
14082       return -1;
14083     }
14084     {
14085       char expected[] = "/dev/VG2/LV4";
14086       if (strcmp (r[3], expected) != 0) {
14087         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14088         return -1;
14089       }
14090     }
14091     if (!r[4]) {
14092       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14093       print_strings (r);
14094       return -1;
14095     }
14096     {
14097       char expected[] = "/dev/VG2/LV5";
14098       if (strcmp (r[4], expected) != 0) {
14099         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14100         return -1;
14101       }
14102     }
14103     if (r[5] != NULL) {
14104       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14105       print_strings (r);
14106       return -1;
14107     }
14108     for (i = 0; r[i] != NULL; ++i)
14109       free (r[i]);
14110     free (r);
14111   }
14112   return 0;
14113 }
14114
14115 static int test_vgcreate_0_skip (void)
14116 {
14117   const char *str;
14118
14119   str = getenv ("TEST_ONLY");
14120   if (str)
14121     return strstr (str, "vgcreate") == NULL;
14122   str = getenv ("SKIP_TEST_VGCREATE_0");
14123   if (str && strcmp (str, "1") == 0) return 1;
14124   str = getenv ("SKIP_TEST_VGCREATE");
14125   if (str && strcmp (str, "1") == 0) return 1;
14126   return 0;
14127 }
14128
14129 static int test_vgcreate_0 (void)
14130 {
14131   if (test_vgcreate_0_skip ()) {
14132     printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14133     return 0;
14134   }
14135
14136   /* InitNone|InitEmpty for test_vgcreate_0 */
14137   {
14138     char device[] = "/dev/sda";
14139     int r;
14140     suppress_error = 0;
14141     r = guestfs_blockdev_setrw (g, device);
14142     if (r == -1)
14143       return -1;
14144   }
14145   {
14146     int r;
14147     suppress_error = 0;
14148     r = guestfs_umount_all (g);
14149     if (r == -1)
14150       return -1;
14151   }
14152   {
14153     int r;
14154     suppress_error = 0;
14155     r = guestfs_lvm_remove_all (g);
14156     if (r == -1)
14157       return -1;
14158   }
14159   /* TestOutputList for vgcreate (0) */
14160   {
14161     char device[] = "/dev/sda";
14162     char lines_0[] = ",10";
14163     char lines_1[] = ",20";
14164     char lines_2[] = ",";
14165     char *lines[] = {
14166       lines_0,
14167       lines_1,
14168       lines_2,
14169       NULL
14170     };
14171     int r;
14172     suppress_error = 0;
14173     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14174     if (r == -1)
14175       return -1;
14176   }
14177   {
14178     char device[] = "/dev/sda1";
14179     int r;
14180     suppress_error = 0;
14181     r = guestfs_pvcreate (g, device);
14182     if (r == -1)
14183       return -1;
14184   }
14185   {
14186     char device[] = "/dev/sda2";
14187     int r;
14188     suppress_error = 0;
14189     r = guestfs_pvcreate (g, device);
14190     if (r == -1)
14191       return -1;
14192   }
14193   {
14194     char device[] = "/dev/sda3";
14195     int r;
14196     suppress_error = 0;
14197     r = guestfs_pvcreate (g, device);
14198     if (r == -1)
14199       return -1;
14200   }
14201   {
14202     char volgroup[] = "VG1";
14203     char physvols_0[] = "/dev/sda1";
14204     char physvols_1[] = "/dev/sda2";
14205     char *physvols[] = {
14206       physvols_0,
14207       physvols_1,
14208       NULL
14209     };
14210     int r;
14211     suppress_error = 0;
14212     r = guestfs_vgcreate (g, volgroup, physvols);
14213     if (r == -1)
14214       return -1;
14215   }
14216   {
14217     char volgroup[] = "VG2";
14218     char physvols_0[] = "/dev/sda3";
14219     char *physvols[] = {
14220       physvols_0,
14221       NULL
14222     };
14223     int r;
14224     suppress_error = 0;
14225     r = guestfs_vgcreate (g, volgroup, physvols);
14226     if (r == -1)
14227       return -1;
14228   }
14229   {
14230     char **r;
14231     int i;
14232     suppress_error = 0;
14233     r = guestfs_vgs (g);
14234     if (r == NULL)
14235       return -1;
14236     if (!r[0]) {
14237       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14238       print_strings (r);
14239       return -1;
14240     }
14241     {
14242       char expected[] = "VG1";
14243       if (strcmp (r[0], expected) != 0) {
14244         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14245         return -1;
14246       }
14247     }
14248     if (!r[1]) {
14249       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14250       print_strings (r);
14251       return -1;
14252     }
14253     {
14254       char expected[] = "VG2";
14255       if (strcmp (r[1], expected) != 0) {
14256         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14257         return -1;
14258       }
14259     }
14260     if (r[2] != NULL) {
14261       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14262       print_strings (r);
14263       return -1;
14264     }
14265     for (i = 0; r[i] != NULL; ++i)
14266       free (r[i]);
14267     free (r);
14268   }
14269   return 0;
14270 }
14271
14272 static int test_pvcreate_0_skip (void)
14273 {
14274   const char *str;
14275
14276   str = getenv ("TEST_ONLY");
14277   if (str)
14278     return strstr (str, "pvcreate") == NULL;
14279   str = getenv ("SKIP_TEST_PVCREATE_0");
14280   if (str && strcmp (str, "1") == 0) return 1;
14281   str = getenv ("SKIP_TEST_PVCREATE");
14282   if (str && strcmp (str, "1") == 0) return 1;
14283   return 0;
14284 }
14285
14286 static int test_pvcreate_0 (void)
14287 {
14288   if (test_pvcreate_0_skip ()) {
14289     printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14290     return 0;
14291   }
14292
14293   /* InitNone|InitEmpty for test_pvcreate_0 */
14294   {
14295     char device[] = "/dev/sda";
14296     int r;
14297     suppress_error = 0;
14298     r = guestfs_blockdev_setrw (g, device);
14299     if (r == -1)
14300       return -1;
14301   }
14302   {
14303     int r;
14304     suppress_error = 0;
14305     r = guestfs_umount_all (g);
14306     if (r == -1)
14307       return -1;
14308   }
14309   {
14310     int r;
14311     suppress_error = 0;
14312     r = guestfs_lvm_remove_all (g);
14313     if (r == -1)
14314       return -1;
14315   }
14316   /* TestOutputListOfDevices for pvcreate (0) */
14317   {
14318     char device[] = "/dev/sda";
14319     char lines_0[] = ",10";
14320     char lines_1[] = ",20";
14321     char lines_2[] = ",";
14322     char *lines[] = {
14323       lines_0,
14324       lines_1,
14325       lines_2,
14326       NULL
14327     };
14328     int r;
14329     suppress_error = 0;
14330     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14331     if (r == -1)
14332       return -1;
14333   }
14334   {
14335     char device[] = "/dev/sda1";
14336     int r;
14337     suppress_error = 0;
14338     r = guestfs_pvcreate (g, device);
14339     if (r == -1)
14340       return -1;
14341   }
14342   {
14343     char device[] = "/dev/sda2";
14344     int r;
14345     suppress_error = 0;
14346     r = guestfs_pvcreate (g, device);
14347     if (r == -1)
14348       return -1;
14349   }
14350   {
14351     char device[] = "/dev/sda3";
14352     int r;
14353     suppress_error = 0;
14354     r = guestfs_pvcreate (g, device);
14355     if (r == -1)
14356       return -1;
14357   }
14358   {
14359     char **r;
14360     int i;
14361     suppress_error = 0;
14362     r = guestfs_pvs (g);
14363     if (r == NULL)
14364       return -1;
14365     if (!r[0]) {
14366       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14367       print_strings (r);
14368       return -1;
14369     }
14370     {
14371       char expected[] = "/dev/sda1";
14372       r[0][5] = 's';
14373       if (strcmp (r[0], expected) != 0) {
14374         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14375         return -1;
14376       }
14377     }
14378     if (!r[1]) {
14379       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14380       print_strings (r);
14381       return -1;
14382     }
14383     {
14384       char expected[] = "/dev/sda2";
14385       r[1][5] = 's';
14386       if (strcmp (r[1], expected) != 0) {
14387         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14388         return -1;
14389       }
14390     }
14391     if (!r[2]) {
14392       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14393       print_strings (r);
14394       return -1;
14395     }
14396     {
14397       char expected[] = "/dev/sda3";
14398       r[2][5] = 's';
14399       if (strcmp (r[2], expected) != 0) {
14400         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14401         return -1;
14402       }
14403     }
14404     if (r[3] != NULL) {
14405       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14406       print_strings (r);
14407       return -1;
14408     }
14409     for (i = 0; r[i] != NULL; ++i)
14410       free (r[i]);
14411     free (r);
14412   }
14413   return 0;
14414 }
14415
14416 static int test_is_dir_0_skip (void)
14417 {
14418   const char *str;
14419
14420   str = getenv ("TEST_ONLY");
14421   if (str)
14422     return strstr (str, "is_dir") == NULL;
14423   str = getenv ("SKIP_TEST_IS_DIR_0");
14424   if (str && strcmp (str, "1") == 0) return 1;
14425   str = getenv ("SKIP_TEST_IS_DIR");
14426   if (str && strcmp (str, "1") == 0) return 1;
14427   return 0;
14428 }
14429
14430 static int test_is_dir_0 (void)
14431 {
14432   if (test_is_dir_0_skip ()) {
14433     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14434     return 0;
14435   }
14436
14437   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14438   {
14439     char device[] = "/dev/sda";
14440     int r;
14441     suppress_error = 0;
14442     r = guestfs_blockdev_setrw (g, device);
14443     if (r == -1)
14444       return -1;
14445   }
14446   {
14447     int r;
14448     suppress_error = 0;
14449     r = guestfs_umount_all (g);
14450     if (r == -1)
14451       return -1;
14452   }
14453   {
14454     int r;
14455     suppress_error = 0;
14456     r = guestfs_lvm_remove_all (g);
14457     if (r == -1)
14458       return -1;
14459   }
14460   {
14461     char device[] = "/dev/sda";
14462     char lines_0[] = ",";
14463     char *lines[] = {
14464       lines_0,
14465       NULL
14466     };
14467     int r;
14468     suppress_error = 0;
14469     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14470     if (r == -1)
14471       return -1;
14472   }
14473   {
14474     char fstype[] = "ext2";
14475     char device[] = "/dev/sda1";
14476     int r;
14477     suppress_error = 0;
14478     r = guestfs_mkfs (g, fstype, device);
14479     if (r == -1)
14480       return -1;
14481   }
14482   {
14483     char device[] = "/dev/sda1";
14484     char mountpoint[] = "/";
14485     int r;
14486     suppress_error = 0;
14487     r = guestfs_mount (g, device, mountpoint);
14488     if (r == -1)
14489       return -1;
14490   }
14491   /* TestOutputFalse for is_dir (0) */
14492   {
14493     char path[] = "/new";
14494     int r;
14495     suppress_error = 0;
14496     r = guestfs_touch (g, path);
14497     if (r == -1)
14498       return -1;
14499   }
14500   {
14501     char path[] = "/new";
14502     int r;
14503     suppress_error = 0;
14504     r = guestfs_is_dir (g, path);
14505     if (r == -1)
14506       return -1;
14507     if (r) {
14508       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14509       return -1;
14510     }
14511   }
14512   return 0;
14513 }
14514
14515 static int test_is_dir_1_skip (void)
14516 {
14517   const char *str;
14518
14519   str = getenv ("TEST_ONLY");
14520   if (str)
14521     return strstr (str, "is_dir") == NULL;
14522   str = getenv ("SKIP_TEST_IS_DIR_1");
14523   if (str && strcmp (str, "1") == 0) return 1;
14524   str = getenv ("SKIP_TEST_IS_DIR");
14525   if (str && strcmp (str, "1") == 0) return 1;
14526   return 0;
14527 }
14528
14529 static int test_is_dir_1 (void)
14530 {
14531   if (test_is_dir_1_skip ()) {
14532     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
14533     return 0;
14534   }
14535
14536   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
14537   {
14538     char device[] = "/dev/sda";
14539     int r;
14540     suppress_error = 0;
14541     r = guestfs_blockdev_setrw (g, device);
14542     if (r == -1)
14543       return -1;
14544   }
14545   {
14546     int r;
14547     suppress_error = 0;
14548     r = guestfs_umount_all (g);
14549     if (r == -1)
14550       return -1;
14551   }
14552   {
14553     int r;
14554     suppress_error = 0;
14555     r = guestfs_lvm_remove_all (g);
14556     if (r == -1)
14557       return -1;
14558   }
14559   {
14560     char device[] = "/dev/sda";
14561     char lines_0[] = ",";
14562     char *lines[] = {
14563       lines_0,
14564       NULL
14565     };
14566     int r;
14567     suppress_error = 0;
14568     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14569     if (r == -1)
14570       return -1;
14571   }
14572   {
14573     char fstype[] = "ext2";
14574     char device[] = "/dev/sda1";
14575     int r;
14576     suppress_error = 0;
14577     r = guestfs_mkfs (g, fstype, device);
14578     if (r == -1)
14579       return -1;
14580   }
14581   {
14582     char device[] = "/dev/sda1";
14583     char mountpoint[] = "/";
14584     int r;
14585     suppress_error = 0;
14586     r = guestfs_mount (g, device, mountpoint);
14587     if (r == -1)
14588       return -1;
14589   }
14590   /* TestOutputTrue for is_dir (1) */
14591   {
14592     char path[] = "/new";
14593     int r;
14594     suppress_error = 0;
14595     r = guestfs_mkdir (g, path);
14596     if (r == -1)
14597       return -1;
14598   }
14599   {
14600     char path[] = "/new";
14601     int r;
14602     suppress_error = 0;
14603     r = guestfs_is_dir (g, path);
14604     if (r == -1)
14605       return -1;
14606     if (!r) {
14607       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
14608       return -1;
14609     }
14610   }
14611   return 0;
14612 }
14613
14614 static int test_is_file_0_skip (void)
14615 {
14616   const char *str;
14617
14618   str = getenv ("TEST_ONLY");
14619   if (str)
14620     return strstr (str, "is_file") == NULL;
14621   str = getenv ("SKIP_TEST_IS_FILE_0");
14622   if (str && strcmp (str, "1") == 0) return 1;
14623   str = getenv ("SKIP_TEST_IS_FILE");
14624   if (str && strcmp (str, "1") == 0) return 1;
14625   return 0;
14626 }
14627
14628 static int test_is_file_0 (void)
14629 {
14630   if (test_is_file_0_skip ()) {
14631     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
14632     return 0;
14633   }
14634
14635   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
14636   {
14637     char device[] = "/dev/sda";
14638     int r;
14639     suppress_error = 0;
14640     r = guestfs_blockdev_setrw (g, device);
14641     if (r == -1)
14642       return -1;
14643   }
14644   {
14645     int r;
14646     suppress_error = 0;
14647     r = guestfs_umount_all (g);
14648     if (r == -1)
14649       return -1;
14650   }
14651   {
14652     int r;
14653     suppress_error = 0;
14654     r = guestfs_lvm_remove_all (g);
14655     if (r == -1)
14656       return -1;
14657   }
14658   {
14659     char device[] = "/dev/sda";
14660     char lines_0[] = ",";
14661     char *lines[] = {
14662       lines_0,
14663       NULL
14664     };
14665     int r;
14666     suppress_error = 0;
14667     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14668     if (r == -1)
14669       return -1;
14670   }
14671   {
14672     char fstype[] = "ext2";
14673     char device[] = "/dev/sda1";
14674     int r;
14675     suppress_error = 0;
14676     r = guestfs_mkfs (g, fstype, device);
14677     if (r == -1)
14678       return -1;
14679   }
14680   {
14681     char device[] = "/dev/sda1";
14682     char mountpoint[] = "/";
14683     int r;
14684     suppress_error = 0;
14685     r = guestfs_mount (g, device, mountpoint);
14686     if (r == -1)
14687       return -1;
14688   }
14689   /* TestOutputTrue for is_file (0) */
14690   {
14691     char path[] = "/new";
14692     int r;
14693     suppress_error = 0;
14694     r = guestfs_touch (g, path);
14695     if (r == -1)
14696       return -1;
14697   }
14698   {
14699     char path[] = "/new";
14700     int r;
14701     suppress_error = 0;
14702     r = guestfs_is_file (g, path);
14703     if (r == -1)
14704       return -1;
14705     if (!r) {
14706       fprintf (stderr, "test_is_file_0: expected true, got false\n");
14707       return -1;
14708     }
14709   }
14710   return 0;
14711 }
14712
14713 static int test_is_file_1_skip (void)
14714 {
14715   const char *str;
14716
14717   str = getenv ("TEST_ONLY");
14718   if (str)
14719     return strstr (str, "is_file") == NULL;
14720   str = getenv ("SKIP_TEST_IS_FILE_1");
14721   if (str && strcmp (str, "1") == 0) return 1;
14722   str = getenv ("SKIP_TEST_IS_FILE");
14723   if (str && strcmp (str, "1") == 0) return 1;
14724   return 0;
14725 }
14726
14727 static int test_is_file_1 (void)
14728 {
14729   if (test_is_file_1_skip ()) {
14730     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
14731     return 0;
14732   }
14733
14734   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
14735   {
14736     char device[] = "/dev/sda";
14737     int r;
14738     suppress_error = 0;
14739     r = guestfs_blockdev_setrw (g, device);
14740     if (r == -1)
14741       return -1;
14742   }
14743   {
14744     int r;
14745     suppress_error = 0;
14746     r = guestfs_umount_all (g);
14747     if (r == -1)
14748       return -1;
14749   }
14750   {
14751     int r;
14752     suppress_error = 0;
14753     r = guestfs_lvm_remove_all (g);
14754     if (r == -1)
14755       return -1;
14756   }
14757   {
14758     char device[] = "/dev/sda";
14759     char lines_0[] = ",";
14760     char *lines[] = {
14761       lines_0,
14762       NULL
14763     };
14764     int r;
14765     suppress_error = 0;
14766     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14767     if (r == -1)
14768       return -1;
14769   }
14770   {
14771     char fstype[] = "ext2";
14772     char device[] = "/dev/sda1";
14773     int r;
14774     suppress_error = 0;
14775     r = guestfs_mkfs (g, fstype, device);
14776     if (r == -1)
14777       return -1;
14778   }
14779   {
14780     char device[] = "/dev/sda1";
14781     char mountpoint[] = "/";
14782     int r;
14783     suppress_error = 0;
14784     r = guestfs_mount (g, device, mountpoint);
14785     if (r == -1)
14786       return -1;
14787   }
14788   /* TestOutputFalse for is_file (1) */
14789   {
14790     char path[] = "/new";
14791     int r;
14792     suppress_error = 0;
14793     r = guestfs_mkdir (g, path);
14794     if (r == -1)
14795       return -1;
14796   }
14797   {
14798     char path[] = "/new";
14799     int r;
14800     suppress_error = 0;
14801     r = guestfs_is_file (g, path);
14802     if (r == -1)
14803       return -1;
14804     if (r) {
14805       fprintf (stderr, "test_is_file_1: expected false, got true\n");
14806       return -1;
14807     }
14808   }
14809   return 0;
14810 }
14811
14812 static int test_exists_0_skip (void)
14813 {
14814   const char *str;
14815
14816   str = getenv ("TEST_ONLY");
14817   if (str)
14818     return strstr (str, "exists") == NULL;
14819   str = getenv ("SKIP_TEST_EXISTS_0");
14820   if (str && strcmp (str, "1") == 0) return 1;
14821   str = getenv ("SKIP_TEST_EXISTS");
14822   if (str && strcmp (str, "1") == 0) return 1;
14823   return 0;
14824 }
14825
14826 static int test_exists_0 (void)
14827 {
14828   if (test_exists_0_skip ()) {
14829     printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
14830     return 0;
14831   }
14832
14833   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
14834   {
14835     char device[] = "/dev/sda";
14836     int r;
14837     suppress_error = 0;
14838     r = guestfs_blockdev_setrw (g, device);
14839     if (r == -1)
14840       return -1;
14841   }
14842   {
14843     int r;
14844     suppress_error = 0;
14845     r = guestfs_umount_all (g);
14846     if (r == -1)
14847       return -1;
14848   }
14849   {
14850     int r;
14851     suppress_error = 0;
14852     r = guestfs_lvm_remove_all (g);
14853     if (r == -1)
14854       return -1;
14855   }
14856   {
14857     char device[] = "/dev/sda";
14858     char lines_0[] = ",";
14859     char *lines[] = {
14860       lines_0,
14861       NULL
14862     };
14863     int r;
14864     suppress_error = 0;
14865     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14866     if (r == -1)
14867       return -1;
14868   }
14869   {
14870     char fstype[] = "ext2";
14871     char device[] = "/dev/sda1";
14872     int r;
14873     suppress_error = 0;
14874     r = guestfs_mkfs (g, fstype, device);
14875     if (r == -1)
14876       return -1;
14877   }
14878   {
14879     char device[] = "/dev/sda1";
14880     char mountpoint[] = "/";
14881     int r;
14882     suppress_error = 0;
14883     r = guestfs_mount (g, device, mountpoint);
14884     if (r == -1)
14885       return -1;
14886   }
14887   /* TestOutputTrue for exists (0) */
14888   {
14889     char path[] = "/new";
14890     int r;
14891     suppress_error = 0;
14892     r = guestfs_touch (g, path);
14893     if (r == -1)
14894       return -1;
14895   }
14896   {
14897     char path[] = "/new";
14898     int r;
14899     suppress_error = 0;
14900     r = guestfs_exists (g, path);
14901     if (r == -1)
14902       return -1;
14903     if (!r) {
14904       fprintf (stderr, "test_exists_0: expected true, got false\n");
14905       return -1;
14906     }
14907   }
14908   return 0;
14909 }
14910
14911 static int test_exists_1_skip (void)
14912 {
14913   const char *str;
14914
14915   str = getenv ("TEST_ONLY");
14916   if (str)
14917     return strstr (str, "exists") == NULL;
14918   str = getenv ("SKIP_TEST_EXISTS_1");
14919   if (str && strcmp (str, "1") == 0) return 1;
14920   str = getenv ("SKIP_TEST_EXISTS");
14921   if (str && strcmp (str, "1") == 0) return 1;
14922   return 0;
14923 }
14924
14925 static int test_exists_1 (void)
14926 {
14927   if (test_exists_1_skip ()) {
14928     printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
14929     return 0;
14930   }
14931
14932   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
14933   {
14934     char device[] = "/dev/sda";
14935     int r;
14936     suppress_error = 0;
14937     r = guestfs_blockdev_setrw (g, device);
14938     if (r == -1)
14939       return -1;
14940   }
14941   {
14942     int r;
14943     suppress_error = 0;
14944     r = guestfs_umount_all (g);
14945     if (r == -1)
14946       return -1;
14947   }
14948   {
14949     int r;
14950     suppress_error = 0;
14951     r = guestfs_lvm_remove_all (g);
14952     if (r == -1)
14953       return -1;
14954   }
14955   {
14956     char device[] = "/dev/sda";
14957     char lines_0[] = ",";
14958     char *lines[] = {
14959       lines_0,
14960       NULL
14961     };
14962     int r;
14963     suppress_error = 0;
14964     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14965     if (r == -1)
14966       return -1;
14967   }
14968   {
14969     char fstype[] = "ext2";
14970     char device[] = "/dev/sda1";
14971     int r;
14972     suppress_error = 0;
14973     r = guestfs_mkfs (g, fstype, device);
14974     if (r == -1)
14975       return -1;
14976   }
14977   {
14978     char device[] = "/dev/sda1";
14979     char mountpoint[] = "/";
14980     int r;
14981     suppress_error = 0;
14982     r = guestfs_mount (g, device, mountpoint);
14983     if (r == -1)
14984       return -1;
14985   }
14986   /* TestOutputTrue for exists (1) */
14987   {
14988     char path[] = "/new";
14989     int r;
14990     suppress_error = 0;
14991     r = guestfs_mkdir (g, path);
14992     if (r == -1)
14993       return -1;
14994   }
14995   {
14996     char path[] = "/new";
14997     int r;
14998     suppress_error = 0;
14999     r = guestfs_exists (g, path);
15000     if (r == -1)
15001       return -1;
15002     if (!r) {
15003       fprintf (stderr, "test_exists_1: expected true, got false\n");
15004       return -1;
15005     }
15006   }
15007   return 0;
15008 }
15009
15010 static int test_mkdir_p_0_skip (void)
15011 {
15012   const char *str;
15013
15014   str = getenv ("TEST_ONLY");
15015   if (str)
15016     return strstr (str, "mkdir_p") == NULL;
15017   str = getenv ("SKIP_TEST_MKDIR_P_0");
15018   if (str && strcmp (str, "1") == 0) return 1;
15019   str = getenv ("SKIP_TEST_MKDIR_P");
15020   if (str && strcmp (str, "1") == 0) return 1;
15021   return 0;
15022 }
15023
15024 static int test_mkdir_p_0 (void)
15025 {
15026   if (test_mkdir_p_0_skip ()) {
15027     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15028     return 0;
15029   }
15030
15031   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
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   {
15055     char device[] = "/dev/sda";
15056     char lines_0[] = ",";
15057     char *lines[] = {
15058       lines_0,
15059       NULL
15060     };
15061     int r;
15062     suppress_error = 0;
15063     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15064     if (r == -1)
15065       return -1;
15066   }
15067   {
15068     char fstype[] = "ext2";
15069     char device[] = "/dev/sda1";
15070     int r;
15071     suppress_error = 0;
15072     r = guestfs_mkfs (g, fstype, device);
15073     if (r == -1)
15074       return -1;
15075   }
15076   {
15077     char device[] = "/dev/sda1";
15078     char mountpoint[] = "/";
15079     int r;
15080     suppress_error = 0;
15081     r = guestfs_mount (g, device, mountpoint);
15082     if (r == -1)
15083       return -1;
15084   }
15085   /* TestOutputTrue for mkdir_p (0) */
15086   {
15087     char path[] = "/new/foo/bar";
15088     int r;
15089     suppress_error = 0;
15090     r = guestfs_mkdir_p (g, path);
15091     if (r == -1)
15092       return -1;
15093   }
15094   {
15095     char path[] = "/new/foo/bar";
15096     int r;
15097     suppress_error = 0;
15098     r = guestfs_is_dir (g, path);
15099     if (r == -1)
15100       return -1;
15101     if (!r) {
15102       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15103       return -1;
15104     }
15105   }
15106   return 0;
15107 }
15108
15109 static int test_mkdir_p_1_skip (void)
15110 {
15111   const char *str;
15112
15113   str = getenv ("TEST_ONLY");
15114   if (str)
15115     return strstr (str, "mkdir_p") == NULL;
15116   str = getenv ("SKIP_TEST_MKDIR_P_1");
15117   if (str && strcmp (str, "1") == 0) return 1;
15118   str = getenv ("SKIP_TEST_MKDIR_P");
15119   if (str && strcmp (str, "1") == 0) return 1;
15120   return 0;
15121 }
15122
15123 static int test_mkdir_p_1 (void)
15124 {
15125   if (test_mkdir_p_1_skip ()) {
15126     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15127     return 0;
15128   }
15129
15130   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15131   {
15132     char device[] = "/dev/sda";
15133     int r;
15134     suppress_error = 0;
15135     r = guestfs_blockdev_setrw (g, device);
15136     if (r == -1)
15137       return -1;
15138   }
15139   {
15140     int r;
15141     suppress_error = 0;
15142     r = guestfs_umount_all (g);
15143     if (r == -1)
15144       return -1;
15145   }
15146   {
15147     int r;
15148     suppress_error = 0;
15149     r = guestfs_lvm_remove_all (g);
15150     if (r == -1)
15151       return -1;
15152   }
15153   {
15154     char device[] = "/dev/sda";
15155     char lines_0[] = ",";
15156     char *lines[] = {
15157       lines_0,
15158       NULL
15159     };
15160     int r;
15161     suppress_error = 0;
15162     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15163     if (r == -1)
15164       return -1;
15165   }
15166   {
15167     char fstype[] = "ext2";
15168     char device[] = "/dev/sda1";
15169     int r;
15170     suppress_error = 0;
15171     r = guestfs_mkfs (g, fstype, device);
15172     if (r == -1)
15173       return -1;
15174   }
15175   {
15176     char device[] = "/dev/sda1";
15177     char mountpoint[] = "/";
15178     int r;
15179     suppress_error = 0;
15180     r = guestfs_mount (g, device, mountpoint);
15181     if (r == -1)
15182       return -1;
15183   }
15184   /* TestOutputTrue for mkdir_p (1) */
15185   {
15186     char path[] = "/new/foo/bar";
15187     int r;
15188     suppress_error = 0;
15189     r = guestfs_mkdir_p (g, path);
15190     if (r == -1)
15191       return -1;
15192   }
15193   {
15194     char path[] = "/new/foo";
15195     int r;
15196     suppress_error = 0;
15197     r = guestfs_is_dir (g, path);
15198     if (r == -1)
15199       return -1;
15200     if (!r) {
15201       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15202       return -1;
15203     }
15204   }
15205   return 0;
15206 }
15207
15208 static int test_mkdir_p_2_skip (void)
15209 {
15210   const char *str;
15211
15212   str = getenv ("TEST_ONLY");
15213   if (str)
15214     return strstr (str, "mkdir_p") == NULL;
15215   str = getenv ("SKIP_TEST_MKDIR_P_2");
15216   if (str && strcmp (str, "1") == 0) return 1;
15217   str = getenv ("SKIP_TEST_MKDIR_P");
15218   if (str && strcmp (str, "1") == 0) return 1;
15219   return 0;
15220 }
15221
15222 static int test_mkdir_p_2 (void)
15223 {
15224   if (test_mkdir_p_2_skip ()) {
15225     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15226     return 0;
15227   }
15228
15229   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15230   {
15231     char device[] = "/dev/sda";
15232     int r;
15233     suppress_error = 0;
15234     r = guestfs_blockdev_setrw (g, device);
15235     if (r == -1)
15236       return -1;
15237   }
15238   {
15239     int r;
15240     suppress_error = 0;
15241     r = guestfs_umount_all (g);
15242     if (r == -1)
15243       return -1;
15244   }
15245   {
15246     int r;
15247     suppress_error = 0;
15248     r = guestfs_lvm_remove_all (g);
15249     if (r == -1)
15250       return -1;
15251   }
15252   {
15253     char device[] = "/dev/sda";
15254     char lines_0[] = ",";
15255     char *lines[] = {
15256       lines_0,
15257       NULL
15258     };
15259     int r;
15260     suppress_error = 0;
15261     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15262     if (r == -1)
15263       return -1;
15264   }
15265   {
15266     char fstype[] = "ext2";
15267     char device[] = "/dev/sda1";
15268     int r;
15269     suppress_error = 0;
15270     r = guestfs_mkfs (g, fstype, device);
15271     if (r == -1)
15272       return -1;
15273   }
15274   {
15275     char device[] = "/dev/sda1";
15276     char mountpoint[] = "/";
15277     int r;
15278     suppress_error = 0;
15279     r = guestfs_mount (g, device, mountpoint);
15280     if (r == -1)
15281       return -1;
15282   }
15283   /* TestOutputTrue for mkdir_p (2) */
15284   {
15285     char path[] = "/new/foo/bar";
15286     int r;
15287     suppress_error = 0;
15288     r = guestfs_mkdir_p (g, path);
15289     if (r == -1)
15290       return -1;
15291   }
15292   {
15293     char path[] = "/new";
15294     int r;
15295     suppress_error = 0;
15296     r = guestfs_is_dir (g, path);
15297     if (r == -1)
15298       return -1;
15299     if (!r) {
15300       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15301       return -1;
15302     }
15303   }
15304   return 0;
15305 }
15306
15307 static int test_mkdir_p_3_skip (void)
15308 {
15309   const char *str;
15310
15311   str = getenv ("TEST_ONLY");
15312   if (str)
15313     return strstr (str, "mkdir_p") == NULL;
15314   str = getenv ("SKIP_TEST_MKDIR_P_3");
15315   if (str && strcmp (str, "1") == 0) return 1;
15316   str = getenv ("SKIP_TEST_MKDIR_P");
15317   if (str && strcmp (str, "1") == 0) return 1;
15318   return 0;
15319 }
15320
15321 static int test_mkdir_p_3 (void)
15322 {
15323   if (test_mkdir_p_3_skip ()) {
15324     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15325     return 0;
15326   }
15327
15328   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15329   {
15330     char device[] = "/dev/sda";
15331     int r;
15332     suppress_error = 0;
15333     r = guestfs_blockdev_setrw (g, device);
15334     if (r == -1)
15335       return -1;
15336   }
15337   {
15338     int r;
15339     suppress_error = 0;
15340     r = guestfs_umount_all (g);
15341     if (r == -1)
15342       return -1;
15343   }
15344   {
15345     int r;
15346     suppress_error = 0;
15347     r = guestfs_lvm_remove_all (g);
15348     if (r == -1)
15349       return -1;
15350   }
15351   {
15352     char device[] = "/dev/sda";
15353     char lines_0[] = ",";
15354     char *lines[] = {
15355       lines_0,
15356       NULL
15357     };
15358     int r;
15359     suppress_error = 0;
15360     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15361     if (r == -1)
15362       return -1;
15363   }
15364   {
15365     char fstype[] = "ext2";
15366     char device[] = "/dev/sda1";
15367     int r;
15368     suppress_error = 0;
15369     r = guestfs_mkfs (g, fstype, device);
15370     if (r == -1)
15371       return -1;
15372   }
15373   {
15374     char device[] = "/dev/sda1";
15375     char mountpoint[] = "/";
15376     int r;
15377     suppress_error = 0;
15378     r = guestfs_mount (g, device, mountpoint);
15379     if (r == -1)
15380       return -1;
15381   }
15382   /* TestRun for mkdir_p (3) */
15383   {
15384     char path[] = "/new";
15385     int r;
15386     suppress_error = 0;
15387     r = guestfs_mkdir (g, path);
15388     if (r == -1)
15389       return -1;
15390   }
15391   {
15392     char path[] = "/new";
15393     int r;
15394     suppress_error = 0;
15395     r = guestfs_mkdir_p (g, path);
15396     if (r == -1)
15397       return -1;
15398   }
15399   return 0;
15400 }
15401
15402 static int test_mkdir_p_4_skip (void)
15403 {
15404   const char *str;
15405
15406   str = getenv ("TEST_ONLY");
15407   if (str)
15408     return strstr (str, "mkdir_p") == NULL;
15409   str = getenv ("SKIP_TEST_MKDIR_P_4");
15410   if (str && strcmp (str, "1") == 0) return 1;
15411   str = getenv ("SKIP_TEST_MKDIR_P");
15412   if (str && strcmp (str, "1") == 0) return 1;
15413   return 0;
15414 }
15415
15416 static int test_mkdir_p_4 (void)
15417 {
15418   if (test_mkdir_p_4_skip ()) {
15419     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15420     return 0;
15421   }
15422
15423   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15424   {
15425     char device[] = "/dev/sda";
15426     int r;
15427     suppress_error = 0;
15428     r = guestfs_blockdev_setrw (g, device);
15429     if (r == -1)
15430       return -1;
15431   }
15432   {
15433     int r;
15434     suppress_error = 0;
15435     r = guestfs_umount_all (g);
15436     if (r == -1)
15437       return -1;
15438   }
15439   {
15440     int r;
15441     suppress_error = 0;
15442     r = guestfs_lvm_remove_all (g);
15443     if (r == -1)
15444       return -1;
15445   }
15446   {
15447     char device[] = "/dev/sda";
15448     char lines_0[] = ",";
15449     char *lines[] = {
15450       lines_0,
15451       NULL
15452     };
15453     int r;
15454     suppress_error = 0;
15455     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15456     if (r == -1)
15457       return -1;
15458   }
15459   {
15460     char fstype[] = "ext2";
15461     char device[] = "/dev/sda1";
15462     int r;
15463     suppress_error = 0;
15464     r = guestfs_mkfs (g, fstype, device);
15465     if (r == -1)
15466       return -1;
15467   }
15468   {
15469     char device[] = "/dev/sda1";
15470     char mountpoint[] = "/";
15471     int r;
15472     suppress_error = 0;
15473     r = guestfs_mount (g, device, mountpoint);
15474     if (r == -1)
15475       return -1;
15476   }
15477   /* TestLastFail for mkdir_p (4) */
15478   {
15479     char path[] = "/new";
15480     int r;
15481     suppress_error = 0;
15482     r = guestfs_touch (g, path);
15483     if (r == -1)
15484       return -1;
15485   }
15486   {
15487     char path[] = "/new";
15488     int r;
15489     suppress_error = 1;
15490     r = guestfs_mkdir_p (g, path);
15491     if (r != -1)
15492       return -1;
15493   }
15494   return 0;
15495 }
15496
15497 static int test_mkdir_0_skip (void)
15498 {
15499   const char *str;
15500
15501   str = getenv ("TEST_ONLY");
15502   if (str)
15503     return strstr (str, "mkdir") == NULL;
15504   str = getenv ("SKIP_TEST_MKDIR_0");
15505   if (str && strcmp (str, "1") == 0) return 1;
15506   str = getenv ("SKIP_TEST_MKDIR");
15507   if (str && strcmp (str, "1") == 0) return 1;
15508   return 0;
15509 }
15510
15511 static int test_mkdir_0 (void)
15512 {
15513   if (test_mkdir_0_skip ()) {
15514     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15515     return 0;
15516   }
15517
15518   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15519   {
15520     char device[] = "/dev/sda";
15521     int r;
15522     suppress_error = 0;
15523     r = guestfs_blockdev_setrw (g, device);
15524     if (r == -1)
15525       return -1;
15526   }
15527   {
15528     int r;
15529     suppress_error = 0;
15530     r = guestfs_umount_all (g);
15531     if (r == -1)
15532       return -1;
15533   }
15534   {
15535     int r;
15536     suppress_error = 0;
15537     r = guestfs_lvm_remove_all (g);
15538     if (r == -1)
15539       return -1;
15540   }
15541   {
15542     char device[] = "/dev/sda";
15543     char lines_0[] = ",";
15544     char *lines[] = {
15545       lines_0,
15546       NULL
15547     };
15548     int r;
15549     suppress_error = 0;
15550     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15551     if (r == -1)
15552       return -1;
15553   }
15554   {
15555     char fstype[] = "ext2";
15556     char device[] = "/dev/sda1";
15557     int r;
15558     suppress_error = 0;
15559     r = guestfs_mkfs (g, fstype, device);
15560     if (r == -1)
15561       return -1;
15562   }
15563   {
15564     char device[] = "/dev/sda1";
15565     char mountpoint[] = "/";
15566     int r;
15567     suppress_error = 0;
15568     r = guestfs_mount (g, device, mountpoint);
15569     if (r == -1)
15570       return -1;
15571   }
15572   /* TestOutputTrue for mkdir (0) */
15573   {
15574     char path[] = "/new";
15575     int r;
15576     suppress_error = 0;
15577     r = guestfs_mkdir (g, path);
15578     if (r == -1)
15579       return -1;
15580   }
15581   {
15582     char path[] = "/new";
15583     int r;
15584     suppress_error = 0;
15585     r = guestfs_is_dir (g, path);
15586     if (r == -1)
15587       return -1;
15588     if (!r) {
15589       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
15590       return -1;
15591     }
15592   }
15593   return 0;
15594 }
15595
15596 static int test_mkdir_1_skip (void)
15597 {
15598   const char *str;
15599
15600   str = getenv ("TEST_ONLY");
15601   if (str)
15602     return strstr (str, "mkdir") == NULL;
15603   str = getenv ("SKIP_TEST_MKDIR_1");
15604   if (str && strcmp (str, "1") == 0) return 1;
15605   str = getenv ("SKIP_TEST_MKDIR");
15606   if (str && strcmp (str, "1") == 0) return 1;
15607   return 0;
15608 }
15609
15610 static int test_mkdir_1 (void)
15611 {
15612   if (test_mkdir_1_skip ()) {
15613     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
15614     return 0;
15615   }
15616
15617   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
15618   {
15619     char device[] = "/dev/sda";
15620     int r;
15621     suppress_error = 0;
15622     r = guestfs_blockdev_setrw (g, device);
15623     if (r == -1)
15624       return -1;
15625   }
15626   {
15627     int r;
15628     suppress_error = 0;
15629     r = guestfs_umount_all (g);
15630     if (r == -1)
15631       return -1;
15632   }
15633   {
15634     int r;
15635     suppress_error = 0;
15636     r = guestfs_lvm_remove_all (g);
15637     if (r == -1)
15638       return -1;
15639   }
15640   {
15641     char device[] = "/dev/sda";
15642     char lines_0[] = ",";
15643     char *lines[] = {
15644       lines_0,
15645       NULL
15646     };
15647     int r;
15648     suppress_error = 0;
15649     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15650     if (r == -1)
15651       return -1;
15652   }
15653   {
15654     char fstype[] = "ext2";
15655     char device[] = "/dev/sda1";
15656     int r;
15657     suppress_error = 0;
15658     r = guestfs_mkfs (g, fstype, device);
15659     if (r == -1)
15660       return -1;
15661   }
15662   {
15663     char device[] = "/dev/sda1";
15664     char mountpoint[] = "/";
15665     int r;
15666     suppress_error = 0;
15667     r = guestfs_mount (g, device, mountpoint);
15668     if (r == -1)
15669       return -1;
15670   }
15671   /* TestLastFail for mkdir (1) */
15672   {
15673     char path[] = "/new/foo/bar";
15674     int r;
15675     suppress_error = 1;
15676     r = guestfs_mkdir (g, path);
15677     if (r != -1)
15678       return -1;
15679   }
15680   return 0;
15681 }
15682
15683 static int test_rm_rf_0_skip (void)
15684 {
15685   const char *str;
15686
15687   str = getenv ("TEST_ONLY");
15688   if (str)
15689     return strstr (str, "rm_rf") == NULL;
15690   str = getenv ("SKIP_TEST_RM_RF_0");
15691   if (str && strcmp (str, "1") == 0) return 1;
15692   str = getenv ("SKIP_TEST_RM_RF");
15693   if (str && strcmp (str, "1") == 0) return 1;
15694   return 0;
15695 }
15696
15697 static int test_rm_rf_0 (void)
15698 {
15699   if (test_rm_rf_0_skip ()) {
15700     printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
15701     return 0;
15702   }
15703
15704   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
15705   {
15706     char device[] = "/dev/sda";
15707     int r;
15708     suppress_error = 0;
15709     r = guestfs_blockdev_setrw (g, device);
15710     if (r == -1)
15711       return -1;
15712   }
15713   {
15714     int r;
15715     suppress_error = 0;
15716     r = guestfs_umount_all (g);
15717     if (r == -1)
15718       return -1;
15719   }
15720   {
15721     int r;
15722     suppress_error = 0;
15723     r = guestfs_lvm_remove_all (g);
15724     if (r == -1)
15725       return -1;
15726   }
15727   {
15728     char device[] = "/dev/sda";
15729     char lines_0[] = ",";
15730     char *lines[] = {
15731       lines_0,
15732       NULL
15733     };
15734     int r;
15735     suppress_error = 0;
15736     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15737     if (r == -1)
15738       return -1;
15739   }
15740   {
15741     char fstype[] = "ext2";
15742     char device[] = "/dev/sda1";
15743     int r;
15744     suppress_error = 0;
15745     r = guestfs_mkfs (g, fstype, device);
15746     if (r == -1)
15747       return -1;
15748   }
15749   {
15750     char device[] = "/dev/sda1";
15751     char mountpoint[] = "/";
15752     int r;
15753     suppress_error = 0;
15754     r = guestfs_mount (g, device, mountpoint);
15755     if (r == -1)
15756       return -1;
15757   }
15758   /* TestOutputFalse for rm_rf (0) */
15759   {
15760     char path[] = "/new";
15761     int r;
15762     suppress_error = 0;
15763     r = guestfs_mkdir (g, path);
15764     if (r == -1)
15765       return -1;
15766   }
15767   {
15768     char path[] = "/new/foo";
15769     int r;
15770     suppress_error = 0;
15771     r = guestfs_mkdir (g, path);
15772     if (r == -1)
15773       return -1;
15774   }
15775   {
15776     char path[] = "/new/foo/bar";
15777     int r;
15778     suppress_error = 0;
15779     r = guestfs_touch (g, path);
15780     if (r == -1)
15781       return -1;
15782   }
15783   {
15784     char path[] = "/new";
15785     int r;
15786     suppress_error = 0;
15787     r = guestfs_rm_rf (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_rm_rf_0: expected false, got true\n");
15800       return -1;
15801     }
15802   }
15803   return 0;
15804 }
15805
15806 static int test_rmdir_0_skip (void)
15807 {
15808   const char *str;
15809
15810   str = getenv ("TEST_ONLY");
15811   if (str)
15812     return strstr (str, "rmdir") == NULL;
15813   str = getenv ("SKIP_TEST_RMDIR_0");
15814   if (str && strcmp (str, "1") == 0) return 1;
15815   str = getenv ("SKIP_TEST_RMDIR");
15816   if (str && strcmp (str, "1") == 0) return 1;
15817   return 0;
15818 }
15819
15820 static int test_rmdir_0 (void)
15821 {
15822   if (test_rmdir_0_skip ()) {
15823     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
15824     return 0;
15825   }
15826
15827   /* InitBasicFS for test_rmdir_0: 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   /* TestRun for rmdir (0) */
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_rmdir (g, path);
15895     if (r == -1)
15896       return -1;
15897   }
15898   return 0;
15899 }
15900
15901 static int test_rmdir_1_skip (void)
15902 {
15903   const char *str;
15904
15905   str = getenv ("TEST_ONLY");
15906   if (str)
15907     return strstr (str, "rmdir") == NULL;
15908   str = getenv ("SKIP_TEST_RMDIR_1");
15909   if (str && strcmp (str, "1") == 0) return 1;
15910   str = getenv ("SKIP_TEST_RMDIR");
15911   if (str && strcmp (str, "1") == 0) return 1;
15912   return 0;
15913 }
15914
15915 static int test_rmdir_1 (void)
15916 {
15917   if (test_rmdir_1_skip ()) {
15918     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
15919     return 0;
15920   }
15921
15922   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
15923   {
15924     char device[] = "/dev/sda";
15925     int r;
15926     suppress_error = 0;
15927     r = guestfs_blockdev_setrw (g, device);
15928     if (r == -1)
15929       return -1;
15930   }
15931   {
15932     int r;
15933     suppress_error = 0;
15934     r = guestfs_umount_all (g);
15935     if (r == -1)
15936       return -1;
15937   }
15938   {
15939     int r;
15940     suppress_error = 0;
15941     r = guestfs_lvm_remove_all (g);
15942     if (r == -1)
15943       return -1;
15944   }
15945   {
15946     char device[] = "/dev/sda";
15947     char lines_0[] = ",";
15948     char *lines[] = {
15949       lines_0,
15950       NULL
15951     };
15952     int r;
15953     suppress_error = 0;
15954     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15955     if (r == -1)
15956       return -1;
15957   }
15958   {
15959     char fstype[] = "ext2";
15960     char device[] = "/dev/sda1";
15961     int r;
15962     suppress_error = 0;
15963     r = guestfs_mkfs (g, fstype, device);
15964     if (r == -1)
15965       return -1;
15966   }
15967   {
15968     char device[] = "/dev/sda1";
15969     char mountpoint[] = "/";
15970     int r;
15971     suppress_error = 0;
15972     r = guestfs_mount (g, device, mountpoint);
15973     if (r == -1)
15974       return -1;
15975   }
15976   /* TestLastFail for rmdir (1) */
15977   {
15978     char path[] = "/new";
15979     int r;
15980     suppress_error = 1;
15981     r = guestfs_rmdir (g, path);
15982     if (r != -1)
15983       return -1;
15984   }
15985   return 0;
15986 }
15987
15988 static int test_rmdir_2_skip (void)
15989 {
15990   const char *str;
15991
15992   str = getenv ("TEST_ONLY");
15993   if (str)
15994     return strstr (str, "rmdir") == NULL;
15995   str = getenv ("SKIP_TEST_RMDIR_2");
15996   if (str && strcmp (str, "1") == 0) return 1;
15997   str = getenv ("SKIP_TEST_RMDIR");
15998   if (str && strcmp (str, "1") == 0) return 1;
15999   return 0;
16000 }
16001
16002 static int test_rmdir_2 (void)
16003 {
16004   if (test_rmdir_2_skip ()) {
16005     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16006     return 0;
16007   }
16008
16009   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16010   {
16011     char device[] = "/dev/sda";
16012     int r;
16013     suppress_error = 0;
16014     r = guestfs_blockdev_setrw (g, device);
16015     if (r == -1)
16016       return -1;
16017   }
16018   {
16019     int r;
16020     suppress_error = 0;
16021     r = guestfs_umount_all (g);
16022     if (r == -1)
16023       return -1;
16024   }
16025   {
16026     int r;
16027     suppress_error = 0;
16028     r = guestfs_lvm_remove_all (g);
16029     if (r == -1)
16030       return -1;
16031   }
16032   {
16033     char device[] = "/dev/sda";
16034     char lines_0[] = ",";
16035     char *lines[] = {
16036       lines_0,
16037       NULL
16038     };
16039     int r;
16040     suppress_error = 0;
16041     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16042     if (r == -1)
16043       return -1;
16044   }
16045   {
16046     char fstype[] = "ext2";
16047     char device[] = "/dev/sda1";
16048     int r;
16049     suppress_error = 0;
16050     r = guestfs_mkfs (g, fstype, device);
16051     if (r == -1)
16052       return -1;
16053   }
16054   {
16055     char device[] = "/dev/sda1";
16056     char mountpoint[] = "/";
16057     int r;
16058     suppress_error = 0;
16059     r = guestfs_mount (g, device, mountpoint);
16060     if (r == -1)
16061       return -1;
16062   }
16063   /* TestLastFail for rmdir (2) */
16064   {
16065     char path[] = "/new";
16066     int r;
16067     suppress_error = 0;
16068     r = guestfs_touch (g, path);
16069     if (r == -1)
16070       return -1;
16071   }
16072   {
16073     char path[] = "/new";
16074     int r;
16075     suppress_error = 1;
16076     r = guestfs_rmdir (g, path);
16077     if (r != -1)
16078       return -1;
16079   }
16080   return 0;
16081 }
16082
16083 static int test_rm_0_skip (void)
16084 {
16085   const char *str;
16086
16087   str = getenv ("TEST_ONLY");
16088   if (str)
16089     return strstr (str, "rm") == NULL;
16090   str = getenv ("SKIP_TEST_RM_0");
16091   if (str && strcmp (str, "1") == 0) return 1;
16092   str = getenv ("SKIP_TEST_RM");
16093   if (str && strcmp (str, "1") == 0) return 1;
16094   return 0;
16095 }
16096
16097 static int test_rm_0 (void)
16098 {
16099   if (test_rm_0_skip ()) {
16100     printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16101     return 0;
16102   }
16103
16104   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16105   {
16106     char device[] = "/dev/sda";
16107     int r;
16108     suppress_error = 0;
16109     r = guestfs_blockdev_setrw (g, device);
16110     if (r == -1)
16111       return -1;
16112   }
16113   {
16114     int r;
16115     suppress_error = 0;
16116     r = guestfs_umount_all (g);
16117     if (r == -1)
16118       return -1;
16119   }
16120   {
16121     int r;
16122     suppress_error = 0;
16123     r = guestfs_lvm_remove_all (g);
16124     if (r == -1)
16125       return -1;
16126   }
16127   {
16128     char device[] = "/dev/sda";
16129     char lines_0[] = ",";
16130     char *lines[] = {
16131       lines_0,
16132       NULL
16133     };
16134     int r;
16135     suppress_error = 0;
16136     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16137     if (r == -1)
16138       return -1;
16139   }
16140   {
16141     char fstype[] = "ext2";
16142     char device[] = "/dev/sda1";
16143     int r;
16144     suppress_error = 0;
16145     r = guestfs_mkfs (g, fstype, device);
16146     if (r == -1)
16147       return -1;
16148   }
16149   {
16150     char device[] = "/dev/sda1";
16151     char mountpoint[] = "/";
16152     int r;
16153     suppress_error = 0;
16154     r = guestfs_mount (g, device, mountpoint);
16155     if (r == -1)
16156       return -1;
16157   }
16158   /* TestRun for rm (0) */
16159   {
16160     char path[] = "/new";
16161     int r;
16162     suppress_error = 0;
16163     r = guestfs_touch (g, path);
16164     if (r == -1)
16165       return -1;
16166   }
16167   {
16168     char path[] = "/new";
16169     int r;
16170     suppress_error = 0;
16171     r = guestfs_rm (g, path);
16172     if (r == -1)
16173       return -1;
16174   }
16175   return 0;
16176 }
16177
16178 static int test_rm_1_skip (void)
16179 {
16180   const char *str;
16181
16182   str = getenv ("TEST_ONLY");
16183   if (str)
16184     return strstr (str, "rm") == NULL;
16185   str = getenv ("SKIP_TEST_RM_1");
16186   if (str && strcmp (str, "1") == 0) return 1;
16187   str = getenv ("SKIP_TEST_RM");
16188   if (str && strcmp (str, "1") == 0) return 1;
16189   return 0;
16190 }
16191
16192 static int test_rm_1 (void)
16193 {
16194   if (test_rm_1_skip ()) {
16195     printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16196     return 0;
16197   }
16198
16199   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16200   {
16201     char device[] = "/dev/sda";
16202     int r;
16203     suppress_error = 0;
16204     r = guestfs_blockdev_setrw (g, device);
16205     if (r == -1)
16206       return -1;
16207   }
16208   {
16209     int r;
16210     suppress_error = 0;
16211     r = guestfs_umount_all (g);
16212     if (r == -1)
16213       return -1;
16214   }
16215   {
16216     int r;
16217     suppress_error = 0;
16218     r = guestfs_lvm_remove_all (g);
16219     if (r == -1)
16220       return -1;
16221   }
16222   {
16223     char device[] = "/dev/sda";
16224     char lines_0[] = ",";
16225     char *lines[] = {
16226       lines_0,
16227       NULL
16228     };
16229     int r;
16230     suppress_error = 0;
16231     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16232     if (r == -1)
16233       return -1;
16234   }
16235   {
16236     char fstype[] = "ext2";
16237     char device[] = "/dev/sda1";
16238     int r;
16239     suppress_error = 0;
16240     r = guestfs_mkfs (g, fstype, device);
16241     if (r == -1)
16242       return -1;
16243   }
16244   {
16245     char device[] = "/dev/sda1";
16246     char mountpoint[] = "/";
16247     int r;
16248     suppress_error = 0;
16249     r = guestfs_mount (g, device, mountpoint);
16250     if (r == -1)
16251       return -1;
16252   }
16253   /* TestLastFail for rm (1) */
16254   {
16255     char path[] = "/new";
16256     int r;
16257     suppress_error = 1;
16258     r = guestfs_rm (g, path);
16259     if (r != -1)
16260       return -1;
16261   }
16262   return 0;
16263 }
16264
16265 static int test_rm_2_skip (void)
16266 {
16267   const char *str;
16268
16269   str = getenv ("TEST_ONLY");
16270   if (str)
16271     return strstr (str, "rm") == NULL;
16272   str = getenv ("SKIP_TEST_RM_2");
16273   if (str && strcmp (str, "1") == 0) return 1;
16274   str = getenv ("SKIP_TEST_RM");
16275   if (str && strcmp (str, "1") == 0) return 1;
16276   return 0;
16277 }
16278
16279 static int test_rm_2 (void)
16280 {
16281   if (test_rm_2_skip ()) {
16282     printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16283     return 0;
16284   }
16285
16286   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16287   {
16288     char device[] = "/dev/sda";
16289     int r;
16290     suppress_error = 0;
16291     r = guestfs_blockdev_setrw (g, device);
16292     if (r == -1)
16293       return -1;
16294   }
16295   {
16296     int r;
16297     suppress_error = 0;
16298     r = guestfs_umount_all (g);
16299     if (r == -1)
16300       return -1;
16301   }
16302   {
16303     int r;
16304     suppress_error = 0;
16305     r = guestfs_lvm_remove_all (g);
16306     if (r == -1)
16307       return -1;
16308   }
16309   {
16310     char device[] = "/dev/sda";
16311     char lines_0[] = ",";
16312     char *lines[] = {
16313       lines_0,
16314       NULL
16315     };
16316     int r;
16317     suppress_error = 0;
16318     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16319     if (r == -1)
16320       return -1;
16321   }
16322   {
16323     char fstype[] = "ext2";
16324     char device[] = "/dev/sda1";
16325     int r;
16326     suppress_error = 0;
16327     r = guestfs_mkfs (g, fstype, device);
16328     if (r == -1)
16329       return -1;
16330   }
16331   {
16332     char device[] = "/dev/sda1";
16333     char mountpoint[] = "/";
16334     int r;
16335     suppress_error = 0;
16336     r = guestfs_mount (g, device, mountpoint);
16337     if (r == -1)
16338       return -1;
16339   }
16340   /* TestLastFail for rm (2) */
16341   {
16342     char path[] = "/new";
16343     int r;
16344     suppress_error = 0;
16345     r = guestfs_mkdir (g, path);
16346     if (r == -1)
16347       return -1;
16348   }
16349   {
16350     char path[] = "/new";
16351     int r;
16352     suppress_error = 1;
16353     r = guestfs_rm (g, path);
16354     if (r != -1)
16355       return -1;
16356   }
16357   return 0;
16358 }
16359
16360 static int test_read_lines_0_skip (void)
16361 {
16362   const char *str;
16363
16364   str = getenv ("TEST_ONLY");
16365   if (str)
16366     return strstr (str, "read_lines") == NULL;
16367   str = getenv ("SKIP_TEST_READ_LINES_0");
16368   if (str && strcmp (str, "1") == 0) return 1;
16369   str = getenv ("SKIP_TEST_READ_LINES");
16370   if (str && strcmp (str, "1") == 0) return 1;
16371   return 0;
16372 }
16373
16374 static int test_read_lines_0 (void)
16375 {
16376   if (test_read_lines_0_skip ()) {
16377     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16378     return 0;
16379   }
16380
16381   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16382   {
16383     char device[] = "/dev/sda";
16384     int r;
16385     suppress_error = 0;
16386     r = guestfs_blockdev_setrw (g, device);
16387     if (r == -1)
16388       return -1;
16389   }
16390   {
16391     int r;
16392     suppress_error = 0;
16393     r = guestfs_umount_all (g);
16394     if (r == -1)
16395       return -1;
16396   }
16397   {
16398     int r;
16399     suppress_error = 0;
16400     r = guestfs_lvm_remove_all (g);
16401     if (r == -1)
16402       return -1;
16403   }
16404   {
16405     char device[] = "/dev/sda";
16406     char lines_0[] = ",";
16407     char *lines[] = {
16408       lines_0,
16409       NULL
16410     };
16411     int r;
16412     suppress_error = 0;
16413     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16414     if (r == -1)
16415       return -1;
16416   }
16417   {
16418     char fstype[] = "ext2";
16419     char device[] = "/dev/sda1";
16420     int r;
16421     suppress_error = 0;
16422     r = guestfs_mkfs (g, fstype, device);
16423     if (r == -1)
16424       return -1;
16425   }
16426   {
16427     char device[] = "/dev/sda1";
16428     char mountpoint[] = "/";
16429     int r;
16430     suppress_error = 0;
16431     r = guestfs_mount (g, device, mountpoint);
16432     if (r == -1)
16433       return -1;
16434   }
16435   /* TestOutputList for read_lines (0) */
16436   {
16437     char path[] = "/new";
16438     char content[] = "line1\r\nline2\nline3";
16439     int r;
16440     suppress_error = 0;
16441     r = guestfs_write_file (g, path, content, 0);
16442     if (r == -1)
16443       return -1;
16444   }
16445   {
16446     char path[] = "/new";
16447     char **r;
16448     int i;
16449     suppress_error = 0;
16450     r = guestfs_read_lines (g, path);
16451     if (r == NULL)
16452       return -1;
16453     if (!r[0]) {
16454       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16455       print_strings (r);
16456       return -1;
16457     }
16458     {
16459       char expected[] = "line1";
16460       if (strcmp (r[0], expected) != 0) {
16461         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16462         return -1;
16463       }
16464     }
16465     if (!r[1]) {
16466       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16467       print_strings (r);
16468       return -1;
16469     }
16470     {
16471       char expected[] = "line2";
16472       if (strcmp (r[1], expected) != 0) {
16473         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16474         return -1;
16475       }
16476     }
16477     if (!r[2]) {
16478       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16479       print_strings (r);
16480       return -1;
16481     }
16482     {
16483       char expected[] = "line3";
16484       if (strcmp (r[2], expected) != 0) {
16485         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16486         return -1;
16487       }
16488     }
16489     if (r[3] != NULL) {
16490       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16491       print_strings (r);
16492       return -1;
16493     }
16494     for (i = 0; r[i] != NULL; ++i)
16495       free (r[i]);
16496     free (r);
16497   }
16498   return 0;
16499 }
16500
16501 static int test_read_lines_1_skip (void)
16502 {
16503   const char *str;
16504
16505   str = getenv ("TEST_ONLY");
16506   if (str)
16507     return strstr (str, "read_lines") == NULL;
16508   str = getenv ("SKIP_TEST_READ_LINES_1");
16509   if (str && strcmp (str, "1") == 0) return 1;
16510   str = getenv ("SKIP_TEST_READ_LINES");
16511   if (str && strcmp (str, "1") == 0) return 1;
16512   return 0;
16513 }
16514
16515 static int test_read_lines_1 (void)
16516 {
16517   if (test_read_lines_1_skip ()) {
16518     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16519     return 0;
16520   }
16521
16522   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16523   {
16524     char device[] = "/dev/sda";
16525     int r;
16526     suppress_error = 0;
16527     r = guestfs_blockdev_setrw (g, device);
16528     if (r == -1)
16529       return -1;
16530   }
16531   {
16532     int r;
16533     suppress_error = 0;
16534     r = guestfs_umount_all (g);
16535     if (r == -1)
16536       return -1;
16537   }
16538   {
16539     int r;
16540     suppress_error = 0;
16541     r = guestfs_lvm_remove_all (g);
16542     if (r == -1)
16543       return -1;
16544   }
16545   {
16546     char device[] = "/dev/sda";
16547     char lines_0[] = ",";
16548     char *lines[] = {
16549       lines_0,
16550       NULL
16551     };
16552     int r;
16553     suppress_error = 0;
16554     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16555     if (r == -1)
16556       return -1;
16557   }
16558   {
16559     char fstype[] = "ext2";
16560     char device[] = "/dev/sda1";
16561     int r;
16562     suppress_error = 0;
16563     r = guestfs_mkfs (g, fstype, device);
16564     if (r == -1)
16565       return -1;
16566   }
16567   {
16568     char device[] = "/dev/sda1";
16569     char mountpoint[] = "/";
16570     int r;
16571     suppress_error = 0;
16572     r = guestfs_mount (g, device, mountpoint);
16573     if (r == -1)
16574       return -1;
16575   }
16576   /* TestOutputList for read_lines (1) */
16577   {
16578     char path[] = "/new";
16579     char content[] = "";
16580     int r;
16581     suppress_error = 0;
16582     r = guestfs_write_file (g, path, content, 0);
16583     if (r == -1)
16584       return -1;
16585   }
16586   {
16587     char path[] = "/new";
16588     char **r;
16589     int i;
16590     suppress_error = 0;
16591     r = guestfs_read_lines (g, path);
16592     if (r == NULL)
16593       return -1;
16594     if (r[0] != NULL) {
16595       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
16596       print_strings (r);
16597       return -1;
16598     }
16599     for (i = 0; r[i] != NULL; ++i)
16600       free (r[i]);
16601     free (r);
16602   }
16603   return 0;
16604 }
16605
16606 static int test_lvs_0_skip (void)
16607 {
16608   const char *str;
16609
16610   str = getenv ("TEST_ONLY");
16611   if (str)
16612     return strstr (str, "lvs") == NULL;
16613   str = getenv ("SKIP_TEST_LVS_0");
16614   if (str && strcmp (str, "1") == 0) return 1;
16615   str = getenv ("SKIP_TEST_LVS");
16616   if (str && strcmp (str, "1") == 0) return 1;
16617   return 0;
16618 }
16619
16620 static int test_lvs_0 (void)
16621 {
16622   if (test_lvs_0_skip ()) {
16623     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
16624     return 0;
16625   }
16626
16627   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
16628   {
16629     char device[] = "/dev/sda";
16630     int r;
16631     suppress_error = 0;
16632     r = guestfs_blockdev_setrw (g, device);
16633     if (r == -1)
16634       return -1;
16635   }
16636   {
16637     int r;
16638     suppress_error = 0;
16639     r = guestfs_umount_all (g);
16640     if (r == -1)
16641       return -1;
16642   }
16643   {
16644     int r;
16645     suppress_error = 0;
16646     r = guestfs_lvm_remove_all (g);
16647     if (r == -1)
16648       return -1;
16649   }
16650   {
16651     char device[] = "/dev/sda";
16652     char lines_0[] = ",";
16653     char *lines[] = {
16654       lines_0,
16655       NULL
16656     };
16657     int r;
16658     suppress_error = 0;
16659     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16660     if (r == -1)
16661       return -1;
16662   }
16663   {
16664     char device[] = "/dev/sda1";
16665     int r;
16666     suppress_error = 0;
16667     r = guestfs_pvcreate (g, device);
16668     if (r == -1)
16669       return -1;
16670   }
16671   {
16672     char volgroup[] = "VG";
16673     char physvols_0[] = "/dev/sda1";
16674     char *physvols[] = {
16675       physvols_0,
16676       NULL
16677     };
16678     int r;
16679     suppress_error = 0;
16680     r = guestfs_vgcreate (g, volgroup, physvols);
16681     if (r == -1)
16682       return -1;
16683   }
16684   {
16685     char logvol[] = "LV";
16686     char volgroup[] = "VG";
16687     int r;
16688     suppress_error = 0;
16689     r = guestfs_lvcreate (g, logvol, volgroup, 8);
16690     if (r == -1)
16691       return -1;
16692   }
16693   {
16694     char fstype[] = "ext2";
16695     char device[] = "/dev/VG/LV";
16696     int r;
16697     suppress_error = 0;
16698     r = guestfs_mkfs (g, fstype, device);
16699     if (r == -1)
16700       return -1;
16701   }
16702   {
16703     char device[] = "/dev/VG/LV";
16704     char mountpoint[] = "/";
16705     int r;
16706     suppress_error = 0;
16707     r = guestfs_mount (g, device, mountpoint);
16708     if (r == -1)
16709       return -1;
16710   }
16711   /* TestOutputList for lvs (0) */
16712   {
16713     char **r;
16714     int i;
16715     suppress_error = 0;
16716     r = guestfs_lvs (g);
16717     if (r == NULL)
16718       return -1;
16719     if (!r[0]) {
16720       fprintf (stderr, "test_lvs_0: short list returned from command\n");
16721       print_strings (r);
16722       return -1;
16723     }
16724     {
16725       char expected[] = "/dev/VG/LV";
16726       if (strcmp (r[0], expected) != 0) {
16727         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16728         return -1;
16729       }
16730     }
16731     if (r[1] != NULL) {
16732       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
16733       print_strings (r);
16734       return -1;
16735     }
16736     for (i = 0; r[i] != NULL; ++i)
16737       free (r[i]);
16738     free (r);
16739   }
16740   return 0;
16741 }
16742
16743 static int test_lvs_1_skip (void)
16744 {
16745   const char *str;
16746
16747   str = getenv ("TEST_ONLY");
16748   if (str)
16749     return strstr (str, "lvs") == NULL;
16750   str = getenv ("SKIP_TEST_LVS_1");
16751   if (str && strcmp (str, "1") == 0) return 1;
16752   str = getenv ("SKIP_TEST_LVS");
16753   if (str && strcmp (str, "1") == 0) return 1;
16754   return 0;
16755 }
16756
16757 static int test_lvs_1 (void)
16758 {
16759   if (test_lvs_1_skip ()) {
16760     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
16761     return 0;
16762   }
16763
16764   /* InitNone|InitEmpty for test_lvs_1 */
16765   {
16766     char device[] = "/dev/sda";
16767     int r;
16768     suppress_error = 0;
16769     r = guestfs_blockdev_setrw (g, device);
16770     if (r == -1)
16771       return -1;
16772   }
16773   {
16774     int r;
16775     suppress_error = 0;
16776     r = guestfs_umount_all (g);
16777     if (r == -1)
16778       return -1;
16779   }
16780   {
16781     int r;
16782     suppress_error = 0;
16783     r = guestfs_lvm_remove_all (g);
16784     if (r == -1)
16785       return -1;
16786   }
16787   /* TestOutputList for lvs (1) */
16788   {
16789     char device[] = "/dev/sda";
16790     char lines_0[] = ",10";
16791     char lines_1[] = ",20";
16792     char lines_2[] = ",";
16793     char *lines[] = {
16794       lines_0,
16795       lines_1,
16796       lines_2,
16797       NULL
16798     };
16799     int r;
16800     suppress_error = 0;
16801     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16802     if (r == -1)
16803       return -1;
16804   }
16805   {
16806     char device[] = "/dev/sda1";
16807     int r;
16808     suppress_error = 0;
16809     r = guestfs_pvcreate (g, device);
16810     if (r == -1)
16811       return -1;
16812   }
16813   {
16814     char device[] = "/dev/sda2";
16815     int r;
16816     suppress_error = 0;
16817     r = guestfs_pvcreate (g, device);
16818     if (r == -1)
16819       return -1;
16820   }
16821   {
16822     char device[] = "/dev/sda3";
16823     int r;
16824     suppress_error = 0;
16825     r = guestfs_pvcreate (g, device);
16826     if (r == -1)
16827       return -1;
16828   }
16829   {
16830     char volgroup[] = "VG1";
16831     char physvols_0[] = "/dev/sda1";
16832     char physvols_1[] = "/dev/sda2";
16833     char *physvols[] = {
16834       physvols_0,
16835       physvols_1,
16836       NULL
16837     };
16838     int r;
16839     suppress_error = 0;
16840     r = guestfs_vgcreate (g, volgroup, physvols);
16841     if (r == -1)
16842       return -1;
16843   }
16844   {
16845     char volgroup[] = "VG2";
16846     char physvols_0[] = "/dev/sda3";
16847     char *physvols[] = {
16848       physvols_0,
16849       NULL
16850     };
16851     int r;
16852     suppress_error = 0;
16853     r = guestfs_vgcreate (g, volgroup, physvols);
16854     if (r == -1)
16855       return -1;
16856   }
16857   {
16858     char logvol[] = "LV1";
16859     char volgroup[] = "VG1";
16860     int r;
16861     suppress_error = 0;
16862     r = guestfs_lvcreate (g, logvol, volgroup, 50);
16863     if (r == -1)
16864       return -1;
16865   }
16866   {
16867     char logvol[] = "LV2";
16868     char volgroup[] = "VG1";
16869     int r;
16870     suppress_error = 0;
16871     r = guestfs_lvcreate (g, logvol, volgroup, 50);
16872     if (r == -1)
16873       return -1;
16874   }
16875   {
16876     char logvol[] = "LV3";
16877     char volgroup[] = "VG2";
16878     int r;
16879     suppress_error = 0;
16880     r = guestfs_lvcreate (g, logvol, volgroup, 50);
16881     if (r == -1)
16882       return -1;
16883   }
16884   {
16885     char **r;
16886     int i;
16887     suppress_error = 0;
16888     r = guestfs_lvs (g);
16889     if (r == NULL)
16890       return -1;
16891     if (!r[0]) {
16892       fprintf (stderr, "test_lvs_1: short list returned from command\n");
16893       print_strings (r);
16894       return -1;
16895     }
16896     {
16897       char expected[] = "/dev/VG1/LV1";
16898       if (strcmp (r[0], expected) != 0) {
16899         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16900         return -1;
16901       }
16902     }
16903     if (!r[1]) {
16904       fprintf (stderr, "test_lvs_1: short list returned from command\n");
16905       print_strings (r);
16906       return -1;
16907     }
16908     {
16909       char expected[] = "/dev/VG1/LV2";
16910       if (strcmp (r[1], expected) != 0) {
16911         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16912         return -1;
16913       }
16914     }
16915     if (!r[2]) {
16916       fprintf (stderr, "test_lvs_1: short list returned from command\n");
16917       print_strings (r);
16918       return -1;
16919     }
16920     {
16921       char expected[] = "/dev/VG2/LV3";
16922       if (strcmp (r[2], expected) != 0) {
16923         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16924         return -1;
16925       }
16926     }
16927     if (r[3] != NULL) {
16928       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
16929       print_strings (r);
16930       return -1;
16931     }
16932     for (i = 0; r[i] != NULL; ++i)
16933       free (r[i]);
16934     free (r);
16935   }
16936   return 0;
16937 }
16938
16939 static int test_vgs_0_skip (void)
16940 {
16941   const char *str;
16942
16943   str = getenv ("TEST_ONLY");
16944   if (str)
16945     return strstr (str, "vgs") == NULL;
16946   str = getenv ("SKIP_TEST_VGS_0");
16947   if (str && strcmp (str, "1") == 0) return 1;
16948   str = getenv ("SKIP_TEST_VGS");
16949   if (str && strcmp (str, "1") == 0) return 1;
16950   return 0;
16951 }
16952
16953 static int test_vgs_0 (void)
16954 {
16955   if (test_vgs_0_skip ()) {
16956     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
16957     return 0;
16958   }
16959
16960   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
16961   {
16962     char device[] = "/dev/sda";
16963     int r;
16964     suppress_error = 0;
16965     r = guestfs_blockdev_setrw (g, device);
16966     if (r == -1)
16967       return -1;
16968   }
16969   {
16970     int r;
16971     suppress_error = 0;
16972     r = guestfs_umount_all (g);
16973     if (r == -1)
16974       return -1;
16975   }
16976   {
16977     int r;
16978     suppress_error = 0;
16979     r = guestfs_lvm_remove_all (g);
16980     if (r == -1)
16981       return -1;
16982   }
16983   {
16984     char device[] = "/dev/sda";
16985     char lines_0[] = ",";
16986     char *lines[] = {
16987       lines_0,
16988       NULL
16989     };
16990     int r;
16991     suppress_error = 0;
16992     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16993     if (r == -1)
16994       return -1;
16995   }
16996   {
16997     char device[] = "/dev/sda1";
16998     int r;
16999     suppress_error = 0;
17000     r = guestfs_pvcreate (g, device);
17001     if (r == -1)
17002       return -1;
17003   }
17004   {
17005     char volgroup[] = "VG";
17006     char physvols_0[] = "/dev/sda1";
17007     char *physvols[] = {
17008       physvols_0,
17009       NULL
17010     };
17011     int r;
17012     suppress_error = 0;
17013     r = guestfs_vgcreate (g, volgroup, physvols);
17014     if (r == -1)
17015       return -1;
17016   }
17017   {
17018     char logvol[] = "LV";
17019     char volgroup[] = "VG";
17020     int r;
17021     suppress_error = 0;
17022     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17023     if (r == -1)
17024       return -1;
17025   }
17026   {
17027     char fstype[] = "ext2";
17028     char device[] = "/dev/VG/LV";
17029     int r;
17030     suppress_error = 0;
17031     r = guestfs_mkfs (g, fstype, device);
17032     if (r == -1)
17033       return -1;
17034   }
17035   {
17036     char device[] = "/dev/VG/LV";
17037     char mountpoint[] = "/";
17038     int r;
17039     suppress_error = 0;
17040     r = guestfs_mount (g, device, mountpoint);
17041     if (r == -1)
17042       return -1;
17043   }
17044   /* TestOutputList for vgs (0) */
17045   {
17046     char **r;
17047     int i;
17048     suppress_error = 0;
17049     r = guestfs_vgs (g);
17050     if (r == NULL)
17051       return -1;
17052     if (!r[0]) {
17053       fprintf (stderr, "test_vgs_0: short list returned from command\n");
17054       print_strings (r);
17055       return -1;
17056     }
17057     {
17058       char expected[] = "VG";
17059       if (strcmp (r[0], expected) != 0) {
17060         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17061         return -1;
17062       }
17063     }
17064     if (r[1] != NULL) {
17065       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17066       print_strings (r);
17067       return -1;
17068     }
17069     for (i = 0; r[i] != NULL; ++i)
17070       free (r[i]);
17071     free (r);
17072   }
17073   return 0;
17074 }
17075
17076 static int test_vgs_1_skip (void)
17077 {
17078   const char *str;
17079
17080   str = getenv ("TEST_ONLY");
17081   if (str)
17082     return strstr (str, "vgs") == NULL;
17083   str = getenv ("SKIP_TEST_VGS_1");
17084   if (str && strcmp (str, "1") == 0) return 1;
17085   str = getenv ("SKIP_TEST_VGS");
17086   if (str && strcmp (str, "1") == 0) return 1;
17087   return 0;
17088 }
17089
17090 static int test_vgs_1 (void)
17091 {
17092   if (test_vgs_1_skip ()) {
17093     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17094     return 0;
17095   }
17096
17097   /* InitNone|InitEmpty for test_vgs_1 */
17098   {
17099     char device[] = "/dev/sda";
17100     int r;
17101     suppress_error = 0;
17102     r = guestfs_blockdev_setrw (g, device);
17103     if (r == -1)
17104       return -1;
17105   }
17106   {
17107     int r;
17108     suppress_error = 0;
17109     r = guestfs_umount_all (g);
17110     if (r == -1)
17111       return -1;
17112   }
17113   {
17114     int r;
17115     suppress_error = 0;
17116     r = guestfs_lvm_remove_all (g);
17117     if (r == -1)
17118       return -1;
17119   }
17120   /* TestOutputList for vgs (1) */
17121   {
17122     char device[] = "/dev/sda";
17123     char lines_0[] = ",10";
17124     char lines_1[] = ",20";
17125     char lines_2[] = ",";
17126     char *lines[] = {
17127       lines_0,
17128       lines_1,
17129       lines_2,
17130       NULL
17131     };
17132     int r;
17133     suppress_error = 0;
17134     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17135     if (r == -1)
17136       return -1;
17137   }
17138   {
17139     char device[] = "/dev/sda1";
17140     int r;
17141     suppress_error = 0;
17142     r = guestfs_pvcreate (g, device);
17143     if (r == -1)
17144       return -1;
17145   }
17146   {
17147     char device[] = "/dev/sda2";
17148     int r;
17149     suppress_error = 0;
17150     r = guestfs_pvcreate (g, device);
17151     if (r == -1)
17152       return -1;
17153   }
17154   {
17155     char device[] = "/dev/sda3";
17156     int r;
17157     suppress_error = 0;
17158     r = guestfs_pvcreate (g, device);
17159     if (r == -1)
17160       return -1;
17161   }
17162   {
17163     char volgroup[] = "VG1";
17164     char physvols_0[] = "/dev/sda1";
17165     char physvols_1[] = "/dev/sda2";
17166     char *physvols[] = {
17167       physvols_0,
17168       physvols_1,
17169       NULL
17170     };
17171     int r;
17172     suppress_error = 0;
17173     r = guestfs_vgcreate (g, volgroup, physvols);
17174     if (r == -1)
17175       return -1;
17176   }
17177   {
17178     char volgroup[] = "VG2";
17179     char physvols_0[] = "/dev/sda3";
17180     char *physvols[] = {
17181       physvols_0,
17182       NULL
17183     };
17184     int r;
17185     suppress_error = 0;
17186     r = guestfs_vgcreate (g, volgroup, physvols);
17187     if (r == -1)
17188       return -1;
17189   }
17190   {
17191     char **r;
17192     int i;
17193     suppress_error = 0;
17194     r = guestfs_vgs (g);
17195     if (r == NULL)
17196       return -1;
17197     if (!r[0]) {
17198       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17199       print_strings (r);
17200       return -1;
17201     }
17202     {
17203       char expected[] = "VG1";
17204       if (strcmp (r[0], expected) != 0) {
17205         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17206         return -1;
17207       }
17208     }
17209     if (!r[1]) {
17210       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17211       print_strings (r);
17212       return -1;
17213     }
17214     {
17215       char expected[] = "VG2";
17216       if (strcmp (r[1], expected) != 0) {
17217         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17218         return -1;
17219       }
17220     }
17221     if (r[2] != NULL) {
17222       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17223       print_strings (r);
17224       return -1;
17225     }
17226     for (i = 0; r[i] != NULL; ++i)
17227       free (r[i]);
17228     free (r);
17229   }
17230   return 0;
17231 }
17232
17233 static int test_pvs_0_skip (void)
17234 {
17235   const char *str;
17236
17237   str = getenv ("TEST_ONLY");
17238   if (str)
17239     return strstr (str, "pvs") == NULL;
17240   str = getenv ("SKIP_TEST_PVS_0");
17241   if (str && strcmp (str, "1") == 0) return 1;
17242   str = getenv ("SKIP_TEST_PVS");
17243   if (str && strcmp (str, "1") == 0) return 1;
17244   return 0;
17245 }
17246
17247 static int test_pvs_0 (void)
17248 {
17249   if (test_pvs_0_skip ()) {
17250     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17251     return 0;
17252   }
17253
17254   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17255   {
17256     char device[] = "/dev/sda";
17257     int r;
17258     suppress_error = 0;
17259     r = guestfs_blockdev_setrw (g, device);
17260     if (r == -1)
17261       return -1;
17262   }
17263   {
17264     int r;
17265     suppress_error = 0;
17266     r = guestfs_umount_all (g);
17267     if (r == -1)
17268       return -1;
17269   }
17270   {
17271     int r;
17272     suppress_error = 0;
17273     r = guestfs_lvm_remove_all (g);
17274     if (r == -1)
17275       return -1;
17276   }
17277   {
17278     char device[] = "/dev/sda";
17279     char lines_0[] = ",";
17280     char *lines[] = {
17281       lines_0,
17282       NULL
17283     };
17284     int r;
17285     suppress_error = 0;
17286     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17287     if (r == -1)
17288       return -1;
17289   }
17290   {
17291     char device[] = "/dev/sda1";
17292     int r;
17293     suppress_error = 0;
17294     r = guestfs_pvcreate (g, device);
17295     if (r == -1)
17296       return -1;
17297   }
17298   {
17299     char volgroup[] = "VG";
17300     char physvols_0[] = "/dev/sda1";
17301     char *physvols[] = {
17302       physvols_0,
17303       NULL
17304     };
17305     int r;
17306     suppress_error = 0;
17307     r = guestfs_vgcreate (g, volgroup, physvols);
17308     if (r == -1)
17309       return -1;
17310   }
17311   {
17312     char logvol[] = "LV";
17313     char volgroup[] = "VG";
17314     int r;
17315     suppress_error = 0;
17316     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17317     if (r == -1)
17318       return -1;
17319   }
17320   {
17321     char fstype[] = "ext2";
17322     char device[] = "/dev/VG/LV";
17323     int r;
17324     suppress_error = 0;
17325     r = guestfs_mkfs (g, fstype, device);
17326     if (r == -1)
17327       return -1;
17328   }
17329   {
17330     char device[] = "/dev/VG/LV";
17331     char mountpoint[] = "/";
17332     int r;
17333     suppress_error = 0;
17334     r = guestfs_mount (g, device, mountpoint);
17335     if (r == -1)
17336       return -1;
17337   }
17338   /* TestOutputListOfDevices for pvs (0) */
17339   {
17340     char **r;
17341     int i;
17342     suppress_error = 0;
17343     r = guestfs_pvs (g);
17344     if (r == NULL)
17345       return -1;
17346     if (!r[0]) {
17347       fprintf (stderr, "test_pvs_0: short list returned from command\n");
17348       print_strings (r);
17349       return -1;
17350     }
17351     {
17352       char expected[] = "/dev/sda1";
17353       r[0][5] = 's';
17354       if (strcmp (r[0], expected) != 0) {
17355         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17356         return -1;
17357       }
17358     }
17359     if (r[1] != NULL) {
17360       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17361       print_strings (r);
17362       return -1;
17363     }
17364     for (i = 0; r[i] != NULL; ++i)
17365       free (r[i]);
17366     free (r);
17367   }
17368   return 0;
17369 }
17370
17371 static int test_pvs_1_skip (void)
17372 {
17373   const char *str;
17374
17375   str = getenv ("TEST_ONLY");
17376   if (str)
17377     return strstr (str, "pvs") == NULL;
17378   str = getenv ("SKIP_TEST_PVS_1");
17379   if (str && strcmp (str, "1") == 0) return 1;
17380   str = getenv ("SKIP_TEST_PVS");
17381   if (str && strcmp (str, "1") == 0) return 1;
17382   return 0;
17383 }
17384
17385 static int test_pvs_1 (void)
17386 {
17387   if (test_pvs_1_skip ()) {
17388     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17389     return 0;
17390   }
17391
17392   /* InitNone|InitEmpty for test_pvs_1 */
17393   {
17394     char device[] = "/dev/sda";
17395     int r;
17396     suppress_error = 0;
17397     r = guestfs_blockdev_setrw (g, device);
17398     if (r == -1)
17399       return -1;
17400   }
17401   {
17402     int r;
17403     suppress_error = 0;
17404     r = guestfs_umount_all (g);
17405     if (r == -1)
17406       return -1;
17407   }
17408   {
17409     int r;
17410     suppress_error = 0;
17411     r = guestfs_lvm_remove_all (g);
17412     if (r == -1)
17413       return -1;
17414   }
17415   /* TestOutputListOfDevices for pvs (1) */
17416   {
17417     char device[] = "/dev/sda";
17418     char lines_0[] = ",10";
17419     char lines_1[] = ",20";
17420     char lines_2[] = ",";
17421     char *lines[] = {
17422       lines_0,
17423       lines_1,
17424       lines_2,
17425       NULL
17426     };
17427     int r;
17428     suppress_error = 0;
17429     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17430     if (r == -1)
17431       return -1;
17432   }
17433   {
17434     char device[] = "/dev/sda1";
17435     int r;
17436     suppress_error = 0;
17437     r = guestfs_pvcreate (g, device);
17438     if (r == -1)
17439       return -1;
17440   }
17441   {
17442     char device[] = "/dev/sda2";
17443     int r;
17444     suppress_error = 0;
17445     r = guestfs_pvcreate (g, device);
17446     if (r == -1)
17447       return -1;
17448   }
17449   {
17450     char device[] = "/dev/sda3";
17451     int r;
17452     suppress_error = 0;
17453     r = guestfs_pvcreate (g, device);
17454     if (r == -1)
17455       return -1;
17456   }
17457   {
17458     char **r;
17459     int i;
17460     suppress_error = 0;
17461     r = guestfs_pvs (g);
17462     if (r == NULL)
17463       return -1;
17464     if (!r[0]) {
17465       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17466       print_strings (r);
17467       return -1;
17468     }
17469     {
17470       char expected[] = "/dev/sda1";
17471       r[0][5] = 's';
17472       if (strcmp (r[0], expected) != 0) {
17473         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17474         return -1;
17475       }
17476     }
17477     if (!r[1]) {
17478       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17479       print_strings (r);
17480       return -1;
17481     }
17482     {
17483       char expected[] = "/dev/sda2";
17484       r[1][5] = 's';
17485       if (strcmp (r[1], expected) != 0) {
17486         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17487         return -1;
17488       }
17489     }
17490     if (!r[2]) {
17491       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17492       print_strings (r);
17493       return -1;
17494     }
17495     {
17496       char expected[] = "/dev/sda3";
17497       r[2][5] = 's';
17498       if (strcmp (r[2], expected) != 0) {
17499         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17500         return -1;
17501       }
17502     }
17503     if (r[3] != NULL) {
17504       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17505       print_strings (r);
17506       return -1;
17507     }
17508     for (i = 0; r[i] != NULL; ++i)
17509       free (r[i]);
17510     free (r);
17511   }
17512   return 0;
17513 }
17514
17515 static int test_list_partitions_0_skip (void)
17516 {
17517   const char *str;
17518
17519   str = getenv ("TEST_ONLY");
17520   if (str)
17521     return strstr (str, "list_partitions") == NULL;
17522   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17523   if (str && strcmp (str, "1") == 0) return 1;
17524   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17525   if (str && strcmp (str, "1") == 0) return 1;
17526   return 0;
17527 }
17528
17529 static int test_list_partitions_0 (void)
17530 {
17531   if (test_list_partitions_0_skip ()) {
17532     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
17533     return 0;
17534   }
17535
17536   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
17537   {
17538     char device[] = "/dev/sda";
17539     int r;
17540     suppress_error = 0;
17541     r = guestfs_blockdev_setrw (g, device);
17542     if (r == -1)
17543       return -1;
17544   }
17545   {
17546     int r;
17547     suppress_error = 0;
17548     r = guestfs_umount_all (g);
17549     if (r == -1)
17550       return -1;
17551   }
17552   {
17553     int r;
17554     suppress_error = 0;
17555     r = guestfs_lvm_remove_all (g);
17556     if (r == -1)
17557       return -1;
17558   }
17559   {
17560     char device[] = "/dev/sda";
17561     char lines_0[] = ",";
17562     char *lines[] = {
17563       lines_0,
17564       NULL
17565     };
17566     int r;
17567     suppress_error = 0;
17568     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17569     if (r == -1)
17570       return -1;
17571   }
17572   {
17573     char fstype[] = "ext2";
17574     char device[] = "/dev/sda1";
17575     int r;
17576     suppress_error = 0;
17577     r = guestfs_mkfs (g, fstype, device);
17578     if (r == -1)
17579       return -1;
17580   }
17581   {
17582     char device[] = "/dev/sda1";
17583     char mountpoint[] = "/";
17584     int r;
17585     suppress_error = 0;
17586     r = guestfs_mount (g, device, mountpoint);
17587     if (r == -1)
17588       return -1;
17589   }
17590   /* TestOutputListOfDevices for list_partitions (0) */
17591   {
17592     char **r;
17593     int i;
17594     suppress_error = 0;
17595     r = guestfs_list_partitions (g);
17596     if (r == NULL)
17597       return -1;
17598     if (!r[0]) {
17599       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
17600       print_strings (r);
17601       return -1;
17602     }
17603     {
17604       char expected[] = "/dev/sda1";
17605       r[0][5] = 's';
17606       if (strcmp (r[0], expected) != 0) {
17607         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17608         return -1;
17609       }
17610     }
17611     if (r[1] != NULL) {
17612       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
17613       print_strings (r);
17614       return -1;
17615     }
17616     for (i = 0; r[i] != NULL; ++i)
17617       free (r[i]);
17618     free (r);
17619   }
17620   return 0;
17621 }
17622
17623 static int test_list_partitions_1_skip (void)
17624 {
17625   const char *str;
17626
17627   str = getenv ("TEST_ONLY");
17628   if (str)
17629     return strstr (str, "list_partitions") == NULL;
17630   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
17631   if (str && strcmp (str, "1") == 0) return 1;
17632   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17633   if (str && strcmp (str, "1") == 0) return 1;
17634   return 0;
17635 }
17636
17637 static int test_list_partitions_1 (void)
17638 {
17639   if (test_list_partitions_1_skip ()) {
17640     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
17641     return 0;
17642   }
17643
17644   /* InitNone|InitEmpty for test_list_partitions_1 */
17645   {
17646     char device[] = "/dev/sda";
17647     int r;
17648     suppress_error = 0;
17649     r = guestfs_blockdev_setrw (g, device);
17650     if (r == -1)
17651       return -1;
17652   }
17653   {
17654     int r;
17655     suppress_error = 0;
17656     r = guestfs_umount_all (g);
17657     if (r == -1)
17658       return -1;
17659   }
17660   {
17661     int r;
17662     suppress_error = 0;
17663     r = guestfs_lvm_remove_all (g);
17664     if (r == -1)
17665       return -1;
17666   }
17667   /* TestOutputListOfDevices for list_partitions (1) */
17668   {
17669     char device[] = "/dev/sda";
17670     char lines_0[] = ",10";
17671     char lines_1[] = ",20";
17672     char lines_2[] = ",";
17673     char *lines[] = {
17674       lines_0,
17675       lines_1,
17676       lines_2,
17677       NULL
17678     };
17679     int r;
17680     suppress_error = 0;
17681     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17682     if (r == -1)
17683       return -1;
17684   }
17685   {
17686     char **r;
17687     int i;
17688     suppress_error = 0;
17689     r = guestfs_list_partitions (g);
17690     if (r == NULL)
17691       return -1;
17692     if (!r[0]) {
17693       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17694       print_strings (r);
17695       return -1;
17696     }
17697     {
17698       char expected[] = "/dev/sda1";
17699       r[0][5] = 's';
17700       if (strcmp (r[0], expected) != 0) {
17701         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17702         return -1;
17703       }
17704     }
17705     if (!r[1]) {
17706       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17707       print_strings (r);
17708       return -1;
17709     }
17710     {
17711       char expected[] = "/dev/sda2";
17712       r[1][5] = 's';
17713       if (strcmp (r[1], expected) != 0) {
17714         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17715         return -1;
17716       }
17717     }
17718     if (!r[2]) {
17719       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17720       print_strings (r);
17721       return -1;
17722     }
17723     {
17724       char expected[] = "/dev/sda3";
17725       r[2][5] = 's';
17726       if (strcmp (r[2], expected) != 0) {
17727         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17728         return -1;
17729       }
17730     }
17731     if (r[3] != NULL) {
17732       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
17733       print_strings (r);
17734       return -1;
17735     }
17736     for (i = 0; r[i] != NULL; ++i)
17737       free (r[i]);
17738     free (r);
17739   }
17740   return 0;
17741 }
17742
17743 static int test_list_devices_0_skip (void)
17744 {
17745   const char *str;
17746
17747   str = getenv ("TEST_ONLY");
17748   if (str)
17749     return strstr (str, "list_devices") == NULL;
17750   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
17751   if (str && strcmp (str, "1") == 0) return 1;
17752   str = getenv ("SKIP_TEST_LIST_DEVICES");
17753   if (str && strcmp (str, "1") == 0) return 1;
17754   return 0;
17755 }
17756
17757 static int test_list_devices_0 (void)
17758 {
17759   if (test_list_devices_0_skip ()) {
17760     printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
17761     return 0;
17762   }
17763
17764   /* InitNone|InitEmpty for test_list_devices_0 */
17765   {
17766     char device[] = "/dev/sda";
17767     int r;
17768     suppress_error = 0;
17769     r = guestfs_blockdev_setrw (g, device);
17770     if (r == -1)
17771       return -1;
17772   }
17773   {
17774     int r;
17775     suppress_error = 0;
17776     r = guestfs_umount_all (g);
17777     if (r == -1)
17778       return -1;
17779   }
17780   {
17781     int r;
17782     suppress_error = 0;
17783     r = guestfs_lvm_remove_all (g);
17784     if (r == -1)
17785       return -1;
17786   }
17787   /* TestOutputListOfDevices for list_devices (0) */
17788   {
17789     char **r;
17790     int i;
17791     suppress_error = 0;
17792     r = guestfs_list_devices (g);
17793     if (r == NULL)
17794       return -1;
17795     if (!r[0]) {
17796       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17797       print_strings (r);
17798       return -1;
17799     }
17800     {
17801       char expected[] = "/dev/sda";
17802       r[0][5] = 's';
17803       if (strcmp (r[0], expected) != 0) {
17804         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17805         return -1;
17806       }
17807     }
17808     if (!r[1]) {
17809       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17810       print_strings (r);
17811       return -1;
17812     }
17813     {
17814       char expected[] = "/dev/sdb";
17815       r[1][5] = 's';
17816       if (strcmp (r[1], expected) != 0) {
17817         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17818         return -1;
17819       }
17820     }
17821     if (!r[2]) {
17822       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17823       print_strings (r);
17824       return -1;
17825     }
17826     {
17827       char expected[] = "/dev/sdc";
17828       r[2][5] = 's';
17829       if (strcmp (r[2], expected) != 0) {
17830         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17831         return -1;
17832       }
17833     }
17834     if (!r[3]) {
17835       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17836       print_strings (r);
17837       return -1;
17838     }
17839     {
17840       char expected[] = "/dev/sdd";
17841       r[3][5] = 's';
17842       if (strcmp (r[3], expected) != 0) {
17843         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
17844         return -1;
17845       }
17846     }
17847     if (r[4] != NULL) {
17848       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
17849       print_strings (r);
17850       return -1;
17851     }
17852     for (i = 0; r[i] != NULL; ++i)
17853       free (r[i]);
17854     free (r);
17855   }
17856   return 0;
17857 }
17858
17859 static int test_ls_0_skip (void)
17860 {
17861   const char *str;
17862
17863   str = getenv ("TEST_ONLY");
17864   if (str)
17865     return strstr (str, "ls") == NULL;
17866   str = getenv ("SKIP_TEST_LS_0");
17867   if (str && strcmp (str, "1") == 0) return 1;
17868   str = getenv ("SKIP_TEST_LS");
17869   if (str && strcmp (str, "1") == 0) return 1;
17870   return 0;
17871 }
17872
17873 static int test_ls_0 (void)
17874 {
17875   if (test_ls_0_skip ()) {
17876     printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
17877     return 0;
17878   }
17879
17880   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
17881   {
17882     char device[] = "/dev/sda";
17883     int r;
17884     suppress_error = 0;
17885     r = guestfs_blockdev_setrw (g, device);
17886     if (r == -1)
17887       return -1;
17888   }
17889   {
17890     int r;
17891     suppress_error = 0;
17892     r = guestfs_umount_all (g);
17893     if (r == -1)
17894       return -1;
17895   }
17896   {
17897     int r;
17898     suppress_error = 0;
17899     r = guestfs_lvm_remove_all (g);
17900     if (r == -1)
17901       return -1;
17902   }
17903   {
17904     char device[] = "/dev/sda";
17905     char lines_0[] = ",";
17906     char *lines[] = {
17907       lines_0,
17908       NULL
17909     };
17910     int r;
17911     suppress_error = 0;
17912     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17913     if (r == -1)
17914       return -1;
17915   }
17916   {
17917     char fstype[] = "ext2";
17918     char device[] = "/dev/sda1";
17919     int r;
17920     suppress_error = 0;
17921     r = guestfs_mkfs (g, fstype, device);
17922     if (r == -1)
17923       return -1;
17924   }
17925   {
17926     char device[] = "/dev/sda1";
17927     char mountpoint[] = "/";
17928     int r;
17929     suppress_error = 0;
17930     r = guestfs_mount (g, device, mountpoint);
17931     if (r == -1)
17932       return -1;
17933   }
17934   /* TestOutputList for ls (0) */
17935   {
17936     char path[] = "/new";
17937     int r;
17938     suppress_error = 0;
17939     r = guestfs_touch (g, path);
17940     if (r == -1)
17941       return -1;
17942   }
17943   {
17944     char path[] = "/newer";
17945     int r;
17946     suppress_error = 0;
17947     r = guestfs_touch (g, path);
17948     if (r == -1)
17949       return -1;
17950   }
17951   {
17952     char path[] = "/newest";
17953     int r;
17954     suppress_error = 0;
17955     r = guestfs_touch (g, path);
17956     if (r == -1)
17957       return -1;
17958   }
17959   {
17960     char directory[] = "/";
17961     char **r;
17962     int i;
17963     suppress_error = 0;
17964     r = guestfs_ls (g, directory);
17965     if (r == NULL)
17966       return -1;
17967     if (!r[0]) {
17968       fprintf (stderr, "test_ls_0: short list returned from command\n");
17969       print_strings (r);
17970       return -1;
17971     }
17972     {
17973       char expected[] = "lost+found";
17974       if (strcmp (r[0], expected) != 0) {
17975         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17976         return -1;
17977       }
17978     }
17979     if (!r[1]) {
17980       fprintf (stderr, "test_ls_0: short list returned from command\n");
17981       print_strings (r);
17982       return -1;
17983     }
17984     {
17985       char expected[] = "new";
17986       if (strcmp (r[1], expected) != 0) {
17987         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17988         return -1;
17989       }
17990     }
17991     if (!r[2]) {
17992       fprintf (stderr, "test_ls_0: short list returned from command\n");
17993       print_strings (r);
17994       return -1;
17995     }
17996     {
17997       char expected[] = "newer";
17998       if (strcmp (r[2], expected) != 0) {
17999         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18000         return -1;
18001       }
18002     }
18003     if (!r[3]) {
18004       fprintf (stderr, "test_ls_0: short list returned from command\n");
18005       print_strings (r);
18006       return -1;
18007     }
18008     {
18009       char expected[] = "newest";
18010       if (strcmp (r[3], expected) != 0) {
18011         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18012         return -1;
18013       }
18014     }
18015     if (r[4] != NULL) {
18016       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18017       print_strings (r);
18018       return -1;
18019     }
18020     for (i = 0; r[i] != NULL; ++i)
18021       free (r[i]);
18022     free (r);
18023   }
18024   return 0;
18025 }
18026
18027 static int test_cat_0_skip (void)
18028 {
18029   const char *str;
18030
18031   str = getenv ("TEST_ONLY");
18032   if (str)
18033     return strstr (str, "cat") == NULL;
18034   str = getenv ("SKIP_TEST_CAT_0");
18035   if (str && strcmp (str, "1") == 0) return 1;
18036   str = getenv ("SKIP_TEST_CAT");
18037   if (str && strcmp (str, "1") == 0) return 1;
18038   return 0;
18039 }
18040
18041 static int test_cat_0 (void)
18042 {
18043   if (test_cat_0_skip ()) {
18044     printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18045     return 0;
18046   }
18047
18048   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18049   {
18050     char device[] = "/dev/sda";
18051     int r;
18052     suppress_error = 0;
18053     r = guestfs_blockdev_setrw (g, device);
18054     if (r == -1)
18055       return -1;
18056   }
18057   {
18058     int r;
18059     suppress_error = 0;
18060     r = guestfs_umount_all (g);
18061     if (r == -1)
18062       return -1;
18063   }
18064   {
18065     int r;
18066     suppress_error = 0;
18067     r = guestfs_lvm_remove_all (g);
18068     if (r == -1)
18069       return -1;
18070   }
18071   {
18072     char device[] = "/dev/sda";
18073     char lines_0[] = ",";
18074     char *lines[] = {
18075       lines_0,
18076       NULL
18077     };
18078     int r;
18079     suppress_error = 0;
18080     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18081     if (r == -1)
18082       return -1;
18083   }
18084   {
18085     char fstype[] = "ext2";
18086     char device[] = "/dev/sda1";
18087     int r;
18088     suppress_error = 0;
18089     r = guestfs_mkfs (g, fstype, device);
18090     if (r == -1)
18091       return -1;
18092   }
18093   {
18094     char device[] = "/dev/sda1";
18095     char mountpoint[] = "/";
18096     int r;
18097     suppress_error = 0;
18098     r = guestfs_mount (g, device, mountpoint);
18099     if (r == -1)
18100       return -1;
18101   }
18102   /* TestOutput for cat (0) */
18103   char expected[] = "new file contents";
18104   {
18105     char path[] = "/new";
18106     char content[] = "new file contents";
18107     int r;
18108     suppress_error = 0;
18109     r = guestfs_write_file (g, path, content, 0);
18110     if (r == -1)
18111       return -1;
18112   }
18113   {
18114     char path[] = "/new";
18115     char *r;
18116     suppress_error = 0;
18117     r = guestfs_cat (g, path);
18118     if (r == NULL)
18119       return -1;
18120     if (strcmp (r, expected) != 0) {
18121       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18122       return -1;
18123     }
18124     free (r);
18125   }
18126   return 0;
18127 }
18128
18129 static int test_touch_0_skip (void)
18130 {
18131   const char *str;
18132
18133   str = getenv ("TEST_ONLY");
18134   if (str)
18135     return strstr (str, "touch") == NULL;
18136   str = getenv ("SKIP_TEST_TOUCH_0");
18137   if (str && strcmp (str, "1") == 0) return 1;
18138   str = getenv ("SKIP_TEST_TOUCH");
18139   if (str && strcmp (str, "1") == 0) return 1;
18140   return 0;
18141 }
18142
18143 static int test_touch_0 (void)
18144 {
18145   if (test_touch_0_skip ()) {
18146     printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18147     return 0;
18148   }
18149
18150   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18151   {
18152     char device[] = "/dev/sda";
18153     int r;
18154     suppress_error = 0;
18155     r = guestfs_blockdev_setrw (g, device);
18156     if (r == -1)
18157       return -1;
18158   }
18159   {
18160     int r;
18161     suppress_error = 0;
18162     r = guestfs_umount_all (g);
18163     if (r == -1)
18164       return -1;
18165   }
18166   {
18167     int r;
18168     suppress_error = 0;
18169     r = guestfs_lvm_remove_all (g);
18170     if (r == -1)
18171       return -1;
18172   }
18173   {
18174     char device[] = "/dev/sda";
18175     char lines_0[] = ",";
18176     char *lines[] = {
18177       lines_0,
18178       NULL
18179     };
18180     int r;
18181     suppress_error = 0;
18182     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18183     if (r == -1)
18184       return -1;
18185   }
18186   {
18187     char fstype[] = "ext2";
18188     char device[] = "/dev/sda1";
18189     int r;
18190     suppress_error = 0;
18191     r = guestfs_mkfs (g, fstype, device);
18192     if (r == -1)
18193       return -1;
18194   }
18195   {
18196     char device[] = "/dev/sda1";
18197     char mountpoint[] = "/";
18198     int r;
18199     suppress_error = 0;
18200     r = guestfs_mount (g, device, mountpoint);
18201     if (r == -1)
18202       return -1;
18203   }
18204   /* TestOutputTrue for touch (0) */
18205   {
18206     char path[] = "/new";
18207     int r;
18208     suppress_error = 0;
18209     r = guestfs_touch (g, path);
18210     if (r == -1)
18211       return -1;
18212   }
18213   {
18214     char path[] = "/new";
18215     int r;
18216     suppress_error = 0;
18217     r = guestfs_exists (g, path);
18218     if (r == -1)
18219       return -1;
18220     if (!r) {
18221       fprintf (stderr, "test_touch_0: expected true, got false\n");
18222       return -1;
18223     }
18224   }
18225   return 0;
18226 }
18227
18228 static int test_sync_0_skip (void)
18229 {
18230   const char *str;
18231
18232   str = getenv ("TEST_ONLY");
18233   if (str)
18234     return strstr (str, "sync") == NULL;
18235   str = getenv ("SKIP_TEST_SYNC_0");
18236   if (str && strcmp (str, "1") == 0) return 1;
18237   str = getenv ("SKIP_TEST_SYNC");
18238   if (str && strcmp (str, "1") == 0) return 1;
18239   return 0;
18240 }
18241
18242 static int test_sync_0 (void)
18243 {
18244   if (test_sync_0_skip ()) {
18245     printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18246     return 0;
18247   }
18248
18249   /* InitNone|InitEmpty for test_sync_0 */
18250   {
18251     char device[] = "/dev/sda";
18252     int r;
18253     suppress_error = 0;
18254     r = guestfs_blockdev_setrw (g, device);
18255     if (r == -1)
18256       return -1;
18257   }
18258   {
18259     int r;
18260     suppress_error = 0;
18261     r = guestfs_umount_all (g);
18262     if (r == -1)
18263       return -1;
18264   }
18265   {
18266     int r;
18267     suppress_error = 0;
18268     r = guestfs_lvm_remove_all (g);
18269     if (r == -1)
18270       return -1;
18271   }
18272   /* TestRun for sync (0) */
18273   {
18274     int r;
18275     suppress_error = 0;
18276     r = guestfs_sync (g);
18277     if (r == -1)
18278       return -1;
18279   }
18280   return 0;
18281 }
18282
18283 static int test_mount_0_skip (void)
18284 {
18285   const char *str;
18286
18287   str = getenv ("TEST_ONLY");
18288   if (str)
18289     return strstr (str, "mount") == NULL;
18290   str = getenv ("SKIP_TEST_MOUNT_0");
18291   if (str && strcmp (str, "1") == 0) return 1;
18292   str = getenv ("SKIP_TEST_MOUNT");
18293   if (str && strcmp (str, "1") == 0) return 1;
18294   return 0;
18295 }
18296
18297 static int test_mount_0 (void)
18298 {
18299   if (test_mount_0_skip ()) {
18300     printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18301     return 0;
18302   }
18303
18304   /* InitNone|InitEmpty for test_mount_0 */
18305   {
18306     char device[] = "/dev/sda";
18307     int r;
18308     suppress_error = 0;
18309     r = guestfs_blockdev_setrw (g, device);
18310     if (r == -1)
18311       return -1;
18312   }
18313   {
18314     int r;
18315     suppress_error = 0;
18316     r = guestfs_umount_all (g);
18317     if (r == -1)
18318       return -1;
18319   }
18320   {
18321     int r;
18322     suppress_error = 0;
18323     r = guestfs_lvm_remove_all (g);
18324     if (r == -1)
18325       return -1;
18326   }
18327   /* TestOutput for mount (0) */
18328   char expected[] = "new file contents";
18329   {
18330     char device[] = "/dev/sda";
18331     char lines_0[] = ",";
18332     char *lines[] = {
18333       lines_0,
18334       NULL
18335     };
18336     int r;
18337     suppress_error = 0;
18338     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18339     if (r == -1)
18340       return -1;
18341   }
18342   {
18343     char fstype[] = "ext2";
18344     char device[] = "/dev/sda1";
18345     int r;
18346     suppress_error = 0;
18347     r = guestfs_mkfs (g, fstype, device);
18348     if (r == -1)
18349       return -1;
18350   }
18351   {
18352     char device[] = "/dev/sda1";
18353     char mountpoint[] = "/";
18354     int r;
18355     suppress_error = 0;
18356     r = guestfs_mount (g, device, mountpoint);
18357     if (r == -1)
18358       return -1;
18359   }
18360   {
18361     char path[] = "/new";
18362     char content[] = "new file contents";
18363     int r;
18364     suppress_error = 0;
18365     r = guestfs_write_file (g, path, content, 0);
18366     if (r == -1)
18367       return -1;
18368   }
18369   {
18370     char path[] = "/new";
18371     char *r;
18372     suppress_error = 0;
18373     r = guestfs_cat (g, path);
18374     if (r == NULL)
18375       return -1;
18376     if (strcmp (r, expected) != 0) {
18377       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18378       return -1;
18379     }
18380     free (r);
18381   }
18382   return 0;
18383 }
18384
18385 int main (int argc, char *argv[])
18386 {
18387   char c = 0;
18388   int failed = 0;
18389   const char *filename;
18390   int fd;
18391   int nr_tests, test_num = 0;
18392
18393   no_test_warnings ();
18394
18395   g = guestfs_create ();
18396   if (g == NULL) {
18397     printf ("guestfs_create FAILED\n");
18398     exit (1);
18399   }
18400
18401   guestfs_set_error_handler (g, print_error, NULL);
18402
18403   guestfs_set_path (g, "../appliance");
18404
18405   filename = "test1.img";
18406   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18407   if (fd == -1) {
18408     perror (filename);
18409     exit (1);
18410   }
18411   if (lseek (fd, 524288000, SEEK_SET) == -1) {
18412     perror ("lseek");
18413     close (fd);
18414     unlink (filename);
18415     exit (1);
18416   }
18417   if (write (fd, &c, 1) == -1) {
18418     perror ("write");
18419     close (fd);
18420     unlink (filename);
18421     exit (1);
18422   }
18423   if (close (fd) == -1) {
18424     perror (filename);
18425     unlink (filename);
18426     exit (1);
18427   }
18428   if (guestfs_add_drive (g, filename) == -1) {
18429     printf ("guestfs_add_drive %s FAILED\n", filename);
18430     exit (1);
18431   }
18432
18433   filename = "test2.img";
18434   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18435   if (fd == -1) {
18436     perror (filename);
18437     exit (1);
18438   }
18439   if (lseek (fd, 52428800, SEEK_SET) == -1) {
18440     perror ("lseek");
18441     close (fd);
18442     unlink (filename);
18443     exit (1);
18444   }
18445   if (write (fd, &c, 1) == -1) {
18446     perror ("write");
18447     close (fd);
18448     unlink (filename);
18449     exit (1);
18450   }
18451   if (close (fd) == -1) {
18452     perror (filename);
18453     unlink (filename);
18454     exit (1);
18455   }
18456   if (guestfs_add_drive (g, filename) == -1) {
18457     printf ("guestfs_add_drive %s FAILED\n", filename);
18458     exit (1);
18459   }
18460
18461   filename = "test3.img";
18462   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18463   if (fd == -1) {
18464     perror (filename);
18465     exit (1);
18466   }
18467   if (lseek (fd, 10485760, SEEK_SET) == -1) {
18468     perror ("lseek");
18469     close (fd);
18470     unlink (filename);
18471     exit (1);
18472   }
18473   if (write (fd, &c, 1) == -1) {
18474     perror ("write");
18475     close (fd);
18476     unlink (filename);
18477     exit (1);
18478   }
18479   if (close (fd) == -1) {
18480     perror (filename);
18481     unlink (filename);
18482     exit (1);
18483   }
18484   if (guestfs_add_drive (g, filename) == -1) {
18485     printf ("guestfs_add_drive %s FAILED\n", filename);
18486     exit (1);
18487   }
18488
18489   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18490     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18491     exit (1);
18492   }
18493
18494   if (guestfs_launch (g) == -1) {
18495     printf ("guestfs_launch FAILED\n");
18496     exit (1);
18497   }
18498
18499   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18500   alarm (600);
18501
18502   if (guestfs_wait_ready (g) == -1) {
18503     printf ("guestfs_wait_ready FAILED\n");
18504     exit (1);
18505   }
18506
18507   /* Cancel previous alarm. */
18508   alarm (0);
18509
18510   nr_tests = 164;
18511
18512   test_num++;
18513   printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
18514   if (test_tail_n_0 () == -1) {
18515     printf ("test_tail_n_0 FAILED\n");
18516     failed++;
18517   }
18518   test_num++;
18519   printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
18520   if (test_tail_n_1 () == -1) {
18521     printf ("test_tail_n_1 FAILED\n");
18522     failed++;
18523   }
18524   test_num++;
18525   printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
18526   if (test_tail_n_2 () == -1) {
18527     printf ("test_tail_n_2 FAILED\n");
18528     failed++;
18529   }
18530   test_num++;
18531   printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
18532   if (test_tail_0 () == -1) {
18533     printf ("test_tail_0 FAILED\n");
18534     failed++;
18535   }
18536   test_num++;
18537   printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
18538   if (test_head_n_0 () == -1) {
18539     printf ("test_head_n_0 FAILED\n");
18540     failed++;
18541   }
18542   test_num++;
18543   printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
18544   if (test_head_n_1 () == -1) {
18545     printf ("test_head_n_1 FAILED\n");
18546     failed++;
18547   }
18548   test_num++;
18549   printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
18550   if (test_head_n_2 () == -1) {
18551     printf ("test_head_n_2 FAILED\n");
18552     failed++;
18553   }
18554   test_num++;
18555   printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
18556   if (test_head_0 () == -1) {
18557     printf ("test_head_0 FAILED\n");
18558     failed++;
18559   }
18560   test_num++;
18561   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
18562   if (test_wc_c_0 () == -1) {
18563     printf ("test_wc_c_0 FAILED\n");
18564     failed++;
18565   }
18566   test_num++;
18567   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
18568   if (test_wc_w_0 () == -1) {
18569     printf ("test_wc_w_0 FAILED\n");
18570     failed++;
18571   }
18572   test_num++;
18573   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
18574   if (test_wc_l_0 () == -1) {
18575     printf ("test_wc_l_0 FAILED\n");
18576     failed++;
18577   }
18578   test_num++;
18579   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
18580   if (test_mkdtemp_0 () == -1) {
18581     printf ("test_mkdtemp_0 FAILED\n");
18582     failed++;
18583   }
18584   test_num++;
18585   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
18586   if (test_scrub_file_0 () == -1) {
18587     printf ("test_scrub_file_0 FAILED\n");
18588     failed++;
18589   }
18590   test_num++;
18591   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
18592   if (test_scrub_device_0 () == -1) {
18593     printf ("test_scrub_device_0 FAILED\n");
18594     failed++;
18595   }
18596   test_num++;
18597   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
18598   if (test_glob_expand_0 () == -1) {
18599     printf ("test_glob_expand_0 FAILED\n");
18600     failed++;
18601   }
18602   test_num++;
18603   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
18604   if (test_glob_expand_1 () == -1) {
18605     printf ("test_glob_expand_1 FAILED\n");
18606     failed++;
18607   }
18608   test_num++;
18609   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
18610   if (test_glob_expand_2 () == -1) {
18611     printf ("test_glob_expand_2 FAILED\n");
18612     failed++;
18613   }
18614   test_num++;
18615   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
18616   if (test_ntfs_3g_probe_0 () == -1) {
18617     printf ("test_ntfs_3g_probe_0 FAILED\n");
18618     failed++;
18619   }
18620   test_num++;
18621   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
18622   if (test_ntfs_3g_probe_1 () == -1) {
18623     printf ("test_ntfs_3g_probe_1 FAILED\n");
18624     failed++;
18625   }
18626   test_num++;
18627   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
18628   if (test_sleep_0 () == -1) {
18629     printf ("test_sleep_0 FAILED\n");
18630     failed++;
18631   }
18632   test_num++;
18633   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
18634   if (test_find_0 () == -1) {
18635     printf ("test_find_0 FAILED\n");
18636     failed++;
18637   }
18638   test_num++;
18639   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
18640   if (test_find_1 () == -1) {
18641     printf ("test_find_1 FAILED\n");
18642     failed++;
18643   }
18644   test_num++;
18645   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
18646   if (test_find_2 () == -1) {
18647     printf ("test_find_2 FAILED\n");
18648     failed++;
18649   }
18650   test_num++;
18651   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
18652   if (test_lvresize_0 () == -1) {
18653     printf ("test_lvresize_0 FAILED\n");
18654     failed++;
18655   }
18656   test_num++;
18657   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
18658   if (test_zerofree_0 () == -1) {
18659     printf ("test_zerofree_0 FAILED\n");
18660     failed++;
18661   }
18662   test_num++;
18663   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
18664   if (test_hexdump_0 () == -1) {
18665     printf ("test_hexdump_0 FAILED\n");
18666     failed++;
18667   }
18668   test_num++;
18669   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
18670   if (test_hexdump_1 () == -1) {
18671     printf ("test_hexdump_1 FAILED\n");
18672     failed++;
18673   }
18674   test_num++;
18675   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
18676   if (test_strings_e_0 () == -1) {
18677     printf ("test_strings_e_0 FAILED\n");
18678     failed++;
18679   }
18680   test_num++;
18681   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
18682   if (test_strings_e_1 () == -1) {
18683     printf ("test_strings_e_1 FAILED\n");
18684     failed++;
18685   }
18686   test_num++;
18687   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
18688   if (test_strings_0 () == -1) {
18689     printf ("test_strings_0 FAILED\n");
18690     failed++;
18691   }
18692   test_num++;
18693   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
18694   if (test_strings_1 () == -1) {
18695     printf ("test_strings_1 FAILED\n");
18696     failed++;
18697   }
18698   test_num++;
18699   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
18700   if (test_equal_0 () == -1) {
18701     printf ("test_equal_0 FAILED\n");
18702     failed++;
18703   }
18704   test_num++;
18705   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
18706   if (test_equal_1 () == -1) {
18707     printf ("test_equal_1 FAILED\n");
18708     failed++;
18709   }
18710   test_num++;
18711   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
18712   if (test_equal_2 () == -1) {
18713     printf ("test_equal_2 FAILED\n");
18714     failed++;
18715   }
18716   test_num++;
18717   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
18718   if (test_ping_daemon_0 () == -1) {
18719     printf ("test_ping_daemon_0 FAILED\n");
18720     failed++;
18721   }
18722   test_num++;
18723   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
18724   if (test_dmesg_0 () == -1) {
18725     printf ("test_dmesg_0 FAILED\n");
18726     failed++;
18727   }
18728   test_num++;
18729   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
18730   if (test_drop_caches_0 () == -1) {
18731     printf ("test_drop_caches_0 FAILED\n");
18732     failed++;
18733   }
18734   test_num++;
18735   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
18736   if (test_mv_0 () == -1) {
18737     printf ("test_mv_0 FAILED\n");
18738     failed++;
18739   }
18740   test_num++;
18741   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
18742   if (test_mv_1 () == -1) {
18743     printf ("test_mv_1 FAILED\n");
18744     failed++;
18745   }
18746   test_num++;
18747   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
18748   if (test_cp_a_0 () == -1) {
18749     printf ("test_cp_a_0 FAILED\n");
18750     failed++;
18751   }
18752   test_num++;
18753   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
18754   if (test_cp_0 () == -1) {
18755     printf ("test_cp_0 FAILED\n");
18756     failed++;
18757   }
18758   test_num++;
18759   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
18760   if (test_cp_1 () == -1) {
18761     printf ("test_cp_1 FAILED\n");
18762     failed++;
18763   }
18764   test_num++;
18765   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
18766   if (test_cp_2 () == -1) {
18767     printf ("test_cp_2 FAILED\n");
18768     failed++;
18769   }
18770   test_num++;
18771   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
18772   if (test_grub_install_0 () == -1) {
18773     printf ("test_grub_install_0 FAILED\n");
18774     failed++;
18775   }
18776   test_num++;
18777   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
18778   if (test_zero_0 () == -1) {
18779     printf ("test_zero_0 FAILED\n");
18780     failed++;
18781   }
18782   test_num++;
18783   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
18784   if (test_fsck_0 () == -1) {
18785     printf ("test_fsck_0 FAILED\n");
18786     failed++;
18787   }
18788   test_num++;
18789   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
18790   if (test_fsck_1 () == -1) {
18791     printf ("test_fsck_1 FAILED\n");
18792     failed++;
18793   }
18794   test_num++;
18795   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
18796   if (test_set_e2uuid_0 () == -1) {
18797     printf ("test_set_e2uuid_0 FAILED\n");
18798     failed++;
18799   }
18800   test_num++;
18801   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
18802   if (test_set_e2uuid_1 () == -1) {
18803     printf ("test_set_e2uuid_1 FAILED\n");
18804     failed++;
18805   }
18806   test_num++;
18807   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
18808   if (test_set_e2uuid_2 () == -1) {
18809     printf ("test_set_e2uuid_2 FAILED\n");
18810     failed++;
18811   }
18812   test_num++;
18813   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
18814   if (test_set_e2uuid_3 () == -1) {
18815     printf ("test_set_e2uuid_3 FAILED\n");
18816     failed++;
18817   }
18818   test_num++;
18819   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
18820   if (test_set_e2label_0 () == -1) {
18821     printf ("test_set_e2label_0 FAILED\n");
18822     failed++;
18823   }
18824   test_num++;
18825   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
18826   if (test_pvremove_0 () == -1) {
18827     printf ("test_pvremove_0 FAILED\n");
18828     failed++;
18829   }
18830   test_num++;
18831   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
18832   if (test_pvremove_1 () == -1) {
18833     printf ("test_pvremove_1 FAILED\n");
18834     failed++;
18835   }
18836   test_num++;
18837   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
18838   if (test_pvremove_2 () == -1) {
18839     printf ("test_pvremove_2 FAILED\n");
18840     failed++;
18841   }
18842   test_num++;
18843   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
18844   if (test_vgremove_0 () == -1) {
18845     printf ("test_vgremove_0 FAILED\n");
18846     failed++;
18847   }
18848   test_num++;
18849   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
18850   if (test_vgremove_1 () == -1) {
18851     printf ("test_vgremove_1 FAILED\n");
18852     failed++;
18853   }
18854   test_num++;
18855   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
18856   if (test_lvremove_0 () == -1) {
18857     printf ("test_lvremove_0 FAILED\n");
18858     failed++;
18859   }
18860   test_num++;
18861   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
18862   if (test_lvremove_1 () == -1) {
18863     printf ("test_lvremove_1 FAILED\n");
18864     failed++;
18865   }
18866   test_num++;
18867   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
18868   if (test_lvremove_2 () == -1) {
18869     printf ("test_lvremove_2 FAILED\n");
18870     failed++;
18871   }
18872   test_num++;
18873   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
18874   if (test_mount_ro_0 () == -1) {
18875     printf ("test_mount_ro_0 FAILED\n");
18876     failed++;
18877   }
18878   test_num++;
18879   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
18880   if (test_mount_ro_1 () == -1) {
18881     printf ("test_mount_ro_1 FAILED\n");
18882     failed++;
18883   }
18884   test_num++;
18885   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
18886   if (test_tgz_in_0 () == -1) {
18887     printf ("test_tgz_in_0 FAILED\n");
18888     failed++;
18889   }
18890   test_num++;
18891   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
18892   if (test_tar_in_0 () == -1) {
18893     printf ("test_tar_in_0 FAILED\n");
18894     failed++;
18895   }
18896   test_num++;
18897   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
18898   if (test_checksum_0 () == -1) {
18899     printf ("test_checksum_0 FAILED\n");
18900     failed++;
18901   }
18902   test_num++;
18903   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
18904   if (test_checksum_1 () == -1) {
18905     printf ("test_checksum_1 FAILED\n");
18906     failed++;
18907   }
18908   test_num++;
18909   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
18910   if (test_checksum_2 () == -1) {
18911     printf ("test_checksum_2 FAILED\n");
18912     failed++;
18913   }
18914   test_num++;
18915   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
18916   if (test_checksum_3 () == -1) {
18917     printf ("test_checksum_3 FAILED\n");
18918     failed++;
18919   }
18920   test_num++;
18921   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
18922   if (test_checksum_4 () == -1) {
18923     printf ("test_checksum_4 FAILED\n");
18924     failed++;
18925   }
18926   test_num++;
18927   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
18928   if (test_checksum_5 () == -1) {
18929     printf ("test_checksum_5 FAILED\n");
18930     failed++;
18931   }
18932   test_num++;
18933   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
18934   if (test_checksum_6 () == -1) {
18935     printf ("test_checksum_6 FAILED\n");
18936     failed++;
18937   }
18938   test_num++;
18939   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
18940   if (test_checksum_7 () == -1) {
18941     printf ("test_checksum_7 FAILED\n");
18942     failed++;
18943   }
18944   test_num++;
18945   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
18946   if (test_checksum_8 () == -1) {
18947     printf ("test_checksum_8 FAILED\n");
18948     failed++;
18949   }
18950   test_num++;
18951   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
18952   if (test_download_0 () == -1) {
18953     printf ("test_download_0 FAILED\n");
18954     failed++;
18955   }
18956   test_num++;
18957   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
18958   if (test_upload_0 () == -1) {
18959     printf ("test_upload_0 FAILED\n");
18960     failed++;
18961   }
18962   test_num++;
18963   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
18964   if (test_blockdev_rereadpt_0 () == -1) {
18965     printf ("test_blockdev_rereadpt_0 FAILED\n");
18966     failed++;
18967   }
18968   test_num++;
18969   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
18970   if (test_blockdev_flushbufs_0 () == -1) {
18971     printf ("test_blockdev_flushbufs_0 FAILED\n");
18972     failed++;
18973   }
18974   test_num++;
18975   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
18976   if (test_blockdev_getsize64_0 () == -1) {
18977     printf ("test_blockdev_getsize64_0 FAILED\n");
18978     failed++;
18979   }
18980   test_num++;
18981   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
18982   if (test_blockdev_getsz_0 () == -1) {
18983     printf ("test_blockdev_getsz_0 FAILED\n");
18984     failed++;
18985   }
18986   test_num++;
18987   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
18988   if (test_blockdev_getbsz_0 () == -1) {
18989     printf ("test_blockdev_getbsz_0 FAILED\n");
18990     failed++;
18991   }
18992   test_num++;
18993   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
18994   if (test_blockdev_getss_0 () == -1) {
18995     printf ("test_blockdev_getss_0 FAILED\n");
18996     failed++;
18997   }
18998   test_num++;
18999   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19000   if (test_blockdev_getro_0 () == -1) {
19001     printf ("test_blockdev_getro_0 FAILED\n");
19002     failed++;
19003   }
19004   test_num++;
19005   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19006   if (test_blockdev_setrw_0 () == -1) {
19007     printf ("test_blockdev_setrw_0 FAILED\n");
19008     failed++;
19009   }
19010   test_num++;
19011   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19012   if (test_blockdev_setro_0 () == -1) {
19013     printf ("test_blockdev_setro_0 FAILED\n");
19014     failed++;
19015   }
19016   test_num++;
19017   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19018   if (test_statvfs_0 () == -1) {
19019     printf ("test_statvfs_0 FAILED\n");
19020     failed++;
19021   }
19022   test_num++;
19023   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19024   if (test_lstat_0 () == -1) {
19025     printf ("test_lstat_0 FAILED\n");
19026     failed++;
19027   }
19028   test_num++;
19029   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19030   if (test_stat_0 () == -1) {
19031     printf ("test_stat_0 FAILED\n");
19032     failed++;
19033   }
19034   test_num++;
19035   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19036   if (test_command_lines_0 () == -1) {
19037     printf ("test_command_lines_0 FAILED\n");
19038     failed++;
19039   }
19040   test_num++;
19041   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19042   if (test_command_lines_1 () == -1) {
19043     printf ("test_command_lines_1 FAILED\n");
19044     failed++;
19045   }
19046   test_num++;
19047   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19048   if (test_command_lines_2 () == -1) {
19049     printf ("test_command_lines_2 FAILED\n");
19050     failed++;
19051   }
19052   test_num++;
19053   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19054   if (test_command_lines_3 () == -1) {
19055     printf ("test_command_lines_3 FAILED\n");
19056     failed++;
19057   }
19058   test_num++;
19059   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19060   if (test_command_lines_4 () == -1) {
19061     printf ("test_command_lines_4 FAILED\n");
19062     failed++;
19063   }
19064   test_num++;
19065   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19066   if (test_command_lines_5 () == -1) {
19067     printf ("test_command_lines_5 FAILED\n");
19068     failed++;
19069   }
19070   test_num++;
19071   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19072   if (test_command_lines_6 () == -1) {
19073     printf ("test_command_lines_6 FAILED\n");
19074     failed++;
19075   }
19076   test_num++;
19077   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19078   if (test_command_lines_7 () == -1) {
19079     printf ("test_command_lines_7 FAILED\n");
19080     failed++;
19081   }
19082   test_num++;
19083   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19084   if (test_command_lines_8 () == -1) {
19085     printf ("test_command_lines_8 FAILED\n");
19086     failed++;
19087   }
19088   test_num++;
19089   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19090   if (test_command_lines_9 () == -1) {
19091     printf ("test_command_lines_9 FAILED\n");
19092     failed++;
19093   }
19094   test_num++;
19095   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19096   if (test_command_lines_10 () == -1) {
19097     printf ("test_command_lines_10 FAILED\n");
19098     failed++;
19099   }
19100   test_num++;
19101   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19102   if (test_command_0 () == -1) {
19103     printf ("test_command_0 FAILED\n");
19104     failed++;
19105   }
19106   test_num++;
19107   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19108   if (test_command_1 () == -1) {
19109     printf ("test_command_1 FAILED\n");
19110     failed++;
19111   }
19112   test_num++;
19113   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19114   if (test_command_2 () == -1) {
19115     printf ("test_command_2 FAILED\n");
19116     failed++;
19117   }
19118   test_num++;
19119   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19120   if (test_command_3 () == -1) {
19121     printf ("test_command_3 FAILED\n");
19122     failed++;
19123   }
19124   test_num++;
19125   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19126   if (test_command_4 () == -1) {
19127     printf ("test_command_4 FAILED\n");
19128     failed++;
19129   }
19130   test_num++;
19131   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19132   if (test_command_5 () == -1) {
19133     printf ("test_command_5 FAILED\n");
19134     failed++;
19135   }
19136   test_num++;
19137   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19138   if (test_command_6 () == -1) {
19139     printf ("test_command_6 FAILED\n");
19140     failed++;
19141   }
19142   test_num++;
19143   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19144   if (test_command_7 () == -1) {
19145     printf ("test_command_7 FAILED\n");
19146     failed++;
19147   }
19148   test_num++;
19149   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19150   if (test_command_8 () == -1) {
19151     printf ("test_command_8 FAILED\n");
19152     failed++;
19153   }
19154   test_num++;
19155   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19156   if (test_command_9 () == -1) {
19157     printf ("test_command_9 FAILED\n");
19158     failed++;
19159   }
19160   test_num++;
19161   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19162   if (test_command_10 () == -1) {
19163     printf ("test_command_10 FAILED\n");
19164     failed++;
19165   }
19166   test_num++;
19167   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19168   if (test_command_11 () == -1) {
19169     printf ("test_command_11 FAILED\n");
19170     failed++;
19171   }
19172   test_num++;
19173   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19174   if (test_file_0 () == -1) {
19175     printf ("test_file_0 FAILED\n");
19176     failed++;
19177   }
19178   test_num++;
19179   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19180   if (test_file_1 () == -1) {
19181     printf ("test_file_1 FAILED\n");
19182     failed++;
19183   }
19184   test_num++;
19185   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19186   if (test_file_2 () == -1) {
19187     printf ("test_file_2 FAILED\n");
19188     failed++;
19189   }
19190   test_num++;
19191   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19192   if (test_umount_all_0 () == -1) {
19193     printf ("test_umount_all_0 FAILED\n");
19194     failed++;
19195   }
19196   test_num++;
19197   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19198   if (test_umount_all_1 () == -1) {
19199     printf ("test_umount_all_1 FAILED\n");
19200     failed++;
19201   }
19202   test_num++;
19203   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19204   if (test_mounts_0 () == -1) {
19205     printf ("test_mounts_0 FAILED\n");
19206     failed++;
19207   }
19208   test_num++;
19209   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19210   if (test_umount_0 () == -1) {
19211     printf ("test_umount_0 FAILED\n");
19212     failed++;
19213   }
19214   test_num++;
19215   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19216   if (test_umount_1 () == -1) {
19217     printf ("test_umount_1 FAILED\n");
19218     failed++;
19219   }
19220   test_num++;
19221   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19222   if (test_write_file_0 () == -1) {
19223     printf ("test_write_file_0 FAILED\n");
19224     failed++;
19225   }
19226   test_num++;
19227   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19228   if (test_write_file_1 () == -1) {
19229     printf ("test_write_file_1 FAILED\n");
19230     failed++;
19231   }
19232   test_num++;
19233   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19234   if (test_write_file_2 () == -1) {
19235     printf ("test_write_file_2 FAILED\n");
19236     failed++;
19237   }
19238   test_num++;
19239   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19240   if (test_write_file_3 () == -1) {
19241     printf ("test_write_file_3 FAILED\n");
19242     failed++;
19243   }
19244   test_num++;
19245   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19246   if (test_write_file_4 () == -1) {
19247     printf ("test_write_file_4 FAILED\n");
19248     failed++;
19249   }
19250   test_num++;
19251   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19252   if (test_write_file_5 () == -1) {
19253     printf ("test_write_file_5 FAILED\n");
19254     failed++;
19255   }
19256   test_num++;
19257   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19258   if (test_mkfs_0 () == -1) {
19259     printf ("test_mkfs_0 FAILED\n");
19260     failed++;
19261   }
19262   test_num++;
19263   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19264   if (test_lvcreate_0 () == -1) {
19265     printf ("test_lvcreate_0 FAILED\n");
19266     failed++;
19267   }
19268   test_num++;
19269   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19270   if (test_vgcreate_0 () == -1) {
19271     printf ("test_vgcreate_0 FAILED\n");
19272     failed++;
19273   }
19274   test_num++;
19275   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19276   if (test_pvcreate_0 () == -1) {
19277     printf ("test_pvcreate_0 FAILED\n");
19278     failed++;
19279   }
19280   test_num++;
19281   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19282   if (test_is_dir_0 () == -1) {
19283     printf ("test_is_dir_0 FAILED\n");
19284     failed++;
19285   }
19286   test_num++;
19287   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19288   if (test_is_dir_1 () == -1) {
19289     printf ("test_is_dir_1 FAILED\n");
19290     failed++;
19291   }
19292   test_num++;
19293   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19294   if (test_is_file_0 () == -1) {
19295     printf ("test_is_file_0 FAILED\n");
19296     failed++;
19297   }
19298   test_num++;
19299   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19300   if (test_is_file_1 () == -1) {
19301     printf ("test_is_file_1 FAILED\n");
19302     failed++;
19303   }
19304   test_num++;
19305   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19306   if (test_exists_0 () == -1) {
19307     printf ("test_exists_0 FAILED\n");
19308     failed++;
19309   }
19310   test_num++;
19311   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19312   if (test_exists_1 () == -1) {
19313     printf ("test_exists_1 FAILED\n");
19314     failed++;
19315   }
19316   test_num++;
19317   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19318   if (test_mkdir_p_0 () == -1) {
19319     printf ("test_mkdir_p_0 FAILED\n");
19320     failed++;
19321   }
19322   test_num++;
19323   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19324   if (test_mkdir_p_1 () == -1) {
19325     printf ("test_mkdir_p_1 FAILED\n");
19326     failed++;
19327   }
19328   test_num++;
19329   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19330   if (test_mkdir_p_2 () == -1) {
19331     printf ("test_mkdir_p_2 FAILED\n");
19332     failed++;
19333   }
19334   test_num++;
19335   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19336   if (test_mkdir_p_3 () == -1) {
19337     printf ("test_mkdir_p_3 FAILED\n");
19338     failed++;
19339   }
19340   test_num++;
19341   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19342   if (test_mkdir_p_4 () == -1) {
19343     printf ("test_mkdir_p_4 FAILED\n");
19344     failed++;
19345   }
19346   test_num++;
19347   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19348   if (test_mkdir_0 () == -1) {
19349     printf ("test_mkdir_0 FAILED\n");
19350     failed++;
19351   }
19352   test_num++;
19353   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19354   if (test_mkdir_1 () == -1) {
19355     printf ("test_mkdir_1 FAILED\n");
19356     failed++;
19357   }
19358   test_num++;
19359   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19360   if (test_rm_rf_0 () == -1) {
19361     printf ("test_rm_rf_0 FAILED\n");
19362     failed++;
19363   }
19364   test_num++;
19365   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19366   if (test_rmdir_0 () == -1) {
19367     printf ("test_rmdir_0 FAILED\n");
19368     failed++;
19369   }
19370   test_num++;
19371   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19372   if (test_rmdir_1 () == -1) {
19373     printf ("test_rmdir_1 FAILED\n");
19374     failed++;
19375   }
19376   test_num++;
19377   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19378   if (test_rmdir_2 () == -1) {
19379     printf ("test_rmdir_2 FAILED\n");
19380     failed++;
19381   }
19382   test_num++;
19383   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19384   if (test_rm_0 () == -1) {
19385     printf ("test_rm_0 FAILED\n");
19386     failed++;
19387   }
19388   test_num++;
19389   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19390   if (test_rm_1 () == -1) {
19391     printf ("test_rm_1 FAILED\n");
19392     failed++;
19393   }
19394   test_num++;
19395   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19396   if (test_rm_2 () == -1) {
19397     printf ("test_rm_2 FAILED\n");
19398     failed++;
19399   }
19400   test_num++;
19401   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19402   if (test_read_lines_0 () == -1) {
19403     printf ("test_read_lines_0 FAILED\n");
19404     failed++;
19405   }
19406   test_num++;
19407   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19408   if (test_read_lines_1 () == -1) {
19409     printf ("test_read_lines_1 FAILED\n");
19410     failed++;
19411   }
19412   test_num++;
19413   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19414   if (test_lvs_0 () == -1) {
19415     printf ("test_lvs_0 FAILED\n");
19416     failed++;
19417   }
19418   test_num++;
19419   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19420   if (test_lvs_1 () == -1) {
19421     printf ("test_lvs_1 FAILED\n");
19422     failed++;
19423   }
19424   test_num++;
19425   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19426   if (test_vgs_0 () == -1) {
19427     printf ("test_vgs_0 FAILED\n");
19428     failed++;
19429   }
19430   test_num++;
19431   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19432   if (test_vgs_1 () == -1) {
19433     printf ("test_vgs_1 FAILED\n");
19434     failed++;
19435   }
19436   test_num++;
19437   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19438   if (test_pvs_0 () == -1) {
19439     printf ("test_pvs_0 FAILED\n");
19440     failed++;
19441   }
19442   test_num++;
19443   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19444   if (test_pvs_1 () == -1) {
19445     printf ("test_pvs_1 FAILED\n");
19446     failed++;
19447   }
19448   test_num++;
19449   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19450   if (test_list_partitions_0 () == -1) {
19451     printf ("test_list_partitions_0 FAILED\n");
19452     failed++;
19453   }
19454   test_num++;
19455   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19456   if (test_list_partitions_1 () == -1) {
19457     printf ("test_list_partitions_1 FAILED\n");
19458     failed++;
19459   }
19460   test_num++;
19461   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19462   if (test_list_devices_0 () == -1) {
19463     printf ("test_list_devices_0 FAILED\n");
19464     failed++;
19465   }
19466   test_num++;
19467   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19468   if (test_ls_0 () == -1) {
19469     printf ("test_ls_0 FAILED\n");
19470     failed++;
19471   }
19472   test_num++;
19473   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19474   if (test_cat_0 () == -1) {
19475     printf ("test_cat_0 FAILED\n");
19476     failed++;
19477   }
19478   test_num++;
19479   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19480   if (test_touch_0 () == -1) {
19481     printf ("test_touch_0 FAILED\n");
19482     failed++;
19483   }
19484   test_num++;
19485   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19486   if (test_sync_0 () == -1) {
19487     printf ("test_sync_0 FAILED\n");
19488     failed++;
19489   }
19490   test_num++;
19491   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19492   if (test_mount_0 () == -1) {
19493     printf ("test_mount_0 FAILED\n");
19494     failed++;
19495   }
19496
19497   guestfs_close (g);
19498   unlink ("test1.img");
19499   unlink ("test2.img");
19500   unlink ("test3.img");
19501
19502   if (failed > 0) {
19503     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
19504     exit (1);
19505   }
19506
19507   exit (0);
19508 }