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 }
 154
 155 static int test_glob_expand_0_skip (void)
 156 {
 157   const char *str;
 158
 159   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
 160   if (str && strcmp (str, "1") == 0) return 1;
 161   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 162   if (str && strcmp (str, "1") == 0) return 1;
 163   return 0;
 164 }
 165
 166 static int test_glob_expand_0 (void)
 167 {
 168   if (test_glob_expand_0_skip ()) {
 169     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_0");
 170     return 0;
 171   }
 172
 173   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
 174   {
 175     char device[] = "/dev/sda";
 176     int r;
 177     suppress_error = 0;
 178     r = guestfs_blockdev_setrw (g, device);
 179     if (r == -1)
 180       return -1;
 181   }
 182   {
 183     int r;
 184     suppress_error = 0;
 185     r = guestfs_umount_all (g);
 186     if (r == -1)
 187       return -1;
 188   }
 189   {
 190     int r;
 191     suppress_error = 0;
 192     r = guestfs_lvm_remove_all (g);
 193     if (r == -1)
 194       return -1;
 195   }
 196   {
 197     char device[] = "/dev/sda";
 198     char lines_0[] = ",";
 199     char *lines[] = {
 200       lines_0,
 201       NULL
 202     };
 203     int r;
 204     suppress_error = 0;
 205     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 206     if (r == -1)
 207       return -1;
 208   }
 209   {
 210     char fstype[] = "ext2";
 211     char device[] = "/dev/sda1";
 212     int r;
 213     suppress_error = 0;
 214     r = guestfs_mkfs (g, fstype, device);
 215     if (r == -1)
 216       return -1;
 217   }
 218   {
 219     char device[] = "/dev/sda1";
 220     char mountpoint[] = "/";
 221     int r;
 222     suppress_error = 0;
 223     r = guestfs_mount (g, device, mountpoint);
 224     if (r == -1)
 225       return -1;
 226   }
 227   /* TestOutputList for glob_expand (0) */
 228   {
 229     char path[] = "/a/b/c";
 230     int r;
 231     suppress_error = 0;
 232     r = guestfs_mkdir_p (g, path);
 233     if (r == -1)
 234       return -1;
 235   }
 236   {
 237     char path[] = "/a/b/c/d";
 238     int r;
 239     suppress_error = 0;
 240     r = guestfs_touch (g, path);
 241     if (r == -1)
 242       return -1;
 243   }
 244   {
 245     char path[] = "/a/b/c/e";
 246     int r;
 247     suppress_error = 0;
 248     r = guestfs_touch (g, path);
 249     if (r == -1)
 250       return -1;
 251   }
 252   {
 253     char pattern[] = "/a/b/c/*";
 254     char **r;
 255     int i;
 256     suppress_error = 0;
 257     r = guestfs_glob_expand (g, pattern);
 258     if (r == NULL)
 259       return -1;
 260     if (!r[0]) {
 261       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
 262       print_strings (r);
 263       return -1;
 264     }
 265     {
 266       char expected[] = "/a/b/c/d";
 267       if (strcmp (r[0], expected) != 0) {
 268         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 269         return -1;
 270       }
 271     }
 272     if (!r[1]) {
 273       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
 274       print_strings (r);
 275       return -1;
 276     }
 277     {
 278       char expected[] = "/a/b/c/e";
 279       if (strcmp (r[1], expected) != 0) {
 280         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 281         return -1;
 282       }
 283     }
 284     if (r[2] != NULL) {
 285       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
 286       print_strings (r);
 287       return -1;
 288     }
 289     for (i = 0; r[i] != NULL; ++i)
 290       free (r[i]);
 291     free (r);
 292   }
 293   return 0;
 294 }
 295
 296 static int test_glob_expand_1_skip (void)
 297 {
 298   const char *str;
 299
 300   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
 301   if (str && strcmp (str, "1") == 0) return 1;
 302   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 303   if (str && strcmp (str, "1") == 0) return 1;
 304   return 0;
 305 }
 306
 307 static int test_glob_expand_1 (void)
 308 {
 309   if (test_glob_expand_1_skip ()) {
 310     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_1");
 311     return 0;
 312   }
 313
 314   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
 315   {
 316     char device[] = "/dev/sda";
 317     int r;
 318     suppress_error = 0;
 319     r = guestfs_blockdev_setrw (g, device);
 320     if (r == -1)
 321       return -1;
 322   }
 323   {
 324     int r;
 325     suppress_error = 0;
 326     r = guestfs_umount_all (g);
 327     if (r == -1)
 328       return -1;
 329   }
 330   {
 331     int r;
 332     suppress_error = 0;
 333     r = guestfs_lvm_remove_all (g);
 334     if (r == -1)
 335       return -1;
 336   }
 337   {
 338     char device[] = "/dev/sda";
 339     char lines_0[] = ",";
 340     char *lines[] = {
 341       lines_0,
 342       NULL
 343     };
 344     int r;
 345     suppress_error = 0;
 346     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 347     if (r == -1)
 348       return -1;
 349   }
 350   {
 351     char fstype[] = "ext2";
 352     char device[] = "/dev/sda1";
 353     int r;
 354     suppress_error = 0;
 355     r = guestfs_mkfs (g, fstype, device);
 356     if (r == -1)
 357       return -1;
 358   }
 359   {
 360     char device[] = "/dev/sda1";
 361     char mountpoint[] = "/";
 362     int r;
 363     suppress_error = 0;
 364     r = guestfs_mount (g, device, mountpoint);
 365     if (r == -1)
 366       return -1;
 367   }
 368   /* TestOutputList for glob_expand (1) */
 369   {
 370     char path[] = "/a/b/c";
 371     int r;
 372     suppress_error = 0;
 373     r = guestfs_mkdir_p (g, path);
 374     if (r == -1)
 375       return -1;
 376   }
 377   {
 378     char path[] = "/a/b/c/d";
 379     int r;
 380     suppress_error = 0;
 381     r = guestfs_touch (g, path);
 382     if (r == -1)
 383       return -1;
 384   }
 385   {
 386     char path[] = "/a/b/c/e";
 387     int r;
 388     suppress_error = 0;
 389     r = guestfs_touch (g, path);
 390     if (r == -1)
 391       return -1;
 392   }
 393   {
 394     char pattern[] = "/a/*/c/*";
 395     char **r;
 396     int i;
 397     suppress_error = 0;
 398     r = guestfs_glob_expand (g, pattern);
 399     if (r == NULL)
 400       return -1;
 401     if (!r[0]) {
 402       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
 403       print_strings (r);
 404       return -1;
 405     }
 406     {
 407       char expected[] = "/a/b/c/d";
 408       if (strcmp (r[0], expected) != 0) {
 409         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 410         return -1;
 411       }
 412     }
 413     if (!r[1]) {
 414       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
 415       print_strings (r);
 416       return -1;
 417     }
 418     {
 419       char expected[] = "/a/b/c/e";
 420       if (strcmp (r[1], expected) != 0) {
 421         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 422         return -1;
 423       }
 424     }
 425     if (r[2] != NULL) {
 426       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
 427       print_strings (r);
 428       return -1;
 429     }
 430     for (i = 0; r[i] != NULL; ++i)
 431       free (r[i]);
 432     free (r);
 433   }
 434   return 0;
 435 }
 436
 437 static int test_glob_expand_2_skip (void)
 438 {
 439   const char *str;
 440
 441   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
 442   if (str && strcmp (str, "1") == 0) return 1;
 443   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 444   if (str && strcmp (str, "1") == 0) return 1;
 445   return 0;
 446 }
 447
 448 static int test_glob_expand_2 (void)
 449 {
 450   if (test_glob_expand_2_skip ()) {
 451     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_2");
 452     return 0;
 453   }
 454
 455   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
 456   {
 457     char device[] = "/dev/sda";
 458     int r;
 459     suppress_error = 0;
 460     r = guestfs_blockdev_setrw (g, device);
 461     if (r == -1)
 462       return -1;
 463   }
 464   {
 465     int r;
 466     suppress_error = 0;
 467     r = guestfs_umount_all (g);
 468     if (r == -1)
 469       return -1;
 470   }
 471   {
 472     int r;
 473     suppress_error = 0;
 474     r = guestfs_lvm_remove_all (g);
 475     if (r == -1)
 476       return -1;
 477   }
 478   {
 479     char device[] = "/dev/sda";
 480     char lines_0[] = ",";
 481     char *lines[] = {
 482       lines_0,
 483       NULL
 484     };
 485     int r;
 486     suppress_error = 0;
 487     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 488     if (r == -1)
 489       return -1;
 490   }
 491   {
 492     char fstype[] = "ext2";
 493     char device[] = "/dev/sda1";
 494     int r;
 495     suppress_error = 0;
 496     r = guestfs_mkfs (g, fstype, device);
 497     if (r == -1)
 498       return -1;
 499   }
 500   {
 501     char device[] = "/dev/sda1";
 502     char mountpoint[] = "/";
 503     int r;
 504     suppress_error = 0;
 505     r = guestfs_mount (g, device, mountpoint);
 506     if (r == -1)
 507       return -1;
 508   }
 509   /* TestOutputList for glob_expand (2) */
 510   {
 511     char path[] = "/a/b/c";
 512     int r;
 513     suppress_error = 0;
 514     r = guestfs_mkdir_p (g, path);
 515     if (r == -1)
 516       return -1;
 517   }
 518   {
 519     char path[] = "/a/b/c/d";
 520     int r;
 521     suppress_error = 0;
 522     r = guestfs_touch (g, path);
 523     if (r == -1)
 524       return -1;
 525   }
 526   {
 527     char path[] = "/a/b/c/e";
 528     int r;
 529     suppress_error = 0;
 530     r = guestfs_touch (g, path);
 531     if (r == -1)
 532       return -1;
 533   }
 534   {
 535     char pattern[] = "/a/*/x/*";
 536     char **r;
 537     int i;
 538     suppress_error = 0;
 539     r = guestfs_glob_expand (g, pattern);
 540     if (r == NULL)
 541       return -1;
 542     if (r[0] != NULL) {
 543       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
 544       print_strings (r);
 545       return -1;
 546     }
 547     for (i = 0; r[i] != NULL; ++i)
 548       free (r[i]);
 549     free (r);
 550   }
 551   return 0;
 552 }
 553
 554 static int test_ntfs_3g_probe_0_skip (void)
 555 {
 556   const char *str;
 557
 558   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
 559   if (str && strcmp (str, "1") == 0) return 1;
 560   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 561   if (str && strcmp (str, "1") == 0) return 1;
 562   return 0;
 563 }
 564
 565 static int test_ntfs_3g_probe_0 (void)
 566 {
 567   if (test_ntfs_3g_probe_0_skip ()) {
 568     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
 569     return 0;
 570   }
 571
 572   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
 573   {
 574     char device[] = "/dev/sda";
 575     int r;
 576     suppress_error = 0;
 577     r = guestfs_blockdev_setrw (g, device);
 578     if (r == -1)
 579       return -1;
 580   }
 581   {
 582     int r;
 583     suppress_error = 0;
 584     r = guestfs_umount_all (g);
 585     if (r == -1)
 586       return -1;
 587   }
 588   {
 589     int r;
 590     suppress_error = 0;
 591     r = guestfs_lvm_remove_all (g);
 592     if (r == -1)
 593       return -1;
 594   }
 595   /* TestOutputInt for ntfs_3g_probe (0) */
 596   {
 597     char device[] = "/dev/sda";
 598     char lines_0[] = ",";
 599     char *lines[] = {
 600       lines_0,
 601       NULL
 602     };
 603     int r;
 604     suppress_error = 0;
 605     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 606     if (r == -1)
 607       return -1;
 608   }
 609   {
 610     char fstype[] = "ntfs";
 611     char device[] = "/dev/sda1";
 612     int r;
 613     suppress_error = 0;
 614     r = guestfs_mkfs (g, fstype, device);
 615     if (r == -1)
 616       return -1;
 617   }
 618   {
 619     char device[] = "/dev/sda1";
 620     int r;
 621     suppress_error = 0;
 622     r = guestfs_ntfs_3g_probe (g, 1, device);
 623     if (r == -1)
 624       return -1;
 625     if (r != 0) {
 626       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
 627       return -1;
 628     }
 629   }
 630   return 0;
 631 }
 632
 633 static int test_ntfs_3g_probe_1_skip (void)
 634 {
 635   const char *str;
 636
 637   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
 638   if (str && strcmp (str, "1") == 0) return 1;
 639   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 640   if (str && strcmp (str, "1") == 0) return 1;
 641   return 0;
 642 }
 643
 644 static int test_ntfs_3g_probe_1 (void)
 645 {
 646   if (test_ntfs_3g_probe_1_skip ()) {
 647     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
 648     return 0;
 649   }
 650
 651   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
 652   {
 653     char device[] = "/dev/sda";
 654     int r;
 655     suppress_error = 0;
 656     r = guestfs_blockdev_setrw (g, device);
 657     if (r == -1)
 658       return -1;
 659   }
 660   {
 661     int r;
 662     suppress_error = 0;
 663     r = guestfs_umount_all (g);
 664     if (r == -1)
 665       return -1;
 666   }
 667   {
 668     int r;
 669     suppress_error = 0;
 670     r = guestfs_lvm_remove_all (g);
 671     if (r == -1)
 672       return -1;
 673   }
 674   /* TestOutputInt for ntfs_3g_probe (1) */
 675   {
 676     char device[] = "/dev/sda";
 677     char lines_0[] = ",";
 678     char *lines[] = {
 679       lines_0,
 680       NULL
 681     };
 682     int r;
 683     suppress_error = 0;
 684     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 685     if (r == -1)
 686       return -1;
 687   }
 688   {
 689     char fstype[] = "ext2";
 690     char device[] = "/dev/sda1";
 691     int r;
 692     suppress_error = 0;
 693     r = guestfs_mkfs (g, fstype, device);
 694     if (r == -1)
 695       return -1;
 696   }
 697   {
 698     char device[] = "/dev/sda1";
 699     int r;
 700     suppress_error = 0;
 701     r = guestfs_ntfs_3g_probe (g, 1, device);
 702     if (r == -1)
 703       return -1;
 704     if (r != 12) {
 705       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
 706       return -1;
 707     }
 708   }
 709   return 0;
 710 }
 711
 712 static int test_sleep_0_skip (void)
 713 {
 714   const char *str;
 715
 716   str = getenv ("SKIP_TEST_SLEEP_0");
 717   if (str && strcmp (str, "1") == 0) return 1;
 718   str = getenv ("SKIP_TEST_SLEEP");
 719   if (str && strcmp (str, "1") == 0) return 1;
 720   return 0;
 721 }
 722
 723 static int test_sleep_0 (void)
 724 {
 725   if (test_sleep_0_skip ()) {
 726     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
 727     return 0;
 728   }
 729
 730   /* InitNone|InitEmpty for test_sleep_0 */
 731   {
 732     char device[] = "/dev/sda";
 733     int r;
 734     suppress_error = 0;
 735     r = guestfs_blockdev_setrw (g, device);
 736     if (r == -1)
 737       return -1;
 738   }
 739   {
 740     int r;
 741     suppress_error = 0;
 742     r = guestfs_umount_all (g);
 743     if (r == -1)
 744       return -1;
 745   }
 746   {
 747     int r;
 748     suppress_error = 0;
 749     r = guestfs_lvm_remove_all (g);
 750     if (r == -1)
 751       return -1;
 752   }
 753   /* TestRun for sleep (0) */
 754   {
 755     int r;
 756     suppress_error = 0;
 757     r = guestfs_sleep (g, 1);
 758     if (r == -1)
 759       return -1;
 760   }
 761   return 0;
 762 }
 763
 764 static int test_find_0_skip (void)
 765 {
 766   const char *str;
 767
 768   str = getenv ("SKIP_TEST_FIND_0");
 769   if (str && strcmp (str, "1") == 0) return 1;
 770   str = getenv ("SKIP_TEST_FIND");
 771   if (str && strcmp (str, "1") == 0) return 1;
 772   return 0;
 773 }
 774
 775 static int test_find_0 (void)
 776 {
 777   if (test_find_0_skip ()) {
 778     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
 779     return 0;
 780   }
 781
 782   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 783   {
 784     char device[] = "/dev/sda";
 785     int r;
 786     suppress_error = 0;
 787     r = guestfs_blockdev_setrw (g, device);
 788     if (r == -1)
 789       return -1;
 790   }
 791   {
 792     int r;
 793     suppress_error = 0;
 794     r = guestfs_umount_all (g);
 795     if (r == -1)
 796       return -1;
 797   }
 798   {
 799     int r;
 800     suppress_error = 0;
 801     r = guestfs_lvm_remove_all (g);
 802     if (r == -1)
 803       return -1;
 804   }
 805   {
 806     char device[] = "/dev/sda";
 807     char lines_0[] = ",";
 808     char *lines[] = {
 809       lines_0,
 810       NULL
 811     };
 812     int r;
 813     suppress_error = 0;
 814     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 815     if (r == -1)
 816       return -1;
 817   }
 818   {
 819     char fstype[] = "ext2";
 820     char device[] = "/dev/sda1";
 821     int r;
 822     suppress_error = 0;
 823     r = guestfs_mkfs (g, fstype, device);
 824     if (r == -1)
 825       return -1;
 826   }
 827   {
 828     char device[] = "/dev/sda1";
 829     char mountpoint[] = "/";
 830     int r;
 831     suppress_error = 0;
 832     r = guestfs_mount (g, device, mountpoint);
 833     if (r == -1)
 834       return -1;
 835   }
 836   /* TestOutputList for find (0) */
 837   {
 838     char directory[] = "/";
 839     char **r;
 840     int i;
 841     suppress_error = 0;
 842     r = guestfs_find (g, directory);
 843     if (r == NULL)
 844       return -1;
 845     if (!r[0]) {
 846       fprintf (stderr, "test_find_0: short list returned from command\n");
 847       print_strings (r);
 848       return -1;
 849     }
 850     {
 851       char expected[] = "lost+found";
 852       if (strcmp (r[0], expected) != 0) {
 853         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 854         return -1;
 855       }
 856     }
 857     if (r[1] != NULL) {
 858       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 859       print_strings (r);
 860       return -1;
 861     }
 862     for (i = 0; r[i] != NULL; ++i)
 863       free (r[i]);
 864     free (r);
 865   }
 866   return 0;
 867 }
 868
 869 static int test_find_1_skip (void)
 870 {
 871   const char *str;
 872
 873   str = getenv ("SKIP_TEST_FIND_1");
 874   if (str && strcmp (str, "1") == 0) return 1;
 875   str = getenv ("SKIP_TEST_FIND");
 876   if (str && strcmp (str, "1") == 0) return 1;
 877   return 0;
 878 }
 879
 880 static int test_find_1 (void)
 881 {
 882   if (test_find_1_skip ()) {
 883     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
 884     return 0;
 885   }
 886
 887   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
 888   {
 889     char device[] = "/dev/sda";
 890     int r;
 891     suppress_error = 0;
 892     r = guestfs_blockdev_setrw (g, device);
 893     if (r == -1)
 894       return -1;
 895   }
 896   {
 897     int r;
 898     suppress_error = 0;
 899     r = guestfs_umount_all (g);
 900     if (r == -1)
 901       return -1;
 902   }
 903   {
 904     int r;
 905     suppress_error = 0;
 906     r = guestfs_lvm_remove_all (g);
 907     if (r == -1)
 908       return -1;
 909   }
 910   {
 911     char device[] = "/dev/sda";
 912     char lines_0[] = ",";
 913     char *lines[] = {
 914       lines_0,
 915       NULL
 916     };
 917     int r;
 918     suppress_error = 0;
 919     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 920     if (r == -1)
 921       return -1;
 922   }
 923   {
 924     char fstype[] = "ext2";
 925     char device[] = "/dev/sda1";
 926     int r;
 927     suppress_error = 0;
 928     r = guestfs_mkfs (g, fstype, device);
 929     if (r == -1)
 930       return -1;
 931   }
 932   {
 933     char device[] = "/dev/sda1";
 934     char mountpoint[] = "/";
 935     int r;
 936     suppress_error = 0;
 937     r = guestfs_mount (g, device, mountpoint);
 938     if (r == -1)
 939       return -1;
 940   }
 941   /* TestOutputList for find (1) */
 942   {
 943     char path[] = "/a";
 944     int r;
 945     suppress_error = 0;
 946     r = guestfs_touch (g, path);
 947     if (r == -1)
 948       return -1;
 949   }
 950   {
 951     char path[] = "/b";
 952     int r;
 953     suppress_error = 0;
 954     r = guestfs_mkdir (g, path);
 955     if (r == -1)
 956       return -1;
 957   }
 958   {
 959     char path[] = "/b/c";
 960     int r;
 961     suppress_error = 0;
 962     r = guestfs_touch (g, path);
 963     if (r == -1)
 964       return -1;
 965   }
 966   {
 967     char directory[] = "/";
 968     char **r;
 969     int i;
 970     suppress_error = 0;
 971     r = guestfs_find (g, directory);
 972     if (r == NULL)
 973       return -1;
 974     if (!r[0]) {
 975       fprintf (stderr, "test_find_1: short list returned from command\n");
 976       print_strings (r);
 977       return -1;
 978     }
 979     {
 980       char expected[] = "a";
 981       if (strcmp (r[0], expected) != 0) {
 982         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 983         return -1;
 984       }
 985     }
 986     if (!r[1]) {
 987       fprintf (stderr, "test_find_1: short list returned from command\n");
 988       print_strings (r);
 989       return -1;
 990     }
 991     {
 992       char expected[] = "b";
 993       if (strcmp (r[1], expected) != 0) {
 994         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 995         return -1;
 996       }
 997     }
 998     if (!r[2]) {
 999       fprintf (stderr, "test_find_1: short list returned from command\n");
1000       print_strings (r);
1001       return -1;
1002     }
1003     {
1004       char expected[] = "b/c";
1005       if (strcmp (r[2], expected) != 0) {
1006         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1007         return -1;
1008       }
1009     }
1010     if (!r[3]) {
1011       fprintf (stderr, "test_find_1: short list returned from command\n");
1012       print_strings (r);
1013       return -1;
1014     }
1015     {
1016       char expected[] = "lost+found";
1017       if (strcmp (r[3], expected) != 0) {
1018         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1019         return -1;
1020       }
1021     }
1022     if (r[4] != NULL) {
1023       fprintf (stderr, "test_find_1: extra elements returned from command\n");
1024       print_strings (r);
1025       return -1;
1026     }
1027     for (i = 0; r[i] != NULL; ++i)
1028       free (r[i]);
1029     free (r);
1030   }
1031   return 0;
1032 }
1033
1034 static int test_find_2_skip (void)
1035 {
1036   const char *str;
1037
1038   str = getenv ("SKIP_TEST_FIND_2");
1039   if (str && strcmp (str, "1") == 0) return 1;
1040   str = getenv ("SKIP_TEST_FIND");
1041   if (str && strcmp (str, "1") == 0) return 1;
1042   return 0;
1043 }
1044
1045 static int test_find_2 (void)
1046 {
1047   if (test_find_2_skip ()) {
1048     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
1049     return 0;
1050   }
1051
1052   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
1053   {
1054     char device[] = "/dev/sda";
1055     int r;
1056     suppress_error = 0;
1057     r = guestfs_blockdev_setrw (g, device);
1058     if (r == -1)
1059       return -1;
1060   }
1061   {
1062     int r;
1063     suppress_error = 0;
1064     r = guestfs_umount_all (g);
1065     if (r == -1)
1066       return -1;
1067   }
1068   {
1069     int r;
1070     suppress_error = 0;
1071     r = guestfs_lvm_remove_all (g);
1072     if (r == -1)
1073       return -1;
1074   }
1075   {
1076     char device[] = "/dev/sda";
1077     char lines_0[] = ",";
1078     char *lines[] = {
1079       lines_0,
1080       NULL
1081     };
1082     int r;
1083     suppress_error = 0;
1084     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1085     if (r == -1)
1086       return -1;
1087   }
1088   {
1089     char fstype[] = "ext2";
1090     char device[] = "/dev/sda1";
1091     int r;
1092     suppress_error = 0;
1093     r = guestfs_mkfs (g, fstype, device);
1094     if (r == -1)
1095       return -1;
1096   }
1097   {
1098     char device[] = "/dev/sda1";
1099     char mountpoint[] = "/";
1100     int r;
1101     suppress_error = 0;
1102     r = guestfs_mount (g, device, mountpoint);
1103     if (r == -1)
1104       return -1;
1105   }
1106   /* TestOutputList for find (2) */
1107   {
1108     char path[] = "/a/b/c";
1109     int r;
1110     suppress_error = 0;
1111     r = guestfs_mkdir_p (g, path);
1112     if (r == -1)
1113       return -1;
1114   }
1115   {
1116     char path[] = "/a/b/c/d";
1117     int r;
1118     suppress_error = 0;
1119     r = guestfs_touch (g, path);
1120     if (r == -1)
1121       return -1;
1122   }
1123   {
1124     char directory[] = "/a/b/";
1125     char **r;
1126     int i;
1127     suppress_error = 0;
1128     r = guestfs_find (g, directory);
1129     if (r == NULL)
1130       return -1;
1131     if (!r[0]) {
1132       fprintf (stderr, "test_find_2: short list returned from command\n");
1133       print_strings (r);
1134       return -1;
1135     }
1136     {
1137       char expected[] = "c";
1138       if (strcmp (r[0], expected) != 0) {
1139         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1140         return -1;
1141       }
1142     }
1143     if (!r[1]) {
1144       fprintf (stderr, "test_find_2: short list returned from command\n");
1145       print_strings (r);
1146       return -1;
1147     }
1148     {
1149       char expected[] = "c/d";
1150       if (strcmp (r[1], expected) != 0) {
1151         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1152         return -1;
1153       }
1154     }
1155     if (r[2] != NULL) {
1156       fprintf (stderr, "test_find_2: extra elements returned from command\n");
1157       print_strings (r);
1158       return -1;
1159     }
1160     for (i = 0; r[i] != NULL; ++i)
1161       free (r[i]);
1162     free (r);
1163   }
1164   return 0;
1165 }
1166
1167 static int test_lvresize_0_skip (void)
1168 {
1169   const char *str;
1170
1171   str = getenv ("SKIP_TEST_LVRESIZE_0");
1172   if (str && strcmp (str, "1") == 0) return 1;
1173   str = getenv ("SKIP_TEST_LVRESIZE");
1174   if (str && strcmp (str, "1") == 0) return 1;
1175   return 0;
1176 }
1177
1178 static int test_lvresize_0 (void)
1179 {
1180   if (test_lvresize_0_skip ()) {
1181     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
1182     return 0;
1183   }
1184
1185   /* InitNone|InitEmpty for test_lvresize_0 */
1186   {
1187     char device[] = "/dev/sda";
1188     int r;
1189     suppress_error = 0;
1190     r = guestfs_blockdev_setrw (g, device);
1191     if (r == -1)
1192       return -1;
1193   }
1194   {
1195     int r;
1196     suppress_error = 0;
1197     r = guestfs_umount_all (g);
1198     if (r == -1)
1199       return -1;
1200   }
1201   {
1202     int r;
1203     suppress_error = 0;
1204     r = guestfs_lvm_remove_all (g);
1205     if (r == -1)
1206       return -1;
1207   }
1208   /* TestOutput for lvresize (0) */
1209   char expected[] = "test content";
1210   {
1211     char device[] = "/dev/sda";
1212     char lines_0[] = ",";
1213     char *lines[] = {
1214       lines_0,
1215       NULL
1216     };
1217     int r;
1218     suppress_error = 0;
1219     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1220     if (r == -1)
1221       return -1;
1222   }
1223   {
1224     char device[] = "/dev/sda1";
1225     int r;
1226     suppress_error = 0;
1227     r = guestfs_pvcreate (g, device);
1228     if (r == -1)
1229       return -1;
1230   }
1231   {
1232     char volgroup[] = "VG";
1233     char physvols_0[] = "/dev/sda1";
1234     char *physvols[] = {
1235       physvols_0,
1236       NULL
1237     };
1238     int r;
1239     suppress_error = 0;
1240     r = guestfs_vgcreate (g, volgroup, physvols);
1241     if (r == -1)
1242       return -1;
1243   }
1244   {
1245     char logvol[] = "LV";
1246     char volgroup[] = "VG";
1247     int r;
1248     suppress_error = 0;
1249     r = guestfs_lvcreate (g, logvol, volgroup, 10);
1250     if (r == -1)
1251       return -1;
1252   }
1253   {
1254     char fstype[] = "ext2";
1255     char device[] = "/dev/VG/LV";
1256     int r;
1257     suppress_error = 0;
1258     r = guestfs_mkfs (g, fstype, device);
1259     if (r == -1)
1260       return -1;
1261   }
1262   {
1263     char device[] = "/dev/VG/LV";
1264     char mountpoint[] = "/";
1265     int r;
1266     suppress_error = 0;
1267     r = guestfs_mount (g, device, mountpoint);
1268     if (r == -1)
1269       return -1;
1270   }
1271   {
1272     char path[] = "/new";
1273     char content[] = "test content";
1274     int r;
1275     suppress_error = 0;
1276     r = guestfs_write_file (g, path, content, 0);
1277     if (r == -1)
1278       return -1;
1279   }
1280   {
1281     char pathordevice[] = "/";
1282     int r;
1283     suppress_error = 0;
1284     r = guestfs_umount (g, pathordevice);
1285     if (r == -1)
1286       return -1;
1287   }
1288   {
1289     char device[] = "/dev/VG/LV";
1290     int r;
1291     suppress_error = 0;
1292     r = guestfs_lvresize (g, device, 20);
1293     if (r == -1)
1294       return -1;
1295   }
1296   {
1297     char device[] = "/dev/VG/LV";
1298     int r;
1299     suppress_error = 0;
1300     r = guestfs_e2fsck_f (g, device);
1301     if (r == -1)
1302       return -1;
1303   }
1304   {
1305     char device[] = "/dev/VG/LV";
1306     int r;
1307     suppress_error = 0;
1308     r = guestfs_resize2fs (g, device);
1309     if (r == -1)
1310       return -1;
1311   }
1312   {
1313     char device[] = "/dev/VG/LV";
1314     char mountpoint[] = "/";
1315     int r;
1316     suppress_error = 0;
1317     r = guestfs_mount (g, device, mountpoint);
1318     if (r == -1)
1319       return -1;
1320   }
1321   {
1322     char path[] = "/new";
1323     char *r;
1324     suppress_error = 0;
1325     r = guestfs_cat (g, path);
1326     if (r == NULL)
1327       return -1;
1328     if (strcmp (r, expected) != 0) {
1329       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
1330       return -1;
1331     }
1332     free (r);
1333   }
1334   return 0;
1335 }
1336
1337 static int test_zerofree_0_skip (void)
1338 {
1339   const char *str;
1340
1341   str = getenv ("SKIP_TEST_ZEROFREE_0");
1342   if (str && strcmp (str, "1") == 0) return 1;
1343   str = getenv ("SKIP_TEST_ZEROFREE");
1344   if (str && strcmp (str, "1") == 0) return 1;
1345   return 0;
1346 }
1347
1348 static int test_zerofree_0 (void)
1349 {
1350   if (test_zerofree_0_skip ()) {
1351     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
1352     return 0;
1353   }
1354
1355   /* InitNone|InitEmpty for test_zerofree_0 */
1356   {
1357     char device[] = "/dev/sda";
1358     int r;
1359     suppress_error = 0;
1360     r = guestfs_blockdev_setrw (g, device);
1361     if (r == -1)
1362       return -1;
1363   }
1364   {
1365     int r;
1366     suppress_error = 0;
1367     r = guestfs_umount_all (g);
1368     if (r == -1)
1369       return -1;
1370   }
1371   {
1372     int r;
1373     suppress_error = 0;
1374     r = guestfs_lvm_remove_all (g);
1375     if (r == -1)
1376       return -1;
1377   }
1378   /* TestOutput for zerofree (0) */
1379   char expected[] = "test file";
1380   {
1381     char device[] = "/dev/sda";
1382     char lines_0[] = ",";
1383     char *lines[] = {
1384       lines_0,
1385       NULL
1386     };
1387     int r;
1388     suppress_error = 0;
1389     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1390     if (r == -1)
1391       return -1;
1392   }
1393   {
1394     char fstype[] = "ext3";
1395     char device[] = "/dev/sda1";
1396     int r;
1397     suppress_error = 0;
1398     r = guestfs_mkfs (g, fstype, device);
1399     if (r == -1)
1400       return -1;
1401   }
1402   {
1403     char device[] = "/dev/sda1";
1404     char mountpoint[] = "/";
1405     int r;
1406     suppress_error = 0;
1407     r = guestfs_mount (g, device, mountpoint);
1408     if (r == -1)
1409       return -1;
1410   }
1411   {
1412     char path[] = "/new";
1413     char content[] = "test file";
1414     int r;
1415     suppress_error = 0;
1416     r = guestfs_write_file (g, path, content, 0);
1417     if (r == -1)
1418       return -1;
1419   }
1420   {
1421     char pathordevice[] = "/dev/sda1";
1422     int r;
1423     suppress_error = 0;
1424     r = guestfs_umount (g, pathordevice);
1425     if (r == -1)
1426       return -1;
1427   }
1428   {
1429     char device[] = "/dev/sda1";
1430     int r;
1431     suppress_error = 0;
1432     r = guestfs_zerofree (g, device);
1433     if (r == -1)
1434       return -1;
1435   }
1436   {
1437     char device[] = "/dev/sda1";
1438     char mountpoint[] = "/";
1439     int r;
1440     suppress_error = 0;
1441     r = guestfs_mount (g, device, mountpoint);
1442     if (r == -1)
1443       return -1;
1444   }
1445   {
1446     char path[] = "/new";
1447     char *r;
1448     suppress_error = 0;
1449     r = guestfs_cat (g, path);
1450     if (r == NULL)
1451       return -1;
1452     if (strcmp (r, expected) != 0) {
1453       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1454       return -1;
1455     }
1456     free (r);
1457   }
1458   return 0;
1459 }
1460
1461 static int test_hexdump_0_skip (void)
1462 {
1463   const char *str;
1464
1465   str = getenv ("SKIP_TEST_HEXDUMP_0");
1466   if (str && strcmp (str, "1") == 0) return 1;
1467   str = getenv ("SKIP_TEST_HEXDUMP");
1468   if (str && strcmp (str, "1") == 0) return 1;
1469   return 0;
1470 }
1471
1472 static int test_hexdump_0 (void)
1473 {
1474   if (test_hexdump_0_skip ()) {
1475     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1476     return 0;
1477   }
1478
1479   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1480   {
1481     char device[] = "/dev/sda";
1482     int r;
1483     suppress_error = 0;
1484     r = guestfs_blockdev_setrw (g, device);
1485     if (r == -1)
1486       return -1;
1487   }
1488   {
1489     int r;
1490     suppress_error = 0;
1491     r = guestfs_umount_all (g);
1492     if (r == -1)
1493       return -1;
1494   }
1495   {
1496     int r;
1497     suppress_error = 0;
1498     r = guestfs_lvm_remove_all (g);
1499     if (r == -1)
1500       return -1;
1501   }
1502   {
1503     char device[] = "/dev/sda";
1504     char lines_0[] = ",";
1505     char *lines[] = {
1506       lines_0,
1507       NULL
1508     };
1509     int r;
1510     suppress_error = 0;
1511     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1512     if (r == -1)
1513       return -1;
1514   }
1515   {
1516     char fstype[] = "ext2";
1517     char device[] = "/dev/sda1";
1518     int r;
1519     suppress_error = 0;
1520     r = guestfs_mkfs (g, fstype, device);
1521     if (r == -1)
1522       return -1;
1523   }
1524   {
1525     char device[] = "/dev/sda1";
1526     char mountpoint[] = "/";
1527     int r;
1528     suppress_error = 0;
1529     r = guestfs_mount (g, device, mountpoint);
1530     if (r == -1)
1531       return -1;
1532   }
1533   /* TestOutput for hexdump (0) */
1534   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
1535   {
1536     char path[] = "/new";
1537     char content[] = "hello\nworld\n";
1538     int r;
1539     suppress_error = 0;
1540     r = guestfs_write_file (g, path, content, 12);
1541     if (r == -1)
1542       return -1;
1543   }
1544   {
1545     char path[] = "/new";
1546     char *r;
1547     suppress_error = 0;
1548     r = guestfs_hexdump (g, path);
1549     if (r == NULL)
1550       return -1;
1551     if (strcmp (r, expected) != 0) {
1552       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1553       return -1;
1554     }
1555     free (r);
1556   }
1557   return 0;
1558 }
1559
1560 static int test_strings_e_0_skip (void)
1561 {
1562   const char *str;
1563
1564   str = getenv ("SKIP_TEST_STRINGS_E_0");
1565   if (str && strcmp (str, "1") == 0) return 1;
1566   str = getenv ("SKIP_TEST_STRINGS_E");
1567   if (str && strcmp (str, "1") == 0) return 1;
1568   return 0;
1569 }
1570
1571 static int test_strings_e_0 (void)
1572 {
1573   if (test_strings_e_0_skip ()) {
1574     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1575     return 0;
1576   }
1577
1578   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1579   {
1580     char device[] = "/dev/sda";
1581     int r;
1582     suppress_error = 0;
1583     r = guestfs_blockdev_setrw (g, device);
1584     if (r == -1)
1585       return -1;
1586   }
1587   {
1588     int r;
1589     suppress_error = 0;
1590     r = guestfs_umount_all (g);
1591     if (r == -1)
1592       return -1;
1593   }
1594   {
1595     int r;
1596     suppress_error = 0;
1597     r = guestfs_lvm_remove_all (g);
1598     if (r == -1)
1599       return -1;
1600   }
1601   {
1602     char device[] = "/dev/sda";
1603     char lines_0[] = ",";
1604     char *lines[] = {
1605       lines_0,
1606       NULL
1607     };
1608     int r;
1609     suppress_error = 0;
1610     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1611     if (r == -1)
1612       return -1;
1613   }
1614   {
1615     char fstype[] = "ext2";
1616     char device[] = "/dev/sda1";
1617     int r;
1618     suppress_error = 0;
1619     r = guestfs_mkfs (g, fstype, device);
1620     if (r == -1)
1621       return -1;
1622   }
1623   {
1624     char device[] = "/dev/sda1";
1625     char mountpoint[] = "/";
1626     int r;
1627     suppress_error = 0;
1628     r = guestfs_mount (g, device, mountpoint);
1629     if (r == -1)
1630       return -1;
1631   }
1632   /* TestOutputList for strings_e (0) */
1633   {
1634     char path[] = "/new";
1635     char content[] = "hello\nworld\n";
1636     int r;
1637     suppress_error = 0;
1638     r = guestfs_write_file (g, path, content, 0);
1639     if (r == -1)
1640       return -1;
1641   }
1642   {
1643     char encoding[] = "b";
1644     char path[] = "/new";
1645     char **r;
1646     int i;
1647     suppress_error = 0;
1648     r = guestfs_strings_e (g, encoding, path);
1649     if (r == NULL)
1650       return -1;
1651     if (r[0] != NULL) {
1652       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1653       print_strings (r);
1654       return -1;
1655     }
1656     for (i = 0; r[i] != NULL; ++i)
1657       free (r[i]);
1658     free (r);
1659   }
1660   return 0;
1661 }
1662
1663 static int test_strings_e_1_skip (void)
1664 {
1665   const char *str;
1666
1667   str = getenv ("SKIP_TEST_STRINGS_E_1");
1668   if (str && strcmp (str, "1") == 0) return 1;
1669   str = getenv ("SKIP_TEST_STRINGS_E");
1670   if (str && strcmp (str, "1") == 0) return 1;
1671   return 0;
1672 }
1673
1674 static int test_strings_e_1 (void)
1675 {
1676   if (test_strings_e_1_skip ()) {
1677     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1678     return 0;
1679   }
1680
1681   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1682   return 0;
1683 }
1684
1685 static int test_strings_0_skip (void)
1686 {
1687   const char *str;
1688
1689   str = getenv ("SKIP_TEST_STRINGS_0");
1690   if (str && strcmp (str, "1") == 0) return 1;
1691   str = getenv ("SKIP_TEST_STRINGS");
1692   if (str && strcmp (str, "1") == 0) return 1;
1693   return 0;
1694 }
1695
1696 static int test_strings_0 (void)
1697 {
1698   if (test_strings_0_skip ()) {
1699     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1700     return 0;
1701   }
1702
1703   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1704   {
1705     char device[] = "/dev/sda";
1706     int r;
1707     suppress_error = 0;
1708     r = guestfs_blockdev_setrw (g, device);
1709     if (r == -1)
1710       return -1;
1711   }
1712   {
1713     int r;
1714     suppress_error = 0;
1715     r = guestfs_umount_all (g);
1716     if (r == -1)
1717       return -1;
1718   }
1719   {
1720     int r;
1721     suppress_error = 0;
1722     r = guestfs_lvm_remove_all (g);
1723     if (r == -1)
1724       return -1;
1725   }
1726   {
1727     char device[] = "/dev/sda";
1728     char lines_0[] = ",";
1729     char *lines[] = {
1730       lines_0,
1731       NULL
1732     };
1733     int r;
1734     suppress_error = 0;
1735     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1736     if (r == -1)
1737       return -1;
1738   }
1739   {
1740     char fstype[] = "ext2";
1741     char device[] = "/dev/sda1";
1742     int r;
1743     suppress_error = 0;
1744     r = guestfs_mkfs (g, fstype, device);
1745     if (r == -1)
1746       return -1;
1747   }
1748   {
1749     char device[] = "/dev/sda1";
1750     char mountpoint[] = "/";
1751     int r;
1752     suppress_error = 0;
1753     r = guestfs_mount (g, device, mountpoint);
1754     if (r == -1)
1755       return -1;
1756   }
1757   /* TestOutputList for strings (0) */
1758   {
1759     char path[] = "/new";
1760     char content[] = "hello\nworld\n";
1761     int r;
1762     suppress_error = 0;
1763     r = guestfs_write_file (g, path, content, 0);
1764     if (r == -1)
1765       return -1;
1766   }
1767   {
1768     char path[] = "/new";
1769     char **r;
1770     int i;
1771     suppress_error = 0;
1772     r = guestfs_strings (g, path);
1773     if (r == NULL)
1774       return -1;
1775     if (!r[0]) {
1776       fprintf (stderr, "test_strings_0: short list returned from command\n");
1777       print_strings (r);
1778       return -1;
1779     }
1780     {
1781       char expected[] = "hello";
1782       if (strcmp (r[0], expected) != 0) {
1783         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1784         return -1;
1785       }
1786     }
1787     if (!r[1]) {
1788       fprintf (stderr, "test_strings_0: short list returned from command\n");
1789       print_strings (r);
1790       return -1;
1791     }
1792     {
1793       char expected[] = "world";
1794       if (strcmp (r[1], expected) != 0) {
1795         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1796         return -1;
1797       }
1798     }
1799     if (r[2] != NULL) {
1800       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1801       print_strings (r);
1802       return -1;
1803     }
1804     for (i = 0; r[i] != NULL; ++i)
1805       free (r[i]);
1806     free (r);
1807   }
1808   return 0;
1809 }
1810
1811 static int test_strings_1_skip (void)
1812 {
1813   const char *str;
1814
1815   str = getenv ("SKIP_TEST_STRINGS_1");
1816   if (str && strcmp (str, "1") == 0) return 1;
1817   str = getenv ("SKIP_TEST_STRINGS");
1818   if (str && strcmp (str, "1") == 0) return 1;
1819   return 0;
1820 }
1821
1822 static int test_strings_1 (void)
1823 {
1824   if (test_strings_1_skip ()) {
1825     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1826     return 0;
1827   }
1828
1829   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1830   {
1831     char device[] = "/dev/sda";
1832     int r;
1833     suppress_error = 0;
1834     r = guestfs_blockdev_setrw (g, device);
1835     if (r == -1)
1836       return -1;
1837   }
1838   {
1839     int r;
1840     suppress_error = 0;
1841     r = guestfs_umount_all (g);
1842     if (r == -1)
1843       return -1;
1844   }
1845   {
1846     int r;
1847     suppress_error = 0;
1848     r = guestfs_lvm_remove_all (g);
1849     if (r == -1)
1850       return -1;
1851   }
1852   {
1853     char device[] = "/dev/sda";
1854     char lines_0[] = ",";
1855     char *lines[] = {
1856       lines_0,
1857       NULL
1858     };
1859     int r;
1860     suppress_error = 0;
1861     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1862     if (r == -1)
1863       return -1;
1864   }
1865   {
1866     char fstype[] = "ext2";
1867     char device[] = "/dev/sda1";
1868     int r;
1869     suppress_error = 0;
1870     r = guestfs_mkfs (g, fstype, device);
1871     if (r == -1)
1872       return -1;
1873   }
1874   {
1875     char device[] = "/dev/sda1";
1876     char mountpoint[] = "/";
1877     int r;
1878     suppress_error = 0;
1879     r = guestfs_mount (g, device, mountpoint);
1880     if (r == -1)
1881       return -1;
1882   }
1883   /* TestOutputList for strings (1) */
1884   {
1885     char path[] = "/new";
1886     int r;
1887     suppress_error = 0;
1888     r = guestfs_touch (g, path);
1889     if (r == -1)
1890       return -1;
1891   }
1892   {
1893     char path[] = "/new";
1894     char **r;
1895     int i;
1896     suppress_error = 0;
1897     r = guestfs_strings (g, path);
1898     if (r == NULL)
1899       return -1;
1900     if (r[0] != NULL) {
1901       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1902       print_strings (r);
1903       return -1;
1904     }
1905     for (i = 0; r[i] != NULL; ++i)
1906       free (r[i]);
1907     free (r);
1908   }
1909   return 0;
1910 }
1911
1912 static int test_equal_0_skip (void)
1913 {
1914   const char *str;
1915
1916   str = getenv ("SKIP_TEST_EQUAL_0");
1917   if (str && strcmp (str, "1") == 0) return 1;
1918   str = getenv ("SKIP_TEST_EQUAL");
1919   if (str && strcmp (str, "1") == 0) return 1;
1920   return 0;
1921 }
1922
1923 static int test_equal_0 (void)
1924 {
1925   if (test_equal_0_skip ()) {
1926     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1927     return 0;
1928   }
1929
1930   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1931   {
1932     char device[] = "/dev/sda";
1933     int r;
1934     suppress_error = 0;
1935     r = guestfs_blockdev_setrw (g, device);
1936     if (r == -1)
1937       return -1;
1938   }
1939   {
1940     int r;
1941     suppress_error = 0;
1942     r = guestfs_umount_all (g);
1943     if (r == -1)
1944       return -1;
1945   }
1946   {
1947     int r;
1948     suppress_error = 0;
1949     r = guestfs_lvm_remove_all (g);
1950     if (r == -1)
1951       return -1;
1952   }
1953   {
1954     char device[] = "/dev/sda";
1955     char lines_0[] = ",";
1956     char *lines[] = {
1957       lines_0,
1958       NULL
1959     };
1960     int r;
1961     suppress_error = 0;
1962     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1963     if (r == -1)
1964       return -1;
1965   }
1966   {
1967     char fstype[] = "ext2";
1968     char device[] = "/dev/sda1";
1969     int r;
1970     suppress_error = 0;
1971     r = guestfs_mkfs (g, fstype, device);
1972     if (r == -1)
1973       return -1;
1974   }
1975   {
1976     char device[] = "/dev/sda1";
1977     char mountpoint[] = "/";
1978     int r;
1979     suppress_error = 0;
1980     r = guestfs_mount (g, device, mountpoint);
1981     if (r == -1)
1982       return -1;
1983   }
1984   /* TestOutputTrue for equal (0) */
1985   {
1986     char path[] = "/file1";
1987     char content[] = "contents of a file";
1988     int r;
1989     suppress_error = 0;
1990     r = guestfs_write_file (g, path, content, 0);
1991     if (r == -1)
1992       return -1;
1993   }
1994   {
1995     char src[] = "/file1";
1996     char dest[] = "/file2";
1997     int r;
1998     suppress_error = 0;
1999     r = guestfs_cp (g, src, dest);
2000     if (r == -1)
2001       return -1;
2002   }
2003   {
2004     char file1[] = "/file1";
2005     char file2[] = "/file2";
2006     int r;
2007     suppress_error = 0;
2008     r = guestfs_equal (g, file1, file2);
2009     if (r == -1)
2010       return -1;
2011     if (!r) {
2012       fprintf (stderr, "test_equal_0: expected true, got false\n");
2013       return -1;
2014     }
2015   }
2016   return 0;
2017 }
2018
2019 static int test_equal_1_skip (void)
2020 {
2021   const char *str;
2022
2023   str = getenv ("SKIP_TEST_EQUAL_1");
2024   if (str && strcmp (str, "1") == 0) return 1;
2025   str = getenv ("SKIP_TEST_EQUAL");
2026   if (str && strcmp (str, "1") == 0) return 1;
2027   return 0;
2028 }
2029
2030 static int test_equal_1 (void)
2031 {
2032   if (test_equal_1_skip ()) {
2033     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
2034     return 0;
2035   }
2036
2037   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2038   {
2039     char device[] = "/dev/sda";
2040     int r;
2041     suppress_error = 0;
2042     r = guestfs_blockdev_setrw (g, device);
2043     if (r == -1)
2044       return -1;
2045   }
2046   {
2047     int r;
2048     suppress_error = 0;
2049     r = guestfs_umount_all (g);
2050     if (r == -1)
2051       return -1;
2052   }
2053   {
2054     int r;
2055     suppress_error = 0;
2056     r = guestfs_lvm_remove_all (g);
2057     if (r == -1)
2058       return -1;
2059   }
2060   {
2061     char device[] = "/dev/sda";
2062     char lines_0[] = ",";
2063     char *lines[] = {
2064       lines_0,
2065       NULL
2066     };
2067     int r;
2068     suppress_error = 0;
2069     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2070     if (r == -1)
2071       return -1;
2072   }
2073   {
2074     char fstype[] = "ext2";
2075     char device[] = "/dev/sda1";
2076     int r;
2077     suppress_error = 0;
2078     r = guestfs_mkfs (g, fstype, device);
2079     if (r == -1)
2080       return -1;
2081   }
2082   {
2083     char device[] = "/dev/sda1";
2084     char mountpoint[] = "/";
2085     int r;
2086     suppress_error = 0;
2087     r = guestfs_mount (g, device, mountpoint);
2088     if (r == -1)
2089       return -1;
2090   }
2091   /* TestOutputFalse for equal (1) */
2092   {
2093     char path[] = "/file1";
2094     char content[] = "contents of a file";
2095     int r;
2096     suppress_error = 0;
2097     r = guestfs_write_file (g, path, content, 0);
2098     if (r == -1)
2099       return -1;
2100   }
2101   {
2102     char path[] = "/file2";
2103     char content[] = "contents of another file";
2104     int r;
2105     suppress_error = 0;
2106     r = guestfs_write_file (g, path, content, 0);
2107     if (r == -1)
2108       return -1;
2109   }
2110   {
2111     char file1[] = "/file1";
2112     char file2[] = "/file2";
2113     int r;
2114     suppress_error = 0;
2115     r = guestfs_equal (g, file1, file2);
2116     if (r == -1)
2117       return -1;
2118     if (r) {
2119       fprintf (stderr, "test_equal_1: expected false, got true\n");
2120       return -1;
2121     }
2122   }
2123   return 0;
2124 }
2125
2126 static int test_equal_2_skip (void)
2127 {
2128   const char *str;
2129
2130   str = getenv ("SKIP_TEST_EQUAL_2");
2131   if (str && strcmp (str, "1") == 0) return 1;
2132   str = getenv ("SKIP_TEST_EQUAL");
2133   if (str && strcmp (str, "1") == 0) return 1;
2134   return 0;
2135 }
2136
2137 static int test_equal_2 (void)
2138 {
2139   if (test_equal_2_skip ()) {
2140     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
2141     return 0;
2142   }
2143
2144   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
2145   {
2146     char device[] = "/dev/sda";
2147     int r;
2148     suppress_error = 0;
2149     r = guestfs_blockdev_setrw (g, device);
2150     if (r == -1)
2151       return -1;
2152   }
2153   {
2154     int r;
2155     suppress_error = 0;
2156     r = guestfs_umount_all (g);
2157     if (r == -1)
2158       return -1;
2159   }
2160   {
2161     int r;
2162     suppress_error = 0;
2163     r = guestfs_lvm_remove_all (g);
2164     if (r == -1)
2165       return -1;
2166   }
2167   {
2168     char device[] = "/dev/sda";
2169     char lines_0[] = ",";
2170     char *lines[] = {
2171       lines_0,
2172       NULL
2173     };
2174     int r;
2175     suppress_error = 0;
2176     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2177     if (r == -1)
2178       return -1;
2179   }
2180   {
2181     char fstype[] = "ext2";
2182     char device[] = "/dev/sda1";
2183     int r;
2184     suppress_error = 0;
2185     r = guestfs_mkfs (g, fstype, device);
2186     if (r == -1)
2187       return -1;
2188   }
2189   {
2190     char device[] = "/dev/sda1";
2191     char mountpoint[] = "/";
2192     int r;
2193     suppress_error = 0;
2194     r = guestfs_mount (g, device, mountpoint);
2195     if (r == -1)
2196       return -1;
2197   }
2198   /* TestLastFail for equal (2) */
2199   {
2200     char file1[] = "/file1";
2201     char file2[] = "/file2";
2202     int r;
2203     suppress_error = 1;
2204     r = guestfs_equal (g, file1, file2);
2205     if (r != -1)
2206       return -1;
2207   }
2208   return 0;
2209 }
2210
2211 static int test_ping_daemon_0_skip (void)
2212 {
2213   const char *str;
2214
2215   str = getenv ("SKIP_TEST_PING_DAEMON_0");
2216   if (str && strcmp (str, "1") == 0) return 1;
2217   str = getenv ("SKIP_TEST_PING_DAEMON");
2218   if (str && strcmp (str, "1") == 0) return 1;
2219   return 0;
2220 }
2221
2222 static int test_ping_daemon_0 (void)
2223 {
2224   if (test_ping_daemon_0_skip ()) {
2225     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
2226     return 0;
2227   }
2228
2229   /* InitNone|InitEmpty for test_ping_daemon_0 */
2230   {
2231     char device[] = "/dev/sda";
2232     int r;
2233     suppress_error = 0;
2234     r = guestfs_blockdev_setrw (g, device);
2235     if (r == -1)
2236       return -1;
2237   }
2238   {
2239     int r;
2240     suppress_error = 0;
2241     r = guestfs_umount_all (g);
2242     if (r == -1)
2243       return -1;
2244   }
2245   {
2246     int r;
2247     suppress_error = 0;
2248     r = guestfs_lvm_remove_all (g);
2249     if (r == -1)
2250       return -1;
2251   }
2252   /* TestRun for ping_daemon (0) */
2253   {
2254     int r;
2255     suppress_error = 0;
2256     r = guestfs_ping_daemon (g);
2257     if (r == -1)
2258       return -1;
2259   }
2260   return 0;
2261 }
2262
2263 static int test_dmesg_0_skip (void)
2264 {
2265   const char *str;
2266
2267   str = getenv ("SKIP_TEST_DMESG_0");
2268   if (str && strcmp (str, "1") == 0) return 1;
2269   str = getenv ("SKIP_TEST_DMESG");
2270   if (str && strcmp (str, "1") == 0) return 1;
2271   return 0;
2272 }
2273
2274 static int test_dmesg_0 (void)
2275 {
2276   if (test_dmesg_0_skip ()) {
2277     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
2278     return 0;
2279   }
2280
2281   /* InitNone|InitEmpty for test_dmesg_0 */
2282   {
2283     char device[] = "/dev/sda";
2284     int r;
2285     suppress_error = 0;
2286     r = guestfs_blockdev_setrw (g, device);
2287     if (r == -1)
2288       return -1;
2289   }
2290   {
2291     int r;
2292     suppress_error = 0;
2293     r = guestfs_umount_all (g);
2294     if (r == -1)
2295       return -1;
2296   }
2297   {
2298     int r;
2299     suppress_error = 0;
2300     r = guestfs_lvm_remove_all (g);
2301     if (r == -1)
2302       return -1;
2303   }
2304   /* TestRun for dmesg (0) */
2305   {
2306     char *r;
2307     suppress_error = 0;
2308     r = guestfs_dmesg (g);
2309     if (r == NULL)
2310       return -1;
2311     free (r);
2312   }
2313   return 0;
2314 }
2315
2316 static int test_drop_caches_0_skip (void)
2317 {
2318   const char *str;
2319
2320   str = getenv ("SKIP_TEST_DROP_CACHES_0");
2321   if (str && strcmp (str, "1") == 0) return 1;
2322   str = getenv ("SKIP_TEST_DROP_CACHES");
2323   if (str && strcmp (str, "1") == 0) return 1;
2324   return 0;
2325 }
2326
2327 static int test_drop_caches_0 (void)
2328 {
2329   if (test_drop_caches_0_skip ()) {
2330     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
2331     return 0;
2332   }
2333
2334   /* InitNone|InitEmpty for test_drop_caches_0 */
2335   {
2336     char device[] = "/dev/sda";
2337     int r;
2338     suppress_error = 0;
2339     r = guestfs_blockdev_setrw (g, device);
2340     if (r == -1)
2341       return -1;
2342   }
2343   {
2344     int r;
2345     suppress_error = 0;
2346     r = guestfs_umount_all (g);
2347     if (r == -1)
2348       return -1;
2349   }
2350   {
2351     int r;
2352     suppress_error = 0;
2353     r = guestfs_lvm_remove_all (g);
2354     if (r == -1)
2355       return -1;
2356   }
2357   /* TestRun for drop_caches (0) */
2358   {
2359     int r;
2360     suppress_error = 0;
2361     r = guestfs_drop_caches (g, 3);
2362     if (r == -1)
2363       return -1;
2364   }
2365   return 0;
2366 }
2367
2368 static int test_mv_0_skip (void)
2369 {
2370   const char *str;
2371
2372   str = getenv ("SKIP_TEST_MV_0");
2373   if (str && strcmp (str, "1") == 0) return 1;
2374   str = getenv ("SKIP_TEST_MV");
2375   if (str && strcmp (str, "1") == 0) return 1;
2376   return 0;
2377 }
2378
2379 static int test_mv_0 (void)
2380 {
2381   if (test_mv_0_skip ()) {
2382     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2383     return 0;
2384   }
2385
2386   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2387   {
2388     char device[] = "/dev/sda";
2389     int r;
2390     suppress_error = 0;
2391     r = guestfs_blockdev_setrw (g, device);
2392     if (r == -1)
2393       return -1;
2394   }
2395   {
2396     int r;
2397     suppress_error = 0;
2398     r = guestfs_umount_all (g);
2399     if (r == -1)
2400       return -1;
2401   }
2402   {
2403     int r;
2404     suppress_error = 0;
2405     r = guestfs_lvm_remove_all (g);
2406     if (r == -1)
2407       return -1;
2408   }
2409   {
2410     char device[] = "/dev/sda";
2411     char lines_0[] = ",";
2412     char *lines[] = {
2413       lines_0,
2414       NULL
2415     };
2416     int r;
2417     suppress_error = 0;
2418     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2419     if (r == -1)
2420       return -1;
2421   }
2422   {
2423     char fstype[] = "ext2";
2424     char device[] = "/dev/sda1";
2425     int r;
2426     suppress_error = 0;
2427     r = guestfs_mkfs (g, fstype, device);
2428     if (r == -1)
2429       return -1;
2430   }
2431   {
2432     char device[] = "/dev/sda1";
2433     char mountpoint[] = "/";
2434     int r;
2435     suppress_error = 0;
2436     r = guestfs_mount (g, device, mountpoint);
2437     if (r == -1)
2438       return -1;
2439   }
2440   /* TestOutput for mv (0) */
2441   char expected[] = "file content";
2442   {
2443     char path[] = "/old";
2444     char content[] = "file content";
2445     int r;
2446     suppress_error = 0;
2447     r = guestfs_write_file (g, path, content, 0);
2448     if (r == -1)
2449       return -1;
2450   }
2451   {
2452     char src[] = "/old";
2453     char dest[] = "/new";
2454     int r;
2455     suppress_error = 0;
2456     r = guestfs_mv (g, src, dest);
2457     if (r == -1)
2458       return -1;
2459   }
2460   {
2461     char path[] = "/new";
2462     char *r;
2463     suppress_error = 0;
2464     r = guestfs_cat (g, path);
2465     if (r == NULL)
2466       return -1;
2467     if (strcmp (r, expected) != 0) {
2468       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2469       return -1;
2470     }
2471     free (r);
2472   }
2473   return 0;
2474 }
2475
2476 static int test_mv_1_skip (void)
2477 {
2478   const char *str;
2479
2480   str = getenv ("SKIP_TEST_MV_1");
2481   if (str && strcmp (str, "1") == 0) return 1;
2482   str = getenv ("SKIP_TEST_MV");
2483   if (str && strcmp (str, "1") == 0) return 1;
2484   return 0;
2485 }
2486
2487 static int test_mv_1 (void)
2488 {
2489   if (test_mv_1_skip ()) {
2490     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2491     return 0;
2492   }
2493
2494   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2495   {
2496     char device[] = "/dev/sda";
2497     int r;
2498     suppress_error = 0;
2499     r = guestfs_blockdev_setrw (g, device);
2500     if (r == -1)
2501       return -1;
2502   }
2503   {
2504     int r;
2505     suppress_error = 0;
2506     r = guestfs_umount_all (g);
2507     if (r == -1)
2508       return -1;
2509   }
2510   {
2511     int r;
2512     suppress_error = 0;
2513     r = guestfs_lvm_remove_all (g);
2514     if (r == -1)
2515       return -1;
2516   }
2517   {
2518     char device[] = "/dev/sda";
2519     char lines_0[] = ",";
2520     char *lines[] = {
2521       lines_0,
2522       NULL
2523     };
2524     int r;
2525     suppress_error = 0;
2526     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2527     if (r == -1)
2528       return -1;
2529   }
2530   {
2531     char fstype[] = "ext2";
2532     char device[] = "/dev/sda1";
2533     int r;
2534     suppress_error = 0;
2535     r = guestfs_mkfs (g, fstype, device);
2536     if (r == -1)
2537       return -1;
2538   }
2539   {
2540     char device[] = "/dev/sda1";
2541     char mountpoint[] = "/";
2542     int r;
2543     suppress_error = 0;
2544     r = guestfs_mount (g, device, mountpoint);
2545     if (r == -1)
2546       return -1;
2547   }
2548   /* TestOutputFalse for mv (1) */
2549   {
2550     char path[] = "/old";
2551     char content[] = "file content";
2552     int r;
2553     suppress_error = 0;
2554     r = guestfs_write_file (g, path, content, 0);
2555     if (r == -1)
2556       return -1;
2557   }
2558   {
2559     char src[] = "/old";
2560     char dest[] = "/new";
2561     int r;
2562     suppress_error = 0;
2563     r = guestfs_mv (g, src, dest);
2564     if (r == -1)
2565       return -1;
2566   }
2567   {
2568     char path[] = "/old";
2569     int r;
2570     suppress_error = 0;
2571     r = guestfs_is_file (g, path);
2572     if (r == -1)
2573       return -1;
2574     if (r) {
2575       fprintf (stderr, "test_mv_1: expected false, got true\n");
2576       return -1;
2577     }
2578   }
2579   return 0;
2580 }
2581
2582 static int test_cp_a_0_skip (void)
2583 {
2584   const char *str;
2585
2586   str = getenv ("SKIP_TEST_CP_A_0");
2587   if (str && strcmp (str, "1") == 0) return 1;
2588   str = getenv ("SKIP_TEST_CP_A");
2589   if (str && strcmp (str, "1") == 0) return 1;
2590   return 0;
2591 }
2592
2593 static int test_cp_a_0 (void)
2594 {
2595   if (test_cp_a_0_skip ()) {
2596     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2597     return 0;
2598   }
2599
2600   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2601   {
2602     char device[] = "/dev/sda";
2603     int r;
2604     suppress_error = 0;
2605     r = guestfs_blockdev_setrw (g, device);
2606     if (r == -1)
2607       return -1;
2608   }
2609   {
2610     int r;
2611     suppress_error = 0;
2612     r = guestfs_umount_all (g);
2613     if (r == -1)
2614       return -1;
2615   }
2616   {
2617     int r;
2618     suppress_error = 0;
2619     r = guestfs_lvm_remove_all (g);
2620     if (r == -1)
2621       return -1;
2622   }
2623   {
2624     char device[] = "/dev/sda";
2625     char lines_0[] = ",";
2626     char *lines[] = {
2627       lines_0,
2628       NULL
2629     };
2630     int r;
2631     suppress_error = 0;
2632     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2633     if (r == -1)
2634       return -1;
2635   }
2636   {
2637     char fstype[] = "ext2";
2638     char device[] = "/dev/sda1";
2639     int r;
2640     suppress_error = 0;
2641     r = guestfs_mkfs (g, fstype, device);
2642     if (r == -1)
2643       return -1;
2644   }
2645   {
2646     char device[] = "/dev/sda1";
2647     char mountpoint[] = "/";
2648     int r;
2649     suppress_error = 0;
2650     r = guestfs_mount (g, device, mountpoint);
2651     if (r == -1)
2652       return -1;
2653   }
2654   /* TestOutput for cp_a (0) */
2655   char expected[] = "file content";
2656   {
2657     char path[] = "/olddir";
2658     int r;
2659     suppress_error = 0;
2660     r = guestfs_mkdir (g, path);
2661     if (r == -1)
2662       return -1;
2663   }
2664   {
2665     char path[] = "/newdir";
2666     int r;
2667     suppress_error = 0;
2668     r = guestfs_mkdir (g, path);
2669     if (r == -1)
2670       return -1;
2671   }
2672   {
2673     char path[] = "/olddir/file";
2674     char content[] = "file content";
2675     int r;
2676     suppress_error = 0;
2677     r = guestfs_write_file (g, path, content, 0);
2678     if (r == -1)
2679       return -1;
2680   }
2681   {
2682     char src[] = "/olddir";
2683     char dest[] = "/newdir";
2684     int r;
2685     suppress_error = 0;
2686     r = guestfs_cp_a (g, src, dest);
2687     if (r == -1)
2688       return -1;
2689   }
2690   {
2691     char path[] = "/newdir/olddir/file";
2692     char *r;
2693     suppress_error = 0;
2694     r = guestfs_cat (g, path);
2695     if (r == NULL)
2696       return -1;
2697     if (strcmp (r, expected) != 0) {
2698       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2699       return -1;
2700     }
2701     free (r);
2702   }
2703   return 0;
2704 }
2705
2706 static int test_cp_0_skip (void)
2707 {
2708   const char *str;
2709
2710   str = getenv ("SKIP_TEST_CP_0");
2711   if (str && strcmp (str, "1") == 0) return 1;
2712   str = getenv ("SKIP_TEST_CP");
2713   if (str && strcmp (str, "1") == 0) return 1;
2714   return 0;
2715 }
2716
2717 static int test_cp_0 (void)
2718 {
2719   if (test_cp_0_skip ()) {
2720     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2721     return 0;
2722   }
2723
2724   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2725   {
2726     char device[] = "/dev/sda";
2727     int r;
2728     suppress_error = 0;
2729     r = guestfs_blockdev_setrw (g, device);
2730     if (r == -1)
2731       return -1;
2732   }
2733   {
2734     int r;
2735     suppress_error = 0;
2736     r = guestfs_umount_all (g);
2737     if (r == -1)
2738       return -1;
2739   }
2740   {
2741     int r;
2742     suppress_error = 0;
2743     r = guestfs_lvm_remove_all (g);
2744     if (r == -1)
2745       return -1;
2746   }
2747   {
2748     char device[] = "/dev/sda";
2749     char lines_0[] = ",";
2750     char *lines[] = {
2751       lines_0,
2752       NULL
2753     };
2754     int r;
2755     suppress_error = 0;
2756     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2757     if (r == -1)
2758       return -1;
2759   }
2760   {
2761     char fstype[] = "ext2";
2762     char device[] = "/dev/sda1";
2763     int r;
2764     suppress_error = 0;
2765     r = guestfs_mkfs (g, fstype, device);
2766     if (r == -1)
2767       return -1;
2768   }
2769   {
2770     char device[] = "/dev/sda1";
2771     char mountpoint[] = "/";
2772     int r;
2773     suppress_error = 0;
2774     r = guestfs_mount (g, device, mountpoint);
2775     if (r == -1)
2776       return -1;
2777   }
2778   /* TestOutput for cp (0) */
2779   char expected[] = "file content";
2780   {
2781     char path[] = "/old";
2782     char content[] = "file content";
2783     int r;
2784     suppress_error = 0;
2785     r = guestfs_write_file (g, path, content, 0);
2786     if (r == -1)
2787       return -1;
2788   }
2789   {
2790     char src[] = "/old";
2791     char dest[] = "/new";
2792     int r;
2793     suppress_error = 0;
2794     r = guestfs_cp (g, src, dest);
2795     if (r == -1)
2796       return -1;
2797   }
2798   {
2799     char path[] = "/new";
2800     char *r;
2801     suppress_error = 0;
2802     r = guestfs_cat (g, path);
2803     if (r == NULL)
2804       return -1;
2805     if (strcmp (r, expected) != 0) {
2806       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2807       return -1;
2808     }
2809     free (r);
2810   }
2811   return 0;
2812 }
2813
2814 static int test_cp_1_skip (void)
2815 {
2816   const char *str;
2817
2818   str = getenv ("SKIP_TEST_CP_1");
2819   if (str && strcmp (str, "1") == 0) return 1;
2820   str = getenv ("SKIP_TEST_CP");
2821   if (str && strcmp (str, "1") == 0) return 1;
2822   return 0;
2823 }
2824
2825 static int test_cp_1 (void)
2826 {
2827   if (test_cp_1_skip ()) {
2828     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2829     return 0;
2830   }
2831
2832   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2833   {
2834     char device[] = "/dev/sda";
2835     int r;
2836     suppress_error = 0;
2837     r = guestfs_blockdev_setrw (g, device);
2838     if (r == -1)
2839       return -1;
2840   }
2841   {
2842     int r;
2843     suppress_error = 0;
2844     r = guestfs_umount_all (g);
2845     if (r == -1)
2846       return -1;
2847   }
2848   {
2849     int r;
2850     suppress_error = 0;
2851     r = guestfs_lvm_remove_all (g);
2852     if (r == -1)
2853       return -1;
2854   }
2855   {
2856     char device[] = "/dev/sda";
2857     char lines_0[] = ",";
2858     char *lines[] = {
2859       lines_0,
2860       NULL
2861     };
2862     int r;
2863     suppress_error = 0;
2864     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2865     if (r == -1)
2866       return -1;
2867   }
2868   {
2869     char fstype[] = "ext2";
2870     char device[] = "/dev/sda1";
2871     int r;
2872     suppress_error = 0;
2873     r = guestfs_mkfs (g, fstype, device);
2874     if (r == -1)
2875       return -1;
2876   }
2877   {
2878     char device[] = "/dev/sda1";
2879     char mountpoint[] = "/";
2880     int r;
2881     suppress_error = 0;
2882     r = guestfs_mount (g, device, mountpoint);
2883     if (r == -1)
2884       return -1;
2885   }
2886   /* TestOutputTrue for cp (1) */
2887   {
2888     char path[] = "/old";
2889     char content[] = "file content";
2890     int r;
2891     suppress_error = 0;
2892     r = guestfs_write_file (g, path, content, 0);
2893     if (r == -1)
2894       return -1;
2895   }
2896   {
2897     char src[] = "/old";
2898     char dest[] = "/new";
2899     int r;
2900     suppress_error = 0;
2901     r = guestfs_cp (g, src, dest);
2902     if (r == -1)
2903       return -1;
2904   }
2905   {
2906     char path[] = "/old";
2907     int r;
2908     suppress_error = 0;
2909     r = guestfs_is_file (g, path);
2910     if (r == -1)
2911       return -1;
2912     if (!r) {
2913       fprintf (stderr, "test_cp_1: expected true, got false\n");
2914       return -1;
2915     }
2916   }
2917   return 0;
2918 }
2919
2920 static int test_cp_2_skip (void)
2921 {
2922   const char *str;
2923
2924   str = getenv ("SKIP_TEST_CP_2");
2925   if (str && strcmp (str, "1") == 0) return 1;
2926   str = getenv ("SKIP_TEST_CP");
2927   if (str && strcmp (str, "1") == 0) return 1;
2928   return 0;
2929 }
2930
2931 static int test_cp_2 (void)
2932 {
2933   if (test_cp_2_skip ()) {
2934     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2935     return 0;
2936   }
2937
2938   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2939   {
2940     char device[] = "/dev/sda";
2941     int r;
2942     suppress_error = 0;
2943     r = guestfs_blockdev_setrw (g, device);
2944     if (r == -1)
2945       return -1;
2946   }
2947   {
2948     int r;
2949     suppress_error = 0;
2950     r = guestfs_umount_all (g);
2951     if (r == -1)
2952       return -1;
2953   }
2954   {
2955     int r;
2956     suppress_error = 0;
2957     r = guestfs_lvm_remove_all (g);
2958     if (r == -1)
2959       return -1;
2960   }
2961   {
2962     char device[] = "/dev/sda";
2963     char lines_0[] = ",";
2964     char *lines[] = {
2965       lines_0,
2966       NULL
2967     };
2968     int r;
2969     suppress_error = 0;
2970     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2971     if (r == -1)
2972       return -1;
2973   }
2974   {
2975     char fstype[] = "ext2";
2976     char device[] = "/dev/sda1";
2977     int r;
2978     suppress_error = 0;
2979     r = guestfs_mkfs (g, fstype, device);
2980     if (r == -1)
2981       return -1;
2982   }
2983   {
2984     char device[] = "/dev/sda1";
2985     char mountpoint[] = "/";
2986     int r;
2987     suppress_error = 0;
2988     r = guestfs_mount (g, device, mountpoint);
2989     if (r == -1)
2990       return -1;
2991   }
2992   /* TestOutput for cp (2) */
2993   char expected[] = "file content";
2994   {
2995     char path[] = "/old";
2996     char content[] = "file content";
2997     int r;
2998     suppress_error = 0;
2999     r = guestfs_write_file (g, path, content, 0);
3000     if (r == -1)
3001       return -1;
3002   }
3003   {
3004     char path[] = "/dir";
3005     int r;
3006     suppress_error = 0;
3007     r = guestfs_mkdir (g, path);
3008     if (r == -1)
3009       return -1;
3010   }
3011   {
3012     char src[] = "/old";
3013     char dest[] = "/dir/new";
3014     int r;
3015     suppress_error = 0;
3016     r = guestfs_cp (g, src, dest);
3017     if (r == -1)
3018       return -1;
3019   }
3020   {
3021     char path[] = "/dir/new";
3022     char *r;
3023     suppress_error = 0;
3024     r = guestfs_cat (g, path);
3025     if (r == NULL)
3026       return -1;
3027     if (strcmp (r, expected) != 0) {
3028       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3029       return -1;
3030     }
3031     free (r);
3032   }
3033   return 0;
3034 }
3035
3036 static int test_grub_install_0_skip (void)
3037 {
3038   const char *str;
3039
3040   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3041   if (str && strcmp (str, "1") == 0) return 1;
3042   str = getenv ("SKIP_TEST_GRUB_INSTALL");
3043   if (str && strcmp (str, "1") == 0) return 1;
3044   return 0;
3045 }
3046
3047 static int test_grub_install_0 (void)
3048 {
3049   if (test_grub_install_0_skip ()) {
3050     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
3051     return 0;
3052   }
3053
3054   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3055   {
3056     char device[] = "/dev/sda";
3057     int r;
3058     suppress_error = 0;
3059     r = guestfs_blockdev_setrw (g, device);
3060     if (r == -1)
3061       return -1;
3062   }
3063   {
3064     int r;
3065     suppress_error = 0;
3066     r = guestfs_umount_all (g);
3067     if (r == -1)
3068       return -1;
3069   }
3070   {
3071     int r;
3072     suppress_error = 0;
3073     r = guestfs_lvm_remove_all (g);
3074     if (r == -1)
3075       return -1;
3076   }
3077   {
3078     char device[] = "/dev/sda";
3079     char lines_0[] = ",";
3080     char *lines[] = {
3081       lines_0,
3082       NULL
3083     };
3084     int r;
3085     suppress_error = 0;
3086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3087     if (r == -1)
3088       return -1;
3089   }
3090   {
3091     char fstype[] = "ext2";
3092     char device[] = "/dev/sda1";
3093     int r;
3094     suppress_error = 0;
3095     r = guestfs_mkfs (g, fstype, device);
3096     if (r == -1)
3097       return -1;
3098   }
3099   {
3100     char device[] = "/dev/sda1";
3101     char mountpoint[] = "/";
3102     int r;
3103     suppress_error = 0;
3104     r = guestfs_mount (g, device, mountpoint);
3105     if (r == -1)
3106       return -1;
3107   }
3108   /* TestOutputTrue for grub_install (0) */
3109   {
3110     char root[] = "/";
3111     char device[] = "/dev/sda1";
3112     int r;
3113     suppress_error = 0;
3114     r = guestfs_grub_install (g, root, device);
3115     if (r == -1)
3116       return -1;
3117   }
3118   {
3119     char path[] = "/boot";
3120     int r;
3121     suppress_error = 0;
3122     r = guestfs_is_dir (g, path);
3123     if (r == -1)
3124       return -1;
3125     if (!r) {
3126       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3127       return -1;
3128     }
3129   }
3130   return 0;
3131 }
3132
3133 static int test_zero_0_skip (void)
3134 {
3135   const char *str;
3136
3137   str = getenv ("SKIP_TEST_ZERO_0");
3138   if (str && strcmp (str, "1") == 0) return 1;
3139   str = getenv ("SKIP_TEST_ZERO");
3140   if (str && strcmp (str, "1") == 0) return 1;
3141   return 0;
3142 }
3143
3144 static int test_zero_0 (void)
3145 {
3146   if (test_zero_0_skip ()) {
3147     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
3148     return 0;
3149   }
3150
3151   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3152   {
3153     char device[] = "/dev/sda";
3154     int r;
3155     suppress_error = 0;
3156     r = guestfs_blockdev_setrw (g, device);
3157     if (r == -1)
3158       return -1;
3159   }
3160   {
3161     int r;
3162     suppress_error = 0;
3163     r = guestfs_umount_all (g);
3164     if (r == -1)
3165       return -1;
3166   }
3167   {
3168     int r;
3169     suppress_error = 0;
3170     r = guestfs_lvm_remove_all (g);
3171     if (r == -1)
3172       return -1;
3173   }
3174   {
3175     char device[] = "/dev/sda";
3176     char lines_0[] = ",";
3177     char *lines[] = {
3178       lines_0,
3179       NULL
3180     };
3181     int r;
3182     suppress_error = 0;
3183     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3184     if (r == -1)
3185       return -1;
3186   }
3187   {
3188     char fstype[] = "ext2";
3189     char device[] = "/dev/sda1";
3190     int r;
3191     suppress_error = 0;
3192     r = guestfs_mkfs (g, fstype, device);
3193     if (r == -1)
3194       return -1;
3195   }
3196   {
3197     char device[] = "/dev/sda1";
3198     char mountpoint[] = "/";
3199     int r;
3200     suppress_error = 0;
3201     r = guestfs_mount (g, device, mountpoint);
3202     if (r == -1)
3203       return -1;
3204   }
3205   /* TestOutput for zero (0) */
3206   char expected[] = "data";
3207   {
3208     char pathordevice[] = "/dev/sda1";
3209     int r;
3210     suppress_error = 0;
3211     r = guestfs_umount (g, pathordevice);
3212     if (r == -1)
3213       return -1;
3214   }
3215   {
3216     char device[] = "/dev/sda1";
3217     int r;
3218     suppress_error = 0;
3219     r = guestfs_zero (g, device);
3220     if (r == -1)
3221       return -1;
3222   }
3223   {
3224     char path[] = "/dev/sda1";
3225     char *r;
3226     suppress_error = 0;
3227     r = guestfs_file (g, path);
3228     if (r == NULL)
3229       return -1;
3230     if (strcmp (r, expected) != 0) {
3231       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3232       return -1;
3233     }
3234     free (r);
3235   }
3236   return 0;
3237 }
3238
3239 static int test_fsck_0_skip (void)
3240 {
3241   const char *str;
3242
3243   str = getenv ("SKIP_TEST_FSCK_0");
3244   if (str && strcmp (str, "1") == 0) return 1;
3245   str = getenv ("SKIP_TEST_FSCK");
3246   if (str && strcmp (str, "1") == 0) return 1;
3247   return 0;
3248 }
3249
3250 static int test_fsck_0 (void)
3251 {
3252   if (test_fsck_0_skip ()) {
3253     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
3254     return 0;
3255   }
3256
3257   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
3258   {
3259     char device[] = "/dev/sda";
3260     int r;
3261     suppress_error = 0;
3262     r = guestfs_blockdev_setrw (g, device);
3263     if (r == -1)
3264       return -1;
3265   }
3266   {
3267     int r;
3268     suppress_error = 0;
3269     r = guestfs_umount_all (g);
3270     if (r == -1)
3271       return -1;
3272   }
3273   {
3274     int r;
3275     suppress_error = 0;
3276     r = guestfs_lvm_remove_all (g);
3277     if (r == -1)
3278       return -1;
3279   }
3280   {
3281     char device[] = "/dev/sda";
3282     char lines_0[] = ",";
3283     char *lines[] = {
3284       lines_0,
3285       NULL
3286     };
3287     int r;
3288     suppress_error = 0;
3289     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3290     if (r == -1)
3291       return -1;
3292   }
3293   {
3294     char fstype[] = "ext2";
3295     char device[] = "/dev/sda1";
3296     int r;
3297     suppress_error = 0;
3298     r = guestfs_mkfs (g, fstype, device);
3299     if (r == -1)
3300       return -1;
3301   }
3302   {
3303     char device[] = "/dev/sda1";
3304     char mountpoint[] = "/";
3305     int r;
3306     suppress_error = 0;
3307     r = guestfs_mount (g, device, mountpoint);
3308     if (r == -1)
3309       return -1;
3310   }
3311   /* TestOutputInt for fsck (0) */
3312   {
3313     char pathordevice[] = "/dev/sda1";
3314     int r;
3315     suppress_error = 0;
3316     r = guestfs_umount (g, pathordevice);
3317     if (r == -1)
3318       return -1;
3319   }
3320   {
3321     char fstype[] = "ext2";
3322     char device[] = "/dev/sda1";
3323     int r;
3324     suppress_error = 0;
3325     r = guestfs_fsck (g, fstype, device);
3326     if (r == -1)
3327       return -1;
3328     if (r != 0) {
3329       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
3330       return -1;
3331     }
3332   }
3333   return 0;
3334 }
3335
3336 static int test_fsck_1_skip (void)
3337 {
3338   const char *str;
3339
3340   str = getenv ("SKIP_TEST_FSCK_1");
3341   if (str && strcmp (str, "1") == 0) return 1;
3342   str = getenv ("SKIP_TEST_FSCK");
3343   if (str && strcmp (str, "1") == 0) return 1;
3344   return 0;
3345 }
3346
3347 static int test_fsck_1 (void)
3348 {
3349   if (test_fsck_1_skip ()) {
3350     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3351     return 0;
3352   }
3353
3354   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3355   {
3356     char device[] = "/dev/sda";
3357     int r;
3358     suppress_error = 0;
3359     r = guestfs_blockdev_setrw (g, device);
3360     if (r == -1)
3361       return -1;
3362   }
3363   {
3364     int r;
3365     suppress_error = 0;
3366     r = guestfs_umount_all (g);
3367     if (r == -1)
3368       return -1;
3369   }
3370   {
3371     int r;
3372     suppress_error = 0;
3373     r = guestfs_lvm_remove_all (g);
3374     if (r == -1)
3375       return -1;
3376   }
3377   {
3378     char device[] = "/dev/sda";
3379     char lines_0[] = ",";
3380     char *lines[] = {
3381       lines_0,
3382       NULL
3383     };
3384     int r;
3385     suppress_error = 0;
3386     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3387     if (r == -1)
3388       return -1;
3389   }
3390   {
3391     char fstype[] = "ext2";
3392     char device[] = "/dev/sda1";
3393     int r;
3394     suppress_error = 0;
3395     r = guestfs_mkfs (g, fstype, device);
3396     if (r == -1)
3397       return -1;
3398   }
3399   {
3400     char device[] = "/dev/sda1";
3401     char mountpoint[] = "/";
3402     int r;
3403     suppress_error = 0;
3404     r = guestfs_mount (g, device, mountpoint);
3405     if (r == -1)
3406       return -1;
3407   }
3408   /* TestOutputInt for fsck (1) */
3409   {
3410     char pathordevice[] = "/dev/sda1";
3411     int r;
3412     suppress_error = 0;
3413     r = guestfs_umount (g, pathordevice);
3414     if (r == -1)
3415       return -1;
3416   }
3417   {
3418     char device[] = "/dev/sda1";
3419     int r;
3420     suppress_error = 0;
3421     r = guestfs_zero (g, device);
3422     if (r == -1)
3423       return -1;
3424   }
3425   {
3426     char fstype[] = "ext2";
3427     char device[] = "/dev/sda1";
3428     int r;
3429     suppress_error = 0;
3430     r = guestfs_fsck (g, fstype, device);
3431     if (r == -1)
3432       return -1;
3433     if (r != 8) {
3434       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
3435       return -1;
3436     }
3437   }
3438   return 0;
3439 }
3440
3441 static int test_set_e2uuid_0_skip (void)
3442 {
3443   const char *str;
3444
3445   str = getenv ("SKIP_TEST_SET_E2UUID_0");
3446   if (str && strcmp (str, "1") == 0) return 1;
3447   str = getenv ("SKIP_TEST_SET_E2UUID");
3448   if (str && strcmp (str, "1") == 0) return 1;
3449   return 0;
3450 }
3451
3452 static int test_set_e2uuid_0 (void)
3453 {
3454   if (test_set_e2uuid_0_skip ()) {
3455     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3456     return 0;
3457   }
3458
3459   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3460   {
3461     char device[] = "/dev/sda";
3462     int r;
3463     suppress_error = 0;
3464     r = guestfs_blockdev_setrw (g, device);
3465     if (r == -1)
3466       return -1;
3467   }
3468   {
3469     int r;
3470     suppress_error = 0;
3471     r = guestfs_umount_all (g);
3472     if (r == -1)
3473       return -1;
3474   }
3475   {
3476     int r;
3477     suppress_error = 0;
3478     r = guestfs_lvm_remove_all (g);
3479     if (r == -1)
3480       return -1;
3481   }
3482   {
3483     char device[] = "/dev/sda";
3484     char lines_0[] = ",";
3485     char *lines[] = {
3486       lines_0,
3487       NULL
3488     };
3489     int r;
3490     suppress_error = 0;
3491     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3492     if (r == -1)
3493       return -1;
3494   }
3495   {
3496     char fstype[] = "ext2";
3497     char device[] = "/dev/sda1";
3498     int r;
3499     suppress_error = 0;
3500     r = guestfs_mkfs (g, fstype, device);
3501     if (r == -1)
3502       return -1;
3503   }
3504   {
3505     char device[] = "/dev/sda1";
3506     char mountpoint[] = "/";
3507     int r;
3508     suppress_error = 0;
3509     r = guestfs_mount (g, device, mountpoint);
3510     if (r == -1)
3511       return -1;
3512   }
3513   /* TestOutput for set_e2uuid (0) */
3514   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3515   {
3516     char device[] = "/dev/sda1";
3517     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3518     int r;
3519     suppress_error = 0;
3520     r = guestfs_set_e2uuid (g, device, uuid);
3521     if (r == -1)
3522       return -1;
3523   }
3524   {
3525     char device[] = "/dev/sda1";
3526     char *r;
3527     suppress_error = 0;
3528     r = guestfs_get_e2uuid (g, device);
3529     if (r == NULL)
3530       return -1;
3531     if (strcmp (r, expected) != 0) {
3532       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3533       return -1;
3534     }
3535     free (r);
3536   }
3537   return 0;
3538 }
3539
3540 static int test_set_e2uuid_1_skip (void)
3541 {
3542   const char *str;
3543
3544   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3545   if (str && strcmp (str, "1") == 0) return 1;
3546   str = getenv ("SKIP_TEST_SET_E2UUID");
3547   if (str && strcmp (str, "1") == 0) return 1;
3548   return 0;
3549 }
3550
3551 static int test_set_e2uuid_1 (void)
3552 {
3553   if (test_set_e2uuid_1_skip ()) {
3554     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3555     return 0;
3556   }
3557
3558   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3559   {
3560     char device[] = "/dev/sda";
3561     int r;
3562     suppress_error = 0;
3563     r = guestfs_blockdev_setrw (g, device);
3564     if (r == -1)
3565       return -1;
3566   }
3567   {
3568     int r;
3569     suppress_error = 0;
3570     r = guestfs_umount_all (g);
3571     if (r == -1)
3572       return -1;
3573   }
3574   {
3575     int r;
3576     suppress_error = 0;
3577     r = guestfs_lvm_remove_all (g);
3578     if (r == -1)
3579       return -1;
3580   }
3581   {
3582     char device[] = "/dev/sda";
3583     char lines_0[] = ",";
3584     char *lines[] = {
3585       lines_0,
3586       NULL
3587     };
3588     int r;
3589     suppress_error = 0;
3590     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3591     if (r == -1)
3592       return -1;
3593   }
3594   {
3595     char fstype[] = "ext2";
3596     char device[] = "/dev/sda1";
3597     int r;
3598     suppress_error = 0;
3599     r = guestfs_mkfs (g, fstype, device);
3600     if (r == -1)
3601       return -1;
3602   }
3603   {
3604     char device[] = "/dev/sda1";
3605     char mountpoint[] = "/";
3606     int r;
3607     suppress_error = 0;
3608     r = guestfs_mount (g, device, mountpoint);
3609     if (r == -1)
3610       return -1;
3611   }
3612   /* TestOutput for set_e2uuid (1) */
3613   char expected[] = "";
3614   {
3615     char device[] = "/dev/sda1";
3616     char uuid[] = "clear";
3617     int r;
3618     suppress_error = 0;
3619     r = guestfs_set_e2uuid (g, device, uuid);
3620     if (r == -1)
3621       return -1;
3622   }
3623   {
3624     char device[] = "/dev/sda1";
3625     char *r;
3626     suppress_error = 0;
3627     r = guestfs_get_e2uuid (g, device);
3628     if (r == NULL)
3629       return -1;
3630     if (strcmp (r, expected) != 0) {
3631       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3632       return -1;
3633     }
3634     free (r);
3635   }
3636   return 0;
3637 }
3638
3639 static int test_set_e2uuid_2_skip (void)
3640 {
3641   const char *str;
3642
3643   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3644   if (str && strcmp (str, "1") == 0) return 1;
3645   str = getenv ("SKIP_TEST_SET_E2UUID");
3646   if (str && strcmp (str, "1") == 0) return 1;
3647   return 0;
3648 }
3649
3650 static int test_set_e2uuid_2 (void)
3651 {
3652   if (test_set_e2uuid_2_skip ()) {
3653     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3654     return 0;
3655   }
3656
3657   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3658   {
3659     char device[] = "/dev/sda";
3660     int r;
3661     suppress_error = 0;
3662     r = guestfs_blockdev_setrw (g, device);
3663     if (r == -1)
3664       return -1;
3665   }
3666   {
3667     int r;
3668     suppress_error = 0;
3669     r = guestfs_umount_all (g);
3670     if (r == -1)
3671       return -1;
3672   }
3673   {
3674     int r;
3675     suppress_error = 0;
3676     r = guestfs_lvm_remove_all (g);
3677     if (r == -1)
3678       return -1;
3679   }
3680   {
3681     char device[] = "/dev/sda";
3682     char lines_0[] = ",";
3683     char *lines[] = {
3684       lines_0,
3685       NULL
3686     };
3687     int r;
3688     suppress_error = 0;
3689     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3690     if (r == -1)
3691       return -1;
3692   }
3693   {
3694     char fstype[] = "ext2";
3695     char device[] = "/dev/sda1";
3696     int r;
3697     suppress_error = 0;
3698     r = guestfs_mkfs (g, fstype, device);
3699     if (r == -1)
3700       return -1;
3701   }
3702   {
3703     char device[] = "/dev/sda1";
3704     char mountpoint[] = "/";
3705     int r;
3706     suppress_error = 0;
3707     r = guestfs_mount (g, device, mountpoint);
3708     if (r == -1)
3709       return -1;
3710   }
3711   /* TestRun for set_e2uuid (2) */
3712   {
3713     char device[] = "/dev/sda1";
3714     char uuid[] = "random";
3715     int r;
3716     suppress_error = 0;
3717     r = guestfs_set_e2uuid (g, device, uuid);
3718     if (r == -1)
3719       return -1;
3720   }
3721   return 0;
3722 }
3723
3724 static int test_set_e2uuid_3_skip (void)
3725 {
3726   const char *str;
3727
3728   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3729   if (str && strcmp (str, "1") == 0) return 1;
3730   str = getenv ("SKIP_TEST_SET_E2UUID");
3731   if (str && strcmp (str, "1") == 0) return 1;
3732   return 0;
3733 }
3734
3735 static int test_set_e2uuid_3 (void)
3736 {
3737   if (test_set_e2uuid_3_skip ()) {
3738     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3739     return 0;
3740   }
3741
3742   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3743   {
3744     char device[] = "/dev/sda";
3745     int r;
3746     suppress_error = 0;
3747     r = guestfs_blockdev_setrw (g, device);
3748     if (r == -1)
3749       return -1;
3750   }
3751   {
3752     int r;
3753     suppress_error = 0;
3754     r = guestfs_umount_all (g);
3755     if (r == -1)
3756       return -1;
3757   }
3758   {
3759     int r;
3760     suppress_error = 0;
3761     r = guestfs_lvm_remove_all (g);
3762     if (r == -1)
3763       return -1;
3764   }
3765   {
3766     char device[] = "/dev/sda";
3767     char lines_0[] = ",";
3768     char *lines[] = {
3769       lines_0,
3770       NULL
3771     };
3772     int r;
3773     suppress_error = 0;
3774     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3775     if (r == -1)
3776       return -1;
3777   }
3778   {
3779     char fstype[] = "ext2";
3780     char device[] = "/dev/sda1";
3781     int r;
3782     suppress_error = 0;
3783     r = guestfs_mkfs (g, fstype, device);
3784     if (r == -1)
3785       return -1;
3786   }
3787   {
3788     char device[] = "/dev/sda1";
3789     char mountpoint[] = "/";
3790     int r;
3791     suppress_error = 0;
3792     r = guestfs_mount (g, device, mountpoint);
3793     if (r == -1)
3794       return -1;
3795   }
3796   /* TestRun for set_e2uuid (3) */
3797   {
3798     char device[] = "/dev/sda1";
3799     char uuid[] = "time";
3800     int r;
3801     suppress_error = 0;
3802     r = guestfs_set_e2uuid (g, device, uuid);
3803     if (r == -1)
3804       return -1;
3805   }
3806   return 0;
3807 }
3808
3809 static int test_set_e2label_0_skip (void)
3810 {
3811   const char *str;
3812
3813   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3814   if (str && strcmp (str, "1") == 0) return 1;
3815   str = getenv ("SKIP_TEST_SET_E2LABEL");
3816   if (str && strcmp (str, "1") == 0) return 1;
3817   return 0;
3818 }
3819
3820 static int test_set_e2label_0 (void)
3821 {
3822   if (test_set_e2label_0_skip ()) {
3823     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3824     return 0;
3825   }
3826
3827   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3828   {
3829     char device[] = "/dev/sda";
3830     int r;
3831     suppress_error = 0;
3832     r = guestfs_blockdev_setrw (g, device);
3833     if (r == -1)
3834       return -1;
3835   }
3836   {
3837     int r;
3838     suppress_error = 0;
3839     r = guestfs_umount_all (g);
3840     if (r == -1)
3841       return -1;
3842   }
3843   {
3844     int r;
3845     suppress_error = 0;
3846     r = guestfs_lvm_remove_all (g);
3847     if (r == -1)
3848       return -1;
3849   }
3850   {
3851     char device[] = "/dev/sda";
3852     char lines_0[] = ",";
3853     char *lines[] = {
3854       lines_0,
3855       NULL
3856     };
3857     int r;
3858     suppress_error = 0;
3859     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3860     if (r == -1)
3861       return -1;
3862   }
3863   {
3864     char fstype[] = "ext2";
3865     char device[] = "/dev/sda1";
3866     int r;
3867     suppress_error = 0;
3868     r = guestfs_mkfs (g, fstype, device);
3869     if (r == -1)
3870       return -1;
3871   }
3872   {
3873     char device[] = "/dev/sda1";
3874     char mountpoint[] = "/";
3875     int r;
3876     suppress_error = 0;
3877     r = guestfs_mount (g, device, mountpoint);
3878     if (r == -1)
3879       return -1;
3880   }
3881   /* TestOutput for set_e2label (0) */
3882   char expected[] = "testlabel";
3883   {
3884     char device[] = "/dev/sda1";
3885     char label[] = "testlabel";
3886     int r;
3887     suppress_error = 0;
3888     r = guestfs_set_e2label (g, device, label);
3889     if (r == -1)
3890       return -1;
3891   }
3892   {
3893     char device[] = "/dev/sda1";
3894     char *r;
3895     suppress_error = 0;
3896     r = guestfs_get_e2label (g, device);
3897     if (r == NULL)
3898       return -1;
3899     if (strcmp (r, expected) != 0) {
3900       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3901       return -1;
3902     }
3903     free (r);
3904   }
3905   return 0;
3906 }
3907
3908 static int test_pvremove_0_skip (void)
3909 {
3910   const char *str;
3911
3912   str = getenv ("SKIP_TEST_PVREMOVE_0");
3913   if (str && strcmp (str, "1") == 0) return 1;
3914   str = getenv ("SKIP_TEST_PVREMOVE");
3915   if (str && strcmp (str, "1") == 0) return 1;
3916   return 0;
3917 }
3918
3919 static int test_pvremove_0 (void)
3920 {
3921   if (test_pvremove_0_skip ()) {
3922     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3923     return 0;
3924   }
3925
3926   /* InitNone|InitEmpty for test_pvremove_0 */
3927   {
3928     char device[] = "/dev/sda";
3929     int r;
3930     suppress_error = 0;
3931     r = guestfs_blockdev_setrw (g, device);
3932     if (r == -1)
3933       return -1;
3934   }
3935   {
3936     int r;
3937     suppress_error = 0;
3938     r = guestfs_umount_all (g);
3939     if (r == -1)
3940       return -1;
3941   }
3942   {
3943     int r;
3944     suppress_error = 0;
3945     r = guestfs_lvm_remove_all (g);
3946     if (r == -1)
3947       return -1;
3948   }
3949   /* TestOutputListOfDevices for pvremove (0) */
3950   {
3951     char device[] = "/dev/sda";
3952     char lines_0[] = ",";
3953     char *lines[] = {
3954       lines_0,
3955       NULL
3956     };
3957     int r;
3958     suppress_error = 0;
3959     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3960     if (r == -1)
3961       return -1;
3962   }
3963   {
3964     char device[] = "/dev/sda1";
3965     int r;
3966     suppress_error = 0;
3967     r = guestfs_pvcreate (g, device);
3968     if (r == -1)
3969       return -1;
3970   }
3971   {
3972     char volgroup[] = "VG";
3973     char physvols_0[] = "/dev/sda1";
3974     char *physvols[] = {
3975       physvols_0,
3976       NULL
3977     };
3978     int r;
3979     suppress_error = 0;
3980     r = guestfs_vgcreate (g, volgroup, physvols);
3981     if (r == -1)
3982       return -1;
3983   }
3984   {
3985     char logvol[] = "LV1";
3986     char volgroup[] = "VG";
3987     int r;
3988     suppress_error = 0;
3989     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3990     if (r == -1)
3991       return -1;
3992   }
3993   {
3994     char logvol[] = "LV2";
3995     char volgroup[] = "VG";
3996     int r;
3997     suppress_error = 0;
3998     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3999     if (r == -1)
4000       return -1;
4001   }
4002   {
4003     char vgname[] = "VG";
4004     int r;
4005     suppress_error = 0;
4006     r = guestfs_vgremove (g, vgname);
4007     if (r == -1)
4008       return -1;
4009   }
4010   {
4011     char device[] = "/dev/sda1";
4012     int r;
4013     suppress_error = 0;
4014     r = guestfs_pvremove (g, device);
4015     if (r == -1)
4016       return -1;
4017   }
4018   {
4019     char **r;
4020     int i;
4021     suppress_error = 0;
4022     r = guestfs_lvs (g);
4023     if (r == NULL)
4024       return -1;
4025     if (r[0] != NULL) {
4026       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
4027       print_strings (r);
4028       return -1;
4029     }
4030     for (i = 0; r[i] != NULL; ++i)
4031       free (r[i]);
4032     free (r);
4033   }
4034   return 0;
4035 }
4036
4037 static int test_pvremove_1_skip (void)
4038 {
4039   const char *str;
4040
4041   str = getenv ("SKIP_TEST_PVREMOVE_1");
4042   if (str && strcmp (str, "1") == 0) return 1;
4043   str = getenv ("SKIP_TEST_PVREMOVE");
4044   if (str && strcmp (str, "1") == 0) return 1;
4045   return 0;
4046 }
4047
4048 static int test_pvremove_1 (void)
4049 {
4050   if (test_pvremove_1_skip ()) {
4051     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
4052     return 0;
4053   }
4054
4055   /* InitNone|InitEmpty for test_pvremove_1 */
4056   {
4057     char device[] = "/dev/sda";
4058     int r;
4059     suppress_error = 0;
4060     r = guestfs_blockdev_setrw (g, device);
4061     if (r == -1)
4062       return -1;
4063   }
4064   {
4065     int r;
4066     suppress_error = 0;
4067     r = guestfs_umount_all (g);
4068     if (r == -1)
4069       return -1;
4070   }
4071   {
4072     int r;
4073     suppress_error = 0;
4074     r = guestfs_lvm_remove_all (g);
4075     if (r == -1)
4076       return -1;
4077   }
4078   /* TestOutputListOfDevices for pvremove (1) */
4079   {
4080     char device[] = "/dev/sda";
4081     char lines_0[] = ",";
4082     char *lines[] = {
4083       lines_0,
4084       NULL
4085     };
4086     int r;
4087     suppress_error = 0;
4088     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4089     if (r == -1)
4090       return -1;
4091   }
4092   {
4093     char device[] = "/dev/sda1";
4094     int r;
4095     suppress_error = 0;
4096     r = guestfs_pvcreate (g, device);
4097     if (r == -1)
4098       return -1;
4099   }
4100   {
4101     char volgroup[] = "VG";
4102     char physvols_0[] = "/dev/sda1";
4103     char *physvols[] = {
4104       physvols_0,
4105       NULL
4106     };
4107     int r;
4108     suppress_error = 0;
4109     r = guestfs_vgcreate (g, volgroup, physvols);
4110     if (r == -1)
4111       return -1;
4112   }
4113   {
4114     char logvol[] = "LV1";
4115     char volgroup[] = "VG";
4116     int r;
4117     suppress_error = 0;
4118     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4119     if (r == -1)
4120       return -1;
4121   }
4122   {
4123     char logvol[] = "LV2";
4124     char volgroup[] = "VG";
4125     int r;
4126     suppress_error = 0;
4127     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4128     if (r == -1)
4129       return -1;
4130   }
4131   {
4132     char vgname[] = "VG";
4133     int r;
4134     suppress_error = 0;
4135     r = guestfs_vgremove (g, vgname);
4136     if (r == -1)
4137       return -1;
4138   }
4139   {
4140     char device[] = "/dev/sda1";
4141     int r;
4142     suppress_error = 0;
4143     r = guestfs_pvremove (g, device);
4144     if (r == -1)
4145       return -1;
4146   }
4147   {
4148     char **r;
4149     int i;
4150     suppress_error = 0;
4151     r = guestfs_vgs (g);
4152     if (r == NULL)
4153       return -1;
4154     if (r[0] != NULL) {
4155       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
4156       print_strings (r);
4157       return -1;
4158     }
4159     for (i = 0; r[i] != NULL; ++i)
4160       free (r[i]);
4161     free (r);
4162   }
4163   return 0;
4164 }
4165
4166 static int test_pvremove_2_skip (void)
4167 {
4168   const char *str;
4169
4170   str = getenv ("SKIP_TEST_PVREMOVE_2");
4171   if (str && strcmp (str, "1") == 0) return 1;
4172   str = getenv ("SKIP_TEST_PVREMOVE");
4173   if (str && strcmp (str, "1") == 0) return 1;
4174   return 0;
4175 }
4176
4177 static int test_pvremove_2 (void)
4178 {
4179   if (test_pvremove_2_skip ()) {
4180     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
4181     return 0;
4182   }
4183
4184   /* InitNone|InitEmpty for test_pvremove_2 */
4185   {
4186     char device[] = "/dev/sda";
4187     int r;
4188     suppress_error = 0;
4189     r = guestfs_blockdev_setrw (g, device);
4190     if (r == -1)
4191       return -1;
4192   }
4193   {
4194     int r;
4195     suppress_error = 0;
4196     r = guestfs_umount_all (g);
4197     if (r == -1)
4198       return -1;
4199   }
4200   {
4201     int r;
4202     suppress_error = 0;
4203     r = guestfs_lvm_remove_all (g);
4204     if (r == -1)
4205       return -1;
4206   }
4207   /* TestOutputListOfDevices for pvremove (2) */
4208   {
4209     char device[] = "/dev/sda";
4210     char lines_0[] = ",";
4211     char *lines[] = {
4212       lines_0,
4213       NULL
4214     };
4215     int r;
4216     suppress_error = 0;
4217     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4218     if (r == -1)
4219       return -1;
4220   }
4221   {
4222     char device[] = "/dev/sda1";
4223     int r;
4224     suppress_error = 0;
4225     r = guestfs_pvcreate (g, device);
4226     if (r == -1)
4227       return -1;
4228   }
4229   {
4230     char volgroup[] = "VG";
4231     char physvols_0[] = "/dev/sda1";
4232     char *physvols[] = {
4233       physvols_0,
4234       NULL
4235     };
4236     int r;
4237     suppress_error = 0;
4238     r = guestfs_vgcreate (g, volgroup, physvols);
4239     if (r == -1)
4240       return -1;
4241   }
4242   {
4243     char logvol[] = "LV1";
4244     char volgroup[] = "VG";
4245     int r;
4246     suppress_error = 0;
4247     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4248     if (r == -1)
4249       return -1;
4250   }
4251   {
4252     char logvol[] = "LV2";
4253     char volgroup[] = "VG";
4254     int r;
4255     suppress_error = 0;
4256     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4257     if (r == -1)
4258       return -1;
4259   }
4260   {
4261     char vgname[] = "VG";
4262     int r;
4263     suppress_error = 0;
4264     r = guestfs_vgremove (g, vgname);
4265     if (r == -1)
4266       return -1;
4267   }
4268   {
4269     char device[] = "/dev/sda1";
4270     int r;
4271     suppress_error = 0;
4272     r = guestfs_pvremove (g, device);
4273     if (r == -1)
4274       return -1;
4275   }
4276   {
4277     char **r;
4278     int i;
4279     suppress_error = 0;
4280     r = guestfs_pvs (g);
4281     if (r == NULL)
4282       return -1;
4283     if (r[0] != NULL) {
4284       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
4285       print_strings (r);
4286       return -1;
4287     }
4288     for (i = 0; r[i] != NULL; ++i)
4289       free (r[i]);
4290     free (r);
4291   }
4292   return 0;
4293 }
4294
4295 static int test_vgremove_0_skip (void)
4296 {
4297   const char *str;
4298
4299   str = getenv ("SKIP_TEST_VGREMOVE_0");
4300   if (str && strcmp (str, "1") == 0) return 1;
4301   str = getenv ("SKIP_TEST_VGREMOVE");
4302   if (str && strcmp (str, "1") == 0) return 1;
4303   return 0;
4304 }
4305
4306 static int test_vgremove_0 (void)
4307 {
4308   if (test_vgremove_0_skip ()) {
4309     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
4310     return 0;
4311   }
4312
4313   /* InitNone|InitEmpty for test_vgremove_0 */
4314   {
4315     char device[] = "/dev/sda";
4316     int r;
4317     suppress_error = 0;
4318     r = guestfs_blockdev_setrw (g, device);
4319     if (r == -1)
4320       return -1;
4321   }
4322   {
4323     int r;
4324     suppress_error = 0;
4325     r = guestfs_umount_all (g);
4326     if (r == -1)
4327       return -1;
4328   }
4329   {
4330     int r;
4331     suppress_error = 0;
4332     r = guestfs_lvm_remove_all (g);
4333     if (r == -1)
4334       return -1;
4335   }
4336   /* TestOutputList for vgremove (0) */
4337   {
4338     char device[] = "/dev/sda";
4339     char lines_0[] = ",";
4340     char *lines[] = {
4341       lines_0,
4342       NULL
4343     };
4344     int r;
4345     suppress_error = 0;
4346     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4347     if (r == -1)
4348       return -1;
4349   }
4350   {
4351     char device[] = "/dev/sda1";
4352     int r;
4353     suppress_error = 0;
4354     r = guestfs_pvcreate (g, device);
4355     if (r == -1)
4356       return -1;
4357   }
4358   {
4359     char volgroup[] = "VG";
4360     char physvols_0[] = "/dev/sda1";
4361     char *physvols[] = {
4362       physvols_0,
4363       NULL
4364     };
4365     int r;
4366     suppress_error = 0;
4367     r = guestfs_vgcreate (g, volgroup, physvols);
4368     if (r == -1)
4369       return -1;
4370   }
4371   {
4372     char logvol[] = "LV1";
4373     char volgroup[] = "VG";
4374     int r;
4375     suppress_error = 0;
4376     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4377     if (r == -1)
4378       return -1;
4379   }
4380   {
4381     char logvol[] = "LV2";
4382     char volgroup[] = "VG";
4383     int r;
4384     suppress_error = 0;
4385     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4386     if (r == -1)
4387       return -1;
4388   }
4389   {
4390     char vgname[] = "VG";
4391     int r;
4392     suppress_error = 0;
4393     r = guestfs_vgremove (g, vgname);
4394     if (r == -1)
4395       return -1;
4396   }
4397   {
4398     char **r;
4399     int i;
4400     suppress_error = 0;
4401     r = guestfs_lvs (g);
4402     if (r == NULL)
4403       return -1;
4404     if (r[0] != NULL) {
4405       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4406       print_strings (r);
4407       return -1;
4408     }
4409     for (i = 0; r[i] != NULL; ++i)
4410       free (r[i]);
4411     free (r);
4412   }
4413   return 0;
4414 }
4415
4416 static int test_vgremove_1_skip (void)
4417 {
4418   const char *str;
4419
4420   str = getenv ("SKIP_TEST_VGREMOVE_1");
4421   if (str && strcmp (str, "1") == 0) return 1;
4422   str = getenv ("SKIP_TEST_VGREMOVE");
4423   if (str && strcmp (str, "1") == 0) return 1;
4424   return 0;
4425 }
4426
4427 static int test_vgremove_1 (void)
4428 {
4429   if (test_vgremove_1_skip ()) {
4430     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4431     return 0;
4432   }
4433
4434   /* InitNone|InitEmpty for test_vgremove_1 */
4435   {
4436     char device[] = "/dev/sda";
4437     int r;
4438     suppress_error = 0;
4439     r = guestfs_blockdev_setrw (g, device);
4440     if (r == -1)
4441       return -1;
4442   }
4443   {
4444     int r;
4445     suppress_error = 0;
4446     r = guestfs_umount_all (g);
4447     if (r == -1)
4448       return -1;
4449   }
4450   {
4451     int r;
4452     suppress_error = 0;
4453     r = guestfs_lvm_remove_all (g);
4454     if (r == -1)
4455       return -1;
4456   }
4457   /* TestOutputList for vgremove (1) */
4458   {
4459     char device[] = "/dev/sda";
4460     char lines_0[] = ",";
4461     char *lines[] = {
4462       lines_0,
4463       NULL
4464     };
4465     int r;
4466     suppress_error = 0;
4467     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4468     if (r == -1)
4469       return -1;
4470   }
4471   {
4472     char device[] = "/dev/sda1";
4473     int r;
4474     suppress_error = 0;
4475     r = guestfs_pvcreate (g, device);
4476     if (r == -1)
4477       return -1;
4478   }
4479   {
4480     char volgroup[] = "VG";
4481     char physvols_0[] = "/dev/sda1";
4482     char *physvols[] = {
4483       physvols_0,
4484       NULL
4485     };
4486     int r;
4487     suppress_error = 0;
4488     r = guestfs_vgcreate (g, volgroup, physvols);
4489     if (r == -1)
4490       return -1;
4491   }
4492   {
4493     char logvol[] = "LV1";
4494     char volgroup[] = "VG";
4495     int r;
4496     suppress_error = 0;
4497     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4498     if (r == -1)
4499       return -1;
4500   }
4501   {
4502     char logvol[] = "LV2";
4503     char volgroup[] = "VG";
4504     int r;
4505     suppress_error = 0;
4506     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4507     if (r == -1)
4508       return -1;
4509   }
4510   {
4511     char vgname[] = "VG";
4512     int r;
4513     suppress_error = 0;
4514     r = guestfs_vgremove (g, vgname);
4515     if (r == -1)
4516       return -1;
4517   }
4518   {
4519     char **r;
4520     int i;
4521     suppress_error = 0;
4522     r = guestfs_vgs (g);
4523     if (r == NULL)
4524       return -1;
4525     if (r[0] != NULL) {
4526       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4527       print_strings (r);
4528       return -1;
4529     }
4530     for (i = 0; r[i] != NULL; ++i)
4531       free (r[i]);
4532     free (r);
4533   }
4534   return 0;
4535 }
4536
4537 static int test_lvremove_0_skip (void)
4538 {
4539   const char *str;
4540
4541   str = getenv ("SKIP_TEST_LVREMOVE_0");
4542   if (str && strcmp (str, "1") == 0) return 1;
4543   str = getenv ("SKIP_TEST_LVREMOVE");
4544   if (str && strcmp (str, "1") == 0) return 1;
4545   return 0;
4546 }
4547
4548 static int test_lvremove_0 (void)
4549 {
4550   if (test_lvremove_0_skip ()) {
4551     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4552     return 0;
4553   }
4554
4555   /* InitNone|InitEmpty for test_lvremove_0 */
4556   {
4557     char device[] = "/dev/sda";
4558     int r;
4559     suppress_error = 0;
4560     r = guestfs_blockdev_setrw (g, device);
4561     if (r == -1)
4562       return -1;
4563   }
4564   {
4565     int r;
4566     suppress_error = 0;
4567     r = guestfs_umount_all (g);
4568     if (r == -1)
4569       return -1;
4570   }
4571   {
4572     int r;
4573     suppress_error = 0;
4574     r = guestfs_lvm_remove_all (g);
4575     if (r == -1)
4576       return -1;
4577   }
4578   /* TestOutputList for lvremove (0) */
4579   {
4580     char device[] = "/dev/sda";
4581     char lines_0[] = ",";
4582     char *lines[] = {
4583       lines_0,
4584       NULL
4585     };
4586     int r;
4587     suppress_error = 0;
4588     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4589     if (r == -1)
4590       return -1;
4591   }
4592   {
4593     char device[] = "/dev/sda1";
4594     int r;
4595     suppress_error = 0;
4596     r = guestfs_pvcreate (g, device);
4597     if (r == -1)
4598       return -1;
4599   }
4600   {
4601     char volgroup[] = "VG";
4602     char physvols_0[] = "/dev/sda1";
4603     char *physvols[] = {
4604       physvols_0,
4605       NULL
4606     };
4607     int r;
4608     suppress_error = 0;
4609     r = guestfs_vgcreate (g, volgroup, physvols);
4610     if (r == -1)
4611       return -1;
4612   }
4613   {
4614     char logvol[] = "LV1";
4615     char volgroup[] = "VG";
4616     int r;
4617     suppress_error = 0;
4618     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4619     if (r == -1)
4620       return -1;
4621   }
4622   {
4623     char logvol[] = "LV2";
4624     char volgroup[] = "VG";
4625     int r;
4626     suppress_error = 0;
4627     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4628     if (r == -1)
4629       return -1;
4630   }
4631   {
4632     char device[] = "/dev/VG/LV1";
4633     int r;
4634     suppress_error = 0;
4635     r = guestfs_lvremove (g, device);
4636     if (r == -1)
4637       return -1;
4638   }
4639   {
4640     char **r;
4641     int i;
4642     suppress_error = 0;
4643     r = guestfs_lvs (g);
4644     if (r == NULL)
4645       return -1;
4646     if (!r[0]) {
4647       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4648       print_strings (r);
4649       return -1;
4650     }
4651     {
4652       char expected[] = "/dev/VG/LV2";
4653       if (strcmp (r[0], expected) != 0) {
4654         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4655         return -1;
4656       }
4657     }
4658     if (r[1] != NULL) {
4659       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4660       print_strings (r);
4661       return -1;
4662     }
4663     for (i = 0; r[i] != NULL; ++i)
4664       free (r[i]);
4665     free (r);
4666   }
4667   return 0;
4668 }
4669
4670 static int test_lvremove_1_skip (void)
4671 {
4672   const char *str;
4673
4674   str = getenv ("SKIP_TEST_LVREMOVE_1");
4675   if (str && strcmp (str, "1") == 0) return 1;
4676   str = getenv ("SKIP_TEST_LVREMOVE");
4677   if (str && strcmp (str, "1") == 0) return 1;
4678   return 0;
4679 }
4680
4681 static int test_lvremove_1 (void)
4682 {
4683   if (test_lvremove_1_skip ()) {
4684     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4685     return 0;
4686   }
4687
4688   /* InitNone|InitEmpty for test_lvremove_1 */
4689   {
4690     char device[] = "/dev/sda";
4691     int r;
4692     suppress_error = 0;
4693     r = guestfs_blockdev_setrw (g, device);
4694     if (r == -1)
4695       return -1;
4696   }
4697   {
4698     int r;
4699     suppress_error = 0;
4700     r = guestfs_umount_all (g);
4701     if (r == -1)
4702       return -1;
4703   }
4704   {
4705     int r;
4706     suppress_error = 0;
4707     r = guestfs_lvm_remove_all (g);
4708     if (r == -1)
4709       return -1;
4710   }
4711   /* TestOutputList for lvremove (1) */
4712   {
4713     char device[] = "/dev/sda";
4714     char lines_0[] = ",";
4715     char *lines[] = {
4716       lines_0,
4717       NULL
4718     };
4719     int r;
4720     suppress_error = 0;
4721     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4722     if (r == -1)
4723       return -1;
4724   }
4725   {
4726     char device[] = "/dev/sda1";
4727     int r;
4728     suppress_error = 0;
4729     r = guestfs_pvcreate (g, device);
4730     if (r == -1)
4731       return -1;
4732   }
4733   {
4734     char volgroup[] = "VG";
4735     char physvols_0[] = "/dev/sda1";
4736     char *physvols[] = {
4737       physvols_0,
4738       NULL
4739     };
4740     int r;
4741     suppress_error = 0;
4742     r = guestfs_vgcreate (g, volgroup, physvols);
4743     if (r == -1)
4744       return -1;
4745   }
4746   {
4747     char logvol[] = "LV1";
4748     char volgroup[] = "VG";
4749     int r;
4750     suppress_error = 0;
4751     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4752     if (r == -1)
4753       return -1;
4754   }
4755   {
4756     char logvol[] = "LV2";
4757     char volgroup[] = "VG";
4758     int r;
4759     suppress_error = 0;
4760     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4761     if (r == -1)
4762       return -1;
4763   }
4764   {
4765     char device[] = "/dev/VG";
4766     int r;
4767     suppress_error = 0;
4768     r = guestfs_lvremove (g, device);
4769     if (r == -1)
4770       return -1;
4771   }
4772   {
4773     char **r;
4774     int i;
4775     suppress_error = 0;
4776     r = guestfs_lvs (g);
4777     if (r == NULL)
4778       return -1;
4779     if (r[0] != NULL) {
4780       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4781       print_strings (r);
4782       return -1;
4783     }
4784     for (i = 0; r[i] != NULL; ++i)
4785       free (r[i]);
4786     free (r);
4787   }
4788   return 0;
4789 }
4790
4791 static int test_lvremove_2_skip (void)
4792 {
4793   const char *str;
4794
4795   str = getenv ("SKIP_TEST_LVREMOVE_2");
4796   if (str && strcmp (str, "1") == 0) return 1;
4797   str = getenv ("SKIP_TEST_LVREMOVE");
4798   if (str && strcmp (str, "1") == 0) return 1;
4799   return 0;
4800 }
4801
4802 static int test_lvremove_2 (void)
4803 {
4804   if (test_lvremove_2_skip ()) {
4805     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4806     return 0;
4807   }
4808
4809   /* InitNone|InitEmpty for test_lvremove_2 */
4810   {
4811     char device[] = "/dev/sda";
4812     int r;
4813     suppress_error = 0;
4814     r = guestfs_blockdev_setrw (g, device);
4815     if (r == -1)
4816       return -1;
4817   }
4818   {
4819     int r;
4820     suppress_error = 0;
4821     r = guestfs_umount_all (g);
4822     if (r == -1)
4823       return -1;
4824   }
4825   {
4826     int r;
4827     suppress_error = 0;
4828     r = guestfs_lvm_remove_all (g);
4829     if (r == -1)
4830       return -1;
4831   }
4832   /* TestOutputList for lvremove (2) */
4833   {
4834     char device[] = "/dev/sda";
4835     char lines_0[] = ",";
4836     char *lines[] = {
4837       lines_0,
4838       NULL
4839     };
4840     int r;
4841     suppress_error = 0;
4842     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4843     if (r == -1)
4844       return -1;
4845   }
4846   {
4847     char device[] = "/dev/sda1";
4848     int r;
4849     suppress_error = 0;
4850     r = guestfs_pvcreate (g, device);
4851     if (r == -1)
4852       return -1;
4853   }
4854   {
4855     char volgroup[] = "VG";
4856     char physvols_0[] = "/dev/sda1";
4857     char *physvols[] = {
4858       physvols_0,
4859       NULL
4860     };
4861     int r;
4862     suppress_error = 0;
4863     r = guestfs_vgcreate (g, volgroup, physvols);
4864     if (r == -1)
4865       return -1;
4866   }
4867   {
4868     char logvol[] = "LV1";
4869     char volgroup[] = "VG";
4870     int r;
4871     suppress_error = 0;
4872     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4873     if (r == -1)
4874       return -1;
4875   }
4876   {
4877     char logvol[] = "LV2";
4878     char volgroup[] = "VG";
4879     int r;
4880     suppress_error = 0;
4881     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4882     if (r == -1)
4883       return -1;
4884   }
4885   {
4886     char device[] = "/dev/VG";
4887     int r;
4888     suppress_error = 0;
4889     r = guestfs_lvremove (g, device);
4890     if (r == -1)
4891       return -1;
4892   }
4893   {
4894     char **r;
4895     int i;
4896     suppress_error = 0;
4897     r = guestfs_vgs (g);
4898     if (r == NULL)
4899       return -1;
4900     if (!r[0]) {
4901       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4902       print_strings (r);
4903       return -1;
4904     }
4905     {
4906       char expected[] = "VG";
4907       if (strcmp (r[0], expected) != 0) {
4908         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4909         return -1;
4910       }
4911     }
4912     if (r[1] != NULL) {
4913       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4914       print_strings (r);
4915       return -1;
4916     }
4917     for (i = 0; r[i] != NULL; ++i)
4918       free (r[i]);
4919     free (r);
4920   }
4921   return 0;
4922 }
4923
4924 static int test_mount_ro_0_skip (void)
4925 {
4926   const char *str;
4927
4928   str = getenv ("SKIP_TEST_MOUNT_RO_0");
4929   if (str && strcmp (str, "1") == 0) return 1;
4930   str = getenv ("SKIP_TEST_MOUNT_RO");
4931   if (str && strcmp (str, "1") == 0) return 1;
4932   return 0;
4933 }
4934
4935 static int test_mount_ro_0 (void)
4936 {
4937   if (test_mount_ro_0_skip ()) {
4938     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4939     return 0;
4940   }
4941
4942   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4943   {
4944     char device[] = "/dev/sda";
4945     int r;
4946     suppress_error = 0;
4947     r = guestfs_blockdev_setrw (g, device);
4948     if (r == -1)
4949       return -1;
4950   }
4951   {
4952     int r;
4953     suppress_error = 0;
4954     r = guestfs_umount_all (g);
4955     if (r == -1)
4956       return -1;
4957   }
4958   {
4959     int r;
4960     suppress_error = 0;
4961     r = guestfs_lvm_remove_all (g);
4962     if (r == -1)
4963       return -1;
4964   }
4965   {
4966     char device[] = "/dev/sda";
4967     char lines_0[] = ",";
4968     char *lines[] = {
4969       lines_0,
4970       NULL
4971     };
4972     int r;
4973     suppress_error = 0;
4974     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4975     if (r == -1)
4976       return -1;
4977   }
4978   {
4979     char fstype[] = "ext2";
4980     char device[] = "/dev/sda1";
4981     int r;
4982     suppress_error = 0;
4983     r = guestfs_mkfs (g, fstype, device);
4984     if (r == -1)
4985       return -1;
4986   }
4987   {
4988     char device[] = "/dev/sda1";
4989     char mountpoint[] = "/";
4990     int r;
4991     suppress_error = 0;
4992     r = guestfs_mount (g, device, mountpoint);
4993     if (r == -1)
4994       return -1;
4995   }
4996   /* TestLastFail for mount_ro (0) */
4997   {
4998     char pathordevice[] = "/";
4999     int r;
5000     suppress_error = 0;
5001     r = guestfs_umount (g, pathordevice);
5002     if (r == -1)
5003       return -1;
5004   }
5005   {
5006     char device[] = "/dev/sda1";
5007     char mountpoint[] = "/";
5008     int r;
5009     suppress_error = 0;
5010     r = guestfs_mount_ro (g, device, mountpoint);
5011     if (r == -1)
5012       return -1;
5013   }
5014   {
5015     char path[] = "/new";
5016     int r;
5017     suppress_error = 1;
5018     r = guestfs_touch (g, path);
5019     if (r != -1)
5020       return -1;
5021   }
5022   return 0;
5023 }
5024
5025 static int test_mount_ro_1_skip (void)
5026 {
5027   const char *str;
5028
5029   str = getenv ("SKIP_TEST_MOUNT_RO_1");
5030   if (str && strcmp (str, "1") == 0) return 1;
5031   str = getenv ("SKIP_TEST_MOUNT_RO");
5032   if (str && strcmp (str, "1") == 0) return 1;
5033   return 0;
5034 }
5035
5036 static int test_mount_ro_1 (void)
5037 {
5038   if (test_mount_ro_1_skip ()) {
5039     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
5040     return 0;
5041   }
5042
5043   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5044   {
5045     char device[] = "/dev/sda";
5046     int r;
5047     suppress_error = 0;
5048     r = guestfs_blockdev_setrw (g, device);
5049     if (r == -1)
5050       return -1;
5051   }
5052   {
5053     int r;
5054     suppress_error = 0;
5055     r = guestfs_umount_all (g);
5056     if (r == -1)
5057       return -1;
5058   }
5059   {
5060     int r;
5061     suppress_error = 0;
5062     r = guestfs_lvm_remove_all (g);
5063     if (r == -1)
5064       return -1;
5065   }
5066   {
5067     char device[] = "/dev/sda";
5068     char lines_0[] = ",";
5069     char *lines[] = {
5070       lines_0,
5071       NULL
5072     };
5073     int r;
5074     suppress_error = 0;
5075     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5076     if (r == -1)
5077       return -1;
5078   }
5079   {
5080     char fstype[] = "ext2";
5081     char device[] = "/dev/sda1";
5082     int r;
5083     suppress_error = 0;
5084     r = guestfs_mkfs (g, fstype, device);
5085     if (r == -1)
5086       return -1;
5087   }
5088   {
5089     char device[] = "/dev/sda1";
5090     char mountpoint[] = "/";
5091     int r;
5092     suppress_error = 0;
5093     r = guestfs_mount (g, device, mountpoint);
5094     if (r == -1)
5095       return -1;
5096   }
5097   /* TestOutput for mount_ro (1) */
5098   char expected[] = "data";
5099   {
5100     char path[] = "/new";
5101     char content[] = "data";
5102     int r;
5103     suppress_error = 0;
5104     r = guestfs_write_file (g, path, content, 0);
5105     if (r == -1)
5106       return -1;
5107   }
5108   {
5109     char pathordevice[] = "/";
5110     int r;
5111     suppress_error = 0;
5112     r = guestfs_umount (g, pathordevice);
5113     if (r == -1)
5114       return -1;
5115   }
5116   {
5117     char device[] = "/dev/sda1";
5118     char mountpoint[] = "/";
5119     int r;
5120     suppress_error = 0;
5121     r = guestfs_mount_ro (g, device, mountpoint);
5122     if (r == -1)
5123       return -1;
5124   }
5125   {
5126     char path[] = "/new";
5127     char *r;
5128     suppress_error = 0;
5129     r = guestfs_cat (g, path);
5130     if (r == NULL)
5131       return -1;
5132     if (strcmp (r, expected) != 0) {
5133       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5134       return -1;
5135     }
5136     free (r);
5137   }
5138   return 0;
5139 }
5140
5141 static int test_tgz_in_0_skip (void)
5142 {
5143   const char *str;
5144
5145   str = getenv ("SKIP_TEST_TGZ_IN_0");
5146   if (str && strcmp (str, "1") == 0) return 1;
5147   str = getenv ("SKIP_TEST_TGZ_IN");
5148   if (str && strcmp (str, "1") == 0) return 1;
5149   return 0;
5150 }
5151
5152 static int test_tgz_in_0 (void)
5153 {
5154   if (test_tgz_in_0_skip ()) {
5155     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
5156     return 0;
5157   }
5158
5159   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5160   {
5161     char device[] = "/dev/sda";
5162     int r;
5163     suppress_error = 0;
5164     r = guestfs_blockdev_setrw (g, device);
5165     if (r == -1)
5166       return -1;
5167   }
5168   {
5169     int r;
5170     suppress_error = 0;
5171     r = guestfs_umount_all (g);
5172     if (r == -1)
5173       return -1;
5174   }
5175   {
5176     int r;
5177     suppress_error = 0;
5178     r = guestfs_lvm_remove_all (g);
5179     if (r == -1)
5180       return -1;
5181   }
5182   {
5183     char device[] = "/dev/sda";
5184     char lines_0[] = ",";
5185     char *lines[] = {
5186       lines_0,
5187       NULL
5188     };
5189     int r;
5190     suppress_error = 0;
5191     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5192     if (r == -1)
5193       return -1;
5194   }
5195   {
5196     char fstype[] = "ext2";
5197     char device[] = "/dev/sda1";
5198     int r;
5199     suppress_error = 0;
5200     r = guestfs_mkfs (g, fstype, device);
5201     if (r == -1)
5202       return -1;
5203   }
5204   {
5205     char device[] = "/dev/sda1";
5206     char mountpoint[] = "/";
5207     int r;
5208     suppress_error = 0;
5209     r = guestfs_mount (g, device, mountpoint);
5210     if (r == -1)
5211       return -1;
5212   }
5213   /* TestOutput for tgz_in (0) */
5214   char expected[] = "hello\n";
5215   {
5216     char directory[] = "/";
5217     int r;
5218     suppress_error = 0;
5219     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5220     if (r == -1)
5221       return -1;
5222   }
5223   {
5224     char path[] = "/hello";
5225     char *r;
5226     suppress_error = 0;
5227     r = guestfs_cat (g, path);
5228     if (r == NULL)
5229       return -1;
5230     if (strcmp (r, expected) != 0) {
5231       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5232       return -1;
5233     }
5234     free (r);
5235   }
5236   return 0;
5237 }
5238
5239 static int test_tar_in_0_skip (void)
5240 {
5241   const char *str;
5242
5243   str = getenv ("SKIP_TEST_TAR_IN_0");
5244   if (str && strcmp (str, "1") == 0) return 1;
5245   str = getenv ("SKIP_TEST_TAR_IN");
5246   if (str && strcmp (str, "1") == 0) return 1;
5247   return 0;
5248 }
5249
5250 static int test_tar_in_0 (void)
5251 {
5252   if (test_tar_in_0_skip ()) {
5253     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5254     return 0;
5255   }
5256
5257   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5258   {
5259     char device[] = "/dev/sda";
5260     int r;
5261     suppress_error = 0;
5262     r = guestfs_blockdev_setrw (g, device);
5263     if (r == -1)
5264       return -1;
5265   }
5266   {
5267     int r;
5268     suppress_error = 0;
5269     r = guestfs_umount_all (g);
5270     if (r == -1)
5271       return -1;
5272   }
5273   {
5274     int r;
5275     suppress_error = 0;
5276     r = guestfs_lvm_remove_all (g);
5277     if (r == -1)
5278       return -1;
5279   }
5280   {
5281     char device[] = "/dev/sda";
5282     char lines_0[] = ",";
5283     char *lines[] = {
5284       lines_0,
5285       NULL
5286     };
5287     int r;
5288     suppress_error = 0;
5289     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5290     if (r == -1)
5291       return -1;
5292   }
5293   {
5294     char fstype[] = "ext2";
5295     char device[] = "/dev/sda1";
5296     int r;
5297     suppress_error = 0;
5298     r = guestfs_mkfs (g, fstype, device);
5299     if (r == -1)
5300       return -1;
5301   }
5302   {
5303     char device[] = "/dev/sda1";
5304     char mountpoint[] = "/";
5305     int r;
5306     suppress_error = 0;
5307     r = guestfs_mount (g, device, mountpoint);
5308     if (r == -1)
5309       return -1;
5310   }
5311   /* TestOutput for tar_in (0) */
5312   char expected[] = "hello\n";
5313   {
5314     char directory[] = "/";
5315     int r;
5316     suppress_error = 0;
5317     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5318     if (r == -1)
5319       return -1;
5320   }
5321   {
5322     char path[] = "/hello";
5323     char *r;
5324     suppress_error = 0;
5325     r = guestfs_cat (g, path);
5326     if (r == NULL)
5327       return -1;
5328     if (strcmp (r, expected) != 0) {
5329       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5330       return -1;
5331     }
5332     free (r);
5333   }
5334   return 0;
5335 }
5336
5337 static int test_checksum_0_skip (void)
5338 {
5339   const char *str;
5340
5341   str = getenv ("SKIP_TEST_CHECKSUM_0");
5342   if (str && strcmp (str, "1") == 0) return 1;
5343   str = getenv ("SKIP_TEST_CHECKSUM");
5344   if (str && strcmp (str, "1") == 0) return 1;
5345   return 0;
5346 }
5347
5348 static int test_checksum_0 (void)
5349 {
5350   if (test_checksum_0_skip ()) {
5351     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5352     return 0;
5353   }
5354
5355   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5356   {
5357     char device[] = "/dev/sda";
5358     int r;
5359     suppress_error = 0;
5360     r = guestfs_blockdev_setrw (g, device);
5361     if (r == -1)
5362       return -1;
5363   }
5364   {
5365     int r;
5366     suppress_error = 0;
5367     r = guestfs_umount_all (g);
5368     if (r == -1)
5369       return -1;
5370   }
5371   {
5372     int r;
5373     suppress_error = 0;
5374     r = guestfs_lvm_remove_all (g);
5375     if (r == -1)
5376       return -1;
5377   }
5378   {
5379     char device[] = "/dev/sda";
5380     char lines_0[] = ",";
5381     char *lines[] = {
5382       lines_0,
5383       NULL
5384     };
5385     int r;
5386     suppress_error = 0;
5387     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5388     if (r == -1)
5389       return -1;
5390   }
5391   {
5392     char fstype[] = "ext2";
5393     char device[] = "/dev/sda1";
5394     int r;
5395     suppress_error = 0;
5396     r = guestfs_mkfs (g, fstype, device);
5397     if (r == -1)
5398       return -1;
5399   }
5400   {
5401     char device[] = "/dev/sda1";
5402     char mountpoint[] = "/";
5403     int r;
5404     suppress_error = 0;
5405     r = guestfs_mount (g, device, mountpoint);
5406     if (r == -1)
5407       return -1;
5408   }
5409   /* TestOutput for checksum (0) */
5410   char expected[] = "935282863";
5411   {
5412     char path[] = "/new";
5413     char content[] = "test\n";
5414     int r;
5415     suppress_error = 0;
5416     r = guestfs_write_file (g, path, content, 0);
5417     if (r == -1)
5418       return -1;
5419   }
5420   {
5421     char csumtype[] = "crc";
5422     char path[] = "/new";
5423     char *r;
5424     suppress_error = 0;
5425     r = guestfs_checksum (g, csumtype, path);
5426     if (r == NULL)
5427       return -1;
5428     if (strcmp (r, expected) != 0) {
5429       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5430       return -1;
5431     }
5432     free (r);
5433   }
5434   return 0;
5435 }
5436
5437 static int test_checksum_1_skip (void)
5438 {
5439   const char *str;
5440
5441   str = getenv ("SKIP_TEST_CHECKSUM_1");
5442   if (str && strcmp (str, "1") == 0) return 1;
5443   str = getenv ("SKIP_TEST_CHECKSUM");
5444   if (str && strcmp (str, "1") == 0) return 1;
5445   return 0;
5446 }
5447
5448 static int test_checksum_1 (void)
5449 {
5450   if (test_checksum_1_skip ()) {
5451     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5452     return 0;
5453   }
5454
5455   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5456   {
5457     char device[] = "/dev/sda";
5458     int r;
5459     suppress_error = 0;
5460     r = guestfs_blockdev_setrw (g, device);
5461     if (r == -1)
5462       return -1;
5463   }
5464   {
5465     int r;
5466     suppress_error = 0;
5467     r = guestfs_umount_all (g);
5468     if (r == -1)
5469       return -1;
5470   }
5471   {
5472     int r;
5473     suppress_error = 0;
5474     r = guestfs_lvm_remove_all (g);
5475     if (r == -1)
5476       return -1;
5477   }
5478   {
5479     char device[] = "/dev/sda";
5480     char lines_0[] = ",";
5481     char *lines[] = {
5482       lines_0,
5483       NULL
5484     };
5485     int r;
5486     suppress_error = 0;
5487     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5488     if (r == -1)
5489       return -1;
5490   }
5491   {
5492     char fstype[] = "ext2";
5493     char device[] = "/dev/sda1";
5494     int r;
5495     suppress_error = 0;
5496     r = guestfs_mkfs (g, fstype, device);
5497     if (r == -1)
5498       return -1;
5499   }
5500   {
5501     char device[] = "/dev/sda1";
5502     char mountpoint[] = "/";
5503     int r;
5504     suppress_error = 0;
5505     r = guestfs_mount (g, device, mountpoint);
5506     if (r == -1)
5507       return -1;
5508   }
5509   /* TestLastFail for checksum (1) */
5510   {
5511     char csumtype[] = "crc";
5512     char path[] = "/new";
5513     char *r;
5514     suppress_error = 1;
5515     r = guestfs_checksum (g, csumtype, path);
5516     if (r != NULL)
5517       return -1;
5518     free (r);
5519   }
5520   return 0;
5521 }
5522
5523 static int test_checksum_2_skip (void)
5524 {
5525   const char *str;
5526
5527   str = getenv ("SKIP_TEST_CHECKSUM_2");
5528   if (str && strcmp (str, "1") == 0) return 1;
5529   str = getenv ("SKIP_TEST_CHECKSUM");
5530   if (str && strcmp (str, "1") == 0) return 1;
5531   return 0;
5532 }
5533
5534 static int test_checksum_2 (void)
5535 {
5536   if (test_checksum_2_skip ()) {
5537     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5538     return 0;
5539   }
5540
5541   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5542   {
5543     char device[] = "/dev/sda";
5544     int r;
5545     suppress_error = 0;
5546     r = guestfs_blockdev_setrw (g, device);
5547     if (r == -1)
5548       return -1;
5549   }
5550   {
5551     int r;
5552     suppress_error = 0;
5553     r = guestfs_umount_all (g);
5554     if (r == -1)
5555       return -1;
5556   }
5557   {
5558     int r;
5559     suppress_error = 0;
5560     r = guestfs_lvm_remove_all (g);
5561     if (r == -1)
5562       return -1;
5563   }
5564   {
5565     char device[] = "/dev/sda";
5566     char lines_0[] = ",";
5567     char *lines[] = {
5568       lines_0,
5569       NULL
5570     };
5571     int r;
5572     suppress_error = 0;
5573     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5574     if (r == -1)
5575       return -1;
5576   }
5577   {
5578     char fstype[] = "ext2";
5579     char device[] = "/dev/sda1";
5580     int r;
5581     suppress_error = 0;
5582     r = guestfs_mkfs (g, fstype, device);
5583     if (r == -1)
5584       return -1;
5585   }
5586   {
5587     char device[] = "/dev/sda1";
5588     char mountpoint[] = "/";
5589     int r;
5590     suppress_error = 0;
5591     r = guestfs_mount (g, device, mountpoint);
5592     if (r == -1)
5593       return -1;
5594   }
5595   /* TestOutput for checksum (2) */
5596   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5597   {
5598     char path[] = "/new";
5599     char content[] = "test\n";
5600     int r;
5601     suppress_error = 0;
5602     r = guestfs_write_file (g, path, content, 0);
5603     if (r == -1)
5604       return -1;
5605   }
5606   {
5607     char csumtype[] = "md5";
5608     char path[] = "/new";
5609     char *r;
5610     suppress_error = 0;
5611     r = guestfs_checksum (g, csumtype, path);
5612     if (r == NULL)
5613       return -1;
5614     if (strcmp (r, expected) != 0) {
5615       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5616       return -1;
5617     }
5618     free (r);
5619   }
5620   return 0;
5621 }
5622
5623 static int test_checksum_3_skip (void)
5624 {
5625   const char *str;
5626
5627   str = getenv ("SKIP_TEST_CHECKSUM_3");
5628   if (str && strcmp (str, "1") == 0) return 1;
5629   str = getenv ("SKIP_TEST_CHECKSUM");
5630   if (str && strcmp (str, "1") == 0) return 1;
5631   return 0;
5632 }
5633
5634 static int test_checksum_3 (void)
5635 {
5636   if (test_checksum_3_skip ()) {
5637     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5638     return 0;
5639   }
5640
5641   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5642   {
5643     char device[] = "/dev/sda";
5644     int r;
5645     suppress_error = 0;
5646     r = guestfs_blockdev_setrw (g, device);
5647     if (r == -1)
5648       return -1;
5649   }
5650   {
5651     int r;
5652     suppress_error = 0;
5653     r = guestfs_umount_all (g);
5654     if (r == -1)
5655       return -1;
5656   }
5657   {
5658     int r;
5659     suppress_error = 0;
5660     r = guestfs_lvm_remove_all (g);
5661     if (r == -1)
5662       return -1;
5663   }
5664   {
5665     char device[] = "/dev/sda";
5666     char lines_0[] = ",";
5667     char *lines[] = {
5668       lines_0,
5669       NULL
5670     };
5671     int r;
5672     suppress_error = 0;
5673     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5674     if (r == -1)
5675       return -1;
5676   }
5677   {
5678     char fstype[] = "ext2";
5679     char device[] = "/dev/sda1";
5680     int r;
5681     suppress_error = 0;
5682     r = guestfs_mkfs (g, fstype, device);
5683     if (r == -1)
5684       return -1;
5685   }
5686   {
5687     char device[] = "/dev/sda1";
5688     char mountpoint[] = "/";
5689     int r;
5690     suppress_error = 0;
5691     r = guestfs_mount (g, device, mountpoint);
5692     if (r == -1)
5693       return -1;
5694   }
5695   /* TestOutput for checksum (3) */
5696   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5697   {
5698     char path[] = "/new";
5699     char content[] = "test\n";
5700     int r;
5701     suppress_error = 0;
5702     r = guestfs_write_file (g, path, content, 0);
5703     if (r == -1)
5704       return -1;
5705   }
5706   {
5707     char csumtype[] = "sha1";
5708     char path[] = "/new";
5709     char *r;
5710     suppress_error = 0;
5711     r = guestfs_checksum (g, csumtype, path);
5712     if (r == NULL)
5713       return -1;
5714     if (strcmp (r, expected) != 0) {
5715       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5716       return -1;
5717     }
5718     free (r);
5719   }
5720   return 0;
5721 }
5722
5723 static int test_checksum_4_skip (void)
5724 {
5725   const char *str;
5726
5727   str = getenv ("SKIP_TEST_CHECKSUM_4");
5728   if (str && strcmp (str, "1") == 0) return 1;
5729   str = getenv ("SKIP_TEST_CHECKSUM");
5730   if (str && strcmp (str, "1") == 0) return 1;
5731   return 0;
5732 }
5733
5734 static int test_checksum_4 (void)
5735 {
5736   if (test_checksum_4_skip ()) {
5737     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5738     return 0;
5739   }
5740
5741   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5742   {
5743     char device[] = "/dev/sda";
5744     int r;
5745     suppress_error = 0;
5746     r = guestfs_blockdev_setrw (g, device);
5747     if (r == -1)
5748       return -1;
5749   }
5750   {
5751     int r;
5752     suppress_error = 0;
5753     r = guestfs_umount_all (g);
5754     if (r == -1)
5755       return -1;
5756   }
5757   {
5758     int r;
5759     suppress_error = 0;
5760     r = guestfs_lvm_remove_all (g);
5761     if (r == -1)
5762       return -1;
5763   }
5764   {
5765     char device[] = "/dev/sda";
5766     char lines_0[] = ",";
5767     char *lines[] = {
5768       lines_0,
5769       NULL
5770     };
5771     int r;
5772     suppress_error = 0;
5773     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5774     if (r == -1)
5775       return -1;
5776   }
5777   {
5778     char fstype[] = "ext2";
5779     char device[] = "/dev/sda1";
5780     int r;
5781     suppress_error = 0;
5782     r = guestfs_mkfs (g, fstype, device);
5783     if (r == -1)
5784       return -1;
5785   }
5786   {
5787     char device[] = "/dev/sda1";
5788     char mountpoint[] = "/";
5789     int r;
5790     suppress_error = 0;
5791     r = guestfs_mount (g, device, mountpoint);
5792     if (r == -1)
5793       return -1;
5794   }
5795   /* TestOutput for checksum (4) */
5796   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5797   {
5798     char path[] = "/new";
5799     char content[] = "test\n";
5800     int r;
5801     suppress_error = 0;
5802     r = guestfs_write_file (g, path, content, 0);
5803     if (r == -1)
5804       return -1;
5805   }
5806   {
5807     char csumtype[] = "sha224";
5808     char path[] = "/new";
5809     char *r;
5810     suppress_error = 0;
5811     r = guestfs_checksum (g, csumtype, path);
5812     if (r == NULL)
5813       return -1;
5814     if (strcmp (r, expected) != 0) {
5815       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5816       return -1;
5817     }
5818     free (r);
5819   }
5820   return 0;
5821 }
5822
5823 static int test_checksum_5_skip (void)
5824 {
5825   const char *str;
5826
5827   str = getenv ("SKIP_TEST_CHECKSUM_5");
5828   if (str && strcmp (str, "1") == 0) return 1;
5829   str = getenv ("SKIP_TEST_CHECKSUM");
5830   if (str && strcmp (str, "1") == 0) return 1;
5831   return 0;
5832 }
5833
5834 static int test_checksum_5 (void)
5835 {
5836   if (test_checksum_5_skip ()) {
5837     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5838     return 0;
5839   }
5840
5841   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5842   {
5843     char device[] = "/dev/sda";
5844     int r;
5845     suppress_error = 0;
5846     r = guestfs_blockdev_setrw (g, device);
5847     if (r == -1)
5848       return -1;
5849   }
5850   {
5851     int r;
5852     suppress_error = 0;
5853     r = guestfs_umount_all (g);
5854     if (r == -1)
5855       return -1;
5856   }
5857   {
5858     int r;
5859     suppress_error = 0;
5860     r = guestfs_lvm_remove_all (g);
5861     if (r == -1)
5862       return -1;
5863   }
5864   {
5865     char device[] = "/dev/sda";
5866     char lines_0[] = ",";
5867     char *lines[] = {
5868       lines_0,
5869       NULL
5870     };
5871     int r;
5872     suppress_error = 0;
5873     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5874     if (r == -1)
5875       return -1;
5876   }
5877   {
5878     char fstype[] = "ext2";
5879     char device[] = "/dev/sda1";
5880     int r;
5881     suppress_error = 0;
5882     r = guestfs_mkfs (g, fstype, device);
5883     if (r == -1)
5884       return -1;
5885   }
5886   {
5887     char device[] = "/dev/sda1";
5888     char mountpoint[] = "/";
5889     int r;
5890     suppress_error = 0;
5891     r = guestfs_mount (g, device, mountpoint);
5892     if (r == -1)
5893       return -1;
5894   }
5895   /* TestOutput for checksum (5) */
5896   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5897   {
5898     char path[] = "/new";
5899     char content[] = "test\n";
5900     int r;
5901     suppress_error = 0;
5902     r = guestfs_write_file (g, path, content, 0);
5903     if (r == -1)
5904       return -1;
5905   }
5906   {
5907     char csumtype[] = "sha256";
5908     char path[] = "/new";
5909     char *r;
5910     suppress_error = 0;
5911     r = guestfs_checksum (g, csumtype, path);
5912     if (r == NULL)
5913       return -1;
5914     if (strcmp (r, expected) != 0) {
5915       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5916       return -1;
5917     }
5918     free (r);
5919   }
5920   return 0;
5921 }
5922
5923 static int test_checksum_6_skip (void)
5924 {
5925   const char *str;
5926
5927   str = getenv ("SKIP_TEST_CHECKSUM_6");
5928   if (str && strcmp (str, "1") == 0) return 1;
5929   str = getenv ("SKIP_TEST_CHECKSUM");
5930   if (str && strcmp (str, "1") == 0) return 1;
5931   return 0;
5932 }
5933
5934 static int test_checksum_6 (void)
5935 {
5936   if (test_checksum_6_skip ()) {
5937     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5938     return 0;
5939   }
5940
5941   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5942   {
5943     char device[] = "/dev/sda";
5944     int r;
5945     suppress_error = 0;
5946     r = guestfs_blockdev_setrw (g, device);
5947     if (r == -1)
5948       return -1;
5949   }
5950   {
5951     int r;
5952     suppress_error = 0;
5953     r = guestfs_umount_all (g);
5954     if (r == -1)
5955       return -1;
5956   }
5957   {
5958     int r;
5959     suppress_error = 0;
5960     r = guestfs_lvm_remove_all (g);
5961     if (r == -1)
5962       return -1;
5963   }
5964   {
5965     char device[] = "/dev/sda";
5966     char lines_0[] = ",";
5967     char *lines[] = {
5968       lines_0,
5969       NULL
5970     };
5971     int r;
5972     suppress_error = 0;
5973     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5974     if (r == -1)
5975       return -1;
5976   }
5977   {
5978     char fstype[] = "ext2";
5979     char device[] = "/dev/sda1";
5980     int r;
5981     suppress_error = 0;
5982     r = guestfs_mkfs (g, fstype, device);
5983     if (r == -1)
5984       return -1;
5985   }
5986   {
5987     char device[] = "/dev/sda1";
5988     char mountpoint[] = "/";
5989     int r;
5990     suppress_error = 0;
5991     r = guestfs_mount (g, device, mountpoint);
5992     if (r == -1)
5993       return -1;
5994   }
5995   /* TestOutput for checksum (6) */
5996   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5997   {
5998     char path[] = "/new";
5999     char content[] = "test\n";
6000     int r;
6001     suppress_error = 0;
6002     r = guestfs_write_file (g, path, content, 0);
6003     if (r == -1)
6004       return -1;
6005   }
6006   {
6007     char csumtype[] = "sha384";
6008     char path[] = "/new";
6009     char *r;
6010     suppress_error = 0;
6011     r = guestfs_checksum (g, csumtype, path);
6012     if (r == NULL)
6013       return -1;
6014     if (strcmp (r, expected) != 0) {
6015       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6016       return -1;
6017     }
6018     free (r);
6019   }
6020   return 0;
6021 }
6022
6023 static int test_checksum_7_skip (void)
6024 {
6025   const char *str;
6026
6027   str = getenv ("SKIP_TEST_CHECKSUM_7");
6028   if (str && strcmp (str, "1") == 0) return 1;
6029   str = getenv ("SKIP_TEST_CHECKSUM");
6030   if (str && strcmp (str, "1") == 0) return 1;
6031   return 0;
6032 }
6033
6034 static int test_checksum_7 (void)
6035 {
6036   if (test_checksum_7_skip ()) {
6037     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
6038     return 0;
6039   }
6040
6041   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6042   {
6043     char device[] = "/dev/sda";
6044     int r;
6045     suppress_error = 0;
6046     r = guestfs_blockdev_setrw (g, device);
6047     if (r == -1)
6048       return -1;
6049   }
6050   {
6051     int r;
6052     suppress_error = 0;
6053     r = guestfs_umount_all (g);
6054     if (r == -1)
6055       return -1;
6056   }
6057   {
6058     int r;
6059     suppress_error = 0;
6060     r = guestfs_lvm_remove_all (g);
6061     if (r == -1)
6062       return -1;
6063   }
6064   {
6065     char device[] = "/dev/sda";
6066     char lines_0[] = ",";
6067     char *lines[] = {
6068       lines_0,
6069       NULL
6070     };
6071     int r;
6072     suppress_error = 0;
6073     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6074     if (r == -1)
6075       return -1;
6076   }
6077   {
6078     char fstype[] = "ext2";
6079     char device[] = "/dev/sda1";
6080     int r;
6081     suppress_error = 0;
6082     r = guestfs_mkfs (g, fstype, device);
6083     if (r == -1)
6084       return -1;
6085   }
6086   {
6087     char device[] = "/dev/sda1";
6088     char mountpoint[] = "/";
6089     int r;
6090     suppress_error = 0;
6091     r = guestfs_mount (g, device, mountpoint);
6092     if (r == -1)
6093       return -1;
6094   }
6095   /* TestOutput for checksum (7) */
6096   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6097   {
6098     char path[] = "/new";
6099     char content[] = "test\n";
6100     int r;
6101     suppress_error = 0;
6102     r = guestfs_write_file (g, path, content, 0);
6103     if (r == -1)
6104       return -1;
6105   }
6106   {
6107     char csumtype[] = "sha512";
6108     char path[] = "/new";
6109     char *r;
6110     suppress_error = 0;
6111     r = guestfs_checksum (g, csumtype, path);
6112     if (r == NULL)
6113       return -1;
6114     if (strcmp (r, expected) != 0) {
6115       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6116       return -1;
6117     }
6118     free (r);
6119   }
6120   return 0;
6121 }
6122
6123 static int test_checksum_8_skip (void)
6124 {
6125   const char *str;
6126
6127   str = getenv ("SKIP_TEST_CHECKSUM_8");
6128   if (str && strcmp (str, "1") == 0) return 1;
6129   str = getenv ("SKIP_TEST_CHECKSUM");
6130   if (str && strcmp (str, "1") == 0) return 1;
6131   return 0;
6132 }
6133
6134 static int test_checksum_8 (void)
6135 {
6136   if (test_checksum_8_skip ()) {
6137     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
6138     return 0;
6139   }
6140
6141   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6142   {
6143     char device[] = "/dev/sda";
6144     int r;
6145     suppress_error = 0;
6146     r = guestfs_blockdev_setrw (g, device);
6147     if (r == -1)
6148       return -1;
6149   }
6150   {
6151     int r;
6152     suppress_error = 0;
6153     r = guestfs_umount_all (g);
6154     if (r == -1)
6155       return -1;
6156   }
6157   {
6158     int r;
6159     suppress_error = 0;
6160     r = guestfs_lvm_remove_all (g);
6161     if (r == -1)
6162       return -1;
6163   }
6164   {
6165     char device[] = "/dev/sda";
6166     char lines_0[] = ",";
6167     char *lines[] = {
6168       lines_0,
6169       NULL
6170     };
6171     int r;
6172     suppress_error = 0;
6173     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6174     if (r == -1)
6175       return -1;
6176   }
6177   {
6178     char fstype[] = "ext2";
6179     char device[] = "/dev/sda1";
6180     int r;
6181     suppress_error = 0;
6182     r = guestfs_mkfs (g, fstype, device);
6183     if (r == -1)
6184       return -1;
6185   }
6186   {
6187     char device[] = "/dev/sda1";
6188     char mountpoint[] = "/";
6189     int r;
6190     suppress_error = 0;
6191     r = guestfs_mount (g, device, mountpoint);
6192     if (r == -1)
6193       return -1;
6194   }
6195   /* TestOutput for checksum (8) */
6196   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6197   {
6198     char options[] = "ro";
6199     char vfstype[] = "squashfs";
6200     char device[] = "/dev/sdd";
6201     char mountpoint[] = "/";
6202     int r;
6203     suppress_error = 0;
6204     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
6205     if (r == -1)
6206       return -1;
6207   }
6208   {
6209     char csumtype[] = "md5";
6210     char path[] = "/known-3";
6211     char *r;
6212     suppress_error = 0;
6213     r = guestfs_checksum (g, csumtype, path);
6214     if (r == NULL)
6215       return -1;
6216     if (strcmp (r, expected) != 0) {
6217       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6218       return -1;
6219     }
6220     free (r);
6221   }
6222   return 0;
6223 }
6224
6225 static int test_download_0_skip (void)
6226 {
6227   const char *str;
6228
6229   str = getenv ("SKIP_TEST_DOWNLOAD_0");
6230   if (str && strcmp (str, "1") == 0) return 1;
6231   str = getenv ("SKIP_TEST_DOWNLOAD");
6232   if (str && strcmp (str, "1") == 0) return 1;
6233   return 0;
6234 }
6235
6236 static int test_download_0 (void)
6237 {
6238   if (test_download_0_skip ()) {
6239     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6240     return 0;
6241   }
6242
6243   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
6244   {
6245     char device[] = "/dev/sda";
6246     int r;
6247     suppress_error = 0;
6248     r = guestfs_blockdev_setrw (g, device);
6249     if (r == -1)
6250       return -1;
6251   }
6252   {
6253     int r;
6254     suppress_error = 0;
6255     r = guestfs_umount_all (g);
6256     if (r == -1)
6257       return -1;
6258   }
6259   {
6260     int r;
6261     suppress_error = 0;
6262     r = guestfs_lvm_remove_all (g);
6263     if (r == -1)
6264       return -1;
6265   }
6266   {
6267     char device[] = "/dev/sda";
6268     char lines_0[] = ",";
6269     char *lines[] = {
6270       lines_0,
6271       NULL
6272     };
6273     int r;
6274     suppress_error = 0;
6275     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6276     if (r == -1)
6277       return -1;
6278   }
6279   {
6280     char fstype[] = "ext2";
6281     char device[] = "/dev/sda1";
6282     int r;
6283     suppress_error = 0;
6284     r = guestfs_mkfs (g, fstype, device);
6285     if (r == -1)
6286       return -1;
6287   }
6288   {
6289     char device[] = "/dev/sda1";
6290     char mountpoint[] = "/";
6291     int r;
6292     suppress_error = 0;
6293     r = guestfs_mount (g, device, mountpoint);
6294     if (r == -1)
6295       return -1;
6296   }
6297   /* TestOutput for download (0) */
6298   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6299   {
6300     char remotefilename[] = "/COPYING.LIB";
6301     int r;
6302     suppress_error = 0;
6303     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6304     if (r == -1)
6305       return -1;
6306   }
6307   {
6308     char remotefilename[] = "/COPYING.LIB";
6309     int r;
6310     suppress_error = 0;
6311     r = guestfs_download (g, remotefilename, "testdownload.tmp");
6312     if (r == -1)
6313       return -1;
6314   }
6315   {
6316     char remotefilename[] = "/upload";
6317     int r;
6318     suppress_error = 0;
6319     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6320     if (r == -1)
6321       return -1;
6322   }
6323   {
6324     char csumtype[] = "md5";
6325     char path[] = "/upload";
6326     char *r;
6327     suppress_error = 0;
6328     r = guestfs_checksum (g, csumtype, path);
6329     if (r == NULL)
6330       return -1;
6331     if (strcmp (r, expected) != 0) {
6332       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6333       return -1;
6334     }
6335     free (r);
6336   }
6337   return 0;
6338 }
6339
6340 static int test_upload_0_skip (void)
6341 {
6342   const char *str;
6343
6344   str = getenv ("SKIP_TEST_UPLOAD_0");
6345   if (str && strcmp (str, "1") == 0) return 1;
6346   str = getenv ("SKIP_TEST_UPLOAD");
6347   if (str && strcmp (str, "1") == 0) return 1;
6348   return 0;
6349 }
6350
6351 static int test_upload_0 (void)
6352 {
6353   if (test_upload_0_skip ()) {
6354     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6355     return 0;
6356   }
6357
6358   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6359   {
6360     char device[] = "/dev/sda";
6361     int r;
6362     suppress_error = 0;
6363     r = guestfs_blockdev_setrw (g, device);
6364     if (r == -1)
6365       return -1;
6366   }
6367   {
6368     int r;
6369     suppress_error = 0;
6370     r = guestfs_umount_all (g);
6371     if (r == -1)
6372       return -1;
6373   }
6374   {
6375     int r;
6376     suppress_error = 0;
6377     r = guestfs_lvm_remove_all (g);
6378     if (r == -1)
6379       return -1;
6380   }
6381   {
6382     char device[] = "/dev/sda";
6383     char lines_0[] = ",";
6384     char *lines[] = {
6385       lines_0,
6386       NULL
6387     };
6388     int r;
6389     suppress_error = 0;
6390     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6391     if (r == -1)
6392       return -1;
6393   }
6394   {
6395     char fstype[] = "ext2";
6396     char device[] = "/dev/sda1";
6397     int r;
6398     suppress_error = 0;
6399     r = guestfs_mkfs (g, fstype, device);
6400     if (r == -1)
6401       return -1;
6402   }
6403   {
6404     char device[] = "/dev/sda1";
6405     char mountpoint[] = "/";
6406     int r;
6407     suppress_error = 0;
6408     r = guestfs_mount (g, device, mountpoint);
6409     if (r == -1)
6410       return -1;
6411   }
6412   /* TestOutput for upload (0) */
6413   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6414   {
6415     char remotefilename[] = "/COPYING.LIB";
6416     int r;
6417     suppress_error = 0;
6418     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6419     if (r == -1)
6420       return -1;
6421   }
6422   {
6423     char csumtype[] = "md5";
6424     char path[] = "/COPYING.LIB";
6425     char *r;
6426     suppress_error = 0;
6427     r = guestfs_checksum (g, csumtype, path);
6428     if (r == NULL)
6429       return -1;
6430     if (strcmp (r, expected) != 0) {
6431       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6432       return -1;
6433     }
6434     free (r);
6435   }
6436   return 0;
6437 }
6438
6439 static int test_blockdev_rereadpt_0_skip (void)
6440 {
6441   const char *str;
6442
6443   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6444   if (str && strcmp (str, "1") == 0) return 1;
6445   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6446   if (str && strcmp (str, "1") == 0) return 1;
6447   return 0;
6448 }
6449
6450 static int test_blockdev_rereadpt_0 (void)
6451 {
6452   if (test_blockdev_rereadpt_0_skip ()) {
6453     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6454     return 0;
6455   }
6456
6457   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6458   {
6459     char device[] = "/dev/sda";
6460     int r;
6461     suppress_error = 0;
6462     r = guestfs_blockdev_setrw (g, device);
6463     if (r == -1)
6464       return -1;
6465   }
6466   {
6467     int r;
6468     suppress_error = 0;
6469     r = guestfs_umount_all (g);
6470     if (r == -1)
6471       return -1;
6472   }
6473   {
6474     int r;
6475     suppress_error = 0;
6476     r = guestfs_lvm_remove_all (g);
6477     if (r == -1)
6478       return -1;
6479   }
6480   /* TestRun for blockdev_rereadpt (0) */
6481   {
6482     char device[] = "/dev/sda";
6483     int r;
6484     suppress_error = 0;
6485     r = guestfs_blockdev_rereadpt (g, device);
6486     if (r == -1)
6487       return -1;
6488   }
6489   return 0;
6490 }
6491
6492 static int test_blockdev_flushbufs_0_skip (void)
6493 {
6494   const char *str;
6495
6496   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6497   if (str && strcmp (str, "1") == 0) return 1;
6498   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6499   if (str && strcmp (str, "1") == 0) return 1;
6500   return 0;
6501 }
6502
6503 static int test_blockdev_flushbufs_0 (void)
6504 {
6505   if (test_blockdev_flushbufs_0_skip ()) {
6506     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6507     return 0;
6508   }
6509
6510   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6511   {
6512     char device[] = "/dev/sda";
6513     int r;
6514     suppress_error = 0;
6515     r = guestfs_blockdev_setrw (g, device);
6516     if (r == -1)
6517       return -1;
6518   }
6519   {
6520     int r;
6521     suppress_error = 0;
6522     r = guestfs_umount_all (g);
6523     if (r == -1)
6524       return -1;
6525   }
6526   {
6527     int r;
6528     suppress_error = 0;
6529     r = guestfs_lvm_remove_all (g);
6530     if (r == -1)
6531       return -1;
6532   }
6533   /* TestRun for blockdev_flushbufs (0) */
6534   {
6535     char device[] = "/dev/sda";
6536     int r;
6537     suppress_error = 0;
6538     r = guestfs_blockdev_flushbufs (g, device);
6539     if (r == -1)
6540       return -1;
6541   }
6542   return 0;
6543 }
6544
6545 static int test_blockdev_getsize64_0_skip (void)
6546 {
6547   const char *str;
6548
6549   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6550   if (str && strcmp (str, "1") == 0) return 1;
6551   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6552   if (str && strcmp (str, "1") == 0) return 1;
6553   return 0;
6554 }
6555
6556 static int test_blockdev_getsize64_0 (void)
6557 {
6558   if (test_blockdev_getsize64_0_skip ()) {
6559     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6560     return 0;
6561   }
6562
6563   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6564   {
6565     char device[] = "/dev/sda";
6566     int r;
6567     suppress_error = 0;
6568     r = guestfs_blockdev_setrw (g, device);
6569     if (r == -1)
6570       return -1;
6571   }
6572   {
6573     int r;
6574     suppress_error = 0;
6575     r = guestfs_umount_all (g);
6576     if (r == -1)
6577       return -1;
6578   }
6579   {
6580     int r;
6581     suppress_error = 0;
6582     r = guestfs_lvm_remove_all (g);
6583     if (r == -1)
6584       return -1;
6585   }
6586   /* TestOutputInt for blockdev_getsize64 (0) */
6587   {
6588     char device[] = "/dev/sda";
6589     int64_t r;
6590     suppress_error = 0;
6591     r = guestfs_blockdev_getsize64 (g, device);
6592     if (r == -1)
6593       return -1;
6594     if (r != 524288000) {
6595       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6596       return -1;
6597     }
6598   }
6599   return 0;
6600 }
6601
6602 static int test_blockdev_getsz_0_skip (void)
6603 {
6604   const char *str;
6605
6606   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6607   if (str && strcmp (str, "1") == 0) return 1;
6608   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6609   if (str && strcmp (str, "1") == 0) return 1;
6610   return 0;
6611 }
6612
6613 static int test_blockdev_getsz_0 (void)
6614 {
6615   if (test_blockdev_getsz_0_skip ()) {
6616     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6617     return 0;
6618   }
6619
6620   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6621   {
6622     char device[] = "/dev/sda";
6623     int r;
6624     suppress_error = 0;
6625     r = guestfs_blockdev_setrw (g, device);
6626     if (r == -1)
6627       return -1;
6628   }
6629   {
6630     int r;
6631     suppress_error = 0;
6632     r = guestfs_umount_all (g);
6633     if (r == -1)
6634       return -1;
6635   }
6636   {
6637     int r;
6638     suppress_error = 0;
6639     r = guestfs_lvm_remove_all (g);
6640     if (r == -1)
6641       return -1;
6642   }
6643   /* TestOutputInt for blockdev_getsz (0) */
6644   {
6645     char device[] = "/dev/sda";
6646     int64_t r;
6647     suppress_error = 0;
6648     r = guestfs_blockdev_getsz (g, device);
6649     if (r == -1)
6650       return -1;
6651     if (r != 1024000) {
6652       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6653       return -1;
6654     }
6655   }
6656   return 0;
6657 }
6658
6659 static int test_blockdev_getbsz_0_skip (void)
6660 {
6661   const char *str;
6662
6663   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6664   if (str && strcmp (str, "1") == 0) return 1;
6665   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6666   if (str && strcmp (str, "1") == 0) return 1;
6667   return 0;
6668 }
6669
6670 static int test_blockdev_getbsz_0 (void)
6671 {
6672   if (test_blockdev_getbsz_0_skip ()) {
6673     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6674     return 0;
6675   }
6676
6677   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6678   {
6679     char device[] = "/dev/sda";
6680     int r;
6681     suppress_error = 0;
6682     r = guestfs_blockdev_setrw (g, device);
6683     if (r == -1)
6684       return -1;
6685   }
6686   {
6687     int r;
6688     suppress_error = 0;
6689     r = guestfs_umount_all (g);
6690     if (r == -1)
6691       return -1;
6692   }
6693   {
6694     int r;
6695     suppress_error = 0;
6696     r = guestfs_lvm_remove_all (g);
6697     if (r == -1)
6698       return -1;
6699   }
6700   /* TestOutputInt for blockdev_getbsz (0) */
6701   {
6702     char device[] = "/dev/sda";
6703     int r;
6704     suppress_error = 0;
6705     r = guestfs_blockdev_getbsz (g, device);
6706     if (r == -1)
6707       return -1;
6708     if (r != 4096) {
6709       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6710       return -1;
6711     }
6712   }
6713   return 0;
6714 }
6715
6716 static int test_blockdev_getss_0_skip (void)
6717 {
6718   const char *str;
6719
6720   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6721   if (str && strcmp (str, "1") == 0) return 1;
6722   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6723   if (str && strcmp (str, "1") == 0) return 1;
6724   return 0;
6725 }
6726
6727 static int test_blockdev_getss_0 (void)
6728 {
6729   if (test_blockdev_getss_0_skip ()) {
6730     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6731     return 0;
6732   }
6733
6734   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6735   {
6736     char device[] = "/dev/sda";
6737     int r;
6738     suppress_error = 0;
6739     r = guestfs_blockdev_setrw (g, device);
6740     if (r == -1)
6741       return -1;
6742   }
6743   {
6744     int r;
6745     suppress_error = 0;
6746     r = guestfs_umount_all (g);
6747     if (r == -1)
6748       return -1;
6749   }
6750   {
6751     int r;
6752     suppress_error = 0;
6753     r = guestfs_lvm_remove_all (g);
6754     if (r == -1)
6755       return -1;
6756   }
6757   /* TestOutputInt for blockdev_getss (0) */
6758   {
6759     char device[] = "/dev/sda";
6760     int r;
6761     suppress_error = 0;
6762     r = guestfs_blockdev_getss (g, device);
6763     if (r == -1)
6764       return -1;
6765     if (r != 512) {
6766       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6767       return -1;
6768     }
6769   }
6770   return 0;
6771 }
6772
6773 static int test_blockdev_getro_0_skip (void)
6774 {
6775   const char *str;
6776
6777   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6778   if (str && strcmp (str, "1") == 0) return 1;
6779   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6780   if (str && strcmp (str, "1") == 0) return 1;
6781   return 0;
6782 }
6783
6784 static int test_blockdev_getro_0 (void)
6785 {
6786   if (test_blockdev_getro_0_skip ()) {
6787     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6788     return 0;
6789   }
6790
6791   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6792   {
6793     char device[] = "/dev/sda";
6794     int r;
6795     suppress_error = 0;
6796     r = guestfs_blockdev_setrw (g, device);
6797     if (r == -1)
6798       return -1;
6799   }
6800   {
6801     int r;
6802     suppress_error = 0;
6803     r = guestfs_umount_all (g);
6804     if (r == -1)
6805       return -1;
6806   }
6807   {
6808     int r;
6809     suppress_error = 0;
6810     r = guestfs_lvm_remove_all (g);
6811     if (r == -1)
6812       return -1;
6813   }
6814   /* TestOutputTrue for blockdev_getro (0) */
6815   {
6816     char device[] = "/dev/sda";
6817     int r;
6818     suppress_error = 0;
6819     r = guestfs_blockdev_setro (g, device);
6820     if (r == -1)
6821       return -1;
6822   }
6823   {
6824     char device[] = "/dev/sda";
6825     int r;
6826     suppress_error = 0;
6827     r = guestfs_blockdev_getro (g, device);
6828     if (r == -1)
6829       return -1;
6830     if (!r) {
6831       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6832       return -1;
6833     }
6834   }
6835   return 0;
6836 }
6837
6838 static int test_blockdev_setrw_0_skip (void)
6839 {
6840   const char *str;
6841
6842   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6843   if (str && strcmp (str, "1") == 0) return 1;
6844   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6845   if (str && strcmp (str, "1") == 0) return 1;
6846   return 0;
6847 }
6848
6849 static int test_blockdev_setrw_0 (void)
6850 {
6851   if (test_blockdev_setrw_0_skip ()) {
6852     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6853     return 0;
6854   }
6855
6856   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6857   {
6858     char device[] = "/dev/sda";
6859     int r;
6860     suppress_error = 0;
6861     r = guestfs_blockdev_setrw (g, device);
6862     if (r == -1)
6863       return -1;
6864   }
6865   {
6866     int r;
6867     suppress_error = 0;
6868     r = guestfs_umount_all (g);
6869     if (r == -1)
6870       return -1;
6871   }
6872   {
6873     int r;
6874     suppress_error = 0;
6875     r = guestfs_lvm_remove_all (g);
6876     if (r == -1)
6877       return -1;
6878   }
6879   /* TestOutputFalse for blockdev_setrw (0) */
6880   {
6881     char device[] = "/dev/sda";
6882     int r;
6883     suppress_error = 0;
6884     r = guestfs_blockdev_setrw (g, device);
6885     if (r == -1)
6886       return -1;
6887   }
6888   {
6889     char device[] = "/dev/sda";
6890     int r;
6891     suppress_error = 0;
6892     r = guestfs_blockdev_getro (g, device);
6893     if (r == -1)
6894       return -1;
6895     if (r) {
6896       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6897       return -1;
6898     }
6899   }
6900   return 0;
6901 }
6902
6903 static int test_blockdev_setro_0_skip (void)
6904 {
6905   const char *str;
6906
6907   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6908   if (str && strcmp (str, "1") == 0) return 1;
6909   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6910   if (str && strcmp (str, "1") == 0) return 1;
6911   return 0;
6912 }
6913
6914 static int test_blockdev_setro_0 (void)
6915 {
6916   if (test_blockdev_setro_0_skip ()) {
6917     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6918     return 0;
6919   }
6920
6921   /* InitNone|InitEmpty for test_blockdev_setro_0 */
6922   {
6923     char device[] = "/dev/sda";
6924     int r;
6925     suppress_error = 0;
6926     r = guestfs_blockdev_setrw (g, device);
6927     if (r == -1)
6928       return -1;
6929   }
6930   {
6931     int r;
6932     suppress_error = 0;
6933     r = guestfs_umount_all (g);
6934     if (r == -1)
6935       return -1;
6936   }
6937   {
6938     int r;
6939     suppress_error = 0;
6940     r = guestfs_lvm_remove_all (g);
6941     if (r == -1)
6942       return -1;
6943   }
6944   /* TestOutputTrue for blockdev_setro (0) */
6945   {
6946     char device[] = "/dev/sda";
6947     int r;
6948     suppress_error = 0;
6949     r = guestfs_blockdev_setro (g, device);
6950     if (r == -1)
6951       return -1;
6952   }
6953   {
6954     char device[] = "/dev/sda";
6955     int r;
6956     suppress_error = 0;
6957     r = guestfs_blockdev_getro (g, device);
6958     if (r == -1)
6959       return -1;
6960     if (!r) {
6961       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6962       return -1;
6963     }
6964   }
6965   return 0;
6966 }
6967
6968 static int test_statvfs_0_skip (void)
6969 {
6970   const char *str;
6971
6972   str = getenv ("SKIP_TEST_STATVFS_0");
6973   if (str && strcmp (str, "1") == 0) return 1;
6974   str = getenv ("SKIP_TEST_STATVFS");
6975   if (str && strcmp (str, "1") == 0) return 1;
6976   return 0;
6977 }
6978
6979 static int test_statvfs_0 (void)
6980 {
6981   if (test_statvfs_0_skip ()) {
6982     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6983     return 0;
6984   }
6985
6986   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6987   {
6988     char device[] = "/dev/sda";
6989     int r;
6990     suppress_error = 0;
6991     r = guestfs_blockdev_setrw (g, device);
6992     if (r == -1)
6993       return -1;
6994   }
6995   {
6996     int r;
6997     suppress_error = 0;
6998     r = guestfs_umount_all (g);
6999     if (r == -1)
7000       return -1;
7001   }
7002   {
7003     int r;
7004     suppress_error = 0;
7005     r = guestfs_lvm_remove_all (g);
7006     if (r == -1)
7007       return -1;
7008   }
7009   {
7010     char device[] = "/dev/sda";
7011     char lines_0[] = ",";
7012     char *lines[] = {
7013       lines_0,
7014       NULL
7015     };
7016     int r;
7017     suppress_error = 0;
7018     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7019     if (r == -1)
7020       return -1;
7021   }
7022   {
7023     char fstype[] = "ext2";
7024     char device[] = "/dev/sda1";
7025     int r;
7026     suppress_error = 0;
7027     r = guestfs_mkfs (g, fstype, device);
7028     if (r == -1)
7029       return -1;
7030   }
7031   {
7032     char device[] = "/dev/sda1";
7033     char mountpoint[] = "/";
7034     int r;
7035     suppress_error = 0;
7036     r = guestfs_mount (g, device, mountpoint);
7037     if (r == -1)
7038       return -1;
7039   }
7040   /* TestOutputStruct for statvfs (0) */
7041   {
7042     char path[] = "/";
7043     struct guestfs_statvfs *r;
7044     suppress_error = 0;
7045     r = guestfs_statvfs (g, path);
7046     if (r == NULL)
7047       return -1;
7048     if (r->bfree != 487702) {
7049       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7050                (int) r->bfree);
7051       return -1;
7052     }
7053     if (r->blocks != 490020) {
7054       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7055                (int) r->blocks);
7056       return -1;
7057     }
7058     if (r->bsize != 1024) {
7059       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7060                (int) r->bsize);
7061       return -1;
7062     }
7063     free (r);
7064   }
7065   return 0;
7066 }
7067
7068 static int test_lstat_0_skip (void)
7069 {
7070   const char *str;
7071
7072   str = getenv ("SKIP_TEST_LSTAT_0");
7073   if (str && strcmp (str, "1") == 0) return 1;
7074   str = getenv ("SKIP_TEST_LSTAT");
7075   if (str && strcmp (str, "1") == 0) return 1;
7076   return 0;
7077 }
7078
7079 static int test_lstat_0 (void)
7080 {
7081   if (test_lstat_0_skip ()) {
7082     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
7083     return 0;
7084   }
7085
7086   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7087   {
7088     char device[] = "/dev/sda";
7089     int r;
7090     suppress_error = 0;
7091     r = guestfs_blockdev_setrw (g, device);
7092     if (r == -1)
7093       return -1;
7094   }
7095   {
7096     int r;
7097     suppress_error = 0;
7098     r = guestfs_umount_all (g);
7099     if (r == -1)
7100       return -1;
7101   }
7102   {
7103     int r;
7104     suppress_error = 0;
7105     r = guestfs_lvm_remove_all (g);
7106     if (r == -1)
7107       return -1;
7108   }
7109   {
7110     char device[] = "/dev/sda";
7111     char lines_0[] = ",";
7112     char *lines[] = {
7113       lines_0,
7114       NULL
7115     };
7116     int r;
7117     suppress_error = 0;
7118     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7119     if (r == -1)
7120       return -1;
7121   }
7122   {
7123     char fstype[] = "ext2";
7124     char device[] = "/dev/sda1";
7125     int r;
7126     suppress_error = 0;
7127     r = guestfs_mkfs (g, fstype, device);
7128     if (r == -1)
7129       return -1;
7130   }
7131   {
7132     char device[] = "/dev/sda1";
7133     char mountpoint[] = "/";
7134     int r;
7135     suppress_error = 0;
7136     r = guestfs_mount (g, device, mountpoint);
7137     if (r == -1)
7138       return -1;
7139   }
7140   /* TestOutputStruct for lstat (0) */
7141   {
7142     char path[] = "/new";
7143     int r;
7144     suppress_error = 0;
7145     r = guestfs_touch (g, path);
7146     if (r == -1)
7147       return -1;
7148   }
7149   {
7150     char path[] = "/new";
7151     struct guestfs_stat *r;
7152     suppress_error = 0;
7153     r = guestfs_lstat (g, path);
7154     if (r == NULL)
7155       return -1;
7156     if (r->size != 0) {
7157       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7158                (int) r->size);
7159       return -1;
7160     }
7161     free (r);
7162   }
7163   return 0;
7164 }
7165
7166 static int test_stat_0_skip (void)
7167 {
7168   const char *str;
7169
7170   str = getenv ("SKIP_TEST_STAT_0");
7171   if (str && strcmp (str, "1") == 0) return 1;
7172   str = getenv ("SKIP_TEST_STAT");
7173   if (str && strcmp (str, "1") == 0) return 1;
7174   return 0;
7175 }
7176
7177 static int test_stat_0 (void)
7178 {
7179   if (test_stat_0_skip ()) {
7180     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7181     return 0;
7182   }
7183
7184   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7185   {
7186     char device[] = "/dev/sda";
7187     int r;
7188     suppress_error = 0;
7189     r = guestfs_blockdev_setrw (g, device);
7190     if (r == -1)
7191       return -1;
7192   }
7193   {
7194     int r;
7195     suppress_error = 0;
7196     r = guestfs_umount_all (g);
7197     if (r == -1)
7198       return -1;
7199   }
7200   {
7201     int r;
7202     suppress_error = 0;
7203     r = guestfs_lvm_remove_all (g);
7204     if (r == -1)
7205       return -1;
7206   }
7207   {
7208     char device[] = "/dev/sda";
7209     char lines_0[] = ",";
7210     char *lines[] = {
7211       lines_0,
7212       NULL
7213     };
7214     int r;
7215     suppress_error = 0;
7216     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7217     if (r == -1)
7218       return -1;
7219   }
7220   {
7221     char fstype[] = "ext2";
7222     char device[] = "/dev/sda1";
7223     int r;
7224     suppress_error = 0;
7225     r = guestfs_mkfs (g, fstype, device);
7226     if (r == -1)
7227       return -1;
7228   }
7229   {
7230     char device[] = "/dev/sda1";
7231     char mountpoint[] = "/";
7232     int r;
7233     suppress_error = 0;
7234     r = guestfs_mount (g, device, mountpoint);
7235     if (r == -1)
7236       return -1;
7237   }
7238   /* TestOutputStruct for stat (0) */
7239   {
7240     char path[] = "/new";
7241     int r;
7242     suppress_error = 0;
7243     r = guestfs_touch (g, path);
7244     if (r == -1)
7245       return -1;
7246   }
7247   {
7248     char path[] = "/new";
7249     struct guestfs_stat *r;
7250     suppress_error = 0;
7251     r = guestfs_stat (g, path);
7252     if (r == NULL)
7253       return -1;
7254     if (r->size != 0) {
7255       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7256                (int) r->size);
7257       return -1;
7258     }
7259     free (r);
7260   }
7261   return 0;
7262 }
7263
7264 static int test_command_lines_0_skip (void)
7265 {
7266   const char *str;
7267
7268   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7269   if (str && strcmp (str, "1") == 0) return 1;
7270   str = getenv ("SKIP_TEST_COMMAND_LINES");
7271   if (str && strcmp (str, "1") == 0) return 1;
7272   return 0;
7273 }
7274
7275 static int test_command_lines_0 (void)
7276 {
7277   if (test_command_lines_0_skip ()) {
7278     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7279     return 0;
7280   }
7281
7282   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7283   {
7284     char device[] = "/dev/sda";
7285     int r;
7286     suppress_error = 0;
7287     r = guestfs_blockdev_setrw (g, device);
7288     if (r == -1)
7289       return -1;
7290   }
7291   {
7292     int r;
7293     suppress_error = 0;
7294     r = guestfs_umount_all (g);
7295     if (r == -1)
7296       return -1;
7297   }
7298   {
7299     int r;
7300     suppress_error = 0;
7301     r = guestfs_lvm_remove_all (g);
7302     if (r == -1)
7303       return -1;
7304   }
7305   {
7306     char device[] = "/dev/sda";
7307     char lines_0[] = ",";
7308     char *lines[] = {
7309       lines_0,
7310       NULL
7311     };
7312     int r;
7313     suppress_error = 0;
7314     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7315     if (r == -1)
7316       return -1;
7317   }
7318   {
7319     char fstype[] = "ext2";
7320     char device[] = "/dev/sda1";
7321     int r;
7322     suppress_error = 0;
7323     r = guestfs_mkfs (g, fstype, device);
7324     if (r == -1)
7325       return -1;
7326   }
7327   {
7328     char device[] = "/dev/sda1";
7329     char mountpoint[] = "/";
7330     int r;
7331     suppress_error = 0;
7332     r = guestfs_mount (g, device, mountpoint);
7333     if (r == -1)
7334       return -1;
7335   }
7336   /* TestOutputList for command_lines (0) */
7337   {
7338     char remotefilename[] = "/test-command";
7339     int r;
7340     suppress_error = 0;
7341     r = guestfs_upload (g, "test-command", remotefilename);
7342     if (r == -1)
7343       return -1;
7344   }
7345   {
7346     char path[] = "/test-command";
7347     int r;
7348     suppress_error = 0;
7349     r = guestfs_chmod (g, 493, path);
7350     if (r == -1)
7351       return -1;
7352   }
7353   {
7354     char arguments_0[] = "/test-command";
7355     char arguments_1[] = "1";
7356     char *arguments[] = {
7357       arguments_0,
7358       arguments_1,
7359       NULL
7360     };
7361     char **r;
7362     int i;
7363     suppress_error = 0;
7364     r = guestfs_command_lines (g, arguments);
7365     if (r == NULL)
7366       return -1;
7367     if (!r[0]) {
7368       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7369       print_strings (r);
7370       return -1;
7371     }
7372     {
7373       char expected[] = "Result1";
7374       if (strcmp (r[0], expected) != 0) {
7375         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7376         return -1;
7377       }
7378     }
7379     if (r[1] != NULL) {
7380       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7381       print_strings (r);
7382       return -1;
7383     }
7384     for (i = 0; r[i] != NULL; ++i)
7385       free (r[i]);
7386     free (r);
7387   }
7388   return 0;
7389 }
7390
7391 static int test_command_lines_1_skip (void)
7392 {
7393   const char *str;
7394
7395   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7396   if (str && strcmp (str, "1") == 0) return 1;
7397   str = getenv ("SKIP_TEST_COMMAND_LINES");
7398   if (str && strcmp (str, "1") == 0) return 1;
7399   return 0;
7400 }
7401
7402 static int test_command_lines_1 (void)
7403 {
7404   if (test_command_lines_1_skip ()) {
7405     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7406     return 0;
7407   }
7408
7409   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7410   {
7411     char device[] = "/dev/sda";
7412     int r;
7413     suppress_error = 0;
7414     r = guestfs_blockdev_setrw (g, device);
7415     if (r == -1)
7416       return -1;
7417   }
7418   {
7419     int r;
7420     suppress_error = 0;
7421     r = guestfs_umount_all (g);
7422     if (r == -1)
7423       return -1;
7424   }
7425   {
7426     int r;
7427     suppress_error = 0;
7428     r = guestfs_lvm_remove_all (g);
7429     if (r == -1)
7430       return -1;
7431   }
7432   {
7433     char device[] = "/dev/sda";
7434     char lines_0[] = ",";
7435     char *lines[] = {
7436       lines_0,
7437       NULL
7438     };
7439     int r;
7440     suppress_error = 0;
7441     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7442     if (r == -1)
7443       return -1;
7444   }
7445   {
7446     char fstype[] = "ext2";
7447     char device[] = "/dev/sda1";
7448     int r;
7449     suppress_error = 0;
7450     r = guestfs_mkfs (g, fstype, device);
7451     if (r == -1)
7452       return -1;
7453   }
7454   {
7455     char device[] = "/dev/sda1";
7456     char mountpoint[] = "/";
7457     int r;
7458     suppress_error = 0;
7459     r = guestfs_mount (g, device, mountpoint);
7460     if (r == -1)
7461       return -1;
7462   }
7463   /* TestOutputList for command_lines (1) */
7464   {
7465     char remotefilename[] = "/test-command";
7466     int r;
7467     suppress_error = 0;
7468     r = guestfs_upload (g, "test-command", remotefilename);
7469     if (r == -1)
7470       return -1;
7471   }
7472   {
7473     char path[] = "/test-command";
7474     int r;
7475     suppress_error = 0;
7476     r = guestfs_chmod (g, 493, path);
7477     if (r == -1)
7478       return -1;
7479   }
7480   {
7481     char arguments_0[] = "/test-command";
7482     char arguments_1[] = "2";
7483     char *arguments[] = {
7484       arguments_0,
7485       arguments_1,
7486       NULL
7487     };
7488     char **r;
7489     int i;
7490     suppress_error = 0;
7491     r = guestfs_command_lines (g, arguments);
7492     if (r == NULL)
7493       return -1;
7494     if (!r[0]) {
7495       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7496       print_strings (r);
7497       return -1;
7498     }
7499     {
7500       char expected[] = "Result2";
7501       if (strcmp (r[0], expected) != 0) {
7502         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7503         return -1;
7504       }
7505     }
7506     if (r[1] != NULL) {
7507       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7508       print_strings (r);
7509       return -1;
7510     }
7511     for (i = 0; r[i] != NULL; ++i)
7512       free (r[i]);
7513     free (r);
7514   }
7515   return 0;
7516 }
7517
7518 static int test_command_lines_2_skip (void)
7519 {
7520   const char *str;
7521
7522   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7523   if (str && strcmp (str, "1") == 0) return 1;
7524   str = getenv ("SKIP_TEST_COMMAND_LINES");
7525   if (str && strcmp (str, "1") == 0) return 1;
7526   return 0;
7527 }
7528
7529 static int test_command_lines_2 (void)
7530 {
7531   if (test_command_lines_2_skip ()) {
7532     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7533     return 0;
7534   }
7535
7536   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7537   {
7538     char device[] = "/dev/sda";
7539     int r;
7540     suppress_error = 0;
7541     r = guestfs_blockdev_setrw (g, device);
7542     if (r == -1)
7543       return -1;
7544   }
7545   {
7546     int r;
7547     suppress_error = 0;
7548     r = guestfs_umount_all (g);
7549     if (r == -1)
7550       return -1;
7551   }
7552   {
7553     int r;
7554     suppress_error = 0;
7555     r = guestfs_lvm_remove_all (g);
7556     if (r == -1)
7557       return -1;
7558   }
7559   {
7560     char device[] = "/dev/sda";
7561     char lines_0[] = ",";
7562     char *lines[] = {
7563       lines_0,
7564       NULL
7565     };
7566     int r;
7567     suppress_error = 0;
7568     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7569     if (r == -1)
7570       return -1;
7571   }
7572   {
7573     char fstype[] = "ext2";
7574     char device[] = "/dev/sda1";
7575     int r;
7576     suppress_error = 0;
7577     r = guestfs_mkfs (g, fstype, device);
7578     if (r == -1)
7579       return -1;
7580   }
7581   {
7582     char device[] = "/dev/sda1";
7583     char mountpoint[] = "/";
7584     int r;
7585     suppress_error = 0;
7586     r = guestfs_mount (g, device, mountpoint);
7587     if (r == -1)
7588       return -1;
7589   }
7590   /* TestOutputList for command_lines (2) */
7591   {
7592     char remotefilename[] = "/test-command";
7593     int r;
7594     suppress_error = 0;
7595     r = guestfs_upload (g, "test-command", remotefilename);
7596     if (r == -1)
7597       return -1;
7598   }
7599   {
7600     char path[] = "/test-command";
7601     int r;
7602     suppress_error = 0;
7603     r = guestfs_chmod (g, 493, path);
7604     if (r == -1)
7605       return -1;
7606   }
7607   {
7608     char arguments_0[] = "/test-command";
7609     char arguments_1[] = "3";
7610     char *arguments[] = {
7611       arguments_0,
7612       arguments_1,
7613       NULL
7614     };
7615     char **r;
7616     int i;
7617     suppress_error = 0;
7618     r = guestfs_command_lines (g, arguments);
7619     if (r == NULL)
7620       return -1;
7621     if (!r[0]) {
7622       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7623       print_strings (r);
7624       return -1;
7625     }
7626     {
7627       char expected[] = "";
7628       if (strcmp (r[0], expected) != 0) {
7629         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7630         return -1;
7631       }
7632     }
7633     if (!r[1]) {
7634       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7635       print_strings (r);
7636       return -1;
7637     }
7638     {
7639       char expected[] = "Result3";
7640       if (strcmp (r[1], expected) != 0) {
7641         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7642         return -1;
7643       }
7644     }
7645     if (r[2] != NULL) {
7646       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7647       print_strings (r);
7648       return -1;
7649     }
7650     for (i = 0; r[i] != NULL; ++i)
7651       free (r[i]);
7652     free (r);
7653   }
7654   return 0;
7655 }
7656
7657 static int test_command_lines_3_skip (void)
7658 {
7659   const char *str;
7660
7661   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7662   if (str && strcmp (str, "1") == 0) return 1;
7663   str = getenv ("SKIP_TEST_COMMAND_LINES");
7664   if (str && strcmp (str, "1") == 0) return 1;
7665   return 0;
7666 }
7667
7668 static int test_command_lines_3 (void)
7669 {
7670   if (test_command_lines_3_skip ()) {
7671     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7672     return 0;
7673   }
7674
7675   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7676   {
7677     char device[] = "/dev/sda";
7678     int r;
7679     suppress_error = 0;
7680     r = guestfs_blockdev_setrw (g, device);
7681     if (r == -1)
7682       return -1;
7683   }
7684   {
7685     int r;
7686     suppress_error = 0;
7687     r = guestfs_umount_all (g);
7688     if (r == -1)
7689       return -1;
7690   }
7691   {
7692     int r;
7693     suppress_error = 0;
7694     r = guestfs_lvm_remove_all (g);
7695     if (r == -1)
7696       return -1;
7697   }
7698   {
7699     char device[] = "/dev/sda";
7700     char lines_0[] = ",";
7701     char *lines[] = {
7702       lines_0,
7703       NULL
7704     };
7705     int r;
7706     suppress_error = 0;
7707     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7708     if (r == -1)
7709       return -1;
7710   }
7711   {
7712     char fstype[] = "ext2";
7713     char device[] = "/dev/sda1";
7714     int r;
7715     suppress_error = 0;
7716     r = guestfs_mkfs (g, fstype, device);
7717     if (r == -1)
7718       return -1;
7719   }
7720   {
7721     char device[] = "/dev/sda1";
7722     char mountpoint[] = "/";
7723     int r;
7724     suppress_error = 0;
7725     r = guestfs_mount (g, device, mountpoint);
7726     if (r == -1)
7727       return -1;
7728   }
7729   /* TestOutputList for command_lines (3) */
7730   {
7731     char remotefilename[] = "/test-command";
7732     int r;
7733     suppress_error = 0;
7734     r = guestfs_upload (g, "test-command", remotefilename);
7735     if (r == -1)
7736       return -1;
7737   }
7738   {
7739     char path[] = "/test-command";
7740     int r;
7741     suppress_error = 0;
7742     r = guestfs_chmod (g, 493, path);
7743     if (r == -1)
7744       return -1;
7745   }
7746   {
7747     char arguments_0[] = "/test-command";
7748     char arguments_1[] = "4";
7749     char *arguments[] = {
7750       arguments_0,
7751       arguments_1,
7752       NULL
7753     };
7754     char **r;
7755     int i;
7756     suppress_error = 0;
7757     r = guestfs_command_lines (g, arguments);
7758     if (r == NULL)
7759       return -1;
7760     if (!r[0]) {
7761       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7762       print_strings (r);
7763       return -1;
7764     }
7765     {
7766       char expected[] = "";
7767       if (strcmp (r[0], expected) != 0) {
7768         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7769         return -1;
7770       }
7771     }
7772     if (!r[1]) {
7773       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7774       print_strings (r);
7775       return -1;
7776     }
7777     {
7778       char expected[] = "Result4";
7779       if (strcmp (r[1], expected) != 0) {
7780         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7781         return -1;
7782       }
7783     }
7784     if (r[2] != NULL) {
7785       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7786       print_strings (r);
7787       return -1;
7788     }
7789     for (i = 0; r[i] != NULL; ++i)
7790       free (r[i]);
7791     free (r);
7792   }
7793   return 0;
7794 }
7795
7796 static int test_command_lines_4_skip (void)
7797 {
7798   const char *str;
7799
7800   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7801   if (str && strcmp (str, "1") == 0) return 1;
7802   str = getenv ("SKIP_TEST_COMMAND_LINES");
7803   if (str && strcmp (str, "1") == 0) return 1;
7804   return 0;
7805 }
7806
7807 static int test_command_lines_4 (void)
7808 {
7809   if (test_command_lines_4_skip ()) {
7810     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7811     return 0;
7812   }
7813
7814   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7815   {
7816     char device[] = "/dev/sda";
7817     int r;
7818     suppress_error = 0;
7819     r = guestfs_blockdev_setrw (g, device);
7820     if (r == -1)
7821       return -1;
7822   }
7823   {
7824     int r;
7825     suppress_error = 0;
7826     r = guestfs_umount_all (g);
7827     if (r == -1)
7828       return -1;
7829   }
7830   {
7831     int r;
7832     suppress_error = 0;
7833     r = guestfs_lvm_remove_all (g);
7834     if (r == -1)
7835       return -1;
7836   }
7837   {
7838     char device[] = "/dev/sda";
7839     char lines_0[] = ",";
7840     char *lines[] = {
7841       lines_0,
7842       NULL
7843     };
7844     int r;
7845     suppress_error = 0;
7846     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7847     if (r == -1)
7848       return -1;
7849   }
7850   {
7851     char fstype[] = "ext2";
7852     char device[] = "/dev/sda1";
7853     int r;
7854     suppress_error = 0;
7855     r = guestfs_mkfs (g, fstype, device);
7856     if (r == -1)
7857       return -1;
7858   }
7859   {
7860     char device[] = "/dev/sda1";
7861     char mountpoint[] = "/";
7862     int r;
7863     suppress_error = 0;
7864     r = guestfs_mount (g, device, mountpoint);
7865     if (r == -1)
7866       return -1;
7867   }
7868   /* TestOutputList for command_lines (4) */
7869   {
7870     char remotefilename[] = "/test-command";
7871     int r;
7872     suppress_error = 0;
7873     r = guestfs_upload (g, "test-command", remotefilename);
7874     if (r == -1)
7875       return -1;
7876   }
7877   {
7878     char path[] = "/test-command";
7879     int r;
7880     suppress_error = 0;
7881     r = guestfs_chmod (g, 493, path);
7882     if (r == -1)
7883       return -1;
7884   }
7885   {
7886     char arguments_0[] = "/test-command";
7887     char arguments_1[] = "5";
7888     char *arguments[] = {
7889       arguments_0,
7890       arguments_1,
7891       NULL
7892     };
7893     char **r;
7894     int i;
7895     suppress_error = 0;
7896     r = guestfs_command_lines (g, arguments);
7897     if (r == NULL)
7898       return -1;
7899     if (!r[0]) {
7900       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7901       print_strings (r);
7902       return -1;
7903     }
7904     {
7905       char expected[] = "";
7906       if (strcmp (r[0], expected) != 0) {
7907         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7908         return -1;
7909       }
7910     }
7911     if (!r[1]) {
7912       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7913       print_strings (r);
7914       return -1;
7915     }
7916     {
7917       char expected[] = "Result5";
7918       if (strcmp (r[1], expected) != 0) {
7919         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7920         return -1;
7921       }
7922     }
7923     if (!r[2]) {
7924       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7925       print_strings (r);
7926       return -1;
7927     }
7928     {
7929       char expected[] = "";
7930       if (strcmp (r[2], expected) != 0) {
7931         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7932         return -1;
7933       }
7934     }
7935     if (r[3] != NULL) {
7936       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7937       print_strings (r);
7938       return -1;
7939     }
7940     for (i = 0; r[i] != NULL; ++i)
7941       free (r[i]);
7942     free (r);
7943   }
7944   return 0;
7945 }
7946
7947 static int test_command_lines_5_skip (void)
7948 {
7949   const char *str;
7950
7951   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7952   if (str && strcmp (str, "1") == 0) return 1;
7953   str = getenv ("SKIP_TEST_COMMAND_LINES");
7954   if (str && strcmp (str, "1") == 0) return 1;
7955   return 0;
7956 }
7957
7958 static int test_command_lines_5 (void)
7959 {
7960   if (test_command_lines_5_skip ()) {
7961     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7962     return 0;
7963   }
7964
7965   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7966   {
7967     char device[] = "/dev/sda";
7968     int r;
7969     suppress_error = 0;
7970     r = guestfs_blockdev_setrw (g, device);
7971     if (r == -1)
7972       return -1;
7973   }
7974   {
7975     int r;
7976     suppress_error = 0;
7977     r = guestfs_umount_all (g);
7978     if (r == -1)
7979       return -1;
7980   }
7981   {
7982     int r;
7983     suppress_error = 0;
7984     r = guestfs_lvm_remove_all (g);
7985     if (r == -1)
7986       return -1;
7987   }
7988   {
7989     char device[] = "/dev/sda";
7990     char lines_0[] = ",";
7991     char *lines[] = {
7992       lines_0,
7993       NULL
7994     };
7995     int r;
7996     suppress_error = 0;
7997     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7998     if (r == -1)
7999       return -1;
8000   }
8001   {
8002     char fstype[] = "ext2";
8003     char device[] = "/dev/sda1";
8004     int r;
8005     suppress_error = 0;
8006     r = guestfs_mkfs (g, fstype, device);
8007     if (r == -1)
8008       return -1;
8009   }
8010   {
8011     char device[] = "/dev/sda1";
8012     char mountpoint[] = "/";
8013     int r;
8014     suppress_error = 0;
8015     r = guestfs_mount (g, device, mountpoint);
8016     if (r == -1)
8017       return -1;
8018   }
8019   /* TestOutputList for command_lines (5) */
8020   {
8021     char remotefilename[] = "/test-command";
8022     int r;
8023     suppress_error = 0;
8024     r = guestfs_upload (g, "test-command", remotefilename);
8025     if (r == -1)
8026       return -1;
8027   }
8028   {
8029     char path[] = "/test-command";
8030     int r;
8031     suppress_error = 0;
8032     r = guestfs_chmod (g, 493, path);
8033     if (r == -1)
8034       return -1;
8035   }
8036   {
8037     char arguments_0[] = "/test-command";
8038     char arguments_1[] = "6";
8039     char *arguments[] = {
8040       arguments_0,
8041       arguments_1,
8042       NULL
8043     };
8044     char **r;
8045     int i;
8046     suppress_error = 0;
8047     r = guestfs_command_lines (g, arguments);
8048     if (r == NULL)
8049       return -1;
8050     if (!r[0]) {
8051       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8052       print_strings (r);
8053       return -1;
8054     }
8055     {
8056       char expected[] = "";
8057       if (strcmp (r[0], expected) != 0) {
8058         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8059         return -1;
8060       }
8061     }
8062     if (!r[1]) {
8063       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8064       print_strings (r);
8065       return -1;
8066     }
8067     {
8068       char expected[] = "";
8069       if (strcmp (r[1], expected) != 0) {
8070         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8071         return -1;
8072       }
8073     }
8074     if (!r[2]) {
8075       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8076       print_strings (r);
8077       return -1;
8078     }
8079     {
8080       char expected[] = "Result6";
8081       if (strcmp (r[2], expected) != 0) {
8082         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8083         return -1;
8084       }
8085     }
8086     if (!r[3]) {
8087       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8088       print_strings (r);
8089       return -1;
8090     }
8091     {
8092       char expected[] = "";
8093       if (strcmp (r[3], expected) != 0) {
8094         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8095         return -1;
8096       }
8097     }
8098     if (r[4] != NULL) {
8099       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8100       print_strings (r);
8101       return -1;
8102     }
8103     for (i = 0; r[i] != NULL; ++i)
8104       free (r[i]);
8105     free (r);
8106   }
8107   return 0;
8108 }
8109
8110 static int test_command_lines_6_skip (void)
8111 {
8112   const char *str;
8113
8114   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8115   if (str && strcmp (str, "1") == 0) return 1;
8116   str = getenv ("SKIP_TEST_COMMAND_LINES");
8117   if (str && strcmp (str, "1") == 0) return 1;
8118   return 0;
8119 }
8120
8121 static int test_command_lines_6 (void)
8122 {
8123   if (test_command_lines_6_skip ()) {
8124     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8125     return 0;
8126   }
8127
8128   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8129   {
8130     char device[] = "/dev/sda";
8131     int r;
8132     suppress_error = 0;
8133     r = guestfs_blockdev_setrw (g, device);
8134     if (r == -1)
8135       return -1;
8136   }
8137   {
8138     int r;
8139     suppress_error = 0;
8140     r = guestfs_umount_all (g);
8141     if (r == -1)
8142       return -1;
8143   }
8144   {
8145     int r;
8146     suppress_error = 0;
8147     r = guestfs_lvm_remove_all (g);
8148     if (r == -1)
8149       return -1;
8150   }
8151   {
8152     char device[] = "/dev/sda";
8153     char lines_0[] = ",";
8154     char *lines[] = {
8155       lines_0,
8156       NULL
8157     };
8158     int r;
8159     suppress_error = 0;
8160     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8161     if (r == -1)
8162       return -1;
8163   }
8164   {
8165     char fstype[] = "ext2";
8166     char device[] = "/dev/sda1";
8167     int r;
8168     suppress_error = 0;
8169     r = guestfs_mkfs (g, fstype, device);
8170     if (r == -1)
8171       return -1;
8172   }
8173   {
8174     char device[] = "/dev/sda1";
8175     char mountpoint[] = "/";
8176     int r;
8177     suppress_error = 0;
8178     r = guestfs_mount (g, device, mountpoint);
8179     if (r == -1)
8180       return -1;
8181   }
8182   /* TestOutputList for command_lines (6) */
8183   {
8184     char remotefilename[] = "/test-command";
8185     int r;
8186     suppress_error = 0;
8187     r = guestfs_upload (g, "test-command", remotefilename);
8188     if (r == -1)
8189       return -1;
8190   }
8191   {
8192     char path[] = "/test-command";
8193     int r;
8194     suppress_error = 0;
8195     r = guestfs_chmod (g, 493, path);
8196     if (r == -1)
8197       return -1;
8198   }
8199   {
8200     char arguments_0[] = "/test-command";
8201     char arguments_1[] = "7";
8202     char *arguments[] = {
8203       arguments_0,
8204       arguments_1,
8205       NULL
8206     };
8207     char **r;
8208     int i;
8209     suppress_error = 0;
8210     r = guestfs_command_lines (g, arguments);
8211     if (r == NULL)
8212       return -1;
8213     if (r[0] != NULL) {
8214       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8215       print_strings (r);
8216       return -1;
8217     }
8218     for (i = 0; r[i] != NULL; ++i)
8219       free (r[i]);
8220     free (r);
8221   }
8222   return 0;
8223 }
8224
8225 static int test_command_lines_7_skip (void)
8226 {
8227   const char *str;
8228
8229   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8230   if (str && strcmp (str, "1") == 0) return 1;
8231   str = getenv ("SKIP_TEST_COMMAND_LINES");
8232   if (str && strcmp (str, "1") == 0) return 1;
8233   return 0;
8234 }
8235
8236 static int test_command_lines_7 (void)
8237 {
8238   if (test_command_lines_7_skip ()) {
8239     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8240     return 0;
8241   }
8242
8243   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8244   {
8245     char device[] = "/dev/sda";
8246     int r;
8247     suppress_error = 0;
8248     r = guestfs_blockdev_setrw (g, device);
8249     if (r == -1)
8250       return -1;
8251   }
8252   {
8253     int r;
8254     suppress_error = 0;
8255     r = guestfs_umount_all (g);
8256     if (r == -1)
8257       return -1;
8258   }
8259   {
8260     int r;
8261     suppress_error = 0;
8262     r = guestfs_lvm_remove_all (g);
8263     if (r == -1)
8264       return -1;
8265   }
8266   {
8267     char device[] = "/dev/sda";
8268     char lines_0[] = ",";
8269     char *lines[] = {
8270       lines_0,
8271       NULL
8272     };
8273     int r;
8274     suppress_error = 0;
8275     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8276     if (r == -1)
8277       return -1;
8278   }
8279   {
8280     char fstype[] = "ext2";
8281     char device[] = "/dev/sda1";
8282     int r;
8283     suppress_error = 0;
8284     r = guestfs_mkfs (g, fstype, device);
8285     if (r == -1)
8286       return -1;
8287   }
8288   {
8289     char device[] = "/dev/sda1";
8290     char mountpoint[] = "/";
8291     int r;
8292     suppress_error = 0;
8293     r = guestfs_mount (g, device, mountpoint);
8294     if (r == -1)
8295       return -1;
8296   }
8297   /* TestOutputList for command_lines (7) */
8298   {
8299     char remotefilename[] = "/test-command";
8300     int r;
8301     suppress_error = 0;
8302     r = guestfs_upload (g, "test-command", remotefilename);
8303     if (r == -1)
8304       return -1;
8305   }
8306   {
8307     char path[] = "/test-command";
8308     int r;
8309     suppress_error = 0;
8310     r = guestfs_chmod (g, 493, path);
8311     if (r == -1)
8312       return -1;
8313   }
8314   {
8315     char arguments_0[] = "/test-command";
8316     char arguments_1[] = "8";
8317     char *arguments[] = {
8318       arguments_0,
8319       arguments_1,
8320       NULL
8321     };
8322     char **r;
8323     int i;
8324     suppress_error = 0;
8325     r = guestfs_command_lines (g, arguments);
8326     if (r == NULL)
8327       return -1;
8328     if (!r[0]) {
8329       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8330       print_strings (r);
8331       return -1;
8332     }
8333     {
8334       char expected[] = "";
8335       if (strcmp (r[0], expected) != 0) {
8336         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8337         return -1;
8338       }
8339     }
8340     if (r[1] != NULL) {
8341       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8342       print_strings (r);
8343       return -1;
8344     }
8345     for (i = 0; r[i] != NULL; ++i)
8346       free (r[i]);
8347     free (r);
8348   }
8349   return 0;
8350 }
8351
8352 static int test_command_lines_8_skip (void)
8353 {
8354   const char *str;
8355
8356   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8357   if (str && strcmp (str, "1") == 0) return 1;
8358   str = getenv ("SKIP_TEST_COMMAND_LINES");
8359   if (str && strcmp (str, "1") == 0) return 1;
8360   return 0;
8361 }
8362
8363 static int test_command_lines_8 (void)
8364 {
8365   if (test_command_lines_8_skip ()) {
8366     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8367     return 0;
8368   }
8369
8370   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8371   {
8372     char device[] = "/dev/sda";
8373     int r;
8374     suppress_error = 0;
8375     r = guestfs_blockdev_setrw (g, device);
8376     if (r == -1)
8377       return -1;
8378   }
8379   {
8380     int r;
8381     suppress_error = 0;
8382     r = guestfs_umount_all (g);
8383     if (r == -1)
8384       return -1;
8385   }
8386   {
8387     int r;
8388     suppress_error = 0;
8389     r = guestfs_lvm_remove_all (g);
8390     if (r == -1)
8391       return -1;
8392   }
8393   {
8394     char device[] = "/dev/sda";
8395     char lines_0[] = ",";
8396     char *lines[] = {
8397       lines_0,
8398       NULL
8399     };
8400     int r;
8401     suppress_error = 0;
8402     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8403     if (r == -1)
8404       return -1;
8405   }
8406   {
8407     char fstype[] = "ext2";
8408     char device[] = "/dev/sda1";
8409     int r;
8410     suppress_error = 0;
8411     r = guestfs_mkfs (g, fstype, device);
8412     if (r == -1)
8413       return -1;
8414   }
8415   {
8416     char device[] = "/dev/sda1";
8417     char mountpoint[] = "/";
8418     int r;
8419     suppress_error = 0;
8420     r = guestfs_mount (g, device, mountpoint);
8421     if (r == -1)
8422       return -1;
8423   }
8424   /* TestOutputList for command_lines (8) */
8425   {
8426     char remotefilename[] = "/test-command";
8427     int r;
8428     suppress_error = 0;
8429     r = guestfs_upload (g, "test-command", remotefilename);
8430     if (r == -1)
8431       return -1;
8432   }
8433   {
8434     char path[] = "/test-command";
8435     int r;
8436     suppress_error = 0;
8437     r = guestfs_chmod (g, 493, path);
8438     if (r == -1)
8439       return -1;
8440   }
8441   {
8442     char arguments_0[] = "/test-command";
8443     char arguments_1[] = "9";
8444     char *arguments[] = {
8445       arguments_0,
8446       arguments_1,
8447       NULL
8448     };
8449     char **r;
8450     int i;
8451     suppress_error = 0;
8452     r = guestfs_command_lines (g, arguments);
8453     if (r == NULL)
8454       return -1;
8455     if (!r[0]) {
8456       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8457       print_strings (r);
8458       return -1;
8459     }
8460     {
8461       char expected[] = "";
8462       if (strcmp (r[0], expected) != 0) {
8463         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8464         return -1;
8465       }
8466     }
8467     if (!r[1]) {
8468       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8469       print_strings (r);
8470       return -1;
8471     }
8472     {
8473       char expected[] = "";
8474       if (strcmp (r[1], expected) != 0) {
8475         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8476         return -1;
8477       }
8478     }
8479     if (r[2] != NULL) {
8480       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8481       print_strings (r);
8482       return -1;
8483     }
8484     for (i = 0; r[i] != NULL; ++i)
8485       free (r[i]);
8486     free (r);
8487   }
8488   return 0;
8489 }
8490
8491 static int test_command_lines_9_skip (void)
8492 {
8493   const char *str;
8494
8495   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8496   if (str && strcmp (str, "1") == 0) return 1;
8497   str = getenv ("SKIP_TEST_COMMAND_LINES");
8498   if (str && strcmp (str, "1") == 0) return 1;
8499   return 0;
8500 }
8501
8502 static int test_command_lines_9 (void)
8503 {
8504   if (test_command_lines_9_skip ()) {
8505     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8506     return 0;
8507   }
8508
8509   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8510   {
8511     char device[] = "/dev/sda";
8512     int r;
8513     suppress_error = 0;
8514     r = guestfs_blockdev_setrw (g, device);
8515     if (r == -1)
8516       return -1;
8517   }
8518   {
8519     int r;
8520     suppress_error = 0;
8521     r = guestfs_umount_all (g);
8522     if (r == -1)
8523       return -1;
8524   }
8525   {
8526     int r;
8527     suppress_error = 0;
8528     r = guestfs_lvm_remove_all (g);
8529     if (r == -1)
8530       return -1;
8531   }
8532   {
8533     char device[] = "/dev/sda";
8534     char lines_0[] = ",";
8535     char *lines[] = {
8536       lines_0,
8537       NULL
8538     };
8539     int r;
8540     suppress_error = 0;
8541     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8542     if (r == -1)
8543       return -1;
8544   }
8545   {
8546     char fstype[] = "ext2";
8547     char device[] = "/dev/sda1";
8548     int r;
8549     suppress_error = 0;
8550     r = guestfs_mkfs (g, fstype, device);
8551     if (r == -1)
8552       return -1;
8553   }
8554   {
8555     char device[] = "/dev/sda1";
8556     char mountpoint[] = "/";
8557     int r;
8558     suppress_error = 0;
8559     r = guestfs_mount (g, device, mountpoint);
8560     if (r == -1)
8561       return -1;
8562   }
8563   /* TestOutputList for command_lines (9) */
8564   {
8565     char remotefilename[] = "/test-command";
8566     int r;
8567     suppress_error = 0;
8568     r = guestfs_upload (g, "test-command", remotefilename);
8569     if (r == -1)
8570       return -1;
8571   }
8572   {
8573     char path[] = "/test-command";
8574     int r;
8575     suppress_error = 0;
8576     r = guestfs_chmod (g, 493, path);
8577     if (r == -1)
8578       return -1;
8579   }
8580   {
8581     char arguments_0[] = "/test-command";
8582     char arguments_1[] = "10";
8583     char *arguments[] = {
8584       arguments_0,
8585       arguments_1,
8586       NULL
8587     };
8588     char **r;
8589     int i;
8590     suppress_error = 0;
8591     r = guestfs_command_lines (g, arguments);
8592     if (r == NULL)
8593       return -1;
8594     if (!r[0]) {
8595       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8596       print_strings (r);
8597       return -1;
8598     }
8599     {
8600       char expected[] = "Result10-1";
8601       if (strcmp (r[0], expected) != 0) {
8602         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8603         return -1;
8604       }
8605     }
8606     if (!r[1]) {
8607       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8608       print_strings (r);
8609       return -1;
8610     }
8611     {
8612       char expected[] = "Result10-2";
8613       if (strcmp (r[1], expected) != 0) {
8614         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8615         return -1;
8616       }
8617     }
8618     if (r[2] != NULL) {
8619       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8620       print_strings (r);
8621       return -1;
8622     }
8623     for (i = 0; r[i] != NULL; ++i)
8624       free (r[i]);
8625     free (r);
8626   }
8627   return 0;
8628 }
8629
8630 static int test_command_lines_10_skip (void)
8631 {
8632   const char *str;
8633
8634   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8635   if (str && strcmp (str, "1") == 0) return 1;
8636   str = getenv ("SKIP_TEST_COMMAND_LINES");
8637   if (str && strcmp (str, "1") == 0) return 1;
8638   return 0;
8639 }
8640
8641 static int test_command_lines_10 (void)
8642 {
8643   if (test_command_lines_10_skip ()) {
8644     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8645     return 0;
8646   }
8647
8648   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8649   {
8650     char device[] = "/dev/sda";
8651     int r;
8652     suppress_error = 0;
8653     r = guestfs_blockdev_setrw (g, device);
8654     if (r == -1)
8655       return -1;
8656   }
8657   {
8658     int r;
8659     suppress_error = 0;
8660     r = guestfs_umount_all (g);
8661     if (r == -1)
8662       return -1;
8663   }
8664   {
8665     int r;
8666     suppress_error = 0;
8667     r = guestfs_lvm_remove_all (g);
8668     if (r == -1)
8669       return -1;
8670   }
8671   {
8672     char device[] = "/dev/sda";
8673     char lines_0[] = ",";
8674     char *lines[] = {
8675       lines_0,
8676       NULL
8677     };
8678     int r;
8679     suppress_error = 0;
8680     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8681     if (r == -1)
8682       return -1;
8683   }
8684   {
8685     char fstype[] = "ext2";
8686     char device[] = "/dev/sda1";
8687     int r;
8688     suppress_error = 0;
8689     r = guestfs_mkfs (g, fstype, device);
8690     if (r == -1)
8691       return -1;
8692   }
8693   {
8694     char device[] = "/dev/sda1";
8695     char mountpoint[] = "/";
8696     int r;
8697     suppress_error = 0;
8698     r = guestfs_mount (g, device, mountpoint);
8699     if (r == -1)
8700       return -1;
8701   }
8702   /* TestOutputList for command_lines (10) */
8703   {
8704     char remotefilename[] = "/test-command";
8705     int r;
8706     suppress_error = 0;
8707     r = guestfs_upload (g, "test-command", remotefilename);
8708     if (r == -1)
8709       return -1;
8710   }
8711   {
8712     char path[] = "/test-command";
8713     int r;
8714     suppress_error = 0;
8715     r = guestfs_chmod (g, 493, path);
8716     if (r == -1)
8717       return -1;
8718   }
8719   {
8720     char arguments_0[] = "/test-command";
8721     char arguments_1[] = "11";
8722     char *arguments[] = {
8723       arguments_0,
8724       arguments_1,
8725       NULL
8726     };
8727     char **r;
8728     int i;
8729     suppress_error = 0;
8730     r = guestfs_command_lines (g, arguments);
8731     if (r == NULL)
8732       return -1;
8733     if (!r[0]) {
8734       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8735       print_strings (r);
8736       return -1;
8737     }
8738     {
8739       char expected[] = "Result11-1";
8740       if (strcmp (r[0], expected) != 0) {
8741         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8742         return -1;
8743       }
8744     }
8745     if (!r[1]) {
8746       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8747       print_strings (r);
8748       return -1;
8749     }
8750     {
8751       char expected[] = "Result11-2";
8752       if (strcmp (r[1], expected) != 0) {
8753         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8754         return -1;
8755       }
8756     }
8757     if (r[2] != NULL) {
8758       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8759       print_strings (r);
8760       return -1;
8761     }
8762     for (i = 0; r[i] != NULL; ++i)
8763       free (r[i]);
8764     free (r);
8765   }
8766   return 0;
8767 }
8768
8769 static int test_command_0_skip (void)
8770 {
8771   const char *str;
8772
8773   str = getenv ("SKIP_TEST_COMMAND_0");
8774   if (str && strcmp (str, "1") == 0) return 1;
8775   str = getenv ("SKIP_TEST_COMMAND");
8776   if (str && strcmp (str, "1") == 0) return 1;
8777   return 0;
8778 }
8779
8780 static int test_command_0 (void)
8781 {
8782   if (test_command_0_skip ()) {
8783     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8784     return 0;
8785   }
8786
8787   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8788   {
8789     char device[] = "/dev/sda";
8790     int r;
8791     suppress_error = 0;
8792     r = guestfs_blockdev_setrw (g, device);
8793     if (r == -1)
8794       return -1;
8795   }
8796   {
8797     int r;
8798     suppress_error = 0;
8799     r = guestfs_umount_all (g);
8800     if (r == -1)
8801       return -1;
8802   }
8803   {
8804     int r;
8805     suppress_error = 0;
8806     r = guestfs_lvm_remove_all (g);
8807     if (r == -1)
8808       return -1;
8809   }
8810   {
8811     char device[] = "/dev/sda";
8812     char lines_0[] = ",";
8813     char *lines[] = {
8814       lines_0,
8815       NULL
8816     };
8817     int r;
8818     suppress_error = 0;
8819     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8820     if (r == -1)
8821       return -1;
8822   }
8823   {
8824     char fstype[] = "ext2";
8825     char device[] = "/dev/sda1";
8826     int r;
8827     suppress_error = 0;
8828     r = guestfs_mkfs (g, fstype, device);
8829     if (r == -1)
8830       return -1;
8831   }
8832   {
8833     char device[] = "/dev/sda1";
8834     char mountpoint[] = "/";
8835     int r;
8836     suppress_error = 0;
8837     r = guestfs_mount (g, device, mountpoint);
8838     if (r == -1)
8839       return -1;
8840   }
8841   /* TestOutput for command (0) */
8842   char expected[] = "Result1";
8843   {
8844     char remotefilename[] = "/test-command";
8845     int r;
8846     suppress_error = 0;
8847     r = guestfs_upload (g, "test-command", remotefilename);
8848     if (r == -1)
8849       return -1;
8850   }
8851   {
8852     char path[] = "/test-command";
8853     int r;
8854     suppress_error = 0;
8855     r = guestfs_chmod (g, 493, path);
8856     if (r == -1)
8857       return -1;
8858   }
8859   {
8860     char arguments_0[] = "/test-command";
8861     char arguments_1[] = "1";
8862     char *arguments[] = {
8863       arguments_0,
8864       arguments_1,
8865       NULL
8866     };
8867     char *r;
8868     suppress_error = 0;
8869     r = guestfs_command (g, arguments);
8870     if (r == NULL)
8871       return -1;
8872     if (strcmp (r, expected) != 0) {
8873       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8874       return -1;
8875     }
8876     free (r);
8877   }
8878   return 0;
8879 }
8880
8881 static int test_command_1_skip (void)
8882 {
8883   const char *str;
8884
8885   str = getenv ("SKIP_TEST_COMMAND_1");
8886   if (str && strcmp (str, "1") == 0) return 1;
8887   str = getenv ("SKIP_TEST_COMMAND");
8888   if (str && strcmp (str, "1") == 0) return 1;
8889   return 0;
8890 }
8891
8892 static int test_command_1 (void)
8893 {
8894   if (test_command_1_skip ()) {
8895     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8896     return 0;
8897   }
8898
8899   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8900   {
8901     char device[] = "/dev/sda";
8902     int r;
8903     suppress_error = 0;
8904     r = guestfs_blockdev_setrw (g, device);
8905     if (r == -1)
8906       return -1;
8907   }
8908   {
8909     int r;
8910     suppress_error = 0;
8911     r = guestfs_umount_all (g);
8912     if (r == -1)
8913       return -1;
8914   }
8915   {
8916     int r;
8917     suppress_error = 0;
8918     r = guestfs_lvm_remove_all (g);
8919     if (r == -1)
8920       return -1;
8921   }
8922   {
8923     char device[] = "/dev/sda";
8924     char lines_0[] = ",";
8925     char *lines[] = {
8926       lines_0,
8927       NULL
8928     };
8929     int r;
8930     suppress_error = 0;
8931     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8932     if (r == -1)
8933       return -1;
8934   }
8935   {
8936     char fstype[] = "ext2";
8937     char device[] = "/dev/sda1";
8938     int r;
8939     suppress_error = 0;
8940     r = guestfs_mkfs (g, fstype, device);
8941     if (r == -1)
8942       return -1;
8943   }
8944   {
8945     char device[] = "/dev/sda1";
8946     char mountpoint[] = "/";
8947     int r;
8948     suppress_error = 0;
8949     r = guestfs_mount (g, device, mountpoint);
8950     if (r == -1)
8951       return -1;
8952   }
8953   /* TestOutput for command (1) */
8954   char expected[] = "Result2\n";
8955   {
8956     char remotefilename[] = "/test-command";
8957     int r;
8958     suppress_error = 0;
8959     r = guestfs_upload (g, "test-command", remotefilename);
8960     if (r == -1)
8961       return -1;
8962   }
8963   {
8964     char path[] = "/test-command";
8965     int r;
8966     suppress_error = 0;
8967     r = guestfs_chmod (g, 493, path);
8968     if (r == -1)
8969       return -1;
8970   }
8971   {
8972     char arguments_0[] = "/test-command";
8973     char arguments_1[] = "2";
8974     char *arguments[] = {
8975       arguments_0,
8976       arguments_1,
8977       NULL
8978     };
8979     char *r;
8980     suppress_error = 0;
8981     r = guestfs_command (g, arguments);
8982     if (r == NULL)
8983       return -1;
8984     if (strcmp (r, expected) != 0) {
8985       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8986       return -1;
8987     }
8988     free (r);
8989   }
8990   return 0;
8991 }
8992
8993 static int test_command_2_skip (void)
8994 {
8995   const char *str;
8996
8997   str = getenv ("SKIP_TEST_COMMAND_2");
8998   if (str && strcmp (str, "1") == 0) return 1;
8999   str = getenv ("SKIP_TEST_COMMAND");
9000   if (str && strcmp (str, "1") == 0) return 1;
9001   return 0;
9002 }
9003
9004 static int test_command_2 (void)
9005 {
9006   if (test_command_2_skip ()) {
9007     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
9008     return 0;
9009   }
9010
9011   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9012   {
9013     char device[] = "/dev/sda";
9014     int r;
9015     suppress_error = 0;
9016     r = guestfs_blockdev_setrw (g, device);
9017     if (r == -1)
9018       return -1;
9019   }
9020   {
9021     int r;
9022     suppress_error = 0;
9023     r = guestfs_umount_all (g);
9024     if (r == -1)
9025       return -1;
9026   }
9027   {
9028     int r;
9029     suppress_error = 0;
9030     r = guestfs_lvm_remove_all (g);
9031     if (r == -1)
9032       return -1;
9033   }
9034   {
9035     char device[] = "/dev/sda";
9036     char lines_0[] = ",";
9037     char *lines[] = {
9038       lines_0,
9039       NULL
9040     };
9041     int r;
9042     suppress_error = 0;
9043     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9044     if (r == -1)
9045       return -1;
9046   }
9047   {
9048     char fstype[] = "ext2";
9049     char device[] = "/dev/sda1";
9050     int r;
9051     suppress_error = 0;
9052     r = guestfs_mkfs (g, fstype, device);
9053     if (r == -1)
9054       return -1;
9055   }
9056   {
9057     char device[] = "/dev/sda1";
9058     char mountpoint[] = "/";
9059     int r;
9060     suppress_error = 0;
9061     r = guestfs_mount (g, device, mountpoint);
9062     if (r == -1)
9063       return -1;
9064   }
9065   /* TestOutput for command (2) */
9066   char expected[] = "\nResult3";
9067   {
9068     char remotefilename[] = "/test-command";
9069     int r;
9070     suppress_error = 0;
9071     r = guestfs_upload (g, "test-command", remotefilename);
9072     if (r == -1)
9073       return -1;
9074   }
9075   {
9076     char path[] = "/test-command";
9077     int r;
9078     suppress_error = 0;
9079     r = guestfs_chmod (g, 493, path);
9080     if (r == -1)
9081       return -1;
9082   }
9083   {
9084     char arguments_0[] = "/test-command";
9085     char arguments_1[] = "3";
9086     char *arguments[] = {
9087       arguments_0,
9088       arguments_1,
9089       NULL
9090     };
9091     char *r;
9092     suppress_error = 0;
9093     r = guestfs_command (g, arguments);
9094     if (r == NULL)
9095       return -1;
9096     if (strcmp (r, expected) != 0) {
9097       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9098       return -1;
9099     }
9100     free (r);
9101   }
9102   return 0;
9103 }
9104
9105 static int test_command_3_skip (void)
9106 {
9107   const char *str;
9108
9109   str = getenv ("SKIP_TEST_COMMAND_3");
9110   if (str && strcmp (str, "1") == 0) return 1;
9111   str = getenv ("SKIP_TEST_COMMAND");
9112   if (str && strcmp (str, "1") == 0) return 1;
9113   return 0;
9114 }
9115
9116 static int test_command_3 (void)
9117 {
9118   if (test_command_3_skip ()) {
9119     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9120     return 0;
9121   }
9122
9123   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9124   {
9125     char device[] = "/dev/sda";
9126     int r;
9127     suppress_error = 0;
9128     r = guestfs_blockdev_setrw (g, device);
9129     if (r == -1)
9130       return -1;
9131   }
9132   {
9133     int r;
9134     suppress_error = 0;
9135     r = guestfs_umount_all (g);
9136     if (r == -1)
9137       return -1;
9138   }
9139   {
9140     int r;
9141     suppress_error = 0;
9142     r = guestfs_lvm_remove_all (g);
9143     if (r == -1)
9144       return -1;
9145   }
9146   {
9147     char device[] = "/dev/sda";
9148     char lines_0[] = ",";
9149     char *lines[] = {
9150       lines_0,
9151       NULL
9152     };
9153     int r;
9154     suppress_error = 0;
9155     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9156     if (r == -1)
9157       return -1;
9158   }
9159   {
9160     char fstype[] = "ext2";
9161     char device[] = "/dev/sda1";
9162     int r;
9163     suppress_error = 0;
9164     r = guestfs_mkfs (g, fstype, device);
9165     if (r == -1)
9166       return -1;
9167   }
9168   {
9169     char device[] = "/dev/sda1";
9170     char mountpoint[] = "/";
9171     int r;
9172     suppress_error = 0;
9173     r = guestfs_mount (g, device, mountpoint);
9174     if (r == -1)
9175       return -1;
9176   }
9177   /* TestOutput for command (3) */
9178   char expected[] = "\nResult4\n";
9179   {
9180     char remotefilename[] = "/test-command";
9181     int r;
9182     suppress_error = 0;
9183     r = guestfs_upload (g, "test-command", remotefilename);
9184     if (r == -1)
9185       return -1;
9186   }
9187   {
9188     char path[] = "/test-command";
9189     int r;
9190     suppress_error = 0;
9191     r = guestfs_chmod (g, 493, path);
9192     if (r == -1)
9193       return -1;
9194   }
9195   {
9196     char arguments_0[] = "/test-command";
9197     char arguments_1[] = "4";
9198     char *arguments[] = {
9199       arguments_0,
9200       arguments_1,
9201       NULL
9202     };
9203     char *r;
9204     suppress_error = 0;
9205     r = guestfs_command (g, arguments);
9206     if (r == NULL)
9207       return -1;
9208     if (strcmp (r, expected) != 0) {
9209       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9210       return -1;
9211     }
9212     free (r);
9213   }
9214   return 0;
9215 }
9216
9217 static int test_command_4_skip (void)
9218 {
9219   const char *str;
9220
9221   str = getenv ("SKIP_TEST_COMMAND_4");
9222   if (str && strcmp (str, "1") == 0) return 1;
9223   str = getenv ("SKIP_TEST_COMMAND");
9224   if (str && strcmp (str, "1") == 0) return 1;
9225   return 0;
9226 }
9227
9228 static int test_command_4 (void)
9229 {
9230   if (test_command_4_skip ()) {
9231     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9232     return 0;
9233   }
9234
9235   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9236   {
9237     char device[] = "/dev/sda";
9238     int r;
9239     suppress_error = 0;
9240     r = guestfs_blockdev_setrw (g, device);
9241     if (r == -1)
9242       return -1;
9243   }
9244   {
9245     int r;
9246     suppress_error = 0;
9247     r = guestfs_umount_all (g);
9248     if (r == -1)
9249       return -1;
9250   }
9251   {
9252     int r;
9253     suppress_error = 0;
9254     r = guestfs_lvm_remove_all (g);
9255     if (r == -1)
9256       return -1;
9257   }
9258   {
9259     char device[] = "/dev/sda";
9260     char lines_0[] = ",";
9261     char *lines[] = {
9262       lines_0,
9263       NULL
9264     };
9265     int r;
9266     suppress_error = 0;
9267     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9268     if (r == -1)
9269       return -1;
9270   }
9271   {
9272     char fstype[] = "ext2";
9273     char device[] = "/dev/sda1";
9274     int r;
9275     suppress_error = 0;
9276     r = guestfs_mkfs (g, fstype, device);
9277     if (r == -1)
9278       return -1;
9279   }
9280   {
9281     char device[] = "/dev/sda1";
9282     char mountpoint[] = "/";
9283     int r;
9284     suppress_error = 0;
9285     r = guestfs_mount (g, device, mountpoint);
9286     if (r == -1)
9287       return -1;
9288   }
9289   /* TestOutput for command (4) */
9290   char expected[] = "\nResult5\n\n";
9291   {
9292     char remotefilename[] = "/test-command";
9293     int r;
9294     suppress_error = 0;
9295     r = guestfs_upload (g, "test-command", remotefilename);
9296     if (r == -1)
9297       return -1;
9298   }
9299   {
9300     char path[] = "/test-command";
9301     int r;
9302     suppress_error = 0;
9303     r = guestfs_chmod (g, 493, path);
9304     if (r == -1)
9305       return -1;
9306   }
9307   {
9308     char arguments_0[] = "/test-command";
9309     char arguments_1[] = "5";
9310     char *arguments[] = {
9311       arguments_0,
9312       arguments_1,
9313       NULL
9314     };
9315     char *r;
9316     suppress_error = 0;
9317     r = guestfs_command (g, arguments);
9318     if (r == NULL)
9319       return -1;
9320     if (strcmp (r, expected) != 0) {
9321       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9322       return -1;
9323     }
9324     free (r);
9325   }
9326   return 0;
9327 }
9328
9329 static int test_command_5_skip (void)
9330 {
9331   const char *str;
9332
9333   str = getenv ("SKIP_TEST_COMMAND_5");
9334   if (str && strcmp (str, "1") == 0) return 1;
9335   str = getenv ("SKIP_TEST_COMMAND");
9336   if (str && strcmp (str, "1") == 0) return 1;
9337   return 0;
9338 }
9339
9340 static int test_command_5 (void)
9341 {
9342   if (test_command_5_skip ()) {
9343     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9344     return 0;
9345   }
9346
9347   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9348   {
9349     char device[] = "/dev/sda";
9350     int r;
9351     suppress_error = 0;
9352     r = guestfs_blockdev_setrw (g, device);
9353     if (r == -1)
9354       return -1;
9355   }
9356   {
9357     int r;
9358     suppress_error = 0;
9359     r = guestfs_umount_all (g);
9360     if (r == -1)
9361       return -1;
9362   }
9363   {
9364     int r;
9365     suppress_error = 0;
9366     r = guestfs_lvm_remove_all (g);
9367     if (r == -1)
9368       return -1;
9369   }
9370   {
9371     char device[] = "/dev/sda";
9372     char lines_0[] = ",";
9373     char *lines[] = {
9374       lines_0,
9375       NULL
9376     };
9377     int r;
9378     suppress_error = 0;
9379     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9380     if (r == -1)
9381       return -1;
9382   }
9383   {
9384     char fstype[] = "ext2";
9385     char device[] = "/dev/sda1";
9386     int r;
9387     suppress_error = 0;
9388     r = guestfs_mkfs (g, fstype, device);
9389     if (r == -1)
9390       return -1;
9391   }
9392   {
9393     char device[] = "/dev/sda1";
9394     char mountpoint[] = "/";
9395     int r;
9396     suppress_error = 0;
9397     r = guestfs_mount (g, device, mountpoint);
9398     if (r == -1)
9399       return -1;
9400   }
9401   /* TestOutput for command (5) */
9402   char expected[] = "\n\nResult6\n\n";
9403   {
9404     char remotefilename[] = "/test-command";
9405     int r;
9406     suppress_error = 0;
9407     r = guestfs_upload (g, "test-command", remotefilename);
9408     if (r == -1)
9409       return -1;
9410   }
9411   {
9412     char path[] = "/test-command";
9413     int r;
9414     suppress_error = 0;
9415     r = guestfs_chmod (g, 493, path);
9416     if (r == -1)
9417       return -1;
9418   }
9419   {
9420     char arguments_0[] = "/test-command";
9421     char arguments_1[] = "6";
9422     char *arguments[] = {
9423       arguments_0,
9424       arguments_1,
9425       NULL
9426     };
9427     char *r;
9428     suppress_error = 0;
9429     r = guestfs_command (g, arguments);
9430     if (r == NULL)
9431       return -1;
9432     if (strcmp (r, expected) != 0) {
9433       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9434       return -1;
9435     }
9436     free (r);
9437   }
9438   return 0;
9439 }
9440
9441 static int test_command_6_skip (void)
9442 {
9443   const char *str;
9444
9445   str = getenv ("SKIP_TEST_COMMAND_6");
9446   if (str && strcmp (str, "1") == 0) return 1;
9447   str = getenv ("SKIP_TEST_COMMAND");
9448   if (str && strcmp (str, "1") == 0) return 1;
9449   return 0;
9450 }
9451
9452 static int test_command_6 (void)
9453 {
9454   if (test_command_6_skip ()) {
9455     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9456     return 0;
9457   }
9458
9459   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9460   {
9461     char device[] = "/dev/sda";
9462     int r;
9463     suppress_error = 0;
9464     r = guestfs_blockdev_setrw (g, device);
9465     if (r == -1)
9466       return -1;
9467   }
9468   {
9469     int r;
9470     suppress_error = 0;
9471     r = guestfs_umount_all (g);
9472     if (r == -1)
9473       return -1;
9474   }
9475   {
9476     int r;
9477     suppress_error = 0;
9478     r = guestfs_lvm_remove_all (g);
9479     if (r == -1)
9480       return -1;
9481   }
9482   {
9483     char device[] = "/dev/sda";
9484     char lines_0[] = ",";
9485     char *lines[] = {
9486       lines_0,
9487       NULL
9488     };
9489     int r;
9490     suppress_error = 0;
9491     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9492     if (r == -1)
9493       return -1;
9494   }
9495   {
9496     char fstype[] = "ext2";
9497     char device[] = "/dev/sda1";
9498     int r;
9499     suppress_error = 0;
9500     r = guestfs_mkfs (g, fstype, device);
9501     if (r == -1)
9502       return -1;
9503   }
9504   {
9505     char device[] = "/dev/sda1";
9506     char mountpoint[] = "/";
9507     int r;
9508     suppress_error = 0;
9509     r = guestfs_mount (g, device, mountpoint);
9510     if (r == -1)
9511       return -1;
9512   }
9513   /* TestOutput for command (6) */
9514   char expected[] = "";
9515   {
9516     char remotefilename[] = "/test-command";
9517     int r;
9518     suppress_error = 0;
9519     r = guestfs_upload (g, "test-command", remotefilename);
9520     if (r == -1)
9521       return -1;
9522   }
9523   {
9524     char path[] = "/test-command";
9525     int r;
9526     suppress_error = 0;
9527     r = guestfs_chmod (g, 493, path);
9528     if (r == -1)
9529       return -1;
9530   }
9531   {
9532     char arguments_0[] = "/test-command";
9533     char arguments_1[] = "7";
9534     char *arguments[] = {
9535       arguments_0,
9536       arguments_1,
9537       NULL
9538     };
9539     char *r;
9540     suppress_error = 0;
9541     r = guestfs_command (g, arguments);
9542     if (r == NULL)
9543       return -1;
9544     if (strcmp (r, expected) != 0) {
9545       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9546       return -1;
9547     }
9548     free (r);
9549   }
9550   return 0;
9551 }
9552
9553 static int test_command_7_skip (void)
9554 {
9555   const char *str;
9556
9557   str = getenv ("SKIP_TEST_COMMAND_7");
9558   if (str && strcmp (str, "1") == 0) return 1;
9559   str = getenv ("SKIP_TEST_COMMAND");
9560   if (str && strcmp (str, "1") == 0) return 1;
9561   return 0;
9562 }
9563
9564 static int test_command_7 (void)
9565 {
9566   if (test_command_7_skip ()) {
9567     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9568     return 0;
9569   }
9570
9571   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9572   {
9573     char device[] = "/dev/sda";
9574     int r;
9575     suppress_error = 0;
9576     r = guestfs_blockdev_setrw (g, device);
9577     if (r == -1)
9578       return -1;
9579   }
9580   {
9581     int r;
9582     suppress_error = 0;
9583     r = guestfs_umount_all (g);
9584     if (r == -1)
9585       return -1;
9586   }
9587   {
9588     int r;
9589     suppress_error = 0;
9590     r = guestfs_lvm_remove_all (g);
9591     if (r == -1)
9592       return -1;
9593   }
9594   {
9595     char device[] = "/dev/sda";
9596     char lines_0[] = ",";
9597     char *lines[] = {
9598       lines_0,
9599       NULL
9600     };
9601     int r;
9602     suppress_error = 0;
9603     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9604     if (r == -1)
9605       return -1;
9606   }
9607   {
9608     char fstype[] = "ext2";
9609     char device[] = "/dev/sda1";
9610     int r;
9611     suppress_error = 0;
9612     r = guestfs_mkfs (g, fstype, device);
9613     if (r == -1)
9614       return -1;
9615   }
9616   {
9617     char device[] = "/dev/sda1";
9618     char mountpoint[] = "/";
9619     int r;
9620     suppress_error = 0;
9621     r = guestfs_mount (g, device, mountpoint);
9622     if (r == -1)
9623       return -1;
9624   }
9625   /* TestOutput for command (7) */
9626   char expected[] = "\n";
9627   {
9628     char remotefilename[] = "/test-command";
9629     int r;
9630     suppress_error = 0;
9631     r = guestfs_upload (g, "test-command", remotefilename);
9632     if (r == -1)
9633       return -1;
9634   }
9635   {
9636     char path[] = "/test-command";
9637     int r;
9638     suppress_error = 0;
9639     r = guestfs_chmod (g, 493, path);
9640     if (r == -1)
9641       return -1;
9642   }
9643   {
9644     char arguments_0[] = "/test-command";
9645     char arguments_1[] = "8";
9646     char *arguments[] = {
9647       arguments_0,
9648       arguments_1,
9649       NULL
9650     };
9651     char *r;
9652     suppress_error = 0;
9653     r = guestfs_command (g, arguments);
9654     if (r == NULL)
9655       return -1;
9656     if (strcmp (r, expected) != 0) {
9657       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9658       return -1;
9659     }
9660     free (r);
9661   }
9662   return 0;
9663 }
9664
9665 static int test_command_8_skip (void)
9666 {
9667   const char *str;
9668
9669   str = getenv ("SKIP_TEST_COMMAND_8");
9670   if (str && strcmp (str, "1") == 0) return 1;
9671   str = getenv ("SKIP_TEST_COMMAND");
9672   if (str && strcmp (str, "1") == 0) return 1;
9673   return 0;
9674 }
9675
9676 static int test_command_8 (void)
9677 {
9678   if (test_command_8_skip ()) {
9679     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9680     return 0;
9681   }
9682
9683   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9684   {
9685     char device[] = "/dev/sda";
9686     int r;
9687     suppress_error = 0;
9688     r = guestfs_blockdev_setrw (g, device);
9689     if (r == -1)
9690       return -1;
9691   }
9692   {
9693     int r;
9694     suppress_error = 0;
9695     r = guestfs_umount_all (g);
9696     if (r == -1)
9697       return -1;
9698   }
9699   {
9700     int r;
9701     suppress_error = 0;
9702     r = guestfs_lvm_remove_all (g);
9703     if (r == -1)
9704       return -1;
9705   }
9706   {
9707     char device[] = "/dev/sda";
9708     char lines_0[] = ",";
9709     char *lines[] = {
9710       lines_0,
9711       NULL
9712     };
9713     int r;
9714     suppress_error = 0;
9715     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9716     if (r == -1)
9717       return -1;
9718   }
9719   {
9720     char fstype[] = "ext2";
9721     char device[] = "/dev/sda1";
9722     int r;
9723     suppress_error = 0;
9724     r = guestfs_mkfs (g, fstype, device);
9725     if (r == -1)
9726       return -1;
9727   }
9728   {
9729     char device[] = "/dev/sda1";
9730     char mountpoint[] = "/";
9731     int r;
9732     suppress_error = 0;
9733     r = guestfs_mount (g, device, mountpoint);
9734     if (r == -1)
9735       return -1;
9736   }
9737   /* TestOutput for command (8) */
9738   char expected[] = "\n\n";
9739   {
9740     char remotefilename[] = "/test-command";
9741     int r;
9742     suppress_error = 0;
9743     r = guestfs_upload (g, "test-command", remotefilename);
9744     if (r == -1)
9745       return -1;
9746   }
9747   {
9748     char path[] = "/test-command";
9749     int r;
9750     suppress_error = 0;
9751     r = guestfs_chmod (g, 493, path);
9752     if (r == -1)
9753       return -1;
9754   }
9755   {
9756     char arguments_0[] = "/test-command";
9757     char arguments_1[] = "9";
9758     char *arguments[] = {
9759       arguments_0,
9760       arguments_1,
9761       NULL
9762     };
9763     char *r;
9764     suppress_error = 0;
9765     r = guestfs_command (g, arguments);
9766     if (r == NULL)
9767       return -1;
9768     if (strcmp (r, expected) != 0) {
9769       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9770       return -1;
9771     }
9772     free (r);
9773   }
9774   return 0;
9775 }
9776
9777 static int test_command_9_skip (void)
9778 {
9779   const char *str;
9780
9781   str = getenv ("SKIP_TEST_COMMAND_9");
9782   if (str && strcmp (str, "1") == 0) return 1;
9783   str = getenv ("SKIP_TEST_COMMAND");
9784   if (str && strcmp (str, "1") == 0) return 1;
9785   return 0;
9786 }
9787
9788 static int test_command_9 (void)
9789 {
9790   if (test_command_9_skip ()) {
9791     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9792     return 0;
9793   }
9794
9795   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9796   {
9797     char device[] = "/dev/sda";
9798     int r;
9799     suppress_error = 0;
9800     r = guestfs_blockdev_setrw (g, device);
9801     if (r == -1)
9802       return -1;
9803   }
9804   {
9805     int r;
9806     suppress_error = 0;
9807     r = guestfs_umount_all (g);
9808     if (r == -1)
9809       return -1;
9810   }
9811   {
9812     int r;
9813     suppress_error = 0;
9814     r = guestfs_lvm_remove_all (g);
9815     if (r == -1)
9816       return -1;
9817   }
9818   {
9819     char device[] = "/dev/sda";
9820     char lines_0[] = ",";
9821     char *lines[] = {
9822       lines_0,
9823       NULL
9824     };
9825     int r;
9826     suppress_error = 0;
9827     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9828     if (r == -1)
9829       return -1;
9830   }
9831   {
9832     char fstype[] = "ext2";
9833     char device[] = "/dev/sda1";
9834     int r;
9835     suppress_error = 0;
9836     r = guestfs_mkfs (g, fstype, device);
9837     if (r == -1)
9838       return -1;
9839   }
9840   {
9841     char device[] = "/dev/sda1";
9842     char mountpoint[] = "/";
9843     int r;
9844     suppress_error = 0;
9845     r = guestfs_mount (g, device, mountpoint);
9846     if (r == -1)
9847       return -1;
9848   }
9849   /* TestOutput for command (9) */
9850   char expected[] = "Result10-1\nResult10-2\n";
9851   {
9852     char remotefilename[] = "/test-command";
9853     int r;
9854     suppress_error = 0;
9855     r = guestfs_upload (g, "test-command", remotefilename);
9856     if (r == -1)
9857       return -1;
9858   }
9859   {
9860     char path[] = "/test-command";
9861     int r;
9862     suppress_error = 0;
9863     r = guestfs_chmod (g, 493, path);
9864     if (r == -1)
9865       return -1;
9866   }
9867   {
9868     char arguments_0[] = "/test-command";
9869     char arguments_1[] = "10";
9870     char *arguments[] = {
9871       arguments_0,
9872       arguments_1,
9873       NULL
9874     };
9875     char *r;
9876     suppress_error = 0;
9877     r = guestfs_command (g, arguments);
9878     if (r == NULL)
9879       return -1;
9880     if (strcmp (r, expected) != 0) {
9881       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9882       return -1;
9883     }
9884     free (r);
9885   }
9886   return 0;
9887 }
9888
9889 static int test_command_10_skip (void)
9890 {
9891   const char *str;
9892
9893   str = getenv ("SKIP_TEST_COMMAND_10");
9894   if (str && strcmp (str, "1") == 0) return 1;
9895   str = getenv ("SKIP_TEST_COMMAND");
9896   if (str && strcmp (str, "1") == 0) return 1;
9897   return 0;
9898 }
9899
9900 static int test_command_10 (void)
9901 {
9902   if (test_command_10_skip ()) {
9903     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9904     return 0;
9905   }
9906
9907   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9908   {
9909     char device[] = "/dev/sda";
9910     int r;
9911     suppress_error = 0;
9912     r = guestfs_blockdev_setrw (g, device);
9913     if (r == -1)
9914       return -1;
9915   }
9916   {
9917     int r;
9918     suppress_error = 0;
9919     r = guestfs_umount_all (g);
9920     if (r == -1)
9921       return -1;
9922   }
9923   {
9924     int r;
9925     suppress_error = 0;
9926     r = guestfs_lvm_remove_all (g);
9927     if (r == -1)
9928       return -1;
9929   }
9930   {
9931     char device[] = "/dev/sda";
9932     char lines_0[] = ",";
9933     char *lines[] = {
9934       lines_0,
9935       NULL
9936     };
9937     int r;
9938     suppress_error = 0;
9939     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9940     if (r == -1)
9941       return -1;
9942   }
9943   {
9944     char fstype[] = "ext2";
9945     char device[] = "/dev/sda1";
9946     int r;
9947     suppress_error = 0;
9948     r = guestfs_mkfs (g, fstype, device);
9949     if (r == -1)
9950       return -1;
9951   }
9952   {
9953     char device[] = "/dev/sda1";
9954     char mountpoint[] = "/";
9955     int r;
9956     suppress_error = 0;
9957     r = guestfs_mount (g, device, mountpoint);
9958     if (r == -1)
9959       return -1;
9960   }
9961   /* TestOutput for command (10) */
9962   char expected[] = "Result11-1\nResult11-2";
9963   {
9964     char remotefilename[] = "/test-command";
9965     int r;
9966     suppress_error = 0;
9967     r = guestfs_upload (g, "test-command", remotefilename);
9968     if (r == -1)
9969       return -1;
9970   }
9971   {
9972     char path[] = "/test-command";
9973     int r;
9974     suppress_error = 0;
9975     r = guestfs_chmod (g, 493, path);
9976     if (r == -1)
9977       return -1;
9978   }
9979   {
9980     char arguments_0[] = "/test-command";
9981     char arguments_1[] = "11";
9982     char *arguments[] = {
9983       arguments_0,
9984       arguments_1,
9985       NULL
9986     };
9987     char *r;
9988     suppress_error = 0;
9989     r = guestfs_command (g, arguments);
9990     if (r == NULL)
9991       return -1;
9992     if (strcmp (r, expected) != 0) {
9993       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9994       return -1;
9995     }
9996     free (r);
9997   }
9998   return 0;
9999 }
10000
10001 static int test_command_11_skip (void)
10002 {
10003   const char *str;
10004
10005   str = getenv ("SKIP_TEST_COMMAND_11");
10006   if (str && strcmp (str, "1") == 0) return 1;
10007   str = getenv ("SKIP_TEST_COMMAND");
10008   if (str && strcmp (str, "1") == 0) return 1;
10009   return 0;
10010 }
10011
10012 static int test_command_11 (void)
10013 {
10014   if (test_command_11_skip ()) {
10015     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
10016     return 0;
10017   }
10018
10019   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10020   {
10021     char device[] = "/dev/sda";
10022     int r;
10023     suppress_error = 0;
10024     r = guestfs_blockdev_setrw (g, device);
10025     if (r == -1)
10026       return -1;
10027   }
10028   {
10029     int r;
10030     suppress_error = 0;
10031     r = guestfs_umount_all (g);
10032     if (r == -1)
10033       return -1;
10034   }
10035   {
10036     int r;
10037     suppress_error = 0;
10038     r = guestfs_lvm_remove_all (g);
10039     if (r == -1)
10040       return -1;
10041   }
10042   {
10043     char device[] = "/dev/sda";
10044     char lines_0[] = ",";
10045     char *lines[] = {
10046       lines_0,
10047       NULL
10048     };
10049     int r;
10050     suppress_error = 0;
10051     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10052     if (r == -1)
10053       return -1;
10054   }
10055   {
10056     char fstype[] = "ext2";
10057     char device[] = "/dev/sda1";
10058     int r;
10059     suppress_error = 0;
10060     r = guestfs_mkfs (g, fstype, device);
10061     if (r == -1)
10062       return -1;
10063   }
10064   {
10065     char device[] = "/dev/sda1";
10066     char mountpoint[] = "/";
10067     int r;
10068     suppress_error = 0;
10069     r = guestfs_mount (g, device, mountpoint);
10070     if (r == -1)
10071       return -1;
10072   }
10073   /* TestLastFail for command (11) */
10074   {
10075     char remotefilename[] = "/test-command";
10076     int r;
10077     suppress_error = 0;
10078     r = guestfs_upload (g, "test-command", remotefilename);
10079     if (r == -1)
10080       return -1;
10081   }
10082   {
10083     char path[] = "/test-command";
10084     int r;
10085     suppress_error = 0;
10086     r = guestfs_chmod (g, 493, path);
10087     if (r == -1)
10088       return -1;
10089   }
10090   {
10091     char arguments_0[] = "/test-command";
10092     char *arguments[] = {
10093       arguments_0,
10094       NULL
10095     };
10096     char *r;
10097     suppress_error = 1;
10098     r = guestfs_command (g, arguments);
10099     if (r != NULL)
10100       return -1;
10101     free (r);
10102   }
10103   return 0;
10104 }
10105
10106 static int test_file_0_skip (void)
10107 {
10108   const char *str;
10109
10110   str = getenv ("SKIP_TEST_FILE_0");
10111   if (str && strcmp (str, "1") == 0) return 1;
10112   str = getenv ("SKIP_TEST_FILE");
10113   if (str && strcmp (str, "1") == 0) return 1;
10114   return 0;
10115 }
10116
10117 static int test_file_0 (void)
10118 {
10119   if (test_file_0_skip ()) {
10120     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10121     return 0;
10122   }
10123
10124   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10125   {
10126     char device[] = "/dev/sda";
10127     int r;
10128     suppress_error = 0;
10129     r = guestfs_blockdev_setrw (g, device);
10130     if (r == -1)
10131       return -1;
10132   }
10133   {
10134     int r;
10135     suppress_error = 0;
10136     r = guestfs_umount_all (g);
10137     if (r == -1)
10138       return -1;
10139   }
10140   {
10141     int r;
10142     suppress_error = 0;
10143     r = guestfs_lvm_remove_all (g);
10144     if (r == -1)
10145       return -1;
10146   }
10147   {
10148     char device[] = "/dev/sda";
10149     char lines_0[] = ",";
10150     char *lines[] = {
10151       lines_0,
10152       NULL
10153     };
10154     int r;
10155     suppress_error = 0;
10156     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10157     if (r == -1)
10158       return -1;
10159   }
10160   {
10161     char fstype[] = "ext2";
10162     char device[] = "/dev/sda1";
10163     int r;
10164     suppress_error = 0;
10165     r = guestfs_mkfs (g, fstype, device);
10166     if (r == -1)
10167       return -1;
10168   }
10169   {
10170     char device[] = "/dev/sda1";
10171     char mountpoint[] = "/";
10172     int r;
10173     suppress_error = 0;
10174     r = guestfs_mount (g, device, mountpoint);
10175     if (r == -1)
10176       return -1;
10177   }
10178   /* TestOutput for file (0) */
10179   char expected[] = "empty";
10180   {
10181     char path[] = "/new";
10182     int r;
10183     suppress_error = 0;
10184     r = guestfs_touch (g, path);
10185     if (r == -1)
10186       return -1;
10187   }
10188   {
10189     char path[] = "/new";
10190     char *r;
10191     suppress_error = 0;
10192     r = guestfs_file (g, path);
10193     if (r == NULL)
10194       return -1;
10195     if (strcmp (r, expected) != 0) {
10196       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10197       return -1;
10198     }
10199     free (r);
10200   }
10201   return 0;
10202 }
10203
10204 static int test_file_1_skip (void)
10205 {
10206   const char *str;
10207
10208   str = getenv ("SKIP_TEST_FILE_1");
10209   if (str && strcmp (str, "1") == 0) return 1;
10210   str = getenv ("SKIP_TEST_FILE");
10211   if (str && strcmp (str, "1") == 0) return 1;
10212   return 0;
10213 }
10214
10215 static int test_file_1 (void)
10216 {
10217   if (test_file_1_skip ()) {
10218     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10219     return 0;
10220   }
10221
10222   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10223   {
10224     char device[] = "/dev/sda";
10225     int r;
10226     suppress_error = 0;
10227     r = guestfs_blockdev_setrw (g, device);
10228     if (r == -1)
10229       return -1;
10230   }
10231   {
10232     int r;
10233     suppress_error = 0;
10234     r = guestfs_umount_all (g);
10235     if (r == -1)
10236       return -1;
10237   }
10238   {
10239     int r;
10240     suppress_error = 0;
10241     r = guestfs_lvm_remove_all (g);
10242     if (r == -1)
10243       return -1;
10244   }
10245   {
10246     char device[] = "/dev/sda";
10247     char lines_0[] = ",";
10248     char *lines[] = {
10249       lines_0,
10250       NULL
10251     };
10252     int r;
10253     suppress_error = 0;
10254     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10255     if (r == -1)
10256       return -1;
10257   }
10258   {
10259     char fstype[] = "ext2";
10260     char device[] = "/dev/sda1";
10261     int r;
10262     suppress_error = 0;
10263     r = guestfs_mkfs (g, fstype, device);
10264     if (r == -1)
10265       return -1;
10266   }
10267   {
10268     char device[] = "/dev/sda1";
10269     char mountpoint[] = "/";
10270     int r;
10271     suppress_error = 0;
10272     r = guestfs_mount (g, device, mountpoint);
10273     if (r == -1)
10274       return -1;
10275   }
10276   /* TestOutput for file (1) */
10277   char expected[] = "ASCII text";
10278   {
10279     char path[] = "/new";
10280     char content[] = "some content\n";
10281     int r;
10282     suppress_error = 0;
10283     r = guestfs_write_file (g, path, content, 0);
10284     if (r == -1)
10285       return -1;
10286   }
10287   {
10288     char path[] = "/new";
10289     char *r;
10290     suppress_error = 0;
10291     r = guestfs_file (g, path);
10292     if (r == NULL)
10293       return -1;
10294     if (strcmp (r, expected) != 0) {
10295       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10296       return -1;
10297     }
10298     free (r);
10299   }
10300   return 0;
10301 }
10302
10303 static int test_file_2_skip (void)
10304 {
10305   const char *str;
10306
10307   str = getenv ("SKIP_TEST_FILE_2");
10308   if (str && strcmp (str, "1") == 0) return 1;
10309   str = getenv ("SKIP_TEST_FILE");
10310   if (str && strcmp (str, "1") == 0) return 1;
10311   return 0;
10312 }
10313
10314 static int test_file_2 (void)
10315 {
10316   if (test_file_2_skip ()) {
10317     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10318     return 0;
10319   }
10320
10321   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10322   {
10323     char device[] = "/dev/sda";
10324     int r;
10325     suppress_error = 0;
10326     r = guestfs_blockdev_setrw (g, device);
10327     if (r == -1)
10328       return -1;
10329   }
10330   {
10331     int r;
10332     suppress_error = 0;
10333     r = guestfs_umount_all (g);
10334     if (r == -1)
10335       return -1;
10336   }
10337   {
10338     int r;
10339     suppress_error = 0;
10340     r = guestfs_lvm_remove_all (g);
10341     if (r == -1)
10342       return -1;
10343   }
10344   {
10345     char device[] = "/dev/sda";
10346     char lines_0[] = ",";
10347     char *lines[] = {
10348       lines_0,
10349       NULL
10350     };
10351     int r;
10352     suppress_error = 0;
10353     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10354     if (r == -1)
10355       return -1;
10356   }
10357   {
10358     char fstype[] = "ext2";
10359     char device[] = "/dev/sda1";
10360     int r;
10361     suppress_error = 0;
10362     r = guestfs_mkfs (g, fstype, device);
10363     if (r == -1)
10364       return -1;
10365   }
10366   {
10367     char device[] = "/dev/sda1";
10368     char mountpoint[] = "/";
10369     int r;
10370     suppress_error = 0;
10371     r = guestfs_mount (g, device, mountpoint);
10372     if (r == -1)
10373       return -1;
10374   }
10375   /* TestLastFail for file (2) */
10376   {
10377     char path[] = "/nofile";
10378     char *r;
10379     suppress_error = 1;
10380     r = guestfs_file (g, path);
10381     if (r != NULL)
10382       return -1;
10383     free (r);
10384   }
10385   return 0;
10386 }
10387
10388 static int test_umount_all_0_skip (void)
10389 {
10390   const char *str;
10391
10392   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10393   if (str && strcmp (str, "1") == 0) return 1;
10394   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10395   if (str && strcmp (str, "1") == 0) return 1;
10396   return 0;
10397 }
10398
10399 static int test_umount_all_0 (void)
10400 {
10401   if (test_umount_all_0_skip ()) {
10402     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10403     return 0;
10404   }
10405
10406   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10407   {
10408     char device[] = "/dev/sda";
10409     int r;
10410     suppress_error = 0;
10411     r = guestfs_blockdev_setrw (g, device);
10412     if (r == -1)
10413       return -1;
10414   }
10415   {
10416     int r;
10417     suppress_error = 0;
10418     r = guestfs_umount_all (g);
10419     if (r == -1)
10420       return -1;
10421   }
10422   {
10423     int r;
10424     suppress_error = 0;
10425     r = guestfs_lvm_remove_all (g);
10426     if (r == -1)
10427       return -1;
10428   }
10429   {
10430     char device[] = "/dev/sda";
10431     char lines_0[] = ",";
10432     char *lines[] = {
10433       lines_0,
10434       NULL
10435     };
10436     int r;
10437     suppress_error = 0;
10438     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10439     if (r == -1)
10440       return -1;
10441   }
10442   {
10443     char fstype[] = "ext2";
10444     char device[] = "/dev/sda1";
10445     int r;
10446     suppress_error = 0;
10447     r = guestfs_mkfs (g, fstype, device);
10448     if (r == -1)
10449       return -1;
10450   }
10451   {
10452     char device[] = "/dev/sda1";
10453     char mountpoint[] = "/";
10454     int r;
10455     suppress_error = 0;
10456     r = guestfs_mount (g, device, mountpoint);
10457     if (r == -1)
10458       return -1;
10459   }
10460   /* TestOutputList for umount_all (0) */
10461   {
10462     int r;
10463     suppress_error = 0;
10464     r = guestfs_umount_all (g);
10465     if (r == -1)
10466       return -1;
10467   }
10468   {
10469     char **r;
10470     int i;
10471     suppress_error = 0;
10472     r = guestfs_mounts (g);
10473     if (r == NULL)
10474       return -1;
10475     if (r[0] != NULL) {
10476       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10477       print_strings (r);
10478       return -1;
10479     }
10480     for (i = 0; r[i] != NULL; ++i)
10481       free (r[i]);
10482     free (r);
10483   }
10484   return 0;
10485 }
10486
10487 static int test_umount_all_1_skip (void)
10488 {
10489   const char *str;
10490
10491   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10492   if (str && strcmp (str, "1") == 0) return 1;
10493   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10494   if (str && strcmp (str, "1") == 0) return 1;
10495   return 0;
10496 }
10497
10498 static int test_umount_all_1 (void)
10499 {
10500   if (test_umount_all_1_skip ()) {
10501     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10502     return 0;
10503   }
10504
10505   /* InitNone|InitEmpty for test_umount_all_1 */
10506   {
10507     char device[] = "/dev/sda";
10508     int r;
10509     suppress_error = 0;
10510     r = guestfs_blockdev_setrw (g, device);
10511     if (r == -1)
10512       return -1;
10513   }
10514   {
10515     int r;
10516     suppress_error = 0;
10517     r = guestfs_umount_all (g);
10518     if (r == -1)
10519       return -1;
10520   }
10521   {
10522     int r;
10523     suppress_error = 0;
10524     r = guestfs_lvm_remove_all (g);
10525     if (r == -1)
10526       return -1;
10527   }
10528   /* TestOutputList for umount_all (1) */
10529   {
10530     char device[] = "/dev/sda";
10531     char lines_0[] = ",10";
10532     char lines_1[] = ",20";
10533     char lines_2[] = ",";
10534     char *lines[] = {
10535       lines_0,
10536       lines_1,
10537       lines_2,
10538       NULL
10539     };
10540     int r;
10541     suppress_error = 0;
10542     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10543     if (r == -1)
10544       return -1;
10545   }
10546   {
10547     char fstype[] = "ext2";
10548     char device[] = "/dev/sda1";
10549     int r;
10550     suppress_error = 0;
10551     r = guestfs_mkfs (g, fstype, device);
10552     if (r == -1)
10553       return -1;
10554   }
10555   {
10556     char fstype[] = "ext2";
10557     char device[] = "/dev/sda2";
10558     int r;
10559     suppress_error = 0;
10560     r = guestfs_mkfs (g, fstype, device);
10561     if (r == -1)
10562       return -1;
10563   }
10564   {
10565     char fstype[] = "ext2";
10566     char device[] = "/dev/sda3";
10567     int r;
10568     suppress_error = 0;
10569     r = guestfs_mkfs (g, fstype, device);
10570     if (r == -1)
10571       return -1;
10572   }
10573   {
10574     char device[] = "/dev/sda1";
10575     char mountpoint[] = "/";
10576     int r;
10577     suppress_error = 0;
10578     r = guestfs_mount (g, device, mountpoint);
10579     if (r == -1)
10580       return -1;
10581   }
10582   {
10583     char path[] = "/mp1";
10584     int r;
10585     suppress_error = 0;
10586     r = guestfs_mkdir (g, path);
10587     if (r == -1)
10588       return -1;
10589   }
10590   {
10591     char device[] = "/dev/sda2";
10592     char mountpoint[] = "/mp1";
10593     int r;
10594     suppress_error = 0;
10595     r = guestfs_mount (g, device, mountpoint);
10596     if (r == -1)
10597       return -1;
10598   }
10599   {
10600     char path[] = "/mp1/mp2";
10601     int r;
10602     suppress_error = 0;
10603     r = guestfs_mkdir (g, path);
10604     if (r == -1)
10605       return -1;
10606   }
10607   {
10608     char device[] = "/dev/sda3";
10609     char mountpoint[] = "/mp1/mp2";
10610     int r;
10611     suppress_error = 0;
10612     r = guestfs_mount (g, device, mountpoint);
10613     if (r == -1)
10614       return -1;
10615   }
10616   {
10617     char path[] = "/mp1/mp2/mp3";
10618     int r;
10619     suppress_error = 0;
10620     r = guestfs_mkdir (g, path);
10621     if (r == -1)
10622       return -1;
10623   }
10624   {
10625     int r;
10626     suppress_error = 0;
10627     r = guestfs_umount_all (g);
10628     if (r == -1)
10629       return -1;
10630   }
10631   {
10632     char **r;
10633     int i;
10634     suppress_error = 0;
10635     r = guestfs_mounts (g);
10636     if (r == NULL)
10637       return -1;
10638     if (r[0] != NULL) {
10639       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10640       print_strings (r);
10641       return -1;
10642     }
10643     for (i = 0; r[i] != NULL; ++i)
10644       free (r[i]);
10645     free (r);
10646   }
10647   return 0;
10648 }
10649
10650 static int test_mounts_0_skip (void)
10651 {
10652   const char *str;
10653
10654   str = getenv ("SKIP_TEST_MOUNTS_0");
10655   if (str && strcmp (str, "1") == 0) return 1;
10656   str = getenv ("SKIP_TEST_MOUNTS");
10657   if (str && strcmp (str, "1") == 0) return 1;
10658   return 0;
10659 }
10660
10661 static int test_mounts_0 (void)
10662 {
10663   if (test_mounts_0_skip ()) {
10664     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10665     return 0;
10666   }
10667
10668   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10669   {
10670     char device[] = "/dev/sda";
10671     int r;
10672     suppress_error = 0;
10673     r = guestfs_blockdev_setrw (g, device);
10674     if (r == -1)
10675       return -1;
10676   }
10677   {
10678     int r;
10679     suppress_error = 0;
10680     r = guestfs_umount_all (g);
10681     if (r == -1)
10682       return -1;
10683   }
10684   {
10685     int r;
10686     suppress_error = 0;
10687     r = guestfs_lvm_remove_all (g);
10688     if (r == -1)
10689       return -1;
10690   }
10691   {
10692     char device[] = "/dev/sda";
10693     char lines_0[] = ",";
10694     char *lines[] = {
10695       lines_0,
10696       NULL
10697     };
10698     int r;
10699     suppress_error = 0;
10700     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10701     if (r == -1)
10702       return -1;
10703   }
10704   {
10705     char fstype[] = "ext2";
10706     char device[] = "/dev/sda1";
10707     int r;
10708     suppress_error = 0;
10709     r = guestfs_mkfs (g, fstype, device);
10710     if (r == -1)
10711       return -1;
10712   }
10713   {
10714     char device[] = "/dev/sda1";
10715     char mountpoint[] = "/";
10716     int r;
10717     suppress_error = 0;
10718     r = guestfs_mount (g, device, mountpoint);
10719     if (r == -1)
10720       return -1;
10721   }
10722   /* TestOutputListOfDevices for mounts (0) */
10723   {
10724     char **r;
10725     int i;
10726     suppress_error = 0;
10727     r = guestfs_mounts (g);
10728     if (r == NULL)
10729       return -1;
10730     if (!r[0]) {
10731       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10732       print_strings (r);
10733       return -1;
10734     }
10735     {
10736       char expected[] = "/dev/sda1";
10737       r[0][5] = 's';
10738       if (strcmp (r[0], expected) != 0) {
10739         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10740         return -1;
10741       }
10742     }
10743     if (r[1] != NULL) {
10744       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10745       print_strings (r);
10746       return -1;
10747     }
10748     for (i = 0; r[i] != NULL; ++i)
10749       free (r[i]);
10750     free (r);
10751   }
10752   return 0;
10753 }
10754
10755 static int test_umount_0_skip (void)
10756 {
10757   const char *str;
10758
10759   str = getenv ("SKIP_TEST_UMOUNT_0");
10760   if (str && strcmp (str, "1") == 0) return 1;
10761   str = getenv ("SKIP_TEST_UMOUNT");
10762   if (str && strcmp (str, "1") == 0) return 1;
10763   return 0;
10764 }
10765
10766 static int test_umount_0 (void)
10767 {
10768   if (test_umount_0_skip ()) {
10769     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10770     return 0;
10771   }
10772
10773   /* InitNone|InitEmpty for test_umount_0 */
10774   {
10775     char device[] = "/dev/sda";
10776     int r;
10777     suppress_error = 0;
10778     r = guestfs_blockdev_setrw (g, device);
10779     if (r == -1)
10780       return -1;
10781   }
10782   {
10783     int r;
10784     suppress_error = 0;
10785     r = guestfs_umount_all (g);
10786     if (r == -1)
10787       return -1;
10788   }
10789   {
10790     int r;
10791     suppress_error = 0;
10792     r = guestfs_lvm_remove_all (g);
10793     if (r == -1)
10794       return -1;
10795   }
10796   /* TestOutputListOfDevices for umount (0) */
10797   {
10798     char device[] = "/dev/sda";
10799     char lines_0[] = ",";
10800     char *lines[] = {
10801       lines_0,
10802       NULL
10803     };
10804     int r;
10805     suppress_error = 0;
10806     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10807     if (r == -1)
10808       return -1;
10809   }
10810   {
10811     char fstype[] = "ext2";
10812     char device[] = "/dev/sda1";
10813     int r;
10814     suppress_error = 0;
10815     r = guestfs_mkfs (g, fstype, device);
10816     if (r == -1)
10817       return -1;
10818   }
10819   {
10820     char device[] = "/dev/sda1";
10821     char mountpoint[] = "/";
10822     int r;
10823     suppress_error = 0;
10824     r = guestfs_mount (g, device, mountpoint);
10825     if (r == -1)
10826       return -1;
10827   }
10828   {
10829     char **r;
10830     int i;
10831     suppress_error = 0;
10832     r = guestfs_mounts (g);
10833     if (r == NULL)
10834       return -1;
10835     if (!r[0]) {
10836       fprintf (stderr, "test_umount_0: short list returned from command\n");
10837       print_strings (r);
10838       return -1;
10839     }
10840     {
10841       char expected[] = "/dev/sda1";
10842       r[0][5] = 's';
10843       if (strcmp (r[0], expected) != 0) {
10844         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10845         return -1;
10846       }
10847     }
10848     if (r[1] != NULL) {
10849       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10850       print_strings (r);
10851       return -1;
10852     }
10853     for (i = 0; r[i] != NULL; ++i)
10854       free (r[i]);
10855     free (r);
10856   }
10857   return 0;
10858 }
10859
10860 static int test_umount_1_skip (void)
10861 {
10862   const char *str;
10863
10864   str = getenv ("SKIP_TEST_UMOUNT_1");
10865   if (str && strcmp (str, "1") == 0) return 1;
10866   str = getenv ("SKIP_TEST_UMOUNT");
10867   if (str && strcmp (str, "1") == 0) return 1;
10868   return 0;
10869 }
10870
10871 static int test_umount_1 (void)
10872 {
10873   if (test_umount_1_skip ()) {
10874     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10875     return 0;
10876   }
10877
10878   /* InitNone|InitEmpty for test_umount_1 */
10879   {
10880     char device[] = "/dev/sda";
10881     int r;
10882     suppress_error = 0;
10883     r = guestfs_blockdev_setrw (g, device);
10884     if (r == -1)
10885       return -1;
10886   }
10887   {
10888     int r;
10889     suppress_error = 0;
10890     r = guestfs_umount_all (g);
10891     if (r == -1)
10892       return -1;
10893   }
10894   {
10895     int r;
10896     suppress_error = 0;
10897     r = guestfs_lvm_remove_all (g);
10898     if (r == -1)
10899       return -1;
10900   }
10901   /* TestOutputList for umount (1) */
10902   {
10903     char device[] = "/dev/sda";
10904     char lines_0[] = ",";
10905     char *lines[] = {
10906       lines_0,
10907       NULL
10908     };
10909     int r;
10910     suppress_error = 0;
10911     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10912     if (r == -1)
10913       return -1;
10914   }
10915   {
10916     char fstype[] = "ext2";
10917     char device[] = "/dev/sda1";
10918     int r;
10919     suppress_error = 0;
10920     r = guestfs_mkfs (g, fstype, device);
10921     if (r == -1)
10922       return -1;
10923   }
10924   {
10925     char device[] = "/dev/sda1";
10926     char mountpoint[] = "/";
10927     int r;
10928     suppress_error = 0;
10929     r = guestfs_mount (g, device, mountpoint);
10930     if (r == -1)
10931       return -1;
10932   }
10933   {
10934     char pathordevice[] = "/";
10935     int r;
10936     suppress_error = 0;
10937     r = guestfs_umount (g, pathordevice);
10938     if (r == -1)
10939       return -1;
10940   }
10941   {
10942     char **r;
10943     int i;
10944     suppress_error = 0;
10945     r = guestfs_mounts (g);
10946     if (r == NULL)
10947       return -1;
10948     if (r[0] != NULL) {
10949       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10950       print_strings (r);
10951       return -1;
10952     }
10953     for (i = 0; r[i] != NULL; ++i)
10954       free (r[i]);
10955     free (r);
10956   }
10957   return 0;
10958 }
10959
10960 static int test_write_file_0_skip (void)
10961 {
10962   const char *str;
10963
10964   str = getenv ("SKIP_TEST_WRITE_FILE_0");
10965   if (str && strcmp (str, "1") == 0) return 1;
10966   str = getenv ("SKIP_TEST_WRITE_FILE");
10967   if (str && strcmp (str, "1") == 0) return 1;
10968   return 0;
10969 }
10970
10971 static int test_write_file_0 (void)
10972 {
10973   if (test_write_file_0_skip ()) {
10974     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10975     return 0;
10976   }
10977
10978   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10979   {
10980     char device[] = "/dev/sda";
10981     int r;
10982     suppress_error = 0;
10983     r = guestfs_blockdev_setrw (g, device);
10984     if (r == -1)
10985       return -1;
10986   }
10987   {
10988     int r;
10989     suppress_error = 0;
10990     r = guestfs_umount_all (g);
10991     if (r == -1)
10992       return -1;
10993   }
10994   {
10995     int r;
10996     suppress_error = 0;
10997     r = guestfs_lvm_remove_all (g);
10998     if (r == -1)
10999       return -1;
11000   }
11001   {
11002     char device[] = "/dev/sda";
11003     char lines_0[] = ",";
11004     char *lines[] = {
11005       lines_0,
11006       NULL
11007     };
11008     int r;
11009     suppress_error = 0;
11010     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11011     if (r == -1)
11012       return -1;
11013   }
11014   {
11015     char fstype[] = "ext2";
11016     char device[] = "/dev/sda1";
11017     int r;
11018     suppress_error = 0;
11019     r = guestfs_mkfs (g, fstype, device);
11020     if (r == -1)
11021       return -1;
11022   }
11023   {
11024     char device[] = "/dev/sda1";
11025     char mountpoint[] = "/";
11026     int r;
11027     suppress_error = 0;
11028     r = guestfs_mount (g, device, mountpoint);
11029     if (r == -1)
11030       return -1;
11031   }
11032   /* TestOutput for write_file (0) */
11033   char expected[] = "new file contents";
11034   {
11035     char path[] = "/new";
11036     char content[] = "new file contents";
11037     int r;
11038     suppress_error = 0;
11039     r = guestfs_write_file (g, path, content, 0);
11040     if (r == -1)
11041       return -1;
11042   }
11043   {
11044     char path[] = "/new";
11045     char *r;
11046     suppress_error = 0;
11047     r = guestfs_cat (g, path);
11048     if (r == NULL)
11049       return -1;
11050     if (strcmp (r, expected) != 0) {
11051       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11052       return -1;
11053     }
11054     free (r);
11055   }
11056   return 0;
11057 }
11058
11059 static int test_write_file_1_skip (void)
11060 {
11061   const char *str;
11062
11063   str = getenv ("SKIP_TEST_WRITE_FILE_1");
11064   if (str && strcmp (str, "1") == 0) return 1;
11065   str = getenv ("SKIP_TEST_WRITE_FILE");
11066   if (str && strcmp (str, "1") == 0) return 1;
11067   return 0;
11068 }
11069
11070 static int test_write_file_1 (void)
11071 {
11072   if (test_write_file_1_skip ()) {
11073     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11074     return 0;
11075   }
11076
11077   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11078   {
11079     char device[] = "/dev/sda";
11080     int r;
11081     suppress_error = 0;
11082     r = guestfs_blockdev_setrw (g, device);
11083     if (r == -1)
11084       return -1;
11085   }
11086   {
11087     int r;
11088     suppress_error = 0;
11089     r = guestfs_umount_all (g);
11090     if (r == -1)
11091       return -1;
11092   }
11093   {
11094     int r;
11095     suppress_error = 0;
11096     r = guestfs_lvm_remove_all (g);
11097     if (r == -1)
11098       return -1;
11099   }
11100   {
11101     char device[] = "/dev/sda";
11102     char lines_0[] = ",";
11103     char *lines[] = {
11104       lines_0,
11105       NULL
11106     };
11107     int r;
11108     suppress_error = 0;
11109     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11110     if (r == -1)
11111       return -1;
11112   }
11113   {
11114     char fstype[] = "ext2";
11115     char device[] = "/dev/sda1";
11116     int r;
11117     suppress_error = 0;
11118     r = guestfs_mkfs (g, fstype, device);
11119     if (r == -1)
11120       return -1;
11121   }
11122   {
11123     char device[] = "/dev/sda1";
11124     char mountpoint[] = "/";
11125     int r;
11126     suppress_error = 0;
11127     r = guestfs_mount (g, device, mountpoint);
11128     if (r == -1)
11129       return -1;
11130   }
11131   /* TestOutput for write_file (1) */
11132   char expected[] = "\nnew file contents\n";
11133   {
11134     char path[] = "/new";
11135     char content[] = "\nnew file contents\n";
11136     int r;
11137     suppress_error = 0;
11138     r = guestfs_write_file (g, path, content, 0);
11139     if (r == -1)
11140       return -1;
11141   }
11142   {
11143     char path[] = "/new";
11144     char *r;
11145     suppress_error = 0;
11146     r = guestfs_cat (g, path);
11147     if (r == NULL)
11148       return -1;
11149     if (strcmp (r, expected) != 0) {
11150       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11151       return -1;
11152     }
11153     free (r);
11154   }
11155   return 0;
11156 }
11157
11158 static int test_write_file_2_skip (void)
11159 {
11160   const char *str;
11161
11162   str = getenv ("SKIP_TEST_WRITE_FILE_2");
11163   if (str && strcmp (str, "1") == 0) return 1;
11164   str = getenv ("SKIP_TEST_WRITE_FILE");
11165   if (str && strcmp (str, "1") == 0) return 1;
11166   return 0;
11167 }
11168
11169 static int test_write_file_2 (void)
11170 {
11171   if (test_write_file_2_skip ()) {
11172     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11173     return 0;
11174   }
11175
11176   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11177   {
11178     char device[] = "/dev/sda";
11179     int r;
11180     suppress_error = 0;
11181     r = guestfs_blockdev_setrw (g, device);
11182     if (r == -1)
11183       return -1;
11184   }
11185   {
11186     int r;
11187     suppress_error = 0;
11188     r = guestfs_umount_all (g);
11189     if (r == -1)
11190       return -1;
11191   }
11192   {
11193     int r;
11194     suppress_error = 0;
11195     r = guestfs_lvm_remove_all (g);
11196     if (r == -1)
11197       return -1;
11198   }
11199   {
11200     char device[] = "/dev/sda";
11201     char lines_0[] = ",";
11202     char *lines[] = {
11203       lines_0,
11204       NULL
11205     };
11206     int r;
11207     suppress_error = 0;
11208     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11209     if (r == -1)
11210       return -1;
11211   }
11212   {
11213     char fstype[] = "ext2";
11214     char device[] = "/dev/sda1";
11215     int r;
11216     suppress_error = 0;
11217     r = guestfs_mkfs (g, fstype, device);
11218     if (r == -1)
11219       return -1;
11220   }
11221   {
11222     char device[] = "/dev/sda1";
11223     char mountpoint[] = "/";
11224     int r;
11225     suppress_error = 0;
11226     r = guestfs_mount (g, device, mountpoint);
11227     if (r == -1)
11228       return -1;
11229   }
11230   /* TestOutput for write_file (2) */
11231   char expected[] = "\n\n";
11232   {
11233     char path[] = "/new";
11234     char content[] = "\n\n";
11235     int r;
11236     suppress_error = 0;
11237     r = guestfs_write_file (g, path, content, 0);
11238     if (r == -1)
11239       return -1;
11240   }
11241   {
11242     char path[] = "/new";
11243     char *r;
11244     suppress_error = 0;
11245     r = guestfs_cat (g, path);
11246     if (r == NULL)
11247       return -1;
11248     if (strcmp (r, expected) != 0) {
11249       fprintf (stderr, "test_write_file_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_write_file_3_skip (void)
11258 {
11259   const char *str;
11260
11261   str = getenv ("SKIP_TEST_WRITE_FILE_3");
11262   if (str && strcmp (str, "1") == 0) return 1;
11263   str = getenv ("SKIP_TEST_WRITE_FILE");
11264   if (str && strcmp (str, "1") == 0) return 1;
11265   return 0;
11266 }
11267
11268 static int test_write_file_3 (void)
11269 {
11270   if (test_write_file_3_skip ()) {
11271     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11272     return 0;
11273   }
11274
11275   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11276   {
11277     char device[] = "/dev/sda";
11278     int r;
11279     suppress_error = 0;
11280     r = guestfs_blockdev_setrw (g, device);
11281     if (r == -1)
11282       return -1;
11283   }
11284   {
11285     int r;
11286     suppress_error = 0;
11287     r = guestfs_umount_all (g);
11288     if (r == -1)
11289       return -1;
11290   }
11291   {
11292     int r;
11293     suppress_error = 0;
11294     r = guestfs_lvm_remove_all (g);
11295     if (r == -1)
11296       return -1;
11297   }
11298   {
11299     char device[] = "/dev/sda";
11300     char lines_0[] = ",";
11301     char *lines[] = {
11302       lines_0,
11303       NULL
11304     };
11305     int r;
11306     suppress_error = 0;
11307     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11308     if (r == -1)
11309       return -1;
11310   }
11311   {
11312     char fstype[] = "ext2";
11313     char device[] = "/dev/sda1";
11314     int r;
11315     suppress_error = 0;
11316     r = guestfs_mkfs (g, fstype, device);
11317     if (r == -1)
11318       return -1;
11319   }
11320   {
11321     char device[] = "/dev/sda1";
11322     char mountpoint[] = "/";
11323     int r;
11324     suppress_error = 0;
11325     r = guestfs_mount (g, device, mountpoint);
11326     if (r == -1)
11327       return -1;
11328   }
11329   /* TestOutput for write_file (3) */
11330   char expected[] = "";
11331   {
11332     char path[] = "/new";
11333     char content[] = "";
11334     int r;
11335     suppress_error = 0;
11336     r = guestfs_write_file (g, path, content, 0);
11337     if (r == -1)
11338       return -1;
11339   }
11340   {
11341     char path[] = "/new";
11342     char *r;
11343     suppress_error = 0;
11344     r = guestfs_cat (g, path);
11345     if (r == NULL)
11346       return -1;
11347     if (strcmp (r, expected) != 0) {
11348       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11349       return -1;
11350     }
11351     free (r);
11352   }
11353   return 0;
11354 }
11355
11356 static int test_write_file_4_skip (void)
11357 {
11358   const char *str;
11359
11360   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11361   if (str && strcmp (str, "1") == 0) return 1;
11362   str = getenv ("SKIP_TEST_WRITE_FILE");
11363   if (str && strcmp (str, "1") == 0) return 1;
11364   return 0;
11365 }
11366
11367 static int test_write_file_4 (void)
11368 {
11369   if (test_write_file_4_skip ()) {
11370     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11371     return 0;
11372   }
11373
11374   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11375   {
11376     char device[] = "/dev/sda";
11377     int r;
11378     suppress_error = 0;
11379     r = guestfs_blockdev_setrw (g, device);
11380     if (r == -1)
11381       return -1;
11382   }
11383   {
11384     int r;
11385     suppress_error = 0;
11386     r = guestfs_umount_all (g);
11387     if (r == -1)
11388       return -1;
11389   }
11390   {
11391     int r;
11392     suppress_error = 0;
11393     r = guestfs_lvm_remove_all (g);
11394     if (r == -1)
11395       return -1;
11396   }
11397   {
11398     char device[] = "/dev/sda";
11399     char lines_0[] = ",";
11400     char *lines[] = {
11401       lines_0,
11402       NULL
11403     };
11404     int r;
11405     suppress_error = 0;
11406     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11407     if (r == -1)
11408       return -1;
11409   }
11410   {
11411     char fstype[] = "ext2";
11412     char device[] = "/dev/sda1";
11413     int r;
11414     suppress_error = 0;
11415     r = guestfs_mkfs (g, fstype, device);
11416     if (r == -1)
11417       return -1;
11418   }
11419   {
11420     char device[] = "/dev/sda1";
11421     char mountpoint[] = "/";
11422     int r;
11423     suppress_error = 0;
11424     r = guestfs_mount (g, device, mountpoint);
11425     if (r == -1)
11426       return -1;
11427   }
11428   /* TestOutput for write_file (4) */
11429   char expected[] = "\n\n\n";
11430   {
11431     char path[] = "/new";
11432     char content[] = "\n\n\n";
11433     int r;
11434     suppress_error = 0;
11435     r = guestfs_write_file (g, path, content, 0);
11436     if (r == -1)
11437       return -1;
11438   }
11439   {
11440     char path[] = "/new";
11441     char *r;
11442     suppress_error = 0;
11443     r = guestfs_cat (g, path);
11444     if (r == NULL)
11445       return -1;
11446     if (strcmp (r, expected) != 0) {
11447       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11448       return -1;
11449     }
11450     free (r);
11451   }
11452   return 0;
11453 }
11454
11455 static int test_write_file_5_skip (void)
11456 {
11457   const char *str;
11458
11459   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11460   if (str && strcmp (str, "1") == 0) return 1;
11461   str = getenv ("SKIP_TEST_WRITE_FILE");
11462   if (str && strcmp (str, "1") == 0) return 1;
11463   return 0;
11464 }
11465
11466 static int test_write_file_5 (void)
11467 {
11468   if (test_write_file_5_skip ()) {
11469     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11470     return 0;
11471   }
11472
11473   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11474   {
11475     char device[] = "/dev/sda";
11476     int r;
11477     suppress_error = 0;
11478     r = guestfs_blockdev_setrw (g, device);
11479     if (r == -1)
11480       return -1;
11481   }
11482   {
11483     int r;
11484     suppress_error = 0;
11485     r = guestfs_umount_all (g);
11486     if (r == -1)
11487       return -1;
11488   }
11489   {
11490     int r;
11491     suppress_error = 0;
11492     r = guestfs_lvm_remove_all (g);
11493     if (r == -1)
11494       return -1;
11495   }
11496   {
11497     char device[] = "/dev/sda";
11498     char lines_0[] = ",";
11499     char *lines[] = {
11500       lines_0,
11501       NULL
11502     };
11503     int r;
11504     suppress_error = 0;
11505     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11506     if (r == -1)
11507       return -1;
11508   }
11509   {
11510     char fstype[] = "ext2";
11511     char device[] = "/dev/sda1";
11512     int r;
11513     suppress_error = 0;
11514     r = guestfs_mkfs (g, fstype, device);
11515     if (r == -1)
11516       return -1;
11517   }
11518   {
11519     char device[] = "/dev/sda1";
11520     char mountpoint[] = "/";
11521     int r;
11522     suppress_error = 0;
11523     r = guestfs_mount (g, device, mountpoint);
11524     if (r == -1)
11525       return -1;
11526   }
11527   /* TestOutput for write_file (5) */
11528   char expected[] = "\n";
11529   {
11530     char path[] = "/new";
11531     char content[] = "\n";
11532     int r;
11533     suppress_error = 0;
11534     r = guestfs_write_file (g, path, content, 0);
11535     if (r == -1)
11536       return -1;
11537   }
11538   {
11539     char path[] = "/new";
11540     char *r;
11541     suppress_error = 0;
11542     r = guestfs_cat (g, path);
11543     if (r == NULL)
11544       return -1;
11545     if (strcmp (r, expected) != 0) {
11546       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11547       return -1;
11548     }
11549     free (r);
11550   }
11551   return 0;
11552 }
11553
11554 static int test_mkfs_0_skip (void)
11555 {
11556   const char *str;
11557
11558   str = getenv ("SKIP_TEST_MKFS_0");
11559   if (str && strcmp (str, "1") == 0) return 1;
11560   str = getenv ("SKIP_TEST_MKFS");
11561   if (str && strcmp (str, "1") == 0) return 1;
11562   return 0;
11563 }
11564
11565 static int test_mkfs_0 (void)
11566 {
11567   if (test_mkfs_0_skip ()) {
11568     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11569     return 0;
11570   }
11571
11572   /* InitNone|InitEmpty for test_mkfs_0 */
11573   {
11574     char device[] = "/dev/sda";
11575     int r;
11576     suppress_error = 0;
11577     r = guestfs_blockdev_setrw (g, device);
11578     if (r == -1)
11579       return -1;
11580   }
11581   {
11582     int r;
11583     suppress_error = 0;
11584     r = guestfs_umount_all (g);
11585     if (r == -1)
11586       return -1;
11587   }
11588   {
11589     int r;
11590     suppress_error = 0;
11591     r = guestfs_lvm_remove_all (g);
11592     if (r == -1)
11593       return -1;
11594   }
11595   /* TestOutput for mkfs (0) */
11596   char expected[] = "new file contents";
11597   {
11598     char device[] = "/dev/sda";
11599     char lines_0[] = ",";
11600     char *lines[] = {
11601       lines_0,
11602       NULL
11603     };
11604     int r;
11605     suppress_error = 0;
11606     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11607     if (r == -1)
11608       return -1;
11609   }
11610   {
11611     char fstype[] = "ext2";
11612     char device[] = "/dev/sda1";
11613     int r;
11614     suppress_error = 0;
11615     r = guestfs_mkfs (g, fstype, device);
11616     if (r == -1)
11617       return -1;
11618   }
11619   {
11620     char device[] = "/dev/sda1";
11621     char mountpoint[] = "/";
11622     int r;
11623     suppress_error = 0;
11624     r = guestfs_mount (g, device, mountpoint);
11625     if (r == -1)
11626       return -1;
11627   }
11628   {
11629     char path[] = "/new";
11630     char content[] = "new file contents";
11631     int r;
11632     suppress_error = 0;
11633     r = guestfs_write_file (g, path, content, 0);
11634     if (r == -1)
11635       return -1;
11636   }
11637   {
11638     char path[] = "/new";
11639     char *r;
11640     suppress_error = 0;
11641     r = guestfs_cat (g, path);
11642     if (r == NULL)
11643       return -1;
11644     if (strcmp (r, expected) != 0) {
11645       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11646       return -1;
11647     }
11648     free (r);
11649   }
11650   return 0;
11651 }
11652
11653 static int test_lvcreate_0_skip (void)
11654 {
11655   const char *str;
11656
11657   str = getenv ("SKIP_TEST_LVCREATE_0");
11658   if (str && strcmp (str, "1") == 0) return 1;
11659   str = getenv ("SKIP_TEST_LVCREATE");
11660   if (str && strcmp (str, "1") == 0) return 1;
11661   return 0;
11662 }
11663
11664 static int test_lvcreate_0 (void)
11665 {
11666   if (test_lvcreate_0_skip ()) {
11667     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11668     return 0;
11669   }
11670
11671   /* InitNone|InitEmpty for test_lvcreate_0 */
11672   {
11673     char device[] = "/dev/sda";
11674     int r;
11675     suppress_error = 0;
11676     r = guestfs_blockdev_setrw (g, device);
11677     if (r == -1)
11678       return -1;
11679   }
11680   {
11681     int r;
11682     suppress_error = 0;
11683     r = guestfs_umount_all (g);
11684     if (r == -1)
11685       return -1;
11686   }
11687   {
11688     int r;
11689     suppress_error = 0;
11690     r = guestfs_lvm_remove_all (g);
11691     if (r == -1)
11692       return -1;
11693   }
11694   /* TestOutputList for lvcreate (0) */
11695   {
11696     char device[] = "/dev/sda";
11697     char lines_0[] = ",10";
11698     char lines_1[] = ",20";
11699     char lines_2[] = ",";
11700     char *lines[] = {
11701       lines_0,
11702       lines_1,
11703       lines_2,
11704       NULL
11705     };
11706     int r;
11707     suppress_error = 0;
11708     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11709     if (r == -1)
11710       return -1;
11711   }
11712   {
11713     char device[] = "/dev/sda1";
11714     int r;
11715     suppress_error = 0;
11716     r = guestfs_pvcreate (g, device);
11717     if (r == -1)
11718       return -1;
11719   }
11720   {
11721     char device[] = "/dev/sda2";
11722     int r;
11723     suppress_error = 0;
11724     r = guestfs_pvcreate (g, device);
11725     if (r == -1)
11726       return -1;
11727   }
11728   {
11729     char device[] = "/dev/sda3";
11730     int r;
11731     suppress_error = 0;
11732     r = guestfs_pvcreate (g, device);
11733     if (r == -1)
11734       return -1;
11735   }
11736   {
11737     char volgroup[] = "VG1";
11738     char physvols_0[] = "/dev/sda1";
11739     char physvols_1[] = "/dev/sda2";
11740     char *physvols[] = {
11741       physvols_0,
11742       physvols_1,
11743       NULL
11744     };
11745     int r;
11746     suppress_error = 0;
11747     r = guestfs_vgcreate (g, volgroup, physvols);
11748     if (r == -1)
11749       return -1;
11750   }
11751   {
11752     char volgroup[] = "VG2";
11753     char physvols_0[] = "/dev/sda3";
11754     char *physvols[] = {
11755       physvols_0,
11756       NULL
11757     };
11758     int r;
11759     suppress_error = 0;
11760     r = guestfs_vgcreate (g, volgroup, physvols);
11761     if (r == -1)
11762       return -1;
11763   }
11764   {
11765     char logvol[] = "LV1";
11766     char volgroup[] = "VG1";
11767     int r;
11768     suppress_error = 0;
11769     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11770     if (r == -1)
11771       return -1;
11772   }
11773   {
11774     char logvol[] = "LV2";
11775     char volgroup[] = "VG1";
11776     int r;
11777     suppress_error = 0;
11778     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11779     if (r == -1)
11780       return -1;
11781   }
11782   {
11783     char logvol[] = "LV3";
11784     char volgroup[] = "VG2";
11785     int r;
11786     suppress_error = 0;
11787     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11788     if (r == -1)
11789       return -1;
11790   }
11791   {
11792     char logvol[] = "LV4";
11793     char volgroup[] = "VG2";
11794     int r;
11795     suppress_error = 0;
11796     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11797     if (r == -1)
11798       return -1;
11799   }
11800   {
11801     char logvol[] = "LV5";
11802     char volgroup[] = "VG2";
11803     int r;
11804     suppress_error = 0;
11805     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11806     if (r == -1)
11807       return -1;
11808   }
11809   {
11810     char **r;
11811     int i;
11812     suppress_error = 0;
11813     r = guestfs_lvs (g);
11814     if (r == NULL)
11815       return -1;
11816     if (!r[0]) {
11817       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11818       print_strings (r);
11819       return -1;
11820     }
11821     {
11822       char expected[] = "/dev/VG1/LV1";
11823       if (strcmp (r[0], expected) != 0) {
11824         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11825         return -1;
11826       }
11827     }
11828     if (!r[1]) {
11829       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11830       print_strings (r);
11831       return -1;
11832     }
11833     {
11834       char expected[] = "/dev/VG1/LV2";
11835       if (strcmp (r[1], expected) != 0) {
11836         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11837         return -1;
11838       }
11839     }
11840     if (!r[2]) {
11841       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11842       print_strings (r);
11843       return -1;
11844     }
11845     {
11846       char expected[] = "/dev/VG2/LV3";
11847       if (strcmp (r[2], expected) != 0) {
11848         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11849         return -1;
11850       }
11851     }
11852     if (!r[3]) {
11853       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11854       print_strings (r);
11855       return -1;
11856     }
11857     {
11858       char expected[] = "/dev/VG2/LV4";
11859       if (strcmp (r[3], expected) != 0) {
11860         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11861         return -1;
11862       }
11863     }
11864     if (!r[4]) {
11865       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11866       print_strings (r);
11867       return -1;
11868     }
11869     {
11870       char expected[] = "/dev/VG2/LV5";
11871       if (strcmp (r[4], expected) != 0) {
11872         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11873         return -1;
11874       }
11875     }
11876     if (r[5] != NULL) {
11877       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11878       print_strings (r);
11879       return -1;
11880     }
11881     for (i = 0; r[i] != NULL; ++i)
11882       free (r[i]);
11883     free (r);
11884   }
11885   return 0;
11886 }
11887
11888 static int test_vgcreate_0_skip (void)
11889 {
11890   const char *str;
11891
11892   str = getenv ("SKIP_TEST_VGCREATE_0");
11893   if (str && strcmp (str, "1") == 0) return 1;
11894   str = getenv ("SKIP_TEST_VGCREATE");
11895   if (str && strcmp (str, "1") == 0) return 1;
11896   return 0;
11897 }
11898
11899 static int test_vgcreate_0 (void)
11900 {
11901   if (test_vgcreate_0_skip ()) {
11902     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11903     return 0;
11904   }
11905
11906   /* InitNone|InitEmpty for test_vgcreate_0 */
11907   {
11908     char device[] = "/dev/sda";
11909     int r;
11910     suppress_error = 0;
11911     r = guestfs_blockdev_setrw (g, device);
11912     if (r == -1)
11913       return -1;
11914   }
11915   {
11916     int r;
11917     suppress_error = 0;
11918     r = guestfs_umount_all (g);
11919     if (r == -1)
11920       return -1;
11921   }
11922   {
11923     int r;
11924     suppress_error = 0;
11925     r = guestfs_lvm_remove_all (g);
11926     if (r == -1)
11927       return -1;
11928   }
11929   /* TestOutputList for vgcreate (0) */
11930   {
11931     char device[] = "/dev/sda";
11932     char lines_0[] = ",10";
11933     char lines_1[] = ",20";
11934     char lines_2[] = ",";
11935     char *lines[] = {
11936       lines_0,
11937       lines_1,
11938       lines_2,
11939       NULL
11940     };
11941     int r;
11942     suppress_error = 0;
11943     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11944     if (r == -1)
11945       return -1;
11946   }
11947   {
11948     char device[] = "/dev/sda1";
11949     int r;
11950     suppress_error = 0;
11951     r = guestfs_pvcreate (g, device);
11952     if (r == -1)
11953       return -1;
11954   }
11955   {
11956     char device[] = "/dev/sda2";
11957     int r;
11958     suppress_error = 0;
11959     r = guestfs_pvcreate (g, device);
11960     if (r == -1)
11961       return -1;
11962   }
11963   {
11964     char device[] = "/dev/sda3";
11965     int r;
11966     suppress_error = 0;
11967     r = guestfs_pvcreate (g, device);
11968     if (r == -1)
11969       return -1;
11970   }
11971   {
11972     char volgroup[] = "VG1";
11973     char physvols_0[] = "/dev/sda1";
11974     char physvols_1[] = "/dev/sda2";
11975     char *physvols[] = {
11976       physvols_0,
11977       physvols_1,
11978       NULL
11979     };
11980     int r;
11981     suppress_error = 0;
11982     r = guestfs_vgcreate (g, volgroup, physvols);
11983     if (r == -1)
11984       return -1;
11985   }
11986   {
11987     char volgroup[] = "VG2";
11988     char physvols_0[] = "/dev/sda3";
11989     char *physvols[] = {
11990       physvols_0,
11991       NULL
11992     };
11993     int r;
11994     suppress_error = 0;
11995     r = guestfs_vgcreate (g, volgroup, physvols);
11996     if (r == -1)
11997       return -1;
11998   }
11999   {
12000     char **r;
12001     int i;
12002     suppress_error = 0;
12003     r = guestfs_vgs (g);
12004     if (r == NULL)
12005       return -1;
12006     if (!r[0]) {
12007       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12008       print_strings (r);
12009       return -1;
12010     }
12011     {
12012       char expected[] = "VG1";
12013       if (strcmp (r[0], expected) != 0) {
12014         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12015         return -1;
12016       }
12017     }
12018     if (!r[1]) {
12019       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12020       print_strings (r);
12021       return -1;
12022     }
12023     {
12024       char expected[] = "VG2";
12025       if (strcmp (r[1], expected) != 0) {
12026         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12027         return -1;
12028       }
12029     }
12030     if (r[2] != NULL) {
12031       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12032       print_strings (r);
12033       return -1;
12034     }
12035     for (i = 0; r[i] != NULL; ++i)
12036       free (r[i]);
12037     free (r);
12038   }
12039   return 0;
12040 }
12041
12042 static int test_pvcreate_0_skip (void)
12043 {
12044   const char *str;
12045
12046   str = getenv ("SKIP_TEST_PVCREATE_0");
12047   if (str && strcmp (str, "1") == 0) return 1;
12048   str = getenv ("SKIP_TEST_PVCREATE");
12049   if (str && strcmp (str, "1") == 0) return 1;
12050   return 0;
12051 }
12052
12053 static int test_pvcreate_0 (void)
12054 {
12055   if (test_pvcreate_0_skip ()) {
12056     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12057     return 0;
12058   }
12059
12060   /* InitNone|InitEmpty for test_pvcreate_0 */
12061   {
12062     char device[] = "/dev/sda";
12063     int r;
12064     suppress_error = 0;
12065     r = guestfs_blockdev_setrw (g, device);
12066     if (r == -1)
12067       return -1;
12068   }
12069   {
12070     int r;
12071     suppress_error = 0;
12072     r = guestfs_umount_all (g);
12073     if (r == -1)
12074       return -1;
12075   }
12076   {
12077     int r;
12078     suppress_error = 0;
12079     r = guestfs_lvm_remove_all (g);
12080     if (r == -1)
12081       return -1;
12082   }
12083   /* TestOutputListOfDevices for pvcreate (0) */
12084   {
12085     char device[] = "/dev/sda";
12086     char lines_0[] = ",10";
12087     char lines_1[] = ",20";
12088     char lines_2[] = ",";
12089     char *lines[] = {
12090       lines_0,
12091       lines_1,
12092       lines_2,
12093       NULL
12094     };
12095     int r;
12096     suppress_error = 0;
12097     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12098     if (r == -1)
12099       return -1;
12100   }
12101   {
12102     char device[] = "/dev/sda1";
12103     int r;
12104     suppress_error = 0;
12105     r = guestfs_pvcreate (g, device);
12106     if (r == -1)
12107       return -1;
12108   }
12109   {
12110     char device[] = "/dev/sda2";
12111     int r;
12112     suppress_error = 0;
12113     r = guestfs_pvcreate (g, device);
12114     if (r == -1)
12115       return -1;
12116   }
12117   {
12118     char device[] = "/dev/sda3";
12119     int r;
12120     suppress_error = 0;
12121     r = guestfs_pvcreate (g, device);
12122     if (r == -1)
12123       return -1;
12124   }
12125   {
12126     char **r;
12127     int i;
12128     suppress_error = 0;
12129     r = guestfs_pvs (g);
12130     if (r == NULL)
12131       return -1;
12132     if (!r[0]) {
12133       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12134       print_strings (r);
12135       return -1;
12136     }
12137     {
12138       char expected[] = "/dev/sda1";
12139       r[0][5] = 's';
12140       if (strcmp (r[0], expected) != 0) {
12141         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12142         return -1;
12143       }
12144     }
12145     if (!r[1]) {
12146       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12147       print_strings (r);
12148       return -1;
12149     }
12150     {
12151       char expected[] = "/dev/sda2";
12152       r[1][5] = 's';
12153       if (strcmp (r[1], expected) != 0) {
12154         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12155         return -1;
12156       }
12157     }
12158     if (!r[2]) {
12159       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12160       print_strings (r);
12161       return -1;
12162     }
12163     {
12164       char expected[] = "/dev/sda3";
12165       r[2][5] = 's';
12166       if (strcmp (r[2], expected) != 0) {
12167         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12168         return -1;
12169       }
12170     }
12171     if (r[3] != NULL) {
12172       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12173       print_strings (r);
12174       return -1;
12175     }
12176     for (i = 0; r[i] != NULL; ++i)
12177       free (r[i]);
12178     free (r);
12179   }
12180   return 0;
12181 }
12182
12183 static int test_is_dir_0_skip (void)
12184 {
12185   const char *str;
12186
12187   str = getenv ("SKIP_TEST_IS_DIR_0");
12188   if (str && strcmp (str, "1") == 0) return 1;
12189   str = getenv ("SKIP_TEST_IS_DIR");
12190   if (str && strcmp (str, "1") == 0) return 1;
12191   return 0;
12192 }
12193
12194 static int test_is_dir_0 (void)
12195 {
12196   if (test_is_dir_0_skip ()) {
12197     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12198     return 0;
12199   }
12200
12201   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12202   {
12203     char device[] = "/dev/sda";
12204     int r;
12205     suppress_error = 0;
12206     r = guestfs_blockdev_setrw (g, device);
12207     if (r == -1)
12208       return -1;
12209   }
12210   {
12211     int r;
12212     suppress_error = 0;
12213     r = guestfs_umount_all (g);
12214     if (r == -1)
12215       return -1;
12216   }
12217   {
12218     int r;
12219     suppress_error = 0;
12220     r = guestfs_lvm_remove_all (g);
12221     if (r == -1)
12222       return -1;
12223   }
12224   {
12225     char device[] = "/dev/sda";
12226     char lines_0[] = ",";
12227     char *lines[] = {
12228       lines_0,
12229       NULL
12230     };
12231     int r;
12232     suppress_error = 0;
12233     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12234     if (r == -1)
12235       return -1;
12236   }
12237   {
12238     char fstype[] = "ext2";
12239     char device[] = "/dev/sda1";
12240     int r;
12241     suppress_error = 0;
12242     r = guestfs_mkfs (g, fstype, device);
12243     if (r == -1)
12244       return -1;
12245   }
12246   {
12247     char device[] = "/dev/sda1";
12248     char mountpoint[] = "/";
12249     int r;
12250     suppress_error = 0;
12251     r = guestfs_mount (g, device, mountpoint);
12252     if (r == -1)
12253       return -1;
12254   }
12255   /* TestOutputFalse for is_dir (0) */
12256   {
12257     char path[] = "/new";
12258     int r;
12259     suppress_error = 0;
12260     r = guestfs_touch (g, path);
12261     if (r == -1)
12262       return -1;
12263   }
12264   {
12265     char path[] = "/new";
12266     int r;
12267     suppress_error = 0;
12268     r = guestfs_is_dir (g, path);
12269     if (r == -1)
12270       return -1;
12271     if (r) {
12272       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12273       return -1;
12274     }
12275   }
12276   return 0;
12277 }
12278
12279 static int test_is_dir_1_skip (void)
12280 {
12281   const char *str;
12282
12283   str = getenv ("SKIP_TEST_IS_DIR_1");
12284   if (str && strcmp (str, "1") == 0) return 1;
12285   str = getenv ("SKIP_TEST_IS_DIR");
12286   if (str && strcmp (str, "1") == 0) return 1;
12287   return 0;
12288 }
12289
12290 static int test_is_dir_1 (void)
12291 {
12292   if (test_is_dir_1_skip ()) {
12293     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12294     return 0;
12295   }
12296
12297   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12298   {
12299     char device[] = "/dev/sda";
12300     int r;
12301     suppress_error = 0;
12302     r = guestfs_blockdev_setrw (g, device);
12303     if (r == -1)
12304       return -1;
12305   }
12306   {
12307     int r;
12308     suppress_error = 0;
12309     r = guestfs_umount_all (g);
12310     if (r == -1)
12311       return -1;
12312   }
12313   {
12314     int r;
12315     suppress_error = 0;
12316     r = guestfs_lvm_remove_all (g);
12317     if (r == -1)
12318       return -1;
12319   }
12320   {
12321     char device[] = "/dev/sda";
12322     char lines_0[] = ",";
12323     char *lines[] = {
12324       lines_0,
12325       NULL
12326     };
12327     int r;
12328     suppress_error = 0;
12329     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12330     if (r == -1)
12331       return -1;
12332   }
12333   {
12334     char fstype[] = "ext2";
12335     char device[] = "/dev/sda1";
12336     int r;
12337     suppress_error = 0;
12338     r = guestfs_mkfs (g, fstype, device);
12339     if (r == -1)
12340       return -1;
12341   }
12342   {
12343     char device[] = "/dev/sda1";
12344     char mountpoint[] = "/";
12345     int r;
12346     suppress_error = 0;
12347     r = guestfs_mount (g, device, mountpoint);
12348     if (r == -1)
12349       return -1;
12350   }
12351   /* TestOutputTrue for is_dir (1) */
12352   {
12353     char path[] = "/new";
12354     int r;
12355     suppress_error = 0;
12356     r = guestfs_mkdir (g, path);
12357     if (r == -1)
12358       return -1;
12359   }
12360   {
12361     char path[] = "/new";
12362     int r;
12363     suppress_error = 0;
12364     r = guestfs_is_dir (g, path);
12365     if (r == -1)
12366       return -1;
12367     if (!r) {
12368       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12369       return -1;
12370     }
12371   }
12372   return 0;
12373 }
12374
12375 static int test_is_file_0_skip (void)
12376 {
12377   const char *str;
12378
12379   str = getenv ("SKIP_TEST_IS_FILE_0");
12380   if (str && strcmp (str, "1") == 0) return 1;
12381   str = getenv ("SKIP_TEST_IS_FILE");
12382   if (str && strcmp (str, "1") == 0) return 1;
12383   return 0;
12384 }
12385
12386 static int test_is_file_0 (void)
12387 {
12388   if (test_is_file_0_skip ()) {
12389     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12390     return 0;
12391   }
12392
12393   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12394   {
12395     char device[] = "/dev/sda";
12396     int r;
12397     suppress_error = 0;
12398     r = guestfs_blockdev_setrw (g, device);
12399     if (r == -1)
12400       return -1;
12401   }
12402   {
12403     int r;
12404     suppress_error = 0;
12405     r = guestfs_umount_all (g);
12406     if (r == -1)
12407       return -1;
12408   }
12409   {
12410     int r;
12411     suppress_error = 0;
12412     r = guestfs_lvm_remove_all (g);
12413     if (r == -1)
12414       return -1;
12415   }
12416   {
12417     char device[] = "/dev/sda";
12418     char lines_0[] = ",";
12419     char *lines[] = {
12420       lines_0,
12421       NULL
12422     };
12423     int r;
12424     suppress_error = 0;
12425     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12426     if (r == -1)
12427       return -1;
12428   }
12429   {
12430     char fstype[] = "ext2";
12431     char device[] = "/dev/sda1";
12432     int r;
12433     suppress_error = 0;
12434     r = guestfs_mkfs (g, fstype, device);
12435     if (r == -1)
12436       return -1;
12437   }
12438   {
12439     char device[] = "/dev/sda1";
12440     char mountpoint[] = "/";
12441     int r;
12442     suppress_error = 0;
12443     r = guestfs_mount (g, device, mountpoint);
12444     if (r == -1)
12445       return -1;
12446   }
12447   /* TestOutputTrue for is_file (0) */
12448   {
12449     char path[] = "/new";
12450     int r;
12451     suppress_error = 0;
12452     r = guestfs_touch (g, path);
12453     if (r == -1)
12454       return -1;
12455   }
12456   {
12457     char path[] = "/new";
12458     int r;
12459     suppress_error = 0;
12460     r = guestfs_is_file (g, path);
12461     if (r == -1)
12462       return -1;
12463     if (!r) {
12464       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12465       return -1;
12466     }
12467   }
12468   return 0;
12469 }
12470
12471 static int test_is_file_1_skip (void)
12472 {
12473   const char *str;
12474
12475   str = getenv ("SKIP_TEST_IS_FILE_1");
12476   if (str && strcmp (str, "1") == 0) return 1;
12477   str = getenv ("SKIP_TEST_IS_FILE");
12478   if (str && strcmp (str, "1") == 0) return 1;
12479   return 0;
12480 }
12481
12482 static int test_is_file_1 (void)
12483 {
12484   if (test_is_file_1_skip ()) {
12485     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12486     return 0;
12487   }
12488
12489   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12490   {
12491     char device[] = "/dev/sda";
12492     int r;
12493     suppress_error = 0;
12494     r = guestfs_blockdev_setrw (g, device);
12495     if (r == -1)
12496       return -1;
12497   }
12498   {
12499     int r;
12500     suppress_error = 0;
12501     r = guestfs_umount_all (g);
12502     if (r == -1)
12503       return -1;
12504   }
12505   {
12506     int r;
12507     suppress_error = 0;
12508     r = guestfs_lvm_remove_all (g);
12509     if (r == -1)
12510       return -1;
12511   }
12512   {
12513     char device[] = "/dev/sda";
12514     char lines_0[] = ",";
12515     char *lines[] = {
12516       lines_0,
12517       NULL
12518     };
12519     int r;
12520     suppress_error = 0;
12521     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12522     if (r == -1)
12523       return -1;
12524   }
12525   {
12526     char fstype[] = "ext2";
12527     char device[] = "/dev/sda1";
12528     int r;
12529     suppress_error = 0;
12530     r = guestfs_mkfs (g, fstype, device);
12531     if (r == -1)
12532       return -1;
12533   }
12534   {
12535     char device[] = "/dev/sda1";
12536     char mountpoint[] = "/";
12537     int r;
12538     suppress_error = 0;
12539     r = guestfs_mount (g, device, mountpoint);
12540     if (r == -1)
12541       return -1;
12542   }
12543   /* TestOutputFalse for is_file (1) */
12544   {
12545     char path[] = "/new";
12546     int r;
12547     suppress_error = 0;
12548     r = guestfs_mkdir (g, path);
12549     if (r == -1)
12550       return -1;
12551   }
12552   {
12553     char path[] = "/new";
12554     int r;
12555     suppress_error = 0;
12556     r = guestfs_is_file (g, path);
12557     if (r == -1)
12558       return -1;
12559     if (r) {
12560       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12561       return -1;
12562     }
12563   }
12564   return 0;
12565 }
12566
12567 static int test_exists_0_skip (void)
12568 {
12569   const char *str;
12570
12571   str = getenv ("SKIP_TEST_EXISTS_0");
12572   if (str && strcmp (str, "1") == 0) return 1;
12573   str = getenv ("SKIP_TEST_EXISTS");
12574   if (str && strcmp (str, "1") == 0) return 1;
12575   return 0;
12576 }
12577
12578 static int test_exists_0 (void)
12579 {
12580   if (test_exists_0_skip ()) {
12581     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12582     return 0;
12583   }
12584
12585   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12586   {
12587     char device[] = "/dev/sda";
12588     int r;
12589     suppress_error = 0;
12590     r = guestfs_blockdev_setrw (g, device);
12591     if (r == -1)
12592       return -1;
12593   }
12594   {
12595     int r;
12596     suppress_error = 0;
12597     r = guestfs_umount_all (g);
12598     if (r == -1)
12599       return -1;
12600   }
12601   {
12602     int r;
12603     suppress_error = 0;
12604     r = guestfs_lvm_remove_all (g);
12605     if (r == -1)
12606       return -1;
12607   }
12608   {
12609     char device[] = "/dev/sda";
12610     char lines_0[] = ",";
12611     char *lines[] = {
12612       lines_0,
12613       NULL
12614     };
12615     int r;
12616     suppress_error = 0;
12617     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12618     if (r == -1)
12619       return -1;
12620   }
12621   {
12622     char fstype[] = "ext2";
12623     char device[] = "/dev/sda1";
12624     int r;
12625     suppress_error = 0;
12626     r = guestfs_mkfs (g, fstype, device);
12627     if (r == -1)
12628       return -1;
12629   }
12630   {
12631     char device[] = "/dev/sda1";
12632     char mountpoint[] = "/";
12633     int r;
12634     suppress_error = 0;
12635     r = guestfs_mount (g, device, mountpoint);
12636     if (r == -1)
12637       return -1;
12638   }
12639   /* TestOutputTrue for exists (0) */
12640   {
12641     char path[] = "/new";
12642     int r;
12643     suppress_error = 0;
12644     r = guestfs_touch (g, path);
12645     if (r == -1)
12646       return -1;
12647   }
12648   {
12649     char path[] = "/new";
12650     int r;
12651     suppress_error = 0;
12652     r = guestfs_exists (g, path);
12653     if (r == -1)
12654       return -1;
12655     if (!r) {
12656       fprintf (stderr, "test_exists_0: expected true, got false\n");
12657       return -1;
12658     }
12659   }
12660   return 0;
12661 }
12662
12663 static int test_exists_1_skip (void)
12664 {
12665   const char *str;
12666
12667   str = getenv ("SKIP_TEST_EXISTS_1");
12668   if (str && strcmp (str, "1") == 0) return 1;
12669   str = getenv ("SKIP_TEST_EXISTS");
12670   if (str && strcmp (str, "1") == 0) return 1;
12671   return 0;
12672 }
12673
12674 static int test_exists_1 (void)
12675 {
12676   if (test_exists_1_skip ()) {
12677     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12678     return 0;
12679   }
12680
12681   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12682   {
12683     char device[] = "/dev/sda";
12684     int r;
12685     suppress_error = 0;
12686     r = guestfs_blockdev_setrw (g, device);
12687     if (r == -1)
12688       return -1;
12689   }
12690   {
12691     int r;
12692     suppress_error = 0;
12693     r = guestfs_umount_all (g);
12694     if (r == -1)
12695       return -1;
12696   }
12697   {
12698     int r;
12699     suppress_error = 0;
12700     r = guestfs_lvm_remove_all (g);
12701     if (r == -1)
12702       return -1;
12703   }
12704   {
12705     char device[] = "/dev/sda";
12706     char lines_0[] = ",";
12707     char *lines[] = {
12708       lines_0,
12709       NULL
12710     };
12711     int r;
12712     suppress_error = 0;
12713     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12714     if (r == -1)
12715       return -1;
12716   }
12717   {
12718     char fstype[] = "ext2";
12719     char device[] = "/dev/sda1";
12720     int r;
12721     suppress_error = 0;
12722     r = guestfs_mkfs (g, fstype, device);
12723     if (r == -1)
12724       return -1;
12725   }
12726   {
12727     char device[] = "/dev/sda1";
12728     char mountpoint[] = "/";
12729     int r;
12730     suppress_error = 0;
12731     r = guestfs_mount (g, device, mountpoint);
12732     if (r == -1)
12733       return -1;
12734   }
12735   /* TestOutputTrue for exists (1) */
12736   {
12737     char path[] = "/new";
12738     int r;
12739     suppress_error = 0;
12740     r = guestfs_mkdir (g, path);
12741     if (r == -1)
12742       return -1;
12743   }
12744   {
12745     char path[] = "/new";
12746     int r;
12747     suppress_error = 0;
12748     r = guestfs_exists (g, path);
12749     if (r == -1)
12750       return -1;
12751     if (!r) {
12752       fprintf (stderr, "test_exists_1: expected true, got false\n");
12753       return -1;
12754     }
12755   }
12756   return 0;
12757 }
12758
12759 static int test_mkdir_p_0_skip (void)
12760 {
12761   const char *str;
12762
12763   str = getenv ("SKIP_TEST_MKDIR_P_0");
12764   if (str && strcmp (str, "1") == 0) return 1;
12765   str = getenv ("SKIP_TEST_MKDIR_P");
12766   if (str && strcmp (str, "1") == 0) return 1;
12767   return 0;
12768 }
12769
12770 static int test_mkdir_p_0 (void)
12771 {
12772   if (test_mkdir_p_0_skip ()) {
12773     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12774     return 0;
12775   }
12776
12777   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12778   {
12779     char device[] = "/dev/sda";
12780     int r;
12781     suppress_error = 0;
12782     r = guestfs_blockdev_setrw (g, device);
12783     if (r == -1)
12784       return -1;
12785   }
12786   {
12787     int r;
12788     suppress_error = 0;
12789     r = guestfs_umount_all (g);
12790     if (r == -1)
12791       return -1;
12792   }
12793   {
12794     int r;
12795     suppress_error = 0;
12796     r = guestfs_lvm_remove_all (g);
12797     if (r == -1)
12798       return -1;
12799   }
12800   {
12801     char device[] = "/dev/sda";
12802     char lines_0[] = ",";
12803     char *lines[] = {
12804       lines_0,
12805       NULL
12806     };
12807     int r;
12808     suppress_error = 0;
12809     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12810     if (r == -1)
12811       return -1;
12812   }
12813   {
12814     char fstype[] = "ext2";
12815     char device[] = "/dev/sda1";
12816     int r;
12817     suppress_error = 0;
12818     r = guestfs_mkfs (g, fstype, device);
12819     if (r == -1)
12820       return -1;
12821   }
12822   {
12823     char device[] = "/dev/sda1";
12824     char mountpoint[] = "/";
12825     int r;
12826     suppress_error = 0;
12827     r = guestfs_mount (g, device, mountpoint);
12828     if (r == -1)
12829       return -1;
12830   }
12831   /* TestOutputTrue for mkdir_p (0) */
12832   {
12833     char path[] = "/new/foo/bar";
12834     int r;
12835     suppress_error = 0;
12836     r = guestfs_mkdir_p (g, path);
12837     if (r == -1)
12838       return -1;
12839   }
12840   {
12841     char path[] = "/new/foo/bar";
12842     int r;
12843     suppress_error = 0;
12844     r = guestfs_is_dir (g, path);
12845     if (r == -1)
12846       return -1;
12847     if (!r) {
12848       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12849       return -1;
12850     }
12851   }
12852   return 0;
12853 }
12854
12855 static int test_mkdir_p_1_skip (void)
12856 {
12857   const char *str;
12858
12859   str = getenv ("SKIP_TEST_MKDIR_P_1");
12860   if (str && strcmp (str, "1") == 0) return 1;
12861   str = getenv ("SKIP_TEST_MKDIR_P");
12862   if (str && strcmp (str, "1") == 0) return 1;
12863   return 0;
12864 }
12865
12866 static int test_mkdir_p_1 (void)
12867 {
12868   if (test_mkdir_p_1_skip ()) {
12869     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12870     return 0;
12871   }
12872
12873   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12874   {
12875     char device[] = "/dev/sda";
12876     int r;
12877     suppress_error = 0;
12878     r = guestfs_blockdev_setrw (g, device);
12879     if (r == -1)
12880       return -1;
12881   }
12882   {
12883     int r;
12884     suppress_error = 0;
12885     r = guestfs_umount_all (g);
12886     if (r == -1)
12887       return -1;
12888   }
12889   {
12890     int r;
12891     suppress_error = 0;
12892     r = guestfs_lvm_remove_all (g);
12893     if (r == -1)
12894       return -1;
12895   }
12896   {
12897     char device[] = "/dev/sda";
12898     char lines_0[] = ",";
12899     char *lines[] = {
12900       lines_0,
12901       NULL
12902     };
12903     int r;
12904     suppress_error = 0;
12905     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12906     if (r == -1)
12907       return -1;
12908   }
12909   {
12910     char fstype[] = "ext2";
12911     char device[] = "/dev/sda1";
12912     int r;
12913     suppress_error = 0;
12914     r = guestfs_mkfs (g, fstype, device);
12915     if (r == -1)
12916       return -1;
12917   }
12918   {
12919     char device[] = "/dev/sda1";
12920     char mountpoint[] = "/";
12921     int r;
12922     suppress_error = 0;
12923     r = guestfs_mount (g, device, mountpoint);
12924     if (r == -1)
12925       return -1;
12926   }
12927   /* TestOutputTrue for mkdir_p (1) */
12928   {
12929     char path[] = "/new/foo/bar";
12930     int r;
12931     suppress_error = 0;
12932     r = guestfs_mkdir_p (g, path);
12933     if (r == -1)
12934       return -1;
12935   }
12936   {
12937     char path[] = "/new/foo";
12938     int r;
12939     suppress_error = 0;
12940     r = guestfs_is_dir (g, path);
12941     if (r == -1)
12942       return -1;
12943     if (!r) {
12944       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12945       return -1;
12946     }
12947   }
12948   return 0;
12949 }
12950
12951 static int test_mkdir_p_2_skip (void)
12952 {
12953   const char *str;
12954
12955   str = getenv ("SKIP_TEST_MKDIR_P_2");
12956   if (str && strcmp (str, "1") == 0) return 1;
12957   str = getenv ("SKIP_TEST_MKDIR_P");
12958   if (str && strcmp (str, "1") == 0) return 1;
12959   return 0;
12960 }
12961
12962 static int test_mkdir_p_2 (void)
12963 {
12964   if (test_mkdir_p_2_skip ()) {
12965     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12966     return 0;
12967   }
12968
12969   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12970   {
12971     char device[] = "/dev/sda";
12972     int r;
12973     suppress_error = 0;
12974     r = guestfs_blockdev_setrw (g, device);
12975     if (r == -1)
12976       return -1;
12977   }
12978   {
12979     int r;
12980     suppress_error = 0;
12981     r = guestfs_umount_all (g);
12982     if (r == -1)
12983       return -1;
12984   }
12985   {
12986     int r;
12987     suppress_error = 0;
12988     r = guestfs_lvm_remove_all (g);
12989     if (r == -1)
12990       return -1;
12991   }
12992   {
12993     char device[] = "/dev/sda";
12994     char lines_0[] = ",";
12995     char *lines[] = {
12996       lines_0,
12997       NULL
12998     };
12999     int r;
13000     suppress_error = 0;
13001     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13002     if (r == -1)
13003       return -1;
13004   }
13005   {
13006     char fstype[] = "ext2";
13007     char device[] = "/dev/sda1";
13008     int r;
13009     suppress_error = 0;
13010     r = guestfs_mkfs (g, fstype, device);
13011     if (r == -1)
13012       return -1;
13013   }
13014   {
13015     char device[] = "/dev/sda1";
13016     char mountpoint[] = "/";
13017     int r;
13018     suppress_error = 0;
13019     r = guestfs_mount (g, device, mountpoint);
13020     if (r == -1)
13021       return -1;
13022   }
13023   /* TestOutputTrue for mkdir_p (2) */
13024   {
13025     char path[] = "/new/foo/bar";
13026     int r;
13027     suppress_error = 0;
13028     r = guestfs_mkdir_p (g, path);
13029     if (r == -1)
13030       return -1;
13031   }
13032   {
13033     char path[] = "/new";
13034     int r;
13035     suppress_error = 0;
13036     r = guestfs_is_dir (g, path);
13037     if (r == -1)
13038       return -1;
13039     if (!r) {
13040       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13041       return -1;
13042     }
13043   }
13044   return 0;
13045 }
13046
13047 static int test_mkdir_p_3_skip (void)
13048 {
13049   const char *str;
13050
13051   str = getenv ("SKIP_TEST_MKDIR_P_3");
13052   if (str && strcmp (str, "1") == 0) return 1;
13053   str = getenv ("SKIP_TEST_MKDIR_P");
13054   if (str && strcmp (str, "1") == 0) return 1;
13055   return 0;
13056 }
13057
13058 static int test_mkdir_p_3 (void)
13059 {
13060   if (test_mkdir_p_3_skip ()) {
13061     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13062     return 0;
13063   }
13064
13065   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13066   {
13067     char device[] = "/dev/sda";
13068     int r;
13069     suppress_error = 0;
13070     r = guestfs_blockdev_setrw (g, device);
13071     if (r == -1)
13072       return -1;
13073   }
13074   {
13075     int r;
13076     suppress_error = 0;
13077     r = guestfs_umount_all (g);
13078     if (r == -1)
13079       return -1;
13080   }
13081   {
13082     int r;
13083     suppress_error = 0;
13084     r = guestfs_lvm_remove_all (g);
13085     if (r == -1)
13086       return -1;
13087   }
13088   {
13089     char device[] = "/dev/sda";
13090     char lines_0[] = ",";
13091     char *lines[] = {
13092       lines_0,
13093       NULL
13094     };
13095     int r;
13096     suppress_error = 0;
13097     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13098     if (r == -1)
13099       return -1;
13100   }
13101   {
13102     char fstype[] = "ext2";
13103     char device[] = "/dev/sda1";
13104     int r;
13105     suppress_error = 0;
13106     r = guestfs_mkfs (g, fstype, device);
13107     if (r == -1)
13108       return -1;
13109   }
13110   {
13111     char device[] = "/dev/sda1";
13112     char mountpoint[] = "/";
13113     int r;
13114     suppress_error = 0;
13115     r = guestfs_mount (g, device, mountpoint);
13116     if (r == -1)
13117       return -1;
13118   }
13119   /* TestRun for mkdir_p (3) */
13120   {
13121     char path[] = "/new";
13122     int r;
13123     suppress_error = 0;
13124     r = guestfs_mkdir (g, path);
13125     if (r == -1)
13126       return -1;
13127   }
13128   {
13129     char path[] = "/new";
13130     int r;
13131     suppress_error = 0;
13132     r = guestfs_mkdir_p (g, path);
13133     if (r == -1)
13134       return -1;
13135   }
13136   return 0;
13137 }
13138
13139 static int test_mkdir_p_4_skip (void)
13140 {
13141   const char *str;
13142
13143   str = getenv ("SKIP_TEST_MKDIR_P_4");
13144   if (str && strcmp (str, "1") == 0) return 1;
13145   str = getenv ("SKIP_TEST_MKDIR_P");
13146   if (str && strcmp (str, "1") == 0) return 1;
13147   return 0;
13148 }
13149
13150 static int test_mkdir_p_4 (void)
13151 {
13152   if (test_mkdir_p_4_skip ()) {
13153     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13154     return 0;
13155   }
13156
13157   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13158   {
13159     char device[] = "/dev/sda";
13160     int r;
13161     suppress_error = 0;
13162     r = guestfs_blockdev_setrw (g, device);
13163     if (r == -1)
13164       return -1;
13165   }
13166   {
13167     int r;
13168     suppress_error = 0;
13169     r = guestfs_umount_all (g);
13170     if (r == -1)
13171       return -1;
13172   }
13173   {
13174     int r;
13175     suppress_error = 0;
13176     r = guestfs_lvm_remove_all (g);
13177     if (r == -1)
13178       return -1;
13179   }
13180   {
13181     char device[] = "/dev/sda";
13182     char lines_0[] = ",";
13183     char *lines[] = {
13184       lines_0,
13185       NULL
13186     };
13187     int r;
13188     suppress_error = 0;
13189     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13190     if (r == -1)
13191       return -1;
13192   }
13193   {
13194     char fstype[] = "ext2";
13195     char device[] = "/dev/sda1";
13196     int r;
13197     suppress_error = 0;
13198     r = guestfs_mkfs (g, fstype, device);
13199     if (r == -1)
13200       return -1;
13201   }
13202   {
13203     char device[] = "/dev/sda1";
13204     char mountpoint[] = "/";
13205     int r;
13206     suppress_error = 0;
13207     r = guestfs_mount (g, device, mountpoint);
13208     if (r == -1)
13209       return -1;
13210   }
13211   /* TestLastFail for mkdir_p (4) */
13212   {
13213     char path[] = "/new";
13214     int r;
13215     suppress_error = 0;
13216     r = guestfs_touch (g, path);
13217     if (r == -1)
13218       return -1;
13219   }
13220   {
13221     char path[] = "/new";
13222     int r;
13223     suppress_error = 1;
13224     r = guestfs_mkdir_p (g, path);
13225     if (r != -1)
13226       return -1;
13227   }
13228   return 0;
13229 }
13230
13231 static int test_mkdir_0_skip (void)
13232 {
13233   const char *str;
13234
13235   str = getenv ("SKIP_TEST_MKDIR_0");
13236   if (str && strcmp (str, "1") == 0) return 1;
13237   str = getenv ("SKIP_TEST_MKDIR");
13238   if (str && strcmp (str, "1") == 0) return 1;
13239   return 0;
13240 }
13241
13242 static int test_mkdir_0 (void)
13243 {
13244   if (test_mkdir_0_skip ()) {
13245     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13246     return 0;
13247   }
13248
13249   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13250   {
13251     char device[] = "/dev/sda";
13252     int r;
13253     suppress_error = 0;
13254     r = guestfs_blockdev_setrw (g, device);
13255     if (r == -1)
13256       return -1;
13257   }
13258   {
13259     int r;
13260     suppress_error = 0;
13261     r = guestfs_umount_all (g);
13262     if (r == -1)
13263       return -1;
13264   }
13265   {
13266     int r;
13267     suppress_error = 0;
13268     r = guestfs_lvm_remove_all (g);
13269     if (r == -1)
13270       return -1;
13271   }
13272   {
13273     char device[] = "/dev/sda";
13274     char lines_0[] = ",";
13275     char *lines[] = {
13276       lines_0,
13277       NULL
13278     };
13279     int r;
13280     suppress_error = 0;
13281     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13282     if (r == -1)
13283       return -1;
13284   }
13285   {
13286     char fstype[] = "ext2";
13287     char device[] = "/dev/sda1";
13288     int r;
13289     suppress_error = 0;
13290     r = guestfs_mkfs (g, fstype, device);
13291     if (r == -1)
13292       return -1;
13293   }
13294   {
13295     char device[] = "/dev/sda1";
13296     char mountpoint[] = "/";
13297     int r;
13298     suppress_error = 0;
13299     r = guestfs_mount (g, device, mountpoint);
13300     if (r == -1)
13301       return -1;
13302   }
13303   /* TestOutputTrue for mkdir (0) */
13304   {
13305     char path[] = "/new";
13306     int r;
13307     suppress_error = 0;
13308     r = guestfs_mkdir (g, path);
13309     if (r == -1)
13310       return -1;
13311   }
13312   {
13313     char path[] = "/new";
13314     int r;
13315     suppress_error = 0;
13316     r = guestfs_is_dir (g, path);
13317     if (r == -1)
13318       return -1;
13319     if (!r) {
13320       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13321       return -1;
13322     }
13323   }
13324   return 0;
13325 }
13326
13327 static int test_mkdir_1_skip (void)
13328 {
13329   const char *str;
13330
13331   str = getenv ("SKIP_TEST_MKDIR_1");
13332   if (str && strcmp (str, "1") == 0) return 1;
13333   str = getenv ("SKIP_TEST_MKDIR");
13334   if (str && strcmp (str, "1") == 0) return 1;
13335   return 0;
13336 }
13337
13338 static int test_mkdir_1 (void)
13339 {
13340   if (test_mkdir_1_skip ()) {
13341     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13342     return 0;
13343   }
13344
13345   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13346   {
13347     char device[] = "/dev/sda";
13348     int r;
13349     suppress_error = 0;
13350     r = guestfs_blockdev_setrw (g, device);
13351     if (r == -1)
13352       return -1;
13353   }
13354   {
13355     int r;
13356     suppress_error = 0;
13357     r = guestfs_umount_all (g);
13358     if (r == -1)
13359       return -1;
13360   }
13361   {
13362     int r;
13363     suppress_error = 0;
13364     r = guestfs_lvm_remove_all (g);
13365     if (r == -1)
13366       return -1;
13367   }
13368   {
13369     char device[] = "/dev/sda";
13370     char lines_0[] = ",";
13371     char *lines[] = {
13372       lines_0,
13373       NULL
13374     };
13375     int r;
13376     suppress_error = 0;
13377     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13378     if (r == -1)
13379       return -1;
13380   }
13381   {
13382     char fstype[] = "ext2";
13383     char device[] = "/dev/sda1";
13384     int r;
13385     suppress_error = 0;
13386     r = guestfs_mkfs (g, fstype, device);
13387     if (r == -1)
13388       return -1;
13389   }
13390   {
13391     char device[] = "/dev/sda1";
13392     char mountpoint[] = "/";
13393     int r;
13394     suppress_error = 0;
13395     r = guestfs_mount (g, device, mountpoint);
13396     if (r == -1)
13397       return -1;
13398   }
13399   /* TestLastFail for mkdir (1) */
13400   {
13401     char path[] = "/new/foo/bar";
13402     int r;
13403     suppress_error = 1;
13404     r = guestfs_mkdir (g, path);
13405     if (r != -1)
13406       return -1;
13407   }
13408   return 0;
13409 }
13410
13411 static int test_rm_rf_0_skip (void)
13412 {
13413   const char *str;
13414
13415   str = getenv ("SKIP_TEST_RM_RF_0");
13416   if (str && strcmp (str, "1") == 0) return 1;
13417   str = getenv ("SKIP_TEST_RM_RF");
13418   if (str && strcmp (str, "1") == 0) return 1;
13419   return 0;
13420 }
13421
13422 static int test_rm_rf_0 (void)
13423 {
13424   if (test_rm_rf_0_skip ()) {
13425     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13426     return 0;
13427   }
13428
13429   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13430   {
13431     char device[] = "/dev/sda";
13432     int r;
13433     suppress_error = 0;
13434     r = guestfs_blockdev_setrw (g, device);
13435     if (r == -1)
13436       return -1;
13437   }
13438   {
13439     int r;
13440     suppress_error = 0;
13441     r = guestfs_umount_all (g);
13442     if (r == -1)
13443       return -1;
13444   }
13445   {
13446     int r;
13447     suppress_error = 0;
13448     r = guestfs_lvm_remove_all (g);
13449     if (r == -1)
13450       return -1;
13451   }
13452   {
13453     char device[] = "/dev/sda";
13454     char lines_0[] = ",";
13455     char *lines[] = {
13456       lines_0,
13457       NULL
13458     };
13459     int r;
13460     suppress_error = 0;
13461     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13462     if (r == -1)
13463       return -1;
13464   }
13465   {
13466     char fstype[] = "ext2";
13467     char device[] = "/dev/sda1";
13468     int r;
13469     suppress_error = 0;
13470     r = guestfs_mkfs (g, fstype, device);
13471     if (r == -1)
13472       return -1;
13473   }
13474   {
13475     char device[] = "/dev/sda1";
13476     char mountpoint[] = "/";
13477     int r;
13478     suppress_error = 0;
13479     r = guestfs_mount (g, device, mountpoint);
13480     if (r == -1)
13481       return -1;
13482   }
13483   /* TestOutputFalse for rm_rf (0) */
13484   {
13485     char path[] = "/new";
13486     int r;
13487     suppress_error = 0;
13488     r = guestfs_mkdir (g, path);
13489     if (r == -1)
13490       return -1;
13491   }
13492   {
13493     char path[] = "/new/foo";
13494     int r;
13495     suppress_error = 0;
13496     r = guestfs_mkdir (g, path);
13497     if (r == -1)
13498       return -1;
13499   }
13500   {
13501     char path[] = "/new/foo/bar";
13502     int r;
13503     suppress_error = 0;
13504     r = guestfs_touch (g, path);
13505     if (r == -1)
13506       return -1;
13507   }
13508   {
13509     char path[] = "/new";
13510     int r;
13511     suppress_error = 0;
13512     r = guestfs_rm_rf (g, path);
13513     if (r == -1)
13514       return -1;
13515   }
13516   {
13517     char path[] = "/new";
13518     int r;
13519     suppress_error = 0;
13520     r = guestfs_exists (g, path);
13521     if (r == -1)
13522       return -1;
13523     if (r) {
13524       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13525       return -1;
13526     }
13527   }
13528   return 0;
13529 }
13530
13531 static int test_rmdir_0_skip (void)
13532 {
13533   const char *str;
13534
13535   str = getenv ("SKIP_TEST_RMDIR_0");
13536   if (str && strcmp (str, "1") == 0) return 1;
13537   str = getenv ("SKIP_TEST_RMDIR");
13538   if (str && strcmp (str, "1") == 0) return 1;
13539   return 0;
13540 }
13541
13542 static int test_rmdir_0 (void)
13543 {
13544   if (test_rmdir_0_skip ()) {
13545     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13546     return 0;
13547   }
13548
13549   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13550   {
13551     char device[] = "/dev/sda";
13552     int r;
13553     suppress_error = 0;
13554     r = guestfs_blockdev_setrw (g, device);
13555     if (r == -1)
13556       return -1;
13557   }
13558   {
13559     int r;
13560     suppress_error = 0;
13561     r = guestfs_umount_all (g);
13562     if (r == -1)
13563       return -1;
13564   }
13565   {
13566     int r;
13567     suppress_error = 0;
13568     r = guestfs_lvm_remove_all (g);
13569     if (r == -1)
13570       return -1;
13571   }
13572   {
13573     char device[] = "/dev/sda";
13574     char lines_0[] = ",";
13575     char *lines[] = {
13576       lines_0,
13577       NULL
13578     };
13579     int r;
13580     suppress_error = 0;
13581     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13582     if (r == -1)
13583       return -1;
13584   }
13585   {
13586     char fstype[] = "ext2";
13587     char device[] = "/dev/sda1";
13588     int r;
13589     suppress_error = 0;
13590     r = guestfs_mkfs (g, fstype, device);
13591     if (r == -1)
13592       return -1;
13593   }
13594   {
13595     char device[] = "/dev/sda1";
13596     char mountpoint[] = "/";
13597     int r;
13598     suppress_error = 0;
13599     r = guestfs_mount (g, device, mountpoint);
13600     if (r == -1)
13601       return -1;
13602   }
13603   /* TestRun for rmdir (0) */
13604   {
13605     char path[] = "/new";
13606     int r;
13607     suppress_error = 0;
13608     r = guestfs_mkdir (g, path);
13609     if (r == -1)
13610       return -1;
13611   }
13612   {
13613     char path[] = "/new";
13614     int r;
13615     suppress_error = 0;
13616     r = guestfs_rmdir (g, path);
13617     if (r == -1)
13618       return -1;
13619   }
13620   return 0;
13621 }
13622
13623 static int test_rmdir_1_skip (void)
13624 {
13625   const char *str;
13626
13627   str = getenv ("SKIP_TEST_RMDIR_1");
13628   if (str && strcmp (str, "1") == 0) return 1;
13629   str = getenv ("SKIP_TEST_RMDIR");
13630   if (str && strcmp (str, "1") == 0) return 1;
13631   return 0;
13632 }
13633
13634 static int test_rmdir_1 (void)
13635 {
13636   if (test_rmdir_1_skip ()) {
13637     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13638     return 0;
13639   }
13640
13641   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13642   {
13643     char device[] = "/dev/sda";
13644     int r;
13645     suppress_error = 0;
13646     r = guestfs_blockdev_setrw (g, device);
13647     if (r == -1)
13648       return -1;
13649   }
13650   {
13651     int r;
13652     suppress_error = 0;
13653     r = guestfs_umount_all (g);
13654     if (r == -1)
13655       return -1;
13656   }
13657   {
13658     int r;
13659     suppress_error = 0;
13660     r = guestfs_lvm_remove_all (g);
13661     if (r == -1)
13662       return -1;
13663   }
13664   {
13665     char device[] = "/dev/sda";
13666     char lines_0[] = ",";
13667     char *lines[] = {
13668       lines_0,
13669       NULL
13670     };
13671     int r;
13672     suppress_error = 0;
13673     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13674     if (r == -1)
13675       return -1;
13676   }
13677   {
13678     char fstype[] = "ext2";
13679     char device[] = "/dev/sda1";
13680     int r;
13681     suppress_error = 0;
13682     r = guestfs_mkfs (g, fstype, device);
13683     if (r == -1)
13684       return -1;
13685   }
13686   {
13687     char device[] = "/dev/sda1";
13688     char mountpoint[] = "/";
13689     int r;
13690     suppress_error = 0;
13691     r = guestfs_mount (g, device, mountpoint);
13692     if (r == -1)
13693       return -1;
13694   }
13695   /* TestLastFail for rmdir (1) */
13696   {
13697     char path[] = "/new";
13698     int r;
13699     suppress_error = 1;
13700     r = guestfs_rmdir (g, path);
13701     if (r != -1)
13702       return -1;
13703   }
13704   return 0;
13705 }
13706
13707 static int test_rmdir_2_skip (void)
13708 {
13709   const char *str;
13710
13711   str = getenv ("SKIP_TEST_RMDIR_2");
13712   if (str && strcmp (str, "1") == 0) return 1;
13713   str = getenv ("SKIP_TEST_RMDIR");
13714   if (str && strcmp (str, "1") == 0) return 1;
13715   return 0;
13716 }
13717
13718 static int test_rmdir_2 (void)
13719 {
13720   if (test_rmdir_2_skip ()) {
13721     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13722     return 0;
13723   }
13724
13725   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13726   {
13727     char device[] = "/dev/sda";
13728     int r;
13729     suppress_error = 0;
13730     r = guestfs_blockdev_setrw (g, device);
13731     if (r == -1)
13732       return -1;
13733   }
13734   {
13735     int r;
13736     suppress_error = 0;
13737     r = guestfs_umount_all (g);
13738     if (r == -1)
13739       return -1;
13740   }
13741   {
13742     int r;
13743     suppress_error = 0;
13744     r = guestfs_lvm_remove_all (g);
13745     if (r == -1)
13746       return -1;
13747   }
13748   {
13749     char device[] = "/dev/sda";
13750     char lines_0[] = ",";
13751     char *lines[] = {
13752       lines_0,
13753       NULL
13754     };
13755     int r;
13756     suppress_error = 0;
13757     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13758     if (r == -1)
13759       return -1;
13760   }
13761   {
13762     char fstype[] = "ext2";
13763     char device[] = "/dev/sda1";
13764     int r;
13765     suppress_error = 0;
13766     r = guestfs_mkfs (g, fstype, device);
13767     if (r == -1)
13768       return -1;
13769   }
13770   {
13771     char device[] = "/dev/sda1";
13772     char mountpoint[] = "/";
13773     int r;
13774     suppress_error = 0;
13775     r = guestfs_mount (g, device, mountpoint);
13776     if (r == -1)
13777       return -1;
13778   }
13779   /* TestLastFail for rmdir (2) */
13780   {
13781     char path[] = "/new";
13782     int r;
13783     suppress_error = 0;
13784     r = guestfs_touch (g, path);
13785     if (r == -1)
13786       return -1;
13787   }
13788   {
13789     char path[] = "/new";
13790     int r;
13791     suppress_error = 1;
13792     r = guestfs_rmdir (g, path);
13793     if (r != -1)
13794       return -1;
13795   }
13796   return 0;
13797 }
13798
13799 static int test_rm_0_skip (void)
13800 {
13801   const char *str;
13802
13803   str = getenv ("SKIP_TEST_RM_0");
13804   if (str && strcmp (str, "1") == 0) return 1;
13805   str = getenv ("SKIP_TEST_RM");
13806   if (str && strcmp (str, "1") == 0) return 1;
13807   return 0;
13808 }
13809
13810 static int test_rm_0 (void)
13811 {
13812   if (test_rm_0_skip ()) {
13813     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13814     return 0;
13815   }
13816
13817   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13818   {
13819     char device[] = "/dev/sda";
13820     int r;
13821     suppress_error = 0;
13822     r = guestfs_blockdev_setrw (g, device);
13823     if (r == -1)
13824       return -1;
13825   }
13826   {
13827     int r;
13828     suppress_error = 0;
13829     r = guestfs_umount_all (g);
13830     if (r == -1)
13831       return -1;
13832   }
13833   {
13834     int r;
13835     suppress_error = 0;
13836     r = guestfs_lvm_remove_all (g);
13837     if (r == -1)
13838       return -1;
13839   }
13840   {
13841     char device[] = "/dev/sda";
13842     char lines_0[] = ",";
13843     char *lines[] = {
13844       lines_0,
13845       NULL
13846     };
13847     int r;
13848     suppress_error = 0;
13849     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13850     if (r == -1)
13851       return -1;
13852   }
13853   {
13854     char fstype[] = "ext2";
13855     char device[] = "/dev/sda1";
13856     int r;
13857     suppress_error = 0;
13858     r = guestfs_mkfs (g, fstype, device);
13859     if (r == -1)
13860       return -1;
13861   }
13862   {
13863     char device[] = "/dev/sda1";
13864     char mountpoint[] = "/";
13865     int r;
13866     suppress_error = 0;
13867     r = guestfs_mount (g, device, mountpoint);
13868     if (r == -1)
13869       return -1;
13870   }
13871   /* TestRun for rm (0) */
13872   {
13873     char path[] = "/new";
13874     int r;
13875     suppress_error = 0;
13876     r = guestfs_touch (g, path);
13877     if (r == -1)
13878       return -1;
13879   }
13880   {
13881     char path[] = "/new";
13882     int r;
13883     suppress_error = 0;
13884     r = guestfs_rm (g, path);
13885     if (r == -1)
13886       return -1;
13887   }
13888   return 0;
13889 }
13890
13891 static int test_rm_1_skip (void)
13892 {
13893   const char *str;
13894
13895   str = getenv ("SKIP_TEST_RM_1");
13896   if (str && strcmp (str, "1") == 0) return 1;
13897   str = getenv ("SKIP_TEST_RM");
13898   if (str && strcmp (str, "1") == 0) return 1;
13899   return 0;
13900 }
13901
13902 static int test_rm_1 (void)
13903 {
13904   if (test_rm_1_skip ()) {
13905     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13906     return 0;
13907   }
13908
13909   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13910   {
13911     char device[] = "/dev/sda";
13912     int r;
13913     suppress_error = 0;
13914     r = guestfs_blockdev_setrw (g, device);
13915     if (r == -1)
13916       return -1;
13917   }
13918   {
13919     int r;
13920     suppress_error = 0;
13921     r = guestfs_umount_all (g);
13922     if (r == -1)
13923       return -1;
13924   }
13925   {
13926     int r;
13927     suppress_error = 0;
13928     r = guestfs_lvm_remove_all (g);
13929     if (r == -1)
13930       return -1;
13931   }
13932   {
13933     char device[] = "/dev/sda";
13934     char lines_0[] = ",";
13935     char *lines[] = {
13936       lines_0,
13937       NULL
13938     };
13939     int r;
13940     suppress_error = 0;
13941     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13942     if (r == -1)
13943       return -1;
13944   }
13945   {
13946     char fstype[] = "ext2";
13947     char device[] = "/dev/sda1";
13948     int r;
13949     suppress_error = 0;
13950     r = guestfs_mkfs (g, fstype, device);
13951     if (r == -1)
13952       return -1;
13953   }
13954   {
13955     char device[] = "/dev/sda1";
13956     char mountpoint[] = "/";
13957     int r;
13958     suppress_error = 0;
13959     r = guestfs_mount (g, device, mountpoint);
13960     if (r == -1)
13961       return -1;
13962   }
13963   /* TestLastFail for rm (1) */
13964   {
13965     char path[] = "/new";
13966     int r;
13967     suppress_error = 1;
13968     r = guestfs_rm (g, path);
13969     if (r != -1)
13970       return -1;
13971   }
13972   return 0;
13973 }
13974
13975 static int test_rm_2_skip (void)
13976 {
13977   const char *str;
13978
13979   str = getenv ("SKIP_TEST_RM_2");
13980   if (str && strcmp (str, "1") == 0) return 1;
13981   str = getenv ("SKIP_TEST_RM");
13982   if (str && strcmp (str, "1") == 0) return 1;
13983   return 0;
13984 }
13985
13986 static int test_rm_2 (void)
13987 {
13988   if (test_rm_2_skip ()) {
13989     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13990     return 0;
13991   }
13992
13993   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13994   {
13995     char device[] = "/dev/sda";
13996     int r;
13997     suppress_error = 0;
13998     r = guestfs_blockdev_setrw (g, device);
13999     if (r == -1)
14000       return -1;
14001   }
14002   {
14003     int r;
14004     suppress_error = 0;
14005     r = guestfs_umount_all (g);
14006     if (r == -1)
14007       return -1;
14008   }
14009   {
14010     int r;
14011     suppress_error = 0;
14012     r = guestfs_lvm_remove_all (g);
14013     if (r == -1)
14014       return -1;
14015   }
14016   {
14017     char device[] = "/dev/sda";
14018     char lines_0[] = ",";
14019     char *lines[] = {
14020       lines_0,
14021       NULL
14022     };
14023     int r;
14024     suppress_error = 0;
14025     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14026     if (r == -1)
14027       return -1;
14028   }
14029   {
14030     char fstype[] = "ext2";
14031     char device[] = "/dev/sda1";
14032     int r;
14033     suppress_error = 0;
14034     r = guestfs_mkfs (g, fstype, device);
14035     if (r == -1)
14036       return -1;
14037   }
14038   {
14039     char device[] = "/dev/sda1";
14040     char mountpoint[] = "/";
14041     int r;
14042     suppress_error = 0;
14043     r = guestfs_mount (g, device, mountpoint);
14044     if (r == -1)
14045       return -1;
14046   }
14047   /* TestLastFail for rm (2) */
14048   {
14049     char path[] = "/new";
14050     int r;
14051     suppress_error = 0;
14052     r = guestfs_mkdir (g, path);
14053     if (r == -1)
14054       return -1;
14055   }
14056   {
14057     char path[] = "/new";
14058     int r;
14059     suppress_error = 1;
14060     r = guestfs_rm (g, path);
14061     if (r != -1)
14062       return -1;
14063   }
14064   return 0;
14065 }
14066
14067 static int test_read_lines_0_skip (void)
14068 {
14069   const char *str;
14070
14071   str = getenv ("SKIP_TEST_READ_LINES_0");
14072   if (str && strcmp (str, "1") == 0) return 1;
14073   str = getenv ("SKIP_TEST_READ_LINES");
14074   if (str && strcmp (str, "1") == 0) return 1;
14075   return 0;
14076 }
14077
14078 static int test_read_lines_0 (void)
14079 {
14080   if (test_read_lines_0_skip ()) {
14081     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14082     return 0;
14083   }
14084
14085   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14086   {
14087     char device[] = "/dev/sda";
14088     int r;
14089     suppress_error = 0;
14090     r = guestfs_blockdev_setrw (g, device);
14091     if (r == -1)
14092       return -1;
14093   }
14094   {
14095     int r;
14096     suppress_error = 0;
14097     r = guestfs_umount_all (g);
14098     if (r == -1)
14099       return -1;
14100   }
14101   {
14102     int r;
14103     suppress_error = 0;
14104     r = guestfs_lvm_remove_all (g);
14105     if (r == -1)
14106       return -1;
14107   }
14108   {
14109     char device[] = "/dev/sda";
14110     char lines_0[] = ",";
14111     char *lines[] = {
14112       lines_0,
14113       NULL
14114     };
14115     int r;
14116     suppress_error = 0;
14117     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14118     if (r == -1)
14119       return -1;
14120   }
14121   {
14122     char fstype[] = "ext2";
14123     char device[] = "/dev/sda1";
14124     int r;
14125     suppress_error = 0;
14126     r = guestfs_mkfs (g, fstype, device);
14127     if (r == -1)
14128       return -1;
14129   }
14130   {
14131     char device[] = "/dev/sda1";
14132     char mountpoint[] = "/";
14133     int r;
14134     suppress_error = 0;
14135     r = guestfs_mount (g, device, mountpoint);
14136     if (r == -1)
14137       return -1;
14138   }
14139   /* TestOutputList for read_lines (0) */
14140   {
14141     char path[] = "/new";
14142     char content[] = "line1\r\nline2\nline3";
14143     int r;
14144     suppress_error = 0;
14145     r = guestfs_write_file (g, path, content, 0);
14146     if (r == -1)
14147       return -1;
14148   }
14149   {
14150     char path[] = "/new";
14151     char **r;
14152     int i;
14153     suppress_error = 0;
14154     r = guestfs_read_lines (g, path);
14155     if (r == NULL)
14156       return -1;
14157     if (!r[0]) {
14158       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14159       print_strings (r);
14160       return -1;
14161     }
14162     {
14163       char expected[] = "line1";
14164       if (strcmp (r[0], expected) != 0) {
14165         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14166         return -1;
14167       }
14168     }
14169     if (!r[1]) {
14170       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14171       print_strings (r);
14172       return -1;
14173     }
14174     {
14175       char expected[] = "line2";
14176       if (strcmp (r[1], expected) != 0) {
14177         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14178         return -1;
14179       }
14180     }
14181     if (!r[2]) {
14182       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14183       print_strings (r);
14184       return -1;
14185     }
14186     {
14187       char expected[] = "line3";
14188       if (strcmp (r[2], expected) != 0) {
14189         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14190         return -1;
14191       }
14192     }
14193     if (r[3] != NULL) {
14194       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14195       print_strings (r);
14196       return -1;
14197     }
14198     for (i = 0; r[i] != NULL; ++i)
14199       free (r[i]);
14200     free (r);
14201   }
14202   return 0;
14203 }
14204
14205 static int test_read_lines_1_skip (void)
14206 {
14207   const char *str;
14208
14209   str = getenv ("SKIP_TEST_READ_LINES_1");
14210   if (str && strcmp (str, "1") == 0) return 1;
14211   str = getenv ("SKIP_TEST_READ_LINES");
14212   if (str && strcmp (str, "1") == 0) return 1;
14213   return 0;
14214 }
14215
14216 static int test_read_lines_1 (void)
14217 {
14218   if (test_read_lines_1_skip ()) {
14219     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14220     return 0;
14221   }
14222
14223   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14224   {
14225     char device[] = "/dev/sda";
14226     int r;
14227     suppress_error = 0;
14228     r = guestfs_blockdev_setrw (g, device);
14229     if (r == -1)
14230       return -1;
14231   }
14232   {
14233     int r;
14234     suppress_error = 0;
14235     r = guestfs_umount_all (g);
14236     if (r == -1)
14237       return -1;
14238   }
14239   {
14240     int r;
14241     suppress_error = 0;
14242     r = guestfs_lvm_remove_all (g);
14243     if (r == -1)
14244       return -1;
14245   }
14246   {
14247     char device[] = "/dev/sda";
14248     char lines_0[] = ",";
14249     char *lines[] = {
14250       lines_0,
14251       NULL
14252     };
14253     int r;
14254     suppress_error = 0;
14255     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14256     if (r == -1)
14257       return -1;
14258   }
14259   {
14260     char fstype[] = "ext2";
14261     char device[] = "/dev/sda1";
14262     int r;
14263     suppress_error = 0;
14264     r = guestfs_mkfs (g, fstype, device);
14265     if (r == -1)
14266       return -1;
14267   }
14268   {
14269     char device[] = "/dev/sda1";
14270     char mountpoint[] = "/";
14271     int r;
14272     suppress_error = 0;
14273     r = guestfs_mount (g, device, mountpoint);
14274     if (r == -1)
14275       return -1;
14276   }
14277   /* TestOutputList for read_lines (1) */
14278   {
14279     char path[] = "/new";
14280     char content[] = "";
14281     int r;
14282     suppress_error = 0;
14283     r = guestfs_write_file (g, path, content, 0);
14284     if (r == -1)
14285       return -1;
14286   }
14287   {
14288     char path[] = "/new";
14289     char **r;
14290     int i;
14291     suppress_error = 0;
14292     r = guestfs_read_lines (g, path);
14293     if (r == NULL)
14294       return -1;
14295     if (r[0] != NULL) {
14296       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14297       print_strings (r);
14298       return -1;
14299     }
14300     for (i = 0; r[i] != NULL; ++i)
14301       free (r[i]);
14302     free (r);
14303   }
14304   return 0;
14305 }
14306
14307 static int test_lvs_0_skip (void)
14308 {
14309   const char *str;
14310
14311   str = getenv ("SKIP_TEST_LVS_0");
14312   if (str && strcmp (str, "1") == 0) return 1;
14313   str = getenv ("SKIP_TEST_LVS");
14314   if (str && strcmp (str, "1") == 0) return 1;
14315   return 0;
14316 }
14317
14318 static int test_lvs_0 (void)
14319 {
14320   if (test_lvs_0_skip ()) {
14321     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14322     return 0;
14323   }
14324
14325   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14326   {
14327     char device[] = "/dev/sda";
14328     int r;
14329     suppress_error = 0;
14330     r = guestfs_blockdev_setrw (g, device);
14331     if (r == -1)
14332       return -1;
14333   }
14334   {
14335     int r;
14336     suppress_error = 0;
14337     r = guestfs_umount_all (g);
14338     if (r == -1)
14339       return -1;
14340   }
14341   {
14342     int r;
14343     suppress_error = 0;
14344     r = guestfs_lvm_remove_all (g);
14345     if (r == -1)
14346       return -1;
14347   }
14348   {
14349     char device[] = "/dev/sda";
14350     char lines_0[] = ",";
14351     char *lines[] = {
14352       lines_0,
14353       NULL
14354     };
14355     int r;
14356     suppress_error = 0;
14357     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14358     if (r == -1)
14359       return -1;
14360   }
14361   {
14362     char device[] = "/dev/sda1";
14363     int r;
14364     suppress_error = 0;
14365     r = guestfs_pvcreate (g, device);
14366     if (r == -1)
14367       return -1;
14368   }
14369   {
14370     char volgroup[] = "VG";
14371     char physvols_0[] = "/dev/sda1";
14372     char *physvols[] = {
14373       physvols_0,
14374       NULL
14375     };
14376     int r;
14377     suppress_error = 0;
14378     r = guestfs_vgcreate (g, volgroup, physvols);
14379     if (r == -1)
14380       return -1;
14381   }
14382   {
14383     char logvol[] = "LV";
14384     char volgroup[] = "VG";
14385     int r;
14386     suppress_error = 0;
14387     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14388     if (r == -1)
14389       return -1;
14390   }
14391   {
14392     char fstype[] = "ext2";
14393     char device[] = "/dev/VG/LV";
14394     int r;
14395     suppress_error = 0;
14396     r = guestfs_mkfs (g, fstype, device);
14397     if (r == -1)
14398       return -1;
14399   }
14400   {
14401     char device[] = "/dev/VG/LV";
14402     char mountpoint[] = "/";
14403     int r;
14404     suppress_error = 0;
14405     r = guestfs_mount (g, device, mountpoint);
14406     if (r == -1)
14407       return -1;
14408   }
14409   /* TestOutputList for lvs (0) */
14410   {
14411     char **r;
14412     int i;
14413     suppress_error = 0;
14414     r = guestfs_lvs (g);
14415     if (r == NULL)
14416       return -1;
14417     if (!r[0]) {
14418       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14419       print_strings (r);
14420       return -1;
14421     }
14422     {
14423       char expected[] = "/dev/VG/LV";
14424       if (strcmp (r[0], expected) != 0) {
14425         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14426         return -1;
14427       }
14428     }
14429     if (r[1] != NULL) {
14430       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14431       print_strings (r);
14432       return -1;
14433     }
14434     for (i = 0; r[i] != NULL; ++i)
14435       free (r[i]);
14436     free (r);
14437   }
14438   return 0;
14439 }
14440
14441 static int test_lvs_1_skip (void)
14442 {
14443   const char *str;
14444
14445   str = getenv ("SKIP_TEST_LVS_1");
14446   if (str && strcmp (str, "1") == 0) return 1;
14447   str = getenv ("SKIP_TEST_LVS");
14448   if (str && strcmp (str, "1") == 0) return 1;
14449   return 0;
14450 }
14451
14452 static int test_lvs_1 (void)
14453 {
14454   if (test_lvs_1_skip ()) {
14455     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14456     return 0;
14457   }
14458
14459   /* InitNone|InitEmpty for test_lvs_1 */
14460   {
14461     char device[] = "/dev/sda";
14462     int r;
14463     suppress_error = 0;
14464     r = guestfs_blockdev_setrw (g, device);
14465     if (r == -1)
14466       return -1;
14467   }
14468   {
14469     int r;
14470     suppress_error = 0;
14471     r = guestfs_umount_all (g);
14472     if (r == -1)
14473       return -1;
14474   }
14475   {
14476     int r;
14477     suppress_error = 0;
14478     r = guestfs_lvm_remove_all (g);
14479     if (r == -1)
14480       return -1;
14481   }
14482   /* TestOutputList for lvs (1) */
14483   {
14484     char device[] = "/dev/sda";
14485     char lines_0[] = ",10";
14486     char lines_1[] = ",20";
14487     char lines_2[] = ",";
14488     char *lines[] = {
14489       lines_0,
14490       lines_1,
14491       lines_2,
14492       NULL
14493     };
14494     int r;
14495     suppress_error = 0;
14496     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14497     if (r == -1)
14498       return -1;
14499   }
14500   {
14501     char device[] = "/dev/sda1";
14502     int r;
14503     suppress_error = 0;
14504     r = guestfs_pvcreate (g, device);
14505     if (r == -1)
14506       return -1;
14507   }
14508   {
14509     char device[] = "/dev/sda2";
14510     int r;
14511     suppress_error = 0;
14512     r = guestfs_pvcreate (g, device);
14513     if (r == -1)
14514       return -1;
14515   }
14516   {
14517     char device[] = "/dev/sda3";
14518     int r;
14519     suppress_error = 0;
14520     r = guestfs_pvcreate (g, device);
14521     if (r == -1)
14522       return -1;
14523   }
14524   {
14525     char volgroup[] = "VG1";
14526     char physvols_0[] = "/dev/sda1";
14527     char physvols_1[] = "/dev/sda2";
14528     char *physvols[] = {
14529       physvols_0,
14530       physvols_1,
14531       NULL
14532     };
14533     int r;
14534     suppress_error = 0;
14535     r = guestfs_vgcreate (g, volgroup, physvols);
14536     if (r == -1)
14537       return -1;
14538   }
14539   {
14540     char volgroup[] = "VG2";
14541     char physvols_0[] = "/dev/sda3";
14542     char *physvols[] = {
14543       physvols_0,
14544       NULL
14545     };
14546     int r;
14547     suppress_error = 0;
14548     r = guestfs_vgcreate (g, volgroup, physvols);
14549     if (r == -1)
14550       return -1;
14551   }
14552   {
14553     char logvol[] = "LV1";
14554     char volgroup[] = "VG1";
14555     int r;
14556     suppress_error = 0;
14557     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14558     if (r == -1)
14559       return -1;
14560   }
14561   {
14562     char logvol[] = "LV2";
14563     char volgroup[] = "VG1";
14564     int r;
14565     suppress_error = 0;
14566     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14567     if (r == -1)
14568       return -1;
14569   }
14570   {
14571     char logvol[] = "LV3";
14572     char volgroup[] = "VG2";
14573     int r;
14574     suppress_error = 0;
14575     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14576     if (r == -1)
14577       return -1;
14578   }
14579   {
14580     char **r;
14581     int i;
14582     suppress_error = 0;
14583     r = guestfs_lvs (g);
14584     if (r == NULL)
14585       return -1;
14586     if (!r[0]) {
14587       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14588       print_strings (r);
14589       return -1;
14590     }
14591     {
14592       char expected[] = "/dev/VG1/LV1";
14593       if (strcmp (r[0], expected) != 0) {
14594         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14595         return -1;
14596       }
14597     }
14598     if (!r[1]) {
14599       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14600       print_strings (r);
14601       return -1;
14602     }
14603     {
14604       char expected[] = "/dev/VG1/LV2";
14605       if (strcmp (r[1], expected) != 0) {
14606         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14607         return -1;
14608       }
14609     }
14610     if (!r[2]) {
14611       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14612       print_strings (r);
14613       return -1;
14614     }
14615     {
14616       char expected[] = "/dev/VG2/LV3";
14617       if (strcmp (r[2], expected) != 0) {
14618         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14619         return -1;
14620       }
14621     }
14622     if (r[3] != NULL) {
14623       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14624       print_strings (r);
14625       return -1;
14626     }
14627     for (i = 0; r[i] != NULL; ++i)
14628       free (r[i]);
14629     free (r);
14630   }
14631   return 0;
14632 }
14633
14634 static int test_vgs_0_skip (void)
14635 {
14636   const char *str;
14637
14638   str = getenv ("SKIP_TEST_VGS_0");
14639   if (str && strcmp (str, "1") == 0) return 1;
14640   str = getenv ("SKIP_TEST_VGS");
14641   if (str && strcmp (str, "1") == 0) return 1;
14642   return 0;
14643 }
14644
14645 static int test_vgs_0 (void)
14646 {
14647   if (test_vgs_0_skip ()) {
14648     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14649     return 0;
14650   }
14651
14652   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14653   {
14654     char device[] = "/dev/sda";
14655     int r;
14656     suppress_error = 0;
14657     r = guestfs_blockdev_setrw (g, device);
14658     if (r == -1)
14659       return -1;
14660   }
14661   {
14662     int r;
14663     suppress_error = 0;
14664     r = guestfs_umount_all (g);
14665     if (r == -1)
14666       return -1;
14667   }
14668   {
14669     int r;
14670     suppress_error = 0;
14671     r = guestfs_lvm_remove_all (g);
14672     if (r == -1)
14673       return -1;
14674   }
14675   {
14676     char device[] = "/dev/sda";
14677     char lines_0[] = ",";
14678     char *lines[] = {
14679       lines_0,
14680       NULL
14681     };
14682     int r;
14683     suppress_error = 0;
14684     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14685     if (r == -1)
14686       return -1;
14687   }
14688   {
14689     char device[] = "/dev/sda1";
14690     int r;
14691     suppress_error = 0;
14692     r = guestfs_pvcreate (g, device);
14693     if (r == -1)
14694       return -1;
14695   }
14696   {
14697     char volgroup[] = "VG";
14698     char physvols_0[] = "/dev/sda1";
14699     char *physvols[] = {
14700       physvols_0,
14701       NULL
14702     };
14703     int r;
14704     suppress_error = 0;
14705     r = guestfs_vgcreate (g, volgroup, physvols);
14706     if (r == -1)
14707       return -1;
14708   }
14709   {
14710     char logvol[] = "LV";
14711     char volgroup[] = "VG";
14712     int r;
14713     suppress_error = 0;
14714     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14715     if (r == -1)
14716       return -1;
14717   }
14718   {
14719     char fstype[] = "ext2";
14720     char device[] = "/dev/VG/LV";
14721     int r;
14722     suppress_error = 0;
14723     r = guestfs_mkfs (g, fstype, device);
14724     if (r == -1)
14725       return -1;
14726   }
14727   {
14728     char device[] = "/dev/VG/LV";
14729     char mountpoint[] = "/";
14730     int r;
14731     suppress_error = 0;
14732     r = guestfs_mount (g, device, mountpoint);
14733     if (r == -1)
14734       return -1;
14735   }
14736   /* TestOutputList for vgs (0) */
14737   {
14738     char **r;
14739     int i;
14740     suppress_error = 0;
14741     r = guestfs_vgs (g);
14742     if (r == NULL)
14743       return -1;
14744     if (!r[0]) {
14745       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14746       print_strings (r);
14747       return -1;
14748     }
14749     {
14750       char expected[] = "VG";
14751       if (strcmp (r[0], expected) != 0) {
14752         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14753         return -1;
14754       }
14755     }
14756     if (r[1] != NULL) {
14757       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14758       print_strings (r);
14759       return -1;
14760     }
14761     for (i = 0; r[i] != NULL; ++i)
14762       free (r[i]);
14763     free (r);
14764   }
14765   return 0;
14766 }
14767
14768 static int test_vgs_1_skip (void)
14769 {
14770   const char *str;
14771
14772   str = getenv ("SKIP_TEST_VGS_1");
14773   if (str && strcmp (str, "1") == 0) return 1;
14774   str = getenv ("SKIP_TEST_VGS");
14775   if (str && strcmp (str, "1") == 0) return 1;
14776   return 0;
14777 }
14778
14779 static int test_vgs_1 (void)
14780 {
14781   if (test_vgs_1_skip ()) {
14782     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14783     return 0;
14784   }
14785
14786   /* InitNone|InitEmpty for test_vgs_1 */
14787   {
14788     char device[] = "/dev/sda";
14789     int r;
14790     suppress_error = 0;
14791     r = guestfs_blockdev_setrw (g, device);
14792     if (r == -1)
14793       return -1;
14794   }
14795   {
14796     int r;
14797     suppress_error = 0;
14798     r = guestfs_umount_all (g);
14799     if (r == -1)
14800       return -1;
14801   }
14802   {
14803     int r;
14804     suppress_error = 0;
14805     r = guestfs_lvm_remove_all (g);
14806     if (r == -1)
14807       return -1;
14808   }
14809   /* TestOutputList for vgs (1) */
14810   {
14811     char device[] = "/dev/sda";
14812     char lines_0[] = ",10";
14813     char lines_1[] = ",20";
14814     char lines_2[] = ",";
14815     char *lines[] = {
14816       lines_0,
14817       lines_1,
14818       lines_2,
14819       NULL
14820     };
14821     int r;
14822     suppress_error = 0;
14823     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14824     if (r == -1)
14825       return -1;
14826   }
14827   {
14828     char device[] = "/dev/sda1";
14829     int r;
14830     suppress_error = 0;
14831     r = guestfs_pvcreate (g, device);
14832     if (r == -1)
14833       return -1;
14834   }
14835   {
14836     char device[] = "/dev/sda2";
14837     int r;
14838     suppress_error = 0;
14839     r = guestfs_pvcreate (g, device);
14840     if (r == -1)
14841       return -1;
14842   }
14843   {
14844     char device[] = "/dev/sda3";
14845     int r;
14846     suppress_error = 0;
14847     r = guestfs_pvcreate (g, device);
14848     if (r == -1)
14849       return -1;
14850   }
14851   {
14852     char volgroup[] = "VG1";
14853     char physvols_0[] = "/dev/sda1";
14854     char physvols_1[] = "/dev/sda2";
14855     char *physvols[] = {
14856       physvols_0,
14857       physvols_1,
14858       NULL
14859     };
14860     int r;
14861     suppress_error = 0;
14862     r = guestfs_vgcreate (g, volgroup, physvols);
14863     if (r == -1)
14864       return -1;
14865   }
14866   {
14867     char volgroup[] = "VG2";
14868     char physvols_0[] = "/dev/sda3";
14869     char *physvols[] = {
14870       physvols_0,
14871       NULL
14872     };
14873     int r;
14874     suppress_error = 0;
14875     r = guestfs_vgcreate (g, volgroup, physvols);
14876     if (r == -1)
14877       return -1;
14878   }
14879   {
14880     char **r;
14881     int i;
14882     suppress_error = 0;
14883     r = guestfs_vgs (g);
14884     if (r == NULL)
14885       return -1;
14886     if (!r[0]) {
14887       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14888       print_strings (r);
14889       return -1;
14890     }
14891     {
14892       char expected[] = "VG1";
14893       if (strcmp (r[0], expected) != 0) {
14894         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14895         return -1;
14896       }
14897     }
14898     if (!r[1]) {
14899       fprintf (stderr, "test_vgs_1: short list returned from command\n");
14900       print_strings (r);
14901       return -1;
14902     }
14903     {
14904       char expected[] = "VG2";
14905       if (strcmp (r[1], expected) != 0) {
14906         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14907         return -1;
14908       }
14909     }
14910     if (r[2] != NULL) {
14911       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14912       print_strings (r);
14913       return -1;
14914     }
14915     for (i = 0; r[i] != NULL; ++i)
14916       free (r[i]);
14917     free (r);
14918   }
14919   return 0;
14920 }
14921
14922 static int test_pvs_0_skip (void)
14923 {
14924   const char *str;
14925
14926   str = getenv ("SKIP_TEST_PVS_0");
14927   if (str && strcmp (str, "1") == 0) return 1;
14928   str = getenv ("SKIP_TEST_PVS");
14929   if (str && strcmp (str, "1") == 0) return 1;
14930   return 0;
14931 }
14932
14933 static int test_pvs_0 (void)
14934 {
14935   if (test_pvs_0_skip ()) {
14936     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14937     return 0;
14938   }
14939
14940   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14941   {
14942     char device[] = "/dev/sda";
14943     int r;
14944     suppress_error = 0;
14945     r = guestfs_blockdev_setrw (g, device);
14946     if (r == -1)
14947       return -1;
14948   }
14949   {
14950     int r;
14951     suppress_error = 0;
14952     r = guestfs_umount_all (g);
14953     if (r == -1)
14954       return -1;
14955   }
14956   {
14957     int r;
14958     suppress_error = 0;
14959     r = guestfs_lvm_remove_all (g);
14960     if (r == -1)
14961       return -1;
14962   }
14963   {
14964     char device[] = "/dev/sda";
14965     char lines_0[] = ",";
14966     char *lines[] = {
14967       lines_0,
14968       NULL
14969     };
14970     int r;
14971     suppress_error = 0;
14972     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14973     if (r == -1)
14974       return -1;
14975   }
14976   {
14977     char device[] = "/dev/sda1";
14978     int r;
14979     suppress_error = 0;
14980     r = guestfs_pvcreate (g, device);
14981     if (r == -1)
14982       return -1;
14983   }
14984   {
14985     char volgroup[] = "VG";
14986     char physvols_0[] = "/dev/sda1";
14987     char *physvols[] = {
14988       physvols_0,
14989       NULL
14990     };
14991     int r;
14992     suppress_error = 0;
14993     r = guestfs_vgcreate (g, volgroup, physvols);
14994     if (r == -1)
14995       return -1;
14996   }
14997   {
14998     char logvol[] = "LV";
14999     char volgroup[] = "VG";
15000     int r;
15001     suppress_error = 0;
15002     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15003     if (r == -1)
15004       return -1;
15005   }
15006   {
15007     char fstype[] = "ext2";
15008     char device[] = "/dev/VG/LV";
15009     int r;
15010     suppress_error = 0;
15011     r = guestfs_mkfs (g, fstype, device);
15012     if (r == -1)
15013       return -1;
15014   }
15015   {
15016     char device[] = "/dev/VG/LV";
15017     char mountpoint[] = "/";
15018     int r;
15019     suppress_error = 0;
15020     r = guestfs_mount (g, device, mountpoint);
15021     if (r == -1)
15022       return -1;
15023   }
15024   /* TestOutputListOfDevices for pvs (0) */
15025   {
15026     char **r;
15027     int i;
15028     suppress_error = 0;
15029     r = guestfs_pvs (g);
15030     if (r == NULL)
15031       return -1;
15032     if (!r[0]) {
15033       fprintf (stderr, "test_pvs_0: short list returned from command\n");
15034       print_strings (r);
15035       return -1;
15036     }
15037     {
15038       char expected[] = "/dev/sda1";
15039       r[0][5] = 's';
15040       if (strcmp (r[0], expected) != 0) {
15041         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15042         return -1;
15043       }
15044     }
15045     if (r[1] != NULL) {
15046       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15047       print_strings (r);
15048       return -1;
15049     }
15050     for (i = 0; r[i] != NULL; ++i)
15051       free (r[i]);
15052     free (r);
15053   }
15054   return 0;
15055 }
15056
15057 static int test_pvs_1_skip (void)
15058 {
15059   const char *str;
15060
15061   str = getenv ("SKIP_TEST_PVS_1");
15062   if (str && strcmp (str, "1") == 0) return 1;
15063   str = getenv ("SKIP_TEST_PVS");
15064   if (str && strcmp (str, "1") == 0) return 1;
15065   return 0;
15066 }
15067
15068 static int test_pvs_1 (void)
15069 {
15070   if (test_pvs_1_skip ()) {
15071     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15072     return 0;
15073   }
15074
15075   /* InitNone|InitEmpty for test_pvs_1 */
15076   {
15077     char device[] = "/dev/sda";
15078     int r;
15079     suppress_error = 0;
15080     r = guestfs_blockdev_setrw (g, device);
15081     if (r == -1)
15082       return -1;
15083   }
15084   {
15085     int r;
15086     suppress_error = 0;
15087     r = guestfs_umount_all (g);
15088     if (r == -1)
15089       return -1;
15090   }
15091   {
15092     int r;
15093     suppress_error = 0;
15094     r = guestfs_lvm_remove_all (g);
15095     if (r == -1)
15096       return -1;
15097   }
15098   /* TestOutputListOfDevices for pvs (1) */
15099   {
15100     char device[] = "/dev/sda";
15101     char lines_0[] = ",10";
15102     char lines_1[] = ",20";
15103     char lines_2[] = ",";
15104     char *lines[] = {
15105       lines_0,
15106       lines_1,
15107       lines_2,
15108       NULL
15109     };
15110     int r;
15111     suppress_error = 0;
15112     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15113     if (r == -1)
15114       return -1;
15115   }
15116   {
15117     char device[] = "/dev/sda1";
15118     int r;
15119     suppress_error = 0;
15120     r = guestfs_pvcreate (g, device);
15121     if (r == -1)
15122       return -1;
15123   }
15124   {
15125     char device[] = "/dev/sda2";
15126     int r;
15127     suppress_error = 0;
15128     r = guestfs_pvcreate (g, device);
15129     if (r == -1)
15130       return -1;
15131   }
15132   {
15133     char device[] = "/dev/sda3";
15134     int r;
15135     suppress_error = 0;
15136     r = guestfs_pvcreate (g, device);
15137     if (r == -1)
15138       return -1;
15139   }
15140   {
15141     char **r;
15142     int i;
15143     suppress_error = 0;
15144     r = guestfs_pvs (g);
15145     if (r == NULL)
15146       return -1;
15147     if (!r[0]) {
15148       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15149       print_strings (r);
15150       return -1;
15151     }
15152     {
15153       char expected[] = "/dev/sda1";
15154       r[0][5] = 's';
15155       if (strcmp (r[0], expected) != 0) {
15156         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15157         return -1;
15158       }
15159     }
15160     if (!r[1]) {
15161       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15162       print_strings (r);
15163       return -1;
15164     }
15165     {
15166       char expected[] = "/dev/sda2";
15167       r[1][5] = 's';
15168       if (strcmp (r[1], expected) != 0) {
15169         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15170         return -1;
15171       }
15172     }
15173     if (!r[2]) {
15174       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15175       print_strings (r);
15176       return -1;
15177     }
15178     {
15179       char expected[] = "/dev/sda3";
15180       r[2][5] = 's';
15181       if (strcmp (r[2], expected) != 0) {
15182         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15183         return -1;
15184       }
15185     }
15186     if (r[3] != NULL) {
15187       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15188       print_strings (r);
15189       return -1;
15190     }
15191     for (i = 0; r[i] != NULL; ++i)
15192       free (r[i]);
15193     free (r);
15194   }
15195   return 0;
15196 }
15197
15198 static int test_list_partitions_0_skip (void)
15199 {
15200   const char *str;
15201
15202   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15203   if (str && strcmp (str, "1") == 0) return 1;
15204   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15205   if (str && strcmp (str, "1") == 0) return 1;
15206   return 0;
15207 }
15208
15209 static int test_list_partitions_0 (void)
15210 {
15211   if (test_list_partitions_0_skip ()) {
15212     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15213     return 0;
15214   }
15215
15216   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15217   {
15218     char device[] = "/dev/sda";
15219     int r;
15220     suppress_error = 0;
15221     r = guestfs_blockdev_setrw (g, device);
15222     if (r == -1)
15223       return -1;
15224   }
15225   {
15226     int r;
15227     suppress_error = 0;
15228     r = guestfs_umount_all (g);
15229     if (r == -1)
15230       return -1;
15231   }
15232   {
15233     int r;
15234     suppress_error = 0;
15235     r = guestfs_lvm_remove_all (g);
15236     if (r == -1)
15237       return -1;
15238   }
15239   {
15240     char device[] = "/dev/sda";
15241     char lines_0[] = ",";
15242     char *lines[] = {
15243       lines_0,
15244       NULL
15245     };
15246     int r;
15247     suppress_error = 0;
15248     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15249     if (r == -1)
15250       return -1;
15251   }
15252   {
15253     char fstype[] = "ext2";
15254     char device[] = "/dev/sda1";
15255     int r;
15256     suppress_error = 0;
15257     r = guestfs_mkfs (g, fstype, device);
15258     if (r == -1)
15259       return -1;
15260   }
15261   {
15262     char device[] = "/dev/sda1";
15263     char mountpoint[] = "/";
15264     int r;
15265     suppress_error = 0;
15266     r = guestfs_mount (g, device, mountpoint);
15267     if (r == -1)
15268       return -1;
15269   }
15270   /* TestOutputListOfDevices for list_partitions (0) */
15271   {
15272     char **r;
15273     int i;
15274     suppress_error = 0;
15275     r = guestfs_list_partitions (g);
15276     if (r == NULL)
15277       return -1;
15278     if (!r[0]) {
15279       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15280       print_strings (r);
15281       return -1;
15282     }
15283     {
15284       char expected[] = "/dev/sda1";
15285       r[0][5] = 's';
15286       if (strcmp (r[0], expected) != 0) {
15287         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15288         return -1;
15289       }
15290     }
15291     if (r[1] != NULL) {
15292       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15293       print_strings (r);
15294       return -1;
15295     }
15296     for (i = 0; r[i] != NULL; ++i)
15297       free (r[i]);
15298     free (r);
15299   }
15300   return 0;
15301 }
15302
15303 static int test_list_partitions_1_skip (void)
15304 {
15305   const char *str;
15306
15307   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15308   if (str && strcmp (str, "1") == 0) return 1;
15309   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15310   if (str && strcmp (str, "1") == 0) return 1;
15311   return 0;
15312 }
15313
15314 static int test_list_partitions_1 (void)
15315 {
15316   if (test_list_partitions_1_skip ()) {
15317     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15318     return 0;
15319   }
15320
15321   /* InitNone|InitEmpty for test_list_partitions_1 */
15322   {
15323     char device[] = "/dev/sda";
15324     int r;
15325     suppress_error = 0;
15326     r = guestfs_blockdev_setrw (g, device);
15327     if (r == -1)
15328       return -1;
15329   }
15330   {
15331     int r;
15332     suppress_error = 0;
15333     r = guestfs_umount_all (g);
15334     if (r == -1)
15335       return -1;
15336   }
15337   {
15338     int r;
15339     suppress_error = 0;
15340     r = guestfs_lvm_remove_all (g);
15341     if (r == -1)
15342       return -1;
15343   }
15344   /* TestOutputListOfDevices for list_partitions (1) */
15345   {
15346     char device[] = "/dev/sda";
15347     char lines_0[] = ",10";
15348     char lines_1[] = ",20";
15349     char lines_2[] = ",";
15350     char *lines[] = {
15351       lines_0,
15352       lines_1,
15353       lines_2,
15354       NULL
15355     };
15356     int r;
15357     suppress_error = 0;
15358     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15359     if (r == -1)
15360       return -1;
15361   }
15362   {
15363     char **r;
15364     int i;
15365     suppress_error = 0;
15366     r = guestfs_list_partitions (g);
15367     if (r == NULL)
15368       return -1;
15369     if (!r[0]) {
15370       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15371       print_strings (r);
15372       return -1;
15373     }
15374     {
15375       char expected[] = "/dev/sda1";
15376       r[0][5] = 's';
15377       if (strcmp (r[0], expected) != 0) {
15378         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15379         return -1;
15380       }
15381     }
15382     if (!r[1]) {
15383       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15384       print_strings (r);
15385       return -1;
15386     }
15387     {
15388       char expected[] = "/dev/sda2";
15389       r[1][5] = 's';
15390       if (strcmp (r[1], expected) != 0) {
15391         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15392         return -1;
15393       }
15394     }
15395     if (!r[2]) {
15396       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15397       print_strings (r);
15398       return -1;
15399     }
15400     {
15401       char expected[] = "/dev/sda3";
15402       r[2][5] = 's';
15403       if (strcmp (r[2], expected) != 0) {
15404         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15405         return -1;
15406       }
15407     }
15408     if (r[3] != NULL) {
15409       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15410       print_strings (r);
15411       return -1;
15412     }
15413     for (i = 0; r[i] != NULL; ++i)
15414       free (r[i]);
15415     free (r);
15416   }
15417   return 0;
15418 }
15419
15420 static int test_list_devices_0_skip (void)
15421 {
15422   const char *str;
15423
15424   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15425   if (str && strcmp (str, "1") == 0) return 1;
15426   str = getenv ("SKIP_TEST_LIST_DEVICES");
15427   if (str && strcmp (str, "1") == 0) return 1;
15428   return 0;
15429 }
15430
15431 static int test_list_devices_0 (void)
15432 {
15433   if (test_list_devices_0_skip ()) {
15434     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15435     return 0;
15436   }
15437
15438   /* InitNone|InitEmpty for test_list_devices_0 */
15439   {
15440     char device[] = "/dev/sda";
15441     int r;
15442     suppress_error = 0;
15443     r = guestfs_blockdev_setrw (g, device);
15444     if (r == -1)
15445       return -1;
15446   }
15447   {
15448     int r;
15449     suppress_error = 0;
15450     r = guestfs_umount_all (g);
15451     if (r == -1)
15452       return -1;
15453   }
15454   {
15455     int r;
15456     suppress_error = 0;
15457     r = guestfs_lvm_remove_all (g);
15458     if (r == -1)
15459       return -1;
15460   }
15461   /* TestOutputListOfDevices for list_devices (0) */
15462   {
15463     char **r;
15464     int i;
15465     suppress_error = 0;
15466     r = guestfs_list_devices (g);
15467     if (r == NULL)
15468       return -1;
15469     if (!r[0]) {
15470       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15471       print_strings (r);
15472       return -1;
15473     }
15474     {
15475       char expected[] = "/dev/sda";
15476       r[0][5] = 's';
15477       if (strcmp (r[0], expected) != 0) {
15478         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15479         return -1;
15480       }
15481     }
15482     if (!r[1]) {
15483       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15484       print_strings (r);
15485       return -1;
15486     }
15487     {
15488       char expected[] = "/dev/sdb";
15489       r[1][5] = 's';
15490       if (strcmp (r[1], expected) != 0) {
15491         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15492         return -1;
15493       }
15494     }
15495     if (!r[2]) {
15496       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15497       print_strings (r);
15498       return -1;
15499     }
15500     {
15501       char expected[] = "/dev/sdc";
15502       r[2][5] = 's';
15503       if (strcmp (r[2], expected) != 0) {
15504         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15505         return -1;
15506       }
15507     }
15508     if (!r[3]) {
15509       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15510       print_strings (r);
15511       return -1;
15512     }
15513     {
15514       char expected[] = "/dev/sdd";
15515       r[3][5] = 's';
15516       if (strcmp (r[3], expected) != 0) {
15517         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15518         return -1;
15519       }
15520     }
15521     if (r[4] != NULL) {
15522       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15523       print_strings (r);
15524       return -1;
15525     }
15526     for (i = 0; r[i] != NULL; ++i)
15527       free (r[i]);
15528     free (r);
15529   }
15530   return 0;
15531 }
15532
15533 static int test_ls_0_skip (void)
15534 {
15535   const char *str;
15536
15537   str = getenv ("SKIP_TEST_LS_0");
15538   if (str && strcmp (str, "1") == 0) return 1;
15539   str = getenv ("SKIP_TEST_LS");
15540   if (str && strcmp (str, "1") == 0) return 1;
15541   return 0;
15542 }
15543
15544 static int test_ls_0 (void)
15545 {
15546   if (test_ls_0_skip ()) {
15547     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15548     return 0;
15549   }
15550
15551   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15552   {
15553     char device[] = "/dev/sda";
15554     int r;
15555     suppress_error = 0;
15556     r = guestfs_blockdev_setrw (g, device);
15557     if (r == -1)
15558       return -1;
15559   }
15560   {
15561     int r;
15562     suppress_error = 0;
15563     r = guestfs_umount_all (g);
15564     if (r == -1)
15565       return -1;
15566   }
15567   {
15568     int r;
15569     suppress_error = 0;
15570     r = guestfs_lvm_remove_all (g);
15571     if (r == -1)
15572       return -1;
15573   }
15574   {
15575     char device[] = "/dev/sda";
15576     char lines_0[] = ",";
15577     char *lines[] = {
15578       lines_0,
15579       NULL
15580     };
15581     int r;
15582     suppress_error = 0;
15583     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15584     if (r == -1)
15585       return -1;
15586   }
15587   {
15588     char fstype[] = "ext2";
15589     char device[] = "/dev/sda1";
15590     int r;
15591     suppress_error = 0;
15592     r = guestfs_mkfs (g, fstype, device);
15593     if (r == -1)
15594       return -1;
15595   }
15596   {
15597     char device[] = "/dev/sda1";
15598     char mountpoint[] = "/";
15599     int r;
15600     suppress_error = 0;
15601     r = guestfs_mount (g, device, mountpoint);
15602     if (r == -1)
15603       return -1;
15604   }
15605   /* TestOutputList for ls (0) */
15606   {
15607     char path[] = "/new";
15608     int r;
15609     suppress_error = 0;
15610     r = guestfs_touch (g, path);
15611     if (r == -1)
15612       return -1;
15613   }
15614   {
15615     char path[] = "/newer";
15616     int r;
15617     suppress_error = 0;
15618     r = guestfs_touch (g, path);
15619     if (r == -1)
15620       return -1;
15621   }
15622   {
15623     char path[] = "/newest";
15624     int r;
15625     suppress_error = 0;
15626     r = guestfs_touch (g, path);
15627     if (r == -1)
15628       return -1;
15629   }
15630   {
15631     char directory[] = "/";
15632     char **r;
15633     int i;
15634     suppress_error = 0;
15635     r = guestfs_ls (g, directory);
15636     if (r == NULL)
15637       return -1;
15638     if (!r[0]) {
15639       fprintf (stderr, "test_ls_0: short list returned from command\n");
15640       print_strings (r);
15641       return -1;
15642     }
15643     {
15644       char expected[] = "lost+found";
15645       if (strcmp (r[0], expected) != 0) {
15646         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15647         return -1;
15648       }
15649     }
15650     if (!r[1]) {
15651       fprintf (stderr, "test_ls_0: short list returned from command\n");
15652       print_strings (r);
15653       return -1;
15654     }
15655     {
15656       char expected[] = "new";
15657       if (strcmp (r[1], expected) != 0) {
15658         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15659         return -1;
15660       }
15661     }
15662     if (!r[2]) {
15663       fprintf (stderr, "test_ls_0: short list returned from command\n");
15664       print_strings (r);
15665       return -1;
15666     }
15667     {
15668       char expected[] = "newer";
15669       if (strcmp (r[2], expected) != 0) {
15670         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15671         return -1;
15672       }
15673     }
15674     if (!r[3]) {
15675       fprintf (stderr, "test_ls_0: short list returned from command\n");
15676       print_strings (r);
15677       return -1;
15678     }
15679     {
15680       char expected[] = "newest";
15681       if (strcmp (r[3], expected) != 0) {
15682         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15683         return -1;
15684       }
15685     }
15686     if (r[4] != NULL) {
15687       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15688       print_strings (r);
15689       return -1;
15690     }
15691     for (i = 0; r[i] != NULL; ++i)
15692       free (r[i]);
15693     free (r);
15694   }
15695   return 0;
15696 }
15697
15698 static int test_cat_0_skip (void)
15699 {
15700   const char *str;
15701
15702   str = getenv ("SKIP_TEST_CAT_0");
15703   if (str && strcmp (str, "1") == 0) return 1;
15704   str = getenv ("SKIP_TEST_CAT");
15705   if (str && strcmp (str, "1") == 0) return 1;
15706   return 0;
15707 }
15708
15709 static int test_cat_0 (void)
15710 {
15711   if (test_cat_0_skip ()) {
15712     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15713     return 0;
15714   }
15715
15716   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15717   {
15718     char device[] = "/dev/sda";
15719     int r;
15720     suppress_error = 0;
15721     r = guestfs_blockdev_setrw (g, device);
15722     if (r == -1)
15723       return -1;
15724   }
15725   {
15726     int r;
15727     suppress_error = 0;
15728     r = guestfs_umount_all (g);
15729     if (r == -1)
15730       return -1;
15731   }
15732   {
15733     int r;
15734     suppress_error = 0;
15735     r = guestfs_lvm_remove_all (g);
15736     if (r == -1)
15737       return -1;
15738   }
15739   {
15740     char device[] = "/dev/sda";
15741     char lines_0[] = ",";
15742     char *lines[] = {
15743       lines_0,
15744       NULL
15745     };
15746     int r;
15747     suppress_error = 0;
15748     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15749     if (r == -1)
15750       return -1;
15751   }
15752   {
15753     char fstype[] = "ext2";
15754     char device[] = "/dev/sda1";
15755     int r;
15756     suppress_error = 0;
15757     r = guestfs_mkfs (g, fstype, device);
15758     if (r == -1)
15759       return -1;
15760   }
15761   {
15762     char device[] = "/dev/sda1";
15763     char mountpoint[] = "/";
15764     int r;
15765     suppress_error = 0;
15766     r = guestfs_mount (g, device, mountpoint);
15767     if (r == -1)
15768       return -1;
15769   }
15770   /* TestOutput for cat (0) */
15771   char expected[] = "new file contents";
15772   {
15773     char path[] = "/new";
15774     char content[] = "new file contents";
15775     int r;
15776     suppress_error = 0;
15777     r = guestfs_write_file (g, path, content, 0);
15778     if (r == -1)
15779       return -1;
15780   }
15781   {
15782     char path[] = "/new";
15783     char *r;
15784     suppress_error = 0;
15785     r = guestfs_cat (g, path);
15786     if (r == NULL)
15787       return -1;
15788     if (strcmp (r, expected) != 0) {
15789       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15790       return -1;
15791     }
15792     free (r);
15793   }
15794   return 0;
15795 }
15796
15797 static int test_touch_0_skip (void)
15798 {
15799   const char *str;
15800
15801   str = getenv ("SKIP_TEST_TOUCH_0");
15802   if (str && strcmp (str, "1") == 0) return 1;
15803   str = getenv ("SKIP_TEST_TOUCH");
15804   if (str && strcmp (str, "1") == 0) return 1;
15805   return 0;
15806 }
15807
15808 static int test_touch_0 (void)
15809 {
15810   if (test_touch_0_skip ()) {
15811     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15812     return 0;
15813   }
15814
15815   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15816   {
15817     char device[] = "/dev/sda";
15818     int r;
15819     suppress_error = 0;
15820     r = guestfs_blockdev_setrw (g, device);
15821     if (r == -1)
15822       return -1;
15823   }
15824   {
15825     int r;
15826     suppress_error = 0;
15827     r = guestfs_umount_all (g);
15828     if (r == -1)
15829       return -1;
15830   }
15831   {
15832     int r;
15833     suppress_error = 0;
15834     r = guestfs_lvm_remove_all (g);
15835     if (r == -1)
15836       return -1;
15837   }
15838   {
15839     char device[] = "/dev/sda";
15840     char lines_0[] = ",";
15841     char *lines[] = {
15842       lines_0,
15843       NULL
15844     };
15845     int r;
15846     suppress_error = 0;
15847     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15848     if (r == -1)
15849       return -1;
15850   }
15851   {
15852     char fstype[] = "ext2";
15853     char device[] = "/dev/sda1";
15854     int r;
15855     suppress_error = 0;
15856     r = guestfs_mkfs (g, fstype, device);
15857     if (r == -1)
15858       return -1;
15859   }
15860   {
15861     char device[] = "/dev/sda1";
15862     char mountpoint[] = "/";
15863     int r;
15864     suppress_error = 0;
15865     r = guestfs_mount (g, device, mountpoint);
15866     if (r == -1)
15867       return -1;
15868   }
15869   /* TestOutputTrue for touch (0) */
15870   {
15871     char path[] = "/new";
15872     int r;
15873     suppress_error = 0;
15874     r = guestfs_touch (g, path);
15875     if (r == -1)
15876       return -1;
15877   }
15878   {
15879     char path[] = "/new";
15880     int r;
15881     suppress_error = 0;
15882     r = guestfs_exists (g, path);
15883     if (r == -1)
15884       return -1;
15885     if (!r) {
15886       fprintf (stderr, "test_touch_0: expected true, got false\n");
15887       return -1;
15888     }
15889   }
15890   return 0;
15891 }
15892
15893 static int test_sync_0_skip (void)
15894 {
15895   const char *str;
15896
15897   str = getenv ("SKIP_TEST_SYNC_0");
15898   if (str && strcmp (str, "1") == 0) return 1;
15899   str = getenv ("SKIP_TEST_SYNC");
15900   if (str && strcmp (str, "1") == 0) return 1;
15901   return 0;
15902 }
15903
15904 static int test_sync_0 (void)
15905 {
15906   if (test_sync_0_skip ()) {
15907     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15908     return 0;
15909   }
15910
15911   /* InitNone|InitEmpty for test_sync_0 */
15912   {
15913     char device[] = "/dev/sda";
15914     int r;
15915     suppress_error = 0;
15916     r = guestfs_blockdev_setrw (g, device);
15917     if (r == -1)
15918       return -1;
15919   }
15920   {
15921     int r;
15922     suppress_error = 0;
15923     r = guestfs_umount_all (g);
15924     if (r == -1)
15925       return -1;
15926   }
15927   {
15928     int r;
15929     suppress_error = 0;
15930     r = guestfs_lvm_remove_all (g);
15931     if (r == -1)
15932       return -1;
15933   }
15934   /* TestRun for sync (0) */
15935   {
15936     int r;
15937     suppress_error = 0;
15938     r = guestfs_sync (g);
15939     if (r == -1)
15940       return -1;
15941   }
15942   return 0;
15943 }
15944
15945 static int test_mount_0_skip (void)
15946 {
15947   const char *str;
15948
15949   str = getenv ("SKIP_TEST_MOUNT_0");
15950   if (str && strcmp (str, "1") == 0) return 1;
15951   str = getenv ("SKIP_TEST_MOUNT");
15952   if (str && strcmp (str, "1") == 0) return 1;
15953   return 0;
15954 }
15955
15956 static int test_mount_0 (void)
15957 {
15958   if (test_mount_0_skip ()) {
15959     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15960     return 0;
15961   }
15962
15963   /* InitNone|InitEmpty for test_mount_0 */
15964   {
15965     char device[] = "/dev/sda";
15966     int r;
15967     suppress_error = 0;
15968     r = guestfs_blockdev_setrw (g, device);
15969     if (r == -1)
15970       return -1;
15971   }
15972   {
15973     int r;
15974     suppress_error = 0;
15975     r = guestfs_umount_all (g);
15976     if (r == -1)
15977       return -1;
15978   }
15979   {
15980     int r;
15981     suppress_error = 0;
15982     r = guestfs_lvm_remove_all (g);
15983     if (r == -1)
15984       return -1;
15985   }
15986   /* TestOutput for mount (0) */
15987   char expected[] = "new file contents";
15988   {
15989     char device[] = "/dev/sda";
15990     char lines_0[] = ",";
15991     char *lines[] = {
15992       lines_0,
15993       NULL
15994     };
15995     int r;
15996     suppress_error = 0;
15997     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15998     if (r == -1)
15999       return -1;
16000   }
16001   {
16002     char fstype[] = "ext2";
16003     char device[] = "/dev/sda1";
16004     int r;
16005     suppress_error = 0;
16006     r = guestfs_mkfs (g, fstype, device);
16007     if (r == -1)
16008       return -1;
16009   }
16010   {
16011     char device[] = "/dev/sda1";
16012     char mountpoint[] = "/";
16013     int r;
16014     suppress_error = 0;
16015     r = guestfs_mount (g, device, mountpoint);
16016     if (r == -1)
16017       return -1;
16018   }
16019   {
16020     char path[] = "/new";
16021     char content[] = "new file contents";
16022     int r;
16023     suppress_error = 0;
16024     r = guestfs_write_file (g, path, content, 0);
16025     if (r == -1)
16026       return -1;
16027   }
16028   {
16029     char path[] = "/new";
16030     char *r;
16031     suppress_error = 0;
16032     r = guestfs_cat (g, path);
16033     if (r == NULL)
16034       return -1;
16035     if (strcmp (r, expected) != 0) {
16036       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16037       return -1;
16038     }
16039     free (r);
16040   }
16041   return 0;
16042 }
16043
16044 int main (int argc, char *argv[])
16045 {
16046   char c = 0;
16047   int failed = 0;
16048   const char *filename;
16049   int fd;
16050   int nr_tests, test_num = 0;
16051
16052   no_test_warnings ();
16053
16054   g = guestfs_create ();
16055   if (g == NULL) {
16056     printf ("guestfs_create FAILED\n");
16057     exit (1);
16058   }
16059
16060   guestfs_set_error_handler (g, print_error, NULL);
16061
16062   guestfs_set_path (g, "../appliance");
16063
16064   filename = "test1.img";
16065   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16066   if (fd == -1) {
16067     perror (filename);
16068     exit (1);
16069   }
16070   if (lseek (fd, 524288000, SEEK_SET) == -1) {
16071     perror ("lseek");
16072     close (fd);
16073     unlink (filename);
16074     exit (1);
16075   }
16076   if (write (fd, &c, 1) == -1) {
16077     perror ("write");
16078     close (fd);
16079     unlink (filename);
16080     exit (1);
16081   }
16082   if (close (fd) == -1) {
16083     perror (filename);
16084     unlink (filename);
16085     exit (1);
16086   }
16087   if (guestfs_add_drive (g, filename) == -1) {
16088     printf ("guestfs_add_drive %s FAILED\n", filename);
16089     exit (1);
16090   }
16091
16092   filename = "test2.img";
16093   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16094   if (fd == -1) {
16095     perror (filename);
16096     exit (1);
16097   }
16098   if (lseek (fd, 52428800, SEEK_SET) == -1) {
16099     perror ("lseek");
16100     close (fd);
16101     unlink (filename);
16102     exit (1);
16103   }
16104   if (write (fd, &c, 1) == -1) {
16105     perror ("write");
16106     close (fd);
16107     unlink (filename);
16108     exit (1);
16109   }
16110   if (close (fd) == -1) {
16111     perror (filename);
16112     unlink (filename);
16113     exit (1);
16114   }
16115   if (guestfs_add_drive (g, filename) == -1) {
16116     printf ("guestfs_add_drive %s FAILED\n", filename);
16117     exit (1);
16118   }
16119
16120   filename = "test3.img";
16121   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16122   if (fd == -1) {
16123     perror (filename);
16124     exit (1);
16125   }
16126   if (lseek (fd, 10485760, SEEK_SET) == -1) {
16127     perror ("lseek");
16128     close (fd);
16129     unlink (filename);
16130     exit (1);
16131   }
16132   if (write (fd, &c, 1) == -1) {
16133     perror ("write");
16134     close (fd);
16135     unlink (filename);
16136     exit (1);
16137   }
16138   if (close (fd) == -1) {
16139     perror (filename);
16140     unlink (filename);
16141     exit (1);
16142   }
16143   if (guestfs_add_drive (g, filename) == -1) {
16144     printf ("guestfs_add_drive %s FAILED\n", filename);
16145     exit (1);
16146   }
16147
16148   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16149     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16150     exit (1);
16151   }
16152
16153   if (guestfs_launch (g) == -1) {
16154     printf ("guestfs_launch FAILED\n");
16155     exit (1);
16156   }
16157
16158   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
16159   alarm (600);
16160
16161   if (guestfs_wait_ready (g) == -1) {
16162     printf ("guestfs_wait_ready FAILED\n");
16163     exit (1);
16164   }
16165
16166   /* Cancel previous alarm. */
16167   alarm (0);
16168
16169   nr_tests = 149;
16170
16171   test_num++;
16172   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
16173   if (test_glob_expand_0 () == -1) {
16174     printf ("test_glob_expand_0 FAILED\n");
16175     failed++;
16176   }
16177   test_num++;
16178   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
16179   if (test_glob_expand_1 () == -1) {
16180     printf ("test_glob_expand_1 FAILED\n");
16181     failed++;
16182   }
16183   test_num++;
16184   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
16185   if (test_glob_expand_2 () == -1) {
16186     printf ("test_glob_expand_2 FAILED\n");
16187     failed++;
16188   }
16189   test_num++;
16190   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
16191   if (test_ntfs_3g_probe_0 () == -1) {
16192     printf ("test_ntfs_3g_probe_0 FAILED\n");
16193     failed++;
16194   }
16195   test_num++;
16196   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
16197   if (test_ntfs_3g_probe_1 () == -1) {
16198     printf ("test_ntfs_3g_probe_1 FAILED\n");
16199     failed++;
16200   }
16201   test_num++;
16202   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16203   if (test_sleep_0 () == -1) {
16204     printf ("test_sleep_0 FAILED\n");
16205     failed++;
16206   }
16207   test_num++;
16208   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16209   if (test_find_0 () == -1) {
16210     printf ("test_find_0 FAILED\n");
16211     failed++;
16212   }
16213   test_num++;
16214   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16215   if (test_find_1 () == -1) {
16216     printf ("test_find_1 FAILED\n");
16217     failed++;
16218   }
16219   test_num++;
16220   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16221   if (test_find_2 () == -1) {
16222     printf ("test_find_2 FAILED\n");
16223     failed++;
16224   }
16225   test_num++;
16226   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16227   if (test_lvresize_0 () == -1) {
16228     printf ("test_lvresize_0 FAILED\n");
16229     failed++;
16230   }
16231   test_num++;
16232   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16233   if (test_zerofree_0 () == -1) {
16234     printf ("test_zerofree_0 FAILED\n");
16235     failed++;
16236   }
16237   test_num++;
16238   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16239   if (test_hexdump_0 () == -1) {
16240     printf ("test_hexdump_0 FAILED\n");
16241     failed++;
16242   }
16243   test_num++;
16244   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16245   if (test_strings_e_0 () == -1) {
16246     printf ("test_strings_e_0 FAILED\n");
16247     failed++;
16248   }
16249   test_num++;
16250   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16251   if (test_strings_e_1 () == -1) {
16252     printf ("test_strings_e_1 FAILED\n");
16253     failed++;
16254   }
16255   test_num++;
16256   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16257   if (test_strings_0 () == -1) {
16258     printf ("test_strings_0 FAILED\n");
16259     failed++;
16260   }
16261   test_num++;
16262   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16263   if (test_strings_1 () == -1) {
16264     printf ("test_strings_1 FAILED\n");
16265     failed++;
16266   }
16267   test_num++;
16268   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16269   if (test_equal_0 () == -1) {
16270     printf ("test_equal_0 FAILED\n");
16271     failed++;
16272   }
16273   test_num++;
16274   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16275   if (test_equal_1 () == -1) {
16276     printf ("test_equal_1 FAILED\n");
16277     failed++;
16278   }
16279   test_num++;
16280   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16281   if (test_equal_2 () == -1) {
16282     printf ("test_equal_2 FAILED\n");
16283     failed++;
16284   }
16285   test_num++;
16286   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16287   if (test_ping_daemon_0 () == -1) {
16288     printf ("test_ping_daemon_0 FAILED\n");
16289     failed++;
16290   }
16291   test_num++;
16292   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16293   if (test_dmesg_0 () == -1) {
16294     printf ("test_dmesg_0 FAILED\n");
16295     failed++;
16296   }
16297   test_num++;
16298   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16299   if (test_drop_caches_0 () == -1) {
16300     printf ("test_drop_caches_0 FAILED\n");
16301     failed++;
16302   }
16303   test_num++;
16304   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16305   if (test_mv_0 () == -1) {
16306     printf ("test_mv_0 FAILED\n");
16307     failed++;
16308   }
16309   test_num++;
16310   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16311   if (test_mv_1 () == -1) {
16312     printf ("test_mv_1 FAILED\n");
16313     failed++;
16314   }
16315   test_num++;
16316   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16317   if (test_cp_a_0 () == -1) {
16318     printf ("test_cp_a_0 FAILED\n");
16319     failed++;
16320   }
16321   test_num++;
16322   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16323   if (test_cp_0 () == -1) {
16324     printf ("test_cp_0 FAILED\n");
16325     failed++;
16326   }
16327   test_num++;
16328   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16329   if (test_cp_1 () == -1) {
16330     printf ("test_cp_1 FAILED\n");
16331     failed++;
16332   }
16333   test_num++;
16334   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16335   if (test_cp_2 () == -1) {
16336     printf ("test_cp_2 FAILED\n");
16337     failed++;
16338   }
16339   test_num++;
16340   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16341   if (test_grub_install_0 () == -1) {
16342     printf ("test_grub_install_0 FAILED\n");
16343     failed++;
16344   }
16345   test_num++;
16346   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16347   if (test_zero_0 () == -1) {
16348     printf ("test_zero_0 FAILED\n");
16349     failed++;
16350   }
16351   test_num++;
16352   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16353   if (test_fsck_0 () == -1) {
16354     printf ("test_fsck_0 FAILED\n");
16355     failed++;
16356   }
16357   test_num++;
16358   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16359   if (test_fsck_1 () == -1) {
16360     printf ("test_fsck_1 FAILED\n");
16361     failed++;
16362   }
16363   test_num++;
16364   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16365   if (test_set_e2uuid_0 () == -1) {
16366     printf ("test_set_e2uuid_0 FAILED\n");
16367     failed++;
16368   }
16369   test_num++;
16370   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16371   if (test_set_e2uuid_1 () == -1) {
16372     printf ("test_set_e2uuid_1 FAILED\n");
16373     failed++;
16374   }
16375   test_num++;
16376   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16377   if (test_set_e2uuid_2 () == -1) {
16378     printf ("test_set_e2uuid_2 FAILED\n");
16379     failed++;
16380   }
16381   test_num++;
16382   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16383   if (test_set_e2uuid_3 () == -1) {
16384     printf ("test_set_e2uuid_3 FAILED\n");
16385     failed++;
16386   }
16387   test_num++;
16388   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16389   if (test_set_e2label_0 () == -1) {
16390     printf ("test_set_e2label_0 FAILED\n");
16391     failed++;
16392   }
16393   test_num++;
16394   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16395   if (test_pvremove_0 () == -1) {
16396     printf ("test_pvremove_0 FAILED\n");
16397     failed++;
16398   }
16399   test_num++;
16400   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16401   if (test_pvremove_1 () == -1) {
16402     printf ("test_pvremove_1 FAILED\n");
16403     failed++;
16404   }
16405   test_num++;
16406   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16407   if (test_pvremove_2 () == -1) {
16408     printf ("test_pvremove_2 FAILED\n");
16409     failed++;
16410   }
16411   test_num++;
16412   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16413   if (test_vgremove_0 () == -1) {
16414     printf ("test_vgremove_0 FAILED\n");
16415     failed++;
16416   }
16417   test_num++;
16418   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16419   if (test_vgremove_1 () == -1) {
16420     printf ("test_vgremove_1 FAILED\n");
16421     failed++;
16422   }
16423   test_num++;
16424   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16425   if (test_lvremove_0 () == -1) {
16426     printf ("test_lvremove_0 FAILED\n");
16427     failed++;
16428   }
16429   test_num++;
16430   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16431   if (test_lvremove_1 () == -1) {
16432     printf ("test_lvremove_1 FAILED\n");
16433     failed++;
16434   }
16435   test_num++;
16436   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16437   if (test_lvremove_2 () == -1) {
16438     printf ("test_lvremove_2 FAILED\n");
16439     failed++;
16440   }
16441   test_num++;
16442   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16443   if (test_mount_ro_0 () == -1) {
16444     printf ("test_mount_ro_0 FAILED\n");
16445     failed++;
16446   }
16447   test_num++;
16448   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16449   if (test_mount_ro_1 () == -1) {
16450     printf ("test_mount_ro_1 FAILED\n");
16451     failed++;
16452   }
16453   test_num++;
16454   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16455   if (test_tgz_in_0 () == -1) {
16456     printf ("test_tgz_in_0 FAILED\n");
16457     failed++;
16458   }
16459   test_num++;
16460   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16461   if (test_tar_in_0 () == -1) {
16462     printf ("test_tar_in_0 FAILED\n");
16463     failed++;
16464   }
16465   test_num++;
16466   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16467   if (test_checksum_0 () == -1) {
16468     printf ("test_checksum_0 FAILED\n");
16469     failed++;
16470   }
16471   test_num++;
16472   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16473   if (test_checksum_1 () == -1) {
16474     printf ("test_checksum_1 FAILED\n");
16475     failed++;
16476   }
16477   test_num++;
16478   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16479   if (test_checksum_2 () == -1) {
16480     printf ("test_checksum_2 FAILED\n");
16481     failed++;
16482   }
16483   test_num++;
16484   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16485   if (test_checksum_3 () == -1) {
16486     printf ("test_checksum_3 FAILED\n");
16487     failed++;
16488   }
16489   test_num++;
16490   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16491   if (test_checksum_4 () == -1) {
16492     printf ("test_checksum_4 FAILED\n");
16493     failed++;
16494   }
16495   test_num++;
16496   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16497   if (test_checksum_5 () == -1) {
16498     printf ("test_checksum_5 FAILED\n");
16499     failed++;
16500   }
16501   test_num++;
16502   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16503   if (test_checksum_6 () == -1) {
16504     printf ("test_checksum_6 FAILED\n");
16505     failed++;
16506   }
16507   test_num++;
16508   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16509   if (test_checksum_7 () == -1) {
16510     printf ("test_checksum_7 FAILED\n");
16511     failed++;
16512   }
16513   test_num++;
16514   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16515   if (test_checksum_8 () == -1) {
16516     printf ("test_checksum_8 FAILED\n");
16517     failed++;
16518   }
16519   test_num++;
16520   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16521   if (test_download_0 () == -1) {
16522     printf ("test_download_0 FAILED\n");
16523     failed++;
16524   }
16525   test_num++;
16526   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16527   if (test_upload_0 () == -1) {
16528     printf ("test_upload_0 FAILED\n");
16529     failed++;
16530   }
16531   test_num++;
16532   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16533   if (test_blockdev_rereadpt_0 () == -1) {
16534     printf ("test_blockdev_rereadpt_0 FAILED\n");
16535     failed++;
16536   }
16537   test_num++;
16538   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16539   if (test_blockdev_flushbufs_0 () == -1) {
16540     printf ("test_blockdev_flushbufs_0 FAILED\n");
16541     failed++;
16542   }
16543   test_num++;
16544   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16545   if (test_blockdev_getsize64_0 () == -1) {
16546     printf ("test_blockdev_getsize64_0 FAILED\n");
16547     failed++;
16548   }
16549   test_num++;
16550   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16551   if (test_blockdev_getsz_0 () == -1) {
16552     printf ("test_blockdev_getsz_0 FAILED\n");
16553     failed++;
16554   }
16555   test_num++;
16556   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16557   if (test_blockdev_getbsz_0 () == -1) {
16558     printf ("test_blockdev_getbsz_0 FAILED\n");
16559     failed++;
16560   }
16561   test_num++;
16562   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16563   if (test_blockdev_getss_0 () == -1) {
16564     printf ("test_blockdev_getss_0 FAILED\n");
16565     failed++;
16566   }
16567   test_num++;
16568   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16569   if (test_blockdev_getro_0 () == -1) {
16570     printf ("test_blockdev_getro_0 FAILED\n");
16571     failed++;
16572   }
16573   test_num++;
16574   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16575   if (test_blockdev_setrw_0 () == -1) {
16576     printf ("test_blockdev_setrw_0 FAILED\n");
16577     failed++;
16578   }
16579   test_num++;
16580   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16581   if (test_blockdev_setro_0 () == -1) {
16582     printf ("test_blockdev_setro_0 FAILED\n");
16583     failed++;
16584   }
16585   test_num++;
16586   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16587   if (test_statvfs_0 () == -1) {
16588     printf ("test_statvfs_0 FAILED\n");
16589     failed++;
16590   }
16591   test_num++;
16592   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16593   if (test_lstat_0 () == -1) {
16594     printf ("test_lstat_0 FAILED\n");
16595     failed++;
16596   }
16597   test_num++;
16598   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16599   if (test_stat_0 () == -1) {
16600     printf ("test_stat_0 FAILED\n");
16601     failed++;
16602   }
16603   test_num++;
16604   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16605   if (test_command_lines_0 () == -1) {
16606     printf ("test_command_lines_0 FAILED\n");
16607     failed++;
16608   }
16609   test_num++;
16610   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16611   if (test_command_lines_1 () == -1) {
16612     printf ("test_command_lines_1 FAILED\n");
16613     failed++;
16614   }
16615   test_num++;
16616   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16617   if (test_command_lines_2 () == -1) {
16618     printf ("test_command_lines_2 FAILED\n");
16619     failed++;
16620   }
16621   test_num++;
16622   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16623   if (test_command_lines_3 () == -1) {
16624     printf ("test_command_lines_3 FAILED\n");
16625     failed++;
16626   }
16627   test_num++;
16628   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16629   if (test_command_lines_4 () == -1) {
16630     printf ("test_command_lines_4 FAILED\n");
16631     failed++;
16632   }
16633   test_num++;
16634   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16635   if (test_command_lines_5 () == -1) {
16636     printf ("test_command_lines_5 FAILED\n");
16637     failed++;
16638   }
16639   test_num++;
16640   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16641   if (test_command_lines_6 () == -1) {
16642     printf ("test_command_lines_6 FAILED\n");
16643     failed++;
16644   }
16645   test_num++;
16646   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16647   if (test_command_lines_7 () == -1) {
16648     printf ("test_command_lines_7 FAILED\n");
16649     failed++;
16650   }
16651   test_num++;
16652   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16653   if (test_command_lines_8 () == -1) {
16654     printf ("test_command_lines_8 FAILED\n");
16655     failed++;
16656   }
16657   test_num++;
16658   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16659   if (test_command_lines_9 () == -1) {
16660     printf ("test_command_lines_9 FAILED\n");
16661     failed++;
16662   }
16663   test_num++;
16664   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16665   if (test_command_lines_10 () == -1) {
16666     printf ("test_command_lines_10 FAILED\n");
16667     failed++;
16668   }
16669   test_num++;
16670   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16671   if (test_command_0 () == -1) {
16672     printf ("test_command_0 FAILED\n");
16673     failed++;
16674   }
16675   test_num++;
16676   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16677   if (test_command_1 () == -1) {
16678     printf ("test_command_1 FAILED\n");
16679     failed++;
16680   }
16681   test_num++;
16682   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16683   if (test_command_2 () == -1) {
16684     printf ("test_command_2 FAILED\n");
16685     failed++;
16686   }
16687   test_num++;
16688   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16689   if (test_command_3 () == -1) {
16690     printf ("test_command_3 FAILED\n");
16691     failed++;
16692   }
16693   test_num++;
16694   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16695   if (test_command_4 () == -1) {
16696     printf ("test_command_4 FAILED\n");
16697     failed++;
16698   }
16699   test_num++;
16700   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16701   if (test_command_5 () == -1) {
16702     printf ("test_command_5 FAILED\n");
16703     failed++;
16704   }
16705   test_num++;
16706   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16707   if (test_command_6 () == -1) {
16708     printf ("test_command_6 FAILED\n");
16709     failed++;
16710   }
16711   test_num++;
16712   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16713   if (test_command_7 () == -1) {
16714     printf ("test_command_7 FAILED\n");
16715     failed++;
16716   }
16717   test_num++;
16718   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16719   if (test_command_8 () == -1) {
16720     printf ("test_command_8 FAILED\n");
16721     failed++;
16722   }
16723   test_num++;
16724   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16725   if (test_command_9 () == -1) {
16726     printf ("test_command_9 FAILED\n");
16727     failed++;
16728   }
16729   test_num++;
16730   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16731   if (test_command_10 () == -1) {
16732     printf ("test_command_10 FAILED\n");
16733     failed++;
16734   }
16735   test_num++;
16736   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16737   if (test_command_11 () == -1) {
16738     printf ("test_command_11 FAILED\n");
16739     failed++;
16740   }
16741   test_num++;
16742   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16743   if (test_file_0 () == -1) {
16744     printf ("test_file_0 FAILED\n");
16745     failed++;
16746   }
16747   test_num++;
16748   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16749   if (test_file_1 () == -1) {
16750     printf ("test_file_1 FAILED\n");
16751     failed++;
16752   }
16753   test_num++;
16754   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16755   if (test_file_2 () == -1) {
16756     printf ("test_file_2 FAILED\n");
16757     failed++;
16758   }
16759   test_num++;
16760   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16761   if (test_umount_all_0 () == -1) {
16762     printf ("test_umount_all_0 FAILED\n");
16763     failed++;
16764   }
16765   test_num++;
16766   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16767   if (test_umount_all_1 () == -1) {
16768     printf ("test_umount_all_1 FAILED\n");
16769     failed++;
16770   }
16771   test_num++;
16772   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16773   if (test_mounts_0 () == -1) {
16774     printf ("test_mounts_0 FAILED\n");
16775     failed++;
16776   }
16777   test_num++;
16778   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16779   if (test_umount_0 () == -1) {
16780     printf ("test_umount_0 FAILED\n");
16781     failed++;
16782   }
16783   test_num++;
16784   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16785   if (test_umount_1 () == -1) {
16786     printf ("test_umount_1 FAILED\n");
16787     failed++;
16788   }
16789   test_num++;
16790   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16791   if (test_write_file_0 () == -1) {
16792     printf ("test_write_file_0 FAILED\n");
16793     failed++;
16794   }
16795   test_num++;
16796   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16797   if (test_write_file_1 () == -1) {
16798     printf ("test_write_file_1 FAILED\n");
16799     failed++;
16800   }
16801   test_num++;
16802   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16803   if (test_write_file_2 () == -1) {
16804     printf ("test_write_file_2 FAILED\n");
16805     failed++;
16806   }
16807   test_num++;
16808   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16809   if (test_write_file_3 () == -1) {
16810     printf ("test_write_file_3 FAILED\n");
16811     failed++;
16812   }
16813   test_num++;
16814   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16815   if (test_write_file_4 () == -1) {
16816     printf ("test_write_file_4 FAILED\n");
16817     failed++;
16818   }
16819   test_num++;
16820   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16821   if (test_write_file_5 () == -1) {
16822     printf ("test_write_file_5 FAILED\n");
16823     failed++;
16824   }
16825   test_num++;
16826   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16827   if (test_mkfs_0 () == -1) {
16828     printf ("test_mkfs_0 FAILED\n");
16829     failed++;
16830   }
16831   test_num++;
16832   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16833   if (test_lvcreate_0 () == -1) {
16834     printf ("test_lvcreate_0 FAILED\n");
16835     failed++;
16836   }
16837   test_num++;
16838   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16839   if (test_vgcreate_0 () == -1) {
16840     printf ("test_vgcreate_0 FAILED\n");
16841     failed++;
16842   }
16843   test_num++;
16844   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16845   if (test_pvcreate_0 () == -1) {
16846     printf ("test_pvcreate_0 FAILED\n");
16847     failed++;
16848   }
16849   test_num++;
16850   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16851   if (test_is_dir_0 () == -1) {
16852     printf ("test_is_dir_0 FAILED\n");
16853     failed++;
16854   }
16855   test_num++;
16856   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16857   if (test_is_dir_1 () == -1) {
16858     printf ("test_is_dir_1 FAILED\n");
16859     failed++;
16860   }
16861   test_num++;
16862   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16863   if (test_is_file_0 () == -1) {
16864     printf ("test_is_file_0 FAILED\n");
16865     failed++;
16866   }
16867   test_num++;
16868   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16869   if (test_is_file_1 () == -1) {
16870     printf ("test_is_file_1 FAILED\n");
16871     failed++;
16872   }
16873   test_num++;
16874   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16875   if (test_exists_0 () == -1) {
16876     printf ("test_exists_0 FAILED\n");
16877     failed++;
16878   }
16879   test_num++;
16880   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16881   if (test_exists_1 () == -1) {
16882     printf ("test_exists_1 FAILED\n");
16883     failed++;
16884   }
16885   test_num++;
16886   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16887   if (test_mkdir_p_0 () == -1) {
16888     printf ("test_mkdir_p_0 FAILED\n");
16889     failed++;
16890   }
16891   test_num++;
16892   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16893   if (test_mkdir_p_1 () == -1) {
16894     printf ("test_mkdir_p_1 FAILED\n");
16895     failed++;
16896   }
16897   test_num++;
16898   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16899   if (test_mkdir_p_2 () == -1) {
16900     printf ("test_mkdir_p_2 FAILED\n");
16901     failed++;
16902   }
16903   test_num++;
16904   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16905   if (test_mkdir_p_3 () == -1) {
16906     printf ("test_mkdir_p_3 FAILED\n");
16907     failed++;
16908   }
16909   test_num++;
16910   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16911   if (test_mkdir_p_4 () == -1) {
16912     printf ("test_mkdir_p_4 FAILED\n");
16913     failed++;
16914   }
16915   test_num++;
16916   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16917   if (test_mkdir_0 () == -1) {
16918     printf ("test_mkdir_0 FAILED\n");
16919     failed++;
16920   }
16921   test_num++;
16922   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16923   if (test_mkdir_1 () == -1) {
16924     printf ("test_mkdir_1 FAILED\n");
16925     failed++;
16926   }
16927   test_num++;
16928   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16929   if (test_rm_rf_0 () == -1) {
16930     printf ("test_rm_rf_0 FAILED\n");
16931     failed++;
16932   }
16933   test_num++;
16934   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16935   if (test_rmdir_0 () == -1) {
16936     printf ("test_rmdir_0 FAILED\n");
16937     failed++;
16938   }
16939   test_num++;
16940   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16941   if (test_rmdir_1 () == -1) {
16942     printf ("test_rmdir_1 FAILED\n");
16943     failed++;
16944   }
16945   test_num++;
16946   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16947   if (test_rmdir_2 () == -1) {
16948     printf ("test_rmdir_2 FAILED\n");
16949     failed++;
16950   }
16951   test_num++;
16952   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16953   if (test_rm_0 () == -1) {
16954     printf ("test_rm_0 FAILED\n");
16955     failed++;
16956   }
16957   test_num++;
16958   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16959   if (test_rm_1 () == -1) {
16960     printf ("test_rm_1 FAILED\n");
16961     failed++;
16962   }
16963   test_num++;
16964   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16965   if (test_rm_2 () == -1) {
16966     printf ("test_rm_2 FAILED\n");
16967     failed++;
16968   }
16969   test_num++;
16970   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16971   if (test_read_lines_0 () == -1) {
16972     printf ("test_read_lines_0 FAILED\n");
16973     failed++;
16974   }
16975   test_num++;
16976   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16977   if (test_read_lines_1 () == -1) {
16978     printf ("test_read_lines_1 FAILED\n");
16979     failed++;
16980   }
16981   test_num++;
16982   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16983   if (test_lvs_0 () == -1) {
16984     printf ("test_lvs_0 FAILED\n");
16985     failed++;
16986   }
16987   test_num++;
16988   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16989   if (test_lvs_1 () == -1) {
16990     printf ("test_lvs_1 FAILED\n");
16991     failed++;
16992   }
16993   test_num++;
16994   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16995   if (test_vgs_0 () == -1) {
16996     printf ("test_vgs_0 FAILED\n");
16997     failed++;
16998   }
16999   test_num++;
17000   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17001   if (test_vgs_1 () == -1) {
17002     printf ("test_vgs_1 FAILED\n");
17003     failed++;
17004   }
17005   test_num++;
17006   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17007   if (test_pvs_0 () == -1) {
17008     printf ("test_pvs_0 FAILED\n");
17009     failed++;
17010   }
17011   test_num++;
17012   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17013   if (test_pvs_1 () == -1) {
17014     printf ("test_pvs_1 FAILED\n");
17015     failed++;
17016   }
17017   test_num++;
17018   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17019   if (test_list_partitions_0 () == -1) {
17020     printf ("test_list_partitions_0 FAILED\n");
17021     failed++;
17022   }
17023   test_num++;
17024   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17025   if (test_list_partitions_1 () == -1) {
17026     printf ("test_list_partitions_1 FAILED\n");
17027     failed++;
17028   }
17029   test_num++;
17030   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17031   if (test_list_devices_0 () == -1) {
17032     printf ("test_list_devices_0 FAILED\n");
17033     failed++;
17034   }
17035   test_num++;
17036   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17037   if (test_ls_0 () == -1) {
17038     printf ("test_ls_0 FAILED\n");
17039     failed++;
17040   }
17041   test_num++;
17042   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17043   if (test_cat_0 () == -1) {
17044     printf ("test_cat_0 FAILED\n");
17045     failed++;
17046   }
17047   test_num++;
17048   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17049   if (test_touch_0 () == -1) {
17050     printf ("test_touch_0 FAILED\n");
17051     failed++;
17052   }
17053   test_num++;
17054   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17055   if (test_sync_0 () == -1) {
17056     printf ("test_sync_0 FAILED\n");
17057     failed++;
17058   }
17059   test_num++;
17060   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17061   if (test_mount_0 () == -1) {
17062     printf ("test_mount_0 FAILED\n");
17063     failed++;
17064   }
17065
17066   guestfs_close (g);
17067   unlink ("test1.img");
17068   unlink ("test2.img");
17069   unlink ("test3.img");
17070
17071   if (failed > 0) {
17072     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
17073     exit (1);
17074   }
17075
17076   exit (0);
17077 }