capitests/tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 static void print_error (guestfs_h *g, void *data, const char *msg)
  35 {
  36   if (!suppress_error)
  37     fprintf (stderr, "%s\n", msg);
  38 }
  39
  40 static void print_strings (char * const * const argv)
  41 {
  42   int argc;
  43
  44   for (argc = 0; argv[argc] != NULL; ++argc)
  45     printf ("\t%s\n", argv[argc]);
  46 }
  47
  48 /*
  49 static void print_table (char * const * const argv)
  50 {
  51   int i;
  52
  53   for (i = 0; argv[i] != NULL; i += 2)
  54     printf ("%s: %s\n", argv[i], argv[i+1]);
  55 }
  56 */
  57
  58 static void no_test_warnings (void)
  59 {
  60   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  61   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  62   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  63   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  64   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  65   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
 156   fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
 157 }
 158
 159 static int test_initrd_list_0_skip (void)
 160 {
 161   const char *str;
 162
 163   str = getenv ("TEST_ONLY");
 164   if (str)
 165     return strstr (str, "initrd_list") == NULL;
 166   str = getenv ("SKIP_TEST_INITRD_LIST_0");
 167   if (str && strcmp (str, "1") == 0) return 1;
 168   str = getenv ("SKIP_TEST_INITRD_LIST");
 169   if (str && strcmp (str, "1") == 0) return 1;
 170   return 0;
 171 }
 172
 173 static int test_initrd_list_0 (void)
 174 {
 175   if (test_initrd_list_0_skip ()) {
 176     printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
 177     return 0;
 178   }
 179
 180   /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
 181   {
 182     char device[] = "/dev/sda";
 183     int r;
 184     suppress_error = 0;
 185     r = guestfs_blockdev_setrw (g, device);
 186     if (r == -1)
 187       return -1;
 188   }
 189   {
 190     int r;
 191     suppress_error = 0;
 192     r = guestfs_umount_all (g);
 193     if (r == -1)
 194       return -1;
 195   }
 196   {
 197     int r;
 198     suppress_error = 0;
 199     r = guestfs_lvm_remove_all (g);
 200     if (r == -1)
 201       return -1;
 202   }
 203   {
 204     char device[] = "/dev/sda";
 205     char lines_0[] = ",";
 206     char *lines[] = {
 207       lines_0,
 208       NULL
 209     };
 210     int r;
 211     suppress_error = 0;
 212     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 213     if (r == -1)
 214       return -1;
 215   }
 216   {
 217     char fstype[] = "ext2";
 218     char device[] = "/dev/sda1";
 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     char mountpoint[] = "/";
 228     int r;
 229     suppress_error = 0;
 230     r = guestfs_mount (g, device, mountpoint);
 231     if (r == -1)
 232       return -1;
 233   }
 234   /* TestOutputList for initrd_list (0) */
 235   {
 236     char options[] = "ro";
 237     char vfstype[] = "squashfs";
 238     char device[] = "/dev/sdd";
 239     char mountpoint[] = "/";
 240     int r;
 241     suppress_error = 0;
 242     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 243     if (r == -1)
 244       return -1;
 245   }
 246   {
 247     char path[] = "/initrd";
 248     char **r;
 249     int i;
 250     suppress_error = 0;
 251     r = guestfs_initrd_list (g, path);
 252     if (r == NULL)
 253       return -1;
 254     if (!r[0]) {
 255       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 256       print_strings (r);
 257       return -1;
 258     }
 259     {
 260       char expected[] = "empty";
 261       if (strcmp (r[0], expected) != 0) {
 262         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 263         return -1;
 264       }
 265     }
 266     if (!r[1]) {
 267       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 268       print_strings (r);
 269       return -1;
 270     }
 271     {
 272       char expected[] = "known-1";
 273       if (strcmp (r[1], expected) != 0) {
 274         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 275         return -1;
 276       }
 277     }
 278     if (!r[2]) {
 279       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 280       print_strings (r);
 281       return -1;
 282     }
 283     {
 284       char expected[] = "known-2";
 285       if (strcmp (r[2], expected) != 0) {
 286         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 287         return -1;
 288       }
 289     }
 290     if (!r[3]) {
 291       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 292       print_strings (r);
 293       return -1;
 294     }
 295     {
 296       char expected[] = "known-3";
 297       if (strcmp (r[3], expected) != 0) {
 298         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 299         return -1;
 300       }
 301     }
 302     if (r[4] != NULL) {
 303       fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
 304       print_strings (r);
 305       return -1;
 306     }
 307     for (i = 0; r[i] != NULL; ++i)
 308       free (r[i]);
 309     free (r);
 310   }
 311   return 0;
 312 }
 313
 314 static int test_du_0_skip (void)
 315 {
 316   const char *str;
 317
 318   str = getenv ("TEST_ONLY");
 319   if (str)
 320     return strstr (str, "du") == NULL;
 321   str = getenv ("SKIP_TEST_DU_0");
 322   if (str && strcmp (str, "1") == 0) return 1;
 323   str = getenv ("SKIP_TEST_DU");
 324   if (str && strcmp (str, "1") == 0) return 1;
 325   return 0;
 326 }
 327
 328 static int test_du_0 (void)
 329 {
 330   if (test_du_0_skip ()) {
 331     printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
 332     return 0;
 333   }
 334
 335   /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
 336   {
 337     char device[] = "/dev/sda";
 338     int r;
 339     suppress_error = 0;
 340     r = guestfs_blockdev_setrw (g, device);
 341     if (r == -1)
 342       return -1;
 343   }
 344   {
 345     int r;
 346     suppress_error = 0;
 347     r = guestfs_umount_all (g);
 348     if (r == -1)
 349       return -1;
 350   }
 351   {
 352     int r;
 353     suppress_error = 0;
 354     r = guestfs_lvm_remove_all (g);
 355     if (r == -1)
 356       return -1;
 357   }
 358   {
 359     char device[] = "/dev/sda";
 360     char lines_0[] = ",";
 361     char *lines[] = {
 362       lines_0,
 363       NULL
 364     };
 365     int r;
 366     suppress_error = 0;
 367     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 368     if (r == -1)
 369       return -1;
 370   }
 371   {
 372     char fstype[] = "ext2";
 373     char device[] = "/dev/sda1";
 374     int r;
 375     suppress_error = 0;
 376     r = guestfs_mkfs (g, fstype, device);
 377     if (r == -1)
 378       return -1;
 379   }
 380   {
 381     char device[] = "/dev/sda1";
 382     char mountpoint[] = "/";
 383     int r;
 384     suppress_error = 0;
 385     r = guestfs_mount (g, device, mountpoint);
 386     if (r == -1)
 387       return -1;
 388   }
 389   /* TestOutputInt for du (0) */
 390   {
 391     char path[] = "/p";
 392     int r;
 393     suppress_error = 0;
 394     r = guestfs_mkdir (g, path);
 395     if (r == -1)
 396       return -1;
 397   }
 398   {
 399     char path[] = "/p";
 400     int64_t r;
 401     suppress_error = 0;
 402     r = guestfs_du (g, path);
 403     if (r == -1)
 404       return -1;
 405     if (r != 1) {
 406       fprintf (stderr, "test_du_0: expected 1 but got %d\n",               (int) r);
 407       return -1;
 408     }
 409   }
 410   return 0;
 411 }
 412
 413 static int test_tail_n_0_skip (void)
 414 {
 415   const char *str;
 416
 417   str = getenv ("TEST_ONLY");
 418   if (str)
 419     return strstr (str, "tail_n") == NULL;
 420   str = getenv ("SKIP_TEST_TAIL_N_0");
 421   if (str && strcmp (str, "1") == 0) return 1;
 422   str = getenv ("SKIP_TEST_TAIL_N");
 423   if (str && strcmp (str, "1") == 0) return 1;
 424   return 0;
 425 }
 426
 427 static int test_tail_n_0 (void)
 428 {
 429   if (test_tail_n_0_skip ()) {
 430     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
 431     return 0;
 432   }
 433
 434   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
 435   {
 436     char device[] = "/dev/sda";
 437     int r;
 438     suppress_error = 0;
 439     r = guestfs_blockdev_setrw (g, device);
 440     if (r == -1)
 441       return -1;
 442   }
 443   {
 444     int r;
 445     suppress_error = 0;
 446     r = guestfs_umount_all (g);
 447     if (r == -1)
 448       return -1;
 449   }
 450   {
 451     int r;
 452     suppress_error = 0;
 453     r = guestfs_lvm_remove_all (g);
 454     if (r == -1)
 455       return -1;
 456   }
 457   {
 458     char device[] = "/dev/sda";
 459     char lines_0[] = ",";
 460     char *lines[] = {
 461       lines_0,
 462       NULL
 463     };
 464     int r;
 465     suppress_error = 0;
 466     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 467     if (r == -1)
 468       return -1;
 469   }
 470   {
 471     char fstype[] = "ext2";
 472     char device[] = "/dev/sda1";
 473     int r;
 474     suppress_error = 0;
 475     r = guestfs_mkfs (g, fstype, device);
 476     if (r == -1)
 477       return -1;
 478   }
 479   {
 480     char device[] = "/dev/sda1";
 481     char mountpoint[] = "/";
 482     int r;
 483     suppress_error = 0;
 484     r = guestfs_mount (g, device, mountpoint);
 485     if (r == -1)
 486       return -1;
 487   }
 488   /* TestOutputList for tail_n (0) */
 489   {
 490     char options[] = "ro";
 491     char vfstype[] = "squashfs";
 492     char device[] = "/dev/sdd";
 493     char mountpoint[] = "/";
 494     int r;
 495     suppress_error = 0;
 496     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 497     if (r == -1)
 498       return -1;
 499   }
 500   {
 501     char path[] = "/10klines";
 502     char **r;
 503     int i;
 504     suppress_error = 0;
 505     r = guestfs_tail_n (g, 3, path);
 506     if (r == NULL)
 507       return -1;
 508     if (!r[0]) {
 509       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 510       print_strings (r);
 511       return -1;
 512     }
 513     {
 514       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 515       if (strcmp (r[0], expected) != 0) {
 516         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 517         return -1;
 518       }
 519     }
 520     if (!r[1]) {
 521       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 522       print_strings (r);
 523       return -1;
 524     }
 525     {
 526       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 527       if (strcmp (r[1], expected) != 0) {
 528         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 529         return -1;
 530       }
 531     }
 532     if (!r[2]) {
 533       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 534       print_strings (r);
 535       return -1;
 536     }
 537     {
 538       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 539       if (strcmp (r[2], expected) != 0) {
 540         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 541         return -1;
 542       }
 543     }
 544     if (r[3] != NULL) {
 545       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
 546       print_strings (r);
 547       return -1;
 548     }
 549     for (i = 0; r[i] != NULL; ++i)
 550       free (r[i]);
 551     free (r);
 552   }
 553   return 0;
 554 }
 555
 556 static int test_tail_n_1_skip (void)
 557 {
 558   const char *str;
 559
 560   str = getenv ("TEST_ONLY");
 561   if (str)
 562     return strstr (str, "tail_n") == NULL;
 563   str = getenv ("SKIP_TEST_TAIL_N_1");
 564   if (str && strcmp (str, "1") == 0) return 1;
 565   str = getenv ("SKIP_TEST_TAIL_N");
 566   if (str && strcmp (str, "1") == 0) return 1;
 567   return 0;
 568 }
 569
 570 static int test_tail_n_1 (void)
 571 {
 572   if (test_tail_n_1_skip ()) {
 573     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
 574     return 0;
 575   }
 576
 577   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
 578   {
 579     char device[] = "/dev/sda";
 580     int r;
 581     suppress_error = 0;
 582     r = guestfs_blockdev_setrw (g, device);
 583     if (r == -1)
 584       return -1;
 585   }
 586   {
 587     int r;
 588     suppress_error = 0;
 589     r = guestfs_umount_all (g);
 590     if (r == -1)
 591       return -1;
 592   }
 593   {
 594     int r;
 595     suppress_error = 0;
 596     r = guestfs_lvm_remove_all (g);
 597     if (r == -1)
 598       return -1;
 599   }
 600   {
 601     char device[] = "/dev/sda";
 602     char lines_0[] = ",";
 603     char *lines[] = {
 604       lines_0,
 605       NULL
 606     };
 607     int r;
 608     suppress_error = 0;
 609     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 610     if (r == -1)
 611       return -1;
 612   }
 613   {
 614     char fstype[] = "ext2";
 615     char device[] = "/dev/sda1";
 616     int r;
 617     suppress_error = 0;
 618     r = guestfs_mkfs (g, fstype, device);
 619     if (r == -1)
 620       return -1;
 621   }
 622   {
 623     char device[] = "/dev/sda1";
 624     char mountpoint[] = "/";
 625     int r;
 626     suppress_error = 0;
 627     r = guestfs_mount (g, device, mountpoint);
 628     if (r == -1)
 629       return -1;
 630   }
 631   /* TestOutputList for tail_n (1) */
 632   {
 633     char options[] = "ro";
 634     char vfstype[] = "squashfs";
 635     char device[] = "/dev/sdd";
 636     char mountpoint[] = "/";
 637     int r;
 638     suppress_error = 0;
 639     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 640     if (r == -1)
 641       return -1;
 642   }
 643   {
 644     char path[] = "/10klines";
 645     char **r;
 646     int i;
 647     suppress_error = 0;
 648     r = guestfs_tail_n (g, -9998, path);
 649     if (r == NULL)
 650       return -1;
 651     if (!r[0]) {
 652       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 653       print_strings (r);
 654       return -1;
 655     }
 656     {
 657       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 658       if (strcmp (r[0], expected) != 0) {
 659         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 660         return -1;
 661       }
 662     }
 663     if (!r[1]) {
 664       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 665       print_strings (r);
 666       return -1;
 667     }
 668     {
 669       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 670       if (strcmp (r[1], expected) != 0) {
 671         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 672         return -1;
 673       }
 674     }
 675     if (!r[2]) {
 676       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 677       print_strings (r);
 678       return -1;
 679     }
 680     {
 681       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 682       if (strcmp (r[2], expected) != 0) {
 683         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 684         return -1;
 685       }
 686     }
 687     if (r[3] != NULL) {
 688       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
 689       print_strings (r);
 690       return -1;
 691     }
 692     for (i = 0; r[i] != NULL; ++i)
 693       free (r[i]);
 694     free (r);
 695   }
 696   return 0;
 697 }
 698
 699 static int test_tail_n_2_skip (void)
 700 {
 701   const char *str;
 702
 703   str = getenv ("TEST_ONLY");
 704   if (str)
 705     return strstr (str, "tail_n") == NULL;
 706   str = getenv ("SKIP_TEST_TAIL_N_2");
 707   if (str && strcmp (str, "1") == 0) return 1;
 708   str = getenv ("SKIP_TEST_TAIL_N");
 709   if (str && strcmp (str, "1") == 0) return 1;
 710   return 0;
 711 }
 712
 713 static int test_tail_n_2 (void)
 714 {
 715   if (test_tail_n_2_skip ()) {
 716     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
 717     return 0;
 718   }
 719
 720   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
 721   {
 722     char device[] = "/dev/sda";
 723     int r;
 724     suppress_error = 0;
 725     r = guestfs_blockdev_setrw (g, device);
 726     if (r == -1)
 727       return -1;
 728   }
 729   {
 730     int r;
 731     suppress_error = 0;
 732     r = guestfs_umount_all (g);
 733     if (r == -1)
 734       return -1;
 735   }
 736   {
 737     int r;
 738     suppress_error = 0;
 739     r = guestfs_lvm_remove_all (g);
 740     if (r == -1)
 741       return -1;
 742   }
 743   {
 744     char device[] = "/dev/sda";
 745     char lines_0[] = ",";
 746     char *lines[] = {
 747       lines_0,
 748       NULL
 749     };
 750     int r;
 751     suppress_error = 0;
 752     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 753     if (r == -1)
 754       return -1;
 755   }
 756   {
 757     char fstype[] = "ext2";
 758     char device[] = "/dev/sda1";
 759     int r;
 760     suppress_error = 0;
 761     r = guestfs_mkfs (g, fstype, device);
 762     if (r == -1)
 763       return -1;
 764   }
 765   {
 766     char device[] = "/dev/sda1";
 767     char mountpoint[] = "/";
 768     int r;
 769     suppress_error = 0;
 770     r = guestfs_mount (g, device, mountpoint);
 771     if (r == -1)
 772       return -1;
 773   }
 774   /* TestOutputList for tail_n (2) */
 775   {
 776     char options[] = "ro";
 777     char vfstype[] = "squashfs";
 778     char device[] = "/dev/sdd";
 779     char mountpoint[] = "/";
 780     int r;
 781     suppress_error = 0;
 782     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 783     if (r == -1)
 784       return -1;
 785   }
 786   {
 787     char path[] = "/10klines";
 788     char **r;
 789     int i;
 790     suppress_error = 0;
 791     r = guestfs_tail_n (g, 0, path);
 792     if (r == NULL)
 793       return -1;
 794     if (r[0] != NULL) {
 795       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
 796       print_strings (r);
 797       return -1;
 798     }
 799     for (i = 0; r[i] != NULL; ++i)
 800       free (r[i]);
 801     free (r);
 802   }
 803   return 0;
 804 }
 805
 806 static int test_tail_0_skip (void)
 807 {
 808   const char *str;
 809
 810   str = getenv ("TEST_ONLY");
 811   if (str)
 812     return strstr (str, "tail") == NULL;
 813   str = getenv ("SKIP_TEST_TAIL_0");
 814   if (str && strcmp (str, "1") == 0) return 1;
 815   str = getenv ("SKIP_TEST_TAIL");
 816   if (str && strcmp (str, "1") == 0) return 1;
 817   return 0;
 818 }
 819
 820 static int test_tail_0 (void)
 821 {
 822   if (test_tail_0_skip ()) {
 823     printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
 824     return 0;
 825   }
 826
 827   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
 828   {
 829     char device[] = "/dev/sda";
 830     int r;
 831     suppress_error = 0;
 832     r = guestfs_blockdev_setrw (g, device);
 833     if (r == -1)
 834       return -1;
 835   }
 836   {
 837     int r;
 838     suppress_error = 0;
 839     r = guestfs_umount_all (g);
 840     if (r == -1)
 841       return -1;
 842   }
 843   {
 844     int r;
 845     suppress_error = 0;
 846     r = guestfs_lvm_remove_all (g);
 847     if (r == -1)
 848       return -1;
 849   }
 850   {
 851     char device[] = "/dev/sda";
 852     char lines_0[] = ",";
 853     char *lines[] = {
 854       lines_0,
 855       NULL
 856     };
 857     int r;
 858     suppress_error = 0;
 859     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 860     if (r == -1)
 861       return -1;
 862   }
 863   {
 864     char fstype[] = "ext2";
 865     char device[] = "/dev/sda1";
 866     int r;
 867     suppress_error = 0;
 868     r = guestfs_mkfs (g, fstype, device);
 869     if (r == -1)
 870       return -1;
 871   }
 872   {
 873     char device[] = "/dev/sda1";
 874     char mountpoint[] = "/";
 875     int r;
 876     suppress_error = 0;
 877     r = guestfs_mount (g, device, mountpoint);
 878     if (r == -1)
 879       return -1;
 880   }
 881   /* TestOutputList for tail (0) */
 882   {
 883     char options[] = "ro";
 884     char vfstype[] = "squashfs";
 885     char device[] = "/dev/sdd";
 886     char mountpoint[] = "/";
 887     int r;
 888     suppress_error = 0;
 889     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 890     if (r == -1)
 891       return -1;
 892   }
 893   {
 894     char path[] = "/10klines";
 895     char **r;
 896     int i;
 897     suppress_error = 0;
 898     r = guestfs_tail (g, path);
 899     if (r == NULL)
 900       return -1;
 901     if (!r[0]) {
 902       fprintf (stderr, "test_tail_0: short list returned from command\n");
 903       print_strings (r);
 904       return -1;
 905     }
 906     {
 907       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
 908       if (strcmp (r[0], expected) != 0) {
 909         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 910         return -1;
 911       }
 912     }
 913     if (!r[1]) {
 914       fprintf (stderr, "test_tail_0: short list returned from command\n");
 915       print_strings (r);
 916       return -1;
 917     }
 918     {
 919       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
 920       if (strcmp (r[1], expected) != 0) {
 921         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 922         return -1;
 923       }
 924     }
 925     if (!r[2]) {
 926       fprintf (stderr, "test_tail_0: short list returned from command\n");
 927       print_strings (r);
 928       return -1;
 929     }
 930     {
 931       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
 932       if (strcmp (r[2], expected) != 0) {
 933         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 934         return -1;
 935       }
 936     }
 937     if (!r[3]) {
 938       fprintf (stderr, "test_tail_0: short list returned from command\n");
 939       print_strings (r);
 940       return -1;
 941     }
 942     {
 943       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
 944       if (strcmp (r[3], expected) != 0) {
 945         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 946         return -1;
 947       }
 948     }
 949     if (!r[4]) {
 950       fprintf (stderr, "test_tail_0: short list returned from command\n");
 951       print_strings (r);
 952       return -1;
 953     }
 954     {
 955       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
 956       if (strcmp (r[4], expected) != 0) {
 957         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
 958         return -1;
 959       }
 960     }
 961     if (!r[5]) {
 962       fprintf (stderr, "test_tail_0: short list returned from command\n");
 963       print_strings (r);
 964       return -1;
 965     }
 966     {
 967       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
 968       if (strcmp (r[5], expected) != 0) {
 969         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
 970         return -1;
 971       }
 972     }
 973     if (!r[6]) {
 974       fprintf (stderr, "test_tail_0: short list returned from command\n");
 975       print_strings (r);
 976       return -1;
 977     }
 978     {
 979       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
 980       if (strcmp (r[6], expected) != 0) {
 981         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
 982         return -1;
 983       }
 984     }
 985     if (!r[7]) {
 986       fprintf (stderr, "test_tail_0: short list returned from command\n");
 987       print_strings (r);
 988       return -1;
 989     }
 990     {
 991       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 992       if (strcmp (r[7], expected) != 0) {
 993         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
 994         return -1;
 995       }
 996     }
 997     if (!r[8]) {
 998       fprintf (stderr, "test_tail_0: short list returned from command\n");
 999       print_strings (r);
1000       return -1;
1001     }
1002     {
1003       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1004       if (strcmp (r[8], expected) != 0) {
1005         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1006         return -1;
1007       }
1008     }
1009     if (!r[9]) {
1010       fprintf (stderr, "test_tail_0: short list returned from command\n");
1011       print_strings (r);
1012       return -1;
1013     }
1014     {
1015       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1016       if (strcmp (r[9], expected) != 0) {
1017         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1018         return -1;
1019       }
1020     }
1021     if (r[10] != NULL) {
1022       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1023       print_strings (r);
1024       return -1;
1025     }
1026     for (i = 0; r[i] != NULL; ++i)
1027       free (r[i]);
1028     free (r);
1029   }
1030   return 0;
1031 }
1032
1033 static int test_head_n_0_skip (void)
1034 {
1035   const char *str;
1036
1037   str = getenv ("TEST_ONLY");
1038   if (str)
1039     return strstr (str, "head_n") == NULL;
1040   str = getenv ("SKIP_TEST_HEAD_N_0");
1041   if (str && strcmp (str, "1") == 0) return 1;
1042   str = getenv ("SKIP_TEST_HEAD_N");
1043   if (str && strcmp (str, "1") == 0) return 1;
1044   return 0;
1045 }
1046
1047 static int test_head_n_0 (void)
1048 {
1049   if (test_head_n_0_skip ()) {
1050     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1051     return 0;
1052   }
1053
1054   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1055   {
1056     char device[] = "/dev/sda";
1057     int r;
1058     suppress_error = 0;
1059     r = guestfs_blockdev_setrw (g, device);
1060     if (r == -1)
1061       return -1;
1062   }
1063   {
1064     int r;
1065     suppress_error = 0;
1066     r = guestfs_umount_all (g);
1067     if (r == -1)
1068       return -1;
1069   }
1070   {
1071     int r;
1072     suppress_error = 0;
1073     r = guestfs_lvm_remove_all (g);
1074     if (r == -1)
1075       return -1;
1076   }
1077   {
1078     char device[] = "/dev/sda";
1079     char lines_0[] = ",";
1080     char *lines[] = {
1081       lines_0,
1082       NULL
1083     };
1084     int r;
1085     suppress_error = 0;
1086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1087     if (r == -1)
1088       return -1;
1089   }
1090   {
1091     char fstype[] = "ext2";
1092     char device[] = "/dev/sda1";
1093     int r;
1094     suppress_error = 0;
1095     r = guestfs_mkfs (g, fstype, device);
1096     if (r == -1)
1097       return -1;
1098   }
1099   {
1100     char device[] = "/dev/sda1";
1101     char mountpoint[] = "/";
1102     int r;
1103     suppress_error = 0;
1104     r = guestfs_mount (g, device, mountpoint);
1105     if (r == -1)
1106       return -1;
1107   }
1108   /* TestOutputList for head_n (0) */
1109   {
1110     char options[] = "ro";
1111     char vfstype[] = "squashfs";
1112     char device[] = "/dev/sdd";
1113     char mountpoint[] = "/";
1114     int r;
1115     suppress_error = 0;
1116     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1117     if (r == -1)
1118       return -1;
1119   }
1120   {
1121     char path[] = "/10klines";
1122     char **r;
1123     int i;
1124     suppress_error = 0;
1125     r = guestfs_head_n (g, 3, path);
1126     if (r == NULL)
1127       return -1;
1128     if (!r[0]) {
1129       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1130       print_strings (r);
1131       return -1;
1132     }
1133     {
1134       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1135       if (strcmp (r[0], expected) != 0) {
1136         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1137         return -1;
1138       }
1139     }
1140     if (!r[1]) {
1141       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1142       print_strings (r);
1143       return -1;
1144     }
1145     {
1146       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1147       if (strcmp (r[1], expected) != 0) {
1148         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1149         return -1;
1150       }
1151     }
1152     if (!r[2]) {
1153       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1154       print_strings (r);
1155       return -1;
1156     }
1157     {
1158       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1159       if (strcmp (r[2], expected) != 0) {
1160         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1161         return -1;
1162       }
1163     }
1164     if (r[3] != NULL) {
1165       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1166       print_strings (r);
1167       return -1;
1168     }
1169     for (i = 0; r[i] != NULL; ++i)
1170       free (r[i]);
1171     free (r);
1172   }
1173   return 0;
1174 }
1175
1176 static int test_head_n_1_skip (void)
1177 {
1178   const char *str;
1179
1180   str = getenv ("TEST_ONLY");
1181   if (str)
1182     return strstr (str, "head_n") == NULL;
1183   str = getenv ("SKIP_TEST_HEAD_N_1");
1184   if (str && strcmp (str, "1") == 0) return 1;
1185   str = getenv ("SKIP_TEST_HEAD_N");
1186   if (str && strcmp (str, "1") == 0) return 1;
1187   return 0;
1188 }
1189
1190 static int test_head_n_1 (void)
1191 {
1192   if (test_head_n_1_skip ()) {
1193     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1194     return 0;
1195   }
1196
1197   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1198   {
1199     char device[] = "/dev/sda";
1200     int r;
1201     suppress_error = 0;
1202     r = guestfs_blockdev_setrw (g, device);
1203     if (r == -1)
1204       return -1;
1205   }
1206   {
1207     int r;
1208     suppress_error = 0;
1209     r = guestfs_umount_all (g);
1210     if (r == -1)
1211       return -1;
1212   }
1213   {
1214     int r;
1215     suppress_error = 0;
1216     r = guestfs_lvm_remove_all (g);
1217     if (r == -1)
1218       return -1;
1219   }
1220   {
1221     char device[] = "/dev/sda";
1222     char lines_0[] = ",";
1223     char *lines[] = {
1224       lines_0,
1225       NULL
1226     };
1227     int r;
1228     suppress_error = 0;
1229     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1230     if (r == -1)
1231       return -1;
1232   }
1233   {
1234     char fstype[] = "ext2";
1235     char device[] = "/dev/sda1";
1236     int r;
1237     suppress_error = 0;
1238     r = guestfs_mkfs (g, fstype, device);
1239     if (r == -1)
1240       return -1;
1241   }
1242   {
1243     char device[] = "/dev/sda1";
1244     char mountpoint[] = "/";
1245     int r;
1246     suppress_error = 0;
1247     r = guestfs_mount (g, device, mountpoint);
1248     if (r == -1)
1249       return -1;
1250   }
1251   /* TestOutputList for head_n (1) */
1252   {
1253     char options[] = "ro";
1254     char vfstype[] = "squashfs";
1255     char device[] = "/dev/sdd";
1256     char mountpoint[] = "/";
1257     int r;
1258     suppress_error = 0;
1259     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1260     if (r == -1)
1261       return -1;
1262   }
1263   {
1264     char path[] = "/10klines";
1265     char **r;
1266     int i;
1267     suppress_error = 0;
1268     r = guestfs_head_n (g, -9997, path);
1269     if (r == NULL)
1270       return -1;
1271     if (!r[0]) {
1272       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1273       print_strings (r);
1274       return -1;
1275     }
1276     {
1277       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1278       if (strcmp (r[0], expected) != 0) {
1279         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1280         return -1;
1281       }
1282     }
1283     if (!r[1]) {
1284       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1285       print_strings (r);
1286       return -1;
1287     }
1288     {
1289       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1290       if (strcmp (r[1], expected) != 0) {
1291         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1292         return -1;
1293       }
1294     }
1295     if (!r[2]) {
1296       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1297       print_strings (r);
1298       return -1;
1299     }
1300     {
1301       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1302       if (strcmp (r[2], expected) != 0) {
1303         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1304         return -1;
1305       }
1306     }
1307     if (r[3] != NULL) {
1308       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1309       print_strings (r);
1310       return -1;
1311     }
1312     for (i = 0; r[i] != NULL; ++i)
1313       free (r[i]);
1314     free (r);
1315   }
1316   return 0;
1317 }
1318
1319 static int test_head_n_2_skip (void)
1320 {
1321   const char *str;
1322
1323   str = getenv ("TEST_ONLY");
1324   if (str)
1325     return strstr (str, "head_n") == NULL;
1326   str = getenv ("SKIP_TEST_HEAD_N_2");
1327   if (str && strcmp (str, "1") == 0) return 1;
1328   str = getenv ("SKIP_TEST_HEAD_N");
1329   if (str && strcmp (str, "1") == 0) return 1;
1330   return 0;
1331 }
1332
1333 static int test_head_n_2 (void)
1334 {
1335   if (test_head_n_2_skip ()) {
1336     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1337     return 0;
1338   }
1339
1340   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1341   {
1342     char device[] = "/dev/sda";
1343     int r;
1344     suppress_error = 0;
1345     r = guestfs_blockdev_setrw (g, device);
1346     if (r == -1)
1347       return -1;
1348   }
1349   {
1350     int r;
1351     suppress_error = 0;
1352     r = guestfs_umount_all (g);
1353     if (r == -1)
1354       return -1;
1355   }
1356   {
1357     int r;
1358     suppress_error = 0;
1359     r = guestfs_lvm_remove_all (g);
1360     if (r == -1)
1361       return -1;
1362   }
1363   {
1364     char device[] = "/dev/sda";
1365     char lines_0[] = ",";
1366     char *lines[] = {
1367       lines_0,
1368       NULL
1369     };
1370     int r;
1371     suppress_error = 0;
1372     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1373     if (r == -1)
1374       return -1;
1375   }
1376   {
1377     char fstype[] = "ext2";
1378     char device[] = "/dev/sda1";
1379     int r;
1380     suppress_error = 0;
1381     r = guestfs_mkfs (g, fstype, device);
1382     if (r == -1)
1383       return -1;
1384   }
1385   {
1386     char device[] = "/dev/sda1";
1387     char mountpoint[] = "/";
1388     int r;
1389     suppress_error = 0;
1390     r = guestfs_mount (g, device, mountpoint);
1391     if (r == -1)
1392       return -1;
1393   }
1394   /* TestOutputList for head_n (2) */
1395   {
1396     char options[] = "ro";
1397     char vfstype[] = "squashfs";
1398     char device[] = "/dev/sdd";
1399     char mountpoint[] = "/";
1400     int r;
1401     suppress_error = 0;
1402     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1403     if (r == -1)
1404       return -1;
1405   }
1406   {
1407     char path[] = "/10klines";
1408     char **r;
1409     int i;
1410     suppress_error = 0;
1411     r = guestfs_head_n (g, 0, path);
1412     if (r == NULL)
1413       return -1;
1414     if (r[0] != NULL) {
1415       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1416       print_strings (r);
1417       return -1;
1418     }
1419     for (i = 0; r[i] != NULL; ++i)
1420       free (r[i]);
1421     free (r);
1422   }
1423   return 0;
1424 }
1425
1426 static int test_head_0_skip (void)
1427 {
1428   const char *str;
1429
1430   str = getenv ("TEST_ONLY");
1431   if (str)
1432     return strstr (str, "head") == NULL;
1433   str = getenv ("SKIP_TEST_HEAD_0");
1434   if (str && strcmp (str, "1") == 0) return 1;
1435   str = getenv ("SKIP_TEST_HEAD");
1436   if (str && strcmp (str, "1") == 0) return 1;
1437   return 0;
1438 }
1439
1440 static int test_head_0 (void)
1441 {
1442   if (test_head_0_skip ()) {
1443     printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1444     return 0;
1445   }
1446
1447   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1448   {
1449     char device[] = "/dev/sda";
1450     int r;
1451     suppress_error = 0;
1452     r = guestfs_blockdev_setrw (g, device);
1453     if (r == -1)
1454       return -1;
1455   }
1456   {
1457     int r;
1458     suppress_error = 0;
1459     r = guestfs_umount_all (g);
1460     if (r == -1)
1461       return -1;
1462   }
1463   {
1464     int r;
1465     suppress_error = 0;
1466     r = guestfs_lvm_remove_all (g);
1467     if (r == -1)
1468       return -1;
1469   }
1470   {
1471     char device[] = "/dev/sda";
1472     char lines_0[] = ",";
1473     char *lines[] = {
1474       lines_0,
1475       NULL
1476     };
1477     int r;
1478     suppress_error = 0;
1479     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1480     if (r == -1)
1481       return -1;
1482   }
1483   {
1484     char fstype[] = "ext2";
1485     char device[] = "/dev/sda1";
1486     int r;
1487     suppress_error = 0;
1488     r = guestfs_mkfs (g, fstype, device);
1489     if (r == -1)
1490       return -1;
1491   }
1492   {
1493     char device[] = "/dev/sda1";
1494     char mountpoint[] = "/";
1495     int r;
1496     suppress_error = 0;
1497     r = guestfs_mount (g, device, mountpoint);
1498     if (r == -1)
1499       return -1;
1500   }
1501   /* TestOutputList for head (0) */
1502   {
1503     char options[] = "ro";
1504     char vfstype[] = "squashfs";
1505     char device[] = "/dev/sdd";
1506     char mountpoint[] = "/";
1507     int r;
1508     suppress_error = 0;
1509     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1510     if (r == -1)
1511       return -1;
1512   }
1513   {
1514     char path[] = "/10klines";
1515     char **r;
1516     int i;
1517     suppress_error = 0;
1518     r = guestfs_head (g, path);
1519     if (r == NULL)
1520       return -1;
1521     if (!r[0]) {
1522       fprintf (stderr, "test_head_0: short list returned from command\n");
1523       print_strings (r);
1524       return -1;
1525     }
1526     {
1527       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1528       if (strcmp (r[0], expected) != 0) {
1529         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1530         return -1;
1531       }
1532     }
1533     if (!r[1]) {
1534       fprintf (stderr, "test_head_0: short list returned from command\n");
1535       print_strings (r);
1536       return -1;
1537     }
1538     {
1539       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1540       if (strcmp (r[1], expected) != 0) {
1541         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1542         return -1;
1543       }
1544     }
1545     if (!r[2]) {
1546       fprintf (stderr, "test_head_0: short list returned from command\n");
1547       print_strings (r);
1548       return -1;
1549     }
1550     {
1551       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1552       if (strcmp (r[2], expected) != 0) {
1553         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1554         return -1;
1555       }
1556     }
1557     if (!r[3]) {
1558       fprintf (stderr, "test_head_0: short list returned from command\n");
1559       print_strings (r);
1560       return -1;
1561     }
1562     {
1563       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1564       if (strcmp (r[3], expected) != 0) {
1565         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1566         return -1;
1567       }
1568     }
1569     if (!r[4]) {
1570       fprintf (stderr, "test_head_0: short list returned from command\n");
1571       print_strings (r);
1572       return -1;
1573     }
1574     {
1575       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1576       if (strcmp (r[4], expected) != 0) {
1577         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1578         return -1;
1579       }
1580     }
1581     if (!r[5]) {
1582       fprintf (stderr, "test_head_0: short list returned from command\n");
1583       print_strings (r);
1584       return -1;
1585     }
1586     {
1587       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1588       if (strcmp (r[5], expected) != 0) {
1589         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1590         return -1;
1591       }
1592     }
1593     if (!r[6]) {
1594       fprintf (stderr, "test_head_0: short list returned from command\n");
1595       print_strings (r);
1596       return -1;
1597     }
1598     {
1599       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1600       if (strcmp (r[6], expected) != 0) {
1601         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1602         return -1;
1603       }
1604     }
1605     if (!r[7]) {
1606       fprintf (stderr, "test_head_0: short list returned from command\n");
1607       print_strings (r);
1608       return -1;
1609     }
1610     {
1611       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1612       if (strcmp (r[7], expected) != 0) {
1613         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1614         return -1;
1615       }
1616     }
1617     if (!r[8]) {
1618       fprintf (stderr, "test_head_0: short list returned from command\n");
1619       print_strings (r);
1620       return -1;
1621     }
1622     {
1623       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1624       if (strcmp (r[8], expected) != 0) {
1625         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1626         return -1;
1627       }
1628     }
1629     if (!r[9]) {
1630       fprintf (stderr, "test_head_0: short list returned from command\n");
1631       print_strings (r);
1632       return -1;
1633     }
1634     {
1635       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1636       if (strcmp (r[9], expected) != 0) {
1637         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1638         return -1;
1639       }
1640     }
1641     if (r[10] != NULL) {
1642       fprintf (stderr, "test_head_0: extra elements returned from command\n");
1643       print_strings (r);
1644       return -1;
1645     }
1646     for (i = 0; r[i] != NULL; ++i)
1647       free (r[i]);
1648     free (r);
1649   }
1650   return 0;
1651 }
1652
1653 static int test_wc_c_0_skip (void)
1654 {
1655   const char *str;
1656
1657   str = getenv ("TEST_ONLY");
1658   if (str)
1659     return strstr (str, "wc_c") == NULL;
1660   str = getenv ("SKIP_TEST_WC_C_0");
1661   if (str && strcmp (str, "1") == 0) return 1;
1662   str = getenv ("SKIP_TEST_WC_C");
1663   if (str && strcmp (str, "1") == 0) return 1;
1664   return 0;
1665 }
1666
1667 static int test_wc_c_0 (void)
1668 {
1669   if (test_wc_c_0_skip ()) {
1670     printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1671     return 0;
1672   }
1673
1674   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1675   {
1676     char device[] = "/dev/sda";
1677     int r;
1678     suppress_error = 0;
1679     r = guestfs_blockdev_setrw (g, device);
1680     if (r == -1)
1681       return -1;
1682   }
1683   {
1684     int r;
1685     suppress_error = 0;
1686     r = guestfs_umount_all (g);
1687     if (r == -1)
1688       return -1;
1689   }
1690   {
1691     int r;
1692     suppress_error = 0;
1693     r = guestfs_lvm_remove_all (g);
1694     if (r == -1)
1695       return -1;
1696   }
1697   {
1698     char device[] = "/dev/sda";
1699     char lines_0[] = ",";
1700     char *lines[] = {
1701       lines_0,
1702       NULL
1703     };
1704     int r;
1705     suppress_error = 0;
1706     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1707     if (r == -1)
1708       return -1;
1709   }
1710   {
1711     char fstype[] = "ext2";
1712     char device[] = "/dev/sda1";
1713     int r;
1714     suppress_error = 0;
1715     r = guestfs_mkfs (g, fstype, device);
1716     if (r == -1)
1717       return -1;
1718   }
1719   {
1720     char device[] = "/dev/sda1";
1721     char mountpoint[] = "/";
1722     int r;
1723     suppress_error = 0;
1724     r = guestfs_mount (g, device, mountpoint);
1725     if (r == -1)
1726       return -1;
1727   }
1728   /* TestOutputInt for wc_c (0) */
1729   {
1730     char options[] = "ro";
1731     char vfstype[] = "squashfs";
1732     char device[] = "/dev/sdd";
1733     char mountpoint[] = "/";
1734     int r;
1735     suppress_error = 0;
1736     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1737     if (r == -1)
1738       return -1;
1739   }
1740   {
1741     char path[] = "/100kallspaces";
1742     int r;
1743     suppress_error = 0;
1744     r = guestfs_wc_c (g, path);
1745     if (r == -1)
1746       return -1;
1747     if (r != 102400) {
1748       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
1749       return -1;
1750     }
1751   }
1752   return 0;
1753 }
1754
1755 static int test_wc_w_0_skip (void)
1756 {
1757   const char *str;
1758
1759   str = getenv ("TEST_ONLY");
1760   if (str)
1761     return strstr (str, "wc_w") == NULL;
1762   str = getenv ("SKIP_TEST_WC_W_0");
1763   if (str && strcmp (str, "1") == 0) return 1;
1764   str = getenv ("SKIP_TEST_WC_W");
1765   if (str && strcmp (str, "1") == 0) return 1;
1766   return 0;
1767 }
1768
1769 static int test_wc_w_0 (void)
1770 {
1771   if (test_wc_w_0_skip ()) {
1772     printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1773     return 0;
1774   }
1775
1776   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1777   {
1778     char device[] = "/dev/sda";
1779     int r;
1780     suppress_error = 0;
1781     r = guestfs_blockdev_setrw (g, device);
1782     if (r == -1)
1783       return -1;
1784   }
1785   {
1786     int r;
1787     suppress_error = 0;
1788     r = guestfs_umount_all (g);
1789     if (r == -1)
1790       return -1;
1791   }
1792   {
1793     int r;
1794     suppress_error = 0;
1795     r = guestfs_lvm_remove_all (g);
1796     if (r == -1)
1797       return -1;
1798   }
1799   {
1800     char device[] = "/dev/sda";
1801     char lines_0[] = ",";
1802     char *lines[] = {
1803       lines_0,
1804       NULL
1805     };
1806     int r;
1807     suppress_error = 0;
1808     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1809     if (r == -1)
1810       return -1;
1811   }
1812   {
1813     char fstype[] = "ext2";
1814     char device[] = "/dev/sda1";
1815     int r;
1816     suppress_error = 0;
1817     r = guestfs_mkfs (g, fstype, device);
1818     if (r == -1)
1819       return -1;
1820   }
1821   {
1822     char device[] = "/dev/sda1";
1823     char mountpoint[] = "/";
1824     int r;
1825     suppress_error = 0;
1826     r = guestfs_mount (g, device, mountpoint);
1827     if (r == -1)
1828       return -1;
1829   }
1830   /* TestOutputInt for wc_w (0) */
1831   {
1832     char options[] = "ro";
1833     char vfstype[] = "squashfs";
1834     char device[] = "/dev/sdd";
1835     char mountpoint[] = "/";
1836     int r;
1837     suppress_error = 0;
1838     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1839     if (r == -1)
1840       return -1;
1841   }
1842   {
1843     char path[] = "/10klines";
1844     int r;
1845     suppress_error = 0;
1846     r = guestfs_wc_w (g, path);
1847     if (r == -1)
1848       return -1;
1849     if (r != 10000) {
1850       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
1851       return -1;
1852     }
1853   }
1854   return 0;
1855 }
1856
1857 static int test_wc_l_0_skip (void)
1858 {
1859   const char *str;
1860
1861   str = getenv ("TEST_ONLY");
1862   if (str)
1863     return strstr (str, "wc_l") == NULL;
1864   str = getenv ("SKIP_TEST_WC_L_0");
1865   if (str && strcmp (str, "1") == 0) return 1;
1866   str = getenv ("SKIP_TEST_WC_L");
1867   if (str && strcmp (str, "1") == 0) return 1;
1868   return 0;
1869 }
1870
1871 static int test_wc_l_0 (void)
1872 {
1873   if (test_wc_l_0_skip ()) {
1874     printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
1875     return 0;
1876   }
1877
1878   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
1879   {
1880     char device[] = "/dev/sda";
1881     int r;
1882     suppress_error = 0;
1883     r = guestfs_blockdev_setrw (g, device);
1884     if (r == -1)
1885       return -1;
1886   }
1887   {
1888     int r;
1889     suppress_error = 0;
1890     r = guestfs_umount_all (g);
1891     if (r == -1)
1892       return -1;
1893   }
1894   {
1895     int r;
1896     suppress_error = 0;
1897     r = guestfs_lvm_remove_all (g);
1898     if (r == -1)
1899       return -1;
1900   }
1901   {
1902     char device[] = "/dev/sda";
1903     char lines_0[] = ",";
1904     char *lines[] = {
1905       lines_0,
1906       NULL
1907     };
1908     int r;
1909     suppress_error = 0;
1910     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1911     if (r == -1)
1912       return -1;
1913   }
1914   {
1915     char fstype[] = "ext2";
1916     char device[] = "/dev/sda1";
1917     int r;
1918     suppress_error = 0;
1919     r = guestfs_mkfs (g, fstype, device);
1920     if (r == -1)
1921       return -1;
1922   }
1923   {
1924     char device[] = "/dev/sda1";
1925     char mountpoint[] = "/";
1926     int r;
1927     suppress_error = 0;
1928     r = guestfs_mount (g, device, mountpoint);
1929     if (r == -1)
1930       return -1;
1931   }
1932   /* TestOutputInt for wc_l (0) */
1933   {
1934     char options[] = "ro";
1935     char vfstype[] = "squashfs";
1936     char device[] = "/dev/sdd";
1937     char mountpoint[] = "/";
1938     int r;
1939     suppress_error = 0;
1940     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1941     if (r == -1)
1942       return -1;
1943   }
1944   {
1945     char path[] = "/10klines";
1946     int r;
1947     suppress_error = 0;
1948     r = guestfs_wc_l (g, path);
1949     if (r == -1)
1950       return -1;
1951     if (r != 10000) {
1952       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
1953       return -1;
1954     }
1955   }
1956   return 0;
1957 }
1958
1959 static int test_mkdtemp_0_skip (void)
1960 {
1961   const char *str;
1962
1963   str = getenv ("TEST_ONLY");
1964   if (str)
1965     return strstr (str, "mkdtemp") == NULL;
1966   str = getenv ("SKIP_TEST_MKDTEMP_0");
1967   if (str && strcmp (str, "1") == 0) return 1;
1968   str = getenv ("SKIP_TEST_MKDTEMP");
1969   if (str && strcmp (str, "1") == 0) return 1;
1970   return 0;
1971 }
1972
1973 static int test_mkdtemp_0 (void)
1974 {
1975   if (test_mkdtemp_0_skip ()) {
1976     printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
1977     return 0;
1978   }
1979
1980   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
1981   {
1982     char device[] = "/dev/sda";
1983     int r;
1984     suppress_error = 0;
1985     r = guestfs_blockdev_setrw (g, device);
1986     if (r == -1)
1987       return -1;
1988   }
1989   {
1990     int r;
1991     suppress_error = 0;
1992     r = guestfs_umount_all (g);
1993     if (r == -1)
1994       return -1;
1995   }
1996   {
1997     int r;
1998     suppress_error = 0;
1999     r = guestfs_lvm_remove_all (g);
2000     if (r == -1)
2001       return -1;
2002   }
2003   {
2004     char device[] = "/dev/sda";
2005     char lines_0[] = ",";
2006     char *lines[] = {
2007       lines_0,
2008       NULL
2009     };
2010     int r;
2011     suppress_error = 0;
2012     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2013     if (r == -1)
2014       return -1;
2015   }
2016   {
2017     char fstype[] = "ext2";
2018     char device[] = "/dev/sda1";
2019     int r;
2020     suppress_error = 0;
2021     r = guestfs_mkfs (g, fstype, device);
2022     if (r == -1)
2023       return -1;
2024   }
2025   {
2026     char device[] = "/dev/sda1";
2027     char mountpoint[] = "/";
2028     int r;
2029     suppress_error = 0;
2030     r = guestfs_mount (g, device, mountpoint);
2031     if (r == -1)
2032       return -1;
2033   }
2034   /* TestRun for mkdtemp (0) */
2035   {
2036     char path[] = "/tmp";
2037     int r;
2038     suppress_error = 0;
2039     r = guestfs_mkdir (g, path);
2040     if (r == -1)
2041       return -1;
2042   }
2043   {
2044     char template[] = "/tmp/tmpXXXXXX";
2045     char *r;
2046     suppress_error = 0;
2047     r = guestfs_mkdtemp (g, template);
2048     if (r == NULL)
2049       return -1;
2050     free (r);
2051   }
2052   return 0;
2053 }
2054
2055 static int test_scrub_file_0_skip (void)
2056 {
2057   const char *str;
2058
2059   str = getenv ("TEST_ONLY");
2060   if (str)
2061     return strstr (str, "scrub_file") == NULL;
2062   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2063   if (str && strcmp (str, "1") == 0) return 1;
2064   str = getenv ("SKIP_TEST_SCRUB_FILE");
2065   if (str && strcmp (str, "1") == 0) return 1;
2066   return 0;
2067 }
2068
2069 static int test_scrub_file_0 (void)
2070 {
2071   if (test_scrub_file_0_skip ()) {
2072     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2073     return 0;
2074   }
2075
2076   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2077   {
2078     char device[] = "/dev/sda";
2079     int r;
2080     suppress_error = 0;
2081     r = guestfs_blockdev_setrw (g, device);
2082     if (r == -1)
2083       return -1;
2084   }
2085   {
2086     int r;
2087     suppress_error = 0;
2088     r = guestfs_umount_all (g);
2089     if (r == -1)
2090       return -1;
2091   }
2092   {
2093     int r;
2094     suppress_error = 0;
2095     r = guestfs_lvm_remove_all (g);
2096     if (r == -1)
2097       return -1;
2098   }
2099   {
2100     char device[] = "/dev/sda";
2101     char lines_0[] = ",";
2102     char *lines[] = {
2103       lines_0,
2104       NULL
2105     };
2106     int r;
2107     suppress_error = 0;
2108     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2109     if (r == -1)
2110       return -1;
2111   }
2112   {
2113     char fstype[] = "ext2";
2114     char device[] = "/dev/sda1";
2115     int r;
2116     suppress_error = 0;
2117     r = guestfs_mkfs (g, fstype, device);
2118     if (r == -1)
2119       return -1;
2120   }
2121   {
2122     char device[] = "/dev/sda1";
2123     char mountpoint[] = "/";
2124     int r;
2125     suppress_error = 0;
2126     r = guestfs_mount (g, device, mountpoint);
2127     if (r == -1)
2128       return -1;
2129   }
2130   /* TestRun for scrub_file (0) */
2131   {
2132     char path[] = "/file";
2133     char content[] = "content";
2134     int r;
2135     suppress_error = 0;
2136     r = guestfs_write_file (g, path, content, 0);
2137     if (r == -1)
2138       return -1;
2139   }
2140   {
2141     char file[] = "/file";
2142     int r;
2143     suppress_error = 0;
2144     r = guestfs_scrub_file (g, file);
2145     if (r == -1)
2146       return -1;
2147   }
2148   return 0;
2149 }
2150
2151 static int test_scrub_device_0_skip (void)
2152 {
2153   const char *str;
2154
2155   str = getenv ("TEST_ONLY");
2156   if (str)
2157     return strstr (str, "scrub_device") == NULL;
2158   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2159   if (str && strcmp (str, "1") == 0) return 1;
2160   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2161   if (str && strcmp (str, "1") == 0) return 1;
2162   return 0;
2163 }
2164
2165 static int test_scrub_device_0 (void)
2166 {
2167   if (test_scrub_device_0_skip ()) {
2168     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2169     return 0;
2170   }
2171
2172   /* InitNone|InitEmpty for test_scrub_device_0 */
2173   {
2174     char device[] = "/dev/sda";
2175     int r;
2176     suppress_error = 0;
2177     r = guestfs_blockdev_setrw (g, device);
2178     if (r == -1)
2179       return -1;
2180   }
2181   {
2182     int r;
2183     suppress_error = 0;
2184     r = guestfs_umount_all (g);
2185     if (r == -1)
2186       return -1;
2187   }
2188   {
2189     int r;
2190     suppress_error = 0;
2191     r = guestfs_lvm_remove_all (g);
2192     if (r == -1)
2193       return -1;
2194   }
2195   /* TestRun for scrub_device (0) */
2196   {
2197     char device[] = "/dev/sdc";
2198     int r;
2199     suppress_error = 0;
2200     r = guestfs_scrub_device (g, device);
2201     if (r == -1)
2202       return -1;
2203   }
2204   return 0;
2205 }
2206
2207 static int test_glob_expand_0_skip (void)
2208 {
2209   const char *str;
2210
2211   str = getenv ("TEST_ONLY");
2212   if (str)
2213     return strstr (str, "glob_expand") == NULL;
2214   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2215   if (str && strcmp (str, "1") == 0) return 1;
2216   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2217   if (str && strcmp (str, "1") == 0) return 1;
2218   return 0;
2219 }
2220
2221 static int test_glob_expand_0 (void)
2222 {
2223   if (test_glob_expand_0_skip ()) {
2224     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2225     return 0;
2226   }
2227
2228   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2229   {
2230     char device[] = "/dev/sda";
2231     int r;
2232     suppress_error = 0;
2233     r = guestfs_blockdev_setrw (g, device);
2234     if (r == -1)
2235       return -1;
2236   }
2237   {
2238     int r;
2239     suppress_error = 0;
2240     r = guestfs_umount_all (g);
2241     if (r == -1)
2242       return -1;
2243   }
2244   {
2245     int r;
2246     suppress_error = 0;
2247     r = guestfs_lvm_remove_all (g);
2248     if (r == -1)
2249       return -1;
2250   }
2251   {
2252     char device[] = "/dev/sda";
2253     char lines_0[] = ",";
2254     char *lines[] = {
2255       lines_0,
2256       NULL
2257     };
2258     int r;
2259     suppress_error = 0;
2260     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2261     if (r == -1)
2262       return -1;
2263   }
2264   {
2265     char fstype[] = "ext2";
2266     char device[] = "/dev/sda1";
2267     int r;
2268     suppress_error = 0;
2269     r = guestfs_mkfs (g, fstype, device);
2270     if (r == -1)
2271       return -1;
2272   }
2273   {
2274     char device[] = "/dev/sda1";
2275     char mountpoint[] = "/";
2276     int r;
2277     suppress_error = 0;
2278     r = guestfs_mount (g, device, mountpoint);
2279     if (r == -1)
2280       return -1;
2281   }
2282   /* TestOutputList for glob_expand (0) */
2283   {
2284     char path[] = "/a/b/c";
2285     int r;
2286     suppress_error = 0;
2287     r = guestfs_mkdir_p (g, path);
2288     if (r == -1)
2289       return -1;
2290   }
2291   {
2292     char path[] = "/a/b/c/d";
2293     int r;
2294     suppress_error = 0;
2295     r = guestfs_touch (g, path);
2296     if (r == -1)
2297       return -1;
2298   }
2299   {
2300     char path[] = "/a/b/c/e";
2301     int r;
2302     suppress_error = 0;
2303     r = guestfs_touch (g, path);
2304     if (r == -1)
2305       return -1;
2306   }
2307   {
2308     char pattern[] = "/a/b/c/*";
2309     char **r;
2310     int i;
2311     suppress_error = 0;
2312     r = guestfs_glob_expand (g, pattern);
2313     if (r == NULL)
2314       return -1;
2315     if (!r[0]) {
2316       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2317       print_strings (r);
2318       return -1;
2319     }
2320     {
2321       char expected[] = "/a/b/c/d";
2322       if (strcmp (r[0], expected) != 0) {
2323         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2324         return -1;
2325       }
2326     }
2327     if (!r[1]) {
2328       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2329       print_strings (r);
2330       return -1;
2331     }
2332     {
2333       char expected[] = "/a/b/c/e";
2334       if (strcmp (r[1], expected) != 0) {
2335         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2336         return -1;
2337       }
2338     }
2339     if (r[2] != NULL) {
2340       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2341       print_strings (r);
2342       return -1;
2343     }
2344     for (i = 0; r[i] != NULL; ++i)
2345       free (r[i]);
2346     free (r);
2347   }
2348   return 0;
2349 }
2350
2351 static int test_glob_expand_1_skip (void)
2352 {
2353   const char *str;
2354
2355   str = getenv ("TEST_ONLY");
2356   if (str)
2357     return strstr (str, "glob_expand") == NULL;
2358   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2359   if (str && strcmp (str, "1") == 0) return 1;
2360   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2361   if (str && strcmp (str, "1") == 0) return 1;
2362   return 0;
2363 }
2364
2365 static int test_glob_expand_1 (void)
2366 {
2367   if (test_glob_expand_1_skip ()) {
2368     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2369     return 0;
2370   }
2371
2372   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2373   {
2374     char device[] = "/dev/sda";
2375     int r;
2376     suppress_error = 0;
2377     r = guestfs_blockdev_setrw (g, device);
2378     if (r == -1)
2379       return -1;
2380   }
2381   {
2382     int r;
2383     suppress_error = 0;
2384     r = guestfs_umount_all (g);
2385     if (r == -1)
2386       return -1;
2387   }
2388   {
2389     int r;
2390     suppress_error = 0;
2391     r = guestfs_lvm_remove_all (g);
2392     if (r == -1)
2393       return -1;
2394   }
2395   {
2396     char device[] = "/dev/sda";
2397     char lines_0[] = ",";
2398     char *lines[] = {
2399       lines_0,
2400       NULL
2401     };
2402     int r;
2403     suppress_error = 0;
2404     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2405     if (r == -1)
2406       return -1;
2407   }
2408   {
2409     char fstype[] = "ext2";
2410     char device[] = "/dev/sda1";
2411     int r;
2412     suppress_error = 0;
2413     r = guestfs_mkfs (g, fstype, device);
2414     if (r == -1)
2415       return -1;
2416   }
2417   {
2418     char device[] = "/dev/sda1";
2419     char mountpoint[] = "/";
2420     int r;
2421     suppress_error = 0;
2422     r = guestfs_mount (g, device, mountpoint);
2423     if (r == -1)
2424       return -1;
2425   }
2426   /* TestOutputList for glob_expand (1) */
2427   {
2428     char path[] = "/a/b/c";
2429     int r;
2430     suppress_error = 0;
2431     r = guestfs_mkdir_p (g, path);
2432     if (r == -1)
2433       return -1;
2434   }
2435   {
2436     char path[] = "/a/b/c/d";
2437     int r;
2438     suppress_error = 0;
2439     r = guestfs_touch (g, path);
2440     if (r == -1)
2441       return -1;
2442   }
2443   {
2444     char path[] = "/a/b/c/e";
2445     int r;
2446     suppress_error = 0;
2447     r = guestfs_touch (g, path);
2448     if (r == -1)
2449       return -1;
2450   }
2451   {
2452     char pattern[] = "/a/*/c/*";
2453     char **r;
2454     int i;
2455     suppress_error = 0;
2456     r = guestfs_glob_expand (g, pattern);
2457     if (r == NULL)
2458       return -1;
2459     if (!r[0]) {
2460       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2461       print_strings (r);
2462       return -1;
2463     }
2464     {
2465       char expected[] = "/a/b/c/d";
2466       if (strcmp (r[0], expected) != 0) {
2467         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2468         return -1;
2469       }
2470     }
2471     if (!r[1]) {
2472       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2473       print_strings (r);
2474       return -1;
2475     }
2476     {
2477       char expected[] = "/a/b/c/e";
2478       if (strcmp (r[1], expected) != 0) {
2479         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2480         return -1;
2481       }
2482     }
2483     if (r[2] != NULL) {
2484       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2485       print_strings (r);
2486       return -1;
2487     }
2488     for (i = 0; r[i] != NULL; ++i)
2489       free (r[i]);
2490     free (r);
2491   }
2492   return 0;
2493 }
2494
2495 static int test_glob_expand_2_skip (void)
2496 {
2497   const char *str;
2498
2499   str = getenv ("TEST_ONLY");
2500   if (str)
2501     return strstr (str, "glob_expand") == NULL;
2502   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2503   if (str && strcmp (str, "1") == 0) return 1;
2504   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2505   if (str && strcmp (str, "1") == 0) return 1;
2506   return 0;
2507 }
2508
2509 static int test_glob_expand_2 (void)
2510 {
2511   if (test_glob_expand_2_skip ()) {
2512     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2513     return 0;
2514   }
2515
2516   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2517   {
2518     char device[] = "/dev/sda";
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     char lines_0[] = ",";
2542     char *lines[] = {
2543       lines_0,
2544       NULL
2545     };
2546     int r;
2547     suppress_error = 0;
2548     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2549     if (r == -1)
2550       return -1;
2551   }
2552   {
2553     char fstype[] = "ext2";
2554     char device[] = "/dev/sda1";
2555     int r;
2556     suppress_error = 0;
2557     r = guestfs_mkfs (g, fstype, device);
2558     if (r == -1)
2559       return -1;
2560   }
2561   {
2562     char device[] = "/dev/sda1";
2563     char mountpoint[] = "/";
2564     int r;
2565     suppress_error = 0;
2566     r = guestfs_mount (g, device, mountpoint);
2567     if (r == -1)
2568       return -1;
2569   }
2570   /* TestOutputList for glob_expand (2) */
2571   {
2572     char path[] = "/a/b/c";
2573     int r;
2574     suppress_error = 0;
2575     r = guestfs_mkdir_p (g, path);
2576     if (r == -1)
2577       return -1;
2578   }
2579   {
2580     char path[] = "/a/b/c/d";
2581     int r;
2582     suppress_error = 0;
2583     r = guestfs_touch (g, path);
2584     if (r == -1)
2585       return -1;
2586   }
2587   {
2588     char path[] = "/a/b/c/e";
2589     int r;
2590     suppress_error = 0;
2591     r = guestfs_touch (g, path);
2592     if (r == -1)
2593       return -1;
2594   }
2595   {
2596     char pattern[] = "/a/*/x/*";
2597     char **r;
2598     int i;
2599     suppress_error = 0;
2600     r = guestfs_glob_expand (g, pattern);
2601     if (r == NULL)
2602       return -1;
2603     if (r[0] != NULL) {
2604       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2605       print_strings (r);
2606       return -1;
2607     }
2608     for (i = 0; r[i] != NULL; ++i)
2609       free (r[i]);
2610     free (r);
2611   }
2612   return 0;
2613 }
2614
2615 static int test_ntfs_3g_probe_0_skip (void)
2616 {
2617   const char *str;
2618
2619   str = getenv ("TEST_ONLY");
2620   if (str)
2621     return strstr (str, "ntfs_3g_probe") == NULL;
2622   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2623   if (str && strcmp (str, "1") == 0) return 1;
2624   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2625   if (str && strcmp (str, "1") == 0) return 1;
2626   return 0;
2627 }
2628
2629 static int test_ntfs_3g_probe_0 (void)
2630 {
2631   if (test_ntfs_3g_probe_0_skip ()) {
2632     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2633     return 0;
2634   }
2635
2636   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2637   {
2638     char device[] = "/dev/sda";
2639     int r;
2640     suppress_error = 0;
2641     r = guestfs_blockdev_setrw (g, device);
2642     if (r == -1)
2643       return -1;
2644   }
2645   {
2646     int r;
2647     suppress_error = 0;
2648     r = guestfs_umount_all (g);
2649     if (r == -1)
2650       return -1;
2651   }
2652   {
2653     int r;
2654     suppress_error = 0;
2655     r = guestfs_lvm_remove_all (g);
2656     if (r == -1)
2657       return -1;
2658   }
2659   /* TestOutputInt for ntfs_3g_probe (0) */
2660   {
2661     char device[] = "/dev/sda";
2662     char lines_0[] = ",";
2663     char *lines[] = {
2664       lines_0,
2665       NULL
2666     };
2667     int r;
2668     suppress_error = 0;
2669     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2670     if (r == -1)
2671       return -1;
2672   }
2673   {
2674     char fstype[] = "ntfs";
2675     char device[] = "/dev/sda1";
2676     int r;
2677     suppress_error = 0;
2678     r = guestfs_mkfs (g, fstype, device);
2679     if (r == -1)
2680       return -1;
2681   }
2682   {
2683     char device[] = "/dev/sda1";
2684     int r;
2685     suppress_error = 0;
2686     r = guestfs_ntfs_3g_probe (g, 1, device);
2687     if (r == -1)
2688       return -1;
2689     if (r != 0) {
2690       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
2691       return -1;
2692     }
2693   }
2694   return 0;
2695 }
2696
2697 static int test_ntfs_3g_probe_1_skip (void)
2698 {
2699   const char *str;
2700
2701   str = getenv ("TEST_ONLY");
2702   if (str)
2703     return strstr (str, "ntfs_3g_probe") == NULL;
2704   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2705   if (str && strcmp (str, "1") == 0) return 1;
2706   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2707   if (str && strcmp (str, "1") == 0) return 1;
2708   return 0;
2709 }
2710
2711 static int test_ntfs_3g_probe_1 (void)
2712 {
2713   if (test_ntfs_3g_probe_1_skip ()) {
2714     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2715     return 0;
2716   }
2717
2718   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2719   {
2720     char device[] = "/dev/sda";
2721     int r;
2722     suppress_error = 0;
2723     r = guestfs_blockdev_setrw (g, device);
2724     if (r == -1)
2725       return -1;
2726   }
2727   {
2728     int r;
2729     suppress_error = 0;
2730     r = guestfs_umount_all (g);
2731     if (r == -1)
2732       return -1;
2733   }
2734   {
2735     int r;
2736     suppress_error = 0;
2737     r = guestfs_lvm_remove_all (g);
2738     if (r == -1)
2739       return -1;
2740   }
2741   /* TestOutputInt for ntfs_3g_probe (1) */
2742   {
2743     char device[] = "/dev/sda";
2744     char lines_0[] = ",";
2745     char *lines[] = {
2746       lines_0,
2747       NULL
2748     };
2749     int r;
2750     suppress_error = 0;
2751     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2752     if (r == -1)
2753       return -1;
2754   }
2755   {
2756     char fstype[] = "ext2";
2757     char device[] = "/dev/sda1";
2758     int r;
2759     suppress_error = 0;
2760     r = guestfs_mkfs (g, fstype, device);
2761     if (r == -1)
2762       return -1;
2763   }
2764   {
2765     char device[] = "/dev/sda1";
2766     int r;
2767     suppress_error = 0;
2768     r = guestfs_ntfs_3g_probe (g, 1, device);
2769     if (r == -1)
2770       return -1;
2771     if (r != 12) {
2772       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
2773       return -1;
2774     }
2775   }
2776   return 0;
2777 }
2778
2779 static int test_sleep_0_skip (void)
2780 {
2781   const char *str;
2782
2783   str = getenv ("TEST_ONLY");
2784   if (str)
2785     return strstr (str, "sleep") == NULL;
2786   str = getenv ("SKIP_TEST_SLEEP_0");
2787   if (str && strcmp (str, "1") == 0) return 1;
2788   str = getenv ("SKIP_TEST_SLEEP");
2789   if (str && strcmp (str, "1") == 0) return 1;
2790   return 0;
2791 }
2792
2793 static int test_sleep_0 (void)
2794 {
2795   if (test_sleep_0_skip ()) {
2796     printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
2797     return 0;
2798   }
2799
2800   /* InitNone|InitEmpty for test_sleep_0 */
2801   {
2802     char device[] = "/dev/sda";
2803     int r;
2804     suppress_error = 0;
2805     r = guestfs_blockdev_setrw (g, device);
2806     if (r == -1)
2807       return -1;
2808   }
2809   {
2810     int r;
2811     suppress_error = 0;
2812     r = guestfs_umount_all (g);
2813     if (r == -1)
2814       return -1;
2815   }
2816   {
2817     int r;
2818     suppress_error = 0;
2819     r = guestfs_lvm_remove_all (g);
2820     if (r == -1)
2821       return -1;
2822   }
2823   /* TestRun for sleep (0) */
2824   {
2825     int r;
2826     suppress_error = 0;
2827     r = guestfs_sleep (g, 1);
2828     if (r == -1)
2829       return -1;
2830   }
2831   return 0;
2832 }
2833
2834 static int test_find_0_skip (void)
2835 {
2836   const char *str;
2837
2838   str = getenv ("TEST_ONLY");
2839   if (str)
2840     return strstr (str, "find") == NULL;
2841   str = getenv ("SKIP_TEST_FIND_0");
2842   if (str && strcmp (str, "1") == 0) return 1;
2843   str = getenv ("SKIP_TEST_FIND");
2844   if (str && strcmp (str, "1") == 0) return 1;
2845   return 0;
2846 }
2847
2848 static int test_find_0 (void)
2849 {
2850   if (test_find_0_skip ()) {
2851     printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
2852     return 0;
2853   }
2854
2855   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
2856   {
2857     char device[] = "/dev/sda";
2858     int r;
2859     suppress_error = 0;
2860     r = guestfs_blockdev_setrw (g, device);
2861     if (r == -1)
2862       return -1;
2863   }
2864   {
2865     int r;
2866     suppress_error = 0;
2867     r = guestfs_umount_all (g);
2868     if (r == -1)
2869       return -1;
2870   }
2871   {
2872     int r;
2873     suppress_error = 0;
2874     r = guestfs_lvm_remove_all (g);
2875     if (r == -1)
2876       return -1;
2877   }
2878   {
2879     char device[] = "/dev/sda";
2880     char lines_0[] = ",";
2881     char *lines[] = {
2882       lines_0,
2883       NULL
2884     };
2885     int r;
2886     suppress_error = 0;
2887     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2888     if (r == -1)
2889       return -1;
2890   }
2891   {
2892     char fstype[] = "ext2";
2893     char device[] = "/dev/sda1";
2894     int r;
2895     suppress_error = 0;
2896     r = guestfs_mkfs (g, fstype, device);
2897     if (r == -1)
2898       return -1;
2899   }
2900   {
2901     char device[] = "/dev/sda1";
2902     char mountpoint[] = "/";
2903     int r;
2904     suppress_error = 0;
2905     r = guestfs_mount (g, device, mountpoint);
2906     if (r == -1)
2907       return -1;
2908   }
2909   /* TestOutputList for find (0) */
2910   {
2911     char directory[] = "/";
2912     char **r;
2913     int i;
2914     suppress_error = 0;
2915     r = guestfs_find (g, directory);
2916     if (r == NULL)
2917       return -1;
2918     if (!r[0]) {
2919       fprintf (stderr, "test_find_0: short list returned from command\n");
2920       print_strings (r);
2921       return -1;
2922     }
2923     {
2924       char expected[] = "lost+found";
2925       if (strcmp (r[0], expected) != 0) {
2926         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2927         return -1;
2928       }
2929     }
2930     if (r[1] != NULL) {
2931       fprintf (stderr, "test_find_0: extra elements returned from command\n");
2932       print_strings (r);
2933       return -1;
2934     }
2935     for (i = 0; r[i] != NULL; ++i)
2936       free (r[i]);
2937     free (r);
2938   }
2939   return 0;
2940 }
2941
2942 static int test_find_1_skip (void)
2943 {
2944   const char *str;
2945
2946   str = getenv ("TEST_ONLY");
2947   if (str)
2948     return strstr (str, "find") == NULL;
2949   str = getenv ("SKIP_TEST_FIND_1");
2950   if (str && strcmp (str, "1") == 0) return 1;
2951   str = getenv ("SKIP_TEST_FIND");
2952   if (str && strcmp (str, "1") == 0) return 1;
2953   return 0;
2954 }
2955
2956 static int test_find_1 (void)
2957 {
2958   if (test_find_1_skip ()) {
2959     printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
2960     return 0;
2961   }
2962
2963   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
2964   {
2965     char device[] = "/dev/sda";
2966     int r;
2967     suppress_error = 0;
2968     r = guestfs_blockdev_setrw (g, device);
2969     if (r == -1)
2970       return -1;
2971   }
2972   {
2973     int r;
2974     suppress_error = 0;
2975     r = guestfs_umount_all (g);
2976     if (r == -1)
2977       return -1;
2978   }
2979   {
2980     int r;
2981     suppress_error = 0;
2982     r = guestfs_lvm_remove_all (g);
2983     if (r == -1)
2984       return -1;
2985   }
2986   {
2987     char device[] = "/dev/sda";
2988     char lines_0[] = ",";
2989     char *lines[] = {
2990       lines_0,
2991       NULL
2992     };
2993     int r;
2994     suppress_error = 0;
2995     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2996     if (r == -1)
2997       return -1;
2998   }
2999   {
3000     char fstype[] = "ext2";
3001     char device[] = "/dev/sda1";
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     char mountpoint[] = "/";
3011     int r;
3012     suppress_error = 0;
3013     r = guestfs_mount (g, device, mountpoint);
3014     if (r == -1)
3015       return -1;
3016   }
3017   /* TestOutputList for find (1) */
3018   {
3019     char path[] = "/a";
3020     int r;
3021     suppress_error = 0;
3022     r = guestfs_touch (g, path);
3023     if (r == -1)
3024       return -1;
3025   }
3026   {
3027     char path[] = "/b";
3028     int r;
3029     suppress_error = 0;
3030     r = guestfs_mkdir (g, path);
3031     if (r == -1)
3032       return -1;
3033   }
3034   {
3035     char path[] = "/b/c";
3036     int r;
3037     suppress_error = 0;
3038     r = guestfs_touch (g, path);
3039     if (r == -1)
3040       return -1;
3041   }
3042   {
3043     char directory[] = "/";
3044     char **r;
3045     int i;
3046     suppress_error = 0;
3047     r = guestfs_find (g, directory);
3048     if (r == NULL)
3049       return -1;
3050     if (!r[0]) {
3051       fprintf (stderr, "test_find_1: short list returned from command\n");
3052       print_strings (r);
3053       return -1;
3054     }
3055     {
3056       char expected[] = "a";
3057       if (strcmp (r[0], expected) != 0) {
3058         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3059         return -1;
3060       }
3061     }
3062     if (!r[1]) {
3063       fprintf (stderr, "test_find_1: short list returned from command\n");
3064       print_strings (r);
3065       return -1;
3066     }
3067     {
3068       char expected[] = "b";
3069       if (strcmp (r[1], expected) != 0) {
3070         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3071         return -1;
3072       }
3073     }
3074     if (!r[2]) {
3075       fprintf (stderr, "test_find_1: short list returned from command\n");
3076       print_strings (r);
3077       return -1;
3078     }
3079     {
3080       char expected[] = "b/c";
3081       if (strcmp (r[2], expected) != 0) {
3082         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3083         return -1;
3084       }
3085     }
3086     if (!r[3]) {
3087       fprintf (stderr, "test_find_1: short list returned from command\n");
3088       print_strings (r);
3089       return -1;
3090     }
3091     {
3092       char expected[] = "lost+found";
3093       if (strcmp (r[3], expected) != 0) {
3094         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3095         return -1;
3096       }
3097     }
3098     if (r[4] != NULL) {
3099       fprintf (stderr, "test_find_1: extra elements returned from command\n");
3100       print_strings (r);
3101       return -1;
3102     }
3103     for (i = 0; r[i] != NULL; ++i)
3104       free (r[i]);
3105     free (r);
3106   }
3107   return 0;
3108 }
3109
3110 static int test_find_2_skip (void)
3111 {
3112   const char *str;
3113
3114   str = getenv ("TEST_ONLY");
3115   if (str)
3116     return strstr (str, "find") == NULL;
3117   str = getenv ("SKIP_TEST_FIND_2");
3118   if (str && strcmp (str, "1") == 0) return 1;
3119   str = getenv ("SKIP_TEST_FIND");
3120   if (str && strcmp (str, "1") == 0) return 1;
3121   return 0;
3122 }
3123
3124 static int test_find_2 (void)
3125 {
3126   if (test_find_2_skip ()) {
3127     printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3128     return 0;
3129   }
3130
3131   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3132   {
3133     char device[] = "/dev/sda";
3134     int r;
3135     suppress_error = 0;
3136     r = guestfs_blockdev_setrw (g, device);
3137     if (r == -1)
3138       return -1;
3139   }
3140   {
3141     int r;
3142     suppress_error = 0;
3143     r = guestfs_umount_all (g);
3144     if (r == -1)
3145       return -1;
3146   }
3147   {
3148     int r;
3149     suppress_error = 0;
3150     r = guestfs_lvm_remove_all (g);
3151     if (r == -1)
3152       return -1;
3153   }
3154   {
3155     char device[] = "/dev/sda";
3156     char lines_0[] = ",";
3157     char *lines[] = {
3158       lines_0,
3159       NULL
3160     };
3161     int r;
3162     suppress_error = 0;
3163     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3164     if (r == -1)
3165       return -1;
3166   }
3167   {
3168     char fstype[] = "ext2";
3169     char device[] = "/dev/sda1";
3170     int r;
3171     suppress_error = 0;
3172     r = guestfs_mkfs (g, fstype, device);
3173     if (r == -1)
3174       return -1;
3175   }
3176   {
3177     char device[] = "/dev/sda1";
3178     char mountpoint[] = "/";
3179     int r;
3180     suppress_error = 0;
3181     r = guestfs_mount (g, device, mountpoint);
3182     if (r == -1)
3183       return -1;
3184   }
3185   /* TestOutputList for find (2) */
3186   {
3187     char path[] = "/a/b/c";
3188     int r;
3189     suppress_error = 0;
3190     r = guestfs_mkdir_p (g, path);
3191     if (r == -1)
3192       return -1;
3193   }
3194   {
3195     char path[] = "/a/b/c/d";
3196     int r;
3197     suppress_error = 0;
3198     r = guestfs_touch (g, path);
3199     if (r == -1)
3200       return -1;
3201   }
3202   {
3203     char directory[] = "/a/b/";
3204     char **r;
3205     int i;
3206     suppress_error = 0;
3207     r = guestfs_find (g, directory);
3208     if (r == NULL)
3209       return -1;
3210     if (!r[0]) {
3211       fprintf (stderr, "test_find_2: short list returned from command\n");
3212       print_strings (r);
3213       return -1;
3214     }
3215     {
3216       char expected[] = "c";
3217       if (strcmp (r[0], expected) != 0) {
3218         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3219         return -1;
3220       }
3221     }
3222     if (!r[1]) {
3223       fprintf (stderr, "test_find_2: short list returned from command\n");
3224       print_strings (r);
3225       return -1;
3226     }
3227     {
3228       char expected[] = "c/d";
3229       if (strcmp (r[1], expected) != 0) {
3230         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3231         return -1;
3232       }
3233     }
3234     if (r[2] != NULL) {
3235       fprintf (stderr, "test_find_2: extra elements returned from command\n");
3236       print_strings (r);
3237       return -1;
3238     }
3239     for (i = 0; r[i] != NULL; ++i)
3240       free (r[i]);
3241     free (r);
3242   }
3243   return 0;
3244 }
3245
3246 static int test_lvresize_0_skip (void)
3247 {
3248   const char *str;
3249
3250   str = getenv ("TEST_ONLY");
3251   if (str)
3252     return strstr (str, "lvresize") == NULL;
3253   str = getenv ("SKIP_TEST_LVRESIZE_0");
3254   if (str && strcmp (str, "1") == 0) return 1;
3255   str = getenv ("SKIP_TEST_LVRESIZE");
3256   if (str && strcmp (str, "1") == 0) return 1;
3257   return 0;
3258 }
3259
3260 static int test_lvresize_0 (void)
3261 {
3262   if (test_lvresize_0_skip ()) {
3263     printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3264     return 0;
3265   }
3266
3267   /* InitNone|InitEmpty for test_lvresize_0 */
3268   {
3269     char device[] = "/dev/sda";
3270     int r;
3271     suppress_error = 0;
3272     r = guestfs_blockdev_setrw (g, device);
3273     if (r == -1)
3274       return -1;
3275   }
3276   {
3277     int r;
3278     suppress_error = 0;
3279     r = guestfs_umount_all (g);
3280     if (r == -1)
3281       return -1;
3282   }
3283   {
3284     int r;
3285     suppress_error = 0;
3286     r = guestfs_lvm_remove_all (g);
3287     if (r == -1)
3288       return -1;
3289   }
3290   /* TestOutput for lvresize (0) */
3291   char expected[] = "test content";
3292   {
3293     char device[] = "/dev/sda";
3294     char lines_0[] = ",";
3295     char *lines[] = {
3296       lines_0,
3297       NULL
3298     };
3299     int r;
3300     suppress_error = 0;
3301     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3302     if (r == -1)
3303       return -1;
3304   }
3305   {
3306     char device[] = "/dev/sda1";
3307     int r;
3308     suppress_error = 0;
3309     r = guestfs_pvcreate (g, device);
3310     if (r == -1)
3311       return -1;
3312   }
3313   {
3314     char volgroup[] = "VG";
3315     char physvols_0[] = "/dev/sda1";
3316     char *physvols[] = {
3317       physvols_0,
3318       NULL
3319     };
3320     int r;
3321     suppress_error = 0;
3322     r = guestfs_vgcreate (g, volgroup, physvols);
3323     if (r == -1)
3324       return -1;
3325   }
3326   {
3327     char logvol[] = "LV";
3328     char volgroup[] = "VG";
3329     int r;
3330     suppress_error = 0;
3331     r = guestfs_lvcreate (g, logvol, volgroup, 10);
3332     if (r == -1)
3333       return -1;
3334   }
3335   {
3336     char fstype[] = "ext2";
3337     char device[] = "/dev/VG/LV";
3338     int r;
3339     suppress_error = 0;
3340     r = guestfs_mkfs (g, fstype, device);
3341     if (r == -1)
3342       return -1;
3343   }
3344   {
3345     char device[] = "/dev/VG/LV";
3346     char mountpoint[] = "/";
3347     int r;
3348     suppress_error = 0;
3349     r = guestfs_mount (g, device, mountpoint);
3350     if (r == -1)
3351       return -1;
3352   }
3353   {
3354     char path[] = "/new";
3355     char content[] = "test content";
3356     int r;
3357     suppress_error = 0;
3358     r = guestfs_write_file (g, path, content, 0);
3359     if (r == -1)
3360       return -1;
3361   }
3362   {
3363     char pathordevice[] = "/";
3364     int r;
3365     suppress_error = 0;
3366     r = guestfs_umount (g, pathordevice);
3367     if (r == -1)
3368       return -1;
3369   }
3370   {
3371     char device[] = "/dev/VG/LV";
3372     int r;
3373     suppress_error = 0;
3374     r = guestfs_lvresize (g, device, 20);
3375     if (r == -1)
3376       return -1;
3377   }
3378   {
3379     char device[] = "/dev/VG/LV";
3380     int r;
3381     suppress_error = 0;
3382     r = guestfs_e2fsck_f (g, device);
3383     if (r == -1)
3384       return -1;
3385   }
3386   {
3387     char device[] = "/dev/VG/LV";
3388     int r;
3389     suppress_error = 0;
3390     r = guestfs_resize2fs (g, device);
3391     if (r == -1)
3392       return -1;
3393   }
3394   {
3395     char device[] = "/dev/VG/LV";
3396     char mountpoint[] = "/";
3397     int r;
3398     suppress_error = 0;
3399     r = guestfs_mount (g, device, mountpoint);
3400     if (r == -1)
3401       return -1;
3402   }
3403   {
3404     char path[] = "/new";
3405     char *r;
3406     suppress_error = 0;
3407     r = guestfs_cat (g, path);
3408     if (r == NULL)
3409       return -1;
3410     if (strcmp (r, expected) != 0) {
3411       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3412       return -1;
3413     }
3414     free (r);
3415   }
3416   return 0;
3417 }
3418
3419 static int test_zerofree_0_skip (void)
3420 {
3421   const char *str;
3422
3423   str = getenv ("TEST_ONLY");
3424   if (str)
3425     return strstr (str, "zerofree") == NULL;
3426   str = getenv ("SKIP_TEST_ZEROFREE_0");
3427   if (str && strcmp (str, "1") == 0) return 1;
3428   str = getenv ("SKIP_TEST_ZEROFREE");
3429   if (str && strcmp (str, "1") == 0) return 1;
3430   return 0;
3431 }
3432
3433 static int test_zerofree_0 (void)
3434 {
3435   if (test_zerofree_0_skip ()) {
3436     printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3437     return 0;
3438   }
3439
3440   /* InitNone|InitEmpty for test_zerofree_0 */
3441   {
3442     char device[] = "/dev/sda";
3443     int r;
3444     suppress_error = 0;
3445     r = guestfs_blockdev_setrw (g, device);
3446     if (r == -1)
3447       return -1;
3448   }
3449   {
3450     int r;
3451     suppress_error = 0;
3452     r = guestfs_umount_all (g);
3453     if (r == -1)
3454       return -1;
3455   }
3456   {
3457     int r;
3458     suppress_error = 0;
3459     r = guestfs_lvm_remove_all (g);
3460     if (r == -1)
3461       return -1;
3462   }
3463   /* TestOutput for zerofree (0) */
3464   char expected[] = "test file";
3465   {
3466     char device[] = "/dev/sda";
3467     char lines_0[] = ",";
3468     char *lines[] = {
3469       lines_0,
3470       NULL
3471     };
3472     int r;
3473     suppress_error = 0;
3474     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3475     if (r == -1)
3476       return -1;
3477   }
3478   {
3479     char fstype[] = "ext3";
3480     char device[] = "/dev/sda1";
3481     int r;
3482     suppress_error = 0;
3483     r = guestfs_mkfs (g, fstype, device);
3484     if (r == -1)
3485       return -1;
3486   }
3487   {
3488     char device[] = "/dev/sda1";
3489     char mountpoint[] = "/";
3490     int r;
3491     suppress_error = 0;
3492     r = guestfs_mount (g, device, mountpoint);
3493     if (r == -1)
3494       return -1;
3495   }
3496   {
3497     char path[] = "/new";
3498     char content[] = "test file";
3499     int r;
3500     suppress_error = 0;
3501     r = guestfs_write_file (g, path, content, 0);
3502     if (r == -1)
3503       return -1;
3504   }
3505   {
3506     char pathordevice[] = "/dev/sda1";
3507     int r;
3508     suppress_error = 0;
3509     r = guestfs_umount (g, pathordevice);
3510     if (r == -1)
3511       return -1;
3512   }
3513   {
3514     char device[] = "/dev/sda1";
3515     int r;
3516     suppress_error = 0;
3517     r = guestfs_zerofree (g, device);
3518     if (r == -1)
3519       return -1;
3520   }
3521   {
3522     char device[] = "/dev/sda1";
3523     char mountpoint[] = "/";
3524     int r;
3525     suppress_error = 0;
3526     r = guestfs_mount (g, device, mountpoint);
3527     if (r == -1)
3528       return -1;
3529   }
3530   {
3531     char path[] = "/new";
3532     char *r;
3533     suppress_error = 0;
3534     r = guestfs_cat (g, path);
3535     if (r == NULL)
3536       return -1;
3537     if (strcmp (r, expected) != 0) {
3538       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3539       return -1;
3540     }
3541     free (r);
3542   }
3543   return 0;
3544 }
3545
3546 static int test_hexdump_0_skip (void)
3547 {
3548   const char *str;
3549
3550   str = getenv ("TEST_ONLY");
3551   if (str)
3552     return strstr (str, "hexdump") == NULL;
3553   str = getenv ("SKIP_TEST_HEXDUMP_0");
3554   if (str && strcmp (str, "1") == 0) return 1;
3555   str = getenv ("SKIP_TEST_HEXDUMP");
3556   if (str && strcmp (str, "1") == 0) return 1;
3557   return 0;
3558 }
3559
3560 static int test_hexdump_0 (void)
3561 {
3562   if (test_hexdump_0_skip ()) {
3563     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3564     return 0;
3565   }
3566
3567   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3568   {
3569     char device[] = "/dev/sda";
3570     int r;
3571     suppress_error = 0;
3572     r = guestfs_blockdev_setrw (g, device);
3573     if (r == -1)
3574       return -1;
3575   }
3576   {
3577     int r;
3578     suppress_error = 0;
3579     r = guestfs_umount_all (g);
3580     if (r == -1)
3581       return -1;
3582   }
3583   {
3584     int r;
3585     suppress_error = 0;
3586     r = guestfs_lvm_remove_all (g);
3587     if (r == -1)
3588       return -1;
3589   }
3590   {
3591     char device[] = "/dev/sda";
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     int r;
3607     suppress_error = 0;
3608     r = guestfs_mkfs (g, fstype, device);
3609     if (r == -1)
3610       return -1;
3611   }
3612   {
3613     char device[] = "/dev/sda1";
3614     char mountpoint[] = "/";
3615     int r;
3616     suppress_error = 0;
3617     r = guestfs_mount (g, device, mountpoint);
3618     if (r == -1)
3619       return -1;
3620   }
3621   /* TestOutput for hexdump (0) */
3622   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
3623   {
3624     char path[] = "/new";
3625     char content[] = "hello\nworld\n";
3626     int r;
3627     suppress_error = 0;
3628     r = guestfs_write_file (g, path, content, 12);
3629     if (r == -1)
3630       return -1;
3631   }
3632   {
3633     char path[] = "/new";
3634     char *r;
3635     suppress_error = 0;
3636     r = guestfs_hexdump (g, path);
3637     if (r == NULL)
3638       return -1;
3639     if (strcmp (r, expected) != 0) {
3640       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3641       return -1;
3642     }
3643     free (r);
3644   }
3645   return 0;
3646 }
3647
3648 static int test_hexdump_1_skip (void)
3649 {
3650   const char *str;
3651
3652   str = getenv ("TEST_ONLY");
3653   if (str)
3654     return strstr (str, "hexdump") == NULL;
3655   str = getenv ("SKIP_TEST_HEXDUMP_1");
3656   if (str && strcmp (str, "1") == 0) return 1;
3657   str = getenv ("SKIP_TEST_HEXDUMP");
3658   if (str && strcmp (str, "1") == 0) return 1;
3659   return 0;
3660 }
3661
3662 static int test_hexdump_1 (void)
3663 {
3664   if (test_hexdump_1_skip ()) {
3665     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3666     return 0;
3667   }
3668
3669   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3670   {
3671     char device[] = "/dev/sda";
3672     int r;
3673     suppress_error = 0;
3674     r = guestfs_blockdev_setrw (g, device);
3675     if (r == -1)
3676       return -1;
3677   }
3678   {
3679     int r;
3680     suppress_error = 0;
3681     r = guestfs_umount_all (g);
3682     if (r == -1)
3683       return -1;
3684   }
3685   {
3686     int r;
3687     suppress_error = 0;
3688     r = guestfs_lvm_remove_all (g);
3689     if (r == -1)
3690       return -1;
3691   }
3692   {
3693     char device[] = "/dev/sda";
3694     char lines_0[] = ",";
3695     char *lines[] = {
3696       lines_0,
3697       NULL
3698     };
3699     int r;
3700     suppress_error = 0;
3701     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3702     if (r == -1)
3703       return -1;
3704   }
3705   {
3706     char fstype[] = "ext2";
3707     char device[] = "/dev/sda1";
3708     int r;
3709     suppress_error = 0;
3710     r = guestfs_mkfs (g, fstype, device);
3711     if (r == -1)
3712       return -1;
3713   }
3714   {
3715     char device[] = "/dev/sda1";
3716     char mountpoint[] = "/";
3717     int r;
3718     suppress_error = 0;
3719     r = guestfs_mount (g, device, mountpoint);
3720     if (r == -1)
3721       return -1;
3722   }
3723   /* TestRun for hexdump (1) */
3724   {
3725     char options[] = "ro";
3726     char vfstype[] = "squashfs";
3727     char device[] = "/dev/sdd";
3728     char mountpoint[] = "/";
3729     int r;
3730     suppress_error = 0;
3731     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3732     if (r == -1)
3733       return -1;
3734   }
3735   {
3736     char path[] = "/100krandom";
3737     char *r;
3738     suppress_error = 0;
3739     r = guestfs_hexdump (g, path);
3740     if (r == NULL)
3741       return -1;
3742     free (r);
3743   }
3744   return 0;
3745 }
3746
3747 static int test_strings_e_0_skip (void)
3748 {
3749   const char *str;
3750
3751   str = getenv ("TEST_ONLY");
3752   if (str)
3753     return strstr (str, "strings_e") == NULL;
3754   str = getenv ("SKIP_TEST_STRINGS_E_0");
3755   if (str && strcmp (str, "1") == 0) return 1;
3756   str = getenv ("SKIP_TEST_STRINGS_E");
3757   if (str && strcmp (str, "1") == 0) return 1;
3758   return 0;
3759 }
3760
3761 static int test_strings_e_0 (void)
3762 {
3763   if (test_strings_e_0_skip ()) {
3764     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3765     return 0;
3766   }
3767
3768   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3769   {
3770     char device[] = "/dev/sda";
3771     int r;
3772     suppress_error = 0;
3773     r = guestfs_blockdev_setrw (g, device);
3774     if (r == -1)
3775       return -1;
3776   }
3777   {
3778     int r;
3779     suppress_error = 0;
3780     r = guestfs_umount_all (g);
3781     if (r == -1)
3782       return -1;
3783   }
3784   {
3785     int r;
3786     suppress_error = 0;
3787     r = guestfs_lvm_remove_all (g);
3788     if (r == -1)
3789       return -1;
3790   }
3791   {
3792     char device[] = "/dev/sda";
3793     char lines_0[] = ",";
3794     char *lines[] = {
3795       lines_0,
3796       NULL
3797     };
3798     int r;
3799     suppress_error = 0;
3800     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3801     if (r == -1)
3802       return -1;
3803   }
3804   {
3805     char fstype[] = "ext2";
3806     char device[] = "/dev/sda1";
3807     int r;
3808     suppress_error = 0;
3809     r = guestfs_mkfs (g, fstype, device);
3810     if (r == -1)
3811       return -1;
3812   }
3813   {
3814     char device[] = "/dev/sda1";
3815     char mountpoint[] = "/";
3816     int r;
3817     suppress_error = 0;
3818     r = guestfs_mount (g, device, mountpoint);
3819     if (r == -1)
3820       return -1;
3821   }
3822   /* TestOutputList for strings_e (0) */
3823   {
3824     char path[] = "/new";
3825     char content[] = "hello\nworld\n";
3826     int r;
3827     suppress_error = 0;
3828     r = guestfs_write_file (g, path, content, 0);
3829     if (r == -1)
3830       return -1;
3831   }
3832   {
3833     char encoding[] = "b";
3834     char path[] = "/new";
3835     char **r;
3836     int i;
3837     suppress_error = 0;
3838     r = guestfs_strings_e (g, encoding, path);
3839     if (r == NULL)
3840       return -1;
3841     if (r[0] != NULL) {
3842       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
3843       print_strings (r);
3844       return -1;
3845     }
3846     for (i = 0; r[i] != NULL; ++i)
3847       free (r[i]);
3848     free (r);
3849   }
3850   return 0;
3851 }
3852
3853 static int test_strings_e_1_skip (void)
3854 {
3855   const char *str;
3856
3857   str = getenv ("TEST_ONLY");
3858   if (str)
3859     return strstr (str, "strings_e") == NULL;
3860   str = getenv ("SKIP_TEST_STRINGS_E_1");
3861   if (str && strcmp (str, "1") == 0) return 1;
3862   str = getenv ("SKIP_TEST_STRINGS_E");
3863   if (str && strcmp (str, "1") == 0) return 1;
3864   return 0;
3865 }
3866
3867 static int test_strings_e_1 (void)
3868 {
3869   if (test_strings_e_1_skip ()) {
3870     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
3871     return 0;
3872   }
3873
3874   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
3875   return 0;
3876 }
3877
3878 static int test_strings_0_skip (void)
3879 {
3880   const char *str;
3881
3882   str = getenv ("TEST_ONLY");
3883   if (str)
3884     return strstr (str, "strings") == NULL;
3885   str = getenv ("SKIP_TEST_STRINGS_0");
3886   if (str && strcmp (str, "1") == 0) return 1;
3887   str = getenv ("SKIP_TEST_STRINGS");
3888   if (str && strcmp (str, "1") == 0) return 1;
3889   return 0;
3890 }
3891
3892 static int test_strings_0 (void)
3893 {
3894   if (test_strings_0_skip ()) {
3895     printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
3896     return 0;
3897   }
3898
3899   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
3900   {
3901     char device[] = "/dev/sda";
3902     int r;
3903     suppress_error = 0;
3904     r = guestfs_blockdev_setrw (g, device);
3905     if (r == -1)
3906       return -1;
3907   }
3908   {
3909     int r;
3910     suppress_error = 0;
3911     r = guestfs_umount_all (g);
3912     if (r == -1)
3913       return -1;
3914   }
3915   {
3916     int r;
3917     suppress_error = 0;
3918     r = guestfs_lvm_remove_all (g);
3919     if (r == -1)
3920       return -1;
3921   }
3922   {
3923     char device[] = "/dev/sda";
3924     char lines_0[] = ",";
3925     char *lines[] = {
3926       lines_0,
3927       NULL
3928     };
3929     int r;
3930     suppress_error = 0;
3931     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3932     if (r == -1)
3933       return -1;
3934   }
3935   {
3936     char fstype[] = "ext2";
3937     char device[] = "/dev/sda1";
3938     int r;
3939     suppress_error = 0;
3940     r = guestfs_mkfs (g, fstype, device);
3941     if (r == -1)
3942       return -1;
3943   }
3944   {
3945     char device[] = "/dev/sda1";
3946     char mountpoint[] = "/";
3947     int r;
3948     suppress_error = 0;
3949     r = guestfs_mount (g, device, mountpoint);
3950     if (r == -1)
3951       return -1;
3952   }
3953   /* TestOutputList for strings (0) */
3954   {
3955     char path[] = "/new";
3956     char content[] = "hello\nworld\n";
3957     int r;
3958     suppress_error = 0;
3959     r = guestfs_write_file (g, path, content, 0);
3960     if (r == -1)
3961       return -1;
3962   }
3963   {
3964     char path[] = "/new";
3965     char **r;
3966     int i;
3967     suppress_error = 0;
3968     r = guestfs_strings (g, path);
3969     if (r == NULL)
3970       return -1;
3971     if (!r[0]) {
3972       fprintf (stderr, "test_strings_0: short list returned from command\n");
3973       print_strings (r);
3974       return -1;
3975     }
3976     {
3977       char expected[] = "hello";
3978       if (strcmp (r[0], expected) != 0) {
3979         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3980         return -1;
3981       }
3982     }
3983     if (!r[1]) {
3984       fprintf (stderr, "test_strings_0: short list returned from command\n");
3985       print_strings (r);
3986       return -1;
3987     }
3988     {
3989       char expected[] = "world";
3990       if (strcmp (r[1], expected) != 0) {
3991         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3992         return -1;
3993       }
3994     }
3995     if (r[2] != NULL) {
3996       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
3997       print_strings (r);
3998       return -1;
3999     }
4000     for (i = 0; r[i] != NULL; ++i)
4001       free (r[i]);
4002     free (r);
4003   }
4004   return 0;
4005 }
4006
4007 static int test_strings_1_skip (void)
4008 {
4009   const char *str;
4010
4011   str = getenv ("TEST_ONLY");
4012   if (str)
4013     return strstr (str, "strings") == NULL;
4014   str = getenv ("SKIP_TEST_STRINGS_1");
4015   if (str && strcmp (str, "1") == 0) return 1;
4016   str = getenv ("SKIP_TEST_STRINGS");
4017   if (str && strcmp (str, "1") == 0) return 1;
4018   return 0;
4019 }
4020
4021 static int test_strings_1 (void)
4022 {
4023   if (test_strings_1_skip ()) {
4024     printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
4025     return 0;
4026   }
4027
4028   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4029   {
4030     char device[] = "/dev/sda";
4031     int r;
4032     suppress_error = 0;
4033     r = guestfs_blockdev_setrw (g, device);
4034     if (r == -1)
4035       return -1;
4036   }
4037   {
4038     int r;
4039     suppress_error = 0;
4040     r = guestfs_umount_all (g);
4041     if (r == -1)
4042       return -1;
4043   }
4044   {
4045     int r;
4046     suppress_error = 0;
4047     r = guestfs_lvm_remove_all (g);
4048     if (r == -1)
4049       return -1;
4050   }
4051   {
4052     char device[] = "/dev/sda";
4053     char lines_0[] = ",";
4054     char *lines[] = {
4055       lines_0,
4056       NULL
4057     };
4058     int r;
4059     suppress_error = 0;
4060     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4061     if (r == -1)
4062       return -1;
4063   }
4064   {
4065     char fstype[] = "ext2";
4066     char device[] = "/dev/sda1";
4067     int r;
4068     suppress_error = 0;
4069     r = guestfs_mkfs (g, fstype, device);
4070     if (r == -1)
4071       return -1;
4072   }
4073   {
4074     char device[] = "/dev/sda1";
4075     char mountpoint[] = "/";
4076     int r;
4077     suppress_error = 0;
4078     r = guestfs_mount (g, device, mountpoint);
4079     if (r == -1)
4080       return -1;
4081   }
4082   /* TestOutputList for strings (1) */
4083   {
4084     char path[] = "/new";
4085     int r;
4086     suppress_error = 0;
4087     r = guestfs_touch (g, path);
4088     if (r == -1)
4089       return -1;
4090   }
4091   {
4092     char path[] = "/new";
4093     char **r;
4094     int i;
4095     suppress_error = 0;
4096     r = guestfs_strings (g, path);
4097     if (r == NULL)
4098       return -1;
4099     if (r[0] != NULL) {
4100       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4101       print_strings (r);
4102       return -1;
4103     }
4104     for (i = 0; r[i] != NULL; ++i)
4105       free (r[i]);
4106     free (r);
4107   }
4108   return 0;
4109 }
4110
4111 static int test_equal_0_skip (void)
4112 {
4113   const char *str;
4114
4115   str = getenv ("TEST_ONLY");
4116   if (str)
4117     return strstr (str, "equal") == NULL;
4118   str = getenv ("SKIP_TEST_EQUAL_0");
4119   if (str && strcmp (str, "1") == 0) return 1;
4120   str = getenv ("SKIP_TEST_EQUAL");
4121   if (str && strcmp (str, "1") == 0) return 1;
4122   return 0;
4123 }
4124
4125 static int test_equal_0 (void)
4126 {
4127   if (test_equal_0_skip ()) {
4128     printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
4129     return 0;
4130   }
4131
4132   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4133   {
4134     char device[] = "/dev/sda";
4135     int r;
4136     suppress_error = 0;
4137     r = guestfs_blockdev_setrw (g, device);
4138     if (r == -1)
4139       return -1;
4140   }
4141   {
4142     int r;
4143     suppress_error = 0;
4144     r = guestfs_umount_all (g);
4145     if (r == -1)
4146       return -1;
4147   }
4148   {
4149     int r;
4150     suppress_error = 0;
4151     r = guestfs_lvm_remove_all (g);
4152     if (r == -1)
4153       return -1;
4154   }
4155   {
4156     char device[] = "/dev/sda";
4157     char lines_0[] = ",";
4158     char *lines[] = {
4159       lines_0,
4160       NULL
4161     };
4162     int r;
4163     suppress_error = 0;
4164     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4165     if (r == -1)
4166       return -1;
4167   }
4168   {
4169     char fstype[] = "ext2";
4170     char device[] = "/dev/sda1";
4171     int r;
4172     suppress_error = 0;
4173     r = guestfs_mkfs (g, fstype, device);
4174     if (r == -1)
4175       return -1;
4176   }
4177   {
4178     char device[] = "/dev/sda1";
4179     char mountpoint[] = "/";
4180     int r;
4181     suppress_error = 0;
4182     r = guestfs_mount (g, device, mountpoint);
4183     if (r == -1)
4184       return -1;
4185   }
4186   /* TestOutputTrue for equal (0) */
4187   {
4188     char path[] = "/file1";
4189     char content[] = "contents of a file";
4190     int r;
4191     suppress_error = 0;
4192     r = guestfs_write_file (g, path, content, 0);
4193     if (r == -1)
4194       return -1;
4195   }
4196   {
4197     char src[] = "/file1";
4198     char dest[] = "/file2";
4199     int r;
4200     suppress_error = 0;
4201     r = guestfs_cp (g, src, dest);
4202     if (r == -1)
4203       return -1;
4204   }
4205   {
4206     char file1[] = "/file1";
4207     char file2[] = "/file2";
4208     int r;
4209     suppress_error = 0;
4210     r = guestfs_equal (g, file1, file2);
4211     if (r == -1)
4212       return -1;
4213     if (!r) {
4214       fprintf (stderr, "test_equal_0: expected true, got false\n");
4215       return -1;
4216     }
4217   }
4218   return 0;
4219 }
4220
4221 static int test_equal_1_skip (void)
4222 {
4223   const char *str;
4224
4225   str = getenv ("TEST_ONLY");
4226   if (str)
4227     return strstr (str, "equal") == NULL;
4228   str = getenv ("SKIP_TEST_EQUAL_1");
4229   if (str && strcmp (str, "1") == 0) return 1;
4230   str = getenv ("SKIP_TEST_EQUAL");
4231   if (str && strcmp (str, "1") == 0) return 1;
4232   return 0;
4233 }
4234
4235 static int test_equal_1 (void)
4236 {
4237   if (test_equal_1_skip ()) {
4238     printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4239     return 0;
4240   }
4241
4242   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4243   {
4244     char device[] = "/dev/sda";
4245     int r;
4246     suppress_error = 0;
4247     r = guestfs_blockdev_setrw (g, device);
4248     if (r == -1)
4249       return -1;
4250   }
4251   {
4252     int r;
4253     suppress_error = 0;
4254     r = guestfs_umount_all (g);
4255     if (r == -1)
4256       return -1;
4257   }
4258   {
4259     int r;
4260     suppress_error = 0;
4261     r = guestfs_lvm_remove_all (g);
4262     if (r == -1)
4263       return -1;
4264   }
4265   {
4266     char device[] = "/dev/sda";
4267     char lines_0[] = ",";
4268     char *lines[] = {
4269       lines_0,
4270       NULL
4271     };
4272     int r;
4273     suppress_error = 0;
4274     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4275     if (r == -1)
4276       return -1;
4277   }
4278   {
4279     char fstype[] = "ext2";
4280     char device[] = "/dev/sda1";
4281     int r;
4282     suppress_error = 0;
4283     r = guestfs_mkfs (g, fstype, device);
4284     if (r == -1)
4285       return -1;
4286   }
4287   {
4288     char device[] = "/dev/sda1";
4289     char mountpoint[] = "/";
4290     int r;
4291     suppress_error = 0;
4292     r = guestfs_mount (g, device, mountpoint);
4293     if (r == -1)
4294       return -1;
4295   }
4296   /* TestOutputFalse for equal (1) */
4297   {
4298     char path[] = "/file1";
4299     char content[] = "contents of a file";
4300     int r;
4301     suppress_error = 0;
4302     r = guestfs_write_file (g, path, content, 0);
4303     if (r == -1)
4304       return -1;
4305   }
4306   {
4307     char path[] = "/file2";
4308     char content[] = "contents of another file";
4309     int r;
4310     suppress_error = 0;
4311     r = guestfs_write_file (g, path, content, 0);
4312     if (r == -1)
4313       return -1;
4314   }
4315   {
4316     char file1[] = "/file1";
4317     char file2[] = "/file2";
4318     int r;
4319     suppress_error = 0;
4320     r = guestfs_equal (g, file1, file2);
4321     if (r == -1)
4322       return -1;
4323     if (r) {
4324       fprintf (stderr, "test_equal_1: expected false, got true\n");
4325       return -1;
4326     }
4327   }
4328   return 0;
4329 }
4330
4331 static int test_equal_2_skip (void)
4332 {
4333   const char *str;
4334
4335   str = getenv ("TEST_ONLY");
4336   if (str)
4337     return strstr (str, "equal") == NULL;
4338   str = getenv ("SKIP_TEST_EQUAL_2");
4339   if (str && strcmp (str, "1") == 0) return 1;
4340   str = getenv ("SKIP_TEST_EQUAL");
4341   if (str && strcmp (str, "1") == 0) return 1;
4342   return 0;
4343 }
4344
4345 static int test_equal_2 (void)
4346 {
4347   if (test_equal_2_skip ()) {
4348     printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4349     return 0;
4350   }
4351
4352   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4353   {
4354     char device[] = "/dev/sda";
4355     int r;
4356     suppress_error = 0;
4357     r = guestfs_blockdev_setrw (g, device);
4358     if (r == -1)
4359       return -1;
4360   }
4361   {
4362     int r;
4363     suppress_error = 0;
4364     r = guestfs_umount_all (g);
4365     if (r == -1)
4366       return -1;
4367   }
4368   {
4369     int r;
4370     suppress_error = 0;
4371     r = guestfs_lvm_remove_all (g);
4372     if (r == -1)
4373       return -1;
4374   }
4375   {
4376     char device[] = "/dev/sda";
4377     char lines_0[] = ",";
4378     char *lines[] = {
4379       lines_0,
4380       NULL
4381     };
4382     int r;
4383     suppress_error = 0;
4384     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4385     if (r == -1)
4386       return -1;
4387   }
4388   {
4389     char fstype[] = "ext2";
4390     char device[] = "/dev/sda1";
4391     int r;
4392     suppress_error = 0;
4393     r = guestfs_mkfs (g, fstype, device);
4394     if (r == -1)
4395       return -1;
4396   }
4397   {
4398     char device[] = "/dev/sda1";
4399     char mountpoint[] = "/";
4400     int r;
4401     suppress_error = 0;
4402     r = guestfs_mount (g, device, mountpoint);
4403     if (r == -1)
4404       return -1;
4405   }
4406   /* TestLastFail for equal (2) */
4407   {
4408     char file1[] = "/file1";
4409     char file2[] = "/file2";
4410     int r;
4411     suppress_error = 1;
4412     r = guestfs_equal (g, file1, file2);
4413     if (r != -1)
4414       return -1;
4415   }
4416   return 0;
4417 }
4418
4419 static int test_ping_daemon_0_skip (void)
4420 {
4421   const char *str;
4422
4423   str = getenv ("TEST_ONLY");
4424   if (str)
4425     return strstr (str, "ping_daemon") == NULL;
4426   str = getenv ("SKIP_TEST_PING_DAEMON_0");
4427   if (str && strcmp (str, "1") == 0) return 1;
4428   str = getenv ("SKIP_TEST_PING_DAEMON");
4429   if (str && strcmp (str, "1") == 0) return 1;
4430   return 0;
4431 }
4432
4433 static int test_ping_daemon_0 (void)
4434 {
4435   if (test_ping_daemon_0_skip ()) {
4436     printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4437     return 0;
4438   }
4439
4440   /* InitNone|InitEmpty for test_ping_daemon_0 */
4441   {
4442     char device[] = "/dev/sda";
4443     int r;
4444     suppress_error = 0;
4445     r = guestfs_blockdev_setrw (g, device);
4446     if (r == -1)
4447       return -1;
4448   }
4449   {
4450     int r;
4451     suppress_error = 0;
4452     r = guestfs_umount_all (g);
4453     if (r == -1)
4454       return -1;
4455   }
4456   {
4457     int r;
4458     suppress_error = 0;
4459     r = guestfs_lvm_remove_all (g);
4460     if (r == -1)
4461       return -1;
4462   }
4463   /* TestRun for ping_daemon (0) */
4464   {
4465     int r;
4466     suppress_error = 0;
4467     r = guestfs_ping_daemon (g);
4468     if (r == -1)
4469       return -1;
4470   }
4471   return 0;
4472 }
4473
4474 static int test_dmesg_0_skip (void)
4475 {
4476   const char *str;
4477
4478   str = getenv ("TEST_ONLY");
4479   if (str)
4480     return strstr (str, "dmesg") == NULL;
4481   str = getenv ("SKIP_TEST_DMESG_0");
4482   if (str && strcmp (str, "1") == 0) return 1;
4483   str = getenv ("SKIP_TEST_DMESG");
4484   if (str && strcmp (str, "1") == 0) return 1;
4485   return 0;
4486 }
4487
4488 static int test_dmesg_0 (void)
4489 {
4490   if (test_dmesg_0_skip ()) {
4491     printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4492     return 0;
4493   }
4494
4495   /* InitNone|InitEmpty for test_dmesg_0 */
4496   {
4497     char device[] = "/dev/sda";
4498     int r;
4499     suppress_error = 0;
4500     r = guestfs_blockdev_setrw (g, device);
4501     if (r == -1)
4502       return -1;
4503   }
4504   {
4505     int r;
4506     suppress_error = 0;
4507     r = guestfs_umount_all (g);
4508     if (r == -1)
4509       return -1;
4510   }
4511   {
4512     int r;
4513     suppress_error = 0;
4514     r = guestfs_lvm_remove_all (g);
4515     if (r == -1)
4516       return -1;
4517   }
4518   /* TestRun for dmesg (0) */
4519   {
4520     char *r;
4521     suppress_error = 0;
4522     r = guestfs_dmesg (g);
4523     if (r == NULL)
4524       return -1;
4525     free (r);
4526   }
4527   return 0;
4528 }
4529
4530 static int test_drop_caches_0_skip (void)
4531 {
4532   const char *str;
4533
4534   str = getenv ("TEST_ONLY");
4535   if (str)
4536     return strstr (str, "drop_caches") == NULL;
4537   str = getenv ("SKIP_TEST_DROP_CACHES_0");
4538   if (str && strcmp (str, "1") == 0) return 1;
4539   str = getenv ("SKIP_TEST_DROP_CACHES");
4540   if (str && strcmp (str, "1") == 0) return 1;
4541   return 0;
4542 }
4543
4544 static int test_drop_caches_0 (void)
4545 {
4546   if (test_drop_caches_0_skip ()) {
4547     printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4548     return 0;
4549   }
4550
4551   /* InitNone|InitEmpty for test_drop_caches_0 */
4552   {
4553     char device[] = "/dev/sda";
4554     int r;
4555     suppress_error = 0;
4556     r = guestfs_blockdev_setrw (g, device);
4557     if (r == -1)
4558       return -1;
4559   }
4560   {
4561     int r;
4562     suppress_error = 0;
4563     r = guestfs_umount_all (g);
4564     if (r == -1)
4565       return -1;
4566   }
4567   {
4568     int r;
4569     suppress_error = 0;
4570     r = guestfs_lvm_remove_all (g);
4571     if (r == -1)
4572       return -1;
4573   }
4574   /* TestRun for drop_caches (0) */
4575   {
4576     int r;
4577     suppress_error = 0;
4578     r = guestfs_drop_caches (g, 3);
4579     if (r == -1)
4580       return -1;
4581   }
4582   return 0;
4583 }
4584
4585 static int test_mv_0_skip (void)
4586 {
4587   const char *str;
4588
4589   str = getenv ("TEST_ONLY");
4590   if (str)
4591     return strstr (str, "mv") == NULL;
4592   str = getenv ("SKIP_TEST_MV_0");
4593   if (str && strcmp (str, "1") == 0) return 1;
4594   str = getenv ("SKIP_TEST_MV");
4595   if (str && strcmp (str, "1") == 0) return 1;
4596   return 0;
4597 }
4598
4599 static int test_mv_0 (void)
4600 {
4601   if (test_mv_0_skip ()) {
4602     printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4603     return 0;
4604   }
4605
4606   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4607   {
4608     char device[] = "/dev/sda";
4609     int r;
4610     suppress_error = 0;
4611     r = guestfs_blockdev_setrw (g, device);
4612     if (r == -1)
4613       return -1;
4614   }
4615   {
4616     int r;
4617     suppress_error = 0;
4618     r = guestfs_umount_all (g);
4619     if (r == -1)
4620       return -1;
4621   }
4622   {
4623     int r;
4624     suppress_error = 0;
4625     r = guestfs_lvm_remove_all (g);
4626     if (r == -1)
4627       return -1;
4628   }
4629   {
4630     char device[] = "/dev/sda";
4631     char lines_0[] = ",";
4632     char *lines[] = {
4633       lines_0,
4634       NULL
4635     };
4636     int r;
4637     suppress_error = 0;
4638     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4639     if (r == -1)
4640       return -1;
4641   }
4642   {
4643     char fstype[] = "ext2";
4644     char device[] = "/dev/sda1";
4645     int r;
4646     suppress_error = 0;
4647     r = guestfs_mkfs (g, fstype, device);
4648     if (r == -1)
4649       return -1;
4650   }
4651   {
4652     char device[] = "/dev/sda1";
4653     char mountpoint[] = "/";
4654     int r;
4655     suppress_error = 0;
4656     r = guestfs_mount (g, device, mountpoint);
4657     if (r == -1)
4658       return -1;
4659   }
4660   /* TestOutput for mv (0) */
4661   char expected[] = "file content";
4662   {
4663     char path[] = "/old";
4664     char content[] = "file content";
4665     int r;
4666     suppress_error = 0;
4667     r = guestfs_write_file (g, path, content, 0);
4668     if (r == -1)
4669       return -1;
4670   }
4671   {
4672     char src[] = "/old";
4673     char dest[] = "/new";
4674     int r;
4675     suppress_error = 0;
4676     r = guestfs_mv (g, src, dest);
4677     if (r == -1)
4678       return -1;
4679   }
4680   {
4681     char path[] = "/new";
4682     char *r;
4683     suppress_error = 0;
4684     r = guestfs_cat (g, path);
4685     if (r == NULL)
4686       return -1;
4687     if (strcmp (r, expected) != 0) {
4688       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4689       return -1;
4690     }
4691     free (r);
4692   }
4693   return 0;
4694 }
4695
4696 static int test_mv_1_skip (void)
4697 {
4698   const char *str;
4699
4700   str = getenv ("TEST_ONLY");
4701   if (str)
4702     return strstr (str, "mv") == NULL;
4703   str = getenv ("SKIP_TEST_MV_1");
4704   if (str && strcmp (str, "1") == 0) return 1;
4705   str = getenv ("SKIP_TEST_MV");
4706   if (str && strcmp (str, "1") == 0) return 1;
4707   return 0;
4708 }
4709
4710 static int test_mv_1 (void)
4711 {
4712   if (test_mv_1_skip ()) {
4713     printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4714     return 0;
4715   }
4716
4717   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4718   {
4719     char device[] = "/dev/sda";
4720     int r;
4721     suppress_error = 0;
4722     r = guestfs_blockdev_setrw (g, device);
4723     if (r == -1)
4724       return -1;
4725   }
4726   {
4727     int r;
4728     suppress_error = 0;
4729     r = guestfs_umount_all (g);
4730     if (r == -1)
4731       return -1;
4732   }
4733   {
4734     int r;
4735     suppress_error = 0;
4736     r = guestfs_lvm_remove_all (g);
4737     if (r == -1)
4738       return -1;
4739   }
4740   {
4741     char device[] = "/dev/sda";
4742     char lines_0[] = ",";
4743     char *lines[] = {
4744       lines_0,
4745       NULL
4746     };
4747     int r;
4748     suppress_error = 0;
4749     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4750     if (r == -1)
4751       return -1;
4752   }
4753   {
4754     char fstype[] = "ext2";
4755     char device[] = "/dev/sda1";
4756     int r;
4757     suppress_error = 0;
4758     r = guestfs_mkfs (g, fstype, device);
4759     if (r == -1)
4760       return -1;
4761   }
4762   {
4763     char device[] = "/dev/sda1";
4764     char mountpoint[] = "/";
4765     int r;
4766     suppress_error = 0;
4767     r = guestfs_mount (g, device, mountpoint);
4768     if (r == -1)
4769       return -1;
4770   }
4771   /* TestOutputFalse for mv (1) */
4772   {
4773     char path[] = "/old";
4774     char content[] = "file content";
4775     int r;
4776     suppress_error = 0;
4777     r = guestfs_write_file (g, path, content, 0);
4778     if (r == -1)
4779       return -1;
4780   }
4781   {
4782     char src[] = "/old";
4783     char dest[] = "/new";
4784     int r;
4785     suppress_error = 0;
4786     r = guestfs_mv (g, src, dest);
4787     if (r == -1)
4788       return -1;
4789   }
4790   {
4791     char path[] = "/old";
4792     int r;
4793     suppress_error = 0;
4794     r = guestfs_is_file (g, path);
4795     if (r == -1)
4796       return -1;
4797     if (r) {
4798       fprintf (stderr, "test_mv_1: expected false, got true\n");
4799       return -1;
4800     }
4801   }
4802   return 0;
4803 }
4804
4805 static int test_cp_a_0_skip (void)
4806 {
4807   const char *str;
4808
4809   str = getenv ("TEST_ONLY");
4810   if (str)
4811     return strstr (str, "cp_a") == NULL;
4812   str = getenv ("SKIP_TEST_CP_A_0");
4813   if (str && strcmp (str, "1") == 0) return 1;
4814   str = getenv ("SKIP_TEST_CP_A");
4815   if (str && strcmp (str, "1") == 0) return 1;
4816   return 0;
4817 }
4818
4819 static int test_cp_a_0 (void)
4820 {
4821   if (test_cp_a_0_skip ()) {
4822     printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
4823     return 0;
4824   }
4825
4826   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
4827   {
4828     char device[] = "/dev/sda";
4829     int r;
4830     suppress_error = 0;
4831     r = guestfs_blockdev_setrw (g, device);
4832     if (r == -1)
4833       return -1;
4834   }
4835   {
4836     int r;
4837     suppress_error = 0;
4838     r = guestfs_umount_all (g);
4839     if (r == -1)
4840       return -1;
4841   }
4842   {
4843     int r;
4844     suppress_error = 0;
4845     r = guestfs_lvm_remove_all (g);
4846     if (r == -1)
4847       return -1;
4848   }
4849   {
4850     char device[] = "/dev/sda";
4851     char lines_0[] = ",";
4852     char *lines[] = {
4853       lines_0,
4854       NULL
4855     };
4856     int r;
4857     suppress_error = 0;
4858     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4859     if (r == -1)
4860       return -1;
4861   }
4862   {
4863     char fstype[] = "ext2";
4864     char device[] = "/dev/sda1";
4865     int r;
4866     suppress_error = 0;
4867     r = guestfs_mkfs (g, fstype, device);
4868     if (r == -1)
4869       return -1;
4870   }
4871   {
4872     char device[] = "/dev/sda1";
4873     char mountpoint[] = "/";
4874     int r;
4875     suppress_error = 0;
4876     r = guestfs_mount (g, device, mountpoint);
4877     if (r == -1)
4878       return -1;
4879   }
4880   /* TestOutput for cp_a (0) */
4881   char expected[] = "file content";
4882   {
4883     char path[] = "/olddir";
4884     int r;
4885     suppress_error = 0;
4886     r = guestfs_mkdir (g, path);
4887     if (r == -1)
4888       return -1;
4889   }
4890   {
4891     char path[] = "/newdir";
4892     int r;
4893     suppress_error = 0;
4894     r = guestfs_mkdir (g, path);
4895     if (r == -1)
4896       return -1;
4897   }
4898   {
4899     char path[] = "/olddir/file";
4900     char content[] = "file content";
4901     int r;
4902     suppress_error = 0;
4903     r = guestfs_write_file (g, path, content, 0);
4904     if (r == -1)
4905       return -1;
4906   }
4907   {
4908     char src[] = "/olddir";
4909     char dest[] = "/newdir";
4910     int r;
4911     suppress_error = 0;
4912     r = guestfs_cp_a (g, src, dest);
4913     if (r == -1)
4914       return -1;
4915   }
4916   {
4917     char path[] = "/newdir/olddir/file";
4918     char *r;
4919     suppress_error = 0;
4920     r = guestfs_cat (g, path);
4921     if (r == NULL)
4922       return -1;
4923     if (strcmp (r, expected) != 0) {
4924       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
4925       return -1;
4926     }
4927     free (r);
4928   }
4929   return 0;
4930 }
4931
4932 static int test_cp_0_skip (void)
4933 {
4934   const char *str;
4935
4936   str = getenv ("TEST_ONLY");
4937   if (str)
4938     return strstr (str, "cp") == NULL;
4939   str = getenv ("SKIP_TEST_CP_0");
4940   if (str && strcmp (str, "1") == 0) return 1;
4941   str = getenv ("SKIP_TEST_CP");
4942   if (str && strcmp (str, "1") == 0) return 1;
4943   return 0;
4944 }
4945
4946 static int test_cp_0 (void)
4947 {
4948   if (test_cp_0_skip ()) {
4949     printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
4950     return 0;
4951   }
4952
4953   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
4954   {
4955     char device[] = "/dev/sda";
4956     int r;
4957     suppress_error = 0;
4958     r = guestfs_blockdev_setrw (g, device);
4959     if (r == -1)
4960       return -1;
4961   }
4962   {
4963     int r;
4964     suppress_error = 0;
4965     r = guestfs_umount_all (g);
4966     if (r == -1)
4967       return -1;
4968   }
4969   {
4970     int r;
4971     suppress_error = 0;
4972     r = guestfs_lvm_remove_all (g);
4973     if (r == -1)
4974       return -1;
4975   }
4976   {
4977     char device[] = "/dev/sda";
4978     char lines_0[] = ",";
4979     char *lines[] = {
4980       lines_0,
4981       NULL
4982     };
4983     int r;
4984     suppress_error = 0;
4985     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4986     if (r == -1)
4987       return -1;
4988   }
4989   {
4990     char fstype[] = "ext2";
4991     char device[] = "/dev/sda1";
4992     int r;
4993     suppress_error = 0;
4994     r = guestfs_mkfs (g, fstype, device);
4995     if (r == -1)
4996       return -1;
4997   }
4998   {
4999     char device[] = "/dev/sda1";
5000     char mountpoint[] = "/";
5001     int r;
5002     suppress_error = 0;
5003     r = guestfs_mount (g, device, mountpoint);
5004     if (r == -1)
5005       return -1;
5006   }
5007   /* TestOutput for cp (0) */
5008   char expected[] = "file content";
5009   {
5010     char path[] = "/old";
5011     char content[] = "file content";
5012     int r;
5013     suppress_error = 0;
5014     r = guestfs_write_file (g, path, content, 0);
5015     if (r == -1)
5016       return -1;
5017   }
5018   {
5019     char src[] = "/old";
5020     char dest[] = "/new";
5021     int r;
5022     suppress_error = 0;
5023     r = guestfs_cp (g, src, dest);
5024     if (r == -1)
5025       return -1;
5026   }
5027   {
5028     char path[] = "/new";
5029     char *r;
5030     suppress_error = 0;
5031     r = guestfs_cat (g, path);
5032     if (r == NULL)
5033       return -1;
5034     if (strcmp (r, expected) != 0) {
5035       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5036       return -1;
5037     }
5038     free (r);
5039   }
5040   return 0;
5041 }
5042
5043 static int test_cp_1_skip (void)
5044 {
5045   const char *str;
5046
5047   str = getenv ("TEST_ONLY");
5048   if (str)
5049     return strstr (str, "cp") == NULL;
5050   str = getenv ("SKIP_TEST_CP_1");
5051   if (str && strcmp (str, "1") == 0) return 1;
5052   str = getenv ("SKIP_TEST_CP");
5053   if (str && strcmp (str, "1") == 0) return 1;
5054   return 0;
5055 }
5056
5057 static int test_cp_1 (void)
5058 {
5059   if (test_cp_1_skip ()) {
5060     printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
5061     return 0;
5062   }
5063
5064   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5065   {
5066     char device[] = "/dev/sda";
5067     int r;
5068     suppress_error = 0;
5069     r = guestfs_blockdev_setrw (g, device);
5070     if (r == -1)
5071       return -1;
5072   }
5073   {
5074     int r;
5075     suppress_error = 0;
5076     r = guestfs_umount_all (g);
5077     if (r == -1)
5078       return -1;
5079   }
5080   {
5081     int r;
5082     suppress_error = 0;
5083     r = guestfs_lvm_remove_all (g);
5084     if (r == -1)
5085       return -1;
5086   }
5087   {
5088     char device[] = "/dev/sda";
5089     char lines_0[] = ",";
5090     char *lines[] = {
5091       lines_0,
5092       NULL
5093     };
5094     int r;
5095     suppress_error = 0;
5096     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5097     if (r == -1)
5098       return -1;
5099   }
5100   {
5101     char fstype[] = "ext2";
5102     char device[] = "/dev/sda1";
5103     int r;
5104     suppress_error = 0;
5105     r = guestfs_mkfs (g, fstype, device);
5106     if (r == -1)
5107       return -1;
5108   }
5109   {
5110     char device[] = "/dev/sda1";
5111     char mountpoint[] = "/";
5112     int r;
5113     suppress_error = 0;
5114     r = guestfs_mount (g, device, mountpoint);
5115     if (r == -1)
5116       return -1;
5117   }
5118   /* TestOutputTrue for cp (1) */
5119   {
5120     char path[] = "/old";
5121     char content[] = "file content";
5122     int r;
5123     suppress_error = 0;
5124     r = guestfs_write_file (g, path, content, 0);
5125     if (r == -1)
5126       return -1;
5127   }
5128   {
5129     char src[] = "/old";
5130     char dest[] = "/new";
5131     int r;
5132     suppress_error = 0;
5133     r = guestfs_cp (g, src, dest);
5134     if (r == -1)
5135       return -1;
5136   }
5137   {
5138     char path[] = "/old";
5139     int r;
5140     suppress_error = 0;
5141     r = guestfs_is_file (g, path);
5142     if (r == -1)
5143       return -1;
5144     if (!r) {
5145       fprintf (stderr, "test_cp_1: expected true, got false\n");
5146       return -1;
5147     }
5148   }
5149   return 0;
5150 }
5151
5152 static int test_cp_2_skip (void)
5153 {
5154   const char *str;
5155
5156   str = getenv ("TEST_ONLY");
5157   if (str)
5158     return strstr (str, "cp") == NULL;
5159   str = getenv ("SKIP_TEST_CP_2");
5160   if (str && strcmp (str, "1") == 0) return 1;
5161   str = getenv ("SKIP_TEST_CP");
5162   if (str && strcmp (str, "1") == 0) return 1;
5163   return 0;
5164 }
5165
5166 static int test_cp_2 (void)
5167 {
5168   if (test_cp_2_skip ()) {
5169     printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5170     return 0;
5171   }
5172
5173   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5174   {
5175     char device[] = "/dev/sda";
5176     int r;
5177     suppress_error = 0;
5178     r = guestfs_blockdev_setrw (g, device);
5179     if (r == -1)
5180       return -1;
5181   }
5182   {
5183     int r;
5184     suppress_error = 0;
5185     r = guestfs_umount_all (g);
5186     if (r == -1)
5187       return -1;
5188   }
5189   {
5190     int r;
5191     suppress_error = 0;
5192     r = guestfs_lvm_remove_all (g);
5193     if (r == -1)
5194       return -1;
5195   }
5196   {
5197     char device[] = "/dev/sda";
5198     char lines_0[] = ",";
5199     char *lines[] = {
5200       lines_0,
5201       NULL
5202     };
5203     int r;
5204     suppress_error = 0;
5205     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5206     if (r == -1)
5207       return -1;
5208   }
5209   {
5210     char fstype[] = "ext2";
5211     char device[] = "/dev/sda1";
5212     int r;
5213     suppress_error = 0;
5214     r = guestfs_mkfs (g, fstype, device);
5215     if (r == -1)
5216       return -1;
5217   }
5218   {
5219     char device[] = "/dev/sda1";
5220     char mountpoint[] = "/";
5221     int r;
5222     suppress_error = 0;
5223     r = guestfs_mount (g, device, mountpoint);
5224     if (r == -1)
5225       return -1;
5226   }
5227   /* TestOutput for cp (2) */
5228   char expected[] = "file content";
5229   {
5230     char path[] = "/old";
5231     char content[] = "file content";
5232     int r;
5233     suppress_error = 0;
5234     r = guestfs_write_file (g, path, content, 0);
5235     if (r == -1)
5236       return -1;
5237   }
5238   {
5239     char path[] = "/dir";
5240     int r;
5241     suppress_error = 0;
5242     r = guestfs_mkdir (g, path);
5243     if (r == -1)
5244       return -1;
5245   }
5246   {
5247     char src[] = "/old";
5248     char dest[] = "/dir/new";
5249     int r;
5250     suppress_error = 0;
5251     r = guestfs_cp (g, src, dest);
5252     if (r == -1)
5253       return -1;
5254   }
5255   {
5256     char path[] = "/dir/new";
5257     char *r;
5258     suppress_error = 0;
5259     r = guestfs_cat (g, path);
5260     if (r == NULL)
5261       return -1;
5262     if (strcmp (r, expected) != 0) {
5263       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5264       return -1;
5265     }
5266     free (r);
5267   }
5268   return 0;
5269 }
5270
5271 static int test_grub_install_0_skip (void)
5272 {
5273   const char *str;
5274
5275   str = getenv ("TEST_ONLY");
5276   if (str)
5277     return strstr (str, "grub_install") == NULL;
5278   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5279   if (str && strcmp (str, "1") == 0) return 1;
5280   str = getenv ("SKIP_TEST_GRUB_INSTALL");
5281   if (str && strcmp (str, "1") == 0) return 1;
5282   return 0;
5283 }
5284
5285 static int test_grub_install_0 (void)
5286 {
5287   if (test_grub_install_0_skip ()) {
5288     printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5289     return 0;
5290   }
5291
5292   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5293   {
5294     char device[] = "/dev/sda";
5295     int r;
5296     suppress_error = 0;
5297     r = guestfs_blockdev_setrw (g, device);
5298     if (r == -1)
5299       return -1;
5300   }
5301   {
5302     int r;
5303     suppress_error = 0;
5304     r = guestfs_umount_all (g);
5305     if (r == -1)
5306       return -1;
5307   }
5308   {
5309     int r;
5310     suppress_error = 0;
5311     r = guestfs_lvm_remove_all (g);
5312     if (r == -1)
5313       return -1;
5314   }
5315   {
5316     char device[] = "/dev/sda";
5317     char lines_0[] = ",";
5318     char *lines[] = {
5319       lines_0,
5320       NULL
5321     };
5322     int r;
5323     suppress_error = 0;
5324     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5325     if (r == -1)
5326       return -1;
5327   }
5328   {
5329     char fstype[] = "ext2";
5330     char device[] = "/dev/sda1";
5331     int r;
5332     suppress_error = 0;
5333     r = guestfs_mkfs (g, fstype, device);
5334     if (r == -1)
5335       return -1;
5336   }
5337   {
5338     char device[] = "/dev/sda1";
5339     char mountpoint[] = "/";
5340     int r;
5341     suppress_error = 0;
5342     r = guestfs_mount (g, device, mountpoint);
5343     if (r == -1)
5344       return -1;
5345   }
5346   /* TestOutputTrue for grub_install (0) */
5347   {
5348     char root[] = "/";
5349     char device[] = "/dev/sda1";
5350     int r;
5351     suppress_error = 0;
5352     r = guestfs_grub_install (g, root, device);
5353     if (r == -1)
5354       return -1;
5355   }
5356   {
5357     char path[] = "/boot";
5358     int r;
5359     suppress_error = 0;
5360     r = guestfs_is_dir (g, path);
5361     if (r == -1)
5362       return -1;
5363     if (!r) {
5364       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5365       return -1;
5366     }
5367   }
5368   return 0;
5369 }
5370
5371 static int test_zero_0_skip (void)
5372 {
5373   const char *str;
5374
5375   str = getenv ("TEST_ONLY");
5376   if (str)
5377     return strstr (str, "zero") == NULL;
5378   str = getenv ("SKIP_TEST_ZERO_0");
5379   if (str && strcmp (str, "1") == 0) return 1;
5380   str = getenv ("SKIP_TEST_ZERO");
5381   if (str && strcmp (str, "1") == 0) return 1;
5382   return 0;
5383 }
5384
5385 static int test_zero_0 (void)
5386 {
5387   if (test_zero_0_skip ()) {
5388     printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5389     return 0;
5390   }
5391
5392   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5393   {
5394     char device[] = "/dev/sda";
5395     int r;
5396     suppress_error = 0;
5397     r = guestfs_blockdev_setrw (g, device);
5398     if (r == -1)
5399       return -1;
5400   }
5401   {
5402     int r;
5403     suppress_error = 0;
5404     r = guestfs_umount_all (g);
5405     if (r == -1)
5406       return -1;
5407   }
5408   {
5409     int r;
5410     suppress_error = 0;
5411     r = guestfs_lvm_remove_all (g);
5412     if (r == -1)
5413       return -1;
5414   }
5415   {
5416     char device[] = "/dev/sda";
5417     char lines_0[] = ",";
5418     char *lines[] = {
5419       lines_0,
5420       NULL
5421     };
5422     int r;
5423     suppress_error = 0;
5424     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5425     if (r == -1)
5426       return -1;
5427   }
5428   {
5429     char fstype[] = "ext2";
5430     char device[] = "/dev/sda1";
5431     int r;
5432     suppress_error = 0;
5433     r = guestfs_mkfs (g, fstype, device);
5434     if (r == -1)
5435       return -1;
5436   }
5437   {
5438     char device[] = "/dev/sda1";
5439     char mountpoint[] = "/";
5440     int r;
5441     suppress_error = 0;
5442     r = guestfs_mount (g, device, mountpoint);
5443     if (r == -1)
5444       return -1;
5445   }
5446   /* TestOutput for zero (0) */
5447   char expected[] = "data";
5448   {
5449     char pathordevice[] = "/dev/sda1";
5450     int r;
5451     suppress_error = 0;
5452     r = guestfs_umount (g, pathordevice);
5453     if (r == -1)
5454       return -1;
5455   }
5456   {
5457     char device[] = "/dev/sda1";
5458     int r;
5459     suppress_error = 0;
5460     r = guestfs_zero (g, device);
5461     if (r == -1)
5462       return -1;
5463   }
5464   {
5465     char path[] = "/dev/sda1";
5466     char *r;
5467     suppress_error = 0;
5468     r = guestfs_file (g, path);
5469     if (r == NULL)
5470       return -1;
5471     if (strcmp (r, expected) != 0) {
5472       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5473       return -1;
5474     }
5475     free (r);
5476   }
5477   return 0;
5478 }
5479
5480 static int test_fsck_0_skip (void)
5481 {
5482   const char *str;
5483
5484   str = getenv ("TEST_ONLY");
5485   if (str)
5486     return strstr (str, "fsck") == NULL;
5487   str = getenv ("SKIP_TEST_FSCK_0");
5488   if (str && strcmp (str, "1") == 0) return 1;
5489   str = getenv ("SKIP_TEST_FSCK");
5490   if (str && strcmp (str, "1") == 0) return 1;
5491   return 0;
5492 }
5493
5494 static int test_fsck_0 (void)
5495 {
5496   if (test_fsck_0_skip ()) {
5497     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5498     return 0;
5499   }
5500
5501   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5502   {
5503     char device[] = "/dev/sda";
5504     int r;
5505     suppress_error = 0;
5506     r = guestfs_blockdev_setrw (g, device);
5507     if (r == -1)
5508       return -1;
5509   }
5510   {
5511     int r;
5512     suppress_error = 0;
5513     r = guestfs_umount_all (g);
5514     if (r == -1)
5515       return -1;
5516   }
5517   {
5518     int r;
5519     suppress_error = 0;
5520     r = guestfs_lvm_remove_all (g);
5521     if (r == -1)
5522       return -1;
5523   }
5524   {
5525     char device[] = "/dev/sda";
5526     char lines_0[] = ",";
5527     char *lines[] = {
5528       lines_0,
5529       NULL
5530     };
5531     int r;
5532     suppress_error = 0;
5533     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5534     if (r == -1)
5535       return -1;
5536   }
5537   {
5538     char fstype[] = "ext2";
5539     char device[] = "/dev/sda1";
5540     int r;
5541     suppress_error = 0;
5542     r = guestfs_mkfs (g, fstype, device);
5543     if (r == -1)
5544       return -1;
5545   }
5546   {
5547     char device[] = "/dev/sda1";
5548     char mountpoint[] = "/";
5549     int r;
5550     suppress_error = 0;
5551     r = guestfs_mount (g, device, mountpoint);
5552     if (r == -1)
5553       return -1;
5554   }
5555   /* TestOutputInt for fsck (0) */
5556   {
5557     char pathordevice[] = "/dev/sda1";
5558     int r;
5559     suppress_error = 0;
5560     r = guestfs_umount (g, pathordevice);
5561     if (r == -1)
5562       return -1;
5563   }
5564   {
5565     char fstype[] = "ext2";
5566     char device[] = "/dev/sda1";
5567     int r;
5568     suppress_error = 0;
5569     r = guestfs_fsck (g, fstype, device);
5570     if (r == -1)
5571       return -1;
5572     if (r != 0) {
5573       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
5574       return -1;
5575     }
5576   }
5577   return 0;
5578 }
5579
5580 static int test_fsck_1_skip (void)
5581 {
5582   const char *str;
5583
5584   str = getenv ("TEST_ONLY");
5585   if (str)
5586     return strstr (str, "fsck") == NULL;
5587   str = getenv ("SKIP_TEST_FSCK_1");
5588   if (str && strcmp (str, "1") == 0) return 1;
5589   str = getenv ("SKIP_TEST_FSCK");
5590   if (str && strcmp (str, "1") == 0) return 1;
5591   return 0;
5592 }
5593
5594 static int test_fsck_1 (void)
5595 {
5596   if (test_fsck_1_skip ()) {
5597     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5598     return 0;
5599   }
5600
5601   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5602   {
5603     char device[] = "/dev/sda";
5604     int r;
5605     suppress_error = 0;
5606     r = guestfs_blockdev_setrw (g, device);
5607     if (r == -1)
5608       return -1;
5609   }
5610   {
5611     int r;
5612     suppress_error = 0;
5613     r = guestfs_umount_all (g);
5614     if (r == -1)
5615       return -1;
5616   }
5617   {
5618     int r;
5619     suppress_error = 0;
5620     r = guestfs_lvm_remove_all (g);
5621     if (r == -1)
5622       return -1;
5623   }
5624   {
5625     char device[] = "/dev/sda";
5626     char lines_0[] = ",";
5627     char *lines[] = {
5628       lines_0,
5629       NULL
5630     };
5631     int r;
5632     suppress_error = 0;
5633     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5634     if (r == -1)
5635       return -1;
5636   }
5637   {
5638     char fstype[] = "ext2";
5639     char device[] = "/dev/sda1";
5640     int r;
5641     suppress_error = 0;
5642     r = guestfs_mkfs (g, fstype, device);
5643     if (r == -1)
5644       return -1;
5645   }
5646   {
5647     char device[] = "/dev/sda1";
5648     char mountpoint[] = "/";
5649     int r;
5650     suppress_error = 0;
5651     r = guestfs_mount (g, device, mountpoint);
5652     if (r == -1)
5653       return -1;
5654   }
5655   /* TestOutputInt for fsck (1) */
5656   {
5657     char pathordevice[] = "/dev/sda1";
5658     int r;
5659     suppress_error = 0;
5660     r = guestfs_umount (g, pathordevice);
5661     if (r == -1)
5662       return -1;
5663   }
5664   {
5665     char device[] = "/dev/sda1";
5666     int r;
5667     suppress_error = 0;
5668     r = guestfs_zero (g, device);
5669     if (r == -1)
5670       return -1;
5671   }
5672   {
5673     char fstype[] = "ext2";
5674     char device[] = "/dev/sda1";
5675     int r;
5676     suppress_error = 0;
5677     r = guestfs_fsck (g, fstype, device);
5678     if (r == -1)
5679       return -1;
5680     if (r != 8) {
5681       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
5682       return -1;
5683     }
5684   }
5685   return 0;
5686 }
5687
5688 static int test_set_e2uuid_0_skip (void)
5689 {
5690   const char *str;
5691
5692   str = getenv ("TEST_ONLY");
5693   if (str)
5694     return strstr (str, "set_e2uuid") == NULL;
5695   str = getenv ("SKIP_TEST_SET_E2UUID_0");
5696   if (str && strcmp (str, "1") == 0) return 1;
5697   str = getenv ("SKIP_TEST_SET_E2UUID");
5698   if (str && strcmp (str, "1") == 0) return 1;
5699   return 0;
5700 }
5701
5702 static int test_set_e2uuid_0 (void)
5703 {
5704   if (test_set_e2uuid_0_skip ()) {
5705     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5706     return 0;
5707   }
5708
5709   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5710   {
5711     char device[] = "/dev/sda";
5712     int r;
5713     suppress_error = 0;
5714     r = guestfs_blockdev_setrw (g, device);
5715     if (r == -1)
5716       return -1;
5717   }
5718   {
5719     int r;
5720     suppress_error = 0;
5721     r = guestfs_umount_all (g);
5722     if (r == -1)
5723       return -1;
5724   }
5725   {
5726     int r;
5727     suppress_error = 0;
5728     r = guestfs_lvm_remove_all (g);
5729     if (r == -1)
5730       return -1;
5731   }
5732   {
5733     char device[] = "/dev/sda";
5734     char lines_0[] = ",";
5735     char *lines[] = {
5736       lines_0,
5737       NULL
5738     };
5739     int r;
5740     suppress_error = 0;
5741     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5742     if (r == -1)
5743       return -1;
5744   }
5745   {
5746     char fstype[] = "ext2";
5747     char device[] = "/dev/sda1";
5748     int r;
5749     suppress_error = 0;
5750     r = guestfs_mkfs (g, fstype, device);
5751     if (r == -1)
5752       return -1;
5753   }
5754   {
5755     char device[] = "/dev/sda1";
5756     char mountpoint[] = "/";
5757     int r;
5758     suppress_error = 0;
5759     r = guestfs_mount (g, device, mountpoint);
5760     if (r == -1)
5761       return -1;
5762   }
5763   /* TestOutput for set_e2uuid (0) */
5764   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5765   {
5766     char device[] = "/dev/sda1";
5767     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5768     int r;
5769     suppress_error = 0;
5770     r = guestfs_set_e2uuid (g, device, uuid);
5771     if (r == -1)
5772       return -1;
5773   }
5774   {
5775     char device[] = "/dev/sda1";
5776     char *r;
5777     suppress_error = 0;
5778     r = guestfs_get_e2uuid (g, device);
5779     if (r == NULL)
5780       return -1;
5781     if (strcmp (r, expected) != 0) {
5782       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5783       return -1;
5784     }
5785     free (r);
5786   }
5787   return 0;
5788 }
5789
5790 static int test_set_e2uuid_1_skip (void)
5791 {
5792   const char *str;
5793
5794   str = getenv ("TEST_ONLY");
5795   if (str)
5796     return strstr (str, "set_e2uuid") == NULL;
5797   str = getenv ("SKIP_TEST_SET_E2UUID_1");
5798   if (str && strcmp (str, "1") == 0) return 1;
5799   str = getenv ("SKIP_TEST_SET_E2UUID");
5800   if (str && strcmp (str, "1") == 0) return 1;
5801   return 0;
5802 }
5803
5804 static int test_set_e2uuid_1 (void)
5805 {
5806   if (test_set_e2uuid_1_skip ()) {
5807     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
5808     return 0;
5809   }
5810
5811   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
5812   {
5813     char device[] = "/dev/sda";
5814     int r;
5815     suppress_error = 0;
5816     r = guestfs_blockdev_setrw (g, device);
5817     if (r == -1)
5818       return -1;
5819   }
5820   {
5821     int r;
5822     suppress_error = 0;
5823     r = guestfs_umount_all (g);
5824     if (r == -1)
5825       return -1;
5826   }
5827   {
5828     int r;
5829     suppress_error = 0;
5830     r = guestfs_lvm_remove_all (g);
5831     if (r == -1)
5832       return -1;
5833   }
5834   {
5835     char device[] = "/dev/sda";
5836     char lines_0[] = ",";
5837     char *lines[] = {
5838       lines_0,
5839       NULL
5840     };
5841     int r;
5842     suppress_error = 0;
5843     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5844     if (r == -1)
5845       return -1;
5846   }
5847   {
5848     char fstype[] = "ext2";
5849     char device[] = "/dev/sda1";
5850     int r;
5851     suppress_error = 0;
5852     r = guestfs_mkfs (g, fstype, device);
5853     if (r == -1)
5854       return -1;
5855   }
5856   {
5857     char device[] = "/dev/sda1";
5858     char mountpoint[] = "/";
5859     int r;
5860     suppress_error = 0;
5861     r = guestfs_mount (g, device, mountpoint);
5862     if (r == -1)
5863       return -1;
5864   }
5865   /* TestOutput for set_e2uuid (1) */
5866   char expected[] = "";
5867   {
5868     char device[] = "/dev/sda1";
5869     char uuid[] = "clear";
5870     int r;
5871     suppress_error = 0;
5872     r = guestfs_set_e2uuid (g, device, uuid);
5873     if (r == -1)
5874       return -1;
5875   }
5876   {
5877     char device[] = "/dev/sda1";
5878     char *r;
5879     suppress_error = 0;
5880     r = guestfs_get_e2uuid (g, device);
5881     if (r == NULL)
5882       return -1;
5883     if (strcmp (r, expected) != 0) {
5884       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
5885       return -1;
5886     }
5887     free (r);
5888   }
5889   return 0;
5890 }
5891
5892 static int test_set_e2uuid_2_skip (void)
5893 {
5894   const char *str;
5895
5896   str = getenv ("TEST_ONLY");
5897   if (str)
5898     return strstr (str, "set_e2uuid") == NULL;
5899   str = getenv ("SKIP_TEST_SET_E2UUID_2");
5900   if (str && strcmp (str, "1") == 0) return 1;
5901   str = getenv ("SKIP_TEST_SET_E2UUID");
5902   if (str && strcmp (str, "1") == 0) return 1;
5903   return 0;
5904 }
5905
5906 static int test_set_e2uuid_2 (void)
5907 {
5908   if (test_set_e2uuid_2_skip ()) {
5909     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
5910     return 0;
5911   }
5912
5913   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
5914   {
5915     char device[] = "/dev/sda";
5916     int r;
5917     suppress_error = 0;
5918     r = guestfs_blockdev_setrw (g, device);
5919     if (r == -1)
5920       return -1;
5921   }
5922   {
5923     int r;
5924     suppress_error = 0;
5925     r = guestfs_umount_all (g);
5926     if (r == -1)
5927       return -1;
5928   }
5929   {
5930     int r;
5931     suppress_error = 0;
5932     r = guestfs_lvm_remove_all (g);
5933     if (r == -1)
5934       return -1;
5935   }
5936   {
5937     char device[] = "/dev/sda";
5938     char lines_0[] = ",";
5939     char *lines[] = {
5940       lines_0,
5941       NULL
5942     };
5943     int r;
5944     suppress_error = 0;
5945     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5946     if (r == -1)
5947       return -1;
5948   }
5949   {
5950     char fstype[] = "ext2";
5951     char device[] = "/dev/sda1";
5952     int r;
5953     suppress_error = 0;
5954     r = guestfs_mkfs (g, fstype, device);
5955     if (r == -1)
5956       return -1;
5957   }
5958   {
5959     char device[] = "/dev/sda1";
5960     char mountpoint[] = "/";
5961     int r;
5962     suppress_error = 0;
5963     r = guestfs_mount (g, device, mountpoint);
5964     if (r == -1)
5965       return -1;
5966   }
5967   /* TestRun for set_e2uuid (2) */
5968   {
5969     char device[] = "/dev/sda1";
5970     char uuid[] = "random";
5971     int r;
5972     suppress_error = 0;
5973     r = guestfs_set_e2uuid (g, device, uuid);
5974     if (r == -1)
5975       return -1;
5976   }
5977   return 0;
5978 }
5979
5980 static int test_set_e2uuid_3_skip (void)
5981 {
5982   const char *str;
5983
5984   str = getenv ("TEST_ONLY");
5985   if (str)
5986     return strstr (str, "set_e2uuid") == NULL;
5987   str = getenv ("SKIP_TEST_SET_E2UUID_3");
5988   if (str && strcmp (str, "1") == 0) return 1;
5989   str = getenv ("SKIP_TEST_SET_E2UUID");
5990   if (str && strcmp (str, "1") == 0) return 1;
5991   return 0;
5992 }
5993
5994 static int test_set_e2uuid_3 (void)
5995 {
5996   if (test_set_e2uuid_3_skip ()) {
5997     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
5998     return 0;
5999   }
6000
6001   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6002   {
6003     char device[] = "/dev/sda";
6004     int r;
6005     suppress_error = 0;
6006     r = guestfs_blockdev_setrw (g, device);
6007     if (r == -1)
6008       return -1;
6009   }
6010   {
6011     int r;
6012     suppress_error = 0;
6013     r = guestfs_umount_all (g);
6014     if (r == -1)
6015       return -1;
6016   }
6017   {
6018     int r;
6019     suppress_error = 0;
6020     r = guestfs_lvm_remove_all (g);
6021     if (r == -1)
6022       return -1;
6023   }
6024   {
6025     char device[] = "/dev/sda";
6026     char lines_0[] = ",";
6027     char *lines[] = {
6028       lines_0,
6029       NULL
6030     };
6031     int r;
6032     suppress_error = 0;
6033     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6034     if (r == -1)
6035       return -1;
6036   }
6037   {
6038     char fstype[] = "ext2";
6039     char device[] = "/dev/sda1";
6040     int r;
6041     suppress_error = 0;
6042     r = guestfs_mkfs (g, fstype, device);
6043     if (r == -1)
6044       return -1;
6045   }
6046   {
6047     char device[] = "/dev/sda1";
6048     char mountpoint[] = "/";
6049     int r;
6050     suppress_error = 0;
6051     r = guestfs_mount (g, device, mountpoint);
6052     if (r == -1)
6053       return -1;
6054   }
6055   /* TestRun for set_e2uuid (3) */
6056   {
6057     char device[] = "/dev/sda1";
6058     char uuid[] = "time";
6059     int r;
6060     suppress_error = 0;
6061     r = guestfs_set_e2uuid (g, device, uuid);
6062     if (r == -1)
6063       return -1;
6064   }
6065   return 0;
6066 }
6067
6068 static int test_set_e2label_0_skip (void)
6069 {
6070   const char *str;
6071
6072   str = getenv ("TEST_ONLY");
6073   if (str)
6074     return strstr (str, "set_e2label") == NULL;
6075   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6076   if (str && strcmp (str, "1") == 0) return 1;
6077   str = getenv ("SKIP_TEST_SET_E2LABEL");
6078   if (str && strcmp (str, "1") == 0) return 1;
6079   return 0;
6080 }
6081
6082 static int test_set_e2label_0 (void)
6083 {
6084   if (test_set_e2label_0_skip ()) {
6085     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6086     return 0;
6087   }
6088
6089   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6090   {
6091     char device[] = "/dev/sda";
6092     int r;
6093     suppress_error = 0;
6094     r = guestfs_blockdev_setrw (g, device);
6095     if (r == -1)
6096       return -1;
6097   }
6098   {
6099     int r;
6100     suppress_error = 0;
6101     r = guestfs_umount_all (g);
6102     if (r == -1)
6103       return -1;
6104   }
6105   {
6106     int r;
6107     suppress_error = 0;
6108     r = guestfs_lvm_remove_all (g);
6109     if (r == -1)
6110       return -1;
6111   }
6112   {
6113     char device[] = "/dev/sda";
6114     char lines_0[] = ",";
6115     char *lines[] = {
6116       lines_0,
6117       NULL
6118     };
6119     int r;
6120     suppress_error = 0;
6121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6122     if (r == -1)
6123       return -1;
6124   }
6125   {
6126     char fstype[] = "ext2";
6127     char device[] = "/dev/sda1";
6128     int r;
6129     suppress_error = 0;
6130     r = guestfs_mkfs (g, fstype, device);
6131     if (r == -1)
6132       return -1;
6133   }
6134   {
6135     char device[] = "/dev/sda1";
6136     char mountpoint[] = "/";
6137     int r;
6138     suppress_error = 0;
6139     r = guestfs_mount (g, device, mountpoint);
6140     if (r == -1)
6141       return -1;
6142   }
6143   /* TestOutput for set_e2label (0) */
6144   char expected[] = "testlabel";
6145   {
6146     char device[] = "/dev/sda1";
6147     char label[] = "testlabel";
6148     int r;
6149     suppress_error = 0;
6150     r = guestfs_set_e2label (g, device, label);
6151     if (r == -1)
6152       return -1;
6153   }
6154   {
6155     char device[] = "/dev/sda1";
6156     char *r;
6157     suppress_error = 0;
6158     r = guestfs_get_e2label (g, device);
6159     if (r == NULL)
6160       return -1;
6161     if (strcmp (r, expected) != 0) {
6162       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6163       return -1;
6164     }
6165     free (r);
6166   }
6167   return 0;
6168 }
6169
6170 static int test_pvremove_0_skip (void)
6171 {
6172   const char *str;
6173
6174   str = getenv ("TEST_ONLY");
6175   if (str)
6176     return strstr (str, "pvremove") == NULL;
6177   str = getenv ("SKIP_TEST_PVREMOVE_0");
6178   if (str && strcmp (str, "1") == 0) return 1;
6179   str = getenv ("SKIP_TEST_PVREMOVE");
6180   if (str && strcmp (str, "1") == 0) return 1;
6181   return 0;
6182 }
6183
6184 static int test_pvremove_0 (void)
6185 {
6186   if (test_pvremove_0_skip ()) {
6187     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6188     return 0;
6189   }
6190
6191   /* InitNone|InitEmpty for test_pvremove_0 */
6192   {
6193     char device[] = "/dev/sda";
6194     int r;
6195     suppress_error = 0;
6196     r = guestfs_blockdev_setrw (g, device);
6197     if (r == -1)
6198       return -1;
6199   }
6200   {
6201     int r;
6202     suppress_error = 0;
6203     r = guestfs_umount_all (g);
6204     if (r == -1)
6205       return -1;
6206   }
6207   {
6208     int r;
6209     suppress_error = 0;
6210     r = guestfs_lvm_remove_all (g);
6211     if (r == -1)
6212       return -1;
6213   }
6214   /* TestOutputListOfDevices for pvremove (0) */
6215   {
6216     char device[] = "/dev/sda";
6217     char lines_0[] = ",";
6218     char *lines[] = {
6219       lines_0,
6220       NULL
6221     };
6222     int r;
6223     suppress_error = 0;
6224     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6225     if (r == -1)
6226       return -1;
6227   }
6228   {
6229     char device[] = "/dev/sda1";
6230     int r;
6231     suppress_error = 0;
6232     r = guestfs_pvcreate (g, device);
6233     if (r == -1)
6234       return -1;
6235   }
6236   {
6237     char volgroup[] = "VG";
6238     char physvols_0[] = "/dev/sda1";
6239     char *physvols[] = {
6240       physvols_0,
6241       NULL
6242     };
6243     int r;
6244     suppress_error = 0;
6245     r = guestfs_vgcreate (g, volgroup, physvols);
6246     if (r == -1)
6247       return -1;
6248   }
6249   {
6250     char logvol[] = "LV1";
6251     char volgroup[] = "VG";
6252     int r;
6253     suppress_error = 0;
6254     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6255     if (r == -1)
6256       return -1;
6257   }
6258   {
6259     char logvol[] = "LV2";
6260     char volgroup[] = "VG";
6261     int r;
6262     suppress_error = 0;
6263     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6264     if (r == -1)
6265       return -1;
6266   }
6267   {
6268     char vgname[] = "VG";
6269     int r;
6270     suppress_error = 0;
6271     r = guestfs_vgremove (g, vgname);
6272     if (r == -1)
6273       return -1;
6274   }
6275   {
6276     char device[] = "/dev/sda1";
6277     int r;
6278     suppress_error = 0;
6279     r = guestfs_pvremove (g, device);
6280     if (r == -1)
6281       return -1;
6282   }
6283   {
6284     char **r;
6285     int i;
6286     suppress_error = 0;
6287     r = guestfs_lvs (g);
6288     if (r == NULL)
6289       return -1;
6290     if (r[0] != NULL) {
6291       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6292       print_strings (r);
6293       return -1;
6294     }
6295     for (i = 0; r[i] != NULL; ++i)
6296       free (r[i]);
6297     free (r);
6298   }
6299   return 0;
6300 }
6301
6302 static int test_pvremove_1_skip (void)
6303 {
6304   const char *str;
6305
6306   str = getenv ("TEST_ONLY");
6307   if (str)
6308     return strstr (str, "pvremove") == NULL;
6309   str = getenv ("SKIP_TEST_PVREMOVE_1");
6310   if (str && strcmp (str, "1") == 0) return 1;
6311   str = getenv ("SKIP_TEST_PVREMOVE");
6312   if (str && strcmp (str, "1") == 0) return 1;
6313   return 0;
6314 }
6315
6316 static int test_pvremove_1 (void)
6317 {
6318   if (test_pvremove_1_skip ()) {
6319     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6320     return 0;
6321   }
6322
6323   /* InitNone|InitEmpty for test_pvremove_1 */
6324   {
6325     char device[] = "/dev/sda";
6326     int r;
6327     suppress_error = 0;
6328     r = guestfs_blockdev_setrw (g, device);
6329     if (r == -1)
6330       return -1;
6331   }
6332   {
6333     int r;
6334     suppress_error = 0;
6335     r = guestfs_umount_all (g);
6336     if (r == -1)
6337       return -1;
6338   }
6339   {
6340     int r;
6341     suppress_error = 0;
6342     r = guestfs_lvm_remove_all (g);
6343     if (r == -1)
6344       return -1;
6345   }
6346   /* TestOutputListOfDevices for pvremove (1) */
6347   {
6348     char device[] = "/dev/sda";
6349     char lines_0[] = ",";
6350     char *lines[] = {
6351       lines_0,
6352       NULL
6353     };
6354     int r;
6355     suppress_error = 0;
6356     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6357     if (r == -1)
6358       return -1;
6359   }
6360   {
6361     char device[] = "/dev/sda1";
6362     int r;
6363     suppress_error = 0;
6364     r = guestfs_pvcreate (g, device);
6365     if (r == -1)
6366       return -1;
6367   }
6368   {
6369     char volgroup[] = "VG";
6370     char physvols_0[] = "/dev/sda1";
6371     char *physvols[] = {
6372       physvols_0,
6373       NULL
6374     };
6375     int r;
6376     suppress_error = 0;
6377     r = guestfs_vgcreate (g, volgroup, physvols);
6378     if (r == -1)
6379       return -1;
6380   }
6381   {
6382     char logvol[] = "LV1";
6383     char volgroup[] = "VG";
6384     int r;
6385     suppress_error = 0;
6386     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6387     if (r == -1)
6388       return -1;
6389   }
6390   {
6391     char logvol[] = "LV2";
6392     char volgroup[] = "VG";
6393     int r;
6394     suppress_error = 0;
6395     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6396     if (r == -1)
6397       return -1;
6398   }
6399   {
6400     char vgname[] = "VG";
6401     int r;
6402     suppress_error = 0;
6403     r = guestfs_vgremove (g, vgname);
6404     if (r == -1)
6405       return -1;
6406   }
6407   {
6408     char device[] = "/dev/sda1";
6409     int r;
6410     suppress_error = 0;
6411     r = guestfs_pvremove (g, device);
6412     if (r == -1)
6413       return -1;
6414   }
6415   {
6416     char **r;
6417     int i;
6418     suppress_error = 0;
6419     r = guestfs_vgs (g);
6420     if (r == NULL)
6421       return -1;
6422     if (r[0] != NULL) {
6423       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6424       print_strings (r);
6425       return -1;
6426     }
6427     for (i = 0; r[i] != NULL; ++i)
6428       free (r[i]);
6429     free (r);
6430   }
6431   return 0;
6432 }
6433
6434 static int test_pvremove_2_skip (void)
6435 {
6436   const char *str;
6437
6438   str = getenv ("TEST_ONLY");
6439   if (str)
6440     return strstr (str, "pvremove") == NULL;
6441   str = getenv ("SKIP_TEST_PVREMOVE_2");
6442   if (str && strcmp (str, "1") == 0) return 1;
6443   str = getenv ("SKIP_TEST_PVREMOVE");
6444   if (str && strcmp (str, "1") == 0) return 1;
6445   return 0;
6446 }
6447
6448 static int test_pvremove_2 (void)
6449 {
6450   if (test_pvremove_2_skip ()) {
6451     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6452     return 0;
6453   }
6454
6455   /* InitNone|InitEmpty for test_pvremove_2 */
6456   {
6457     char device[] = "/dev/sda";
6458     int r;
6459     suppress_error = 0;
6460     r = guestfs_blockdev_setrw (g, device);
6461     if (r == -1)
6462       return -1;
6463   }
6464   {
6465     int r;
6466     suppress_error = 0;
6467     r = guestfs_umount_all (g);
6468     if (r == -1)
6469       return -1;
6470   }
6471   {
6472     int r;
6473     suppress_error = 0;
6474     r = guestfs_lvm_remove_all (g);
6475     if (r == -1)
6476       return -1;
6477   }
6478   /* TestOutputListOfDevices for pvremove (2) */
6479   {
6480     char device[] = "/dev/sda";
6481     char lines_0[] = ",";
6482     char *lines[] = {
6483       lines_0,
6484       NULL
6485     };
6486     int r;
6487     suppress_error = 0;
6488     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6489     if (r == -1)
6490       return -1;
6491   }
6492   {
6493     char device[] = "/dev/sda1";
6494     int r;
6495     suppress_error = 0;
6496     r = guestfs_pvcreate (g, device);
6497     if (r == -1)
6498       return -1;
6499   }
6500   {
6501     char volgroup[] = "VG";
6502     char physvols_0[] = "/dev/sda1";
6503     char *physvols[] = {
6504       physvols_0,
6505       NULL
6506     };
6507     int r;
6508     suppress_error = 0;
6509     r = guestfs_vgcreate (g, volgroup, physvols);
6510     if (r == -1)
6511       return -1;
6512   }
6513   {
6514     char logvol[] = "LV1";
6515     char volgroup[] = "VG";
6516     int r;
6517     suppress_error = 0;
6518     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6519     if (r == -1)
6520       return -1;
6521   }
6522   {
6523     char logvol[] = "LV2";
6524     char volgroup[] = "VG";
6525     int r;
6526     suppress_error = 0;
6527     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6528     if (r == -1)
6529       return -1;
6530   }
6531   {
6532     char vgname[] = "VG";
6533     int r;
6534     suppress_error = 0;
6535     r = guestfs_vgremove (g, vgname);
6536     if (r == -1)
6537       return -1;
6538   }
6539   {
6540     char device[] = "/dev/sda1";
6541     int r;
6542     suppress_error = 0;
6543     r = guestfs_pvremove (g, device);
6544     if (r == -1)
6545       return -1;
6546   }
6547   {
6548     char **r;
6549     int i;
6550     suppress_error = 0;
6551     r = guestfs_pvs (g);
6552     if (r == NULL)
6553       return -1;
6554     if (r[0] != NULL) {
6555       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6556       print_strings (r);
6557       return -1;
6558     }
6559     for (i = 0; r[i] != NULL; ++i)
6560       free (r[i]);
6561     free (r);
6562   }
6563   return 0;
6564 }
6565
6566 static int test_vgremove_0_skip (void)
6567 {
6568   const char *str;
6569
6570   str = getenv ("TEST_ONLY");
6571   if (str)
6572     return strstr (str, "vgremove") == NULL;
6573   str = getenv ("SKIP_TEST_VGREMOVE_0");
6574   if (str && strcmp (str, "1") == 0) return 1;
6575   str = getenv ("SKIP_TEST_VGREMOVE");
6576   if (str && strcmp (str, "1") == 0) return 1;
6577   return 0;
6578 }
6579
6580 static int test_vgremove_0 (void)
6581 {
6582   if (test_vgremove_0_skip ()) {
6583     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6584     return 0;
6585   }
6586
6587   /* InitNone|InitEmpty for test_vgremove_0 */
6588   {
6589     char device[] = "/dev/sda";
6590     int r;
6591     suppress_error = 0;
6592     r = guestfs_blockdev_setrw (g, device);
6593     if (r == -1)
6594       return -1;
6595   }
6596   {
6597     int r;
6598     suppress_error = 0;
6599     r = guestfs_umount_all (g);
6600     if (r == -1)
6601       return -1;
6602   }
6603   {
6604     int r;
6605     suppress_error = 0;
6606     r = guestfs_lvm_remove_all (g);
6607     if (r == -1)
6608       return -1;
6609   }
6610   /* TestOutputList for vgremove (0) */
6611   {
6612     char device[] = "/dev/sda";
6613     char lines_0[] = ",";
6614     char *lines[] = {
6615       lines_0,
6616       NULL
6617     };
6618     int r;
6619     suppress_error = 0;
6620     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6621     if (r == -1)
6622       return -1;
6623   }
6624   {
6625     char device[] = "/dev/sda1";
6626     int r;
6627     suppress_error = 0;
6628     r = guestfs_pvcreate (g, device);
6629     if (r == -1)
6630       return -1;
6631   }
6632   {
6633     char volgroup[] = "VG";
6634     char physvols_0[] = "/dev/sda1";
6635     char *physvols[] = {
6636       physvols_0,
6637       NULL
6638     };
6639     int r;
6640     suppress_error = 0;
6641     r = guestfs_vgcreate (g, volgroup, physvols);
6642     if (r == -1)
6643       return -1;
6644   }
6645   {
6646     char logvol[] = "LV1";
6647     char volgroup[] = "VG";
6648     int r;
6649     suppress_error = 0;
6650     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6651     if (r == -1)
6652       return -1;
6653   }
6654   {
6655     char logvol[] = "LV2";
6656     char volgroup[] = "VG";
6657     int r;
6658     suppress_error = 0;
6659     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6660     if (r == -1)
6661       return -1;
6662   }
6663   {
6664     char vgname[] = "VG";
6665     int r;
6666     suppress_error = 0;
6667     r = guestfs_vgremove (g, vgname);
6668     if (r == -1)
6669       return -1;
6670   }
6671   {
6672     char **r;
6673     int i;
6674     suppress_error = 0;
6675     r = guestfs_lvs (g);
6676     if (r == NULL)
6677       return -1;
6678     if (r[0] != NULL) {
6679       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6680       print_strings (r);
6681       return -1;
6682     }
6683     for (i = 0; r[i] != NULL; ++i)
6684       free (r[i]);
6685     free (r);
6686   }
6687   return 0;
6688 }
6689
6690 static int test_vgremove_1_skip (void)
6691 {
6692   const char *str;
6693
6694   str = getenv ("TEST_ONLY");
6695   if (str)
6696     return strstr (str, "vgremove") == NULL;
6697   str = getenv ("SKIP_TEST_VGREMOVE_1");
6698   if (str && strcmp (str, "1") == 0) return 1;
6699   str = getenv ("SKIP_TEST_VGREMOVE");
6700   if (str && strcmp (str, "1") == 0) return 1;
6701   return 0;
6702 }
6703
6704 static int test_vgremove_1 (void)
6705 {
6706   if (test_vgremove_1_skip ()) {
6707     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6708     return 0;
6709   }
6710
6711   /* InitNone|InitEmpty for test_vgremove_1 */
6712   {
6713     char device[] = "/dev/sda";
6714     int r;
6715     suppress_error = 0;
6716     r = guestfs_blockdev_setrw (g, device);
6717     if (r == -1)
6718       return -1;
6719   }
6720   {
6721     int r;
6722     suppress_error = 0;
6723     r = guestfs_umount_all (g);
6724     if (r == -1)
6725       return -1;
6726   }
6727   {
6728     int r;
6729     suppress_error = 0;
6730     r = guestfs_lvm_remove_all (g);
6731     if (r == -1)
6732       return -1;
6733   }
6734   /* TestOutputList for vgremove (1) */
6735   {
6736     char device[] = "/dev/sda";
6737     char lines_0[] = ",";
6738     char *lines[] = {
6739       lines_0,
6740       NULL
6741     };
6742     int r;
6743     suppress_error = 0;
6744     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6745     if (r == -1)
6746       return -1;
6747   }
6748   {
6749     char device[] = "/dev/sda1";
6750     int r;
6751     suppress_error = 0;
6752     r = guestfs_pvcreate (g, device);
6753     if (r == -1)
6754       return -1;
6755   }
6756   {
6757     char volgroup[] = "VG";
6758     char physvols_0[] = "/dev/sda1";
6759     char *physvols[] = {
6760       physvols_0,
6761       NULL
6762     };
6763     int r;
6764     suppress_error = 0;
6765     r = guestfs_vgcreate (g, volgroup, physvols);
6766     if (r == -1)
6767       return -1;
6768   }
6769   {
6770     char logvol[] = "LV1";
6771     char volgroup[] = "VG";
6772     int r;
6773     suppress_error = 0;
6774     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6775     if (r == -1)
6776       return -1;
6777   }
6778   {
6779     char logvol[] = "LV2";
6780     char volgroup[] = "VG";
6781     int r;
6782     suppress_error = 0;
6783     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6784     if (r == -1)
6785       return -1;
6786   }
6787   {
6788     char vgname[] = "VG";
6789     int r;
6790     suppress_error = 0;
6791     r = guestfs_vgremove (g, vgname);
6792     if (r == -1)
6793       return -1;
6794   }
6795   {
6796     char **r;
6797     int i;
6798     suppress_error = 0;
6799     r = guestfs_vgs (g);
6800     if (r == NULL)
6801       return -1;
6802     if (r[0] != NULL) {
6803       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
6804       print_strings (r);
6805       return -1;
6806     }
6807     for (i = 0; r[i] != NULL; ++i)
6808       free (r[i]);
6809     free (r);
6810   }
6811   return 0;
6812 }
6813
6814 static int test_lvremove_0_skip (void)
6815 {
6816   const char *str;
6817
6818   str = getenv ("TEST_ONLY");
6819   if (str)
6820     return strstr (str, "lvremove") == NULL;
6821   str = getenv ("SKIP_TEST_LVREMOVE_0");
6822   if (str && strcmp (str, "1") == 0) return 1;
6823   str = getenv ("SKIP_TEST_LVREMOVE");
6824   if (str && strcmp (str, "1") == 0) return 1;
6825   return 0;
6826 }
6827
6828 static int test_lvremove_0 (void)
6829 {
6830   if (test_lvremove_0_skip ()) {
6831     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
6832     return 0;
6833   }
6834
6835   /* InitNone|InitEmpty for test_lvremove_0 */
6836   {
6837     char device[] = "/dev/sda";
6838     int r;
6839     suppress_error = 0;
6840     r = guestfs_blockdev_setrw (g, device);
6841     if (r == -1)
6842       return -1;
6843   }
6844   {
6845     int r;
6846     suppress_error = 0;
6847     r = guestfs_umount_all (g);
6848     if (r == -1)
6849       return -1;
6850   }
6851   {
6852     int r;
6853     suppress_error = 0;
6854     r = guestfs_lvm_remove_all (g);
6855     if (r == -1)
6856       return -1;
6857   }
6858   /* TestOutputList for lvremove (0) */
6859   {
6860     char device[] = "/dev/sda";
6861     char lines_0[] = ",";
6862     char *lines[] = {
6863       lines_0,
6864       NULL
6865     };
6866     int r;
6867     suppress_error = 0;
6868     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6869     if (r == -1)
6870       return -1;
6871   }
6872   {
6873     char device[] = "/dev/sda1";
6874     int r;
6875     suppress_error = 0;
6876     r = guestfs_pvcreate (g, device);
6877     if (r == -1)
6878       return -1;
6879   }
6880   {
6881     char volgroup[] = "VG";
6882     char physvols_0[] = "/dev/sda1";
6883     char *physvols[] = {
6884       physvols_0,
6885       NULL
6886     };
6887     int r;
6888     suppress_error = 0;
6889     r = guestfs_vgcreate (g, volgroup, physvols);
6890     if (r == -1)
6891       return -1;
6892   }
6893   {
6894     char logvol[] = "LV1";
6895     char volgroup[] = "VG";
6896     int r;
6897     suppress_error = 0;
6898     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6899     if (r == -1)
6900       return -1;
6901   }
6902   {
6903     char logvol[] = "LV2";
6904     char volgroup[] = "VG";
6905     int r;
6906     suppress_error = 0;
6907     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6908     if (r == -1)
6909       return -1;
6910   }
6911   {
6912     char device[] = "/dev/VG/LV1";
6913     int r;
6914     suppress_error = 0;
6915     r = guestfs_lvremove (g, device);
6916     if (r == -1)
6917       return -1;
6918   }
6919   {
6920     char **r;
6921     int i;
6922     suppress_error = 0;
6923     r = guestfs_lvs (g);
6924     if (r == NULL)
6925       return -1;
6926     if (!r[0]) {
6927       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
6928       print_strings (r);
6929       return -1;
6930     }
6931     {
6932       char expected[] = "/dev/VG/LV2";
6933       if (strcmp (r[0], expected) != 0) {
6934         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6935         return -1;
6936       }
6937     }
6938     if (r[1] != NULL) {
6939       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
6940       print_strings (r);
6941       return -1;
6942     }
6943     for (i = 0; r[i] != NULL; ++i)
6944       free (r[i]);
6945     free (r);
6946   }
6947   return 0;
6948 }
6949
6950 static int test_lvremove_1_skip (void)
6951 {
6952   const char *str;
6953
6954   str = getenv ("TEST_ONLY");
6955   if (str)
6956     return strstr (str, "lvremove") == NULL;
6957   str = getenv ("SKIP_TEST_LVREMOVE_1");
6958   if (str && strcmp (str, "1") == 0) return 1;
6959   str = getenv ("SKIP_TEST_LVREMOVE");
6960   if (str && strcmp (str, "1") == 0) return 1;
6961   return 0;
6962 }
6963
6964 static int test_lvremove_1 (void)
6965 {
6966   if (test_lvremove_1_skip ()) {
6967     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
6968     return 0;
6969   }
6970
6971   /* InitNone|InitEmpty for test_lvremove_1 */
6972   {
6973     char device[] = "/dev/sda";
6974     int r;
6975     suppress_error = 0;
6976     r = guestfs_blockdev_setrw (g, device);
6977     if (r == -1)
6978       return -1;
6979   }
6980   {
6981     int r;
6982     suppress_error = 0;
6983     r = guestfs_umount_all (g);
6984     if (r == -1)
6985       return -1;
6986   }
6987   {
6988     int r;
6989     suppress_error = 0;
6990     r = guestfs_lvm_remove_all (g);
6991     if (r == -1)
6992       return -1;
6993   }
6994   /* TestOutputList for lvremove (1) */
6995   {
6996     char device[] = "/dev/sda";
6997     char lines_0[] = ",";
6998     char *lines[] = {
6999       lines_0,
7000       NULL
7001     };
7002     int r;
7003     suppress_error = 0;
7004     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7005     if (r == -1)
7006       return -1;
7007   }
7008   {
7009     char device[] = "/dev/sda1";
7010     int r;
7011     suppress_error = 0;
7012     r = guestfs_pvcreate (g, device);
7013     if (r == -1)
7014       return -1;
7015   }
7016   {
7017     char volgroup[] = "VG";
7018     char physvols_0[] = "/dev/sda1";
7019     char *physvols[] = {
7020       physvols_0,
7021       NULL
7022     };
7023     int r;
7024     suppress_error = 0;
7025     r = guestfs_vgcreate (g, volgroup, physvols);
7026     if (r == -1)
7027       return -1;
7028   }
7029   {
7030     char logvol[] = "LV1";
7031     char volgroup[] = "VG";
7032     int r;
7033     suppress_error = 0;
7034     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7035     if (r == -1)
7036       return -1;
7037   }
7038   {
7039     char logvol[] = "LV2";
7040     char volgroup[] = "VG";
7041     int r;
7042     suppress_error = 0;
7043     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7044     if (r == -1)
7045       return -1;
7046   }
7047   {
7048     char device[] = "/dev/VG";
7049     int r;
7050     suppress_error = 0;
7051     r = guestfs_lvremove (g, device);
7052     if (r == -1)
7053       return -1;
7054   }
7055   {
7056     char **r;
7057     int i;
7058     suppress_error = 0;
7059     r = guestfs_lvs (g);
7060     if (r == NULL)
7061       return -1;
7062     if (r[0] != NULL) {
7063       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7064       print_strings (r);
7065       return -1;
7066     }
7067     for (i = 0; r[i] != NULL; ++i)
7068       free (r[i]);
7069     free (r);
7070   }
7071   return 0;
7072 }
7073
7074 static int test_lvremove_2_skip (void)
7075 {
7076   const char *str;
7077
7078   str = getenv ("TEST_ONLY");
7079   if (str)
7080     return strstr (str, "lvremove") == NULL;
7081   str = getenv ("SKIP_TEST_LVREMOVE_2");
7082   if (str && strcmp (str, "1") == 0) return 1;
7083   str = getenv ("SKIP_TEST_LVREMOVE");
7084   if (str && strcmp (str, "1") == 0) return 1;
7085   return 0;
7086 }
7087
7088 static int test_lvremove_2 (void)
7089 {
7090   if (test_lvremove_2_skip ()) {
7091     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
7092     return 0;
7093   }
7094
7095   /* InitNone|InitEmpty for test_lvremove_2 */
7096   {
7097     char device[] = "/dev/sda";
7098     int r;
7099     suppress_error = 0;
7100     r = guestfs_blockdev_setrw (g, device);
7101     if (r == -1)
7102       return -1;
7103   }
7104   {
7105     int r;
7106     suppress_error = 0;
7107     r = guestfs_umount_all (g);
7108     if (r == -1)
7109       return -1;
7110   }
7111   {
7112     int r;
7113     suppress_error = 0;
7114     r = guestfs_lvm_remove_all (g);
7115     if (r == -1)
7116       return -1;
7117   }
7118   /* TestOutputList for lvremove (2) */
7119   {
7120     char device[] = "/dev/sda";
7121     char lines_0[] = ",";
7122     char *lines[] = {
7123       lines_0,
7124       NULL
7125     };
7126     int r;
7127     suppress_error = 0;
7128     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7129     if (r == -1)
7130       return -1;
7131   }
7132   {
7133     char device[] = "/dev/sda1";
7134     int r;
7135     suppress_error = 0;
7136     r = guestfs_pvcreate (g, device);
7137     if (r == -1)
7138       return -1;
7139   }
7140   {
7141     char volgroup[] = "VG";
7142     char physvols_0[] = "/dev/sda1";
7143     char *physvols[] = {
7144       physvols_0,
7145       NULL
7146     };
7147     int r;
7148     suppress_error = 0;
7149     r = guestfs_vgcreate (g, volgroup, physvols);
7150     if (r == -1)
7151       return -1;
7152   }
7153   {
7154     char logvol[] = "LV1";
7155     char volgroup[] = "VG";
7156     int r;
7157     suppress_error = 0;
7158     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7159     if (r == -1)
7160       return -1;
7161   }
7162   {
7163     char logvol[] = "LV2";
7164     char volgroup[] = "VG";
7165     int r;
7166     suppress_error = 0;
7167     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7168     if (r == -1)
7169       return -1;
7170   }
7171   {
7172     char device[] = "/dev/VG";
7173     int r;
7174     suppress_error = 0;
7175     r = guestfs_lvremove (g, device);
7176     if (r == -1)
7177       return -1;
7178   }
7179   {
7180     char **r;
7181     int i;
7182     suppress_error = 0;
7183     r = guestfs_vgs (g);
7184     if (r == NULL)
7185       return -1;
7186     if (!r[0]) {
7187       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7188       print_strings (r);
7189       return -1;
7190     }
7191     {
7192       char expected[] = "VG";
7193       if (strcmp (r[0], expected) != 0) {
7194         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7195         return -1;
7196       }
7197     }
7198     if (r[1] != NULL) {
7199       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7200       print_strings (r);
7201       return -1;
7202     }
7203     for (i = 0; r[i] != NULL; ++i)
7204       free (r[i]);
7205     free (r);
7206   }
7207   return 0;
7208 }
7209
7210 static int test_mount_ro_0_skip (void)
7211 {
7212   const char *str;
7213
7214   str = getenv ("TEST_ONLY");
7215   if (str)
7216     return strstr (str, "mount_ro") == NULL;
7217   str = getenv ("SKIP_TEST_MOUNT_RO_0");
7218   if (str && strcmp (str, "1") == 0) return 1;
7219   str = getenv ("SKIP_TEST_MOUNT_RO");
7220   if (str && strcmp (str, "1") == 0) return 1;
7221   return 0;
7222 }
7223
7224 static int test_mount_ro_0 (void)
7225 {
7226   if (test_mount_ro_0_skip ()) {
7227     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7228     return 0;
7229   }
7230
7231   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7232   {
7233     char device[] = "/dev/sda";
7234     int r;
7235     suppress_error = 0;
7236     r = guestfs_blockdev_setrw (g, device);
7237     if (r == -1)
7238       return -1;
7239   }
7240   {
7241     int r;
7242     suppress_error = 0;
7243     r = guestfs_umount_all (g);
7244     if (r == -1)
7245       return -1;
7246   }
7247   {
7248     int r;
7249     suppress_error = 0;
7250     r = guestfs_lvm_remove_all (g);
7251     if (r == -1)
7252       return -1;
7253   }
7254   {
7255     char device[] = "/dev/sda";
7256     char lines_0[] = ",";
7257     char *lines[] = {
7258       lines_0,
7259       NULL
7260     };
7261     int r;
7262     suppress_error = 0;
7263     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7264     if (r == -1)
7265       return -1;
7266   }
7267   {
7268     char fstype[] = "ext2";
7269     char device[] = "/dev/sda1";
7270     int r;
7271     suppress_error = 0;
7272     r = guestfs_mkfs (g, fstype, device);
7273     if (r == -1)
7274       return -1;
7275   }
7276   {
7277     char device[] = "/dev/sda1";
7278     char mountpoint[] = "/";
7279     int r;
7280     suppress_error = 0;
7281     r = guestfs_mount (g, device, mountpoint);
7282     if (r == -1)
7283       return -1;
7284   }
7285   /* TestLastFail for mount_ro (0) */
7286   {
7287     char pathordevice[] = "/";
7288     int r;
7289     suppress_error = 0;
7290     r = guestfs_umount (g, pathordevice);
7291     if (r == -1)
7292       return -1;
7293   }
7294   {
7295     char device[] = "/dev/sda1";
7296     char mountpoint[] = "/";
7297     int r;
7298     suppress_error = 0;
7299     r = guestfs_mount_ro (g, device, mountpoint);
7300     if (r == -1)
7301       return -1;
7302   }
7303   {
7304     char path[] = "/new";
7305     int r;
7306     suppress_error = 1;
7307     r = guestfs_touch (g, path);
7308     if (r != -1)
7309       return -1;
7310   }
7311   return 0;
7312 }
7313
7314 static int test_mount_ro_1_skip (void)
7315 {
7316   const char *str;
7317
7318   str = getenv ("TEST_ONLY");
7319   if (str)
7320     return strstr (str, "mount_ro") == NULL;
7321   str = getenv ("SKIP_TEST_MOUNT_RO_1");
7322   if (str && strcmp (str, "1") == 0) return 1;
7323   str = getenv ("SKIP_TEST_MOUNT_RO");
7324   if (str && strcmp (str, "1") == 0) return 1;
7325   return 0;
7326 }
7327
7328 static int test_mount_ro_1 (void)
7329 {
7330   if (test_mount_ro_1_skip ()) {
7331     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7332     return 0;
7333   }
7334
7335   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7336   {
7337     char device[] = "/dev/sda";
7338     int r;
7339     suppress_error = 0;
7340     r = guestfs_blockdev_setrw (g, device);
7341     if (r == -1)
7342       return -1;
7343   }
7344   {
7345     int r;
7346     suppress_error = 0;
7347     r = guestfs_umount_all (g);
7348     if (r == -1)
7349       return -1;
7350   }
7351   {
7352     int r;
7353     suppress_error = 0;
7354     r = guestfs_lvm_remove_all (g);
7355     if (r == -1)
7356       return -1;
7357   }
7358   {
7359     char device[] = "/dev/sda";
7360     char lines_0[] = ",";
7361     char *lines[] = {
7362       lines_0,
7363       NULL
7364     };
7365     int r;
7366     suppress_error = 0;
7367     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7368     if (r == -1)
7369       return -1;
7370   }
7371   {
7372     char fstype[] = "ext2";
7373     char device[] = "/dev/sda1";
7374     int r;
7375     suppress_error = 0;
7376     r = guestfs_mkfs (g, fstype, device);
7377     if (r == -1)
7378       return -1;
7379   }
7380   {
7381     char device[] = "/dev/sda1";
7382     char mountpoint[] = "/";
7383     int r;
7384     suppress_error = 0;
7385     r = guestfs_mount (g, device, mountpoint);
7386     if (r == -1)
7387       return -1;
7388   }
7389   /* TestOutput for mount_ro (1) */
7390   char expected[] = "data";
7391   {
7392     char path[] = "/new";
7393     char content[] = "data";
7394     int r;
7395     suppress_error = 0;
7396     r = guestfs_write_file (g, path, content, 0);
7397     if (r == -1)
7398       return -1;
7399   }
7400   {
7401     char pathordevice[] = "/";
7402     int r;
7403     suppress_error = 0;
7404     r = guestfs_umount (g, pathordevice);
7405     if (r == -1)
7406       return -1;
7407   }
7408   {
7409     char device[] = "/dev/sda1";
7410     char mountpoint[] = "/";
7411     int r;
7412     suppress_error = 0;
7413     r = guestfs_mount_ro (g, device, mountpoint);
7414     if (r == -1)
7415       return -1;
7416   }
7417   {
7418     char path[] = "/new";
7419     char *r;
7420     suppress_error = 0;
7421     r = guestfs_cat (g, path);
7422     if (r == NULL)
7423       return -1;
7424     if (strcmp (r, expected) != 0) {
7425       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7426       return -1;
7427     }
7428     free (r);
7429   }
7430   return 0;
7431 }
7432
7433 static int test_tgz_in_0_skip (void)
7434 {
7435   const char *str;
7436
7437   str = getenv ("TEST_ONLY");
7438   if (str)
7439     return strstr (str, "tgz_in") == NULL;
7440   str = getenv ("SKIP_TEST_TGZ_IN_0");
7441   if (str && strcmp (str, "1") == 0) return 1;
7442   str = getenv ("SKIP_TEST_TGZ_IN");
7443   if (str && strcmp (str, "1") == 0) return 1;
7444   return 0;
7445 }
7446
7447 static int test_tgz_in_0 (void)
7448 {
7449   if (test_tgz_in_0_skip ()) {
7450     printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7451     return 0;
7452   }
7453
7454   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7455   {
7456     char device[] = "/dev/sda";
7457     int r;
7458     suppress_error = 0;
7459     r = guestfs_blockdev_setrw (g, device);
7460     if (r == -1)
7461       return -1;
7462   }
7463   {
7464     int r;
7465     suppress_error = 0;
7466     r = guestfs_umount_all (g);
7467     if (r == -1)
7468       return -1;
7469   }
7470   {
7471     int r;
7472     suppress_error = 0;
7473     r = guestfs_lvm_remove_all (g);
7474     if (r == -1)
7475       return -1;
7476   }
7477   {
7478     char device[] = "/dev/sda";
7479     char lines_0[] = ",";
7480     char *lines[] = {
7481       lines_0,
7482       NULL
7483     };
7484     int r;
7485     suppress_error = 0;
7486     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7487     if (r == -1)
7488       return -1;
7489   }
7490   {
7491     char fstype[] = "ext2";
7492     char device[] = "/dev/sda1";
7493     int r;
7494     suppress_error = 0;
7495     r = guestfs_mkfs (g, fstype, device);
7496     if (r == -1)
7497       return -1;
7498   }
7499   {
7500     char device[] = "/dev/sda1";
7501     char mountpoint[] = "/";
7502     int r;
7503     suppress_error = 0;
7504     r = guestfs_mount (g, device, mountpoint);
7505     if (r == -1)
7506       return -1;
7507   }
7508   /* TestOutput for tgz_in (0) */
7509   char expected[] = "hello\n";
7510   {
7511     char directory[] = "/";
7512     int r;
7513     suppress_error = 0;
7514     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7515     if (r == -1)
7516       return -1;
7517   }
7518   {
7519     char path[] = "/hello";
7520     char *r;
7521     suppress_error = 0;
7522     r = guestfs_cat (g, path);
7523     if (r == NULL)
7524       return -1;
7525     if (strcmp (r, expected) != 0) {
7526       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7527       return -1;
7528     }
7529     free (r);
7530   }
7531   return 0;
7532 }
7533
7534 static int test_tar_in_0_skip (void)
7535 {
7536   const char *str;
7537
7538   str = getenv ("TEST_ONLY");
7539   if (str)
7540     return strstr (str, "tar_in") == NULL;
7541   str = getenv ("SKIP_TEST_TAR_IN_0");
7542   if (str && strcmp (str, "1") == 0) return 1;
7543   str = getenv ("SKIP_TEST_TAR_IN");
7544   if (str && strcmp (str, "1") == 0) return 1;
7545   return 0;
7546 }
7547
7548 static int test_tar_in_0 (void)
7549 {
7550   if (test_tar_in_0_skip ()) {
7551     printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7552     return 0;
7553   }
7554
7555   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7556   {
7557     char device[] = "/dev/sda";
7558     int r;
7559     suppress_error = 0;
7560     r = guestfs_blockdev_setrw (g, device);
7561     if (r == -1)
7562       return -1;
7563   }
7564   {
7565     int r;
7566     suppress_error = 0;
7567     r = guestfs_umount_all (g);
7568     if (r == -1)
7569       return -1;
7570   }
7571   {
7572     int r;
7573     suppress_error = 0;
7574     r = guestfs_lvm_remove_all (g);
7575     if (r == -1)
7576       return -1;
7577   }
7578   {
7579     char device[] = "/dev/sda";
7580     char lines_0[] = ",";
7581     char *lines[] = {
7582       lines_0,
7583       NULL
7584     };
7585     int r;
7586     suppress_error = 0;
7587     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7588     if (r == -1)
7589       return -1;
7590   }
7591   {
7592     char fstype[] = "ext2";
7593     char device[] = "/dev/sda1";
7594     int r;
7595     suppress_error = 0;
7596     r = guestfs_mkfs (g, fstype, device);
7597     if (r == -1)
7598       return -1;
7599   }
7600   {
7601     char device[] = "/dev/sda1";
7602     char mountpoint[] = "/";
7603     int r;
7604     suppress_error = 0;
7605     r = guestfs_mount (g, device, mountpoint);
7606     if (r == -1)
7607       return -1;
7608   }
7609   /* TestOutput for tar_in (0) */
7610   char expected[] = "hello\n";
7611   {
7612     char directory[] = "/";
7613     int r;
7614     suppress_error = 0;
7615     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7616     if (r == -1)
7617       return -1;
7618   }
7619   {
7620     char path[] = "/hello";
7621     char *r;
7622     suppress_error = 0;
7623     r = guestfs_cat (g, path);
7624     if (r == NULL)
7625       return -1;
7626     if (strcmp (r, expected) != 0) {
7627       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7628       return -1;
7629     }
7630     free (r);
7631   }
7632   return 0;
7633 }
7634
7635 static int test_checksum_0_skip (void)
7636 {
7637   const char *str;
7638
7639   str = getenv ("TEST_ONLY");
7640   if (str)
7641     return strstr (str, "checksum") == NULL;
7642   str = getenv ("SKIP_TEST_CHECKSUM_0");
7643   if (str && strcmp (str, "1") == 0) return 1;
7644   str = getenv ("SKIP_TEST_CHECKSUM");
7645   if (str && strcmp (str, "1") == 0) return 1;
7646   return 0;
7647 }
7648
7649 static int test_checksum_0 (void)
7650 {
7651   if (test_checksum_0_skip ()) {
7652     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7653     return 0;
7654   }
7655
7656   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7657   {
7658     char device[] = "/dev/sda";
7659     int r;
7660     suppress_error = 0;
7661     r = guestfs_blockdev_setrw (g, device);
7662     if (r == -1)
7663       return -1;
7664   }
7665   {
7666     int r;
7667     suppress_error = 0;
7668     r = guestfs_umount_all (g);
7669     if (r == -1)
7670       return -1;
7671   }
7672   {
7673     int r;
7674     suppress_error = 0;
7675     r = guestfs_lvm_remove_all (g);
7676     if (r == -1)
7677       return -1;
7678   }
7679   {
7680     char device[] = "/dev/sda";
7681     char lines_0[] = ",";
7682     char *lines[] = {
7683       lines_0,
7684       NULL
7685     };
7686     int r;
7687     suppress_error = 0;
7688     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7689     if (r == -1)
7690       return -1;
7691   }
7692   {
7693     char fstype[] = "ext2";
7694     char device[] = "/dev/sda1";
7695     int r;
7696     suppress_error = 0;
7697     r = guestfs_mkfs (g, fstype, device);
7698     if (r == -1)
7699       return -1;
7700   }
7701   {
7702     char device[] = "/dev/sda1";
7703     char mountpoint[] = "/";
7704     int r;
7705     suppress_error = 0;
7706     r = guestfs_mount (g, device, mountpoint);
7707     if (r == -1)
7708       return -1;
7709   }
7710   /* TestOutput for checksum (0) */
7711   char expected[] = "935282863";
7712   {
7713     char path[] = "/new";
7714     char content[] = "test\n";
7715     int r;
7716     suppress_error = 0;
7717     r = guestfs_write_file (g, path, content, 0);
7718     if (r == -1)
7719       return -1;
7720   }
7721   {
7722     char csumtype[] = "crc";
7723     char path[] = "/new";
7724     char *r;
7725     suppress_error = 0;
7726     r = guestfs_checksum (g, csumtype, path);
7727     if (r == NULL)
7728       return -1;
7729     if (strcmp (r, expected) != 0) {
7730       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7731       return -1;
7732     }
7733     free (r);
7734   }
7735   return 0;
7736 }
7737
7738 static int test_checksum_1_skip (void)
7739 {
7740   const char *str;
7741
7742   str = getenv ("TEST_ONLY");
7743   if (str)
7744     return strstr (str, "checksum") == NULL;
7745   str = getenv ("SKIP_TEST_CHECKSUM_1");
7746   if (str && strcmp (str, "1") == 0) return 1;
7747   str = getenv ("SKIP_TEST_CHECKSUM");
7748   if (str && strcmp (str, "1") == 0) return 1;
7749   return 0;
7750 }
7751
7752 static int test_checksum_1 (void)
7753 {
7754   if (test_checksum_1_skip ()) {
7755     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7756     return 0;
7757   }
7758
7759   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7760   {
7761     char device[] = "/dev/sda";
7762     int r;
7763     suppress_error = 0;
7764     r = guestfs_blockdev_setrw (g, device);
7765     if (r == -1)
7766       return -1;
7767   }
7768   {
7769     int r;
7770     suppress_error = 0;
7771     r = guestfs_umount_all (g);
7772     if (r == -1)
7773       return -1;
7774   }
7775   {
7776     int r;
7777     suppress_error = 0;
7778     r = guestfs_lvm_remove_all (g);
7779     if (r == -1)
7780       return -1;
7781   }
7782   {
7783     char device[] = "/dev/sda";
7784     char lines_0[] = ",";
7785     char *lines[] = {
7786       lines_0,
7787       NULL
7788     };
7789     int r;
7790     suppress_error = 0;
7791     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7792     if (r == -1)
7793       return -1;
7794   }
7795   {
7796     char fstype[] = "ext2";
7797     char device[] = "/dev/sda1";
7798     int r;
7799     suppress_error = 0;
7800     r = guestfs_mkfs (g, fstype, device);
7801     if (r == -1)
7802       return -1;
7803   }
7804   {
7805     char device[] = "/dev/sda1";
7806     char mountpoint[] = "/";
7807     int r;
7808     suppress_error = 0;
7809     r = guestfs_mount (g, device, mountpoint);
7810     if (r == -1)
7811       return -1;
7812   }
7813   /* TestLastFail for checksum (1) */
7814   {
7815     char csumtype[] = "crc";
7816     char path[] = "/new";
7817     char *r;
7818     suppress_error = 1;
7819     r = guestfs_checksum (g, csumtype, path);
7820     if (r != NULL)
7821       return -1;
7822     free (r);
7823   }
7824   return 0;
7825 }
7826
7827 static int test_checksum_2_skip (void)
7828 {
7829   const char *str;
7830
7831   str = getenv ("TEST_ONLY");
7832   if (str)
7833     return strstr (str, "checksum") == NULL;
7834   str = getenv ("SKIP_TEST_CHECKSUM_2");
7835   if (str && strcmp (str, "1") == 0) return 1;
7836   str = getenv ("SKIP_TEST_CHECKSUM");
7837   if (str && strcmp (str, "1") == 0) return 1;
7838   return 0;
7839 }
7840
7841 static int test_checksum_2 (void)
7842 {
7843   if (test_checksum_2_skip ()) {
7844     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
7845     return 0;
7846   }
7847
7848   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
7849   {
7850     char device[] = "/dev/sda";
7851     int r;
7852     suppress_error = 0;
7853     r = guestfs_blockdev_setrw (g, device);
7854     if (r == -1)
7855       return -1;
7856   }
7857   {
7858     int r;
7859     suppress_error = 0;
7860     r = guestfs_umount_all (g);
7861     if (r == -1)
7862       return -1;
7863   }
7864   {
7865     int r;
7866     suppress_error = 0;
7867     r = guestfs_lvm_remove_all (g);
7868     if (r == -1)
7869       return -1;
7870   }
7871   {
7872     char device[] = "/dev/sda";
7873     char lines_0[] = ",";
7874     char *lines[] = {
7875       lines_0,
7876       NULL
7877     };
7878     int r;
7879     suppress_error = 0;
7880     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7881     if (r == -1)
7882       return -1;
7883   }
7884   {
7885     char fstype[] = "ext2";
7886     char device[] = "/dev/sda1";
7887     int r;
7888     suppress_error = 0;
7889     r = guestfs_mkfs (g, fstype, device);
7890     if (r == -1)
7891       return -1;
7892   }
7893   {
7894     char device[] = "/dev/sda1";
7895     char mountpoint[] = "/";
7896     int r;
7897     suppress_error = 0;
7898     r = guestfs_mount (g, device, mountpoint);
7899     if (r == -1)
7900       return -1;
7901   }
7902   /* TestOutput for checksum (2) */
7903   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
7904   {
7905     char path[] = "/new";
7906     char content[] = "test\n";
7907     int r;
7908     suppress_error = 0;
7909     r = guestfs_write_file (g, path, content, 0);
7910     if (r == -1)
7911       return -1;
7912   }
7913   {
7914     char csumtype[] = "md5";
7915     char path[] = "/new";
7916     char *r;
7917     suppress_error = 0;
7918     r = guestfs_checksum (g, csumtype, path);
7919     if (r == NULL)
7920       return -1;
7921     if (strcmp (r, expected) != 0) {
7922       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
7923       return -1;
7924     }
7925     free (r);
7926   }
7927   return 0;
7928 }
7929
7930 static int test_checksum_3_skip (void)
7931 {
7932   const char *str;
7933
7934   str = getenv ("TEST_ONLY");
7935   if (str)
7936     return strstr (str, "checksum") == NULL;
7937   str = getenv ("SKIP_TEST_CHECKSUM_3");
7938   if (str && strcmp (str, "1") == 0) return 1;
7939   str = getenv ("SKIP_TEST_CHECKSUM");
7940   if (str && strcmp (str, "1") == 0) return 1;
7941   return 0;
7942 }
7943
7944 static int test_checksum_3 (void)
7945 {
7946   if (test_checksum_3_skip ()) {
7947     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
7948     return 0;
7949   }
7950
7951   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
7952   {
7953     char device[] = "/dev/sda";
7954     int r;
7955     suppress_error = 0;
7956     r = guestfs_blockdev_setrw (g, device);
7957     if (r == -1)
7958       return -1;
7959   }
7960   {
7961     int r;
7962     suppress_error = 0;
7963     r = guestfs_umount_all (g);
7964     if (r == -1)
7965       return -1;
7966   }
7967   {
7968     int r;
7969     suppress_error = 0;
7970     r = guestfs_lvm_remove_all (g);
7971     if (r == -1)
7972       return -1;
7973   }
7974   {
7975     char device[] = "/dev/sda";
7976     char lines_0[] = ",";
7977     char *lines[] = {
7978       lines_0,
7979       NULL
7980     };
7981     int r;
7982     suppress_error = 0;
7983     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7984     if (r == -1)
7985       return -1;
7986   }
7987   {
7988     char fstype[] = "ext2";
7989     char device[] = "/dev/sda1";
7990     int r;
7991     suppress_error = 0;
7992     r = guestfs_mkfs (g, fstype, device);
7993     if (r == -1)
7994       return -1;
7995   }
7996   {
7997     char device[] = "/dev/sda1";
7998     char mountpoint[] = "/";
7999     int r;
8000     suppress_error = 0;
8001     r = guestfs_mount (g, device, mountpoint);
8002     if (r == -1)
8003       return -1;
8004   }
8005   /* TestOutput for checksum (3) */
8006   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8007   {
8008     char path[] = "/new";
8009     char content[] = "test\n";
8010     int r;
8011     suppress_error = 0;
8012     r = guestfs_write_file (g, path, content, 0);
8013     if (r == -1)
8014       return -1;
8015   }
8016   {
8017     char csumtype[] = "sha1";
8018     char path[] = "/new";
8019     char *r;
8020     suppress_error = 0;
8021     r = guestfs_checksum (g, csumtype, path);
8022     if (r == NULL)
8023       return -1;
8024     if (strcmp (r, expected) != 0) {
8025       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8026       return -1;
8027     }
8028     free (r);
8029   }
8030   return 0;
8031 }
8032
8033 static int test_checksum_4_skip (void)
8034 {
8035   const char *str;
8036
8037   str = getenv ("TEST_ONLY");
8038   if (str)
8039     return strstr (str, "checksum") == NULL;
8040   str = getenv ("SKIP_TEST_CHECKSUM_4");
8041   if (str && strcmp (str, "1") == 0) return 1;
8042   str = getenv ("SKIP_TEST_CHECKSUM");
8043   if (str && strcmp (str, "1") == 0) return 1;
8044   return 0;
8045 }
8046
8047 static int test_checksum_4 (void)
8048 {
8049   if (test_checksum_4_skip ()) {
8050     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
8051     return 0;
8052   }
8053
8054   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8055   {
8056     char device[] = "/dev/sda";
8057     int r;
8058     suppress_error = 0;
8059     r = guestfs_blockdev_setrw (g, device);
8060     if (r == -1)
8061       return -1;
8062   }
8063   {
8064     int r;
8065     suppress_error = 0;
8066     r = guestfs_umount_all (g);
8067     if (r == -1)
8068       return -1;
8069   }
8070   {
8071     int r;
8072     suppress_error = 0;
8073     r = guestfs_lvm_remove_all (g);
8074     if (r == -1)
8075       return -1;
8076   }
8077   {
8078     char device[] = "/dev/sda";
8079     char lines_0[] = ",";
8080     char *lines[] = {
8081       lines_0,
8082       NULL
8083     };
8084     int r;
8085     suppress_error = 0;
8086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8087     if (r == -1)
8088       return -1;
8089   }
8090   {
8091     char fstype[] = "ext2";
8092     char device[] = "/dev/sda1";
8093     int r;
8094     suppress_error = 0;
8095     r = guestfs_mkfs (g, fstype, device);
8096     if (r == -1)
8097       return -1;
8098   }
8099   {
8100     char device[] = "/dev/sda1";
8101     char mountpoint[] = "/";
8102     int r;
8103     suppress_error = 0;
8104     r = guestfs_mount (g, device, mountpoint);
8105     if (r == -1)
8106       return -1;
8107   }
8108   /* TestOutput for checksum (4) */
8109   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8110   {
8111     char path[] = "/new";
8112     char content[] = "test\n";
8113     int r;
8114     suppress_error = 0;
8115     r = guestfs_write_file (g, path, content, 0);
8116     if (r == -1)
8117       return -1;
8118   }
8119   {
8120     char csumtype[] = "sha224";
8121     char path[] = "/new";
8122     char *r;
8123     suppress_error = 0;
8124     r = guestfs_checksum (g, csumtype, path);
8125     if (r == NULL)
8126       return -1;
8127     if (strcmp (r, expected) != 0) {
8128       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8129       return -1;
8130     }
8131     free (r);
8132   }
8133   return 0;
8134 }
8135
8136 static int test_checksum_5_skip (void)
8137 {
8138   const char *str;
8139
8140   str = getenv ("TEST_ONLY");
8141   if (str)
8142     return strstr (str, "checksum") == NULL;
8143   str = getenv ("SKIP_TEST_CHECKSUM_5");
8144   if (str && strcmp (str, "1") == 0) return 1;
8145   str = getenv ("SKIP_TEST_CHECKSUM");
8146   if (str && strcmp (str, "1") == 0) return 1;
8147   return 0;
8148 }
8149
8150 static int test_checksum_5 (void)
8151 {
8152   if (test_checksum_5_skip ()) {
8153     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8154     return 0;
8155   }
8156
8157   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8158   {
8159     char device[] = "/dev/sda";
8160     int r;
8161     suppress_error = 0;
8162     r = guestfs_blockdev_setrw (g, device);
8163     if (r == -1)
8164       return -1;
8165   }
8166   {
8167     int r;
8168     suppress_error = 0;
8169     r = guestfs_umount_all (g);
8170     if (r == -1)
8171       return -1;
8172   }
8173   {
8174     int r;
8175     suppress_error = 0;
8176     r = guestfs_lvm_remove_all (g);
8177     if (r == -1)
8178       return -1;
8179   }
8180   {
8181     char device[] = "/dev/sda";
8182     char lines_0[] = ",";
8183     char *lines[] = {
8184       lines_0,
8185       NULL
8186     };
8187     int r;
8188     suppress_error = 0;
8189     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8190     if (r == -1)
8191       return -1;
8192   }
8193   {
8194     char fstype[] = "ext2";
8195     char device[] = "/dev/sda1";
8196     int r;
8197     suppress_error = 0;
8198     r = guestfs_mkfs (g, fstype, device);
8199     if (r == -1)
8200       return -1;
8201   }
8202   {
8203     char device[] = "/dev/sda1";
8204     char mountpoint[] = "/";
8205     int r;
8206     suppress_error = 0;
8207     r = guestfs_mount (g, device, mountpoint);
8208     if (r == -1)
8209       return -1;
8210   }
8211   /* TestOutput for checksum (5) */
8212   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8213   {
8214     char path[] = "/new";
8215     char content[] = "test\n";
8216     int r;
8217     suppress_error = 0;
8218     r = guestfs_write_file (g, path, content, 0);
8219     if (r == -1)
8220       return -1;
8221   }
8222   {
8223     char csumtype[] = "sha256";
8224     char path[] = "/new";
8225     char *r;
8226     suppress_error = 0;
8227     r = guestfs_checksum (g, csumtype, path);
8228     if (r == NULL)
8229       return -1;
8230     if (strcmp (r, expected) != 0) {
8231       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8232       return -1;
8233     }
8234     free (r);
8235   }
8236   return 0;
8237 }
8238
8239 static int test_checksum_6_skip (void)
8240 {
8241   const char *str;
8242
8243   str = getenv ("TEST_ONLY");
8244   if (str)
8245     return strstr (str, "checksum") == NULL;
8246   str = getenv ("SKIP_TEST_CHECKSUM_6");
8247   if (str && strcmp (str, "1") == 0) return 1;
8248   str = getenv ("SKIP_TEST_CHECKSUM");
8249   if (str && strcmp (str, "1") == 0) return 1;
8250   return 0;
8251 }
8252
8253 static int test_checksum_6 (void)
8254 {
8255   if (test_checksum_6_skip ()) {
8256     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8257     return 0;
8258   }
8259
8260   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8261   {
8262     char device[] = "/dev/sda";
8263     int r;
8264     suppress_error = 0;
8265     r = guestfs_blockdev_setrw (g, device);
8266     if (r == -1)
8267       return -1;
8268   }
8269   {
8270     int r;
8271     suppress_error = 0;
8272     r = guestfs_umount_all (g);
8273     if (r == -1)
8274       return -1;
8275   }
8276   {
8277     int r;
8278     suppress_error = 0;
8279     r = guestfs_lvm_remove_all (g);
8280     if (r == -1)
8281       return -1;
8282   }
8283   {
8284     char device[] = "/dev/sda";
8285     char lines_0[] = ",";
8286     char *lines[] = {
8287       lines_0,
8288       NULL
8289     };
8290     int r;
8291     suppress_error = 0;
8292     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8293     if (r == -1)
8294       return -1;
8295   }
8296   {
8297     char fstype[] = "ext2";
8298     char device[] = "/dev/sda1";
8299     int r;
8300     suppress_error = 0;
8301     r = guestfs_mkfs (g, fstype, device);
8302     if (r == -1)
8303       return -1;
8304   }
8305   {
8306     char device[] = "/dev/sda1";
8307     char mountpoint[] = "/";
8308     int r;
8309     suppress_error = 0;
8310     r = guestfs_mount (g, device, mountpoint);
8311     if (r == -1)
8312       return -1;
8313   }
8314   /* TestOutput for checksum (6) */
8315   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8316   {
8317     char path[] = "/new";
8318     char content[] = "test\n";
8319     int r;
8320     suppress_error = 0;
8321     r = guestfs_write_file (g, path, content, 0);
8322     if (r == -1)
8323       return -1;
8324   }
8325   {
8326     char csumtype[] = "sha384";
8327     char path[] = "/new";
8328     char *r;
8329     suppress_error = 0;
8330     r = guestfs_checksum (g, csumtype, path);
8331     if (r == NULL)
8332       return -1;
8333     if (strcmp (r, expected) != 0) {
8334       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8335       return -1;
8336     }
8337     free (r);
8338   }
8339   return 0;
8340 }
8341
8342 static int test_checksum_7_skip (void)
8343 {
8344   const char *str;
8345
8346   str = getenv ("TEST_ONLY");
8347   if (str)
8348     return strstr (str, "checksum") == NULL;
8349   str = getenv ("SKIP_TEST_CHECKSUM_7");
8350   if (str && strcmp (str, "1") == 0) return 1;
8351   str = getenv ("SKIP_TEST_CHECKSUM");
8352   if (str && strcmp (str, "1") == 0) return 1;
8353   return 0;
8354 }
8355
8356 static int test_checksum_7 (void)
8357 {
8358   if (test_checksum_7_skip ()) {
8359     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8360     return 0;
8361   }
8362
8363   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8364   {
8365     char device[] = "/dev/sda";
8366     int r;
8367     suppress_error = 0;
8368     r = guestfs_blockdev_setrw (g, device);
8369     if (r == -1)
8370       return -1;
8371   }
8372   {
8373     int r;
8374     suppress_error = 0;
8375     r = guestfs_umount_all (g);
8376     if (r == -1)
8377       return -1;
8378   }
8379   {
8380     int r;
8381     suppress_error = 0;
8382     r = guestfs_lvm_remove_all (g);
8383     if (r == -1)
8384       return -1;
8385   }
8386   {
8387     char device[] = "/dev/sda";
8388     char lines_0[] = ",";
8389     char *lines[] = {
8390       lines_0,
8391       NULL
8392     };
8393     int r;
8394     suppress_error = 0;
8395     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8396     if (r == -1)
8397       return -1;
8398   }
8399   {
8400     char fstype[] = "ext2";
8401     char device[] = "/dev/sda1";
8402     int r;
8403     suppress_error = 0;
8404     r = guestfs_mkfs (g, fstype, device);
8405     if (r == -1)
8406       return -1;
8407   }
8408   {
8409     char device[] = "/dev/sda1";
8410     char mountpoint[] = "/";
8411     int r;
8412     suppress_error = 0;
8413     r = guestfs_mount (g, device, mountpoint);
8414     if (r == -1)
8415       return -1;
8416   }
8417   /* TestOutput for checksum (7) */
8418   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8419   {
8420     char path[] = "/new";
8421     char content[] = "test\n";
8422     int r;
8423     suppress_error = 0;
8424     r = guestfs_write_file (g, path, content, 0);
8425     if (r == -1)
8426       return -1;
8427   }
8428   {
8429     char csumtype[] = "sha512";
8430     char path[] = "/new";
8431     char *r;
8432     suppress_error = 0;
8433     r = guestfs_checksum (g, csumtype, path);
8434     if (r == NULL)
8435       return -1;
8436     if (strcmp (r, expected) != 0) {
8437       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8438       return -1;
8439     }
8440     free (r);
8441   }
8442   return 0;
8443 }
8444
8445 static int test_checksum_8_skip (void)
8446 {
8447   const char *str;
8448
8449   str = getenv ("TEST_ONLY");
8450   if (str)
8451     return strstr (str, "checksum") == NULL;
8452   str = getenv ("SKIP_TEST_CHECKSUM_8");
8453   if (str && strcmp (str, "1") == 0) return 1;
8454   str = getenv ("SKIP_TEST_CHECKSUM");
8455   if (str && strcmp (str, "1") == 0) return 1;
8456   return 0;
8457 }
8458
8459 static int test_checksum_8 (void)
8460 {
8461   if (test_checksum_8_skip ()) {
8462     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8463     return 0;
8464   }
8465
8466   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8467   {
8468     char device[] = "/dev/sda";
8469     int r;
8470     suppress_error = 0;
8471     r = guestfs_blockdev_setrw (g, device);
8472     if (r == -1)
8473       return -1;
8474   }
8475   {
8476     int r;
8477     suppress_error = 0;
8478     r = guestfs_umount_all (g);
8479     if (r == -1)
8480       return -1;
8481   }
8482   {
8483     int r;
8484     suppress_error = 0;
8485     r = guestfs_lvm_remove_all (g);
8486     if (r == -1)
8487       return -1;
8488   }
8489   {
8490     char device[] = "/dev/sda";
8491     char lines_0[] = ",";
8492     char *lines[] = {
8493       lines_0,
8494       NULL
8495     };
8496     int r;
8497     suppress_error = 0;
8498     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8499     if (r == -1)
8500       return -1;
8501   }
8502   {
8503     char fstype[] = "ext2";
8504     char device[] = "/dev/sda1";
8505     int r;
8506     suppress_error = 0;
8507     r = guestfs_mkfs (g, fstype, device);
8508     if (r == -1)
8509       return -1;
8510   }
8511   {
8512     char device[] = "/dev/sda1";
8513     char mountpoint[] = "/";
8514     int r;
8515     suppress_error = 0;
8516     r = guestfs_mount (g, device, mountpoint);
8517     if (r == -1)
8518       return -1;
8519   }
8520   /* TestOutput for checksum (8) */
8521   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8522   {
8523     char options[] = "ro";
8524     char vfstype[] = "squashfs";
8525     char device[] = "/dev/sdd";
8526     char mountpoint[] = "/";
8527     int r;
8528     suppress_error = 0;
8529     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8530     if (r == -1)
8531       return -1;
8532   }
8533   {
8534     char csumtype[] = "md5";
8535     char path[] = "/known-3";
8536     char *r;
8537     suppress_error = 0;
8538     r = guestfs_checksum (g, csumtype, path);
8539     if (r == NULL)
8540       return -1;
8541     if (strcmp (r, expected) != 0) {
8542       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8543       return -1;
8544     }
8545     free (r);
8546   }
8547   return 0;
8548 }
8549
8550 static int test_download_0_skip (void)
8551 {
8552   const char *str;
8553
8554   str = getenv ("TEST_ONLY");
8555   if (str)
8556     return strstr (str, "download") == NULL;
8557   str = getenv ("SKIP_TEST_DOWNLOAD_0");
8558   if (str && strcmp (str, "1") == 0) return 1;
8559   str = getenv ("SKIP_TEST_DOWNLOAD");
8560   if (str && strcmp (str, "1") == 0) return 1;
8561   return 0;
8562 }
8563
8564 static int test_download_0 (void)
8565 {
8566   if (test_download_0_skip ()) {
8567     printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8568     return 0;
8569   }
8570
8571   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8572   {
8573     char device[] = "/dev/sda";
8574     int r;
8575     suppress_error = 0;
8576     r = guestfs_blockdev_setrw (g, device);
8577     if (r == -1)
8578       return -1;
8579   }
8580   {
8581     int r;
8582     suppress_error = 0;
8583     r = guestfs_umount_all (g);
8584     if (r == -1)
8585       return -1;
8586   }
8587   {
8588     int r;
8589     suppress_error = 0;
8590     r = guestfs_lvm_remove_all (g);
8591     if (r == -1)
8592       return -1;
8593   }
8594   {
8595     char device[] = "/dev/sda";
8596     char lines_0[] = ",";
8597     char *lines[] = {
8598       lines_0,
8599       NULL
8600     };
8601     int r;
8602     suppress_error = 0;
8603     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8604     if (r == -1)
8605       return -1;
8606   }
8607   {
8608     char fstype[] = "ext2";
8609     char device[] = "/dev/sda1";
8610     int r;
8611     suppress_error = 0;
8612     r = guestfs_mkfs (g, fstype, device);
8613     if (r == -1)
8614       return -1;
8615   }
8616   {
8617     char device[] = "/dev/sda1";
8618     char mountpoint[] = "/";
8619     int r;
8620     suppress_error = 0;
8621     r = guestfs_mount (g, device, mountpoint);
8622     if (r == -1)
8623       return -1;
8624   }
8625   /* TestOutput for download (0) */
8626   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8627   {
8628     char remotefilename[] = "/COPYING.LIB";
8629     int r;
8630     suppress_error = 0;
8631     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8632     if (r == -1)
8633       return -1;
8634   }
8635   {
8636     char remotefilename[] = "/COPYING.LIB";
8637     int r;
8638     suppress_error = 0;
8639     r = guestfs_download (g, remotefilename, "testdownload.tmp");
8640     if (r == -1)
8641       return -1;
8642   }
8643   {
8644     char remotefilename[] = "/upload";
8645     int r;
8646     suppress_error = 0;
8647     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8648     if (r == -1)
8649       return -1;
8650   }
8651   {
8652     char csumtype[] = "md5";
8653     char path[] = "/upload";
8654     char *r;
8655     suppress_error = 0;
8656     r = guestfs_checksum (g, csumtype, path);
8657     if (r == NULL)
8658       return -1;
8659     if (strcmp (r, expected) != 0) {
8660       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8661       return -1;
8662     }
8663     free (r);
8664   }
8665   return 0;
8666 }
8667
8668 static int test_upload_0_skip (void)
8669 {
8670   const char *str;
8671
8672   str = getenv ("TEST_ONLY");
8673   if (str)
8674     return strstr (str, "upload") == NULL;
8675   str = getenv ("SKIP_TEST_UPLOAD_0");
8676   if (str && strcmp (str, "1") == 0) return 1;
8677   str = getenv ("SKIP_TEST_UPLOAD");
8678   if (str && strcmp (str, "1") == 0) return 1;
8679   return 0;
8680 }
8681
8682 static int test_upload_0 (void)
8683 {
8684   if (test_upload_0_skip ()) {
8685     printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8686     return 0;
8687   }
8688
8689   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8690   {
8691     char device[] = "/dev/sda";
8692     int r;
8693     suppress_error = 0;
8694     r = guestfs_blockdev_setrw (g, device);
8695     if (r == -1)
8696       return -1;
8697   }
8698   {
8699     int r;
8700     suppress_error = 0;
8701     r = guestfs_umount_all (g);
8702     if (r == -1)
8703       return -1;
8704   }
8705   {
8706     int r;
8707     suppress_error = 0;
8708     r = guestfs_lvm_remove_all (g);
8709     if (r == -1)
8710       return -1;
8711   }
8712   {
8713     char device[] = "/dev/sda";
8714     char lines_0[] = ",";
8715     char *lines[] = {
8716       lines_0,
8717       NULL
8718     };
8719     int r;
8720     suppress_error = 0;
8721     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8722     if (r == -1)
8723       return -1;
8724   }
8725   {
8726     char fstype[] = "ext2";
8727     char device[] = "/dev/sda1";
8728     int r;
8729     suppress_error = 0;
8730     r = guestfs_mkfs (g, fstype, device);
8731     if (r == -1)
8732       return -1;
8733   }
8734   {
8735     char device[] = "/dev/sda1";
8736     char mountpoint[] = "/";
8737     int r;
8738     suppress_error = 0;
8739     r = guestfs_mount (g, device, mountpoint);
8740     if (r == -1)
8741       return -1;
8742   }
8743   /* TestOutput for upload (0) */
8744   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8745   {
8746     char remotefilename[] = "/COPYING.LIB";
8747     int r;
8748     suppress_error = 0;
8749     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8750     if (r == -1)
8751       return -1;
8752   }
8753   {
8754     char csumtype[] = "md5";
8755     char path[] = "/COPYING.LIB";
8756     char *r;
8757     suppress_error = 0;
8758     r = guestfs_checksum (g, csumtype, path);
8759     if (r == NULL)
8760       return -1;
8761     if (strcmp (r, expected) != 0) {
8762       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8763       return -1;
8764     }
8765     free (r);
8766   }
8767   return 0;
8768 }
8769
8770 static int test_blockdev_rereadpt_0_skip (void)
8771 {
8772   const char *str;
8773
8774   str = getenv ("TEST_ONLY");
8775   if (str)
8776     return strstr (str, "blockdev_rereadpt") == NULL;
8777   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8778   if (str && strcmp (str, "1") == 0) return 1;
8779   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8780   if (str && strcmp (str, "1") == 0) return 1;
8781   return 0;
8782 }
8783
8784 static int test_blockdev_rereadpt_0 (void)
8785 {
8786   if (test_blockdev_rereadpt_0_skip ()) {
8787     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8788     return 0;
8789   }
8790
8791   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
8792   {
8793     char device[] = "/dev/sda";
8794     int r;
8795     suppress_error = 0;
8796     r = guestfs_blockdev_setrw (g, device);
8797     if (r == -1)
8798       return -1;
8799   }
8800   {
8801     int r;
8802     suppress_error = 0;
8803     r = guestfs_umount_all (g);
8804     if (r == -1)
8805       return -1;
8806   }
8807   {
8808     int r;
8809     suppress_error = 0;
8810     r = guestfs_lvm_remove_all (g);
8811     if (r == -1)
8812       return -1;
8813   }
8814   /* TestRun for blockdev_rereadpt (0) */
8815   {
8816     char device[] = "/dev/sda";
8817     int r;
8818     suppress_error = 0;
8819     r = guestfs_blockdev_rereadpt (g, device);
8820     if (r == -1)
8821       return -1;
8822   }
8823   return 0;
8824 }
8825
8826 static int test_blockdev_flushbufs_0_skip (void)
8827 {
8828   const char *str;
8829
8830   str = getenv ("TEST_ONLY");
8831   if (str)
8832     return strstr (str, "blockdev_flushbufs") == NULL;
8833   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
8834   if (str && strcmp (str, "1") == 0) return 1;
8835   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
8836   if (str && strcmp (str, "1") == 0) return 1;
8837   return 0;
8838 }
8839
8840 static int test_blockdev_flushbufs_0 (void)
8841 {
8842   if (test_blockdev_flushbufs_0_skip ()) {
8843     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
8844     return 0;
8845   }
8846
8847   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
8848   {
8849     char device[] = "/dev/sda";
8850     int r;
8851     suppress_error = 0;
8852     r = guestfs_blockdev_setrw (g, device);
8853     if (r == -1)
8854       return -1;
8855   }
8856   {
8857     int r;
8858     suppress_error = 0;
8859     r = guestfs_umount_all (g);
8860     if (r == -1)
8861       return -1;
8862   }
8863   {
8864     int r;
8865     suppress_error = 0;
8866     r = guestfs_lvm_remove_all (g);
8867     if (r == -1)
8868       return -1;
8869   }
8870   /* TestRun for blockdev_flushbufs (0) */
8871   {
8872     char device[] = "/dev/sda";
8873     int r;
8874     suppress_error = 0;
8875     r = guestfs_blockdev_flushbufs (g, device);
8876     if (r == -1)
8877       return -1;
8878   }
8879   return 0;
8880 }
8881
8882 static int test_blockdev_getsize64_0_skip (void)
8883 {
8884   const char *str;
8885
8886   str = getenv ("TEST_ONLY");
8887   if (str)
8888     return strstr (str, "blockdev_getsize64") == NULL;
8889   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
8890   if (str && strcmp (str, "1") == 0) return 1;
8891   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
8892   if (str && strcmp (str, "1") == 0) return 1;
8893   return 0;
8894 }
8895
8896 static int test_blockdev_getsize64_0 (void)
8897 {
8898   if (test_blockdev_getsize64_0_skip ()) {
8899     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
8900     return 0;
8901   }
8902
8903   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
8904   {
8905     char device[] = "/dev/sda";
8906     int r;
8907     suppress_error = 0;
8908     r = guestfs_blockdev_setrw (g, device);
8909     if (r == -1)
8910       return -1;
8911   }
8912   {
8913     int r;
8914     suppress_error = 0;
8915     r = guestfs_umount_all (g);
8916     if (r == -1)
8917       return -1;
8918   }
8919   {
8920     int r;
8921     suppress_error = 0;
8922     r = guestfs_lvm_remove_all (g);
8923     if (r == -1)
8924       return -1;
8925   }
8926   /* TestOutputInt for blockdev_getsize64 (0) */
8927   {
8928     char device[] = "/dev/sda";
8929     int64_t r;
8930     suppress_error = 0;
8931     r = guestfs_blockdev_getsize64 (g, device);
8932     if (r == -1)
8933       return -1;
8934     if (r != 524288000) {
8935       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
8936       return -1;
8937     }
8938   }
8939   return 0;
8940 }
8941
8942 static int test_blockdev_getsz_0_skip (void)
8943 {
8944   const char *str;
8945
8946   str = getenv ("TEST_ONLY");
8947   if (str)
8948     return strstr (str, "blockdev_getsz") == NULL;
8949   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
8950   if (str && strcmp (str, "1") == 0) return 1;
8951   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
8952   if (str && strcmp (str, "1") == 0) return 1;
8953   return 0;
8954 }
8955
8956 static int test_blockdev_getsz_0 (void)
8957 {
8958   if (test_blockdev_getsz_0_skip ()) {
8959     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
8960     return 0;
8961   }
8962
8963   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
8964   {
8965     char device[] = "/dev/sda";
8966     int r;
8967     suppress_error = 0;
8968     r = guestfs_blockdev_setrw (g, device);
8969     if (r == -1)
8970       return -1;
8971   }
8972   {
8973     int r;
8974     suppress_error = 0;
8975     r = guestfs_umount_all (g);
8976     if (r == -1)
8977       return -1;
8978   }
8979   {
8980     int r;
8981     suppress_error = 0;
8982     r = guestfs_lvm_remove_all (g);
8983     if (r == -1)
8984       return -1;
8985   }
8986   /* TestOutputInt for blockdev_getsz (0) */
8987   {
8988     char device[] = "/dev/sda";
8989     int64_t r;
8990     suppress_error = 0;
8991     r = guestfs_blockdev_getsz (g, device);
8992     if (r == -1)
8993       return -1;
8994     if (r != 1024000) {
8995       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
8996       return -1;
8997     }
8998   }
8999   return 0;
9000 }
9001
9002 static int test_blockdev_getbsz_0_skip (void)
9003 {
9004   const char *str;
9005
9006   str = getenv ("TEST_ONLY");
9007   if (str)
9008     return strstr (str, "blockdev_getbsz") == NULL;
9009   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9010   if (str && strcmp (str, "1") == 0) return 1;
9011   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9012   if (str && strcmp (str, "1") == 0) return 1;
9013   return 0;
9014 }
9015
9016 static int test_blockdev_getbsz_0 (void)
9017 {
9018   if (test_blockdev_getbsz_0_skip ()) {
9019     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9020     return 0;
9021   }
9022
9023   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9024   {
9025     char device[] = "/dev/sda";
9026     int r;
9027     suppress_error = 0;
9028     r = guestfs_blockdev_setrw (g, device);
9029     if (r == -1)
9030       return -1;
9031   }
9032   {
9033     int r;
9034     suppress_error = 0;
9035     r = guestfs_umount_all (g);
9036     if (r == -1)
9037       return -1;
9038   }
9039   {
9040     int r;
9041     suppress_error = 0;
9042     r = guestfs_lvm_remove_all (g);
9043     if (r == -1)
9044       return -1;
9045   }
9046   /* TestOutputInt for blockdev_getbsz (0) */
9047   {
9048     char device[] = "/dev/sda";
9049     int r;
9050     suppress_error = 0;
9051     r = guestfs_blockdev_getbsz (g, device);
9052     if (r == -1)
9053       return -1;
9054     if (r != 4096) {
9055       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
9056       return -1;
9057     }
9058   }
9059   return 0;
9060 }
9061
9062 static int test_blockdev_getss_0_skip (void)
9063 {
9064   const char *str;
9065
9066   str = getenv ("TEST_ONLY");
9067   if (str)
9068     return strstr (str, "blockdev_getss") == NULL;
9069   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9070   if (str && strcmp (str, "1") == 0) return 1;
9071   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9072   if (str && strcmp (str, "1") == 0) return 1;
9073   return 0;
9074 }
9075
9076 static int test_blockdev_getss_0 (void)
9077 {
9078   if (test_blockdev_getss_0_skip ()) {
9079     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9080     return 0;
9081   }
9082
9083   /* InitNone|InitEmpty for test_blockdev_getss_0 */
9084   {
9085     char device[] = "/dev/sda";
9086     int r;
9087     suppress_error = 0;
9088     r = guestfs_blockdev_setrw (g, device);
9089     if (r == -1)
9090       return -1;
9091   }
9092   {
9093     int r;
9094     suppress_error = 0;
9095     r = guestfs_umount_all (g);
9096     if (r == -1)
9097       return -1;
9098   }
9099   {
9100     int r;
9101     suppress_error = 0;
9102     r = guestfs_lvm_remove_all (g);
9103     if (r == -1)
9104       return -1;
9105   }
9106   /* TestOutputInt for blockdev_getss (0) */
9107   {
9108     char device[] = "/dev/sda";
9109     int r;
9110     suppress_error = 0;
9111     r = guestfs_blockdev_getss (g, device);
9112     if (r == -1)
9113       return -1;
9114     if (r != 512) {
9115       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
9116       return -1;
9117     }
9118   }
9119   return 0;
9120 }
9121
9122 static int test_blockdev_getro_0_skip (void)
9123 {
9124   const char *str;
9125
9126   str = getenv ("TEST_ONLY");
9127   if (str)
9128     return strstr (str, "blockdev_getro") == NULL;
9129   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9130   if (str && strcmp (str, "1") == 0) return 1;
9131   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9132   if (str && strcmp (str, "1") == 0) return 1;
9133   return 0;
9134 }
9135
9136 static int test_blockdev_getro_0 (void)
9137 {
9138   if (test_blockdev_getro_0_skip ()) {
9139     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9140     return 0;
9141   }
9142
9143   /* InitNone|InitEmpty for test_blockdev_getro_0 */
9144   {
9145     char device[] = "/dev/sda";
9146     int r;
9147     suppress_error = 0;
9148     r = guestfs_blockdev_setrw (g, device);
9149     if (r == -1)
9150       return -1;
9151   }
9152   {
9153     int r;
9154     suppress_error = 0;
9155     r = guestfs_umount_all (g);
9156     if (r == -1)
9157       return -1;
9158   }
9159   {
9160     int r;
9161     suppress_error = 0;
9162     r = guestfs_lvm_remove_all (g);
9163     if (r == -1)
9164       return -1;
9165   }
9166   /* TestOutputTrue for blockdev_getro (0) */
9167   {
9168     char device[] = "/dev/sda";
9169     int r;
9170     suppress_error = 0;
9171     r = guestfs_blockdev_setro (g, device);
9172     if (r == -1)
9173       return -1;
9174   }
9175   {
9176     char device[] = "/dev/sda";
9177     int r;
9178     suppress_error = 0;
9179     r = guestfs_blockdev_getro (g, device);
9180     if (r == -1)
9181       return -1;
9182     if (!r) {
9183       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9184       return -1;
9185     }
9186   }
9187   return 0;
9188 }
9189
9190 static int test_blockdev_setrw_0_skip (void)
9191 {
9192   const char *str;
9193
9194   str = getenv ("TEST_ONLY");
9195   if (str)
9196     return strstr (str, "blockdev_setrw") == NULL;
9197   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9198   if (str && strcmp (str, "1") == 0) return 1;
9199   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9200   if (str && strcmp (str, "1") == 0) return 1;
9201   return 0;
9202 }
9203
9204 static int test_blockdev_setrw_0 (void)
9205 {
9206   if (test_blockdev_setrw_0_skip ()) {
9207     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9208     return 0;
9209   }
9210
9211   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9212   {
9213     char device[] = "/dev/sda";
9214     int r;
9215     suppress_error = 0;
9216     r = guestfs_blockdev_setrw (g, device);
9217     if (r == -1)
9218       return -1;
9219   }
9220   {
9221     int r;
9222     suppress_error = 0;
9223     r = guestfs_umount_all (g);
9224     if (r == -1)
9225       return -1;
9226   }
9227   {
9228     int r;
9229     suppress_error = 0;
9230     r = guestfs_lvm_remove_all (g);
9231     if (r == -1)
9232       return -1;
9233   }
9234   /* TestOutputFalse for blockdev_setrw (0) */
9235   {
9236     char device[] = "/dev/sda";
9237     int r;
9238     suppress_error = 0;
9239     r = guestfs_blockdev_setrw (g, device);
9240     if (r == -1)
9241       return -1;
9242   }
9243   {
9244     char device[] = "/dev/sda";
9245     int r;
9246     suppress_error = 0;
9247     r = guestfs_blockdev_getro (g, device);
9248     if (r == -1)
9249       return -1;
9250     if (r) {
9251       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9252       return -1;
9253     }
9254   }
9255   return 0;
9256 }
9257
9258 static int test_blockdev_setro_0_skip (void)
9259 {
9260   const char *str;
9261
9262   str = getenv ("TEST_ONLY");
9263   if (str)
9264     return strstr (str, "blockdev_setro") == NULL;
9265   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9266   if (str && strcmp (str, "1") == 0) return 1;
9267   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9268   if (str && strcmp (str, "1") == 0) return 1;
9269   return 0;
9270 }
9271
9272 static int test_blockdev_setro_0 (void)
9273 {
9274   if (test_blockdev_setro_0_skip ()) {
9275     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9276     return 0;
9277   }
9278
9279   /* InitNone|InitEmpty for test_blockdev_setro_0 */
9280   {
9281     char device[] = "/dev/sda";
9282     int r;
9283     suppress_error = 0;
9284     r = guestfs_blockdev_setrw (g, device);
9285     if (r == -1)
9286       return -1;
9287   }
9288   {
9289     int r;
9290     suppress_error = 0;
9291     r = guestfs_umount_all (g);
9292     if (r == -1)
9293       return -1;
9294   }
9295   {
9296     int r;
9297     suppress_error = 0;
9298     r = guestfs_lvm_remove_all (g);
9299     if (r == -1)
9300       return -1;
9301   }
9302   /* TestOutputTrue for blockdev_setro (0) */
9303   {
9304     char device[] = "/dev/sda";
9305     int r;
9306     suppress_error = 0;
9307     r = guestfs_blockdev_setro (g, device);
9308     if (r == -1)
9309       return -1;
9310   }
9311   {
9312     char device[] = "/dev/sda";
9313     int r;
9314     suppress_error = 0;
9315     r = guestfs_blockdev_getro (g, device);
9316     if (r == -1)
9317       return -1;
9318     if (!r) {
9319       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9320       return -1;
9321     }
9322   }
9323   return 0;
9324 }
9325
9326 static int test_statvfs_0_skip (void)
9327 {
9328   const char *str;
9329
9330   str = getenv ("TEST_ONLY");
9331   if (str)
9332     return strstr (str, "statvfs") == NULL;
9333   str = getenv ("SKIP_TEST_STATVFS_0");
9334   if (str && strcmp (str, "1") == 0) return 1;
9335   str = getenv ("SKIP_TEST_STATVFS");
9336   if (str && strcmp (str, "1") == 0) return 1;
9337   return 0;
9338 }
9339
9340 static int test_statvfs_0 (void)
9341 {
9342   if (test_statvfs_0_skip ()) {
9343     printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9344     return 0;
9345   }
9346
9347   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9348   {
9349     char device[] = "/dev/sda";
9350     int r;
9351     suppress_error = 0;
9352     r = guestfs_blockdev_setrw (g, device);
9353     if (r == -1)
9354       return -1;
9355   }
9356   {
9357     int r;
9358     suppress_error = 0;
9359     r = guestfs_umount_all (g);
9360     if (r == -1)
9361       return -1;
9362   }
9363   {
9364     int r;
9365     suppress_error = 0;
9366     r = guestfs_lvm_remove_all (g);
9367     if (r == -1)
9368       return -1;
9369   }
9370   {
9371     char device[] = "/dev/sda";
9372     char lines_0[] = ",";
9373     char *lines[] = {
9374       lines_0,
9375       NULL
9376     };
9377     int r;
9378     suppress_error = 0;
9379     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9380     if (r == -1)
9381       return -1;
9382   }
9383   {
9384     char fstype[] = "ext2";
9385     char device[] = "/dev/sda1";
9386     int r;
9387     suppress_error = 0;
9388     r = guestfs_mkfs (g, fstype, device);
9389     if (r == -1)
9390       return -1;
9391   }
9392   {
9393     char device[] = "/dev/sda1";
9394     char mountpoint[] = "/";
9395     int r;
9396     suppress_error = 0;
9397     r = guestfs_mount (g, device, mountpoint);
9398     if (r == -1)
9399       return -1;
9400   }
9401   /* TestOutputStruct for statvfs (0) */
9402   {
9403     char path[] = "/";
9404     struct guestfs_statvfs *r;
9405     suppress_error = 0;
9406     r = guestfs_statvfs (g, path);
9407     if (r == NULL)
9408       return -1;
9409     if (r->bfree != 487702) {
9410       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9411                (int) r->bfree);
9412       return -1;
9413     }
9414     if (r->blocks != 490020) {
9415       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9416                (int) r->blocks);
9417       return -1;
9418     }
9419     if (r->bsize != 1024) {
9420       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9421                (int) r->bsize);
9422       return -1;
9423     }
9424     free (r);
9425   }
9426   return 0;
9427 }
9428
9429 static int test_lstat_0_skip (void)
9430 {
9431   const char *str;
9432
9433   str = getenv ("TEST_ONLY");
9434   if (str)
9435     return strstr (str, "lstat") == NULL;
9436   str = getenv ("SKIP_TEST_LSTAT_0");
9437   if (str && strcmp (str, "1") == 0) return 1;
9438   str = getenv ("SKIP_TEST_LSTAT");
9439   if (str && strcmp (str, "1") == 0) return 1;
9440   return 0;
9441 }
9442
9443 static int test_lstat_0 (void)
9444 {
9445   if (test_lstat_0_skip ()) {
9446     printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9447     return 0;
9448   }
9449
9450   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9451   {
9452     char device[] = "/dev/sda";
9453     int r;
9454     suppress_error = 0;
9455     r = guestfs_blockdev_setrw (g, device);
9456     if (r == -1)
9457       return -1;
9458   }
9459   {
9460     int r;
9461     suppress_error = 0;
9462     r = guestfs_umount_all (g);
9463     if (r == -1)
9464       return -1;
9465   }
9466   {
9467     int r;
9468     suppress_error = 0;
9469     r = guestfs_lvm_remove_all (g);
9470     if (r == -1)
9471       return -1;
9472   }
9473   {
9474     char device[] = "/dev/sda";
9475     char lines_0[] = ",";
9476     char *lines[] = {
9477       lines_0,
9478       NULL
9479     };
9480     int r;
9481     suppress_error = 0;
9482     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9483     if (r == -1)
9484       return -1;
9485   }
9486   {
9487     char fstype[] = "ext2";
9488     char device[] = "/dev/sda1";
9489     int r;
9490     suppress_error = 0;
9491     r = guestfs_mkfs (g, fstype, device);
9492     if (r == -1)
9493       return -1;
9494   }
9495   {
9496     char device[] = "/dev/sda1";
9497     char mountpoint[] = "/";
9498     int r;
9499     suppress_error = 0;
9500     r = guestfs_mount (g, device, mountpoint);
9501     if (r == -1)
9502       return -1;
9503   }
9504   /* TestOutputStruct for lstat (0) */
9505   {
9506     char path[] = "/new";
9507     int r;
9508     suppress_error = 0;
9509     r = guestfs_touch (g, path);
9510     if (r == -1)
9511       return -1;
9512   }
9513   {
9514     char path[] = "/new";
9515     struct guestfs_stat *r;
9516     suppress_error = 0;
9517     r = guestfs_lstat (g, path);
9518     if (r == NULL)
9519       return -1;
9520     if (r->size != 0) {
9521       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9522                (int) r->size);
9523       return -1;
9524     }
9525     free (r);
9526   }
9527   return 0;
9528 }
9529
9530 static int test_stat_0_skip (void)
9531 {
9532   const char *str;
9533
9534   str = getenv ("TEST_ONLY");
9535   if (str)
9536     return strstr (str, "stat") == NULL;
9537   str = getenv ("SKIP_TEST_STAT_0");
9538   if (str && strcmp (str, "1") == 0) return 1;
9539   str = getenv ("SKIP_TEST_STAT");
9540   if (str && strcmp (str, "1") == 0) return 1;
9541   return 0;
9542 }
9543
9544 static int test_stat_0 (void)
9545 {
9546   if (test_stat_0_skip ()) {
9547     printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9548     return 0;
9549   }
9550
9551   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9552   {
9553     char device[] = "/dev/sda";
9554     int r;
9555     suppress_error = 0;
9556     r = guestfs_blockdev_setrw (g, device);
9557     if (r == -1)
9558       return -1;
9559   }
9560   {
9561     int r;
9562     suppress_error = 0;
9563     r = guestfs_umount_all (g);
9564     if (r == -1)
9565       return -1;
9566   }
9567   {
9568     int r;
9569     suppress_error = 0;
9570     r = guestfs_lvm_remove_all (g);
9571     if (r == -1)
9572       return -1;
9573   }
9574   {
9575     char device[] = "/dev/sda";
9576     char lines_0[] = ",";
9577     char *lines[] = {
9578       lines_0,
9579       NULL
9580     };
9581     int r;
9582     suppress_error = 0;
9583     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9584     if (r == -1)
9585       return -1;
9586   }
9587   {
9588     char fstype[] = "ext2";
9589     char device[] = "/dev/sda1";
9590     int r;
9591     suppress_error = 0;
9592     r = guestfs_mkfs (g, fstype, device);
9593     if (r == -1)
9594       return -1;
9595   }
9596   {
9597     char device[] = "/dev/sda1";
9598     char mountpoint[] = "/";
9599     int r;
9600     suppress_error = 0;
9601     r = guestfs_mount (g, device, mountpoint);
9602     if (r == -1)
9603       return -1;
9604   }
9605   /* TestOutputStruct for stat (0) */
9606   {
9607     char path[] = "/new";
9608     int r;
9609     suppress_error = 0;
9610     r = guestfs_touch (g, path);
9611     if (r == -1)
9612       return -1;
9613   }
9614   {
9615     char path[] = "/new";
9616     struct guestfs_stat *r;
9617     suppress_error = 0;
9618     r = guestfs_stat (g, path);
9619     if (r == NULL)
9620       return -1;
9621     if (r->size != 0) {
9622       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9623                (int) r->size);
9624       return -1;
9625     }
9626     free (r);
9627   }
9628   return 0;
9629 }
9630
9631 static int test_command_lines_0_skip (void)
9632 {
9633   const char *str;
9634
9635   str = getenv ("TEST_ONLY");
9636   if (str)
9637     return strstr (str, "command_lines") == NULL;
9638   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9639   if (str && strcmp (str, "1") == 0) return 1;
9640   str = getenv ("SKIP_TEST_COMMAND_LINES");
9641   if (str && strcmp (str, "1") == 0) return 1;
9642   return 0;
9643 }
9644
9645 static int test_command_lines_0 (void)
9646 {
9647   if (test_command_lines_0_skip ()) {
9648     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9649     return 0;
9650   }
9651
9652   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9653   {
9654     char device[] = "/dev/sda";
9655     int r;
9656     suppress_error = 0;
9657     r = guestfs_blockdev_setrw (g, device);
9658     if (r == -1)
9659       return -1;
9660   }
9661   {
9662     int r;
9663     suppress_error = 0;
9664     r = guestfs_umount_all (g);
9665     if (r == -1)
9666       return -1;
9667   }
9668   {
9669     int r;
9670     suppress_error = 0;
9671     r = guestfs_lvm_remove_all (g);
9672     if (r == -1)
9673       return -1;
9674   }
9675   {
9676     char device[] = "/dev/sda";
9677     char lines_0[] = ",";
9678     char *lines[] = {
9679       lines_0,
9680       NULL
9681     };
9682     int r;
9683     suppress_error = 0;
9684     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9685     if (r == -1)
9686       return -1;
9687   }
9688   {
9689     char fstype[] = "ext2";
9690     char device[] = "/dev/sda1";
9691     int r;
9692     suppress_error = 0;
9693     r = guestfs_mkfs (g, fstype, device);
9694     if (r == -1)
9695       return -1;
9696   }
9697   {
9698     char device[] = "/dev/sda1";
9699     char mountpoint[] = "/";
9700     int r;
9701     suppress_error = 0;
9702     r = guestfs_mount (g, device, mountpoint);
9703     if (r == -1)
9704       return -1;
9705   }
9706   /* TestOutputList for command_lines (0) */
9707   {
9708     char remotefilename[] = "/test-command";
9709     int r;
9710     suppress_error = 0;
9711     r = guestfs_upload (g, "test-command", remotefilename);
9712     if (r == -1)
9713       return -1;
9714   }
9715   {
9716     char path[] = "/test-command";
9717     int r;
9718     suppress_error = 0;
9719     r = guestfs_chmod (g, 493, path);
9720     if (r == -1)
9721       return -1;
9722   }
9723   {
9724     char arguments_0[] = "/test-command";
9725     char arguments_1[] = "1";
9726     char *arguments[] = {
9727       arguments_0,
9728       arguments_1,
9729       NULL
9730     };
9731     char **r;
9732     int i;
9733     suppress_error = 0;
9734     r = guestfs_command_lines (g, arguments);
9735     if (r == NULL)
9736       return -1;
9737     if (!r[0]) {
9738       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9739       print_strings (r);
9740       return -1;
9741     }
9742     {
9743       char expected[] = "Result1";
9744       if (strcmp (r[0], expected) != 0) {
9745         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9746         return -1;
9747       }
9748     }
9749     if (r[1] != NULL) {
9750       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9751       print_strings (r);
9752       return -1;
9753     }
9754     for (i = 0; r[i] != NULL; ++i)
9755       free (r[i]);
9756     free (r);
9757   }
9758   return 0;
9759 }
9760
9761 static int test_command_lines_1_skip (void)
9762 {
9763   const char *str;
9764
9765   str = getenv ("TEST_ONLY");
9766   if (str)
9767     return strstr (str, "command_lines") == NULL;
9768   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9769   if (str && strcmp (str, "1") == 0) return 1;
9770   str = getenv ("SKIP_TEST_COMMAND_LINES");
9771   if (str && strcmp (str, "1") == 0) return 1;
9772   return 0;
9773 }
9774
9775 static int test_command_lines_1 (void)
9776 {
9777   if (test_command_lines_1_skip ()) {
9778     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9779     return 0;
9780   }
9781
9782   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9783   {
9784     char device[] = "/dev/sda";
9785     int r;
9786     suppress_error = 0;
9787     r = guestfs_blockdev_setrw (g, device);
9788     if (r == -1)
9789       return -1;
9790   }
9791   {
9792     int r;
9793     suppress_error = 0;
9794     r = guestfs_umount_all (g);
9795     if (r == -1)
9796       return -1;
9797   }
9798   {
9799     int r;
9800     suppress_error = 0;
9801     r = guestfs_lvm_remove_all (g);
9802     if (r == -1)
9803       return -1;
9804   }
9805   {
9806     char device[] = "/dev/sda";
9807     char lines_0[] = ",";
9808     char *lines[] = {
9809       lines_0,
9810       NULL
9811     };
9812     int r;
9813     suppress_error = 0;
9814     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9815     if (r == -1)
9816       return -1;
9817   }
9818   {
9819     char fstype[] = "ext2";
9820     char device[] = "/dev/sda1";
9821     int r;
9822     suppress_error = 0;
9823     r = guestfs_mkfs (g, fstype, device);
9824     if (r == -1)
9825       return -1;
9826   }
9827   {
9828     char device[] = "/dev/sda1";
9829     char mountpoint[] = "/";
9830     int r;
9831     suppress_error = 0;
9832     r = guestfs_mount (g, device, mountpoint);
9833     if (r == -1)
9834       return -1;
9835   }
9836   /* TestOutputList for command_lines (1) */
9837   {
9838     char remotefilename[] = "/test-command";
9839     int r;
9840     suppress_error = 0;
9841     r = guestfs_upload (g, "test-command", remotefilename);
9842     if (r == -1)
9843       return -1;
9844   }
9845   {
9846     char path[] = "/test-command";
9847     int r;
9848     suppress_error = 0;
9849     r = guestfs_chmod (g, 493, path);
9850     if (r == -1)
9851       return -1;
9852   }
9853   {
9854     char arguments_0[] = "/test-command";
9855     char arguments_1[] = "2";
9856     char *arguments[] = {
9857       arguments_0,
9858       arguments_1,
9859       NULL
9860     };
9861     char **r;
9862     int i;
9863     suppress_error = 0;
9864     r = guestfs_command_lines (g, arguments);
9865     if (r == NULL)
9866       return -1;
9867     if (!r[0]) {
9868       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
9869       print_strings (r);
9870       return -1;
9871     }
9872     {
9873       char expected[] = "Result2";
9874       if (strcmp (r[0], expected) != 0) {
9875         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9876         return -1;
9877       }
9878     }
9879     if (r[1] != NULL) {
9880       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
9881       print_strings (r);
9882       return -1;
9883     }
9884     for (i = 0; r[i] != NULL; ++i)
9885       free (r[i]);
9886     free (r);
9887   }
9888   return 0;
9889 }
9890
9891 static int test_command_lines_2_skip (void)
9892 {
9893   const char *str;
9894
9895   str = getenv ("TEST_ONLY");
9896   if (str)
9897     return strstr (str, "command_lines") == NULL;
9898   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
9899   if (str && strcmp (str, "1") == 0) return 1;
9900   str = getenv ("SKIP_TEST_COMMAND_LINES");
9901   if (str && strcmp (str, "1") == 0) return 1;
9902   return 0;
9903 }
9904
9905 static int test_command_lines_2 (void)
9906 {
9907   if (test_command_lines_2_skip ()) {
9908     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
9909     return 0;
9910   }
9911
9912   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
9913   {
9914     char device[] = "/dev/sda";
9915     int r;
9916     suppress_error = 0;
9917     r = guestfs_blockdev_setrw (g, device);
9918     if (r == -1)
9919       return -1;
9920   }
9921   {
9922     int r;
9923     suppress_error = 0;
9924     r = guestfs_umount_all (g);
9925     if (r == -1)
9926       return -1;
9927   }
9928   {
9929     int r;
9930     suppress_error = 0;
9931     r = guestfs_lvm_remove_all (g);
9932     if (r == -1)
9933       return -1;
9934   }
9935   {
9936     char device[] = "/dev/sda";
9937     char lines_0[] = ",";
9938     char *lines[] = {
9939       lines_0,
9940       NULL
9941     };
9942     int r;
9943     suppress_error = 0;
9944     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9945     if (r == -1)
9946       return -1;
9947   }
9948   {
9949     char fstype[] = "ext2";
9950     char device[] = "/dev/sda1";
9951     int r;
9952     suppress_error = 0;
9953     r = guestfs_mkfs (g, fstype, device);
9954     if (r == -1)
9955       return -1;
9956   }
9957   {
9958     char device[] = "/dev/sda1";
9959     char mountpoint[] = "/";
9960     int r;
9961     suppress_error = 0;
9962     r = guestfs_mount (g, device, mountpoint);
9963     if (r == -1)
9964       return -1;
9965   }
9966   /* TestOutputList for command_lines (2) */
9967   {
9968     char remotefilename[] = "/test-command";
9969     int r;
9970     suppress_error = 0;
9971     r = guestfs_upload (g, "test-command", remotefilename);
9972     if (r == -1)
9973       return -1;
9974   }
9975   {
9976     char path[] = "/test-command";
9977     int r;
9978     suppress_error = 0;
9979     r = guestfs_chmod (g, 493, path);
9980     if (r == -1)
9981       return -1;
9982   }
9983   {
9984     char arguments_0[] = "/test-command";
9985     char arguments_1[] = "3";
9986     char *arguments[] = {
9987       arguments_0,
9988       arguments_1,
9989       NULL
9990     };
9991     char **r;
9992     int i;
9993     suppress_error = 0;
9994     r = guestfs_command_lines (g, arguments);
9995     if (r == NULL)
9996       return -1;
9997     if (!r[0]) {
9998       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9999       print_strings (r);
10000       return -1;
10001     }
10002     {
10003       char expected[] = "";
10004       if (strcmp (r[0], expected) != 0) {
10005         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10006         return -1;
10007       }
10008     }
10009     if (!r[1]) {
10010       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10011       print_strings (r);
10012       return -1;
10013     }
10014     {
10015       char expected[] = "Result3";
10016       if (strcmp (r[1], expected) != 0) {
10017         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10018         return -1;
10019       }
10020     }
10021     if (r[2] != NULL) {
10022       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10023       print_strings (r);
10024       return -1;
10025     }
10026     for (i = 0; r[i] != NULL; ++i)
10027       free (r[i]);
10028     free (r);
10029   }
10030   return 0;
10031 }
10032
10033 static int test_command_lines_3_skip (void)
10034 {
10035   const char *str;
10036
10037   str = getenv ("TEST_ONLY");
10038   if (str)
10039     return strstr (str, "command_lines") == NULL;
10040   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10041   if (str && strcmp (str, "1") == 0) return 1;
10042   str = getenv ("SKIP_TEST_COMMAND_LINES");
10043   if (str && strcmp (str, "1") == 0) return 1;
10044   return 0;
10045 }
10046
10047 static int test_command_lines_3 (void)
10048 {
10049   if (test_command_lines_3_skip ()) {
10050     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
10051     return 0;
10052   }
10053
10054   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10055   {
10056     char device[] = "/dev/sda";
10057     int r;
10058     suppress_error = 0;
10059     r = guestfs_blockdev_setrw (g, device);
10060     if (r == -1)
10061       return -1;
10062   }
10063   {
10064     int r;
10065     suppress_error = 0;
10066     r = guestfs_umount_all (g);
10067     if (r == -1)
10068       return -1;
10069   }
10070   {
10071     int r;
10072     suppress_error = 0;
10073     r = guestfs_lvm_remove_all (g);
10074     if (r == -1)
10075       return -1;
10076   }
10077   {
10078     char device[] = "/dev/sda";
10079     char lines_0[] = ",";
10080     char *lines[] = {
10081       lines_0,
10082       NULL
10083     };
10084     int r;
10085     suppress_error = 0;
10086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10087     if (r == -1)
10088       return -1;
10089   }
10090   {
10091     char fstype[] = "ext2";
10092     char device[] = "/dev/sda1";
10093     int r;
10094     suppress_error = 0;
10095     r = guestfs_mkfs (g, fstype, device);
10096     if (r == -1)
10097       return -1;
10098   }
10099   {
10100     char device[] = "/dev/sda1";
10101     char mountpoint[] = "/";
10102     int r;
10103     suppress_error = 0;
10104     r = guestfs_mount (g, device, mountpoint);
10105     if (r == -1)
10106       return -1;
10107   }
10108   /* TestOutputList for command_lines (3) */
10109   {
10110     char remotefilename[] = "/test-command";
10111     int r;
10112     suppress_error = 0;
10113     r = guestfs_upload (g, "test-command", remotefilename);
10114     if (r == -1)
10115       return -1;
10116   }
10117   {
10118     char path[] = "/test-command";
10119     int r;
10120     suppress_error = 0;
10121     r = guestfs_chmod (g, 493, path);
10122     if (r == -1)
10123       return -1;
10124   }
10125   {
10126     char arguments_0[] = "/test-command";
10127     char arguments_1[] = "4";
10128     char *arguments[] = {
10129       arguments_0,
10130       arguments_1,
10131       NULL
10132     };
10133     char **r;
10134     int i;
10135     suppress_error = 0;
10136     r = guestfs_command_lines (g, arguments);
10137     if (r == NULL)
10138       return -1;
10139     if (!r[0]) {
10140       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10141       print_strings (r);
10142       return -1;
10143     }
10144     {
10145       char expected[] = "";
10146       if (strcmp (r[0], expected) != 0) {
10147         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10148         return -1;
10149       }
10150     }
10151     if (!r[1]) {
10152       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10153       print_strings (r);
10154       return -1;
10155     }
10156     {
10157       char expected[] = "Result4";
10158       if (strcmp (r[1], expected) != 0) {
10159         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10160         return -1;
10161       }
10162     }
10163     if (r[2] != NULL) {
10164       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10165       print_strings (r);
10166       return -1;
10167     }
10168     for (i = 0; r[i] != NULL; ++i)
10169       free (r[i]);
10170     free (r);
10171   }
10172   return 0;
10173 }
10174
10175 static int test_command_lines_4_skip (void)
10176 {
10177   const char *str;
10178
10179   str = getenv ("TEST_ONLY");
10180   if (str)
10181     return strstr (str, "command_lines") == NULL;
10182   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10183   if (str && strcmp (str, "1") == 0) return 1;
10184   str = getenv ("SKIP_TEST_COMMAND_LINES");
10185   if (str && strcmp (str, "1") == 0) return 1;
10186   return 0;
10187 }
10188
10189 static int test_command_lines_4 (void)
10190 {
10191   if (test_command_lines_4_skip ()) {
10192     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10193     return 0;
10194   }
10195
10196   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10197   {
10198     char device[] = "/dev/sda";
10199     int r;
10200     suppress_error = 0;
10201     r = guestfs_blockdev_setrw (g, device);
10202     if (r == -1)
10203       return -1;
10204   }
10205   {
10206     int r;
10207     suppress_error = 0;
10208     r = guestfs_umount_all (g);
10209     if (r == -1)
10210       return -1;
10211   }
10212   {
10213     int r;
10214     suppress_error = 0;
10215     r = guestfs_lvm_remove_all (g);
10216     if (r == -1)
10217       return -1;
10218   }
10219   {
10220     char device[] = "/dev/sda";
10221     char lines_0[] = ",";
10222     char *lines[] = {
10223       lines_0,
10224       NULL
10225     };
10226     int r;
10227     suppress_error = 0;
10228     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10229     if (r == -1)
10230       return -1;
10231   }
10232   {
10233     char fstype[] = "ext2";
10234     char device[] = "/dev/sda1";
10235     int r;
10236     suppress_error = 0;
10237     r = guestfs_mkfs (g, fstype, device);
10238     if (r == -1)
10239       return -1;
10240   }
10241   {
10242     char device[] = "/dev/sda1";
10243     char mountpoint[] = "/";
10244     int r;
10245     suppress_error = 0;
10246     r = guestfs_mount (g, device, mountpoint);
10247     if (r == -1)
10248       return -1;
10249   }
10250   /* TestOutputList for command_lines (4) */
10251   {
10252     char remotefilename[] = "/test-command";
10253     int r;
10254     suppress_error = 0;
10255     r = guestfs_upload (g, "test-command", remotefilename);
10256     if (r == -1)
10257       return -1;
10258   }
10259   {
10260     char path[] = "/test-command";
10261     int r;
10262     suppress_error = 0;
10263     r = guestfs_chmod (g, 493, path);
10264     if (r == -1)
10265       return -1;
10266   }
10267   {
10268     char arguments_0[] = "/test-command";
10269     char arguments_1[] = "5";
10270     char *arguments[] = {
10271       arguments_0,
10272       arguments_1,
10273       NULL
10274     };
10275     char **r;
10276     int i;
10277     suppress_error = 0;
10278     r = guestfs_command_lines (g, arguments);
10279     if (r == NULL)
10280       return -1;
10281     if (!r[0]) {
10282       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10283       print_strings (r);
10284       return -1;
10285     }
10286     {
10287       char expected[] = "";
10288       if (strcmp (r[0], expected) != 0) {
10289         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10290         return -1;
10291       }
10292     }
10293     if (!r[1]) {
10294       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10295       print_strings (r);
10296       return -1;
10297     }
10298     {
10299       char expected[] = "Result5";
10300       if (strcmp (r[1], expected) != 0) {
10301         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10302         return -1;
10303       }
10304     }
10305     if (!r[2]) {
10306       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10307       print_strings (r);
10308       return -1;
10309     }
10310     {
10311       char expected[] = "";
10312       if (strcmp (r[2], expected) != 0) {
10313         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10314         return -1;
10315       }
10316     }
10317     if (r[3] != NULL) {
10318       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10319       print_strings (r);
10320       return -1;
10321     }
10322     for (i = 0; r[i] != NULL; ++i)
10323       free (r[i]);
10324     free (r);
10325   }
10326   return 0;
10327 }
10328
10329 static int test_command_lines_5_skip (void)
10330 {
10331   const char *str;
10332
10333   str = getenv ("TEST_ONLY");
10334   if (str)
10335     return strstr (str, "command_lines") == NULL;
10336   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10337   if (str && strcmp (str, "1") == 0) return 1;
10338   str = getenv ("SKIP_TEST_COMMAND_LINES");
10339   if (str && strcmp (str, "1") == 0) return 1;
10340   return 0;
10341 }
10342
10343 static int test_command_lines_5 (void)
10344 {
10345   if (test_command_lines_5_skip ()) {
10346     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10347     return 0;
10348   }
10349
10350   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10351   {
10352     char device[] = "/dev/sda";
10353     int r;
10354     suppress_error = 0;
10355     r = guestfs_blockdev_setrw (g, device);
10356     if (r == -1)
10357       return -1;
10358   }
10359   {
10360     int r;
10361     suppress_error = 0;
10362     r = guestfs_umount_all (g);
10363     if (r == -1)
10364       return -1;
10365   }
10366   {
10367     int r;
10368     suppress_error = 0;
10369     r = guestfs_lvm_remove_all (g);
10370     if (r == -1)
10371       return -1;
10372   }
10373   {
10374     char device[] = "/dev/sda";
10375     char lines_0[] = ",";
10376     char *lines[] = {
10377       lines_0,
10378       NULL
10379     };
10380     int r;
10381     suppress_error = 0;
10382     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10383     if (r == -1)
10384       return -1;
10385   }
10386   {
10387     char fstype[] = "ext2";
10388     char device[] = "/dev/sda1";
10389     int r;
10390     suppress_error = 0;
10391     r = guestfs_mkfs (g, fstype, device);
10392     if (r == -1)
10393       return -1;
10394   }
10395   {
10396     char device[] = "/dev/sda1";
10397     char mountpoint[] = "/";
10398     int r;
10399     suppress_error = 0;
10400     r = guestfs_mount (g, device, mountpoint);
10401     if (r == -1)
10402       return -1;
10403   }
10404   /* TestOutputList for command_lines (5) */
10405   {
10406     char remotefilename[] = "/test-command";
10407     int r;
10408     suppress_error = 0;
10409     r = guestfs_upload (g, "test-command", remotefilename);
10410     if (r == -1)
10411       return -1;
10412   }
10413   {
10414     char path[] = "/test-command";
10415     int r;
10416     suppress_error = 0;
10417     r = guestfs_chmod (g, 493, path);
10418     if (r == -1)
10419       return -1;
10420   }
10421   {
10422     char arguments_0[] = "/test-command";
10423     char arguments_1[] = "6";
10424     char *arguments[] = {
10425       arguments_0,
10426       arguments_1,
10427       NULL
10428     };
10429     char **r;
10430     int i;
10431     suppress_error = 0;
10432     r = guestfs_command_lines (g, arguments);
10433     if (r == NULL)
10434       return -1;
10435     if (!r[0]) {
10436       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10437       print_strings (r);
10438       return -1;
10439     }
10440     {
10441       char expected[] = "";
10442       if (strcmp (r[0], expected) != 0) {
10443         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10444         return -1;
10445       }
10446     }
10447     if (!r[1]) {
10448       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10449       print_strings (r);
10450       return -1;
10451     }
10452     {
10453       char expected[] = "";
10454       if (strcmp (r[1], expected) != 0) {
10455         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10456         return -1;
10457       }
10458     }
10459     if (!r[2]) {
10460       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10461       print_strings (r);
10462       return -1;
10463     }
10464     {
10465       char expected[] = "Result6";
10466       if (strcmp (r[2], expected) != 0) {
10467         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10468         return -1;
10469       }
10470     }
10471     if (!r[3]) {
10472       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10473       print_strings (r);
10474       return -1;
10475     }
10476     {
10477       char expected[] = "";
10478       if (strcmp (r[3], expected) != 0) {
10479         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10480         return -1;
10481       }
10482     }
10483     if (r[4] != NULL) {
10484       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10485       print_strings (r);
10486       return -1;
10487     }
10488     for (i = 0; r[i] != NULL; ++i)
10489       free (r[i]);
10490     free (r);
10491   }
10492   return 0;
10493 }
10494
10495 static int test_command_lines_6_skip (void)
10496 {
10497   const char *str;
10498
10499   str = getenv ("TEST_ONLY");
10500   if (str)
10501     return strstr (str, "command_lines") == NULL;
10502   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10503   if (str && strcmp (str, "1") == 0) return 1;
10504   str = getenv ("SKIP_TEST_COMMAND_LINES");
10505   if (str && strcmp (str, "1") == 0) return 1;
10506   return 0;
10507 }
10508
10509 static int test_command_lines_6 (void)
10510 {
10511   if (test_command_lines_6_skip ()) {
10512     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10513     return 0;
10514   }
10515
10516   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10517   {
10518     char device[] = "/dev/sda";
10519     int r;
10520     suppress_error = 0;
10521     r = guestfs_blockdev_setrw (g, device);
10522     if (r == -1)
10523       return -1;
10524   }
10525   {
10526     int r;
10527     suppress_error = 0;
10528     r = guestfs_umount_all (g);
10529     if (r == -1)
10530       return -1;
10531   }
10532   {
10533     int r;
10534     suppress_error = 0;
10535     r = guestfs_lvm_remove_all (g);
10536     if (r == -1)
10537       return -1;
10538   }
10539   {
10540     char device[] = "/dev/sda";
10541     char lines_0[] = ",";
10542     char *lines[] = {
10543       lines_0,
10544       NULL
10545     };
10546     int r;
10547     suppress_error = 0;
10548     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10549     if (r == -1)
10550       return -1;
10551   }
10552   {
10553     char fstype[] = "ext2";
10554     char device[] = "/dev/sda1";
10555     int r;
10556     suppress_error = 0;
10557     r = guestfs_mkfs (g, fstype, device);
10558     if (r == -1)
10559       return -1;
10560   }
10561   {
10562     char device[] = "/dev/sda1";
10563     char mountpoint[] = "/";
10564     int r;
10565     suppress_error = 0;
10566     r = guestfs_mount (g, device, mountpoint);
10567     if (r == -1)
10568       return -1;
10569   }
10570   /* TestOutputList for command_lines (6) */
10571   {
10572     char remotefilename[] = "/test-command";
10573     int r;
10574     suppress_error = 0;
10575     r = guestfs_upload (g, "test-command", remotefilename);
10576     if (r == -1)
10577       return -1;
10578   }
10579   {
10580     char path[] = "/test-command";
10581     int r;
10582     suppress_error = 0;
10583     r = guestfs_chmod (g, 493, path);
10584     if (r == -1)
10585       return -1;
10586   }
10587   {
10588     char arguments_0[] = "/test-command";
10589     char arguments_1[] = "7";
10590     char *arguments[] = {
10591       arguments_0,
10592       arguments_1,
10593       NULL
10594     };
10595     char **r;
10596     int i;
10597     suppress_error = 0;
10598     r = guestfs_command_lines (g, arguments);
10599     if (r == NULL)
10600       return -1;
10601     if (r[0] != NULL) {
10602       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10603       print_strings (r);
10604       return -1;
10605     }
10606     for (i = 0; r[i] != NULL; ++i)
10607       free (r[i]);
10608     free (r);
10609   }
10610   return 0;
10611 }
10612
10613 static int test_command_lines_7_skip (void)
10614 {
10615   const char *str;
10616
10617   str = getenv ("TEST_ONLY");
10618   if (str)
10619     return strstr (str, "command_lines") == NULL;
10620   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10621   if (str && strcmp (str, "1") == 0) return 1;
10622   str = getenv ("SKIP_TEST_COMMAND_LINES");
10623   if (str && strcmp (str, "1") == 0) return 1;
10624   return 0;
10625 }
10626
10627 static int test_command_lines_7 (void)
10628 {
10629   if (test_command_lines_7_skip ()) {
10630     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10631     return 0;
10632   }
10633
10634   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10635   {
10636     char device[] = "/dev/sda";
10637     int r;
10638     suppress_error = 0;
10639     r = guestfs_blockdev_setrw (g, device);
10640     if (r == -1)
10641       return -1;
10642   }
10643   {
10644     int r;
10645     suppress_error = 0;
10646     r = guestfs_umount_all (g);
10647     if (r == -1)
10648       return -1;
10649   }
10650   {
10651     int r;
10652     suppress_error = 0;
10653     r = guestfs_lvm_remove_all (g);
10654     if (r == -1)
10655       return -1;
10656   }
10657   {
10658     char device[] = "/dev/sda";
10659     char lines_0[] = ",";
10660     char *lines[] = {
10661       lines_0,
10662       NULL
10663     };
10664     int r;
10665     suppress_error = 0;
10666     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10667     if (r == -1)
10668       return -1;
10669   }
10670   {
10671     char fstype[] = "ext2";
10672     char device[] = "/dev/sda1";
10673     int r;
10674     suppress_error = 0;
10675     r = guestfs_mkfs (g, fstype, device);
10676     if (r == -1)
10677       return -1;
10678   }
10679   {
10680     char device[] = "/dev/sda1";
10681     char mountpoint[] = "/";
10682     int r;
10683     suppress_error = 0;
10684     r = guestfs_mount (g, device, mountpoint);
10685     if (r == -1)
10686       return -1;
10687   }
10688   /* TestOutputList for command_lines (7) */
10689   {
10690     char remotefilename[] = "/test-command";
10691     int r;
10692     suppress_error = 0;
10693     r = guestfs_upload (g, "test-command", remotefilename);
10694     if (r == -1)
10695       return -1;
10696   }
10697   {
10698     char path[] = "/test-command";
10699     int r;
10700     suppress_error = 0;
10701     r = guestfs_chmod (g, 493, path);
10702     if (r == -1)
10703       return -1;
10704   }
10705   {
10706     char arguments_0[] = "/test-command";
10707     char arguments_1[] = "8";
10708     char *arguments[] = {
10709       arguments_0,
10710       arguments_1,
10711       NULL
10712     };
10713     char **r;
10714     int i;
10715     suppress_error = 0;
10716     r = guestfs_command_lines (g, arguments);
10717     if (r == NULL)
10718       return -1;
10719     if (!r[0]) {
10720       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10721       print_strings (r);
10722       return -1;
10723     }
10724     {
10725       char expected[] = "";
10726       if (strcmp (r[0], expected) != 0) {
10727         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10728         return -1;
10729       }
10730     }
10731     if (r[1] != NULL) {
10732       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10733       print_strings (r);
10734       return -1;
10735     }
10736     for (i = 0; r[i] != NULL; ++i)
10737       free (r[i]);
10738     free (r);
10739   }
10740   return 0;
10741 }
10742
10743 static int test_command_lines_8_skip (void)
10744 {
10745   const char *str;
10746
10747   str = getenv ("TEST_ONLY");
10748   if (str)
10749     return strstr (str, "command_lines") == NULL;
10750   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10751   if (str && strcmp (str, "1") == 0) return 1;
10752   str = getenv ("SKIP_TEST_COMMAND_LINES");
10753   if (str && strcmp (str, "1") == 0) return 1;
10754   return 0;
10755 }
10756
10757 static int test_command_lines_8 (void)
10758 {
10759   if (test_command_lines_8_skip ()) {
10760     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10761     return 0;
10762   }
10763
10764   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10765   {
10766     char device[] = "/dev/sda";
10767     int r;
10768     suppress_error = 0;
10769     r = guestfs_blockdev_setrw (g, device);
10770     if (r == -1)
10771       return -1;
10772   }
10773   {
10774     int r;
10775     suppress_error = 0;
10776     r = guestfs_umount_all (g);
10777     if (r == -1)
10778       return -1;
10779   }
10780   {
10781     int r;
10782     suppress_error = 0;
10783     r = guestfs_lvm_remove_all (g);
10784     if (r == -1)
10785       return -1;
10786   }
10787   {
10788     char device[] = "/dev/sda";
10789     char lines_0[] = ",";
10790     char *lines[] = {
10791       lines_0,
10792       NULL
10793     };
10794     int r;
10795     suppress_error = 0;
10796     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10797     if (r == -1)
10798       return -1;
10799   }
10800   {
10801     char fstype[] = "ext2";
10802     char device[] = "/dev/sda1";
10803     int r;
10804     suppress_error = 0;
10805     r = guestfs_mkfs (g, fstype, device);
10806     if (r == -1)
10807       return -1;
10808   }
10809   {
10810     char device[] = "/dev/sda1";
10811     char mountpoint[] = "/";
10812     int r;
10813     suppress_error = 0;
10814     r = guestfs_mount (g, device, mountpoint);
10815     if (r == -1)
10816       return -1;
10817   }
10818   /* TestOutputList for command_lines (8) */
10819   {
10820     char remotefilename[] = "/test-command";
10821     int r;
10822     suppress_error = 0;
10823     r = guestfs_upload (g, "test-command", remotefilename);
10824     if (r == -1)
10825       return -1;
10826   }
10827   {
10828     char path[] = "/test-command";
10829     int r;
10830     suppress_error = 0;
10831     r = guestfs_chmod (g, 493, path);
10832     if (r == -1)
10833       return -1;
10834   }
10835   {
10836     char arguments_0[] = "/test-command";
10837     char arguments_1[] = "9";
10838     char *arguments[] = {
10839       arguments_0,
10840       arguments_1,
10841       NULL
10842     };
10843     char **r;
10844     int i;
10845     suppress_error = 0;
10846     r = guestfs_command_lines (g, arguments);
10847     if (r == NULL)
10848       return -1;
10849     if (!r[0]) {
10850       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10851       print_strings (r);
10852       return -1;
10853     }
10854     {
10855       char expected[] = "";
10856       if (strcmp (r[0], expected) != 0) {
10857         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10858         return -1;
10859       }
10860     }
10861     if (!r[1]) {
10862       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10863       print_strings (r);
10864       return -1;
10865     }
10866     {
10867       char expected[] = "";
10868       if (strcmp (r[1], expected) != 0) {
10869         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10870         return -1;
10871       }
10872     }
10873     if (r[2] != NULL) {
10874       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
10875       print_strings (r);
10876       return -1;
10877     }
10878     for (i = 0; r[i] != NULL; ++i)
10879       free (r[i]);
10880     free (r);
10881   }
10882   return 0;
10883 }
10884
10885 static int test_command_lines_9_skip (void)
10886 {
10887   const char *str;
10888
10889   str = getenv ("TEST_ONLY");
10890   if (str)
10891     return strstr (str, "command_lines") == NULL;
10892   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
10893   if (str && strcmp (str, "1") == 0) return 1;
10894   str = getenv ("SKIP_TEST_COMMAND_LINES");
10895   if (str && strcmp (str, "1") == 0) return 1;
10896   return 0;
10897 }
10898
10899 static int test_command_lines_9 (void)
10900 {
10901   if (test_command_lines_9_skip ()) {
10902     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
10903     return 0;
10904   }
10905
10906   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
10907   {
10908     char device[] = "/dev/sda";
10909     int r;
10910     suppress_error = 0;
10911     r = guestfs_blockdev_setrw (g, device);
10912     if (r == -1)
10913       return -1;
10914   }
10915   {
10916     int r;
10917     suppress_error = 0;
10918     r = guestfs_umount_all (g);
10919     if (r == -1)
10920       return -1;
10921   }
10922   {
10923     int r;
10924     suppress_error = 0;
10925     r = guestfs_lvm_remove_all (g);
10926     if (r == -1)
10927       return -1;
10928   }
10929   {
10930     char device[] = "/dev/sda";
10931     char lines_0[] = ",";
10932     char *lines[] = {
10933       lines_0,
10934       NULL
10935     };
10936     int r;
10937     suppress_error = 0;
10938     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10939     if (r == -1)
10940       return -1;
10941   }
10942   {
10943     char fstype[] = "ext2";
10944     char device[] = "/dev/sda1";
10945     int r;
10946     suppress_error = 0;
10947     r = guestfs_mkfs (g, fstype, device);
10948     if (r == -1)
10949       return -1;
10950   }
10951   {
10952     char device[] = "/dev/sda1";
10953     char mountpoint[] = "/";
10954     int r;
10955     suppress_error = 0;
10956     r = guestfs_mount (g, device, mountpoint);
10957     if (r == -1)
10958       return -1;
10959   }
10960   /* TestOutputList for command_lines (9) */
10961   {
10962     char remotefilename[] = "/test-command";
10963     int r;
10964     suppress_error = 0;
10965     r = guestfs_upload (g, "test-command", remotefilename);
10966     if (r == -1)
10967       return -1;
10968   }
10969   {
10970     char path[] = "/test-command";
10971     int r;
10972     suppress_error = 0;
10973     r = guestfs_chmod (g, 493, path);
10974     if (r == -1)
10975       return -1;
10976   }
10977   {
10978     char arguments_0[] = "/test-command";
10979     char arguments_1[] = "10";
10980     char *arguments[] = {
10981       arguments_0,
10982       arguments_1,
10983       NULL
10984     };
10985     char **r;
10986     int i;
10987     suppress_error = 0;
10988     r = guestfs_command_lines (g, arguments);
10989     if (r == NULL)
10990       return -1;
10991     if (!r[0]) {
10992       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10993       print_strings (r);
10994       return -1;
10995     }
10996     {
10997       char expected[] = "Result10-1";
10998       if (strcmp (r[0], expected) != 0) {
10999         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11000         return -1;
11001       }
11002     }
11003     if (!r[1]) {
11004       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11005       print_strings (r);
11006       return -1;
11007     }
11008     {
11009       char expected[] = "Result10-2";
11010       if (strcmp (r[1], expected) != 0) {
11011         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11012         return -1;
11013       }
11014     }
11015     if (r[2] != NULL) {
11016       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11017       print_strings (r);
11018       return -1;
11019     }
11020     for (i = 0; r[i] != NULL; ++i)
11021       free (r[i]);
11022     free (r);
11023   }
11024   return 0;
11025 }
11026
11027 static int test_command_lines_10_skip (void)
11028 {
11029   const char *str;
11030
11031   str = getenv ("TEST_ONLY");
11032   if (str)
11033     return strstr (str, "command_lines") == NULL;
11034   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11035   if (str && strcmp (str, "1") == 0) return 1;
11036   str = getenv ("SKIP_TEST_COMMAND_LINES");
11037   if (str && strcmp (str, "1") == 0) return 1;
11038   return 0;
11039 }
11040
11041 static int test_command_lines_10 (void)
11042 {
11043   if (test_command_lines_10_skip ()) {
11044     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
11045     return 0;
11046   }
11047
11048   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11049   {
11050     char device[] = "/dev/sda";
11051     int r;
11052     suppress_error = 0;
11053     r = guestfs_blockdev_setrw (g, device);
11054     if (r == -1)
11055       return -1;
11056   }
11057   {
11058     int r;
11059     suppress_error = 0;
11060     r = guestfs_umount_all (g);
11061     if (r == -1)
11062       return -1;
11063   }
11064   {
11065     int r;
11066     suppress_error = 0;
11067     r = guestfs_lvm_remove_all (g);
11068     if (r == -1)
11069       return -1;
11070   }
11071   {
11072     char device[] = "/dev/sda";
11073     char lines_0[] = ",";
11074     char *lines[] = {
11075       lines_0,
11076       NULL
11077     };
11078     int r;
11079     suppress_error = 0;
11080     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11081     if (r == -1)
11082       return -1;
11083   }
11084   {
11085     char fstype[] = "ext2";
11086     char device[] = "/dev/sda1";
11087     int r;
11088     suppress_error = 0;
11089     r = guestfs_mkfs (g, fstype, device);
11090     if (r == -1)
11091       return -1;
11092   }
11093   {
11094     char device[] = "/dev/sda1";
11095     char mountpoint[] = "/";
11096     int r;
11097     suppress_error = 0;
11098     r = guestfs_mount (g, device, mountpoint);
11099     if (r == -1)
11100       return -1;
11101   }
11102   /* TestOutputList for command_lines (10) */
11103   {
11104     char remotefilename[] = "/test-command";
11105     int r;
11106     suppress_error = 0;
11107     r = guestfs_upload (g, "test-command", remotefilename);
11108     if (r == -1)
11109       return -1;
11110   }
11111   {
11112     char path[] = "/test-command";
11113     int r;
11114     suppress_error = 0;
11115     r = guestfs_chmod (g, 493, path);
11116     if (r == -1)
11117       return -1;
11118   }
11119   {
11120     char arguments_0[] = "/test-command";
11121     char arguments_1[] = "11";
11122     char *arguments[] = {
11123       arguments_0,
11124       arguments_1,
11125       NULL
11126     };
11127     char **r;
11128     int i;
11129     suppress_error = 0;
11130     r = guestfs_command_lines (g, arguments);
11131     if (r == NULL)
11132       return -1;
11133     if (!r[0]) {
11134       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11135       print_strings (r);
11136       return -1;
11137     }
11138     {
11139       char expected[] = "Result11-1";
11140       if (strcmp (r[0], expected) != 0) {
11141         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11142         return -1;
11143       }
11144     }
11145     if (!r[1]) {
11146       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11147       print_strings (r);
11148       return -1;
11149     }
11150     {
11151       char expected[] = "Result11-2";
11152       if (strcmp (r[1], expected) != 0) {
11153         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11154         return -1;
11155       }
11156     }
11157     if (r[2] != NULL) {
11158       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11159       print_strings (r);
11160       return -1;
11161     }
11162     for (i = 0; r[i] != NULL; ++i)
11163       free (r[i]);
11164     free (r);
11165   }
11166   return 0;
11167 }
11168
11169 static int test_command_0_skip (void)
11170 {
11171   const char *str;
11172
11173   str = getenv ("TEST_ONLY");
11174   if (str)
11175     return strstr (str, "command") == NULL;
11176   str = getenv ("SKIP_TEST_COMMAND_0");
11177   if (str && strcmp (str, "1") == 0) return 1;
11178   str = getenv ("SKIP_TEST_COMMAND");
11179   if (str && strcmp (str, "1") == 0) return 1;
11180   return 0;
11181 }
11182
11183 static int test_command_0 (void)
11184 {
11185   if (test_command_0_skip ()) {
11186     printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11187     return 0;
11188   }
11189
11190   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11191   {
11192     char device[] = "/dev/sda";
11193     int r;
11194     suppress_error = 0;
11195     r = guestfs_blockdev_setrw (g, device);
11196     if (r == -1)
11197       return -1;
11198   }
11199   {
11200     int r;
11201     suppress_error = 0;
11202     r = guestfs_umount_all (g);
11203     if (r == -1)
11204       return -1;
11205   }
11206   {
11207     int r;
11208     suppress_error = 0;
11209     r = guestfs_lvm_remove_all (g);
11210     if (r == -1)
11211       return -1;
11212   }
11213   {
11214     char device[] = "/dev/sda";
11215     char lines_0[] = ",";
11216     char *lines[] = {
11217       lines_0,
11218       NULL
11219     };
11220     int r;
11221     suppress_error = 0;
11222     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11223     if (r == -1)
11224       return -1;
11225   }
11226   {
11227     char fstype[] = "ext2";
11228     char device[] = "/dev/sda1";
11229     int r;
11230     suppress_error = 0;
11231     r = guestfs_mkfs (g, fstype, device);
11232     if (r == -1)
11233       return -1;
11234   }
11235   {
11236     char device[] = "/dev/sda1";
11237     char mountpoint[] = "/";
11238     int r;
11239     suppress_error = 0;
11240     r = guestfs_mount (g, device, mountpoint);
11241     if (r == -1)
11242       return -1;
11243   }
11244   /* TestOutput for command (0) */
11245   char expected[] = "Result1";
11246   {
11247     char remotefilename[] = "/test-command";
11248     int r;
11249     suppress_error = 0;
11250     r = guestfs_upload (g, "test-command", remotefilename);
11251     if (r == -1)
11252       return -1;
11253   }
11254   {
11255     char path[] = "/test-command";
11256     int r;
11257     suppress_error = 0;
11258     r = guestfs_chmod (g, 493, path);
11259     if (r == -1)
11260       return -1;
11261   }
11262   {
11263     char arguments_0[] = "/test-command";
11264     char arguments_1[] = "1";
11265     char *arguments[] = {
11266       arguments_0,
11267       arguments_1,
11268       NULL
11269     };
11270     char *r;
11271     suppress_error = 0;
11272     r = guestfs_command (g, arguments);
11273     if (r == NULL)
11274       return -1;
11275     if (strcmp (r, expected) != 0) {
11276       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11277       return -1;
11278     }
11279     free (r);
11280   }
11281   return 0;
11282 }
11283
11284 static int test_command_1_skip (void)
11285 {
11286   const char *str;
11287
11288   str = getenv ("TEST_ONLY");
11289   if (str)
11290     return strstr (str, "command") == NULL;
11291   str = getenv ("SKIP_TEST_COMMAND_1");
11292   if (str && strcmp (str, "1") == 0) return 1;
11293   str = getenv ("SKIP_TEST_COMMAND");
11294   if (str && strcmp (str, "1") == 0) return 1;
11295   return 0;
11296 }
11297
11298 static int test_command_1 (void)
11299 {
11300   if (test_command_1_skip ()) {
11301     printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11302     return 0;
11303   }
11304
11305   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11306   {
11307     char device[] = "/dev/sda";
11308     int r;
11309     suppress_error = 0;
11310     r = guestfs_blockdev_setrw (g, device);
11311     if (r == -1)
11312       return -1;
11313   }
11314   {
11315     int r;
11316     suppress_error = 0;
11317     r = guestfs_umount_all (g);
11318     if (r == -1)
11319       return -1;
11320   }
11321   {
11322     int r;
11323     suppress_error = 0;
11324     r = guestfs_lvm_remove_all (g);
11325     if (r == -1)
11326       return -1;
11327   }
11328   {
11329     char device[] = "/dev/sda";
11330     char lines_0[] = ",";
11331     char *lines[] = {
11332       lines_0,
11333       NULL
11334     };
11335     int r;
11336     suppress_error = 0;
11337     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11338     if (r == -1)
11339       return -1;
11340   }
11341   {
11342     char fstype[] = "ext2";
11343     char device[] = "/dev/sda1";
11344     int r;
11345     suppress_error = 0;
11346     r = guestfs_mkfs (g, fstype, device);
11347     if (r == -1)
11348       return -1;
11349   }
11350   {
11351     char device[] = "/dev/sda1";
11352     char mountpoint[] = "/";
11353     int r;
11354     suppress_error = 0;
11355     r = guestfs_mount (g, device, mountpoint);
11356     if (r == -1)
11357       return -1;
11358   }
11359   /* TestOutput for command (1) */
11360   char expected[] = "Result2\n";
11361   {
11362     char remotefilename[] = "/test-command";
11363     int r;
11364     suppress_error = 0;
11365     r = guestfs_upload (g, "test-command", remotefilename);
11366     if (r == -1)
11367       return -1;
11368   }
11369   {
11370     char path[] = "/test-command";
11371     int r;
11372     suppress_error = 0;
11373     r = guestfs_chmod (g, 493, path);
11374     if (r == -1)
11375       return -1;
11376   }
11377   {
11378     char arguments_0[] = "/test-command";
11379     char arguments_1[] = "2";
11380     char *arguments[] = {
11381       arguments_0,
11382       arguments_1,
11383       NULL
11384     };
11385     char *r;
11386     suppress_error = 0;
11387     r = guestfs_command (g, arguments);
11388     if (r == NULL)
11389       return -1;
11390     if (strcmp (r, expected) != 0) {
11391       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11392       return -1;
11393     }
11394     free (r);
11395   }
11396   return 0;
11397 }
11398
11399 static int test_command_2_skip (void)
11400 {
11401   const char *str;
11402
11403   str = getenv ("TEST_ONLY");
11404   if (str)
11405     return strstr (str, "command") == NULL;
11406   str = getenv ("SKIP_TEST_COMMAND_2");
11407   if (str && strcmp (str, "1") == 0) return 1;
11408   str = getenv ("SKIP_TEST_COMMAND");
11409   if (str && strcmp (str, "1") == 0) return 1;
11410   return 0;
11411 }
11412
11413 static int test_command_2 (void)
11414 {
11415   if (test_command_2_skip ()) {
11416     printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11417     return 0;
11418   }
11419
11420   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11421   {
11422     char device[] = "/dev/sda";
11423     int r;
11424     suppress_error = 0;
11425     r = guestfs_blockdev_setrw (g, device);
11426     if (r == -1)
11427       return -1;
11428   }
11429   {
11430     int r;
11431     suppress_error = 0;
11432     r = guestfs_umount_all (g);
11433     if (r == -1)
11434       return -1;
11435   }
11436   {
11437     int r;
11438     suppress_error = 0;
11439     r = guestfs_lvm_remove_all (g);
11440     if (r == -1)
11441       return -1;
11442   }
11443   {
11444     char device[] = "/dev/sda";
11445     char lines_0[] = ",";
11446     char *lines[] = {
11447       lines_0,
11448       NULL
11449     };
11450     int r;
11451     suppress_error = 0;
11452     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11453     if (r == -1)
11454       return -1;
11455   }
11456   {
11457     char fstype[] = "ext2";
11458     char device[] = "/dev/sda1";
11459     int r;
11460     suppress_error = 0;
11461     r = guestfs_mkfs (g, fstype, device);
11462     if (r == -1)
11463       return -1;
11464   }
11465   {
11466     char device[] = "/dev/sda1";
11467     char mountpoint[] = "/";
11468     int r;
11469     suppress_error = 0;
11470     r = guestfs_mount (g, device, mountpoint);
11471     if (r == -1)
11472       return -1;
11473   }
11474   /* TestOutput for command (2) */
11475   char expected[] = "\nResult3";
11476   {
11477     char remotefilename[] = "/test-command";
11478     int r;
11479     suppress_error = 0;
11480     r = guestfs_upload (g, "test-command", remotefilename);
11481     if (r == -1)
11482       return -1;
11483   }
11484   {
11485     char path[] = "/test-command";
11486     int r;
11487     suppress_error = 0;
11488     r = guestfs_chmod (g, 493, path);
11489     if (r == -1)
11490       return -1;
11491   }
11492   {
11493     char arguments_0[] = "/test-command";
11494     char arguments_1[] = "3";
11495     char *arguments[] = {
11496       arguments_0,
11497       arguments_1,
11498       NULL
11499     };
11500     char *r;
11501     suppress_error = 0;
11502     r = guestfs_command (g, arguments);
11503     if (r == NULL)
11504       return -1;
11505     if (strcmp (r, expected) != 0) {
11506       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11507       return -1;
11508     }
11509     free (r);
11510   }
11511   return 0;
11512 }
11513
11514 static int test_command_3_skip (void)
11515 {
11516   const char *str;
11517
11518   str = getenv ("TEST_ONLY");
11519   if (str)
11520     return strstr (str, "command") == NULL;
11521   str = getenv ("SKIP_TEST_COMMAND_3");
11522   if (str && strcmp (str, "1") == 0) return 1;
11523   str = getenv ("SKIP_TEST_COMMAND");
11524   if (str && strcmp (str, "1") == 0) return 1;
11525   return 0;
11526 }
11527
11528 static int test_command_3 (void)
11529 {
11530   if (test_command_3_skip ()) {
11531     printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11532     return 0;
11533   }
11534
11535   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11536   {
11537     char device[] = "/dev/sda";
11538     int r;
11539     suppress_error = 0;
11540     r = guestfs_blockdev_setrw (g, device);
11541     if (r == -1)
11542       return -1;
11543   }
11544   {
11545     int r;
11546     suppress_error = 0;
11547     r = guestfs_umount_all (g);
11548     if (r == -1)
11549       return -1;
11550   }
11551   {
11552     int r;
11553     suppress_error = 0;
11554     r = guestfs_lvm_remove_all (g);
11555     if (r == -1)
11556       return -1;
11557   }
11558   {
11559     char device[] = "/dev/sda";
11560     char lines_0[] = ",";
11561     char *lines[] = {
11562       lines_0,
11563       NULL
11564     };
11565     int r;
11566     suppress_error = 0;
11567     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11568     if (r == -1)
11569       return -1;
11570   }
11571   {
11572     char fstype[] = "ext2";
11573     char device[] = "/dev/sda1";
11574     int r;
11575     suppress_error = 0;
11576     r = guestfs_mkfs (g, fstype, device);
11577     if (r == -1)
11578       return -1;
11579   }
11580   {
11581     char device[] = "/dev/sda1";
11582     char mountpoint[] = "/";
11583     int r;
11584     suppress_error = 0;
11585     r = guestfs_mount (g, device, mountpoint);
11586     if (r == -1)
11587       return -1;
11588   }
11589   /* TestOutput for command (3) */
11590   char expected[] = "\nResult4\n";
11591   {
11592     char remotefilename[] = "/test-command";
11593     int r;
11594     suppress_error = 0;
11595     r = guestfs_upload (g, "test-command", remotefilename);
11596     if (r == -1)
11597       return -1;
11598   }
11599   {
11600     char path[] = "/test-command";
11601     int r;
11602     suppress_error = 0;
11603     r = guestfs_chmod (g, 493, path);
11604     if (r == -1)
11605       return -1;
11606   }
11607   {
11608     char arguments_0[] = "/test-command";
11609     char arguments_1[] = "4";
11610     char *arguments[] = {
11611       arguments_0,
11612       arguments_1,
11613       NULL
11614     };
11615     char *r;
11616     suppress_error = 0;
11617     r = guestfs_command (g, arguments);
11618     if (r == NULL)
11619       return -1;
11620     if (strcmp (r, expected) != 0) {
11621       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11622       return -1;
11623     }
11624     free (r);
11625   }
11626   return 0;
11627 }
11628
11629 static int test_command_4_skip (void)
11630 {
11631   const char *str;
11632
11633   str = getenv ("TEST_ONLY");
11634   if (str)
11635     return strstr (str, "command") == NULL;
11636   str = getenv ("SKIP_TEST_COMMAND_4");
11637   if (str && strcmp (str, "1") == 0) return 1;
11638   str = getenv ("SKIP_TEST_COMMAND");
11639   if (str && strcmp (str, "1") == 0) return 1;
11640   return 0;
11641 }
11642
11643 static int test_command_4 (void)
11644 {
11645   if (test_command_4_skip ()) {
11646     printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11647     return 0;
11648   }
11649
11650   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11651   {
11652     char device[] = "/dev/sda";
11653     int r;
11654     suppress_error = 0;
11655     r = guestfs_blockdev_setrw (g, device);
11656     if (r == -1)
11657       return -1;
11658   }
11659   {
11660     int r;
11661     suppress_error = 0;
11662     r = guestfs_umount_all (g);
11663     if (r == -1)
11664       return -1;
11665   }
11666   {
11667     int r;
11668     suppress_error = 0;
11669     r = guestfs_lvm_remove_all (g);
11670     if (r == -1)
11671       return -1;
11672   }
11673   {
11674     char device[] = "/dev/sda";
11675     char lines_0[] = ",";
11676     char *lines[] = {
11677       lines_0,
11678       NULL
11679     };
11680     int r;
11681     suppress_error = 0;
11682     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11683     if (r == -1)
11684       return -1;
11685   }
11686   {
11687     char fstype[] = "ext2";
11688     char device[] = "/dev/sda1";
11689     int r;
11690     suppress_error = 0;
11691     r = guestfs_mkfs (g, fstype, device);
11692     if (r == -1)
11693       return -1;
11694   }
11695   {
11696     char device[] = "/dev/sda1";
11697     char mountpoint[] = "/";
11698     int r;
11699     suppress_error = 0;
11700     r = guestfs_mount (g, device, mountpoint);
11701     if (r == -1)
11702       return -1;
11703   }
11704   /* TestOutput for command (4) */
11705   char expected[] = "\nResult5\n\n";
11706   {
11707     char remotefilename[] = "/test-command";
11708     int r;
11709     suppress_error = 0;
11710     r = guestfs_upload (g, "test-command", remotefilename);
11711     if (r == -1)
11712       return -1;
11713   }
11714   {
11715     char path[] = "/test-command";
11716     int r;
11717     suppress_error = 0;
11718     r = guestfs_chmod (g, 493, path);
11719     if (r == -1)
11720       return -1;
11721   }
11722   {
11723     char arguments_0[] = "/test-command";
11724     char arguments_1[] = "5";
11725     char *arguments[] = {
11726       arguments_0,
11727       arguments_1,
11728       NULL
11729     };
11730     char *r;
11731     suppress_error = 0;
11732     r = guestfs_command (g, arguments);
11733     if (r == NULL)
11734       return -1;
11735     if (strcmp (r, expected) != 0) {
11736       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11737       return -1;
11738     }
11739     free (r);
11740   }
11741   return 0;
11742 }
11743
11744 static int test_command_5_skip (void)
11745 {
11746   const char *str;
11747
11748   str = getenv ("TEST_ONLY");
11749   if (str)
11750     return strstr (str, "command") == NULL;
11751   str = getenv ("SKIP_TEST_COMMAND_5");
11752   if (str && strcmp (str, "1") == 0) return 1;
11753   str = getenv ("SKIP_TEST_COMMAND");
11754   if (str && strcmp (str, "1") == 0) return 1;
11755   return 0;
11756 }
11757
11758 static int test_command_5 (void)
11759 {
11760   if (test_command_5_skip ()) {
11761     printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11762     return 0;
11763   }
11764
11765   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11766   {
11767     char device[] = "/dev/sda";
11768     int r;
11769     suppress_error = 0;
11770     r = guestfs_blockdev_setrw (g, device);
11771     if (r == -1)
11772       return -1;
11773   }
11774   {
11775     int r;
11776     suppress_error = 0;
11777     r = guestfs_umount_all (g);
11778     if (r == -1)
11779       return -1;
11780   }
11781   {
11782     int r;
11783     suppress_error = 0;
11784     r = guestfs_lvm_remove_all (g);
11785     if (r == -1)
11786       return -1;
11787   }
11788   {
11789     char device[] = "/dev/sda";
11790     char lines_0[] = ",";
11791     char *lines[] = {
11792       lines_0,
11793       NULL
11794     };
11795     int r;
11796     suppress_error = 0;
11797     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11798     if (r == -1)
11799       return -1;
11800   }
11801   {
11802     char fstype[] = "ext2";
11803     char device[] = "/dev/sda1";
11804     int r;
11805     suppress_error = 0;
11806     r = guestfs_mkfs (g, fstype, device);
11807     if (r == -1)
11808       return -1;
11809   }
11810   {
11811     char device[] = "/dev/sda1";
11812     char mountpoint[] = "/";
11813     int r;
11814     suppress_error = 0;
11815     r = guestfs_mount (g, device, mountpoint);
11816     if (r == -1)
11817       return -1;
11818   }
11819   /* TestOutput for command (5) */
11820   char expected[] = "\n\nResult6\n\n";
11821   {
11822     char remotefilename[] = "/test-command";
11823     int r;
11824     suppress_error = 0;
11825     r = guestfs_upload (g, "test-command", remotefilename);
11826     if (r == -1)
11827       return -1;
11828   }
11829   {
11830     char path[] = "/test-command";
11831     int r;
11832     suppress_error = 0;
11833     r = guestfs_chmod (g, 493, path);
11834     if (r == -1)
11835       return -1;
11836   }
11837   {
11838     char arguments_0[] = "/test-command";
11839     char arguments_1[] = "6";
11840     char *arguments[] = {
11841       arguments_0,
11842       arguments_1,
11843       NULL
11844     };
11845     char *r;
11846     suppress_error = 0;
11847     r = guestfs_command (g, arguments);
11848     if (r == NULL)
11849       return -1;
11850     if (strcmp (r, expected) != 0) {
11851       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
11852       return -1;
11853     }
11854     free (r);
11855   }
11856   return 0;
11857 }
11858
11859 static int test_command_6_skip (void)
11860 {
11861   const char *str;
11862
11863   str = getenv ("TEST_ONLY");
11864   if (str)
11865     return strstr (str, "command") == NULL;
11866   str = getenv ("SKIP_TEST_COMMAND_6");
11867   if (str && strcmp (str, "1") == 0) return 1;
11868   str = getenv ("SKIP_TEST_COMMAND");
11869   if (str && strcmp (str, "1") == 0) return 1;
11870   return 0;
11871 }
11872
11873 static int test_command_6 (void)
11874 {
11875   if (test_command_6_skip ()) {
11876     printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
11877     return 0;
11878   }
11879
11880   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
11881   {
11882     char device[] = "/dev/sda";
11883     int r;
11884     suppress_error = 0;
11885     r = guestfs_blockdev_setrw (g, device);
11886     if (r == -1)
11887       return -1;
11888   }
11889   {
11890     int r;
11891     suppress_error = 0;
11892     r = guestfs_umount_all (g);
11893     if (r == -1)
11894       return -1;
11895   }
11896   {
11897     int r;
11898     suppress_error = 0;
11899     r = guestfs_lvm_remove_all (g);
11900     if (r == -1)
11901       return -1;
11902   }
11903   {
11904     char device[] = "/dev/sda";
11905     char lines_0[] = ",";
11906     char *lines[] = {
11907       lines_0,
11908       NULL
11909     };
11910     int r;
11911     suppress_error = 0;
11912     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11913     if (r == -1)
11914       return -1;
11915   }
11916   {
11917     char fstype[] = "ext2";
11918     char device[] = "/dev/sda1";
11919     int r;
11920     suppress_error = 0;
11921     r = guestfs_mkfs (g, fstype, device);
11922     if (r == -1)
11923       return -1;
11924   }
11925   {
11926     char device[] = "/dev/sda1";
11927     char mountpoint[] = "/";
11928     int r;
11929     suppress_error = 0;
11930     r = guestfs_mount (g, device, mountpoint);
11931     if (r == -1)
11932       return -1;
11933   }
11934   /* TestOutput for command (6) */
11935   char expected[] = "";
11936   {
11937     char remotefilename[] = "/test-command";
11938     int r;
11939     suppress_error = 0;
11940     r = guestfs_upload (g, "test-command", remotefilename);
11941     if (r == -1)
11942       return -1;
11943   }
11944   {
11945     char path[] = "/test-command";
11946     int r;
11947     suppress_error = 0;
11948     r = guestfs_chmod (g, 493, path);
11949     if (r == -1)
11950       return -1;
11951   }
11952   {
11953     char arguments_0[] = "/test-command";
11954     char arguments_1[] = "7";
11955     char *arguments[] = {
11956       arguments_0,
11957       arguments_1,
11958       NULL
11959     };
11960     char *r;
11961     suppress_error = 0;
11962     r = guestfs_command (g, arguments);
11963     if (r == NULL)
11964       return -1;
11965     if (strcmp (r, expected) != 0) {
11966       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
11967       return -1;
11968     }
11969     free (r);
11970   }
11971   return 0;
11972 }
11973
11974 static int test_command_7_skip (void)
11975 {
11976   const char *str;
11977
11978   str = getenv ("TEST_ONLY");
11979   if (str)
11980     return strstr (str, "command") == NULL;
11981   str = getenv ("SKIP_TEST_COMMAND_7");
11982   if (str && strcmp (str, "1") == 0) return 1;
11983   str = getenv ("SKIP_TEST_COMMAND");
11984   if (str && strcmp (str, "1") == 0) return 1;
11985   return 0;
11986 }
11987
11988 static int test_command_7 (void)
11989 {
11990   if (test_command_7_skip ()) {
11991     printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
11992     return 0;
11993   }
11994
11995   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
11996   {
11997     char device[] = "/dev/sda";
11998     int r;
11999     suppress_error = 0;
12000     r = guestfs_blockdev_setrw (g, device);
12001     if (r == -1)
12002       return -1;
12003   }
12004   {
12005     int r;
12006     suppress_error = 0;
12007     r = guestfs_umount_all (g);
12008     if (r == -1)
12009       return -1;
12010   }
12011   {
12012     int r;
12013     suppress_error = 0;
12014     r = guestfs_lvm_remove_all (g);
12015     if (r == -1)
12016       return -1;
12017   }
12018   {
12019     char device[] = "/dev/sda";
12020     char lines_0[] = ",";
12021     char *lines[] = {
12022       lines_0,
12023       NULL
12024     };
12025     int r;
12026     suppress_error = 0;
12027     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12028     if (r == -1)
12029       return -1;
12030   }
12031   {
12032     char fstype[] = "ext2";
12033     char device[] = "/dev/sda1";
12034     int r;
12035     suppress_error = 0;
12036     r = guestfs_mkfs (g, fstype, device);
12037     if (r == -1)
12038       return -1;
12039   }
12040   {
12041     char device[] = "/dev/sda1";
12042     char mountpoint[] = "/";
12043     int r;
12044     suppress_error = 0;
12045     r = guestfs_mount (g, device, mountpoint);
12046     if (r == -1)
12047       return -1;
12048   }
12049   /* TestOutput for command (7) */
12050   char expected[] = "\n";
12051   {
12052     char remotefilename[] = "/test-command";
12053     int r;
12054     suppress_error = 0;
12055     r = guestfs_upload (g, "test-command", remotefilename);
12056     if (r == -1)
12057       return -1;
12058   }
12059   {
12060     char path[] = "/test-command";
12061     int r;
12062     suppress_error = 0;
12063     r = guestfs_chmod (g, 493, path);
12064     if (r == -1)
12065       return -1;
12066   }
12067   {
12068     char arguments_0[] = "/test-command";
12069     char arguments_1[] = "8";
12070     char *arguments[] = {
12071       arguments_0,
12072       arguments_1,
12073       NULL
12074     };
12075     char *r;
12076     suppress_error = 0;
12077     r = guestfs_command (g, arguments);
12078     if (r == NULL)
12079       return -1;
12080     if (strcmp (r, expected) != 0) {
12081       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12082       return -1;
12083     }
12084     free (r);
12085   }
12086   return 0;
12087 }
12088
12089 static int test_command_8_skip (void)
12090 {
12091   const char *str;
12092
12093   str = getenv ("TEST_ONLY");
12094   if (str)
12095     return strstr (str, "command") == NULL;
12096   str = getenv ("SKIP_TEST_COMMAND_8");
12097   if (str && strcmp (str, "1") == 0) return 1;
12098   str = getenv ("SKIP_TEST_COMMAND");
12099   if (str && strcmp (str, "1") == 0) return 1;
12100   return 0;
12101 }
12102
12103 static int test_command_8 (void)
12104 {
12105   if (test_command_8_skip ()) {
12106     printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
12107     return 0;
12108   }
12109
12110   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12111   {
12112     char device[] = "/dev/sda";
12113     int r;
12114     suppress_error = 0;
12115     r = guestfs_blockdev_setrw (g, device);
12116     if (r == -1)
12117       return -1;
12118   }
12119   {
12120     int r;
12121     suppress_error = 0;
12122     r = guestfs_umount_all (g);
12123     if (r == -1)
12124       return -1;
12125   }
12126   {
12127     int r;
12128     suppress_error = 0;
12129     r = guestfs_lvm_remove_all (g);
12130     if (r == -1)
12131       return -1;
12132   }
12133   {
12134     char device[] = "/dev/sda";
12135     char lines_0[] = ",";
12136     char *lines[] = {
12137       lines_0,
12138       NULL
12139     };
12140     int r;
12141     suppress_error = 0;
12142     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12143     if (r == -1)
12144       return -1;
12145   }
12146   {
12147     char fstype[] = "ext2";
12148     char device[] = "/dev/sda1";
12149     int r;
12150     suppress_error = 0;
12151     r = guestfs_mkfs (g, fstype, device);
12152     if (r == -1)
12153       return -1;
12154   }
12155   {
12156     char device[] = "/dev/sda1";
12157     char mountpoint[] = "/";
12158     int r;
12159     suppress_error = 0;
12160     r = guestfs_mount (g, device, mountpoint);
12161     if (r == -1)
12162       return -1;
12163   }
12164   /* TestOutput for command (8) */
12165   char expected[] = "\n\n";
12166   {
12167     char remotefilename[] = "/test-command";
12168     int r;
12169     suppress_error = 0;
12170     r = guestfs_upload (g, "test-command", remotefilename);
12171     if (r == -1)
12172       return -1;
12173   }
12174   {
12175     char path[] = "/test-command";
12176     int r;
12177     suppress_error = 0;
12178     r = guestfs_chmod (g, 493, path);
12179     if (r == -1)
12180       return -1;
12181   }
12182   {
12183     char arguments_0[] = "/test-command";
12184     char arguments_1[] = "9";
12185     char *arguments[] = {
12186       arguments_0,
12187       arguments_1,
12188       NULL
12189     };
12190     char *r;
12191     suppress_error = 0;
12192     r = guestfs_command (g, arguments);
12193     if (r == NULL)
12194       return -1;
12195     if (strcmp (r, expected) != 0) {
12196       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12197       return -1;
12198     }
12199     free (r);
12200   }
12201   return 0;
12202 }
12203
12204 static int test_command_9_skip (void)
12205 {
12206   const char *str;
12207
12208   str = getenv ("TEST_ONLY");
12209   if (str)
12210     return strstr (str, "command") == NULL;
12211   str = getenv ("SKIP_TEST_COMMAND_9");
12212   if (str && strcmp (str, "1") == 0) return 1;
12213   str = getenv ("SKIP_TEST_COMMAND");
12214   if (str && strcmp (str, "1") == 0) return 1;
12215   return 0;
12216 }
12217
12218 static int test_command_9 (void)
12219 {
12220   if (test_command_9_skip ()) {
12221     printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12222     return 0;
12223   }
12224
12225   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12226   {
12227     char device[] = "/dev/sda";
12228     int r;
12229     suppress_error = 0;
12230     r = guestfs_blockdev_setrw (g, device);
12231     if (r == -1)
12232       return -1;
12233   }
12234   {
12235     int r;
12236     suppress_error = 0;
12237     r = guestfs_umount_all (g);
12238     if (r == -1)
12239       return -1;
12240   }
12241   {
12242     int r;
12243     suppress_error = 0;
12244     r = guestfs_lvm_remove_all (g);
12245     if (r == -1)
12246       return -1;
12247   }
12248   {
12249     char device[] = "/dev/sda";
12250     char lines_0[] = ",";
12251     char *lines[] = {
12252       lines_0,
12253       NULL
12254     };
12255     int r;
12256     suppress_error = 0;
12257     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12258     if (r == -1)
12259       return -1;
12260   }
12261   {
12262     char fstype[] = "ext2";
12263     char device[] = "/dev/sda1";
12264     int r;
12265     suppress_error = 0;
12266     r = guestfs_mkfs (g, fstype, device);
12267     if (r == -1)
12268       return -1;
12269   }
12270   {
12271     char device[] = "/dev/sda1";
12272     char mountpoint[] = "/";
12273     int r;
12274     suppress_error = 0;
12275     r = guestfs_mount (g, device, mountpoint);
12276     if (r == -1)
12277       return -1;
12278   }
12279   /* TestOutput for command (9) */
12280   char expected[] = "Result10-1\nResult10-2\n";
12281   {
12282     char remotefilename[] = "/test-command";
12283     int r;
12284     suppress_error = 0;
12285     r = guestfs_upload (g, "test-command", remotefilename);
12286     if (r == -1)
12287       return -1;
12288   }
12289   {
12290     char path[] = "/test-command";
12291     int r;
12292     suppress_error = 0;
12293     r = guestfs_chmod (g, 493, path);
12294     if (r == -1)
12295       return -1;
12296   }
12297   {
12298     char arguments_0[] = "/test-command";
12299     char arguments_1[] = "10";
12300     char *arguments[] = {
12301       arguments_0,
12302       arguments_1,
12303       NULL
12304     };
12305     char *r;
12306     suppress_error = 0;
12307     r = guestfs_command (g, arguments);
12308     if (r == NULL)
12309       return -1;
12310     if (strcmp (r, expected) != 0) {
12311       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12312       return -1;
12313     }
12314     free (r);
12315   }
12316   return 0;
12317 }
12318
12319 static int test_command_10_skip (void)
12320 {
12321   const char *str;
12322
12323   str = getenv ("TEST_ONLY");
12324   if (str)
12325     return strstr (str, "command") == NULL;
12326   str = getenv ("SKIP_TEST_COMMAND_10");
12327   if (str && strcmp (str, "1") == 0) return 1;
12328   str = getenv ("SKIP_TEST_COMMAND");
12329   if (str && strcmp (str, "1") == 0) return 1;
12330   return 0;
12331 }
12332
12333 static int test_command_10 (void)
12334 {
12335   if (test_command_10_skip ()) {
12336     printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12337     return 0;
12338   }
12339
12340   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12341   {
12342     char device[] = "/dev/sda";
12343     int r;
12344     suppress_error = 0;
12345     r = guestfs_blockdev_setrw (g, device);
12346     if (r == -1)
12347       return -1;
12348   }
12349   {
12350     int r;
12351     suppress_error = 0;
12352     r = guestfs_umount_all (g);
12353     if (r == -1)
12354       return -1;
12355   }
12356   {
12357     int r;
12358     suppress_error = 0;
12359     r = guestfs_lvm_remove_all (g);
12360     if (r == -1)
12361       return -1;
12362   }
12363   {
12364     char device[] = "/dev/sda";
12365     char lines_0[] = ",";
12366     char *lines[] = {
12367       lines_0,
12368       NULL
12369     };
12370     int r;
12371     suppress_error = 0;
12372     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12373     if (r == -1)
12374       return -1;
12375   }
12376   {
12377     char fstype[] = "ext2";
12378     char device[] = "/dev/sda1";
12379     int r;
12380     suppress_error = 0;
12381     r = guestfs_mkfs (g, fstype, device);
12382     if (r == -1)
12383       return -1;
12384   }
12385   {
12386     char device[] = "/dev/sda1";
12387     char mountpoint[] = "/";
12388     int r;
12389     suppress_error = 0;
12390     r = guestfs_mount (g, device, mountpoint);
12391     if (r == -1)
12392       return -1;
12393   }
12394   /* TestOutput for command (10) */
12395   char expected[] = "Result11-1\nResult11-2";
12396   {
12397     char remotefilename[] = "/test-command";
12398     int r;
12399     suppress_error = 0;
12400     r = guestfs_upload (g, "test-command", remotefilename);
12401     if (r == -1)
12402       return -1;
12403   }
12404   {
12405     char path[] = "/test-command";
12406     int r;
12407     suppress_error = 0;
12408     r = guestfs_chmod (g, 493, path);
12409     if (r == -1)
12410       return -1;
12411   }
12412   {
12413     char arguments_0[] = "/test-command";
12414     char arguments_1[] = "11";
12415     char *arguments[] = {
12416       arguments_0,
12417       arguments_1,
12418       NULL
12419     };
12420     char *r;
12421     suppress_error = 0;
12422     r = guestfs_command (g, arguments);
12423     if (r == NULL)
12424       return -1;
12425     if (strcmp (r, expected) != 0) {
12426       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12427       return -1;
12428     }
12429     free (r);
12430   }
12431   return 0;
12432 }
12433
12434 static int test_command_11_skip (void)
12435 {
12436   const char *str;
12437
12438   str = getenv ("TEST_ONLY");
12439   if (str)
12440     return strstr (str, "command") == NULL;
12441   str = getenv ("SKIP_TEST_COMMAND_11");
12442   if (str && strcmp (str, "1") == 0) return 1;
12443   str = getenv ("SKIP_TEST_COMMAND");
12444   if (str && strcmp (str, "1") == 0) return 1;
12445   return 0;
12446 }
12447
12448 static int test_command_11 (void)
12449 {
12450   if (test_command_11_skip ()) {
12451     printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12452     return 0;
12453   }
12454
12455   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12456   {
12457     char device[] = "/dev/sda";
12458     int r;
12459     suppress_error = 0;
12460     r = guestfs_blockdev_setrw (g, device);
12461     if (r == -1)
12462       return -1;
12463   }
12464   {
12465     int r;
12466     suppress_error = 0;
12467     r = guestfs_umount_all (g);
12468     if (r == -1)
12469       return -1;
12470   }
12471   {
12472     int r;
12473     suppress_error = 0;
12474     r = guestfs_lvm_remove_all (g);
12475     if (r == -1)
12476       return -1;
12477   }
12478   {
12479     char device[] = "/dev/sda";
12480     char lines_0[] = ",";
12481     char *lines[] = {
12482       lines_0,
12483       NULL
12484     };
12485     int r;
12486     suppress_error = 0;
12487     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12488     if (r == -1)
12489       return -1;
12490   }
12491   {
12492     char fstype[] = "ext2";
12493     char device[] = "/dev/sda1";
12494     int r;
12495     suppress_error = 0;
12496     r = guestfs_mkfs (g, fstype, device);
12497     if (r == -1)
12498       return -1;
12499   }
12500   {
12501     char device[] = "/dev/sda1";
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   /* TestLastFail for command (11) */
12510   {
12511     char remotefilename[] = "/test-command";
12512     int r;
12513     suppress_error = 0;
12514     r = guestfs_upload (g, "test-command", remotefilename);
12515     if (r == -1)
12516       return -1;
12517   }
12518   {
12519     char path[] = "/test-command";
12520     int r;
12521     suppress_error = 0;
12522     r = guestfs_chmod (g, 493, path);
12523     if (r == -1)
12524       return -1;
12525   }
12526   {
12527     char arguments_0[] = "/test-command";
12528     char *arguments[] = {
12529       arguments_0,
12530       NULL
12531     };
12532     char *r;
12533     suppress_error = 1;
12534     r = guestfs_command (g, arguments);
12535     if (r != NULL)
12536       return -1;
12537     free (r);
12538   }
12539   return 0;
12540 }
12541
12542 static int test_file_0_skip (void)
12543 {
12544   const char *str;
12545
12546   str = getenv ("TEST_ONLY");
12547   if (str)
12548     return strstr (str, "file") == NULL;
12549   str = getenv ("SKIP_TEST_FILE_0");
12550   if (str && strcmp (str, "1") == 0) return 1;
12551   str = getenv ("SKIP_TEST_FILE");
12552   if (str && strcmp (str, "1") == 0) return 1;
12553   return 0;
12554 }
12555
12556 static int test_file_0 (void)
12557 {
12558   if (test_file_0_skip ()) {
12559     printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12560     return 0;
12561   }
12562
12563   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12564   {
12565     char device[] = "/dev/sda";
12566     int r;
12567     suppress_error = 0;
12568     r = guestfs_blockdev_setrw (g, device);
12569     if (r == -1)
12570       return -1;
12571   }
12572   {
12573     int r;
12574     suppress_error = 0;
12575     r = guestfs_umount_all (g);
12576     if (r == -1)
12577       return -1;
12578   }
12579   {
12580     int r;
12581     suppress_error = 0;
12582     r = guestfs_lvm_remove_all (g);
12583     if (r == -1)
12584       return -1;
12585   }
12586   {
12587     char device[] = "/dev/sda";
12588     char lines_0[] = ",";
12589     char *lines[] = {
12590       lines_0,
12591       NULL
12592     };
12593     int r;
12594     suppress_error = 0;
12595     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12596     if (r == -1)
12597       return -1;
12598   }
12599   {
12600     char fstype[] = "ext2";
12601     char device[] = "/dev/sda1";
12602     int r;
12603     suppress_error = 0;
12604     r = guestfs_mkfs (g, fstype, device);
12605     if (r == -1)
12606       return -1;
12607   }
12608   {
12609     char device[] = "/dev/sda1";
12610     char mountpoint[] = "/";
12611     int r;
12612     suppress_error = 0;
12613     r = guestfs_mount (g, device, mountpoint);
12614     if (r == -1)
12615       return -1;
12616   }
12617   /* TestOutput for file (0) */
12618   char expected[] = "empty";
12619   {
12620     char path[] = "/new";
12621     int r;
12622     suppress_error = 0;
12623     r = guestfs_touch (g, path);
12624     if (r == -1)
12625       return -1;
12626   }
12627   {
12628     char path[] = "/new";
12629     char *r;
12630     suppress_error = 0;
12631     r = guestfs_file (g, path);
12632     if (r == NULL)
12633       return -1;
12634     if (strcmp (r, expected) != 0) {
12635       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12636       return -1;
12637     }
12638     free (r);
12639   }
12640   return 0;
12641 }
12642
12643 static int test_file_1_skip (void)
12644 {
12645   const char *str;
12646
12647   str = getenv ("TEST_ONLY");
12648   if (str)
12649     return strstr (str, "file") == NULL;
12650   str = getenv ("SKIP_TEST_FILE_1");
12651   if (str && strcmp (str, "1") == 0) return 1;
12652   str = getenv ("SKIP_TEST_FILE");
12653   if (str && strcmp (str, "1") == 0) return 1;
12654   return 0;
12655 }
12656
12657 static int test_file_1 (void)
12658 {
12659   if (test_file_1_skip ()) {
12660     printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12661     return 0;
12662   }
12663
12664   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12665   {
12666     char device[] = "/dev/sda";
12667     int r;
12668     suppress_error = 0;
12669     r = guestfs_blockdev_setrw (g, device);
12670     if (r == -1)
12671       return -1;
12672   }
12673   {
12674     int r;
12675     suppress_error = 0;
12676     r = guestfs_umount_all (g);
12677     if (r == -1)
12678       return -1;
12679   }
12680   {
12681     int r;
12682     suppress_error = 0;
12683     r = guestfs_lvm_remove_all (g);
12684     if (r == -1)
12685       return -1;
12686   }
12687   {
12688     char device[] = "/dev/sda";
12689     char lines_0[] = ",";
12690     char *lines[] = {
12691       lines_0,
12692       NULL
12693     };
12694     int r;
12695     suppress_error = 0;
12696     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12697     if (r == -1)
12698       return -1;
12699   }
12700   {
12701     char fstype[] = "ext2";
12702     char device[] = "/dev/sda1";
12703     int r;
12704     suppress_error = 0;
12705     r = guestfs_mkfs (g, fstype, device);
12706     if (r == -1)
12707       return -1;
12708   }
12709   {
12710     char device[] = "/dev/sda1";
12711     char mountpoint[] = "/";
12712     int r;
12713     suppress_error = 0;
12714     r = guestfs_mount (g, device, mountpoint);
12715     if (r == -1)
12716       return -1;
12717   }
12718   /* TestOutput for file (1) */
12719   char expected[] = "ASCII text";
12720   {
12721     char path[] = "/new";
12722     char content[] = "some content\n";
12723     int r;
12724     suppress_error = 0;
12725     r = guestfs_write_file (g, path, content, 0);
12726     if (r == -1)
12727       return -1;
12728   }
12729   {
12730     char path[] = "/new";
12731     char *r;
12732     suppress_error = 0;
12733     r = guestfs_file (g, path);
12734     if (r == NULL)
12735       return -1;
12736     if (strcmp (r, expected) != 0) {
12737       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12738       return -1;
12739     }
12740     free (r);
12741   }
12742   return 0;
12743 }
12744
12745 static int test_file_2_skip (void)
12746 {
12747   const char *str;
12748
12749   str = getenv ("TEST_ONLY");
12750   if (str)
12751     return strstr (str, "file") == NULL;
12752   str = getenv ("SKIP_TEST_FILE_2");
12753   if (str && strcmp (str, "1") == 0) return 1;
12754   str = getenv ("SKIP_TEST_FILE");
12755   if (str && strcmp (str, "1") == 0) return 1;
12756   return 0;
12757 }
12758
12759 static int test_file_2 (void)
12760 {
12761   if (test_file_2_skip ()) {
12762     printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12763     return 0;
12764   }
12765
12766   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12767   {
12768     char device[] = "/dev/sda";
12769     int r;
12770     suppress_error = 0;
12771     r = guestfs_blockdev_setrw (g, device);
12772     if (r == -1)
12773       return -1;
12774   }
12775   {
12776     int r;
12777     suppress_error = 0;
12778     r = guestfs_umount_all (g);
12779     if (r == -1)
12780       return -1;
12781   }
12782   {
12783     int r;
12784     suppress_error = 0;
12785     r = guestfs_lvm_remove_all (g);
12786     if (r == -1)
12787       return -1;
12788   }
12789   {
12790     char device[] = "/dev/sda";
12791     char lines_0[] = ",";
12792     char *lines[] = {
12793       lines_0,
12794       NULL
12795     };
12796     int r;
12797     suppress_error = 0;
12798     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12799     if (r == -1)
12800       return -1;
12801   }
12802   {
12803     char fstype[] = "ext2";
12804     char device[] = "/dev/sda1";
12805     int r;
12806     suppress_error = 0;
12807     r = guestfs_mkfs (g, fstype, device);
12808     if (r == -1)
12809       return -1;
12810   }
12811   {
12812     char device[] = "/dev/sda1";
12813     char mountpoint[] = "/";
12814     int r;
12815     suppress_error = 0;
12816     r = guestfs_mount (g, device, mountpoint);
12817     if (r == -1)
12818       return -1;
12819   }
12820   /* TestLastFail for file (2) */
12821   {
12822     char path[] = "/nofile";
12823     char *r;
12824     suppress_error = 1;
12825     r = guestfs_file (g, path);
12826     if (r != NULL)
12827       return -1;
12828     free (r);
12829   }
12830   return 0;
12831 }
12832
12833 static int test_umount_all_0_skip (void)
12834 {
12835   const char *str;
12836
12837   str = getenv ("TEST_ONLY");
12838   if (str)
12839     return strstr (str, "umount_all") == NULL;
12840   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
12841   if (str && strcmp (str, "1") == 0) return 1;
12842   str = getenv ("SKIP_TEST_UMOUNT_ALL");
12843   if (str && strcmp (str, "1") == 0) return 1;
12844   return 0;
12845 }
12846
12847 static int test_umount_all_0 (void)
12848 {
12849   if (test_umount_all_0_skip ()) {
12850     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
12851     return 0;
12852   }
12853
12854   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
12855   {
12856     char device[] = "/dev/sda";
12857     int r;
12858     suppress_error = 0;
12859     r = guestfs_blockdev_setrw (g, device);
12860     if (r == -1)
12861       return -1;
12862   }
12863   {
12864     int r;
12865     suppress_error = 0;
12866     r = guestfs_umount_all (g);
12867     if (r == -1)
12868       return -1;
12869   }
12870   {
12871     int r;
12872     suppress_error = 0;
12873     r = guestfs_lvm_remove_all (g);
12874     if (r == -1)
12875       return -1;
12876   }
12877   {
12878     char device[] = "/dev/sda";
12879     char lines_0[] = ",";
12880     char *lines[] = {
12881       lines_0,
12882       NULL
12883     };
12884     int r;
12885     suppress_error = 0;
12886     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12887     if (r == -1)
12888       return -1;
12889   }
12890   {
12891     char fstype[] = "ext2";
12892     char device[] = "/dev/sda1";
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     char mountpoint[] = "/";
12902     int r;
12903     suppress_error = 0;
12904     r = guestfs_mount (g, device, mountpoint);
12905     if (r == -1)
12906       return -1;
12907   }
12908   /* TestOutputList for umount_all (0) */
12909   {
12910     int r;
12911     suppress_error = 0;
12912     r = guestfs_umount_all (g);
12913     if (r == -1)
12914       return -1;
12915   }
12916   {
12917     char **r;
12918     int i;
12919     suppress_error = 0;
12920     r = guestfs_mounts (g);
12921     if (r == NULL)
12922       return -1;
12923     if (r[0] != NULL) {
12924       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
12925       print_strings (r);
12926       return -1;
12927     }
12928     for (i = 0; r[i] != NULL; ++i)
12929       free (r[i]);
12930     free (r);
12931   }
12932   return 0;
12933 }
12934
12935 static int test_umount_all_1_skip (void)
12936 {
12937   const char *str;
12938
12939   str = getenv ("TEST_ONLY");
12940   if (str)
12941     return strstr (str, "umount_all") == NULL;
12942   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
12943   if (str && strcmp (str, "1") == 0) return 1;
12944   str = getenv ("SKIP_TEST_UMOUNT_ALL");
12945   if (str && strcmp (str, "1") == 0) return 1;
12946   return 0;
12947 }
12948
12949 static int test_umount_all_1 (void)
12950 {
12951   if (test_umount_all_1_skip ()) {
12952     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
12953     return 0;
12954   }
12955
12956   /* InitNone|InitEmpty for test_umount_all_1 */
12957   {
12958     char device[] = "/dev/sda";
12959     int r;
12960     suppress_error = 0;
12961     r = guestfs_blockdev_setrw (g, device);
12962     if (r == -1)
12963       return -1;
12964   }
12965   {
12966     int r;
12967     suppress_error = 0;
12968     r = guestfs_umount_all (g);
12969     if (r == -1)
12970       return -1;
12971   }
12972   {
12973     int r;
12974     suppress_error = 0;
12975     r = guestfs_lvm_remove_all (g);
12976     if (r == -1)
12977       return -1;
12978   }
12979   /* TestOutputList for umount_all (1) */
12980   {
12981     char device[] = "/dev/sda";
12982     char lines_0[] = ",10";
12983     char lines_1[] = ",20";
12984     char lines_2[] = ",";
12985     char *lines[] = {
12986       lines_0,
12987       lines_1,
12988       lines_2,
12989       NULL
12990     };
12991     int r;
12992     suppress_error = 0;
12993     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12994     if (r == -1)
12995       return -1;
12996   }
12997   {
12998     char fstype[] = "ext2";
12999     char device[] = "/dev/sda1";
13000     int r;
13001     suppress_error = 0;
13002     r = guestfs_mkfs (g, fstype, device);
13003     if (r == -1)
13004       return -1;
13005   }
13006   {
13007     char fstype[] = "ext2";
13008     char device[] = "/dev/sda2";
13009     int r;
13010     suppress_error = 0;
13011     r = guestfs_mkfs (g, fstype, device);
13012     if (r == -1)
13013       return -1;
13014   }
13015   {
13016     char fstype[] = "ext2";
13017     char device[] = "/dev/sda3";
13018     int r;
13019     suppress_error = 0;
13020     r = guestfs_mkfs (g, fstype, device);
13021     if (r == -1)
13022       return -1;
13023   }
13024   {
13025     char device[] = "/dev/sda1";
13026     char mountpoint[] = "/";
13027     int r;
13028     suppress_error = 0;
13029     r = guestfs_mount (g, device, mountpoint);
13030     if (r == -1)
13031       return -1;
13032   }
13033   {
13034     char path[] = "/mp1";
13035     int r;
13036     suppress_error = 0;
13037     r = guestfs_mkdir (g, path);
13038     if (r == -1)
13039       return -1;
13040   }
13041   {
13042     char device[] = "/dev/sda2";
13043     char mountpoint[] = "/mp1";
13044     int r;
13045     suppress_error = 0;
13046     r = guestfs_mount (g, device, mountpoint);
13047     if (r == -1)
13048       return -1;
13049   }
13050   {
13051     char path[] = "/mp1/mp2";
13052     int r;
13053     suppress_error = 0;
13054     r = guestfs_mkdir (g, path);
13055     if (r == -1)
13056       return -1;
13057   }
13058   {
13059     char device[] = "/dev/sda3";
13060     char mountpoint[] = "/mp1/mp2";
13061     int r;
13062     suppress_error = 0;
13063     r = guestfs_mount (g, device, mountpoint);
13064     if (r == -1)
13065       return -1;
13066   }
13067   {
13068     char path[] = "/mp1/mp2/mp3";
13069     int r;
13070     suppress_error = 0;
13071     r = guestfs_mkdir (g, path);
13072     if (r == -1)
13073       return -1;
13074   }
13075   {
13076     int r;
13077     suppress_error = 0;
13078     r = guestfs_umount_all (g);
13079     if (r == -1)
13080       return -1;
13081   }
13082   {
13083     char **r;
13084     int i;
13085     suppress_error = 0;
13086     r = guestfs_mounts (g);
13087     if (r == NULL)
13088       return -1;
13089     if (r[0] != NULL) {
13090       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13091       print_strings (r);
13092       return -1;
13093     }
13094     for (i = 0; r[i] != NULL; ++i)
13095       free (r[i]);
13096     free (r);
13097   }
13098   return 0;
13099 }
13100
13101 static int test_mounts_0_skip (void)
13102 {
13103   const char *str;
13104
13105   str = getenv ("TEST_ONLY");
13106   if (str)
13107     return strstr (str, "mounts") == NULL;
13108   str = getenv ("SKIP_TEST_MOUNTS_0");
13109   if (str && strcmp (str, "1") == 0) return 1;
13110   str = getenv ("SKIP_TEST_MOUNTS");
13111   if (str && strcmp (str, "1") == 0) return 1;
13112   return 0;
13113 }
13114
13115 static int test_mounts_0 (void)
13116 {
13117   if (test_mounts_0_skip ()) {
13118     printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
13119     return 0;
13120   }
13121
13122   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13123   {
13124     char device[] = "/dev/sda";
13125     int r;
13126     suppress_error = 0;
13127     r = guestfs_blockdev_setrw (g, device);
13128     if (r == -1)
13129       return -1;
13130   }
13131   {
13132     int r;
13133     suppress_error = 0;
13134     r = guestfs_umount_all (g);
13135     if (r == -1)
13136       return -1;
13137   }
13138   {
13139     int r;
13140     suppress_error = 0;
13141     r = guestfs_lvm_remove_all (g);
13142     if (r == -1)
13143       return -1;
13144   }
13145   {
13146     char device[] = "/dev/sda";
13147     char lines_0[] = ",";
13148     char *lines[] = {
13149       lines_0,
13150       NULL
13151     };
13152     int r;
13153     suppress_error = 0;
13154     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13155     if (r == -1)
13156       return -1;
13157   }
13158   {
13159     char fstype[] = "ext2";
13160     char device[] = "/dev/sda1";
13161     int r;
13162     suppress_error = 0;
13163     r = guestfs_mkfs (g, fstype, device);
13164     if (r == -1)
13165       return -1;
13166   }
13167   {
13168     char device[] = "/dev/sda1";
13169     char mountpoint[] = "/";
13170     int r;
13171     suppress_error = 0;
13172     r = guestfs_mount (g, device, mountpoint);
13173     if (r == -1)
13174       return -1;
13175   }
13176   /* TestOutputListOfDevices for mounts (0) */
13177   {
13178     char **r;
13179     int i;
13180     suppress_error = 0;
13181     r = guestfs_mounts (g);
13182     if (r == NULL)
13183       return -1;
13184     if (!r[0]) {
13185       fprintf (stderr, "test_mounts_0: short list returned from command\n");
13186       print_strings (r);
13187       return -1;
13188     }
13189     {
13190       char expected[] = "/dev/sda1";
13191       r[0][5] = 's';
13192       if (strcmp (r[0], expected) != 0) {
13193         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13194         return -1;
13195       }
13196     }
13197     if (r[1] != NULL) {
13198       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13199       print_strings (r);
13200       return -1;
13201     }
13202     for (i = 0; r[i] != NULL; ++i)
13203       free (r[i]);
13204     free (r);
13205   }
13206   return 0;
13207 }
13208
13209 static int test_umount_0_skip (void)
13210 {
13211   const char *str;
13212
13213   str = getenv ("TEST_ONLY");
13214   if (str)
13215     return strstr (str, "umount") == NULL;
13216   str = getenv ("SKIP_TEST_UMOUNT_0");
13217   if (str && strcmp (str, "1") == 0) return 1;
13218   str = getenv ("SKIP_TEST_UMOUNT");
13219   if (str && strcmp (str, "1") == 0) return 1;
13220   return 0;
13221 }
13222
13223 static int test_umount_0 (void)
13224 {
13225   if (test_umount_0_skip ()) {
13226     printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13227     return 0;
13228   }
13229
13230   /* InitNone|InitEmpty for test_umount_0 */
13231   {
13232     char device[] = "/dev/sda";
13233     int r;
13234     suppress_error = 0;
13235     r = guestfs_blockdev_setrw (g, device);
13236     if (r == -1)
13237       return -1;
13238   }
13239   {
13240     int r;
13241     suppress_error = 0;
13242     r = guestfs_umount_all (g);
13243     if (r == -1)
13244       return -1;
13245   }
13246   {
13247     int r;
13248     suppress_error = 0;
13249     r = guestfs_lvm_remove_all (g);
13250     if (r == -1)
13251       return -1;
13252   }
13253   /* TestOutputListOfDevices for umount (0) */
13254   {
13255     char device[] = "/dev/sda";
13256     char lines_0[] = ",";
13257     char *lines[] = {
13258       lines_0,
13259       NULL
13260     };
13261     int r;
13262     suppress_error = 0;
13263     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13264     if (r == -1)
13265       return -1;
13266   }
13267   {
13268     char fstype[] = "ext2";
13269     char device[] = "/dev/sda1";
13270     int r;
13271     suppress_error = 0;
13272     r = guestfs_mkfs (g, fstype, device);
13273     if (r == -1)
13274       return -1;
13275   }
13276   {
13277     char device[] = "/dev/sda1";
13278     char mountpoint[] = "/";
13279     int r;
13280     suppress_error = 0;
13281     r = guestfs_mount (g, device, mountpoint);
13282     if (r == -1)
13283       return -1;
13284   }
13285   {
13286     char **r;
13287     int i;
13288     suppress_error = 0;
13289     r = guestfs_mounts (g);
13290     if (r == NULL)
13291       return -1;
13292     if (!r[0]) {
13293       fprintf (stderr, "test_umount_0: short list returned from command\n");
13294       print_strings (r);
13295       return -1;
13296     }
13297     {
13298       char expected[] = "/dev/sda1";
13299       r[0][5] = 's';
13300       if (strcmp (r[0], expected) != 0) {
13301         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13302         return -1;
13303       }
13304     }
13305     if (r[1] != NULL) {
13306       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13307       print_strings (r);
13308       return -1;
13309     }
13310     for (i = 0; r[i] != NULL; ++i)
13311       free (r[i]);
13312     free (r);
13313   }
13314   return 0;
13315 }
13316
13317 static int test_umount_1_skip (void)
13318 {
13319   const char *str;
13320
13321   str = getenv ("TEST_ONLY");
13322   if (str)
13323     return strstr (str, "umount") == NULL;
13324   str = getenv ("SKIP_TEST_UMOUNT_1");
13325   if (str && strcmp (str, "1") == 0) return 1;
13326   str = getenv ("SKIP_TEST_UMOUNT");
13327   if (str && strcmp (str, "1") == 0) return 1;
13328   return 0;
13329 }
13330
13331 static int test_umount_1 (void)
13332 {
13333   if (test_umount_1_skip ()) {
13334     printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13335     return 0;
13336   }
13337
13338   /* InitNone|InitEmpty for test_umount_1 */
13339   {
13340     char device[] = "/dev/sda";
13341     int r;
13342     suppress_error = 0;
13343     r = guestfs_blockdev_setrw (g, device);
13344     if (r == -1)
13345       return -1;
13346   }
13347   {
13348     int r;
13349     suppress_error = 0;
13350     r = guestfs_umount_all (g);
13351     if (r == -1)
13352       return -1;
13353   }
13354   {
13355     int r;
13356     suppress_error = 0;
13357     r = guestfs_lvm_remove_all (g);
13358     if (r == -1)
13359       return -1;
13360   }
13361   /* TestOutputList for umount (1) */
13362   {
13363     char device[] = "/dev/sda";
13364     char lines_0[] = ",";
13365     char *lines[] = {
13366       lines_0,
13367       NULL
13368     };
13369     int r;
13370     suppress_error = 0;
13371     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13372     if (r == -1)
13373       return -1;
13374   }
13375   {
13376     char fstype[] = "ext2";
13377     char device[] = "/dev/sda1";
13378     int r;
13379     suppress_error = 0;
13380     r = guestfs_mkfs (g, fstype, device);
13381     if (r == -1)
13382       return -1;
13383   }
13384   {
13385     char device[] = "/dev/sda1";
13386     char mountpoint[] = "/";
13387     int r;
13388     suppress_error = 0;
13389     r = guestfs_mount (g, device, mountpoint);
13390     if (r == -1)
13391       return -1;
13392   }
13393   {
13394     char pathordevice[] = "/";
13395     int r;
13396     suppress_error = 0;
13397     r = guestfs_umount (g, pathordevice);
13398     if (r == -1)
13399       return -1;
13400   }
13401   {
13402     char **r;
13403     int i;
13404     suppress_error = 0;
13405     r = guestfs_mounts (g);
13406     if (r == NULL)
13407       return -1;
13408     if (r[0] != NULL) {
13409       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13410       print_strings (r);
13411       return -1;
13412     }
13413     for (i = 0; r[i] != NULL; ++i)
13414       free (r[i]);
13415     free (r);
13416   }
13417   return 0;
13418 }
13419
13420 static int test_write_file_0_skip (void)
13421 {
13422   const char *str;
13423
13424   str = getenv ("TEST_ONLY");
13425   if (str)
13426     return strstr (str, "write_file") == NULL;
13427   str = getenv ("SKIP_TEST_WRITE_FILE_0");
13428   if (str && strcmp (str, "1") == 0) return 1;
13429   str = getenv ("SKIP_TEST_WRITE_FILE");
13430   if (str && strcmp (str, "1") == 0) return 1;
13431   return 0;
13432 }
13433
13434 static int test_write_file_0 (void)
13435 {
13436   if (test_write_file_0_skip ()) {
13437     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13438     return 0;
13439   }
13440
13441   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13442   {
13443     char device[] = "/dev/sda";
13444     int r;
13445     suppress_error = 0;
13446     r = guestfs_blockdev_setrw (g, device);
13447     if (r == -1)
13448       return -1;
13449   }
13450   {
13451     int r;
13452     suppress_error = 0;
13453     r = guestfs_umount_all (g);
13454     if (r == -1)
13455       return -1;
13456   }
13457   {
13458     int r;
13459     suppress_error = 0;
13460     r = guestfs_lvm_remove_all (g);
13461     if (r == -1)
13462       return -1;
13463   }
13464   {
13465     char device[] = "/dev/sda";
13466     char lines_0[] = ",";
13467     char *lines[] = {
13468       lines_0,
13469       NULL
13470     };
13471     int r;
13472     suppress_error = 0;
13473     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13474     if (r == -1)
13475       return -1;
13476   }
13477   {
13478     char fstype[] = "ext2";
13479     char device[] = "/dev/sda1";
13480     int r;
13481     suppress_error = 0;
13482     r = guestfs_mkfs (g, fstype, device);
13483     if (r == -1)
13484       return -1;
13485   }
13486   {
13487     char device[] = "/dev/sda1";
13488     char mountpoint[] = "/";
13489     int r;
13490     suppress_error = 0;
13491     r = guestfs_mount (g, device, mountpoint);
13492     if (r == -1)
13493       return -1;
13494   }
13495   /* TestOutput for write_file (0) */
13496   char expected[] = "new file contents";
13497   {
13498     char path[] = "/new";
13499     char content[] = "new file contents";
13500     int r;
13501     suppress_error = 0;
13502     r = guestfs_write_file (g, path, content, 0);
13503     if (r == -1)
13504       return -1;
13505   }
13506   {
13507     char path[] = "/new";
13508     char *r;
13509     suppress_error = 0;
13510     r = guestfs_cat (g, path);
13511     if (r == NULL)
13512       return -1;
13513     if (strcmp (r, expected) != 0) {
13514       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13515       return -1;
13516     }
13517     free (r);
13518   }
13519   return 0;
13520 }
13521
13522 static int test_write_file_1_skip (void)
13523 {
13524   const char *str;
13525
13526   str = getenv ("TEST_ONLY");
13527   if (str)
13528     return strstr (str, "write_file") == NULL;
13529   str = getenv ("SKIP_TEST_WRITE_FILE_1");
13530   if (str && strcmp (str, "1") == 0) return 1;
13531   str = getenv ("SKIP_TEST_WRITE_FILE");
13532   if (str && strcmp (str, "1") == 0) return 1;
13533   return 0;
13534 }
13535
13536 static int test_write_file_1 (void)
13537 {
13538   if (test_write_file_1_skip ()) {
13539     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13540     return 0;
13541   }
13542
13543   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13544   {
13545     char device[] = "/dev/sda";
13546     int r;
13547     suppress_error = 0;
13548     r = guestfs_blockdev_setrw (g, device);
13549     if (r == -1)
13550       return -1;
13551   }
13552   {
13553     int r;
13554     suppress_error = 0;
13555     r = guestfs_umount_all (g);
13556     if (r == -1)
13557       return -1;
13558   }
13559   {
13560     int r;
13561     suppress_error = 0;
13562     r = guestfs_lvm_remove_all (g);
13563     if (r == -1)
13564       return -1;
13565   }
13566   {
13567     char device[] = "/dev/sda";
13568     char lines_0[] = ",";
13569     char *lines[] = {
13570       lines_0,
13571       NULL
13572     };
13573     int r;
13574     suppress_error = 0;
13575     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13576     if (r == -1)
13577       return -1;
13578   }
13579   {
13580     char fstype[] = "ext2";
13581     char device[] = "/dev/sda1";
13582     int r;
13583     suppress_error = 0;
13584     r = guestfs_mkfs (g, fstype, device);
13585     if (r == -1)
13586       return -1;
13587   }
13588   {
13589     char device[] = "/dev/sda1";
13590     char mountpoint[] = "/";
13591     int r;
13592     suppress_error = 0;
13593     r = guestfs_mount (g, device, mountpoint);
13594     if (r == -1)
13595       return -1;
13596   }
13597   /* TestOutput for write_file (1) */
13598   char expected[] = "\nnew file contents\n";
13599   {
13600     char path[] = "/new";
13601     char content[] = "\nnew file contents\n";
13602     int r;
13603     suppress_error = 0;
13604     r = guestfs_write_file (g, path, content, 0);
13605     if (r == -1)
13606       return -1;
13607   }
13608   {
13609     char path[] = "/new";
13610     char *r;
13611     suppress_error = 0;
13612     r = guestfs_cat (g, path);
13613     if (r == NULL)
13614       return -1;
13615     if (strcmp (r, expected) != 0) {
13616       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13617       return -1;
13618     }
13619     free (r);
13620   }
13621   return 0;
13622 }
13623
13624 static int test_write_file_2_skip (void)
13625 {
13626   const char *str;
13627
13628   str = getenv ("TEST_ONLY");
13629   if (str)
13630     return strstr (str, "write_file") == NULL;
13631   str = getenv ("SKIP_TEST_WRITE_FILE_2");
13632   if (str && strcmp (str, "1") == 0) return 1;
13633   str = getenv ("SKIP_TEST_WRITE_FILE");
13634   if (str && strcmp (str, "1") == 0) return 1;
13635   return 0;
13636 }
13637
13638 static int test_write_file_2 (void)
13639 {
13640   if (test_write_file_2_skip ()) {
13641     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13642     return 0;
13643   }
13644
13645   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13646   {
13647     char device[] = "/dev/sda";
13648     int r;
13649     suppress_error = 0;
13650     r = guestfs_blockdev_setrw (g, device);
13651     if (r == -1)
13652       return -1;
13653   }
13654   {
13655     int r;
13656     suppress_error = 0;
13657     r = guestfs_umount_all (g);
13658     if (r == -1)
13659       return -1;
13660   }
13661   {
13662     int r;
13663     suppress_error = 0;
13664     r = guestfs_lvm_remove_all (g);
13665     if (r == -1)
13666       return -1;
13667   }
13668   {
13669     char device[] = "/dev/sda";
13670     char lines_0[] = ",";
13671     char *lines[] = {
13672       lines_0,
13673       NULL
13674     };
13675     int r;
13676     suppress_error = 0;
13677     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13678     if (r == -1)
13679       return -1;
13680   }
13681   {
13682     char fstype[] = "ext2";
13683     char device[] = "/dev/sda1";
13684     int r;
13685     suppress_error = 0;
13686     r = guestfs_mkfs (g, fstype, device);
13687     if (r == -1)
13688       return -1;
13689   }
13690   {
13691     char device[] = "/dev/sda1";
13692     char mountpoint[] = "/";
13693     int r;
13694     suppress_error = 0;
13695     r = guestfs_mount (g, device, mountpoint);
13696     if (r == -1)
13697       return -1;
13698   }
13699   /* TestOutput for write_file (2) */
13700   char expected[] = "\n\n";
13701   {
13702     char path[] = "/new";
13703     char content[] = "\n\n";
13704     int r;
13705     suppress_error = 0;
13706     r = guestfs_write_file (g, path, content, 0);
13707     if (r == -1)
13708       return -1;
13709   }
13710   {
13711     char path[] = "/new";
13712     char *r;
13713     suppress_error = 0;
13714     r = guestfs_cat (g, path);
13715     if (r == NULL)
13716       return -1;
13717     if (strcmp (r, expected) != 0) {
13718       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13719       return -1;
13720     }
13721     free (r);
13722   }
13723   return 0;
13724 }
13725
13726 static int test_write_file_3_skip (void)
13727 {
13728   const char *str;
13729
13730   str = getenv ("TEST_ONLY");
13731   if (str)
13732     return strstr (str, "write_file") == NULL;
13733   str = getenv ("SKIP_TEST_WRITE_FILE_3");
13734   if (str && strcmp (str, "1") == 0) return 1;
13735   str = getenv ("SKIP_TEST_WRITE_FILE");
13736   if (str && strcmp (str, "1") == 0) return 1;
13737   return 0;
13738 }
13739
13740 static int test_write_file_3 (void)
13741 {
13742   if (test_write_file_3_skip ()) {
13743     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13744     return 0;
13745   }
13746
13747   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13748   {
13749     char device[] = "/dev/sda";
13750     int r;
13751     suppress_error = 0;
13752     r = guestfs_blockdev_setrw (g, device);
13753     if (r == -1)
13754       return -1;
13755   }
13756   {
13757     int r;
13758     suppress_error = 0;
13759     r = guestfs_umount_all (g);
13760     if (r == -1)
13761       return -1;
13762   }
13763   {
13764     int r;
13765     suppress_error = 0;
13766     r = guestfs_lvm_remove_all (g);
13767     if (r == -1)
13768       return -1;
13769   }
13770   {
13771     char device[] = "/dev/sda";
13772     char lines_0[] = ",";
13773     char *lines[] = {
13774       lines_0,
13775       NULL
13776     };
13777     int r;
13778     suppress_error = 0;
13779     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13780     if (r == -1)
13781       return -1;
13782   }
13783   {
13784     char fstype[] = "ext2";
13785     char device[] = "/dev/sda1";
13786     int r;
13787     suppress_error = 0;
13788     r = guestfs_mkfs (g, fstype, device);
13789     if (r == -1)
13790       return -1;
13791   }
13792   {
13793     char device[] = "/dev/sda1";
13794     char mountpoint[] = "/";
13795     int r;
13796     suppress_error = 0;
13797     r = guestfs_mount (g, device, mountpoint);
13798     if (r == -1)
13799       return -1;
13800   }
13801   /* TestOutput for write_file (3) */
13802   char expected[] = "";
13803   {
13804     char path[] = "/new";
13805     char content[] = "";
13806     int r;
13807     suppress_error = 0;
13808     r = guestfs_write_file (g, path, content, 0);
13809     if (r == -1)
13810       return -1;
13811   }
13812   {
13813     char path[] = "/new";
13814     char *r;
13815     suppress_error = 0;
13816     r = guestfs_cat (g, path);
13817     if (r == NULL)
13818       return -1;
13819     if (strcmp (r, expected) != 0) {
13820       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
13821       return -1;
13822     }
13823     free (r);
13824   }
13825   return 0;
13826 }
13827
13828 static int test_write_file_4_skip (void)
13829 {
13830   const char *str;
13831
13832   str = getenv ("TEST_ONLY");
13833   if (str)
13834     return strstr (str, "write_file") == NULL;
13835   str = getenv ("SKIP_TEST_WRITE_FILE_4");
13836   if (str && strcmp (str, "1") == 0) return 1;
13837   str = getenv ("SKIP_TEST_WRITE_FILE");
13838   if (str && strcmp (str, "1") == 0) return 1;
13839   return 0;
13840 }
13841
13842 static int test_write_file_4 (void)
13843 {
13844   if (test_write_file_4_skip ()) {
13845     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
13846     return 0;
13847   }
13848
13849   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
13850   {
13851     char device[] = "/dev/sda";
13852     int r;
13853     suppress_error = 0;
13854     r = guestfs_blockdev_setrw (g, device);
13855     if (r == -1)
13856       return -1;
13857   }
13858   {
13859     int r;
13860     suppress_error = 0;
13861     r = guestfs_umount_all (g);
13862     if (r == -1)
13863       return -1;
13864   }
13865   {
13866     int r;
13867     suppress_error = 0;
13868     r = guestfs_lvm_remove_all (g);
13869     if (r == -1)
13870       return -1;
13871   }
13872   {
13873     char device[] = "/dev/sda";
13874     char lines_0[] = ",";
13875     char *lines[] = {
13876       lines_0,
13877       NULL
13878     };
13879     int r;
13880     suppress_error = 0;
13881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13882     if (r == -1)
13883       return -1;
13884   }
13885   {
13886     char fstype[] = "ext2";
13887     char device[] = "/dev/sda1";
13888     int r;
13889     suppress_error = 0;
13890     r = guestfs_mkfs (g, fstype, device);
13891     if (r == -1)
13892       return -1;
13893   }
13894   {
13895     char device[] = "/dev/sda1";
13896     char mountpoint[] = "/";
13897     int r;
13898     suppress_error = 0;
13899     r = guestfs_mount (g, device, mountpoint);
13900     if (r == -1)
13901       return -1;
13902   }
13903   /* TestOutput for write_file (4) */
13904   char expected[] = "\n\n\n";
13905   {
13906     char path[] = "/new";
13907     char content[] = "\n\n\n";
13908     int r;
13909     suppress_error = 0;
13910     r = guestfs_write_file (g, path, content, 0);
13911     if (r == -1)
13912       return -1;
13913   }
13914   {
13915     char path[] = "/new";
13916     char *r;
13917     suppress_error = 0;
13918     r = guestfs_cat (g, path);
13919     if (r == NULL)
13920       return -1;
13921     if (strcmp (r, expected) != 0) {
13922       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
13923       return -1;
13924     }
13925     free (r);
13926   }
13927   return 0;
13928 }
13929
13930 static int test_write_file_5_skip (void)
13931 {
13932   const char *str;
13933
13934   str = getenv ("TEST_ONLY");
13935   if (str)
13936     return strstr (str, "write_file") == NULL;
13937   str = getenv ("SKIP_TEST_WRITE_FILE_5");
13938   if (str && strcmp (str, "1") == 0) return 1;
13939   str = getenv ("SKIP_TEST_WRITE_FILE");
13940   if (str && strcmp (str, "1") == 0) return 1;
13941   return 0;
13942 }
13943
13944 static int test_write_file_5 (void)
13945 {
13946   if (test_write_file_5_skip ()) {
13947     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
13948     return 0;
13949   }
13950
13951   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
13952   {
13953     char device[] = "/dev/sda";
13954     int r;
13955     suppress_error = 0;
13956     r = guestfs_blockdev_setrw (g, device);
13957     if (r == -1)
13958       return -1;
13959   }
13960   {
13961     int r;
13962     suppress_error = 0;
13963     r = guestfs_umount_all (g);
13964     if (r == -1)
13965       return -1;
13966   }
13967   {
13968     int r;
13969     suppress_error = 0;
13970     r = guestfs_lvm_remove_all (g);
13971     if (r == -1)
13972       return -1;
13973   }
13974   {
13975     char device[] = "/dev/sda";
13976     char lines_0[] = ",";
13977     char *lines[] = {
13978       lines_0,
13979       NULL
13980     };
13981     int r;
13982     suppress_error = 0;
13983     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13984     if (r == -1)
13985       return -1;
13986   }
13987   {
13988     char fstype[] = "ext2";
13989     char device[] = "/dev/sda1";
13990     int r;
13991     suppress_error = 0;
13992     r = guestfs_mkfs (g, fstype, device);
13993     if (r == -1)
13994       return -1;
13995   }
13996   {
13997     char device[] = "/dev/sda1";
13998     char mountpoint[] = "/";
13999     int r;
14000     suppress_error = 0;
14001     r = guestfs_mount (g, device, mountpoint);
14002     if (r == -1)
14003       return -1;
14004   }
14005   /* TestOutput for write_file (5) */
14006   char expected[] = "\n";
14007   {
14008     char path[] = "/new";
14009     char content[] = "\n";
14010     int r;
14011     suppress_error = 0;
14012     r = guestfs_write_file (g, path, content, 0);
14013     if (r == -1)
14014       return -1;
14015   }
14016   {
14017     char path[] = "/new";
14018     char *r;
14019     suppress_error = 0;
14020     r = guestfs_cat (g, path);
14021     if (r == NULL)
14022       return -1;
14023     if (strcmp (r, expected) != 0) {
14024       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14025       return -1;
14026     }
14027     free (r);
14028   }
14029   return 0;
14030 }
14031
14032 static int test_mkfs_0_skip (void)
14033 {
14034   const char *str;
14035
14036   str = getenv ("TEST_ONLY");
14037   if (str)
14038     return strstr (str, "mkfs") == NULL;
14039   str = getenv ("SKIP_TEST_MKFS_0");
14040   if (str && strcmp (str, "1") == 0) return 1;
14041   str = getenv ("SKIP_TEST_MKFS");
14042   if (str && strcmp (str, "1") == 0) return 1;
14043   return 0;
14044 }
14045
14046 static int test_mkfs_0 (void)
14047 {
14048   if (test_mkfs_0_skip ()) {
14049     printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
14050     return 0;
14051   }
14052
14053   /* InitNone|InitEmpty for test_mkfs_0 */
14054   {
14055     char device[] = "/dev/sda";
14056     int r;
14057     suppress_error = 0;
14058     r = guestfs_blockdev_setrw (g, device);
14059     if (r == -1)
14060       return -1;
14061   }
14062   {
14063     int r;
14064     suppress_error = 0;
14065     r = guestfs_umount_all (g);
14066     if (r == -1)
14067       return -1;
14068   }
14069   {
14070     int r;
14071     suppress_error = 0;
14072     r = guestfs_lvm_remove_all (g);
14073     if (r == -1)
14074       return -1;
14075   }
14076   /* TestOutput for mkfs (0) */
14077   char expected[] = "new file contents";
14078   {
14079     char device[] = "/dev/sda";
14080     char lines_0[] = ",";
14081     char *lines[] = {
14082       lines_0,
14083       NULL
14084     };
14085     int r;
14086     suppress_error = 0;
14087     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14088     if (r == -1)
14089       return -1;
14090   }
14091   {
14092     char fstype[] = "ext2";
14093     char device[] = "/dev/sda1";
14094     int r;
14095     suppress_error = 0;
14096     r = guestfs_mkfs (g, fstype, device);
14097     if (r == -1)
14098       return -1;
14099   }
14100   {
14101     char device[] = "/dev/sda1";
14102     char mountpoint[] = "/";
14103     int r;
14104     suppress_error = 0;
14105     r = guestfs_mount (g, device, mountpoint);
14106     if (r == -1)
14107       return -1;
14108   }
14109   {
14110     char path[] = "/new";
14111     char content[] = "new file contents";
14112     int r;
14113     suppress_error = 0;
14114     r = guestfs_write_file (g, path, content, 0);
14115     if (r == -1)
14116       return -1;
14117   }
14118   {
14119     char path[] = "/new";
14120     char *r;
14121     suppress_error = 0;
14122     r = guestfs_cat (g, path);
14123     if (r == NULL)
14124       return -1;
14125     if (strcmp (r, expected) != 0) {
14126       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14127       return -1;
14128     }
14129     free (r);
14130   }
14131   return 0;
14132 }
14133
14134 static int test_lvcreate_0_skip (void)
14135 {
14136   const char *str;
14137
14138   str = getenv ("TEST_ONLY");
14139   if (str)
14140     return strstr (str, "lvcreate") == NULL;
14141   str = getenv ("SKIP_TEST_LVCREATE_0");
14142   if (str && strcmp (str, "1") == 0) return 1;
14143   str = getenv ("SKIP_TEST_LVCREATE");
14144   if (str && strcmp (str, "1") == 0) return 1;
14145   return 0;
14146 }
14147
14148 static int test_lvcreate_0 (void)
14149 {
14150   if (test_lvcreate_0_skip ()) {
14151     printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14152     return 0;
14153   }
14154
14155   /* InitNone|InitEmpty for test_lvcreate_0 */
14156   {
14157     char device[] = "/dev/sda";
14158     int r;
14159     suppress_error = 0;
14160     r = guestfs_blockdev_setrw (g, device);
14161     if (r == -1)
14162       return -1;
14163   }
14164   {
14165     int r;
14166     suppress_error = 0;
14167     r = guestfs_umount_all (g);
14168     if (r == -1)
14169       return -1;
14170   }
14171   {
14172     int r;
14173     suppress_error = 0;
14174     r = guestfs_lvm_remove_all (g);
14175     if (r == -1)
14176       return -1;
14177   }
14178   /* TestOutputList for lvcreate (0) */
14179   {
14180     char device[] = "/dev/sda";
14181     char lines_0[] = ",10";
14182     char lines_1[] = ",20";
14183     char lines_2[] = ",";
14184     char *lines[] = {
14185       lines_0,
14186       lines_1,
14187       lines_2,
14188       NULL
14189     };
14190     int r;
14191     suppress_error = 0;
14192     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14193     if (r == -1)
14194       return -1;
14195   }
14196   {
14197     char device[] = "/dev/sda1";
14198     int r;
14199     suppress_error = 0;
14200     r = guestfs_pvcreate (g, device);
14201     if (r == -1)
14202       return -1;
14203   }
14204   {
14205     char device[] = "/dev/sda2";
14206     int r;
14207     suppress_error = 0;
14208     r = guestfs_pvcreate (g, device);
14209     if (r == -1)
14210       return -1;
14211   }
14212   {
14213     char device[] = "/dev/sda3";
14214     int r;
14215     suppress_error = 0;
14216     r = guestfs_pvcreate (g, device);
14217     if (r == -1)
14218       return -1;
14219   }
14220   {
14221     char volgroup[] = "VG1";
14222     char physvols_0[] = "/dev/sda1";
14223     char physvols_1[] = "/dev/sda2";
14224     char *physvols[] = {
14225       physvols_0,
14226       physvols_1,
14227       NULL
14228     };
14229     int r;
14230     suppress_error = 0;
14231     r = guestfs_vgcreate (g, volgroup, physvols);
14232     if (r == -1)
14233       return -1;
14234   }
14235   {
14236     char volgroup[] = "VG2";
14237     char physvols_0[] = "/dev/sda3";
14238     char *physvols[] = {
14239       physvols_0,
14240       NULL
14241     };
14242     int r;
14243     suppress_error = 0;
14244     r = guestfs_vgcreate (g, volgroup, physvols);
14245     if (r == -1)
14246       return -1;
14247   }
14248   {
14249     char logvol[] = "LV1";
14250     char volgroup[] = "VG1";
14251     int r;
14252     suppress_error = 0;
14253     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14254     if (r == -1)
14255       return -1;
14256   }
14257   {
14258     char logvol[] = "LV2";
14259     char volgroup[] = "VG1";
14260     int r;
14261     suppress_error = 0;
14262     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14263     if (r == -1)
14264       return -1;
14265   }
14266   {
14267     char logvol[] = "LV3";
14268     char volgroup[] = "VG2";
14269     int r;
14270     suppress_error = 0;
14271     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14272     if (r == -1)
14273       return -1;
14274   }
14275   {
14276     char logvol[] = "LV4";
14277     char volgroup[] = "VG2";
14278     int r;
14279     suppress_error = 0;
14280     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14281     if (r == -1)
14282       return -1;
14283   }
14284   {
14285     char logvol[] = "LV5";
14286     char volgroup[] = "VG2";
14287     int r;
14288     suppress_error = 0;
14289     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14290     if (r == -1)
14291       return -1;
14292   }
14293   {
14294     char **r;
14295     int i;
14296     suppress_error = 0;
14297     r = guestfs_lvs (g);
14298     if (r == NULL)
14299       return -1;
14300     if (!r[0]) {
14301       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14302       print_strings (r);
14303       return -1;
14304     }
14305     {
14306       char expected[] = "/dev/VG1/LV1";
14307       if (strcmp (r[0], expected) != 0) {
14308         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14309         return -1;
14310       }
14311     }
14312     if (!r[1]) {
14313       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14314       print_strings (r);
14315       return -1;
14316     }
14317     {
14318       char expected[] = "/dev/VG1/LV2";
14319       if (strcmp (r[1], expected) != 0) {
14320         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14321         return -1;
14322       }
14323     }
14324     if (!r[2]) {
14325       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14326       print_strings (r);
14327       return -1;
14328     }
14329     {
14330       char expected[] = "/dev/VG2/LV3";
14331       if (strcmp (r[2], expected) != 0) {
14332         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14333         return -1;
14334       }
14335     }
14336     if (!r[3]) {
14337       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14338       print_strings (r);
14339       return -1;
14340     }
14341     {
14342       char expected[] = "/dev/VG2/LV4";
14343       if (strcmp (r[3], expected) != 0) {
14344         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14345         return -1;
14346       }
14347     }
14348     if (!r[4]) {
14349       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14350       print_strings (r);
14351       return -1;
14352     }
14353     {
14354       char expected[] = "/dev/VG2/LV5";
14355       if (strcmp (r[4], expected) != 0) {
14356         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14357         return -1;
14358       }
14359     }
14360     if (r[5] != NULL) {
14361       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14362       print_strings (r);
14363       return -1;
14364     }
14365     for (i = 0; r[i] != NULL; ++i)
14366       free (r[i]);
14367     free (r);
14368   }
14369   return 0;
14370 }
14371
14372 static int test_vgcreate_0_skip (void)
14373 {
14374   const char *str;
14375
14376   str = getenv ("TEST_ONLY");
14377   if (str)
14378     return strstr (str, "vgcreate") == NULL;
14379   str = getenv ("SKIP_TEST_VGCREATE_0");
14380   if (str && strcmp (str, "1") == 0) return 1;
14381   str = getenv ("SKIP_TEST_VGCREATE");
14382   if (str && strcmp (str, "1") == 0) return 1;
14383   return 0;
14384 }
14385
14386 static int test_vgcreate_0 (void)
14387 {
14388   if (test_vgcreate_0_skip ()) {
14389     printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14390     return 0;
14391   }
14392
14393   /* InitNone|InitEmpty for test_vgcreate_0 */
14394   {
14395     char device[] = "/dev/sda";
14396     int r;
14397     suppress_error = 0;
14398     r = guestfs_blockdev_setrw (g, device);
14399     if (r == -1)
14400       return -1;
14401   }
14402   {
14403     int r;
14404     suppress_error = 0;
14405     r = guestfs_umount_all (g);
14406     if (r == -1)
14407       return -1;
14408   }
14409   {
14410     int r;
14411     suppress_error = 0;
14412     r = guestfs_lvm_remove_all (g);
14413     if (r == -1)
14414       return -1;
14415   }
14416   /* TestOutputList for vgcreate (0) */
14417   {
14418     char device[] = "/dev/sda";
14419     char lines_0[] = ",10";
14420     char lines_1[] = ",20";
14421     char lines_2[] = ",";
14422     char *lines[] = {
14423       lines_0,
14424       lines_1,
14425       lines_2,
14426       NULL
14427     };
14428     int r;
14429     suppress_error = 0;
14430     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14431     if (r == -1)
14432       return -1;
14433   }
14434   {
14435     char device[] = "/dev/sda1";
14436     int r;
14437     suppress_error = 0;
14438     r = guestfs_pvcreate (g, device);
14439     if (r == -1)
14440       return -1;
14441   }
14442   {
14443     char device[] = "/dev/sda2";
14444     int r;
14445     suppress_error = 0;
14446     r = guestfs_pvcreate (g, device);
14447     if (r == -1)
14448       return -1;
14449   }
14450   {
14451     char device[] = "/dev/sda3";
14452     int r;
14453     suppress_error = 0;
14454     r = guestfs_pvcreate (g, device);
14455     if (r == -1)
14456       return -1;
14457   }
14458   {
14459     char volgroup[] = "VG1";
14460     char physvols_0[] = "/dev/sda1";
14461     char physvols_1[] = "/dev/sda2";
14462     char *physvols[] = {
14463       physvols_0,
14464       physvols_1,
14465       NULL
14466     };
14467     int r;
14468     suppress_error = 0;
14469     r = guestfs_vgcreate (g, volgroup, physvols);
14470     if (r == -1)
14471       return -1;
14472   }
14473   {
14474     char volgroup[] = "VG2";
14475     char physvols_0[] = "/dev/sda3";
14476     char *physvols[] = {
14477       physvols_0,
14478       NULL
14479     };
14480     int r;
14481     suppress_error = 0;
14482     r = guestfs_vgcreate (g, volgroup, physvols);
14483     if (r == -1)
14484       return -1;
14485   }
14486   {
14487     char **r;
14488     int i;
14489     suppress_error = 0;
14490     r = guestfs_vgs (g);
14491     if (r == NULL)
14492       return -1;
14493     if (!r[0]) {
14494       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14495       print_strings (r);
14496       return -1;
14497     }
14498     {
14499       char expected[] = "VG1";
14500       if (strcmp (r[0], expected) != 0) {
14501         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14502         return -1;
14503       }
14504     }
14505     if (!r[1]) {
14506       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14507       print_strings (r);
14508       return -1;
14509     }
14510     {
14511       char expected[] = "VG2";
14512       if (strcmp (r[1], expected) != 0) {
14513         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14514         return -1;
14515       }
14516     }
14517     if (r[2] != NULL) {
14518       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14519       print_strings (r);
14520       return -1;
14521     }
14522     for (i = 0; r[i] != NULL; ++i)
14523       free (r[i]);
14524     free (r);
14525   }
14526   return 0;
14527 }
14528
14529 static int test_pvcreate_0_skip (void)
14530 {
14531   const char *str;
14532
14533   str = getenv ("TEST_ONLY");
14534   if (str)
14535     return strstr (str, "pvcreate") == NULL;
14536   str = getenv ("SKIP_TEST_PVCREATE_0");
14537   if (str && strcmp (str, "1") == 0) return 1;
14538   str = getenv ("SKIP_TEST_PVCREATE");
14539   if (str && strcmp (str, "1") == 0) return 1;
14540   return 0;
14541 }
14542
14543 static int test_pvcreate_0 (void)
14544 {
14545   if (test_pvcreate_0_skip ()) {
14546     printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14547     return 0;
14548   }
14549
14550   /* InitNone|InitEmpty for test_pvcreate_0 */
14551   {
14552     char device[] = "/dev/sda";
14553     int r;
14554     suppress_error = 0;
14555     r = guestfs_blockdev_setrw (g, device);
14556     if (r == -1)
14557       return -1;
14558   }
14559   {
14560     int r;
14561     suppress_error = 0;
14562     r = guestfs_umount_all (g);
14563     if (r == -1)
14564       return -1;
14565   }
14566   {
14567     int r;
14568     suppress_error = 0;
14569     r = guestfs_lvm_remove_all (g);
14570     if (r == -1)
14571       return -1;
14572   }
14573   /* TestOutputListOfDevices for pvcreate (0) */
14574   {
14575     char device[] = "/dev/sda";
14576     char lines_0[] = ",10";
14577     char lines_1[] = ",20";
14578     char lines_2[] = ",";
14579     char *lines[] = {
14580       lines_0,
14581       lines_1,
14582       lines_2,
14583       NULL
14584     };
14585     int r;
14586     suppress_error = 0;
14587     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14588     if (r == -1)
14589       return -1;
14590   }
14591   {
14592     char device[] = "/dev/sda1";
14593     int r;
14594     suppress_error = 0;
14595     r = guestfs_pvcreate (g, device);
14596     if (r == -1)
14597       return -1;
14598   }
14599   {
14600     char device[] = "/dev/sda2";
14601     int r;
14602     suppress_error = 0;
14603     r = guestfs_pvcreate (g, device);
14604     if (r == -1)
14605       return -1;
14606   }
14607   {
14608     char device[] = "/dev/sda3";
14609     int r;
14610     suppress_error = 0;
14611     r = guestfs_pvcreate (g, device);
14612     if (r == -1)
14613       return -1;
14614   }
14615   {
14616     char **r;
14617     int i;
14618     suppress_error = 0;
14619     r = guestfs_pvs (g);
14620     if (r == NULL)
14621       return -1;
14622     if (!r[0]) {
14623       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14624       print_strings (r);
14625       return -1;
14626     }
14627     {
14628       char expected[] = "/dev/sda1";
14629       r[0][5] = 's';
14630       if (strcmp (r[0], expected) != 0) {
14631         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14632         return -1;
14633       }
14634     }
14635     if (!r[1]) {
14636       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14637       print_strings (r);
14638       return -1;
14639     }
14640     {
14641       char expected[] = "/dev/sda2";
14642       r[1][5] = 's';
14643       if (strcmp (r[1], expected) != 0) {
14644         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14645         return -1;
14646       }
14647     }
14648     if (!r[2]) {
14649       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14650       print_strings (r);
14651       return -1;
14652     }
14653     {
14654       char expected[] = "/dev/sda3";
14655       r[2][5] = 's';
14656       if (strcmp (r[2], expected) != 0) {
14657         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14658         return -1;
14659       }
14660     }
14661     if (r[3] != NULL) {
14662       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14663       print_strings (r);
14664       return -1;
14665     }
14666     for (i = 0; r[i] != NULL; ++i)
14667       free (r[i]);
14668     free (r);
14669   }
14670   return 0;
14671 }
14672
14673 static int test_is_dir_0_skip (void)
14674 {
14675   const char *str;
14676
14677   str = getenv ("TEST_ONLY");
14678   if (str)
14679     return strstr (str, "is_dir") == NULL;
14680   str = getenv ("SKIP_TEST_IS_DIR_0");
14681   if (str && strcmp (str, "1") == 0) return 1;
14682   str = getenv ("SKIP_TEST_IS_DIR");
14683   if (str && strcmp (str, "1") == 0) return 1;
14684   return 0;
14685 }
14686
14687 static int test_is_dir_0 (void)
14688 {
14689   if (test_is_dir_0_skip ()) {
14690     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14691     return 0;
14692   }
14693
14694   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14695   {
14696     char device[] = "/dev/sda";
14697     int r;
14698     suppress_error = 0;
14699     r = guestfs_blockdev_setrw (g, device);
14700     if (r == -1)
14701       return -1;
14702   }
14703   {
14704     int r;
14705     suppress_error = 0;
14706     r = guestfs_umount_all (g);
14707     if (r == -1)
14708       return -1;
14709   }
14710   {
14711     int r;
14712     suppress_error = 0;
14713     r = guestfs_lvm_remove_all (g);
14714     if (r == -1)
14715       return -1;
14716   }
14717   {
14718     char device[] = "/dev/sda";
14719     char lines_0[] = ",";
14720     char *lines[] = {
14721       lines_0,
14722       NULL
14723     };
14724     int r;
14725     suppress_error = 0;
14726     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14727     if (r == -1)
14728       return -1;
14729   }
14730   {
14731     char fstype[] = "ext2";
14732     char device[] = "/dev/sda1";
14733     int r;
14734     suppress_error = 0;
14735     r = guestfs_mkfs (g, fstype, device);
14736     if (r == -1)
14737       return -1;
14738   }
14739   {
14740     char device[] = "/dev/sda1";
14741     char mountpoint[] = "/";
14742     int r;
14743     suppress_error = 0;
14744     r = guestfs_mount (g, device, mountpoint);
14745     if (r == -1)
14746       return -1;
14747   }
14748   /* TestOutputFalse for is_dir (0) */
14749   {
14750     char path[] = "/new";
14751     int r;
14752     suppress_error = 0;
14753     r = guestfs_touch (g, path);
14754     if (r == -1)
14755       return -1;
14756   }
14757   {
14758     char path[] = "/new";
14759     int r;
14760     suppress_error = 0;
14761     r = guestfs_is_dir (g, path);
14762     if (r == -1)
14763       return -1;
14764     if (r) {
14765       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14766       return -1;
14767     }
14768   }
14769   return 0;
14770 }
14771
14772 static int test_is_dir_1_skip (void)
14773 {
14774   const char *str;
14775
14776   str = getenv ("TEST_ONLY");
14777   if (str)
14778     return strstr (str, "is_dir") == NULL;
14779   str = getenv ("SKIP_TEST_IS_DIR_1");
14780   if (str && strcmp (str, "1") == 0) return 1;
14781   str = getenv ("SKIP_TEST_IS_DIR");
14782   if (str && strcmp (str, "1") == 0) return 1;
14783   return 0;
14784 }
14785
14786 static int test_is_dir_1 (void)
14787 {
14788   if (test_is_dir_1_skip ()) {
14789     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
14790     return 0;
14791   }
14792
14793   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
14794   {
14795     char device[] = "/dev/sda";
14796     int r;
14797     suppress_error = 0;
14798     r = guestfs_blockdev_setrw (g, device);
14799     if (r == -1)
14800       return -1;
14801   }
14802   {
14803     int r;
14804     suppress_error = 0;
14805     r = guestfs_umount_all (g);
14806     if (r == -1)
14807       return -1;
14808   }
14809   {
14810     int r;
14811     suppress_error = 0;
14812     r = guestfs_lvm_remove_all (g);
14813     if (r == -1)
14814       return -1;
14815   }
14816   {
14817     char device[] = "/dev/sda";
14818     char lines_0[] = ",";
14819     char *lines[] = {
14820       lines_0,
14821       NULL
14822     };
14823     int r;
14824     suppress_error = 0;
14825     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14826     if (r == -1)
14827       return -1;
14828   }
14829   {
14830     char fstype[] = "ext2";
14831     char device[] = "/dev/sda1";
14832     int r;
14833     suppress_error = 0;
14834     r = guestfs_mkfs (g, fstype, device);
14835     if (r == -1)
14836       return -1;
14837   }
14838   {
14839     char device[] = "/dev/sda1";
14840     char mountpoint[] = "/";
14841     int r;
14842     suppress_error = 0;
14843     r = guestfs_mount (g, device, mountpoint);
14844     if (r == -1)
14845       return -1;
14846   }
14847   /* TestOutputTrue for is_dir (1) */
14848   {
14849     char path[] = "/new";
14850     int r;
14851     suppress_error = 0;
14852     r = guestfs_mkdir (g, path);
14853     if (r == -1)
14854       return -1;
14855   }
14856   {
14857     char path[] = "/new";
14858     int r;
14859     suppress_error = 0;
14860     r = guestfs_is_dir (g, path);
14861     if (r == -1)
14862       return -1;
14863     if (!r) {
14864       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
14865       return -1;
14866     }
14867   }
14868   return 0;
14869 }
14870
14871 static int test_is_file_0_skip (void)
14872 {
14873   const char *str;
14874
14875   str = getenv ("TEST_ONLY");
14876   if (str)
14877     return strstr (str, "is_file") == NULL;
14878   str = getenv ("SKIP_TEST_IS_FILE_0");
14879   if (str && strcmp (str, "1") == 0) return 1;
14880   str = getenv ("SKIP_TEST_IS_FILE");
14881   if (str && strcmp (str, "1") == 0) return 1;
14882   return 0;
14883 }
14884
14885 static int test_is_file_0 (void)
14886 {
14887   if (test_is_file_0_skip ()) {
14888     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
14889     return 0;
14890   }
14891
14892   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
14893   {
14894     char device[] = "/dev/sda";
14895     int r;
14896     suppress_error = 0;
14897     r = guestfs_blockdev_setrw (g, device);
14898     if (r == -1)
14899       return -1;
14900   }
14901   {
14902     int r;
14903     suppress_error = 0;
14904     r = guestfs_umount_all (g);
14905     if (r == -1)
14906       return -1;
14907   }
14908   {
14909     int r;
14910     suppress_error = 0;
14911     r = guestfs_lvm_remove_all (g);
14912     if (r == -1)
14913       return -1;
14914   }
14915   {
14916     char device[] = "/dev/sda";
14917     char lines_0[] = ",";
14918     char *lines[] = {
14919       lines_0,
14920       NULL
14921     };
14922     int r;
14923     suppress_error = 0;
14924     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14925     if (r == -1)
14926       return -1;
14927   }
14928   {
14929     char fstype[] = "ext2";
14930     char device[] = "/dev/sda1";
14931     int r;
14932     suppress_error = 0;
14933     r = guestfs_mkfs (g, fstype, device);
14934     if (r == -1)
14935       return -1;
14936   }
14937   {
14938     char device[] = "/dev/sda1";
14939     char mountpoint[] = "/";
14940     int r;
14941     suppress_error = 0;
14942     r = guestfs_mount (g, device, mountpoint);
14943     if (r == -1)
14944       return -1;
14945   }
14946   /* TestOutputTrue for is_file (0) */
14947   {
14948     char path[] = "/new";
14949     int r;
14950     suppress_error = 0;
14951     r = guestfs_touch (g, path);
14952     if (r == -1)
14953       return -1;
14954   }
14955   {
14956     char path[] = "/new";
14957     int r;
14958     suppress_error = 0;
14959     r = guestfs_is_file (g, path);
14960     if (r == -1)
14961       return -1;
14962     if (!r) {
14963       fprintf (stderr, "test_is_file_0: expected true, got false\n");
14964       return -1;
14965     }
14966   }
14967   return 0;
14968 }
14969
14970 static int test_is_file_1_skip (void)
14971 {
14972   const char *str;
14973
14974   str = getenv ("TEST_ONLY");
14975   if (str)
14976     return strstr (str, "is_file") == NULL;
14977   str = getenv ("SKIP_TEST_IS_FILE_1");
14978   if (str && strcmp (str, "1") == 0) return 1;
14979   str = getenv ("SKIP_TEST_IS_FILE");
14980   if (str && strcmp (str, "1") == 0) return 1;
14981   return 0;
14982 }
14983
14984 static int test_is_file_1 (void)
14985 {
14986   if (test_is_file_1_skip ()) {
14987     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
14988     return 0;
14989   }
14990
14991   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
14992   {
14993     char device[] = "/dev/sda";
14994     int r;
14995     suppress_error = 0;
14996     r = guestfs_blockdev_setrw (g, device);
14997     if (r == -1)
14998       return -1;
14999   }
15000   {
15001     int r;
15002     suppress_error = 0;
15003     r = guestfs_umount_all (g);
15004     if (r == -1)
15005       return -1;
15006   }
15007   {
15008     int r;
15009     suppress_error = 0;
15010     r = guestfs_lvm_remove_all (g);
15011     if (r == -1)
15012       return -1;
15013   }
15014   {
15015     char device[] = "/dev/sda";
15016     char lines_0[] = ",";
15017     char *lines[] = {
15018       lines_0,
15019       NULL
15020     };
15021     int r;
15022     suppress_error = 0;
15023     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15024     if (r == -1)
15025       return -1;
15026   }
15027   {
15028     char fstype[] = "ext2";
15029     char device[] = "/dev/sda1";
15030     int r;
15031     suppress_error = 0;
15032     r = guestfs_mkfs (g, fstype, device);
15033     if (r == -1)
15034       return -1;
15035   }
15036   {
15037     char device[] = "/dev/sda1";
15038     char mountpoint[] = "/";
15039     int r;
15040     suppress_error = 0;
15041     r = guestfs_mount (g, device, mountpoint);
15042     if (r == -1)
15043       return -1;
15044   }
15045   /* TestOutputFalse for is_file (1) */
15046   {
15047     char path[] = "/new";
15048     int r;
15049     suppress_error = 0;
15050     r = guestfs_mkdir (g, path);
15051     if (r == -1)
15052       return -1;
15053   }
15054   {
15055     char path[] = "/new";
15056     int r;
15057     suppress_error = 0;
15058     r = guestfs_is_file (g, path);
15059     if (r == -1)
15060       return -1;
15061     if (r) {
15062       fprintf (stderr, "test_is_file_1: expected false, got true\n");
15063       return -1;
15064     }
15065   }
15066   return 0;
15067 }
15068
15069 static int test_exists_0_skip (void)
15070 {
15071   const char *str;
15072
15073   str = getenv ("TEST_ONLY");
15074   if (str)
15075     return strstr (str, "exists") == NULL;
15076   str = getenv ("SKIP_TEST_EXISTS_0");
15077   if (str && strcmp (str, "1") == 0) return 1;
15078   str = getenv ("SKIP_TEST_EXISTS");
15079   if (str && strcmp (str, "1") == 0) return 1;
15080   return 0;
15081 }
15082
15083 static int test_exists_0 (void)
15084 {
15085   if (test_exists_0_skip ()) {
15086     printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
15087     return 0;
15088   }
15089
15090   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15091   {
15092     char device[] = "/dev/sda";
15093     int r;
15094     suppress_error = 0;
15095     r = guestfs_blockdev_setrw (g, device);
15096     if (r == -1)
15097       return -1;
15098   }
15099   {
15100     int r;
15101     suppress_error = 0;
15102     r = guestfs_umount_all (g);
15103     if (r == -1)
15104       return -1;
15105   }
15106   {
15107     int r;
15108     suppress_error = 0;
15109     r = guestfs_lvm_remove_all (g);
15110     if (r == -1)
15111       return -1;
15112   }
15113   {
15114     char device[] = "/dev/sda";
15115     char lines_0[] = ",";
15116     char *lines[] = {
15117       lines_0,
15118       NULL
15119     };
15120     int r;
15121     suppress_error = 0;
15122     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15123     if (r == -1)
15124       return -1;
15125   }
15126   {
15127     char fstype[] = "ext2";
15128     char device[] = "/dev/sda1";
15129     int r;
15130     suppress_error = 0;
15131     r = guestfs_mkfs (g, fstype, device);
15132     if (r == -1)
15133       return -1;
15134   }
15135   {
15136     char device[] = "/dev/sda1";
15137     char mountpoint[] = "/";
15138     int r;
15139     suppress_error = 0;
15140     r = guestfs_mount (g, device, mountpoint);
15141     if (r == -1)
15142       return -1;
15143   }
15144   /* TestOutputTrue for exists (0) */
15145   {
15146     char path[] = "/new";
15147     int r;
15148     suppress_error = 0;
15149     r = guestfs_touch (g, path);
15150     if (r == -1)
15151       return -1;
15152   }
15153   {
15154     char path[] = "/new";
15155     int r;
15156     suppress_error = 0;
15157     r = guestfs_exists (g, path);
15158     if (r == -1)
15159       return -1;
15160     if (!r) {
15161       fprintf (stderr, "test_exists_0: expected true, got false\n");
15162       return -1;
15163     }
15164   }
15165   return 0;
15166 }
15167
15168 static int test_exists_1_skip (void)
15169 {
15170   const char *str;
15171
15172   str = getenv ("TEST_ONLY");
15173   if (str)
15174     return strstr (str, "exists") == NULL;
15175   str = getenv ("SKIP_TEST_EXISTS_1");
15176   if (str && strcmp (str, "1") == 0) return 1;
15177   str = getenv ("SKIP_TEST_EXISTS");
15178   if (str && strcmp (str, "1") == 0) return 1;
15179   return 0;
15180 }
15181
15182 static int test_exists_1 (void)
15183 {
15184   if (test_exists_1_skip ()) {
15185     printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15186     return 0;
15187   }
15188
15189   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15190   {
15191     char device[] = "/dev/sda";
15192     int r;
15193     suppress_error = 0;
15194     r = guestfs_blockdev_setrw (g, device);
15195     if (r == -1)
15196       return -1;
15197   }
15198   {
15199     int r;
15200     suppress_error = 0;
15201     r = guestfs_umount_all (g);
15202     if (r == -1)
15203       return -1;
15204   }
15205   {
15206     int r;
15207     suppress_error = 0;
15208     r = guestfs_lvm_remove_all (g);
15209     if (r == -1)
15210       return -1;
15211   }
15212   {
15213     char device[] = "/dev/sda";
15214     char lines_0[] = ",";
15215     char *lines[] = {
15216       lines_0,
15217       NULL
15218     };
15219     int r;
15220     suppress_error = 0;
15221     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15222     if (r == -1)
15223       return -1;
15224   }
15225   {
15226     char fstype[] = "ext2";
15227     char device[] = "/dev/sda1";
15228     int r;
15229     suppress_error = 0;
15230     r = guestfs_mkfs (g, fstype, device);
15231     if (r == -1)
15232       return -1;
15233   }
15234   {
15235     char device[] = "/dev/sda1";
15236     char mountpoint[] = "/";
15237     int r;
15238     suppress_error = 0;
15239     r = guestfs_mount (g, device, mountpoint);
15240     if (r == -1)
15241       return -1;
15242   }
15243   /* TestOutputTrue for exists (1) */
15244   {
15245     char path[] = "/new";
15246     int r;
15247     suppress_error = 0;
15248     r = guestfs_mkdir (g, path);
15249     if (r == -1)
15250       return -1;
15251   }
15252   {
15253     char path[] = "/new";
15254     int r;
15255     suppress_error = 0;
15256     r = guestfs_exists (g, path);
15257     if (r == -1)
15258       return -1;
15259     if (!r) {
15260       fprintf (stderr, "test_exists_1: expected true, got false\n");
15261       return -1;
15262     }
15263   }
15264   return 0;
15265 }
15266
15267 static int test_mkdir_p_0_skip (void)
15268 {
15269   const char *str;
15270
15271   str = getenv ("TEST_ONLY");
15272   if (str)
15273     return strstr (str, "mkdir_p") == NULL;
15274   str = getenv ("SKIP_TEST_MKDIR_P_0");
15275   if (str && strcmp (str, "1") == 0) return 1;
15276   str = getenv ("SKIP_TEST_MKDIR_P");
15277   if (str && strcmp (str, "1") == 0) return 1;
15278   return 0;
15279 }
15280
15281 static int test_mkdir_p_0 (void)
15282 {
15283   if (test_mkdir_p_0_skip ()) {
15284     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15285     return 0;
15286   }
15287
15288   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15289   {
15290     char device[] = "/dev/sda";
15291     int r;
15292     suppress_error = 0;
15293     r = guestfs_blockdev_setrw (g, device);
15294     if (r == -1)
15295       return -1;
15296   }
15297   {
15298     int r;
15299     suppress_error = 0;
15300     r = guestfs_umount_all (g);
15301     if (r == -1)
15302       return -1;
15303   }
15304   {
15305     int r;
15306     suppress_error = 0;
15307     r = guestfs_lvm_remove_all (g);
15308     if (r == -1)
15309       return -1;
15310   }
15311   {
15312     char device[] = "/dev/sda";
15313     char lines_0[] = ",";
15314     char *lines[] = {
15315       lines_0,
15316       NULL
15317     };
15318     int r;
15319     suppress_error = 0;
15320     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15321     if (r == -1)
15322       return -1;
15323   }
15324   {
15325     char fstype[] = "ext2";
15326     char device[] = "/dev/sda1";
15327     int r;
15328     suppress_error = 0;
15329     r = guestfs_mkfs (g, fstype, device);
15330     if (r == -1)
15331       return -1;
15332   }
15333   {
15334     char device[] = "/dev/sda1";
15335     char mountpoint[] = "/";
15336     int r;
15337     suppress_error = 0;
15338     r = guestfs_mount (g, device, mountpoint);
15339     if (r == -1)
15340       return -1;
15341   }
15342   /* TestOutputTrue for mkdir_p (0) */
15343   {
15344     char path[] = "/new/foo/bar";
15345     int r;
15346     suppress_error = 0;
15347     r = guestfs_mkdir_p (g, path);
15348     if (r == -1)
15349       return -1;
15350   }
15351   {
15352     char path[] = "/new/foo/bar";
15353     int r;
15354     suppress_error = 0;
15355     r = guestfs_is_dir (g, path);
15356     if (r == -1)
15357       return -1;
15358     if (!r) {
15359       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15360       return -1;
15361     }
15362   }
15363   return 0;
15364 }
15365
15366 static int test_mkdir_p_1_skip (void)
15367 {
15368   const char *str;
15369
15370   str = getenv ("TEST_ONLY");
15371   if (str)
15372     return strstr (str, "mkdir_p") == NULL;
15373   str = getenv ("SKIP_TEST_MKDIR_P_1");
15374   if (str && strcmp (str, "1") == 0) return 1;
15375   str = getenv ("SKIP_TEST_MKDIR_P");
15376   if (str && strcmp (str, "1") == 0) return 1;
15377   return 0;
15378 }
15379
15380 static int test_mkdir_p_1 (void)
15381 {
15382   if (test_mkdir_p_1_skip ()) {
15383     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15384     return 0;
15385   }
15386
15387   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15388   {
15389     char device[] = "/dev/sda";
15390     int r;
15391     suppress_error = 0;
15392     r = guestfs_blockdev_setrw (g, device);
15393     if (r == -1)
15394       return -1;
15395   }
15396   {
15397     int r;
15398     suppress_error = 0;
15399     r = guestfs_umount_all (g);
15400     if (r == -1)
15401       return -1;
15402   }
15403   {
15404     int r;
15405     suppress_error = 0;
15406     r = guestfs_lvm_remove_all (g);
15407     if (r == -1)
15408       return -1;
15409   }
15410   {
15411     char device[] = "/dev/sda";
15412     char lines_0[] = ",";
15413     char *lines[] = {
15414       lines_0,
15415       NULL
15416     };
15417     int r;
15418     suppress_error = 0;
15419     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15420     if (r == -1)
15421       return -1;
15422   }
15423   {
15424     char fstype[] = "ext2";
15425     char device[] = "/dev/sda1";
15426     int r;
15427     suppress_error = 0;
15428     r = guestfs_mkfs (g, fstype, device);
15429     if (r == -1)
15430       return -1;
15431   }
15432   {
15433     char device[] = "/dev/sda1";
15434     char mountpoint[] = "/";
15435     int r;
15436     suppress_error = 0;
15437     r = guestfs_mount (g, device, mountpoint);
15438     if (r == -1)
15439       return -1;
15440   }
15441   /* TestOutputTrue for mkdir_p (1) */
15442   {
15443     char path[] = "/new/foo/bar";
15444     int r;
15445     suppress_error = 0;
15446     r = guestfs_mkdir_p (g, path);
15447     if (r == -1)
15448       return -1;
15449   }
15450   {
15451     char path[] = "/new/foo";
15452     int r;
15453     suppress_error = 0;
15454     r = guestfs_is_dir (g, path);
15455     if (r == -1)
15456       return -1;
15457     if (!r) {
15458       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15459       return -1;
15460     }
15461   }
15462   return 0;
15463 }
15464
15465 static int test_mkdir_p_2_skip (void)
15466 {
15467   const char *str;
15468
15469   str = getenv ("TEST_ONLY");
15470   if (str)
15471     return strstr (str, "mkdir_p") == NULL;
15472   str = getenv ("SKIP_TEST_MKDIR_P_2");
15473   if (str && strcmp (str, "1") == 0) return 1;
15474   str = getenv ("SKIP_TEST_MKDIR_P");
15475   if (str && strcmp (str, "1") == 0) return 1;
15476   return 0;
15477 }
15478
15479 static int test_mkdir_p_2 (void)
15480 {
15481   if (test_mkdir_p_2_skip ()) {
15482     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15483     return 0;
15484   }
15485
15486   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15487   {
15488     char device[] = "/dev/sda";
15489     int r;
15490     suppress_error = 0;
15491     r = guestfs_blockdev_setrw (g, device);
15492     if (r == -1)
15493       return -1;
15494   }
15495   {
15496     int r;
15497     suppress_error = 0;
15498     r = guestfs_umount_all (g);
15499     if (r == -1)
15500       return -1;
15501   }
15502   {
15503     int r;
15504     suppress_error = 0;
15505     r = guestfs_lvm_remove_all (g);
15506     if (r == -1)
15507       return -1;
15508   }
15509   {
15510     char device[] = "/dev/sda";
15511     char lines_0[] = ",";
15512     char *lines[] = {
15513       lines_0,
15514       NULL
15515     };
15516     int r;
15517     suppress_error = 0;
15518     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15519     if (r == -1)
15520       return -1;
15521   }
15522   {
15523     char fstype[] = "ext2";
15524     char device[] = "/dev/sda1";
15525     int r;
15526     suppress_error = 0;
15527     r = guestfs_mkfs (g, fstype, device);
15528     if (r == -1)
15529       return -1;
15530   }
15531   {
15532     char device[] = "/dev/sda1";
15533     char mountpoint[] = "/";
15534     int r;
15535     suppress_error = 0;
15536     r = guestfs_mount (g, device, mountpoint);
15537     if (r == -1)
15538       return -1;
15539   }
15540   /* TestOutputTrue for mkdir_p (2) */
15541   {
15542     char path[] = "/new/foo/bar";
15543     int r;
15544     suppress_error = 0;
15545     r = guestfs_mkdir_p (g, path);
15546     if (r == -1)
15547       return -1;
15548   }
15549   {
15550     char path[] = "/new";
15551     int r;
15552     suppress_error = 0;
15553     r = guestfs_is_dir (g, path);
15554     if (r == -1)
15555       return -1;
15556     if (!r) {
15557       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15558       return -1;
15559     }
15560   }
15561   return 0;
15562 }
15563
15564 static int test_mkdir_p_3_skip (void)
15565 {
15566   const char *str;
15567
15568   str = getenv ("TEST_ONLY");
15569   if (str)
15570     return strstr (str, "mkdir_p") == NULL;
15571   str = getenv ("SKIP_TEST_MKDIR_P_3");
15572   if (str && strcmp (str, "1") == 0) return 1;
15573   str = getenv ("SKIP_TEST_MKDIR_P");
15574   if (str && strcmp (str, "1") == 0) return 1;
15575   return 0;
15576 }
15577
15578 static int test_mkdir_p_3 (void)
15579 {
15580   if (test_mkdir_p_3_skip ()) {
15581     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15582     return 0;
15583   }
15584
15585   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15586   {
15587     char device[] = "/dev/sda";
15588     int r;
15589     suppress_error = 0;
15590     r = guestfs_blockdev_setrw (g, device);
15591     if (r == -1)
15592       return -1;
15593   }
15594   {
15595     int r;
15596     suppress_error = 0;
15597     r = guestfs_umount_all (g);
15598     if (r == -1)
15599       return -1;
15600   }
15601   {
15602     int r;
15603     suppress_error = 0;
15604     r = guestfs_lvm_remove_all (g);
15605     if (r == -1)
15606       return -1;
15607   }
15608   {
15609     char device[] = "/dev/sda";
15610     char lines_0[] = ",";
15611     char *lines[] = {
15612       lines_0,
15613       NULL
15614     };
15615     int r;
15616     suppress_error = 0;
15617     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15618     if (r == -1)
15619       return -1;
15620   }
15621   {
15622     char fstype[] = "ext2";
15623     char device[] = "/dev/sda1";
15624     int r;
15625     suppress_error = 0;
15626     r = guestfs_mkfs (g, fstype, device);
15627     if (r == -1)
15628       return -1;
15629   }
15630   {
15631     char device[] = "/dev/sda1";
15632     char mountpoint[] = "/";
15633     int r;
15634     suppress_error = 0;
15635     r = guestfs_mount (g, device, mountpoint);
15636     if (r == -1)
15637       return -1;
15638   }
15639   /* TestRun for mkdir_p (3) */
15640   {
15641     char path[] = "/new";
15642     int r;
15643     suppress_error = 0;
15644     r = guestfs_mkdir (g, path);
15645     if (r == -1)
15646       return -1;
15647   }
15648   {
15649     char path[] = "/new";
15650     int r;
15651     suppress_error = 0;
15652     r = guestfs_mkdir_p (g, path);
15653     if (r == -1)
15654       return -1;
15655   }
15656   return 0;
15657 }
15658
15659 static int test_mkdir_p_4_skip (void)
15660 {
15661   const char *str;
15662
15663   str = getenv ("TEST_ONLY");
15664   if (str)
15665     return strstr (str, "mkdir_p") == NULL;
15666   str = getenv ("SKIP_TEST_MKDIR_P_4");
15667   if (str && strcmp (str, "1") == 0) return 1;
15668   str = getenv ("SKIP_TEST_MKDIR_P");
15669   if (str && strcmp (str, "1") == 0) return 1;
15670   return 0;
15671 }
15672
15673 static int test_mkdir_p_4 (void)
15674 {
15675   if (test_mkdir_p_4_skip ()) {
15676     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15677     return 0;
15678   }
15679
15680   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15681   {
15682     char device[] = "/dev/sda";
15683     int r;
15684     suppress_error = 0;
15685     r = guestfs_blockdev_setrw (g, device);
15686     if (r == -1)
15687       return -1;
15688   }
15689   {
15690     int r;
15691     suppress_error = 0;
15692     r = guestfs_umount_all (g);
15693     if (r == -1)
15694       return -1;
15695   }
15696   {
15697     int r;
15698     suppress_error = 0;
15699     r = guestfs_lvm_remove_all (g);
15700     if (r == -1)
15701       return -1;
15702   }
15703   {
15704     char device[] = "/dev/sda";
15705     char lines_0[] = ",";
15706     char *lines[] = {
15707       lines_0,
15708       NULL
15709     };
15710     int r;
15711     suppress_error = 0;
15712     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15713     if (r == -1)
15714       return -1;
15715   }
15716   {
15717     char fstype[] = "ext2";
15718     char device[] = "/dev/sda1";
15719     int r;
15720     suppress_error = 0;
15721     r = guestfs_mkfs (g, fstype, device);
15722     if (r == -1)
15723       return -1;
15724   }
15725   {
15726     char device[] = "/dev/sda1";
15727     char mountpoint[] = "/";
15728     int r;
15729     suppress_error = 0;
15730     r = guestfs_mount (g, device, mountpoint);
15731     if (r == -1)
15732       return -1;
15733   }
15734   /* TestLastFail for mkdir_p (4) */
15735   {
15736     char path[] = "/new";
15737     int r;
15738     suppress_error = 0;
15739     r = guestfs_touch (g, path);
15740     if (r == -1)
15741       return -1;
15742   }
15743   {
15744     char path[] = "/new";
15745     int r;
15746     suppress_error = 1;
15747     r = guestfs_mkdir_p (g, path);
15748     if (r != -1)
15749       return -1;
15750   }
15751   return 0;
15752 }
15753
15754 static int test_mkdir_0_skip (void)
15755 {
15756   const char *str;
15757
15758   str = getenv ("TEST_ONLY");
15759   if (str)
15760     return strstr (str, "mkdir") == NULL;
15761   str = getenv ("SKIP_TEST_MKDIR_0");
15762   if (str && strcmp (str, "1") == 0) return 1;
15763   str = getenv ("SKIP_TEST_MKDIR");
15764   if (str && strcmp (str, "1") == 0) return 1;
15765   return 0;
15766 }
15767
15768 static int test_mkdir_0 (void)
15769 {
15770   if (test_mkdir_0_skip ()) {
15771     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15772     return 0;
15773   }
15774
15775   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15776   {
15777     char device[] = "/dev/sda";
15778     int r;
15779     suppress_error = 0;
15780     r = guestfs_blockdev_setrw (g, device);
15781     if (r == -1)
15782       return -1;
15783   }
15784   {
15785     int r;
15786     suppress_error = 0;
15787     r = guestfs_umount_all (g);
15788     if (r == -1)
15789       return -1;
15790   }
15791   {
15792     int r;
15793     suppress_error = 0;
15794     r = guestfs_lvm_remove_all (g);
15795     if (r == -1)
15796       return -1;
15797   }
15798   {
15799     char device[] = "/dev/sda";
15800     char lines_0[] = ",";
15801     char *lines[] = {
15802       lines_0,
15803       NULL
15804     };
15805     int r;
15806     suppress_error = 0;
15807     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15808     if (r == -1)
15809       return -1;
15810   }
15811   {
15812     char fstype[] = "ext2";
15813     char device[] = "/dev/sda1";
15814     int r;
15815     suppress_error = 0;
15816     r = guestfs_mkfs (g, fstype, device);
15817     if (r == -1)
15818       return -1;
15819   }
15820   {
15821     char device[] = "/dev/sda1";
15822     char mountpoint[] = "/";
15823     int r;
15824     suppress_error = 0;
15825     r = guestfs_mount (g, device, mountpoint);
15826     if (r == -1)
15827       return -1;
15828   }
15829   /* TestOutputTrue for mkdir (0) */
15830   {
15831     char path[] = "/new";
15832     int r;
15833     suppress_error = 0;
15834     r = guestfs_mkdir (g, path);
15835     if (r == -1)
15836       return -1;
15837   }
15838   {
15839     char path[] = "/new";
15840     int r;
15841     suppress_error = 0;
15842     r = guestfs_is_dir (g, path);
15843     if (r == -1)
15844       return -1;
15845     if (!r) {
15846       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
15847       return -1;
15848     }
15849   }
15850   return 0;
15851 }
15852
15853 static int test_mkdir_1_skip (void)
15854 {
15855   const char *str;
15856
15857   str = getenv ("TEST_ONLY");
15858   if (str)
15859     return strstr (str, "mkdir") == NULL;
15860   str = getenv ("SKIP_TEST_MKDIR_1");
15861   if (str && strcmp (str, "1") == 0) return 1;
15862   str = getenv ("SKIP_TEST_MKDIR");
15863   if (str && strcmp (str, "1") == 0) return 1;
15864   return 0;
15865 }
15866
15867 static int test_mkdir_1 (void)
15868 {
15869   if (test_mkdir_1_skip ()) {
15870     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
15871     return 0;
15872   }
15873
15874   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
15875   {
15876     char device[] = "/dev/sda";
15877     int r;
15878     suppress_error = 0;
15879     r = guestfs_blockdev_setrw (g, device);
15880     if (r == -1)
15881       return -1;
15882   }
15883   {
15884     int r;
15885     suppress_error = 0;
15886     r = guestfs_umount_all (g);
15887     if (r == -1)
15888       return -1;
15889   }
15890   {
15891     int r;
15892     suppress_error = 0;
15893     r = guestfs_lvm_remove_all (g);
15894     if (r == -1)
15895       return -1;
15896   }
15897   {
15898     char device[] = "/dev/sda";
15899     char lines_0[] = ",";
15900     char *lines[] = {
15901       lines_0,
15902       NULL
15903     };
15904     int r;
15905     suppress_error = 0;
15906     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15907     if (r == -1)
15908       return -1;
15909   }
15910   {
15911     char fstype[] = "ext2";
15912     char device[] = "/dev/sda1";
15913     int r;
15914     suppress_error = 0;
15915     r = guestfs_mkfs (g, fstype, device);
15916     if (r == -1)
15917       return -1;
15918   }
15919   {
15920     char device[] = "/dev/sda1";
15921     char mountpoint[] = "/";
15922     int r;
15923     suppress_error = 0;
15924     r = guestfs_mount (g, device, mountpoint);
15925     if (r == -1)
15926       return -1;
15927   }
15928   /* TestLastFail for mkdir (1) */
15929   {
15930     char path[] = "/new/foo/bar";
15931     int r;
15932     suppress_error = 1;
15933     r = guestfs_mkdir (g, path);
15934     if (r != -1)
15935       return -1;
15936   }
15937   return 0;
15938 }
15939
15940 static int test_rm_rf_0_skip (void)
15941 {
15942   const char *str;
15943
15944   str = getenv ("TEST_ONLY");
15945   if (str)
15946     return strstr (str, "rm_rf") == NULL;
15947   str = getenv ("SKIP_TEST_RM_RF_0");
15948   if (str && strcmp (str, "1") == 0) return 1;
15949   str = getenv ("SKIP_TEST_RM_RF");
15950   if (str && strcmp (str, "1") == 0) return 1;
15951   return 0;
15952 }
15953
15954 static int test_rm_rf_0 (void)
15955 {
15956   if (test_rm_rf_0_skip ()) {
15957     printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
15958     return 0;
15959   }
15960
15961   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
15962   {
15963     char device[] = "/dev/sda";
15964     int r;
15965     suppress_error = 0;
15966     r = guestfs_blockdev_setrw (g, device);
15967     if (r == -1)
15968       return -1;
15969   }
15970   {
15971     int r;
15972     suppress_error = 0;
15973     r = guestfs_umount_all (g);
15974     if (r == -1)
15975       return -1;
15976   }
15977   {
15978     int r;
15979     suppress_error = 0;
15980     r = guestfs_lvm_remove_all (g);
15981     if (r == -1)
15982       return -1;
15983   }
15984   {
15985     char device[] = "/dev/sda";
15986     char lines_0[] = ",";
15987     char *lines[] = {
15988       lines_0,
15989       NULL
15990     };
15991     int r;
15992     suppress_error = 0;
15993     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15994     if (r == -1)
15995       return -1;
15996   }
15997   {
15998     char fstype[] = "ext2";
15999     char device[] = "/dev/sda1";
16000     int r;
16001     suppress_error = 0;
16002     r = guestfs_mkfs (g, fstype, device);
16003     if (r == -1)
16004       return -1;
16005   }
16006   {
16007     char device[] = "/dev/sda1";
16008     char mountpoint[] = "/";
16009     int r;
16010     suppress_error = 0;
16011     r = guestfs_mount (g, device, mountpoint);
16012     if (r == -1)
16013       return -1;
16014   }
16015   /* TestOutputFalse for rm_rf (0) */
16016   {
16017     char path[] = "/new";
16018     int r;
16019     suppress_error = 0;
16020     r = guestfs_mkdir (g, path);
16021     if (r == -1)
16022       return -1;
16023   }
16024   {
16025     char path[] = "/new/foo";
16026     int r;
16027     suppress_error = 0;
16028     r = guestfs_mkdir (g, path);
16029     if (r == -1)
16030       return -1;
16031   }
16032   {
16033     char path[] = "/new/foo/bar";
16034     int r;
16035     suppress_error = 0;
16036     r = guestfs_touch (g, path);
16037     if (r == -1)
16038       return -1;
16039   }
16040   {
16041     char path[] = "/new";
16042     int r;
16043     suppress_error = 0;
16044     r = guestfs_rm_rf (g, path);
16045     if (r == -1)
16046       return -1;
16047   }
16048   {
16049     char path[] = "/new";
16050     int r;
16051     suppress_error = 0;
16052     r = guestfs_exists (g, path);
16053     if (r == -1)
16054       return -1;
16055     if (r) {
16056       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16057       return -1;
16058     }
16059   }
16060   return 0;
16061 }
16062
16063 static int test_rmdir_0_skip (void)
16064 {
16065   const char *str;
16066
16067   str = getenv ("TEST_ONLY");
16068   if (str)
16069     return strstr (str, "rmdir") == NULL;
16070   str = getenv ("SKIP_TEST_RMDIR_0");
16071   if (str && strcmp (str, "1") == 0) return 1;
16072   str = getenv ("SKIP_TEST_RMDIR");
16073   if (str && strcmp (str, "1") == 0) return 1;
16074   return 0;
16075 }
16076
16077 static int test_rmdir_0 (void)
16078 {
16079   if (test_rmdir_0_skip ()) {
16080     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
16081     return 0;
16082   }
16083
16084   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16085   {
16086     char device[] = "/dev/sda";
16087     int r;
16088     suppress_error = 0;
16089     r = guestfs_blockdev_setrw (g, device);
16090     if (r == -1)
16091       return -1;
16092   }
16093   {
16094     int r;
16095     suppress_error = 0;
16096     r = guestfs_umount_all (g);
16097     if (r == -1)
16098       return -1;
16099   }
16100   {
16101     int r;
16102     suppress_error = 0;
16103     r = guestfs_lvm_remove_all (g);
16104     if (r == -1)
16105       return -1;
16106   }
16107   {
16108     char device[] = "/dev/sda";
16109     char lines_0[] = ",";
16110     char *lines[] = {
16111       lines_0,
16112       NULL
16113     };
16114     int r;
16115     suppress_error = 0;
16116     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16117     if (r == -1)
16118       return -1;
16119   }
16120   {
16121     char fstype[] = "ext2";
16122     char device[] = "/dev/sda1";
16123     int r;
16124     suppress_error = 0;
16125     r = guestfs_mkfs (g, fstype, device);
16126     if (r == -1)
16127       return -1;
16128   }
16129   {
16130     char device[] = "/dev/sda1";
16131     char mountpoint[] = "/";
16132     int r;
16133     suppress_error = 0;
16134     r = guestfs_mount (g, device, mountpoint);
16135     if (r == -1)
16136       return -1;
16137   }
16138   /* TestRun for rmdir (0) */
16139   {
16140     char path[] = "/new";
16141     int r;
16142     suppress_error = 0;
16143     r = guestfs_mkdir (g, path);
16144     if (r == -1)
16145       return -1;
16146   }
16147   {
16148     char path[] = "/new";
16149     int r;
16150     suppress_error = 0;
16151     r = guestfs_rmdir (g, path);
16152     if (r == -1)
16153       return -1;
16154   }
16155   return 0;
16156 }
16157
16158 static int test_rmdir_1_skip (void)
16159 {
16160   const char *str;
16161
16162   str = getenv ("TEST_ONLY");
16163   if (str)
16164     return strstr (str, "rmdir") == NULL;
16165   str = getenv ("SKIP_TEST_RMDIR_1");
16166   if (str && strcmp (str, "1") == 0) return 1;
16167   str = getenv ("SKIP_TEST_RMDIR");
16168   if (str && strcmp (str, "1") == 0) return 1;
16169   return 0;
16170 }
16171
16172 static int test_rmdir_1 (void)
16173 {
16174   if (test_rmdir_1_skip ()) {
16175     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16176     return 0;
16177   }
16178
16179   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16180   {
16181     char device[] = "/dev/sda";
16182     int r;
16183     suppress_error = 0;
16184     r = guestfs_blockdev_setrw (g, device);
16185     if (r == -1)
16186       return -1;
16187   }
16188   {
16189     int r;
16190     suppress_error = 0;
16191     r = guestfs_umount_all (g);
16192     if (r == -1)
16193       return -1;
16194   }
16195   {
16196     int r;
16197     suppress_error = 0;
16198     r = guestfs_lvm_remove_all (g);
16199     if (r == -1)
16200       return -1;
16201   }
16202   {
16203     char device[] = "/dev/sda";
16204     char lines_0[] = ",";
16205     char *lines[] = {
16206       lines_0,
16207       NULL
16208     };
16209     int r;
16210     suppress_error = 0;
16211     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16212     if (r == -1)
16213       return -1;
16214   }
16215   {
16216     char fstype[] = "ext2";
16217     char device[] = "/dev/sda1";
16218     int r;
16219     suppress_error = 0;
16220     r = guestfs_mkfs (g, fstype, device);
16221     if (r == -1)
16222       return -1;
16223   }
16224   {
16225     char device[] = "/dev/sda1";
16226     char mountpoint[] = "/";
16227     int r;
16228     suppress_error = 0;
16229     r = guestfs_mount (g, device, mountpoint);
16230     if (r == -1)
16231       return -1;
16232   }
16233   /* TestLastFail for rmdir (1) */
16234   {
16235     char path[] = "/new";
16236     int r;
16237     suppress_error = 1;
16238     r = guestfs_rmdir (g, path);
16239     if (r != -1)
16240       return -1;
16241   }
16242   return 0;
16243 }
16244
16245 static int test_rmdir_2_skip (void)
16246 {
16247   const char *str;
16248
16249   str = getenv ("TEST_ONLY");
16250   if (str)
16251     return strstr (str, "rmdir") == NULL;
16252   str = getenv ("SKIP_TEST_RMDIR_2");
16253   if (str && strcmp (str, "1") == 0) return 1;
16254   str = getenv ("SKIP_TEST_RMDIR");
16255   if (str && strcmp (str, "1") == 0) return 1;
16256   return 0;
16257 }
16258
16259 static int test_rmdir_2 (void)
16260 {
16261   if (test_rmdir_2_skip ()) {
16262     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16263     return 0;
16264   }
16265
16266   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16267   {
16268     char device[] = "/dev/sda";
16269     int r;
16270     suppress_error = 0;
16271     r = guestfs_blockdev_setrw (g, device);
16272     if (r == -1)
16273       return -1;
16274   }
16275   {
16276     int r;
16277     suppress_error = 0;
16278     r = guestfs_umount_all (g);
16279     if (r == -1)
16280       return -1;
16281   }
16282   {
16283     int r;
16284     suppress_error = 0;
16285     r = guestfs_lvm_remove_all (g);
16286     if (r == -1)
16287       return -1;
16288   }
16289   {
16290     char device[] = "/dev/sda";
16291     char lines_0[] = ",";
16292     char *lines[] = {
16293       lines_0,
16294       NULL
16295     };
16296     int r;
16297     suppress_error = 0;
16298     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16299     if (r == -1)
16300       return -1;
16301   }
16302   {
16303     char fstype[] = "ext2";
16304     char device[] = "/dev/sda1";
16305     int r;
16306     suppress_error = 0;
16307     r = guestfs_mkfs (g, fstype, device);
16308     if (r == -1)
16309       return -1;
16310   }
16311   {
16312     char device[] = "/dev/sda1";
16313     char mountpoint[] = "/";
16314     int r;
16315     suppress_error = 0;
16316     r = guestfs_mount (g, device, mountpoint);
16317     if (r == -1)
16318       return -1;
16319   }
16320   /* TestLastFail for rmdir (2) */
16321   {
16322     char path[] = "/new";
16323     int r;
16324     suppress_error = 0;
16325     r = guestfs_touch (g, path);
16326     if (r == -1)
16327       return -1;
16328   }
16329   {
16330     char path[] = "/new";
16331     int r;
16332     suppress_error = 1;
16333     r = guestfs_rmdir (g, path);
16334     if (r != -1)
16335       return -1;
16336   }
16337   return 0;
16338 }
16339
16340 static int test_rm_0_skip (void)
16341 {
16342   const char *str;
16343
16344   str = getenv ("TEST_ONLY");
16345   if (str)
16346     return strstr (str, "rm") == NULL;
16347   str = getenv ("SKIP_TEST_RM_0");
16348   if (str && strcmp (str, "1") == 0) return 1;
16349   str = getenv ("SKIP_TEST_RM");
16350   if (str && strcmp (str, "1") == 0) return 1;
16351   return 0;
16352 }
16353
16354 static int test_rm_0 (void)
16355 {
16356   if (test_rm_0_skip ()) {
16357     printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16358     return 0;
16359   }
16360
16361   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16362   {
16363     char device[] = "/dev/sda";
16364     int r;
16365     suppress_error = 0;
16366     r = guestfs_blockdev_setrw (g, device);
16367     if (r == -1)
16368       return -1;
16369   }
16370   {
16371     int r;
16372     suppress_error = 0;
16373     r = guestfs_umount_all (g);
16374     if (r == -1)
16375       return -1;
16376   }
16377   {
16378     int r;
16379     suppress_error = 0;
16380     r = guestfs_lvm_remove_all (g);
16381     if (r == -1)
16382       return -1;
16383   }
16384   {
16385     char device[] = "/dev/sda";
16386     char lines_0[] = ",";
16387     char *lines[] = {
16388       lines_0,
16389       NULL
16390     };
16391     int r;
16392     suppress_error = 0;
16393     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16394     if (r == -1)
16395       return -1;
16396   }
16397   {
16398     char fstype[] = "ext2";
16399     char device[] = "/dev/sda1";
16400     int r;
16401     suppress_error = 0;
16402     r = guestfs_mkfs (g, fstype, device);
16403     if (r == -1)
16404       return -1;
16405   }
16406   {
16407     char device[] = "/dev/sda1";
16408     char mountpoint[] = "/";
16409     int r;
16410     suppress_error = 0;
16411     r = guestfs_mount (g, device, mountpoint);
16412     if (r == -1)
16413       return -1;
16414   }
16415   /* TestRun for rm (0) */
16416   {
16417     char path[] = "/new";
16418     int r;
16419     suppress_error = 0;
16420     r = guestfs_touch (g, path);
16421     if (r == -1)
16422       return -1;
16423   }
16424   {
16425     char path[] = "/new";
16426     int r;
16427     suppress_error = 0;
16428     r = guestfs_rm (g, path);
16429     if (r == -1)
16430       return -1;
16431   }
16432   return 0;
16433 }
16434
16435 static int test_rm_1_skip (void)
16436 {
16437   const char *str;
16438
16439   str = getenv ("TEST_ONLY");
16440   if (str)
16441     return strstr (str, "rm") == NULL;
16442   str = getenv ("SKIP_TEST_RM_1");
16443   if (str && strcmp (str, "1") == 0) return 1;
16444   str = getenv ("SKIP_TEST_RM");
16445   if (str && strcmp (str, "1") == 0) return 1;
16446   return 0;
16447 }
16448
16449 static int test_rm_1 (void)
16450 {
16451   if (test_rm_1_skip ()) {
16452     printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16453     return 0;
16454   }
16455
16456   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16457   {
16458     char device[] = "/dev/sda";
16459     int r;
16460     suppress_error = 0;
16461     r = guestfs_blockdev_setrw (g, device);
16462     if (r == -1)
16463       return -1;
16464   }
16465   {
16466     int r;
16467     suppress_error = 0;
16468     r = guestfs_umount_all (g);
16469     if (r == -1)
16470       return -1;
16471   }
16472   {
16473     int r;
16474     suppress_error = 0;
16475     r = guestfs_lvm_remove_all (g);
16476     if (r == -1)
16477       return -1;
16478   }
16479   {
16480     char device[] = "/dev/sda";
16481     char lines_0[] = ",";
16482     char *lines[] = {
16483       lines_0,
16484       NULL
16485     };
16486     int r;
16487     suppress_error = 0;
16488     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16489     if (r == -1)
16490       return -1;
16491   }
16492   {
16493     char fstype[] = "ext2";
16494     char device[] = "/dev/sda1";
16495     int r;
16496     suppress_error = 0;
16497     r = guestfs_mkfs (g, fstype, device);
16498     if (r == -1)
16499       return -1;
16500   }
16501   {
16502     char device[] = "/dev/sda1";
16503     char mountpoint[] = "/";
16504     int r;
16505     suppress_error = 0;
16506     r = guestfs_mount (g, device, mountpoint);
16507     if (r == -1)
16508       return -1;
16509   }
16510   /* TestLastFail for rm (1) */
16511   {
16512     char path[] = "/new";
16513     int r;
16514     suppress_error = 1;
16515     r = guestfs_rm (g, path);
16516     if (r != -1)
16517       return -1;
16518   }
16519   return 0;
16520 }
16521
16522 static int test_rm_2_skip (void)
16523 {
16524   const char *str;
16525
16526   str = getenv ("TEST_ONLY");
16527   if (str)
16528     return strstr (str, "rm") == NULL;
16529   str = getenv ("SKIP_TEST_RM_2");
16530   if (str && strcmp (str, "1") == 0) return 1;
16531   str = getenv ("SKIP_TEST_RM");
16532   if (str && strcmp (str, "1") == 0) return 1;
16533   return 0;
16534 }
16535
16536 static int test_rm_2 (void)
16537 {
16538   if (test_rm_2_skip ()) {
16539     printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16540     return 0;
16541   }
16542
16543   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16544   {
16545     char device[] = "/dev/sda";
16546     int r;
16547     suppress_error = 0;
16548     r = guestfs_blockdev_setrw (g, device);
16549     if (r == -1)
16550       return -1;
16551   }
16552   {
16553     int r;
16554     suppress_error = 0;
16555     r = guestfs_umount_all (g);
16556     if (r == -1)
16557       return -1;
16558   }
16559   {
16560     int r;
16561     suppress_error = 0;
16562     r = guestfs_lvm_remove_all (g);
16563     if (r == -1)
16564       return -1;
16565   }
16566   {
16567     char device[] = "/dev/sda";
16568     char lines_0[] = ",";
16569     char *lines[] = {
16570       lines_0,
16571       NULL
16572     };
16573     int r;
16574     suppress_error = 0;
16575     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16576     if (r == -1)
16577       return -1;
16578   }
16579   {
16580     char fstype[] = "ext2";
16581     char device[] = "/dev/sda1";
16582     int r;
16583     suppress_error = 0;
16584     r = guestfs_mkfs (g, fstype, device);
16585     if (r == -1)
16586       return -1;
16587   }
16588   {
16589     char device[] = "/dev/sda1";
16590     char mountpoint[] = "/";
16591     int r;
16592     suppress_error = 0;
16593     r = guestfs_mount (g, device, mountpoint);
16594     if (r == -1)
16595       return -1;
16596   }
16597   /* TestLastFail for rm (2) */
16598   {
16599     char path[] = "/new";
16600     int r;
16601     suppress_error = 0;
16602     r = guestfs_mkdir (g, path);
16603     if (r == -1)
16604       return -1;
16605   }
16606   {
16607     char path[] = "/new";
16608     int r;
16609     suppress_error = 1;
16610     r = guestfs_rm (g, path);
16611     if (r != -1)
16612       return -1;
16613   }
16614   return 0;
16615 }
16616
16617 static int test_read_lines_0_skip (void)
16618 {
16619   const char *str;
16620
16621   str = getenv ("TEST_ONLY");
16622   if (str)
16623     return strstr (str, "read_lines") == NULL;
16624   str = getenv ("SKIP_TEST_READ_LINES_0");
16625   if (str && strcmp (str, "1") == 0) return 1;
16626   str = getenv ("SKIP_TEST_READ_LINES");
16627   if (str && strcmp (str, "1") == 0) return 1;
16628   return 0;
16629 }
16630
16631 static int test_read_lines_0 (void)
16632 {
16633   if (test_read_lines_0_skip ()) {
16634     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16635     return 0;
16636   }
16637
16638   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16639   {
16640     char device[] = "/dev/sda";
16641     int r;
16642     suppress_error = 0;
16643     r = guestfs_blockdev_setrw (g, device);
16644     if (r == -1)
16645       return -1;
16646   }
16647   {
16648     int r;
16649     suppress_error = 0;
16650     r = guestfs_umount_all (g);
16651     if (r == -1)
16652       return -1;
16653   }
16654   {
16655     int r;
16656     suppress_error = 0;
16657     r = guestfs_lvm_remove_all (g);
16658     if (r == -1)
16659       return -1;
16660   }
16661   {
16662     char device[] = "/dev/sda";
16663     char lines_0[] = ",";
16664     char *lines[] = {
16665       lines_0,
16666       NULL
16667     };
16668     int r;
16669     suppress_error = 0;
16670     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16671     if (r == -1)
16672       return -1;
16673   }
16674   {
16675     char fstype[] = "ext2";
16676     char device[] = "/dev/sda1";
16677     int r;
16678     suppress_error = 0;
16679     r = guestfs_mkfs (g, fstype, device);
16680     if (r == -1)
16681       return -1;
16682   }
16683   {
16684     char device[] = "/dev/sda1";
16685     char mountpoint[] = "/";
16686     int r;
16687     suppress_error = 0;
16688     r = guestfs_mount (g, device, mountpoint);
16689     if (r == -1)
16690       return -1;
16691   }
16692   /* TestOutputList for read_lines (0) */
16693   {
16694     char path[] = "/new";
16695     char content[] = "line1\r\nline2\nline3";
16696     int r;
16697     suppress_error = 0;
16698     r = guestfs_write_file (g, path, content, 0);
16699     if (r == -1)
16700       return -1;
16701   }
16702   {
16703     char path[] = "/new";
16704     char **r;
16705     int i;
16706     suppress_error = 0;
16707     r = guestfs_read_lines (g, path);
16708     if (r == NULL)
16709       return -1;
16710     if (!r[0]) {
16711       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16712       print_strings (r);
16713       return -1;
16714     }
16715     {
16716       char expected[] = "line1";
16717       if (strcmp (r[0], expected) != 0) {
16718         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16719         return -1;
16720       }
16721     }
16722     if (!r[1]) {
16723       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16724       print_strings (r);
16725       return -1;
16726     }
16727     {
16728       char expected[] = "line2";
16729       if (strcmp (r[1], expected) != 0) {
16730         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16731         return -1;
16732       }
16733     }
16734     if (!r[2]) {
16735       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16736       print_strings (r);
16737       return -1;
16738     }
16739     {
16740       char expected[] = "line3";
16741       if (strcmp (r[2], expected) != 0) {
16742         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16743         return -1;
16744       }
16745     }
16746     if (r[3] != NULL) {
16747       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16748       print_strings (r);
16749       return -1;
16750     }
16751     for (i = 0; r[i] != NULL; ++i)
16752       free (r[i]);
16753     free (r);
16754   }
16755   return 0;
16756 }
16757
16758 static int test_read_lines_1_skip (void)
16759 {
16760   const char *str;
16761
16762   str = getenv ("TEST_ONLY");
16763   if (str)
16764     return strstr (str, "read_lines") == NULL;
16765   str = getenv ("SKIP_TEST_READ_LINES_1");
16766   if (str && strcmp (str, "1") == 0) return 1;
16767   str = getenv ("SKIP_TEST_READ_LINES");
16768   if (str && strcmp (str, "1") == 0) return 1;
16769   return 0;
16770 }
16771
16772 static int test_read_lines_1 (void)
16773 {
16774   if (test_read_lines_1_skip ()) {
16775     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16776     return 0;
16777   }
16778
16779   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16780   {
16781     char device[] = "/dev/sda";
16782     int r;
16783     suppress_error = 0;
16784     r = guestfs_blockdev_setrw (g, device);
16785     if (r == -1)
16786       return -1;
16787   }
16788   {
16789     int r;
16790     suppress_error = 0;
16791     r = guestfs_umount_all (g);
16792     if (r == -1)
16793       return -1;
16794   }
16795   {
16796     int r;
16797     suppress_error = 0;
16798     r = guestfs_lvm_remove_all (g);
16799     if (r == -1)
16800       return -1;
16801   }
16802   {
16803     char device[] = "/dev/sda";
16804     char lines_0[] = ",";
16805     char *lines[] = {
16806       lines_0,
16807       NULL
16808     };
16809     int r;
16810     suppress_error = 0;
16811     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16812     if (r == -1)
16813       return -1;
16814   }
16815   {
16816     char fstype[] = "ext2";
16817     char device[] = "/dev/sda1";
16818     int r;
16819     suppress_error = 0;
16820     r = guestfs_mkfs (g, fstype, device);
16821     if (r == -1)
16822       return -1;
16823   }
16824   {
16825     char device[] = "/dev/sda1";
16826     char mountpoint[] = "/";
16827     int r;
16828     suppress_error = 0;
16829     r = guestfs_mount (g, device, mountpoint);
16830     if (r == -1)
16831       return -1;
16832   }
16833   /* TestOutputList for read_lines (1) */
16834   {
16835     char path[] = "/new";
16836     char content[] = "";
16837     int r;
16838     suppress_error = 0;
16839     r = guestfs_write_file (g, path, content, 0);
16840     if (r == -1)
16841       return -1;
16842   }
16843   {
16844     char path[] = "/new";
16845     char **r;
16846     int i;
16847     suppress_error = 0;
16848     r = guestfs_read_lines (g, path);
16849     if (r == NULL)
16850       return -1;
16851     if (r[0] != NULL) {
16852       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
16853       print_strings (r);
16854       return -1;
16855     }
16856     for (i = 0; r[i] != NULL; ++i)
16857       free (r[i]);
16858     free (r);
16859   }
16860   return 0;
16861 }
16862
16863 static int test_lvs_0_skip (void)
16864 {
16865   const char *str;
16866
16867   str = getenv ("TEST_ONLY");
16868   if (str)
16869     return strstr (str, "lvs") == NULL;
16870   str = getenv ("SKIP_TEST_LVS_0");
16871   if (str && strcmp (str, "1") == 0) return 1;
16872   str = getenv ("SKIP_TEST_LVS");
16873   if (str && strcmp (str, "1") == 0) return 1;
16874   return 0;
16875 }
16876
16877 static int test_lvs_0 (void)
16878 {
16879   if (test_lvs_0_skip ()) {
16880     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
16881     return 0;
16882   }
16883
16884   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
16885   {
16886     char device[] = "/dev/sda";
16887     int r;
16888     suppress_error = 0;
16889     r = guestfs_blockdev_setrw (g, device);
16890     if (r == -1)
16891       return -1;
16892   }
16893   {
16894     int r;
16895     suppress_error = 0;
16896     r = guestfs_umount_all (g);
16897     if (r == -1)
16898       return -1;
16899   }
16900   {
16901     int r;
16902     suppress_error = 0;
16903     r = guestfs_lvm_remove_all (g);
16904     if (r == -1)
16905       return -1;
16906   }
16907   {
16908     char device[] = "/dev/sda";
16909     char lines_0[] = ",";
16910     char *lines[] = {
16911       lines_0,
16912       NULL
16913     };
16914     int r;
16915     suppress_error = 0;
16916     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16917     if (r == -1)
16918       return -1;
16919   }
16920   {
16921     char device[] = "/dev/sda1";
16922     int r;
16923     suppress_error = 0;
16924     r = guestfs_pvcreate (g, device);
16925     if (r == -1)
16926       return -1;
16927   }
16928   {
16929     char volgroup[] = "VG";
16930     char physvols_0[] = "/dev/sda1";
16931     char *physvols[] = {
16932       physvols_0,
16933       NULL
16934     };
16935     int r;
16936     suppress_error = 0;
16937     r = guestfs_vgcreate (g, volgroup, physvols);
16938     if (r == -1)
16939       return -1;
16940   }
16941   {
16942     char logvol[] = "LV";
16943     char volgroup[] = "VG";
16944     int r;
16945     suppress_error = 0;
16946     r = guestfs_lvcreate (g, logvol, volgroup, 8);
16947     if (r == -1)
16948       return -1;
16949   }
16950   {
16951     char fstype[] = "ext2";
16952     char device[] = "/dev/VG/LV";
16953     int r;
16954     suppress_error = 0;
16955     r = guestfs_mkfs (g, fstype, device);
16956     if (r == -1)
16957       return -1;
16958   }
16959   {
16960     char device[] = "/dev/VG/LV";
16961     char mountpoint[] = "/";
16962     int r;
16963     suppress_error = 0;
16964     r = guestfs_mount (g, device, mountpoint);
16965     if (r == -1)
16966       return -1;
16967   }
16968   /* TestOutputList for lvs (0) */
16969   {
16970     char **r;
16971     int i;
16972     suppress_error = 0;
16973     r = guestfs_lvs (g);
16974     if (r == NULL)
16975       return -1;
16976     if (!r[0]) {
16977       fprintf (stderr, "test_lvs_0: short list returned from command\n");
16978       print_strings (r);
16979       return -1;
16980     }
16981     {
16982       char expected[] = "/dev/VG/LV";
16983       if (strcmp (r[0], expected) != 0) {
16984         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16985         return -1;
16986       }
16987     }
16988     if (r[1] != NULL) {
16989       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
16990       print_strings (r);
16991       return -1;
16992     }
16993     for (i = 0; r[i] != NULL; ++i)
16994       free (r[i]);
16995     free (r);
16996   }
16997   return 0;
16998 }
16999
17000 static int test_lvs_1_skip (void)
17001 {
17002   const char *str;
17003
17004   str = getenv ("TEST_ONLY");
17005   if (str)
17006     return strstr (str, "lvs") == NULL;
17007   str = getenv ("SKIP_TEST_LVS_1");
17008   if (str && strcmp (str, "1") == 0) return 1;
17009   str = getenv ("SKIP_TEST_LVS");
17010   if (str && strcmp (str, "1") == 0) return 1;
17011   return 0;
17012 }
17013
17014 static int test_lvs_1 (void)
17015 {
17016   if (test_lvs_1_skip ()) {
17017     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
17018     return 0;
17019   }
17020
17021   /* InitNone|InitEmpty for test_lvs_1 */
17022   {
17023     char device[] = "/dev/sda";
17024     int r;
17025     suppress_error = 0;
17026     r = guestfs_blockdev_setrw (g, device);
17027     if (r == -1)
17028       return -1;
17029   }
17030   {
17031     int r;
17032     suppress_error = 0;
17033     r = guestfs_umount_all (g);
17034     if (r == -1)
17035       return -1;
17036   }
17037   {
17038     int r;
17039     suppress_error = 0;
17040     r = guestfs_lvm_remove_all (g);
17041     if (r == -1)
17042       return -1;
17043   }
17044   /* TestOutputList for lvs (1) */
17045   {
17046     char device[] = "/dev/sda";
17047     char lines_0[] = ",10";
17048     char lines_1[] = ",20";
17049     char lines_2[] = ",";
17050     char *lines[] = {
17051       lines_0,
17052       lines_1,
17053       lines_2,
17054       NULL
17055     };
17056     int r;
17057     suppress_error = 0;
17058     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17059     if (r == -1)
17060       return -1;
17061   }
17062   {
17063     char device[] = "/dev/sda1";
17064     int r;
17065     suppress_error = 0;
17066     r = guestfs_pvcreate (g, device);
17067     if (r == -1)
17068       return -1;
17069   }
17070   {
17071     char device[] = "/dev/sda2";
17072     int r;
17073     suppress_error = 0;
17074     r = guestfs_pvcreate (g, device);
17075     if (r == -1)
17076       return -1;
17077   }
17078   {
17079     char device[] = "/dev/sda3";
17080     int r;
17081     suppress_error = 0;
17082     r = guestfs_pvcreate (g, device);
17083     if (r == -1)
17084       return -1;
17085   }
17086   {
17087     char volgroup[] = "VG1";
17088     char physvols_0[] = "/dev/sda1";
17089     char physvols_1[] = "/dev/sda2";
17090     char *physvols[] = {
17091       physvols_0,
17092       physvols_1,
17093       NULL
17094     };
17095     int r;
17096     suppress_error = 0;
17097     r = guestfs_vgcreate (g, volgroup, physvols);
17098     if (r == -1)
17099       return -1;
17100   }
17101   {
17102     char volgroup[] = "VG2";
17103     char physvols_0[] = "/dev/sda3";
17104     char *physvols[] = {
17105       physvols_0,
17106       NULL
17107     };
17108     int r;
17109     suppress_error = 0;
17110     r = guestfs_vgcreate (g, volgroup, physvols);
17111     if (r == -1)
17112       return -1;
17113   }
17114   {
17115     char logvol[] = "LV1";
17116     char volgroup[] = "VG1";
17117     int r;
17118     suppress_error = 0;
17119     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17120     if (r == -1)
17121       return -1;
17122   }
17123   {
17124     char logvol[] = "LV2";
17125     char volgroup[] = "VG1";
17126     int r;
17127     suppress_error = 0;
17128     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17129     if (r == -1)
17130       return -1;
17131   }
17132   {
17133     char logvol[] = "LV3";
17134     char volgroup[] = "VG2";
17135     int r;
17136     suppress_error = 0;
17137     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17138     if (r == -1)
17139       return -1;
17140   }
17141   {
17142     char **r;
17143     int i;
17144     suppress_error = 0;
17145     r = guestfs_lvs (g);
17146     if (r == NULL)
17147       return -1;
17148     if (!r[0]) {
17149       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17150       print_strings (r);
17151       return -1;
17152     }
17153     {
17154       char expected[] = "/dev/VG1/LV1";
17155       if (strcmp (r[0], expected) != 0) {
17156         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17157         return -1;
17158       }
17159     }
17160     if (!r[1]) {
17161       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17162       print_strings (r);
17163       return -1;
17164     }
17165     {
17166       char expected[] = "/dev/VG1/LV2";
17167       if (strcmp (r[1], expected) != 0) {
17168         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17169         return -1;
17170       }
17171     }
17172     if (!r[2]) {
17173       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17174       print_strings (r);
17175       return -1;
17176     }
17177     {
17178       char expected[] = "/dev/VG2/LV3";
17179       if (strcmp (r[2], expected) != 0) {
17180         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17181         return -1;
17182       }
17183     }
17184     if (r[3] != NULL) {
17185       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17186       print_strings (r);
17187       return -1;
17188     }
17189     for (i = 0; r[i] != NULL; ++i)
17190       free (r[i]);
17191     free (r);
17192   }
17193   return 0;
17194 }
17195
17196 static int test_vgs_0_skip (void)
17197 {
17198   const char *str;
17199
17200   str = getenv ("TEST_ONLY");
17201   if (str)
17202     return strstr (str, "vgs") == NULL;
17203   str = getenv ("SKIP_TEST_VGS_0");
17204   if (str && strcmp (str, "1") == 0) return 1;
17205   str = getenv ("SKIP_TEST_VGS");
17206   if (str && strcmp (str, "1") == 0) return 1;
17207   return 0;
17208 }
17209
17210 static int test_vgs_0 (void)
17211 {
17212   if (test_vgs_0_skip ()) {
17213     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17214     return 0;
17215   }
17216
17217   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17218   {
17219     char device[] = "/dev/sda";
17220     int r;
17221     suppress_error = 0;
17222     r = guestfs_blockdev_setrw (g, device);
17223     if (r == -1)
17224       return -1;
17225   }
17226   {
17227     int r;
17228     suppress_error = 0;
17229     r = guestfs_umount_all (g);
17230     if (r == -1)
17231       return -1;
17232   }
17233   {
17234     int r;
17235     suppress_error = 0;
17236     r = guestfs_lvm_remove_all (g);
17237     if (r == -1)
17238       return -1;
17239   }
17240   {
17241     char device[] = "/dev/sda";
17242     char lines_0[] = ",";
17243     char *lines[] = {
17244       lines_0,
17245       NULL
17246     };
17247     int r;
17248     suppress_error = 0;
17249     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17250     if (r == -1)
17251       return -1;
17252   }
17253   {
17254     char device[] = "/dev/sda1";
17255     int r;
17256     suppress_error = 0;
17257     r = guestfs_pvcreate (g, device);
17258     if (r == -1)
17259       return -1;
17260   }
17261   {
17262     char volgroup[] = "VG";
17263     char physvols_0[] = "/dev/sda1";
17264     char *physvols[] = {
17265       physvols_0,
17266       NULL
17267     };
17268     int r;
17269     suppress_error = 0;
17270     r = guestfs_vgcreate (g, volgroup, physvols);
17271     if (r == -1)
17272       return -1;
17273   }
17274   {
17275     char logvol[] = "LV";
17276     char volgroup[] = "VG";
17277     int r;
17278     suppress_error = 0;
17279     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17280     if (r == -1)
17281       return -1;
17282   }
17283   {
17284     char fstype[] = "ext2";
17285     char device[] = "/dev/VG/LV";
17286     int r;
17287     suppress_error = 0;
17288     r = guestfs_mkfs (g, fstype, device);
17289     if (r == -1)
17290       return -1;
17291   }
17292   {
17293     char device[] = "/dev/VG/LV";
17294     char mountpoint[] = "/";
17295     int r;
17296     suppress_error = 0;
17297     r = guestfs_mount (g, device, mountpoint);
17298     if (r == -1)
17299       return -1;
17300   }
17301   /* TestOutputList for vgs (0) */
17302   {
17303     char **r;
17304     int i;
17305     suppress_error = 0;
17306     r = guestfs_vgs (g);
17307     if (r == NULL)
17308       return -1;
17309     if (!r[0]) {
17310       fprintf (stderr, "test_vgs_0: short list returned from command\n");
17311       print_strings (r);
17312       return -1;
17313     }
17314     {
17315       char expected[] = "VG";
17316       if (strcmp (r[0], expected) != 0) {
17317         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17318         return -1;
17319       }
17320     }
17321     if (r[1] != NULL) {
17322       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17323       print_strings (r);
17324       return -1;
17325     }
17326     for (i = 0; r[i] != NULL; ++i)
17327       free (r[i]);
17328     free (r);
17329   }
17330   return 0;
17331 }
17332
17333 static int test_vgs_1_skip (void)
17334 {
17335   const char *str;
17336
17337   str = getenv ("TEST_ONLY");
17338   if (str)
17339     return strstr (str, "vgs") == NULL;
17340   str = getenv ("SKIP_TEST_VGS_1");
17341   if (str && strcmp (str, "1") == 0) return 1;
17342   str = getenv ("SKIP_TEST_VGS");
17343   if (str && strcmp (str, "1") == 0) return 1;
17344   return 0;
17345 }
17346
17347 static int test_vgs_1 (void)
17348 {
17349   if (test_vgs_1_skip ()) {
17350     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17351     return 0;
17352   }
17353
17354   /* InitNone|InitEmpty for test_vgs_1 */
17355   {
17356     char device[] = "/dev/sda";
17357     int r;
17358     suppress_error = 0;
17359     r = guestfs_blockdev_setrw (g, device);
17360     if (r == -1)
17361       return -1;
17362   }
17363   {
17364     int r;
17365     suppress_error = 0;
17366     r = guestfs_umount_all (g);
17367     if (r == -1)
17368       return -1;
17369   }
17370   {
17371     int r;
17372     suppress_error = 0;
17373     r = guestfs_lvm_remove_all (g);
17374     if (r == -1)
17375       return -1;
17376   }
17377   /* TestOutputList for vgs (1) */
17378   {
17379     char device[] = "/dev/sda";
17380     char lines_0[] = ",10";
17381     char lines_1[] = ",20";
17382     char lines_2[] = ",";
17383     char *lines[] = {
17384       lines_0,
17385       lines_1,
17386       lines_2,
17387       NULL
17388     };
17389     int r;
17390     suppress_error = 0;
17391     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17392     if (r == -1)
17393       return -1;
17394   }
17395   {
17396     char device[] = "/dev/sda1";
17397     int r;
17398     suppress_error = 0;
17399     r = guestfs_pvcreate (g, device);
17400     if (r == -1)
17401       return -1;
17402   }
17403   {
17404     char device[] = "/dev/sda2";
17405     int r;
17406     suppress_error = 0;
17407     r = guestfs_pvcreate (g, device);
17408     if (r == -1)
17409       return -1;
17410   }
17411   {
17412     char device[] = "/dev/sda3";
17413     int r;
17414     suppress_error = 0;
17415     r = guestfs_pvcreate (g, device);
17416     if (r == -1)
17417       return -1;
17418   }
17419   {
17420     char volgroup[] = "VG1";
17421     char physvols_0[] = "/dev/sda1";
17422     char physvols_1[] = "/dev/sda2";
17423     char *physvols[] = {
17424       physvols_0,
17425       physvols_1,
17426       NULL
17427     };
17428     int r;
17429     suppress_error = 0;
17430     r = guestfs_vgcreate (g, volgroup, physvols);
17431     if (r == -1)
17432       return -1;
17433   }
17434   {
17435     char volgroup[] = "VG2";
17436     char physvols_0[] = "/dev/sda3";
17437     char *physvols[] = {
17438       physvols_0,
17439       NULL
17440     };
17441     int r;
17442     suppress_error = 0;
17443     r = guestfs_vgcreate (g, volgroup, physvols);
17444     if (r == -1)
17445       return -1;
17446   }
17447   {
17448     char **r;
17449     int i;
17450     suppress_error = 0;
17451     r = guestfs_vgs (g);
17452     if (r == NULL)
17453       return -1;
17454     if (!r[0]) {
17455       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17456       print_strings (r);
17457       return -1;
17458     }
17459     {
17460       char expected[] = "VG1";
17461       if (strcmp (r[0], expected) != 0) {
17462         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17463         return -1;
17464       }
17465     }
17466     if (!r[1]) {
17467       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17468       print_strings (r);
17469       return -1;
17470     }
17471     {
17472       char expected[] = "VG2";
17473       if (strcmp (r[1], expected) != 0) {
17474         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17475         return -1;
17476       }
17477     }
17478     if (r[2] != NULL) {
17479       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17480       print_strings (r);
17481       return -1;
17482     }
17483     for (i = 0; r[i] != NULL; ++i)
17484       free (r[i]);
17485     free (r);
17486   }
17487   return 0;
17488 }
17489
17490 static int test_pvs_0_skip (void)
17491 {
17492   const char *str;
17493
17494   str = getenv ("TEST_ONLY");
17495   if (str)
17496     return strstr (str, "pvs") == NULL;
17497   str = getenv ("SKIP_TEST_PVS_0");
17498   if (str && strcmp (str, "1") == 0) return 1;
17499   str = getenv ("SKIP_TEST_PVS");
17500   if (str && strcmp (str, "1") == 0) return 1;
17501   return 0;
17502 }
17503
17504 static int test_pvs_0 (void)
17505 {
17506   if (test_pvs_0_skip ()) {
17507     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17508     return 0;
17509   }
17510
17511   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17512   {
17513     char device[] = "/dev/sda";
17514     int r;
17515     suppress_error = 0;
17516     r = guestfs_blockdev_setrw (g, device);
17517     if (r == -1)
17518       return -1;
17519   }
17520   {
17521     int r;
17522     suppress_error = 0;
17523     r = guestfs_umount_all (g);
17524     if (r == -1)
17525       return -1;
17526   }
17527   {
17528     int r;
17529     suppress_error = 0;
17530     r = guestfs_lvm_remove_all (g);
17531     if (r == -1)
17532       return -1;
17533   }
17534   {
17535     char device[] = "/dev/sda";
17536     char lines_0[] = ",";
17537     char *lines[] = {
17538       lines_0,
17539       NULL
17540     };
17541     int r;
17542     suppress_error = 0;
17543     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17544     if (r == -1)
17545       return -1;
17546   }
17547   {
17548     char device[] = "/dev/sda1";
17549     int r;
17550     suppress_error = 0;
17551     r = guestfs_pvcreate (g, device);
17552     if (r == -1)
17553       return -1;
17554   }
17555   {
17556     char volgroup[] = "VG";
17557     char physvols_0[] = "/dev/sda1";
17558     char *physvols[] = {
17559       physvols_0,
17560       NULL
17561     };
17562     int r;
17563     suppress_error = 0;
17564     r = guestfs_vgcreate (g, volgroup, physvols);
17565     if (r == -1)
17566       return -1;
17567   }
17568   {
17569     char logvol[] = "LV";
17570     char volgroup[] = "VG";
17571     int r;
17572     suppress_error = 0;
17573     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17574     if (r == -1)
17575       return -1;
17576   }
17577   {
17578     char fstype[] = "ext2";
17579     char device[] = "/dev/VG/LV";
17580     int r;
17581     suppress_error = 0;
17582     r = guestfs_mkfs (g, fstype, device);
17583     if (r == -1)
17584       return -1;
17585   }
17586   {
17587     char device[] = "/dev/VG/LV";
17588     char mountpoint[] = "/";
17589     int r;
17590     suppress_error = 0;
17591     r = guestfs_mount (g, device, mountpoint);
17592     if (r == -1)
17593       return -1;
17594   }
17595   /* TestOutputListOfDevices for pvs (0) */
17596   {
17597     char **r;
17598     int i;
17599     suppress_error = 0;
17600     r = guestfs_pvs (g);
17601     if (r == NULL)
17602       return -1;
17603     if (!r[0]) {
17604       fprintf (stderr, "test_pvs_0: short list returned from command\n");
17605       print_strings (r);
17606       return -1;
17607     }
17608     {
17609       char expected[] = "/dev/sda1";
17610       r[0][5] = 's';
17611       if (strcmp (r[0], expected) != 0) {
17612         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17613         return -1;
17614       }
17615     }
17616     if (r[1] != NULL) {
17617       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17618       print_strings (r);
17619       return -1;
17620     }
17621     for (i = 0; r[i] != NULL; ++i)
17622       free (r[i]);
17623     free (r);
17624   }
17625   return 0;
17626 }
17627
17628 static int test_pvs_1_skip (void)
17629 {
17630   const char *str;
17631
17632   str = getenv ("TEST_ONLY");
17633   if (str)
17634     return strstr (str, "pvs") == NULL;
17635   str = getenv ("SKIP_TEST_PVS_1");
17636   if (str && strcmp (str, "1") == 0) return 1;
17637   str = getenv ("SKIP_TEST_PVS");
17638   if (str && strcmp (str, "1") == 0) return 1;
17639   return 0;
17640 }
17641
17642 static int test_pvs_1 (void)
17643 {
17644   if (test_pvs_1_skip ()) {
17645     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17646     return 0;
17647   }
17648
17649   /* InitNone|InitEmpty for test_pvs_1 */
17650   {
17651     char device[] = "/dev/sda";
17652     int r;
17653     suppress_error = 0;
17654     r = guestfs_blockdev_setrw (g, device);
17655     if (r == -1)
17656       return -1;
17657   }
17658   {
17659     int r;
17660     suppress_error = 0;
17661     r = guestfs_umount_all (g);
17662     if (r == -1)
17663       return -1;
17664   }
17665   {
17666     int r;
17667     suppress_error = 0;
17668     r = guestfs_lvm_remove_all (g);
17669     if (r == -1)
17670       return -1;
17671   }
17672   /* TestOutputListOfDevices for pvs (1) */
17673   {
17674     char device[] = "/dev/sda";
17675     char lines_0[] = ",10";
17676     char lines_1[] = ",20";
17677     char lines_2[] = ",";
17678     char *lines[] = {
17679       lines_0,
17680       lines_1,
17681       lines_2,
17682       NULL
17683     };
17684     int r;
17685     suppress_error = 0;
17686     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17687     if (r == -1)
17688       return -1;
17689   }
17690   {
17691     char device[] = "/dev/sda1";
17692     int r;
17693     suppress_error = 0;
17694     r = guestfs_pvcreate (g, device);
17695     if (r == -1)
17696       return -1;
17697   }
17698   {
17699     char device[] = "/dev/sda2";
17700     int r;
17701     suppress_error = 0;
17702     r = guestfs_pvcreate (g, device);
17703     if (r == -1)
17704       return -1;
17705   }
17706   {
17707     char device[] = "/dev/sda3";
17708     int r;
17709     suppress_error = 0;
17710     r = guestfs_pvcreate (g, device);
17711     if (r == -1)
17712       return -1;
17713   }
17714   {
17715     char **r;
17716     int i;
17717     suppress_error = 0;
17718     r = guestfs_pvs (g);
17719     if (r == NULL)
17720       return -1;
17721     if (!r[0]) {
17722       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17723       print_strings (r);
17724       return -1;
17725     }
17726     {
17727       char expected[] = "/dev/sda1";
17728       r[0][5] = 's';
17729       if (strcmp (r[0], expected) != 0) {
17730         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17731         return -1;
17732       }
17733     }
17734     if (!r[1]) {
17735       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17736       print_strings (r);
17737       return -1;
17738     }
17739     {
17740       char expected[] = "/dev/sda2";
17741       r[1][5] = 's';
17742       if (strcmp (r[1], expected) != 0) {
17743         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17744         return -1;
17745       }
17746     }
17747     if (!r[2]) {
17748       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17749       print_strings (r);
17750       return -1;
17751     }
17752     {
17753       char expected[] = "/dev/sda3";
17754       r[2][5] = 's';
17755       if (strcmp (r[2], expected) != 0) {
17756         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17757         return -1;
17758       }
17759     }
17760     if (r[3] != NULL) {
17761       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17762       print_strings (r);
17763       return -1;
17764     }
17765     for (i = 0; r[i] != NULL; ++i)
17766       free (r[i]);
17767     free (r);
17768   }
17769   return 0;
17770 }
17771
17772 static int test_list_partitions_0_skip (void)
17773 {
17774   const char *str;
17775
17776   str = getenv ("TEST_ONLY");
17777   if (str)
17778     return strstr (str, "list_partitions") == NULL;
17779   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17780   if (str && strcmp (str, "1") == 0) return 1;
17781   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17782   if (str && strcmp (str, "1") == 0) return 1;
17783   return 0;
17784 }
17785
17786 static int test_list_partitions_0 (void)
17787 {
17788   if (test_list_partitions_0_skip ()) {
17789     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
17790     return 0;
17791   }
17792
17793   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
17794   {
17795     char device[] = "/dev/sda";
17796     int r;
17797     suppress_error = 0;
17798     r = guestfs_blockdev_setrw (g, device);
17799     if (r == -1)
17800       return -1;
17801   }
17802   {
17803     int r;
17804     suppress_error = 0;
17805     r = guestfs_umount_all (g);
17806     if (r == -1)
17807       return -1;
17808   }
17809   {
17810     int r;
17811     suppress_error = 0;
17812     r = guestfs_lvm_remove_all (g);
17813     if (r == -1)
17814       return -1;
17815   }
17816   {
17817     char device[] = "/dev/sda";
17818     char lines_0[] = ",";
17819     char *lines[] = {
17820       lines_0,
17821       NULL
17822     };
17823     int r;
17824     suppress_error = 0;
17825     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17826     if (r == -1)
17827       return -1;
17828   }
17829   {
17830     char fstype[] = "ext2";
17831     char device[] = "/dev/sda1";
17832     int r;
17833     suppress_error = 0;
17834     r = guestfs_mkfs (g, fstype, device);
17835     if (r == -1)
17836       return -1;
17837   }
17838   {
17839     char device[] = "/dev/sda1";
17840     char mountpoint[] = "/";
17841     int r;
17842     suppress_error = 0;
17843     r = guestfs_mount (g, device, mountpoint);
17844     if (r == -1)
17845       return -1;
17846   }
17847   /* TestOutputListOfDevices for list_partitions (0) */
17848   {
17849     char **r;
17850     int i;
17851     suppress_error = 0;
17852     r = guestfs_list_partitions (g);
17853     if (r == NULL)
17854       return -1;
17855     if (!r[0]) {
17856       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
17857       print_strings (r);
17858       return -1;
17859     }
17860     {
17861       char expected[] = "/dev/sda1";
17862       r[0][5] = 's';
17863       if (strcmp (r[0], expected) != 0) {
17864         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17865         return -1;
17866       }
17867     }
17868     if (r[1] != NULL) {
17869       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
17870       print_strings (r);
17871       return -1;
17872     }
17873     for (i = 0; r[i] != NULL; ++i)
17874       free (r[i]);
17875     free (r);
17876   }
17877   return 0;
17878 }
17879
17880 static int test_list_partitions_1_skip (void)
17881 {
17882   const char *str;
17883
17884   str = getenv ("TEST_ONLY");
17885   if (str)
17886     return strstr (str, "list_partitions") == NULL;
17887   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
17888   if (str && strcmp (str, "1") == 0) return 1;
17889   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17890   if (str && strcmp (str, "1") == 0) return 1;
17891   return 0;
17892 }
17893
17894 static int test_list_partitions_1 (void)
17895 {
17896   if (test_list_partitions_1_skip ()) {
17897     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
17898     return 0;
17899   }
17900
17901   /* InitNone|InitEmpty for test_list_partitions_1 */
17902   {
17903     char device[] = "/dev/sda";
17904     int r;
17905     suppress_error = 0;
17906     r = guestfs_blockdev_setrw (g, device);
17907     if (r == -1)
17908       return -1;
17909   }
17910   {
17911     int r;
17912     suppress_error = 0;
17913     r = guestfs_umount_all (g);
17914     if (r == -1)
17915       return -1;
17916   }
17917   {
17918     int r;
17919     suppress_error = 0;
17920     r = guestfs_lvm_remove_all (g);
17921     if (r == -1)
17922       return -1;
17923   }
17924   /* TestOutputListOfDevices for list_partitions (1) */
17925   {
17926     char device[] = "/dev/sda";
17927     char lines_0[] = ",10";
17928     char lines_1[] = ",20";
17929     char lines_2[] = ",";
17930     char *lines[] = {
17931       lines_0,
17932       lines_1,
17933       lines_2,
17934       NULL
17935     };
17936     int r;
17937     suppress_error = 0;
17938     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17939     if (r == -1)
17940       return -1;
17941   }
17942   {
17943     char **r;
17944     int i;
17945     suppress_error = 0;
17946     r = guestfs_list_partitions (g);
17947     if (r == NULL)
17948       return -1;
17949     if (!r[0]) {
17950       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17951       print_strings (r);
17952       return -1;
17953     }
17954     {
17955       char expected[] = "/dev/sda1";
17956       r[0][5] = 's';
17957       if (strcmp (r[0], expected) != 0) {
17958         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17959         return -1;
17960       }
17961     }
17962     if (!r[1]) {
17963       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17964       print_strings (r);
17965       return -1;
17966     }
17967     {
17968       char expected[] = "/dev/sda2";
17969       r[1][5] = 's';
17970       if (strcmp (r[1], expected) != 0) {
17971         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17972         return -1;
17973       }
17974     }
17975     if (!r[2]) {
17976       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17977       print_strings (r);
17978       return -1;
17979     }
17980     {
17981       char expected[] = "/dev/sda3";
17982       r[2][5] = 's';
17983       if (strcmp (r[2], expected) != 0) {
17984         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17985         return -1;
17986       }
17987     }
17988     if (r[3] != NULL) {
17989       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
17990       print_strings (r);
17991       return -1;
17992     }
17993     for (i = 0; r[i] != NULL; ++i)
17994       free (r[i]);
17995     free (r);
17996   }
17997   return 0;
17998 }
17999
18000 static int test_list_devices_0_skip (void)
18001 {
18002   const char *str;
18003
18004   str = getenv ("TEST_ONLY");
18005   if (str)
18006     return strstr (str, "list_devices") == NULL;
18007   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18008   if (str && strcmp (str, "1") == 0) return 1;
18009   str = getenv ("SKIP_TEST_LIST_DEVICES");
18010   if (str && strcmp (str, "1") == 0) return 1;
18011   return 0;
18012 }
18013
18014 static int test_list_devices_0 (void)
18015 {
18016   if (test_list_devices_0_skip ()) {
18017     printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
18018     return 0;
18019   }
18020
18021   /* InitNone|InitEmpty for test_list_devices_0 */
18022   {
18023     char device[] = "/dev/sda";
18024     int r;
18025     suppress_error = 0;
18026     r = guestfs_blockdev_setrw (g, device);
18027     if (r == -1)
18028       return -1;
18029   }
18030   {
18031     int r;
18032     suppress_error = 0;
18033     r = guestfs_umount_all (g);
18034     if (r == -1)
18035       return -1;
18036   }
18037   {
18038     int r;
18039     suppress_error = 0;
18040     r = guestfs_lvm_remove_all (g);
18041     if (r == -1)
18042       return -1;
18043   }
18044   /* TestOutputListOfDevices for list_devices (0) */
18045   {
18046     char **r;
18047     int i;
18048     suppress_error = 0;
18049     r = guestfs_list_devices (g);
18050     if (r == NULL)
18051       return -1;
18052     if (!r[0]) {
18053       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18054       print_strings (r);
18055       return -1;
18056     }
18057     {
18058       char expected[] = "/dev/sda";
18059       r[0][5] = 's';
18060       if (strcmp (r[0], expected) != 0) {
18061         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18062         return -1;
18063       }
18064     }
18065     if (!r[1]) {
18066       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18067       print_strings (r);
18068       return -1;
18069     }
18070     {
18071       char expected[] = "/dev/sdb";
18072       r[1][5] = 's';
18073       if (strcmp (r[1], expected) != 0) {
18074         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18075         return -1;
18076       }
18077     }
18078     if (!r[2]) {
18079       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18080       print_strings (r);
18081       return -1;
18082     }
18083     {
18084       char expected[] = "/dev/sdc";
18085       r[2][5] = 's';
18086       if (strcmp (r[2], expected) != 0) {
18087         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18088         return -1;
18089       }
18090     }
18091     if (!r[3]) {
18092       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18093       print_strings (r);
18094       return -1;
18095     }
18096     {
18097       char expected[] = "/dev/sdd";
18098       r[3][5] = 's';
18099       if (strcmp (r[3], expected) != 0) {
18100         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18101         return -1;
18102       }
18103     }
18104     if (r[4] != NULL) {
18105       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18106       print_strings (r);
18107       return -1;
18108     }
18109     for (i = 0; r[i] != NULL; ++i)
18110       free (r[i]);
18111     free (r);
18112   }
18113   return 0;
18114 }
18115
18116 static int test_ls_0_skip (void)
18117 {
18118   const char *str;
18119
18120   str = getenv ("TEST_ONLY");
18121   if (str)
18122     return strstr (str, "ls") == NULL;
18123   str = getenv ("SKIP_TEST_LS_0");
18124   if (str && strcmp (str, "1") == 0) return 1;
18125   str = getenv ("SKIP_TEST_LS");
18126   if (str && strcmp (str, "1") == 0) return 1;
18127   return 0;
18128 }
18129
18130 static int test_ls_0 (void)
18131 {
18132   if (test_ls_0_skip ()) {
18133     printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
18134     return 0;
18135   }
18136
18137   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18138   {
18139     char device[] = "/dev/sda";
18140     int r;
18141     suppress_error = 0;
18142     r = guestfs_blockdev_setrw (g, device);
18143     if (r == -1)
18144       return -1;
18145   }
18146   {
18147     int r;
18148     suppress_error = 0;
18149     r = guestfs_umount_all (g);
18150     if (r == -1)
18151       return -1;
18152   }
18153   {
18154     int r;
18155     suppress_error = 0;
18156     r = guestfs_lvm_remove_all (g);
18157     if (r == -1)
18158       return -1;
18159   }
18160   {
18161     char device[] = "/dev/sda";
18162     char lines_0[] = ",";
18163     char *lines[] = {
18164       lines_0,
18165       NULL
18166     };
18167     int r;
18168     suppress_error = 0;
18169     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18170     if (r == -1)
18171       return -1;
18172   }
18173   {
18174     char fstype[] = "ext2";
18175     char device[] = "/dev/sda1";
18176     int r;
18177     suppress_error = 0;
18178     r = guestfs_mkfs (g, fstype, device);
18179     if (r == -1)
18180       return -1;
18181   }
18182   {
18183     char device[] = "/dev/sda1";
18184     char mountpoint[] = "/";
18185     int r;
18186     suppress_error = 0;
18187     r = guestfs_mount (g, device, mountpoint);
18188     if (r == -1)
18189       return -1;
18190   }
18191   /* TestOutputList for ls (0) */
18192   {
18193     char path[] = "/new";
18194     int r;
18195     suppress_error = 0;
18196     r = guestfs_touch (g, path);
18197     if (r == -1)
18198       return -1;
18199   }
18200   {
18201     char path[] = "/newer";
18202     int r;
18203     suppress_error = 0;
18204     r = guestfs_touch (g, path);
18205     if (r == -1)
18206       return -1;
18207   }
18208   {
18209     char path[] = "/newest";
18210     int r;
18211     suppress_error = 0;
18212     r = guestfs_touch (g, path);
18213     if (r == -1)
18214       return -1;
18215   }
18216   {
18217     char directory[] = "/";
18218     char **r;
18219     int i;
18220     suppress_error = 0;
18221     r = guestfs_ls (g, directory);
18222     if (r == NULL)
18223       return -1;
18224     if (!r[0]) {
18225       fprintf (stderr, "test_ls_0: short list returned from command\n");
18226       print_strings (r);
18227       return -1;
18228     }
18229     {
18230       char expected[] = "lost+found";
18231       if (strcmp (r[0], expected) != 0) {
18232         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18233         return -1;
18234       }
18235     }
18236     if (!r[1]) {
18237       fprintf (stderr, "test_ls_0: short list returned from command\n");
18238       print_strings (r);
18239       return -1;
18240     }
18241     {
18242       char expected[] = "new";
18243       if (strcmp (r[1], expected) != 0) {
18244         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18245         return -1;
18246       }
18247     }
18248     if (!r[2]) {
18249       fprintf (stderr, "test_ls_0: short list returned from command\n");
18250       print_strings (r);
18251       return -1;
18252     }
18253     {
18254       char expected[] = "newer";
18255       if (strcmp (r[2], expected) != 0) {
18256         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18257         return -1;
18258       }
18259     }
18260     if (!r[3]) {
18261       fprintf (stderr, "test_ls_0: short list returned from command\n");
18262       print_strings (r);
18263       return -1;
18264     }
18265     {
18266       char expected[] = "newest";
18267       if (strcmp (r[3], expected) != 0) {
18268         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18269         return -1;
18270       }
18271     }
18272     if (r[4] != NULL) {
18273       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18274       print_strings (r);
18275       return -1;
18276     }
18277     for (i = 0; r[i] != NULL; ++i)
18278       free (r[i]);
18279     free (r);
18280   }
18281   return 0;
18282 }
18283
18284 static int test_cat_0_skip (void)
18285 {
18286   const char *str;
18287
18288   str = getenv ("TEST_ONLY");
18289   if (str)
18290     return strstr (str, "cat") == NULL;
18291   str = getenv ("SKIP_TEST_CAT_0");
18292   if (str && strcmp (str, "1") == 0) return 1;
18293   str = getenv ("SKIP_TEST_CAT");
18294   if (str && strcmp (str, "1") == 0) return 1;
18295   return 0;
18296 }
18297
18298 static int test_cat_0 (void)
18299 {
18300   if (test_cat_0_skip ()) {
18301     printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18302     return 0;
18303   }
18304
18305   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18306   {
18307     char device[] = "/dev/sda";
18308     int r;
18309     suppress_error = 0;
18310     r = guestfs_blockdev_setrw (g, device);
18311     if (r == -1)
18312       return -1;
18313   }
18314   {
18315     int r;
18316     suppress_error = 0;
18317     r = guestfs_umount_all (g);
18318     if (r == -1)
18319       return -1;
18320   }
18321   {
18322     int r;
18323     suppress_error = 0;
18324     r = guestfs_lvm_remove_all (g);
18325     if (r == -1)
18326       return -1;
18327   }
18328   {
18329     char device[] = "/dev/sda";
18330     char lines_0[] = ",";
18331     char *lines[] = {
18332       lines_0,
18333       NULL
18334     };
18335     int r;
18336     suppress_error = 0;
18337     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18338     if (r == -1)
18339       return -1;
18340   }
18341   {
18342     char fstype[] = "ext2";
18343     char device[] = "/dev/sda1";
18344     int r;
18345     suppress_error = 0;
18346     r = guestfs_mkfs (g, fstype, device);
18347     if (r == -1)
18348       return -1;
18349   }
18350   {
18351     char device[] = "/dev/sda1";
18352     char mountpoint[] = "/";
18353     int r;
18354     suppress_error = 0;
18355     r = guestfs_mount (g, device, mountpoint);
18356     if (r == -1)
18357       return -1;
18358   }
18359   /* TestOutput for cat (0) */
18360   char expected[] = "new file contents";
18361   {
18362     char path[] = "/new";
18363     char content[] = "new file contents";
18364     int r;
18365     suppress_error = 0;
18366     r = guestfs_write_file (g, path, content, 0);
18367     if (r == -1)
18368       return -1;
18369   }
18370   {
18371     char path[] = "/new";
18372     char *r;
18373     suppress_error = 0;
18374     r = guestfs_cat (g, path);
18375     if (r == NULL)
18376       return -1;
18377     if (strcmp (r, expected) != 0) {
18378       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18379       return -1;
18380     }
18381     free (r);
18382   }
18383   return 0;
18384 }
18385
18386 static int test_touch_0_skip (void)
18387 {
18388   const char *str;
18389
18390   str = getenv ("TEST_ONLY");
18391   if (str)
18392     return strstr (str, "touch") == NULL;
18393   str = getenv ("SKIP_TEST_TOUCH_0");
18394   if (str && strcmp (str, "1") == 0) return 1;
18395   str = getenv ("SKIP_TEST_TOUCH");
18396   if (str && strcmp (str, "1") == 0) return 1;
18397   return 0;
18398 }
18399
18400 static int test_touch_0 (void)
18401 {
18402   if (test_touch_0_skip ()) {
18403     printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18404     return 0;
18405   }
18406
18407   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18408   {
18409     char device[] = "/dev/sda";
18410     int r;
18411     suppress_error = 0;
18412     r = guestfs_blockdev_setrw (g, device);
18413     if (r == -1)
18414       return -1;
18415   }
18416   {
18417     int r;
18418     suppress_error = 0;
18419     r = guestfs_umount_all (g);
18420     if (r == -1)
18421       return -1;
18422   }
18423   {
18424     int r;
18425     suppress_error = 0;
18426     r = guestfs_lvm_remove_all (g);
18427     if (r == -1)
18428       return -1;
18429   }
18430   {
18431     char device[] = "/dev/sda";
18432     char lines_0[] = ",";
18433     char *lines[] = {
18434       lines_0,
18435       NULL
18436     };
18437     int r;
18438     suppress_error = 0;
18439     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18440     if (r == -1)
18441       return -1;
18442   }
18443   {
18444     char fstype[] = "ext2";
18445     char device[] = "/dev/sda1";
18446     int r;
18447     suppress_error = 0;
18448     r = guestfs_mkfs (g, fstype, device);
18449     if (r == -1)
18450       return -1;
18451   }
18452   {
18453     char device[] = "/dev/sda1";
18454     char mountpoint[] = "/";
18455     int r;
18456     suppress_error = 0;
18457     r = guestfs_mount (g, device, mountpoint);
18458     if (r == -1)
18459       return -1;
18460   }
18461   /* TestOutputTrue for touch (0) */
18462   {
18463     char path[] = "/new";
18464     int r;
18465     suppress_error = 0;
18466     r = guestfs_touch (g, path);
18467     if (r == -1)
18468       return -1;
18469   }
18470   {
18471     char path[] = "/new";
18472     int r;
18473     suppress_error = 0;
18474     r = guestfs_exists (g, path);
18475     if (r == -1)
18476       return -1;
18477     if (!r) {
18478       fprintf (stderr, "test_touch_0: expected true, got false\n");
18479       return -1;
18480     }
18481   }
18482   return 0;
18483 }
18484
18485 static int test_sync_0_skip (void)
18486 {
18487   const char *str;
18488
18489   str = getenv ("TEST_ONLY");
18490   if (str)
18491     return strstr (str, "sync") == NULL;
18492   str = getenv ("SKIP_TEST_SYNC_0");
18493   if (str && strcmp (str, "1") == 0) return 1;
18494   str = getenv ("SKIP_TEST_SYNC");
18495   if (str && strcmp (str, "1") == 0) return 1;
18496   return 0;
18497 }
18498
18499 static int test_sync_0 (void)
18500 {
18501   if (test_sync_0_skip ()) {
18502     printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18503     return 0;
18504   }
18505
18506   /* InitNone|InitEmpty for test_sync_0 */
18507   {
18508     char device[] = "/dev/sda";
18509     int r;
18510     suppress_error = 0;
18511     r = guestfs_blockdev_setrw (g, device);
18512     if (r == -1)
18513       return -1;
18514   }
18515   {
18516     int r;
18517     suppress_error = 0;
18518     r = guestfs_umount_all (g);
18519     if (r == -1)
18520       return -1;
18521   }
18522   {
18523     int r;
18524     suppress_error = 0;
18525     r = guestfs_lvm_remove_all (g);
18526     if (r == -1)
18527       return -1;
18528   }
18529   /* TestRun for sync (0) */
18530   {
18531     int r;
18532     suppress_error = 0;
18533     r = guestfs_sync (g);
18534     if (r == -1)
18535       return -1;
18536   }
18537   return 0;
18538 }
18539
18540 static int test_mount_0_skip (void)
18541 {
18542   const char *str;
18543
18544   str = getenv ("TEST_ONLY");
18545   if (str)
18546     return strstr (str, "mount") == NULL;
18547   str = getenv ("SKIP_TEST_MOUNT_0");
18548   if (str && strcmp (str, "1") == 0) return 1;
18549   str = getenv ("SKIP_TEST_MOUNT");
18550   if (str && strcmp (str, "1") == 0) return 1;
18551   return 0;
18552 }
18553
18554 static int test_mount_0 (void)
18555 {
18556   if (test_mount_0_skip ()) {
18557     printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18558     return 0;
18559   }
18560
18561   /* InitNone|InitEmpty for test_mount_0 */
18562   {
18563     char device[] = "/dev/sda";
18564     int r;
18565     suppress_error = 0;
18566     r = guestfs_blockdev_setrw (g, device);
18567     if (r == -1)
18568       return -1;
18569   }
18570   {
18571     int r;
18572     suppress_error = 0;
18573     r = guestfs_umount_all (g);
18574     if (r == -1)
18575       return -1;
18576   }
18577   {
18578     int r;
18579     suppress_error = 0;
18580     r = guestfs_lvm_remove_all (g);
18581     if (r == -1)
18582       return -1;
18583   }
18584   /* TestOutput for mount (0) */
18585   char expected[] = "new file contents";
18586   {
18587     char device[] = "/dev/sda";
18588     char lines_0[] = ",";
18589     char *lines[] = {
18590       lines_0,
18591       NULL
18592     };
18593     int r;
18594     suppress_error = 0;
18595     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18596     if (r == -1)
18597       return -1;
18598   }
18599   {
18600     char fstype[] = "ext2";
18601     char device[] = "/dev/sda1";
18602     int r;
18603     suppress_error = 0;
18604     r = guestfs_mkfs (g, fstype, device);
18605     if (r == -1)
18606       return -1;
18607   }
18608   {
18609     char device[] = "/dev/sda1";
18610     char mountpoint[] = "/";
18611     int r;
18612     suppress_error = 0;
18613     r = guestfs_mount (g, device, mountpoint);
18614     if (r == -1)
18615       return -1;
18616   }
18617   {
18618     char path[] = "/new";
18619     char content[] = "new file contents";
18620     int r;
18621     suppress_error = 0;
18622     r = guestfs_write_file (g, path, content, 0);
18623     if (r == -1)
18624       return -1;
18625   }
18626   {
18627     char path[] = "/new";
18628     char *r;
18629     suppress_error = 0;
18630     r = guestfs_cat (g, path);
18631     if (r == NULL)
18632       return -1;
18633     if (strcmp (r, expected) != 0) {
18634       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18635       return -1;
18636     }
18637     free (r);
18638   }
18639   return 0;
18640 }
18641
18642 int main (int argc, char *argv[])
18643 {
18644   char c = 0;
18645   int failed = 0;
18646   const char *filename;
18647   int fd;
18648   int nr_tests, test_num = 0;
18649
18650   no_test_warnings ();
18651
18652   g = guestfs_create ();
18653   if (g == NULL) {
18654     printf ("guestfs_create FAILED\n");
18655     exit (1);
18656   }
18657
18658   guestfs_set_error_handler (g, print_error, NULL);
18659
18660   guestfs_set_path (g, "../appliance");
18661
18662   filename = "test1.img";
18663   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18664   if (fd == -1) {
18665     perror (filename);
18666     exit (1);
18667   }
18668   if (lseek (fd, 524288000, SEEK_SET) == -1) {
18669     perror ("lseek");
18670     close (fd);
18671     unlink (filename);
18672     exit (1);
18673   }
18674   if (write (fd, &c, 1) == -1) {
18675     perror ("write");
18676     close (fd);
18677     unlink (filename);
18678     exit (1);
18679   }
18680   if (close (fd) == -1) {
18681     perror (filename);
18682     unlink (filename);
18683     exit (1);
18684   }
18685   if (guestfs_add_drive (g, filename) == -1) {
18686     printf ("guestfs_add_drive %s FAILED\n", filename);
18687     exit (1);
18688   }
18689
18690   filename = "test2.img";
18691   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18692   if (fd == -1) {
18693     perror (filename);
18694     exit (1);
18695   }
18696   if (lseek (fd, 52428800, SEEK_SET) == -1) {
18697     perror ("lseek");
18698     close (fd);
18699     unlink (filename);
18700     exit (1);
18701   }
18702   if (write (fd, &c, 1) == -1) {
18703     perror ("write");
18704     close (fd);
18705     unlink (filename);
18706     exit (1);
18707   }
18708   if (close (fd) == -1) {
18709     perror (filename);
18710     unlink (filename);
18711     exit (1);
18712   }
18713   if (guestfs_add_drive (g, filename) == -1) {
18714     printf ("guestfs_add_drive %s FAILED\n", filename);
18715     exit (1);
18716   }
18717
18718   filename = "test3.img";
18719   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18720   if (fd == -1) {
18721     perror (filename);
18722     exit (1);
18723   }
18724   if (lseek (fd, 10485760, SEEK_SET) == -1) {
18725     perror ("lseek");
18726     close (fd);
18727     unlink (filename);
18728     exit (1);
18729   }
18730   if (write (fd, &c, 1) == -1) {
18731     perror ("write");
18732     close (fd);
18733     unlink (filename);
18734     exit (1);
18735   }
18736   if (close (fd) == -1) {
18737     perror (filename);
18738     unlink (filename);
18739     exit (1);
18740   }
18741   if (guestfs_add_drive (g, filename) == -1) {
18742     printf ("guestfs_add_drive %s FAILED\n", filename);
18743     exit (1);
18744   }
18745
18746   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18747     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18748     exit (1);
18749   }
18750
18751   if (guestfs_launch (g) == -1) {
18752     printf ("guestfs_launch FAILED\n");
18753     exit (1);
18754   }
18755
18756   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18757   alarm (600);
18758
18759   if (guestfs_wait_ready (g) == -1) {
18760     printf ("guestfs_wait_ready FAILED\n");
18761     exit (1);
18762   }
18763
18764   /* Cancel previous alarm. */
18765   alarm (0);
18766
18767   nr_tests = 166;
18768
18769   test_num++;
18770   printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
18771   if (test_initrd_list_0 () == -1) {
18772     printf ("test_initrd_list_0 FAILED\n");
18773     failed++;
18774   }
18775   test_num++;
18776   printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
18777   if (test_du_0 () == -1) {
18778     printf ("test_du_0 FAILED\n");
18779     failed++;
18780   }
18781   test_num++;
18782   printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
18783   if (test_tail_n_0 () == -1) {
18784     printf ("test_tail_n_0 FAILED\n");
18785     failed++;
18786   }
18787   test_num++;
18788   printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
18789   if (test_tail_n_1 () == -1) {
18790     printf ("test_tail_n_1 FAILED\n");
18791     failed++;
18792   }
18793   test_num++;
18794   printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
18795   if (test_tail_n_2 () == -1) {
18796     printf ("test_tail_n_2 FAILED\n");
18797     failed++;
18798   }
18799   test_num++;
18800   printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
18801   if (test_tail_0 () == -1) {
18802     printf ("test_tail_0 FAILED\n");
18803     failed++;
18804   }
18805   test_num++;
18806   printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
18807   if (test_head_n_0 () == -1) {
18808     printf ("test_head_n_0 FAILED\n");
18809     failed++;
18810   }
18811   test_num++;
18812   printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
18813   if (test_head_n_1 () == -1) {
18814     printf ("test_head_n_1 FAILED\n");
18815     failed++;
18816   }
18817   test_num++;
18818   printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
18819   if (test_head_n_2 () == -1) {
18820     printf ("test_head_n_2 FAILED\n");
18821     failed++;
18822   }
18823   test_num++;
18824   printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
18825   if (test_head_0 () == -1) {
18826     printf ("test_head_0 FAILED\n");
18827     failed++;
18828   }
18829   test_num++;
18830   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
18831   if (test_wc_c_0 () == -1) {
18832     printf ("test_wc_c_0 FAILED\n");
18833     failed++;
18834   }
18835   test_num++;
18836   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
18837   if (test_wc_w_0 () == -1) {
18838     printf ("test_wc_w_0 FAILED\n");
18839     failed++;
18840   }
18841   test_num++;
18842   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
18843   if (test_wc_l_0 () == -1) {
18844     printf ("test_wc_l_0 FAILED\n");
18845     failed++;
18846   }
18847   test_num++;
18848   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
18849   if (test_mkdtemp_0 () == -1) {
18850     printf ("test_mkdtemp_0 FAILED\n");
18851     failed++;
18852   }
18853   test_num++;
18854   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
18855   if (test_scrub_file_0 () == -1) {
18856     printf ("test_scrub_file_0 FAILED\n");
18857     failed++;
18858   }
18859   test_num++;
18860   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
18861   if (test_scrub_device_0 () == -1) {
18862     printf ("test_scrub_device_0 FAILED\n");
18863     failed++;
18864   }
18865   test_num++;
18866   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
18867   if (test_glob_expand_0 () == -1) {
18868     printf ("test_glob_expand_0 FAILED\n");
18869     failed++;
18870   }
18871   test_num++;
18872   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
18873   if (test_glob_expand_1 () == -1) {
18874     printf ("test_glob_expand_1 FAILED\n");
18875     failed++;
18876   }
18877   test_num++;
18878   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
18879   if (test_glob_expand_2 () == -1) {
18880     printf ("test_glob_expand_2 FAILED\n");
18881     failed++;
18882   }
18883   test_num++;
18884   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
18885   if (test_ntfs_3g_probe_0 () == -1) {
18886     printf ("test_ntfs_3g_probe_0 FAILED\n");
18887     failed++;
18888   }
18889   test_num++;
18890   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
18891   if (test_ntfs_3g_probe_1 () == -1) {
18892     printf ("test_ntfs_3g_probe_1 FAILED\n");
18893     failed++;
18894   }
18895   test_num++;
18896   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
18897   if (test_sleep_0 () == -1) {
18898     printf ("test_sleep_0 FAILED\n");
18899     failed++;
18900   }
18901   test_num++;
18902   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
18903   if (test_find_0 () == -1) {
18904     printf ("test_find_0 FAILED\n");
18905     failed++;
18906   }
18907   test_num++;
18908   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
18909   if (test_find_1 () == -1) {
18910     printf ("test_find_1 FAILED\n");
18911     failed++;
18912   }
18913   test_num++;
18914   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
18915   if (test_find_2 () == -1) {
18916     printf ("test_find_2 FAILED\n");
18917     failed++;
18918   }
18919   test_num++;
18920   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
18921   if (test_lvresize_0 () == -1) {
18922     printf ("test_lvresize_0 FAILED\n");
18923     failed++;
18924   }
18925   test_num++;
18926   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
18927   if (test_zerofree_0 () == -1) {
18928     printf ("test_zerofree_0 FAILED\n");
18929     failed++;
18930   }
18931   test_num++;
18932   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
18933   if (test_hexdump_0 () == -1) {
18934     printf ("test_hexdump_0 FAILED\n");
18935     failed++;
18936   }
18937   test_num++;
18938   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
18939   if (test_hexdump_1 () == -1) {
18940     printf ("test_hexdump_1 FAILED\n");
18941     failed++;
18942   }
18943   test_num++;
18944   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
18945   if (test_strings_e_0 () == -1) {
18946     printf ("test_strings_e_0 FAILED\n");
18947     failed++;
18948   }
18949   test_num++;
18950   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
18951   if (test_strings_e_1 () == -1) {
18952     printf ("test_strings_e_1 FAILED\n");
18953     failed++;
18954   }
18955   test_num++;
18956   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
18957   if (test_strings_0 () == -1) {
18958     printf ("test_strings_0 FAILED\n");
18959     failed++;
18960   }
18961   test_num++;
18962   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
18963   if (test_strings_1 () == -1) {
18964     printf ("test_strings_1 FAILED\n");
18965     failed++;
18966   }
18967   test_num++;
18968   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
18969   if (test_equal_0 () == -1) {
18970     printf ("test_equal_0 FAILED\n");
18971     failed++;
18972   }
18973   test_num++;
18974   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
18975   if (test_equal_1 () == -1) {
18976     printf ("test_equal_1 FAILED\n");
18977     failed++;
18978   }
18979   test_num++;
18980   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
18981   if (test_equal_2 () == -1) {
18982     printf ("test_equal_2 FAILED\n");
18983     failed++;
18984   }
18985   test_num++;
18986   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
18987   if (test_ping_daemon_0 () == -1) {
18988     printf ("test_ping_daemon_0 FAILED\n");
18989     failed++;
18990   }
18991   test_num++;
18992   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
18993   if (test_dmesg_0 () == -1) {
18994     printf ("test_dmesg_0 FAILED\n");
18995     failed++;
18996   }
18997   test_num++;
18998   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
18999   if (test_drop_caches_0 () == -1) {
19000     printf ("test_drop_caches_0 FAILED\n");
19001     failed++;
19002   }
19003   test_num++;
19004   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19005   if (test_mv_0 () == -1) {
19006     printf ("test_mv_0 FAILED\n");
19007     failed++;
19008   }
19009   test_num++;
19010   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19011   if (test_mv_1 () == -1) {
19012     printf ("test_mv_1 FAILED\n");
19013     failed++;
19014   }
19015   test_num++;
19016   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19017   if (test_cp_a_0 () == -1) {
19018     printf ("test_cp_a_0 FAILED\n");
19019     failed++;
19020   }
19021   test_num++;
19022   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19023   if (test_cp_0 () == -1) {
19024     printf ("test_cp_0 FAILED\n");
19025     failed++;
19026   }
19027   test_num++;
19028   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19029   if (test_cp_1 () == -1) {
19030     printf ("test_cp_1 FAILED\n");
19031     failed++;
19032   }
19033   test_num++;
19034   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19035   if (test_cp_2 () == -1) {
19036     printf ("test_cp_2 FAILED\n");
19037     failed++;
19038   }
19039   test_num++;
19040   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19041   if (test_grub_install_0 () == -1) {
19042     printf ("test_grub_install_0 FAILED\n");
19043     failed++;
19044   }
19045   test_num++;
19046   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19047   if (test_zero_0 () == -1) {
19048     printf ("test_zero_0 FAILED\n");
19049     failed++;
19050   }
19051   test_num++;
19052   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19053   if (test_fsck_0 () == -1) {
19054     printf ("test_fsck_0 FAILED\n");
19055     failed++;
19056   }
19057   test_num++;
19058   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19059   if (test_fsck_1 () == -1) {
19060     printf ("test_fsck_1 FAILED\n");
19061     failed++;
19062   }
19063   test_num++;
19064   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19065   if (test_set_e2uuid_0 () == -1) {
19066     printf ("test_set_e2uuid_0 FAILED\n");
19067     failed++;
19068   }
19069   test_num++;
19070   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19071   if (test_set_e2uuid_1 () == -1) {
19072     printf ("test_set_e2uuid_1 FAILED\n");
19073     failed++;
19074   }
19075   test_num++;
19076   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19077   if (test_set_e2uuid_2 () == -1) {
19078     printf ("test_set_e2uuid_2 FAILED\n");
19079     failed++;
19080   }
19081   test_num++;
19082   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19083   if (test_set_e2uuid_3 () == -1) {
19084     printf ("test_set_e2uuid_3 FAILED\n");
19085     failed++;
19086   }
19087   test_num++;
19088   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19089   if (test_set_e2label_0 () == -1) {
19090     printf ("test_set_e2label_0 FAILED\n");
19091     failed++;
19092   }
19093   test_num++;
19094   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19095   if (test_pvremove_0 () == -1) {
19096     printf ("test_pvremove_0 FAILED\n");
19097     failed++;
19098   }
19099   test_num++;
19100   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19101   if (test_pvremove_1 () == -1) {
19102     printf ("test_pvremove_1 FAILED\n");
19103     failed++;
19104   }
19105   test_num++;
19106   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19107   if (test_pvremove_2 () == -1) {
19108     printf ("test_pvremove_2 FAILED\n");
19109     failed++;
19110   }
19111   test_num++;
19112   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19113   if (test_vgremove_0 () == -1) {
19114     printf ("test_vgremove_0 FAILED\n");
19115     failed++;
19116   }
19117   test_num++;
19118   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19119   if (test_vgremove_1 () == -1) {
19120     printf ("test_vgremove_1 FAILED\n");
19121     failed++;
19122   }
19123   test_num++;
19124   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19125   if (test_lvremove_0 () == -1) {
19126     printf ("test_lvremove_0 FAILED\n");
19127     failed++;
19128   }
19129   test_num++;
19130   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19131   if (test_lvremove_1 () == -1) {
19132     printf ("test_lvremove_1 FAILED\n");
19133     failed++;
19134   }
19135   test_num++;
19136   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19137   if (test_lvremove_2 () == -1) {
19138     printf ("test_lvremove_2 FAILED\n");
19139     failed++;
19140   }
19141   test_num++;
19142   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19143   if (test_mount_ro_0 () == -1) {
19144     printf ("test_mount_ro_0 FAILED\n");
19145     failed++;
19146   }
19147   test_num++;
19148   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19149   if (test_mount_ro_1 () == -1) {
19150     printf ("test_mount_ro_1 FAILED\n");
19151     failed++;
19152   }
19153   test_num++;
19154   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19155   if (test_tgz_in_0 () == -1) {
19156     printf ("test_tgz_in_0 FAILED\n");
19157     failed++;
19158   }
19159   test_num++;
19160   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19161   if (test_tar_in_0 () == -1) {
19162     printf ("test_tar_in_0 FAILED\n");
19163     failed++;
19164   }
19165   test_num++;
19166   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19167   if (test_checksum_0 () == -1) {
19168     printf ("test_checksum_0 FAILED\n");
19169     failed++;
19170   }
19171   test_num++;
19172   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19173   if (test_checksum_1 () == -1) {
19174     printf ("test_checksum_1 FAILED\n");
19175     failed++;
19176   }
19177   test_num++;
19178   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19179   if (test_checksum_2 () == -1) {
19180     printf ("test_checksum_2 FAILED\n");
19181     failed++;
19182   }
19183   test_num++;
19184   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19185   if (test_checksum_3 () == -1) {
19186     printf ("test_checksum_3 FAILED\n");
19187     failed++;
19188   }
19189   test_num++;
19190   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19191   if (test_checksum_4 () == -1) {
19192     printf ("test_checksum_4 FAILED\n");
19193     failed++;
19194   }
19195   test_num++;
19196   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19197   if (test_checksum_5 () == -1) {
19198     printf ("test_checksum_5 FAILED\n");
19199     failed++;
19200   }
19201   test_num++;
19202   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19203   if (test_checksum_6 () == -1) {
19204     printf ("test_checksum_6 FAILED\n");
19205     failed++;
19206   }
19207   test_num++;
19208   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19209   if (test_checksum_7 () == -1) {
19210     printf ("test_checksum_7 FAILED\n");
19211     failed++;
19212   }
19213   test_num++;
19214   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19215   if (test_checksum_8 () == -1) {
19216     printf ("test_checksum_8 FAILED\n");
19217     failed++;
19218   }
19219   test_num++;
19220   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19221   if (test_download_0 () == -1) {
19222     printf ("test_download_0 FAILED\n");
19223     failed++;
19224   }
19225   test_num++;
19226   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19227   if (test_upload_0 () == -1) {
19228     printf ("test_upload_0 FAILED\n");
19229     failed++;
19230   }
19231   test_num++;
19232   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19233   if (test_blockdev_rereadpt_0 () == -1) {
19234     printf ("test_blockdev_rereadpt_0 FAILED\n");
19235     failed++;
19236   }
19237   test_num++;
19238   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19239   if (test_blockdev_flushbufs_0 () == -1) {
19240     printf ("test_blockdev_flushbufs_0 FAILED\n");
19241     failed++;
19242   }
19243   test_num++;
19244   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19245   if (test_blockdev_getsize64_0 () == -1) {
19246     printf ("test_blockdev_getsize64_0 FAILED\n");
19247     failed++;
19248   }
19249   test_num++;
19250   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19251   if (test_blockdev_getsz_0 () == -1) {
19252     printf ("test_blockdev_getsz_0 FAILED\n");
19253     failed++;
19254   }
19255   test_num++;
19256   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19257   if (test_blockdev_getbsz_0 () == -1) {
19258     printf ("test_blockdev_getbsz_0 FAILED\n");
19259     failed++;
19260   }
19261   test_num++;
19262   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19263   if (test_blockdev_getss_0 () == -1) {
19264     printf ("test_blockdev_getss_0 FAILED\n");
19265     failed++;
19266   }
19267   test_num++;
19268   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19269   if (test_blockdev_getro_0 () == -1) {
19270     printf ("test_blockdev_getro_0 FAILED\n");
19271     failed++;
19272   }
19273   test_num++;
19274   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19275   if (test_blockdev_setrw_0 () == -1) {
19276     printf ("test_blockdev_setrw_0 FAILED\n");
19277     failed++;
19278   }
19279   test_num++;
19280   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19281   if (test_blockdev_setro_0 () == -1) {
19282     printf ("test_blockdev_setro_0 FAILED\n");
19283     failed++;
19284   }
19285   test_num++;
19286   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19287   if (test_statvfs_0 () == -1) {
19288     printf ("test_statvfs_0 FAILED\n");
19289     failed++;
19290   }
19291   test_num++;
19292   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19293   if (test_lstat_0 () == -1) {
19294     printf ("test_lstat_0 FAILED\n");
19295     failed++;
19296   }
19297   test_num++;
19298   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19299   if (test_stat_0 () == -1) {
19300     printf ("test_stat_0 FAILED\n");
19301     failed++;
19302   }
19303   test_num++;
19304   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19305   if (test_command_lines_0 () == -1) {
19306     printf ("test_command_lines_0 FAILED\n");
19307     failed++;
19308   }
19309   test_num++;
19310   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19311   if (test_command_lines_1 () == -1) {
19312     printf ("test_command_lines_1 FAILED\n");
19313     failed++;
19314   }
19315   test_num++;
19316   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19317   if (test_command_lines_2 () == -1) {
19318     printf ("test_command_lines_2 FAILED\n");
19319     failed++;
19320   }
19321   test_num++;
19322   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19323   if (test_command_lines_3 () == -1) {
19324     printf ("test_command_lines_3 FAILED\n");
19325     failed++;
19326   }
19327   test_num++;
19328   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19329   if (test_command_lines_4 () == -1) {
19330     printf ("test_command_lines_4 FAILED\n");
19331     failed++;
19332   }
19333   test_num++;
19334   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19335   if (test_command_lines_5 () == -1) {
19336     printf ("test_command_lines_5 FAILED\n");
19337     failed++;
19338   }
19339   test_num++;
19340   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19341   if (test_command_lines_6 () == -1) {
19342     printf ("test_command_lines_6 FAILED\n");
19343     failed++;
19344   }
19345   test_num++;
19346   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19347   if (test_command_lines_7 () == -1) {
19348     printf ("test_command_lines_7 FAILED\n");
19349     failed++;
19350   }
19351   test_num++;
19352   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19353   if (test_command_lines_8 () == -1) {
19354     printf ("test_command_lines_8 FAILED\n");
19355     failed++;
19356   }
19357   test_num++;
19358   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19359   if (test_command_lines_9 () == -1) {
19360     printf ("test_command_lines_9 FAILED\n");
19361     failed++;
19362   }
19363   test_num++;
19364   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19365   if (test_command_lines_10 () == -1) {
19366     printf ("test_command_lines_10 FAILED\n");
19367     failed++;
19368   }
19369   test_num++;
19370   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19371   if (test_command_0 () == -1) {
19372     printf ("test_command_0 FAILED\n");
19373     failed++;
19374   }
19375   test_num++;
19376   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19377   if (test_command_1 () == -1) {
19378     printf ("test_command_1 FAILED\n");
19379     failed++;
19380   }
19381   test_num++;
19382   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19383   if (test_command_2 () == -1) {
19384     printf ("test_command_2 FAILED\n");
19385     failed++;
19386   }
19387   test_num++;
19388   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19389   if (test_command_3 () == -1) {
19390     printf ("test_command_3 FAILED\n");
19391     failed++;
19392   }
19393   test_num++;
19394   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19395   if (test_command_4 () == -1) {
19396     printf ("test_command_4 FAILED\n");
19397     failed++;
19398   }
19399   test_num++;
19400   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19401   if (test_command_5 () == -1) {
19402     printf ("test_command_5 FAILED\n");
19403     failed++;
19404   }
19405   test_num++;
19406   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19407   if (test_command_6 () == -1) {
19408     printf ("test_command_6 FAILED\n");
19409     failed++;
19410   }
19411   test_num++;
19412   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19413   if (test_command_7 () == -1) {
19414     printf ("test_command_7 FAILED\n");
19415     failed++;
19416   }
19417   test_num++;
19418   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19419   if (test_command_8 () == -1) {
19420     printf ("test_command_8 FAILED\n");
19421     failed++;
19422   }
19423   test_num++;
19424   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19425   if (test_command_9 () == -1) {
19426     printf ("test_command_9 FAILED\n");
19427     failed++;
19428   }
19429   test_num++;
19430   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19431   if (test_command_10 () == -1) {
19432     printf ("test_command_10 FAILED\n");
19433     failed++;
19434   }
19435   test_num++;
19436   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19437   if (test_command_11 () == -1) {
19438     printf ("test_command_11 FAILED\n");
19439     failed++;
19440   }
19441   test_num++;
19442   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19443   if (test_file_0 () == -1) {
19444     printf ("test_file_0 FAILED\n");
19445     failed++;
19446   }
19447   test_num++;
19448   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19449   if (test_file_1 () == -1) {
19450     printf ("test_file_1 FAILED\n");
19451     failed++;
19452   }
19453   test_num++;
19454   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19455   if (test_file_2 () == -1) {
19456     printf ("test_file_2 FAILED\n");
19457     failed++;
19458   }
19459   test_num++;
19460   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19461   if (test_umount_all_0 () == -1) {
19462     printf ("test_umount_all_0 FAILED\n");
19463     failed++;
19464   }
19465   test_num++;
19466   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19467   if (test_umount_all_1 () == -1) {
19468     printf ("test_umount_all_1 FAILED\n");
19469     failed++;
19470   }
19471   test_num++;
19472   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19473   if (test_mounts_0 () == -1) {
19474     printf ("test_mounts_0 FAILED\n");
19475     failed++;
19476   }
19477   test_num++;
19478   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19479   if (test_umount_0 () == -1) {
19480     printf ("test_umount_0 FAILED\n");
19481     failed++;
19482   }
19483   test_num++;
19484   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19485   if (test_umount_1 () == -1) {
19486     printf ("test_umount_1 FAILED\n");
19487     failed++;
19488   }
19489   test_num++;
19490   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19491   if (test_write_file_0 () == -1) {
19492     printf ("test_write_file_0 FAILED\n");
19493     failed++;
19494   }
19495   test_num++;
19496   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19497   if (test_write_file_1 () == -1) {
19498     printf ("test_write_file_1 FAILED\n");
19499     failed++;
19500   }
19501   test_num++;
19502   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19503   if (test_write_file_2 () == -1) {
19504     printf ("test_write_file_2 FAILED\n");
19505     failed++;
19506   }
19507   test_num++;
19508   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19509   if (test_write_file_3 () == -1) {
19510     printf ("test_write_file_3 FAILED\n");
19511     failed++;
19512   }
19513   test_num++;
19514   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19515   if (test_write_file_4 () == -1) {
19516     printf ("test_write_file_4 FAILED\n");
19517     failed++;
19518   }
19519   test_num++;
19520   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19521   if (test_write_file_5 () == -1) {
19522     printf ("test_write_file_5 FAILED\n");
19523     failed++;
19524   }
19525   test_num++;
19526   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19527   if (test_mkfs_0 () == -1) {
19528     printf ("test_mkfs_0 FAILED\n");
19529     failed++;
19530   }
19531   test_num++;
19532   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19533   if (test_lvcreate_0 () == -1) {
19534     printf ("test_lvcreate_0 FAILED\n");
19535     failed++;
19536   }
19537   test_num++;
19538   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19539   if (test_vgcreate_0 () == -1) {
19540     printf ("test_vgcreate_0 FAILED\n");
19541     failed++;
19542   }
19543   test_num++;
19544   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19545   if (test_pvcreate_0 () == -1) {
19546     printf ("test_pvcreate_0 FAILED\n");
19547     failed++;
19548   }
19549   test_num++;
19550   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19551   if (test_is_dir_0 () == -1) {
19552     printf ("test_is_dir_0 FAILED\n");
19553     failed++;
19554   }
19555   test_num++;
19556   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19557   if (test_is_dir_1 () == -1) {
19558     printf ("test_is_dir_1 FAILED\n");
19559     failed++;
19560   }
19561   test_num++;
19562   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19563   if (test_is_file_0 () == -1) {
19564     printf ("test_is_file_0 FAILED\n");
19565     failed++;
19566   }
19567   test_num++;
19568   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19569   if (test_is_file_1 () == -1) {
19570     printf ("test_is_file_1 FAILED\n");
19571     failed++;
19572   }
19573   test_num++;
19574   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19575   if (test_exists_0 () == -1) {
19576     printf ("test_exists_0 FAILED\n");
19577     failed++;
19578   }
19579   test_num++;
19580   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19581   if (test_exists_1 () == -1) {
19582     printf ("test_exists_1 FAILED\n");
19583     failed++;
19584   }
19585   test_num++;
19586   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19587   if (test_mkdir_p_0 () == -1) {
19588     printf ("test_mkdir_p_0 FAILED\n");
19589     failed++;
19590   }
19591   test_num++;
19592   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19593   if (test_mkdir_p_1 () == -1) {
19594     printf ("test_mkdir_p_1 FAILED\n");
19595     failed++;
19596   }
19597   test_num++;
19598   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19599   if (test_mkdir_p_2 () == -1) {
19600     printf ("test_mkdir_p_2 FAILED\n");
19601     failed++;
19602   }
19603   test_num++;
19604   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19605   if (test_mkdir_p_3 () == -1) {
19606     printf ("test_mkdir_p_3 FAILED\n");
19607     failed++;
19608   }
19609   test_num++;
19610   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19611   if (test_mkdir_p_4 () == -1) {
19612     printf ("test_mkdir_p_4 FAILED\n");
19613     failed++;
19614   }
19615   test_num++;
19616   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19617   if (test_mkdir_0 () == -1) {
19618     printf ("test_mkdir_0 FAILED\n");
19619     failed++;
19620   }
19621   test_num++;
19622   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19623   if (test_mkdir_1 () == -1) {
19624     printf ("test_mkdir_1 FAILED\n");
19625     failed++;
19626   }
19627   test_num++;
19628   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19629   if (test_rm_rf_0 () == -1) {
19630     printf ("test_rm_rf_0 FAILED\n");
19631     failed++;
19632   }
19633   test_num++;
19634   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19635   if (test_rmdir_0 () == -1) {
19636     printf ("test_rmdir_0 FAILED\n");
19637     failed++;
19638   }
19639   test_num++;
19640   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19641   if (test_rmdir_1 () == -1) {
19642     printf ("test_rmdir_1 FAILED\n");
19643     failed++;
19644   }
19645   test_num++;
19646   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19647   if (test_rmdir_2 () == -1) {
19648     printf ("test_rmdir_2 FAILED\n");
19649     failed++;
19650   }
19651   test_num++;
19652   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19653   if (test_rm_0 () == -1) {
19654     printf ("test_rm_0 FAILED\n");
19655     failed++;
19656   }
19657   test_num++;
19658   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19659   if (test_rm_1 () == -1) {
19660     printf ("test_rm_1 FAILED\n");
19661     failed++;
19662   }
19663   test_num++;
19664   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19665   if (test_rm_2 () == -1) {
19666     printf ("test_rm_2 FAILED\n");
19667     failed++;
19668   }
19669   test_num++;
19670   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19671   if (test_read_lines_0 () == -1) {
19672     printf ("test_read_lines_0 FAILED\n");
19673     failed++;
19674   }
19675   test_num++;
19676   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19677   if (test_read_lines_1 () == -1) {
19678     printf ("test_read_lines_1 FAILED\n");
19679     failed++;
19680   }
19681   test_num++;
19682   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19683   if (test_lvs_0 () == -1) {
19684     printf ("test_lvs_0 FAILED\n");
19685     failed++;
19686   }
19687   test_num++;
19688   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19689   if (test_lvs_1 () == -1) {
19690     printf ("test_lvs_1 FAILED\n");
19691     failed++;
19692   }
19693   test_num++;
19694   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19695   if (test_vgs_0 () == -1) {
19696     printf ("test_vgs_0 FAILED\n");
19697     failed++;
19698   }
19699   test_num++;
19700   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19701   if (test_vgs_1 () == -1) {
19702     printf ("test_vgs_1 FAILED\n");
19703     failed++;
19704   }
19705   test_num++;
19706   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19707   if (test_pvs_0 () == -1) {
19708     printf ("test_pvs_0 FAILED\n");
19709     failed++;
19710   }
19711   test_num++;
19712   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19713   if (test_pvs_1 () == -1) {
19714     printf ("test_pvs_1 FAILED\n");
19715     failed++;
19716   }
19717   test_num++;
19718   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19719   if (test_list_partitions_0 () == -1) {
19720     printf ("test_list_partitions_0 FAILED\n");
19721     failed++;
19722   }
19723   test_num++;
19724   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19725   if (test_list_partitions_1 () == -1) {
19726     printf ("test_list_partitions_1 FAILED\n");
19727     failed++;
19728   }
19729   test_num++;
19730   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19731   if (test_list_devices_0 () == -1) {
19732     printf ("test_list_devices_0 FAILED\n");
19733     failed++;
19734   }
19735   test_num++;
19736   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19737   if (test_ls_0 () == -1) {
19738     printf ("test_ls_0 FAILED\n");
19739     failed++;
19740   }
19741   test_num++;
19742   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19743   if (test_cat_0 () == -1) {
19744     printf ("test_cat_0 FAILED\n");
19745     failed++;
19746   }
19747   test_num++;
19748   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19749   if (test_touch_0 () == -1) {
19750     printf ("test_touch_0 FAILED\n");
19751     failed++;
19752   }
19753   test_num++;
19754   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19755   if (test_sync_0 () == -1) {
19756     printf ("test_sync_0 FAILED\n");
19757     failed++;
19758   }
19759   test_num++;
19760   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19761   if (test_mount_0 () == -1) {
19762     printf ("test_mount_0 FAILED\n");
19763     failed++;
19764   }
19765
19766   guestfs_close (g);
19767   unlink ("test1.img");
19768   unlink ("test2.img");
19769   unlink ("test3.img");
19770
19771   if (failed > 0) {
19772     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
19773     exit (1);
19774   }
19775
19776   exit (0);
19777 }