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 /* This will be 's' or 'h' depending on whether the guest kernel
  35  * names IDE devices /dev/sd* or /dev/hd*.
  36  */
  37 static char devchar = 's';
  38
  39 static void print_error (guestfs_h *g, void *data, const char *msg)
  40 {
  41   if (!suppress_error)
  42     fprintf (stderr, "%s\n", msg);
  43 }
  44
  45 static void print_strings (char * const * const argv)
  46 {
  47   int argc;
  48
  49   for (argc = 0; argv[argc] != NULL; ++argc)
  50     printf ("\t%s\n", argv[argc]);
  51 }
  52
  53 /*
  54 static void print_table (char * const * const argv)
  55 {
  56   int i;
  57
  58   for (i = 0; argv[i] != NULL; i += 2)
  59     printf ("%s: %s\n", argv[i], argv[i+1]);
  60 }
  61 */
  62
  63 static void no_test_warnings (void)
  64 {
  65   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 156 }
 157
 158 static int test_ntfs_3g_probe_0_skip (void)
 159 {
 160   const char *str;
 161
 162   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
 163   if (str && strcmp (str, "1") == 0) return 1;
 164   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 165   if (str && strcmp (str, "1") == 0) return 1;
 166   return 0;
 167 }
 168
 169 static int test_ntfs_3g_probe_0 (void)
 170 {
 171   if (test_ntfs_3g_probe_0_skip ()) {
 172     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
 173     return 0;
 174   }
 175
 176   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
 177   {
 178     char device[] = "/dev/sda";
 179     device[5] = devchar;
 180     int r;
 181     suppress_error = 0;
 182     r = guestfs_blockdev_setrw (g, device);
 183     if (r == -1)
 184       return -1;
 185   }
 186   {
 187     int r;
 188     suppress_error = 0;
 189     r = guestfs_umount_all (g);
 190     if (r == -1)
 191       return -1;
 192   }
 193   {
 194     int r;
 195     suppress_error = 0;
 196     r = guestfs_lvm_remove_all (g);
 197     if (r == -1)
 198       return -1;
 199   }
 200   /* TestOutputInt for ntfs_3g_probe (0) */
 201   {
 202     char device[] = "/dev/sda";
 203     device[5] = devchar;
 204     char lines_0[] = ",";
 205     char *lines[] = {
 206       lines_0,
 207       NULL
 208     };
 209     int r;
 210     suppress_error = 0;
 211     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 212     if (r == -1)
 213       return -1;
 214   }
 215   {
 216     char fstype[] = "ntfs";
 217     char device[] = "/dev/sda1";
 218     device[5] = devchar;
 219     int r;
 220     suppress_error = 0;
 221     r = guestfs_mkfs (g, fstype, device);
 222     if (r == -1)
 223       return -1;
 224   }
 225   {
 226     char device[] = "/dev/sda1";
 227     device[5] = devchar;
 228     int r;
 229     suppress_error = 0;
 230     r = guestfs_ntfs_3g_probe (g, 1, device);
 231     if (r == -1)
 232       return -1;
 233     if (r != 0) {
 234       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
 235       return -1;
 236     }
 237   }
 238   return 0;
 239 }
 240
 241 static int test_ntfs_3g_probe_1_skip (void)
 242 {
 243   const char *str;
 244
 245   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
 246   if (str && strcmp (str, "1") == 0) return 1;
 247   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
 248   if (str && strcmp (str, "1") == 0) return 1;
 249   return 0;
 250 }
 251
 252 static int test_ntfs_3g_probe_1 (void)
 253 {
 254   if (test_ntfs_3g_probe_1_skip ()) {
 255     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
 256     return 0;
 257   }
 258
 259   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
 260   {
 261     char device[] = "/dev/sda";
 262     device[5] = devchar;
 263     int r;
 264     suppress_error = 0;
 265     r = guestfs_blockdev_setrw (g, device);
 266     if (r == -1)
 267       return -1;
 268   }
 269   {
 270     int r;
 271     suppress_error = 0;
 272     r = guestfs_umount_all (g);
 273     if (r == -1)
 274       return -1;
 275   }
 276   {
 277     int r;
 278     suppress_error = 0;
 279     r = guestfs_lvm_remove_all (g);
 280     if (r == -1)
 281       return -1;
 282   }
 283   /* TestOutputInt for ntfs_3g_probe (1) */
 284   {
 285     char device[] = "/dev/sda";
 286     device[5] = devchar;
 287     char lines_0[] = ",";
 288     char *lines[] = {
 289       lines_0,
 290       NULL
 291     };
 292     int r;
 293     suppress_error = 0;
 294     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 295     if (r == -1)
 296       return -1;
 297   }
 298   {
 299     char fstype[] = "ext2";
 300     char device[] = "/dev/sda1";
 301     device[5] = devchar;
 302     int r;
 303     suppress_error = 0;
 304     r = guestfs_mkfs (g, fstype, device);
 305     if (r == -1)
 306       return -1;
 307   }
 308   {
 309     char device[] = "/dev/sda1";
 310     device[5] = devchar;
 311     int r;
 312     suppress_error = 0;
 313     r = guestfs_ntfs_3g_probe (g, 1, device);
 314     if (r == -1)
 315       return -1;
 316     if (r != 12) {
 317       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
 318       return -1;
 319     }
 320   }
 321   return 0;
 322 }
 323
 324 static int test_sleep_0_skip (void)
 325 {
 326   const char *str;
 327
 328   str = getenv ("SKIP_TEST_SLEEP_0");
 329   if (str && strcmp (str, "1") == 0) return 1;
 330   str = getenv ("SKIP_TEST_SLEEP");
 331   if (str && strcmp (str, "1") == 0) return 1;
 332   return 0;
 333 }
 334
 335 static int test_sleep_0 (void)
 336 {
 337   if (test_sleep_0_skip ()) {
 338     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
 339     return 0;
 340   }
 341
 342   /* InitNone|InitEmpty for test_sleep_0 */
 343   {
 344     char device[] = "/dev/sda";
 345     device[5] = devchar;
 346     int r;
 347     suppress_error = 0;
 348     r = guestfs_blockdev_setrw (g, device);
 349     if (r == -1)
 350       return -1;
 351   }
 352   {
 353     int r;
 354     suppress_error = 0;
 355     r = guestfs_umount_all (g);
 356     if (r == -1)
 357       return -1;
 358   }
 359   {
 360     int r;
 361     suppress_error = 0;
 362     r = guestfs_lvm_remove_all (g);
 363     if (r == -1)
 364       return -1;
 365   }
 366   /* TestRun for sleep (0) */
 367   {
 368     int r;
 369     suppress_error = 0;
 370     r = guestfs_sleep (g, 1);
 371     if (r == -1)
 372       return -1;
 373   }
 374   return 0;
 375 }
 376
 377 static int test_find_0_skip (void)
 378 {
 379   const char *str;
 380
 381   str = getenv ("SKIP_TEST_FIND_0");
 382   if (str && strcmp (str, "1") == 0) return 1;
 383   str = getenv ("SKIP_TEST_FIND");
 384   if (str && strcmp (str, "1") == 0) return 1;
 385   return 0;
 386 }
 387
 388 static int test_find_0 (void)
 389 {
 390   if (test_find_0_skip ()) {
 391     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
 392     return 0;
 393   }
 394
 395   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
 396   {
 397     char device[] = "/dev/sda";
 398     device[5] = devchar;
 399     int r;
 400     suppress_error = 0;
 401     r = guestfs_blockdev_setrw (g, device);
 402     if (r == -1)
 403       return -1;
 404   }
 405   {
 406     int r;
 407     suppress_error = 0;
 408     r = guestfs_umount_all (g);
 409     if (r == -1)
 410       return -1;
 411   }
 412   {
 413     int r;
 414     suppress_error = 0;
 415     r = guestfs_lvm_remove_all (g);
 416     if (r == -1)
 417       return -1;
 418   }
 419   {
 420     char device[] = "/dev/sda";
 421     device[5] = devchar;
 422     char lines_0[] = ",";
 423     char *lines[] = {
 424       lines_0,
 425       NULL
 426     };
 427     int r;
 428     suppress_error = 0;
 429     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 430     if (r == -1)
 431       return -1;
 432   }
 433   {
 434     char fstype[] = "ext2";
 435     char device[] = "/dev/sda1";
 436     device[5] = devchar;
 437     int r;
 438     suppress_error = 0;
 439     r = guestfs_mkfs (g, fstype, device);
 440     if (r == -1)
 441       return -1;
 442   }
 443   {
 444     char device[] = "/dev/sda1";
 445     device[5] = devchar;
 446     char mountpoint[] = "/";
 447     int r;
 448     suppress_error = 0;
 449     r = guestfs_mount (g, device, mountpoint);
 450     if (r == -1)
 451       return -1;
 452   }
 453   /* TestOutputList for find (0) */
 454   {
 455     char directory[] = "/";
 456     char **r;
 457     int i;
 458     suppress_error = 0;
 459     r = guestfs_find (g, directory);
 460     if (r == NULL)
 461       return -1;
 462     if (!r[0]) {
 463       fprintf (stderr, "test_find_0: short list returned from command\n");
 464       print_strings (r);
 465       return -1;
 466     }
 467     {
 468       char expected[] = "lost+found";
 469       if (strcmp (r[0], expected) != 0) {
 470         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 471         return -1;
 472       }
 473     }
 474     if (r[1] != NULL) {
 475       fprintf (stderr, "test_find_0: extra elements returned from command\n");
 476       print_strings (r);
 477       return -1;
 478     }
 479     for (i = 0; r[i] != NULL; ++i)
 480       free (r[i]);
 481     free (r);
 482   }
 483   return 0;
 484 }
 485
 486 static int test_find_1_skip (void)
 487 {
 488   const char *str;
 489
 490   str = getenv ("SKIP_TEST_FIND_1");
 491   if (str && strcmp (str, "1") == 0) return 1;
 492   str = getenv ("SKIP_TEST_FIND");
 493   if (str && strcmp (str, "1") == 0) return 1;
 494   return 0;
 495 }
 496
 497 static int test_find_1 (void)
 498 {
 499   if (test_find_1_skip ()) {
 500     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
 501     return 0;
 502   }
 503
 504   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
 505   {
 506     char device[] = "/dev/sda";
 507     device[5] = devchar;
 508     int r;
 509     suppress_error = 0;
 510     r = guestfs_blockdev_setrw (g, device);
 511     if (r == -1)
 512       return -1;
 513   }
 514   {
 515     int r;
 516     suppress_error = 0;
 517     r = guestfs_umount_all (g);
 518     if (r == -1)
 519       return -1;
 520   }
 521   {
 522     int r;
 523     suppress_error = 0;
 524     r = guestfs_lvm_remove_all (g);
 525     if (r == -1)
 526       return -1;
 527   }
 528   {
 529     char device[] = "/dev/sda";
 530     device[5] = devchar;
 531     char lines_0[] = ",";
 532     char *lines[] = {
 533       lines_0,
 534       NULL
 535     };
 536     int r;
 537     suppress_error = 0;
 538     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 539     if (r == -1)
 540       return -1;
 541   }
 542   {
 543     char fstype[] = "ext2";
 544     char device[] = "/dev/sda1";
 545     device[5] = devchar;
 546     int r;
 547     suppress_error = 0;
 548     r = guestfs_mkfs (g, fstype, device);
 549     if (r == -1)
 550       return -1;
 551   }
 552   {
 553     char device[] = "/dev/sda1";
 554     device[5] = devchar;
 555     char mountpoint[] = "/";
 556     int r;
 557     suppress_error = 0;
 558     r = guestfs_mount (g, device, mountpoint);
 559     if (r == -1)
 560       return -1;
 561   }
 562   /* TestOutputList for find (1) */
 563   {
 564     char path[] = "/a";
 565     int r;
 566     suppress_error = 0;
 567     r = guestfs_touch (g, path);
 568     if (r == -1)
 569       return -1;
 570   }
 571   {
 572     char path[] = "/b";
 573     int r;
 574     suppress_error = 0;
 575     r = guestfs_mkdir (g, path);
 576     if (r == -1)
 577       return -1;
 578   }
 579   {
 580     char path[] = "/b/c";
 581     int r;
 582     suppress_error = 0;
 583     r = guestfs_touch (g, path);
 584     if (r == -1)
 585       return -1;
 586   }
 587   {
 588     char directory[] = "/";
 589     char **r;
 590     int i;
 591     suppress_error = 0;
 592     r = guestfs_find (g, directory);
 593     if (r == NULL)
 594       return -1;
 595     if (!r[0]) {
 596       fprintf (stderr, "test_find_1: short list returned from command\n");
 597       print_strings (r);
 598       return -1;
 599     }
 600     {
 601       char expected[] = "a";
 602       if (strcmp (r[0], expected) != 0) {
 603         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 604         return -1;
 605       }
 606     }
 607     if (!r[1]) {
 608       fprintf (stderr, "test_find_1: short list returned from command\n");
 609       print_strings (r);
 610       return -1;
 611     }
 612     {
 613       char expected[] = "b";
 614       if (strcmp (r[1], expected) != 0) {
 615         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 616         return -1;
 617       }
 618     }
 619     if (!r[2]) {
 620       fprintf (stderr, "test_find_1: short list returned from command\n");
 621       print_strings (r);
 622       return -1;
 623     }
 624     {
 625       char expected[] = "b/c";
 626       if (strcmp (r[2], expected) != 0) {
 627         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 628         return -1;
 629       }
 630     }
 631     if (!r[3]) {
 632       fprintf (stderr, "test_find_1: short list returned from command\n");
 633       print_strings (r);
 634       return -1;
 635     }
 636     {
 637       char expected[] = "lost+found";
 638       if (strcmp (r[3], expected) != 0) {
 639         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 640         return -1;
 641       }
 642     }
 643     if (r[4] != NULL) {
 644       fprintf (stderr, "test_find_1: extra elements returned from command\n");
 645       print_strings (r);
 646       return -1;
 647     }
 648     for (i = 0; r[i] != NULL; ++i)
 649       free (r[i]);
 650     free (r);
 651   }
 652   return 0;
 653 }
 654
 655 static int test_find_2_skip (void)
 656 {
 657   const char *str;
 658
 659   str = getenv ("SKIP_TEST_FIND_2");
 660   if (str && strcmp (str, "1") == 0) return 1;
 661   str = getenv ("SKIP_TEST_FIND");
 662   if (str && strcmp (str, "1") == 0) return 1;
 663   return 0;
 664 }
 665
 666 static int test_find_2 (void)
 667 {
 668   if (test_find_2_skip ()) {
 669     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
 670     return 0;
 671   }
 672
 673   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
 674   {
 675     char device[] = "/dev/sda";
 676     device[5] = devchar;
 677     int r;
 678     suppress_error = 0;
 679     r = guestfs_blockdev_setrw (g, device);
 680     if (r == -1)
 681       return -1;
 682   }
 683   {
 684     int r;
 685     suppress_error = 0;
 686     r = guestfs_umount_all (g);
 687     if (r == -1)
 688       return -1;
 689   }
 690   {
 691     int r;
 692     suppress_error = 0;
 693     r = guestfs_lvm_remove_all (g);
 694     if (r == -1)
 695       return -1;
 696   }
 697   {
 698     char device[] = "/dev/sda";
 699     device[5] = devchar;
 700     char lines_0[] = ",";
 701     char *lines[] = {
 702       lines_0,
 703       NULL
 704     };
 705     int r;
 706     suppress_error = 0;
 707     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 708     if (r == -1)
 709       return -1;
 710   }
 711   {
 712     char fstype[] = "ext2";
 713     char device[] = "/dev/sda1";
 714     device[5] = devchar;
 715     int r;
 716     suppress_error = 0;
 717     r = guestfs_mkfs (g, fstype, device);
 718     if (r == -1)
 719       return -1;
 720   }
 721   {
 722     char device[] = "/dev/sda1";
 723     device[5] = devchar;
 724     char mountpoint[] = "/";
 725     int r;
 726     suppress_error = 0;
 727     r = guestfs_mount (g, device, mountpoint);
 728     if (r == -1)
 729       return -1;
 730   }
 731   /* TestOutputList for find (2) */
 732   {
 733     char path[] = "/a/b/c";
 734     int r;
 735     suppress_error = 0;
 736     r = guestfs_mkdir_p (g, path);
 737     if (r == -1)
 738       return -1;
 739   }
 740   {
 741     char path[] = "/a/b/c/d";
 742     int r;
 743     suppress_error = 0;
 744     r = guestfs_touch (g, path);
 745     if (r == -1)
 746       return -1;
 747   }
 748   {
 749     char directory[] = "/a/b/";
 750     char **r;
 751     int i;
 752     suppress_error = 0;
 753     r = guestfs_find (g, directory);
 754     if (r == NULL)
 755       return -1;
 756     if (!r[0]) {
 757       fprintf (stderr, "test_find_2: short list returned from command\n");
 758       print_strings (r);
 759       return -1;
 760     }
 761     {
 762       char expected[] = "c";
 763       if (strcmp (r[0], expected) != 0) {
 764         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 765         return -1;
 766       }
 767     }
 768     if (!r[1]) {
 769       fprintf (stderr, "test_find_2: short list returned from command\n");
 770       print_strings (r);
 771       return -1;
 772     }
 773     {
 774       char expected[] = "c/d";
 775       if (strcmp (r[1], expected) != 0) {
 776         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 777         return -1;
 778       }
 779     }
 780     if (r[2] != NULL) {
 781       fprintf (stderr, "test_find_2: extra elements returned from command\n");
 782       print_strings (r);
 783       return -1;
 784     }
 785     for (i = 0; r[i] != NULL; ++i)
 786       free (r[i]);
 787     free (r);
 788   }
 789   return 0;
 790 }
 791
 792 static int test_lvresize_0_skip (void)
 793 {
 794   const char *str;
 795
 796   str = getenv ("SKIP_TEST_LVRESIZE_0");
 797   if (str && strcmp (str, "1") == 0) return 1;
 798   str = getenv ("SKIP_TEST_LVRESIZE");
 799   if (str && strcmp (str, "1") == 0) return 1;
 800   return 0;
 801 }
 802
 803 static int test_lvresize_0 (void)
 804 {
 805   if (test_lvresize_0_skip ()) {
 806     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
 807     return 0;
 808   }
 809
 810   /* InitNone|InitEmpty for test_lvresize_0 */
 811   {
 812     char device[] = "/dev/sda";
 813     device[5] = devchar;
 814     int r;
 815     suppress_error = 0;
 816     r = guestfs_blockdev_setrw (g, device);
 817     if (r == -1)
 818       return -1;
 819   }
 820   {
 821     int r;
 822     suppress_error = 0;
 823     r = guestfs_umount_all (g);
 824     if (r == -1)
 825       return -1;
 826   }
 827   {
 828     int r;
 829     suppress_error = 0;
 830     r = guestfs_lvm_remove_all (g);
 831     if (r == -1)
 832       return -1;
 833   }
 834   /* TestOutput for lvresize (0) */
 835   char expected[] = "test content";
 836   {
 837     char device[] = "/dev/sda";
 838     device[5] = devchar;
 839     char lines_0[] = ",";
 840     char *lines[] = {
 841       lines_0,
 842       NULL
 843     };
 844     int r;
 845     suppress_error = 0;
 846     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 847     if (r == -1)
 848       return -1;
 849   }
 850   {
 851     char device[] = "/dev/sda1";
 852     device[5] = devchar;
 853     int r;
 854     suppress_error = 0;
 855     r = guestfs_pvcreate (g, device);
 856     if (r == -1)
 857       return -1;
 858   }
 859   {
 860     char volgroup[] = "VG";
 861     char physvols_0[] = "/dev/sda1";
 862     physvols_0[5] = devchar;
 863     char *physvols[] = {
 864       physvols_0,
 865       NULL
 866     };
 867     int r;
 868     suppress_error = 0;
 869     r = guestfs_vgcreate (g, volgroup, physvols);
 870     if (r == -1)
 871       return -1;
 872   }
 873   {
 874     char logvol[] = "LV";
 875     char volgroup[] = "VG";
 876     int r;
 877     suppress_error = 0;
 878     r = guestfs_lvcreate (g, logvol, volgroup, 10);
 879     if (r == -1)
 880       return -1;
 881   }
 882   {
 883     char fstype[] = "ext2";
 884     char device[] = "/dev/VG/LV";
 885     int r;
 886     suppress_error = 0;
 887     r = guestfs_mkfs (g, fstype, device);
 888     if (r == -1)
 889       return -1;
 890   }
 891   {
 892     char device[] = "/dev/VG/LV";
 893     char mountpoint[] = "/";
 894     int r;
 895     suppress_error = 0;
 896     r = guestfs_mount (g, device, mountpoint);
 897     if (r == -1)
 898       return -1;
 899   }
 900   {
 901     char path[] = "/new";
 902     char content[] = "test content";
 903     int r;
 904     suppress_error = 0;
 905     r = guestfs_write_file (g, path, content, 0);
 906     if (r == -1)
 907       return -1;
 908   }
 909   {
 910     char pathordevice[] = "/";
 911     int r;
 912     suppress_error = 0;
 913     r = guestfs_umount (g, pathordevice);
 914     if (r == -1)
 915       return -1;
 916   }
 917   {
 918     char device[] = "/dev/VG/LV";
 919     int r;
 920     suppress_error = 0;
 921     r = guestfs_lvresize (g, device, 20);
 922     if (r == -1)
 923       return -1;
 924   }
 925   {
 926     char device[] = "/dev/VG/LV";
 927     int r;
 928     suppress_error = 0;
 929     r = guestfs_e2fsck_f (g, device);
 930     if (r == -1)
 931       return -1;
 932   }
 933   {
 934     char device[] = "/dev/VG/LV";
 935     int r;
 936     suppress_error = 0;
 937     r = guestfs_resize2fs (g, device);
 938     if (r == -1)
 939       return -1;
 940   }
 941   {
 942     char device[] = "/dev/VG/LV";
 943     char mountpoint[] = "/";
 944     int r;
 945     suppress_error = 0;
 946     r = guestfs_mount (g, device, mountpoint);
 947     if (r == -1)
 948       return -1;
 949   }
 950   {
 951     char path[] = "/new";
 952     char *r;
 953     suppress_error = 0;
 954     r = guestfs_cat (g, path);
 955     if (r == NULL)
 956       return -1;
 957     if (strcmp (r, expected) != 0) {
 958       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
 959       return -1;
 960     }
 961     free (r);
 962   }
 963   return 0;
 964 }
 965
 966 static int test_zerofree_0_skip (void)
 967 {
 968   const char *str;
 969
 970   str = getenv ("SKIP_TEST_ZEROFREE_0");
 971   if (str && strcmp (str, "1") == 0) return 1;
 972   str = getenv ("SKIP_TEST_ZEROFREE");
 973   if (str && strcmp (str, "1") == 0) return 1;
 974   return 0;
 975 }
 976
 977 static int test_zerofree_0 (void)
 978 {
 979   if (test_zerofree_0_skip ()) {
 980     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
 981     return 0;
 982   }
 983
 984   /* InitNone|InitEmpty for test_zerofree_0 */
 985   {
 986     char device[] = "/dev/sda";
 987     device[5] = devchar;
 988     int r;
 989     suppress_error = 0;
 990     r = guestfs_blockdev_setrw (g, device);
 991     if (r == -1)
 992       return -1;
 993   }
 994   {
 995     int r;
 996     suppress_error = 0;
 997     r = guestfs_umount_all (g);
 998     if (r == -1)
 999       return -1;
1000   }
1001   {
1002     int r;
1003     suppress_error = 0;
1004     r = guestfs_lvm_remove_all (g);
1005     if (r == -1)
1006       return -1;
1007   }
1008   /* TestOutput for zerofree (0) */
1009   char expected[] = "test file";
1010   {
1011     char device[] = "/dev/sda";
1012     device[5] = devchar;
1013     char lines_0[] = ",";
1014     char *lines[] = {
1015       lines_0,
1016       NULL
1017     };
1018     int r;
1019     suppress_error = 0;
1020     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1021     if (r == -1)
1022       return -1;
1023   }
1024   {
1025     char fstype[] = "ext3";
1026     char device[] = "/dev/sda1";
1027     device[5] = devchar;
1028     int r;
1029     suppress_error = 0;
1030     r = guestfs_mkfs (g, fstype, device);
1031     if (r == -1)
1032       return -1;
1033   }
1034   {
1035     char device[] = "/dev/sda1";
1036     device[5] = devchar;
1037     char mountpoint[] = "/";
1038     int r;
1039     suppress_error = 0;
1040     r = guestfs_mount (g, device, mountpoint);
1041     if (r == -1)
1042       return -1;
1043   }
1044   {
1045     char path[] = "/new";
1046     char content[] = "test file";
1047     int r;
1048     suppress_error = 0;
1049     r = guestfs_write_file (g, path, content, 0);
1050     if (r == -1)
1051       return -1;
1052   }
1053   {
1054     char pathordevice[] = "/dev/sda1";
1055     pathordevice[5] = devchar;
1056     int r;
1057     suppress_error = 0;
1058     r = guestfs_umount (g, pathordevice);
1059     if (r == -1)
1060       return -1;
1061   }
1062   {
1063     char device[] = "/dev/sda1";
1064     device[5] = devchar;
1065     int r;
1066     suppress_error = 0;
1067     r = guestfs_zerofree (g, device);
1068     if (r == -1)
1069       return -1;
1070   }
1071   {
1072     char device[] = "/dev/sda1";
1073     device[5] = devchar;
1074     char mountpoint[] = "/";
1075     int r;
1076     suppress_error = 0;
1077     r = guestfs_mount (g, device, mountpoint);
1078     if (r == -1)
1079       return -1;
1080   }
1081   {
1082     char path[] = "/new";
1083     char *r;
1084     suppress_error = 0;
1085     r = guestfs_cat (g, path);
1086     if (r == NULL)
1087       return -1;
1088     if (strcmp (r, expected) != 0) {
1089       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1090       return -1;
1091     }
1092     free (r);
1093   }
1094   return 0;
1095 }
1096
1097 static int test_hexdump_0_skip (void)
1098 {
1099   const char *str;
1100
1101   str = getenv ("SKIP_TEST_HEXDUMP_0");
1102   if (str && strcmp (str, "1") == 0) return 1;
1103   str = getenv ("SKIP_TEST_HEXDUMP");
1104   if (str && strcmp (str, "1") == 0) return 1;
1105   return 0;
1106 }
1107
1108 static int test_hexdump_0 (void)
1109 {
1110   if (test_hexdump_0_skip ()) {
1111     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1112     return 0;
1113   }
1114
1115   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1116   {
1117     char device[] = "/dev/sda";
1118     device[5] = devchar;
1119     int r;
1120     suppress_error = 0;
1121     r = guestfs_blockdev_setrw (g, device);
1122     if (r == -1)
1123       return -1;
1124   }
1125   {
1126     int r;
1127     suppress_error = 0;
1128     r = guestfs_umount_all (g);
1129     if (r == -1)
1130       return -1;
1131   }
1132   {
1133     int r;
1134     suppress_error = 0;
1135     r = guestfs_lvm_remove_all (g);
1136     if (r == -1)
1137       return -1;
1138   }
1139   {
1140     char device[] = "/dev/sda";
1141     device[5] = devchar;
1142     char lines_0[] = ",";
1143     char *lines[] = {
1144       lines_0,
1145       NULL
1146     };
1147     int r;
1148     suppress_error = 0;
1149     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1150     if (r == -1)
1151       return -1;
1152   }
1153   {
1154     char fstype[] = "ext2";
1155     char device[] = "/dev/sda1";
1156     device[5] = devchar;
1157     int r;
1158     suppress_error = 0;
1159     r = guestfs_mkfs (g, fstype, device);
1160     if (r == -1)
1161       return -1;
1162   }
1163   {
1164     char device[] = "/dev/sda1";
1165     device[5] = devchar;
1166     char mountpoint[] = "/";
1167     int r;
1168     suppress_error = 0;
1169     r = guestfs_mount (g, device, mountpoint);
1170     if (r == -1)
1171       return -1;
1172   }
1173   /* TestOutput for hexdump (0) */
1174   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
1175   {
1176     char path[] = "/new";
1177     char content[] = "hello\nworld\n";
1178     int r;
1179     suppress_error = 0;
1180     r = guestfs_write_file (g, path, content, 12);
1181     if (r == -1)
1182       return -1;
1183   }
1184   {
1185     char path[] = "/new";
1186     char *r;
1187     suppress_error = 0;
1188     r = guestfs_hexdump (g, path);
1189     if (r == NULL)
1190       return -1;
1191     if (strcmp (r, expected) != 0) {
1192       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1193       return -1;
1194     }
1195     free (r);
1196   }
1197   return 0;
1198 }
1199
1200 static int test_strings_e_0_skip (void)
1201 {
1202   const char *str;
1203
1204   str = getenv ("SKIP_TEST_STRINGS_E_0");
1205   if (str && strcmp (str, "1") == 0) return 1;
1206   str = getenv ("SKIP_TEST_STRINGS_E");
1207   if (str && strcmp (str, "1") == 0) return 1;
1208   return 0;
1209 }
1210
1211 static int test_strings_e_0 (void)
1212 {
1213   if (test_strings_e_0_skip ()) {
1214     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1215     return 0;
1216   }
1217
1218   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1219   {
1220     char device[] = "/dev/sda";
1221     device[5] = devchar;
1222     int r;
1223     suppress_error = 0;
1224     r = guestfs_blockdev_setrw (g, device);
1225     if (r == -1)
1226       return -1;
1227   }
1228   {
1229     int r;
1230     suppress_error = 0;
1231     r = guestfs_umount_all (g);
1232     if (r == -1)
1233       return -1;
1234   }
1235   {
1236     int r;
1237     suppress_error = 0;
1238     r = guestfs_lvm_remove_all (g);
1239     if (r == -1)
1240       return -1;
1241   }
1242   {
1243     char device[] = "/dev/sda";
1244     device[5] = devchar;
1245     char lines_0[] = ",";
1246     char *lines[] = {
1247       lines_0,
1248       NULL
1249     };
1250     int r;
1251     suppress_error = 0;
1252     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1253     if (r == -1)
1254       return -1;
1255   }
1256   {
1257     char fstype[] = "ext2";
1258     char device[] = "/dev/sda1";
1259     device[5] = devchar;
1260     int r;
1261     suppress_error = 0;
1262     r = guestfs_mkfs (g, fstype, device);
1263     if (r == -1)
1264       return -1;
1265   }
1266   {
1267     char device[] = "/dev/sda1";
1268     device[5] = devchar;
1269     char mountpoint[] = "/";
1270     int r;
1271     suppress_error = 0;
1272     r = guestfs_mount (g, device, mountpoint);
1273     if (r == -1)
1274       return -1;
1275   }
1276   /* TestOutputList for strings_e (0) */
1277   {
1278     char path[] = "/new";
1279     char content[] = "hello\nworld\n";
1280     int r;
1281     suppress_error = 0;
1282     r = guestfs_write_file (g, path, content, 0);
1283     if (r == -1)
1284       return -1;
1285   }
1286   {
1287     char encoding[] = "b";
1288     char path[] = "/new";
1289     char **r;
1290     int i;
1291     suppress_error = 0;
1292     r = guestfs_strings_e (g, encoding, path);
1293     if (r == NULL)
1294       return -1;
1295     if (r[0] != NULL) {
1296       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1297       print_strings (r);
1298       return -1;
1299     }
1300     for (i = 0; r[i] != NULL; ++i)
1301       free (r[i]);
1302     free (r);
1303   }
1304   return 0;
1305 }
1306
1307 static int test_strings_e_1_skip (void)
1308 {
1309   const char *str;
1310
1311   str = getenv ("SKIP_TEST_STRINGS_E_1");
1312   if (str && strcmp (str, "1") == 0) return 1;
1313   str = getenv ("SKIP_TEST_STRINGS_E");
1314   if (str && strcmp (str, "1") == 0) return 1;
1315   return 0;
1316 }
1317
1318 static int test_strings_e_1 (void)
1319 {
1320   if (test_strings_e_1_skip ()) {
1321     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1322     return 0;
1323   }
1324
1325   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1326   return 0;
1327 }
1328
1329 static int test_strings_0_skip (void)
1330 {
1331   const char *str;
1332
1333   str = getenv ("SKIP_TEST_STRINGS_0");
1334   if (str && strcmp (str, "1") == 0) return 1;
1335   str = getenv ("SKIP_TEST_STRINGS");
1336   if (str && strcmp (str, "1") == 0) return 1;
1337   return 0;
1338 }
1339
1340 static int test_strings_0 (void)
1341 {
1342   if (test_strings_0_skip ()) {
1343     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1344     return 0;
1345   }
1346
1347   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1348   {
1349     char device[] = "/dev/sda";
1350     device[5] = devchar;
1351     int r;
1352     suppress_error = 0;
1353     r = guestfs_blockdev_setrw (g, device);
1354     if (r == -1)
1355       return -1;
1356   }
1357   {
1358     int r;
1359     suppress_error = 0;
1360     r = guestfs_umount_all (g);
1361     if (r == -1)
1362       return -1;
1363   }
1364   {
1365     int r;
1366     suppress_error = 0;
1367     r = guestfs_lvm_remove_all (g);
1368     if (r == -1)
1369       return -1;
1370   }
1371   {
1372     char device[] = "/dev/sda";
1373     device[5] = devchar;
1374     char lines_0[] = ",";
1375     char *lines[] = {
1376       lines_0,
1377       NULL
1378     };
1379     int r;
1380     suppress_error = 0;
1381     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1382     if (r == -1)
1383       return -1;
1384   }
1385   {
1386     char fstype[] = "ext2";
1387     char device[] = "/dev/sda1";
1388     device[5] = devchar;
1389     int r;
1390     suppress_error = 0;
1391     r = guestfs_mkfs (g, fstype, device);
1392     if (r == -1)
1393       return -1;
1394   }
1395   {
1396     char device[] = "/dev/sda1";
1397     device[5] = devchar;
1398     char mountpoint[] = "/";
1399     int r;
1400     suppress_error = 0;
1401     r = guestfs_mount (g, device, mountpoint);
1402     if (r == -1)
1403       return -1;
1404   }
1405   /* TestOutputList for strings (0) */
1406   {
1407     char path[] = "/new";
1408     char content[] = "hello\nworld\n";
1409     int r;
1410     suppress_error = 0;
1411     r = guestfs_write_file (g, path, content, 0);
1412     if (r == -1)
1413       return -1;
1414   }
1415   {
1416     char path[] = "/new";
1417     char **r;
1418     int i;
1419     suppress_error = 0;
1420     r = guestfs_strings (g, path);
1421     if (r == NULL)
1422       return -1;
1423     if (!r[0]) {
1424       fprintf (stderr, "test_strings_0: short list returned from command\n");
1425       print_strings (r);
1426       return -1;
1427     }
1428     {
1429       char expected[] = "hello";
1430       if (strcmp (r[0], expected) != 0) {
1431         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1432         return -1;
1433       }
1434     }
1435     if (!r[1]) {
1436       fprintf (stderr, "test_strings_0: short list returned from command\n");
1437       print_strings (r);
1438       return -1;
1439     }
1440     {
1441       char expected[] = "world";
1442       if (strcmp (r[1], expected) != 0) {
1443         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1444         return -1;
1445       }
1446     }
1447     if (r[2] != NULL) {
1448       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1449       print_strings (r);
1450       return -1;
1451     }
1452     for (i = 0; r[i] != NULL; ++i)
1453       free (r[i]);
1454     free (r);
1455   }
1456   return 0;
1457 }
1458
1459 static int test_strings_1_skip (void)
1460 {
1461   const char *str;
1462
1463   str = getenv ("SKIP_TEST_STRINGS_1");
1464   if (str && strcmp (str, "1") == 0) return 1;
1465   str = getenv ("SKIP_TEST_STRINGS");
1466   if (str && strcmp (str, "1") == 0) return 1;
1467   return 0;
1468 }
1469
1470 static int test_strings_1 (void)
1471 {
1472   if (test_strings_1_skip ()) {
1473     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1474     return 0;
1475   }
1476
1477   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1478   {
1479     char device[] = "/dev/sda";
1480     device[5] = devchar;
1481     int r;
1482     suppress_error = 0;
1483     r = guestfs_blockdev_setrw (g, device);
1484     if (r == -1)
1485       return -1;
1486   }
1487   {
1488     int r;
1489     suppress_error = 0;
1490     r = guestfs_umount_all (g);
1491     if (r == -1)
1492       return -1;
1493   }
1494   {
1495     int r;
1496     suppress_error = 0;
1497     r = guestfs_lvm_remove_all (g);
1498     if (r == -1)
1499       return -1;
1500   }
1501   {
1502     char device[] = "/dev/sda";
1503     device[5] = devchar;
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     device[5] = devchar;
1519     int r;
1520     suppress_error = 0;
1521     r = guestfs_mkfs (g, fstype, device);
1522     if (r == -1)
1523       return -1;
1524   }
1525   {
1526     char device[] = "/dev/sda1";
1527     device[5] = devchar;
1528     char mountpoint[] = "/";
1529     int r;
1530     suppress_error = 0;
1531     r = guestfs_mount (g, device, mountpoint);
1532     if (r == -1)
1533       return -1;
1534   }
1535   /* TestOutputList for strings (1) */
1536   {
1537     char path[] = "/new";
1538     int r;
1539     suppress_error = 0;
1540     r = guestfs_touch (g, path);
1541     if (r == -1)
1542       return -1;
1543   }
1544   {
1545     char path[] = "/new";
1546     char **r;
1547     int i;
1548     suppress_error = 0;
1549     r = guestfs_strings (g, path);
1550     if (r == NULL)
1551       return -1;
1552     if (r[0] != NULL) {
1553       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1554       print_strings (r);
1555       return -1;
1556     }
1557     for (i = 0; r[i] != NULL; ++i)
1558       free (r[i]);
1559     free (r);
1560   }
1561   return 0;
1562 }
1563
1564 static int test_equal_0_skip (void)
1565 {
1566   const char *str;
1567
1568   str = getenv ("SKIP_TEST_EQUAL_0");
1569   if (str && strcmp (str, "1") == 0) return 1;
1570   str = getenv ("SKIP_TEST_EQUAL");
1571   if (str && strcmp (str, "1") == 0) return 1;
1572   return 0;
1573 }
1574
1575 static int test_equal_0 (void)
1576 {
1577   if (test_equal_0_skip ()) {
1578     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1579     return 0;
1580   }
1581
1582   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1583   {
1584     char device[] = "/dev/sda";
1585     device[5] = devchar;
1586     int r;
1587     suppress_error = 0;
1588     r = guestfs_blockdev_setrw (g, device);
1589     if (r == -1)
1590       return -1;
1591   }
1592   {
1593     int r;
1594     suppress_error = 0;
1595     r = guestfs_umount_all (g);
1596     if (r == -1)
1597       return -1;
1598   }
1599   {
1600     int r;
1601     suppress_error = 0;
1602     r = guestfs_lvm_remove_all (g);
1603     if (r == -1)
1604       return -1;
1605   }
1606   {
1607     char device[] = "/dev/sda";
1608     device[5] = devchar;
1609     char lines_0[] = ",";
1610     char *lines[] = {
1611       lines_0,
1612       NULL
1613     };
1614     int r;
1615     suppress_error = 0;
1616     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1617     if (r == -1)
1618       return -1;
1619   }
1620   {
1621     char fstype[] = "ext2";
1622     char device[] = "/dev/sda1";
1623     device[5] = devchar;
1624     int r;
1625     suppress_error = 0;
1626     r = guestfs_mkfs (g, fstype, device);
1627     if (r == -1)
1628       return -1;
1629   }
1630   {
1631     char device[] = "/dev/sda1";
1632     device[5] = devchar;
1633     char mountpoint[] = "/";
1634     int r;
1635     suppress_error = 0;
1636     r = guestfs_mount (g, device, mountpoint);
1637     if (r == -1)
1638       return -1;
1639   }
1640   /* TestOutputTrue for equal (0) */
1641   {
1642     char path[] = "/file1";
1643     char content[] = "contents of a file";
1644     int r;
1645     suppress_error = 0;
1646     r = guestfs_write_file (g, path, content, 0);
1647     if (r == -1)
1648       return -1;
1649   }
1650   {
1651     char src[] = "/file1";
1652     char dest[] = "/file2";
1653     int r;
1654     suppress_error = 0;
1655     r = guestfs_cp (g, src, dest);
1656     if (r == -1)
1657       return -1;
1658   }
1659   {
1660     char file1[] = "/file1";
1661     char file2[] = "/file2";
1662     int r;
1663     suppress_error = 0;
1664     r = guestfs_equal (g, file1, file2);
1665     if (r == -1)
1666       return -1;
1667     if (!r) {
1668       fprintf (stderr, "test_equal_0: expected true, got false\n");
1669       return -1;
1670     }
1671   }
1672   return 0;
1673 }
1674
1675 static int test_equal_1_skip (void)
1676 {
1677   const char *str;
1678
1679   str = getenv ("SKIP_TEST_EQUAL_1");
1680   if (str && strcmp (str, "1") == 0) return 1;
1681   str = getenv ("SKIP_TEST_EQUAL");
1682   if (str && strcmp (str, "1") == 0) return 1;
1683   return 0;
1684 }
1685
1686 static int test_equal_1 (void)
1687 {
1688   if (test_equal_1_skip ()) {
1689     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1690     return 0;
1691   }
1692
1693   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1694   {
1695     char device[] = "/dev/sda";
1696     device[5] = devchar;
1697     int r;
1698     suppress_error = 0;
1699     r = guestfs_blockdev_setrw (g, device);
1700     if (r == -1)
1701       return -1;
1702   }
1703   {
1704     int r;
1705     suppress_error = 0;
1706     r = guestfs_umount_all (g);
1707     if (r == -1)
1708       return -1;
1709   }
1710   {
1711     int r;
1712     suppress_error = 0;
1713     r = guestfs_lvm_remove_all (g);
1714     if (r == -1)
1715       return -1;
1716   }
1717   {
1718     char device[] = "/dev/sda";
1719     device[5] = devchar;
1720     char lines_0[] = ",";
1721     char *lines[] = {
1722       lines_0,
1723       NULL
1724     };
1725     int r;
1726     suppress_error = 0;
1727     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1728     if (r == -1)
1729       return -1;
1730   }
1731   {
1732     char fstype[] = "ext2";
1733     char device[] = "/dev/sda1";
1734     device[5] = devchar;
1735     int r;
1736     suppress_error = 0;
1737     r = guestfs_mkfs (g, fstype, device);
1738     if (r == -1)
1739       return -1;
1740   }
1741   {
1742     char device[] = "/dev/sda1";
1743     device[5] = devchar;
1744     char mountpoint[] = "/";
1745     int r;
1746     suppress_error = 0;
1747     r = guestfs_mount (g, device, mountpoint);
1748     if (r == -1)
1749       return -1;
1750   }
1751   /* TestOutputFalse for equal (1) */
1752   {
1753     char path[] = "/file1";
1754     char content[] = "contents of a file";
1755     int r;
1756     suppress_error = 0;
1757     r = guestfs_write_file (g, path, content, 0);
1758     if (r == -1)
1759       return -1;
1760   }
1761   {
1762     char path[] = "/file2";
1763     char content[] = "contents of another file";
1764     int r;
1765     suppress_error = 0;
1766     r = guestfs_write_file (g, path, content, 0);
1767     if (r == -1)
1768       return -1;
1769   }
1770   {
1771     char file1[] = "/file1";
1772     char file2[] = "/file2";
1773     int r;
1774     suppress_error = 0;
1775     r = guestfs_equal (g, file1, file2);
1776     if (r == -1)
1777       return -1;
1778     if (r) {
1779       fprintf (stderr, "test_equal_1: expected false, got true\n");
1780       return -1;
1781     }
1782   }
1783   return 0;
1784 }
1785
1786 static int test_equal_2_skip (void)
1787 {
1788   const char *str;
1789
1790   str = getenv ("SKIP_TEST_EQUAL_2");
1791   if (str && strcmp (str, "1") == 0) return 1;
1792   str = getenv ("SKIP_TEST_EQUAL");
1793   if (str && strcmp (str, "1") == 0) return 1;
1794   return 0;
1795 }
1796
1797 static int test_equal_2 (void)
1798 {
1799   if (test_equal_2_skip ()) {
1800     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1801     return 0;
1802   }
1803
1804   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1805   {
1806     char device[] = "/dev/sda";
1807     device[5] = devchar;
1808     int r;
1809     suppress_error = 0;
1810     r = guestfs_blockdev_setrw (g, device);
1811     if (r == -1)
1812       return -1;
1813   }
1814   {
1815     int r;
1816     suppress_error = 0;
1817     r = guestfs_umount_all (g);
1818     if (r == -1)
1819       return -1;
1820   }
1821   {
1822     int r;
1823     suppress_error = 0;
1824     r = guestfs_lvm_remove_all (g);
1825     if (r == -1)
1826       return -1;
1827   }
1828   {
1829     char device[] = "/dev/sda";
1830     device[5] = devchar;
1831     char lines_0[] = ",";
1832     char *lines[] = {
1833       lines_0,
1834       NULL
1835     };
1836     int r;
1837     suppress_error = 0;
1838     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1839     if (r == -1)
1840       return -1;
1841   }
1842   {
1843     char fstype[] = "ext2";
1844     char device[] = "/dev/sda1";
1845     device[5] = devchar;
1846     int r;
1847     suppress_error = 0;
1848     r = guestfs_mkfs (g, fstype, device);
1849     if (r == -1)
1850       return -1;
1851   }
1852   {
1853     char device[] = "/dev/sda1";
1854     device[5] = devchar;
1855     char mountpoint[] = "/";
1856     int r;
1857     suppress_error = 0;
1858     r = guestfs_mount (g, device, mountpoint);
1859     if (r == -1)
1860       return -1;
1861   }
1862   /* TestLastFail for equal (2) */
1863   {
1864     char file1[] = "/file1";
1865     char file2[] = "/file2";
1866     int r;
1867     suppress_error = 1;
1868     r = guestfs_equal (g, file1, file2);
1869     if (r != -1)
1870       return -1;
1871   }
1872   return 0;
1873 }
1874
1875 static int test_ping_daemon_0_skip (void)
1876 {
1877   const char *str;
1878
1879   str = getenv ("SKIP_TEST_PING_DAEMON_0");
1880   if (str && strcmp (str, "1") == 0) return 1;
1881   str = getenv ("SKIP_TEST_PING_DAEMON");
1882   if (str && strcmp (str, "1") == 0) return 1;
1883   return 0;
1884 }
1885
1886 static int test_ping_daemon_0 (void)
1887 {
1888   if (test_ping_daemon_0_skip ()) {
1889     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1890     return 0;
1891   }
1892
1893   /* InitNone|InitEmpty for test_ping_daemon_0 */
1894   {
1895     char device[] = "/dev/sda";
1896     device[5] = devchar;
1897     int r;
1898     suppress_error = 0;
1899     r = guestfs_blockdev_setrw (g, device);
1900     if (r == -1)
1901       return -1;
1902   }
1903   {
1904     int r;
1905     suppress_error = 0;
1906     r = guestfs_umount_all (g);
1907     if (r == -1)
1908       return -1;
1909   }
1910   {
1911     int r;
1912     suppress_error = 0;
1913     r = guestfs_lvm_remove_all (g);
1914     if (r == -1)
1915       return -1;
1916   }
1917   /* TestRun for ping_daemon (0) */
1918   {
1919     int r;
1920     suppress_error = 0;
1921     r = guestfs_ping_daemon (g);
1922     if (r == -1)
1923       return -1;
1924   }
1925   return 0;
1926 }
1927
1928 static int test_dmesg_0_skip (void)
1929 {
1930   const char *str;
1931
1932   str = getenv ("SKIP_TEST_DMESG_0");
1933   if (str && strcmp (str, "1") == 0) return 1;
1934   str = getenv ("SKIP_TEST_DMESG");
1935   if (str && strcmp (str, "1") == 0) return 1;
1936   return 0;
1937 }
1938
1939 static int test_dmesg_0 (void)
1940 {
1941   if (test_dmesg_0_skip ()) {
1942     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1943     return 0;
1944   }
1945
1946   /* InitNone|InitEmpty for test_dmesg_0 */
1947   {
1948     char device[] = "/dev/sda";
1949     device[5] = devchar;
1950     int r;
1951     suppress_error = 0;
1952     r = guestfs_blockdev_setrw (g, device);
1953     if (r == -1)
1954       return -1;
1955   }
1956   {
1957     int r;
1958     suppress_error = 0;
1959     r = guestfs_umount_all (g);
1960     if (r == -1)
1961       return -1;
1962   }
1963   {
1964     int r;
1965     suppress_error = 0;
1966     r = guestfs_lvm_remove_all (g);
1967     if (r == -1)
1968       return -1;
1969   }
1970   /* TestRun for dmesg (0) */
1971   {
1972     char *r;
1973     suppress_error = 0;
1974     r = guestfs_dmesg (g);
1975     if (r == NULL)
1976       return -1;
1977     free (r);
1978   }
1979   return 0;
1980 }
1981
1982 static int test_drop_caches_0_skip (void)
1983 {
1984   const char *str;
1985
1986   str = getenv ("SKIP_TEST_DROP_CACHES_0");
1987   if (str && strcmp (str, "1") == 0) return 1;
1988   str = getenv ("SKIP_TEST_DROP_CACHES");
1989   if (str && strcmp (str, "1") == 0) return 1;
1990   return 0;
1991 }
1992
1993 static int test_drop_caches_0 (void)
1994 {
1995   if (test_drop_caches_0_skip ()) {
1996     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1997     return 0;
1998   }
1999
2000   /* InitNone|InitEmpty for test_drop_caches_0 */
2001   {
2002     char device[] = "/dev/sda";
2003     device[5] = devchar;
2004     int r;
2005     suppress_error = 0;
2006     r = guestfs_blockdev_setrw (g, device);
2007     if (r == -1)
2008       return -1;
2009   }
2010   {
2011     int r;
2012     suppress_error = 0;
2013     r = guestfs_umount_all (g);
2014     if (r == -1)
2015       return -1;
2016   }
2017   {
2018     int r;
2019     suppress_error = 0;
2020     r = guestfs_lvm_remove_all (g);
2021     if (r == -1)
2022       return -1;
2023   }
2024   /* TestRun for drop_caches (0) */
2025   {
2026     int r;
2027     suppress_error = 0;
2028     r = guestfs_drop_caches (g, 3);
2029     if (r == -1)
2030       return -1;
2031   }
2032   return 0;
2033 }
2034
2035 static int test_mv_0_skip (void)
2036 {
2037   const char *str;
2038
2039   str = getenv ("SKIP_TEST_MV_0");
2040   if (str && strcmp (str, "1") == 0) return 1;
2041   str = getenv ("SKIP_TEST_MV");
2042   if (str && strcmp (str, "1") == 0) return 1;
2043   return 0;
2044 }
2045
2046 static int test_mv_0 (void)
2047 {
2048   if (test_mv_0_skip ()) {
2049     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2050     return 0;
2051   }
2052
2053   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2054   {
2055     char device[] = "/dev/sda";
2056     device[5] = devchar;
2057     int r;
2058     suppress_error = 0;
2059     r = guestfs_blockdev_setrw (g, device);
2060     if (r == -1)
2061       return -1;
2062   }
2063   {
2064     int r;
2065     suppress_error = 0;
2066     r = guestfs_umount_all (g);
2067     if (r == -1)
2068       return -1;
2069   }
2070   {
2071     int r;
2072     suppress_error = 0;
2073     r = guestfs_lvm_remove_all (g);
2074     if (r == -1)
2075       return -1;
2076   }
2077   {
2078     char device[] = "/dev/sda";
2079     device[5] = devchar;
2080     char lines_0[] = ",";
2081     char *lines[] = {
2082       lines_0,
2083       NULL
2084     };
2085     int r;
2086     suppress_error = 0;
2087     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2088     if (r == -1)
2089       return -1;
2090   }
2091   {
2092     char fstype[] = "ext2";
2093     char device[] = "/dev/sda1";
2094     device[5] = devchar;
2095     int r;
2096     suppress_error = 0;
2097     r = guestfs_mkfs (g, fstype, device);
2098     if (r == -1)
2099       return -1;
2100   }
2101   {
2102     char device[] = "/dev/sda1";
2103     device[5] = devchar;
2104     char mountpoint[] = "/";
2105     int r;
2106     suppress_error = 0;
2107     r = guestfs_mount (g, device, mountpoint);
2108     if (r == -1)
2109       return -1;
2110   }
2111   /* TestOutput for mv (0) */
2112   char expected[] = "file content";
2113   {
2114     char path[] = "/old";
2115     char content[] = "file content";
2116     int r;
2117     suppress_error = 0;
2118     r = guestfs_write_file (g, path, content, 0);
2119     if (r == -1)
2120       return -1;
2121   }
2122   {
2123     char src[] = "/old";
2124     char dest[] = "/new";
2125     int r;
2126     suppress_error = 0;
2127     r = guestfs_mv (g, src, dest);
2128     if (r == -1)
2129       return -1;
2130   }
2131   {
2132     char path[] = "/new";
2133     char *r;
2134     suppress_error = 0;
2135     r = guestfs_cat (g, path);
2136     if (r == NULL)
2137       return -1;
2138     if (strcmp (r, expected) != 0) {
2139       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2140       return -1;
2141     }
2142     free (r);
2143   }
2144   return 0;
2145 }
2146
2147 static int test_mv_1_skip (void)
2148 {
2149   const char *str;
2150
2151   str = getenv ("SKIP_TEST_MV_1");
2152   if (str && strcmp (str, "1") == 0) return 1;
2153   str = getenv ("SKIP_TEST_MV");
2154   if (str && strcmp (str, "1") == 0) return 1;
2155   return 0;
2156 }
2157
2158 static int test_mv_1 (void)
2159 {
2160   if (test_mv_1_skip ()) {
2161     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2162     return 0;
2163   }
2164
2165   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2166   {
2167     char device[] = "/dev/sda";
2168     device[5] = devchar;
2169     int r;
2170     suppress_error = 0;
2171     r = guestfs_blockdev_setrw (g, device);
2172     if (r == -1)
2173       return -1;
2174   }
2175   {
2176     int r;
2177     suppress_error = 0;
2178     r = guestfs_umount_all (g);
2179     if (r == -1)
2180       return -1;
2181   }
2182   {
2183     int r;
2184     suppress_error = 0;
2185     r = guestfs_lvm_remove_all (g);
2186     if (r == -1)
2187       return -1;
2188   }
2189   {
2190     char device[] = "/dev/sda";
2191     device[5] = devchar;
2192     char lines_0[] = ",";
2193     char *lines[] = {
2194       lines_0,
2195       NULL
2196     };
2197     int r;
2198     suppress_error = 0;
2199     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2200     if (r == -1)
2201       return -1;
2202   }
2203   {
2204     char fstype[] = "ext2";
2205     char device[] = "/dev/sda1";
2206     device[5] = devchar;
2207     int r;
2208     suppress_error = 0;
2209     r = guestfs_mkfs (g, fstype, device);
2210     if (r == -1)
2211       return -1;
2212   }
2213   {
2214     char device[] = "/dev/sda1";
2215     device[5] = devchar;
2216     char mountpoint[] = "/";
2217     int r;
2218     suppress_error = 0;
2219     r = guestfs_mount (g, device, mountpoint);
2220     if (r == -1)
2221       return -1;
2222   }
2223   /* TestOutputFalse for mv (1) */
2224   {
2225     char path[] = "/old";
2226     char content[] = "file content";
2227     int r;
2228     suppress_error = 0;
2229     r = guestfs_write_file (g, path, content, 0);
2230     if (r == -1)
2231       return -1;
2232   }
2233   {
2234     char src[] = "/old";
2235     char dest[] = "/new";
2236     int r;
2237     suppress_error = 0;
2238     r = guestfs_mv (g, src, dest);
2239     if (r == -1)
2240       return -1;
2241   }
2242   {
2243     char path[] = "/old";
2244     int r;
2245     suppress_error = 0;
2246     r = guestfs_is_file (g, path);
2247     if (r == -1)
2248       return -1;
2249     if (r) {
2250       fprintf (stderr, "test_mv_1: expected false, got true\n");
2251       return -1;
2252     }
2253   }
2254   return 0;
2255 }
2256
2257 static int test_cp_a_0_skip (void)
2258 {
2259   const char *str;
2260
2261   str = getenv ("SKIP_TEST_CP_A_0");
2262   if (str && strcmp (str, "1") == 0) return 1;
2263   str = getenv ("SKIP_TEST_CP_A");
2264   if (str && strcmp (str, "1") == 0) return 1;
2265   return 0;
2266 }
2267
2268 static int test_cp_a_0 (void)
2269 {
2270   if (test_cp_a_0_skip ()) {
2271     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2272     return 0;
2273   }
2274
2275   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2276   {
2277     char device[] = "/dev/sda";
2278     device[5] = devchar;
2279     int r;
2280     suppress_error = 0;
2281     r = guestfs_blockdev_setrw (g, device);
2282     if (r == -1)
2283       return -1;
2284   }
2285   {
2286     int r;
2287     suppress_error = 0;
2288     r = guestfs_umount_all (g);
2289     if (r == -1)
2290       return -1;
2291   }
2292   {
2293     int r;
2294     suppress_error = 0;
2295     r = guestfs_lvm_remove_all (g);
2296     if (r == -1)
2297       return -1;
2298   }
2299   {
2300     char device[] = "/dev/sda";
2301     device[5] = devchar;
2302     char lines_0[] = ",";
2303     char *lines[] = {
2304       lines_0,
2305       NULL
2306     };
2307     int r;
2308     suppress_error = 0;
2309     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2310     if (r == -1)
2311       return -1;
2312   }
2313   {
2314     char fstype[] = "ext2";
2315     char device[] = "/dev/sda1";
2316     device[5] = devchar;
2317     int r;
2318     suppress_error = 0;
2319     r = guestfs_mkfs (g, fstype, device);
2320     if (r == -1)
2321       return -1;
2322   }
2323   {
2324     char device[] = "/dev/sda1";
2325     device[5] = devchar;
2326     char mountpoint[] = "/";
2327     int r;
2328     suppress_error = 0;
2329     r = guestfs_mount (g, device, mountpoint);
2330     if (r == -1)
2331       return -1;
2332   }
2333   /* TestOutput for cp_a (0) */
2334   char expected[] = "file content";
2335   {
2336     char path[] = "/olddir";
2337     int r;
2338     suppress_error = 0;
2339     r = guestfs_mkdir (g, path);
2340     if (r == -1)
2341       return -1;
2342   }
2343   {
2344     char path[] = "/newdir";
2345     int r;
2346     suppress_error = 0;
2347     r = guestfs_mkdir (g, path);
2348     if (r == -1)
2349       return -1;
2350   }
2351   {
2352     char path[] = "/olddir/file";
2353     char content[] = "file content";
2354     int r;
2355     suppress_error = 0;
2356     r = guestfs_write_file (g, path, content, 0);
2357     if (r == -1)
2358       return -1;
2359   }
2360   {
2361     char src[] = "/olddir";
2362     char dest[] = "/newdir";
2363     int r;
2364     suppress_error = 0;
2365     r = guestfs_cp_a (g, src, dest);
2366     if (r == -1)
2367       return -1;
2368   }
2369   {
2370     char path[] = "/newdir/olddir/file";
2371     char *r;
2372     suppress_error = 0;
2373     r = guestfs_cat (g, path);
2374     if (r == NULL)
2375       return -1;
2376     if (strcmp (r, expected) != 0) {
2377       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2378       return -1;
2379     }
2380     free (r);
2381   }
2382   return 0;
2383 }
2384
2385 static int test_cp_0_skip (void)
2386 {
2387   const char *str;
2388
2389   str = getenv ("SKIP_TEST_CP_0");
2390   if (str && strcmp (str, "1") == 0) return 1;
2391   str = getenv ("SKIP_TEST_CP");
2392   if (str && strcmp (str, "1") == 0) return 1;
2393   return 0;
2394 }
2395
2396 static int test_cp_0 (void)
2397 {
2398   if (test_cp_0_skip ()) {
2399     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2400     return 0;
2401   }
2402
2403   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2404   {
2405     char device[] = "/dev/sda";
2406     device[5] = devchar;
2407     int r;
2408     suppress_error = 0;
2409     r = guestfs_blockdev_setrw (g, device);
2410     if (r == -1)
2411       return -1;
2412   }
2413   {
2414     int r;
2415     suppress_error = 0;
2416     r = guestfs_umount_all (g);
2417     if (r == -1)
2418       return -1;
2419   }
2420   {
2421     int r;
2422     suppress_error = 0;
2423     r = guestfs_lvm_remove_all (g);
2424     if (r == -1)
2425       return -1;
2426   }
2427   {
2428     char device[] = "/dev/sda";
2429     device[5] = devchar;
2430     char lines_0[] = ",";
2431     char *lines[] = {
2432       lines_0,
2433       NULL
2434     };
2435     int r;
2436     suppress_error = 0;
2437     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2438     if (r == -1)
2439       return -1;
2440   }
2441   {
2442     char fstype[] = "ext2";
2443     char device[] = "/dev/sda1";
2444     device[5] = devchar;
2445     int r;
2446     suppress_error = 0;
2447     r = guestfs_mkfs (g, fstype, device);
2448     if (r == -1)
2449       return -1;
2450   }
2451   {
2452     char device[] = "/dev/sda1";
2453     device[5] = devchar;
2454     char mountpoint[] = "/";
2455     int r;
2456     suppress_error = 0;
2457     r = guestfs_mount (g, device, mountpoint);
2458     if (r == -1)
2459       return -1;
2460   }
2461   /* TestOutput for cp (0) */
2462   char expected[] = "file content";
2463   {
2464     char path[] = "/old";
2465     char content[] = "file content";
2466     int r;
2467     suppress_error = 0;
2468     r = guestfs_write_file (g, path, content, 0);
2469     if (r == -1)
2470       return -1;
2471   }
2472   {
2473     char src[] = "/old";
2474     char dest[] = "/new";
2475     int r;
2476     suppress_error = 0;
2477     r = guestfs_cp (g, src, dest);
2478     if (r == -1)
2479       return -1;
2480   }
2481   {
2482     char path[] = "/new";
2483     char *r;
2484     suppress_error = 0;
2485     r = guestfs_cat (g, path);
2486     if (r == NULL)
2487       return -1;
2488     if (strcmp (r, expected) != 0) {
2489       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2490       return -1;
2491     }
2492     free (r);
2493   }
2494   return 0;
2495 }
2496
2497 static int test_cp_1_skip (void)
2498 {
2499   const char *str;
2500
2501   str = getenv ("SKIP_TEST_CP_1");
2502   if (str && strcmp (str, "1") == 0) return 1;
2503   str = getenv ("SKIP_TEST_CP");
2504   if (str && strcmp (str, "1") == 0) return 1;
2505   return 0;
2506 }
2507
2508 static int test_cp_1 (void)
2509 {
2510   if (test_cp_1_skip ()) {
2511     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2512     return 0;
2513   }
2514
2515   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2516   {
2517     char device[] = "/dev/sda";
2518     device[5] = devchar;
2519     int r;
2520     suppress_error = 0;
2521     r = guestfs_blockdev_setrw (g, device);
2522     if (r == -1)
2523       return -1;
2524   }
2525   {
2526     int r;
2527     suppress_error = 0;
2528     r = guestfs_umount_all (g);
2529     if (r == -1)
2530       return -1;
2531   }
2532   {
2533     int r;
2534     suppress_error = 0;
2535     r = guestfs_lvm_remove_all (g);
2536     if (r == -1)
2537       return -1;
2538   }
2539   {
2540     char device[] = "/dev/sda";
2541     device[5] = devchar;
2542     char lines_0[] = ",";
2543     char *lines[] = {
2544       lines_0,
2545       NULL
2546     };
2547     int r;
2548     suppress_error = 0;
2549     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2550     if (r == -1)
2551       return -1;
2552   }
2553   {
2554     char fstype[] = "ext2";
2555     char device[] = "/dev/sda1";
2556     device[5] = devchar;
2557     int r;
2558     suppress_error = 0;
2559     r = guestfs_mkfs (g, fstype, device);
2560     if (r == -1)
2561       return -1;
2562   }
2563   {
2564     char device[] = "/dev/sda1";
2565     device[5] = devchar;
2566     char mountpoint[] = "/";
2567     int r;
2568     suppress_error = 0;
2569     r = guestfs_mount (g, device, mountpoint);
2570     if (r == -1)
2571       return -1;
2572   }
2573   /* TestOutputTrue for cp (1) */
2574   {
2575     char path[] = "/old";
2576     char content[] = "file content";
2577     int r;
2578     suppress_error = 0;
2579     r = guestfs_write_file (g, path, content, 0);
2580     if (r == -1)
2581       return -1;
2582   }
2583   {
2584     char src[] = "/old";
2585     char dest[] = "/new";
2586     int r;
2587     suppress_error = 0;
2588     r = guestfs_cp (g, src, dest);
2589     if (r == -1)
2590       return -1;
2591   }
2592   {
2593     char path[] = "/old";
2594     int r;
2595     suppress_error = 0;
2596     r = guestfs_is_file (g, path);
2597     if (r == -1)
2598       return -1;
2599     if (!r) {
2600       fprintf (stderr, "test_cp_1: expected true, got false\n");
2601       return -1;
2602     }
2603   }
2604   return 0;
2605 }
2606
2607 static int test_cp_2_skip (void)
2608 {
2609   const char *str;
2610
2611   str = getenv ("SKIP_TEST_CP_2");
2612   if (str && strcmp (str, "1") == 0) return 1;
2613   str = getenv ("SKIP_TEST_CP");
2614   if (str && strcmp (str, "1") == 0) return 1;
2615   return 0;
2616 }
2617
2618 static int test_cp_2 (void)
2619 {
2620   if (test_cp_2_skip ()) {
2621     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2622     return 0;
2623   }
2624
2625   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2626   {
2627     char device[] = "/dev/sda";
2628     device[5] = devchar;
2629     int r;
2630     suppress_error = 0;
2631     r = guestfs_blockdev_setrw (g, device);
2632     if (r == -1)
2633       return -1;
2634   }
2635   {
2636     int r;
2637     suppress_error = 0;
2638     r = guestfs_umount_all (g);
2639     if (r == -1)
2640       return -1;
2641   }
2642   {
2643     int r;
2644     suppress_error = 0;
2645     r = guestfs_lvm_remove_all (g);
2646     if (r == -1)
2647       return -1;
2648   }
2649   {
2650     char device[] = "/dev/sda";
2651     device[5] = devchar;
2652     char lines_0[] = ",";
2653     char *lines[] = {
2654       lines_0,
2655       NULL
2656     };
2657     int r;
2658     suppress_error = 0;
2659     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2660     if (r == -1)
2661       return -1;
2662   }
2663   {
2664     char fstype[] = "ext2";
2665     char device[] = "/dev/sda1";
2666     device[5] = devchar;
2667     int r;
2668     suppress_error = 0;
2669     r = guestfs_mkfs (g, fstype, device);
2670     if (r == -1)
2671       return -1;
2672   }
2673   {
2674     char device[] = "/dev/sda1";
2675     device[5] = devchar;
2676     char mountpoint[] = "/";
2677     int r;
2678     suppress_error = 0;
2679     r = guestfs_mount (g, device, mountpoint);
2680     if (r == -1)
2681       return -1;
2682   }
2683   /* TestOutput for cp (2) */
2684   char expected[] = "file content";
2685   {
2686     char path[] = "/old";
2687     char content[] = "file content";
2688     int r;
2689     suppress_error = 0;
2690     r = guestfs_write_file (g, path, content, 0);
2691     if (r == -1)
2692       return -1;
2693   }
2694   {
2695     char path[] = "/dir";
2696     int r;
2697     suppress_error = 0;
2698     r = guestfs_mkdir (g, path);
2699     if (r == -1)
2700       return -1;
2701   }
2702   {
2703     char src[] = "/old";
2704     char dest[] = "/dir/new";
2705     int r;
2706     suppress_error = 0;
2707     r = guestfs_cp (g, src, dest);
2708     if (r == -1)
2709       return -1;
2710   }
2711   {
2712     char path[] = "/dir/new";
2713     char *r;
2714     suppress_error = 0;
2715     r = guestfs_cat (g, path);
2716     if (r == NULL)
2717       return -1;
2718     if (strcmp (r, expected) != 0) {
2719       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2720       return -1;
2721     }
2722     free (r);
2723   }
2724   return 0;
2725 }
2726
2727 static int test_grub_install_0_skip (void)
2728 {
2729   const char *str;
2730
2731   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2732   if (str && strcmp (str, "1") == 0) return 1;
2733   str = getenv ("SKIP_TEST_GRUB_INSTALL");
2734   if (str && strcmp (str, "1") == 0) return 1;
2735   return 0;
2736 }
2737
2738 static int test_grub_install_0 (void)
2739 {
2740   if (test_grub_install_0_skip ()) {
2741     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2742     return 0;
2743   }
2744
2745   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2746   {
2747     char device[] = "/dev/sda";
2748     device[5] = devchar;
2749     int r;
2750     suppress_error = 0;
2751     r = guestfs_blockdev_setrw (g, device);
2752     if (r == -1)
2753       return -1;
2754   }
2755   {
2756     int r;
2757     suppress_error = 0;
2758     r = guestfs_umount_all (g);
2759     if (r == -1)
2760       return -1;
2761   }
2762   {
2763     int r;
2764     suppress_error = 0;
2765     r = guestfs_lvm_remove_all (g);
2766     if (r == -1)
2767       return -1;
2768   }
2769   {
2770     char device[] = "/dev/sda";
2771     device[5] = devchar;
2772     char lines_0[] = ",";
2773     char *lines[] = {
2774       lines_0,
2775       NULL
2776     };
2777     int r;
2778     suppress_error = 0;
2779     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2780     if (r == -1)
2781       return -1;
2782   }
2783   {
2784     char fstype[] = "ext2";
2785     char device[] = "/dev/sda1";
2786     device[5] = devchar;
2787     int r;
2788     suppress_error = 0;
2789     r = guestfs_mkfs (g, fstype, device);
2790     if (r == -1)
2791       return -1;
2792   }
2793   {
2794     char device[] = "/dev/sda1";
2795     device[5] = devchar;
2796     char mountpoint[] = "/";
2797     int r;
2798     suppress_error = 0;
2799     r = guestfs_mount (g, device, mountpoint);
2800     if (r == -1)
2801       return -1;
2802   }
2803   /* TestOutputTrue for grub_install (0) */
2804   {
2805     char root[] = "/";
2806     char device[] = "/dev/sda1";
2807     device[5] = devchar;
2808     int r;
2809     suppress_error = 0;
2810     r = guestfs_grub_install (g, root, device);
2811     if (r == -1)
2812       return -1;
2813   }
2814   {
2815     char path[] = "/boot";
2816     int r;
2817     suppress_error = 0;
2818     r = guestfs_is_dir (g, path);
2819     if (r == -1)
2820       return -1;
2821     if (!r) {
2822       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2823       return -1;
2824     }
2825   }
2826   return 0;
2827 }
2828
2829 static int test_zero_0_skip (void)
2830 {
2831   const char *str;
2832
2833   str = getenv ("SKIP_TEST_ZERO_0");
2834   if (str && strcmp (str, "1") == 0) return 1;
2835   str = getenv ("SKIP_TEST_ZERO");
2836   if (str && strcmp (str, "1") == 0) return 1;
2837   return 0;
2838 }
2839
2840 static int test_zero_0 (void)
2841 {
2842   if (test_zero_0_skip ()) {
2843     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2844     return 0;
2845   }
2846
2847   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2848   {
2849     char device[] = "/dev/sda";
2850     device[5] = devchar;
2851     int r;
2852     suppress_error = 0;
2853     r = guestfs_blockdev_setrw (g, device);
2854     if (r == -1)
2855       return -1;
2856   }
2857   {
2858     int r;
2859     suppress_error = 0;
2860     r = guestfs_umount_all (g);
2861     if (r == -1)
2862       return -1;
2863   }
2864   {
2865     int r;
2866     suppress_error = 0;
2867     r = guestfs_lvm_remove_all (g);
2868     if (r == -1)
2869       return -1;
2870   }
2871   {
2872     char device[] = "/dev/sda";
2873     device[5] = devchar;
2874     char lines_0[] = ",";
2875     char *lines[] = {
2876       lines_0,
2877       NULL
2878     };
2879     int r;
2880     suppress_error = 0;
2881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2882     if (r == -1)
2883       return -1;
2884   }
2885   {
2886     char fstype[] = "ext2";
2887     char device[] = "/dev/sda1";
2888     device[5] = devchar;
2889     int r;
2890     suppress_error = 0;
2891     r = guestfs_mkfs (g, fstype, device);
2892     if (r == -1)
2893       return -1;
2894   }
2895   {
2896     char device[] = "/dev/sda1";
2897     device[5] = devchar;
2898     char mountpoint[] = "/";
2899     int r;
2900     suppress_error = 0;
2901     r = guestfs_mount (g, device, mountpoint);
2902     if (r == -1)
2903       return -1;
2904   }
2905   /* TestOutput for zero (0) */
2906   char expected[] = "data";
2907   {
2908     char pathordevice[] = "/dev/sda1";
2909     pathordevice[5] = devchar;
2910     int r;
2911     suppress_error = 0;
2912     r = guestfs_umount (g, pathordevice);
2913     if (r == -1)
2914       return -1;
2915   }
2916   {
2917     char device[] = "/dev/sda1";
2918     device[5] = devchar;
2919     int r;
2920     suppress_error = 0;
2921     r = guestfs_zero (g, device);
2922     if (r == -1)
2923       return -1;
2924   }
2925   {
2926     char path[] = "/dev/sda1";
2927     path[5] = devchar;
2928     char *r;
2929     suppress_error = 0;
2930     r = guestfs_file (g, path);
2931     if (r == NULL)
2932       return -1;
2933     if (strcmp (r, expected) != 0) {
2934       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2935       return -1;
2936     }
2937     free (r);
2938   }
2939   return 0;
2940 }
2941
2942 static int test_fsck_0_skip (void)
2943 {
2944   const char *str;
2945
2946   str = getenv ("SKIP_TEST_FSCK_0");
2947   if (str && strcmp (str, "1") == 0) return 1;
2948   str = getenv ("SKIP_TEST_FSCK");
2949   if (str && strcmp (str, "1") == 0) return 1;
2950   return 0;
2951 }
2952
2953 static int test_fsck_0 (void)
2954 {
2955   if (test_fsck_0_skip ()) {
2956     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2957     return 0;
2958   }
2959
2960   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2961   {
2962     char device[] = "/dev/sda";
2963     device[5] = devchar;
2964     int r;
2965     suppress_error = 0;
2966     r = guestfs_blockdev_setrw (g, device);
2967     if (r == -1)
2968       return -1;
2969   }
2970   {
2971     int r;
2972     suppress_error = 0;
2973     r = guestfs_umount_all (g);
2974     if (r == -1)
2975       return -1;
2976   }
2977   {
2978     int r;
2979     suppress_error = 0;
2980     r = guestfs_lvm_remove_all (g);
2981     if (r == -1)
2982       return -1;
2983   }
2984   {
2985     char device[] = "/dev/sda";
2986     device[5] = devchar;
2987     char lines_0[] = ",";
2988     char *lines[] = {
2989       lines_0,
2990       NULL
2991     };
2992     int r;
2993     suppress_error = 0;
2994     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2995     if (r == -1)
2996       return -1;
2997   }
2998   {
2999     char fstype[] = "ext2";
3000     char device[] = "/dev/sda1";
3001     device[5] = devchar;
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_mkfs (g, fstype, device);
3005     if (r == -1)
3006       return -1;
3007   }
3008   {
3009     char device[] = "/dev/sda1";
3010     device[5] = devchar;
3011     char mountpoint[] = "/";
3012     int r;
3013     suppress_error = 0;
3014     r = guestfs_mount (g, device, mountpoint);
3015     if (r == -1)
3016       return -1;
3017   }
3018   /* TestOutputInt for fsck (0) */
3019   {
3020     char pathordevice[] = "/dev/sda1";
3021     pathordevice[5] = devchar;
3022     int r;
3023     suppress_error = 0;
3024     r = guestfs_umount (g, pathordevice);
3025     if (r == -1)
3026       return -1;
3027   }
3028   {
3029     char fstype[] = "ext2";
3030     char device[] = "/dev/sda1";
3031     device[5] = devchar;
3032     int r;
3033     suppress_error = 0;
3034     r = guestfs_fsck (g, fstype, device);
3035     if (r == -1)
3036       return -1;
3037     if (r != 0) {
3038       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
3039       return -1;
3040     }
3041   }
3042   return 0;
3043 }
3044
3045 static int test_fsck_1_skip (void)
3046 {
3047   const char *str;
3048
3049   str = getenv ("SKIP_TEST_FSCK_1");
3050   if (str && strcmp (str, "1") == 0) return 1;
3051   str = getenv ("SKIP_TEST_FSCK");
3052   if (str && strcmp (str, "1") == 0) return 1;
3053   return 0;
3054 }
3055
3056 static int test_fsck_1 (void)
3057 {
3058   if (test_fsck_1_skip ()) {
3059     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3060     return 0;
3061   }
3062
3063   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3064   {
3065     char device[] = "/dev/sda";
3066     device[5] = devchar;
3067     int r;
3068     suppress_error = 0;
3069     r = guestfs_blockdev_setrw (g, device);
3070     if (r == -1)
3071       return -1;
3072   }
3073   {
3074     int r;
3075     suppress_error = 0;
3076     r = guestfs_umount_all (g);
3077     if (r == -1)
3078       return -1;
3079   }
3080   {
3081     int r;
3082     suppress_error = 0;
3083     r = guestfs_lvm_remove_all (g);
3084     if (r == -1)
3085       return -1;
3086   }
3087   {
3088     char device[] = "/dev/sda";
3089     device[5] = devchar;
3090     char lines_0[] = ",";
3091     char *lines[] = {
3092       lines_0,
3093       NULL
3094     };
3095     int r;
3096     suppress_error = 0;
3097     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3098     if (r == -1)
3099       return -1;
3100   }
3101   {
3102     char fstype[] = "ext2";
3103     char device[] = "/dev/sda1";
3104     device[5] = devchar;
3105     int r;
3106     suppress_error = 0;
3107     r = guestfs_mkfs (g, fstype, device);
3108     if (r == -1)
3109       return -1;
3110   }
3111   {
3112     char device[] = "/dev/sda1";
3113     device[5] = devchar;
3114     char mountpoint[] = "/";
3115     int r;
3116     suppress_error = 0;
3117     r = guestfs_mount (g, device, mountpoint);
3118     if (r == -1)
3119       return -1;
3120   }
3121   /* TestOutputInt for fsck (1) */
3122   {
3123     char pathordevice[] = "/dev/sda1";
3124     pathordevice[5] = devchar;
3125     int r;
3126     suppress_error = 0;
3127     r = guestfs_umount (g, pathordevice);
3128     if (r == -1)
3129       return -1;
3130   }
3131   {
3132     char device[] = "/dev/sda1";
3133     device[5] = devchar;
3134     int r;
3135     suppress_error = 0;
3136     r = guestfs_zero (g, device);
3137     if (r == -1)
3138       return -1;
3139   }
3140   {
3141     char fstype[] = "ext2";
3142     char device[] = "/dev/sda1";
3143     device[5] = devchar;
3144     int r;
3145     suppress_error = 0;
3146     r = guestfs_fsck (g, fstype, device);
3147     if (r == -1)
3148       return -1;
3149     if (r != 8) {
3150       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
3151       return -1;
3152     }
3153   }
3154   return 0;
3155 }
3156
3157 static int test_set_e2uuid_0_skip (void)
3158 {
3159   const char *str;
3160
3161   str = getenv ("SKIP_TEST_SET_E2UUID_0");
3162   if (str && strcmp (str, "1") == 0) return 1;
3163   str = getenv ("SKIP_TEST_SET_E2UUID");
3164   if (str && strcmp (str, "1") == 0) return 1;
3165   return 0;
3166 }
3167
3168 static int test_set_e2uuid_0 (void)
3169 {
3170   if (test_set_e2uuid_0_skip ()) {
3171     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3172     return 0;
3173   }
3174
3175   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3176   {
3177     char device[] = "/dev/sda";
3178     device[5] = devchar;
3179     int r;
3180     suppress_error = 0;
3181     r = guestfs_blockdev_setrw (g, device);
3182     if (r == -1)
3183       return -1;
3184   }
3185   {
3186     int r;
3187     suppress_error = 0;
3188     r = guestfs_umount_all (g);
3189     if (r == -1)
3190       return -1;
3191   }
3192   {
3193     int r;
3194     suppress_error = 0;
3195     r = guestfs_lvm_remove_all (g);
3196     if (r == -1)
3197       return -1;
3198   }
3199   {
3200     char device[] = "/dev/sda";
3201     device[5] = devchar;
3202     char lines_0[] = ",";
3203     char *lines[] = {
3204       lines_0,
3205       NULL
3206     };
3207     int r;
3208     suppress_error = 0;
3209     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3210     if (r == -1)
3211       return -1;
3212   }
3213   {
3214     char fstype[] = "ext2";
3215     char device[] = "/dev/sda1";
3216     device[5] = devchar;
3217     int r;
3218     suppress_error = 0;
3219     r = guestfs_mkfs (g, fstype, device);
3220     if (r == -1)
3221       return -1;
3222   }
3223   {
3224     char device[] = "/dev/sda1";
3225     device[5] = devchar;
3226     char mountpoint[] = "/";
3227     int r;
3228     suppress_error = 0;
3229     r = guestfs_mount (g, device, mountpoint);
3230     if (r == -1)
3231       return -1;
3232   }
3233   /* TestOutput for set_e2uuid (0) */
3234   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3235   {
3236     char device[] = "/dev/sda1";
3237     device[5] = devchar;
3238     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3239     int r;
3240     suppress_error = 0;
3241     r = guestfs_set_e2uuid (g, device, uuid);
3242     if (r == -1)
3243       return -1;
3244   }
3245   {
3246     char device[] = "/dev/sda1";
3247     device[5] = devchar;
3248     char *r;
3249     suppress_error = 0;
3250     r = guestfs_get_e2uuid (g, device);
3251     if (r == NULL)
3252       return -1;
3253     if (strcmp (r, expected) != 0) {
3254       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3255       return -1;
3256     }
3257     free (r);
3258   }
3259   return 0;
3260 }
3261
3262 static int test_set_e2uuid_1_skip (void)
3263 {
3264   const char *str;
3265
3266   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3267   if (str && strcmp (str, "1") == 0) return 1;
3268   str = getenv ("SKIP_TEST_SET_E2UUID");
3269   if (str && strcmp (str, "1") == 0) return 1;
3270   return 0;
3271 }
3272
3273 static int test_set_e2uuid_1 (void)
3274 {
3275   if (test_set_e2uuid_1_skip ()) {
3276     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3277     return 0;
3278   }
3279
3280   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3281   {
3282     char device[] = "/dev/sda";
3283     device[5] = devchar;
3284     int r;
3285     suppress_error = 0;
3286     r = guestfs_blockdev_setrw (g, device);
3287     if (r == -1)
3288       return -1;
3289   }
3290   {
3291     int r;
3292     suppress_error = 0;
3293     r = guestfs_umount_all (g);
3294     if (r == -1)
3295       return -1;
3296   }
3297   {
3298     int r;
3299     suppress_error = 0;
3300     r = guestfs_lvm_remove_all (g);
3301     if (r == -1)
3302       return -1;
3303   }
3304   {
3305     char device[] = "/dev/sda";
3306     device[5] = devchar;
3307     char lines_0[] = ",";
3308     char *lines[] = {
3309       lines_0,
3310       NULL
3311     };
3312     int r;
3313     suppress_error = 0;
3314     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3315     if (r == -1)
3316       return -1;
3317   }
3318   {
3319     char fstype[] = "ext2";
3320     char device[] = "/dev/sda1";
3321     device[5] = devchar;
3322     int r;
3323     suppress_error = 0;
3324     r = guestfs_mkfs (g, fstype, device);
3325     if (r == -1)
3326       return -1;
3327   }
3328   {
3329     char device[] = "/dev/sda1";
3330     device[5] = devchar;
3331     char mountpoint[] = "/";
3332     int r;
3333     suppress_error = 0;
3334     r = guestfs_mount (g, device, mountpoint);
3335     if (r == -1)
3336       return -1;
3337   }
3338   /* TestOutput for set_e2uuid (1) */
3339   char expected[] = "";
3340   {
3341     char device[] = "/dev/sda1";
3342     device[5] = devchar;
3343     char uuid[] = "clear";
3344     int r;
3345     suppress_error = 0;
3346     r = guestfs_set_e2uuid (g, device, uuid);
3347     if (r == -1)
3348       return -1;
3349   }
3350   {
3351     char device[] = "/dev/sda1";
3352     device[5] = devchar;
3353     char *r;
3354     suppress_error = 0;
3355     r = guestfs_get_e2uuid (g, device);
3356     if (r == NULL)
3357       return -1;
3358     if (strcmp (r, expected) != 0) {
3359       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3360       return -1;
3361     }
3362     free (r);
3363   }
3364   return 0;
3365 }
3366
3367 static int test_set_e2uuid_2_skip (void)
3368 {
3369   const char *str;
3370
3371   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3372   if (str && strcmp (str, "1") == 0) return 1;
3373   str = getenv ("SKIP_TEST_SET_E2UUID");
3374   if (str && strcmp (str, "1") == 0) return 1;
3375   return 0;
3376 }
3377
3378 static int test_set_e2uuid_2 (void)
3379 {
3380   if (test_set_e2uuid_2_skip ()) {
3381     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3382     return 0;
3383   }
3384
3385   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3386   {
3387     char device[] = "/dev/sda";
3388     device[5] = devchar;
3389     int r;
3390     suppress_error = 0;
3391     r = guestfs_blockdev_setrw (g, device);
3392     if (r == -1)
3393       return -1;
3394   }
3395   {
3396     int r;
3397     suppress_error = 0;
3398     r = guestfs_umount_all (g);
3399     if (r == -1)
3400       return -1;
3401   }
3402   {
3403     int r;
3404     suppress_error = 0;
3405     r = guestfs_lvm_remove_all (g);
3406     if (r == -1)
3407       return -1;
3408   }
3409   {
3410     char device[] = "/dev/sda";
3411     device[5] = devchar;
3412     char lines_0[] = ",";
3413     char *lines[] = {
3414       lines_0,
3415       NULL
3416     };
3417     int r;
3418     suppress_error = 0;
3419     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3420     if (r == -1)
3421       return -1;
3422   }
3423   {
3424     char fstype[] = "ext2";
3425     char device[] = "/dev/sda1";
3426     device[5] = devchar;
3427     int r;
3428     suppress_error = 0;
3429     r = guestfs_mkfs (g, fstype, device);
3430     if (r == -1)
3431       return -1;
3432   }
3433   {
3434     char device[] = "/dev/sda1";
3435     device[5] = devchar;
3436     char mountpoint[] = "/";
3437     int r;
3438     suppress_error = 0;
3439     r = guestfs_mount (g, device, mountpoint);
3440     if (r == -1)
3441       return -1;
3442   }
3443   /* TestRun for set_e2uuid (2) */
3444   {
3445     char device[] = "/dev/sda1";
3446     device[5] = devchar;
3447     char uuid[] = "random";
3448     int r;
3449     suppress_error = 0;
3450     r = guestfs_set_e2uuid (g, device, uuid);
3451     if (r == -1)
3452       return -1;
3453   }
3454   return 0;
3455 }
3456
3457 static int test_set_e2uuid_3_skip (void)
3458 {
3459   const char *str;
3460
3461   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3462   if (str && strcmp (str, "1") == 0) return 1;
3463   str = getenv ("SKIP_TEST_SET_E2UUID");
3464   if (str && strcmp (str, "1") == 0) return 1;
3465   return 0;
3466 }
3467
3468 static int test_set_e2uuid_3 (void)
3469 {
3470   if (test_set_e2uuid_3_skip ()) {
3471     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3472     return 0;
3473   }
3474
3475   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3476   {
3477     char device[] = "/dev/sda";
3478     device[5] = devchar;
3479     int r;
3480     suppress_error = 0;
3481     r = guestfs_blockdev_setrw (g, device);
3482     if (r == -1)
3483       return -1;
3484   }
3485   {
3486     int r;
3487     suppress_error = 0;
3488     r = guestfs_umount_all (g);
3489     if (r == -1)
3490       return -1;
3491   }
3492   {
3493     int r;
3494     suppress_error = 0;
3495     r = guestfs_lvm_remove_all (g);
3496     if (r == -1)
3497       return -1;
3498   }
3499   {
3500     char device[] = "/dev/sda";
3501     device[5] = devchar;
3502     char lines_0[] = ",";
3503     char *lines[] = {
3504       lines_0,
3505       NULL
3506     };
3507     int r;
3508     suppress_error = 0;
3509     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3510     if (r == -1)
3511       return -1;
3512   }
3513   {
3514     char fstype[] = "ext2";
3515     char device[] = "/dev/sda1";
3516     device[5] = devchar;
3517     int r;
3518     suppress_error = 0;
3519     r = guestfs_mkfs (g, fstype, device);
3520     if (r == -1)
3521       return -1;
3522   }
3523   {
3524     char device[] = "/dev/sda1";
3525     device[5] = devchar;
3526     char mountpoint[] = "/";
3527     int r;
3528     suppress_error = 0;
3529     r = guestfs_mount (g, device, mountpoint);
3530     if (r == -1)
3531       return -1;
3532   }
3533   /* TestRun for set_e2uuid (3) */
3534   {
3535     char device[] = "/dev/sda1";
3536     device[5] = devchar;
3537     char uuid[] = "time";
3538     int r;
3539     suppress_error = 0;
3540     r = guestfs_set_e2uuid (g, device, uuid);
3541     if (r == -1)
3542       return -1;
3543   }
3544   return 0;
3545 }
3546
3547 static int test_set_e2label_0_skip (void)
3548 {
3549   const char *str;
3550
3551   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3552   if (str && strcmp (str, "1") == 0) return 1;
3553   str = getenv ("SKIP_TEST_SET_E2LABEL");
3554   if (str && strcmp (str, "1") == 0) return 1;
3555   return 0;
3556 }
3557
3558 static int test_set_e2label_0 (void)
3559 {
3560   if (test_set_e2label_0_skip ()) {
3561     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3562     return 0;
3563   }
3564
3565   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3566   {
3567     char device[] = "/dev/sda";
3568     device[5] = devchar;
3569     int r;
3570     suppress_error = 0;
3571     r = guestfs_blockdev_setrw (g, device);
3572     if (r == -1)
3573       return -1;
3574   }
3575   {
3576     int r;
3577     suppress_error = 0;
3578     r = guestfs_umount_all (g);
3579     if (r == -1)
3580       return -1;
3581   }
3582   {
3583     int r;
3584     suppress_error = 0;
3585     r = guestfs_lvm_remove_all (g);
3586     if (r == -1)
3587       return -1;
3588   }
3589   {
3590     char device[] = "/dev/sda";
3591     device[5] = devchar;
3592     char lines_0[] = ",";
3593     char *lines[] = {
3594       lines_0,
3595       NULL
3596     };
3597     int r;
3598     suppress_error = 0;
3599     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3600     if (r == -1)
3601       return -1;
3602   }
3603   {
3604     char fstype[] = "ext2";
3605     char device[] = "/dev/sda1";
3606     device[5] = devchar;
3607     int r;
3608     suppress_error = 0;
3609     r = guestfs_mkfs (g, fstype, device);
3610     if (r == -1)
3611       return -1;
3612   }
3613   {
3614     char device[] = "/dev/sda1";
3615     device[5] = devchar;
3616     char mountpoint[] = "/";
3617     int r;
3618     suppress_error = 0;
3619     r = guestfs_mount (g, device, mountpoint);
3620     if (r == -1)
3621       return -1;
3622   }
3623   /* TestOutput for set_e2label (0) */
3624   char expected[] = "testlabel";
3625   {
3626     char device[] = "/dev/sda1";
3627     device[5] = devchar;
3628     char label[] = "testlabel";
3629     int r;
3630     suppress_error = 0;
3631     r = guestfs_set_e2label (g, device, label);
3632     if (r == -1)
3633       return -1;
3634   }
3635   {
3636     char device[] = "/dev/sda1";
3637     device[5] = devchar;
3638     char *r;
3639     suppress_error = 0;
3640     r = guestfs_get_e2label (g, device);
3641     if (r == NULL)
3642       return -1;
3643     if (strcmp (r, expected) != 0) {
3644       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3645       return -1;
3646     }
3647     free (r);
3648   }
3649   return 0;
3650 }
3651
3652 static int test_pvremove_0_skip (void)
3653 {
3654   const char *str;
3655
3656   str = getenv ("SKIP_TEST_PVREMOVE_0");
3657   if (str && strcmp (str, "1") == 0) return 1;
3658   str = getenv ("SKIP_TEST_PVREMOVE");
3659   if (str && strcmp (str, "1") == 0) return 1;
3660   return 0;
3661 }
3662
3663 static int test_pvremove_0 (void)
3664 {
3665   if (test_pvremove_0_skip ()) {
3666     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3667     return 0;
3668   }
3669
3670   /* InitNone|InitEmpty for test_pvremove_0 */
3671   {
3672     char device[] = "/dev/sda";
3673     device[5] = devchar;
3674     int r;
3675     suppress_error = 0;
3676     r = guestfs_blockdev_setrw (g, device);
3677     if (r == -1)
3678       return -1;
3679   }
3680   {
3681     int r;
3682     suppress_error = 0;
3683     r = guestfs_umount_all (g);
3684     if (r == -1)
3685       return -1;
3686   }
3687   {
3688     int r;
3689     suppress_error = 0;
3690     r = guestfs_lvm_remove_all (g);
3691     if (r == -1)
3692       return -1;
3693   }
3694   /* TestOutputList for pvremove (0) */
3695   {
3696     char device[] = "/dev/sda";
3697     device[5] = devchar;
3698     char lines_0[] = ",";
3699     char *lines[] = {
3700       lines_0,
3701       NULL
3702     };
3703     int r;
3704     suppress_error = 0;
3705     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3706     if (r == -1)
3707       return -1;
3708   }
3709   {
3710     char device[] = "/dev/sda1";
3711     device[5] = devchar;
3712     int r;
3713     suppress_error = 0;
3714     r = guestfs_pvcreate (g, device);
3715     if (r == -1)
3716       return -1;
3717   }
3718   {
3719     char volgroup[] = "VG";
3720     char physvols_0[] = "/dev/sda1";
3721     physvols_0[5] = devchar;
3722     char *physvols[] = {
3723       physvols_0,
3724       NULL
3725     };
3726     int r;
3727     suppress_error = 0;
3728     r = guestfs_vgcreate (g, volgroup, physvols);
3729     if (r == -1)
3730       return -1;
3731   }
3732   {
3733     char logvol[] = "LV1";
3734     char volgroup[] = "VG";
3735     int r;
3736     suppress_error = 0;
3737     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3738     if (r == -1)
3739       return -1;
3740   }
3741   {
3742     char logvol[] = "LV2";
3743     char volgroup[] = "VG";
3744     int r;
3745     suppress_error = 0;
3746     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3747     if (r == -1)
3748       return -1;
3749   }
3750   {
3751     char vgname[] = "VG";
3752     int r;
3753     suppress_error = 0;
3754     r = guestfs_vgremove (g, vgname);
3755     if (r == -1)
3756       return -1;
3757   }
3758   {
3759     char device[] = "/dev/sda1";
3760     device[5] = devchar;
3761     int r;
3762     suppress_error = 0;
3763     r = guestfs_pvremove (g, device);
3764     if (r == -1)
3765       return -1;
3766   }
3767   {
3768     char **r;
3769     int i;
3770     suppress_error = 0;
3771     r = guestfs_lvs (g);
3772     if (r == NULL)
3773       return -1;
3774     if (r[0] != NULL) {
3775       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3776       print_strings (r);
3777       return -1;
3778     }
3779     for (i = 0; r[i] != NULL; ++i)
3780       free (r[i]);
3781     free (r);
3782   }
3783   return 0;
3784 }
3785
3786 static int test_pvremove_1_skip (void)
3787 {
3788   const char *str;
3789
3790   str = getenv ("SKIP_TEST_PVREMOVE_1");
3791   if (str && strcmp (str, "1") == 0) return 1;
3792   str = getenv ("SKIP_TEST_PVREMOVE");
3793   if (str && strcmp (str, "1") == 0) return 1;
3794   return 0;
3795 }
3796
3797 static int test_pvremove_1 (void)
3798 {
3799   if (test_pvremove_1_skip ()) {
3800     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3801     return 0;
3802   }
3803
3804   /* InitNone|InitEmpty for test_pvremove_1 */
3805   {
3806     char device[] = "/dev/sda";
3807     device[5] = devchar;
3808     int r;
3809     suppress_error = 0;
3810     r = guestfs_blockdev_setrw (g, device);
3811     if (r == -1)
3812       return -1;
3813   }
3814   {
3815     int r;
3816     suppress_error = 0;
3817     r = guestfs_umount_all (g);
3818     if (r == -1)
3819       return -1;
3820   }
3821   {
3822     int r;
3823     suppress_error = 0;
3824     r = guestfs_lvm_remove_all (g);
3825     if (r == -1)
3826       return -1;
3827   }
3828   /* TestOutputList for pvremove (1) */
3829   {
3830     char device[] = "/dev/sda";
3831     device[5] = devchar;
3832     char lines_0[] = ",";
3833     char *lines[] = {
3834       lines_0,
3835       NULL
3836     };
3837     int r;
3838     suppress_error = 0;
3839     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3840     if (r == -1)
3841       return -1;
3842   }
3843   {
3844     char device[] = "/dev/sda1";
3845     device[5] = devchar;
3846     int r;
3847     suppress_error = 0;
3848     r = guestfs_pvcreate (g, device);
3849     if (r == -1)
3850       return -1;
3851   }
3852   {
3853     char volgroup[] = "VG";
3854     char physvols_0[] = "/dev/sda1";
3855     physvols_0[5] = devchar;
3856     char *physvols[] = {
3857       physvols_0,
3858       NULL
3859     };
3860     int r;
3861     suppress_error = 0;
3862     r = guestfs_vgcreate (g, volgroup, physvols);
3863     if (r == -1)
3864       return -1;
3865   }
3866   {
3867     char logvol[] = "LV1";
3868     char volgroup[] = "VG";
3869     int r;
3870     suppress_error = 0;
3871     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3872     if (r == -1)
3873       return -1;
3874   }
3875   {
3876     char logvol[] = "LV2";
3877     char volgroup[] = "VG";
3878     int r;
3879     suppress_error = 0;
3880     r = guestfs_lvcreate (g, logvol, volgroup, 50);
3881     if (r == -1)
3882       return -1;
3883   }
3884   {
3885     char vgname[] = "VG";
3886     int r;
3887     suppress_error = 0;
3888     r = guestfs_vgremove (g, vgname);
3889     if (r == -1)
3890       return -1;
3891   }
3892   {
3893     char device[] = "/dev/sda1";
3894     device[5] = devchar;
3895     int r;
3896     suppress_error = 0;
3897     r = guestfs_pvremove (g, device);
3898     if (r == -1)
3899       return -1;
3900   }
3901   {
3902     char **r;
3903     int i;
3904     suppress_error = 0;
3905     r = guestfs_vgs (g);
3906     if (r == NULL)
3907       return -1;
3908     if (r[0] != NULL) {
3909       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3910       print_strings (r);
3911       return -1;
3912     }
3913     for (i = 0; r[i] != NULL; ++i)
3914       free (r[i]);
3915     free (r);
3916   }
3917   return 0;
3918 }
3919
3920 static int test_pvremove_2_skip (void)
3921 {
3922   const char *str;
3923
3924   str = getenv ("SKIP_TEST_PVREMOVE_2");
3925   if (str && strcmp (str, "1") == 0) return 1;
3926   str = getenv ("SKIP_TEST_PVREMOVE");
3927   if (str && strcmp (str, "1") == 0) return 1;
3928   return 0;
3929 }
3930
3931 static int test_pvremove_2 (void)
3932 {
3933   if (test_pvremove_2_skip ()) {
3934     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3935     return 0;
3936   }
3937
3938   /* InitNone|InitEmpty for test_pvremove_2 */
3939   {
3940     char device[] = "/dev/sda";
3941     device[5] = devchar;
3942     int r;
3943     suppress_error = 0;
3944     r = guestfs_blockdev_setrw (g, device);
3945     if (r == -1)
3946       return -1;
3947   }
3948   {
3949     int r;
3950     suppress_error = 0;
3951     r = guestfs_umount_all (g);
3952     if (r == -1)
3953       return -1;
3954   }
3955   {
3956     int r;
3957     suppress_error = 0;
3958     r = guestfs_lvm_remove_all (g);
3959     if (r == -1)
3960       return -1;
3961   }
3962   /* TestOutputList for pvremove (2) */
3963   {
3964     char device[] = "/dev/sda";
3965     device[5] = devchar;
3966     char lines_0[] = ",";
3967     char *lines[] = {
3968       lines_0,
3969       NULL
3970     };
3971     int r;
3972     suppress_error = 0;
3973     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3974     if (r == -1)
3975       return -1;
3976   }
3977   {
3978     char device[] = "/dev/sda1";
3979     device[5] = devchar;
3980     int r;
3981     suppress_error = 0;
3982     r = guestfs_pvcreate (g, device);
3983     if (r == -1)
3984       return -1;
3985   }
3986   {
3987     char volgroup[] = "VG";
3988     char physvols_0[] = "/dev/sda1";
3989     physvols_0[5] = devchar;
3990     char *physvols[] = {
3991       physvols_0,
3992       NULL
3993     };
3994     int r;
3995     suppress_error = 0;
3996     r = guestfs_vgcreate (g, volgroup, physvols);
3997     if (r == -1)
3998       return -1;
3999   }
4000   {
4001     char logvol[] = "LV1";
4002     char volgroup[] = "VG";
4003     int r;
4004     suppress_error = 0;
4005     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4006     if (r == -1)
4007       return -1;
4008   }
4009   {
4010     char logvol[] = "LV2";
4011     char volgroup[] = "VG";
4012     int r;
4013     suppress_error = 0;
4014     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4015     if (r == -1)
4016       return -1;
4017   }
4018   {
4019     char vgname[] = "VG";
4020     int r;
4021     suppress_error = 0;
4022     r = guestfs_vgremove (g, vgname);
4023     if (r == -1)
4024       return -1;
4025   }
4026   {
4027     char device[] = "/dev/sda1";
4028     device[5] = devchar;
4029     int r;
4030     suppress_error = 0;
4031     r = guestfs_pvremove (g, device);
4032     if (r == -1)
4033       return -1;
4034   }
4035   {
4036     char **r;
4037     int i;
4038     suppress_error = 0;
4039     r = guestfs_pvs (g);
4040     if (r == NULL)
4041       return -1;
4042     if (r[0] != NULL) {
4043       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
4044       print_strings (r);
4045       return -1;
4046     }
4047     for (i = 0; r[i] != NULL; ++i)
4048       free (r[i]);
4049     free (r);
4050   }
4051   return 0;
4052 }
4053
4054 static int test_vgremove_0_skip (void)
4055 {
4056   const char *str;
4057
4058   str = getenv ("SKIP_TEST_VGREMOVE_0");
4059   if (str && strcmp (str, "1") == 0) return 1;
4060   str = getenv ("SKIP_TEST_VGREMOVE");
4061   if (str && strcmp (str, "1") == 0) return 1;
4062   return 0;
4063 }
4064
4065 static int test_vgremove_0 (void)
4066 {
4067   if (test_vgremove_0_skip ()) {
4068     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
4069     return 0;
4070   }
4071
4072   /* InitNone|InitEmpty for test_vgremove_0 */
4073   {
4074     char device[] = "/dev/sda";
4075     device[5] = devchar;
4076     int r;
4077     suppress_error = 0;
4078     r = guestfs_blockdev_setrw (g, device);
4079     if (r == -1)
4080       return -1;
4081   }
4082   {
4083     int r;
4084     suppress_error = 0;
4085     r = guestfs_umount_all (g);
4086     if (r == -1)
4087       return -1;
4088   }
4089   {
4090     int r;
4091     suppress_error = 0;
4092     r = guestfs_lvm_remove_all (g);
4093     if (r == -1)
4094       return -1;
4095   }
4096   /* TestOutputList for vgremove (0) */
4097   {
4098     char device[] = "/dev/sda";
4099     device[5] = devchar;
4100     char lines_0[] = ",";
4101     char *lines[] = {
4102       lines_0,
4103       NULL
4104     };
4105     int r;
4106     suppress_error = 0;
4107     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4108     if (r == -1)
4109       return -1;
4110   }
4111   {
4112     char device[] = "/dev/sda1";
4113     device[5] = devchar;
4114     int r;
4115     suppress_error = 0;
4116     r = guestfs_pvcreate (g, device);
4117     if (r == -1)
4118       return -1;
4119   }
4120   {
4121     char volgroup[] = "VG";
4122     char physvols_0[] = "/dev/sda1";
4123     physvols_0[5] = devchar;
4124     char *physvols[] = {
4125       physvols_0,
4126       NULL
4127     };
4128     int r;
4129     suppress_error = 0;
4130     r = guestfs_vgcreate (g, volgroup, physvols);
4131     if (r == -1)
4132       return -1;
4133   }
4134   {
4135     char logvol[] = "LV1";
4136     char volgroup[] = "VG";
4137     int r;
4138     suppress_error = 0;
4139     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4140     if (r == -1)
4141       return -1;
4142   }
4143   {
4144     char logvol[] = "LV2";
4145     char volgroup[] = "VG";
4146     int r;
4147     suppress_error = 0;
4148     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4149     if (r == -1)
4150       return -1;
4151   }
4152   {
4153     char vgname[] = "VG";
4154     int r;
4155     suppress_error = 0;
4156     r = guestfs_vgremove (g, vgname);
4157     if (r == -1)
4158       return -1;
4159   }
4160   {
4161     char **r;
4162     int i;
4163     suppress_error = 0;
4164     r = guestfs_lvs (g);
4165     if (r == NULL)
4166       return -1;
4167     if (r[0] != NULL) {
4168       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4169       print_strings (r);
4170       return -1;
4171     }
4172     for (i = 0; r[i] != NULL; ++i)
4173       free (r[i]);
4174     free (r);
4175   }
4176   return 0;
4177 }
4178
4179 static int test_vgremove_1_skip (void)
4180 {
4181   const char *str;
4182
4183   str = getenv ("SKIP_TEST_VGREMOVE_1");
4184   if (str && strcmp (str, "1") == 0) return 1;
4185   str = getenv ("SKIP_TEST_VGREMOVE");
4186   if (str && strcmp (str, "1") == 0) return 1;
4187   return 0;
4188 }
4189
4190 static int test_vgremove_1 (void)
4191 {
4192   if (test_vgremove_1_skip ()) {
4193     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4194     return 0;
4195   }
4196
4197   /* InitNone|InitEmpty for test_vgremove_1 */
4198   {
4199     char device[] = "/dev/sda";
4200     device[5] = devchar;
4201     int r;
4202     suppress_error = 0;
4203     r = guestfs_blockdev_setrw (g, device);
4204     if (r == -1)
4205       return -1;
4206   }
4207   {
4208     int r;
4209     suppress_error = 0;
4210     r = guestfs_umount_all (g);
4211     if (r == -1)
4212       return -1;
4213   }
4214   {
4215     int r;
4216     suppress_error = 0;
4217     r = guestfs_lvm_remove_all (g);
4218     if (r == -1)
4219       return -1;
4220   }
4221   /* TestOutputList for vgremove (1) */
4222   {
4223     char device[] = "/dev/sda";
4224     device[5] = devchar;
4225     char lines_0[] = ",";
4226     char *lines[] = {
4227       lines_0,
4228       NULL
4229     };
4230     int r;
4231     suppress_error = 0;
4232     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4233     if (r == -1)
4234       return -1;
4235   }
4236   {
4237     char device[] = "/dev/sda1";
4238     device[5] = devchar;
4239     int r;
4240     suppress_error = 0;
4241     r = guestfs_pvcreate (g, device);
4242     if (r == -1)
4243       return -1;
4244   }
4245   {
4246     char volgroup[] = "VG";
4247     char physvols_0[] = "/dev/sda1";
4248     physvols_0[5] = devchar;
4249     char *physvols[] = {
4250       physvols_0,
4251       NULL
4252     };
4253     int r;
4254     suppress_error = 0;
4255     r = guestfs_vgcreate (g, volgroup, physvols);
4256     if (r == -1)
4257       return -1;
4258   }
4259   {
4260     char logvol[] = "LV1";
4261     char volgroup[] = "VG";
4262     int r;
4263     suppress_error = 0;
4264     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4265     if (r == -1)
4266       return -1;
4267   }
4268   {
4269     char logvol[] = "LV2";
4270     char volgroup[] = "VG";
4271     int r;
4272     suppress_error = 0;
4273     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4274     if (r == -1)
4275       return -1;
4276   }
4277   {
4278     char vgname[] = "VG";
4279     int r;
4280     suppress_error = 0;
4281     r = guestfs_vgremove (g, vgname);
4282     if (r == -1)
4283       return -1;
4284   }
4285   {
4286     char **r;
4287     int i;
4288     suppress_error = 0;
4289     r = guestfs_vgs (g);
4290     if (r == NULL)
4291       return -1;
4292     if (r[0] != NULL) {
4293       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4294       print_strings (r);
4295       return -1;
4296     }
4297     for (i = 0; r[i] != NULL; ++i)
4298       free (r[i]);
4299     free (r);
4300   }
4301   return 0;
4302 }
4303
4304 static int test_lvremove_0_skip (void)
4305 {
4306   const char *str;
4307
4308   str = getenv ("SKIP_TEST_LVREMOVE_0");
4309   if (str && strcmp (str, "1") == 0) return 1;
4310   str = getenv ("SKIP_TEST_LVREMOVE");
4311   if (str && strcmp (str, "1") == 0) return 1;
4312   return 0;
4313 }
4314
4315 static int test_lvremove_0 (void)
4316 {
4317   if (test_lvremove_0_skip ()) {
4318     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4319     return 0;
4320   }
4321
4322   /* InitNone|InitEmpty for test_lvremove_0 */
4323   {
4324     char device[] = "/dev/sda";
4325     device[5] = devchar;
4326     int r;
4327     suppress_error = 0;
4328     r = guestfs_blockdev_setrw (g, device);
4329     if (r == -1)
4330       return -1;
4331   }
4332   {
4333     int r;
4334     suppress_error = 0;
4335     r = guestfs_umount_all (g);
4336     if (r == -1)
4337       return -1;
4338   }
4339   {
4340     int r;
4341     suppress_error = 0;
4342     r = guestfs_lvm_remove_all (g);
4343     if (r == -1)
4344       return -1;
4345   }
4346   /* TestOutputList for lvremove (0) */
4347   {
4348     char device[] = "/dev/sda";
4349     device[5] = devchar;
4350     char lines_0[] = ",";
4351     char *lines[] = {
4352       lines_0,
4353       NULL
4354     };
4355     int r;
4356     suppress_error = 0;
4357     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4358     if (r == -1)
4359       return -1;
4360   }
4361   {
4362     char device[] = "/dev/sda1";
4363     device[5] = devchar;
4364     int r;
4365     suppress_error = 0;
4366     r = guestfs_pvcreate (g, device);
4367     if (r == -1)
4368       return -1;
4369   }
4370   {
4371     char volgroup[] = "VG";
4372     char physvols_0[] = "/dev/sda1";
4373     physvols_0[5] = devchar;
4374     char *physvols[] = {
4375       physvols_0,
4376       NULL
4377     };
4378     int r;
4379     suppress_error = 0;
4380     r = guestfs_vgcreate (g, volgroup, physvols);
4381     if (r == -1)
4382       return -1;
4383   }
4384   {
4385     char logvol[] = "LV1";
4386     char volgroup[] = "VG";
4387     int r;
4388     suppress_error = 0;
4389     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4390     if (r == -1)
4391       return -1;
4392   }
4393   {
4394     char logvol[] = "LV2";
4395     char volgroup[] = "VG";
4396     int r;
4397     suppress_error = 0;
4398     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4399     if (r == -1)
4400       return -1;
4401   }
4402   {
4403     char device[] = "/dev/VG/LV1";
4404     int r;
4405     suppress_error = 0;
4406     r = guestfs_lvremove (g, device);
4407     if (r == -1)
4408       return -1;
4409   }
4410   {
4411     char **r;
4412     int i;
4413     suppress_error = 0;
4414     r = guestfs_lvs (g);
4415     if (r == NULL)
4416       return -1;
4417     if (!r[0]) {
4418       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4419       print_strings (r);
4420       return -1;
4421     }
4422     {
4423       char expected[] = "/dev/VG/LV2";
4424       if (strcmp (r[0], expected) != 0) {
4425         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4426         return -1;
4427       }
4428     }
4429     if (r[1] != NULL) {
4430       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4431       print_strings (r);
4432       return -1;
4433     }
4434     for (i = 0; r[i] != NULL; ++i)
4435       free (r[i]);
4436     free (r);
4437   }
4438   return 0;
4439 }
4440
4441 static int test_lvremove_1_skip (void)
4442 {
4443   const char *str;
4444
4445   str = getenv ("SKIP_TEST_LVREMOVE_1");
4446   if (str && strcmp (str, "1") == 0) return 1;
4447   str = getenv ("SKIP_TEST_LVREMOVE");
4448   if (str && strcmp (str, "1") == 0) return 1;
4449   return 0;
4450 }
4451
4452 static int test_lvremove_1 (void)
4453 {
4454   if (test_lvremove_1_skip ()) {
4455     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4456     return 0;
4457   }
4458
4459   /* InitNone|InitEmpty for test_lvremove_1 */
4460   {
4461     char device[] = "/dev/sda";
4462     device[5] = devchar;
4463     int r;
4464     suppress_error = 0;
4465     r = guestfs_blockdev_setrw (g, device);
4466     if (r == -1)
4467       return -1;
4468   }
4469   {
4470     int r;
4471     suppress_error = 0;
4472     r = guestfs_umount_all (g);
4473     if (r == -1)
4474       return -1;
4475   }
4476   {
4477     int r;
4478     suppress_error = 0;
4479     r = guestfs_lvm_remove_all (g);
4480     if (r == -1)
4481       return -1;
4482   }
4483   /* TestOutputList for lvremove (1) */
4484   {
4485     char device[] = "/dev/sda";
4486     device[5] = devchar;
4487     char lines_0[] = ",";
4488     char *lines[] = {
4489       lines_0,
4490       NULL
4491     };
4492     int r;
4493     suppress_error = 0;
4494     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4495     if (r == -1)
4496       return -1;
4497   }
4498   {
4499     char device[] = "/dev/sda1";
4500     device[5] = devchar;
4501     int r;
4502     suppress_error = 0;
4503     r = guestfs_pvcreate (g, device);
4504     if (r == -1)
4505       return -1;
4506   }
4507   {
4508     char volgroup[] = "VG";
4509     char physvols_0[] = "/dev/sda1";
4510     physvols_0[5] = devchar;
4511     char *physvols[] = {
4512       physvols_0,
4513       NULL
4514     };
4515     int r;
4516     suppress_error = 0;
4517     r = guestfs_vgcreate (g, volgroup, physvols);
4518     if (r == -1)
4519       return -1;
4520   }
4521   {
4522     char logvol[] = "LV1";
4523     char volgroup[] = "VG";
4524     int r;
4525     suppress_error = 0;
4526     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4527     if (r == -1)
4528       return -1;
4529   }
4530   {
4531     char logvol[] = "LV2";
4532     char volgroup[] = "VG";
4533     int r;
4534     suppress_error = 0;
4535     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4536     if (r == -1)
4537       return -1;
4538   }
4539   {
4540     char device[] = "/dev/VG";
4541     int r;
4542     suppress_error = 0;
4543     r = guestfs_lvremove (g, device);
4544     if (r == -1)
4545       return -1;
4546   }
4547   {
4548     char **r;
4549     int i;
4550     suppress_error = 0;
4551     r = guestfs_lvs (g);
4552     if (r == NULL)
4553       return -1;
4554     if (r[0] != NULL) {
4555       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4556       print_strings (r);
4557       return -1;
4558     }
4559     for (i = 0; r[i] != NULL; ++i)
4560       free (r[i]);
4561     free (r);
4562   }
4563   return 0;
4564 }
4565
4566 static int test_lvremove_2_skip (void)
4567 {
4568   const char *str;
4569
4570   str = getenv ("SKIP_TEST_LVREMOVE_2");
4571   if (str && strcmp (str, "1") == 0) return 1;
4572   str = getenv ("SKIP_TEST_LVREMOVE");
4573   if (str && strcmp (str, "1") == 0) return 1;
4574   return 0;
4575 }
4576
4577 static int test_lvremove_2 (void)
4578 {
4579   if (test_lvremove_2_skip ()) {
4580     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4581     return 0;
4582   }
4583
4584   /* InitNone|InitEmpty for test_lvremove_2 */
4585   {
4586     char device[] = "/dev/sda";
4587     device[5] = devchar;
4588     int r;
4589     suppress_error = 0;
4590     r = guestfs_blockdev_setrw (g, device);
4591     if (r == -1)
4592       return -1;
4593   }
4594   {
4595     int r;
4596     suppress_error = 0;
4597     r = guestfs_umount_all (g);
4598     if (r == -1)
4599       return -1;
4600   }
4601   {
4602     int r;
4603     suppress_error = 0;
4604     r = guestfs_lvm_remove_all (g);
4605     if (r == -1)
4606       return -1;
4607   }
4608   /* TestOutputList for lvremove (2) */
4609   {
4610     char device[] = "/dev/sda";
4611     device[5] = devchar;
4612     char lines_0[] = ",";
4613     char *lines[] = {
4614       lines_0,
4615       NULL
4616     };
4617     int r;
4618     suppress_error = 0;
4619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4620     if (r == -1)
4621       return -1;
4622   }
4623   {
4624     char device[] = "/dev/sda1";
4625     device[5] = devchar;
4626     int r;
4627     suppress_error = 0;
4628     r = guestfs_pvcreate (g, device);
4629     if (r == -1)
4630       return -1;
4631   }
4632   {
4633     char volgroup[] = "VG";
4634     char physvols_0[] = "/dev/sda1";
4635     physvols_0[5] = devchar;
4636     char *physvols[] = {
4637       physvols_0,
4638       NULL
4639     };
4640     int r;
4641     suppress_error = 0;
4642     r = guestfs_vgcreate (g, volgroup, physvols);
4643     if (r == -1)
4644       return -1;
4645   }
4646   {
4647     char logvol[] = "LV1";
4648     char volgroup[] = "VG";
4649     int r;
4650     suppress_error = 0;
4651     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4652     if (r == -1)
4653       return -1;
4654   }
4655   {
4656     char logvol[] = "LV2";
4657     char volgroup[] = "VG";
4658     int r;
4659     suppress_error = 0;
4660     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4661     if (r == -1)
4662       return -1;
4663   }
4664   {
4665     char device[] = "/dev/VG";
4666     int r;
4667     suppress_error = 0;
4668     r = guestfs_lvremove (g, device);
4669     if (r == -1)
4670       return -1;
4671   }
4672   {
4673     char **r;
4674     int i;
4675     suppress_error = 0;
4676     r = guestfs_vgs (g);
4677     if (r == NULL)
4678       return -1;
4679     if (!r[0]) {
4680       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4681       print_strings (r);
4682       return -1;
4683     }
4684     {
4685       char expected[] = "VG";
4686       if (strcmp (r[0], expected) != 0) {
4687         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4688         return -1;
4689       }
4690     }
4691     if (r[1] != NULL) {
4692       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4693       print_strings (r);
4694       return -1;
4695     }
4696     for (i = 0; r[i] != NULL; ++i)
4697       free (r[i]);
4698     free (r);
4699   }
4700   return 0;
4701 }
4702
4703 static int test_mount_ro_0_skip (void)
4704 {
4705   const char *str;
4706
4707   str = getenv ("SKIP_TEST_MOUNT_RO_0");
4708   if (str && strcmp (str, "1") == 0) return 1;
4709   str = getenv ("SKIP_TEST_MOUNT_RO");
4710   if (str && strcmp (str, "1") == 0) return 1;
4711   return 0;
4712 }
4713
4714 static int test_mount_ro_0 (void)
4715 {
4716   if (test_mount_ro_0_skip ()) {
4717     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4718     return 0;
4719   }
4720
4721   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4722   {
4723     char device[] = "/dev/sda";
4724     device[5] = devchar;
4725     int r;
4726     suppress_error = 0;
4727     r = guestfs_blockdev_setrw (g, device);
4728     if (r == -1)
4729       return -1;
4730   }
4731   {
4732     int r;
4733     suppress_error = 0;
4734     r = guestfs_umount_all (g);
4735     if (r == -1)
4736       return -1;
4737   }
4738   {
4739     int r;
4740     suppress_error = 0;
4741     r = guestfs_lvm_remove_all (g);
4742     if (r == -1)
4743       return -1;
4744   }
4745   {
4746     char device[] = "/dev/sda";
4747     device[5] = devchar;
4748     char lines_0[] = ",";
4749     char *lines[] = {
4750       lines_0,
4751       NULL
4752     };
4753     int r;
4754     suppress_error = 0;
4755     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4756     if (r == -1)
4757       return -1;
4758   }
4759   {
4760     char fstype[] = "ext2";
4761     char device[] = "/dev/sda1";
4762     device[5] = devchar;
4763     int r;
4764     suppress_error = 0;
4765     r = guestfs_mkfs (g, fstype, device);
4766     if (r == -1)
4767       return -1;
4768   }
4769   {
4770     char device[] = "/dev/sda1";
4771     device[5] = devchar;
4772     char mountpoint[] = "/";
4773     int r;
4774     suppress_error = 0;
4775     r = guestfs_mount (g, device, mountpoint);
4776     if (r == -1)
4777       return -1;
4778   }
4779   /* TestLastFail for mount_ro (0) */
4780   {
4781     char pathordevice[] = "/";
4782     int r;
4783     suppress_error = 0;
4784     r = guestfs_umount (g, pathordevice);
4785     if (r == -1)
4786       return -1;
4787   }
4788   {
4789     char device[] = "/dev/sda1";
4790     device[5] = devchar;
4791     char mountpoint[] = "/";
4792     int r;
4793     suppress_error = 0;
4794     r = guestfs_mount_ro (g, device, mountpoint);
4795     if (r == -1)
4796       return -1;
4797   }
4798   {
4799     char path[] = "/new";
4800     int r;
4801     suppress_error = 1;
4802     r = guestfs_touch (g, path);
4803     if (r != -1)
4804       return -1;
4805   }
4806   return 0;
4807 }
4808
4809 static int test_mount_ro_1_skip (void)
4810 {
4811   const char *str;
4812
4813   str = getenv ("SKIP_TEST_MOUNT_RO_1");
4814   if (str && strcmp (str, "1") == 0) return 1;
4815   str = getenv ("SKIP_TEST_MOUNT_RO");
4816   if (str && strcmp (str, "1") == 0) return 1;
4817   return 0;
4818 }
4819
4820 static int test_mount_ro_1 (void)
4821 {
4822   if (test_mount_ro_1_skip ()) {
4823     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4824     return 0;
4825   }
4826
4827   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4828   {
4829     char device[] = "/dev/sda";
4830     device[5] = devchar;
4831     int r;
4832     suppress_error = 0;
4833     r = guestfs_blockdev_setrw (g, device);
4834     if (r == -1)
4835       return -1;
4836   }
4837   {
4838     int r;
4839     suppress_error = 0;
4840     r = guestfs_umount_all (g);
4841     if (r == -1)
4842       return -1;
4843   }
4844   {
4845     int r;
4846     suppress_error = 0;
4847     r = guestfs_lvm_remove_all (g);
4848     if (r == -1)
4849       return -1;
4850   }
4851   {
4852     char device[] = "/dev/sda";
4853     device[5] = devchar;
4854     char lines_0[] = ",";
4855     char *lines[] = {
4856       lines_0,
4857       NULL
4858     };
4859     int r;
4860     suppress_error = 0;
4861     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4862     if (r == -1)
4863       return -1;
4864   }
4865   {
4866     char fstype[] = "ext2";
4867     char device[] = "/dev/sda1";
4868     device[5] = devchar;
4869     int r;
4870     suppress_error = 0;
4871     r = guestfs_mkfs (g, fstype, device);
4872     if (r == -1)
4873       return -1;
4874   }
4875   {
4876     char device[] = "/dev/sda1";
4877     device[5] = devchar;
4878     char mountpoint[] = "/";
4879     int r;
4880     suppress_error = 0;
4881     r = guestfs_mount (g, device, mountpoint);
4882     if (r == -1)
4883       return -1;
4884   }
4885   /* TestOutput for mount_ro (1) */
4886   char expected[] = "data";
4887   {
4888     char path[] = "/new";
4889     char content[] = "data";
4890     int r;
4891     suppress_error = 0;
4892     r = guestfs_write_file (g, path, content, 0);
4893     if (r == -1)
4894       return -1;
4895   }
4896   {
4897     char pathordevice[] = "/";
4898     int r;
4899     suppress_error = 0;
4900     r = guestfs_umount (g, pathordevice);
4901     if (r == -1)
4902       return -1;
4903   }
4904   {
4905     char device[] = "/dev/sda1";
4906     device[5] = devchar;
4907     char mountpoint[] = "/";
4908     int r;
4909     suppress_error = 0;
4910     r = guestfs_mount_ro (g, device, mountpoint);
4911     if (r == -1)
4912       return -1;
4913   }
4914   {
4915     char path[] = "/new";
4916     char *r;
4917     suppress_error = 0;
4918     r = guestfs_cat (g, path);
4919     if (r == NULL)
4920       return -1;
4921     if (strcmp (r, expected) != 0) {
4922       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4923       return -1;
4924     }
4925     free (r);
4926   }
4927   return 0;
4928 }
4929
4930 static int test_tgz_in_0_skip (void)
4931 {
4932   const char *str;
4933
4934   str = getenv ("SKIP_TEST_TGZ_IN_0");
4935   if (str && strcmp (str, "1") == 0) return 1;
4936   str = getenv ("SKIP_TEST_TGZ_IN");
4937   if (str && strcmp (str, "1") == 0) return 1;
4938   return 0;
4939 }
4940
4941 static int test_tgz_in_0 (void)
4942 {
4943   if (test_tgz_in_0_skip ()) {
4944     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4945     return 0;
4946   }
4947
4948   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4949   {
4950     char device[] = "/dev/sda";
4951     device[5] = devchar;
4952     int r;
4953     suppress_error = 0;
4954     r = guestfs_blockdev_setrw (g, device);
4955     if (r == -1)
4956       return -1;
4957   }
4958   {
4959     int r;
4960     suppress_error = 0;
4961     r = guestfs_umount_all (g);
4962     if (r == -1)
4963       return -1;
4964   }
4965   {
4966     int r;
4967     suppress_error = 0;
4968     r = guestfs_lvm_remove_all (g);
4969     if (r == -1)
4970       return -1;
4971   }
4972   {
4973     char device[] = "/dev/sda";
4974     device[5] = devchar;
4975     char lines_0[] = ",";
4976     char *lines[] = {
4977       lines_0,
4978       NULL
4979     };
4980     int r;
4981     suppress_error = 0;
4982     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4983     if (r == -1)
4984       return -1;
4985   }
4986   {
4987     char fstype[] = "ext2";
4988     char device[] = "/dev/sda1";
4989     device[5] = devchar;
4990     int r;
4991     suppress_error = 0;
4992     r = guestfs_mkfs (g, fstype, device);
4993     if (r == -1)
4994       return -1;
4995   }
4996   {
4997     char device[] = "/dev/sda1";
4998     device[5] = devchar;
4999     char mountpoint[] = "/";
5000     int r;
5001     suppress_error = 0;
5002     r = guestfs_mount (g, device, mountpoint);
5003     if (r == -1)
5004       return -1;
5005   }
5006   /* TestOutput for tgz_in (0) */
5007   char expected[] = "hello\n";
5008   {
5009     char directory[] = "/";
5010     int r;
5011     suppress_error = 0;
5012     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5013     if (r == -1)
5014       return -1;
5015   }
5016   {
5017     char path[] = "/hello";
5018     char *r;
5019     suppress_error = 0;
5020     r = guestfs_cat (g, path);
5021     if (r == NULL)
5022       return -1;
5023     if (strcmp (r, expected) != 0) {
5024       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5025       return -1;
5026     }
5027     free (r);
5028   }
5029   return 0;
5030 }
5031
5032 static int test_tar_in_0_skip (void)
5033 {
5034   const char *str;
5035
5036   str = getenv ("SKIP_TEST_TAR_IN_0");
5037   if (str && strcmp (str, "1") == 0) return 1;
5038   str = getenv ("SKIP_TEST_TAR_IN");
5039   if (str && strcmp (str, "1") == 0) return 1;
5040   return 0;
5041 }
5042
5043 static int test_tar_in_0 (void)
5044 {
5045   if (test_tar_in_0_skip ()) {
5046     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5047     return 0;
5048   }
5049
5050   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5051   {
5052     char device[] = "/dev/sda";
5053     device[5] = devchar;
5054     int r;
5055     suppress_error = 0;
5056     r = guestfs_blockdev_setrw (g, device);
5057     if (r == -1)
5058       return -1;
5059   }
5060   {
5061     int r;
5062     suppress_error = 0;
5063     r = guestfs_umount_all (g);
5064     if (r == -1)
5065       return -1;
5066   }
5067   {
5068     int r;
5069     suppress_error = 0;
5070     r = guestfs_lvm_remove_all (g);
5071     if (r == -1)
5072       return -1;
5073   }
5074   {
5075     char device[] = "/dev/sda";
5076     device[5] = devchar;
5077     char lines_0[] = ",";
5078     char *lines[] = {
5079       lines_0,
5080       NULL
5081     };
5082     int r;
5083     suppress_error = 0;
5084     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5085     if (r == -1)
5086       return -1;
5087   }
5088   {
5089     char fstype[] = "ext2";
5090     char device[] = "/dev/sda1";
5091     device[5] = devchar;
5092     int r;
5093     suppress_error = 0;
5094     r = guestfs_mkfs (g, fstype, device);
5095     if (r == -1)
5096       return -1;
5097   }
5098   {
5099     char device[] = "/dev/sda1";
5100     device[5] = devchar;
5101     char mountpoint[] = "/";
5102     int r;
5103     suppress_error = 0;
5104     r = guestfs_mount (g, device, mountpoint);
5105     if (r == -1)
5106       return -1;
5107   }
5108   /* TestOutput for tar_in (0) */
5109   char expected[] = "hello\n";
5110   {
5111     char directory[] = "/";
5112     int r;
5113     suppress_error = 0;
5114     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5115     if (r == -1)
5116       return -1;
5117   }
5118   {
5119     char path[] = "/hello";
5120     char *r;
5121     suppress_error = 0;
5122     r = guestfs_cat (g, path);
5123     if (r == NULL)
5124       return -1;
5125     if (strcmp (r, expected) != 0) {
5126       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5127       return -1;
5128     }
5129     free (r);
5130   }
5131   return 0;
5132 }
5133
5134 static int test_checksum_0_skip (void)
5135 {
5136   const char *str;
5137
5138   str = getenv ("SKIP_TEST_CHECKSUM_0");
5139   if (str && strcmp (str, "1") == 0) return 1;
5140   str = getenv ("SKIP_TEST_CHECKSUM");
5141   if (str && strcmp (str, "1") == 0) return 1;
5142   return 0;
5143 }
5144
5145 static int test_checksum_0 (void)
5146 {
5147   if (test_checksum_0_skip ()) {
5148     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5149     return 0;
5150   }
5151
5152   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5153   {
5154     char device[] = "/dev/sda";
5155     device[5] = devchar;
5156     int r;
5157     suppress_error = 0;
5158     r = guestfs_blockdev_setrw (g, device);
5159     if (r == -1)
5160       return -1;
5161   }
5162   {
5163     int r;
5164     suppress_error = 0;
5165     r = guestfs_umount_all (g);
5166     if (r == -1)
5167       return -1;
5168   }
5169   {
5170     int r;
5171     suppress_error = 0;
5172     r = guestfs_lvm_remove_all (g);
5173     if (r == -1)
5174       return -1;
5175   }
5176   {
5177     char device[] = "/dev/sda";
5178     device[5] = devchar;
5179     char lines_0[] = ",";
5180     char *lines[] = {
5181       lines_0,
5182       NULL
5183     };
5184     int r;
5185     suppress_error = 0;
5186     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5187     if (r == -1)
5188       return -1;
5189   }
5190   {
5191     char fstype[] = "ext2";
5192     char device[] = "/dev/sda1";
5193     device[5] = devchar;
5194     int r;
5195     suppress_error = 0;
5196     r = guestfs_mkfs (g, fstype, device);
5197     if (r == -1)
5198       return -1;
5199   }
5200   {
5201     char device[] = "/dev/sda1";
5202     device[5] = devchar;
5203     char mountpoint[] = "/";
5204     int r;
5205     suppress_error = 0;
5206     r = guestfs_mount (g, device, mountpoint);
5207     if (r == -1)
5208       return -1;
5209   }
5210   /* TestOutput for checksum (0) */
5211   char expected[] = "935282863";
5212   {
5213     char path[] = "/new";
5214     char content[] = "test\n";
5215     int r;
5216     suppress_error = 0;
5217     r = guestfs_write_file (g, path, content, 0);
5218     if (r == -1)
5219       return -1;
5220   }
5221   {
5222     char csumtype[] = "crc";
5223     char path[] = "/new";
5224     char *r;
5225     suppress_error = 0;
5226     r = guestfs_checksum (g, csumtype, path);
5227     if (r == NULL)
5228       return -1;
5229     if (strcmp (r, expected) != 0) {
5230       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5231       return -1;
5232     }
5233     free (r);
5234   }
5235   return 0;
5236 }
5237
5238 static int test_checksum_1_skip (void)
5239 {
5240   const char *str;
5241
5242   str = getenv ("SKIP_TEST_CHECKSUM_1");
5243   if (str && strcmp (str, "1") == 0) return 1;
5244   str = getenv ("SKIP_TEST_CHECKSUM");
5245   if (str && strcmp (str, "1") == 0) return 1;
5246   return 0;
5247 }
5248
5249 static int test_checksum_1 (void)
5250 {
5251   if (test_checksum_1_skip ()) {
5252     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5253     return 0;
5254   }
5255
5256   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5257   {
5258     char device[] = "/dev/sda";
5259     device[5] = devchar;
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     device[5] = devchar;
5283     char lines_0[] = ",";
5284     char *lines[] = {
5285       lines_0,
5286       NULL
5287     };
5288     int r;
5289     suppress_error = 0;
5290     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5291     if (r == -1)
5292       return -1;
5293   }
5294   {
5295     char fstype[] = "ext2";
5296     char device[] = "/dev/sda1";
5297     device[5] = devchar;
5298     int r;
5299     suppress_error = 0;
5300     r = guestfs_mkfs (g, fstype, device);
5301     if (r == -1)
5302       return -1;
5303   }
5304   {
5305     char device[] = "/dev/sda1";
5306     device[5] = devchar;
5307     char mountpoint[] = "/";
5308     int r;
5309     suppress_error = 0;
5310     r = guestfs_mount (g, device, mountpoint);
5311     if (r == -1)
5312       return -1;
5313   }
5314   /* TestLastFail for checksum (1) */
5315   {
5316     char csumtype[] = "crc";
5317     char path[] = "/new";
5318     char *r;
5319     suppress_error = 1;
5320     r = guestfs_checksum (g, csumtype, path);
5321     if (r != NULL)
5322       return -1;
5323     free (r);
5324   }
5325   return 0;
5326 }
5327
5328 static int test_checksum_2_skip (void)
5329 {
5330   const char *str;
5331
5332   str = getenv ("SKIP_TEST_CHECKSUM_2");
5333   if (str && strcmp (str, "1") == 0) return 1;
5334   str = getenv ("SKIP_TEST_CHECKSUM");
5335   if (str && strcmp (str, "1") == 0) return 1;
5336   return 0;
5337 }
5338
5339 static int test_checksum_2 (void)
5340 {
5341   if (test_checksum_2_skip ()) {
5342     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5343     return 0;
5344   }
5345
5346   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5347   {
5348     char device[] = "/dev/sda";
5349     device[5] = devchar;
5350     int r;
5351     suppress_error = 0;
5352     r = guestfs_blockdev_setrw (g, device);
5353     if (r == -1)
5354       return -1;
5355   }
5356   {
5357     int r;
5358     suppress_error = 0;
5359     r = guestfs_umount_all (g);
5360     if (r == -1)
5361       return -1;
5362   }
5363   {
5364     int r;
5365     suppress_error = 0;
5366     r = guestfs_lvm_remove_all (g);
5367     if (r == -1)
5368       return -1;
5369   }
5370   {
5371     char device[] = "/dev/sda";
5372     device[5] = devchar;
5373     char lines_0[] = ",";
5374     char *lines[] = {
5375       lines_0,
5376       NULL
5377     };
5378     int r;
5379     suppress_error = 0;
5380     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5381     if (r == -1)
5382       return -1;
5383   }
5384   {
5385     char fstype[] = "ext2";
5386     char device[] = "/dev/sda1";
5387     device[5] = devchar;
5388     int r;
5389     suppress_error = 0;
5390     r = guestfs_mkfs (g, fstype, device);
5391     if (r == -1)
5392       return -1;
5393   }
5394   {
5395     char device[] = "/dev/sda1";
5396     device[5] = devchar;
5397     char mountpoint[] = "/";
5398     int r;
5399     suppress_error = 0;
5400     r = guestfs_mount (g, device, mountpoint);
5401     if (r == -1)
5402       return -1;
5403   }
5404   /* TestOutput for checksum (2) */
5405   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5406   {
5407     char path[] = "/new";
5408     char content[] = "test\n";
5409     int r;
5410     suppress_error = 0;
5411     r = guestfs_write_file (g, path, content, 0);
5412     if (r == -1)
5413       return -1;
5414   }
5415   {
5416     char csumtype[] = "md5";
5417     char path[] = "/new";
5418     char *r;
5419     suppress_error = 0;
5420     r = guestfs_checksum (g, csumtype, path);
5421     if (r == NULL)
5422       return -1;
5423     if (strcmp (r, expected) != 0) {
5424       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5425       return -1;
5426     }
5427     free (r);
5428   }
5429   return 0;
5430 }
5431
5432 static int test_checksum_3_skip (void)
5433 {
5434   const char *str;
5435
5436   str = getenv ("SKIP_TEST_CHECKSUM_3");
5437   if (str && strcmp (str, "1") == 0) return 1;
5438   str = getenv ("SKIP_TEST_CHECKSUM");
5439   if (str && strcmp (str, "1") == 0) return 1;
5440   return 0;
5441 }
5442
5443 static int test_checksum_3 (void)
5444 {
5445   if (test_checksum_3_skip ()) {
5446     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5447     return 0;
5448   }
5449
5450   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5451   {
5452     char device[] = "/dev/sda";
5453     device[5] = devchar;
5454     int r;
5455     suppress_error = 0;
5456     r = guestfs_blockdev_setrw (g, device);
5457     if (r == -1)
5458       return -1;
5459   }
5460   {
5461     int r;
5462     suppress_error = 0;
5463     r = guestfs_umount_all (g);
5464     if (r == -1)
5465       return -1;
5466   }
5467   {
5468     int r;
5469     suppress_error = 0;
5470     r = guestfs_lvm_remove_all (g);
5471     if (r == -1)
5472       return -1;
5473   }
5474   {
5475     char device[] = "/dev/sda";
5476     device[5] = devchar;
5477     char lines_0[] = ",";
5478     char *lines[] = {
5479       lines_0,
5480       NULL
5481     };
5482     int r;
5483     suppress_error = 0;
5484     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5485     if (r == -1)
5486       return -1;
5487   }
5488   {
5489     char fstype[] = "ext2";
5490     char device[] = "/dev/sda1";
5491     device[5] = devchar;
5492     int r;
5493     suppress_error = 0;
5494     r = guestfs_mkfs (g, fstype, device);
5495     if (r == -1)
5496       return -1;
5497   }
5498   {
5499     char device[] = "/dev/sda1";
5500     device[5] = devchar;
5501     char mountpoint[] = "/";
5502     int r;
5503     suppress_error = 0;
5504     r = guestfs_mount (g, device, mountpoint);
5505     if (r == -1)
5506       return -1;
5507   }
5508   /* TestOutput for checksum (3) */
5509   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5510   {
5511     char path[] = "/new";
5512     char content[] = "test\n";
5513     int r;
5514     suppress_error = 0;
5515     r = guestfs_write_file (g, path, content, 0);
5516     if (r == -1)
5517       return -1;
5518   }
5519   {
5520     char csumtype[] = "sha1";
5521     char path[] = "/new";
5522     char *r;
5523     suppress_error = 0;
5524     r = guestfs_checksum (g, csumtype, path);
5525     if (r == NULL)
5526       return -1;
5527     if (strcmp (r, expected) != 0) {
5528       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5529       return -1;
5530     }
5531     free (r);
5532   }
5533   return 0;
5534 }
5535
5536 static int test_checksum_4_skip (void)
5537 {
5538   const char *str;
5539
5540   str = getenv ("SKIP_TEST_CHECKSUM_4");
5541   if (str && strcmp (str, "1") == 0) return 1;
5542   str = getenv ("SKIP_TEST_CHECKSUM");
5543   if (str && strcmp (str, "1") == 0) return 1;
5544   return 0;
5545 }
5546
5547 static int test_checksum_4 (void)
5548 {
5549   if (test_checksum_4_skip ()) {
5550     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5551     return 0;
5552   }
5553
5554   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5555   {
5556     char device[] = "/dev/sda";
5557     device[5] = devchar;
5558     int r;
5559     suppress_error = 0;
5560     r = guestfs_blockdev_setrw (g, device);
5561     if (r == -1)
5562       return -1;
5563   }
5564   {
5565     int r;
5566     suppress_error = 0;
5567     r = guestfs_umount_all (g);
5568     if (r == -1)
5569       return -1;
5570   }
5571   {
5572     int r;
5573     suppress_error = 0;
5574     r = guestfs_lvm_remove_all (g);
5575     if (r == -1)
5576       return -1;
5577   }
5578   {
5579     char device[] = "/dev/sda";
5580     device[5] = devchar;
5581     char lines_0[] = ",";
5582     char *lines[] = {
5583       lines_0,
5584       NULL
5585     };
5586     int r;
5587     suppress_error = 0;
5588     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5589     if (r == -1)
5590       return -1;
5591   }
5592   {
5593     char fstype[] = "ext2";
5594     char device[] = "/dev/sda1";
5595     device[5] = devchar;
5596     int r;
5597     suppress_error = 0;
5598     r = guestfs_mkfs (g, fstype, device);
5599     if (r == -1)
5600       return -1;
5601   }
5602   {
5603     char device[] = "/dev/sda1";
5604     device[5] = devchar;
5605     char mountpoint[] = "/";
5606     int r;
5607     suppress_error = 0;
5608     r = guestfs_mount (g, device, mountpoint);
5609     if (r == -1)
5610       return -1;
5611   }
5612   /* TestOutput for checksum (4) */
5613   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5614   {
5615     char path[] = "/new";
5616     char content[] = "test\n";
5617     int r;
5618     suppress_error = 0;
5619     r = guestfs_write_file (g, path, content, 0);
5620     if (r == -1)
5621       return -1;
5622   }
5623   {
5624     char csumtype[] = "sha224";
5625     char path[] = "/new";
5626     char *r;
5627     suppress_error = 0;
5628     r = guestfs_checksum (g, csumtype, path);
5629     if (r == NULL)
5630       return -1;
5631     if (strcmp (r, expected) != 0) {
5632       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5633       return -1;
5634     }
5635     free (r);
5636   }
5637   return 0;
5638 }
5639
5640 static int test_checksum_5_skip (void)
5641 {
5642   const char *str;
5643
5644   str = getenv ("SKIP_TEST_CHECKSUM_5");
5645   if (str && strcmp (str, "1") == 0) return 1;
5646   str = getenv ("SKIP_TEST_CHECKSUM");
5647   if (str && strcmp (str, "1") == 0) return 1;
5648   return 0;
5649 }
5650
5651 static int test_checksum_5 (void)
5652 {
5653   if (test_checksum_5_skip ()) {
5654     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5655     return 0;
5656   }
5657
5658   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5659   {
5660     char device[] = "/dev/sda";
5661     device[5] = devchar;
5662     int r;
5663     suppress_error = 0;
5664     r = guestfs_blockdev_setrw (g, device);
5665     if (r == -1)
5666       return -1;
5667   }
5668   {
5669     int r;
5670     suppress_error = 0;
5671     r = guestfs_umount_all (g);
5672     if (r == -1)
5673       return -1;
5674   }
5675   {
5676     int r;
5677     suppress_error = 0;
5678     r = guestfs_lvm_remove_all (g);
5679     if (r == -1)
5680       return -1;
5681   }
5682   {
5683     char device[] = "/dev/sda";
5684     device[5] = devchar;
5685     char lines_0[] = ",";
5686     char *lines[] = {
5687       lines_0,
5688       NULL
5689     };
5690     int r;
5691     suppress_error = 0;
5692     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5693     if (r == -1)
5694       return -1;
5695   }
5696   {
5697     char fstype[] = "ext2";
5698     char device[] = "/dev/sda1";
5699     device[5] = devchar;
5700     int r;
5701     suppress_error = 0;
5702     r = guestfs_mkfs (g, fstype, device);
5703     if (r == -1)
5704       return -1;
5705   }
5706   {
5707     char device[] = "/dev/sda1";
5708     device[5] = devchar;
5709     char mountpoint[] = "/";
5710     int r;
5711     suppress_error = 0;
5712     r = guestfs_mount (g, device, mountpoint);
5713     if (r == -1)
5714       return -1;
5715   }
5716   /* TestOutput for checksum (5) */
5717   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5718   {
5719     char path[] = "/new";
5720     char content[] = "test\n";
5721     int r;
5722     suppress_error = 0;
5723     r = guestfs_write_file (g, path, content, 0);
5724     if (r == -1)
5725       return -1;
5726   }
5727   {
5728     char csumtype[] = "sha256";
5729     char path[] = "/new";
5730     char *r;
5731     suppress_error = 0;
5732     r = guestfs_checksum (g, csumtype, path);
5733     if (r == NULL)
5734       return -1;
5735     if (strcmp (r, expected) != 0) {
5736       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5737       return -1;
5738     }
5739     free (r);
5740   }
5741   return 0;
5742 }
5743
5744 static int test_checksum_6_skip (void)
5745 {
5746   const char *str;
5747
5748   str = getenv ("SKIP_TEST_CHECKSUM_6");
5749   if (str && strcmp (str, "1") == 0) return 1;
5750   str = getenv ("SKIP_TEST_CHECKSUM");
5751   if (str && strcmp (str, "1") == 0) return 1;
5752   return 0;
5753 }
5754
5755 static int test_checksum_6 (void)
5756 {
5757   if (test_checksum_6_skip ()) {
5758     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5759     return 0;
5760   }
5761
5762   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5763   {
5764     char device[] = "/dev/sda";
5765     device[5] = devchar;
5766     int r;
5767     suppress_error = 0;
5768     r = guestfs_blockdev_setrw (g, device);
5769     if (r == -1)
5770       return -1;
5771   }
5772   {
5773     int r;
5774     suppress_error = 0;
5775     r = guestfs_umount_all (g);
5776     if (r == -1)
5777       return -1;
5778   }
5779   {
5780     int r;
5781     suppress_error = 0;
5782     r = guestfs_lvm_remove_all (g);
5783     if (r == -1)
5784       return -1;
5785   }
5786   {
5787     char device[] = "/dev/sda";
5788     device[5] = devchar;
5789     char lines_0[] = ",";
5790     char *lines[] = {
5791       lines_0,
5792       NULL
5793     };
5794     int r;
5795     suppress_error = 0;
5796     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5797     if (r == -1)
5798       return -1;
5799   }
5800   {
5801     char fstype[] = "ext2";
5802     char device[] = "/dev/sda1";
5803     device[5] = devchar;
5804     int r;
5805     suppress_error = 0;
5806     r = guestfs_mkfs (g, fstype, device);
5807     if (r == -1)
5808       return -1;
5809   }
5810   {
5811     char device[] = "/dev/sda1";
5812     device[5] = devchar;
5813     char mountpoint[] = "/";
5814     int r;
5815     suppress_error = 0;
5816     r = guestfs_mount (g, device, mountpoint);
5817     if (r == -1)
5818       return -1;
5819   }
5820   /* TestOutput for checksum (6) */
5821   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5822   {
5823     char path[] = "/new";
5824     char content[] = "test\n";
5825     int r;
5826     suppress_error = 0;
5827     r = guestfs_write_file (g, path, content, 0);
5828     if (r == -1)
5829       return -1;
5830   }
5831   {
5832     char csumtype[] = "sha384";
5833     char path[] = "/new";
5834     char *r;
5835     suppress_error = 0;
5836     r = guestfs_checksum (g, csumtype, path);
5837     if (r == NULL)
5838       return -1;
5839     if (strcmp (r, expected) != 0) {
5840       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5841       return -1;
5842     }
5843     free (r);
5844   }
5845   return 0;
5846 }
5847
5848 static int test_checksum_7_skip (void)
5849 {
5850   const char *str;
5851
5852   str = getenv ("SKIP_TEST_CHECKSUM_7");
5853   if (str && strcmp (str, "1") == 0) return 1;
5854   str = getenv ("SKIP_TEST_CHECKSUM");
5855   if (str && strcmp (str, "1") == 0) return 1;
5856   return 0;
5857 }
5858
5859 static int test_checksum_7 (void)
5860 {
5861   if (test_checksum_7_skip ()) {
5862     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5863     return 0;
5864   }
5865
5866   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5867   {
5868     char device[] = "/dev/sda";
5869     device[5] = devchar;
5870     int r;
5871     suppress_error = 0;
5872     r = guestfs_blockdev_setrw (g, device);
5873     if (r == -1)
5874       return -1;
5875   }
5876   {
5877     int r;
5878     suppress_error = 0;
5879     r = guestfs_umount_all (g);
5880     if (r == -1)
5881       return -1;
5882   }
5883   {
5884     int r;
5885     suppress_error = 0;
5886     r = guestfs_lvm_remove_all (g);
5887     if (r == -1)
5888       return -1;
5889   }
5890   {
5891     char device[] = "/dev/sda";
5892     device[5] = devchar;
5893     char lines_0[] = ",";
5894     char *lines[] = {
5895       lines_0,
5896       NULL
5897     };
5898     int r;
5899     suppress_error = 0;
5900     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5901     if (r == -1)
5902       return -1;
5903   }
5904   {
5905     char fstype[] = "ext2";
5906     char device[] = "/dev/sda1";
5907     device[5] = devchar;
5908     int r;
5909     suppress_error = 0;
5910     r = guestfs_mkfs (g, fstype, device);
5911     if (r == -1)
5912       return -1;
5913   }
5914   {
5915     char device[] = "/dev/sda1";
5916     device[5] = devchar;
5917     char mountpoint[] = "/";
5918     int r;
5919     suppress_error = 0;
5920     r = guestfs_mount (g, device, mountpoint);
5921     if (r == -1)
5922       return -1;
5923   }
5924   /* TestOutput for checksum (7) */
5925   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5926   {
5927     char path[] = "/new";
5928     char content[] = "test\n";
5929     int r;
5930     suppress_error = 0;
5931     r = guestfs_write_file (g, path, content, 0);
5932     if (r == -1)
5933       return -1;
5934   }
5935   {
5936     char csumtype[] = "sha512";
5937     char path[] = "/new";
5938     char *r;
5939     suppress_error = 0;
5940     r = guestfs_checksum (g, csumtype, path);
5941     if (r == NULL)
5942       return -1;
5943     if (strcmp (r, expected) != 0) {
5944       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5945       return -1;
5946     }
5947     free (r);
5948   }
5949   return 0;
5950 }
5951
5952 static int test_checksum_8_skip (void)
5953 {
5954   const char *str;
5955
5956   str = getenv ("SKIP_TEST_CHECKSUM_8");
5957   if (str && strcmp (str, "1") == 0) return 1;
5958   str = getenv ("SKIP_TEST_CHECKSUM");
5959   if (str && strcmp (str, "1") == 0) return 1;
5960   return 0;
5961 }
5962
5963 static int test_checksum_8 (void)
5964 {
5965   if (test_checksum_8_skip ()) {
5966     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
5967     return 0;
5968   }
5969
5970   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
5971   {
5972     char device[] = "/dev/sda";
5973     device[5] = devchar;
5974     int r;
5975     suppress_error = 0;
5976     r = guestfs_blockdev_setrw (g, device);
5977     if (r == -1)
5978       return -1;
5979   }
5980   {
5981     int r;
5982     suppress_error = 0;
5983     r = guestfs_umount_all (g);
5984     if (r == -1)
5985       return -1;
5986   }
5987   {
5988     int r;
5989     suppress_error = 0;
5990     r = guestfs_lvm_remove_all (g);
5991     if (r == -1)
5992       return -1;
5993   }
5994   {
5995     char device[] = "/dev/sda";
5996     device[5] = devchar;
5997     char lines_0[] = ",";
5998     char *lines[] = {
5999       lines_0,
6000       NULL
6001     };
6002     int r;
6003     suppress_error = 0;
6004     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6005     if (r == -1)
6006       return -1;
6007   }
6008   {
6009     char fstype[] = "ext2";
6010     char device[] = "/dev/sda1";
6011     device[5] = devchar;
6012     int r;
6013     suppress_error = 0;
6014     r = guestfs_mkfs (g, fstype, device);
6015     if (r == -1)
6016       return -1;
6017   }
6018   {
6019     char device[] = "/dev/sda1";
6020     device[5] = devchar;
6021     char mountpoint[] = "/";
6022     int r;
6023     suppress_error = 0;
6024     r = guestfs_mount (g, device, mountpoint);
6025     if (r == -1)
6026       return -1;
6027   }
6028   /* TestOutput for checksum (8) */
6029   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6030   {
6031     char device[] = "/dev/sdd";
6032     device[5] = devchar;
6033     char mountpoint[] = "/";
6034     int r;
6035     suppress_error = 0;
6036     r = guestfs_mount (g, device, mountpoint);
6037     if (r == -1)
6038       return -1;
6039   }
6040   {
6041     char csumtype[] = "md5";
6042     char path[] = "/known-3";
6043     char *r;
6044     suppress_error = 0;
6045     r = guestfs_checksum (g, csumtype, path);
6046     if (r == NULL)
6047       return -1;
6048     if (strcmp (r, expected) != 0) {
6049       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6050       return -1;
6051     }
6052     free (r);
6053   }
6054   return 0;
6055 }
6056
6057 static int test_download_0_skip (void)
6058 {
6059   const char *str;
6060
6061   str = getenv ("SKIP_TEST_DOWNLOAD_0");
6062   if (str && strcmp (str, "1") == 0) return 1;
6063   str = getenv ("SKIP_TEST_DOWNLOAD");
6064   if (str && strcmp (str, "1") == 0) return 1;
6065   return 0;
6066 }
6067
6068 static int test_download_0 (void)
6069 {
6070   if (test_download_0_skip ()) {
6071     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6072     return 0;
6073   }
6074
6075   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
6076   {
6077     char device[] = "/dev/sda";
6078     device[5] = devchar;
6079     int r;
6080     suppress_error = 0;
6081     r = guestfs_blockdev_setrw (g, device);
6082     if (r == -1)
6083       return -1;
6084   }
6085   {
6086     int r;
6087     suppress_error = 0;
6088     r = guestfs_umount_all (g);
6089     if (r == -1)
6090       return -1;
6091   }
6092   {
6093     int r;
6094     suppress_error = 0;
6095     r = guestfs_lvm_remove_all (g);
6096     if (r == -1)
6097       return -1;
6098   }
6099   {
6100     char device[] = "/dev/sda";
6101     device[5] = devchar;
6102     char lines_0[] = ",";
6103     char *lines[] = {
6104       lines_0,
6105       NULL
6106     };
6107     int r;
6108     suppress_error = 0;
6109     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6110     if (r == -1)
6111       return -1;
6112   }
6113   {
6114     char fstype[] = "ext2";
6115     char device[] = "/dev/sda1";
6116     device[5] = devchar;
6117     int r;
6118     suppress_error = 0;
6119     r = guestfs_mkfs (g, fstype, device);
6120     if (r == -1)
6121       return -1;
6122   }
6123   {
6124     char device[] = "/dev/sda1";
6125     device[5] = devchar;
6126     char mountpoint[] = "/";
6127     int r;
6128     suppress_error = 0;
6129     r = guestfs_mount (g, device, mountpoint);
6130     if (r == -1)
6131       return -1;
6132   }
6133   /* TestOutput for download (0) */
6134   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6135   {
6136     char remotefilename[] = "/COPYING.LIB";
6137     int r;
6138     suppress_error = 0;
6139     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6140     if (r == -1)
6141       return -1;
6142   }
6143   {
6144     char remotefilename[] = "/COPYING.LIB";
6145     int r;
6146     suppress_error = 0;
6147     r = guestfs_download (g, remotefilename, "testdownload.tmp");
6148     if (r == -1)
6149       return -1;
6150   }
6151   {
6152     char remotefilename[] = "/upload";
6153     int r;
6154     suppress_error = 0;
6155     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6156     if (r == -1)
6157       return -1;
6158   }
6159   {
6160     char csumtype[] = "md5";
6161     char path[] = "/upload";
6162     char *r;
6163     suppress_error = 0;
6164     r = guestfs_checksum (g, csumtype, path);
6165     if (r == NULL)
6166       return -1;
6167     if (strcmp (r, expected) != 0) {
6168       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6169       return -1;
6170     }
6171     free (r);
6172   }
6173   return 0;
6174 }
6175
6176 static int test_upload_0_skip (void)
6177 {
6178   const char *str;
6179
6180   str = getenv ("SKIP_TEST_UPLOAD_0");
6181   if (str && strcmp (str, "1") == 0) return 1;
6182   str = getenv ("SKIP_TEST_UPLOAD");
6183   if (str && strcmp (str, "1") == 0) return 1;
6184   return 0;
6185 }
6186
6187 static int test_upload_0 (void)
6188 {
6189   if (test_upload_0_skip ()) {
6190     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6191     return 0;
6192   }
6193
6194   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6195   {
6196     char device[] = "/dev/sda";
6197     device[5] = devchar;
6198     int r;
6199     suppress_error = 0;
6200     r = guestfs_blockdev_setrw (g, device);
6201     if (r == -1)
6202       return -1;
6203   }
6204   {
6205     int r;
6206     suppress_error = 0;
6207     r = guestfs_umount_all (g);
6208     if (r == -1)
6209       return -1;
6210   }
6211   {
6212     int r;
6213     suppress_error = 0;
6214     r = guestfs_lvm_remove_all (g);
6215     if (r == -1)
6216       return -1;
6217   }
6218   {
6219     char device[] = "/dev/sda";
6220     device[5] = devchar;
6221     char lines_0[] = ",";
6222     char *lines[] = {
6223       lines_0,
6224       NULL
6225     };
6226     int r;
6227     suppress_error = 0;
6228     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6229     if (r == -1)
6230       return -1;
6231   }
6232   {
6233     char fstype[] = "ext2";
6234     char device[] = "/dev/sda1";
6235     device[5] = devchar;
6236     int r;
6237     suppress_error = 0;
6238     r = guestfs_mkfs (g, fstype, device);
6239     if (r == -1)
6240       return -1;
6241   }
6242   {
6243     char device[] = "/dev/sda1";
6244     device[5] = devchar;
6245     char mountpoint[] = "/";
6246     int r;
6247     suppress_error = 0;
6248     r = guestfs_mount (g, device, mountpoint);
6249     if (r == -1)
6250       return -1;
6251   }
6252   /* TestOutput for upload (0) */
6253   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6254   {
6255     char remotefilename[] = "/COPYING.LIB";
6256     int r;
6257     suppress_error = 0;
6258     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6259     if (r == -1)
6260       return -1;
6261   }
6262   {
6263     char csumtype[] = "md5";
6264     char path[] = "/COPYING.LIB";
6265     char *r;
6266     suppress_error = 0;
6267     r = guestfs_checksum (g, csumtype, path);
6268     if (r == NULL)
6269       return -1;
6270     if (strcmp (r, expected) != 0) {
6271       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6272       return -1;
6273     }
6274     free (r);
6275   }
6276   return 0;
6277 }
6278
6279 static int test_blockdev_rereadpt_0_skip (void)
6280 {
6281   const char *str;
6282
6283   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6284   if (str && strcmp (str, "1") == 0) return 1;
6285   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6286   if (str && strcmp (str, "1") == 0) return 1;
6287   return 0;
6288 }
6289
6290 static int test_blockdev_rereadpt_0 (void)
6291 {
6292   if (test_blockdev_rereadpt_0_skip ()) {
6293     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6294     return 0;
6295   }
6296
6297   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6298   {
6299     char device[] = "/dev/sda";
6300     device[5] = devchar;
6301     int r;
6302     suppress_error = 0;
6303     r = guestfs_blockdev_setrw (g, device);
6304     if (r == -1)
6305       return -1;
6306   }
6307   {
6308     int r;
6309     suppress_error = 0;
6310     r = guestfs_umount_all (g);
6311     if (r == -1)
6312       return -1;
6313   }
6314   {
6315     int r;
6316     suppress_error = 0;
6317     r = guestfs_lvm_remove_all (g);
6318     if (r == -1)
6319       return -1;
6320   }
6321   /* TestRun for blockdev_rereadpt (0) */
6322   {
6323     char device[] = "/dev/sda";
6324     device[5] = devchar;
6325     int r;
6326     suppress_error = 0;
6327     r = guestfs_blockdev_rereadpt (g, device);
6328     if (r == -1)
6329       return -1;
6330   }
6331   return 0;
6332 }
6333
6334 static int test_blockdev_flushbufs_0_skip (void)
6335 {
6336   const char *str;
6337
6338   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6339   if (str && strcmp (str, "1") == 0) return 1;
6340   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6341   if (str && strcmp (str, "1") == 0) return 1;
6342   return 0;
6343 }
6344
6345 static int test_blockdev_flushbufs_0 (void)
6346 {
6347   if (test_blockdev_flushbufs_0_skip ()) {
6348     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6349     return 0;
6350   }
6351
6352   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6353   {
6354     char device[] = "/dev/sda";
6355     device[5] = devchar;
6356     int r;
6357     suppress_error = 0;
6358     r = guestfs_blockdev_setrw (g, device);
6359     if (r == -1)
6360       return -1;
6361   }
6362   {
6363     int r;
6364     suppress_error = 0;
6365     r = guestfs_umount_all (g);
6366     if (r == -1)
6367       return -1;
6368   }
6369   {
6370     int r;
6371     suppress_error = 0;
6372     r = guestfs_lvm_remove_all (g);
6373     if (r == -1)
6374       return -1;
6375   }
6376   /* TestRun for blockdev_flushbufs (0) */
6377   {
6378     char device[] = "/dev/sda";
6379     device[5] = devchar;
6380     int r;
6381     suppress_error = 0;
6382     r = guestfs_blockdev_flushbufs (g, device);
6383     if (r == -1)
6384       return -1;
6385   }
6386   return 0;
6387 }
6388
6389 static int test_blockdev_getsize64_0_skip (void)
6390 {
6391   const char *str;
6392
6393   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6394   if (str && strcmp (str, "1") == 0) return 1;
6395   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6396   if (str && strcmp (str, "1") == 0) return 1;
6397   return 0;
6398 }
6399
6400 static int test_blockdev_getsize64_0 (void)
6401 {
6402   if (test_blockdev_getsize64_0_skip ()) {
6403     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6404     return 0;
6405   }
6406
6407   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6408   {
6409     char device[] = "/dev/sda";
6410     device[5] = devchar;
6411     int r;
6412     suppress_error = 0;
6413     r = guestfs_blockdev_setrw (g, device);
6414     if (r == -1)
6415       return -1;
6416   }
6417   {
6418     int r;
6419     suppress_error = 0;
6420     r = guestfs_umount_all (g);
6421     if (r == -1)
6422       return -1;
6423   }
6424   {
6425     int r;
6426     suppress_error = 0;
6427     r = guestfs_lvm_remove_all (g);
6428     if (r == -1)
6429       return -1;
6430   }
6431   /* TestOutputInt for blockdev_getsize64 (0) */
6432   {
6433     char device[] = "/dev/sda";
6434     device[5] = devchar;
6435     int64_t r;
6436     suppress_error = 0;
6437     r = guestfs_blockdev_getsize64 (g, device);
6438     if (r == -1)
6439       return -1;
6440     if (r != 524288000) {
6441       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
6442       return -1;
6443     }
6444   }
6445   return 0;
6446 }
6447
6448 static int test_blockdev_getsz_0_skip (void)
6449 {
6450   const char *str;
6451
6452   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6453   if (str && strcmp (str, "1") == 0) return 1;
6454   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6455   if (str && strcmp (str, "1") == 0) return 1;
6456   return 0;
6457 }
6458
6459 static int test_blockdev_getsz_0 (void)
6460 {
6461   if (test_blockdev_getsz_0_skip ()) {
6462     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6463     return 0;
6464   }
6465
6466   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6467   {
6468     char device[] = "/dev/sda";
6469     device[5] = devchar;
6470     int r;
6471     suppress_error = 0;
6472     r = guestfs_blockdev_setrw (g, device);
6473     if (r == -1)
6474       return -1;
6475   }
6476   {
6477     int r;
6478     suppress_error = 0;
6479     r = guestfs_umount_all (g);
6480     if (r == -1)
6481       return -1;
6482   }
6483   {
6484     int r;
6485     suppress_error = 0;
6486     r = guestfs_lvm_remove_all (g);
6487     if (r == -1)
6488       return -1;
6489   }
6490   /* TestOutputInt for blockdev_getsz (0) */
6491   {
6492     char device[] = "/dev/sda";
6493     device[5] = devchar;
6494     int64_t r;
6495     suppress_error = 0;
6496     r = guestfs_blockdev_getsz (g, device);
6497     if (r == -1)
6498       return -1;
6499     if (r != 1024000) {
6500       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
6501       return -1;
6502     }
6503   }
6504   return 0;
6505 }
6506
6507 static int test_blockdev_getbsz_0_skip (void)
6508 {
6509   const char *str;
6510
6511   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6512   if (str && strcmp (str, "1") == 0) return 1;
6513   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6514   if (str && strcmp (str, "1") == 0) return 1;
6515   return 0;
6516 }
6517
6518 static int test_blockdev_getbsz_0 (void)
6519 {
6520   if (test_blockdev_getbsz_0_skip ()) {
6521     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6522     return 0;
6523   }
6524
6525   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6526   {
6527     char device[] = "/dev/sda";
6528     device[5] = devchar;
6529     int r;
6530     suppress_error = 0;
6531     r = guestfs_blockdev_setrw (g, device);
6532     if (r == -1)
6533       return -1;
6534   }
6535   {
6536     int r;
6537     suppress_error = 0;
6538     r = guestfs_umount_all (g);
6539     if (r == -1)
6540       return -1;
6541   }
6542   {
6543     int r;
6544     suppress_error = 0;
6545     r = guestfs_lvm_remove_all (g);
6546     if (r == -1)
6547       return -1;
6548   }
6549   /* TestOutputInt for blockdev_getbsz (0) */
6550   {
6551     char device[] = "/dev/sda";
6552     device[5] = devchar;
6553     int r;
6554     suppress_error = 0;
6555     r = guestfs_blockdev_getbsz (g, device);
6556     if (r == -1)
6557       return -1;
6558     if (r != 4096) {
6559       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
6560       return -1;
6561     }
6562   }
6563   return 0;
6564 }
6565
6566 static int test_blockdev_getss_0_skip (void)
6567 {
6568   const char *str;
6569
6570   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6571   if (str && strcmp (str, "1") == 0) return 1;
6572   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6573   if (str && strcmp (str, "1") == 0) return 1;
6574   return 0;
6575 }
6576
6577 static int test_blockdev_getss_0 (void)
6578 {
6579   if (test_blockdev_getss_0_skip ()) {
6580     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6581     return 0;
6582   }
6583
6584   /* InitNone|InitEmpty for test_blockdev_getss_0 */
6585   {
6586     char device[] = "/dev/sda";
6587     device[5] = devchar;
6588     int r;
6589     suppress_error = 0;
6590     r = guestfs_blockdev_setrw (g, device);
6591     if (r == -1)
6592       return -1;
6593   }
6594   {
6595     int r;
6596     suppress_error = 0;
6597     r = guestfs_umount_all (g);
6598     if (r == -1)
6599       return -1;
6600   }
6601   {
6602     int r;
6603     suppress_error = 0;
6604     r = guestfs_lvm_remove_all (g);
6605     if (r == -1)
6606       return -1;
6607   }
6608   /* TestOutputInt for blockdev_getss (0) */
6609   {
6610     char device[] = "/dev/sda";
6611     device[5] = devchar;
6612     int r;
6613     suppress_error = 0;
6614     r = guestfs_blockdev_getss (g, device);
6615     if (r == -1)
6616       return -1;
6617     if (r != 512) {
6618       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
6619       return -1;
6620     }
6621   }
6622   return 0;
6623 }
6624
6625 static int test_blockdev_getro_0_skip (void)
6626 {
6627   const char *str;
6628
6629   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6630   if (str && strcmp (str, "1") == 0) return 1;
6631   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6632   if (str && strcmp (str, "1") == 0) return 1;
6633   return 0;
6634 }
6635
6636 static int test_blockdev_getro_0 (void)
6637 {
6638   if (test_blockdev_getro_0_skip ()) {
6639     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6640     return 0;
6641   }
6642
6643   /* InitNone|InitEmpty for test_blockdev_getro_0 */
6644   {
6645     char device[] = "/dev/sda";
6646     device[5] = devchar;
6647     int r;
6648     suppress_error = 0;
6649     r = guestfs_blockdev_setrw (g, device);
6650     if (r == -1)
6651       return -1;
6652   }
6653   {
6654     int r;
6655     suppress_error = 0;
6656     r = guestfs_umount_all (g);
6657     if (r == -1)
6658       return -1;
6659   }
6660   {
6661     int r;
6662     suppress_error = 0;
6663     r = guestfs_lvm_remove_all (g);
6664     if (r == -1)
6665       return -1;
6666   }
6667   /* TestOutputTrue for blockdev_getro (0) */
6668   {
6669     char device[] = "/dev/sda";
6670     device[5] = devchar;
6671     int r;
6672     suppress_error = 0;
6673     r = guestfs_blockdev_setro (g, device);
6674     if (r == -1)
6675       return -1;
6676   }
6677   {
6678     char device[] = "/dev/sda";
6679     device[5] = devchar;
6680     int r;
6681     suppress_error = 0;
6682     r = guestfs_blockdev_getro (g, device);
6683     if (r == -1)
6684       return -1;
6685     if (!r) {
6686       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6687       return -1;
6688     }
6689   }
6690   return 0;
6691 }
6692
6693 static int test_blockdev_setrw_0_skip (void)
6694 {
6695   const char *str;
6696
6697   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6698   if (str && strcmp (str, "1") == 0) return 1;
6699   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6700   if (str && strcmp (str, "1") == 0) return 1;
6701   return 0;
6702 }
6703
6704 static int test_blockdev_setrw_0 (void)
6705 {
6706   if (test_blockdev_setrw_0_skip ()) {
6707     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6708     return 0;
6709   }
6710
6711   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6712   {
6713     char device[] = "/dev/sda";
6714     device[5] = devchar;
6715     int r;
6716     suppress_error = 0;
6717     r = guestfs_blockdev_setrw (g, device);
6718     if (r == -1)
6719       return -1;
6720   }
6721   {
6722     int r;
6723     suppress_error = 0;
6724     r = guestfs_umount_all (g);
6725     if (r == -1)
6726       return -1;
6727   }
6728   {
6729     int r;
6730     suppress_error = 0;
6731     r = guestfs_lvm_remove_all (g);
6732     if (r == -1)
6733       return -1;
6734   }
6735   /* TestOutputFalse for blockdev_setrw (0) */
6736   {
6737     char device[] = "/dev/sda";
6738     device[5] = devchar;
6739     int r;
6740     suppress_error = 0;
6741     r = guestfs_blockdev_setrw (g, device);
6742     if (r == -1)
6743       return -1;
6744   }
6745   {
6746     char device[] = "/dev/sda";
6747     device[5] = devchar;
6748     int r;
6749     suppress_error = 0;
6750     r = guestfs_blockdev_getro (g, device);
6751     if (r == -1)
6752       return -1;
6753     if (r) {
6754       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6755       return -1;
6756     }
6757   }
6758   return 0;
6759 }
6760
6761 static int test_blockdev_setro_0_skip (void)
6762 {
6763   const char *str;
6764
6765   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6766   if (str && strcmp (str, "1") == 0) return 1;
6767   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6768   if (str && strcmp (str, "1") == 0) return 1;
6769   return 0;
6770 }
6771
6772 static int test_blockdev_setro_0 (void)
6773 {
6774   if (test_blockdev_setro_0_skip ()) {
6775     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6776     return 0;
6777   }
6778
6779   /* InitNone|InitEmpty for test_blockdev_setro_0 */
6780   {
6781     char device[] = "/dev/sda";
6782     device[5] = devchar;
6783     int r;
6784     suppress_error = 0;
6785     r = guestfs_blockdev_setrw (g, device);
6786     if (r == -1)
6787       return -1;
6788   }
6789   {
6790     int r;
6791     suppress_error = 0;
6792     r = guestfs_umount_all (g);
6793     if (r == -1)
6794       return -1;
6795   }
6796   {
6797     int r;
6798     suppress_error = 0;
6799     r = guestfs_lvm_remove_all (g);
6800     if (r == -1)
6801       return -1;
6802   }
6803   /* TestOutputTrue for blockdev_setro (0) */
6804   {
6805     char device[] = "/dev/sda";
6806     device[5] = devchar;
6807     int r;
6808     suppress_error = 0;
6809     r = guestfs_blockdev_setro (g, device);
6810     if (r == -1)
6811       return -1;
6812   }
6813   {
6814     char device[] = "/dev/sda";
6815     device[5] = devchar;
6816     int r;
6817     suppress_error = 0;
6818     r = guestfs_blockdev_getro (g, device);
6819     if (r == -1)
6820       return -1;
6821     if (!r) {
6822       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6823       return -1;
6824     }
6825   }
6826   return 0;
6827 }
6828
6829 static int test_statvfs_0_skip (void)
6830 {
6831   const char *str;
6832
6833   str = getenv ("SKIP_TEST_STATVFS_0");
6834   if (str && strcmp (str, "1") == 0) return 1;
6835   str = getenv ("SKIP_TEST_STATVFS");
6836   if (str && strcmp (str, "1") == 0) return 1;
6837   return 0;
6838 }
6839
6840 static int test_statvfs_0 (void)
6841 {
6842   if (test_statvfs_0_skip ()) {
6843     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6844     return 0;
6845   }
6846
6847   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6848   {
6849     char device[] = "/dev/sda";
6850     device[5] = devchar;
6851     int r;
6852     suppress_error = 0;
6853     r = guestfs_blockdev_setrw (g, device);
6854     if (r == -1)
6855       return -1;
6856   }
6857   {
6858     int r;
6859     suppress_error = 0;
6860     r = guestfs_umount_all (g);
6861     if (r == -1)
6862       return -1;
6863   }
6864   {
6865     int r;
6866     suppress_error = 0;
6867     r = guestfs_lvm_remove_all (g);
6868     if (r == -1)
6869       return -1;
6870   }
6871   {
6872     char device[] = "/dev/sda";
6873     device[5] = devchar;
6874     char lines_0[] = ",";
6875     char *lines[] = {
6876       lines_0,
6877       NULL
6878     };
6879     int r;
6880     suppress_error = 0;
6881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6882     if (r == -1)
6883       return -1;
6884   }
6885   {
6886     char fstype[] = "ext2";
6887     char device[] = "/dev/sda1";
6888     device[5] = devchar;
6889     int r;
6890     suppress_error = 0;
6891     r = guestfs_mkfs (g, fstype, device);
6892     if (r == -1)
6893       return -1;
6894   }
6895   {
6896     char device[] = "/dev/sda1";
6897     device[5] = devchar;
6898     char mountpoint[] = "/";
6899     int r;
6900     suppress_error = 0;
6901     r = guestfs_mount (g, device, mountpoint);
6902     if (r == -1)
6903       return -1;
6904   }
6905   /* TestOutputStruct for statvfs (0) */
6906   {
6907     char path[] = "/";
6908     struct guestfs_statvfs *r;
6909     suppress_error = 0;
6910     r = guestfs_statvfs (g, path);
6911     if (r == NULL)
6912       return -1;
6913     if (r->bfree != 487702) {
6914       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6915                (int) r->bfree);
6916       return -1;
6917     }
6918     if (r->blocks != 490020) {
6919       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6920                (int) r->blocks);
6921       return -1;
6922     }
6923     if (r->bsize != 1024) {
6924       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6925                (int) r->bsize);
6926       return -1;
6927     }
6928     free (r);
6929   }
6930   return 0;
6931 }
6932
6933 static int test_lstat_0_skip (void)
6934 {
6935   const char *str;
6936
6937   str = getenv ("SKIP_TEST_LSTAT_0");
6938   if (str && strcmp (str, "1") == 0) return 1;
6939   str = getenv ("SKIP_TEST_LSTAT");
6940   if (str && strcmp (str, "1") == 0) return 1;
6941   return 0;
6942 }
6943
6944 static int test_lstat_0 (void)
6945 {
6946   if (test_lstat_0_skip ()) {
6947     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6948     return 0;
6949   }
6950
6951   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6952   {
6953     char device[] = "/dev/sda";
6954     device[5] = devchar;
6955     int r;
6956     suppress_error = 0;
6957     r = guestfs_blockdev_setrw (g, device);
6958     if (r == -1)
6959       return -1;
6960   }
6961   {
6962     int r;
6963     suppress_error = 0;
6964     r = guestfs_umount_all (g);
6965     if (r == -1)
6966       return -1;
6967   }
6968   {
6969     int r;
6970     suppress_error = 0;
6971     r = guestfs_lvm_remove_all (g);
6972     if (r == -1)
6973       return -1;
6974   }
6975   {
6976     char device[] = "/dev/sda";
6977     device[5] = devchar;
6978     char lines_0[] = ",";
6979     char *lines[] = {
6980       lines_0,
6981       NULL
6982     };
6983     int r;
6984     suppress_error = 0;
6985     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6986     if (r == -1)
6987       return -1;
6988   }
6989   {
6990     char fstype[] = "ext2";
6991     char device[] = "/dev/sda1";
6992     device[5] = devchar;
6993     int r;
6994     suppress_error = 0;
6995     r = guestfs_mkfs (g, fstype, device);
6996     if (r == -1)
6997       return -1;
6998   }
6999   {
7000     char device[] = "/dev/sda1";
7001     device[5] = devchar;
7002     char mountpoint[] = "/";
7003     int r;
7004     suppress_error = 0;
7005     r = guestfs_mount (g, device, mountpoint);
7006     if (r == -1)
7007       return -1;
7008   }
7009   /* TestOutputStruct for lstat (0) */
7010   {
7011     char path[] = "/new";
7012     int r;
7013     suppress_error = 0;
7014     r = guestfs_touch (g, path);
7015     if (r == -1)
7016       return -1;
7017   }
7018   {
7019     char path[] = "/new";
7020     struct guestfs_stat *r;
7021     suppress_error = 0;
7022     r = guestfs_lstat (g, path);
7023     if (r == NULL)
7024       return -1;
7025     if (r->size != 0) {
7026       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7027                (int) r->size);
7028       return -1;
7029     }
7030     free (r);
7031   }
7032   return 0;
7033 }
7034
7035 static int test_stat_0_skip (void)
7036 {
7037   const char *str;
7038
7039   str = getenv ("SKIP_TEST_STAT_0");
7040   if (str && strcmp (str, "1") == 0) return 1;
7041   str = getenv ("SKIP_TEST_STAT");
7042   if (str && strcmp (str, "1") == 0) return 1;
7043   return 0;
7044 }
7045
7046 static int test_stat_0 (void)
7047 {
7048   if (test_stat_0_skip ()) {
7049     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7050     return 0;
7051   }
7052
7053   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7054   {
7055     char device[] = "/dev/sda";
7056     device[5] = devchar;
7057     int r;
7058     suppress_error = 0;
7059     r = guestfs_blockdev_setrw (g, device);
7060     if (r == -1)
7061       return -1;
7062   }
7063   {
7064     int r;
7065     suppress_error = 0;
7066     r = guestfs_umount_all (g);
7067     if (r == -1)
7068       return -1;
7069   }
7070   {
7071     int r;
7072     suppress_error = 0;
7073     r = guestfs_lvm_remove_all (g);
7074     if (r == -1)
7075       return -1;
7076   }
7077   {
7078     char device[] = "/dev/sda";
7079     device[5] = devchar;
7080     char lines_0[] = ",";
7081     char *lines[] = {
7082       lines_0,
7083       NULL
7084     };
7085     int r;
7086     suppress_error = 0;
7087     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7088     if (r == -1)
7089       return -1;
7090   }
7091   {
7092     char fstype[] = "ext2";
7093     char device[] = "/dev/sda1";
7094     device[5] = devchar;
7095     int r;
7096     suppress_error = 0;
7097     r = guestfs_mkfs (g, fstype, device);
7098     if (r == -1)
7099       return -1;
7100   }
7101   {
7102     char device[] = "/dev/sda1";
7103     device[5] = devchar;
7104     char mountpoint[] = "/";
7105     int r;
7106     suppress_error = 0;
7107     r = guestfs_mount (g, device, mountpoint);
7108     if (r == -1)
7109       return -1;
7110   }
7111   /* TestOutputStruct for stat (0) */
7112   {
7113     char path[] = "/new";
7114     int r;
7115     suppress_error = 0;
7116     r = guestfs_touch (g, path);
7117     if (r == -1)
7118       return -1;
7119   }
7120   {
7121     char path[] = "/new";
7122     struct guestfs_stat *r;
7123     suppress_error = 0;
7124     r = guestfs_stat (g, path);
7125     if (r == NULL)
7126       return -1;
7127     if (r->size != 0) {
7128       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7129                (int) r->size);
7130       return -1;
7131     }
7132     free (r);
7133   }
7134   return 0;
7135 }
7136
7137 static int test_command_lines_0_skip (void)
7138 {
7139   const char *str;
7140
7141   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7142   if (str && strcmp (str, "1") == 0) return 1;
7143   str = getenv ("SKIP_TEST_COMMAND_LINES");
7144   if (str && strcmp (str, "1") == 0) return 1;
7145   return 0;
7146 }
7147
7148 static int test_command_lines_0 (void)
7149 {
7150   if (test_command_lines_0_skip ()) {
7151     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7152     return 0;
7153   }
7154
7155   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7156   {
7157     char device[] = "/dev/sda";
7158     device[5] = devchar;
7159     int r;
7160     suppress_error = 0;
7161     r = guestfs_blockdev_setrw (g, device);
7162     if (r == -1)
7163       return -1;
7164   }
7165   {
7166     int r;
7167     suppress_error = 0;
7168     r = guestfs_umount_all (g);
7169     if (r == -1)
7170       return -1;
7171   }
7172   {
7173     int r;
7174     suppress_error = 0;
7175     r = guestfs_lvm_remove_all (g);
7176     if (r == -1)
7177       return -1;
7178   }
7179   {
7180     char device[] = "/dev/sda";
7181     device[5] = devchar;
7182     char lines_0[] = ",";
7183     char *lines[] = {
7184       lines_0,
7185       NULL
7186     };
7187     int r;
7188     suppress_error = 0;
7189     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7190     if (r == -1)
7191       return -1;
7192   }
7193   {
7194     char fstype[] = "ext2";
7195     char device[] = "/dev/sda1";
7196     device[5] = devchar;
7197     int r;
7198     suppress_error = 0;
7199     r = guestfs_mkfs (g, fstype, device);
7200     if (r == -1)
7201       return -1;
7202   }
7203   {
7204     char device[] = "/dev/sda1";
7205     device[5] = devchar;
7206     char mountpoint[] = "/";
7207     int r;
7208     suppress_error = 0;
7209     r = guestfs_mount (g, device, mountpoint);
7210     if (r == -1)
7211       return -1;
7212   }
7213   /* TestOutputList for command_lines (0) */
7214   {
7215     char remotefilename[] = "/test-command";
7216     int r;
7217     suppress_error = 0;
7218     r = guestfs_upload (g, "test-command", remotefilename);
7219     if (r == -1)
7220       return -1;
7221   }
7222   {
7223     char path[] = "/test-command";
7224     int r;
7225     suppress_error = 0;
7226     r = guestfs_chmod (g, 493, path);
7227     if (r == -1)
7228       return -1;
7229   }
7230   {
7231     char arguments_0[] = "/test-command";
7232     char arguments_1[] = "1";
7233     char *arguments[] = {
7234       arguments_0,
7235       arguments_1,
7236       NULL
7237     };
7238     char **r;
7239     int i;
7240     suppress_error = 0;
7241     r = guestfs_command_lines (g, arguments);
7242     if (r == NULL)
7243       return -1;
7244     if (!r[0]) {
7245       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7246       print_strings (r);
7247       return -1;
7248     }
7249     {
7250       char expected[] = "Result1";
7251       if (strcmp (r[0], expected) != 0) {
7252         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7253         return -1;
7254       }
7255     }
7256     if (r[1] != NULL) {
7257       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7258       print_strings (r);
7259       return -1;
7260     }
7261     for (i = 0; r[i] != NULL; ++i)
7262       free (r[i]);
7263     free (r);
7264   }
7265   return 0;
7266 }
7267
7268 static int test_command_lines_1_skip (void)
7269 {
7270   const char *str;
7271
7272   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7273   if (str && strcmp (str, "1") == 0) return 1;
7274   str = getenv ("SKIP_TEST_COMMAND_LINES");
7275   if (str && strcmp (str, "1") == 0) return 1;
7276   return 0;
7277 }
7278
7279 static int test_command_lines_1 (void)
7280 {
7281   if (test_command_lines_1_skip ()) {
7282     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7283     return 0;
7284   }
7285
7286   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7287   {
7288     char device[] = "/dev/sda";
7289     device[5] = devchar;
7290     int r;
7291     suppress_error = 0;
7292     r = guestfs_blockdev_setrw (g, device);
7293     if (r == -1)
7294       return -1;
7295   }
7296   {
7297     int r;
7298     suppress_error = 0;
7299     r = guestfs_umount_all (g);
7300     if (r == -1)
7301       return -1;
7302   }
7303   {
7304     int r;
7305     suppress_error = 0;
7306     r = guestfs_lvm_remove_all (g);
7307     if (r == -1)
7308       return -1;
7309   }
7310   {
7311     char device[] = "/dev/sda";
7312     device[5] = devchar;
7313     char lines_0[] = ",";
7314     char *lines[] = {
7315       lines_0,
7316       NULL
7317     };
7318     int r;
7319     suppress_error = 0;
7320     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7321     if (r == -1)
7322       return -1;
7323   }
7324   {
7325     char fstype[] = "ext2";
7326     char device[] = "/dev/sda1";
7327     device[5] = devchar;
7328     int r;
7329     suppress_error = 0;
7330     r = guestfs_mkfs (g, fstype, device);
7331     if (r == -1)
7332       return -1;
7333   }
7334   {
7335     char device[] = "/dev/sda1";
7336     device[5] = devchar;
7337     char mountpoint[] = "/";
7338     int r;
7339     suppress_error = 0;
7340     r = guestfs_mount (g, device, mountpoint);
7341     if (r == -1)
7342       return -1;
7343   }
7344   /* TestOutputList for command_lines (1) */
7345   {
7346     char remotefilename[] = "/test-command";
7347     int r;
7348     suppress_error = 0;
7349     r = guestfs_upload (g, "test-command", remotefilename);
7350     if (r == -1)
7351       return -1;
7352   }
7353   {
7354     char path[] = "/test-command";
7355     int r;
7356     suppress_error = 0;
7357     r = guestfs_chmod (g, 493, path);
7358     if (r == -1)
7359       return -1;
7360   }
7361   {
7362     char arguments_0[] = "/test-command";
7363     char arguments_1[] = "2";
7364     char *arguments[] = {
7365       arguments_0,
7366       arguments_1,
7367       NULL
7368     };
7369     char **r;
7370     int i;
7371     suppress_error = 0;
7372     r = guestfs_command_lines (g, arguments);
7373     if (r == NULL)
7374       return -1;
7375     if (!r[0]) {
7376       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7377       print_strings (r);
7378       return -1;
7379     }
7380     {
7381       char expected[] = "Result2";
7382       if (strcmp (r[0], expected) != 0) {
7383         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7384         return -1;
7385       }
7386     }
7387     if (r[1] != NULL) {
7388       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7389       print_strings (r);
7390       return -1;
7391     }
7392     for (i = 0; r[i] != NULL; ++i)
7393       free (r[i]);
7394     free (r);
7395   }
7396   return 0;
7397 }
7398
7399 static int test_command_lines_2_skip (void)
7400 {
7401   const char *str;
7402
7403   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7404   if (str && strcmp (str, "1") == 0) return 1;
7405   str = getenv ("SKIP_TEST_COMMAND_LINES");
7406   if (str && strcmp (str, "1") == 0) return 1;
7407   return 0;
7408 }
7409
7410 static int test_command_lines_2 (void)
7411 {
7412   if (test_command_lines_2_skip ()) {
7413     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7414     return 0;
7415   }
7416
7417   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7418   {
7419     char device[] = "/dev/sda";
7420     device[5] = devchar;
7421     int r;
7422     suppress_error = 0;
7423     r = guestfs_blockdev_setrw (g, device);
7424     if (r == -1)
7425       return -1;
7426   }
7427   {
7428     int r;
7429     suppress_error = 0;
7430     r = guestfs_umount_all (g);
7431     if (r == -1)
7432       return -1;
7433   }
7434   {
7435     int r;
7436     suppress_error = 0;
7437     r = guestfs_lvm_remove_all (g);
7438     if (r == -1)
7439       return -1;
7440   }
7441   {
7442     char device[] = "/dev/sda";
7443     device[5] = devchar;
7444     char lines_0[] = ",";
7445     char *lines[] = {
7446       lines_0,
7447       NULL
7448     };
7449     int r;
7450     suppress_error = 0;
7451     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7452     if (r == -1)
7453       return -1;
7454   }
7455   {
7456     char fstype[] = "ext2";
7457     char device[] = "/dev/sda1";
7458     device[5] = devchar;
7459     int r;
7460     suppress_error = 0;
7461     r = guestfs_mkfs (g, fstype, device);
7462     if (r == -1)
7463       return -1;
7464   }
7465   {
7466     char device[] = "/dev/sda1";
7467     device[5] = devchar;
7468     char mountpoint[] = "/";
7469     int r;
7470     suppress_error = 0;
7471     r = guestfs_mount (g, device, mountpoint);
7472     if (r == -1)
7473       return -1;
7474   }
7475   /* TestOutputList for command_lines (2) */
7476   {
7477     char remotefilename[] = "/test-command";
7478     int r;
7479     suppress_error = 0;
7480     r = guestfs_upload (g, "test-command", remotefilename);
7481     if (r == -1)
7482       return -1;
7483   }
7484   {
7485     char path[] = "/test-command";
7486     int r;
7487     suppress_error = 0;
7488     r = guestfs_chmod (g, 493, path);
7489     if (r == -1)
7490       return -1;
7491   }
7492   {
7493     char arguments_0[] = "/test-command";
7494     char arguments_1[] = "3";
7495     char *arguments[] = {
7496       arguments_0,
7497       arguments_1,
7498       NULL
7499     };
7500     char **r;
7501     int i;
7502     suppress_error = 0;
7503     r = guestfs_command_lines (g, arguments);
7504     if (r == NULL)
7505       return -1;
7506     if (!r[0]) {
7507       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7508       print_strings (r);
7509       return -1;
7510     }
7511     {
7512       char expected[] = "";
7513       if (strcmp (r[0], expected) != 0) {
7514         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7515         return -1;
7516       }
7517     }
7518     if (!r[1]) {
7519       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7520       print_strings (r);
7521       return -1;
7522     }
7523     {
7524       char expected[] = "Result3";
7525       if (strcmp (r[1], expected) != 0) {
7526         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7527         return -1;
7528       }
7529     }
7530     if (r[2] != NULL) {
7531       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7532       print_strings (r);
7533       return -1;
7534     }
7535     for (i = 0; r[i] != NULL; ++i)
7536       free (r[i]);
7537     free (r);
7538   }
7539   return 0;
7540 }
7541
7542 static int test_command_lines_3_skip (void)
7543 {
7544   const char *str;
7545
7546   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7547   if (str && strcmp (str, "1") == 0) return 1;
7548   str = getenv ("SKIP_TEST_COMMAND_LINES");
7549   if (str && strcmp (str, "1") == 0) return 1;
7550   return 0;
7551 }
7552
7553 static int test_command_lines_3 (void)
7554 {
7555   if (test_command_lines_3_skip ()) {
7556     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7557     return 0;
7558   }
7559
7560   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7561   {
7562     char device[] = "/dev/sda";
7563     device[5] = devchar;
7564     int r;
7565     suppress_error = 0;
7566     r = guestfs_blockdev_setrw (g, device);
7567     if (r == -1)
7568       return -1;
7569   }
7570   {
7571     int r;
7572     suppress_error = 0;
7573     r = guestfs_umount_all (g);
7574     if (r == -1)
7575       return -1;
7576   }
7577   {
7578     int r;
7579     suppress_error = 0;
7580     r = guestfs_lvm_remove_all (g);
7581     if (r == -1)
7582       return -1;
7583   }
7584   {
7585     char device[] = "/dev/sda";
7586     device[5] = devchar;
7587     char lines_0[] = ",";
7588     char *lines[] = {
7589       lines_0,
7590       NULL
7591     };
7592     int r;
7593     suppress_error = 0;
7594     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7595     if (r == -1)
7596       return -1;
7597   }
7598   {
7599     char fstype[] = "ext2";
7600     char device[] = "/dev/sda1";
7601     device[5] = devchar;
7602     int r;
7603     suppress_error = 0;
7604     r = guestfs_mkfs (g, fstype, device);
7605     if (r == -1)
7606       return -1;
7607   }
7608   {
7609     char device[] = "/dev/sda1";
7610     device[5] = devchar;
7611     char mountpoint[] = "/";
7612     int r;
7613     suppress_error = 0;
7614     r = guestfs_mount (g, device, mountpoint);
7615     if (r == -1)
7616       return -1;
7617   }
7618   /* TestOutputList for command_lines (3) */
7619   {
7620     char remotefilename[] = "/test-command";
7621     int r;
7622     suppress_error = 0;
7623     r = guestfs_upload (g, "test-command", remotefilename);
7624     if (r == -1)
7625       return -1;
7626   }
7627   {
7628     char path[] = "/test-command";
7629     int r;
7630     suppress_error = 0;
7631     r = guestfs_chmod (g, 493, path);
7632     if (r == -1)
7633       return -1;
7634   }
7635   {
7636     char arguments_0[] = "/test-command";
7637     char arguments_1[] = "4";
7638     char *arguments[] = {
7639       arguments_0,
7640       arguments_1,
7641       NULL
7642     };
7643     char **r;
7644     int i;
7645     suppress_error = 0;
7646     r = guestfs_command_lines (g, arguments);
7647     if (r == NULL)
7648       return -1;
7649     if (!r[0]) {
7650       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7651       print_strings (r);
7652       return -1;
7653     }
7654     {
7655       char expected[] = "";
7656       if (strcmp (r[0], expected) != 0) {
7657         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7658         return -1;
7659       }
7660     }
7661     if (!r[1]) {
7662       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7663       print_strings (r);
7664       return -1;
7665     }
7666     {
7667       char expected[] = "Result4";
7668       if (strcmp (r[1], expected) != 0) {
7669         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7670         return -1;
7671       }
7672     }
7673     if (r[2] != NULL) {
7674       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7675       print_strings (r);
7676       return -1;
7677     }
7678     for (i = 0; r[i] != NULL; ++i)
7679       free (r[i]);
7680     free (r);
7681   }
7682   return 0;
7683 }
7684
7685 static int test_command_lines_4_skip (void)
7686 {
7687   const char *str;
7688
7689   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7690   if (str && strcmp (str, "1") == 0) return 1;
7691   str = getenv ("SKIP_TEST_COMMAND_LINES");
7692   if (str && strcmp (str, "1") == 0) return 1;
7693   return 0;
7694 }
7695
7696 static int test_command_lines_4 (void)
7697 {
7698   if (test_command_lines_4_skip ()) {
7699     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7700     return 0;
7701   }
7702
7703   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7704   {
7705     char device[] = "/dev/sda";
7706     device[5] = devchar;
7707     int r;
7708     suppress_error = 0;
7709     r = guestfs_blockdev_setrw (g, device);
7710     if (r == -1)
7711       return -1;
7712   }
7713   {
7714     int r;
7715     suppress_error = 0;
7716     r = guestfs_umount_all (g);
7717     if (r == -1)
7718       return -1;
7719   }
7720   {
7721     int r;
7722     suppress_error = 0;
7723     r = guestfs_lvm_remove_all (g);
7724     if (r == -1)
7725       return -1;
7726   }
7727   {
7728     char device[] = "/dev/sda";
7729     device[5] = devchar;
7730     char lines_0[] = ",";
7731     char *lines[] = {
7732       lines_0,
7733       NULL
7734     };
7735     int r;
7736     suppress_error = 0;
7737     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7738     if (r == -1)
7739       return -1;
7740   }
7741   {
7742     char fstype[] = "ext2";
7743     char device[] = "/dev/sda1";
7744     device[5] = devchar;
7745     int r;
7746     suppress_error = 0;
7747     r = guestfs_mkfs (g, fstype, device);
7748     if (r == -1)
7749       return -1;
7750   }
7751   {
7752     char device[] = "/dev/sda1";
7753     device[5] = devchar;
7754     char mountpoint[] = "/";
7755     int r;
7756     suppress_error = 0;
7757     r = guestfs_mount (g, device, mountpoint);
7758     if (r == -1)
7759       return -1;
7760   }
7761   /* TestOutputList for command_lines (4) */
7762   {
7763     char remotefilename[] = "/test-command";
7764     int r;
7765     suppress_error = 0;
7766     r = guestfs_upload (g, "test-command", remotefilename);
7767     if (r == -1)
7768       return -1;
7769   }
7770   {
7771     char path[] = "/test-command";
7772     int r;
7773     suppress_error = 0;
7774     r = guestfs_chmod (g, 493, path);
7775     if (r == -1)
7776       return -1;
7777   }
7778   {
7779     char arguments_0[] = "/test-command";
7780     char arguments_1[] = "5";
7781     char *arguments[] = {
7782       arguments_0,
7783       arguments_1,
7784       NULL
7785     };
7786     char **r;
7787     int i;
7788     suppress_error = 0;
7789     r = guestfs_command_lines (g, arguments);
7790     if (r == NULL)
7791       return -1;
7792     if (!r[0]) {
7793       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7794       print_strings (r);
7795       return -1;
7796     }
7797     {
7798       char expected[] = "";
7799       if (strcmp (r[0], expected) != 0) {
7800         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7801         return -1;
7802       }
7803     }
7804     if (!r[1]) {
7805       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7806       print_strings (r);
7807       return -1;
7808     }
7809     {
7810       char expected[] = "Result5";
7811       if (strcmp (r[1], expected) != 0) {
7812         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7813         return -1;
7814       }
7815     }
7816     if (!r[2]) {
7817       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7818       print_strings (r);
7819       return -1;
7820     }
7821     {
7822       char expected[] = "";
7823       if (strcmp (r[2], expected) != 0) {
7824         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7825         return -1;
7826       }
7827     }
7828     if (r[3] != NULL) {
7829       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7830       print_strings (r);
7831       return -1;
7832     }
7833     for (i = 0; r[i] != NULL; ++i)
7834       free (r[i]);
7835     free (r);
7836   }
7837   return 0;
7838 }
7839
7840 static int test_command_lines_5_skip (void)
7841 {
7842   const char *str;
7843
7844   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7845   if (str && strcmp (str, "1") == 0) return 1;
7846   str = getenv ("SKIP_TEST_COMMAND_LINES");
7847   if (str && strcmp (str, "1") == 0) return 1;
7848   return 0;
7849 }
7850
7851 static int test_command_lines_5 (void)
7852 {
7853   if (test_command_lines_5_skip ()) {
7854     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7855     return 0;
7856   }
7857
7858   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7859   {
7860     char device[] = "/dev/sda";
7861     device[5] = devchar;
7862     int r;
7863     suppress_error = 0;
7864     r = guestfs_blockdev_setrw (g, device);
7865     if (r == -1)
7866       return -1;
7867   }
7868   {
7869     int r;
7870     suppress_error = 0;
7871     r = guestfs_umount_all (g);
7872     if (r == -1)
7873       return -1;
7874   }
7875   {
7876     int r;
7877     suppress_error = 0;
7878     r = guestfs_lvm_remove_all (g);
7879     if (r == -1)
7880       return -1;
7881   }
7882   {
7883     char device[] = "/dev/sda";
7884     device[5] = devchar;
7885     char lines_0[] = ",";
7886     char *lines[] = {
7887       lines_0,
7888       NULL
7889     };
7890     int r;
7891     suppress_error = 0;
7892     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7893     if (r == -1)
7894       return -1;
7895   }
7896   {
7897     char fstype[] = "ext2";
7898     char device[] = "/dev/sda1";
7899     device[5] = devchar;
7900     int r;
7901     suppress_error = 0;
7902     r = guestfs_mkfs (g, fstype, device);
7903     if (r == -1)
7904       return -1;
7905   }
7906   {
7907     char device[] = "/dev/sda1";
7908     device[5] = devchar;
7909     char mountpoint[] = "/";
7910     int r;
7911     suppress_error = 0;
7912     r = guestfs_mount (g, device, mountpoint);
7913     if (r == -1)
7914       return -1;
7915   }
7916   /* TestOutputList for command_lines (5) */
7917   {
7918     char remotefilename[] = "/test-command";
7919     int r;
7920     suppress_error = 0;
7921     r = guestfs_upload (g, "test-command", remotefilename);
7922     if (r == -1)
7923       return -1;
7924   }
7925   {
7926     char path[] = "/test-command";
7927     int r;
7928     suppress_error = 0;
7929     r = guestfs_chmod (g, 493, path);
7930     if (r == -1)
7931       return -1;
7932   }
7933   {
7934     char arguments_0[] = "/test-command";
7935     char arguments_1[] = "6";
7936     char *arguments[] = {
7937       arguments_0,
7938       arguments_1,
7939       NULL
7940     };
7941     char **r;
7942     int i;
7943     suppress_error = 0;
7944     r = guestfs_command_lines (g, arguments);
7945     if (r == NULL)
7946       return -1;
7947     if (!r[0]) {
7948       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7949       print_strings (r);
7950       return -1;
7951     }
7952     {
7953       char expected[] = "";
7954       if (strcmp (r[0], expected) != 0) {
7955         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7956         return -1;
7957       }
7958     }
7959     if (!r[1]) {
7960       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7961       print_strings (r);
7962       return -1;
7963     }
7964     {
7965       char expected[] = "";
7966       if (strcmp (r[1], expected) != 0) {
7967         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7968         return -1;
7969       }
7970     }
7971     if (!r[2]) {
7972       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7973       print_strings (r);
7974       return -1;
7975     }
7976     {
7977       char expected[] = "Result6";
7978       if (strcmp (r[2], expected) != 0) {
7979         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7980         return -1;
7981       }
7982     }
7983     if (!r[3]) {
7984       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7985       print_strings (r);
7986       return -1;
7987     }
7988     {
7989       char expected[] = "";
7990       if (strcmp (r[3], expected) != 0) {
7991         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7992         return -1;
7993       }
7994     }
7995     if (r[4] != NULL) {
7996       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7997       print_strings (r);
7998       return -1;
7999     }
8000     for (i = 0; r[i] != NULL; ++i)
8001       free (r[i]);
8002     free (r);
8003   }
8004   return 0;
8005 }
8006
8007 static int test_command_lines_6_skip (void)
8008 {
8009   const char *str;
8010
8011   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8012   if (str && strcmp (str, "1") == 0) return 1;
8013   str = getenv ("SKIP_TEST_COMMAND_LINES");
8014   if (str && strcmp (str, "1") == 0) return 1;
8015   return 0;
8016 }
8017
8018 static int test_command_lines_6 (void)
8019 {
8020   if (test_command_lines_6_skip ()) {
8021     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8022     return 0;
8023   }
8024
8025   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8026   {
8027     char device[] = "/dev/sda";
8028     device[5] = devchar;
8029     int r;
8030     suppress_error = 0;
8031     r = guestfs_blockdev_setrw (g, device);
8032     if (r == -1)
8033       return -1;
8034   }
8035   {
8036     int r;
8037     suppress_error = 0;
8038     r = guestfs_umount_all (g);
8039     if (r == -1)
8040       return -1;
8041   }
8042   {
8043     int r;
8044     suppress_error = 0;
8045     r = guestfs_lvm_remove_all (g);
8046     if (r == -1)
8047       return -1;
8048   }
8049   {
8050     char device[] = "/dev/sda";
8051     device[5] = devchar;
8052     char lines_0[] = ",";
8053     char *lines[] = {
8054       lines_0,
8055       NULL
8056     };
8057     int r;
8058     suppress_error = 0;
8059     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8060     if (r == -1)
8061       return -1;
8062   }
8063   {
8064     char fstype[] = "ext2";
8065     char device[] = "/dev/sda1";
8066     device[5] = devchar;
8067     int r;
8068     suppress_error = 0;
8069     r = guestfs_mkfs (g, fstype, device);
8070     if (r == -1)
8071       return -1;
8072   }
8073   {
8074     char device[] = "/dev/sda1";
8075     device[5] = devchar;
8076     char mountpoint[] = "/";
8077     int r;
8078     suppress_error = 0;
8079     r = guestfs_mount (g, device, mountpoint);
8080     if (r == -1)
8081       return -1;
8082   }
8083   /* TestOutputList for command_lines (6) */
8084   {
8085     char remotefilename[] = "/test-command";
8086     int r;
8087     suppress_error = 0;
8088     r = guestfs_upload (g, "test-command", remotefilename);
8089     if (r == -1)
8090       return -1;
8091   }
8092   {
8093     char path[] = "/test-command";
8094     int r;
8095     suppress_error = 0;
8096     r = guestfs_chmod (g, 493, path);
8097     if (r == -1)
8098       return -1;
8099   }
8100   {
8101     char arguments_0[] = "/test-command";
8102     char arguments_1[] = "7";
8103     char *arguments[] = {
8104       arguments_0,
8105       arguments_1,
8106       NULL
8107     };
8108     char **r;
8109     int i;
8110     suppress_error = 0;
8111     r = guestfs_command_lines (g, arguments);
8112     if (r == NULL)
8113       return -1;
8114     if (r[0] != NULL) {
8115       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8116       print_strings (r);
8117       return -1;
8118     }
8119     for (i = 0; r[i] != NULL; ++i)
8120       free (r[i]);
8121     free (r);
8122   }
8123   return 0;
8124 }
8125
8126 static int test_command_lines_7_skip (void)
8127 {
8128   const char *str;
8129
8130   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8131   if (str && strcmp (str, "1") == 0) return 1;
8132   str = getenv ("SKIP_TEST_COMMAND_LINES");
8133   if (str && strcmp (str, "1") == 0) return 1;
8134   return 0;
8135 }
8136
8137 static int test_command_lines_7 (void)
8138 {
8139   if (test_command_lines_7_skip ()) {
8140     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8141     return 0;
8142   }
8143
8144   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8145   {
8146     char device[] = "/dev/sda";
8147     device[5] = devchar;
8148     int r;
8149     suppress_error = 0;
8150     r = guestfs_blockdev_setrw (g, device);
8151     if (r == -1)
8152       return -1;
8153   }
8154   {
8155     int r;
8156     suppress_error = 0;
8157     r = guestfs_umount_all (g);
8158     if (r == -1)
8159       return -1;
8160   }
8161   {
8162     int r;
8163     suppress_error = 0;
8164     r = guestfs_lvm_remove_all (g);
8165     if (r == -1)
8166       return -1;
8167   }
8168   {
8169     char device[] = "/dev/sda";
8170     device[5] = devchar;
8171     char lines_0[] = ",";
8172     char *lines[] = {
8173       lines_0,
8174       NULL
8175     };
8176     int r;
8177     suppress_error = 0;
8178     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8179     if (r == -1)
8180       return -1;
8181   }
8182   {
8183     char fstype[] = "ext2";
8184     char device[] = "/dev/sda1";
8185     device[5] = devchar;
8186     int r;
8187     suppress_error = 0;
8188     r = guestfs_mkfs (g, fstype, device);
8189     if (r == -1)
8190       return -1;
8191   }
8192   {
8193     char device[] = "/dev/sda1";
8194     device[5] = devchar;
8195     char mountpoint[] = "/";
8196     int r;
8197     suppress_error = 0;
8198     r = guestfs_mount (g, device, mountpoint);
8199     if (r == -1)
8200       return -1;
8201   }
8202   /* TestOutputList for command_lines (7) */
8203   {
8204     char remotefilename[] = "/test-command";
8205     int r;
8206     suppress_error = 0;
8207     r = guestfs_upload (g, "test-command", remotefilename);
8208     if (r == -1)
8209       return -1;
8210   }
8211   {
8212     char path[] = "/test-command";
8213     int r;
8214     suppress_error = 0;
8215     r = guestfs_chmod (g, 493, path);
8216     if (r == -1)
8217       return -1;
8218   }
8219   {
8220     char arguments_0[] = "/test-command";
8221     char arguments_1[] = "8";
8222     char *arguments[] = {
8223       arguments_0,
8224       arguments_1,
8225       NULL
8226     };
8227     char **r;
8228     int i;
8229     suppress_error = 0;
8230     r = guestfs_command_lines (g, arguments);
8231     if (r == NULL)
8232       return -1;
8233     if (!r[0]) {
8234       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8235       print_strings (r);
8236       return -1;
8237     }
8238     {
8239       char expected[] = "";
8240       if (strcmp (r[0], expected) != 0) {
8241         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8242         return -1;
8243       }
8244     }
8245     if (r[1] != NULL) {
8246       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8247       print_strings (r);
8248       return -1;
8249     }
8250     for (i = 0; r[i] != NULL; ++i)
8251       free (r[i]);
8252     free (r);
8253   }
8254   return 0;
8255 }
8256
8257 static int test_command_lines_8_skip (void)
8258 {
8259   const char *str;
8260
8261   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8262   if (str && strcmp (str, "1") == 0) return 1;
8263   str = getenv ("SKIP_TEST_COMMAND_LINES");
8264   if (str && strcmp (str, "1") == 0) return 1;
8265   return 0;
8266 }
8267
8268 static int test_command_lines_8 (void)
8269 {
8270   if (test_command_lines_8_skip ()) {
8271     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8272     return 0;
8273   }
8274
8275   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8276   {
8277     char device[] = "/dev/sda";
8278     device[5] = devchar;
8279     int r;
8280     suppress_error = 0;
8281     r = guestfs_blockdev_setrw (g, device);
8282     if (r == -1)
8283       return -1;
8284   }
8285   {
8286     int r;
8287     suppress_error = 0;
8288     r = guestfs_umount_all (g);
8289     if (r == -1)
8290       return -1;
8291   }
8292   {
8293     int r;
8294     suppress_error = 0;
8295     r = guestfs_lvm_remove_all (g);
8296     if (r == -1)
8297       return -1;
8298   }
8299   {
8300     char device[] = "/dev/sda";
8301     device[5] = devchar;
8302     char lines_0[] = ",";
8303     char *lines[] = {
8304       lines_0,
8305       NULL
8306     };
8307     int r;
8308     suppress_error = 0;
8309     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8310     if (r == -1)
8311       return -1;
8312   }
8313   {
8314     char fstype[] = "ext2";
8315     char device[] = "/dev/sda1";
8316     device[5] = devchar;
8317     int r;
8318     suppress_error = 0;
8319     r = guestfs_mkfs (g, fstype, device);
8320     if (r == -1)
8321       return -1;
8322   }
8323   {
8324     char device[] = "/dev/sda1";
8325     device[5] = devchar;
8326     char mountpoint[] = "/";
8327     int r;
8328     suppress_error = 0;
8329     r = guestfs_mount (g, device, mountpoint);
8330     if (r == -1)
8331       return -1;
8332   }
8333   /* TestOutputList for command_lines (8) */
8334   {
8335     char remotefilename[] = "/test-command";
8336     int r;
8337     suppress_error = 0;
8338     r = guestfs_upload (g, "test-command", remotefilename);
8339     if (r == -1)
8340       return -1;
8341   }
8342   {
8343     char path[] = "/test-command";
8344     int r;
8345     suppress_error = 0;
8346     r = guestfs_chmod (g, 493, path);
8347     if (r == -1)
8348       return -1;
8349   }
8350   {
8351     char arguments_0[] = "/test-command";
8352     char arguments_1[] = "9";
8353     char *arguments[] = {
8354       arguments_0,
8355       arguments_1,
8356       NULL
8357     };
8358     char **r;
8359     int i;
8360     suppress_error = 0;
8361     r = guestfs_command_lines (g, arguments);
8362     if (r == NULL)
8363       return -1;
8364     if (!r[0]) {
8365       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8366       print_strings (r);
8367       return -1;
8368     }
8369     {
8370       char expected[] = "";
8371       if (strcmp (r[0], expected) != 0) {
8372         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8373         return -1;
8374       }
8375     }
8376     if (!r[1]) {
8377       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8378       print_strings (r);
8379       return -1;
8380     }
8381     {
8382       char expected[] = "";
8383       if (strcmp (r[1], expected) != 0) {
8384         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8385         return -1;
8386       }
8387     }
8388     if (r[2] != NULL) {
8389       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8390       print_strings (r);
8391       return -1;
8392     }
8393     for (i = 0; r[i] != NULL; ++i)
8394       free (r[i]);
8395     free (r);
8396   }
8397   return 0;
8398 }
8399
8400 static int test_command_lines_9_skip (void)
8401 {
8402   const char *str;
8403
8404   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8405   if (str && strcmp (str, "1") == 0) return 1;
8406   str = getenv ("SKIP_TEST_COMMAND_LINES");
8407   if (str && strcmp (str, "1") == 0) return 1;
8408   return 0;
8409 }
8410
8411 static int test_command_lines_9 (void)
8412 {
8413   if (test_command_lines_9_skip ()) {
8414     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8415     return 0;
8416   }
8417
8418   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8419   {
8420     char device[] = "/dev/sda";
8421     device[5] = devchar;
8422     int r;
8423     suppress_error = 0;
8424     r = guestfs_blockdev_setrw (g, device);
8425     if (r == -1)
8426       return -1;
8427   }
8428   {
8429     int r;
8430     suppress_error = 0;
8431     r = guestfs_umount_all (g);
8432     if (r == -1)
8433       return -1;
8434   }
8435   {
8436     int r;
8437     suppress_error = 0;
8438     r = guestfs_lvm_remove_all (g);
8439     if (r == -1)
8440       return -1;
8441   }
8442   {
8443     char device[] = "/dev/sda";
8444     device[5] = devchar;
8445     char lines_0[] = ",";
8446     char *lines[] = {
8447       lines_0,
8448       NULL
8449     };
8450     int r;
8451     suppress_error = 0;
8452     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8453     if (r == -1)
8454       return -1;
8455   }
8456   {
8457     char fstype[] = "ext2";
8458     char device[] = "/dev/sda1";
8459     device[5] = devchar;
8460     int r;
8461     suppress_error = 0;
8462     r = guestfs_mkfs (g, fstype, device);
8463     if (r == -1)
8464       return -1;
8465   }
8466   {
8467     char device[] = "/dev/sda1";
8468     device[5] = devchar;
8469     char mountpoint[] = "/";
8470     int r;
8471     suppress_error = 0;
8472     r = guestfs_mount (g, device, mountpoint);
8473     if (r == -1)
8474       return -1;
8475   }
8476   /* TestOutputList for command_lines (9) */
8477   {
8478     char remotefilename[] = "/test-command";
8479     int r;
8480     suppress_error = 0;
8481     r = guestfs_upload (g, "test-command", remotefilename);
8482     if (r == -1)
8483       return -1;
8484   }
8485   {
8486     char path[] = "/test-command";
8487     int r;
8488     suppress_error = 0;
8489     r = guestfs_chmod (g, 493, path);
8490     if (r == -1)
8491       return -1;
8492   }
8493   {
8494     char arguments_0[] = "/test-command";
8495     char arguments_1[] = "10";
8496     char *arguments[] = {
8497       arguments_0,
8498       arguments_1,
8499       NULL
8500     };
8501     char **r;
8502     int i;
8503     suppress_error = 0;
8504     r = guestfs_command_lines (g, arguments);
8505     if (r == NULL)
8506       return -1;
8507     if (!r[0]) {
8508       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8509       print_strings (r);
8510       return -1;
8511     }
8512     {
8513       char expected[] = "Result10-1";
8514       if (strcmp (r[0], expected) != 0) {
8515         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8516         return -1;
8517       }
8518     }
8519     if (!r[1]) {
8520       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8521       print_strings (r);
8522       return -1;
8523     }
8524     {
8525       char expected[] = "Result10-2";
8526       if (strcmp (r[1], expected) != 0) {
8527         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8528         return -1;
8529       }
8530     }
8531     if (r[2] != NULL) {
8532       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8533       print_strings (r);
8534       return -1;
8535     }
8536     for (i = 0; r[i] != NULL; ++i)
8537       free (r[i]);
8538     free (r);
8539   }
8540   return 0;
8541 }
8542
8543 static int test_command_lines_10_skip (void)
8544 {
8545   const char *str;
8546
8547   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8548   if (str && strcmp (str, "1") == 0) return 1;
8549   str = getenv ("SKIP_TEST_COMMAND_LINES");
8550   if (str && strcmp (str, "1") == 0) return 1;
8551   return 0;
8552 }
8553
8554 static int test_command_lines_10 (void)
8555 {
8556   if (test_command_lines_10_skip ()) {
8557     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8558     return 0;
8559   }
8560
8561   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8562   {
8563     char device[] = "/dev/sda";
8564     device[5] = devchar;
8565     int r;
8566     suppress_error = 0;
8567     r = guestfs_blockdev_setrw (g, device);
8568     if (r == -1)
8569       return -1;
8570   }
8571   {
8572     int r;
8573     suppress_error = 0;
8574     r = guestfs_umount_all (g);
8575     if (r == -1)
8576       return -1;
8577   }
8578   {
8579     int r;
8580     suppress_error = 0;
8581     r = guestfs_lvm_remove_all (g);
8582     if (r == -1)
8583       return -1;
8584   }
8585   {
8586     char device[] = "/dev/sda";
8587     device[5] = devchar;
8588     char lines_0[] = ",";
8589     char *lines[] = {
8590       lines_0,
8591       NULL
8592     };
8593     int r;
8594     suppress_error = 0;
8595     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8596     if (r == -1)
8597       return -1;
8598   }
8599   {
8600     char fstype[] = "ext2";
8601     char device[] = "/dev/sda1";
8602     device[5] = devchar;
8603     int r;
8604     suppress_error = 0;
8605     r = guestfs_mkfs (g, fstype, device);
8606     if (r == -1)
8607       return -1;
8608   }
8609   {
8610     char device[] = "/dev/sda1";
8611     device[5] = devchar;
8612     char mountpoint[] = "/";
8613     int r;
8614     suppress_error = 0;
8615     r = guestfs_mount (g, device, mountpoint);
8616     if (r == -1)
8617       return -1;
8618   }
8619   /* TestOutputList for command_lines (10) */
8620   {
8621     char remotefilename[] = "/test-command";
8622     int r;
8623     suppress_error = 0;
8624     r = guestfs_upload (g, "test-command", remotefilename);
8625     if (r == -1)
8626       return -1;
8627   }
8628   {
8629     char path[] = "/test-command";
8630     int r;
8631     suppress_error = 0;
8632     r = guestfs_chmod (g, 493, path);
8633     if (r == -1)
8634       return -1;
8635   }
8636   {
8637     char arguments_0[] = "/test-command";
8638     char arguments_1[] = "11";
8639     char *arguments[] = {
8640       arguments_0,
8641       arguments_1,
8642       NULL
8643     };
8644     char **r;
8645     int i;
8646     suppress_error = 0;
8647     r = guestfs_command_lines (g, arguments);
8648     if (r == NULL)
8649       return -1;
8650     if (!r[0]) {
8651       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8652       print_strings (r);
8653       return -1;
8654     }
8655     {
8656       char expected[] = "Result11-1";
8657       if (strcmp (r[0], expected) != 0) {
8658         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8659         return -1;
8660       }
8661     }
8662     if (!r[1]) {
8663       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8664       print_strings (r);
8665       return -1;
8666     }
8667     {
8668       char expected[] = "Result11-2";
8669       if (strcmp (r[1], expected) != 0) {
8670         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8671         return -1;
8672       }
8673     }
8674     if (r[2] != NULL) {
8675       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8676       print_strings (r);
8677       return -1;
8678     }
8679     for (i = 0; r[i] != NULL; ++i)
8680       free (r[i]);
8681     free (r);
8682   }
8683   return 0;
8684 }
8685
8686 static int test_command_0_skip (void)
8687 {
8688   const char *str;
8689
8690   str = getenv ("SKIP_TEST_COMMAND_0");
8691   if (str && strcmp (str, "1") == 0) return 1;
8692   str = getenv ("SKIP_TEST_COMMAND");
8693   if (str && strcmp (str, "1") == 0) return 1;
8694   return 0;
8695 }
8696
8697 static int test_command_0 (void)
8698 {
8699   if (test_command_0_skip ()) {
8700     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8701     return 0;
8702   }
8703
8704   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8705   {
8706     char device[] = "/dev/sda";
8707     device[5] = devchar;
8708     int r;
8709     suppress_error = 0;
8710     r = guestfs_blockdev_setrw (g, device);
8711     if (r == -1)
8712       return -1;
8713   }
8714   {
8715     int r;
8716     suppress_error = 0;
8717     r = guestfs_umount_all (g);
8718     if (r == -1)
8719       return -1;
8720   }
8721   {
8722     int r;
8723     suppress_error = 0;
8724     r = guestfs_lvm_remove_all (g);
8725     if (r == -1)
8726       return -1;
8727   }
8728   {
8729     char device[] = "/dev/sda";
8730     device[5] = devchar;
8731     char lines_0[] = ",";
8732     char *lines[] = {
8733       lines_0,
8734       NULL
8735     };
8736     int r;
8737     suppress_error = 0;
8738     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8739     if (r == -1)
8740       return -1;
8741   }
8742   {
8743     char fstype[] = "ext2";
8744     char device[] = "/dev/sda1";
8745     device[5] = devchar;
8746     int r;
8747     suppress_error = 0;
8748     r = guestfs_mkfs (g, fstype, device);
8749     if (r == -1)
8750       return -1;
8751   }
8752   {
8753     char device[] = "/dev/sda1";
8754     device[5] = devchar;
8755     char mountpoint[] = "/";
8756     int r;
8757     suppress_error = 0;
8758     r = guestfs_mount (g, device, mountpoint);
8759     if (r == -1)
8760       return -1;
8761   }
8762   /* TestOutput for command (0) */
8763   char expected[] = "Result1";
8764   {
8765     char remotefilename[] = "/test-command";
8766     int r;
8767     suppress_error = 0;
8768     r = guestfs_upload (g, "test-command", remotefilename);
8769     if (r == -1)
8770       return -1;
8771   }
8772   {
8773     char path[] = "/test-command";
8774     int r;
8775     suppress_error = 0;
8776     r = guestfs_chmod (g, 493, path);
8777     if (r == -1)
8778       return -1;
8779   }
8780   {
8781     char arguments_0[] = "/test-command";
8782     char arguments_1[] = "1";
8783     char *arguments[] = {
8784       arguments_0,
8785       arguments_1,
8786       NULL
8787     };
8788     char *r;
8789     suppress_error = 0;
8790     r = guestfs_command (g, arguments);
8791     if (r == NULL)
8792       return -1;
8793     if (strcmp (r, expected) != 0) {
8794       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8795       return -1;
8796     }
8797     free (r);
8798   }
8799   return 0;
8800 }
8801
8802 static int test_command_1_skip (void)
8803 {
8804   const char *str;
8805
8806   str = getenv ("SKIP_TEST_COMMAND_1");
8807   if (str && strcmp (str, "1") == 0) return 1;
8808   str = getenv ("SKIP_TEST_COMMAND");
8809   if (str && strcmp (str, "1") == 0) return 1;
8810   return 0;
8811 }
8812
8813 static int test_command_1 (void)
8814 {
8815   if (test_command_1_skip ()) {
8816     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8817     return 0;
8818   }
8819
8820   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8821   {
8822     char device[] = "/dev/sda";
8823     device[5] = devchar;
8824     int r;
8825     suppress_error = 0;
8826     r = guestfs_blockdev_setrw (g, device);
8827     if (r == -1)
8828       return -1;
8829   }
8830   {
8831     int r;
8832     suppress_error = 0;
8833     r = guestfs_umount_all (g);
8834     if (r == -1)
8835       return -1;
8836   }
8837   {
8838     int r;
8839     suppress_error = 0;
8840     r = guestfs_lvm_remove_all (g);
8841     if (r == -1)
8842       return -1;
8843   }
8844   {
8845     char device[] = "/dev/sda";
8846     device[5] = devchar;
8847     char lines_0[] = ",";
8848     char *lines[] = {
8849       lines_0,
8850       NULL
8851     };
8852     int r;
8853     suppress_error = 0;
8854     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8855     if (r == -1)
8856       return -1;
8857   }
8858   {
8859     char fstype[] = "ext2";
8860     char device[] = "/dev/sda1";
8861     device[5] = devchar;
8862     int r;
8863     suppress_error = 0;
8864     r = guestfs_mkfs (g, fstype, device);
8865     if (r == -1)
8866       return -1;
8867   }
8868   {
8869     char device[] = "/dev/sda1";
8870     device[5] = devchar;
8871     char mountpoint[] = "/";
8872     int r;
8873     suppress_error = 0;
8874     r = guestfs_mount (g, device, mountpoint);
8875     if (r == -1)
8876       return -1;
8877   }
8878   /* TestOutput for command (1) */
8879   char expected[] = "Result2\n";
8880   {
8881     char remotefilename[] = "/test-command";
8882     int r;
8883     suppress_error = 0;
8884     r = guestfs_upload (g, "test-command", remotefilename);
8885     if (r == -1)
8886       return -1;
8887   }
8888   {
8889     char path[] = "/test-command";
8890     int r;
8891     suppress_error = 0;
8892     r = guestfs_chmod (g, 493, path);
8893     if (r == -1)
8894       return -1;
8895   }
8896   {
8897     char arguments_0[] = "/test-command";
8898     char arguments_1[] = "2";
8899     char *arguments[] = {
8900       arguments_0,
8901       arguments_1,
8902       NULL
8903     };
8904     char *r;
8905     suppress_error = 0;
8906     r = guestfs_command (g, arguments);
8907     if (r == NULL)
8908       return -1;
8909     if (strcmp (r, expected) != 0) {
8910       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8911       return -1;
8912     }
8913     free (r);
8914   }
8915   return 0;
8916 }
8917
8918 static int test_command_2_skip (void)
8919 {
8920   const char *str;
8921
8922   str = getenv ("SKIP_TEST_COMMAND_2");
8923   if (str && strcmp (str, "1") == 0) return 1;
8924   str = getenv ("SKIP_TEST_COMMAND");
8925   if (str && strcmp (str, "1") == 0) return 1;
8926   return 0;
8927 }
8928
8929 static int test_command_2 (void)
8930 {
8931   if (test_command_2_skip ()) {
8932     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8933     return 0;
8934   }
8935
8936   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8937   {
8938     char device[] = "/dev/sda";
8939     device[5] = devchar;
8940     int r;
8941     suppress_error = 0;
8942     r = guestfs_blockdev_setrw (g, device);
8943     if (r == -1)
8944       return -1;
8945   }
8946   {
8947     int r;
8948     suppress_error = 0;
8949     r = guestfs_umount_all (g);
8950     if (r == -1)
8951       return -1;
8952   }
8953   {
8954     int r;
8955     suppress_error = 0;
8956     r = guestfs_lvm_remove_all (g);
8957     if (r == -1)
8958       return -1;
8959   }
8960   {
8961     char device[] = "/dev/sda";
8962     device[5] = devchar;
8963     char lines_0[] = ",";
8964     char *lines[] = {
8965       lines_0,
8966       NULL
8967     };
8968     int r;
8969     suppress_error = 0;
8970     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8971     if (r == -1)
8972       return -1;
8973   }
8974   {
8975     char fstype[] = "ext2";
8976     char device[] = "/dev/sda1";
8977     device[5] = devchar;
8978     int r;
8979     suppress_error = 0;
8980     r = guestfs_mkfs (g, fstype, device);
8981     if (r == -1)
8982       return -1;
8983   }
8984   {
8985     char device[] = "/dev/sda1";
8986     device[5] = devchar;
8987     char mountpoint[] = "/";
8988     int r;
8989     suppress_error = 0;
8990     r = guestfs_mount (g, device, mountpoint);
8991     if (r == -1)
8992       return -1;
8993   }
8994   /* TestOutput for command (2) */
8995   char expected[] = "\nResult3";
8996   {
8997     char remotefilename[] = "/test-command";
8998     int r;
8999     suppress_error = 0;
9000     r = guestfs_upload (g, "test-command", remotefilename);
9001     if (r == -1)
9002       return -1;
9003   }
9004   {
9005     char path[] = "/test-command";
9006     int r;
9007     suppress_error = 0;
9008     r = guestfs_chmod (g, 493, path);
9009     if (r == -1)
9010       return -1;
9011   }
9012   {
9013     char arguments_0[] = "/test-command";
9014     char arguments_1[] = "3";
9015     char *arguments[] = {
9016       arguments_0,
9017       arguments_1,
9018       NULL
9019     };
9020     char *r;
9021     suppress_error = 0;
9022     r = guestfs_command (g, arguments);
9023     if (r == NULL)
9024       return -1;
9025     if (strcmp (r, expected) != 0) {
9026       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9027       return -1;
9028     }
9029     free (r);
9030   }
9031   return 0;
9032 }
9033
9034 static int test_command_3_skip (void)
9035 {
9036   const char *str;
9037
9038   str = getenv ("SKIP_TEST_COMMAND_3");
9039   if (str && strcmp (str, "1") == 0) return 1;
9040   str = getenv ("SKIP_TEST_COMMAND");
9041   if (str && strcmp (str, "1") == 0) return 1;
9042   return 0;
9043 }
9044
9045 static int test_command_3 (void)
9046 {
9047   if (test_command_3_skip ()) {
9048     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9049     return 0;
9050   }
9051
9052   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9053   {
9054     char device[] = "/dev/sda";
9055     device[5] = devchar;
9056     int r;
9057     suppress_error = 0;
9058     r = guestfs_blockdev_setrw (g, device);
9059     if (r == -1)
9060       return -1;
9061   }
9062   {
9063     int r;
9064     suppress_error = 0;
9065     r = guestfs_umount_all (g);
9066     if (r == -1)
9067       return -1;
9068   }
9069   {
9070     int r;
9071     suppress_error = 0;
9072     r = guestfs_lvm_remove_all (g);
9073     if (r == -1)
9074       return -1;
9075   }
9076   {
9077     char device[] = "/dev/sda";
9078     device[5] = devchar;
9079     char lines_0[] = ",";
9080     char *lines[] = {
9081       lines_0,
9082       NULL
9083     };
9084     int r;
9085     suppress_error = 0;
9086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9087     if (r == -1)
9088       return -1;
9089   }
9090   {
9091     char fstype[] = "ext2";
9092     char device[] = "/dev/sda1";
9093     device[5] = devchar;
9094     int r;
9095     suppress_error = 0;
9096     r = guestfs_mkfs (g, fstype, device);
9097     if (r == -1)
9098       return -1;
9099   }
9100   {
9101     char device[] = "/dev/sda1";
9102     device[5] = devchar;
9103     char mountpoint[] = "/";
9104     int r;
9105     suppress_error = 0;
9106     r = guestfs_mount (g, device, mountpoint);
9107     if (r == -1)
9108       return -1;
9109   }
9110   /* TestOutput for command (3) */
9111   char expected[] = "\nResult4\n";
9112   {
9113     char remotefilename[] = "/test-command";
9114     int r;
9115     suppress_error = 0;
9116     r = guestfs_upload (g, "test-command", remotefilename);
9117     if (r == -1)
9118       return -1;
9119   }
9120   {
9121     char path[] = "/test-command";
9122     int r;
9123     suppress_error = 0;
9124     r = guestfs_chmod (g, 493, path);
9125     if (r == -1)
9126       return -1;
9127   }
9128   {
9129     char arguments_0[] = "/test-command";
9130     char arguments_1[] = "4";
9131     char *arguments[] = {
9132       arguments_0,
9133       arguments_1,
9134       NULL
9135     };
9136     char *r;
9137     suppress_error = 0;
9138     r = guestfs_command (g, arguments);
9139     if (r == NULL)
9140       return -1;
9141     if (strcmp (r, expected) != 0) {
9142       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9143       return -1;
9144     }
9145     free (r);
9146   }
9147   return 0;
9148 }
9149
9150 static int test_command_4_skip (void)
9151 {
9152   const char *str;
9153
9154   str = getenv ("SKIP_TEST_COMMAND_4");
9155   if (str && strcmp (str, "1") == 0) return 1;
9156   str = getenv ("SKIP_TEST_COMMAND");
9157   if (str && strcmp (str, "1") == 0) return 1;
9158   return 0;
9159 }
9160
9161 static int test_command_4 (void)
9162 {
9163   if (test_command_4_skip ()) {
9164     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9165     return 0;
9166   }
9167
9168   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9169   {
9170     char device[] = "/dev/sda";
9171     device[5] = devchar;
9172     int r;
9173     suppress_error = 0;
9174     r = guestfs_blockdev_setrw (g, device);
9175     if (r == -1)
9176       return -1;
9177   }
9178   {
9179     int r;
9180     suppress_error = 0;
9181     r = guestfs_umount_all (g);
9182     if (r == -1)
9183       return -1;
9184   }
9185   {
9186     int r;
9187     suppress_error = 0;
9188     r = guestfs_lvm_remove_all (g);
9189     if (r == -1)
9190       return -1;
9191   }
9192   {
9193     char device[] = "/dev/sda";
9194     device[5] = devchar;
9195     char lines_0[] = ",";
9196     char *lines[] = {
9197       lines_0,
9198       NULL
9199     };
9200     int r;
9201     suppress_error = 0;
9202     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9203     if (r == -1)
9204       return -1;
9205   }
9206   {
9207     char fstype[] = "ext2";
9208     char device[] = "/dev/sda1";
9209     device[5] = devchar;
9210     int r;
9211     suppress_error = 0;
9212     r = guestfs_mkfs (g, fstype, device);
9213     if (r == -1)
9214       return -1;
9215   }
9216   {
9217     char device[] = "/dev/sda1";
9218     device[5] = devchar;
9219     char mountpoint[] = "/";
9220     int r;
9221     suppress_error = 0;
9222     r = guestfs_mount (g, device, mountpoint);
9223     if (r == -1)
9224       return -1;
9225   }
9226   /* TestOutput for command (4) */
9227   char expected[] = "\nResult5\n\n";
9228   {
9229     char remotefilename[] = "/test-command";
9230     int r;
9231     suppress_error = 0;
9232     r = guestfs_upload (g, "test-command", remotefilename);
9233     if (r == -1)
9234       return -1;
9235   }
9236   {
9237     char path[] = "/test-command";
9238     int r;
9239     suppress_error = 0;
9240     r = guestfs_chmod (g, 493, path);
9241     if (r == -1)
9242       return -1;
9243   }
9244   {
9245     char arguments_0[] = "/test-command";
9246     char arguments_1[] = "5";
9247     char *arguments[] = {
9248       arguments_0,
9249       arguments_1,
9250       NULL
9251     };
9252     char *r;
9253     suppress_error = 0;
9254     r = guestfs_command (g, arguments);
9255     if (r == NULL)
9256       return -1;
9257     if (strcmp (r, expected) != 0) {
9258       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9259       return -1;
9260     }
9261     free (r);
9262   }
9263   return 0;
9264 }
9265
9266 static int test_command_5_skip (void)
9267 {
9268   const char *str;
9269
9270   str = getenv ("SKIP_TEST_COMMAND_5");
9271   if (str && strcmp (str, "1") == 0) return 1;
9272   str = getenv ("SKIP_TEST_COMMAND");
9273   if (str && strcmp (str, "1") == 0) return 1;
9274   return 0;
9275 }
9276
9277 static int test_command_5 (void)
9278 {
9279   if (test_command_5_skip ()) {
9280     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9281     return 0;
9282   }
9283
9284   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9285   {
9286     char device[] = "/dev/sda";
9287     device[5] = devchar;
9288     int r;
9289     suppress_error = 0;
9290     r = guestfs_blockdev_setrw (g, device);
9291     if (r == -1)
9292       return -1;
9293   }
9294   {
9295     int r;
9296     suppress_error = 0;
9297     r = guestfs_umount_all (g);
9298     if (r == -1)
9299       return -1;
9300   }
9301   {
9302     int r;
9303     suppress_error = 0;
9304     r = guestfs_lvm_remove_all (g);
9305     if (r == -1)
9306       return -1;
9307   }
9308   {
9309     char device[] = "/dev/sda";
9310     device[5] = devchar;
9311     char lines_0[] = ",";
9312     char *lines[] = {
9313       lines_0,
9314       NULL
9315     };
9316     int r;
9317     suppress_error = 0;
9318     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9319     if (r == -1)
9320       return -1;
9321   }
9322   {
9323     char fstype[] = "ext2";
9324     char device[] = "/dev/sda1";
9325     device[5] = devchar;
9326     int r;
9327     suppress_error = 0;
9328     r = guestfs_mkfs (g, fstype, device);
9329     if (r == -1)
9330       return -1;
9331   }
9332   {
9333     char device[] = "/dev/sda1";
9334     device[5] = devchar;
9335     char mountpoint[] = "/";
9336     int r;
9337     suppress_error = 0;
9338     r = guestfs_mount (g, device, mountpoint);
9339     if (r == -1)
9340       return -1;
9341   }
9342   /* TestOutput for command (5) */
9343   char expected[] = "\n\nResult6\n\n";
9344   {
9345     char remotefilename[] = "/test-command";
9346     int r;
9347     suppress_error = 0;
9348     r = guestfs_upload (g, "test-command", remotefilename);
9349     if (r == -1)
9350       return -1;
9351   }
9352   {
9353     char path[] = "/test-command";
9354     int r;
9355     suppress_error = 0;
9356     r = guestfs_chmod (g, 493, path);
9357     if (r == -1)
9358       return -1;
9359   }
9360   {
9361     char arguments_0[] = "/test-command";
9362     char arguments_1[] = "6";
9363     char *arguments[] = {
9364       arguments_0,
9365       arguments_1,
9366       NULL
9367     };
9368     char *r;
9369     suppress_error = 0;
9370     r = guestfs_command (g, arguments);
9371     if (r == NULL)
9372       return -1;
9373     if (strcmp (r, expected) != 0) {
9374       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9375       return -1;
9376     }
9377     free (r);
9378   }
9379   return 0;
9380 }
9381
9382 static int test_command_6_skip (void)
9383 {
9384   const char *str;
9385
9386   str = getenv ("SKIP_TEST_COMMAND_6");
9387   if (str && strcmp (str, "1") == 0) return 1;
9388   str = getenv ("SKIP_TEST_COMMAND");
9389   if (str && strcmp (str, "1") == 0) return 1;
9390   return 0;
9391 }
9392
9393 static int test_command_6 (void)
9394 {
9395   if (test_command_6_skip ()) {
9396     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9397     return 0;
9398   }
9399
9400   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9401   {
9402     char device[] = "/dev/sda";
9403     device[5] = devchar;
9404     int r;
9405     suppress_error = 0;
9406     r = guestfs_blockdev_setrw (g, device);
9407     if (r == -1)
9408       return -1;
9409   }
9410   {
9411     int r;
9412     suppress_error = 0;
9413     r = guestfs_umount_all (g);
9414     if (r == -1)
9415       return -1;
9416   }
9417   {
9418     int r;
9419     suppress_error = 0;
9420     r = guestfs_lvm_remove_all (g);
9421     if (r == -1)
9422       return -1;
9423   }
9424   {
9425     char device[] = "/dev/sda";
9426     device[5] = devchar;
9427     char lines_0[] = ",";
9428     char *lines[] = {
9429       lines_0,
9430       NULL
9431     };
9432     int r;
9433     suppress_error = 0;
9434     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9435     if (r == -1)
9436       return -1;
9437   }
9438   {
9439     char fstype[] = "ext2";
9440     char device[] = "/dev/sda1";
9441     device[5] = devchar;
9442     int r;
9443     suppress_error = 0;
9444     r = guestfs_mkfs (g, fstype, device);
9445     if (r == -1)
9446       return -1;
9447   }
9448   {
9449     char device[] = "/dev/sda1";
9450     device[5] = devchar;
9451     char mountpoint[] = "/";
9452     int r;
9453     suppress_error = 0;
9454     r = guestfs_mount (g, device, mountpoint);
9455     if (r == -1)
9456       return -1;
9457   }
9458   /* TestOutput for command (6) */
9459   char expected[] = "";
9460   {
9461     char remotefilename[] = "/test-command";
9462     int r;
9463     suppress_error = 0;
9464     r = guestfs_upload (g, "test-command", remotefilename);
9465     if (r == -1)
9466       return -1;
9467   }
9468   {
9469     char path[] = "/test-command";
9470     int r;
9471     suppress_error = 0;
9472     r = guestfs_chmod (g, 493, path);
9473     if (r == -1)
9474       return -1;
9475   }
9476   {
9477     char arguments_0[] = "/test-command";
9478     char arguments_1[] = "7";
9479     char *arguments[] = {
9480       arguments_0,
9481       arguments_1,
9482       NULL
9483     };
9484     char *r;
9485     suppress_error = 0;
9486     r = guestfs_command (g, arguments);
9487     if (r == NULL)
9488       return -1;
9489     if (strcmp (r, expected) != 0) {
9490       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9491       return -1;
9492     }
9493     free (r);
9494   }
9495   return 0;
9496 }
9497
9498 static int test_command_7_skip (void)
9499 {
9500   const char *str;
9501
9502   str = getenv ("SKIP_TEST_COMMAND_7");
9503   if (str && strcmp (str, "1") == 0) return 1;
9504   str = getenv ("SKIP_TEST_COMMAND");
9505   if (str && strcmp (str, "1") == 0) return 1;
9506   return 0;
9507 }
9508
9509 static int test_command_7 (void)
9510 {
9511   if (test_command_7_skip ()) {
9512     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9513     return 0;
9514   }
9515
9516   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9517   {
9518     char device[] = "/dev/sda";
9519     device[5] = devchar;
9520     int r;
9521     suppress_error = 0;
9522     r = guestfs_blockdev_setrw (g, device);
9523     if (r == -1)
9524       return -1;
9525   }
9526   {
9527     int r;
9528     suppress_error = 0;
9529     r = guestfs_umount_all (g);
9530     if (r == -1)
9531       return -1;
9532   }
9533   {
9534     int r;
9535     suppress_error = 0;
9536     r = guestfs_lvm_remove_all (g);
9537     if (r == -1)
9538       return -1;
9539   }
9540   {
9541     char device[] = "/dev/sda";
9542     device[5] = devchar;
9543     char lines_0[] = ",";
9544     char *lines[] = {
9545       lines_0,
9546       NULL
9547     };
9548     int r;
9549     suppress_error = 0;
9550     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9551     if (r == -1)
9552       return -1;
9553   }
9554   {
9555     char fstype[] = "ext2";
9556     char device[] = "/dev/sda1";
9557     device[5] = devchar;
9558     int r;
9559     suppress_error = 0;
9560     r = guestfs_mkfs (g, fstype, device);
9561     if (r == -1)
9562       return -1;
9563   }
9564   {
9565     char device[] = "/dev/sda1";
9566     device[5] = devchar;
9567     char mountpoint[] = "/";
9568     int r;
9569     suppress_error = 0;
9570     r = guestfs_mount (g, device, mountpoint);
9571     if (r == -1)
9572       return -1;
9573   }
9574   /* TestOutput for command (7) */
9575   char expected[] = "\n";
9576   {
9577     char remotefilename[] = "/test-command";
9578     int r;
9579     suppress_error = 0;
9580     r = guestfs_upload (g, "test-command", remotefilename);
9581     if (r == -1)
9582       return -1;
9583   }
9584   {
9585     char path[] = "/test-command";
9586     int r;
9587     suppress_error = 0;
9588     r = guestfs_chmod (g, 493, path);
9589     if (r == -1)
9590       return -1;
9591   }
9592   {
9593     char arguments_0[] = "/test-command";
9594     char arguments_1[] = "8";
9595     char *arguments[] = {
9596       arguments_0,
9597       arguments_1,
9598       NULL
9599     };
9600     char *r;
9601     suppress_error = 0;
9602     r = guestfs_command (g, arguments);
9603     if (r == NULL)
9604       return -1;
9605     if (strcmp (r, expected) != 0) {
9606       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9607       return -1;
9608     }
9609     free (r);
9610   }
9611   return 0;
9612 }
9613
9614 static int test_command_8_skip (void)
9615 {
9616   const char *str;
9617
9618   str = getenv ("SKIP_TEST_COMMAND_8");
9619   if (str && strcmp (str, "1") == 0) return 1;
9620   str = getenv ("SKIP_TEST_COMMAND");
9621   if (str && strcmp (str, "1") == 0) return 1;
9622   return 0;
9623 }
9624
9625 static int test_command_8 (void)
9626 {
9627   if (test_command_8_skip ()) {
9628     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9629     return 0;
9630   }
9631
9632   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9633   {
9634     char device[] = "/dev/sda";
9635     device[5] = devchar;
9636     int r;
9637     suppress_error = 0;
9638     r = guestfs_blockdev_setrw (g, device);
9639     if (r == -1)
9640       return -1;
9641   }
9642   {
9643     int r;
9644     suppress_error = 0;
9645     r = guestfs_umount_all (g);
9646     if (r == -1)
9647       return -1;
9648   }
9649   {
9650     int r;
9651     suppress_error = 0;
9652     r = guestfs_lvm_remove_all (g);
9653     if (r == -1)
9654       return -1;
9655   }
9656   {
9657     char device[] = "/dev/sda";
9658     device[5] = devchar;
9659     char lines_0[] = ",";
9660     char *lines[] = {
9661       lines_0,
9662       NULL
9663     };
9664     int r;
9665     suppress_error = 0;
9666     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9667     if (r == -1)
9668       return -1;
9669   }
9670   {
9671     char fstype[] = "ext2";
9672     char device[] = "/dev/sda1";
9673     device[5] = devchar;
9674     int r;
9675     suppress_error = 0;
9676     r = guestfs_mkfs (g, fstype, device);
9677     if (r == -1)
9678       return -1;
9679   }
9680   {
9681     char device[] = "/dev/sda1";
9682     device[5] = devchar;
9683     char mountpoint[] = "/";
9684     int r;
9685     suppress_error = 0;
9686     r = guestfs_mount (g, device, mountpoint);
9687     if (r == -1)
9688       return -1;
9689   }
9690   /* TestOutput for command (8) */
9691   char expected[] = "\n\n";
9692   {
9693     char remotefilename[] = "/test-command";
9694     int r;
9695     suppress_error = 0;
9696     r = guestfs_upload (g, "test-command", remotefilename);
9697     if (r == -1)
9698       return -1;
9699   }
9700   {
9701     char path[] = "/test-command";
9702     int r;
9703     suppress_error = 0;
9704     r = guestfs_chmod (g, 493, path);
9705     if (r == -1)
9706       return -1;
9707   }
9708   {
9709     char arguments_0[] = "/test-command";
9710     char arguments_1[] = "9";
9711     char *arguments[] = {
9712       arguments_0,
9713       arguments_1,
9714       NULL
9715     };
9716     char *r;
9717     suppress_error = 0;
9718     r = guestfs_command (g, arguments);
9719     if (r == NULL)
9720       return -1;
9721     if (strcmp (r, expected) != 0) {
9722       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9723       return -1;
9724     }
9725     free (r);
9726   }
9727   return 0;
9728 }
9729
9730 static int test_command_9_skip (void)
9731 {
9732   const char *str;
9733
9734   str = getenv ("SKIP_TEST_COMMAND_9");
9735   if (str && strcmp (str, "1") == 0) return 1;
9736   str = getenv ("SKIP_TEST_COMMAND");
9737   if (str && strcmp (str, "1") == 0) return 1;
9738   return 0;
9739 }
9740
9741 static int test_command_9 (void)
9742 {
9743   if (test_command_9_skip ()) {
9744     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9745     return 0;
9746   }
9747
9748   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9749   {
9750     char device[] = "/dev/sda";
9751     device[5] = devchar;
9752     int r;
9753     suppress_error = 0;
9754     r = guestfs_blockdev_setrw (g, device);
9755     if (r == -1)
9756       return -1;
9757   }
9758   {
9759     int r;
9760     suppress_error = 0;
9761     r = guestfs_umount_all (g);
9762     if (r == -1)
9763       return -1;
9764   }
9765   {
9766     int r;
9767     suppress_error = 0;
9768     r = guestfs_lvm_remove_all (g);
9769     if (r == -1)
9770       return -1;
9771   }
9772   {
9773     char device[] = "/dev/sda";
9774     device[5] = devchar;
9775     char lines_0[] = ",";
9776     char *lines[] = {
9777       lines_0,
9778       NULL
9779     };
9780     int r;
9781     suppress_error = 0;
9782     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9783     if (r == -1)
9784       return -1;
9785   }
9786   {
9787     char fstype[] = "ext2";
9788     char device[] = "/dev/sda1";
9789     device[5] = devchar;
9790     int r;
9791     suppress_error = 0;
9792     r = guestfs_mkfs (g, fstype, device);
9793     if (r == -1)
9794       return -1;
9795   }
9796   {
9797     char device[] = "/dev/sda1";
9798     device[5] = devchar;
9799     char mountpoint[] = "/";
9800     int r;
9801     suppress_error = 0;
9802     r = guestfs_mount (g, device, mountpoint);
9803     if (r == -1)
9804       return -1;
9805   }
9806   /* TestOutput for command (9) */
9807   char expected[] = "Result10-1\nResult10-2\n";
9808   {
9809     char remotefilename[] = "/test-command";
9810     int r;
9811     suppress_error = 0;
9812     r = guestfs_upload (g, "test-command", remotefilename);
9813     if (r == -1)
9814       return -1;
9815   }
9816   {
9817     char path[] = "/test-command";
9818     int r;
9819     suppress_error = 0;
9820     r = guestfs_chmod (g, 493, path);
9821     if (r == -1)
9822       return -1;
9823   }
9824   {
9825     char arguments_0[] = "/test-command";
9826     char arguments_1[] = "10";
9827     char *arguments[] = {
9828       arguments_0,
9829       arguments_1,
9830       NULL
9831     };
9832     char *r;
9833     suppress_error = 0;
9834     r = guestfs_command (g, arguments);
9835     if (r == NULL)
9836       return -1;
9837     if (strcmp (r, expected) != 0) {
9838       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9839       return -1;
9840     }
9841     free (r);
9842   }
9843   return 0;
9844 }
9845
9846 static int test_command_10_skip (void)
9847 {
9848   const char *str;
9849
9850   str = getenv ("SKIP_TEST_COMMAND_10");
9851   if (str && strcmp (str, "1") == 0) return 1;
9852   str = getenv ("SKIP_TEST_COMMAND");
9853   if (str && strcmp (str, "1") == 0) return 1;
9854   return 0;
9855 }
9856
9857 static int test_command_10 (void)
9858 {
9859   if (test_command_10_skip ()) {
9860     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9861     return 0;
9862   }
9863
9864   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9865   {
9866     char device[] = "/dev/sda";
9867     device[5] = devchar;
9868     int r;
9869     suppress_error = 0;
9870     r = guestfs_blockdev_setrw (g, device);
9871     if (r == -1)
9872       return -1;
9873   }
9874   {
9875     int r;
9876     suppress_error = 0;
9877     r = guestfs_umount_all (g);
9878     if (r == -1)
9879       return -1;
9880   }
9881   {
9882     int r;
9883     suppress_error = 0;
9884     r = guestfs_lvm_remove_all (g);
9885     if (r == -1)
9886       return -1;
9887   }
9888   {
9889     char device[] = "/dev/sda";
9890     device[5] = devchar;
9891     char lines_0[] = ",";
9892     char *lines[] = {
9893       lines_0,
9894       NULL
9895     };
9896     int r;
9897     suppress_error = 0;
9898     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9899     if (r == -1)
9900       return -1;
9901   }
9902   {
9903     char fstype[] = "ext2";
9904     char device[] = "/dev/sda1";
9905     device[5] = devchar;
9906     int r;
9907     suppress_error = 0;
9908     r = guestfs_mkfs (g, fstype, device);
9909     if (r == -1)
9910       return -1;
9911   }
9912   {
9913     char device[] = "/dev/sda1";
9914     device[5] = devchar;
9915     char mountpoint[] = "/";
9916     int r;
9917     suppress_error = 0;
9918     r = guestfs_mount (g, device, mountpoint);
9919     if (r == -1)
9920       return -1;
9921   }
9922   /* TestOutput for command (10) */
9923   char expected[] = "Result11-1\nResult11-2";
9924   {
9925     char remotefilename[] = "/test-command";
9926     int r;
9927     suppress_error = 0;
9928     r = guestfs_upload (g, "test-command", remotefilename);
9929     if (r == -1)
9930       return -1;
9931   }
9932   {
9933     char path[] = "/test-command";
9934     int r;
9935     suppress_error = 0;
9936     r = guestfs_chmod (g, 493, path);
9937     if (r == -1)
9938       return -1;
9939   }
9940   {
9941     char arguments_0[] = "/test-command";
9942     char arguments_1[] = "11";
9943     char *arguments[] = {
9944       arguments_0,
9945       arguments_1,
9946       NULL
9947     };
9948     char *r;
9949     suppress_error = 0;
9950     r = guestfs_command (g, arguments);
9951     if (r == NULL)
9952       return -1;
9953     if (strcmp (r, expected) != 0) {
9954       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9955       return -1;
9956     }
9957     free (r);
9958   }
9959   return 0;
9960 }
9961
9962 static int test_command_11_skip (void)
9963 {
9964   const char *str;
9965
9966   str = getenv ("SKIP_TEST_COMMAND_11");
9967   if (str && strcmp (str, "1") == 0) return 1;
9968   str = getenv ("SKIP_TEST_COMMAND");
9969   if (str && strcmp (str, "1") == 0) return 1;
9970   return 0;
9971 }
9972
9973 static int test_command_11 (void)
9974 {
9975   if (test_command_11_skip ()) {
9976     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9977     return 0;
9978   }
9979
9980   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9981   {
9982     char device[] = "/dev/sda";
9983     device[5] = devchar;
9984     int r;
9985     suppress_error = 0;
9986     r = guestfs_blockdev_setrw (g, device);
9987     if (r == -1)
9988       return -1;
9989   }
9990   {
9991     int r;
9992     suppress_error = 0;
9993     r = guestfs_umount_all (g);
9994     if (r == -1)
9995       return -1;
9996   }
9997   {
9998     int r;
9999     suppress_error = 0;
10000     r = guestfs_lvm_remove_all (g);
10001     if (r == -1)
10002       return -1;
10003   }
10004   {
10005     char device[] = "/dev/sda";
10006     device[5] = devchar;
10007     char lines_0[] = ",";
10008     char *lines[] = {
10009       lines_0,
10010       NULL
10011     };
10012     int r;
10013     suppress_error = 0;
10014     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10015     if (r == -1)
10016       return -1;
10017   }
10018   {
10019     char fstype[] = "ext2";
10020     char device[] = "/dev/sda1";
10021     device[5] = devchar;
10022     int r;
10023     suppress_error = 0;
10024     r = guestfs_mkfs (g, fstype, device);
10025     if (r == -1)
10026       return -1;
10027   }
10028   {
10029     char device[] = "/dev/sda1";
10030     device[5] = devchar;
10031     char mountpoint[] = "/";
10032     int r;
10033     suppress_error = 0;
10034     r = guestfs_mount (g, device, mountpoint);
10035     if (r == -1)
10036       return -1;
10037   }
10038   /* TestLastFail for command (11) */
10039   {
10040     char remotefilename[] = "/test-command";
10041     int r;
10042     suppress_error = 0;
10043     r = guestfs_upload (g, "test-command", remotefilename);
10044     if (r == -1)
10045       return -1;
10046   }
10047   {
10048     char path[] = "/test-command";
10049     int r;
10050     suppress_error = 0;
10051     r = guestfs_chmod (g, 493, path);
10052     if (r == -1)
10053       return -1;
10054   }
10055   {
10056     char arguments_0[] = "/test-command";
10057     char *arguments[] = {
10058       arguments_0,
10059       NULL
10060     };
10061     char *r;
10062     suppress_error = 1;
10063     r = guestfs_command (g, arguments);
10064     if (r != NULL)
10065       return -1;
10066     free (r);
10067   }
10068   return 0;
10069 }
10070
10071 static int test_file_0_skip (void)
10072 {
10073   const char *str;
10074
10075   str = getenv ("SKIP_TEST_FILE_0");
10076   if (str && strcmp (str, "1") == 0) return 1;
10077   str = getenv ("SKIP_TEST_FILE");
10078   if (str && strcmp (str, "1") == 0) return 1;
10079   return 0;
10080 }
10081
10082 static int test_file_0 (void)
10083 {
10084   if (test_file_0_skip ()) {
10085     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10086     return 0;
10087   }
10088
10089   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10090   {
10091     char device[] = "/dev/sda";
10092     device[5] = devchar;
10093     int r;
10094     suppress_error = 0;
10095     r = guestfs_blockdev_setrw (g, device);
10096     if (r == -1)
10097       return -1;
10098   }
10099   {
10100     int r;
10101     suppress_error = 0;
10102     r = guestfs_umount_all (g);
10103     if (r == -1)
10104       return -1;
10105   }
10106   {
10107     int r;
10108     suppress_error = 0;
10109     r = guestfs_lvm_remove_all (g);
10110     if (r == -1)
10111       return -1;
10112   }
10113   {
10114     char device[] = "/dev/sda";
10115     device[5] = devchar;
10116     char lines_0[] = ",";
10117     char *lines[] = {
10118       lines_0,
10119       NULL
10120     };
10121     int r;
10122     suppress_error = 0;
10123     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10124     if (r == -1)
10125       return -1;
10126   }
10127   {
10128     char fstype[] = "ext2";
10129     char device[] = "/dev/sda1";
10130     device[5] = devchar;
10131     int r;
10132     suppress_error = 0;
10133     r = guestfs_mkfs (g, fstype, device);
10134     if (r == -1)
10135       return -1;
10136   }
10137   {
10138     char device[] = "/dev/sda1";
10139     device[5] = devchar;
10140     char mountpoint[] = "/";
10141     int r;
10142     suppress_error = 0;
10143     r = guestfs_mount (g, device, mountpoint);
10144     if (r == -1)
10145       return -1;
10146   }
10147   /* TestOutput for file (0) */
10148   char expected[] = "empty";
10149   {
10150     char path[] = "/new";
10151     int r;
10152     suppress_error = 0;
10153     r = guestfs_touch (g, path);
10154     if (r == -1)
10155       return -1;
10156   }
10157   {
10158     char path[] = "/new";
10159     char *r;
10160     suppress_error = 0;
10161     r = guestfs_file (g, path);
10162     if (r == NULL)
10163       return -1;
10164     if (strcmp (r, expected) != 0) {
10165       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10166       return -1;
10167     }
10168     free (r);
10169   }
10170   return 0;
10171 }
10172
10173 static int test_file_1_skip (void)
10174 {
10175   const char *str;
10176
10177   str = getenv ("SKIP_TEST_FILE_1");
10178   if (str && strcmp (str, "1") == 0) return 1;
10179   str = getenv ("SKIP_TEST_FILE");
10180   if (str && strcmp (str, "1") == 0) return 1;
10181   return 0;
10182 }
10183
10184 static int test_file_1 (void)
10185 {
10186   if (test_file_1_skip ()) {
10187     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10188     return 0;
10189   }
10190
10191   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10192   {
10193     char device[] = "/dev/sda";
10194     device[5] = devchar;
10195     int r;
10196     suppress_error = 0;
10197     r = guestfs_blockdev_setrw (g, device);
10198     if (r == -1)
10199       return -1;
10200   }
10201   {
10202     int r;
10203     suppress_error = 0;
10204     r = guestfs_umount_all (g);
10205     if (r == -1)
10206       return -1;
10207   }
10208   {
10209     int r;
10210     suppress_error = 0;
10211     r = guestfs_lvm_remove_all (g);
10212     if (r == -1)
10213       return -1;
10214   }
10215   {
10216     char device[] = "/dev/sda";
10217     device[5] = devchar;
10218     char lines_0[] = ",";
10219     char *lines[] = {
10220       lines_0,
10221       NULL
10222     };
10223     int r;
10224     suppress_error = 0;
10225     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10226     if (r == -1)
10227       return -1;
10228   }
10229   {
10230     char fstype[] = "ext2";
10231     char device[] = "/dev/sda1";
10232     device[5] = devchar;
10233     int r;
10234     suppress_error = 0;
10235     r = guestfs_mkfs (g, fstype, device);
10236     if (r == -1)
10237       return -1;
10238   }
10239   {
10240     char device[] = "/dev/sda1";
10241     device[5] = devchar;
10242     char mountpoint[] = "/";
10243     int r;
10244     suppress_error = 0;
10245     r = guestfs_mount (g, device, mountpoint);
10246     if (r == -1)
10247       return -1;
10248   }
10249   /* TestOutput for file (1) */
10250   char expected[] = "ASCII text";
10251   {
10252     char path[] = "/new";
10253     char content[] = "some content\n";
10254     int r;
10255     suppress_error = 0;
10256     r = guestfs_write_file (g, path, content, 0);
10257     if (r == -1)
10258       return -1;
10259   }
10260   {
10261     char path[] = "/new";
10262     char *r;
10263     suppress_error = 0;
10264     r = guestfs_file (g, path);
10265     if (r == NULL)
10266       return -1;
10267     if (strcmp (r, expected) != 0) {
10268       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10269       return -1;
10270     }
10271     free (r);
10272   }
10273   return 0;
10274 }
10275
10276 static int test_file_2_skip (void)
10277 {
10278   const char *str;
10279
10280   str = getenv ("SKIP_TEST_FILE_2");
10281   if (str && strcmp (str, "1") == 0) return 1;
10282   str = getenv ("SKIP_TEST_FILE");
10283   if (str && strcmp (str, "1") == 0) return 1;
10284   return 0;
10285 }
10286
10287 static int test_file_2 (void)
10288 {
10289   if (test_file_2_skip ()) {
10290     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10291     return 0;
10292   }
10293
10294   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10295   {
10296     char device[] = "/dev/sda";
10297     device[5] = devchar;
10298     int r;
10299     suppress_error = 0;
10300     r = guestfs_blockdev_setrw (g, device);
10301     if (r == -1)
10302       return -1;
10303   }
10304   {
10305     int r;
10306     suppress_error = 0;
10307     r = guestfs_umount_all (g);
10308     if (r == -1)
10309       return -1;
10310   }
10311   {
10312     int r;
10313     suppress_error = 0;
10314     r = guestfs_lvm_remove_all (g);
10315     if (r == -1)
10316       return -1;
10317   }
10318   {
10319     char device[] = "/dev/sda";
10320     device[5] = devchar;
10321     char lines_0[] = ",";
10322     char *lines[] = {
10323       lines_0,
10324       NULL
10325     };
10326     int r;
10327     suppress_error = 0;
10328     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10329     if (r == -1)
10330       return -1;
10331   }
10332   {
10333     char fstype[] = "ext2";
10334     char device[] = "/dev/sda1";
10335     device[5] = devchar;
10336     int r;
10337     suppress_error = 0;
10338     r = guestfs_mkfs (g, fstype, device);
10339     if (r == -1)
10340       return -1;
10341   }
10342   {
10343     char device[] = "/dev/sda1";
10344     device[5] = devchar;
10345     char mountpoint[] = "/";
10346     int r;
10347     suppress_error = 0;
10348     r = guestfs_mount (g, device, mountpoint);
10349     if (r == -1)
10350       return -1;
10351   }
10352   /* TestLastFail for file (2) */
10353   {
10354     char path[] = "/nofile";
10355     char *r;
10356     suppress_error = 1;
10357     r = guestfs_file (g, path);
10358     if (r != NULL)
10359       return -1;
10360     free (r);
10361   }
10362   return 0;
10363 }
10364
10365 static int test_umount_all_0_skip (void)
10366 {
10367   const char *str;
10368
10369   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10370   if (str && strcmp (str, "1") == 0) return 1;
10371   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10372   if (str && strcmp (str, "1") == 0) return 1;
10373   return 0;
10374 }
10375
10376 static int test_umount_all_0 (void)
10377 {
10378   if (test_umount_all_0_skip ()) {
10379     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10380     return 0;
10381   }
10382
10383   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10384   {
10385     char device[] = "/dev/sda";
10386     device[5] = devchar;
10387     int r;
10388     suppress_error = 0;
10389     r = guestfs_blockdev_setrw (g, device);
10390     if (r == -1)
10391       return -1;
10392   }
10393   {
10394     int r;
10395     suppress_error = 0;
10396     r = guestfs_umount_all (g);
10397     if (r == -1)
10398       return -1;
10399   }
10400   {
10401     int r;
10402     suppress_error = 0;
10403     r = guestfs_lvm_remove_all (g);
10404     if (r == -1)
10405       return -1;
10406   }
10407   {
10408     char device[] = "/dev/sda";
10409     device[5] = devchar;
10410     char lines_0[] = ",";
10411     char *lines[] = {
10412       lines_0,
10413       NULL
10414     };
10415     int r;
10416     suppress_error = 0;
10417     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10418     if (r == -1)
10419       return -1;
10420   }
10421   {
10422     char fstype[] = "ext2";
10423     char device[] = "/dev/sda1";
10424     device[5] = devchar;
10425     int r;
10426     suppress_error = 0;
10427     r = guestfs_mkfs (g, fstype, device);
10428     if (r == -1)
10429       return -1;
10430   }
10431   {
10432     char device[] = "/dev/sda1";
10433     device[5] = devchar;
10434     char mountpoint[] = "/";
10435     int r;
10436     suppress_error = 0;
10437     r = guestfs_mount (g, device, mountpoint);
10438     if (r == -1)
10439       return -1;
10440   }
10441   /* TestOutputList for umount_all (0) */
10442   {
10443     int r;
10444     suppress_error = 0;
10445     r = guestfs_umount_all (g);
10446     if (r == -1)
10447       return -1;
10448   }
10449   {
10450     char **r;
10451     int i;
10452     suppress_error = 0;
10453     r = guestfs_mounts (g);
10454     if (r == NULL)
10455       return -1;
10456     if (r[0] != NULL) {
10457       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10458       print_strings (r);
10459       return -1;
10460     }
10461     for (i = 0; r[i] != NULL; ++i)
10462       free (r[i]);
10463     free (r);
10464   }
10465   return 0;
10466 }
10467
10468 static int test_umount_all_1_skip (void)
10469 {
10470   const char *str;
10471
10472   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10473   if (str && strcmp (str, "1") == 0) return 1;
10474   str = getenv ("SKIP_TEST_UMOUNT_ALL");
10475   if (str && strcmp (str, "1") == 0) return 1;
10476   return 0;
10477 }
10478
10479 static int test_umount_all_1 (void)
10480 {
10481   if (test_umount_all_1_skip ()) {
10482     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10483     return 0;
10484   }
10485
10486   /* InitNone|InitEmpty for test_umount_all_1 */
10487   {
10488     char device[] = "/dev/sda";
10489     device[5] = devchar;
10490     int r;
10491     suppress_error = 0;
10492     r = guestfs_blockdev_setrw (g, device);
10493     if (r == -1)
10494       return -1;
10495   }
10496   {
10497     int r;
10498     suppress_error = 0;
10499     r = guestfs_umount_all (g);
10500     if (r == -1)
10501       return -1;
10502   }
10503   {
10504     int r;
10505     suppress_error = 0;
10506     r = guestfs_lvm_remove_all (g);
10507     if (r == -1)
10508       return -1;
10509   }
10510   /* TestOutputList for umount_all (1) */
10511   {
10512     char device[] = "/dev/sda";
10513     device[5] = devchar;
10514     char lines_0[] = ",10";
10515     char lines_1[] = ",20";
10516     char lines_2[] = ",";
10517     char *lines[] = {
10518       lines_0,
10519       lines_1,
10520       lines_2,
10521       NULL
10522     };
10523     int r;
10524     suppress_error = 0;
10525     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10526     if (r == -1)
10527       return -1;
10528   }
10529   {
10530     char fstype[] = "ext2";
10531     char device[] = "/dev/sda1";
10532     device[5] = devchar;
10533     int r;
10534     suppress_error = 0;
10535     r = guestfs_mkfs (g, fstype, device);
10536     if (r == -1)
10537       return -1;
10538   }
10539   {
10540     char fstype[] = "ext2";
10541     char device[] = "/dev/sda2";
10542     device[5] = devchar;
10543     int r;
10544     suppress_error = 0;
10545     r = guestfs_mkfs (g, fstype, device);
10546     if (r == -1)
10547       return -1;
10548   }
10549   {
10550     char fstype[] = "ext2";
10551     char device[] = "/dev/sda3";
10552     device[5] = devchar;
10553     int r;
10554     suppress_error = 0;
10555     r = guestfs_mkfs (g, fstype, device);
10556     if (r == -1)
10557       return -1;
10558   }
10559   {
10560     char device[] = "/dev/sda1";
10561     device[5] = devchar;
10562     char mountpoint[] = "/";
10563     int r;
10564     suppress_error = 0;
10565     r = guestfs_mount (g, device, mountpoint);
10566     if (r == -1)
10567       return -1;
10568   }
10569   {
10570     char path[] = "/mp1";
10571     int r;
10572     suppress_error = 0;
10573     r = guestfs_mkdir (g, path);
10574     if (r == -1)
10575       return -1;
10576   }
10577   {
10578     char device[] = "/dev/sda2";
10579     device[5] = devchar;
10580     char mountpoint[] = "/mp1";
10581     int r;
10582     suppress_error = 0;
10583     r = guestfs_mount (g, device, mountpoint);
10584     if (r == -1)
10585       return -1;
10586   }
10587   {
10588     char path[] = "/mp1/mp2";
10589     int r;
10590     suppress_error = 0;
10591     r = guestfs_mkdir (g, path);
10592     if (r == -1)
10593       return -1;
10594   }
10595   {
10596     char device[] = "/dev/sda3";
10597     device[5] = devchar;
10598     char mountpoint[] = "/mp1/mp2";
10599     int r;
10600     suppress_error = 0;
10601     r = guestfs_mount (g, device, mountpoint);
10602     if (r == -1)
10603       return -1;
10604   }
10605   {
10606     char path[] = "/mp1/mp2/mp3";
10607     int r;
10608     suppress_error = 0;
10609     r = guestfs_mkdir (g, path);
10610     if (r == -1)
10611       return -1;
10612   }
10613   {
10614     int r;
10615     suppress_error = 0;
10616     r = guestfs_umount_all (g);
10617     if (r == -1)
10618       return -1;
10619   }
10620   {
10621     char **r;
10622     int i;
10623     suppress_error = 0;
10624     r = guestfs_mounts (g);
10625     if (r == NULL)
10626       return -1;
10627     if (r[0] != NULL) {
10628       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10629       print_strings (r);
10630       return -1;
10631     }
10632     for (i = 0; r[i] != NULL; ++i)
10633       free (r[i]);
10634     free (r);
10635   }
10636   return 0;
10637 }
10638
10639 static int test_mounts_0_skip (void)
10640 {
10641   const char *str;
10642
10643   str = getenv ("SKIP_TEST_MOUNTS_0");
10644   if (str && strcmp (str, "1") == 0) return 1;
10645   str = getenv ("SKIP_TEST_MOUNTS");
10646   if (str && strcmp (str, "1") == 0) return 1;
10647   return 0;
10648 }
10649
10650 static int test_mounts_0 (void)
10651 {
10652   if (test_mounts_0_skip ()) {
10653     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10654     return 0;
10655   }
10656
10657   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10658   {
10659     char device[] = "/dev/sda";
10660     device[5] = devchar;
10661     int r;
10662     suppress_error = 0;
10663     r = guestfs_blockdev_setrw (g, device);
10664     if (r == -1)
10665       return -1;
10666   }
10667   {
10668     int r;
10669     suppress_error = 0;
10670     r = guestfs_umount_all (g);
10671     if (r == -1)
10672       return -1;
10673   }
10674   {
10675     int r;
10676     suppress_error = 0;
10677     r = guestfs_lvm_remove_all (g);
10678     if (r == -1)
10679       return -1;
10680   }
10681   {
10682     char device[] = "/dev/sda";
10683     device[5] = devchar;
10684     char lines_0[] = ",";
10685     char *lines[] = {
10686       lines_0,
10687       NULL
10688     };
10689     int r;
10690     suppress_error = 0;
10691     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10692     if (r == -1)
10693       return -1;
10694   }
10695   {
10696     char fstype[] = "ext2";
10697     char device[] = "/dev/sda1";
10698     device[5] = devchar;
10699     int r;
10700     suppress_error = 0;
10701     r = guestfs_mkfs (g, fstype, device);
10702     if (r == -1)
10703       return -1;
10704   }
10705   {
10706     char device[] = "/dev/sda1";
10707     device[5] = devchar;
10708     char mountpoint[] = "/";
10709     int r;
10710     suppress_error = 0;
10711     r = guestfs_mount (g, device, mountpoint);
10712     if (r == -1)
10713       return -1;
10714   }
10715   /* TestOutputList for mounts (0) */
10716   {
10717     char **r;
10718     int i;
10719     suppress_error = 0;
10720     r = guestfs_mounts (g);
10721     if (r == NULL)
10722       return -1;
10723     if (!r[0]) {
10724       fprintf (stderr, "test_mounts_0: short list returned from command\n");
10725       print_strings (r);
10726       return -1;
10727     }
10728     {
10729       char expected[] = "/dev/sda1";
10730       expected[5] = devchar;
10731       if (strcmp (r[0], expected) != 0) {
10732         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10733         return -1;
10734       }
10735     }
10736     if (r[1] != NULL) {
10737       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10738       print_strings (r);
10739       return -1;
10740     }
10741     for (i = 0; r[i] != NULL; ++i)
10742       free (r[i]);
10743     free (r);
10744   }
10745   return 0;
10746 }
10747
10748 static int test_umount_0_skip (void)
10749 {
10750   const char *str;
10751
10752   str = getenv ("SKIP_TEST_UMOUNT_0");
10753   if (str && strcmp (str, "1") == 0) return 1;
10754   str = getenv ("SKIP_TEST_UMOUNT");
10755   if (str && strcmp (str, "1") == 0) return 1;
10756   return 0;
10757 }
10758
10759 static int test_umount_0 (void)
10760 {
10761   if (test_umount_0_skip ()) {
10762     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10763     return 0;
10764   }
10765
10766   /* InitNone|InitEmpty for test_umount_0 */
10767   {
10768     char device[] = "/dev/sda";
10769     device[5] = devchar;
10770     int r;
10771     suppress_error = 0;
10772     r = guestfs_blockdev_setrw (g, device);
10773     if (r == -1)
10774       return -1;
10775   }
10776   {
10777     int r;
10778     suppress_error = 0;
10779     r = guestfs_umount_all (g);
10780     if (r == -1)
10781       return -1;
10782   }
10783   {
10784     int r;
10785     suppress_error = 0;
10786     r = guestfs_lvm_remove_all (g);
10787     if (r == -1)
10788       return -1;
10789   }
10790   /* TestOutputList for umount (0) */
10791   {
10792     char device[] = "/dev/sda";
10793     device[5] = devchar;
10794     char lines_0[] = ",";
10795     char *lines[] = {
10796       lines_0,
10797       NULL
10798     };
10799     int r;
10800     suppress_error = 0;
10801     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10802     if (r == -1)
10803       return -1;
10804   }
10805   {
10806     char fstype[] = "ext2";
10807     char device[] = "/dev/sda1";
10808     device[5] = devchar;
10809     int r;
10810     suppress_error = 0;
10811     r = guestfs_mkfs (g, fstype, device);
10812     if (r == -1)
10813       return -1;
10814   }
10815   {
10816     char device[] = "/dev/sda1";
10817     device[5] = devchar;
10818     char mountpoint[] = "/";
10819     int r;
10820     suppress_error = 0;
10821     r = guestfs_mount (g, device, mountpoint);
10822     if (r == -1)
10823       return -1;
10824   }
10825   {
10826     char **r;
10827     int i;
10828     suppress_error = 0;
10829     r = guestfs_mounts (g);
10830     if (r == NULL)
10831       return -1;
10832     if (!r[0]) {
10833       fprintf (stderr, "test_umount_0: short list returned from command\n");
10834       print_strings (r);
10835       return -1;
10836     }
10837     {
10838       char expected[] = "/dev/sda1";
10839       expected[5] = devchar;
10840       if (strcmp (r[0], expected) != 0) {
10841         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10842         return -1;
10843       }
10844     }
10845     if (r[1] != NULL) {
10846       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10847       print_strings (r);
10848       return -1;
10849     }
10850     for (i = 0; r[i] != NULL; ++i)
10851       free (r[i]);
10852     free (r);
10853   }
10854   return 0;
10855 }
10856
10857 static int test_umount_1_skip (void)
10858 {
10859   const char *str;
10860
10861   str = getenv ("SKIP_TEST_UMOUNT_1");
10862   if (str && strcmp (str, "1") == 0) return 1;
10863   str = getenv ("SKIP_TEST_UMOUNT");
10864   if (str && strcmp (str, "1") == 0) return 1;
10865   return 0;
10866 }
10867
10868 static int test_umount_1 (void)
10869 {
10870   if (test_umount_1_skip ()) {
10871     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10872     return 0;
10873   }
10874
10875   /* InitNone|InitEmpty for test_umount_1 */
10876   {
10877     char device[] = "/dev/sda";
10878     device[5] = devchar;
10879     int r;
10880     suppress_error = 0;
10881     r = guestfs_blockdev_setrw (g, device);
10882     if (r == -1)
10883       return -1;
10884   }
10885   {
10886     int r;
10887     suppress_error = 0;
10888     r = guestfs_umount_all (g);
10889     if (r == -1)
10890       return -1;
10891   }
10892   {
10893     int r;
10894     suppress_error = 0;
10895     r = guestfs_lvm_remove_all (g);
10896     if (r == -1)
10897       return -1;
10898   }
10899   /* TestOutputList for umount (1) */
10900   {
10901     char device[] = "/dev/sda";
10902     device[5] = devchar;
10903     char lines_0[] = ",";
10904     char *lines[] = {
10905       lines_0,
10906       NULL
10907     };
10908     int r;
10909     suppress_error = 0;
10910     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10911     if (r == -1)
10912       return -1;
10913   }
10914   {
10915     char fstype[] = "ext2";
10916     char device[] = "/dev/sda1";
10917     device[5] = devchar;
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     device[5] = devchar;
10927     char mountpoint[] = "/";
10928     int r;
10929     suppress_error = 0;
10930     r = guestfs_mount (g, device, mountpoint);
10931     if (r == -1)
10932       return -1;
10933   }
10934   {
10935     char pathordevice[] = "/";
10936     int r;
10937     suppress_error = 0;
10938     r = guestfs_umount (g, pathordevice);
10939     if (r == -1)
10940       return -1;
10941   }
10942   {
10943     char **r;
10944     int i;
10945     suppress_error = 0;
10946     r = guestfs_mounts (g);
10947     if (r == NULL)
10948       return -1;
10949     if (r[0] != NULL) {
10950       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10951       print_strings (r);
10952       return -1;
10953     }
10954     for (i = 0; r[i] != NULL; ++i)
10955       free (r[i]);
10956     free (r);
10957   }
10958   return 0;
10959 }
10960
10961 static int test_write_file_0_skip (void)
10962 {
10963   const char *str;
10964
10965   str = getenv ("SKIP_TEST_WRITE_FILE_0");
10966   if (str && strcmp (str, "1") == 0) return 1;
10967   str = getenv ("SKIP_TEST_WRITE_FILE");
10968   if (str && strcmp (str, "1") == 0) return 1;
10969   return 0;
10970 }
10971
10972 static int test_write_file_0 (void)
10973 {
10974   if (test_write_file_0_skip ()) {
10975     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10976     return 0;
10977   }
10978
10979   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10980   {
10981     char device[] = "/dev/sda";
10982     device[5] = devchar;
10983     int r;
10984     suppress_error = 0;
10985     r = guestfs_blockdev_setrw (g, device);
10986     if (r == -1)
10987       return -1;
10988   }
10989   {
10990     int r;
10991     suppress_error = 0;
10992     r = guestfs_umount_all (g);
10993     if (r == -1)
10994       return -1;
10995   }
10996   {
10997     int r;
10998     suppress_error = 0;
10999     r = guestfs_lvm_remove_all (g);
11000     if (r == -1)
11001       return -1;
11002   }
11003   {
11004     char device[] = "/dev/sda";
11005     device[5] = devchar;
11006     char lines_0[] = ",";
11007     char *lines[] = {
11008       lines_0,
11009       NULL
11010     };
11011     int r;
11012     suppress_error = 0;
11013     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11014     if (r == -1)
11015       return -1;
11016   }
11017   {
11018     char fstype[] = "ext2";
11019     char device[] = "/dev/sda1";
11020     device[5] = devchar;
11021     int r;
11022     suppress_error = 0;
11023     r = guestfs_mkfs (g, fstype, device);
11024     if (r == -1)
11025       return -1;
11026   }
11027   {
11028     char device[] = "/dev/sda1";
11029     device[5] = devchar;
11030     char mountpoint[] = "/";
11031     int r;
11032     suppress_error = 0;
11033     r = guestfs_mount (g, device, mountpoint);
11034     if (r == -1)
11035       return -1;
11036   }
11037   /* TestOutput for write_file (0) */
11038   char expected[] = "new file contents";
11039   {
11040     char path[] = "/new";
11041     char content[] = "new file contents";
11042     int r;
11043     suppress_error = 0;
11044     r = guestfs_write_file (g, path, content, 0);
11045     if (r == -1)
11046       return -1;
11047   }
11048   {
11049     char path[] = "/new";
11050     char *r;
11051     suppress_error = 0;
11052     r = guestfs_cat (g, path);
11053     if (r == NULL)
11054       return -1;
11055     if (strcmp (r, expected) != 0) {
11056       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11057       return -1;
11058     }
11059     free (r);
11060   }
11061   return 0;
11062 }
11063
11064 static int test_write_file_1_skip (void)
11065 {
11066   const char *str;
11067
11068   str = getenv ("SKIP_TEST_WRITE_FILE_1");
11069   if (str && strcmp (str, "1") == 0) return 1;
11070   str = getenv ("SKIP_TEST_WRITE_FILE");
11071   if (str && strcmp (str, "1") == 0) return 1;
11072   return 0;
11073 }
11074
11075 static int test_write_file_1 (void)
11076 {
11077   if (test_write_file_1_skip ()) {
11078     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11079     return 0;
11080   }
11081
11082   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11083   {
11084     char device[] = "/dev/sda";
11085     device[5] = devchar;
11086     int r;
11087     suppress_error = 0;
11088     r = guestfs_blockdev_setrw (g, device);
11089     if (r == -1)
11090       return -1;
11091   }
11092   {
11093     int r;
11094     suppress_error = 0;
11095     r = guestfs_umount_all (g);
11096     if (r == -1)
11097       return -1;
11098   }
11099   {
11100     int r;
11101     suppress_error = 0;
11102     r = guestfs_lvm_remove_all (g);
11103     if (r == -1)
11104       return -1;
11105   }
11106   {
11107     char device[] = "/dev/sda";
11108     device[5] = devchar;
11109     char lines_0[] = ",";
11110     char *lines[] = {
11111       lines_0,
11112       NULL
11113     };
11114     int r;
11115     suppress_error = 0;
11116     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11117     if (r == -1)
11118       return -1;
11119   }
11120   {
11121     char fstype[] = "ext2";
11122     char device[] = "/dev/sda1";
11123     device[5] = devchar;
11124     int r;
11125     suppress_error = 0;
11126     r = guestfs_mkfs (g, fstype, device);
11127     if (r == -1)
11128       return -1;
11129   }
11130   {
11131     char device[] = "/dev/sda1";
11132     device[5] = devchar;
11133     char mountpoint[] = "/";
11134     int r;
11135     suppress_error = 0;
11136     r = guestfs_mount (g, device, mountpoint);
11137     if (r == -1)
11138       return -1;
11139   }
11140   /* TestOutput for write_file (1) */
11141   char expected[] = "\nnew file contents\n";
11142   {
11143     char path[] = "/new";
11144     char content[] = "\nnew file contents\n";
11145     int r;
11146     suppress_error = 0;
11147     r = guestfs_write_file (g, path, content, 0);
11148     if (r == -1)
11149       return -1;
11150   }
11151   {
11152     char path[] = "/new";
11153     char *r;
11154     suppress_error = 0;
11155     r = guestfs_cat (g, path);
11156     if (r == NULL)
11157       return -1;
11158     if (strcmp (r, expected) != 0) {
11159       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11160       return -1;
11161     }
11162     free (r);
11163   }
11164   return 0;
11165 }
11166
11167 static int test_write_file_2_skip (void)
11168 {
11169   const char *str;
11170
11171   str = getenv ("SKIP_TEST_WRITE_FILE_2");
11172   if (str && strcmp (str, "1") == 0) return 1;
11173   str = getenv ("SKIP_TEST_WRITE_FILE");
11174   if (str && strcmp (str, "1") == 0) return 1;
11175   return 0;
11176 }
11177
11178 static int test_write_file_2 (void)
11179 {
11180   if (test_write_file_2_skip ()) {
11181     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11182     return 0;
11183   }
11184
11185   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11186   {
11187     char device[] = "/dev/sda";
11188     device[5] = devchar;
11189     int r;
11190     suppress_error = 0;
11191     r = guestfs_blockdev_setrw (g, device);
11192     if (r == -1)
11193       return -1;
11194   }
11195   {
11196     int r;
11197     suppress_error = 0;
11198     r = guestfs_umount_all (g);
11199     if (r == -1)
11200       return -1;
11201   }
11202   {
11203     int r;
11204     suppress_error = 0;
11205     r = guestfs_lvm_remove_all (g);
11206     if (r == -1)
11207       return -1;
11208   }
11209   {
11210     char device[] = "/dev/sda";
11211     device[5] = devchar;
11212     char lines_0[] = ",";
11213     char *lines[] = {
11214       lines_0,
11215       NULL
11216     };
11217     int r;
11218     suppress_error = 0;
11219     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11220     if (r == -1)
11221       return -1;
11222   }
11223   {
11224     char fstype[] = "ext2";
11225     char device[] = "/dev/sda1";
11226     device[5] = devchar;
11227     int r;
11228     suppress_error = 0;
11229     r = guestfs_mkfs (g, fstype, device);
11230     if (r == -1)
11231       return -1;
11232   }
11233   {
11234     char device[] = "/dev/sda1";
11235     device[5] = devchar;
11236     char mountpoint[] = "/";
11237     int r;
11238     suppress_error = 0;
11239     r = guestfs_mount (g, device, mountpoint);
11240     if (r == -1)
11241       return -1;
11242   }
11243   /* TestOutput for write_file (2) */
11244   char expected[] = "\n\n";
11245   {
11246     char path[] = "/new";
11247     char content[] = "\n\n";
11248     int r;
11249     suppress_error = 0;
11250     r = guestfs_write_file (g, path, content, 0);
11251     if (r == -1)
11252       return -1;
11253   }
11254   {
11255     char path[] = "/new";
11256     char *r;
11257     suppress_error = 0;
11258     r = guestfs_cat (g, path);
11259     if (r == NULL)
11260       return -1;
11261     if (strcmp (r, expected) != 0) {
11262       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11263       return -1;
11264     }
11265     free (r);
11266   }
11267   return 0;
11268 }
11269
11270 static int test_write_file_3_skip (void)
11271 {
11272   const char *str;
11273
11274   str = getenv ("SKIP_TEST_WRITE_FILE_3");
11275   if (str && strcmp (str, "1") == 0) return 1;
11276   str = getenv ("SKIP_TEST_WRITE_FILE");
11277   if (str && strcmp (str, "1") == 0) return 1;
11278   return 0;
11279 }
11280
11281 static int test_write_file_3 (void)
11282 {
11283   if (test_write_file_3_skip ()) {
11284     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11285     return 0;
11286   }
11287
11288   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11289   {
11290     char device[] = "/dev/sda";
11291     device[5] = devchar;
11292     int r;
11293     suppress_error = 0;
11294     r = guestfs_blockdev_setrw (g, device);
11295     if (r == -1)
11296       return -1;
11297   }
11298   {
11299     int r;
11300     suppress_error = 0;
11301     r = guestfs_umount_all (g);
11302     if (r == -1)
11303       return -1;
11304   }
11305   {
11306     int r;
11307     suppress_error = 0;
11308     r = guestfs_lvm_remove_all (g);
11309     if (r == -1)
11310       return -1;
11311   }
11312   {
11313     char device[] = "/dev/sda";
11314     device[5] = devchar;
11315     char lines_0[] = ",";
11316     char *lines[] = {
11317       lines_0,
11318       NULL
11319     };
11320     int r;
11321     suppress_error = 0;
11322     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11323     if (r == -1)
11324       return -1;
11325   }
11326   {
11327     char fstype[] = "ext2";
11328     char device[] = "/dev/sda1";
11329     device[5] = devchar;
11330     int r;
11331     suppress_error = 0;
11332     r = guestfs_mkfs (g, fstype, device);
11333     if (r == -1)
11334       return -1;
11335   }
11336   {
11337     char device[] = "/dev/sda1";
11338     device[5] = devchar;
11339     char mountpoint[] = "/";
11340     int r;
11341     suppress_error = 0;
11342     r = guestfs_mount (g, device, mountpoint);
11343     if (r == -1)
11344       return -1;
11345   }
11346   /* TestOutput for write_file (3) */
11347   char expected[] = "";
11348   {
11349     char path[] = "/new";
11350     char content[] = "";
11351     int r;
11352     suppress_error = 0;
11353     r = guestfs_write_file (g, path, content, 0);
11354     if (r == -1)
11355       return -1;
11356   }
11357   {
11358     char path[] = "/new";
11359     char *r;
11360     suppress_error = 0;
11361     r = guestfs_cat (g, path);
11362     if (r == NULL)
11363       return -1;
11364     if (strcmp (r, expected) != 0) {
11365       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11366       return -1;
11367     }
11368     free (r);
11369   }
11370   return 0;
11371 }
11372
11373 static int test_write_file_4_skip (void)
11374 {
11375   const char *str;
11376
11377   str = getenv ("SKIP_TEST_WRITE_FILE_4");
11378   if (str && strcmp (str, "1") == 0) return 1;
11379   str = getenv ("SKIP_TEST_WRITE_FILE");
11380   if (str && strcmp (str, "1") == 0) return 1;
11381   return 0;
11382 }
11383
11384 static int test_write_file_4 (void)
11385 {
11386   if (test_write_file_4_skip ()) {
11387     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11388     return 0;
11389   }
11390
11391   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11392   {
11393     char device[] = "/dev/sda";
11394     device[5] = devchar;
11395     int r;
11396     suppress_error = 0;
11397     r = guestfs_blockdev_setrw (g, device);
11398     if (r == -1)
11399       return -1;
11400   }
11401   {
11402     int r;
11403     suppress_error = 0;
11404     r = guestfs_umount_all (g);
11405     if (r == -1)
11406       return -1;
11407   }
11408   {
11409     int r;
11410     suppress_error = 0;
11411     r = guestfs_lvm_remove_all (g);
11412     if (r == -1)
11413       return -1;
11414   }
11415   {
11416     char device[] = "/dev/sda";
11417     device[5] = devchar;
11418     char lines_0[] = ",";
11419     char *lines[] = {
11420       lines_0,
11421       NULL
11422     };
11423     int r;
11424     suppress_error = 0;
11425     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11426     if (r == -1)
11427       return -1;
11428   }
11429   {
11430     char fstype[] = "ext2";
11431     char device[] = "/dev/sda1";
11432     device[5] = devchar;
11433     int r;
11434     suppress_error = 0;
11435     r = guestfs_mkfs (g, fstype, device);
11436     if (r == -1)
11437       return -1;
11438   }
11439   {
11440     char device[] = "/dev/sda1";
11441     device[5] = devchar;
11442     char mountpoint[] = "/";
11443     int r;
11444     suppress_error = 0;
11445     r = guestfs_mount (g, device, mountpoint);
11446     if (r == -1)
11447       return -1;
11448   }
11449   /* TestOutput for write_file (4) */
11450   char expected[] = "\n\n\n";
11451   {
11452     char path[] = "/new";
11453     char content[] = "\n\n\n";
11454     int r;
11455     suppress_error = 0;
11456     r = guestfs_write_file (g, path, content, 0);
11457     if (r == -1)
11458       return -1;
11459   }
11460   {
11461     char path[] = "/new";
11462     char *r;
11463     suppress_error = 0;
11464     r = guestfs_cat (g, path);
11465     if (r == NULL)
11466       return -1;
11467     if (strcmp (r, expected) != 0) {
11468       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11469       return -1;
11470     }
11471     free (r);
11472   }
11473   return 0;
11474 }
11475
11476 static int test_write_file_5_skip (void)
11477 {
11478   const char *str;
11479
11480   str = getenv ("SKIP_TEST_WRITE_FILE_5");
11481   if (str && strcmp (str, "1") == 0) return 1;
11482   str = getenv ("SKIP_TEST_WRITE_FILE");
11483   if (str && strcmp (str, "1") == 0) return 1;
11484   return 0;
11485 }
11486
11487 static int test_write_file_5 (void)
11488 {
11489   if (test_write_file_5_skip ()) {
11490     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11491     return 0;
11492   }
11493
11494   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11495   {
11496     char device[] = "/dev/sda";
11497     device[5] = devchar;
11498     int r;
11499     suppress_error = 0;
11500     r = guestfs_blockdev_setrw (g, device);
11501     if (r == -1)
11502       return -1;
11503   }
11504   {
11505     int r;
11506     suppress_error = 0;
11507     r = guestfs_umount_all (g);
11508     if (r == -1)
11509       return -1;
11510   }
11511   {
11512     int r;
11513     suppress_error = 0;
11514     r = guestfs_lvm_remove_all (g);
11515     if (r == -1)
11516       return -1;
11517   }
11518   {
11519     char device[] = "/dev/sda";
11520     device[5] = devchar;
11521     char lines_0[] = ",";
11522     char *lines[] = {
11523       lines_0,
11524       NULL
11525     };
11526     int r;
11527     suppress_error = 0;
11528     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11529     if (r == -1)
11530       return -1;
11531   }
11532   {
11533     char fstype[] = "ext2";
11534     char device[] = "/dev/sda1";
11535     device[5] = devchar;
11536     int r;
11537     suppress_error = 0;
11538     r = guestfs_mkfs (g, fstype, device);
11539     if (r == -1)
11540       return -1;
11541   }
11542   {
11543     char device[] = "/dev/sda1";
11544     device[5] = devchar;
11545     char mountpoint[] = "/";
11546     int r;
11547     suppress_error = 0;
11548     r = guestfs_mount (g, device, mountpoint);
11549     if (r == -1)
11550       return -1;
11551   }
11552   /* TestOutput for write_file (5) */
11553   char expected[] = "\n";
11554   {
11555     char path[] = "/new";
11556     char content[] = "\n";
11557     int r;
11558     suppress_error = 0;
11559     r = guestfs_write_file (g, path, content, 0);
11560     if (r == -1)
11561       return -1;
11562   }
11563   {
11564     char path[] = "/new";
11565     char *r;
11566     suppress_error = 0;
11567     r = guestfs_cat (g, path);
11568     if (r == NULL)
11569       return -1;
11570     if (strcmp (r, expected) != 0) {
11571       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11572       return -1;
11573     }
11574     free (r);
11575   }
11576   return 0;
11577 }
11578
11579 static int test_mkfs_0_skip (void)
11580 {
11581   const char *str;
11582
11583   str = getenv ("SKIP_TEST_MKFS_0");
11584   if (str && strcmp (str, "1") == 0) return 1;
11585   str = getenv ("SKIP_TEST_MKFS");
11586   if (str && strcmp (str, "1") == 0) return 1;
11587   return 0;
11588 }
11589
11590 static int test_mkfs_0 (void)
11591 {
11592   if (test_mkfs_0_skip ()) {
11593     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11594     return 0;
11595   }
11596
11597   /* InitNone|InitEmpty for test_mkfs_0 */
11598   {
11599     char device[] = "/dev/sda";
11600     device[5] = devchar;
11601     int r;
11602     suppress_error = 0;
11603     r = guestfs_blockdev_setrw (g, device);
11604     if (r == -1)
11605       return -1;
11606   }
11607   {
11608     int r;
11609     suppress_error = 0;
11610     r = guestfs_umount_all (g);
11611     if (r == -1)
11612       return -1;
11613   }
11614   {
11615     int r;
11616     suppress_error = 0;
11617     r = guestfs_lvm_remove_all (g);
11618     if (r == -1)
11619       return -1;
11620   }
11621   /* TestOutput for mkfs (0) */
11622   char expected[] = "new file contents";
11623   {
11624     char device[] = "/dev/sda";
11625     device[5] = devchar;
11626     char lines_0[] = ",";
11627     char *lines[] = {
11628       lines_0,
11629       NULL
11630     };
11631     int r;
11632     suppress_error = 0;
11633     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11634     if (r == -1)
11635       return -1;
11636   }
11637   {
11638     char fstype[] = "ext2";
11639     char device[] = "/dev/sda1";
11640     device[5] = devchar;
11641     int r;
11642     suppress_error = 0;
11643     r = guestfs_mkfs (g, fstype, device);
11644     if (r == -1)
11645       return -1;
11646   }
11647   {
11648     char device[] = "/dev/sda1";
11649     device[5] = devchar;
11650     char mountpoint[] = "/";
11651     int r;
11652     suppress_error = 0;
11653     r = guestfs_mount (g, device, mountpoint);
11654     if (r == -1)
11655       return -1;
11656   }
11657   {
11658     char path[] = "/new";
11659     char content[] = "new file contents";
11660     int r;
11661     suppress_error = 0;
11662     r = guestfs_write_file (g, path, content, 0);
11663     if (r == -1)
11664       return -1;
11665   }
11666   {
11667     char path[] = "/new";
11668     char *r;
11669     suppress_error = 0;
11670     r = guestfs_cat (g, path);
11671     if (r == NULL)
11672       return -1;
11673     if (strcmp (r, expected) != 0) {
11674       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11675       return -1;
11676     }
11677     free (r);
11678   }
11679   return 0;
11680 }
11681
11682 static int test_lvcreate_0_skip (void)
11683 {
11684   const char *str;
11685
11686   str = getenv ("SKIP_TEST_LVCREATE_0");
11687   if (str && strcmp (str, "1") == 0) return 1;
11688   str = getenv ("SKIP_TEST_LVCREATE");
11689   if (str && strcmp (str, "1") == 0) return 1;
11690   return 0;
11691 }
11692
11693 static int test_lvcreate_0 (void)
11694 {
11695   if (test_lvcreate_0_skip ()) {
11696     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11697     return 0;
11698   }
11699
11700   /* InitNone|InitEmpty for test_lvcreate_0 */
11701   {
11702     char device[] = "/dev/sda";
11703     device[5] = devchar;
11704     int r;
11705     suppress_error = 0;
11706     r = guestfs_blockdev_setrw (g, device);
11707     if (r == -1)
11708       return -1;
11709   }
11710   {
11711     int r;
11712     suppress_error = 0;
11713     r = guestfs_umount_all (g);
11714     if (r == -1)
11715       return -1;
11716   }
11717   {
11718     int r;
11719     suppress_error = 0;
11720     r = guestfs_lvm_remove_all (g);
11721     if (r == -1)
11722       return -1;
11723   }
11724   /* TestOutputList for lvcreate (0) */
11725   {
11726     char device[] = "/dev/sda";
11727     device[5] = devchar;
11728     char lines_0[] = ",10";
11729     char lines_1[] = ",20";
11730     char lines_2[] = ",";
11731     char *lines[] = {
11732       lines_0,
11733       lines_1,
11734       lines_2,
11735       NULL
11736     };
11737     int r;
11738     suppress_error = 0;
11739     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11740     if (r == -1)
11741       return -1;
11742   }
11743   {
11744     char device[] = "/dev/sda1";
11745     device[5] = devchar;
11746     int r;
11747     suppress_error = 0;
11748     r = guestfs_pvcreate (g, device);
11749     if (r == -1)
11750       return -1;
11751   }
11752   {
11753     char device[] = "/dev/sda2";
11754     device[5] = devchar;
11755     int r;
11756     suppress_error = 0;
11757     r = guestfs_pvcreate (g, device);
11758     if (r == -1)
11759       return -1;
11760   }
11761   {
11762     char device[] = "/dev/sda3";
11763     device[5] = devchar;
11764     int r;
11765     suppress_error = 0;
11766     r = guestfs_pvcreate (g, device);
11767     if (r == -1)
11768       return -1;
11769   }
11770   {
11771     char volgroup[] = "VG1";
11772     char physvols_0[] = "/dev/sda1";
11773     physvols_0[5] = devchar;
11774     char physvols_1[] = "/dev/sda2";
11775     physvols_1[5] = devchar;
11776     char *physvols[] = {
11777       physvols_0,
11778       physvols_1,
11779       NULL
11780     };
11781     int r;
11782     suppress_error = 0;
11783     r = guestfs_vgcreate (g, volgroup, physvols);
11784     if (r == -1)
11785       return -1;
11786   }
11787   {
11788     char volgroup[] = "VG2";
11789     char physvols_0[] = "/dev/sda3";
11790     physvols_0[5] = devchar;
11791     char *physvols[] = {
11792       physvols_0,
11793       NULL
11794     };
11795     int r;
11796     suppress_error = 0;
11797     r = guestfs_vgcreate (g, volgroup, physvols);
11798     if (r == -1)
11799       return -1;
11800   }
11801   {
11802     char logvol[] = "LV1";
11803     char volgroup[] = "VG1";
11804     int r;
11805     suppress_error = 0;
11806     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11807     if (r == -1)
11808       return -1;
11809   }
11810   {
11811     char logvol[] = "LV2";
11812     char volgroup[] = "VG1";
11813     int r;
11814     suppress_error = 0;
11815     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11816     if (r == -1)
11817       return -1;
11818   }
11819   {
11820     char logvol[] = "LV3";
11821     char volgroup[] = "VG2";
11822     int r;
11823     suppress_error = 0;
11824     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11825     if (r == -1)
11826       return -1;
11827   }
11828   {
11829     char logvol[] = "LV4";
11830     char volgroup[] = "VG2";
11831     int r;
11832     suppress_error = 0;
11833     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11834     if (r == -1)
11835       return -1;
11836   }
11837   {
11838     char logvol[] = "LV5";
11839     char volgroup[] = "VG2";
11840     int r;
11841     suppress_error = 0;
11842     r = guestfs_lvcreate (g, logvol, volgroup, 50);
11843     if (r == -1)
11844       return -1;
11845   }
11846   {
11847     char **r;
11848     int i;
11849     suppress_error = 0;
11850     r = guestfs_lvs (g);
11851     if (r == NULL)
11852       return -1;
11853     if (!r[0]) {
11854       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11855       print_strings (r);
11856       return -1;
11857     }
11858     {
11859       char expected[] = "/dev/VG1/LV1";
11860       if (strcmp (r[0], expected) != 0) {
11861         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11862         return -1;
11863       }
11864     }
11865     if (!r[1]) {
11866       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11867       print_strings (r);
11868       return -1;
11869     }
11870     {
11871       char expected[] = "/dev/VG1/LV2";
11872       if (strcmp (r[1], expected) != 0) {
11873         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11874         return -1;
11875       }
11876     }
11877     if (!r[2]) {
11878       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11879       print_strings (r);
11880       return -1;
11881     }
11882     {
11883       char expected[] = "/dev/VG2/LV3";
11884       if (strcmp (r[2], expected) != 0) {
11885         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11886         return -1;
11887       }
11888     }
11889     if (!r[3]) {
11890       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11891       print_strings (r);
11892       return -1;
11893     }
11894     {
11895       char expected[] = "/dev/VG2/LV4";
11896       if (strcmp (r[3], expected) != 0) {
11897         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11898         return -1;
11899       }
11900     }
11901     if (!r[4]) {
11902       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11903       print_strings (r);
11904       return -1;
11905     }
11906     {
11907       char expected[] = "/dev/VG2/LV5";
11908       if (strcmp (r[4], expected) != 0) {
11909         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11910         return -1;
11911       }
11912     }
11913     if (r[5] != NULL) {
11914       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11915       print_strings (r);
11916       return -1;
11917     }
11918     for (i = 0; r[i] != NULL; ++i)
11919       free (r[i]);
11920     free (r);
11921   }
11922   return 0;
11923 }
11924
11925 static int test_vgcreate_0_skip (void)
11926 {
11927   const char *str;
11928
11929   str = getenv ("SKIP_TEST_VGCREATE_0");
11930   if (str && strcmp (str, "1") == 0) return 1;
11931   str = getenv ("SKIP_TEST_VGCREATE");
11932   if (str && strcmp (str, "1") == 0) return 1;
11933   return 0;
11934 }
11935
11936 static int test_vgcreate_0 (void)
11937 {
11938   if (test_vgcreate_0_skip ()) {
11939     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11940     return 0;
11941   }
11942
11943   /* InitNone|InitEmpty for test_vgcreate_0 */
11944   {
11945     char device[] = "/dev/sda";
11946     device[5] = devchar;
11947     int r;
11948     suppress_error = 0;
11949     r = guestfs_blockdev_setrw (g, device);
11950     if (r == -1)
11951       return -1;
11952   }
11953   {
11954     int r;
11955     suppress_error = 0;
11956     r = guestfs_umount_all (g);
11957     if (r == -1)
11958       return -1;
11959   }
11960   {
11961     int r;
11962     suppress_error = 0;
11963     r = guestfs_lvm_remove_all (g);
11964     if (r == -1)
11965       return -1;
11966   }
11967   /* TestOutputList for vgcreate (0) */
11968   {
11969     char device[] = "/dev/sda";
11970     device[5] = devchar;
11971     char lines_0[] = ",10";
11972     char lines_1[] = ",20";
11973     char lines_2[] = ",";
11974     char *lines[] = {
11975       lines_0,
11976       lines_1,
11977       lines_2,
11978       NULL
11979     };
11980     int r;
11981     suppress_error = 0;
11982     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11983     if (r == -1)
11984       return -1;
11985   }
11986   {
11987     char device[] = "/dev/sda1";
11988     device[5] = devchar;
11989     int r;
11990     suppress_error = 0;
11991     r = guestfs_pvcreate (g, device);
11992     if (r == -1)
11993       return -1;
11994   }
11995   {
11996     char device[] = "/dev/sda2";
11997     device[5] = devchar;
11998     int r;
11999     suppress_error = 0;
12000     r = guestfs_pvcreate (g, device);
12001     if (r == -1)
12002       return -1;
12003   }
12004   {
12005     char device[] = "/dev/sda3";
12006     device[5] = devchar;
12007     int r;
12008     suppress_error = 0;
12009     r = guestfs_pvcreate (g, device);
12010     if (r == -1)
12011       return -1;
12012   }
12013   {
12014     char volgroup[] = "VG1";
12015     char physvols_0[] = "/dev/sda1";
12016     physvols_0[5] = devchar;
12017     char physvols_1[] = "/dev/sda2";
12018     physvols_1[5] = devchar;
12019     char *physvols[] = {
12020       physvols_0,
12021       physvols_1,
12022       NULL
12023     };
12024     int r;
12025     suppress_error = 0;
12026     r = guestfs_vgcreate (g, volgroup, physvols);
12027     if (r == -1)
12028       return -1;
12029   }
12030   {
12031     char volgroup[] = "VG2";
12032     char physvols_0[] = "/dev/sda3";
12033     physvols_0[5] = devchar;
12034     char *physvols[] = {
12035       physvols_0,
12036       NULL
12037     };
12038     int r;
12039     suppress_error = 0;
12040     r = guestfs_vgcreate (g, volgroup, physvols);
12041     if (r == -1)
12042       return -1;
12043   }
12044   {
12045     char **r;
12046     int i;
12047     suppress_error = 0;
12048     r = guestfs_vgs (g);
12049     if (r == NULL)
12050       return -1;
12051     if (!r[0]) {
12052       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12053       print_strings (r);
12054       return -1;
12055     }
12056     {
12057       char expected[] = "VG1";
12058       if (strcmp (r[0], expected) != 0) {
12059         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12060         return -1;
12061       }
12062     }
12063     if (!r[1]) {
12064       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12065       print_strings (r);
12066       return -1;
12067     }
12068     {
12069       char expected[] = "VG2";
12070       if (strcmp (r[1], expected) != 0) {
12071         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12072         return -1;
12073       }
12074     }
12075     if (r[2] != NULL) {
12076       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12077       print_strings (r);
12078       return -1;
12079     }
12080     for (i = 0; r[i] != NULL; ++i)
12081       free (r[i]);
12082     free (r);
12083   }
12084   return 0;
12085 }
12086
12087 static int test_pvcreate_0_skip (void)
12088 {
12089   const char *str;
12090
12091   str = getenv ("SKIP_TEST_PVCREATE_0");
12092   if (str && strcmp (str, "1") == 0) return 1;
12093   str = getenv ("SKIP_TEST_PVCREATE");
12094   if (str && strcmp (str, "1") == 0) return 1;
12095   return 0;
12096 }
12097
12098 static int test_pvcreate_0 (void)
12099 {
12100   if (test_pvcreate_0_skip ()) {
12101     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12102     return 0;
12103   }
12104
12105   /* InitNone|InitEmpty for test_pvcreate_0 */
12106   {
12107     char device[] = "/dev/sda";
12108     device[5] = devchar;
12109     int r;
12110     suppress_error = 0;
12111     r = guestfs_blockdev_setrw (g, device);
12112     if (r == -1)
12113       return -1;
12114   }
12115   {
12116     int r;
12117     suppress_error = 0;
12118     r = guestfs_umount_all (g);
12119     if (r == -1)
12120       return -1;
12121   }
12122   {
12123     int r;
12124     suppress_error = 0;
12125     r = guestfs_lvm_remove_all (g);
12126     if (r == -1)
12127       return -1;
12128   }
12129   /* TestOutputList for pvcreate (0) */
12130   {
12131     char device[] = "/dev/sda";
12132     device[5] = devchar;
12133     char lines_0[] = ",10";
12134     char lines_1[] = ",20";
12135     char lines_2[] = ",";
12136     char *lines[] = {
12137       lines_0,
12138       lines_1,
12139       lines_2,
12140       NULL
12141     };
12142     int r;
12143     suppress_error = 0;
12144     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12145     if (r == -1)
12146       return -1;
12147   }
12148   {
12149     char device[] = "/dev/sda1";
12150     device[5] = devchar;
12151     int r;
12152     suppress_error = 0;
12153     r = guestfs_pvcreate (g, device);
12154     if (r == -1)
12155       return -1;
12156   }
12157   {
12158     char device[] = "/dev/sda2";
12159     device[5] = devchar;
12160     int r;
12161     suppress_error = 0;
12162     r = guestfs_pvcreate (g, device);
12163     if (r == -1)
12164       return -1;
12165   }
12166   {
12167     char device[] = "/dev/sda3";
12168     device[5] = devchar;
12169     int r;
12170     suppress_error = 0;
12171     r = guestfs_pvcreate (g, device);
12172     if (r == -1)
12173       return -1;
12174   }
12175   {
12176     char **r;
12177     int i;
12178     suppress_error = 0;
12179     r = guestfs_pvs (g);
12180     if (r == NULL)
12181       return -1;
12182     if (!r[0]) {
12183       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12184       print_strings (r);
12185       return -1;
12186     }
12187     {
12188       char expected[] = "/dev/sda1";
12189       expected[5] = devchar;
12190       if (strcmp (r[0], expected) != 0) {
12191         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12192         return -1;
12193       }
12194     }
12195     if (!r[1]) {
12196       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12197       print_strings (r);
12198       return -1;
12199     }
12200     {
12201       char expected[] = "/dev/sda2";
12202       expected[5] = devchar;
12203       if (strcmp (r[1], expected) != 0) {
12204         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12205         return -1;
12206       }
12207     }
12208     if (!r[2]) {
12209       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12210       print_strings (r);
12211       return -1;
12212     }
12213     {
12214       char expected[] = "/dev/sda3";
12215       expected[5] = devchar;
12216       if (strcmp (r[2], expected) != 0) {
12217         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12218         return -1;
12219       }
12220     }
12221     if (r[3] != NULL) {
12222       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12223       print_strings (r);
12224       return -1;
12225     }
12226     for (i = 0; r[i] != NULL; ++i)
12227       free (r[i]);
12228     free (r);
12229   }
12230   return 0;
12231 }
12232
12233 static int test_is_dir_0_skip (void)
12234 {
12235   const char *str;
12236
12237   str = getenv ("SKIP_TEST_IS_DIR_0");
12238   if (str && strcmp (str, "1") == 0) return 1;
12239   str = getenv ("SKIP_TEST_IS_DIR");
12240   if (str && strcmp (str, "1") == 0) return 1;
12241   return 0;
12242 }
12243
12244 static int test_is_dir_0 (void)
12245 {
12246   if (test_is_dir_0_skip ()) {
12247     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12248     return 0;
12249   }
12250
12251   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12252   {
12253     char device[] = "/dev/sda";
12254     device[5] = devchar;
12255     int r;
12256     suppress_error = 0;
12257     r = guestfs_blockdev_setrw (g, device);
12258     if (r == -1)
12259       return -1;
12260   }
12261   {
12262     int r;
12263     suppress_error = 0;
12264     r = guestfs_umount_all (g);
12265     if (r == -1)
12266       return -1;
12267   }
12268   {
12269     int r;
12270     suppress_error = 0;
12271     r = guestfs_lvm_remove_all (g);
12272     if (r == -1)
12273       return -1;
12274   }
12275   {
12276     char device[] = "/dev/sda";
12277     device[5] = devchar;
12278     char lines_0[] = ",";
12279     char *lines[] = {
12280       lines_0,
12281       NULL
12282     };
12283     int r;
12284     suppress_error = 0;
12285     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12286     if (r == -1)
12287       return -1;
12288   }
12289   {
12290     char fstype[] = "ext2";
12291     char device[] = "/dev/sda1";
12292     device[5] = devchar;
12293     int r;
12294     suppress_error = 0;
12295     r = guestfs_mkfs (g, fstype, device);
12296     if (r == -1)
12297       return -1;
12298   }
12299   {
12300     char device[] = "/dev/sda1";
12301     device[5] = devchar;
12302     char mountpoint[] = "/";
12303     int r;
12304     suppress_error = 0;
12305     r = guestfs_mount (g, device, mountpoint);
12306     if (r == -1)
12307       return -1;
12308   }
12309   /* TestOutputFalse for is_dir (0) */
12310   {
12311     char path[] = "/new";
12312     int r;
12313     suppress_error = 0;
12314     r = guestfs_touch (g, path);
12315     if (r == -1)
12316       return -1;
12317   }
12318   {
12319     char path[] = "/new";
12320     int r;
12321     suppress_error = 0;
12322     r = guestfs_is_dir (g, path);
12323     if (r == -1)
12324       return -1;
12325     if (r) {
12326       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12327       return -1;
12328     }
12329   }
12330   return 0;
12331 }
12332
12333 static int test_is_dir_1_skip (void)
12334 {
12335   const char *str;
12336
12337   str = getenv ("SKIP_TEST_IS_DIR_1");
12338   if (str && strcmp (str, "1") == 0) return 1;
12339   str = getenv ("SKIP_TEST_IS_DIR");
12340   if (str && strcmp (str, "1") == 0) return 1;
12341   return 0;
12342 }
12343
12344 static int test_is_dir_1 (void)
12345 {
12346   if (test_is_dir_1_skip ()) {
12347     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12348     return 0;
12349   }
12350
12351   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12352   {
12353     char device[] = "/dev/sda";
12354     device[5] = devchar;
12355     int r;
12356     suppress_error = 0;
12357     r = guestfs_blockdev_setrw (g, device);
12358     if (r == -1)
12359       return -1;
12360   }
12361   {
12362     int r;
12363     suppress_error = 0;
12364     r = guestfs_umount_all (g);
12365     if (r == -1)
12366       return -1;
12367   }
12368   {
12369     int r;
12370     suppress_error = 0;
12371     r = guestfs_lvm_remove_all (g);
12372     if (r == -1)
12373       return -1;
12374   }
12375   {
12376     char device[] = "/dev/sda";
12377     device[5] = devchar;
12378     char lines_0[] = ",";
12379     char *lines[] = {
12380       lines_0,
12381       NULL
12382     };
12383     int r;
12384     suppress_error = 0;
12385     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12386     if (r == -1)
12387       return -1;
12388   }
12389   {
12390     char fstype[] = "ext2";
12391     char device[] = "/dev/sda1";
12392     device[5] = devchar;
12393     int r;
12394     suppress_error = 0;
12395     r = guestfs_mkfs (g, fstype, device);
12396     if (r == -1)
12397       return -1;
12398   }
12399   {
12400     char device[] = "/dev/sda1";
12401     device[5] = devchar;
12402     char mountpoint[] = "/";
12403     int r;
12404     suppress_error = 0;
12405     r = guestfs_mount (g, device, mountpoint);
12406     if (r == -1)
12407       return -1;
12408   }
12409   /* TestOutputTrue for is_dir (1) */
12410   {
12411     char path[] = "/new";
12412     int r;
12413     suppress_error = 0;
12414     r = guestfs_mkdir (g, path);
12415     if (r == -1)
12416       return -1;
12417   }
12418   {
12419     char path[] = "/new";
12420     int r;
12421     suppress_error = 0;
12422     r = guestfs_is_dir (g, path);
12423     if (r == -1)
12424       return -1;
12425     if (!r) {
12426       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12427       return -1;
12428     }
12429   }
12430   return 0;
12431 }
12432
12433 static int test_is_file_0_skip (void)
12434 {
12435   const char *str;
12436
12437   str = getenv ("SKIP_TEST_IS_FILE_0");
12438   if (str && strcmp (str, "1") == 0) return 1;
12439   str = getenv ("SKIP_TEST_IS_FILE");
12440   if (str && strcmp (str, "1") == 0) return 1;
12441   return 0;
12442 }
12443
12444 static int test_is_file_0 (void)
12445 {
12446   if (test_is_file_0_skip ()) {
12447     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12448     return 0;
12449   }
12450
12451   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12452   {
12453     char device[] = "/dev/sda";
12454     device[5] = devchar;
12455     int r;
12456     suppress_error = 0;
12457     r = guestfs_blockdev_setrw (g, device);
12458     if (r == -1)
12459       return -1;
12460   }
12461   {
12462     int r;
12463     suppress_error = 0;
12464     r = guestfs_umount_all (g);
12465     if (r == -1)
12466       return -1;
12467   }
12468   {
12469     int r;
12470     suppress_error = 0;
12471     r = guestfs_lvm_remove_all (g);
12472     if (r == -1)
12473       return -1;
12474   }
12475   {
12476     char device[] = "/dev/sda";
12477     device[5] = devchar;
12478     char lines_0[] = ",";
12479     char *lines[] = {
12480       lines_0,
12481       NULL
12482     };
12483     int r;
12484     suppress_error = 0;
12485     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12486     if (r == -1)
12487       return -1;
12488   }
12489   {
12490     char fstype[] = "ext2";
12491     char device[] = "/dev/sda1";
12492     device[5] = devchar;
12493     int r;
12494     suppress_error = 0;
12495     r = guestfs_mkfs (g, fstype, device);
12496     if (r == -1)
12497       return -1;
12498   }
12499   {
12500     char device[] = "/dev/sda1";
12501     device[5] = devchar;
12502     char mountpoint[] = "/";
12503     int r;
12504     suppress_error = 0;
12505     r = guestfs_mount (g, device, mountpoint);
12506     if (r == -1)
12507       return -1;
12508   }
12509   /* TestOutputTrue for is_file (0) */
12510   {
12511     char path[] = "/new";
12512     int r;
12513     suppress_error = 0;
12514     r = guestfs_touch (g, path);
12515     if (r == -1)
12516       return -1;
12517   }
12518   {
12519     char path[] = "/new";
12520     int r;
12521     suppress_error = 0;
12522     r = guestfs_is_file (g, path);
12523     if (r == -1)
12524       return -1;
12525     if (!r) {
12526       fprintf (stderr, "test_is_file_0: expected true, got false\n");
12527       return -1;
12528     }
12529   }
12530   return 0;
12531 }
12532
12533 static int test_is_file_1_skip (void)
12534 {
12535   const char *str;
12536
12537   str = getenv ("SKIP_TEST_IS_FILE_1");
12538   if (str && strcmp (str, "1") == 0) return 1;
12539   str = getenv ("SKIP_TEST_IS_FILE");
12540   if (str && strcmp (str, "1") == 0) return 1;
12541   return 0;
12542 }
12543
12544 static int test_is_file_1 (void)
12545 {
12546   if (test_is_file_1_skip ()) {
12547     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12548     return 0;
12549   }
12550
12551   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12552   {
12553     char device[] = "/dev/sda";
12554     device[5] = devchar;
12555     int r;
12556     suppress_error = 0;
12557     r = guestfs_blockdev_setrw (g, device);
12558     if (r == -1)
12559       return -1;
12560   }
12561   {
12562     int r;
12563     suppress_error = 0;
12564     r = guestfs_umount_all (g);
12565     if (r == -1)
12566       return -1;
12567   }
12568   {
12569     int r;
12570     suppress_error = 0;
12571     r = guestfs_lvm_remove_all (g);
12572     if (r == -1)
12573       return -1;
12574   }
12575   {
12576     char device[] = "/dev/sda";
12577     device[5] = devchar;
12578     char lines_0[] = ",";
12579     char *lines[] = {
12580       lines_0,
12581       NULL
12582     };
12583     int r;
12584     suppress_error = 0;
12585     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12586     if (r == -1)
12587       return -1;
12588   }
12589   {
12590     char fstype[] = "ext2";
12591     char device[] = "/dev/sda1";
12592     device[5] = devchar;
12593     int r;
12594     suppress_error = 0;
12595     r = guestfs_mkfs (g, fstype, device);
12596     if (r == -1)
12597       return -1;
12598   }
12599   {
12600     char device[] = "/dev/sda1";
12601     device[5] = devchar;
12602     char mountpoint[] = "/";
12603     int r;
12604     suppress_error = 0;
12605     r = guestfs_mount (g, device, mountpoint);
12606     if (r == -1)
12607       return -1;
12608   }
12609   /* TestOutputFalse for is_file (1) */
12610   {
12611     char path[] = "/new";
12612     int r;
12613     suppress_error = 0;
12614     r = guestfs_mkdir (g, path);
12615     if (r == -1)
12616       return -1;
12617   }
12618   {
12619     char path[] = "/new";
12620     int r;
12621     suppress_error = 0;
12622     r = guestfs_is_file (g, path);
12623     if (r == -1)
12624       return -1;
12625     if (r) {
12626       fprintf (stderr, "test_is_file_1: expected false, got true\n");
12627       return -1;
12628     }
12629   }
12630   return 0;
12631 }
12632
12633 static int test_exists_0_skip (void)
12634 {
12635   const char *str;
12636
12637   str = getenv ("SKIP_TEST_EXISTS_0");
12638   if (str && strcmp (str, "1") == 0) return 1;
12639   str = getenv ("SKIP_TEST_EXISTS");
12640   if (str && strcmp (str, "1") == 0) return 1;
12641   return 0;
12642 }
12643
12644 static int test_exists_0 (void)
12645 {
12646   if (test_exists_0_skip ()) {
12647     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12648     return 0;
12649   }
12650
12651   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12652   {
12653     char device[] = "/dev/sda";
12654     device[5] = devchar;
12655     int r;
12656     suppress_error = 0;
12657     r = guestfs_blockdev_setrw (g, device);
12658     if (r == -1)
12659       return -1;
12660   }
12661   {
12662     int r;
12663     suppress_error = 0;
12664     r = guestfs_umount_all (g);
12665     if (r == -1)
12666       return -1;
12667   }
12668   {
12669     int r;
12670     suppress_error = 0;
12671     r = guestfs_lvm_remove_all (g);
12672     if (r == -1)
12673       return -1;
12674   }
12675   {
12676     char device[] = "/dev/sda";
12677     device[5] = devchar;
12678     char lines_0[] = ",";
12679     char *lines[] = {
12680       lines_0,
12681       NULL
12682     };
12683     int r;
12684     suppress_error = 0;
12685     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12686     if (r == -1)
12687       return -1;
12688   }
12689   {
12690     char fstype[] = "ext2";
12691     char device[] = "/dev/sda1";
12692     device[5] = devchar;
12693     int r;
12694     suppress_error = 0;
12695     r = guestfs_mkfs (g, fstype, device);
12696     if (r == -1)
12697       return -1;
12698   }
12699   {
12700     char device[] = "/dev/sda1";
12701     device[5] = devchar;
12702     char mountpoint[] = "/";
12703     int r;
12704     suppress_error = 0;
12705     r = guestfs_mount (g, device, mountpoint);
12706     if (r == -1)
12707       return -1;
12708   }
12709   /* TestOutputTrue for exists (0) */
12710   {
12711     char path[] = "/new";
12712     int r;
12713     suppress_error = 0;
12714     r = guestfs_touch (g, path);
12715     if (r == -1)
12716       return -1;
12717   }
12718   {
12719     char path[] = "/new";
12720     int r;
12721     suppress_error = 0;
12722     r = guestfs_exists (g, path);
12723     if (r == -1)
12724       return -1;
12725     if (!r) {
12726       fprintf (stderr, "test_exists_0: expected true, got false\n");
12727       return -1;
12728     }
12729   }
12730   return 0;
12731 }
12732
12733 static int test_exists_1_skip (void)
12734 {
12735   const char *str;
12736
12737   str = getenv ("SKIP_TEST_EXISTS_1");
12738   if (str && strcmp (str, "1") == 0) return 1;
12739   str = getenv ("SKIP_TEST_EXISTS");
12740   if (str && strcmp (str, "1") == 0) return 1;
12741   return 0;
12742 }
12743
12744 static int test_exists_1 (void)
12745 {
12746   if (test_exists_1_skip ()) {
12747     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12748     return 0;
12749   }
12750
12751   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12752   {
12753     char device[] = "/dev/sda";
12754     device[5] = devchar;
12755     int r;
12756     suppress_error = 0;
12757     r = guestfs_blockdev_setrw (g, device);
12758     if (r == -1)
12759       return -1;
12760   }
12761   {
12762     int r;
12763     suppress_error = 0;
12764     r = guestfs_umount_all (g);
12765     if (r == -1)
12766       return -1;
12767   }
12768   {
12769     int r;
12770     suppress_error = 0;
12771     r = guestfs_lvm_remove_all (g);
12772     if (r == -1)
12773       return -1;
12774   }
12775   {
12776     char device[] = "/dev/sda";
12777     device[5] = devchar;
12778     char lines_0[] = ",";
12779     char *lines[] = {
12780       lines_0,
12781       NULL
12782     };
12783     int r;
12784     suppress_error = 0;
12785     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12786     if (r == -1)
12787       return -1;
12788   }
12789   {
12790     char fstype[] = "ext2";
12791     char device[] = "/dev/sda1";
12792     device[5] = devchar;
12793     int r;
12794     suppress_error = 0;
12795     r = guestfs_mkfs (g, fstype, device);
12796     if (r == -1)
12797       return -1;
12798   }
12799   {
12800     char device[] = "/dev/sda1";
12801     device[5] = devchar;
12802     char mountpoint[] = "/";
12803     int r;
12804     suppress_error = 0;
12805     r = guestfs_mount (g, device, mountpoint);
12806     if (r == -1)
12807       return -1;
12808   }
12809   /* TestOutputTrue for exists (1) */
12810   {
12811     char path[] = "/new";
12812     int r;
12813     suppress_error = 0;
12814     r = guestfs_mkdir (g, path);
12815     if (r == -1)
12816       return -1;
12817   }
12818   {
12819     char path[] = "/new";
12820     int r;
12821     suppress_error = 0;
12822     r = guestfs_exists (g, path);
12823     if (r == -1)
12824       return -1;
12825     if (!r) {
12826       fprintf (stderr, "test_exists_1: expected true, got false\n");
12827       return -1;
12828     }
12829   }
12830   return 0;
12831 }
12832
12833 static int test_mkdir_p_0_skip (void)
12834 {
12835   const char *str;
12836
12837   str = getenv ("SKIP_TEST_MKDIR_P_0");
12838   if (str && strcmp (str, "1") == 0) return 1;
12839   str = getenv ("SKIP_TEST_MKDIR_P");
12840   if (str && strcmp (str, "1") == 0) return 1;
12841   return 0;
12842 }
12843
12844 static int test_mkdir_p_0 (void)
12845 {
12846   if (test_mkdir_p_0_skip ()) {
12847     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12848     return 0;
12849   }
12850
12851   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12852   {
12853     char device[] = "/dev/sda";
12854     device[5] = devchar;
12855     int r;
12856     suppress_error = 0;
12857     r = guestfs_blockdev_setrw (g, device);
12858     if (r == -1)
12859       return -1;
12860   }
12861   {
12862     int r;
12863     suppress_error = 0;
12864     r = guestfs_umount_all (g);
12865     if (r == -1)
12866       return -1;
12867   }
12868   {
12869     int r;
12870     suppress_error = 0;
12871     r = guestfs_lvm_remove_all (g);
12872     if (r == -1)
12873       return -1;
12874   }
12875   {
12876     char device[] = "/dev/sda";
12877     device[5] = devchar;
12878     char lines_0[] = ",";
12879     char *lines[] = {
12880       lines_0,
12881       NULL
12882     };
12883     int r;
12884     suppress_error = 0;
12885     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12886     if (r == -1)
12887       return -1;
12888   }
12889   {
12890     char fstype[] = "ext2";
12891     char device[] = "/dev/sda1";
12892     device[5] = devchar;
12893     int r;
12894     suppress_error = 0;
12895     r = guestfs_mkfs (g, fstype, device);
12896     if (r == -1)
12897       return -1;
12898   }
12899   {
12900     char device[] = "/dev/sda1";
12901     device[5] = devchar;
12902     char mountpoint[] = "/";
12903     int r;
12904     suppress_error = 0;
12905     r = guestfs_mount (g, device, mountpoint);
12906     if (r == -1)
12907       return -1;
12908   }
12909   /* TestOutputTrue for mkdir_p (0) */
12910   {
12911     char path[] = "/new/foo/bar";
12912     int r;
12913     suppress_error = 0;
12914     r = guestfs_mkdir_p (g, path);
12915     if (r == -1)
12916       return -1;
12917   }
12918   {
12919     char path[] = "/new/foo/bar";
12920     int r;
12921     suppress_error = 0;
12922     r = guestfs_is_dir (g, path);
12923     if (r == -1)
12924       return -1;
12925     if (!r) {
12926       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12927       return -1;
12928     }
12929   }
12930   return 0;
12931 }
12932
12933 static int test_mkdir_p_1_skip (void)
12934 {
12935   const char *str;
12936
12937   str = getenv ("SKIP_TEST_MKDIR_P_1");
12938   if (str && strcmp (str, "1") == 0) return 1;
12939   str = getenv ("SKIP_TEST_MKDIR_P");
12940   if (str && strcmp (str, "1") == 0) return 1;
12941   return 0;
12942 }
12943
12944 static int test_mkdir_p_1 (void)
12945 {
12946   if (test_mkdir_p_1_skip ()) {
12947     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12948     return 0;
12949   }
12950
12951   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12952   {
12953     char device[] = "/dev/sda";
12954     device[5] = devchar;
12955     int r;
12956     suppress_error = 0;
12957     r = guestfs_blockdev_setrw (g, device);
12958     if (r == -1)
12959       return -1;
12960   }
12961   {
12962     int r;
12963     suppress_error = 0;
12964     r = guestfs_umount_all (g);
12965     if (r == -1)
12966       return -1;
12967   }
12968   {
12969     int r;
12970     suppress_error = 0;
12971     r = guestfs_lvm_remove_all (g);
12972     if (r == -1)
12973       return -1;
12974   }
12975   {
12976     char device[] = "/dev/sda";
12977     device[5] = devchar;
12978     char lines_0[] = ",";
12979     char *lines[] = {
12980       lines_0,
12981       NULL
12982     };
12983     int r;
12984     suppress_error = 0;
12985     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12986     if (r == -1)
12987       return -1;
12988   }
12989   {
12990     char fstype[] = "ext2";
12991     char device[] = "/dev/sda1";
12992     device[5] = devchar;
12993     int r;
12994     suppress_error = 0;
12995     r = guestfs_mkfs (g, fstype, device);
12996     if (r == -1)
12997       return -1;
12998   }
12999   {
13000     char device[] = "/dev/sda1";
13001     device[5] = devchar;
13002     char mountpoint[] = "/";
13003     int r;
13004     suppress_error = 0;
13005     r = guestfs_mount (g, device, mountpoint);
13006     if (r == -1)
13007       return -1;
13008   }
13009   /* TestOutputTrue for mkdir_p (1) */
13010   {
13011     char path[] = "/new/foo/bar";
13012     int r;
13013     suppress_error = 0;
13014     r = guestfs_mkdir_p (g, path);
13015     if (r == -1)
13016       return -1;
13017   }
13018   {
13019     char path[] = "/new/foo";
13020     int r;
13021     suppress_error = 0;
13022     r = guestfs_is_dir (g, path);
13023     if (r == -1)
13024       return -1;
13025     if (!r) {
13026       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
13027       return -1;
13028     }
13029   }
13030   return 0;
13031 }
13032
13033 static int test_mkdir_p_2_skip (void)
13034 {
13035   const char *str;
13036
13037   str = getenv ("SKIP_TEST_MKDIR_P_2");
13038   if (str && strcmp (str, "1") == 0) return 1;
13039   str = getenv ("SKIP_TEST_MKDIR_P");
13040   if (str && strcmp (str, "1") == 0) return 1;
13041   return 0;
13042 }
13043
13044 static int test_mkdir_p_2 (void)
13045 {
13046   if (test_mkdir_p_2_skip ()) {
13047     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
13048     return 0;
13049   }
13050
13051   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
13052   {
13053     char device[] = "/dev/sda";
13054     device[5] = devchar;
13055     int r;
13056     suppress_error = 0;
13057     r = guestfs_blockdev_setrw (g, device);
13058     if (r == -1)
13059       return -1;
13060   }
13061   {
13062     int r;
13063     suppress_error = 0;
13064     r = guestfs_umount_all (g);
13065     if (r == -1)
13066       return -1;
13067   }
13068   {
13069     int r;
13070     suppress_error = 0;
13071     r = guestfs_lvm_remove_all (g);
13072     if (r == -1)
13073       return -1;
13074   }
13075   {
13076     char device[] = "/dev/sda";
13077     device[5] = devchar;
13078     char lines_0[] = ",";
13079     char *lines[] = {
13080       lines_0,
13081       NULL
13082     };
13083     int r;
13084     suppress_error = 0;
13085     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13086     if (r == -1)
13087       return -1;
13088   }
13089   {
13090     char fstype[] = "ext2";
13091     char device[] = "/dev/sda1";
13092     device[5] = devchar;
13093     int r;
13094     suppress_error = 0;
13095     r = guestfs_mkfs (g, fstype, device);
13096     if (r == -1)
13097       return -1;
13098   }
13099   {
13100     char device[] = "/dev/sda1";
13101     device[5] = devchar;
13102     char mountpoint[] = "/";
13103     int r;
13104     suppress_error = 0;
13105     r = guestfs_mount (g, device, mountpoint);
13106     if (r == -1)
13107       return -1;
13108   }
13109   /* TestOutputTrue for mkdir_p (2) */
13110   {
13111     char path[] = "/new/foo/bar";
13112     int r;
13113     suppress_error = 0;
13114     r = guestfs_mkdir_p (g, path);
13115     if (r == -1)
13116       return -1;
13117   }
13118   {
13119     char path[] = "/new";
13120     int r;
13121     suppress_error = 0;
13122     r = guestfs_is_dir (g, path);
13123     if (r == -1)
13124       return -1;
13125     if (!r) {
13126       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13127       return -1;
13128     }
13129   }
13130   return 0;
13131 }
13132
13133 static int test_mkdir_p_3_skip (void)
13134 {
13135   const char *str;
13136
13137   str = getenv ("SKIP_TEST_MKDIR_P_3");
13138   if (str && strcmp (str, "1") == 0) return 1;
13139   str = getenv ("SKIP_TEST_MKDIR_P");
13140   if (str && strcmp (str, "1") == 0) return 1;
13141   return 0;
13142 }
13143
13144 static int test_mkdir_p_3 (void)
13145 {
13146   if (test_mkdir_p_3_skip ()) {
13147     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13148     return 0;
13149   }
13150
13151   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13152   {
13153     char device[] = "/dev/sda";
13154     device[5] = devchar;
13155     int r;
13156     suppress_error = 0;
13157     r = guestfs_blockdev_setrw (g, device);
13158     if (r == -1)
13159       return -1;
13160   }
13161   {
13162     int r;
13163     suppress_error = 0;
13164     r = guestfs_umount_all (g);
13165     if (r == -1)
13166       return -1;
13167   }
13168   {
13169     int r;
13170     suppress_error = 0;
13171     r = guestfs_lvm_remove_all (g);
13172     if (r == -1)
13173       return -1;
13174   }
13175   {
13176     char device[] = "/dev/sda";
13177     device[5] = devchar;
13178     char lines_0[] = ",";
13179     char *lines[] = {
13180       lines_0,
13181       NULL
13182     };
13183     int r;
13184     suppress_error = 0;
13185     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13186     if (r == -1)
13187       return -1;
13188   }
13189   {
13190     char fstype[] = "ext2";
13191     char device[] = "/dev/sda1";
13192     device[5] = devchar;
13193     int r;
13194     suppress_error = 0;
13195     r = guestfs_mkfs (g, fstype, device);
13196     if (r == -1)
13197       return -1;
13198   }
13199   {
13200     char device[] = "/dev/sda1";
13201     device[5] = devchar;
13202     char mountpoint[] = "/";
13203     int r;
13204     suppress_error = 0;
13205     r = guestfs_mount (g, device, mountpoint);
13206     if (r == -1)
13207       return -1;
13208   }
13209   /* TestRun for mkdir_p (3) */
13210   {
13211     char path[] = "/new";
13212     int r;
13213     suppress_error = 0;
13214     r = guestfs_mkdir (g, path);
13215     if (r == -1)
13216       return -1;
13217   }
13218   {
13219     char path[] = "/new";
13220     int r;
13221     suppress_error = 0;
13222     r = guestfs_mkdir_p (g, path);
13223     if (r == -1)
13224       return -1;
13225   }
13226   return 0;
13227 }
13228
13229 static int test_mkdir_p_4_skip (void)
13230 {
13231   const char *str;
13232
13233   str = getenv ("SKIP_TEST_MKDIR_P_4");
13234   if (str && strcmp (str, "1") == 0) return 1;
13235   str = getenv ("SKIP_TEST_MKDIR_P");
13236   if (str && strcmp (str, "1") == 0) return 1;
13237   return 0;
13238 }
13239
13240 static int test_mkdir_p_4 (void)
13241 {
13242   if (test_mkdir_p_4_skip ()) {
13243     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13244     return 0;
13245   }
13246
13247   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13248   {
13249     char device[] = "/dev/sda";
13250     device[5] = devchar;
13251     int r;
13252     suppress_error = 0;
13253     r = guestfs_blockdev_setrw (g, device);
13254     if (r == -1)
13255       return -1;
13256   }
13257   {
13258     int r;
13259     suppress_error = 0;
13260     r = guestfs_umount_all (g);
13261     if (r == -1)
13262       return -1;
13263   }
13264   {
13265     int r;
13266     suppress_error = 0;
13267     r = guestfs_lvm_remove_all (g);
13268     if (r == -1)
13269       return -1;
13270   }
13271   {
13272     char device[] = "/dev/sda";
13273     device[5] = devchar;
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     device[5] = devchar;
13289     int r;
13290     suppress_error = 0;
13291     r = guestfs_mkfs (g, fstype, device);
13292     if (r == -1)
13293       return -1;
13294   }
13295   {
13296     char device[] = "/dev/sda1";
13297     device[5] = devchar;
13298     char mountpoint[] = "/";
13299     int r;
13300     suppress_error = 0;
13301     r = guestfs_mount (g, device, mountpoint);
13302     if (r == -1)
13303       return -1;
13304   }
13305   /* TestLastFail for mkdir_p (4) */
13306   {
13307     char path[] = "/new";
13308     int r;
13309     suppress_error = 0;
13310     r = guestfs_touch (g, path);
13311     if (r == -1)
13312       return -1;
13313   }
13314   {
13315     char path[] = "/new";
13316     int r;
13317     suppress_error = 1;
13318     r = guestfs_mkdir_p (g, path);
13319     if (r != -1)
13320       return -1;
13321   }
13322   return 0;
13323 }
13324
13325 static int test_mkdir_0_skip (void)
13326 {
13327   const char *str;
13328
13329   str = getenv ("SKIP_TEST_MKDIR_0");
13330   if (str && strcmp (str, "1") == 0) return 1;
13331   str = getenv ("SKIP_TEST_MKDIR");
13332   if (str && strcmp (str, "1") == 0) return 1;
13333   return 0;
13334 }
13335
13336 static int test_mkdir_0 (void)
13337 {
13338   if (test_mkdir_0_skip ()) {
13339     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13340     return 0;
13341   }
13342
13343   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13344   {
13345     char device[] = "/dev/sda";
13346     device[5] = devchar;
13347     int r;
13348     suppress_error = 0;
13349     r = guestfs_blockdev_setrw (g, device);
13350     if (r == -1)
13351       return -1;
13352   }
13353   {
13354     int r;
13355     suppress_error = 0;
13356     r = guestfs_umount_all (g);
13357     if (r == -1)
13358       return -1;
13359   }
13360   {
13361     int r;
13362     suppress_error = 0;
13363     r = guestfs_lvm_remove_all (g);
13364     if (r == -1)
13365       return -1;
13366   }
13367   {
13368     char device[] = "/dev/sda";
13369     device[5] = devchar;
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     device[5] = devchar;
13385     int r;
13386     suppress_error = 0;
13387     r = guestfs_mkfs (g, fstype, device);
13388     if (r == -1)
13389       return -1;
13390   }
13391   {
13392     char device[] = "/dev/sda1";
13393     device[5] = devchar;
13394     char mountpoint[] = "/";
13395     int r;
13396     suppress_error = 0;
13397     r = guestfs_mount (g, device, mountpoint);
13398     if (r == -1)
13399       return -1;
13400   }
13401   /* TestOutputTrue for mkdir (0) */
13402   {
13403     char path[] = "/new";
13404     int r;
13405     suppress_error = 0;
13406     r = guestfs_mkdir (g, path);
13407     if (r == -1)
13408       return -1;
13409   }
13410   {
13411     char path[] = "/new";
13412     int r;
13413     suppress_error = 0;
13414     r = guestfs_is_dir (g, path);
13415     if (r == -1)
13416       return -1;
13417     if (!r) {
13418       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13419       return -1;
13420     }
13421   }
13422   return 0;
13423 }
13424
13425 static int test_mkdir_1_skip (void)
13426 {
13427   const char *str;
13428
13429   str = getenv ("SKIP_TEST_MKDIR_1");
13430   if (str && strcmp (str, "1") == 0) return 1;
13431   str = getenv ("SKIP_TEST_MKDIR");
13432   if (str && strcmp (str, "1") == 0) return 1;
13433   return 0;
13434 }
13435
13436 static int test_mkdir_1 (void)
13437 {
13438   if (test_mkdir_1_skip ()) {
13439     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13440     return 0;
13441   }
13442
13443   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13444   {
13445     char device[] = "/dev/sda";
13446     device[5] = devchar;
13447     int r;
13448     suppress_error = 0;
13449     r = guestfs_blockdev_setrw (g, device);
13450     if (r == -1)
13451       return -1;
13452   }
13453   {
13454     int r;
13455     suppress_error = 0;
13456     r = guestfs_umount_all (g);
13457     if (r == -1)
13458       return -1;
13459   }
13460   {
13461     int r;
13462     suppress_error = 0;
13463     r = guestfs_lvm_remove_all (g);
13464     if (r == -1)
13465       return -1;
13466   }
13467   {
13468     char device[] = "/dev/sda";
13469     device[5] = devchar;
13470     char lines_0[] = ",";
13471     char *lines[] = {
13472       lines_0,
13473       NULL
13474     };
13475     int r;
13476     suppress_error = 0;
13477     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13478     if (r == -1)
13479       return -1;
13480   }
13481   {
13482     char fstype[] = "ext2";
13483     char device[] = "/dev/sda1";
13484     device[5] = devchar;
13485     int r;
13486     suppress_error = 0;
13487     r = guestfs_mkfs (g, fstype, device);
13488     if (r == -1)
13489       return -1;
13490   }
13491   {
13492     char device[] = "/dev/sda1";
13493     device[5] = devchar;
13494     char mountpoint[] = "/";
13495     int r;
13496     suppress_error = 0;
13497     r = guestfs_mount (g, device, mountpoint);
13498     if (r == -1)
13499       return -1;
13500   }
13501   /* TestLastFail for mkdir (1) */
13502   {
13503     char path[] = "/new/foo/bar";
13504     int r;
13505     suppress_error = 1;
13506     r = guestfs_mkdir (g, path);
13507     if (r != -1)
13508       return -1;
13509   }
13510   return 0;
13511 }
13512
13513 static int test_rm_rf_0_skip (void)
13514 {
13515   const char *str;
13516
13517   str = getenv ("SKIP_TEST_RM_RF_0");
13518   if (str && strcmp (str, "1") == 0) return 1;
13519   str = getenv ("SKIP_TEST_RM_RF");
13520   if (str && strcmp (str, "1") == 0) return 1;
13521   return 0;
13522 }
13523
13524 static int test_rm_rf_0 (void)
13525 {
13526   if (test_rm_rf_0_skip ()) {
13527     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13528     return 0;
13529   }
13530
13531   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13532   {
13533     char device[] = "/dev/sda";
13534     device[5] = devchar;
13535     int r;
13536     suppress_error = 0;
13537     r = guestfs_blockdev_setrw (g, device);
13538     if (r == -1)
13539       return -1;
13540   }
13541   {
13542     int r;
13543     suppress_error = 0;
13544     r = guestfs_umount_all (g);
13545     if (r == -1)
13546       return -1;
13547   }
13548   {
13549     int r;
13550     suppress_error = 0;
13551     r = guestfs_lvm_remove_all (g);
13552     if (r == -1)
13553       return -1;
13554   }
13555   {
13556     char device[] = "/dev/sda";
13557     device[5] = devchar;
13558     char lines_0[] = ",";
13559     char *lines[] = {
13560       lines_0,
13561       NULL
13562     };
13563     int r;
13564     suppress_error = 0;
13565     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13566     if (r == -1)
13567       return -1;
13568   }
13569   {
13570     char fstype[] = "ext2";
13571     char device[] = "/dev/sda1";
13572     device[5] = devchar;
13573     int r;
13574     suppress_error = 0;
13575     r = guestfs_mkfs (g, fstype, device);
13576     if (r == -1)
13577       return -1;
13578   }
13579   {
13580     char device[] = "/dev/sda1";
13581     device[5] = devchar;
13582     char mountpoint[] = "/";
13583     int r;
13584     suppress_error = 0;
13585     r = guestfs_mount (g, device, mountpoint);
13586     if (r == -1)
13587       return -1;
13588   }
13589   /* TestOutputFalse for rm_rf (0) */
13590   {
13591     char path[] = "/new";
13592     int r;
13593     suppress_error = 0;
13594     r = guestfs_mkdir (g, path);
13595     if (r == -1)
13596       return -1;
13597   }
13598   {
13599     char path[] = "/new/foo";
13600     int r;
13601     suppress_error = 0;
13602     r = guestfs_mkdir (g, path);
13603     if (r == -1)
13604       return -1;
13605   }
13606   {
13607     char path[] = "/new/foo/bar";
13608     int r;
13609     suppress_error = 0;
13610     r = guestfs_touch (g, path);
13611     if (r == -1)
13612       return -1;
13613   }
13614   {
13615     char path[] = "/new";
13616     int r;
13617     suppress_error = 0;
13618     r = guestfs_rm_rf (g, path);
13619     if (r == -1)
13620       return -1;
13621   }
13622   {
13623     char path[] = "/new";
13624     int r;
13625     suppress_error = 0;
13626     r = guestfs_exists (g, path);
13627     if (r == -1)
13628       return -1;
13629     if (r) {
13630       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13631       return -1;
13632     }
13633   }
13634   return 0;
13635 }
13636
13637 static int test_rmdir_0_skip (void)
13638 {
13639   const char *str;
13640
13641   str = getenv ("SKIP_TEST_RMDIR_0");
13642   if (str && strcmp (str, "1") == 0) return 1;
13643   str = getenv ("SKIP_TEST_RMDIR");
13644   if (str && strcmp (str, "1") == 0) return 1;
13645   return 0;
13646 }
13647
13648 static int test_rmdir_0 (void)
13649 {
13650   if (test_rmdir_0_skip ()) {
13651     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13652     return 0;
13653   }
13654
13655   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13656   {
13657     char device[] = "/dev/sda";
13658     device[5] = devchar;
13659     int r;
13660     suppress_error = 0;
13661     r = guestfs_blockdev_setrw (g, device);
13662     if (r == -1)
13663       return -1;
13664   }
13665   {
13666     int r;
13667     suppress_error = 0;
13668     r = guestfs_umount_all (g);
13669     if (r == -1)
13670       return -1;
13671   }
13672   {
13673     int r;
13674     suppress_error = 0;
13675     r = guestfs_lvm_remove_all (g);
13676     if (r == -1)
13677       return -1;
13678   }
13679   {
13680     char device[] = "/dev/sda";
13681     device[5] = devchar;
13682     char lines_0[] = ",";
13683     char *lines[] = {
13684       lines_0,
13685       NULL
13686     };
13687     int r;
13688     suppress_error = 0;
13689     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13690     if (r == -1)
13691       return -1;
13692   }
13693   {
13694     char fstype[] = "ext2";
13695     char device[] = "/dev/sda1";
13696     device[5] = devchar;
13697     int r;
13698     suppress_error = 0;
13699     r = guestfs_mkfs (g, fstype, device);
13700     if (r == -1)
13701       return -1;
13702   }
13703   {
13704     char device[] = "/dev/sda1";
13705     device[5] = devchar;
13706     char mountpoint[] = "/";
13707     int r;
13708     suppress_error = 0;
13709     r = guestfs_mount (g, device, mountpoint);
13710     if (r == -1)
13711       return -1;
13712   }
13713   /* TestRun for rmdir (0) */
13714   {
13715     char path[] = "/new";
13716     int r;
13717     suppress_error = 0;
13718     r = guestfs_mkdir (g, path);
13719     if (r == -1)
13720       return -1;
13721   }
13722   {
13723     char path[] = "/new";
13724     int r;
13725     suppress_error = 0;
13726     r = guestfs_rmdir (g, path);
13727     if (r == -1)
13728       return -1;
13729   }
13730   return 0;
13731 }
13732
13733 static int test_rmdir_1_skip (void)
13734 {
13735   const char *str;
13736
13737   str = getenv ("SKIP_TEST_RMDIR_1");
13738   if (str && strcmp (str, "1") == 0) return 1;
13739   str = getenv ("SKIP_TEST_RMDIR");
13740   if (str && strcmp (str, "1") == 0) return 1;
13741   return 0;
13742 }
13743
13744 static int test_rmdir_1 (void)
13745 {
13746   if (test_rmdir_1_skip ()) {
13747     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13748     return 0;
13749   }
13750
13751   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13752   {
13753     char device[] = "/dev/sda";
13754     device[5] = devchar;
13755     int r;
13756     suppress_error = 0;
13757     r = guestfs_blockdev_setrw (g, device);
13758     if (r == -1)
13759       return -1;
13760   }
13761   {
13762     int r;
13763     suppress_error = 0;
13764     r = guestfs_umount_all (g);
13765     if (r == -1)
13766       return -1;
13767   }
13768   {
13769     int r;
13770     suppress_error = 0;
13771     r = guestfs_lvm_remove_all (g);
13772     if (r == -1)
13773       return -1;
13774   }
13775   {
13776     char device[] = "/dev/sda";
13777     device[5] = devchar;
13778     char lines_0[] = ",";
13779     char *lines[] = {
13780       lines_0,
13781       NULL
13782     };
13783     int r;
13784     suppress_error = 0;
13785     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13786     if (r == -1)
13787       return -1;
13788   }
13789   {
13790     char fstype[] = "ext2";
13791     char device[] = "/dev/sda1";
13792     device[5] = devchar;
13793     int r;
13794     suppress_error = 0;
13795     r = guestfs_mkfs (g, fstype, device);
13796     if (r == -1)
13797       return -1;
13798   }
13799   {
13800     char device[] = "/dev/sda1";
13801     device[5] = devchar;
13802     char mountpoint[] = "/";
13803     int r;
13804     suppress_error = 0;
13805     r = guestfs_mount (g, device, mountpoint);
13806     if (r == -1)
13807       return -1;
13808   }
13809   /* TestLastFail for rmdir (1) */
13810   {
13811     char path[] = "/new";
13812     int r;
13813     suppress_error = 1;
13814     r = guestfs_rmdir (g, path);
13815     if (r != -1)
13816       return -1;
13817   }
13818   return 0;
13819 }
13820
13821 static int test_rmdir_2_skip (void)
13822 {
13823   const char *str;
13824
13825   str = getenv ("SKIP_TEST_RMDIR_2");
13826   if (str && strcmp (str, "1") == 0) return 1;
13827   str = getenv ("SKIP_TEST_RMDIR");
13828   if (str && strcmp (str, "1") == 0) return 1;
13829   return 0;
13830 }
13831
13832 static int test_rmdir_2 (void)
13833 {
13834   if (test_rmdir_2_skip ()) {
13835     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13836     return 0;
13837   }
13838
13839   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13840   {
13841     char device[] = "/dev/sda";
13842     device[5] = devchar;
13843     int r;
13844     suppress_error = 0;
13845     r = guestfs_blockdev_setrw (g, device);
13846     if (r == -1)
13847       return -1;
13848   }
13849   {
13850     int r;
13851     suppress_error = 0;
13852     r = guestfs_umount_all (g);
13853     if (r == -1)
13854       return -1;
13855   }
13856   {
13857     int r;
13858     suppress_error = 0;
13859     r = guestfs_lvm_remove_all (g);
13860     if (r == -1)
13861       return -1;
13862   }
13863   {
13864     char device[] = "/dev/sda";
13865     device[5] = devchar;
13866     char lines_0[] = ",";
13867     char *lines[] = {
13868       lines_0,
13869       NULL
13870     };
13871     int r;
13872     suppress_error = 0;
13873     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13874     if (r == -1)
13875       return -1;
13876   }
13877   {
13878     char fstype[] = "ext2";
13879     char device[] = "/dev/sda1";
13880     device[5] = devchar;
13881     int r;
13882     suppress_error = 0;
13883     r = guestfs_mkfs (g, fstype, device);
13884     if (r == -1)
13885       return -1;
13886   }
13887   {
13888     char device[] = "/dev/sda1";
13889     device[5] = devchar;
13890     char mountpoint[] = "/";
13891     int r;
13892     suppress_error = 0;
13893     r = guestfs_mount (g, device, mountpoint);
13894     if (r == -1)
13895       return -1;
13896   }
13897   /* TestLastFail for rmdir (2) */
13898   {
13899     char path[] = "/new";
13900     int r;
13901     suppress_error = 0;
13902     r = guestfs_touch (g, path);
13903     if (r == -1)
13904       return -1;
13905   }
13906   {
13907     char path[] = "/new";
13908     int r;
13909     suppress_error = 1;
13910     r = guestfs_rmdir (g, path);
13911     if (r != -1)
13912       return -1;
13913   }
13914   return 0;
13915 }
13916
13917 static int test_rm_0_skip (void)
13918 {
13919   const char *str;
13920
13921   str = getenv ("SKIP_TEST_RM_0");
13922   if (str && strcmp (str, "1") == 0) return 1;
13923   str = getenv ("SKIP_TEST_RM");
13924   if (str && strcmp (str, "1") == 0) return 1;
13925   return 0;
13926 }
13927
13928 static int test_rm_0 (void)
13929 {
13930   if (test_rm_0_skip ()) {
13931     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13932     return 0;
13933   }
13934
13935   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13936   {
13937     char device[] = "/dev/sda";
13938     device[5] = devchar;
13939     int r;
13940     suppress_error = 0;
13941     r = guestfs_blockdev_setrw (g, device);
13942     if (r == -1)
13943       return -1;
13944   }
13945   {
13946     int r;
13947     suppress_error = 0;
13948     r = guestfs_umount_all (g);
13949     if (r == -1)
13950       return -1;
13951   }
13952   {
13953     int r;
13954     suppress_error = 0;
13955     r = guestfs_lvm_remove_all (g);
13956     if (r == -1)
13957       return -1;
13958   }
13959   {
13960     char device[] = "/dev/sda";
13961     device[5] = devchar;
13962     char lines_0[] = ",";
13963     char *lines[] = {
13964       lines_0,
13965       NULL
13966     };
13967     int r;
13968     suppress_error = 0;
13969     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13970     if (r == -1)
13971       return -1;
13972   }
13973   {
13974     char fstype[] = "ext2";
13975     char device[] = "/dev/sda1";
13976     device[5] = devchar;
13977     int r;
13978     suppress_error = 0;
13979     r = guestfs_mkfs (g, fstype, device);
13980     if (r == -1)
13981       return -1;
13982   }
13983   {
13984     char device[] = "/dev/sda1";
13985     device[5] = devchar;
13986     char mountpoint[] = "/";
13987     int r;
13988     suppress_error = 0;
13989     r = guestfs_mount (g, device, mountpoint);
13990     if (r == -1)
13991       return -1;
13992   }
13993   /* TestRun for rm (0) */
13994   {
13995     char path[] = "/new";
13996     int r;
13997     suppress_error = 0;
13998     r = guestfs_touch (g, path);
13999     if (r == -1)
14000       return -1;
14001   }
14002   {
14003     char path[] = "/new";
14004     int r;
14005     suppress_error = 0;
14006     r = guestfs_rm (g, path);
14007     if (r == -1)
14008       return -1;
14009   }
14010   return 0;
14011 }
14012
14013 static int test_rm_1_skip (void)
14014 {
14015   const char *str;
14016
14017   str = getenv ("SKIP_TEST_RM_1");
14018   if (str && strcmp (str, "1") == 0) return 1;
14019   str = getenv ("SKIP_TEST_RM");
14020   if (str && strcmp (str, "1") == 0) return 1;
14021   return 0;
14022 }
14023
14024 static int test_rm_1 (void)
14025 {
14026   if (test_rm_1_skip ()) {
14027     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
14028     return 0;
14029   }
14030
14031   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14032   {
14033     char device[] = "/dev/sda";
14034     device[5] = devchar;
14035     int r;
14036     suppress_error = 0;
14037     r = guestfs_blockdev_setrw (g, device);
14038     if (r == -1)
14039       return -1;
14040   }
14041   {
14042     int r;
14043     suppress_error = 0;
14044     r = guestfs_umount_all (g);
14045     if (r == -1)
14046       return -1;
14047   }
14048   {
14049     int r;
14050     suppress_error = 0;
14051     r = guestfs_lvm_remove_all (g);
14052     if (r == -1)
14053       return -1;
14054   }
14055   {
14056     char device[] = "/dev/sda";
14057     device[5] = devchar;
14058     char lines_0[] = ",";
14059     char *lines[] = {
14060       lines_0,
14061       NULL
14062     };
14063     int r;
14064     suppress_error = 0;
14065     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14066     if (r == -1)
14067       return -1;
14068   }
14069   {
14070     char fstype[] = "ext2";
14071     char device[] = "/dev/sda1";
14072     device[5] = devchar;
14073     int r;
14074     suppress_error = 0;
14075     r = guestfs_mkfs (g, fstype, device);
14076     if (r == -1)
14077       return -1;
14078   }
14079   {
14080     char device[] = "/dev/sda1";
14081     device[5] = devchar;
14082     char mountpoint[] = "/";
14083     int r;
14084     suppress_error = 0;
14085     r = guestfs_mount (g, device, mountpoint);
14086     if (r == -1)
14087       return -1;
14088   }
14089   /* TestLastFail for rm (1) */
14090   {
14091     char path[] = "/new";
14092     int r;
14093     suppress_error = 1;
14094     r = guestfs_rm (g, path);
14095     if (r != -1)
14096       return -1;
14097   }
14098   return 0;
14099 }
14100
14101 static int test_rm_2_skip (void)
14102 {
14103   const char *str;
14104
14105   str = getenv ("SKIP_TEST_RM_2");
14106   if (str && strcmp (str, "1") == 0) return 1;
14107   str = getenv ("SKIP_TEST_RM");
14108   if (str && strcmp (str, "1") == 0) return 1;
14109   return 0;
14110 }
14111
14112 static int test_rm_2 (void)
14113 {
14114   if (test_rm_2_skip ()) {
14115     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
14116     return 0;
14117   }
14118
14119   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
14120   {
14121     char device[] = "/dev/sda";
14122     device[5] = devchar;
14123     int r;
14124     suppress_error = 0;
14125     r = guestfs_blockdev_setrw (g, device);
14126     if (r == -1)
14127       return -1;
14128   }
14129   {
14130     int r;
14131     suppress_error = 0;
14132     r = guestfs_umount_all (g);
14133     if (r == -1)
14134       return -1;
14135   }
14136   {
14137     int r;
14138     suppress_error = 0;
14139     r = guestfs_lvm_remove_all (g);
14140     if (r == -1)
14141       return -1;
14142   }
14143   {
14144     char device[] = "/dev/sda";
14145     device[5] = devchar;
14146     char lines_0[] = ",";
14147     char *lines[] = {
14148       lines_0,
14149       NULL
14150     };
14151     int r;
14152     suppress_error = 0;
14153     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14154     if (r == -1)
14155       return -1;
14156   }
14157   {
14158     char fstype[] = "ext2";
14159     char device[] = "/dev/sda1";
14160     device[5] = devchar;
14161     int r;
14162     suppress_error = 0;
14163     r = guestfs_mkfs (g, fstype, device);
14164     if (r == -1)
14165       return -1;
14166   }
14167   {
14168     char device[] = "/dev/sda1";
14169     device[5] = devchar;
14170     char mountpoint[] = "/";
14171     int r;
14172     suppress_error = 0;
14173     r = guestfs_mount (g, device, mountpoint);
14174     if (r == -1)
14175       return -1;
14176   }
14177   /* TestLastFail for rm (2) */
14178   {
14179     char path[] = "/new";
14180     int r;
14181     suppress_error = 0;
14182     r = guestfs_mkdir (g, path);
14183     if (r == -1)
14184       return -1;
14185   }
14186   {
14187     char path[] = "/new";
14188     int r;
14189     suppress_error = 1;
14190     r = guestfs_rm (g, path);
14191     if (r != -1)
14192       return -1;
14193   }
14194   return 0;
14195 }
14196
14197 static int test_read_lines_0_skip (void)
14198 {
14199   const char *str;
14200
14201   str = getenv ("SKIP_TEST_READ_LINES_0");
14202   if (str && strcmp (str, "1") == 0) return 1;
14203   str = getenv ("SKIP_TEST_READ_LINES");
14204   if (str && strcmp (str, "1") == 0) return 1;
14205   return 0;
14206 }
14207
14208 static int test_read_lines_0 (void)
14209 {
14210   if (test_read_lines_0_skip ()) {
14211     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14212     return 0;
14213   }
14214
14215   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14216   {
14217     char device[] = "/dev/sda";
14218     device[5] = devchar;
14219     int r;
14220     suppress_error = 0;
14221     r = guestfs_blockdev_setrw (g, device);
14222     if (r == -1)
14223       return -1;
14224   }
14225   {
14226     int r;
14227     suppress_error = 0;
14228     r = guestfs_umount_all (g);
14229     if (r == -1)
14230       return -1;
14231   }
14232   {
14233     int r;
14234     suppress_error = 0;
14235     r = guestfs_lvm_remove_all (g);
14236     if (r == -1)
14237       return -1;
14238   }
14239   {
14240     char device[] = "/dev/sda";
14241     device[5] = devchar;
14242     char lines_0[] = ",";
14243     char *lines[] = {
14244       lines_0,
14245       NULL
14246     };
14247     int r;
14248     suppress_error = 0;
14249     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14250     if (r == -1)
14251       return -1;
14252   }
14253   {
14254     char fstype[] = "ext2";
14255     char device[] = "/dev/sda1";
14256     device[5] = devchar;
14257     int r;
14258     suppress_error = 0;
14259     r = guestfs_mkfs (g, fstype, device);
14260     if (r == -1)
14261       return -1;
14262   }
14263   {
14264     char device[] = "/dev/sda1";
14265     device[5] = devchar;
14266     char mountpoint[] = "/";
14267     int r;
14268     suppress_error = 0;
14269     r = guestfs_mount (g, device, mountpoint);
14270     if (r == -1)
14271       return -1;
14272   }
14273   /* TestOutputList for read_lines (0) */
14274   {
14275     char path[] = "/new";
14276     char content[] = "line1\r\nline2\nline3";
14277     int r;
14278     suppress_error = 0;
14279     r = guestfs_write_file (g, path, content, 0);
14280     if (r == -1)
14281       return -1;
14282   }
14283   {
14284     char path[] = "/new";
14285     char **r;
14286     int i;
14287     suppress_error = 0;
14288     r = guestfs_read_lines (g, path);
14289     if (r == NULL)
14290       return -1;
14291     if (!r[0]) {
14292       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14293       print_strings (r);
14294       return -1;
14295     }
14296     {
14297       char expected[] = "line1";
14298       if (strcmp (r[0], expected) != 0) {
14299         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14300         return -1;
14301       }
14302     }
14303     if (!r[1]) {
14304       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14305       print_strings (r);
14306       return -1;
14307     }
14308     {
14309       char expected[] = "line2";
14310       if (strcmp (r[1], expected) != 0) {
14311         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14312         return -1;
14313       }
14314     }
14315     if (!r[2]) {
14316       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14317       print_strings (r);
14318       return -1;
14319     }
14320     {
14321       char expected[] = "line3";
14322       if (strcmp (r[2], expected) != 0) {
14323         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14324         return -1;
14325       }
14326     }
14327     if (r[3] != NULL) {
14328       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14329       print_strings (r);
14330       return -1;
14331     }
14332     for (i = 0; r[i] != NULL; ++i)
14333       free (r[i]);
14334     free (r);
14335   }
14336   return 0;
14337 }
14338
14339 static int test_read_lines_1_skip (void)
14340 {
14341   const char *str;
14342
14343   str = getenv ("SKIP_TEST_READ_LINES_1");
14344   if (str && strcmp (str, "1") == 0) return 1;
14345   str = getenv ("SKIP_TEST_READ_LINES");
14346   if (str && strcmp (str, "1") == 0) return 1;
14347   return 0;
14348 }
14349
14350 static int test_read_lines_1 (void)
14351 {
14352   if (test_read_lines_1_skip ()) {
14353     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14354     return 0;
14355   }
14356
14357   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14358   {
14359     char device[] = "/dev/sda";
14360     device[5] = devchar;
14361     int r;
14362     suppress_error = 0;
14363     r = guestfs_blockdev_setrw (g, device);
14364     if (r == -1)
14365       return -1;
14366   }
14367   {
14368     int r;
14369     suppress_error = 0;
14370     r = guestfs_umount_all (g);
14371     if (r == -1)
14372       return -1;
14373   }
14374   {
14375     int r;
14376     suppress_error = 0;
14377     r = guestfs_lvm_remove_all (g);
14378     if (r == -1)
14379       return -1;
14380   }
14381   {
14382     char device[] = "/dev/sda";
14383     device[5] = devchar;
14384     char lines_0[] = ",";
14385     char *lines[] = {
14386       lines_0,
14387       NULL
14388     };
14389     int r;
14390     suppress_error = 0;
14391     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14392     if (r == -1)
14393       return -1;
14394   }
14395   {
14396     char fstype[] = "ext2";
14397     char device[] = "/dev/sda1";
14398     device[5] = devchar;
14399     int r;
14400     suppress_error = 0;
14401     r = guestfs_mkfs (g, fstype, device);
14402     if (r == -1)
14403       return -1;
14404   }
14405   {
14406     char device[] = "/dev/sda1";
14407     device[5] = devchar;
14408     char mountpoint[] = "/";
14409     int r;
14410     suppress_error = 0;
14411     r = guestfs_mount (g, device, mountpoint);
14412     if (r == -1)
14413       return -1;
14414   }
14415   /* TestOutputList for read_lines (1) */
14416   {
14417     char path[] = "/new";
14418     char content[] = "";
14419     int r;
14420     suppress_error = 0;
14421     r = guestfs_write_file (g, path, content, 0);
14422     if (r == -1)
14423       return -1;
14424   }
14425   {
14426     char path[] = "/new";
14427     char **r;
14428     int i;
14429     suppress_error = 0;
14430     r = guestfs_read_lines (g, path);
14431     if (r == NULL)
14432       return -1;
14433     if (r[0] != NULL) {
14434       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14435       print_strings (r);
14436       return -1;
14437     }
14438     for (i = 0; r[i] != NULL; ++i)
14439       free (r[i]);
14440     free (r);
14441   }
14442   return 0;
14443 }
14444
14445 static int test_lvs_0_skip (void)
14446 {
14447   const char *str;
14448
14449   str = getenv ("SKIP_TEST_LVS_0");
14450   if (str && strcmp (str, "1") == 0) return 1;
14451   str = getenv ("SKIP_TEST_LVS");
14452   if (str && strcmp (str, "1") == 0) return 1;
14453   return 0;
14454 }
14455
14456 static int test_lvs_0 (void)
14457 {
14458   if (test_lvs_0_skip ()) {
14459     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14460     return 0;
14461   }
14462
14463   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14464   {
14465     char device[] = "/dev/sda";
14466     device[5] = devchar;
14467     int r;
14468     suppress_error = 0;
14469     r = guestfs_blockdev_setrw (g, device);
14470     if (r == -1)
14471       return -1;
14472   }
14473   {
14474     int r;
14475     suppress_error = 0;
14476     r = guestfs_umount_all (g);
14477     if (r == -1)
14478       return -1;
14479   }
14480   {
14481     int r;
14482     suppress_error = 0;
14483     r = guestfs_lvm_remove_all (g);
14484     if (r == -1)
14485       return -1;
14486   }
14487   {
14488     char device[] = "/dev/sda";
14489     device[5] = devchar;
14490     char lines_0[] = ",";
14491     char *lines[] = {
14492       lines_0,
14493       NULL
14494     };
14495     int r;
14496     suppress_error = 0;
14497     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14498     if (r == -1)
14499       return -1;
14500   }
14501   {
14502     char device[] = "/dev/sda1";
14503     device[5] = devchar;
14504     int r;
14505     suppress_error = 0;
14506     r = guestfs_pvcreate (g, device);
14507     if (r == -1)
14508       return -1;
14509   }
14510   {
14511     char volgroup[] = "VG";
14512     char physvols_0[] = "/dev/sda1";
14513     physvols_0[5] = devchar;
14514     char *physvols[] = {
14515       physvols_0,
14516       NULL
14517     };
14518     int r;
14519     suppress_error = 0;
14520     r = guestfs_vgcreate (g, volgroup, physvols);
14521     if (r == -1)
14522       return -1;
14523   }
14524   {
14525     char logvol[] = "LV";
14526     char volgroup[] = "VG";
14527     int r;
14528     suppress_error = 0;
14529     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14530     if (r == -1)
14531       return -1;
14532   }
14533   {
14534     char fstype[] = "ext2";
14535     char device[] = "/dev/VG/LV";
14536     int r;
14537     suppress_error = 0;
14538     r = guestfs_mkfs (g, fstype, device);
14539     if (r == -1)
14540       return -1;
14541   }
14542   {
14543     char device[] = "/dev/VG/LV";
14544     char mountpoint[] = "/";
14545     int r;
14546     suppress_error = 0;
14547     r = guestfs_mount (g, device, mountpoint);
14548     if (r == -1)
14549       return -1;
14550   }
14551   /* TestOutputList for lvs (0) */
14552   {
14553     char **r;
14554     int i;
14555     suppress_error = 0;
14556     r = guestfs_lvs (g);
14557     if (r == NULL)
14558       return -1;
14559     if (!r[0]) {
14560       fprintf (stderr, "test_lvs_0: short list returned from command\n");
14561       print_strings (r);
14562       return -1;
14563     }
14564     {
14565       char expected[] = "/dev/VG/LV";
14566       if (strcmp (r[0], expected) != 0) {
14567         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14568         return -1;
14569       }
14570     }
14571     if (r[1] != NULL) {
14572       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14573       print_strings (r);
14574       return -1;
14575     }
14576     for (i = 0; r[i] != NULL; ++i)
14577       free (r[i]);
14578     free (r);
14579   }
14580   return 0;
14581 }
14582
14583 static int test_lvs_1_skip (void)
14584 {
14585   const char *str;
14586
14587   str = getenv ("SKIP_TEST_LVS_1");
14588   if (str && strcmp (str, "1") == 0) return 1;
14589   str = getenv ("SKIP_TEST_LVS");
14590   if (str && strcmp (str, "1") == 0) return 1;
14591   return 0;
14592 }
14593
14594 static int test_lvs_1 (void)
14595 {
14596   if (test_lvs_1_skip ()) {
14597     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14598     return 0;
14599   }
14600
14601   /* InitNone|InitEmpty for test_lvs_1 */
14602   {
14603     char device[] = "/dev/sda";
14604     device[5] = devchar;
14605     int r;
14606     suppress_error = 0;
14607     r = guestfs_blockdev_setrw (g, device);
14608     if (r == -1)
14609       return -1;
14610   }
14611   {
14612     int r;
14613     suppress_error = 0;
14614     r = guestfs_umount_all (g);
14615     if (r == -1)
14616       return -1;
14617   }
14618   {
14619     int r;
14620     suppress_error = 0;
14621     r = guestfs_lvm_remove_all (g);
14622     if (r == -1)
14623       return -1;
14624   }
14625   /* TestOutputList for lvs (1) */
14626   {
14627     char device[] = "/dev/sda";
14628     device[5] = devchar;
14629     char lines_0[] = ",10";
14630     char lines_1[] = ",20";
14631     char lines_2[] = ",";
14632     char *lines[] = {
14633       lines_0,
14634       lines_1,
14635       lines_2,
14636       NULL
14637     };
14638     int r;
14639     suppress_error = 0;
14640     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14641     if (r == -1)
14642       return -1;
14643   }
14644   {
14645     char device[] = "/dev/sda1";
14646     device[5] = devchar;
14647     int r;
14648     suppress_error = 0;
14649     r = guestfs_pvcreate (g, device);
14650     if (r == -1)
14651       return -1;
14652   }
14653   {
14654     char device[] = "/dev/sda2";
14655     device[5] = devchar;
14656     int r;
14657     suppress_error = 0;
14658     r = guestfs_pvcreate (g, device);
14659     if (r == -1)
14660       return -1;
14661   }
14662   {
14663     char device[] = "/dev/sda3";
14664     device[5] = devchar;
14665     int r;
14666     suppress_error = 0;
14667     r = guestfs_pvcreate (g, device);
14668     if (r == -1)
14669       return -1;
14670   }
14671   {
14672     char volgroup[] = "VG1";
14673     char physvols_0[] = "/dev/sda1";
14674     physvols_0[5] = devchar;
14675     char physvols_1[] = "/dev/sda2";
14676     physvols_1[5] = devchar;
14677     char *physvols[] = {
14678       physvols_0,
14679       physvols_1,
14680       NULL
14681     };
14682     int r;
14683     suppress_error = 0;
14684     r = guestfs_vgcreate (g, volgroup, physvols);
14685     if (r == -1)
14686       return -1;
14687   }
14688   {
14689     char volgroup[] = "VG2";
14690     char physvols_0[] = "/dev/sda3";
14691     physvols_0[5] = devchar;
14692     char *physvols[] = {
14693       physvols_0,
14694       NULL
14695     };
14696     int r;
14697     suppress_error = 0;
14698     r = guestfs_vgcreate (g, volgroup, physvols);
14699     if (r == -1)
14700       return -1;
14701   }
14702   {
14703     char logvol[] = "LV1";
14704     char volgroup[] = "VG1";
14705     int r;
14706     suppress_error = 0;
14707     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14708     if (r == -1)
14709       return -1;
14710   }
14711   {
14712     char logvol[] = "LV2";
14713     char volgroup[] = "VG1";
14714     int r;
14715     suppress_error = 0;
14716     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14717     if (r == -1)
14718       return -1;
14719   }
14720   {
14721     char logvol[] = "LV3";
14722     char volgroup[] = "VG2";
14723     int r;
14724     suppress_error = 0;
14725     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14726     if (r == -1)
14727       return -1;
14728   }
14729   {
14730     char **r;
14731     int i;
14732     suppress_error = 0;
14733     r = guestfs_lvs (g);
14734     if (r == NULL)
14735       return -1;
14736     if (!r[0]) {
14737       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14738       print_strings (r);
14739       return -1;
14740     }
14741     {
14742       char expected[] = "/dev/VG1/LV1";
14743       if (strcmp (r[0], expected) != 0) {
14744         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14745         return -1;
14746       }
14747     }
14748     if (!r[1]) {
14749       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14750       print_strings (r);
14751       return -1;
14752     }
14753     {
14754       char expected[] = "/dev/VG1/LV2";
14755       if (strcmp (r[1], expected) != 0) {
14756         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14757         return -1;
14758       }
14759     }
14760     if (!r[2]) {
14761       fprintf (stderr, "test_lvs_1: short list returned from command\n");
14762       print_strings (r);
14763       return -1;
14764     }
14765     {
14766       char expected[] = "/dev/VG2/LV3";
14767       if (strcmp (r[2], expected) != 0) {
14768         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14769         return -1;
14770       }
14771     }
14772     if (r[3] != NULL) {
14773       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14774       print_strings (r);
14775       return -1;
14776     }
14777     for (i = 0; r[i] != NULL; ++i)
14778       free (r[i]);
14779     free (r);
14780   }
14781   return 0;
14782 }
14783
14784 static int test_vgs_0_skip (void)
14785 {
14786   const char *str;
14787
14788   str = getenv ("SKIP_TEST_VGS_0");
14789   if (str && strcmp (str, "1") == 0) return 1;
14790   str = getenv ("SKIP_TEST_VGS");
14791   if (str && strcmp (str, "1") == 0) return 1;
14792   return 0;
14793 }
14794
14795 static int test_vgs_0 (void)
14796 {
14797   if (test_vgs_0_skip ()) {
14798     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14799     return 0;
14800   }
14801
14802   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14803   {
14804     char device[] = "/dev/sda";
14805     device[5] = devchar;
14806     int r;
14807     suppress_error = 0;
14808     r = guestfs_blockdev_setrw (g, device);
14809     if (r == -1)
14810       return -1;
14811   }
14812   {
14813     int r;
14814     suppress_error = 0;
14815     r = guestfs_umount_all (g);
14816     if (r == -1)
14817       return -1;
14818   }
14819   {
14820     int r;
14821     suppress_error = 0;
14822     r = guestfs_lvm_remove_all (g);
14823     if (r == -1)
14824       return -1;
14825   }
14826   {
14827     char device[] = "/dev/sda";
14828     device[5] = devchar;
14829     char lines_0[] = ",";
14830     char *lines[] = {
14831       lines_0,
14832       NULL
14833     };
14834     int r;
14835     suppress_error = 0;
14836     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14837     if (r == -1)
14838       return -1;
14839   }
14840   {
14841     char device[] = "/dev/sda1";
14842     device[5] = devchar;
14843     int r;
14844     suppress_error = 0;
14845     r = guestfs_pvcreate (g, device);
14846     if (r == -1)
14847       return -1;
14848   }
14849   {
14850     char volgroup[] = "VG";
14851     char physvols_0[] = "/dev/sda1";
14852     physvols_0[5] = devchar;
14853     char *physvols[] = {
14854       physvols_0,
14855       NULL
14856     };
14857     int r;
14858     suppress_error = 0;
14859     r = guestfs_vgcreate (g, volgroup, physvols);
14860     if (r == -1)
14861       return -1;
14862   }
14863   {
14864     char logvol[] = "LV";
14865     char volgroup[] = "VG";
14866     int r;
14867     suppress_error = 0;
14868     r = guestfs_lvcreate (g, logvol, volgroup, 8);
14869     if (r == -1)
14870       return -1;
14871   }
14872   {
14873     char fstype[] = "ext2";
14874     char device[] = "/dev/VG/LV";
14875     int r;
14876     suppress_error = 0;
14877     r = guestfs_mkfs (g, fstype, device);
14878     if (r == -1)
14879       return -1;
14880   }
14881   {
14882     char device[] = "/dev/VG/LV";
14883     char mountpoint[] = "/";
14884     int r;
14885     suppress_error = 0;
14886     r = guestfs_mount (g, device, mountpoint);
14887     if (r == -1)
14888       return -1;
14889   }
14890   /* TestOutputList for vgs (0) */
14891   {
14892     char **r;
14893     int i;
14894     suppress_error = 0;
14895     r = guestfs_vgs (g);
14896     if (r == NULL)
14897       return -1;
14898     if (!r[0]) {
14899       fprintf (stderr, "test_vgs_0: short list returned from command\n");
14900       print_strings (r);
14901       return -1;
14902     }
14903     {
14904       char expected[] = "VG";
14905       if (strcmp (r[0], expected) != 0) {
14906         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14907         return -1;
14908       }
14909     }
14910     if (r[1] != NULL) {
14911       fprintf (stderr, "test_vgs_0: 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_vgs_1_skip (void)
14923 {
14924   const char *str;
14925
14926   str = getenv ("SKIP_TEST_VGS_1");
14927   if (str && strcmp (str, "1") == 0) return 1;
14928   str = getenv ("SKIP_TEST_VGS");
14929   if (str && strcmp (str, "1") == 0) return 1;
14930   return 0;
14931 }
14932
14933 static int test_vgs_1 (void)
14934 {
14935   if (test_vgs_1_skip ()) {
14936     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14937     return 0;
14938   }
14939
14940   /* InitNone|InitEmpty for test_vgs_1 */
14941   {
14942     char device[] = "/dev/sda";
14943     device[5] = devchar;
14944     int r;
14945     suppress_error = 0;
14946     r = guestfs_blockdev_setrw (g, device);
14947     if (r == -1)
14948       return -1;
14949   }
14950   {
14951     int r;
14952     suppress_error = 0;
14953     r = guestfs_umount_all (g);
14954     if (r == -1)
14955       return -1;
14956   }
14957   {
14958     int r;
14959     suppress_error = 0;
14960     r = guestfs_lvm_remove_all (g);
14961     if (r == -1)
14962       return -1;
14963   }
14964   /* TestOutputList for vgs (1) */
14965   {
14966     char device[] = "/dev/sda";
14967     device[5] = devchar;
14968     char lines_0[] = ",10";
14969     char lines_1[] = ",20";
14970     char lines_2[] = ",";
14971     char *lines[] = {
14972       lines_0,
14973       lines_1,
14974       lines_2,
14975       NULL
14976     };
14977     int r;
14978     suppress_error = 0;
14979     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14980     if (r == -1)
14981       return -1;
14982   }
14983   {
14984     char device[] = "/dev/sda1";
14985     device[5] = devchar;
14986     int r;
14987     suppress_error = 0;
14988     r = guestfs_pvcreate (g, device);
14989     if (r == -1)
14990       return -1;
14991   }
14992   {
14993     char device[] = "/dev/sda2";
14994     device[5] = devchar;
14995     int r;
14996     suppress_error = 0;
14997     r = guestfs_pvcreate (g, device);
14998     if (r == -1)
14999       return -1;
15000   }
15001   {
15002     char device[] = "/dev/sda3";
15003     device[5] = devchar;
15004     int r;
15005     suppress_error = 0;
15006     r = guestfs_pvcreate (g, device);
15007     if (r == -1)
15008       return -1;
15009   }
15010   {
15011     char volgroup[] = "VG1";
15012     char physvols_0[] = "/dev/sda1";
15013     physvols_0[5] = devchar;
15014     char physvols_1[] = "/dev/sda2";
15015     physvols_1[5] = devchar;
15016     char *physvols[] = {
15017       physvols_0,
15018       physvols_1,
15019       NULL
15020     };
15021     int r;
15022     suppress_error = 0;
15023     r = guestfs_vgcreate (g, volgroup, physvols);
15024     if (r == -1)
15025       return -1;
15026   }
15027   {
15028     char volgroup[] = "VG2";
15029     char physvols_0[] = "/dev/sda3";
15030     physvols_0[5] = devchar;
15031     char *physvols[] = {
15032       physvols_0,
15033       NULL
15034     };
15035     int r;
15036     suppress_error = 0;
15037     r = guestfs_vgcreate (g, volgroup, physvols);
15038     if (r == -1)
15039       return -1;
15040   }
15041   {
15042     char **r;
15043     int i;
15044     suppress_error = 0;
15045     r = guestfs_vgs (g);
15046     if (r == NULL)
15047       return -1;
15048     if (!r[0]) {
15049       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15050       print_strings (r);
15051       return -1;
15052     }
15053     {
15054       char expected[] = "VG1";
15055       if (strcmp (r[0], expected) != 0) {
15056         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15057         return -1;
15058       }
15059     }
15060     if (!r[1]) {
15061       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15062       print_strings (r);
15063       return -1;
15064     }
15065     {
15066       char expected[] = "VG2";
15067       if (strcmp (r[1], expected) != 0) {
15068         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15069         return -1;
15070       }
15071     }
15072     if (r[2] != NULL) {
15073       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15074       print_strings (r);
15075       return -1;
15076     }
15077     for (i = 0; r[i] != NULL; ++i)
15078       free (r[i]);
15079     free (r);
15080   }
15081   return 0;
15082 }
15083
15084 static int test_pvs_0_skip (void)
15085 {
15086   const char *str;
15087
15088   str = getenv ("SKIP_TEST_PVS_0");
15089   if (str && strcmp (str, "1") == 0) return 1;
15090   str = getenv ("SKIP_TEST_PVS");
15091   if (str && strcmp (str, "1") == 0) return 1;
15092   return 0;
15093 }
15094
15095 static int test_pvs_0 (void)
15096 {
15097   if (test_pvs_0_skip ()) {
15098     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
15099     return 0;
15100   }
15101
15102   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
15103   {
15104     char device[] = "/dev/sda";
15105     device[5] = devchar;
15106     int r;
15107     suppress_error = 0;
15108     r = guestfs_blockdev_setrw (g, device);
15109     if (r == -1)
15110       return -1;
15111   }
15112   {
15113     int r;
15114     suppress_error = 0;
15115     r = guestfs_umount_all (g);
15116     if (r == -1)
15117       return -1;
15118   }
15119   {
15120     int r;
15121     suppress_error = 0;
15122     r = guestfs_lvm_remove_all (g);
15123     if (r == -1)
15124       return -1;
15125   }
15126   {
15127     char device[] = "/dev/sda";
15128     device[5] = devchar;
15129     char lines_0[] = ",";
15130     char *lines[] = {
15131       lines_0,
15132       NULL
15133     };
15134     int r;
15135     suppress_error = 0;
15136     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15137     if (r == -1)
15138       return -1;
15139   }
15140   {
15141     char device[] = "/dev/sda1";
15142     device[5] = devchar;
15143     int r;
15144     suppress_error = 0;
15145     r = guestfs_pvcreate (g, device);
15146     if (r == -1)
15147       return -1;
15148   }
15149   {
15150     char volgroup[] = "VG";
15151     char physvols_0[] = "/dev/sda1";
15152     physvols_0[5] = devchar;
15153     char *physvols[] = {
15154       physvols_0,
15155       NULL
15156     };
15157     int r;
15158     suppress_error = 0;
15159     r = guestfs_vgcreate (g, volgroup, physvols);
15160     if (r == -1)
15161       return -1;
15162   }
15163   {
15164     char logvol[] = "LV";
15165     char volgroup[] = "VG";
15166     int r;
15167     suppress_error = 0;
15168     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15169     if (r == -1)
15170       return -1;
15171   }
15172   {
15173     char fstype[] = "ext2";
15174     char device[] = "/dev/VG/LV";
15175     int r;
15176     suppress_error = 0;
15177     r = guestfs_mkfs (g, fstype, device);
15178     if (r == -1)
15179       return -1;
15180   }
15181   {
15182     char device[] = "/dev/VG/LV";
15183     char mountpoint[] = "/";
15184     int r;
15185     suppress_error = 0;
15186     r = guestfs_mount (g, device, mountpoint);
15187     if (r == -1)
15188       return -1;
15189   }
15190   /* TestOutputList for pvs (0) */
15191   {
15192     char **r;
15193     int i;
15194     suppress_error = 0;
15195     r = guestfs_pvs (g);
15196     if (r == NULL)
15197       return -1;
15198     if (!r[0]) {
15199       fprintf (stderr, "test_pvs_0: short list returned from command\n");
15200       print_strings (r);
15201       return -1;
15202     }
15203     {
15204       char expected[] = "/dev/sda1";
15205       expected[5] = devchar;
15206       if (strcmp (r[0], expected) != 0) {
15207         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15208         return -1;
15209       }
15210     }
15211     if (r[1] != NULL) {
15212       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15213       print_strings (r);
15214       return -1;
15215     }
15216     for (i = 0; r[i] != NULL; ++i)
15217       free (r[i]);
15218     free (r);
15219   }
15220   return 0;
15221 }
15222
15223 static int test_pvs_1_skip (void)
15224 {
15225   const char *str;
15226
15227   str = getenv ("SKIP_TEST_PVS_1");
15228   if (str && strcmp (str, "1") == 0) return 1;
15229   str = getenv ("SKIP_TEST_PVS");
15230   if (str && strcmp (str, "1") == 0) return 1;
15231   return 0;
15232 }
15233
15234 static int test_pvs_1 (void)
15235 {
15236   if (test_pvs_1_skip ()) {
15237     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15238     return 0;
15239   }
15240
15241   /* InitNone|InitEmpty for test_pvs_1 */
15242   {
15243     char device[] = "/dev/sda";
15244     device[5] = devchar;
15245     int r;
15246     suppress_error = 0;
15247     r = guestfs_blockdev_setrw (g, device);
15248     if (r == -1)
15249       return -1;
15250   }
15251   {
15252     int r;
15253     suppress_error = 0;
15254     r = guestfs_umount_all (g);
15255     if (r == -1)
15256       return -1;
15257   }
15258   {
15259     int r;
15260     suppress_error = 0;
15261     r = guestfs_lvm_remove_all (g);
15262     if (r == -1)
15263       return -1;
15264   }
15265   /* TestOutputList for pvs (1) */
15266   {
15267     char device[] = "/dev/sda";
15268     device[5] = devchar;
15269     char lines_0[] = ",10";
15270     char lines_1[] = ",20";
15271     char lines_2[] = ",";
15272     char *lines[] = {
15273       lines_0,
15274       lines_1,
15275       lines_2,
15276       NULL
15277     };
15278     int r;
15279     suppress_error = 0;
15280     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15281     if (r == -1)
15282       return -1;
15283   }
15284   {
15285     char device[] = "/dev/sda1";
15286     device[5] = devchar;
15287     int r;
15288     suppress_error = 0;
15289     r = guestfs_pvcreate (g, device);
15290     if (r == -1)
15291       return -1;
15292   }
15293   {
15294     char device[] = "/dev/sda2";
15295     device[5] = devchar;
15296     int r;
15297     suppress_error = 0;
15298     r = guestfs_pvcreate (g, device);
15299     if (r == -1)
15300       return -1;
15301   }
15302   {
15303     char device[] = "/dev/sda3";
15304     device[5] = devchar;
15305     int r;
15306     suppress_error = 0;
15307     r = guestfs_pvcreate (g, device);
15308     if (r == -1)
15309       return -1;
15310   }
15311   {
15312     char **r;
15313     int i;
15314     suppress_error = 0;
15315     r = guestfs_pvs (g);
15316     if (r == NULL)
15317       return -1;
15318     if (!r[0]) {
15319       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15320       print_strings (r);
15321       return -1;
15322     }
15323     {
15324       char expected[] = "/dev/sda1";
15325       expected[5] = devchar;
15326       if (strcmp (r[0], expected) != 0) {
15327         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15328         return -1;
15329       }
15330     }
15331     if (!r[1]) {
15332       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15333       print_strings (r);
15334       return -1;
15335     }
15336     {
15337       char expected[] = "/dev/sda2";
15338       expected[5] = devchar;
15339       if (strcmp (r[1], expected) != 0) {
15340         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15341         return -1;
15342       }
15343     }
15344     if (!r[2]) {
15345       fprintf (stderr, "test_pvs_1: short list returned from command\n");
15346       print_strings (r);
15347       return -1;
15348     }
15349     {
15350       char expected[] = "/dev/sda3";
15351       expected[5] = devchar;
15352       if (strcmp (r[2], expected) != 0) {
15353         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15354         return -1;
15355       }
15356     }
15357     if (r[3] != NULL) {
15358       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15359       print_strings (r);
15360       return -1;
15361     }
15362     for (i = 0; r[i] != NULL; ++i)
15363       free (r[i]);
15364     free (r);
15365   }
15366   return 0;
15367 }
15368
15369 static int test_list_partitions_0_skip (void)
15370 {
15371   const char *str;
15372
15373   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15374   if (str && strcmp (str, "1") == 0) return 1;
15375   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15376   if (str && strcmp (str, "1") == 0) return 1;
15377   return 0;
15378 }
15379
15380 static int test_list_partitions_0 (void)
15381 {
15382   if (test_list_partitions_0_skip ()) {
15383     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15384     return 0;
15385   }
15386
15387   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15388   {
15389     char device[] = "/dev/sda";
15390     device[5] = devchar;
15391     int r;
15392     suppress_error = 0;
15393     r = guestfs_blockdev_setrw (g, device);
15394     if (r == -1)
15395       return -1;
15396   }
15397   {
15398     int r;
15399     suppress_error = 0;
15400     r = guestfs_umount_all (g);
15401     if (r == -1)
15402       return -1;
15403   }
15404   {
15405     int r;
15406     suppress_error = 0;
15407     r = guestfs_lvm_remove_all (g);
15408     if (r == -1)
15409       return -1;
15410   }
15411   {
15412     char device[] = "/dev/sda";
15413     device[5] = devchar;
15414     char lines_0[] = ",";
15415     char *lines[] = {
15416       lines_0,
15417       NULL
15418     };
15419     int r;
15420     suppress_error = 0;
15421     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15422     if (r == -1)
15423       return -1;
15424   }
15425   {
15426     char fstype[] = "ext2";
15427     char device[] = "/dev/sda1";
15428     device[5] = devchar;
15429     int r;
15430     suppress_error = 0;
15431     r = guestfs_mkfs (g, fstype, device);
15432     if (r == -1)
15433       return -1;
15434   }
15435   {
15436     char device[] = "/dev/sda1";
15437     device[5] = devchar;
15438     char mountpoint[] = "/";
15439     int r;
15440     suppress_error = 0;
15441     r = guestfs_mount (g, device, mountpoint);
15442     if (r == -1)
15443       return -1;
15444   }
15445   /* TestOutputList for list_partitions (0) */
15446   {
15447     char **r;
15448     int i;
15449     suppress_error = 0;
15450     r = guestfs_list_partitions (g);
15451     if (r == NULL)
15452       return -1;
15453     if (!r[0]) {
15454       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15455       print_strings (r);
15456       return -1;
15457     }
15458     {
15459       char expected[] = "/dev/sda1";
15460       expected[5] = devchar;
15461       if (strcmp (r[0], expected) != 0) {
15462         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15463         return -1;
15464       }
15465     }
15466     if (r[1] != NULL) {
15467       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15468       print_strings (r);
15469       return -1;
15470     }
15471     for (i = 0; r[i] != NULL; ++i)
15472       free (r[i]);
15473     free (r);
15474   }
15475   return 0;
15476 }
15477
15478 static int test_list_partitions_1_skip (void)
15479 {
15480   const char *str;
15481
15482   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15483   if (str && strcmp (str, "1") == 0) return 1;
15484   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15485   if (str && strcmp (str, "1") == 0) return 1;
15486   return 0;
15487 }
15488
15489 static int test_list_partitions_1 (void)
15490 {
15491   if (test_list_partitions_1_skip ()) {
15492     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15493     return 0;
15494   }
15495
15496   /* InitNone|InitEmpty for test_list_partitions_1 */
15497   {
15498     char device[] = "/dev/sda";
15499     device[5] = devchar;
15500     int r;
15501     suppress_error = 0;
15502     r = guestfs_blockdev_setrw (g, device);
15503     if (r == -1)
15504       return -1;
15505   }
15506   {
15507     int r;
15508     suppress_error = 0;
15509     r = guestfs_umount_all (g);
15510     if (r == -1)
15511       return -1;
15512   }
15513   {
15514     int r;
15515     suppress_error = 0;
15516     r = guestfs_lvm_remove_all (g);
15517     if (r == -1)
15518       return -1;
15519   }
15520   /* TestOutputList for list_partitions (1) */
15521   {
15522     char device[] = "/dev/sda";
15523     device[5] = devchar;
15524     char lines_0[] = ",10";
15525     char lines_1[] = ",20";
15526     char lines_2[] = ",";
15527     char *lines[] = {
15528       lines_0,
15529       lines_1,
15530       lines_2,
15531       NULL
15532     };
15533     int r;
15534     suppress_error = 0;
15535     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15536     if (r == -1)
15537       return -1;
15538   }
15539   {
15540     char **r;
15541     int i;
15542     suppress_error = 0;
15543     r = guestfs_list_partitions (g);
15544     if (r == NULL)
15545       return -1;
15546     if (!r[0]) {
15547       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15548       print_strings (r);
15549       return -1;
15550     }
15551     {
15552       char expected[] = "/dev/sda1";
15553       expected[5] = devchar;
15554       if (strcmp (r[0], expected) != 0) {
15555         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15556         return -1;
15557       }
15558     }
15559     if (!r[1]) {
15560       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15561       print_strings (r);
15562       return -1;
15563     }
15564     {
15565       char expected[] = "/dev/sda2";
15566       expected[5] = devchar;
15567       if (strcmp (r[1], expected) != 0) {
15568         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15569         return -1;
15570       }
15571     }
15572     if (!r[2]) {
15573       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15574       print_strings (r);
15575       return -1;
15576     }
15577     {
15578       char expected[] = "/dev/sda3";
15579       expected[5] = devchar;
15580       if (strcmp (r[2], expected) != 0) {
15581         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15582         return -1;
15583       }
15584     }
15585     if (r[3] != NULL) {
15586       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15587       print_strings (r);
15588       return -1;
15589     }
15590     for (i = 0; r[i] != NULL; ++i)
15591       free (r[i]);
15592     free (r);
15593   }
15594   return 0;
15595 }
15596
15597 static int test_list_devices_0_skip (void)
15598 {
15599   const char *str;
15600
15601   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15602   if (str && strcmp (str, "1") == 0) return 1;
15603   str = getenv ("SKIP_TEST_LIST_DEVICES");
15604   if (str && strcmp (str, "1") == 0) return 1;
15605   return 0;
15606 }
15607
15608 static int test_list_devices_0 (void)
15609 {
15610   if (test_list_devices_0_skip ()) {
15611     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15612     return 0;
15613   }
15614
15615   /* InitNone|InitEmpty for test_list_devices_0 */
15616   {
15617     char device[] = "/dev/sda";
15618     device[5] = devchar;
15619     int r;
15620     suppress_error = 0;
15621     r = guestfs_blockdev_setrw (g, device);
15622     if (r == -1)
15623       return -1;
15624   }
15625   {
15626     int r;
15627     suppress_error = 0;
15628     r = guestfs_umount_all (g);
15629     if (r == -1)
15630       return -1;
15631   }
15632   {
15633     int r;
15634     suppress_error = 0;
15635     r = guestfs_lvm_remove_all (g);
15636     if (r == -1)
15637       return -1;
15638   }
15639   /* TestOutputList for list_devices (0) */
15640   {
15641     char **r;
15642     int i;
15643     suppress_error = 0;
15644     r = guestfs_list_devices (g);
15645     if (r == NULL)
15646       return -1;
15647     if (!r[0]) {
15648       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15649       print_strings (r);
15650       return -1;
15651     }
15652     {
15653       char expected[] = "/dev/sda";
15654       expected[5] = devchar;
15655       if (strcmp (r[0], expected) != 0) {
15656         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15657         return -1;
15658       }
15659     }
15660     if (!r[1]) {
15661       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15662       print_strings (r);
15663       return -1;
15664     }
15665     {
15666       char expected[] = "/dev/sdb";
15667       expected[5] = devchar;
15668       if (strcmp (r[1], expected) != 0) {
15669         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15670         return -1;
15671       }
15672     }
15673     if (!r[2]) {
15674       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15675       print_strings (r);
15676       return -1;
15677     }
15678     {
15679       char expected[] = "/dev/sdc";
15680       expected[5] = devchar;
15681       if (strcmp (r[2], expected) != 0) {
15682         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15683         return -1;
15684       }
15685     }
15686     if (!r[3]) {
15687       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15688       print_strings (r);
15689       return -1;
15690     }
15691     {
15692       char expected[] = "/dev/sdd";
15693       expected[5] = devchar;
15694       if (strcmp (r[3], expected) != 0) {
15695         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15696         return -1;
15697       }
15698     }
15699     if (r[4] != NULL) {
15700       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15701       print_strings (r);
15702       return -1;
15703     }
15704     for (i = 0; r[i] != NULL; ++i)
15705       free (r[i]);
15706     free (r);
15707   }
15708   return 0;
15709 }
15710
15711 static int test_ls_0_skip (void)
15712 {
15713   const char *str;
15714
15715   str = getenv ("SKIP_TEST_LS_0");
15716   if (str && strcmp (str, "1") == 0) return 1;
15717   str = getenv ("SKIP_TEST_LS");
15718   if (str && strcmp (str, "1") == 0) return 1;
15719   return 0;
15720 }
15721
15722 static int test_ls_0 (void)
15723 {
15724   if (test_ls_0_skip ()) {
15725     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15726     return 0;
15727   }
15728
15729   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15730   {
15731     char device[] = "/dev/sda";
15732     device[5] = devchar;
15733     int r;
15734     suppress_error = 0;
15735     r = guestfs_blockdev_setrw (g, device);
15736     if (r == -1)
15737       return -1;
15738   }
15739   {
15740     int r;
15741     suppress_error = 0;
15742     r = guestfs_umount_all (g);
15743     if (r == -1)
15744       return -1;
15745   }
15746   {
15747     int r;
15748     suppress_error = 0;
15749     r = guestfs_lvm_remove_all (g);
15750     if (r == -1)
15751       return -1;
15752   }
15753   {
15754     char device[] = "/dev/sda";
15755     device[5] = devchar;
15756     char lines_0[] = ",";
15757     char *lines[] = {
15758       lines_0,
15759       NULL
15760     };
15761     int r;
15762     suppress_error = 0;
15763     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15764     if (r == -1)
15765       return -1;
15766   }
15767   {
15768     char fstype[] = "ext2";
15769     char device[] = "/dev/sda1";
15770     device[5] = devchar;
15771     int r;
15772     suppress_error = 0;
15773     r = guestfs_mkfs (g, fstype, device);
15774     if (r == -1)
15775       return -1;
15776   }
15777   {
15778     char device[] = "/dev/sda1";
15779     device[5] = devchar;
15780     char mountpoint[] = "/";
15781     int r;
15782     suppress_error = 0;
15783     r = guestfs_mount (g, device, mountpoint);
15784     if (r == -1)
15785       return -1;
15786   }
15787   /* TestOutputList for ls (0) */
15788   {
15789     char path[] = "/new";
15790     int r;
15791     suppress_error = 0;
15792     r = guestfs_touch (g, path);
15793     if (r == -1)
15794       return -1;
15795   }
15796   {
15797     char path[] = "/newer";
15798     int r;
15799     suppress_error = 0;
15800     r = guestfs_touch (g, path);
15801     if (r == -1)
15802       return -1;
15803   }
15804   {
15805     char path[] = "/newest";
15806     int r;
15807     suppress_error = 0;
15808     r = guestfs_touch (g, path);
15809     if (r == -1)
15810       return -1;
15811   }
15812   {
15813     char directory[] = "/";
15814     char **r;
15815     int i;
15816     suppress_error = 0;
15817     r = guestfs_ls (g, directory);
15818     if (r == NULL)
15819       return -1;
15820     if (!r[0]) {
15821       fprintf (stderr, "test_ls_0: short list returned from command\n");
15822       print_strings (r);
15823       return -1;
15824     }
15825     {
15826       char expected[] = "lost+found";
15827       if (strcmp (r[0], expected) != 0) {
15828         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15829         return -1;
15830       }
15831     }
15832     if (!r[1]) {
15833       fprintf (stderr, "test_ls_0: short list returned from command\n");
15834       print_strings (r);
15835       return -1;
15836     }
15837     {
15838       char expected[] = "new";
15839       if (strcmp (r[1], expected) != 0) {
15840         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15841         return -1;
15842       }
15843     }
15844     if (!r[2]) {
15845       fprintf (stderr, "test_ls_0: short list returned from command\n");
15846       print_strings (r);
15847       return -1;
15848     }
15849     {
15850       char expected[] = "newer";
15851       if (strcmp (r[2], expected) != 0) {
15852         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15853         return -1;
15854       }
15855     }
15856     if (!r[3]) {
15857       fprintf (stderr, "test_ls_0: short list returned from command\n");
15858       print_strings (r);
15859       return -1;
15860     }
15861     {
15862       char expected[] = "newest";
15863       if (strcmp (r[3], expected) != 0) {
15864         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15865         return -1;
15866       }
15867     }
15868     if (r[4] != NULL) {
15869       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15870       print_strings (r);
15871       return -1;
15872     }
15873     for (i = 0; r[i] != NULL; ++i)
15874       free (r[i]);
15875     free (r);
15876   }
15877   return 0;
15878 }
15879
15880 static int test_cat_0_skip (void)
15881 {
15882   const char *str;
15883
15884   str = getenv ("SKIP_TEST_CAT_0");
15885   if (str && strcmp (str, "1") == 0) return 1;
15886   str = getenv ("SKIP_TEST_CAT");
15887   if (str && strcmp (str, "1") == 0) return 1;
15888   return 0;
15889 }
15890
15891 static int test_cat_0 (void)
15892 {
15893   if (test_cat_0_skip ()) {
15894     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15895     return 0;
15896   }
15897
15898   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15899   {
15900     char device[] = "/dev/sda";
15901     device[5] = devchar;
15902     int r;
15903     suppress_error = 0;
15904     r = guestfs_blockdev_setrw (g, device);
15905     if (r == -1)
15906       return -1;
15907   }
15908   {
15909     int r;
15910     suppress_error = 0;
15911     r = guestfs_umount_all (g);
15912     if (r == -1)
15913       return -1;
15914   }
15915   {
15916     int r;
15917     suppress_error = 0;
15918     r = guestfs_lvm_remove_all (g);
15919     if (r == -1)
15920       return -1;
15921   }
15922   {
15923     char device[] = "/dev/sda";
15924     device[5] = devchar;
15925     char lines_0[] = ",";
15926     char *lines[] = {
15927       lines_0,
15928       NULL
15929     };
15930     int r;
15931     suppress_error = 0;
15932     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15933     if (r == -1)
15934       return -1;
15935   }
15936   {
15937     char fstype[] = "ext2";
15938     char device[] = "/dev/sda1";
15939     device[5] = devchar;
15940     int r;
15941     suppress_error = 0;
15942     r = guestfs_mkfs (g, fstype, device);
15943     if (r == -1)
15944       return -1;
15945   }
15946   {
15947     char device[] = "/dev/sda1";
15948     device[5] = devchar;
15949     char mountpoint[] = "/";
15950     int r;
15951     suppress_error = 0;
15952     r = guestfs_mount (g, device, mountpoint);
15953     if (r == -1)
15954       return -1;
15955   }
15956   /* TestOutput for cat (0) */
15957   char expected[] = "new file contents";
15958   {
15959     char path[] = "/new";
15960     char content[] = "new file contents";
15961     int r;
15962     suppress_error = 0;
15963     r = guestfs_write_file (g, path, content, 0);
15964     if (r == -1)
15965       return -1;
15966   }
15967   {
15968     char path[] = "/new";
15969     char *r;
15970     suppress_error = 0;
15971     r = guestfs_cat (g, path);
15972     if (r == NULL)
15973       return -1;
15974     if (strcmp (r, expected) != 0) {
15975       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15976       return -1;
15977     }
15978     free (r);
15979   }
15980   return 0;
15981 }
15982
15983 static int test_touch_0_skip (void)
15984 {
15985   const char *str;
15986
15987   str = getenv ("SKIP_TEST_TOUCH_0");
15988   if (str && strcmp (str, "1") == 0) return 1;
15989   str = getenv ("SKIP_TEST_TOUCH");
15990   if (str && strcmp (str, "1") == 0) return 1;
15991   return 0;
15992 }
15993
15994 static int test_touch_0 (void)
15995 {
15996   if (test_touch_0_skip ()) {
15997     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15998     return 0;
15999   }
16000
16001   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
16002   {
16003     char device[] = "/dev/sda";
16004     device[5] = devchar;
16005     int r;
16006     suppress_error = 0;
16007     r = guestfs_blockdev_setrw (g, device);
16008     if (r == -1)
16009       return -1;
16010   }
16011   {
16012     int r;
16013     suppress_error = 0;
16014     r = guestfs_umount_all (g);
16015     if (r == -1)
16016       return -1;
16017   }
16018   {
16019     int r;
16020     suppress_error = 0;
16021     r = guestfs_lvm_remove_all (g);
16022     if (r == -1)
16023       return -1;
16024   }
16025   {
16026     char device[] = "/dev/sda";
16027     device[5] = devchar;
16028     char lines_0[] = ",";
16029     char *lines[] = {
16030       lines_0,
16031       NULL
16032     };
16033     int r;
16034     suppress_error = 0;
16035     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16036     if (r == -1)
16037       return -1;
16038   }
16039   {
16040     char fstype[] = "ext2";
16041     char device[] = "/dev/sda1";
16042     device[5] = devchar;
16043     int r;
16044     suppress_error = 0;
16045     r = guestfs_mkfs (g, fstype, device);
16046     if (r == -1)
16047       return -1;
16048   }
16049   {
16050     char device[] = "/dev/sda1";
16051     device[5] = devchar;
16052     char mountpoint[] = "/";
16053     int r;
16054     suppress_error = 0;
16055     r = guestfs_mount (g, device, mountpoint);
16056     if (r == -1)
16057       return -1;
16058   }
16059   /* TestOutputTrue for touch (0) */
16060   {
16061     char path[] = "/new";
16062     int r;
16063     suppress_error = 0;
16064     r = guestfs_touch (g, path);
16065     if (r == -1)
16066       return -1;
16067   }
16068   {
16069     char path[] = "/new";
16070     int r;
16071     suppress_error = 0;
16072     r = guestfs_exists (g, path);
16073     if (r == -1)
16074       return -1;
16075     if (!r) {
16076       fprintf (stderr, "test_touch_0: expected true, got false\n");
16077       return -1;
16078     }
16079   }
16080   return 0;
16081 }
16082
16083 static int test_sync_0_skip (void)
16084 {
16085   const char *str;
16086
16087   str = getenv ("SKIP_TEST_SYNC_0");
16088   if (str && strcmp (str, "1") == 0) return 1;
16089   str = getenv ("SKIP_TEST_SYNC");
16090   if (str && strcmp (str, "1") == 0) return 1;
16091   return 0;
16092 }
16093
16094 static int test_sync_0 (void)
16095 {
16096   if (test_sync_0_skip ()) {
16097     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
16098     return 0;
16099   }
16100
16101   /* InitNone|InitEmpty for test_sync_0 */
16102   {
16103     char device[] = "/dev/sda";
16104     device[5] = devchar;
16105     int r;
16106     suppress_error = 0;
16107     r = guestfs_blockdev_setrw (g, device);
16108     if (r == -1)
16109       return -1;
16110   }
16111   {
16112     int r;
16113     suppress_error = 0;
16114     r = guestfs_umount_all (g);
16115     if (r == -1)
16116       return -1;
16117   }
16118   {
16119     int r;
16120     suppress_error = 0;
16121     r = guestfs_lvm_remove_all (g);
16122     if (r == -1)
16123       return -1;
16124   }
16125   /* TestRun for sync (0) */
16126   {
16127     int r;
16128     suppress_error = 0;
16129     r = guestfs_sync (g);
16130     if (r == -1)
16131       return -1;
16132   }
16133   return 0;
16134 }
16135
16136 static int test_mount_0_skip (void)
16137 {
16138   const char *str;
16139
16140   str = getenv ("SKIP_TEST_MOUNT_0");
16141   if (str && strcmp (str, "1") == 0) return 1;
16142   str = getenv ("SKIP_TEST_MOUNT");
16143   if (str && strcmp (str, "1") == 0) return 1;
16144   return 0;
16145 }
16146
16147 static int test_mount_0 (void)
16148 {
16149   if (test_mount_0_skip ()) {
16150     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
16151     return 0;
16152   }
16153
16154   /* InitNone|InitEmpty for test_mount_0 */
16155   {
16156     char device[] = "/dev/sda";
16157     device[5] = devchar;
16158     int r;
16159     suppress_error = 0;
16160     r = guestfs_blockdev_setrw (g, device);
16161     if (r == -1)
16162       return -1;
16163   }
16164   {
16165     int r;
16166     suppress_error = 0;
16167     r = guestfs_umount_all (g);
16168     if (r == -1)
16169       return -1;
16170   }
16171   {
16172     int r;
16173     suppress_error = 0;
16174     r = guestfs_lvm_remove_all (g);
16175     if (r == -1)
16176       return -1;
16177   }
16178   /* TestOutput for mount (0) */
16179   char expected[] = "new file contents";
16180   {
16181     char device[] = "/dev/sda";
16182     device[5] = devchar;
16183     char lines_0[] = ",";
16184     char *lines[] = {
16185       lines_0,
16186       NULL
16187     };
16188     int r;
16189     suppress_error = 0;
16190     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16191     if (r == -1)
16192       return -1;
16193   }
16194   {
16195     char fstype[] = "ext2";
16196     char device[] = "/dev/sda1";
16197     device[5] = devchar;
16198     int r;
16199     suppress_error = 0;
16200     r = guestfs_mkfs (g, fstype, device);
16201     if (r == -1)
16202       return -1;
16203   }
16204   {
16205     char device[] = "/dev/sda1";
16206     device[5] = devchar;
16207     char mountpoint[] = "/";
16208     int r;
16209     suppress_error = 0;
16210     r = guestfs_mount (g, device, mountpoint);
16211     if (r == -1)
16212       return -1;
16213   }
16214   {
16215     char path[] = "/new";
16216     char content[] = "new file contents";
16217     int r;
16218     suppress_error = 0;
16219     r = guestfs_write_file (g, path, content, 0);
16220     if (r == -1)
16221       return -1;
16222   }
16223   {
16224     char path[] = "/new";
16225     char *r;
16226     suppress_error = 0;
16227     r = guestfs_cat (g, path);
16228     if (r == NULL)
16229       return -1;
16230     if (strcmp (r, expected) != 0) {
16231       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16232       return -1;
16233     }
16234     free (r);
16235   }
16236   return 0;
16237 }
16238
16239 int main (int argc, char *argv[])
16240 {
16241   char c = 0;
16242   int failed = 0;
16243   const char *filename;
16244   int fd, i;
16245   int nr_tests, test_num = 0;
16246   char **devs;
16247
16248   no_test_warnings ();
16249
16250   g = guestfs_create ();
16251   if (g == NULL) {
16252     printf ("guestfs_create FAILED\n");
16253     exit (1);
16254   }
16255
16256   guestfs_set_error_handler (g, print_error, NULL);
16257
16258   guestfs_set_path (g, "../appliance");
16259
16260   filename = "test1.img";
16261   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16262   if (fd == -1) {
16263     perror (filename);
16264     exit (1);
16265   }
16266   if (lseek (fd, 524288000, SEEK_SET) == -1) {
16267     perror ("lseek");
16268     close (fd);
16269     unlink (filename);
16270     exit (1);
16271   }
16272   if (write (fd, &c, 1) == -1) {
16273     perror ("write");
16274     close (fd);
16275     unlink (filename);
16276     exit (1);
16277   }
16278   if (close (fd) == -1) {
16279     perror (filename);
16280     unlink (filename);
16281     exit (1);
16282   }
16283   if (guestfs_add_drive (g, filename) == -1) {
16284     printf ("guestfs_add_drive %s FAILED\n", filename);
16285     exit (1);
16286   }
16287
16288   filename = "test2.img";
16289   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16290   if (fd == -1) {
16291     perror (filename);
16292     exit (1);
16293   }
16294   if (lseek (fd, 52428800, SEEK_SET) == -1) {
16295     perror ("lseek");
16296     close (fd);
16297     unlink (filename);
16298     exit (1);
16299   }
16300   if (write (fd, &c, 1) == -1) {
16301     perror ("write");
16302     close (fd);
16303     unlink (filename);
16304     exit (1);
16305   }
16306   if (close (fd) == -1) {
16307     perror (filename);
16308     unlink (filename);
16309     exit (1);
16310   }
16311   if (guestfs_add_drive (g, filename) == -1) {
16312     printf ("guestfs_add_drive %s FAILED\n", filename);
16313     exit (1);
16314   }
16315
16316   filename = "test3.img";
16317   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16318   if (fd == -1) {
16319     perror (filename);
16320     exit (1);
16321   }
16322   if (lseek (fd, 10485760, SEEK_SET) == -1) {
16323     perror ("lseek");
16324     close (fd);
16325     unlink (filename);
16326     exit (1);
16327   }
16328   if (write (fd, &c, 1) == -1) {
16329     perror ("write");
16330     close (fd);
16331     unlink (filename);
16332     exit (1);
16333   }
16334   if (close (fd) == -1) {
16335     perror (filename);
16336     unlink (filename);
16337     exit (1);
16338   }
16339   if (guestfs_add_drive (g, filename) == -1) {
16340     printf ("guestfs_add_drive %s FAILED\n", filename);
16341     exit (1);
16342   }
16343
16344   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16345     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16346     exit (1);
16347   }
16348
16349   if (guestfs_launch (g) == -1) {
16350     printf ("guestfs_launch FAILED\n");
16351     exit (1);
16352   }
16353   if (guestfs_wait_ready (g) == -1) {
16354     printf ("guestfs_wait_ready FAILED\n");
16355     exit (1);
16356   }
16357
16358   /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
16359    * names.  This changed between RHEL 5 and RHEL 6 so we have to
16360    * support both.
16361    */
16362   devs = guestfs_list_devices (g);
16363   if (devs == NULL || devs[0] == NULL) {
16364     printf ("guestfs_list_devices FAILED\n");
16365     exit (1);
16366   }
16367   if (strncmp (devs[0], "/dev/sd", 7) == 0)
16368     devchar = 's';
16369   else if (strncmp (devs[0], "/dev/hd", 7) == 0)
16370     devchar = 'h';
16371   else {
16372     printf ("guestfs_list_devices returned unexpected string '%s'\n",
16373             devs[0]);
16374     exit (1);
16375   }
16376   for (i = 0; devs[i] != NULL; ++i)
16377     free (devs[i]);
16378   free (devs);
16379
16380   nr_tests = 146;
16381
16382   test_num++;
16383   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
16384   if (test_ntfs_3g_probe_0 () == -1) {
16385     printf ("test_ntfs_3g_probe_0 FAILED\n");
16386     failed++;
16387   }
16388   test_num++;
16389   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
16390   if (test_ntfs_3g_probe_1 () == -1) {
16391     printf ("test_ntfs_3g_probe_1 FAILED\n");
16392     failed++;
16393   }
16394   test_num++;
16395   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16396   if (test_sleep_0 () == -1) {
16397     printf ("test_sleep_0 FAILED\n");
16398     failed++;
16399   }
16400   test_num++;
16401   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16402   if (test_find_0 () == -1) {
16403     printf ("test_find_0 FAILED\n");
16404     failed++;
16405   }
16406   test_num++;
16407   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16408   if (test_find_1 () == -1) {
16409     printf ("test_find_1 FAILED\n");
16410     failed++;
16411   }
16412   test_num++;
16413   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16414   if (test_find_2 () == -1) {
16415     printf ("test_find_2 FAILED\n");
16416     failed++;
16417   }
16418   test_num++;
16419   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16420   if (test_lvresize_0 () == -1) {
16421     printf ("test_lvresize_0 FAILED\n");
16422     failed++;
16423   }
16424   test_num++;
16425   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16426   if (test_zerofree_0 () == -1) {
16427     printf ("test_zerofree_0 FAILED\n");
16428     failed++;
16429   }
16430   test_num++;
16431   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16432   if (test_hexdump_0 () == -1) {
16433     printf ("test_hexdump_0 FAILED\n");
16434     failed++;
16435   }
16436   test_num++;
16437   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16438   if (test_strings_e_0 () == -1) {
16439     printf ("test_strings_e_0 FAILED\n");
16440     failed++;
16441   }
16442   test_num++;
16443   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16444   if (test_strings_e_1 () == -1) {
16445     printf ("test_strings_e_1 FAILED\n");
16446     failed++;
16447   }
16448   test_num++;
16449   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16450   if (test_strings_0 () == -1) {
16451     printf ("test_strings_0 FAILED\n");
16452     failed++;
16453   }
16454   test_num++;
16455   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16456   if (test_strings_1 () == -1) {
16457     printf ("test_strings_1 FAILED\n");
16458     failed++;
16459   }
16460   test_num++;
16461   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16462   if (test_equal_0 () == -1) {
16463     printf ("test_equal_0 FAILED\n");
16464     failed++;
16465   }
16466   test_num++;
16467   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16468   if (test_equal_1 () == -1) {
16469     printf ("test_equal_1 FAILED\n");
16470     failed++;
16471   }
16472   test_num++;
16473   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16474   if (test_equal_2 () == -1) {
16475     printf ("test_equal_2 FAILED\n");
16476     failed++;
16477   }
16478   test_num++;
16479   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16480   if (test_ping_daemon_0 () == -1) {
16481     printf ("test_ping_daemon_0 FAILED\n");
16482     failed++;
16483   }
16484   test_num++;
16485   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16486   if (test_dmesg_0 () == -1) {
16487     printf ("test_dmesg_0 FAILED\n");
16488     failed++;
16489   }
16490   test_num++;
16491   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16492   if (test_drop_caches_0 () == -1) {
16493     printf ("test_drop_caches_0 FAILED\n");
16494     failed++;
16495   }
16496   test_num++;
16497   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16498   if (test_mv_0 () == -1) {
16499     printf ("test_mv_0 FAILED\n");
16500     failed++;
16501   }
16502   test_num++;
16503   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16504   if (test_mv_1 () == -1) {
16505     printf ("test_mv_1 FAILED\n");
16506     failed++;
16507   }
16508   test_num++;
16509   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16510   if (test_cp_a_0 () == -1) {
16511     printf ("test_cp_a_0 FAILED\n");
16512     failed++;
16513   }
16514   test_num++;
16515   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16516   if (test_cp_0 () == -1) {
16517     printf ("test_cp_0 FAILED\n");
16518     failed++;
16519   }
16520   test_num++;
16521   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16522   if (test_cp_1 () == -1) {
16523     printf ("test_cp_1 FAILED\n");
16524     failed++;
16525   }
16526   test_num++;
16527   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16528   if (test_cp_2 () == -1) {
16529     printf ("test_cp_2 FAILED\n");
16530     failed++;
16531   }
16532   test_num++;
16533   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16534   if (test_grub_install_0 () == -1) {
16535     printf ("test_grub_install_0 FAILED\n");
16536     failed++;
16537   }
16538   test_num++;
16539   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16540   if (test_zero_0 () == -1) {
16541     printf ("test_zero_0 FAILED\n");
16542     failed++;
16543   }
16544   test_num++;
16545   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16546   if (test_fsck_0 () == -1) {
16547     printf ("test_fsck_0 FAILED\n");
16548     failed++;
16549   }
16550   test_num++;
16551   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16552   if (test_fsck_1 () == -1) {
16553     printf ("test_fsck_1 FAILED\n");
16554     failed++;
16555   }
16556   test_num++;
16557   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16558   if (test_set_e2uuid_0 () == -1) {
16559     printf ("test_set_e2uuid_0 FAILED\n");
16560     failed++;
16561   }
16562   test_num++;
16563   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16564   if (test_set_e2uuid_1 () == -1) {
16565     printf ("test_set_e2uuid_1 FAILED\n");
16566     failed++;
16567   }
16568   test_num++;
16569   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16570   if (test_set_e2uuid_2 () == -1) {
16571     printf ("test_set_e2uuid_2 FAILED\n");
16572     failed++;
16573   }
16574   test_num++;
16575   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16576   if (test_set_e2uuid_3 () == -1) {
16577     printf ("test_set_e2uuid_3 FAILED\n");
16578     failed++;
16579   }
16580   test_num++;
16581   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16582   if (test_set_e2label_0 () == -1) {
16583     printf ("test_set_e2label_0 FAILED\n");
16584     failed++;
16585   }
16586   test_num++;
16587   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16588   if (test_pvremove_0 () == -1) {
16589     printf ("test_pvremove_0 FAILED\n");
16590     failed++;
16591   }
16592   test_num++;
16593   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16594   if (test_pvremove_1 () == -1) {
16595     printf ("test_pvremove_1 FAILED\n");
16596     failed++;
16597   }
16598   test_num++;
16599   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16600   if (test_pvremove_2 () == -1) {
16601     printf ("test_pvremove_2 FAILED\n");
16602     failed++;
16603   }
16604   test_num++;
16605   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16606   if (test_vgremove_0 () == -1) {
16607     printf ("test_vgremove_0 FAILED\n");
16608     failed++;
16609   }
16610   test_num++;
16611   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16612   if (test_vgremove_1 () == -1) {
16613     printf ("test_vgremove_1 FAILED\n");
16614     failed++;
16615   }
16616   test_num++;
16617   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16618   if (test_lvremove_0 () == -1) {
16619     printf ("test_lvremove_0 FAILED\n");
16620     failed++;
16621   }
16622   test_num++;
16623   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16624   if (test_lvremove_1 () == -1) {
16625     printf ("test_lvremove_1 FAILED\n");
16626     failed++;
16627   }
16628   test_num++;
16629   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16630   if (test_lvremove_2 () == -1) {
16631     printf ("test_lvremove_2 FAILED\n");
16632     failed++;
16633   }
16634   test_num++;
16635   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16636   if (test_mount_ro_0 () == -1) {
16637     printf ("test_mount_ro_0 FAILED\n");
16638     failed++;
16639   }
16640   test_num++;
16641   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16642   if (test_mount_ro_1 () == -1) {
16643     printf ("test_mount_ro_1 FAILED\n");
16644     failed++;
16645   }
16646   test_num++;
16647   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16648   if (test_tgz_in_0 () == -1) {
16649     printf ("test_tgz_in_0 FAILED\n");
16650     failed++;
16651   }
16652   test_num++;
16653   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16654   if (test_tar_in_0 () == -1) {
16655     printf ("test_tar_in_0 FAILED\n");
16656     failed++;
16657   }
16658   test_num++;
16659   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16660   if (test_checksum_0 () == -1) {
16661     printf ("test_checksum_0 FAILED\n");
16662     failed++;
16663   }
16664   test_num++;
16665   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16666   if (test_checksum_1 () == -1) {
16667     printf ("test_checksum_1 FAILED\n");
16668     failed++;
16669   }
16670   test_num++;
16671   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16672   if (test_checksum_2 () == -1) {
16673     printf ("test_checksum_2 FAILED\n");
16674     failed++;
16675   }
16676   test_num++;
16677   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16678   if (test_checksum_3 () == -1) {
16679     printf ("test_checksum_3 FAILED\n");
16680     failed++;
16681   }
16682   test_num++;
16683   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16684   if (test_checksum_4 () == -1) {
16685     printf ("test_checksum_4 FAILED\n");
16686     failed++;
16687   }
16688   test_num++;
16689   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16690   if (test_checksum_5 () == -1) {
16691     printf ("test_checksum_5 FAILED\n");
16692     failed++;
16693   }
16694   test_num++;
16695   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16696   if (test_checksum_6 () == -1) {
16697     printf ("test_checksum_6 FAILED\n");
16698     failed++;
16699   }
16700   test_num++;
16701   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16702   if (test_checksum_7 () == -1) {
16703     printf ("test_checksum_7 FAILED\n");
16704     failed++;
16705   }
16706   test_num++;
16707   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16708   if (test_checksum_8 () == -1) {
16709     printf ("test_checksum_8 FAILED\n");
16710     failed++;
16711   }
16712   test_num++;
16713   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16714   if (test_download_0 () == -1) {
16715     printf ("test_download_0 FAILED\n");
16716     failed++;
16717   }
16718   test_num++;
16719   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16720   if (test_upload_0 () == -1) {
16721     printf ("test_upload_0 FAILED\n");
16722     failed++;
16723   }
16724   test_num++;
16725   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16726   if (test_blockdev_rereadpt_0 () == -1) {
16727     printf ("test_blockdev_rereadpt_0 FAILED\n");
16728     failed++;
16729   }
16730   test_num++;
16731   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16732   if (test_blockdev_flushbufs_0 () == -1) {
16733     printf ("test_blockdev_flushbufs_0 FAILED\n");
16734     failed++;
16735   }
16736   test_num++;
16737   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16738   if (test_blockdev_getsize64_0 () == -1) {
16739     printf ("test_blockdev_getsize64_0 FAILED\n");
16740     failed++;
16741   }
16742   test_num++;
16743   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16744   if (test_blockdev_getsz_0 () == -1) {
16745     printf ("test_blockdev_getsz_0 FAILED\n");
16746     failed++;
16747   }
16748   test_num++;
16749   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16750   if (test_blockdev_getbsz_0 () == -1) {
16751     printf ("test_blockdev_getbsz_0 FAILED\n");
16752     failed++;
16753   }
16754   test_num++;
16755   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16756   if (test_blockdev_getss_0 () == -1) {
16757     printf ("test_blockdev_getss_0 FAILED\n");
16758     failed++;
16759   }
16760   test_num++;
16761   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16762   if (test_blockdev_getro_0 () == -1) {
16763     printf ("test_blockdev_getro_0 FAILED\n");
16764     failed++;
16765   }
16766   test_num++;
16767   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16768   if (test_blockdev_setrw_0 () == -1) {
16769     printf ("test_blockdev_setrw_0 FAILED\n");
16770     failed++;
16771   }
16772   test_num++;
16773   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16774   if (test_blockdev_setro_0 () == -1) {
16775     printf ("test_blockdev_setro_0 FAILED\n");
16776     failed++;
16777   }
16778   test_num++;
16779   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16780   if (test_statvfs_0 () == -1) {
16781     printf ("test_statvfs_0 FAILED\n");
16782     failed++;
16783   }
16784   test_num++;
16785   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16786   if (test_lstat_0 () == -1) {
16787     printf ("test_lstat_0 FAILED\n");
16788     failed++;
16789   }
16790   test_num++;
16791   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16792   if (test_stat_0 () == -1) {
16793     printf ("test_stat_0 FAILED\n");
16794     failed++;
16795   }
16796   test_num++;
16797   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16798   if (test_command_lines_0 () == -1) {
16799     printf ("test_command_lines_0 FAILED\n");
16800     failed++;
16801   }
16802   test_num++;
16803   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16804   if (test_command_lines_1 () == -1) {
16805     printf ("test_command_lines_1 FAILED\n");
16806     failed++;
16807   }
16808   test_num++;
16809   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16810   if (test_command_lines_2 () == -1) {
16811     printf ("test_command_lines_2 FAILED\n");
16812     failed++;
16813   }
16814   test_num++;
16815   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16816   if (test_command_lines_3 () == -1) {
16817     printf ("test_command_lines_3 FAILED\n");
16818     failed++;
16819   }
16820   test_num++;
16821   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16822   if (test_command_lines_4 () == -1) {
16823     printf ("test_command_lines_4 FAILED\n");
16824     failed++;
16825   }
16826   test_num++;
16827   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16828   if (test_command_lines_5 () == -1) {
16829     printf ("test_command_lines_5 FAILED\n");
16830     failed++;
16831   }
16832   test_num++;
16833   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16834   if (test_command_lines_6 () == -1) {
16835     printf ("test_command_lines_6 FAILED\n");
16836     failed++;
16837   }
16838   test_num++;
16839   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16840   if (test_command_lines_7 () == -1) {
16841     printf ("test_command_lines_7 FAILED\n");
16842     failed++;
16843   }
16844   test_num++;
16845   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16846   if (test_command_lines_8 () == -1) {
16847     printf ("test_command_lines_8 FAILED\n");
16848     failed++;
16849   }
16850   test_num++;
16851   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16852   if (test_command_lines_9 () == -1) {
16853     printf ("test_command_lines_9 FAILED\n");
16854     failed++;
16855   }
16856   test_num++;
16857   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16858   if (test_command_lines_10 () == -1) {
16859     printf ("test_command_lines_10 FAILED\n");
16860     failed++;
16861   }
16862   test_num++;
16863   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16864   if (test_command_0 () == -1) {
16865     printf ("test_command_0 FAILED\n");
16866     failed++;
16867   }
16868   test_num++;
16869   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16870   if (test_command_1 () == -1) {
16871     printf ("test_command_1 FAILED\n");
16872     failed++;
16873   }
16874   test_num++;
16875   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16876   if (test_command_2 () == -1) {
16877     printf ("test_command_2 FAILED\n");
16878     failed++;
16879   }
16880   test_num++;
16881   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16882   if (test_command_3 () == -1) {
16883     printf ("test_command_3 FAILED\n");
16884     failed++;
16885   }
16886   test_num++;
16887   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16888   if (test_command_4 () == -1) {
16889     printf ("test_command_4 FAILED\n");
16890     failed++;
16891   }
16892   test_num++;
16893   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16894   if (test_command_5 () == -1) {
16895     printf ("test_command_5 FAILED\n");
16896     failed++;
16897   }
16898   test_num++;
16899   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16900   if (test_command_6 () == -1) {
16901     printf ("test_command_6 FAILED\n");
16902     failed++;
16903   }
16904   test_num++;
16905   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16906   if (test_command_7 () == -1) {
16907     printf ("test_command_7 FAILED\n");
16908     failed++;
16909   }
16910   test_num++;
16911   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16912   if (test_command_8 () == -1) {
16913     printf ("test_command_8 FAILED\n");
16914     failed++;
16915   }
16916   test_num++;
16917   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16918   if (test_command_9 () == -1) {
16919     printf ("test_command_9 FAILED\n");
16920     failed++;
16921   }
16922   test_num++;
16923   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16924   if (test_command_10 () == -1) {
16925     printf ("test_command_10 FAILED\n");
16926     failed++;
16927   }
16928   test_num++;
16929   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16930   if (test_command_11 () == -1) {
16931     printf ("test_command_11 FAILED\n");
16932     failed++;
16933   }
16934   test_num++;
16935   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16936   if (test_file_0 () == -1) {
16937     printf ("test_file_0 FAILED\n");
16938     failed++;
16939   }
16940   test_num++;
16941   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16942   if (test_file_1 () == -1) {
16943     printf ("test_file_1 FAILED\n");
16944     failed++;
16945   }
16946   test_num++;
16947   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16948   if (test_file_2 () == -1) {
16949     printf ("test_file_2 FAILED\n");
16950     failed++;
16951   }
16952   test_num++;
16953   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16954   if (test_umount_all_0 () == -1) {
16955     printf ("test_umount_all_0 FAILED\n");
16956     failed++;
16957   }
16958   test_num++;
16959   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16960   if (test_umount_all_1 () == -1) {
16961     printf ("test_umount_all_1 FAILED\n");
16962     failed++;
16963   }
16964   test_num++;
16965   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16966   if (test_mounts_0 () == -1) {
16967     printf ("test_mounts_0 FAILED\n");
16968     failed++;
16969   }
16970   test_num++;
16971   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16972   if (test_umount_0 () == -1) {
16973     printf ("test_umount_0 FAILED\n");
16974     failed++;
16975   }
16976   test_num++;
16977   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16978   if (test_umount_1 () == -1) {
16979     printf ("test_umount_1 FAILED\n");
16980     failed++;
16981   }
16982   test_num++;
16983   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16984   if (test_write_file_0 () == -1) {
16985     printf ("test_write_file_0 FAILED\n");
16986     failed++;
16987   }
16988   test_num++;
16989   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16990   if (test_write_file_1 () == -1) {
16991     printf ("test_write_file_1 FAILED\n");
16992     failed++;
16993   }
16994   test_num++;
16995   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16996   if (test_write_file_2 () == -1) {
16997     printf ("test_write_file_2 FAILED\n");
16998     failed++;
16999   }
17000   test_num++;
17001   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
17002   if (test_write_file_3 () == -1) {
17003     printf ("test_write_file_3 FAILED\n");
17004     failed++;
17005   }
17006   test_num++;
17007   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
17008   if (test_write_file_4 () == -1) {
17009     printf ("test_write_file_4 FAILED\n");
17010     failed++;
17011   }
17012   test_num++;
17013   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
17014   if (test_write_file_5 () == -1) {
17015     printf ("test_write_file_5 FAILED\n");
17016     failed++;
17017   }
17018   test_num++;
17019   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
17020   if (test_mkfs_0 () == -1) {
17021     printf ("test_mkfs_0 FAILED\n");
17022     failed++;
17023   }
17024   test_num++;
17025   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
17026   if (test_lvcreate_0 () == -1) {
17027     printf ("test_lvcreate_0 FAILED\n");
17028     failed++;
17029   }
17030   test_num++;
17031   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
17032   if (test_vgcreate_0 () == -1) {
17033     printf ("test_vgcreate_0 FAILED\n");
17034     failed++;
17035   }
17036   test_num++;
17037   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17038   if (test_pvcreate_0 () == -1) {
17039     printf ("test_pvcreate_0 FAILED\n");
17040     failed++;
17041   }
17042   test_num++;
17043   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17044   if (test_is_dir_0 () == -1) {
17045     printf ("test_is_dir_0 FAILED\n");
17046     failed++;
17047   }
17048   test_num++;
17049   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
17050   if (test_is_dir_1 () == -1) {
17051     printf ("test_is_dir_1 FAILED\n");
17052     failed++;
17053   }
17054   test_num++;
17055   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
17056   if (test_is_file_0 () == -1) {
17057     printf ("test_is_file_0 FAILED\n");
17058     failed++;
17059   }
17060   test_num++;
17061   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
17062   if (test_is_file_1 () == -1) {
17063     printf ("test_is_file_1 FAILED\n");
17064     failed++;
17065   }
17066   test_num++;
17067   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
17068   if (test_exists_0 () == -1) {
17069     printf ("test_exists_0 FAILED\n");
17070     failed++;
17071   }
17072   test_num++;
17073   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
17074   if (test_exists_1 () == -1) {
17075     printf ("test_exists_1 FAILED\n");
17076     failed++;
17077   }
17078   test_num++;
17079   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
17080   if (test_mkdir_p_0 () == -1) {
17081     printf ("test_mkdir_p_0 FAILED\n");
17082     failed++;
17083   }
17084   test_num++;
17085   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
17086   if (test_mkdir_p_1 () == -1) {
17087     printf ("test_mkdir_p_1 FAILED\n");
17088     failed++;
17089   }
17090   test_num++;
17091   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
17092   if (test_mkdir_p_2 () == -1) {
17093     printf ("test_mkdir_p_2 FAILED\n");
17094     failed++;
17095   }
17096   test_num++;
17097   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
17098   if (test_mkdir_p_3 () == -1) {
17099     printf ("test_mkdir_p_3 FAILED\n");
17100     failed++;
17101   }
17102   test_num++;
17103   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
17104   if (test_mkdir_p_4 () == -1) {
17105     printf ("test_mkdir_p_4 FAILED\n");
17106     failed++;
17107   }
17108   test_num++;
17109   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
17110   if (test_mkdir_0 () == -1) {
17111     printf ("test_mkdir_0 FAILED\n");
17112     failed++;
17113   }
17114   test_num++;
17115   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
17116   if (test_mkdir_1 () == -1) {
17117     printf ("test_mkdir_1 FAILED\n");
17118     failed++;
17119   }
17120   test_num++;
17121   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
17122   if (test_rm_rf_0 () == -1) {
17123     printf ("test_rm_rf_0 FAILED\n");
17124     failed++;
17125   }
17126   test_num++;
17127   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
17128   if (test_rmdir_0 () == -1) {
17129     printf ("test_rmdir_0 FAILED\n");
17130     failed++;
17131   }
17132   test_num++;
17133   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
17134   if (test_rmdir_1 () == -1) {
17135     printf ("test_rmdir_1 FAILED\n");
17136     failed++;
17137   }
17138   test_num++;
17139   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
17140   if (test_rmdir_2 () == -1) {
17141     printf ("test_rmdir_2 FAILED\n");
17142     failed++;
17143   }
17144   test_num++;
17145   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
17146   if (test_rm_0 () == -1) {
17147     printf ("test_rm_0 FAILED\n");
17148     failed++;
17149   }
17150   test_num++;
17151   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
17152   if (test_rm_1 () == -1) {
17153     printf ("test_rm_1 FAILED\n");
17154     failed++;
17155   }
17156   test_num++;
17157   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
17158   if (test_rm_2 () == -1) {
17159     printf ("test_rm_2 FAILED\n");
17160     failed++;
17161   }
17162   test_num++;
17163   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
17164   if (test_read_lines_0 () == -1) {
17165     printf ("test_read_lines_0 FAILED\n");
17166     failed++;
17167   }
17168   test_num++;
17169   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
17170   if (test_read_lines_1 () == -1) {
17171     printf ("test_read_lines_1 FAILED\n");
17172     failed++;
17173   }
17174   test_num++;
17175   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
17176   if (test_lvs_0 () == -1) {
17177     printf ("test_lvs_0 FAILED\n");
17178     failed++;
17179   }
17180   test_num++;
17181   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
17182   if (test_lvs_1 () == -1) {
17183     printf ("test_lvs_1 FAILED\n");
17184     failed++;
17185   }
17186   test_num++;
17187   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
17188   if (test_vgs_0 () == -1) {
17189     printf ("test_vgs_0 FAILED\n");
17190     failed++;
17191   }
17192   test_num++;
17193   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17194   if (test_vgs_1 () == -1) {
17195     printf ("test_vgs_1 FAILED\n");
17196     failed++;
17197   }
17198   test_num++;
17199   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17200   if (test_pvs_0 () == -1) {
17201     printf ("test_pvs_0 FAILED\n");
17202     failed++;
17203   }
17204   test_num++;
17205   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17206   if (test_pvs_1 () == -1) {
17207     printf ("test_pvs_1 FAILED\n");
17208     failed++;
17209   }
17210   test_num++;
17211   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17212   if (test_list_partitions_0 () == -1) {
17213     printf ("test_list_partitions_0 FAILED\n");
17214     failed++;
17215   }
17216   test_num++;
17217   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17218   if (test_list_partitions_1 () == -1) {
17219     printf ("test_list_partitions_1 FAILED\n");
17220     failed++;
17221   }
17222   test_num++;
17223   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17224   if (test_list_devices_0 () == -1) {
17225     printf ("test_list_devices_0 FAILED\n");
17226     failed++;
17227   }
17228   test_num++;
17229   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17230   if (test_ls_0 () == -1) {
17231     printf ("test_ls_0 FAILED\n");
17232     failed++;
17233   }
17234   test_num++;
17235   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17236   if (test_cat_0 () == -1) {
17237     printf ("test_cat_0 FAILED\n");
17238     failed++;
17239   }
17240   test_num++;
17241   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17242   if (test_touch_0 () == -1) {
17243     printf ("test_touch_0 FAILED\n");
17244     failed++;
17245   }
17246   test_num++;
17247   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17248   if (test_sync_0 () == -1) {
17249     printf ("test_sync_0 FAILED\n");
17250     failed++;
17251   }
17252   test_num++;
17253   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17254   if (test_mount_0 () == -1) {
17255     printf ("test_mount_0 FAILED\n");
17256     failed++;
17257   }
17258
17259   guestfs_close (g);
17260   unlink ("test1.img");
17261   unlink ("test2.img");
17262   unlink ("test3.img");
17263
17264   if (failed > 0) {
17265     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
17266     exit (1);
17267   }
17268
17269   exit (0);
17270 }