capitests/tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 static void print_error (guestfs_h *g, void *data, const char *msg)
  35 {
  36   if (!suppress_error)
  37     fprintf (stderr, "%s\n", msg);
  38 }
  39
  40 static void print_strings (char * const * const argv)
  41 {
  42   int argc;
  43
  44   for (argc = 0; argv[argc] != NULL; ++argc)
  45     printf ("\t%s\n", argv[argc]);
  46 }
  47
  48 /*
  49 static void print_table (char * const * const argv)
  50 {
  51   int i;
  52
  53   for (i = 0; argv[i] != NULL; i += 2)
  54     printf ("%s: %s\n", argv[i], argv[i+1]);
  55 }
  56 */
  57
  58 static void no_test_warnings (void)
  59 {
  60   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  61   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  62   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  63   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  64   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  65   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 154 }
 155
 156 static int test_wc_c_0_skip (void)
 157 {
 158   const char *str;
 159
 160   str = getenv ("TEST_ONLY");
 161   if (str)
 162     return strstr (str, "wc_c") == NULL;
 163   str = getenv ("SKIP_TEST_WC_C_0");
 164   if (str && strcmp (str, "1") == 0) return 1;
 165   str = getenv ("SKIP_TEST_WC_C");
 166   if (str && strcmp (str, "1") == 0) return 1;
 167   return 0;
 168 }
 169
 170 static int test_wc_c_0 (void)
 171 {
 172   if (test_wc_c_0_skip ()) {
 173     printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
 174     return 0;
 175   }
 176
 177   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
 178   {
 179     char device[] = "/dev/sda";
 180     int r;
 181     suppress_error = 0;
 182     r = guestfs_blockdev_setrw (g, device);
 183     if (r == -1)
 184       return -1;
 185   }
 186   {
 187     int r;
 188     suppress_error = 0;
 189     r = guestfs_umount_all (g);
 190     if (r == -1)
 191       return -1;
 192   }
 193   {
 194     int r;
 195     suppress_error = 0;
 196     r = guestfs_lvm_remove_all (g);
 197     if (r == -1)
 198       return -1;
 199   }
 200   {
 201     char device[] = "/dev/sda";
 202     char lines_0[] = ",";
 203     char *lines[] = {
 204       lines_0,
 205       NULL
 206     };
 207     int r;
 208     suppress_error = 0;
 209     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 210     if (r == -1)
 211       return -1;
 212   }
 213   {
 214     char fstype[] = "ext2";
 215     char device[] = "/dev/sda1";
 216     int r;
 217     suppress_error = 0;
 218     r = guestfs_mkfs (g, fstype, device);
 219     if (r == -1)
 220       return -1;
 221   }
 222   {
 223     char device[] = "/dev/sda1";
 224     char mountpoint[] = "/";
 225     int r;
 226     suppress_error = 0;
 227     r = guestfs_mount (g, device, mountpoint);
 228     if (r == -1)
 229       return -1;
 230   }
 231   /* TestOutputInt for wc_c (0) */
 232   {
 233     char options[] = "ro";
 234     char vfstype[] = "squashfs";
 235     char device[] = "/dev/sdd";
 236     char mountpoint[] = "/";
 237     int r;
 238     suppress_error = 0;
 239     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 240     if (r == -1)
 241       return -1;
 242   }
 243   {
 244     char path[] = "/100kallspaces";
 245     int r;
 246     suppress_error = 0;
 247     r = guestfs_wc_c (g, path);
 248     if (r == -1)
 249       return -1;
 250     if (r != 102400) {
 251       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
 252       return -1;
 253     }
 254   }
 255   return 0;
 256 }
 257
 258 static int test_wc_w_0_skip (void)
 259 {
 260   const char *str;
 261
 262   str = getenv ("TEST_ONLY");
 263   if (str)
 264     return strstr (str, "wc_w") == NULL;
 265   str = getenv ("SKIP_TEST_WC_W_0");
 266   if (str && strcmp (str, "1") == 0) return 1;
 267   str = getenv ("SKIP_TEST_WC_W");
 268   if (str && strcmp (str, "1") == 0) return 1;
 269   return 0;
 270 }
 271
 272 static int test_wc_w_0 (void)
 273 {
 274   if (test_wc_w_0_skip ()) {
 275     printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
 276     return 0;
 277   }
 278
 279   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
 280   {
 281     char device[] = "/dev/sda";
 282     int r;
 283     suppress_error = 0;
 284     r = guestfs_blockdev_setrw (g, device);
 285     if (r == -1)
 286       return -1;
 287   }
 288   {
 289     int r;
 290     suppress_error = 0;
 291     r = guestfs_umount_all (g);
 292     if (r == -1)
 293       return -1;
 294   }
 295   {
 296     int r;
 297     suppress_error = 0;
 298     r = guestfs_lvm_remove_all (g);
 299     if (r == -1)
 300       return -1;
 301   }
 302   {
 303     char device[] = "/dev/sda";
 304     char lines_0[] = ",";
 305     char *lines[] = {
 306       lines_0,
 307       NULL
 308     };
 309     int r;
 310     suppress_error = 0;
 311     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 312     if (r == -1)
 313       return -1;
 314   }
 315   {
 316     char fstype[] = "ext2";
 317     char device[] = "/dev/sda1";
 318     int r;
 319     suppress_error = 0;
 320     r = guestfs_mkfs (g, fstype, device);
 321     if (r == -1)
 322       return -1;
 323   }
 324   {
 325     char device[] = "/dev/sda1";
 326     char mountpoint[] = "/";
 327     int r;
 328     suppress_error = 0;
 329     r = guestfs_mount (g, device, mountpoint);
 330     if (r == -1)
 331       return -1;
 332   }
 333   /* TestOutputInt for wc_w (0) */
 334   {
 335     char options[] = "ro";
 336     char vfstype[] = "squashfs";
 337     char device[] = "/dev/sdd";
 338     char mountpoint[] = "/";
 339     int r;
 340     suppress_error = 0;
 341     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 342     if (r == -1)
 343       return -1;
 344   }
 345   {
 346     char path[] = "/10klines";
 347     int r;
 348     suppress_error = 0;
 349     r = guestfs_wc_w (g, path);
 350     if (r == -1)
 351       return -1;
 352     if (r != 10000) {
 353       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
 354       return -1;
 355     }
 356   }
 357   return 0;
 358 }
 359
 360 static int test_wc_l_0_skip (void)
 361 {
 362   const char *str;
 363
 364   str = getenv ("TEST_ONLY");
 365   if (str)
 366     return strstr (str, "wc_l") == NULL;
 367   str = getenv ("SKIP_TEST_WC_L_0");
 368   if (str && strcmp (str, "1") == 0) return 1;
 369   str = getenv ("SKIP_TEST_WC_L");
 370   if (str && strcmp (str, "1") == 0) return 1;
 371   return 0;
 372 }
 373
 374 static int test_wc_l_0 (void)
 375 {
 376   if (test_wc_l_0_skip ()) {
 377     printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
 378     return 0;
 379   }
 380
 381   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
 382   {
 383     char device[] = "/dev/sda";
 384     int r;
 385     suppress_error = 0;
 386     r = guestfs_blockdev_setrw (g, device);
 387     if (r == -1)
 388       return -1;
 389   }
 390   {
 391     int r;
 392     suppress_error = 0;
 393     r = guestfs_umount_all (g);
 394     if (r == -1)
 395       return -1;
 396   }
 397   {
 398     int r;
 399     suppress_error = 0;
 400     r = guestfs_lvm_remove_all (g);
 401     if (r == -1)
 402       return -1;
 403   }
 404   {
 405     char device[] = "/dev/sda";
 406     char lines_0[] = ",";
 407     char *lines[] = {
 408       lines_0,
 409       NULL
 410     };
 411     int r;
 412     suppress_error = 0;
 413     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 414     if (r == -1)
 415       return -1;
 416   }
 417   {
 418     char fstype[] = "ext2";
 419     char device[] = "/dev/sda1";
 420     int r;
 421     suppress_error = 0;
 422     r = guestfs_mkfs (g, fstype, device);
 423     if (r == -1)
 424       return -1;
 425   }
 426   {
 427     char device[] = "/dev/sda1";
 428     char mountpoint[] = "/";
 429     int r;
 430     suppress_error = 0;
 431     r = guestfs_mount (g, device, mountpoint);
 432     if (r == -1)
 433       return -1;
 434   }
 435   /* TestOutputInt for wc_l (0) */
 436   {
 437     char options[] = "ro";
 438     char vfstype[] = "squashfs";
 439     char device[] = "/dev/sdd";
 440     char mountpoint[] = "/";
 441     int r;
 442     suppress_error = 0;
 443     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 444     if (r == -1)
 445       return -1;
 446   }
 447   {
 448     char path[] = "/10klines";
 449     int r;
 450     suppress_error = 0;
 451     r = guestfs_wc_l (g, path);
 452     if (r == -1)
 453       return -1;
 454     if (r != 10000) {
 455       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
 456       return -1;
 457     }
 458   }
 459   return 0;
 460 }
 461
 462 static int test_mkdtemp_0_skip (void)
 463 {
 464   const char *str;
 465
 466   str = getenv ("TEST_ONLY");
 467   if (str)
 468     return strstr (str, "mkdtemp") == NULL;
 469   str = getenv ("SKIP_TEST_MKDTEMP_0");
 470   if (str && strcmp (str, "1") == 0) return 1;
 471   str = getenv ("SKIP_TEST_MKDTEMP");
 472   if (str && strcmp (str, "1") == 0) return 1;
 473   return 0;
 474 }
 475
 476 static int test_mkdtemp_0 (void)
 477 {
 478   if (test_mkdtemp_0_skip ()) {
 479     printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
 480     return 0;
 481   }
 482
 483   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
 484   {
 485     char device[] = "/dev/sda";
 486     int r;
 487     suppress_error = 0;
 488     r = guestfs_blockdev_setrw (g, device);
 489     if (r == -1)
 490       return -1;
 491   }
 492   {
 493     int r;
 494     suppress_error = 0;
 495     r = guestfs_umount_all (g);
 496     if (r == -1)
 497       return -1;
 498   }
 499   {
 500     int r;
 501     suppress_error = 0;
 502     r = guestfs_lvm_remove_all (g);
 503     if (r == -1)
 504       return -1;
 505   }
 506   {
 507     char device[] = "/dev/sda";
 508     char lines_0[] = ",";
 509     char *lines[] = {
 510       lines_0,
 511       NULL
 512     };
 513     int r;
 514     suppress_error = 0;
 515     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 516     if (r == -1)
 517       return -1;
 518   }
 519   {
 520     char fstype[] = "ext2";
 521     char device[] = "/dev/sda1";
 522     int r;
 523     suppress_error = 0;
 524     r = guestfs_mkfs (g, fstype, device);
 525     if (r == -1)
 526       return -1;
 527   }
 528   {
 529     char device[] = "/dev/sda1";
 530     char mountpoint[] = "/";
 531     int r;
 532     suppress_error = 0;
 533     r = guestfs_mount (g, device, mountpoint);
 534     if (r == -1)
 535       return -1;
 536   }
 537   /* TestRun for mkdtemp (0) */
 538   {
 539     char path[] = "/tmp";
 540     int r;
 541     suppress_error = 0;
 542     r = guestfs_mkdir (g, path);
 543     if (r == -1)
 544       return -1;
 545   }
 546   {
 547     char template[] = "/tmp/tmpXXXXXX";
 548     char *r;
 549     suppress_error = 0;
 550     r = guestfs_mkdtemp (g, template);
 551     if (r == NULL)
 552       return -1;
 553     free (r);
 554   }
 555   return 0;
 556 }
 557
 558 static int test_scrub_file_0_skip (void)
 559 {
 560   const char *str;
 561
 562   str = getenv ("TEST_ONLY");
 563   if (str)
 564     return strstr (str, "scrub_file") == NULL;
 565   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
 566   if (str && strcmp (str, "1") == 0) return 1;
 567   str = getenv ("SKIP_TEST_SCRUB_FILE");
 568   if (str && strcmp (str, "1") == 0) return 1;
 569   return 0;
 570 }
 571
 572 static int test_scrub_file_0 (void)
 573 {
 574   if (test_scrub_file_0_skip ()) {
 575     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
 576     return 0;
 577   }
 578
 579   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
 580   {
 581     char device[] = "/dev/sda";
 582     int r;
 583     suppress_error = 0;
 584     r = guestfs_blockdev_setrw (g, device);
 585     if (r == -1)
 586       return -1;
 587   }
 588   {
 589     int r;
 590     suppress_error = 0;
 591     r = guestfs_umount_all (g);
 592     if (r == -1)
 593       return -1;
 594   }
 595   {
 596     int r;
 597     suppress_error = 0;
 598     r = guestfs_lvm_remove_all (g);
 599     if (r == -1)
 600       return -1;
 601   }
 602   {
 603     char device[] = "/dev/sda";
 604     char lines_0[] = ",";
 605     char *lines[] = {
 606       lines_0,
 607       NULL
 608     };
 609     int r;
 610     suppress_error = 0;
 611     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 612     if (r == -1)
 613       return -1;
 614   }
 615   {
 616     char fstype[] = "ext2";
 617     char device[] = "/dev/sda1";
 618     int r;
 619     suppress_error = 0;
 620     r = guestfs_mkfs (g, fstype, device);
 621     if (r == -1)
 622       return -1;
 623   }
 624   {
 625     char device[] = "/dev/sda1";
 626     char mountpoint[] = "/";
 627     int r;
 628     suppress_error = 0;
 629     r = guestfs_mount (g, device, mountpoint);
 630     if (r == -1)
 631       return -1;
 632   }
 633   /* TestRun for scrub_file (0) */
 634   {
 635     char path[] = "/file";
 636     char content[] = "content";
 637     int r;
 638     suppress_error = 0;
 639     r = guestfs_write_file (g, path, content, 0);
 640     if (r == -1)
 641       return -1;
 642   }
 643   {
 644     char file[] = "/file";
 645     int r;
 646     suppress_error = 0;
 647     r = guestfs_scrub_file (g, file);
 648     if (r == -1)
 649       return -1;
 650   }
 651   return 0;
 652 }
 653
 654 static int test_scrub_device_0_skip (void)
 655 {
 656   const char *str;
 657
 658   str = getenv ("TEST_ONLY");
 659   if (str)
 660     return strstr (str, "scrub_device") == NULL;
 661   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
 662   if (str && strcmp (str, "1") == 0) return 1;
 663   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
 664   if (str && strcmp (str, "1") == 0) return 1;
 665   return 0;
 666 }
 667
 668 static int test_scrub_device_0 (void)
 669 {
 670   if (test_scrub_device_0_skip ()) {
 671     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
 672     return 0;
 673   }
 674
 675   /* InitNone|InitEmpty for test_scrub_device_0 */
 676   {
 677     char device[] = "/dev/sda";
 678     int r;
 679     suppress_error = 0;
 680     r = guestfs_blockdev_setrw (g, device);
 681     if (r == -1)
 682       return -1;
 683   }
 684   {
 685     int r;
 686     suppress_error = 0;
 687     r = guestfs_umount_all (g);
 688     if (r == -1)
 689       return -1;
 690   }
 691   {
 692     int r;
 693     suppress_error = 0;
 694     r = guestfs_lvm_remove_all (g);
 695     if (r == -1)
 696       return -1;
 697   }
 698   /* TestRun for scrub_device (0) */
 699   {
 700     char device[] = "/dev/sdc";
 701     int r;
 702     suppress_error = 0;
 703     r = guestfs_scrub_device (g, device);
 704     if (r == -1)
 705       return -1;
 706   }
 707   return 0;
 708 }
 709
 710 static int test_glob_expand_0_skip (void)
 711 {
 712   const char *str;
 713
 714   str = getenv ("TEST_ONLY");
 715   if (str)
 716     return strstr (str, "glob_expand") == NULL;
 717   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
 718   if (str && strcmp (str, "1") == 0) return 1;
 719   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 720   if (str && strcmp (str, "1") == 0) return 1;
 721   return 0;
 722 }
 723
 724 static int test_glob_expand_0 (void)
 725 {
 726   if (test_glob_expand_0_skip ()) {
 727     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
 728     return 0;
 729   }
 730
 731   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
 732   {
 733     char device[] = "/dev/sda";
 734     int r;
 735     suppress_error = 0;
 736     r = guestfs_blockdev_setrw (g, device);
 737     if (r == -1)
 738       return -1;
 739   }
 740   {
 741     int r;
 742     suppress_error = 0;
 743     r = guestfs_umount_all (g);
 744     if (r == -1)
 745       return -1;
 746   }
 747   {
 748     int r;
 749     suppress_error = 0;
 750     r = guestfs_lvm_remove_all (g);
 751     if (r == -1)
 752       return -1;
 753   }
 754   {
 755     char device[] = "/dev/sda";
 756     char lines_0[] = ",";
 757     char *lines[] = {
 758       lines_0,
 759       NULL
 760     };
 761     int r;
 762     suppress_error = 0;
 763     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 764     if (r == -1)
 765       return -1;
 766   }
 767   {
 768     char fstype[] = "ext2";
 769     char device[] = "/dev/sda1";
 770     int r;
 771     suppress_error = 0;
 772     r = guestfs_mkfs (g, fstype, device);
 773     if (r == -1)
 774       return -1;
 775   }
 776   {
 777     char device[] = "/dev/sda1";
 778     char mountpoint[] = "/";
 779     int r;
 780     suppress_error = 0;
 781     r = guestfs_mount (g, device, mountpoint);
 782     if (r == -1)
 783       return -1;
 784   }
 785   /* TestOutputList for glob_expand (0) */
 786   {
 787     char path[] = "/a/b/c";
 788     int r;
 789     suppress_error = 0;
 790     r = guestfs_mkdir_p (g, path);
 791     if (r == -1)
 792       return -1;
 793   }
 794   {
 795     char path[] = "/a/b/c/d";
 796     int r;
 797     suppress_error = 0;
 798     r = guestfs_touch (g, path);
 799     if (r == -1)
 800       return -1;
 801   }
 802   {
 803     char path[] = "/a/b/c/e";
 804     int r;
 805     suppress_error = 0;
 806     r = guestfs_touch (g, path);
 807     if (r == -1)
 808       return -1;
 809   }
 810   {
 811     char pattern[] = "/a/b/c/*";
 812     char **r;
 813     int i;
 814     suppress_error = 0;
 815     r = guestfs_glob_expand (g, pattern);
 816     if (r == NULL)
 817       return -1;
 818     if (!r[0]) {
 819       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
 820       print_strings (r);
 821       return -1;
 822     }
 823     {
 824       char expected[] = "/a/b/c/d";
 825       if (strcmp (r[0], expected) != 0) {
 826         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 827         return -1;
 828       }
 829     }
 830     if (!r[1]) {
 831       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
 832       print_strings (r);
 833       return -1;
 834     }
 835     {
 836       char expected[] = "/a/b/c/e";
 837       if (strcmp (r[1], expected) != 0) {
 838         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 839         return -1;
 840       }
 841     }
 842     if (r[2] != NULL) {
 843       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
 844       print_strings (r);
 845       return -1;
 846     }
 847     for (i = 0; r[i] != NULL; ++i)
 848       free (r[i]);
 849     free (r);
 850   }
 851   return 0;
 852 }
 853
 854 static int test_glob_expand_1_skip (void)
 855 {
 856   const char *str;
 857
 858   str = getenv ("TEST_ONLY");
 859   if (str)
 860     return strstr (str, "glob_expand") == NULL;
 861   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
 862   if (str && strcmp (str, "1") == 0) return 1;
 863   str = getenv ("SKIP_TEST_GLOB_EXPAND");
 864   if (str && strcmp (str, "1") == 0) return 1;
 865   return 0;
 866 }
 867
 868 static int test_glob_expand_1 (void)
 869 {
 870   if (test_glob_expand_1_skip ()) {
 871     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
 872     return 0;
 873   }
 874
 875   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
 876   {
 877     char device[] = "/dev/sda";
 878     int r;
 879     suppress_error = 0;
 880     r = guestfs_blockdev_setrw (g, device);
 881     if (r == -1)
 882       return -1;
 883   }
 884   {
 885     int r;
 886     suppress_error = 0;
 887     r = guestfs_umount_all (g);
 888     if (r == -1)
 889       return -1;
 890   }
 891   {
 892     int r;
 893     suppress_error = 0;
 894     r = guestfs_lvm_remove_all (g);
 895     if (r == -1)
 896       return -1;
 897   }
 898   {
 899     char device[] = "/dev/sda";
 900     char lines_0[] = ",";
 901     char *lines[] = {
 902       lines_0,
 903       NULL
 904     };
 905     int r;
 906     suppress_error = 0;
 907     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 908     if (r == -1)
 909       return -1;
 910   }
 911   {
 912     char fstype[] = "ext2";
 913     char device[] = "/dev/sda1";
 914     int r;
 915     suppress_error = 0;
 916     r = guestfs_mkfs (g, fstype, device);
 917     if (r == -1)
 918       return -1;
 919   }
 920   {
 921     char device[] = "/dev/sda1";
 922     char mountpoint[] = "/";
 923     int r;
 924     suppress_error = 0;
 925     r = guestfs_mount (g, device, mountpoint);
 926     if (r == -1)
 927       return -1;
 928   }
 929   /* TestOutputList for glob_expand (1) */
 930   {
 931     char path[] = "/a/b/c";
 932     int r;
 933     suppress_error = 0;
 934     r = guestfs_mkdir_p (g, path);
 935     if (r == -1)
 936       return -1;
 937   }
 938   {
 939     char path[] = "/a/b/c/d";
 940     int r;
 941     suppress_error = 0;
 942     r = guestfs_touch (g, path);
 943     if (r == -1)
 944       return -1;
 945   }
 946   {
 947     char path[] = "/a/b/c/e";
 948     int r;
 949     suppress_error = 0;
 950     r = guestfs_touch (g, path);
 951     if (r == -1)
 952       return -1;
 953   }
 954   {
 955     char pattern[] = "/a/*/c/*";
 956     char **r;
 957     int i;
 958     suppress_error = 0;
 959     r = guestfs_glob_expand (g, pattern);
 960     if (r == NULL)
 961       return -1;
 962     if (!r[0]) {
 963       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
 964       print_strings (r);
 965       return -1;
 966     }
 967     {
 968       char expected[] = "/a/b/c/d";
 969       if (strcmp (r[0], expected) != 0) {
 970         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 971         return -1;
 972       }
 973     }
 974     if (!r[1]) {
 975       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
 976       print_strings (r);
 977       return -1;
 978     }
 979     {
 980       char expected[] = "/a/b/c/e";
 981       if (strcmp (r[1], expected) != 0) {
 982         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 983         return -1;
 984       }
 985     }
 986     if (r[2] != NULL) {
 987       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
 988       print_strings (r);
 989       return -1;
 990     }
 991     for (i = 0; r[i] != NULL; ++i)
 992       free (r[i]);
 993     free (r);
 994   }
 995   return 0;
 996 }
 997
 998 static int test_glob_expand_2_skip (void)
 999 {
1000   const char *str;
1001
1002   str = getenv ("TEST_ONLY");
1003   if (str)
1004     return strstr (str, "glob_expand") == NULL;
1005   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
1006   if (str && strcmp (str, "1") == 0) return 1;
1007   str = getenv ("SKIP_TEST_GLOB_EXPAND");
1008   if (str && strcmp (str, "1") == 0) return 1;
1009   return 0;
1010 }
1011
1012 static int test_glob_expand_2 (void)
1013 {
1014   if (test_glob_expand_2_skip ()) {
1015     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
1016     return 0;
1017   }
1018
1019   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
1020   {
1021     char device[] = "/dev/sda";
1022     int r;
1023     suppress_error = 0;
1024     r = guestfs_blockdev_setrw (g, device);
1025     if (r == -1)
1026       return -1;
1027   }
1028   {
1029     int r;
1030     suppress_error = 0;
1031     r = guestfs_umount_all (g);
1032     if (r == -1)
1033       return -1;
1034   }
1035   {
1036     int r;
1037     suppress_error = 0;
1038     r = guestfs_lvm_remove_all (g);
1039     if (r == -1)
1040       return -1;
1041   }
1042   {
1043     char device[] = "/dev/sda";
1044     char lines_0[] = ",";
1045     char *lines[] = {
1046       lines_0,
1047       NULL
1048     };
1049     int r;
1050     suppress_error = 0;
1051     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1052     if (r == -1)
1053       return -1;
1054   }
1055   {
1056     char fstype[] = "ext2";
1057     char device[] = "/dev/sda1";
1058     int r;
1059     suppress_error = 0;
1060     r = guestfs_mkfs (g, fstype, device);
1061     if (r == -1)
1062       return -1;
1063   }
1064   {
1065     char device[] = "/dev/sda1";
1066     char mountpoint[] = "/";
1067     int r;
1068     suppress_error = 0;
1069     r = guestfs_mount (g, device, mountpoint);
1070     if (r == -1)
1071       return -1;
1072   }
1073   /* TestOutputList for glob_expand (2) */
1074   {
1075     char path[] = "/a/b/c";
1076     int r;
1077     suppress_error = 0;
1078     r = guestfs_mkdir_p (g, path);
1079     if (r == -1)
1080       return -1;
1081   }
1082   {
1083     char path[] = "/a/b/c/d";
1084     int r;
1085     suppress_error = 0;
1086     r = guestfs_touch (g, path);
1087     if (r == -1)
1088       return -1;
1089   }
1090   {
1091     char path[] = "/a/b/c/e";
1092     int r;
1093     suppress_error = 0;
1094     r = guestfs_touch (g, path);
1095     if (r == -1)
1096       return -1;
1097   }
1098   {
1099     char pattern[] = "/a/*/x/*";
1100     char **r;
1101     int i;
1102     suppress_error = 0;
1103     r = guestfs_glob_expand (g, pattern);
1104     if (r == NULL)
1105       return -1;
1106     if (r[0] != NULL) {
1107       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
1108       print_strings (r);
1109       return -1;
1110     }
1111     for (i = 0; r[i] != NULL; ++i)
1112       free (r[i]);
1113     free (r);
1114   }
1115   return 0;
1116 }
1117
1118 static int test_ntfs_3g_probe_0_skip (void)
1119 {
1120   const char *str;
1121
1122   str = getenv ("TEST_ONLY");
1123   if (str)
1124     return strstr (str, "ntfs_3g_probe") == NULL;
1125   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
1126   if (str && strcmp (str, "1") == 0) return 1;
1127   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
1128   if (str && strcmp (str, "1") == 0) return 1;
1129   return 0;
1130 }
1131
1132 static int test_ntfs_3g_probe_0 (void)
1133 {
1134   if (test_ntfs_3g_probe_0_skip ()) {
1135     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
1136     return 0;
1137   }
1138
1139   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
1140   {
1141     char device[] = "/dev/sda";
1142     int r;
1143     suppress_error = 0;
1144     r = guestfs_blockdev_setrw (g, device);
1145     if (r == -1)
1146       return -1;
1147   }
1148   {
1149     int r;
1150     suppress_error = 0;
1151     r = guestfs_umount_all (g);
1152     if (r == -1)
1153       return -1;
1154   }
1155   {
1156     int r;
1157     suppress_error = 0;
1158     r = guestfs_lvm_remove_all (g);
1159     if (r == -1)
1160       return -1;
1161   }
1162   /* TestOutputInt for ntfs_3g_probe (0) */
1163   {
1164     char device[] = "/dev/sda";
1165     char lines_0[] = ",";
1166     char *lines[] = {
1167       lines_0,
1168       NULL
1169     };
1170     int r;
1171     suppress_error = 0;
1172     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1173     if (r == -1)
1174       return -1;
1175   }
1176   {
1177     char fstype[] = "ntfs";
1178     char device[] = "/dev/sda1";
1179     int r;
1180     suppress_error = 0;
1181     r = guestfs_mkfs (g, fstype, device);
1182     if (r == -1)
1183       return -1;
1184   }
1185   {
1186     char device[] = "/dev/sda1";
1187     int r;
1188     suppress_error = 0;
1189     r = guestfs_ntfs_3g_probe (g, 1, device);
1190     if (r == -1)
1191       return -1;
1192     if (r != 0) {
1193       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
1194       return -1;
1195     }
1196   }
1197   return 0;
1198 }
1199
1200 static int test_ntfs_3g_probe_1_skip (void)
1201 {
1202   const char *str;
1203
1204   str = getenv ("TEST_ONLY");
1205   if (str)
1206     return strstr (str, "ntfs_3g_probe") == NULL;
1207   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
1208   if (str && strcmp (str, "1") == 0) return 1;
1209   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
1210   if (str && strcmp (str, "1") == 0) return 1;
1211   return 0;
1212 }
1213
1214 static int test_ntfs_3g_probe_1 (void)
1215 {
1216   if (test_ntfs_3g_probe_1_skip ()) {
1217     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
1218     return 0;
1219   }
1220
1221   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
1222   {
1223     char device[] = "/dev/sda";
1224     int r;
1225     suppress_error = 0;
1226     r = guestfs_blockdev_setrw (g, device);
1227     if (r == -1)
1228       return -1;
1229   }
1230   {
1231     int r;
1232     suppress_error = 0;
1233     r = guestfs_umount_all (g);
1234     if (r == -1)
1235       return -1;
1236   }
1237   {
1238     int r;
1239     suppress_error = 0;
1240     r = guestfs_lvm_remove_all (g);
1241     if (r == -1)
1242       return -1;
1243   }
1244   /* TestOutputInt for ntfs_3g_probe (1) */
1245   {
1246     char device[] = "/dev/sda";
1247     char lines_0[] = ",";
1248     char *lines[] = {
1249       lines_0,
1250       NULL
1251     };
1252     int r;
1253     suppress_error = 0;
1254     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1255     if (r == -1)
1256       return -1;
1257   }
1258   {
1259     char fstype[] = "ext2";
1260     char device[] = "/dev/sda1";
1261     int r;
1262     suppress_error = 0;
1263     r = guestfs_mkfs (g, fstype, device);
1264     if (r == -1)
1265       return -1;
1266   }
1267   {
1268     char device[] = "/dev/sda1";
1269     int r;
1270     suppress_error = 0;
1271     r = guestfs_ntfs_3g_probe (g, 1, device);
1272     if (r == -1)
1273       return -1;
1274     if (r != 12) {
1275       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
1276       return -1;
1277     }
1278   }
1279   return 0;
1280 }
1281
1282 static int test_sleep_0_skip (void)
1283 {
1284   const char *str;
1285
1286   str = getenv ("TEST_ONLY");
1287   if (str)
1288     return strstr (str, "sleep") == NULL;
1289   str = getenv ("SKIP_TEST_SLEEP_0");
1290   if (str && strcmp (str, "1") == 0) return 1;
1291   str = getenv ("SKIP_TEST_SLEEP");
1292   if (str && strcmp (str, "1") == 0) return 1;
1293   return 0;
1294 }
1295
1296 static int test_sleep_0 (void)
1297 {
1298   if (test_sleep_0_skip ()) {
1299     printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
1300     return 0;
1301   }
1302
1303   /* InitNone|InitEmpty for test_sleep_0 */
1304   {
1305     char device[] = "/dev/sda";
1306     int r;
1307     suppress_error = 0;
1308     r = guestfs_blockdev_setrw (g, device);
1309     if (r == -1)
1310       return -1;
1311   }
1312   {
1313     int r;
1314     suppress_error = 0;
1315     r = guestfs_umount_all (g);
1316     if (r == -1)
1317       return -1;
1318   }
1319   {
1320     int r;
1321     suppress_error = 0;
1322     r = guestfs_lvm_remove_all (g);
1323     if (r == -1)
1324       return -1;
1325   }
1326   /* TestRun for sleep (0) */
1327   {
1328     int r;
1329     suppress_error = 0;
1330     r = guestfs_sleep (g, 1);
1331     if (r == -1)
1332       return -1;
1333   }
1334   return 0;
1335 }
1336
1337 static int test_find_0_skip (void)
1338 {
1339   const char *str;
1340
1341   str = getenv ("TEST_ONLY");
1342   if (str)
1343     return strstr (str, "find") == NULL;
1344   str = getenv ("SKIP_TEST_FIND_0");
1345   if (str && strcmp (str, "1") == 0) return 1;
1346   str = getenv ("SKIP_TEST_FIND");
1347   if (str && strcmp (str, "1") == 0) return 1;
1348   return 0;
1349 }
1350
1351 static int test_find_0 (void)
1352 {
1353   if (test_find_0_skip ()) {
1354     printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
1355     return 0;
1356   }
1357
1358   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
1359   {
1360     char device[] = "/dev/sda";
1361     int r;
1362     suppress_error = 0;
1363     r = guestfs_blockdev_setrw (g, device);
1364     if (r == -1)
1365       return -1;
1366   }
1367   {
1368     int r;
1369     suppress_error = 0;
1370     r = guestfs_umount_all (g);
1371     if (r == -1)
1372       return -1;
1373   }
1374   {
1375     int r;
1376     suppress_error = 0;
1377     r = guestfs_lvm_remove_all (g);
1378     if (r == -1)
1379       return -1;
1380   }
1381   {
1382     char device[] = "/dev/sda";
1383     char lines_0[] = ",";
1384     char *lines[] = {
1385       lines_0,
1386       NULL
1387     };
1388     int r;
1389     suppress_error = 0;
1390     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1391     if (r == -1)
1392       return -1;
1393   }
1394   {
1395     char fstype[] = "ext2";
1396     char device[] = "/dev/sda1";
1397     int r;
1398     suppress_error = 0;
1399     r = guestfs_mkfs (g, fstype, device);
1400     if (r == -1)
1401       return -1;
1402   }
1403   {
1404     char device[] = "/dev/sda1";
1405     char mountpoint[] = "/";
1406     int r;
1407     suppress_error = 0;
1408     r = guestfs_mount (g, device, mountpoint);
1409     if (r == -1)
1410       return -1;
1411   }
1412   /* TestOutputList for find (0) */
1413   {
1414     char directory[] = "/";
1415     char **r;
1416     int i;
1417     suppress_error = 0;
1418     r = guestfs_find (g, directory);
1419     if (r == NULL)
1420       return -1;
1421     if (!r[0]) {
1422       fprintf (stderr, "test_find_0: short list returned from command\n");
1423       print_strings (r);
1424       return -1;
1425     }
1426     {
1427       char expected[] = "lost+found";
1428       if (strcmp (r[0], expected) != 0) {
1429         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1430         return -1;
1431       }
1432     }
1433     if (r[1] != NULL) {
1434       fprintf (stderr, "test_find_0: extra elements returned from command\n");
1435       print_strings (r);
1436       return -1;
1437     }
1438     for (i = 0; r[i] != NULL; ++i)
1439       free (r[i]);
1440     free (r);
1441   }
1442   return 0;
1443 }
1444
1445 static int test_find_1_skip (void)
1446 {
1447   const char *str;
1448
1449   str = getenv ("TEST_ONLY");
1450   if (str)
1451     return strstr (str, "find") == NULL;
1452   str = getenv ("SKIP_TEST_FIND_1");
1453   if (str && strcmp (str, "1") == 0) return 1;
1454   str = getenv ("SKIP_TEST_FIND");
1455   if (str && strcmp (str, "1") == 0) return 1;
1456   return 0;
1457 }
1458
1459 static int test_find_1 (void)
1460 {
1461   if (test_find_1_skip ()) {
1462     printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
1463     return 0;
1464   }
1465
1466   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
1467   {
1468     char device[] = "/dev/sda";
1469     int r;
1470     suppress_error = 0;
1471     r = guestfs_blockdev_setrw (g, device);
1472     if (r == -1)
1473       return -1;
1474   }
1475   {
1476     int r;
1477     suppress_error = 0;
1478     r = guestfs_umount_all (g);
1479     if (r == -1)
1480       return -1;
1481   }
1482   {
1483     int r;
1484     suppress_error = 0;
1485     r = guestfs_lvm_remove_all (g);
1486     if (r == -1)
1487       return -1;
1488   }
1489   {
1490     char device[] = "/dev/sda";
1491     char lines_0[] = ",";
1492     char *lines[] = {
1493       lines_0,
1494       NULL
1495     };
1496     int r;
1497     suppress_error = 0;
1498     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1499     if (r == -1)
1500       return -1;
1501   }
1502   {
1503     char fstype[] = "ext2";
1504     char device[] = "/dev/sda1";
1505     int r;
1506     suppress_error = 0;
1507     r = guestfs_mkfs (g, fstype, device);
1508     if (r == -1)
1509       return -1;
1510   }
1511   {
1512     char device[] = "/dev/sda1";
1513     char mountpoint[] = "/";
1514     int r;
1515     suppress_error = 0;
1516     r = guestfs_mount (g, device, mountpoint);
1517     if (r == -1)
1518       return -1;
1519   }
1520   /* TestOutputList for find (1) */
1521   {
1522     char path[] = "/a";
1523     int r;
1524     suppress_error = 0;
1525     r = guestfs_touch (g, path);
1526     if (r == -1)
1527       return -1;
1528   }
1529   {
1530     char path[] = "/b";
1531     int r;
1532     suppress_error = 0;
1533     r = guestfs_mkdir (g, path);
1534     if (r == -1)
1535       return -1;
1536   }
1537   {
1538     char path[] = "/b/c";
1539     int r;
1540     suppress_error = 0;
1541     r = guestfs_touch (g, path);
1542     if (r == -1)
1543       return -1;
1544   }
1545   {
1546     char directory[] = "/";
1547     char **r;
1548     int i;
1549     suppress_error = 0;
1550     r = guestfs_find (g, directory);
1551     if (r == NULL)
1552       return -1;
1553     if (!r[0]) {
1554       fprintf (stderr, "test_find_1: short list returned from command\n");
1555       print_strings (r);
1556       return -1;
1557     }
1558     {
1559       char expected[] = "a";
1560       if (strcmp (r[0], expected) != 0) {
1561         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1562         return -1;
1563       }
1564     }
1565     if (!r[1]) {
1566       fprintf (stderr, "test_find_1: short list returned from command\n");
1567       print_strings (r);
1568       return -1;
1569     }
1570     {
1571       char expected[] = "b";
1572       if (strcmp (r[1], expected) != 0) {
1573         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1574         return -1;
1575       }
1576     }
1577     if (!r[2]) {
1578       fprintf (stderr, "test_find_1: short list returned from command\n");
1579       print_strings (r);
1580       return -1;
1581     }
1582     {
1583       char expected[] = "b/c";
1584       if (strcmp (r[2], expected) != 0) {
1585         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1586         return -1;
1587       }
1588     }
1589     if (!r[3]) {
1590       fprintf (stderr, "test_find_1: short list returned from command\n");
1591       print_strings (r);
1592       return -1;
1593     }
1594     {
1595       char expected[] = "lost+found";
1596       if (strcmp (r[3], expected) != 0) {
1597         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1598         return -1;
1599       }
1600     }
1601     if (r[4] != NULL) {
1602       fprintf (stderr, "test_find_1: extra elements returned from command\n");
1603       print_strings (r);
1604       return -1;
1605     }
1606     for (i = 0; r[i] != NULL; ++i)
1607       free (r[i]);
1608     free (r);
1609   }
1610   return 0;
1611 }
1612
1613 static int test_find_2_skip (void)
1614 {
1615   const char *str;
1616
1617   str = getenv ("TEST_ONLY");
1618   if (str)
1619     return strstr (str, "find") == NULL;
1620   str = getenv ("SKIP_TEST_FIND_2");
1621   if (str && strcmp (str, "1") == 0) return 1;
1622   str = getenv ("SKIP_TEST_FIND");
1623   if (str && strcmp (str, "1") == 0) return 1;
1624   return 0;
1625 }
1626
1627 static int test_find_2 (void)
1628 {
1629   if (test_find_2_skip ()) {
1630     printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
1631     return 0;
1632   }
1633
1634   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
1635   {
1636     char device[] = "/dev/sda";
1637     int r;
1638     suppress_error = 0;
1639     r = guestfs_blockdev_setrw (g, device);
1640     if (r == -1)
1641       return -1;
1642   }
1643   {
1644     int r;
1645     suppress_error = 0;
1646     r = guestfs_umount_all (g);
1647     if (r == -1)
1648       return -1;
1649   }
1650   {
1651     int r;
1652     suppress_error = 0;
1653     r = guestfs_lvm_remove_all (g);
1654     if (r == -1)
1655       return -1;
1656   }
1657   {
1658     char device[] = "/dev/sda";
1659     char lines_0[] = ",";
1660     char *lines[] = {
1661       lines_0,
1662       NULL
1663     };
1664     int r;
1665     suppress_error = 0;
1666     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1667     if (r == -1)
1668       return -1;
1669   }
1670   {
1671     char fstype[] = "ext2";
1672     char device[] = "/dev/sda1";
1673     int r;
1674     suppress_error = 0;
1675     r = guestfs_mkfs (g, fstype, device);
1676     if (r == -1)
1677       return -1;
1678   }
1679   {
1680     char device[] = "/dev/sda1";
1681     char mountpoint[] = "/";
1682     int r;
1683     suppress_error = 0;
1684     r = guestfs_mount (g, device, mountpoint);
1685     if (r == -1)
1686       return -1;
1687   }
1688   /* TestOutputList for find (2) */
1689   {
1690     char path[] = "/a/b/c";
1691     int r;
1692     suppress_error = 0;
1693     r = guestfs_mkdir_p (g, path);
1694     if (r == -1)
1695       return -1;
1696   }
1697   {
1698     char path[] = "/a/b/c/d";
1699     int r;
1700     suppress_error = 0;
1701     r = guestfs_touch (g, path);
1702     if (r == -1)
1703       return -1;
1704   }
1705   {
1706     char directory[] = "/a/b/";
1707     char **r;
1708     int i;
1709     suppress_error = 0;
1710     r = guestfs_find (g, directory);
1711     if (r == NULL)
1712       return -1;
1713     if (!r[0]) {
1714       fprintf (stderr, "test_find_2: short list returned from command\n");
1715       print_strings (r);
1716       return -1;
1717     }
1718     {
1719       char expected[] = "c";
1720       if (strcmp (r[0], expected) != 0) {
1721         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1722         return -1;
1723       }
1724     }
1725     if (!r[1]) {
1726       fprintf (stderr, "test_find_2: short list returned from command\n");
1727       print_strings (r);
1728       return -1;
1729     }
1730     {
1731       char expected[] = "c/d";
1732       if (strcmp (r[1], expected) != 0) {
1733         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1734         return -1;
1735       }
1736     }
1737     if (r[2] != NULL) {
1738       fprintf (stderr, "test_find_2: extra elements returned from command\n");
1739       print_strings (r);
1740       return -1;
1741     }
1742     for (i = 0; r[i] != NULL; ++i)
1743       free (r[i]);
1744     free (r);
1745   }
1746   return 0;
1747 }
1748
1749 static int test_lvresize_0_skip (void)
1750 {
1751   const char *str;
1752
1753   str = getenv ("TEST_ONLY");
1754   if (str)
1755     return strstr (str, "lvresize") == NULL;
1756   str = getenv ("SKIP_TEST_LVRESIZE_0");
1757   if (str && strcmp (str, "1") == 0) return 1;
1758   str = getenv ("SKIP_TEST_LVRESIZE");
1759   if (str && strcmp (str, "1") == 0) return 1;
1760   return 0;
1761 }
1762
1763 static int test_lvresize_0 (void)
1764 {
1765   if (test_lvresize_0_skip ()) {
1766     printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
1767     return 0;
1768   }
1769
1770   /* InitNone|InitEmpty for test_lvresize_0 */
1771   {
1772     char device[] = "/dev/sda";
1773     int r;
1774     suppress_error = 0;
1775     r = guestfs_blockdev_setrw (g, device);
1776     if (r == -1)
1777       return -1;
1778   }
1779   {
1780     int r;
1781     suppress_error = 0;
1782     r = guestfs_umount_all (g);
1783     if (r == -1)
1784       return -1;
1785   }
1786   {
1787     int r;
1788     suppress_error = 0;
1789     r = guestfs_lvm_remove_all (g);
1790     if (r == -1)
1791       return -1;
1792   }
1793   /* TestOutput for lvresize (0) */
1794   char expected[] = "test content";
1795   {
1796     char device[] = "/dev/sda";
1797     char lines_0[] = ",";
1798     char *lines[] = {
1799       lines_0,
1800       NULL
1801     };
1802     int r;
1803     suppress_error = 0;
1804     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1805     if (r == -1)
1806       return -1;
1807   }
1808   {
1809     char device[] = "/dev/sda1";
1810     int r;
1811     suppress_error = 0;
1812     r = guestfs_pvcreate (g, device);
1813     if (r == -1)
1814       return -1;
1815   }
1816   {
1817     char volgroup[] = "VG";
1818     char physvols_0[] = "/dev/sda1";
1819     char *physvols[] = {
1820       physvols_0,
1821       NULL
1822     };
1823     int r;
1824     suppress_error = 0;
1825     r = guestfs_vgcreate (g, volgroup, physvols);
1826     if (r == -1)
1827       return -1;
1828   }
1829   {
1830     char logvol[] = "LV";
1831     char volgroup[] = "VG";
1832     int r;
1833     suppress_error = 0;
1834     r = guestfs_lvcreate (g, logvol, volgroup, 10);
1835     if (r == -1)
1836       return -1;
1837   }
1838   {
1839     char fstype[] = "ext2";
1840     char device[] = "/dev/VG/LV";
1841     int r;
1842     suppress_error = 0;
1843     r = guestfs_mkfs (g, fstype, device);
1844     if (r == -1)
1845       return -1;
1846   }
1847   {
1848     char device[] = "/dev/VG/LV";
1849     char mountpoint[] = "/";
1850     int r;
1851     suppress_error = 0;
1852     r = guestfs_mount (g, device, mountpoint);
1853     if (r == -1)
1854       return -1;
1855   }
1856   {
1857     char path[] = "/new";
1858     char content[] = "test content";
1859     int r;
1860     suppress_error = 0;
1861     r = guestfs_write_file (g, path, content, 0);
1862     if (r == -1)
1863       return -1;
1864   }
1865   {
1866     char pathordevice[] = "/";
1867     int r;
1868     suppress_error = 0;
1869     r = guestfs_umount (g, pathordevice);
1870     if (r == -1)
1871       return -1;
1872   }
1873   {
1874     char device[] = "/dev/VG/LV";
1875     int r;
1876     suppress_error = 0;
1877     r = guestfs_lvresize (g, device, 20);
1878     if (r == -1)
1879       return -1;
1880   }
1881   {
1882     char device[] = "/dev/VG/LV";
1883     int r;
1884     suppress_error = 0;
1885     r = guestfs_e2fsck_f (g, device);
1886     if (r == -1)
1887       return -1;
1888   }
1889   {
1890     char device[] = "/dev/VG/LV";
1891     int r;
1892     suppress_error = 0;
1893     r = guestfs_resize2fs (g, device);
1894     if (r == -1)
1895       return -1;
1896   }
1897   {
1898     char device[] = "/dev/VG/LV";
1899     char mountpoint[] = "/";
1900     int r;
1901     suppress_error = 0;
1902     r = guestfs_mount (g, device, mountpoint);
1903     if (r == -1)
1904       return -1;
1905   }
1906   {
1907     char path[] = "/new";
1908     char *r;
1909     suppress_error = 0;
1910     r = guestfs_cat (g, path);
1911     if (r == NULL)
1912       return -1;
1913     if (strcmp (r, expected) != 0) {
1914       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
1915       return -1;
1916     }
1917     free (r);
1918   }
1919   return 0;
1920 }
1921
1922 static int test_zerofree_0_skip (void)
1923 {
1924   const char *str;
1925
1926   str = getenv ("TEST_ONLY");
1927   if (str)
1928     return strstr (str, "zerofree") == NULL;
1929   str = getenv ("SKIP_TEST_ZEROFREE_0");
1930   if (str && strcmp (str, "1") == 0) return 1;
1931   str = getenv ("SKIP_TEST_ZEROFREE");
1932   if (str && strcmp (str, "1") == 0) return 1;
1933   return 0;
1934 }
1935
1936 static int test_zerofree_0 (void)
1937 {
1938   if (test_zerofree_0_skip ()) {
1939     printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
1940     return 0;
1941   }
1942
1943   /* InitNone|InitEmpty for test_zerofree_0 */
1944   {
1945     char device[] = "/dev/sda";
1946     int r;
1947     suppress_error = 0;
1948     r = guestfs_blockdev_setrw (g, device);
1949     if (r == -1)
1950       return -1;
1951   }
1952   {
1953     int r;
1954     suppress_error = 0;
1955     r = guestfs_umount_all (g);
1956     if (r == -1)
1957       return -1;
1958   }
1959   {
1960     int r;
1961     suppress_error = 0;
1962     r = guestfs_lvm_remove_all (g);
1963     if (r == -1)
1964       return -1;
1965   }
1966   /* TestOutput for zerofree (0) */
1967   char expected[] = "test file";
1968   {
1969     char device[] = "/dev/sda";
1970     char lines_0[] = ",";
1971     char *lines[] = {
1972       lines_0,
1973       NULL
1974     };
1975     int r;
1976     suppress_error = 0;
1977     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1978     if (r == -1)
1979       return -1;
1980   }
1981   {
1982     char fstype[] = "ext3";
1983     char device[] = "/dev/sda1";
1984     int r;
1985     suppress_error = 0;
1986     r = guestfs_mkfs (g, fstype, device);
1987     if (r == -1)
1988       return -1;
1989   }
1990   {
1991     char device[] = "/dev/sda1";
1992     char mountpoint[] = "/";
1993     int r;
1994     suppress_error = 0;
1995     r = guestfs_mount (g, device, mountpoint);
1996     if (r == -1)
1997       return -1;
1998   }
1999   {
2000     char path[] = "/new";
2001     char content[] = "test file";
2002     int r;
2003     suppress_error = 0;
2004     r = guestfs_write_file (g, path, content, 0);
2005     if (r == -1)
2006       return -1;
2007   }
2008   {
2009     char pathordevice[] = "/dev/sda1";
2010     int r;
2011     suppress_error = 0;
2012     r = guestfs_umount (g, pathordevice);
2013     if (r == -1)
2014       return -1;
2015   }
2016   {
2017     char device[] = "/dev/sda1";
2018     int r;
2019     suppress_error = 0;
2020     r = guestfs_zerofree (g, device);
2021     if (r == -1)
2022       return -1;
2023   }
2024   {
2025     char device[] = "/dev/sda1";
2026     char mountpoint[] = "/";
2027     int r;
2028     suppress_error = 0;
2029     r = guestfs_mount (g, device, mountpoint);
2030     if (r == -1)
2031       return -1;
2032   }
2033   {
2034     char path[] = "/new";
2035     char *r;
2036     suppress_error = 0;
2037     r = guestfs_cat (g, path);
2038     if (r == NULL)
2039       return -1;
2040     if (strcmp (r, expected) != 0) {
2041       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
2042       return -1;
2043     }
2044     free (r);
2045   }
2046   return 0;
2047 }
2048
2049 static int test_hexdump_0_skip (void)
2050 {
2051   const char *str;
2052
2053   str = getenv ("TEST_ONLY");
2054   if (str)
2055     return strstr (str, "hexdump") == NULL;
2056   str = getenv ("SKIP_TEST_HEXDUMP_0");
2057   if (str && strcmp (str, "1") == 0) return 1;
2058   str = getenv ("SKIP_TEST_HEXDUMP");
2059   if (str && strcmp (str, "1") == 0) return 1;
2060   return 0;
2061 }
2062
2063 static int test_hexdump_0 (void)
2064 {
2065   if (test_hexdump_0_skip ()) {
2066     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
2067     return 0;
2068   }
2069
2070   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
2071   {
2072     char device[] = "/dev/sda";
2073     int r;
2074     suppress_error = 0;
2075     r = guestfs_blockdev_setrw (g, device);
2076     if (r == -1)
2077       return -1;
2078   }
2079   {
2080     int r;
2081     suppress_error = 0;
2082     r = guestfs_umount_all (g);
2083     if (r == -1)
2084       return -1;
2085   }
2086   {
2087     int r;
2088     suppress_error = 0;
2089     r = guestfs_lvm_remove_all (g);
2090     if (r == -1)
2091       return -1;
2092   }
2093   {
2094     char device[] = "/dev/sda";
2095     char lines_0[] = ",";
2096     char *lines[] = {
2097       lines_0,
2098       NULL
2099     };
2100     int r;
2101     suppress_error = 0;
2102     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2103     if (r == -1)
2104       return -1;
2105   }
2106   {
2107     char fstype[] = "ext2";
2108     char device[] = "/dev/sda1";
2109     int r;
2110     suppress_error = 0;
2111     r = guestfs_mkfs (g, fstype, device);
2112     if (r == -1)
2113       return -1;
2114   }
2115   {
2116     char device[] = "/dev/sda1";
2117     char mountpoint[] = "/";
2118     int r;
2119     suppress_error = 0;
2120     r = guestfs_mount (g, device, mountpoint);
2121     if (r == -1)
2122       return -1;
2123   }
2124   /* TestOutput for hexdump (0) */
2125   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
2126   {
2127     char path[] = "/new";
2128     char content[] = "hello\nworld\n";
2129     int r;
2130     suppress_error = 0;
2131     r = guestfs_write_file (g, path, content, 12);
2132     if (r == -1)
2133       return -1;
2134   }
2135   {
2136     char path[] = "/new";
2137     char *r;
2138     suppress_error = 0;
2139     r = guestfs_hexdump (g, path);
2140     if (r == NULL)
2141       return -1;
2142     if (strcmp (r, expected) != 0) {
2143       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
2144       return -1;
2145     }
2146     free (r);
2147   }
2148   return 0;
2149 }
2150
2151 static int test_hexdump_1_skip (void)
2152 {
2153   const char *str;
2154
2155   str = getenv ("TEST_ONLY");
2156   if (str)
2157     return strstr (str, "hexdump") == NULL;
2158   str = getenv ("SKIP_TEST_HEXDUMP_1");
2159   if (str && strcmp (str, "1") == 0) return 1;
2160   str = getenv ("SKIP_TEST_HEXDUMP");
2161   if (str && strcmp (str, "1") == 0) return 1;
2162   return 0;
2163 }
2164
2165 static int test_hexdump_1 (void)
2166 {
2167   if (test_hexdump_1_skip ()) {
2168     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
2169     return 0;
2170   }
2171
2172   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
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   {
2196     char device[] = "/dev/sda";
2197     char lines_0[] = ",";
2198     char *lines[] = {
2199       lines_0,
2200       NULL
2201     };
2202     int r;
2203     suppress_error = 0;
2204     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2205     if (r == -1)
2206       return -1;
2207   }
2208   {
2209     char fstype[] = "ext2";
2210     char device[] = "/dev/sda1";
2211     int r;
2212     suppress_error = 0;
2213     r = guestfs_mkfs (g, fstype, device);
2214     if (r == -1)
2215       return -1;
2216   }
2217   {
2218     char device[] = "/dev/sda1";
2219     char mountpoint[] = "/";
2220     int r;
2221     suppress_error = 0;
2222     r = guestfs_mount (g, device, mountpoint);
2223     if (r == -1)
2224       return -1;
2225   }
2226   /* TestRun for hexdump (1) */
2227   {
2228     char options[] = "ro";
2229     char vfstype[] = "squashfs";
2230     char device[] = "/dev/sdd";
2231     char mountpoint[] = "/";
2232     int r;
2233     suppress_error = 0;
2234     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2235     if (r == -1)
2236       return -1;
2237   }
2238   {
2239     char path[] = "/100krandom";
2240     char *r;
2241     suppress_error = 0;
2242     r = guestfs_hexdump (g, path);
2243     if (r == NULL)
2244       return -1;
2245     free (r);
2246   }
2247   return 0;
2248 }
2249
2250 static int test_strings_e_0_skip (void)
2251 {
2252   const char *str;
2253
2254   str = getenv ("TEST_ONLY");
2255   if (str)
2256     return strstr (str, "strings_e") == NULL;
2257   str = getenv ("SKIP_TEST_STRINGS_E_0");
2258   if (str && strcmp (str, "1") == 0) return 1;
2259   str = getenv ("SKIP_TEST_STRINGS_E");
2260   if (str && strcmp (str, "1") == 0) return 1;
2261   return 0;
2262 }
2263
2264 static int test_strings_e_0 (void)
2265 {
2266   if (test_strings_e_0_skip ()) {
2267     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
2268     return 0;
2269   }
2270
2271   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
2272   {
2273     char device[] = "/dev/sda";
2274     int r;
2275     suppress_error = 0;
2276     r = guestfs_blockdev_setrw (g, device);
2277     if (r == -1)
2278       return -1;
2279   }
2280   {
2281     int r;
2282     suppress_error = 0;
2283     r = guestfs_umount_all (g);
2284     if (r == -1)
2285       return -1;
2286   }
2287   {
2288     int r;
2289     suppress_error = 0;
2290     r = guestfs_lvm_remove_all (g);
2291     if (r == -1)
2292       return -1;
2293   }
2294   {
2295     char device[] = "/dev/sda";
2296     char lines_0[] = ",";
2297     char *lines[] = {
2298       lines_0,
2299       NULL
2300     };
2301     int r;
2302     suppress_error = 0;
2303     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2304     if (r == -1)
2305       return -1;
2306   }
2307   {
2308     char fstype[] = "ext2";
2309     char device[] = "/dev/sda1";
2310     int r;
2311     suppress_error = 0;
2312     r = guestfs_mkfs (g, fstype, device);
2313     if (r == -1)
2314       return -1;
2315   }
2316   {
2317     char device[] = "/dev/sda1";
2318     char mountpoint[] = "/";
2319     int r;
2320     suppress_error = 0;
2321     r = guestfs_mount (g, device, mountpoint);
2322     if (r == -1)
2323       return -1;
2324   }
2325   /* TestOutputList for strings_e (0) */
2326   {
2327     char path[] = "/new";
2328     char content[] = "hello\nworld\n";
2329     int r;
2330     suppress_error = 0;
2331     r = guestfs_write_file (g, path, content, 0);
2332     if (r == -1)
2333       return -1;
2334   }
2335   {
2336     char encoding[] = "b";
2337     char path[] = "/new";
2338     char **r;
2339     int i;
2340     suppress_error = 0;
2341     r = guestfs_strings_e (g, encoding, path);
2342     if (r == NULL)
2343       return -1;
2344     if (r[0] != NULL) {
2345       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
2346       print_strings (r);
2347       return -1;
2348     }
2349     for (i = 0; r[i] != NULL; ++i)
2350       free (r[i]);
2351     free (r);
2352   }
2353   return 0;
2354 }
2355
2356 static int test_strings_e_1_skip (void)
2357 {
2358   const char *str;
2359
2360   str = getenv ("TEST_ONLY");
2361   if (str)
2362     return strstr (str, "strings_e") == NULL;
2363   str = getenv ("SKIP_TEST_STRINGS_E_1");
2364   if (str && strcmp (str, "1") == 0) return 1;
2365   str = getenv ("SKIP_TEST_STRINGS_E");
2366   if (str && strcmp (str, "1") == 0) return 1;
2367   return 0;
2368 }
2369
2370 static int test_strings_e_1 (void)
2371 {
2372   if (test_strings_e_1_skip ()) {
2373     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
2374     return 0;
2375   }
2376
2377   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
2378   return 0;
2379 }
2380
2381 static int test_strings_0_skip (void)
2382 {
2383   const char *str;
2384
2385   str = getenv ("TEST_ONLY");
2386   if (str)
2387     return strstr (str, "strings") == NULL;
2388   str = getenv ("SKIP_TEST_STRINGS_0");
2389   if (str && strcmp (str, "1") == 0) return 1;
2390   str = getenv ("SKIP_TEST_STRINGS");
2391   if (str && strcmp (str, "1") == 0) return 1;
2392   return 0;
2393 }
2394
2395 static int test_strings_0 (void)
2396 {
2397   if (test_strings_0_skip ()) {
2398     printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
2399     return 0;
2400   }
2401
2402   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
2403   {
2404     char device[] = "/dev/sda";
2405     int r;
2406     suppress_error = 0;
2407     r = guestfs_blockdev_setrw (g, device);
2408     if (r == -1)
2409       return -1;
2410   }
2411   {
2412     int r;
2413     suppress_error = 0;
2414     r = guestfs_umount_all (g);
2415     if (r == -1)
2416       return -1;
2417   }
2418   {
2419     int r;
2420     suppress_error = 0;
2421     r = guestfs_lvm_remove_all (g);
2422     if (r == -1)
2423       return -1;
2424   }
2425   {
2426     char device[] = "/dev/sda";
2427     char lines_0[] = ",";
2428     char *lines[] = {
2429       lines_0,
2430       NULL
2431     };
2432     int r;
2433     suppress_error = 0;
2434     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2435     if (r == -1)
2436       return -1;
2437   }
2438   {
2439     char fstype[] = "ext2";
2440     char device[] = "/dev/sda1";
2441     int r;
2442     suppress_error = 0;
2443     r = guestfs_mkfs (g, fstype, device);
2444     if (r == -1)
2445       return -1;
2446   }
2447   {
2448     char device[] = "/dev/sda1";
2449     char mountpoint[] = "/";
2450     int r;
2451     suppress_error = 0;
2452     r = guestfs_mount (g, device, mountpoint);
2453     if (r == -1)
2454       return -1;
2455   }
2456   /* TestOutputList for strings (0) */
2457   {
2458     char path[] = "/new";
2459     char content[] = "hello\nworld\n";
2460     int r;
2461     suppress_error = 0;
2462     r = guestfs_write_file (g, path, content, 0);
2463     if (r == -1)
2464       return -1;
2465   }
2466   {
2467     char path[] = "/new";
2468     char **r;
2469     int i;
2470     suppress_error = 0;
2471     r = guestfs_strings (g, path);
2472     if (r == NULL)
2473       return -1;
2474     if (!r[0]) {
2475       fprintf (stderr, "test_strings_0: short list returned from command\n");
2476       print_strings (r);
2477       return -1;
2478     }
2479     {
2480       char expected[] = "hello";
2481       if (strcmp (r[0], expected) != 0) {
2482         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2483         return -1;
2484       }
2485     }
2486     if (!r[1]) {
2487       fprintf (stderr, "test_strings_0: short list returned from command\n");
2488       print_strings (r);
2489       return -1;
2490     }
2491     {
2492       char expected[] = "world";
2493       if (strcmp (r[1], expected) != 0) {
2494         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2495         return -1;
2496       }
2497     }
2498     if (r[2] != NULL) {
2499       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
2500       print_strings (r);
2501       return -1;
2502     }
2503     for (i = 0; r[i] != NULL; ++i)
2504       free (r[i]);
2505     free (r);
2506   }
2507   return 0;
2508 }
2509
2510 static int test_strings_1_skip (void)
2511 {
2512   const char *str;
2513
2514   str = getenv ("TEST_ONLY");
2515   if (str)
2516     return strstr (str, "strings") == NULL;
2517   str = getenv ("SKIP_TEST_STRINGS_1");
2518   if (str && strcmp (str, "1") == 0) return 1;
2519   str = getenv ("SKIP_TEST_STRINGS");
2520   if (str && strcmp (str, "1") == 0) return 1;
2521   return 0;
2522 }
2523
2524 static int test_strings_1 (void)
2525 {
2526   if (test_strings_1_skip ()) {
2527     printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
2528     return 0;
2529   }
2530
2531   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
2532   {
2533     char device[] = "/dev/sda";
2534     int r;
2535     suppress_error = 0;
2536     r = guestfs_blockdev_setrw (g, device);
2537     if (r == -1)
2538       return -1;
2539   }
2540   {
2541     int r;
2542     suppress_error = 0;
2543     r = guestfs_umount_all (g);
2544     if (r == -1)
2545       return -1;
2546   }
2547   {
2548     int r;
2549     suppress_error = 0;
2550     r = guestfs_lvm_remove_all (g);
2551     if (r == -1)
2552       return -1;
2553   }
2554   {
2555     char device[] = "/dev/sda";
2556     char lines_0[] = ",";
2557     char *lines[] = {
2558       lines_0,
2559       NULL
2560     };
2561     int r;
2562     suppress_error = 0;
2563     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2564     if (r == -1)
2565       return -1;
2566   }
2567   {
2568     char fstype[] = "ext2";
2569     char device[] = "/dev/sda1";
2570     int r;
2571     suppress_error = 0;
2572     r = guestfs_mkfs (g, fstype, device);
2573     if (r == -1)
2574       return -1;
2575   }
2576   {
2577     char device[] = "/dev/sda1";
2578     char mountpoint[] = "/";
2579     int r;
2580     suppress_error = 0;
2581     r = guestfs_mount (g, device, mountpoint);
2582     if (r == -1)
2583       return -1;
2584   }
2585   /* TestOutputList for strings (1) */
2586   {
2587     char path[] = "/new";
2588     int r;
2589     suppress_error = 0;
2590     r = guestfs_touch (g, path);
2591     if (r == -1)
2592       return -1;
2593   }
2594   {
2595     char path[] = "/new";
2596     char **r;
2597     int i;
2598     suppress_error = 0;
2599     r = guestfs_strings (g, path);
2600     if (r == NULL)
2601       return -1;
2602     if (r[0] != NULL) {
2603       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
2604       print_strings (r);
2605       return -1;
2606     }
2607     for (i = 0; r[i] != NULL; ++i)
2608       free (r[i]);
2609     free (r);
2610   }
2611   return 0;
2612 }
2613
2614 static int test_equal_0_skip (void)
2615 {
2616   const char *str;
2617
2618   str = getenv ("TEST_ONLY");
2619   if (str)
2620     return strstr (str, "equal") == NULL;
2621   str = getenv ("SKIP_TEST_EQUAL_0");
2622   if (str && strcmp (str, "1") == 0) return 1;
2623   str = getenv ("SKIP_TEST_EQUAL");
2624   if (str && strcmp (str, "1") == 0) return 1;
2625   return 0;
2626 }
2627
2628 static int test_equal_0 (void)
2629 {
2630   if (test_equal_0_skip ()) {
2631     printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
2632     return 0;
2633   }
2634
2635   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
2636   {
2637     char device[] = "/dev/sda";
2638     int r;
2639     suppress_error = 0;
2640     r = guestfs_blockdev_setrw (g, device);
2641     if (r == -1)
2642       return -1;
2643   }
2644   {
2645     int r;
2646     suppress_error = 0;
2647     r = guestfs_umount_all (g);
2648     if (r == -1)
2649       return -1;
2650   }
2651   {
2652     int r;
2653     suppress_error = 0;
2654     r = guestfs_lvm_remove_all (g);
2655     if (r == -1)
2656       return -1;
2657   }
2658   {
2659     char device[] = "/dev/sda";
2660     char lines_0[] = ",";
2661     char *lines[] = {
2662       lines_0,
2663       NULL
2664     };
2665     int r;
2666     suppress_error = 0;
2667     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2668     if (r == -1)
2669       return -1;
2670   }
2671   {
2672     char fstype[] = "ext2";
2673     char device[] = "/dev/sda1";
2674     int r;
2675     suppress_error = 0;
2676     r = guestfs_mkfs (g, fstype, device);
2677     if (r == -1)
2678       return -1;
2679   }
2680   {
2681     char device[] = "/dev/sda1";
2682     char mountpoint[] = "/";
2683     int r;
2684     suppress_error = 0;
2685     r = guestfs_mount (g, device, mountpoint);
2686     if (r == -1)
2687       return -1;
2688   }
2689   /* TestOutputTrue for equal (0) */
2690   {
2691     char path[] = "/file1";
2692     char content[] = "contents of a file";
2693     int r;
2694     suppress_error = 0;
2695     r = guestfs_write_file (g, path, content, 0);
2696     if (r == -1)
2697       return -1;
2698   }
2699   {
2700     char src[] = "/file1";
2701     char dest[] = "/file2";
2702     int r;
2703     suppress_error = 0;
2704     r = guestfs_cp (g, src, dest);
2705     if (r == -1)
2706       return -1;
2707   }
2708   {
2709     char file1[] = "/file1";
2710     char file2[] = "/file2";
2711     int r;
2712     suppress_error = 0;
2713     r = guestfs_equal (g, file1, file2);
2714     if (r == -1)
2715       return -1;
2716     if (!r) {
2717       fprintf (stderr, "test_equal_0: expected true, got false\n");
2718       return -1;
2719     }
2720   }
2721   return 0;
2722 }
2723
2724 static int test_equal_1_skip (void)
2725 {
2726   const char *str;
2727
2728   str = getenv ("TEST_ONLY");
2729   if (str)
2730     return strstr (str, "equal") == NULL;
2731   str = getenv ("SKIP_TEST_EQUAL_1");
2732   if (str && strcmp (str, "1") == 0) return 1;
2733   str = getenv ("SKIP_TEST_EQUAL");
2734   if (str && strcmp (str, "1") == 0) return 1;
2735   return 0;
2736 }
2737
2738 static int test_equal_1 (void)
2739 {
2740   if (test_equal_1_skip ()) {
2741     printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
2742     return 0;
2743   }
2744
2745   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2746   {
2747     char device[] = "/dev/sda";
2748     int r;
2749     suppress_error = 0;
2750     r = guestfs_blockdev_setrw (g, device);
2751     if (r == -1)
2752       return -1;
2753   }
2754   {
2755     int r;
2756     suppress_error = 0;
2757     r = guestfs_umount_all (g);
2758     if (r == -1)
2759       return -1;
2760   }
2761   {
2762     int r;
2763     suppress_error = 0;
2764     r = guestfs_lvm_remove_all (g);
2765     if (r == -1)
2766       return -1;
2767   }
2768   {
2769     char device[] = "/dev/sda";
2770     char lines_0[] = ",";
2771     char *lines[] = {
2772       lines_0,
2773       NULL
2774     };
2775     int r;
2776     suppress_error = 0;
2777     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2778     if (r == -1)
2779       return -1;
2780   }
2781   {
2782     char fstype[] = "ext2";
2783     char device[] = "/dev/sda1";
2784     int r;
2785     suppress_error = 0;
2786     r = guestfs_mkfs (g, fstype, device);
2787     if (r == -1)
2788       return -1;
2789   }
2790   {
2791     char device[] = "/dev/sda1";
2792     char mountpoint[] = "/";
2793     int r;
2794     suppress_error = 0;
2795     r = guestfs_mount (g, device, mountpoint);
2796     if (r == -1)
2797       return -1;
2798   }
2799   /* TestOutputFalse for equal (1) */
2800   {
2801     char path[] = "/file1";
2802     char content[] = "contents of a file";
2803     int r;
2804     suppress_error = 0;
2805     r = guestfs_write_file (g, path, content, 0);
2806     if (r == -1)
2807       return -1;
2808   }
2809   {
2810     char path[] = "/file2";
2811     char content[] = "contents of another file";
2812     int r;
2813     suppress_error = 0;
2814     r = guestfs_write_file (g, path, content, 0);
2815     if (r == -1)
2816       return -1;
2817   }
2818   {
2819     char file1[] = "/file1";
2820     char file2[] = "/file2";
2821     int r;
2822     suppress_error = 0;
2823     r = guestfs_equal (g, file1, file2);
2824     if (r == -1)
2825       return -1;
2826     if (r) {
2827       fprintf (stderr, "test_equal_1: expected false, got true\n");
2828       return -1;
2829     }
2830   }
2831   return 0;
2832 }
2833
2834 static int test_equal_2_skip (void)
2835 {
2836   const char *str;
2837
2838   str = getenv ("TEST_ONLY");
2839   if (str)
2840     return strstr (str, "equal") == NULL;
2841   str = getenv ("SKIP_TEST_EQUAL_2");
2842   if (str && strcmp (str, "1") == 0) return 1;
2843   str = getenv ("SKIP_TEST_EQUAL");
2844   if (str && strcmp (str, "1") == 0) return 1;
2845   return 0;
2846 }
2847
2848 static int test_equal_2 (void)
2849 {
2850   if (test_equal_2_skip ()) {
2851     printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
2852     return 0;
2853   }
2854
2855   /* InitBasicFS for test_equal_2: 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   /* TestLastFail for equal (2) */
2910   {
2911     char file1[] = "/file1";
2912     char file2[] = "/file2";
2913     int r;
2914     suppress_error = 1;
2915     r = guestfs_equal (g, file1, file2);
2916     if (r != -1)
2917       return -1;
2918   }
2919   return 0;
2920 }
2921
2922 static int test_ping_daemon_0_skip (void)
2923 {
2924   const char *str;
2925
2926   str = getenv ("TEST_ONLY");
2927   if (str)
2928     return strstr (str, "ping_daemon") == NULL;
2929   str = getenv ("SKIP_TEST_PING_DAEMON_0");
2930   if (str && strcmp (str, "1") == 0) return 1;
2931   str = getenv ("SKIP_TEST_PING_DAEMON");
2932   if (str && strcmp (str, "1") == 0) return 1;
2933   return 0;
2934 }
2935
2936 static int test_ping_daemon_0 (void)
2937 {
2938   if (test_ping_daemon_0_skip ()) {
2939     printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
2940     return 0;
2941   }
2942
2943   /* InitNone|InitEmpty for test_ping_daemon_0 */
2944   {
2945     char device[] = "/dev/sda";
2946     int r;
2947     suppress_error = 0;
2948     r = guestfs_blockdev_setrw (g, device);
2949     if (r == -1)
2950       return -1;
2951   }
2952   {
2953     int r;
2954     suppress_error = 0;
2955     r = guestfs_umount_all (g);
2956     if (r == -1)
2957       return -1;
2958   }
2959   {
2960     int r;
2961     suppress_error = 0;
2962     r = guestfs_lvm_remove_all (g);
2963     if (r == -1)
2964       return -1;
2965   }
2966   /* TestRun for ping_daemon (0) */
2967   {
2968     int r;
2969     suppress_error = 0;
2970     r = guestfs_ping_daemon (g);
2971     if (r == -1)
2972       return -1;
2973   }
2974   return 0;
2975 }
2976
2977 static int test_dmesg_0_skip (void)
2978 {
2979   const char *str;
2980
2981   str = getenv ("TEST_ONLY");
2982   if (str)
2983     return strstr (str, "dmesg") == NULL;
2984   str = getenv ("SKIP_TEST_DMESG_0");
2985   if (str && strcmp (str, "1") == 0) return 1;
2986   str = getenv ("SKIP_TEST_DMESG");
2987   if (str && strcmp (str, "1") == 0) return 1;
2988   return 0;
2989 }
2990
2991 static int test_dmesg_0 (void)
2992 {
2993   if (test_dmesg_0_skip ()) {
2994     printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
2995     return 0;
2996   }
2997
2998   /* InitNone|InitEmpty for test_dmesg_0 */
2999   {
3000     char device[] = "/dev/sda";
3001     int r;
3002     suppress_error = 0;
3003     r = guestfs_blockdev_setrw (g, device);
3004     if (r == -1)
3005       return -1;
3006   }
3007   {
3008     int r;
3009     suppress_error = 0;
3010     r = guestfs_umount_all (g);
3011     if (r == -1)
3012       return -1;
3013   }
3014   {
3015     int r;
3016     suppress_error = 0;
3017     r = guestfs_lvm_remove_all (g);
3018     if (r == -1)
3019       return -1;
3020   }
3021   /* TestRun for dmesg (0) */
3022   {
3023     char *r;
3024     suppress_error = 0;
3025     r = guestfs_dmesg (g);
3026     if (r == NULL)
3027       return -1;
3028     free (r);
3029   }
3030   return 0;
3031 }
3032
3033 static int test_drop_caches_0_skip (void)
3034 {
3035   const char *str;
3036
3037   str = getenv ("TEST_ONLY");
3038   if (str)
3039     return strstr (str, "drop_caches") == NULL;
3040   str = getenv ("SKIP_TEST_DROP_CACHES_0");
3041   if (str && strcmp (str, "1") == 0) return 1;
3042   str = getenv ("SKIP_TEST_DROP_CACHES");
3043   if (str && strcmp (str, "1") == 0) return 1;
3044   return 0;
3045 }
3046
3047 static int test_drop_caches_0 (void)
3048 {
3049   if (test_drop_caches_0_skip ()) {
3050     printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
3051     return 0;
3052   }
3053
3054   /* InitNone|InitEmpty for test_drop_caches_0 */
3055   {
3056     char device[] = "/dev/sda";
3057     int r;
3058     suppress_error = 0;
3059     r = guestfs_blockdev_setrw (g, device);
3060     if (r == -1)
3061       return -1;
3062   }
3063   {
3064     int r;
3065     suppress_error = 0;
3066     r = guestfs_umount_all (g);
3067     if (r == -1)
3068       return -1;
3069   }
3070   {
3071     int r;
3072     suppress_error = 0;
3073     r = guestfs_lvm_remove_all (g);
3074     if (r == -1)
3075       return -1;
3076   }
3077   /* TestRun for drop_caches (0) */
3078   {
3079     int r;
3080     suppress_error = 0;
3081     r = guestfs_drop_caches (g, 3);
3082     if (r == -1)
3083       return -1;
3084   }
3085   return 0;
3086 }
3087
3088 static int test_mv_0_skip (void)
3089 {
3090   const char *str;
3091
3092   str = getenv ("TEST_ONLY");
3093   if (str)
3094     return strstr (str, "mv") == NULL;
3095   str = getenv ("SKIP_TEST_MV_0");
3096   if (str && strcmp (str, "1") == 0) return 1;
3097   str = getenv ("SKIP_TEST_MV");
3098   if (str && strcmp (str, "1") == 0) return 1;
3099   return 0;
3100 }
3101
3102 static int test_mv_0 (void)
3103 {
3104   if (test_mv_0_skip ()) {
3105     printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
3106     return 0;
3107   }
3108
3109   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
3110   {
3111     char device[] = "/dev/sda";
3112     int r;
3113     suppress_error = 0;
3114     r = guestfs_blockdev_setrw (g, device);
3115     if (r == -1)
3116       return -1;
3117   }
3118   {
3119     int r;
3120     suppress_error = 0;
3121     r = guestfs_umount_all (g);
3122     if (r == -1)
3123       return -1;
3124   }
3125   {
3126     int r;
3127     suppress_error = 0;
3128     r = guestfs_lvm_remove_all (g);
3129     if (r == -1)
3130       return -1;
3131   }
3132   {
3133     char device[] = "/dev/sda";
3134     char lines_0[] = ",";
3135     char *lines[] = {
3136       lines_0,
3137       NULL
3138     };
3139     int r;
3140     suppress_error = 0;
3141     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3142     if (r == -1)
3143       return -1;
3144   }
3145   {
3146     char fstype[] = "ext2";
3147     char device[] = "/dev/sda1";
3148     int r;
3149     suppress_error = 0;
3150     r = guestfs_mkfs (g, fstype, device);
3151     if (r == -1)
3152       return -1;
3153   }
3154   {
3155     char device[] = "/dev/sda1";
3156     char mountpoint[] = "/";
3157     int r;
3158     suppress_error = 0;
3159     r = guestfs_mount (g, device, mountpoint);
3160     if (r == -1)
3161       return -1;
3162   }
3163   /* TestOutput for mv (0) */
3164   char expected[] = "file content";
3165   {
3166     char path[] = "/old";
3167     char content[] = "file content";
3168     int r;
3169     suppress_error = 0;
3170     r = guestfs_write_file (g, path, content, 0);
3171     if (r == -1)
3172       return -1;
3173   }
3174   {
3175     char src[] = "/old";
3176     char dest[] = "/new";
3177     int r;
3178     suppress_error = 0;
3179     r = guestfs_mv (g, src, dest);
3180     if (r == -1)
3181       return -1;
3182   }
3183   {
3184     char path[] = "/new";
3185     char *r;
3186     suppress_error = 0;
3187     r = guestfs_cat (g, path);
3188     if (r == NULL)
3189       return -1;
3190     if (strcmp (r, expected) != 0) {
3191       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
3192       return -1;
3193     }
3194     free (r);
3195   }
3196   return 0;
3197 }
3198
3199 static int test_mv_1_skip (void)
3200 {
3201   const char *str;
3202
3203   str = getenv ("TEST_ONLY");
3204   if (str)
3205     return strstr (str, "mv") == NULL;
3206   str = getenv ("SKIP_TEST_MV_1");
3207   if (str && strcmp (str, "1") == 0) return 1;
3208   str = getenv ("SKIP_TEST_MV");
3209   if (str && strcmp (str, "1") == 0) return 1;
3210   return 0;
3211 }
3212
3213 static int test_mv_1 (void)
3214 {
3215   if (test_mv_1_skip ()) {
3216     printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
3217     return 0;
3218   }
3219
3220   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
3221   {
3222     char device[] = "/dev/sda";
3223     int r;
3224     suppress_error = 0;
3225     r = guestfs_blockdev_setrw (g, device);
3226     if (r == -1)
3227       return -1;
3228   }
3229   {
3230     int r;
3231     suppress_error = 0;
3232     r = guestfs_umount_all (g);
3233     if (r == -1)
3234       return -1;
3235   }
3236   {
3237     int r;
3238     suppress_error = 0;
3239     r = guestfs_lvm_remove_all (g);
3240     if (r == -1)
3241       return -1;
3242   }
3243   {
3244     char device[] = "/dev/sda";
3245     char lines_0[] = ",";
3246     char *lines[] = {
3247       lines_0,
3248       NULL
3249     };
3250     int r;
3251     suppress_error = 0;
3252     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3253     if (r == -1)
3254       return -1;
3255   }
3256   {
3257     char fstype[] = "ext2";
3258     char device[] = "/dev/sda1";
3259     int r;
3260     suppress_error = 0;
3261     r = guestfs_mkfs (g, fstype, device);
3262     if (r == -1)
3263       return -1;
3264   }
3265   {
3266     char device[] = "/dev/sda1";
3267     char mountpoint[] = "/";
3268     int r;
3269     suppress_error = 0;
3270     r = guestfs_mount (g, device, mountpoint);
3271     if (r == -1)
3272       return -1;
3273   }
3274   /* TestOutputFalse for mv (1) */
3275   {
3276     char path[] = "/old";
3277     char content[] = "file content";
3278     int r;
3279     suppress_error = 0;
3280     r = guestfs_write_file (g, path, content, 0);
3281     if (r == -1)
3282       return -1;
3283   }
3284   {
3285     char src[] = "/old";
3286     char dest[] = "/new";
3287     int r;
3288     suppress_error = 0;
3289     r = guestfs_mv (g, src, dest);
3290     if (r == -1)
3291       return -1;
3292   }
3293   {
3294     char path[] = "/old";
3295     int r;
3296     suppress_error = 0;
3297     r = guestfs_is_file (g, path);
3298     if (r == -1)
3299       return -1;
3300     if (r) {
3301       fprintf (stderr, "test_mv_1: expected false, got true\n");
3302       return -1;
3303     }
3304   }
3305   return 0;
3306 }
3307
3308 static int test_cp_a_0_skip (void)
3309 {
3310   const char *str;
3311
3312   str = getenv ("TEST_ONLY");
3313   if (str)
3314     return strstr (str, "cp_a") == NULL;
3315   str = getenv ("SKIP_TEST_CP_A_0");
3316   if (str && strcmp (str, "1") == 0) return 1;
3317   str = getenv ("SKIP_TEST_CP_A");
3318   if (str && strcmp (str, "1") == 0) return 1;
3319   return 0;
3320 }
3321
3322 static int test_cp_a_0 (void)
3323 {
3324   if (test_cp_a_0_skip ()) {
3325     printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
3326     return 0;
3327   }
3328
3329   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
3330   {
3331     char device[] = "/dev/sda";
3332     int r;
3333     suppress_error = 0;
3334     r = guestfs_blockdev_setrw (g, device);
3335     if (r == -1)
3336       return -1;
3337   }
3338   {
3339     int r;
3340     suppress_error = 0;
3341     r = guestfs_umount_all (g);
3342     if (r == -1)
3343       return -1;
3344   }
3345   {
3346     int r;
3347     suppress_error = 0;
3348     r = guestfs_lvm_remove_all (g);
3349     if (r == -1)
3350       return -1;
3351   }
3352   {
3353     char device[] = "/dev/sda";
3354     char lines_0[] = ",";
3355     char *lines[] = {
3356       lines_0,
3357       NULL
3358     };
3359     int r;
3360     suppress_error = 0;
3361     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3362     if (r == -1)
3363       return -1;
3364   }
3365   {
3366     char fstype[] = "ext2";
3367     char device[] = "/dev/sda1";
3368     int r;
3369     suppress_error = 0;
3370     r = guestfs_mkfs (g, fstype, device);
3371     if (r == -1)
3372       return -1;
3373   }
3374   {
3375     char device[] = "/dev/sda1";
3376     char mountpoint[] = "/";
3377     int r;
3378     suppress_error = 0;
3379     r = guestfs_mount (g, device, mountpoint);
3380     if (r == -1)
3381       return -1;
3382   }
3383   /* TestOutput for cp_a (0) */
3384   char expected[] = "file content";
3385   {
3386     char path[] = "/olddir";
3387     int r;
3388     suppress_error = 0;
3389     r = guestfs_mkdir (g, path);
3390     if (r == -1)
3391       return -1;
3392   }
3393   {
3394     char path[] = "/newdir";
3395     int r;
3396     suppress_error = 0;
3397     r = guestfs_mkdir (g, path);
3398     if (r == -1)
3399       return -1;
3400   }
3401   {
3402     char path[] = "/olddir/file";
3403     char content[] = "file content";
3404     int r;
3405     suppress_error = 0;
3406     r = guestfs_write_file (g, path, content, 0);
3407     if (r == -1)
3408       return -1;
3409   }
3410   {
3411     char src[] = "/olddir";
3412     char dest[] = "/newdir";
3413     int r;
3414     suppress_error = 0;
3415     r = guestfs_cp_a (g, src, dest);
3416     if (r == -1)
3417       return -1;
3418   }
3419   {
3420     char path[] = "/newdir/olddir/file";
3421     char *r;
3422     suppress_error = 0;
3423     r = guestfs_cat (g, path);
3424     if (r == NULL)
3425       return -1;
3426     if (strcmp (r, expected) != 0) {
3427       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
3428       return -1;
3429     }
3430     free (r);
3431   }
3432   return 0;
3433 }
3434
3435 static int test_cp_0_skip (void)
3436 {
3437   const char *str;
3438
3439   str = getenv ("TEST_ONLY");
3440   if (str)
3441     return strstr (str, "cp") == NULL;
3442   str = getenv ("SKIP_TEST_CP_0");
3443   if (str && strcmp (str, "1") == 0) return 1;
3444   str = getenv ("SKIP_TEST_CP");
3445   if (str && strcmp (str, "1") == 0) return 1;
3446   return 0;
3447 }
3448
3449 static int test_cp_0 (void)
3450 {
3451   if (test_cp_0_skip ()) {
3452     printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
3453     return 0;
3454   }
3455
3456   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
3457   {
3458     char device[] = "/dev/sda";
3459     int r;
3460     suppress_error = 0;
3461     r = guestfs_blockdev_setrw (g, device);
3462     if (r == -1)
3463       return -1;
3464   }
3465   {
3466     int r;
3467     suppress_error = 0;
3468     r = guestfs_umount_all (g);
3469     if (r == -1)
3470       return -1;
3471   }
3472   {
3473     int r;
3474     suppress_error = 0;
3475     r = guestfs_lvm_remove_all (g);
3476     if (r == -1)
3477       return -1;
3478   }
3479   {
3480     char device[] = "/dev/sda";
3481     char lines_0[] = ",";
3482     char *lines[] = {
3483       lines_0,
3484       NULL
3485     };
3486     int r;
3487     suppress_error = 0;
3488     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3489     if (r == -1)
3490       return -1;
3491   }
3492   {
3493     char fstype[] = "ext2";
3494     char device[] = "/dev/sda1";
3495     int r;
3496     suppress_error = 0;
3497     r = guestfs_mkfs (g, fstype, device);
3498     if (r == -1)
3499       return -1;
3500   }
3501   {
3502     char device[] = "/dev/sda1";
3503     char mountpoint[] = "/";
3504     int r;
3505     suppress_error = 0;
3506     r = guestfs_mount (g, device, mountpoint);
3507     if (r == -1)
3508       return -1;
3509   }
3510   /* TestOutput for cp (0) */
3511   char expected[] = "file content";
3512   {
3513     char path[] = "/old";
3514     char content[] = "file content";
3515     int r;
3516     suppress_error = 0;
3517     r = guestfs_write_file (g, path, content, 0);
3518     if (r == -1)
3519       return -1;
3520   }
3521   {
3522     char src[] = "/old";
3523     char dest[] = "/new";
3524     int r;
3525     suppress_error = 0;
3526     r = guestfs_cp (g, src, dest);
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_cp_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_cp_1_skip (void)
3547 {
3548   const char *str;
3549
3550   str = getenv ("TEST_ONLY");
3551   if (str)
3552     return strstr (str, "cp") == NULL;
3553   str = getenv ("SKIP_TEST_CP_1");
3554   if (str && strcmp (str, "1") == 0) return 1;
3555   str = getenv ("SKIP_TEST_CP");
3556   if (str && strcmp (str, "1") == 0) return 1;
3557   return 0;
3558 }
3559
3560 static int test_cp_1 (void)
3561 {
3562   if (test_cp_1_skip ()) {
3563     printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
3564     return 0;
3565   }
3566
3567   /* InitBasicFS for test_cp_1: 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   /* TestOutputTrue for cp (1) */
3622   {
3623     char path[] = "/old";
3624     char content[] = "file content";
3625     int r;
3626     suppress_error = 0;
3627     r = guestfs_write_file (g, path, content, 0);
3628     if (r == -1)
3629       return -1;
3630   }
3631   {
3632     char src[] = "/old";
3633     char dest[] = "/new";
3634     int r;
3635     suppress_error = 0;
3636     r = guestfs_cp (g, src, dest);
3637     if (r == -1)
3638       return -1;
3639   }
3640   {
3641     char path[] = "/old";
3642     int r;
3643     suppress_error = 0;
3644     r = guestfs_is_file (g, path);
3645     if (r == -1)
3646       return -1;
3647     if (!r) {
3648       fprintf (stderr, "test_cp_1: expected true, got false\n");
3649       return -1;
3650     }
3651   }
3652   return 0;
3653 }
3654
3655 static int test_cp_2_skip (void)
3656 {
3657   const char *str;
3658
3659   str = getenv ("TEST_ONLY");
3660   if (str)
3661     return strstr (str, "cp") == NULL;
3662   str = getenv ("SKIP_TEST_CP_2");
3663   if (str && strcmp (str, "1") == 0) return 1;
3664   str = getenv ("SKIP_TEST_CP");
3665   if (str && strcmp (str, "1") == 0) return 1;
3666   return 0;
3667 }
3668
3669 static int test_cp_2 (void)
3670 {
3671   if (test_cp_2_skip ()) {
3672     printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
3673     return 0;
3674   }
3675
3676   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
3677   {
3678     char device[] = "/dev/sda";
3679     int r;
3680     suppress_error = 0;
3681     r = guestfs_blockdev_setrw (g, device);
3682     if (r == -1)
3683       return -1;
3684   }
3685   {
3686     int r;
3687     suppress_error = 0;
3688     r = guestfs_umount_all (g);
3689     if (r == -1)
3690       return -1;
3691   }
3692   {
3693     int r;
3694     suppress_error = 0;
3695     r = guestfs_lvm_remove_all (g);
3696     if (r == -1)
3697       return -1;
3698   }
3699   {
3700     char device[] = "/dev/sda";
3701     char lines_0[] = ",";
3702     char *lines[] = {
3703       lines_0,
3704       NULL
3705     };
3706     int r;
3707     suppress_error = 0;
3708     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3709     if (r == -1)
3710       return -1;
3711   }
3712   {
3713     char fstype[] = "ext2";
3714     char device[] = "/dev/sda1";
3715     int r;
3716     suppress_error = 0;
3717     r = guestfs_mkfs (g, fstype, device);
3718     if (r == -1)
3719       return -1;
3720   }
3721   {
3722     char device[] = "/dev/sda1";
3723     char mountpoint[] = "/";
3724     int r;
3725     suppress_error = 0;
3726     r = guestfs_mount (g, device, mountpoint);
3727     if (r == -1)
3728       return -1;
3729   }
3730   /* TestOutput for cp (2) */
3731   char expected[] = "file content";
3732   {
3733     char path[] = "/old";
3734     char content[] = "file content";
3735     int r;
3736     suppress_error = 0;
3737     r = guestfs_write_file (g, path, content, 0);
3738     if (r == -1)
3739       return -1;
3740   }
3741   {
3742     char path[] = "/dir";
3743     int r;
3744     suppress_error = 0;
3745     r = guestfs_mkdir (g, path);
3746     if (r == -1)
3747       return -1;
3748   }
3749   {
3750     char src[] = "/old";
3751     char dest[] = "/dir/new";
3752     int r;
3753     suppress_error = 0;
3754     r = guestfs_cp (g, src, dest);
3755     if (r == -1)
3756       return -1;
3757   }
3758   {
3759     char path[] = "/dir/new";
3760     char *r;
3761     suppress_error = 0;
3762     r = guestfs_cat (g, path);
3763     if (r == NULL)
3764       return -1;
3765     if (strcmp (r, expected) != 0) {
3766       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3767       return -1;
3768     }
3769     free (r);
3770   }
3771   return 0;
3772 }
3773
3774 static int test_grub_install_0_skip (void)
3775 {
3776   const char *str;
3777
3778   str = getenv ("TEST_ONLY");
3779   if (str)
3780     return strstr (str, "grub_install") == NULL;
3781   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3782   if (str && strcmp (str, "1") == 0) return 1;
3783   str = getenv ("SKIP_TEST_GRUB_INSTALL");
3784   if (str && strcmp (str, "1") == 0) return 1;
3785   return 0;
3786 }
3787
3788 static int test_grub_install_0 (void)
3789 {
3790   if (test_grub_install_0_skip ()) {
3791     printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
3792     return 0;
3793   }
3794
3795   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3796   {
3797     char device[] = "/dev/sda";
3798     int r;
3799     suppress_error = 0;
3800     r = guestfs_blockdev_setrw (g, device);
3801     if (r == -1)
3802       return -1;
3803   }
3804   {
3805     int r;
3806     suppress_error = 0;
3807     r = guestfs_umount_all (g);
3808     if (r == -1)
3809       return -1;
3810   }
3811   {
3812     int r;
3813     suppress_error = 0;
3814     r = guestfs_lvm_remove_all (g);
3815     if (r == -1)
3816       return -1;
3817   }
3818   {
3819     char device[] = "/dev/sda";
3820     char lines_0[] = ",";
3821     char *lines[] = {
3822       lines_0,
3823       NULL
3824     };
3825     int r;
3826     suppress_error = 0;
3827     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3828     if (r == -1)
3829       return -1;
3830   }
3831   {
3832     char fstype[] = "ext2";
3833     char device[] = "/dev/sda1";
3834     int r;
3835     suppress_error = 0;
3836     r = guestfs_mkfs (g, fstype, device);
3837     if (r == -1)
3838       return -1;
3839   }
3840   {
3841     char device[] = "/dev/sda1";
3842     char mountpoint[] = "/";
3843     int r;
3844     suppress_error = 0;
3845     r = guestfs_mount (g, device, mountpoint);
3846     if (r == -1)
3847       return -1;
3848   }
3849   /* TestOutputTrue for grub_install (0) */
3850   {
3851     char root[] = "/";
3852     char device[] = "/dev/sda1";
3853     int r;
3854     suppress_error = 0;
3855     r = guestfs_grub_install (g, root, device);
3856     if (r == -1)
3857       return -1;
3858   }
3859   {
3860     char path[] = "/boot";
3861     int r;
3862     suppress_error = 0;
3863     r = guestfs_is_dir (g, path);
3864     if (r == -1)
3865       return -1;
3866     if (!r) {
3867       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3868       return -1;
3869     }
3870   }
3871   return 0;
3872 }
3873
3874 static int test_zero_0_skip (void)
3875 {
3876   const char *str;
3877
3878   str = getenv ("TEST_ONLY");
3879   if (str)
3880     return strstr (str, "zero") == NULL;
3881   str = getenv ("SKIP_TEST_ZERO_0");
3882   if (str && strcmp (str, "1") == 0) return 1;
3883   str = getenv ("SKIP_TEST_ZERO");
3884   if (str && strcmp (str, "1") == 0) return 1;
3885   return 0;
3886 }
3887
3888 static int test_zero_0 (void)
3889 {
3890   if (test_zero_0_skip ()) {
3891     printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
3892     return 0;
3893   }
3894
3895   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3896   {
3897     char device[] = "/dev/sda";
3898     int r;
3899     suppress_error = 0;
3900     r = guestfs_blockdev_setrw (g, device);
3901     if (r == -1)
3902       return -1;
3903   }
3904   {
3905     int r;
3906     suppress_error = 0;
3907     r = guestfs_umount_all (g);
3908     if (r == -1)
3909       return -1;
3910   }
3911   {
3912     int r;
3913     suppress_error = 0;
3914     r = guestfs_lvm_remove_all (g);
3915     if (r == -1)
3916       return -1;
3917   }
3918   {
3919     char device[] = "/dev/sda";
3920     char lines_0[] = ",";
3921     char *lines[] = {
3922       lines_0,
3923       NULL
3924     };
3925     int r;
3926     suppress_error = 0;
3927     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3928     if (r == -1)
3929       return -1;
3930   }
3931   {
3932     char fstype[] = "ext2";
3933     char device[] = "/dev/sda1";
3934     int r;
3935     suppress_error = 0;
3936     r = guestfs_mkfs (g, fstype, device);
3937     if (r == -1)
3938       return -1;
3939   }
3940   {
3941     char device[] = "/dev/sda1";
3942     char mountpoint[] = "/";
3943     int r;
3944     suppress_error = 0;
3945     r = guestfs_mount (g, device, mountpoint);
3946     if (r == -1)
3947       return -1;
3948   }
3949   /* TestOutput for zero (0) */
3950   char expected[] = "data";
3951   {
3952     char pathordevice[] = "/dev/sda1";
3953     int r;
3954     suppress_error = 0;
3955     r = guestfs_umount (g, pathordevice);
3956     if (r == -1)
3957       return -1;
3958   }
3959   {
3960     char device[] = "/dev/sda1";
3961     int r;
3962     suppress_error = 0;
3963     r = guestfs_zero (g, device);
3964     if (r == -1)
3965       return -1;
3966   }
3967   {
3968     char path[] = "/dev/sda1";
3969     char *r;
3970     suppress_error = 0;
3971     r = guestfs_file (g, path);
3972     if (r == NULL)
3973       return -1;
3974     if (strcmp (r, expected) != 0) {
3975       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3976       return -1;
3977     }
3978     free (r);
3979   }
3980   return 0;
3981 }
3982
3983 static int test_fsck_0_skip (void)
3984 {
3985   const char *str;
3986
3987   str = getenv ("TEST_ONLY");
3988   if (str)
3989     return strstr (str, "fsck") == NULL;
3990   str = getenv ("SKIP_TEST_FSCK_0");
3991   if (str && strcmp (str, "1") == 0) return 1;
3992   str = getenv ("SKIP_TEST_FSCK");
3993   if (str && strcmp (str, "1") == 0) return 1;
3994   return 0;
3995 }
3996
3997 static int test_fsck_0 (void)
3998 {
3999   if (test_fsck_0_skip ()) {
4000     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
4001     return 0;
4002   }
4003
4004   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
4005   {
4006     char device[] = "/dev/sda";
4007     int r;
4008     suppress_error = 0;
4009     r = guestfs_blockdev_setrw (g, device);
4010     if (r == -1)
4011       return -1;
4012   }
4013   {
4014     int r;
4015     suppress_error = 0;
4016     r = guestfs_umount_all (g);
4017     if (r == -1)
4018       return -1;
4019   }
4020   {
4021     int r;
4022     suppress_error = 0;
4023     r = guestfs_lvm_remove_all (g);
4024     if (r == -1)
4025       return -1;
4026   }
4027   {
4028     char device[] = "/dev/sda";
4029     char lines_0[] = ",";
4030     char *lines[] = {
4031       lines_0,
4032       NULL
4033     };
4034     int r;
4035     suppress_error = 0;
4036     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4037     if (r == -1)
4038       return -1;
4039   }
4040   {
4041     char fstype[] = "ext2";
4042     char device[] = "/dev/sda1";
4043     int r;
4044     suppress_error = 0;
4045     r = guestfs_mkfs (g, fstype, device);
4046     if (r == -1)
4047       return -1;
4048   }
4049   {
4050     char device[] = "/dev/sda1";
4051     char mountpoint[] = "/";
4052     int r;
4053     suppress_error = 0;
4054     r = guestfs_mount (g, device, mountpoint);
4055     if (r == -1)
4056       return -1;
4057   }
4058   /* TestOutputInt for fsck (0) */
4059   {
4060     char pathordevice[] = "/dev/sda1";
4061     int r;
4062     suppress_error = 0;
4063     r = guestfs_umount (g, pathordevice);
4064     if (r == -1)
4065       return -1;
4066   }
4067   {
4068     char fstype[] = "ext2";
4069     char device[] = "/dev/sda1";
4070     int r;
4071     suppress_error = 0;
4072     r = guestfs_fsck (g, fstype, device);
4073     if (r == -1)
4074       return -1;
4075     if (r != 0) {
4076       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
4077       return -1;
4078     }
4079   }
4080   return 0;
4081 }
4082
4083 static int test_fsck_1_skip (void)
4084 {
4085   const char *str;
4086
4087   str = getenv ("TEST_ONLY");
4088   if (str)
4089     return strstr (str, "fsck") == NULL;
4090   str = getenv ("SKIP_TEST_FSCK_1");
4091   if (str && strcmp (str, "1") == 0) return 1;
4092   str = getenv ("SKIP_TEST_FSCK");
4093   if (str && strcmp (str, "1") == 0) return 1;
4094   return 0;
4095 }
4096
4097 static int test_fsck_1 (void)
4098 {
4099   if (test_fsck_1_skip ()) {
4100     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
4101     return 0;
4102   }
4103
4104   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
4105   {
4106     char device[] = "/dev/sda";
4107     int r;
4108     suppress_error = 0;
4109     r = guestfs_blockdev_setrw (g, device);
4110     if (r == -1)
4111       return -1;
4112   }
4113   {
4114     int r;
4115     suppress_error = 0;
4116     r = guestfs_umount_all (g);
4117     if (r == -1)
4118       return -1;
4119   }
4120   {
4121     int r;
4122     suppress_error = 0;
4123     r = guestfs_lvm_remove_all (g);
4124     if (r == -1)
4125       return -1;
4126   }
4127   {
4128     char device[] = "/dev/sda";
4129     char lines_0[] = ",";
4130     char *lines[] = {
4131       lines_0,
4132       NULL
4133     };
4134     int r;
4135     suppress_error = 0;
4136     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4137     if (r == -1)
4138       return -1;
4139   }
4140   {
4141     char fstype[] = "ext2";
4142     char device[] = "/dev/sda1";
4143     int r;
4144     suppress_error = 0;
4145     r = guestfs_mkfs (g, fstype, device);
4146     if (r == -1)
4147       return -1;
4148   }
4149   {
4150     char device[] = "/dev/sda1";
4151     char mountpoint[] = "/";
4152     int r;
4153     suppress_error = 0;
4154     r = guestfs_mount (g, device, mountpoint);
4155     if (r == -1)
4156       return -1;
4157   }
4158   /* TestOutputInt for fsck (1) */
4159   {
4160     char pathordevice[] = "/dev/sda1";
4161     int r;
4162     suppress_error = 0;
4163     r = guestfs_umount (g, pathordevice);
4164     if (r == -1)
4165       return -1;
4166   }
4167   {
4168     char device[] = "/dev/sda1";
4169     int r;
4170     suppress_error = 0;
4171     r = guestfs_zero (g, device);
4172     if (r == -1)
4173       return -1;
4174   }
4175   {
4176     char fstype[] = "ext2";
4177     char device[] = "/dev/sda1";
4178     int r;
4179     suppress_error = 0;
4180     r = guestfs_fsck (g, fstype, device);
4181     if (r == -1)
4182       return -1;
4183     if (r != 8) {
4184       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
4185       return -1;
4186     }
4187   }
4188   return 0;
4189 }
4190
4191 static int test_set_e2uuid_0_skip (void)
4192 {
4193   const char *str;
4194
4195   str = getenv ("TEST_ONLY");
4196   if (str)
4197     return strstr (str, "set_e2uuid") == NULL;
4198   str = getenv ("SKIP_TEST_SET_E2UUID_0");
4199   if (str && strcmp (str, "1") == 0) return 1;
4200   str = getenv ("SKIP_TEST_SET_E2UUID");
4201   if (str && strcmp (str, "1") == 0) return 1;
4202   return 0;
4203 }
4204
4205 static int test_set_e2uuid_0 (void)
4206 {
4207   if (test_set_e2uuid_0_skip ()) {
4208     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
4209     return 0;
4210   }
4211
4212   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
4213   {
4214     char device[] = "/dev/sda";
4215     int r;
4216     suppress_error = 0;
4217     r = guestfs_blockdev_setrw (g, device);
4218     if (r == -1)
4219       return -1;
4220   }
4221   {
4222     int r;
4223     suppress_error = 0;
4224     r = guestfs_umount_all (g);
4225     if (r == -1)
4226       return -1;
4227   }
4228   {
4229     int r;
4230     suppress_error = 0;
4231     r = guestfs_lvm_remove_all (g);
4232     if (r == -1)
4233       return -1;
4234   }
4235   {
4236     char device[] = "/dev/sda";
4237     char lines_0[] = ",";
4238     char *lines[] = {
4239       lines_0,
4240       NULL
4241     };
4242     int r;
4243     suppress_error = 0;
4244     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4245     if (r == -1)
4246       return -1;
4247   }
4248   {
4249     char fstype[] = "ext2";
4250     char device[] = "/dev/sda1";
4251     int r;
4252     suppress_error = 0;
4253     r = guestfs_mkfs (g, fstype, device);
4254     if (r == -1)
4255       return -1;
4256   }
4257   {
4258     char device[] = "/dev/sda1";
4259     char mountpoint[] = "/";
4260     int r;
4261     suppress_error = 0;
4262     r = guestfs_mount (g, device, mountpoint);
4263     if (r == -1)
4264       return -1;
4265   }
4266   /* TestOutput for set_e2uuid (0) */
4267   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
4268   {
4269     char device[] = "/dev/sda1";
4270     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
4271     int r;
4272     suppress_error = 0;
4273     r = guestfs_set_e2uuid (g, device, uuid);
4274     if (r == -1)
4275       return -1;
4276   }
4277   {
4278     char device[] = "/dev/sda1";
4279     char *r;
4280     suppress_error = 0;
4281     r = guestfs_get_e2uuid (g, device);
4282     if (r == NULL)
4283       return -1;
4284     if (strcmp (r, expected) != 0) {
4285       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
4286       return -1;
4287     }
4288     free (r);
4289   }
4290   return 0;
4291 }
4292
4293 static int test_set_e2uuid_1_skip (void)
4294 {
4295   const char *str;
4296
4297   str = getenv ("TEST_ONLY");
4298   if (str)
4299     return strstr (str, "set_e2uuid") == NULL;
4300   str = getenv ("SKIP_TEST_SET_E2UUID_1");
4301   if (str && strcmp (str, "1") == 0) return 1;
4302   str = getenv ("SKIP_TEST_SET_E2UUID");
4303   if (str && strcmp (str, "1") == 0) return 1;
4304   return 0;
4305 }
4306
4307 static int test_set_e2uuid_1 (void)
4308 {
4309   if (test_set_e2uuid_1_skip ()) {
4310     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
4311     return 0;
4312   }
4313
4314   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
4315   {
4316     char device[] = "/dev/sda";
4317     int r;
4318     suppress_error = 0;
4319     r = guestfs_blockdev_setrw (g, device);
4320     if (r == -1)
4321       return -1;
4322   }
4323   {
4324     int r;
4325     suppress_error = 0;
4326     r = guestfs_umount_all (g);
4327     if (r == -1)
4328       return -1;
4329   }
4330   {
4331     int r;
4332     suppress_error = 0;
4333     r = guestfs_lvm_remove_all (g);
4334     if (r == -1)
4335       return -1;
4336   }
4337   {
4338     char device[] = "/dev/sda";
4339     char lines_0[] = ",";
4340     char *lines[] = {
4341       lines_0,
4342       NULL
4343     };
4344     int r;
4345     suppress_error = 0;
4346     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4347     if (r == -1)
4348       return -1;
4349   }
4350   {
4351     char fstype[] = "ext2";
4352     char device[] = "/dev/sda1";
4353     int r;
4354     suppress_error = 0;
4355     r = guestfs_mkfs (g, fstype, device);
4356     if (r == -1)
4357       return -1;
4358   }
4359   {
4360     char device[] = "/dev/sda1";
4361     char mountpoint[] = "/";
4362     int r;
4363     suppress_error = 0;
4364     r = guestfs_mount (g, device, mountpoint);
4365     if (r == -1)
4366       return -1;
4367   }
4368   /* TestOutput for set_e2uuid (1) */
4369   char expected[] = "";
4370   {
4371     char device[] = "/dev/sda1";
4372     char uuid[] = "clear";
4373     int r;
4374     suppress_error = 0;
4375     r = guestfs_set_e2uuid (g, device, uuid);
4376     if (r == -1)
4377       return -1;
4378   }
4379   {
4380     char device[] = "/dev/sda1";
4381     char *r;
4382     suppress_error = 0;
4383     r = guestfs_get_e2uuid (g, device);
4384     if (r == NULL)
4385       return -1;
4386     if (strcmp (r, expected) != 0) {
4387       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
4388       return -1;
4389     }
4390     free (r);
4391   }
4392   return 0;
4393 }
4394
4395 static int test_set_e2uuid_2_skip (void)
4396 {
4397   const char *str;
4398
4399   str = getenv ("TEST_ONLY");
4400   if (str)
4401     return strstr (str, "set_e2uuid") == NULL;
4402   str = getenv ("SKIP_TEST_SET_E2UUID_2");
4403   if (str && strcmp (str, "1") == 0) return 1;
4404   str = getenv ("SKIP_TEST_SET_E2UUID");
4405   if (str && strcmp (str, "1") == 0) return 1;
4406   return 0;
4407 }
4408
4409 static int test_set_e2uuid_2 (void)
4410 {
4411   if (test_set_e2uuid_2_skip ()) {
4412     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
4413     return 0;
4414   }
4415
4416   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
4417   {
4418     char device[] = "/dev/sda";
4419     int r;
4420     suppress_error = 0;
4421     r = guestfs_blockdev_setrw (g, device);
4422     if (r == -1)
4423       return -1;
4424   }
4425   {
4426     int r;
4427     suppress_error = 0;
4428     r = guestfs_umount_all (g);
4429     if (r == -1)
4430       return -1;
4431   }
4432   {
4433     int r;
4434     suppress_error = 0;
4435     r = guestfs_lvm_remove_all (g);
4436     if (r == -1)
4437       return -1;
4438   }
4439   {
4440     char device[] = "/dev/sda";
4441     char lines_0[] = ",";
4442     char *lines[] = {
4443       lines_0,
4444       NULL
4445     };
4446     int r;
4447     suppress_error = 0;
4448     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4449     if (r == -1)
4450       return -1;
4451   }
4452   {
4453     char fstype[] = "ext2";
4454     char device[] = "/dev/sda1";
4455     int r;
4456     suppress_error = 0;
4457     r = guestfs_mkfs (g, fstype, device);
4458     if (r == -1)
4459       return -1;
4460   }
4461   {
4462     char device[] = "/dev/sda1";
4463     char mountpoint[] = "/";
4464     int r;
4465     suppress_error = 0;
4466     r = guestfs_mount (g, device, mountpoint);
4467     if (r == -1)
4468       return -1;
4469   }
4470   /* TestRun for set_e2uuid (2) */
4471   {
4472     char device[] = "/dev/sda1";
4473     char uuid[] = "random";
4474     int r;
4475     suppress_error = 0;
4476     r = guestfs_set_e2uuid (g, device, uuid);
4477     if (r == -1)
4478       return -1;
4479   }
4480   return 0;
4481 }
4482
4483 static int test_set_e2uuid_3_skip (void)
4484 {
4485   const char *str;
4486
4487   str = getenv ("TEST_ONLY");
4488   if (str)
4489     return strstr (str, "set_e2uuid") == NULL;
4490   str = getenv ("SKIP_TEST_SET_E2UUID_3");
4491   if (str && strcmp (str, "1") == 0) return 1;
4492   str = getenv ("SKIP_TEST_SET_E2UUID");
4493   if (str && strcmp (str, "1") == 0) return 1;
4494   return 0;
4495 }
4496
4497 static int test_set_e2uuid_3 (void)
4498 {
4499   if (test_set_e2uuid_3_skip ()) {
4500     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
4501     return 0;
4502   }
4503
4504   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
4505   {
4506     char device[] = "/dev/sda";
4507     int r;
4508     suppress_error = 0;
4509     r = guestfs_blockdev_setrw (g, device);
4510     if (r == -1)
4511       return -1;
4512   }
4513   {
4514     int r;
4515     suppress_error = 0;
4516     r = guestfs_umount_all (g);
4517     if (r == -1)
4518       return -1;
4519   }
4520   {
4521     int r;
4522     suppress_error = 0;
4523     r = guestfs_lvm_remove_all (g);
4524     if (r == -1)
4525       return -1;
4526   }
4527   {
4528     char device[] = "/dev/sda";
4529     char lines_0[] = ",";
4530     char *lines[] = {
4531       lines_0,
4532       NULL
4533     };
4534     int r;
4535     suppress_error = 0;
4536     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4537     if (r == -1)
4538       return -1;
4539   }
4540   {
4541     char fstype[] = "ext2";
4542     char device[] = "/dev/sda1";
4543     int r;
4544     suppress_error = 0;
4545     r = guestfs_mkfs (g, fstype, device);
4546     if (r == -1)
4547       return -1;
4548   }
4549   {
4550     char device[] = "/dev/sda1";
4551     char mountpoint[] = "/";
4552     int r;
4553     suppress_error = 0;
4554     r = guestfs_mount (g, device, mountpoint);
4555     if (r == -1)
4556       return -1;
4557   }
4558   /* TestRun for set_e2uuid (3) */
4559   {
4560     char device[] = "/dev/sda1";
4561     char uuid[] = "time";
4562     int r;
4563     suppress_error = 0;
4564     r = guestfs_set_e2uuid (g, device, uuid);
4565     if (r == -1)
4566       return -1;
4567   }
4568   return 0;
4569 }
4570
4571 static int test_set_e2label_0_skip (void)
4572 {
4573   const char *str;
4574
4575   str = getenv ("TEST_ONLY");
4576   if (str)
4577     return strstr (str, "set_e2label") == NULL;
4578   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
4579   if (str && strcmp (str, "1") == 0) return 1;
4580   str = getenv ("SKIP_TEST_SET_E2LABEL");
4581   if (str && strcmp (str, "1") == 0) return 1;
4582   return 0;
4583 }
4584
4585 static int test_set_e2label_0 (void)
4586 {
4587   if (test_set_e2label_0_skip ()) {
4588     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
4589     return 0;
4590   }
4591
4592   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
4593   {
4594     char device[] = "/dev/sda";
4595     int r;
4596     suppress_error = 0;
4597     r = guestfs_blockdev_setrw (g, device);
4598     if (r == -1)
4599       return -1;
4600   }
4601   {
4602     int r;
4603     suppress_error = 0;
4604     r = guestfs_umount_all (g);
4605     if (r == -1)
4606       return -1;
4607   }
4608   {
4609     int r;
4610     suppress_error = 0;
4611     r = guestfs_lvm_remove_all (g);
4612     if (r == -1)
4613       return -1;
4614   }
4615   {
4616     char device[] = "/dev/sda";
4617     char lines_0[] = ",";
4618     char *lines[] = {
4619       lines_0,
4620       NULL
4621     };
4622     int r;
4623     suppress_error = 0;
4624     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4625     if (r == -1)
4626       return -1;
4627   }
4628   {
4629     char fstype[] = "ext2";
4630     char device[] = "/dev/sda1";
4631     int r;
4632     suppress_error = 0;
4633     r = guestfs_mkfs (g, fstype, device);
4634     if (r == -1)
4635       return -1;
4636   }
4637   {
4638     char device[] = "/dev/sda1";
4639     char mountpoint[] = "/";
4640     int r;
4641     suppress_error = 0;
4642     r = guestfs_mount (g, device, mountpoint);
4643     if (r == -1)
4644       return -1;
4645   }
4646   /* TestOutput for set_e2label (0) */
4647   char expected[] = "testlabel";
4648   {
4649     char device[] = "/dev/sda1";
4650     char label[] = "testlabel";
4651     int r;
4652     suppress_error = 0;
4653     r = guestfs_set_e2label (g, device, label);
4654     if (r == -1)
4655       return -1;
4656   }
4657   {
4658     char device[] = "/dev/sda1";
4659     char *r;
4660     suppress_error = 0;
4661     r = guestfs_get_e2label (g, device);
4662     if (r == NULL)
4663       return -1;
4664     if (strcmp (r, expected) != 0) {
4665       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
4666       return -1;
4667     }
4668     free (r);
4669   }
4670   return 0;
4671 }
4672
4673 static int test_pvremove_0_skip (void)
4674 {
4675   const char *str;
4676
4677   str = getenv ("TEST_ONLY");
4678   if (str)
4679     return strstr (str, "pvremove") == NULL;
4680   str = getenv ("SKIP_TEST_PVREMOVE_0");
4681   if (str && strcmp (str, "1") == 0) return 1;
4682   str = getenv ("SKIP_TEST_PVREMOVE");
4683   if (str && strcmp (str, "1") == 0) return 1;
4684   return 0;
4685 }
4686
4687 static int test_pvremove_0 (void)
4688 {
4689   if (test_pvremove_0_skip ()) {
4690     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
4691     return 0;
4692   }
4693
4694   /* InitNone|InitEmpty for test_pvremove_0 */
4695   {
4696     char device[] = "/dev/sda";
4697     int r;
4698     suppress_error = 0;
4699     r = guestfs_blockdev_setrw (g, device);
4700     if (r == -1)
4701       return -1;
4702   }
4703   {
4704     int r;
4705     suppress_error = 0;
4706     r = guestfs_umount_all (g);
4707     if (r == -1)
4708       return -1;
4709   }
4710   {
4711     int r;
4712     suppress_error = 0;
4713     r = guestfs_lvm_remove_all (g);
4714     if (r == -1)
4715       return -1;
4716   }
4717   /* TestOutputListOfDevices for pvremove (0) */
4718   {
4719     char device[] = "/dev/sda";
4720     char lines_0[] = ",";
4721     char *lines[] = {
4722       lines_0,
4723       NULL
4724     };
4725     int r;
4726     suppress_error = 0;
4727     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4728     if (r == -1)
4729       return -1;
4730   }
4731   {
4732     char device[] = "/dev/sda1";
4733     int r;
4734     suppress_error = 0;
4735     r = guestfs_pvcreate (g, device);
4736     if (r == -1)
4737       return -1;
4738   }
4739   {
4740     char volgroup[] = "VG";
4741     char physvols_0[] = "/dev/sda1";
4742     char *physvols[] = {
4743       physvols_0,
4744       NULL
4745     };
4746     int r;
4747     suppress_error = 0;
4748     r = guestfs_vgcreate (g, volgroup, physvols);
4749     if (r == -1)
4750       return -1;
4751   }
4752   {
4753     char logvol[] = "LV1";
4754     char volgroup[] = "VG";
4755     int r;
4756     suppress_error = 0;
4757     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4758     if (r == -1)
4759       return -1;
4760   }
4761   {
4762     char logvol[] = "LV2";
4763     char volgroup[] = "VG";
4764     int r;
4765     suppress_error = 0;
4766     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4767     if (r == -1)
4768       return -1;
4769   }
4770   {
4771     char vgname[] = "VG";
4772     int r;
4773     suppress_error = 0;
4774     r = guestfs_vgremove (g, vgname);
4775     if (r == -1)
4776       return -1;
4777   }
4778   {
4779     char device[] = "/dev/sda1";
4780     int r;
4781     suppress_error = 0;
4782     r = guestfs_pvremove (g, device);
4783     if (r == -1)
4784       return -1;
4785   }
4786   {
4787     char **r;
4788     int i;
4789     suppress_error = 0;
4790     r = guestfs_lvs (g);
4791     if (r == NULL)
4792       return -1;
4793     if (r[0] != NULL) {
4794       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
4795       print_strings (r);
4796       return -1;
4797     }
4798     for (i = 0; r[i] != NULL; ++i)
4799       free (r[i]);
4800     free (r);
4801   }
4802   return 0;
4803 }
4804
4805 static int test_pvremove_1_skip (void)
4806 {
4807   const char *str;
4808
4809   str = getenv ("TEST_ONLY");
4810   if (str)
4811     return strstr (str, "pvremove") == NULL;
4812   str = getenv ("SKIP_TEST_PVREMOVE_1");
4813   if (str && strcmp (str, "1") == 0) return 1;
4814   str = getenv ("SKIP_TEST_PVREMOVE");
4815   if (str && strcmp (str, "1") == 0) return 1;
4816   return 0;
4817 }
4818
4819 static int test_pvremove_1 (void)
4820 {
4821   if (test_pvremove_1_skip ()) {
4822     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
4823     return 0;
4824   }
4825
4826   /* InitNone|InitEmpty for test_pvremove_1 */
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   /* TestOutputListOfDevices for pvremove (1) */
4850   {
4851     char device[] = "/dev/sda";
4852     char lines_0[] = ",";
4853     char *lines[] = {
4854       lines_0,
4855       NULL
4856     };
4857     int r;
4858     suppress_error = 0;
4859     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4860     if (r == -1)
4861       return -1;
4862   }
4863   {
4864     char device[] = "/dev/sda1";
4865     int r;
4866     suppress_error = 0;
4867     r = guestfs_pvcreate (g, device);
4868     if (r == -1)
4869       return -1;
4870   }
4871   {
4872     char volgroup[] = "VG";
4873     char physvols_0[] = "/dev/sda1";
4874     char *physvols[] = {
4875       physvols_0,
4876       NULL
4877     };
4878     int r;
4879     suppress_error = 0;
4880     r = guestfs_vgcreate (g, volgroup, physvols);
4881     if (r == -1)
4882       return -1;
4883   }
4884   {
4885     char logvol[] = "LV1";
4886     char volgroup[] = "VG";
4887     int r;
4888     suppress_error = 0;
4889     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4890     if (r == -1)
4891       return -1;
4892   }
4893   {
4894     char logvol[] = "LV2";
4895     char volgroup[] = "VG";
4896     int r;
4897     suppress_error = 0;
4898     r = guestfs_lvcreate (g, logvol, volgroup, 50);
4899     if (r == -1)
4900       return -1;
4901   }
4902   {
4903     char vgname[] = "VG";
4904     int r;
4905     suppress_error = 0;
4906     r = guestfs_vgremove (g, vgname);
4907     if (r == -1)
4908       return -1;
4909   }
4910   {
4911     char device[] = "/dev/sda1";
4912     int r;
4913     suppress_error = 0;
4914     r = guestfs_pvremove (g, device);
4915     if (r == -1)
4916       return -1;
4917   }
4918   {
4919     char **r;
4920     int i;
4921     suppress_error = 0;
4922     r = guestfs_vgs (g);
4923     if (r == NULL)
4924       return -1;
4925     if (r[0] != NULL) {
4926       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
4927       print_strings (r);
4928       return -1;
4929     }
4930     for (i = 0; r[i] != NULL; ++i)
4931       free (r[i]);
4932     free (r);
4933   }
4934   return 0;
4935 }
4936
4937 static int test_pvremove_2_skip (void)
4938 {
4939   const char *str;
4940
4941   str = getenv ("TEST_ONLY");
4942   if (str)
4943     return strstr (str, "pvremove") == NULL;
4944   str = getenv ("SKIP_TEST_PVREMOVE_2");
4945   if (str && strcmp (str, "1") == 0) return 1;
4946   str = getenv ("SKIP_TEST_PVREMOVE");
4947   if (str && strcmp (str, "1") == 0) return 1;
4948   return 0;
4949 }
4950
4951 static int test_pvremove_2 (void)
4952 {
4953   if (test_pvremove_2_skip ()) {
4954     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
4955     return 0;
4956   }
4957
4958   /* InitNone|InitEmpty for test_pvremove_2 */
4959   {
4960     char device[] = "/dev/sda";
4961     int r;
4962     suppress_error = 0;
4963     r = guestfs_blockdev_setrw (g, device);
4964     if (r == -1)
4965       return -1;
4966   }
4967   {
4968     int r;
4969     suppress_error = 0;
4970     r = guestfs_umount_all (g);
4971     if (r == -1)
4972       return -1;
4973   }
4974   {
4975     int r;
4976     suppress_error = 0;
4977     r = guestfs_lvm_remove_all (g);
4978     if (r == -1)
4979       return -1;
4980   }
4981   /* TestOutputListOfDevices for pvremove (2) */
4982   {
4983     char device[] = "/dev/sda";
4984     char lines_0[] = ",";
4985     char *lines[] = {
4986       lines_0,
4987       NULL
4988     };
4989     int r;
4990     suppress_error = 0;
4991     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4992     if (r == -1)
4993       return -1;
4994   }
4995   {
4996     char device[] = "/dev/sda1";
4997     int r;
4998     suppress_error = 0;
4999     r = guestfs_pvcreate (g, device);
5000     if (r == -1)
5001       return -1;
5002   }
5003   {
5004     char volgroup[] = "VG";
5005     char physvols_0[] = "/dev/sda1";
5006     char *physvols[] = {
5007       physvols_0,
5008       NULL
5009     };
5010     int r;
5011     suppress_error = 0;
5012     r = guestfs_vgcreate (g, volgroup, physvols);
5013     if (r == -1)
5014       return -1;
5015   }
5016   {
5017     char logvol[] = "LV1";
5018     char volgroup[] = "VG";
5019     int r;
5020     suppress_error = 0;
5021     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5022     if (r == -1)
5023       return -1;
5024   }
5025   {
5026     char logvol[] = "LV2";
5027     char volgroup[] = "VG";
5028     int r;
5029     suppress_error = 0;
5030     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5031     if (r == -1)
5032       return -1;
5033   }
5034   {
5035     char vgname[] = "VG";
5036     int r;
5037     suppress_error = 0;
5038     r = guestfs_vgremove (g, vgname);
5039     if (r == -1)
5040       return -1;
5041   }
5042   {
5043     char device[] = "/dev/sda1";
5044     int r;
5045     suppress_error = 0;
5046     r = guestfs_pvremove (g, device);
5047     if (r == -1)
5048       return -1;
5049   }
5050   {
5051     char **r;
5052     int i;
5053     suppress_error = 0;
5054     r = guestfs_pvs (g);
5055     if (r == NULL)
5056       return -1;
5057     if (r[0] != NULL) {
5058       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
5059       print_strings (r);
5060       return -1;
5061     }
5062     for (i = 0; r[i] != NULL; ++i)
5063       free (r[i]);
5064     free (r);
5065   }
5066   return 0;
5067 }
5068
5069 static int test_vgremove_0_skip (void)
5070 {
5071   const char *str;
5072
5073   str = getenv ("TEST_ONLY");
5074   if (str)
5075     return strstr (str, "vgremove") == NULL;
5076   str = getenv ("SKIP_TEST_VGREMOVE_0");
5077   if (str && strcmp (str, "1") == 0) return 1;
5078   str = getenv ("SKIP_TEST_VGREMOVE");
5079   if (str && strcmp (str, "1") == 0) return 1;
5080   return 0;
5081 }
5082
5083 static int test_vgremove_0 (void)
5084 {
5085   if (test_vgremove_0_skip ()) {
5086     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
5087     return 0;
5088   }
5089
5090   /* InitNone|InitEmpty for test_vgremove_0 */
5091   {
5092     char device[] = "/dev/sda";
5093     int r;
5094     suppress_error = 0;
5095     r = guestfs_blockdev_setrw (g, device);
5096     if (r == -1)
5097       return -1;
5098   }
5099   {
5100     int r;
5101     suppress_error = 0;
5102     r = guestfs_umount_all (g);
5103     if (r == -1)
5104       return -1;
5105   }
5106   {
5107     int r;
5108     suppress_error = 0;
5109     r = guestfs_lvm_remove_all (g);
5110     if (r == -1)
5111       return -1;
5112   }
5113   /* TestOutputList for vgremove (0) */
5114   {
5115     char device[] = "/dev/sda";
5116     char lines_0[] = ",";
5117     char *lines[] = {
5118       lines_0,
5119       NULL
5120     };
5121     int r;
5122     suppress_error = 0;
5123     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5124     if (r == -1)
5125       return -1;
5126   }
5127   {
5128     char device[] = "/dev/sda1";
5129     int r;
5130     suppress_error = 0;
5131     r = guestfs_pvcreate (g, device);
5132     if (r == -1)
5133       return -1;
5134   }
5135   {
5136     char volgroup[] = "VG";
5137     char physvols_0[] = "/dev/sda1";
5138     char *physvols[] = {
5139       physvols_0,
5140       NULL
5141     };
5142     int r;
5143     suppress_error = 0;
5144     r = guestfs_vgcreate (g, volgroup, physvols);
5145     if (r == -1)
5146       return -1;
5147   }
5148   {
5149     char logvol[] = "LV1";
5150     char volgroup[] = "VG";
5151     int r;
5152     suppress_error = 0;
5153     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5154     if (r == -1)
5155       return -1;
5156   }
5157   {
5158     char logvol[] = "LV2";
5159     char volgroup[] = "VG";
5160     int r;
5161     suppress_error = 0;
5162     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5163     if (r == -1)
5164       return -1;
5165   }
5166   {
5167     char vgname[] = "VG";
5168     int r;
5169     suppress_error = 0;
5170     r = guestfs_vgremove (g, vgname);
5171     if (r == -1)
5172       return -1;
5173   }
5174   {
5175     char **r;
5176     int i;
5177     suppress_error = 0;
5178     r = guestfs_lvs (g);
5179     if (r == NULL)
5180       return -1;
5181     if (r[0] != NULL) {
5182       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
5183       print_strings (r);
5184       return -1;
5185     }
5186     for (i = 0; r[i] != NULL; ++i)
5187       free (r[i]);
5188     free (r);
5189   }
5190   return 0;
5191 }
5192
5193 static int test_vgremove_1_skip (void)
5194 {
5195   const char *str;
5196
5197   str = getenv ("TEST_ONLY");
5198   if (str)
5199     return strstr (str, "vgremove") == NULL;
5200   str = getenv ("SKIP_TEST_VGREMOVE_1");
5201   if (str && strcmp (str, "1") == 0) return 1;
5202   str = getenv ("SKIP_TEST_VGREMOVE");
5203   if (str && strcmp (str, "1") == 0) return 1;
5204   return 0;
5205 }
5206
5207 static int test_vgremove_1 (void)
5208 {
5209   if (test_vgremove_1_skip ()) {
5210     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
5211     return 0;
5212   }
5213
5214   /* InitNone|InitEmpty for test_vgremove_1 */
5215   {
5216     char device[] = "/dev/sda";
5217     int r;
5218     suppress_error = 0;
5219     r = guestfs_blockdev_setrw (g, device);
5220     if (r == -1)
5221       return -1;
5222   }
5223   {
5224     int r;
5225     suppress_error = 0;
5226     r = guestfs_umount_all (g);
5227     if (r == -1)
5228       return -1;
5229   }
5230   {
5231     int r;
5232     suppress_error = 0;
5233     r = guestfs_lvm_remove_all (g);
5234     if (r == -1)
5235       return -1;
5236   }
5237   /* TestOutputList for vgremove (1) */
5238   {
5239     char device[] = "/dev/sda";
5240     char lines_0[] = ",";
5241     char *lines[] = {
5242       lines_0,
5243       NULL
5244     };
5245     int r;
5246     suppress_error = 0;
5247     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5248     if (r == -1)
5249       return -1;
5250   }
5251   {
5252     char device[] = "/dev/sda1";
5253     int r;
5254     suppress_error = 0;
5255     r = guestfs_pvcreate (g, device);
5256     if (r == -1)
5257       return -1;
5258   }
5259   {
5260     char volgroup[] = "VG";
5261     char physvols_0[] = "/dev/sda1";
5262     char *physvols[] = {
5263       physvols_0,
5264       NULL
5265     };
5266     int r;
5267     suppress_error = 0;
5268     r = guestfs_vgcreate (g, volgroup, physvols);
5269     if (r == -1)
5270       return -1;
5271   }
5272   {
5273     char logvol[] = "LV1";
5274     char volgroup[] = "VG";
5275     int r;
5276     suppress_error = 0;
5277     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5278     if (r == -1)
5279       return -1;
5280   }
5281   {
5282     char logvol[] = "LV2";
5283     char volgroup[] = "VG";
5284     int r;
5285     suppress_error = 0;
5286     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5287     if (r == -1)
5288       return -1;
5289   }
5290   {
5291     char vgname[] = "VG";
5292     int r;
5293     suppress_error = 0;
5294     r = guestfs_vgremove (g, vgname);
5295     if (r == -1)
5296       return -1;
5297   }
5298   {
5299     char **r;
5300     int i;
5301     suppress_error = 0;
5302     r = guestfs_vgs (g);
5303     if (r == NULL)
5304       return -1;
5305     if (r[0] != NULL) {
5306       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
5307       print_strings (r);
5308       return -1;
5309     }
5310     for (i = 0; r[i] != NULL; ++i)
5311       free (r[i]);
5312     free (r);
5313   }
5314   return 0;
5315 }
5316
5317 static int test_lvremove_0_skip (void)
5318 {
5319   const char *str;
5320
5321   str = getenv ("TEST_ONLY");
5322   if (str)
5323     return strstr (str, "lvremove") == NULL;
5324   str = getenv ("SKIP_TEST_LVREMOVE_0");
5325   if (str && strcmp (str, "1") == 0) return 1;
5326   str = getenv ("SKIP_TEST_LVREMOVE");
5327   if (str && strcmp (str, "1") == 0) return 1;
5328   return 0;
5329 }
5330
5331 static int test_lvremove_0 (void)
5332 {
5333   if (test_lvremove_0_skip ()) {
5334     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
5335     return 0;
5336   }
5337
5338   /* InitNone|InitEmpty for test_lvremove_0 */
5339   {
5340     char device[] = "/dev/sda";
5341     int r;
5342     suppress_error = 0;
5343     r = guestfs_blockdev_setrw (g, device);
5344     if (r == -1)
5345       return -1;
5346   }
5347   {
5348     int r;
5349     suppress_error = 0;
5350     r = guestfs_umount_all (g);
5351     if (r == -1)
5352       return -1;
5353   }
5354   {
5355     int r;
5356     suppress_error = 0;
5357     r = guestfs_lvm_remove_all (g);
5358     if (r == -1)
5359       return -1;
5360   }
5361   /* TestOutputList for lvremove (0) */
5362   {
5363     char device[] = "/dev/sda";
5364     char lines_0[] = ",";
5365     char *lines[] = {
5366       lines_0,
5367       NULL
5368     };
5369     int r;
5370     suppress_error = 0;
5371     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5372     if (r == -1)
5373       return -1;
5374   }
5375   {
5376     char device[] = "/dev/sda1";
5377     int r;
5378     suppress_error = 0;
5379     r = guestfs_pvcreate (g, device);
5380     if (r == -1)
5381       return -1;
5382   }
5383   {
5384     char volgroup[] = "VG";
5385     char physvols_0[] = "/dev/sda1";
5386     char *physvols[] = {
5387       physvols_0,
5388       NULL
5389     };
5390     int r;
5391     suppress_error = 0;
5392     r = guestfs_vgcreate (g, volgroup, physvols);
5393     if (r == -1)
5394       return -1;
5395   }
5396   {
5397     char logvol[] = "LV1";
5398     char volgroup[] = "VG";
5399     int r;
5400     suppress_error = 0;
5401     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5402     if (r == -1)
5403       return -1;
5404   }
5405   {
5406     char logvol[] = "LV2";
5407     char volgroup[] = "VG";
5408     int r;
5409     suppress_error = 0;
5410     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5411     if (r == -1)
5412       return -1;
5413   }
5414   {
5415     char device[] = "/dev/VG/LV1";
5416     int r;
5417     suppress_error = 0;
5418     r = guestfs_lvremove (g, device);
5419     if (r == -1)
5420       return -1;
5421   }
5422   {
5423     char **r;
5424     int i;
5425     suppress_error = 0;
5426     r = guestfs_lvs (g);
5427     if (r == NULL)
5428       return -1;
5429     if (!r[0]) {
5430       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
5431       print_strings (r);
5432       return -1;
5433     }
5434     {
5435       char expected[] = "/dev/VG/LV2";
5436       if (strcmp (r[0], expected) != 0) {
5437         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5438         return -1;
5439       }
5440     }
5441     if (r[1] != NULL) {
5442       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
5443       print_strings (r);
5444       return -1;
5445     }
5446     for (i = 0; r[i] != NULL; ++i)
5447       free (r[i]);
5448     free (r);
5449   }
5450   return 0;
5451 }
5452
5453 static int test_lvremove_1_skip (void)
5454 {
5455   const char *str;
5456
5457   str = getenv ("TEST_ONLY");
5458   if (str)
5459     return strstr (str, "lvremove") == NULL;
5460   str = getenv ("SKIP_TEST_LVREMOVE_1");
5461   if (str && strcmp (str, "1") == 0) return 1;
5462   str = getenv ("SKIP_TEST_LVREMOVE");
5463   if (str && strcmp (str, "1") == 0) return 1;
5464   return 0;
5465 }
5466
5467 static int test_lvremove_1 (void)
5468 {
5469   if (test_lvremove_1_skip ()) {
5470     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
5471     return 0;
5472   }
5473
5474   /* InitNone|InitEmpty for test_lvremove_1 */
5475   {
5476     char device[] = "/dev/sda";
5477     int r;
5478     suppress_error = 0;
5479     r = guestfs_blockdev_setrw (g, device);
5480     if (r == -1)
5481       return -1;
5482   }
5483   {
5484     int r;
5485     suppress_error = 0;
5486     r = guestfs_umount_all (g);
5487     if (r == -1)
5488       return -1;
5489   }
5490   {
5491     int r;
5492     suppress_error = 0;
5493     r = guestfs_lvm_remove_all (g);
5494     if (r == -1)
5495       return -1;
5496   }
5497   /* TestOutputList for lvremove (1) */
5498   {
5499     char device[] = "/dev/sda";
5500     char lines_0[] = ",";
5501     char *lines[] = {
5502       lines_0,
5503       NULL
5504     };
5505     int r;
5506     suppress_error = 0;
5507     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5508     if (r == -1)
5509       return -1;
5510   }
5511   {
5512     char device[] = "/dev/sda1";
5513     int r;
5514     suppress_error = 0;
5515     r = guestfs_pvcreate (g, device);
5516     if (r == -1)
5517       return -1;
5518   }
5519   {
5520     char volgroup[] = "VG";
5521     char physvols_0[] = "/dev/sda1";
5522     char *physvols[] = {
5523       physvols_0,
5524       NULL
5525     };
5526     int r;
5527     suppress_error = 0;
5528     r = guestfs_vgcreate (g, volgroup, physvols);
5529     if (r == -1)
5530       return -1;
5531   }
5532   {
5533     char logvol[] = "LV1";
5534     char volgroup[] = "VG";
5535     int r;
5536     suppress_error = 0;
5537     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5538     if (r == -1)
5539       return -1;
5540   }
5541   {
5542     char logvol[] = "LV2";
5543     char volgroup[] = "VG";
5544     int r;
5545     suppress_error = 0;
5546     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5547     if (r == -1)
5548       return -1;
5549   }
5550   {
5551     char device[] = "/dev/VG";
5552     int r;
5553     suppress_error = 0;
5554     r = guestfs_lvremove (g, device);
5555     if (r == -1)
5556       return -1;
5557   }
5558   {
5559     char **r;
5560     int i;
5561     suppress_error = 0;
5562     r = guestfs_lvs (g);
5563     if (r == NULL)
5564       return -1;
5565     if (r[0] != NULL) {
5566       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
5567       print_strings (r);
5568       return -1;
5569     }
5570     for (i = 0; r[i] != NULL; ++i)
5571       free (r[i]);
5572     free (r);
5573   }
5574   return 0;
5575 }
5576
5577 static int test_lvremove_2_skip (void)
5578 {
5579   const char *str;
5580
5581   str = getenv ("TEST_ONLY");
5582   if (str)
5583     return strstr (str, "lvremove") == NULL;
5584   str = getenv ("SKIP_TEST_LVREMOVE_2");
5585   if (str && strcmp (str, "1") == 0) return 1;
5586   str = getenv ("SKIP_TEST_LVREMOVE");
5587   if (str && strcmp (str, "1") == 0) return 1;
5588   return 0;
5589 }
5590
5591 static int test_lvremove_2 (void)
5592 {
5593   if (test_lvremove_2_skip ()) {
5594     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
5595     return 0;
5596   }
5597
5598   /* InitNone|InitEmpty for test_lvremove_2 */
5599   {
5600     char device[] = "/dev/sda";
5601     int r;
5602     suppress_error = 0;
5603     r = guestfs_blockdev_setrw (g, device);
5604     if (r == -1)
5605       return -1;
5606   }
5607   {
5608     int r;
5609     suppress_error = 0;
5610     r = guestfs_umount_all (g);
5611     if (r == -1)
5612       return -1;
5613   }
5614   {
5615     int r;
5616     suppress_error = 0;
5617     r = guestfs_lvm_remove_all (g);
5618     if (r == -1)
5619       return -1;
5620   }
5621   /* TestOutputList for lvremove (2) */
5622   {
5623     char device[] = "/dev/sda";
5624     char lines_0[] = ",";
5625     char *lines[] = {
5626       lines_0,
5627       NULL
5628     };
5629     int r;
5630     suppress_error = 0;
5631     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5632     if (r == -1)
5633       return -1;
5634   }
5635   {
5636     char device[] = "/dev/sda1";
5637     int r;
5638     suppress_error = 0;
5639     r = guestfs_pvcreate (g, device);
5640     if (r == -1)
5641       return -1;
5642   }
5643   {
5644     char volgroup[] = "VG";
5645     char physvols_0[] = "/dev/sda1";
5646     char *physvols[] = {
5647       physvols_0,
5648       NULL
5649     };
5650     int r;
5651     suppress_error = 0;
5652     r = guestfs_vgcreate (g, volgroup, physvols);
5653     if (r == -1)
5654       return -1;
5655   }
5656   {
5657     char logvol[] = "LV1";
5658     char volgroup[] = "VG";
5659     int r;
5660     suppress_error = 0;
5661     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5662     if (r == -1)
5663       return -1;
5664   }
5665   {
5666     char logvol[] = "LV2";
5667     char volgroup[] = "VG";
5668     int r;
5669     suppress_error = 0;
5670     r = guestfs_lvcreate (g, logvol, volgroup, 50);
5671     if (r == -1)
5672       return -1;
5673   }
5674   {
5675     char device[] = "/dev/VG";
5676     int r;
5677     suppress_error = 0;
5678     r = guestfs_lvremove (g, device);
5679     if (r == -1)
5680       return -1;
5681   }
5682   {
5683     char **r;
5684     int i;
5685     suppress_error = 0;
5686     r = guestfs_vgs (g);
5687     if (r == NULL)
5688       return -1;
5689     if (!r[0]) {
5690       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
5691       print_strings (r);
5692       return -1;
5693     }
5694     {
5695       char expected[] = "VG";
5696       if (strcmp (r[0], expected) != 0) {
5697         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5698         return -1;
5699       }
5700     }
5701     if (r[1] != NULL) {
5702       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
5703       print_strings (r);
5704       return -1;
5705     }
5706     for (i = 0; r[i] != NULL; ++i)
5707       free (r[i]);
5708     free (r);
5709   }
5710   return 0;
5711 }
5712
5713 static int test_mount_ro_0_skip (void)
5714 {
5715   const char *str;
5716
5717   str = getenv ("TEST_ONLY");
5718   if (str)
5719     return strstr (str, "mount_ro") == NULL;
5720   str = getenv ("SKIP_TEST_MOUNT_RO_0");
5721   if (str && strcmp (str, "1") == 0) return 1;
5722   str = getenv ("SKIP_TEST_MOUNT_RO");
5723   if (str && strcmp (str, "1") == 0) return 1;
5724   return 0;
5725 }
5726
5727 static int test_mount_ro_0 (void)
5728 {
5729   if (test_mount_ro_0_skip ()) {
5730     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
5731     return 0;
5732   }
5733
5734   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
5735   {
5736     char device[] = "/dev/sda";
5737     int r;
5738     suppress_error = 0;
5739     r = guestfs_blockdev_setrw (g, device);
5740     if (r == -1)
5741       return -1;
5742   }
5743   {
5744     int r;
5745     suppress_error = 0;
5746     r = guestfs_umount_all (g);
5747     if (r == -1)
5748       return -1;
5749   }
5750   {
5751     int r;
5752     suppress_error = 0;
5753     r = guestfs_lvm_remove_all (g);
5754     if (r == -1)
5755       return -1;
5756   }
5757   {
5758     char device[] = "/dev/sda";
5759     char lines_0[] = ",";
5760     char *lines[] = {
5761       lines_0,
5762       NULL
5763     };
5764     int r;
5765     suppress_error = 0;
5766     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5767     if (r == -1)
5768       return -1;
5769   }
5770   {
5771     char fstype[] = "ext2";
5772     char device[] = "/dev/sda1";
5773     int r;
5774     suppress_error = 0;
5775     r = guestfs_mkfs (g, fstype, device);
5776     if (r == -1)
5777       return -1;
5778   }
5779   {
5780     char device[] = "/dev/sda1";
5781     char mountpoint[] = "/";
5782     int r;
5783     suppress_error = 0;
5784     r = guestfs_mount (g, device, mountpoint);
5785     if (r == -1)
5786       return -1;
5787   }
5788   /* TestLastFail for mount_ro (0) */
5789   {
5790     char pathordevice[] = "/";
5791     int r;
5792     suppress_error = 0;
5793     r = guestfs_umount (g, pathordevice);
5794     if (r == -1)
5795       return -1;
5796   }
5797   {
5798     char device[] = "/dev/sda1";
5799     char mountpoint[] = "/";
5800     int r;
5801     suppress_error = 0;
5802     r = guestfs_mount_ro (g, device, mountpoint);
5803     if (r == -1)
5804       return -1;
5805   }
5806   {
5807     char path[] = "/new";
5808     int r;
5809     suppress_error = 1;
5810     r = guestfs_touch (g, path);
5811     if (r != -1)
5812       return -1;
5813   }
5814   return 0;
5815 }
5816
5817 static int test_mount_ro_1_skip (void)
5818 {
5819   const char *str;
5820
5821   str = getenv ("TEST_ONLY");
5822   if (str)
5823     return strstr (str, "mount_ro") == NULL;
5824   str = getenv ("SKIP_TEST_MOUNT_RO_1");
5825   if (str && strcmp (str, "1") == 0) return 1;
5826   str = getenv ("SKIP_TEST_MOUNT_RO");
5827   if (str && strcmp (str, "1") == 0) return 1;
5828   return 0;
5829 }
5830
5831 static int test_mount_ro_1 (void)
5832 {
5833   if (test_mount_ro_1_skip ()) {
5834     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
5835     return 0;
5836   }
5837
5838   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5839   {
5840     char device[] = "/dev/sda";
5841     int r;
5842     suppress_error = 0;
5843     r = guestfs_blockdev_setrw (g, device);
5844     if (r == -1)
5845       return -1;
5846   }
5847   {
5848     int r;
5849     suppress_error = 0;
5850     r = guestfs_umount_all (g);
5851     if (r == -1)
5852       return -1;
5853   }
5854   {
5855     int r;
5856     suppress_error = 0;
5857     r = guestfs_lvm_remove_all (g);
5858     if (r == -1)
5859       return -1;
5860   }
5861   {
5862     char device[] = "/dev/sda";
5863     char lines_0[] = ",";
5864     char *lines[] = {
5865       lines_0,
5866       NULL
5867     };
5868     int r;
5869     suppress_error = 0;
5870     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5871     if (r == -1)
5872       return -1;
5873   }
5874   {
5875     char fstype[] = "ext2";
5876     char device[] = "/dev/sda1";
5877     int r;
5878     suppress_error = 0;
5879     r = guestfs_mkfs (g, fstype, device);
5880     if (r == -1)
5881       return -1;
5882   }
5883   {
5884     char device[] = "/dev/sda1";
5885     char mountpoint[] = "/";
5886     int r;
5887     suppress_error = 0;
5888     r = guestfs_mount (g, device, mountpoint);
5889     if (r == -1)
5890       return -1;
5891   }
5892   /* TestOutput for mount_ro (1) */
5893   char expected[] = "data";
5894   {
5895     char path[] = "/new";
5896     char content[] = "data";
5897     int r;
5898     suppress_error = 0;
5899     r = guestfs_write_file (g, path, content, 0);
5900     if (r == -1)
5901       return -1;
5902   }
5903   {
5904     char pathordevice[] = "/";
5905     int r;
5906     suppress_error = 0;
5907     r = guestfs_umount (g, pathordevice);
5908     if (r == -1)
5909       return -1;
5910   }
5911   {
5912     char device[] = "/dev/sda1";
5913     char mountpoint[] = "/";
5914     int r;
5915     suppress_error = 0;
5916     r = guestfs_mount_ro (g, device, mountpoint);
5917     if (r == -1)
5918       return -1;
5919   }
5920   {
5921     char path[] = "/new";
5922     char *r;
5923     suppress_error = 0;
5924     r = guestfs_cat (g, path);
5925     if (r == NULL)
5926       return -1;
5927     if (strcmp (r, expected) != 0) {
5928       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5929       return -1;
5930     }
5931     free (r);
5932   }
5933   return 0;
5934 }
5935
5936 static int test_tgz_in_0_skip (void)
5937 {
5938   const char *str;
5939
5940   str = getenv ("TEST_ONLY");
5941   if (str)
5942     return strstr (str, "tgz_in") == NULL;
5943   str = getenv ("SKIP_TEST_TGZ_IN_0");
5944   if (str && strcmp (str, "1") == 0) return 1;
5945   str = getenv ("SKIP_TEST_TGZ_IN");
5946   if (str && strcmp (str, "1") == 0) return 1;
5947   return 0;
5948 }
5949
5950 static int test_tgz_in_0 (void)
5951 {
5952   if (test_tgz_in_0_skip ()) {
5953     printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
5954     return 0;
5955   }
5956
5957   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5958   {
5959     char device[] = "/dev/sda";
5960     int r;
5961     suppress_error = 0;
5962     r = guestfs_blockdev_setrw (g, device);
5963     if (r == -1)
5964       return -1;
5965   }
5966   {
5967     int r;
5968     suppress_error = 0;
5969     r = guestfs_umount_all (g);
5970     if (r == -1)
5971       return -1;
5972   }
5973   {
5974     int r;
5975     suppress_error = 0;
5976     r = guestfs_lvm_remove_all (g);
5977     if (r == -1)
5978       return -1;
5979   }
5980   {
5981     char device[] = "/dev/sda";
5982     char lines_0[] = ",";
5983     char *lines[] = {
5984       lines_0,
5985       NULL
5986     };
5987     int r;
5988     suppress_error = 0;
5989     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5990     if (r == -1)
5991       return -1;
5992   }
5993   {
5994     char fstype[] = "ext2";
5995     char device[] = "/dev/sda1";
5996     int r;
5997     suppress_error = 0;
5998     r = guestfs_mkfs (g, fstype, device);
5999     if (r == -1)
6000       return -1;
6001   }
6002   {
6003     char device[] = "/dev/sda1";
6004     char mountpoint[] = "/";
6005     int r;
6006     suppress_error = 0;
6007     r = guestfs_mount (g, device, mountpoint);
6008     if (r == -1)
6009       return -1;
6010   }
6011   /* TestOutput for tgz_in (0) */
6012   char expected[] = "hello\n";
6013   {
6014     char directory[] = "/";
6015     int r;
6016     suppress_error = 0;
6017     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
6018     if (r == -1)
6019       return -1;
6020   }
6021   {
6022     char path[] = "/hello";
6023     char *r;
6024     suppress_error = 0;
6025     r = guestfs_cat (g, path);
6026     if (r == NULL)
6027       return -1;
6028     if (strcmp (r, expected) != 0) {
6029       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
6030       return -1;
6031     }
6032     free (r);
6033   }
6034   return 0;
6035 }
6036
6037 static int test_tar_in_0_skip (void)
6038 {
6039   const char *str;
6040
6041   str = getenv ("TEST_ONLY");
6042   if (str)
6043     return strstr (str, "tar_in") == NULL;
6044   str = getenv ("SKIP_TEST_TAR_IN_0");
6045   if (str && strcmp (str, "1") == 0) return 1;
6046   str = getenv ("SKIP_TEST_TAR_IN");
6047   if (str && strcmp (str, "1") == 0) return 1;
6048   return 0;
6049 }
6050
6051 static int test_tar_in_0 (void)
6052 {
6053   if (test_tar_in_0_skip ()) {
6054     printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
6055     return 0;
6056   }
6057
6058   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
6059   {
6060     char device[] = "/dev/sda";
6061     int r;
6062     suppress_error = 0;
6063     r = guestfs_blockdev_setrw (g, device);
6064     if (r == -1)
6065       return -1;
6066   }
6067   {
6068     int r;
6069     suppress_error = 0;
6070     r = guestfs_umount_all (g);
6071     if (r == -1)
6072       return -1;
6073   }
6074   {
6075     int r;
6076     suppress_error = 0;
6077     r = guestfs_lvm_remove_all (g);
6078     if (r == -1)
6079       return -1;
6080   }
6081   {
6082     char device[] = "/dev/sda";
6083     char lines_0[] = ",";
6084     char *lines[] = {
6085       lines_0,
6086       NULL
6087     };
6088     int r;
6089     suppress_error = 0;
6090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6091     if (r == -1)
6092       return -1;
6093   }
6094   {
6095     char fstype[] = "ext2";
6096     char device[] = "/dev/sda1";
6097     int r;
6098     suppress_error = 0;
6099     r = guestfs_mkfs (g, fstype, device);
6100     if (r == -1)
6101       return -1;
6102   }
6103   {
6104     char device[] = "/dev/sda1";
6105     char mountpoint[] = "/";
6106     int r;
6107     suppress_error = 0;
6108     r = guestfs_mount (g, device, mountpoint);
6109     if (r == -1)
6110       return -1;
6111   }
6112   /* TestOutput for tar_in (0) */
6113   char expected[] = "hello\n";
6114   {
6115     char directory[] = "/";
6116     int r;
6117     suppress_error = 0;
6118     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
6119     if (r == -1)
6120       return -1;
6121   }
6122   {
6123     char path[] = "/hello";
6124     char *r;
6125     suppress_error = 0;
6126     r = guestfs_cat (g, path);
6127     if (r == NULL)
6128       return -1;
6129     if (strcmp (r, expected) != 0) {
6130       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
6131       return -1;
6132     }
6133     free (r);
6134   }
6135   return 0;
6136 }
6137
6138 static int test_checksum_0_skip (void)
6139 {
6140   const char *str;
6141
6142   str = getenv ("TEST_ONLY");
6143   if (str)
6144     return strstr (str, "checksum") == NULL;
6145   str = getenv ("SKIP_TEST_CHECKSUM_0");
6146   if (str && strcmp (str, "1") == 0) return 1;
6147   str = getenv ("SKIP_TEST_CHECKSUM");
6148   if (str && strcmp (str, "1") == 0) return 1;
6149   return 0;
6150 }
6151
6152 static int test_checksum_0 (void)
6153 {
6154   if (test_checksum_0_skip ()) {
6155     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
6156     return 0;
6157   }
6158
6159   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
6160   {
6161     char device[] = "/dev/sda";
6162     int r;
6163     suppress_error = 0;
6164     r = guestfs_blockdev_setrw (g, device);
6165     if (r == -1)
6166       return -1;
6167   }
6168   {
6169     int r;
6170     suppress_error = 0;
6171     r = guestfs_umount_all (g);
6172     if (r == -1)
6173       return -1;
6174   }
6175   {
6176     int r;
6177     suppress_error = 0;
6178     r = guestfs_lvm_remove_all (g);
6179     if (r == -1)
6180       return -1;
6181   }
6182   {
6183     char device[] = "/dev/sda";
6184     char lines_0[] = ",";
6185     char *lines[] = {
6186       lines_0,
6187       NULL
6188     };
6189     int r;
6190     suppress_error = 0;
6191     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6192     if (r == -1)
6193       return -1;
6194   }
6195   {
6196     char fstype[] = "ext2";
6197     char device[] = "/dev/sda1";
6198     int r;
6199     suppress_error = 0;
6200     r = guestfs_mkfs (g, fstype, device);
6201     if (r == -1)
6202       return -1;
6203   }
6204   {
6205     char device[] = "/dev/sda1";
6206     char mountpoint[] = "/";
6207     int r;
6208     suppress_error = 0;
6209     r = guestfs_mount (g, device, mountpoint);
6210     if (r == -1)
6211       return -1;
6212   }
6213   /* TestOutput for checksum (0) */
6214   char expected[] = "935282863";
6215   {
6216     char path[] = "/new";
6217     char content[] = "test\n";
6218     int r;
6219     suppress_error = 0;
6220     r = guestfs_write_file (g, path, content, 0);
6221     if (r == -1)
6222       return -1;
6223   }
6224   {
6225     char csumtype[] = "crc";
6226     char path[] = "/new";
6227     char *r;
6228     suppress_error = 0;
6229     r = guestfs_checksum (g, csumtype, path);
6230     if (r == NULL)
6231       return -1;
6232     if (strcmp (r, expected) != 0) {
6233       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
6234       return -1;
6235     }
6236     free (r);
6237   }
6238   return 0;
6239 }
6240
6241 static int test_checksum_1_skip (void)
6242 {
6243   const char *str;
6244
6245   str = getenv ("TEST_ONLY");
6246   if (str)
6247     return strstr (str, "checksum") == NULL;
6248   str = getenv ("SKIP_TEST_CHECKSUM_1");
6249   if (str && strcmp (str, "1") == 0) return 1;
6250   str = getenv ("SKIP_TEST_CHECKSUM");
6251   if (str && strcmp (str, "1") == 0) return 1;
6252   return 0;
6253 }
6254
6255 static int test_checksum_1 (void)
6256 {
6257   if (test_checksum_1_skip ()) {
6258     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
6259     return 0;
6260   }
6261
6262   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
6263   {
6264     char device[] = "/dev/sda";
6265     int r;
6266     suppress_error = 0;
6267     r = guestfs_blockdev_setrw (g, device);
6268     if (r == -1)
6269       return -1;
6270   }
6271   {
6272     int r;
6273     suppress_error = 0;
6274     r = guestfs_umount_all (g);
6275     if (r == -1)
6276       return -1;
6277   }
6278   {
6279     int r;
6280     suppress_error = 0;
6281     r = guestfs_lvm_remove_all (g);
6282     if (r == -1)
6283       return -1;
6284   }
6285   {
6286     char device[] = "/dev/sda";
6287     char lines_0[] = ",";
6288     char *lines[] = {
6289       lines_0,
6290       NULL
6291     };
6292     int r;
6293     suppress_error = 0;
6294     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6295     if (r == -1)
6296       return -1;
6297   }
6298   {
6299     char fstype[] = "ext2";
6300     char device[] = "/dev/sda1";
6301     int r;
6302     suppress_error = 0;
6303     r = guestfs_mkfs (g, fstype, device);
6304     if (r == -1)
6305       return -1;
6306   }
6307   {
6308     char device[] = "/dev/sda1";
6309     char mountpoint[] = "/";
6310     int r;
6311     suppress_error = 0;
6312     r = guestfs_mount (g, device, mountpoint);
6313     if (r == -1)
6314       return -1;
6315   }
6316   /* TestLastFail for checksum (1) */
6317   {
6318     char csumtype[] = "crc";
6319     char path[] = "/new";
6320     char *r;
6321     suppress_error = 1;
6322     r = guestfs_checksum (g, csumtype, path);
6323     if (r != NULL)
6324       return -1;
6325     free (r);
6326   }
6327   return 0;
6328 }
6329
6330 static int test_checksum_2_skip (void)
6331 {
6332   const char *str;
6333
6334   str = getenv ("TEST_ONLY");
6335   if (str)
6336     return strstr (str, "checksum") == NULL;
6337   str = getenv ("SKIP_TEST_CHECKSUM_2");
6338   if (str && strcmp (str, "1") == 0) return 1;
6339   str = getenv ("SKIP_TEST_CHECKSUM");
6340   if (str && strcmp (str, "1") == 0) return 1;
6341   return 0;
6342 }
6343
6344 static int test_checksum_2 (void)
6345 {
6346   if (test_checksum_2_skip ()) {
6347     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
6348     return 0;
6349   }
6350
6351   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
6352   {
6353     char device[] = "/dev/sda";
6354     int r;
6355     suppress_error = 0;
6356     r = guestfs_blockdev_setrw (g, device);
6357     if (r == -1)
6358       return -1;
6359   }
6360   {
6361     int r;
6362     suppress_error = 0;
6363     r = guestfs_umount_all (g);
6364     if (r == -1)
6365       return -1;
6366   }
6367   {
6368     int r;
6369     suppress_error = 0;
6370     r = guestfs_lvm_remove_all (g);
6371     if (r == -1)
6372       return -1;
6373   }
6374   {
6375     char device[] = "/dev/sda";
6376     char lines_0[] = ",";
6377     char *lines[] = {
6378       lines_0,
6379       NULL
6380     };
6381     int r;
6382     suppress_error = 0;
6383     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6384     if (r == -1)
6385       return -1;
6386   }
6387   {
6388     char fstype[] = "ext2";
6389     char device[] = "/dev/sda1";
6390     int r;
6391     suppress_error = 0;
6392     r = guestfs_mkfs (g, fstype, device);
6393     if (r == -1)
6394       return -1;
6395   }
6396   {
6397     char device[] = "/dev/sda1";
6398     char mountpoint[] = "/";
6399     int r;
6400     suppress_error = 0;
6401     r = guestfs_mount (g, device, mountpoint);
6402     if (r == -1)
6403       return -1;
6404   }
6405   /* TestOutput for checksum (2) */
6406   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
6407   {
6408     char path[] = "/new";
6409     char content[] = "test\n";
6410     int r;
6411     suppress_error = 0;
6412     r = guestfs_write_file (g, path, content, 0);
6413     if (r == -1)
6414       return -1;
6415   }
6416   {
6417     char csumtype[] = "md5";
6418     char path[] = "/new";
6419     char *r;
6420     suppress_error = 0;
6421     r = guestfs_checksum (g, csumtype, path);
6422     if (r == NULL)
6423       return -1;
6424     if (strcmp (r, expected) != 0) {
6425       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
6426       return -1;
6427     }
6428     free (r);
6429   }
6430   return 0;
6431 }
6432
6433 static int test_checksum_3_skip (void)
6434 {
6435   const char *str;
6436
6437   str = getenv ("TEST_ONLY");
6438   if (str)
6439     return strstr (str, "checksum") == NULL;
6440   str = getenv ("SKIP_TEST_CHECKSUM_3");
6441   if (str && strcmp (str, "1") == 0) return 1;
6442   str = getenv ("SKIP_TEST_CHECKSUM");
6443   if (str && strcmp (str, "1") == 0) return 1;
6444   return 0;
6445 }
6446
6447 static int test_checksum_3 (void)
6448 {
6449   if (test_checksum_3_skip ()) {
6450     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
6451     return 0;
6452   }
6453
6454   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
6455   {
6456     char device[] = "/dev/sda";
6457     int r;
6458     suppress_error = 0;
6459     r = guestfs_blockdev_setrw (g, device);
6460     if (r == -1)
6461       return -1;
6462   }
6463   {
6464     int r;
6465     suppress_error = 0;
6466     r = guestfs_umount_all (g);
6467     if (r == -1)
6468       return -1;
6469   }
6470   {
6471     int r;
6472     suppress_error = 0;
6473     r = guestfs_lvm_remove_all (g);
6474     if (r == -1)
6475       return -1;
6476   }
6477   {
6478     char device[] = "/dev/sda";
6479     char lines_0[] = ",";
6480     char *lines[] = {
6481       lines_0,
6482       NULL
6483     };
6484     int r;
6485     suppress_error = 0;
6486     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6487     if (r == -1)
6488       return -1;
6489   }
6490   {
6491     char fstype[] = "ext2";
6492     char device[] = "/dev/sda1";
6493     int r;
6494     suppress_error = 0;
6495     r = guestfs_mkfs (g, fstype, device);
6496     if (r == -1)
6497       return -1;
6498   }
6499   {
6500     char device[] = "/dev/sda1";
6501     char mountpoint[] = "/";
6502     int r;
6503     suppress_error = 0;
6504     r = guestfs_mount (g, device, mountpoint);
6505     if (r == -1)
6506       return -1;
6507   }
6508   /* TestOutput for checksum (3) */
6509   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
6510   {
6511     char path[] = "/new";
6512     char content[] = "test\n";
6513     int r;
6514     suppress_error = 0;
6515     r = guestfs_write_file (g, path, content, 0);
6516     if (r == -1)
6517       return -1;
6518   }
6519   {
6520     char csumtype[] = "sha1";
6521     char path[] = "/new";
6522     char *r;
6523     suppress_error = 0;
6524     r = guestfs_checksum (g, csumtype, path);
6525     if (r == NULL)
6526       return -1;
6527     if (strcmp (r, expected) != 0) {
6528       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
6529       return -1;
6530     }
6531     free (r);
6532   }
6533   return 0;
6534 }
6535
6536 static int test_checksum_4_skip (void)
6537 {
6538   const char *str;
6539
6540   str = getenv ("TEST_ONLY");
6541   if (str)
6542     return strstr (str, "checksum") == NULL;
6543   str = getenv ("SKIP_TEST_CHECKSUM_4");
6544   if (str && strcmp (str, "1") == 0) return 1;
6545   str = getenv ("SKIP_TEST_CHECKSUM");
6546   if (str && strcmp (str, "1") == 0) return 1;
6547   return 0;
6548 }
6549
6550 static int test_checksum_4 (void)
6551 {
6552   if (test_checksum_4_skip ()) {
6553     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
6554     return 0;
6555   }
6556
6557   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
6558   {
6559     char device[] = "/dev/sda";
6560     int r;
6561     suppress_error = 0;
6562     r = guestfs_blockdev_setrw (g, device);
6563     if (r == -1)
6564       return -1;
6565   }
6566   {
6567     int r;
6568     suppress_error = 0;
6569     r = guestfs_umount_all (g);
6570     if (r == -1)
6571       return -1;
6572   }
6573   {
6574     int r;
6575     suppress_error = 0;
6576     r = guestfs_lvm_remove_all (g);
6577     if (r == -1)
6578       return -1;
6579   }
6580   {
6581     char device[] = "/dev/sda";
6582     char lines_0[] = ",";
6583     char *lines[] = {
6584       lines_0,
6585       NULL
6586     };
6587     int r;
6588     suppress_error = 0;
6589     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6590     if (r == -1)
6591       return -1;
6592   }
6593   {
6594     char fstype[] = "ext2";
6595     char device[] = "/dev/sda1";
6596     int r;
6597     suppress_error = 0;
6598     r = guestfs_mkfs (g, fstype, device);
6599     if (r == -1)
6600       return -1;
6601   }
6602   {
6603     char device[] = "/dev/sda1";
6604     char mountpoint[] = "/";
6605     int r;
6606     suppress_error = 0;
6607     r = guestfs_mount (g, device, mountpoint);
6608     if (r == -1)
6609       return -1;
6610   }
6611   /* TestOutput for checksum (4) */
6612   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
6613   {
6614     char path[] = "/new";
6615     char content[] = "test\n";
6616     int r;
6617     suppress_error = 0;
6618     r = guestfs_write_file (g, path, content, 0);
6619     if (r == -1)
6620       return -1;
6621   }
6622   {
6623     char csumtype[] = "sha224";
6624     char path[] = "/new";
6625     char *r;
6626     suppress_error = 0;
6627     r = guestfs_checksum (g, csumtype, path);
6628     if (r == NULL)
6629       return -1;
6630     if (strcmp (r, expected) != 0) {
6631       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
6632       return -1;
6633     }
6634     free (r);
6635   }
6636   return 0;
6637 }
6638
6639 static int test_checksum_5_skip (void)
6640 {
6641   const char *str;
6642
6643   str = getenv ("TEST_ONLY");
6644   if (str)
6645     return strstr (str, "checksum") == NULL;
6646   str = getenv ("SKIP_TEST_CHECKSUM_5");
6647   if (str && strcmp (str, "1") == 0) return 1;
6648   str = getenv ("SKIP_TEST_CHECKSUM");
6649   if (str && strcmp (str, "1") == 0) return 1;
6650   return 0;
6651 }
6652
6653 static int test_checksum_5 (void)
6654 {
6655   if (test_checksum_5_skip ()) {
6656     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
6657     return 0;
6658   }
6659
6660   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
6661   {
6662     char device[] = "/dev/sda";
6663     int r;
6664     suppress_error = 0;
6665     r = guestfs_blockdev_setrw (g, device);
6666     if (r == -1)
6667       return -1;
6668   }
6669   {
6670     int r;
6671     suppress_error = 0;
6672     r = guestfs_umount_all (g);
6673     if (r == -1)
6674       return -1;
6675   }
6676   {
6677     int r;
6678     suppress_error = 0;
6679     r = guestfs_lvm_remove_all (g);
6680     if (r == -1)
6681       return -1;
6682   }
6683   {
6684     char device[] = "/dev/sda";
6685     char lines_0[] = ",";
6686     char *lines[] = {
6687       lines_0,
6688       NULL
6689     };
6690     int r;
6691     suppress_error = 0;
6692     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6693     if (r == -1)
6694       return -1;
6695   }
6696   {
6697     char fstype[] = "ext2";
6698     char device[] = "/dev/sda1";
6699     int r;
6700     suppress_error = 0;
6701     r = guestfs_mkfs (g, fstype, device);
6702     if (r == -1)
6703       return -1;
6704   }
6705   {
6706     char device[] = "/dev/sda1";
6707     char mountpoint[] = "/";
6708     int r;
6709     suppress_error = 0;
6710     r = guestfs_mount (g, device, mountpoint);
6711     if (r == -1)
6712       return -1;
6713   }
6714   /* TestOutput for checksum (5) */
6715   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
6716   {
6717     char path[] = "/new";
6718     char content[] = "test\n";
6719     int r;
6720     suppress_error = 0;
6721     r = guestfs_write_file (g, path, content, 0);
6722     if (r == -1)
6723       return -1;
6724   }
6725   {
6726     char csumtype[] = "sha256";
6727     char path[] = "/new";
6728     char *r;
6729     suppress_error = 0;
6730     r = guestfs_checksum (g, csumtype, path);
6731     if (r == NULL)
6732       return -1;
6733     if (strcmp (r, expected) != 0) {
6734       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
6735       return -1;
6736     }
6737     free (r);
6738   }
6739   return 0;
6740 }
6741
6742 static int test_checksum_6_skip (void)
6743 {
6744   const char *str;
6745
6746   str = getenv ("TEST_ONLY");
6747   if (str)
6748     return strstr (str, "checksum") == NULL;
6749   str = getenv ("SKIP_TEST_CHECKSUM_6");
6750   if (str && strcmp (str, "1") == 0) return 1;
6751   str = getenv ("SKIP_TEST_CHECKSUM");
6752   if (str && strcmp (str, "1") == 0) return 1;
6753   return 0;
6754 }
6755
6756 static int test_checksum_6 (void)
6757 {
6758   if (test_checksum_6_skip ()) {
6759     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
6760     return 0;
6761   }
6762
6763   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
6764   {
6765     char device[] = "/dev/sda";
6766     int r;
6767     suppress_error = 0;
6768     r = guestfs_blockdev_setrw (g, device);
6769     if (r == -1)
6770       return -1;
6771   }
6772   {
6773     int r;
6774     suppress_error = 0;
6775     r = guestfs_umount_all (g);
6776     if (r == -1)
6777       return -1;
6778   }
6779   {
6780     int r;
6781     suppress_error = 0;
6782     r = guestfs_lvm_remove_all (g);
6783     if (r == -1)
6784       return -1;
6785   }
6786   {
6787     char device[] = "/dev/sda";
6788     char lines_0[] = ",";
6789     char *lines[] = {
6790       lines_0,
6791       NULL
6792     };
6793     int r;
6794     suppress_error = 0;
6795     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6796     if (r == -1)
6797       return -1;
6798   }
6799   {
6800     char fstype[] = "ext2";
6801     char device[] = "/dev/sda1";
6802     int r;
6803     suppress_error = 0;
6804     r = guestfs_mkfs (g, fstype, device);
6805     if (r == -1)
6806       return -1;
6807   }
6808   {
6809     char device[] = "/dev/sda1";
6810     char mountpoint[] = "/";
6811     int r;
6812     suppress_error = 0;
6813     r = guestfs_mount (g, device, mountpoint);
6814     if (r == -1)
6815       return -1;
6816   }
6817   /* TestOutput for checksum (6) */
6818   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
6819   {
6820     char path[] = "/new";
6821     char content[] = "test\n";
6822     int r;
6823     suppress_error = 0;
6824     r = guestfs_write_file (g, path, content, 0);
6825     if (r == -1)
6826       return -1;
6827   }
6828   {
6829     char csumtype[] = "sha384";
6830     char path[] = "/new";
6831     char *r;
6832     suppress_error = 0;
6833     r = guestfs_checksum (g, csumtype, path);
6834     if (r == NULL)
6835       return -1;
6836     if (strcmp (r, expected) != 0) {
6837       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6838       return -1;
6839     }
6840     free (r);
6841   }
6842   return 0;
6843 }
6844
6845 static int test_checksum_7_skip (void)
6846 {
6847   const char *str;
6848
6849   str = getenv ("TEST_ONLY");
6850   if (str)
6851     return strstr (str, "checksum") == NULL;
6852   str = getenv ("SKIP_TEST_CHECKSUM_7");
6853   if (str && strcmp (str, "1") == 0) return 1;
6854   str = getenv ("SKIP_TEST_CHECKSUM");
6855   if (str && strcmp (str, "1") == 0) return 1;
6856   return 0;
6857 }
6858
6859 static int test_checksum_7 (void)
6860 {
6861   if (test_checksum_7_skip ()) {
6862     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
6863     return 0;
6864   }
6865
6866   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6867   {
6868     char device[] = "/dev/sda";
6869     int r;
6870     suppress_error = 0;
6871     r = guestfs_blockdev_setrw (g, device);
6872     if (r == -1)
6873       return -1;
6874   }
6875   {
6876     int r;
6877     suppress_error = 0;
6878     r = guestfs_umount_all (g);
6879     if (r == -1)
6880       return -1;
6881   }
6882   {
6883     int r;
6884     suppress_error = 0;
6885     r = guestfs_lvm_remove_all (g);
6886     if (r == -1)
6887       return -1;
6888   }
6889   {
6890     char device[] = "/dev/sda";
6891     char lines_0[] = ",";
6892     char *lines[] = {
6893       lines_0,
6894       NULL
6895     };
6896     int r;
6897     suppress_error = 0;
6898     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6899     if (r == -1)
6900       return -1;
6901   }
6902   {
6903     char fstype[] = "ext2";
6904     char device[] = "/dev/sda1";
6905     int r;
6906     suppress_error = 0;
6907     r = guestfs_mkfs (g, fstype, device);
6908     if (r == -1)
6909       return -1;
6910   }
6911   {
6912     char device[] = "/dev/sda1";
6913     char mountpoint[] = "/";
6914     int r;
6915     suppress_error = 0;
6916     r = guestfs_mount (g, device, mountpoint);
6917     if (r == -1)
6918       return -1;
6919   }
6920   /* TestOutput for checksum (7) */
6921   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6922   {
6923     char path[] = "/new";
6924     char content[] = "test\n";
6925     int r;
6926     suppress_error = 0;
6927     r = guestfs_write_file (g, path, content, 0);
6928     if (r == -1)
6929       return -1;
6930   }
6931   {
6932     char csumtype[] = "sha512";
6933     char path[] = "/new";
6934     char *r;
6935     suppress_error = 0;
6936     r = guestfs_checksum (g, csumtype, path);
6937     if (r == NULL)
6938       return -1;
6939     if (strcmp (r, expected) != 0) {
6940       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6941       return -1;
6942     }
6943     free (r);
6944   }
6945   return 0;
6946 }
6947
6948 static int test_checksum_8_skip (void)
6949 {
6950   const char *str;
6951
6952   str = getenv ("TEST_ONLY");
6953   if (str)
6954     return strstr (str, "checksum") == NULL;
6955   str = getenv ("SKIP_TEST_CHECKSUM_8");
6956   if (str && strcmp (str, "1") == 0) return 1;
6957   str = getenv ("SKIP_TEST_CHECKSUM");
6958   if (str && strcmp (str, "1") == 0) return 1;
6959   return 0;
6960 }
6961
6962 static int test_checksum_8 (void)
6963 {
6964   if (test_checksum_8_skip ()) {
6965     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
6966     return 0;
6967   }
6968
6969   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6970   {
6971     char device[] = "/dev/sda";
6972     int r;
6973     suppress_error = 0;
6974     r = guestfs_blockdev_setrw (g, device);
6975     if (r == -1)
6976       return -1;
6977   }
6978   {
6979     int r;
6980     suppress_error = 0;
6981     r = guestfs_umount_all (g);
6982     if (r == -1)
6983       return -1;
6984   }
6985   {
6986     int r;
6987     suppress_error = 0;
6988     r = guestfs_lvm_remove_all (g);
6989     if (r == -1)
6990       return -1;
6991   }
6992   {
6993     char device[] = "/dev/sda";
6994     char lines_0[] = ",";
6995     char *lines[] = {
6996       lines_0,
6997       NULL
6998     };
6999     int r;
7000     suppress_error = 0;
7001     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7002     if (r == -1)
7003       return -1;
7004   }
7005   {
7006     char fstype[] = "ext2";
7007     char device[] = "/dev/sda1";
7008     int r;
7009     suppress_error = 0;
7010     r = guestfs_mkfs (g, fstype, device);
7011     if (r == -1)
7012       return -1;
7013   }
7014   {
7015     char device[] = "/dev/sda1";
7016     char mountpoint[] = "/";
7017     int r;
7018     suppress_error = 0;
7019     r = guestfs_mount (g, device, mountpoint);
7020     if (r == -1)
7021       return -1;
7022   }
7023   /* TestOutput for checksum (8) */
7024   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
7025   {
7026     char options[] = "ro";
7027     char vfstype[] = "squashfs";
7028     char device[] = "/dev/sdd";
7029     char mountpoint[] = "/";
7030     int r;
7031     suppress_error = 0;
7032     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
7033     if (r == -1)
7034       return -1;
7035   }
7036   {
7037     char csumtype[] = "md5";
7038     char path[] = "/known-3";
7039     char *r;
7040     suppress_error = 0;
7041     r = guestfs_checksum (g, csumtype, path);
7042     if (r == NULL)
7043       return -1;
7044     if (strcmp (r, expected) != 0) {
7045       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
7046       return -1;
7047     }
7048     free (r);
7049   }
7050   return 0;
7051 }
7052
7053 static int test_download_0_skip (void)
7054 {
7055   const char *str;
7056
7057   str = getenv ("TEST_ONLY");
7058   if (str)
7059     return strstr (str, "download") == NULL;
7060   str = getenv ("SKIP_TEST_DOWNLOAD_0");
7061   if (str && strcmp (str, "1") == 0) return 1;
7062   str = getenv ("SKIP_TEST_DOWNLOAD");
7063   if (str && strcmp (str, "1") == 0) return 1;
7064   return 0;
7065 }
7066
7067 static int test_download_0 (void)
7068 {
7069   if (test_download_0_skip ()) {
7070     printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
7071     return 0;
7072   }
7073
7074   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
7075   {
7076     char device[] = "/dev/sda";
7077     int r;
7078     suppress_error = 0;
7079     r = guestfs_blockdev_setrw (g, device);
7080     if (r == -1)
7081       return -1;
7082   }
7083   {
7084     int r;
7085     suppress_error = 0;
7086     r = guestfs_umount_all (g);
7087     if (r == -1)
7088       return -1;
7089   }
7090   {
7091     int r;
7092     suppress_error = 0;
7093     r = guestfs_lvm_remove_all (g);
7094     if (r == -1)
7095       return -1;
7096   }
7097   {
7098     char device[] = "/dev/sda";
7099     char lines_0[] = ",";
7100     char *lines[] = {
7101       lines_0,
7102       NULL
7103     };
7104     int r;
7105     suppress_error = 0;
7106     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7107     if (r == -1)
7108       return -1;
7109   }
7110   {
7111     char fstype[] = "ext2";
7112     char device[] = "/dev/sda1";
7113     int r;
7114     suppress_error = 0;
7115     r = guestfs_mkfs (g, fstype, device);
7116     if (r == -1)
7117       return -1;
7118   }
7119   {
7120     char device[] = "/dev/sda1";
7121     char mountpoint[] = "/";
7122     int r;
7123     suppress_error = 0;
7124     r = guestfs_mount (g, device, mountpoint);
7125     if (r == -1)
7126       return -1;
7127   }
7128   /* TestOutput for download (0) */
7129   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
7130   {
7131     char remotefilename[] = "/COPYING.LIB";
7132     int r;
7133     suppress_error = 0;
7134     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
7135     if (r == -1)
7136       return -1;
7137   }
7138   {
7139     char remotefilename[] = "/COPYING.LIB";
7140     int r;
7141     suppress_error = 0;
7142     r = guestfs_download (g, remotefilename, "testdownload.tmp");
7143     if (r == -1)
7144       return -1;
7145   }
7146   {
7147     char remotefilename[] = "/upload";
7148     int r;
7149     suppress_error = 0;
7150     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
7151     if (r == -1)
7152       return -1;
7153   }
7154   {
7155     char csumtype[] = "md5";
7156     char path[] = "/upload";
7157     char *r;
7158     suppress_error = 0;
7159     r = guestfs_checksum (g, csumtype, path);
7160     if (r == NULL)
7161       return -1;
7162     if (strcmp (r, expected) != 0) {
7163       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
7164       return -1;
7165     }
7166     free (r);
7167   }
7168   return 0;
7169 }
7170
7171 static int test_upload_0_skip (void)
7172 {
7173   const char *str;
7174
7175   str = getenv ("TEST_ONLY");
7176   if (str)
7177     return strstr (str, "upload") == NULL;
7178   str = getenv ("SKIP_TEST_UPLOAD_0");
7179   if (str && strcmp (str, "1") == 0) return 1;
7180   str = getenv ("SKIP_TEST_UPLOAD");
7181   if (str && strcmp (str, "1") == 0) return 1;
7182   return 0;
7183 }
7184
7185 static int test_upload_0 (void)
7186 {
7187   if (test_upload_0_skip ()) {
7188     printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
7189     return 0;
7190   }
7191
7192   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
7193   {
7194     char device[] = "/dev/sda";
7195     int r;
7196     suppress_error = 0;
7197     r = guestfs_blockdev_setrw (g, device);
7198     if (r == -1)
7199       return -1;
7200   }
7201   {
7202     int r;
7203     suppress_error = 0;
7204     r = guestfs_umount_all (g);
7205     if (r == -1)
7206       return -1;
7207   }
7208   {
7209     int r;
7210     suppress_error = 0;
7211     r = guestfs_lvm_remove_all (g);
7212     if (r == -1)
7213       return -1;
7214   }
7215   {
7216     char device[] = "/dev/sda";
7217     char lines_0[] = ",";
7218     char *lines[] = {
7219       lines_0,
7220       NULL
7221     };
7222     int r;
7223     suppress_error = 0;
7224     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7225     if (r == -1)
7226       return -1;
7227   }
7228   {
7229     char fstype[] = "ext2";
7230     char device[] = "/dev/sda1";
7231     int r;
7232     suppress_error = 0;
7233     r = guestfs_mkfs (g, fstype, device);
7234     if (r == -1)
7235       return -1;
7236   }
7237   {
7238     char device[] = "/dev/sda1";
7239     char mountpoint[] = "/";
7240     int r;
7241     suppress_error = 0;
7242     r = guestfs_mount (g, device, mountpoint);
7243     if (r == -1)
7244       return -1;
7245   }
7246   /* TestOutput for upload (0) */
7247   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
7248   {
7249     char remotefilename[] = "/COPYING.LIB";
7250     int r;
7251     suppress_error = 0;
7252     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
7253     if (r == -1)
7254       return -1;
7255   }
7256   {
7257     char csumtype[] = "md5";
7258     char path[] = "/COPYING.LIB";
7259     char *r;
7260     suppress_error = 0;
7261     r = guestfs_checksum (g, csumtype, path);
7262     if (r == NULL)
7263       return -1;
7264     if (strcmp (r, expected) != 0) {
7265       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
7266       return -1;
7267     }
7268     free (r);
7269   }
7270   return 0;
7271 }
7272
7273 static int test_blockdev_rereadpt_0_skip (void)
7274 {
7275   const char *str;
7276
7277   str = getenv ("TEST_ONLY");
7278   if (str)
7279     return strstr (str, "blockdev_rereadpt") == NULL;
7280   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
7281   if (str && strcmp (str, "1") == 0) return 1;
7282   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
7283   if (str && strcmp (str, "1") == 0) return 1;
7284   return 0;
7285 }
7286
7287 static int test_blockdev_rereadpt_0 (void)
7288 {
7289   if (test_blockdev_rereadpt_0_skip ()) {
7290     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
7291     return 0;
7292   }
7293
7294   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
7295   {
7296     char device[] = "/dev/sda";
7297     int r;
7298     suppress_error = 0;
7299     r = guestfs_blockdev_setrw (g, device);
7300     if (r == -1)
7301       return -1;
7302   }
7303   {
7304     int r;
7305     suppress_error = 0;
7306     r = guestfs_umount_all (g);
7307     if (r == -1)
7308       return -1;
7309   }
7310   {
7311     int r;
7312     suppress_error = 0;
7313     r = guestfs_lvm_remove_all (g);
7314     if (r == -1)
7315       return -1;
7316   }
7317   /* TestRun for blockdev_rereadpt (0) */
7318   {
7319     char device[] = "/dev/sda";
7320     int r;
7321     suppress_error = 0;
7322     r = guestfs_blockdev_rereadpt (g, device);
7323     if (r == -1)
7324       return -1;
7325   }
7326   return 0;
7327 }
7328
7329 static int test_blockdev_flushbufs_0_skip (void)
7330 {
7331   const char *str;
7332
7333   str = getenv ("TEST_ONLY");
7334   if (str)
7335     return strstr (str, "blockdev_flushbufs") == NULL;
7336   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
7337   if (str && strcmp (str, "1") == 0) return 1;
7338   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
7339   if (str && strcmp (str, "1") == 0) return 1;
7340   return 0;
7341 }
7342
7343 static int test_blockdev_flushbufs_0 (void)
7344 {
7345   if (test_blockdev_flushbufs_0_skip ()) {
7346     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
7347     return 0;
7348   }
7349
7350   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
7351   {
7352     char device[] = "/dev/sda";
7353     int r;
7354     suppress_error = 0;
7355     r = guestfs_blockdev_setrw (g, device);
7356     if (r == -1)
7357       return -1;
7358   }
7359   {
7360     int r;
7361     suppress_error = 0;
7362     r = guestfs_umount_all (g);
7363     if (r == -1)
7364       return -1;
7365   }
7366   {
7367     int r;
7368     suppress_error = 0;
7369     r = guestfs_lvm_remove_all (g);
7370     if (r == -1)
7371       return -1;
7372   }
7373   /* TestRun for blockdev_flushbufs (0) */
7374   {
7375     char device[] = "/dev/sda";
7376     int r;
7377     suppress_error = 0;
7378     r = guestfs_blockdev_flushbufs (g, device);
7379     if (r == -1)
7380       return -1;
7381   }
7382   return 0;
7383 }
7384
7385 static int test_blockdev_getsize64_0_skip (void)
7386 {
7387   const char *str;
7388
7389   str = getenv ("TEST_ONLY");
7390   if (str)
7391     return strstr (str, "blockdev_getsize64") == NULL;
7392   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
7393   if (str && strcmp (str, "1") == 0) return 1;
7394   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
7395   if (str && strcmp (str, "1") == 0) return 1;
7396   return 0;
7397 }
7398
7399 static int test_blockdev_getsize64_0 (void)
7400 {
7401   if (test_blockdev_getsize64_0_skip ()) {
7402     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
7403     return 0;
7404   }
7405
7406   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
7407   {
7408     char device[] = "/dev/sda";
7409     int r;
7410     suppress_error = 0;
7411     r = guestfs_blockdev_setrw (g, device);
7412     if (r == -1)
7413       return -1;
7414   }
7415   {
7416     int r;
7417     suppress_error = 0;
7418     r = guestfs_umount_all (g);
7419     if (r == -1)
7420       return -1;
7421   }
7422   {
7423     int r;
7424     suppress_error = 0;
7425     r = guestfs_lvm_remove_all (g);
7426     if (r == -1)
7427       return -1;
7428   }
7429   /* TestOutputInt for blockdev_getsize64 (0) */
7430   {
7431     char device[] = "/dev/sda";
7432     int64_t r;
7433     suppress_error = 0;
7434     r = guestfs_blockdev_getsize64 (g, device);
7435     if (r == -1)
7436       return -1;
7437     if (r != 524288000) {
7438       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
7439       return -1;
7440     }
7441   }
7442   return 0;
7443 }
7444
7445 static int test_blockdev_getsz_0_skip (void)
7446 {
7447   const char *str;
7448
7449   str = getenv ("TEST_ONLY");
7450   if (str)
7451     return strstr (str, "blockdev_getsz") == NULL;
7452   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
7453   if (str && strcmp (str, "1") == 0) return 1;
7454   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
7455   if (str && strcmp (str, "1") == 0) return 1;
7456   return 0;
7457 }
7458
7459 static int test_blockdev_getsz_0 (void)
7460 {
7461   if (test_blockdev_getsz_0_skip ()) {
7462     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
7463     return 0;
7464   }
7465
7466   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
7467   {
7468     char device[] = "/dev/sda";
7469     int r;
7470     suppress_error = 0;
7471     r = guestfs_blockdev_setrw (g, device);
7472     if (r == -1)
7473       return -1;
7474   }
7475   {
7476     int r;
7477     suppress_error = 0;
7478     r = guestfs_umount_all (g);
7479     if (r == -1)
7480       return -1;
7481   }
7482   {
7483     int r;
7484     suppress_error = 0;
7485     r = guestfs_lvm_remove_all (g);
7486     if (r == -1)
7487       return -1;
7488   }
7489   /* TestOutputInt for blockdev_getsz (0) */
7490   {
7491     char device[] = "/dev/sda";
7492     int64_t r;
7493     suppress_error = 0;
7494     r = guestfs_blockdev_getsz (g, device);
7495     if (r == -1)
7496       return -1;
7497     if (r != 1024000) {
7498       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
7499       return -1;
7500     }
7501   }
7502   return 0;
7503 }
7504
7505 static int test_blockdev_getbsz_0_skip (void)
7506 {
7507   const char *str;
7508
7509   str = getenv ("TEST_ONLY");
7510   if (str)
7511     return strstr (str, "blockdev_getbsz") == NULL;
7512   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
7513   if (str && strcmp (str, "1") == 0) return 1;
7514   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
7515   if (str && strcmp (str, "1") == 0) return 1;
7516   return 0;
7517 }
7518
7519 static int test_blockdev_getbsz_0 (void)
7520 {
7521   if (test_blockdev_getbsz_0_skip ()) {
7522     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
7523     return 0;
7524   }
7525
7526   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
7527   {
7528     char device[] = "/dev/sda";
7529     int r;
7530     suppress_error = 0;
7531     r = guestfs_blockdev_setrw (g, device);
7532     if (r == -1)
7533       return -1;
7534   }
7535   {
7536     int r;
7537     suppress_error = 0;
7538     r = guestfs_umount_all (g);
7539     if (r == -1)
7540       return -1;
7541   }
7542   {
7543     int r;
7544     suppress_error = 0;
7545     r = guestfs_lvm_remove_all (g);
7546     if (r == -1)
7547       return -1;
7548   }
7549   /* TestOutputInt for blockdev_getbsz (0) */
7550   {
7551     char device[] = "/dev/sda";
7552     int r;
7553     suppress_error = 0;
7554     r = guestfs_blockdev_getbsz (g, device);
7555     if (r == -1)
7556       return -1;
7557     if (r != 4096) {
7558       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
7559       return -1;
7560     }
7561   }
7562   return 0;
7563 }
7564
7565 static int test_blockdev_getss_0_skip (void)
7566 {
7567   const char *str;
7568
7569   str = getenv ("TEST_ONLY");
7570   if (str)
7571     return strstr (str, "blockdev_getss") == NULL;
7572   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
7573   if (str && strcmp (str, "1") == 0) return 1;
7574   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
7575   if (str && strcmp (str, "1") == 0) return 1;
7576   return 0;
7577 }
7578
7579 static int test_blockdev_getss_0 (void)
7580 {
7581   if (test_blockdev_getss_0_skip ()) {
7582     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
7583     return 0;
7584   }
7585
7586   /* InitNone|InitEmpty for test_blockdev_getss_0 */
7587   {
7588     char device[] = "/dev/sda";
7589     int r;
7590     suppress_error = 0;
7591     r = guestfs_blockdev_setrw (g, device);
7592     if (r == -1)
7593       return -1;
7594   }
7595   {
7596     int r;
7597     suppress_error = 0;
7598     r = guestfs_umount_all (g);
7599     if (r == -1)
7600       return -1;
7601   }
7602   {
7603     int r;
7604     suppress_error = 0;
7605     r = guestfs_lvm_remove_all (g);
7606     if (r == -1)
7607       return -1;
7608   }
7609   /* TestOutputInt for blockdev_getss (0) */
7610   {
7611     char device[] = "/dev/sda";
7612     int r;
7613     suppress_error = 0;
7614     r = guestfs_blockdev_getss (g, device);
7615     if (r == -1)
7616       return -1;
7617     if (r != 512) {
7618       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
7619       return -1;
7620     }
7621   }
7622   return 0;
7623 }
7624
7625 static int test_blockdev_getro_0_skip (void)
7626 {
7627   const char *str;
7628
7629   str = getenv ("TEST_ONLY");
7630   if (str)
7631     return strstr (str, "blockdev_getro") == NULL;
7632   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
7633   if (str && strcmp (str, "1") == 0) return 1;
7634   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
7635   if (str && strcmp (str, "1") == 0) return 1;
7636   return 0;
7637 }
7638
7639 static int test_blockdev_getro_0 (void)
7640 {
7641   if (test_blockdev_getro_0_skip ()) {
7642     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
7643     return 0;
7644   }
7645
7646   /* InitNone|InitEmpty for test_blockdev_getro_0 */
7647   {
7648     char device[] = "/dev/sda";
7649     int r;
7650     suppress_error = 0;
7651     r = guestfs_blockdev_setrw (g, device);
7652     if (r == -1)
7653       return -1;
7654   }
7655   {
7656     int r;
7657     suppress_error = 0;
7658     r = guestfs_umount_all (g);
7659     if (r == -1)
7660       return -1;
7661   }
7662   {
7663     int r;
7664     suppress_error = 0;
7665     r = guestfs_lvm_remove_all (g);
7666     if (r == -1)
7667       return -1;
7668   }
7669   /* TestOutputTrue for blockdev_getro (0) */
7670   {
7671     char device[] = "/dev/sda";
7672     int r;
7673     suppress_error = 0;
7674     r = guestfs_blockdev_setro (g, device);
7675     if (r == -1)
7676       return -1;
7677   }
7678   {
7679     char device[] = "/dev/sda";
7680     int r;
7681     suppress_error = 0;
7682     r = guestfs_blockdev_getro (g, device);
7683     if (r == -1)
7684       return -1;
7685     if (!r) {
7686       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
7687       return -1;
7688     }
7689   }
7690   return 0;
7691 }
7692
7693 static int test_blockdev_setrw_0_skip (void)
7694 {
7695   const char *str;
7696
7697   str = getenv ("TEST_ONLY");
7698   if (str)
7699     return strstr (str, "blockdev_setrw") == NULL;
7700   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
7701   if (str && strcmp (str, "1") == 0) return 1;
7702   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
7703   if (str && strcmp (str, "1") == 0) return 1;
7704   return 0;
7705 }
7706
7707 static int test_blockdev_setrw_0 (void)
7708 {
7709   if (test_blockdev_setrw_0_skip ()) {
7710     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
7711     return 0;
7712   }
7713
7714   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
7715   {
7716     char device[] = "/dev/sda";
7717     int r;
7718     suppress_error = 0;
7719     r = guestfs_blockdev_setrw (g, device);
7720     if (r == -1)
7721       return -1;
7722   }
7723   {
7724     int r;
7725     suppress_error = 0;
7726     r = guestfs_umount_all (g);
7727     if (r == -1)
7728       return -1;
7729   }
7730   {
7731     int r;
7732     suppress_error = 0;
7733     r = guestfs_lvm_remove_all (g);
7734     if (r == -1)
7735       return -1;
7736   }
7737   /* TestOutputFalse for blockdev_setrw (0) */
7738   {
7739     char device[] = "/dev/sda";
7740     int r;
7741     suppress_error = 0;
7742     r = guestfs_blockdev_setrw (g, device);
7743     if (r == -1)
7744       return -1;
7745   }
7746   {
7747     char device[] = "/dev/sda";
7748     int r;
7749     suppress_error = 0;
7750     r = guestfs_blockdev_getro (g, device);
7751     if (r == -1)
7752       return -1;
7753     if (r) {
7754       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
7755       return -1;
7756     }
7757   }
7758   return 0;
7759 }
7760
7761 static int test_blockdev_setro_0_skip (void)
7762 {
7763   const char *str;
7764
7765   str = getenv ("TEST_ONLY");
7766   if (str)
7767     return strstr (str, "blockdev_setro") == NULL;
7768   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
7769   if (str && strcmp (str, "1") == 0) return 1;
7770   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
7771   if (str && strcmp (str, "1") == 0) return 1;
7772   return 0;
7773 }
7774
7775 static int test_blockdev_setro_0 (void)
7776 {
7777   if (test_blockdev_setro_0_skip ()) {
7778     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
7779     return 0;
7780   }
7781
7782   /* InitNone|InitEmpty for test_blockdev_setro_0 */
7783   {
7784     char device[] = "/dev/sda";
7785     int r;
7786     suppress_error = 0;
7787     r = guestfs_blockdev_setrw (g, device);
7788     if (r == -1)
7789       return -1;
7790   }
7791   {
7792     int r;
7793     suppress_error = 0;
7794     r = guestfs_umount_all (g);
7795     if (r == -1)
7796       return -1;
7797   }
7798   {
7799     int r;
7800     suppress_error = 0;
7801     r = guestfs_lvm_remove_all (g);
7802     if (r == -1)
7803       return -1;
7804   }
7805   /* TestOutputTrue for blockdev_setro (0) */
7806   {
7807     char device[] = "/dev/sda";
7808     int r;
7809     suppress_error = 0;
7810     r = guestfs_blockdev_setro (g, device);
7811     if (r == -1)
7812       return -1;
7813   }
7814   {
7815     char device[] = "/dev/sda";
7816     int r;
7817     suppress_error = 0;
7818     r = guestfs_blockdev_getro (g, device);
7819     if (r == -1)
7820       return -1;
7821     if (!r) {
7822       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
7823       return -1;
7824     }
7825   }
7826   return 0;
7827 }
7828
7829 static int test_statvfs_0_skip (void)
7830 {
7831   const char *str;
7832
7833   str = getenv ("TEST_ONLY");
7834   if (str)
7835     return strstr (str, "statvfs") == NULL;
7836   str = getenv ("SKIP_TEST_STATVFS_0");
7837   if (str && strcmp (str, "1") == 0) return 1;
7838   str = getenv ("SKIP_TEST_STATVFS");
7839   if (str && strcmp (str, "1") == 0) return 1;
7840   return 0;
7841 }
7842
7843 static int test_statvfs_0 (void)
7844 {
7845   if (test_statvfs_0_skip ()) {
7846     printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
7847     return 0;
7848   }
7849
7850   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
7851   {
7852     char device[] = "/dev/sda";
7853     int r;
7854     suppress_error = 0;
7855     r = guestfs_blockdev_setrw (g, device);
7856     if (r == -1)
7857       return -1;
7858   }
7859   {
7860     int r;
7861     suppress_error = 0;
7862     r = guestfs_umount_all (g);
7863     if (r == -1)
7864       return -1;
7865   }
7866   {
7867     int r;
7868     suppress_error = 0;
7869     r = guestfs_lvm_remove_all (g);
7870     if (r == -1)
7871       return -1;
7872   }
7873   {
7874     char device[] = "/dev/sda";
7875     char lines_0[] = ",";
7876     char *lines[] = {
7877       lines_0,
7878       NULL
7879     };
7880     int r;
7881     suppress_error = 0;
7882     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7883     if (r == -1)
7884       return -1;
7885   }
7886   {
7887     char fstype[] = "ext2";
7888     char device[] = "/dev/sda1";
7889     int r;
7890     suppress_error = 0;
7891     r = guestfs_mkfs (g, fstype, device);
7892     if (r == -1)
7893       return -1;
7894   }
7895   {
7896     char device[] = "/dev/sda1";
7897     char mountpoint[] = "/";
7898     int r;
7899     suppress_error = 0;
7900     r = guestfs_mount (g, device, mountpoint);
7901     if (r == -1)
7902       return -1;
7903   }
7904   /* TestOutputStruct for statvfs (0) */
7905   {
7906     char path[] = "/";
7907     struct guestfs_statvfs *r;
7908     suppress_error = 0;
7909     r = guestfs_statvfs (g, path);
7910     if (r == NULL)
7911       return -1;
7912     if (r->bfree != 487702) {
7913       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7914                (int) r->bfree);
7915       return -1;
7916     }
7917     if (r->blocks != 490020) {
7918       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7919                (int) r->blocks);
7920       return -1;
7921     }
7922     if (r->bsize != 1024) {
7923       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7924                (int) r->bsize);
7925       return -1;
7926     }
7927     free (r);
7928   }
7929   return 0;
7930 }
7931
7932 static int test_lstat_0_skip (void)
7933 {
7934   const char *str;
7935
7936   str = getenv ("TEST_ONLY");
7937   if (str)
7938     return strstr (str, "lstat") == NULL;
7939   str = getenv ("SKIP_TEST_LSTAT_0");
7940   if (str && strcmp (str, "1") == 0) return 1;
7941   str = getenv ("SKIP_TEST_LSTAT");
7942   if (str && strcmp (str, "1") == 0) return 1;
7943   return 0;
7944 }
7945
7946 static int test_lstat_0 (void)
7947 {
7948   if (test_lstat_0_skip ()) {
7949     printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
7950     return 0;
7951   }
7952
7953   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7954   {
7955     char device[] = "/dev/sda";
7956     int r;
7957     suppress_error = 0;
7958     r = guestfs_blockdev_setrw (g, device);
7959     if (r == -1)
7960       return -1;
7961   }
7962   {
7963     int r;
7964     suppress_error = 0;
7965     r = guestfs_umount_all (g);
7966     if (r == -1)
7967       return -1;
7968   }
7969   {
7970     int r;
7971     suppress_error = 0;
7972     r = guestfs_lvm_remove_all (g);
7973     if (r == -1)
7974       return -1;
7975   }
7976   {
7977     char device[] = "/dev/sda";
7978     char lines_0[] = ",";
7979     char *lines[] = {
7980       lines_0,
7981       NULL
7982     };
7983     int r;
7984     suppress_error = 0;
7985     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7986     if (r == -1)
7987       return -1;
7988   }
7989   {
7990     char fstype[] = "ext2";
7991     char device[] = "/dev/sda1";
7992     int r;
7993     suppress_error = 0;
7994     r = guestfs_mkfs (g, fstype, device);
7995     if (r == -1)
7996       return -1;
7997   }
7998   {
7999     char device[] = "/dev/sda1";
8000     char mountpoint[] = "/";
8001     int r;
8002     suppress_error = 0;
8003     r = guestfs_mount (g, device, mountpoint);
8004     if (r == -1)
8005       return -1;
8006   }
8007   /* TestOutputStruct for lstat (0) */
8008   {
8009     char path[] = "/new";
8010     int r;
8011     suppress_error = 0;
8012     r = guestfs_touch (g, path);
8013     if (r == -1)
8014       return -1;
8015   }
8016   {
8017     char path[] = "/new";
8018     struct guestfs_stat *r;
8019     suppress_error = 0;
8020     r = guestfs_lstat (g, path);
8021     if (r == NULL)
8022       return -1;
8023     if (r->size != 0) {
8024       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
8025                (int) r->size);
8026       return -1;
8027     }
8028     free (r);
8029   }
8030   return 0;
8031 }
8032
8033 static int test_stat_0_skip (void)
8034 {
8035   const char *str;
8036
8037   str = getenv ("TEST_ONLY");
8038   if (str)
8039     return strstr (str, "stat") == NULL;
8040   str = getenv ("SKIP_TEST_STAT_0");
8041   if (str && strcmp (str, "1") == 0) return 1;
8042   str = getenv ("SKIP_TEST_STAT");
8043   if (str && strcmp (str, "1") == 0) return 1;
8044   return 0;
8045 }
8046
8047 static int test_stat_0 (void)
8048 {
8049   if (test_stat_0_skip ()) {
8050     printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
8051     return 0;
8052   }
8053
8054   /* InitBasicFS for test_stat_0: 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   /* TestOutputStruct for stat (0) */
8109   {
8110     char path[] = "/new";
8111     int r;
8112     suppress_error = 0;
8113     r = guestfs_touch (g, path);
8114     if (r == -1)
8115       return -1;
8116   }
8117   {
8118     char path[] = "/new";
8119     struct guestfs_stat *r;
8120     suppress_error = 0;
8121     r = guestfs_stat (g, path);
8122     if (r == NULL)
8123       return -1;
8124     if (r->size != 0) {
8125       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
8126                (int) r->size);
8127       return -1;
8128     }
8129     free (r);
8130   }
8131   return 0;
8132 }
8133
8134 static int test_command_lines_0_skip (void)
8135 {
8136   const char *str;
8137
8138   str = getenv ("TEST_ONLY");
8139   if (str)
8140     return strstr (str, "command_lines") == NULL;
8141   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
8142   if (str && strcmp (str, "1") == 0) return 1;
8143   str = getenv ("SKIP_TEST_COMMAND_LINES");
8144   if (str && strcmp (str, "1") == 0) return 1;
8145   return 0;
8146 }
8147
8148 static int test_command_lines_0 (void)
8149 {
8150   if (test_command_lines_0_skip ()) {
8151     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
8152     return 0;
8153   }
8154
8155   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
8156   {
8157     char device[] = "/dev/sda";
8158     int r;
8159     suppress_error = 0;
8160     r = guestfs_blockdev_setrw (g, device);
8161     if (r == -1)
8162       return -1;
8163   }
8164   {
8165     int r;
8166     suppress_error = 0;
8167     r = guestfs_umount_all (g);
8168     if (r == -1)
8169       return -1;
8170   }
8171   {
8172     int r;
8173     suppress_error = 0;
8174     r = guestfs_lvm_remove_all (g);
8175     if (r == -1)
8176       return -1;
8177   }
8178   {
8179     char device[] = "/dev/sda";
8180     char lines_0[] = ",";
8181     char *lines[] = {
8182       lines_0,
8183       NULL
8184     };
8185     int r;
8186     suppress_error = 0;
8187     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8188     if (r == -1)
8189       return -1;
8190   }
8191   {
8192     char fstype[] = "ext2";
8193     char device[] = "/dev/sda1";
8194     int r;
8195     suppress_error = 0;
8196     r = guestfs_mkfs (g, fstype, device);
8197     if (r == -1)
8198       return -1;
8199   }
8200   {
8201     char device[] = "/dev/sda1";
8202     char mountpoint[] = "/";
8203     int r;
8204     suppress_error = 0;
8205     r = guestfs_mount (g, device, mountpoint);
8206     if (r == -1)
8207       return -1;
8208   }
8209   /* TestOutputList for command_lines (0) */
8210   {
8211     char remotefilename[] = "/test-command";
8212     int r;
8213     suppress_error = 0;
8214     r = guestfs_upload (g, "test-command", remotefilename);
8215     if (r == -1)
8216       return -1;
8217   }
8218   {
8219     char path[] = "/test-command";
8220     int r;
8221     suppress_error = 0;
8222     r = guestfs_chmod (g, 493, path);
8223     if (r == -1)
8224       return -1;
8225   }
8226   {
8227     char arguments_0[] = "/test-command";
8228     char arguments_1[] = "1";
8229     char *arguments[] = {
8230       arguments_0,
8231       arguments_1,
8232       NULL
8233     };
8234     char **r;
8235     int i;
8236     suppress_error = 0;
8237     r = guestfs_command_lines (g, arguments);
8238     if (r == NULL)
8239       return -1;
8240     if (!r[0]) {
8241       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
8242       print_strings (r);
8243       return -1;
8244     }
8245     {
8246       char expected[] = "Result1";
8247       if (strcmp (r[0], expected) != 0) {
8248         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8249         return -1;
8250       }
8251     }
8252     if (r[1] != NULL) {
8253       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
8254       print_strings (r);
8255       return -1;
8256     }
8257     for (i = 0; r[i] != NULL; ++i)
8258       free (r[i]);
8259     free (r);
8260   }
8261   return 0;
8262 }
8263
8264 static int test_command_lines_1_skip (void)
8265 {
8266   const char *str;
8267
8268   str = getenv ("TEST_ONLY");
8269   if (str)
8270     return strstr (str, "command_lines") == NULL;
8271   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
8272   if (str && strcmp (str, "1") == 0) return 1;
8273   str = getenv ("SKIP_TEST_COMMAND_LINES");
8274   if (str && strcmp (str, "1") == 0) return 1;
8275   return 0;
8276 }
8277
8278 static int test_command_lines_1 (void)
8279 {
8280   if (test_command_lines_1_skip ()) {
8281     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
8282     return 0;
8283   }
8284
8285   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
8286   {
8287     char device[] = "/dev/sda";
8288     int r;
8289     suppress_error = 0;
8290     r = guestfs_blockdev_setrw (g, device);
8291     if (r == -1)
8292       return -1;
8293   }
8294   {
8295     int r;
8296     suppress_error = 0;
8297     r = guestfs_umount_all (g);
8298     if (r == -1)
8299       return -1;
8300   }
8301   {
8302     int r;
8303     suppress_error = 0;
8304     r = guestfs_lvm_remove_all (g);
8305     if (r == -1)
8306       return -1;
8307   }
8308   {
8309     char device[] = "/dev/sda";
8310     char lines_0[] = ",";
8311     char *lines[] = {
8312       lines_0,
8313       NULL
8314     };
8315     int r;
8316     suppress_error = 0;
8317     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8318     if (r == -1)
8319       return -1;
8320   }
8321   {
8322     char fstype[] = "ext2";
8323     char device[] = "/dev/sda1";
8324     int r;
8325     suppress_error = 0;
8326     r = guestfs_mkfs (g, fstype, device);
8327     if (r == -1)
8328       return -1;
8329   }
8330   {
8331     char device[] = "/dev/sda1";
8332     char mountpoint[] = "/";
8333     int r;
8334     suppress_error = 0;
8335     r = guestfs_mount (g, device, mountpoint);
8336     if (r == -1)
8337       return -1;
8338   }
8339   /* TestOutputList for command_lines (1) */
8340   {
8341     char remotefilename[] = "/test-command";
8342     int r;
8343     suppress_error = 0;
8344     r = guestfs_upload (g, "test-command", remotefilename);
8345     if (r == -1)
8346       return -1;
8347   }
8348   {
8349     char path[] = "/test-command";
8350     int r;
8351     suppress_error = 0;
8352     r = guestfs_chmod (g, 493, path);
8353     if (r == -1)
8354       return -1;
8355   }
8356   {
8357     char arguments_0[] = "/test-command";
8358     char arguments_1[] = "2";
8359     char *arguments[] = {
8360       arguments_0,
8361       arguments_1,
8362       NULL
8363     };
8364     char **r;
8365     int i;
8366     suppress_error = 0;
8367     r = guestfs_command_lines (g, arguments);
8368     if (r == NULL)
8369       return -1;
8370     if (!r[0]) {
8371       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
8372       print_strings (r);
8373       return -1;
8374     }
8375     {
8376       char expected[] = "Result2";
8377       if (strcmp (r[0], expected) != 0) {
8378         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8379         return -1;
8380       }
8381     }
8382     if (r[1] != NULL) {
8383       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
8384       print_strings (r);
8385       return -1;
8386     }
8387     for (i = 0; r[i] != NULL; ++i)
8388       free (r[i]);
8389     free (r);
8390   }
8391   return 0;
8392 }
8393
8394 static int test_command_lines_2_skip (void)
8395 {
8396   const char *str;
8397
8398   str = getenv ("TEST_ONLY");
8399   if (str)
8400     return strstr (str, "command_lines") == NULL;
8401   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
8402   if (str && strcmp (str, "1") == 0) return 1;
8403   str = getenv ("SKIP_TEST_COMMAND_LINES");
8404   if (str && strcmp (str, "1") == 0) return 1;
8405   return 0;
8406 }
8407
8408 static int test_command_lines_2 (void)
8409 {
8410   if (test_command_lines_2_skip ()) {
8411     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
8412     return 0;
8413   }
8414
8415   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
8416   {
8417     char device[] = "/dev/sda";
8418     int r;
8419     suppress_error = 0;
8420     r = guestfs_blockdev_setrw (g, device);
8421     if (r == -1)
8422       return -1;
8423   }
8424   {
8425     int r;
8426     suppress_error = 0;
8427     r = guestfs_umount_all (g);
8428     if (r == -1)
8429       return -1;
8430   }
8431   {
8432     int r;
8433     suppress_error = 0;
8434     r = guestfs_lvm_remove_all (g);
8435     if (r == -1)
8436       return -1;
8437   }
8438   {
8439     char device[] = "/dev/sda";
8440     char lines_0[] = ",";
8441     char *lines[] = {
8442       lines_0,
8443       NULL
8444     };
8445     int r;
8446     suppress_error = 0;
8447     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8448     if (r == -1)
8449       return -1;
8450   }
8451   {
8452     char fstype[] = "ext2";
8453     char device[] = "/dev/sda1";
8454     int r;
8455     suppress_error = 0;
8456     r = guestfs_mkfs (g, fstype, device);
8457     if (r == -1)
8458       return -1;
8459   }
8460   {
8461     char device[] = "/dev/sda1";
8462     char mountpoint[] = "/";
8463     int r;
8464     suppress_error = 0;
8465     r = guestfs_mount (g, device, mountpoint);
8466     if (r == -1)
8467       return -1;
8468   }
8469   /* TestOutputList for command_lines (2) */
8470   {
8471     char remotefilename[] = "/test-command";
8472     int r;
8473     suppress_error = 0;
8474     r = guestfs_upload (g, "test-command", remotefilename);
8475     if (r == -1)
8476       return -1;
8477   }
8478   {
8479     char path[] = "/test-command";
8480     int r;
8481     suppress_error = 0;
8482     r = guestfs_chmod (g, 493, path);
8483     if (r == -1)
8484       return -1;
8485   }
8486   {
8487     char arguments_0[] = "/test-command";
8488     char arguments_1[] = "3";
8489     char *arguments[] = {
8490       arguments_0,
8491       arguments_1,
8492       NULL
8493     };
8494     char **r;
8495     int i;
8496     suppress_error = 0;
8497     r = guestfs_command_lines (g, arguments);
8498     if (r == NULL)
8499       return -1;
8500     if (!r[0]) {
8501       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
8502       print_strings (r);
8503       return -1;
8504     }
8505     {
8506       char expected[] = "";
8507       if (strcmp (r[0], expected) != 0) {
8508         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8509         return -1;
8510       }
8511     }
8512     if (!r[1]) {
8513       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
8514       print_strings (r);
8515       return -1;
8516     }
8517     {
8518       char expected[] = "Result3";
8519       if (strcmp (r[1], expected) != 0) {
8520         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8521         return -1;
8522       }
8523     }
8524     if (r[2] != NULL) {
8525       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
8526       print_strings (r);
8527       return -1;
8528     }
8529     for (i = 0; r[i] != NULL; ++i)
8530       free (r[i]);
8531     free (r);
8532   }
8533   return 0;
8534 }
8535
8536 static int test_command_lines_3_skip (void)
8537 {
8538   const char *str;
8539
8540   str = getenv ("TEST_ONLY");
8541   if (str)
8542     return strstr (str, "command_lines") == NULL;
8543   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
8544   if (str && strcmp (str, "1") == 0) return 1;
8545   str = getenv ("SKIP_TEST_COMMAND_LINES");
8546   if (str && strcmp (str, "1") == 0) return 1;
8547   return 0;
8548 }
8549
8550 static int test_command_lines_3 (void)
8551 {
8552   if (test_command_lines_3_skip ()) {
8553     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
8554     return 0;
8555   }
8556
8557   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
8558   {
8559     char device[] = "/dev/sda";
8560     int r;
8561     suppress_error = 0;
8562     r = guestfs_blockdev_setrw (g, device);
8563     if (r == -1)
8564       return -1;
8565   }
8566   {
8567     int r;
8568     suppress_error = 0;
8569     r = guestfs_umount_all (g);
8570     if (r == -1)
8571       return -1;
8572   }
8573   {
8574     int r;
8575     suppress_error = 0;
8576     r = guestfs_lvm_remove_all (g);
8577     if (r == -1)
8578       return -1;
8579   }
8580   {
8581     char device[] = "/dev/sda";
8582     char lines_0[] = ",";
8583     char *lines[] = {
8584       lines_0,
8585       NULL
8586     };
8587     int r;
8588     suppress_error = 0;
8589     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8590     if (r == -1)
8591       return -1;
8592   }
8593   {
8594     char fstype[] = "ext2";
8595     char device[] = "/dev/sda1";
8596     int r;
8597     suppress_error = 0;
8598     r = guestfs_mkfs (g, fstype, device);
8599     if (r == -1)
8600       return -1;
8601   }
8602   {
8603     char device[] = "/dev/sda1";
8604     char mountpoint[] = "/";
8605     int r;
8606     suppress_error = 0;
8607     r = guestfs_mount (g, device, mountpoint);
8608     if (r == -1)
8609       return -1;
8610   }
8611   /* TestOutputList for command_lines (3) */
8612   {
8613     char remotefilename[] = "/test-command";
8614     int r;
8615     suppress_error = 0;
8616     r = guestfs_upload (g, "test-command", remotefilename);
8617     if (r == -1)
8618       return -1;
8619   }
8620   {
8621     char path[] = "/test-command";
8622     int r;
8623     suppress_error = 0;
8624     r = guestfs_chmod (g, 493, path);
8625     if (r == -1)
8626       return -1;
8627   }
8628   {
8629     char arguments_0[] = "/test-command";
8630     char arguments_1[] = "4";
8631     char *arguments[] = {
8632       arguments_0,
8633       arguments_1,
8634       NULL
8635     };
8636     char **r;
8637     int i;
8638     suppress_error = 0;
8639     r = guestfs_command_lines (g, arguments);
8640     if (r == NULL)
8641       return -1;
8642     if (!r[0]) {
8643       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8644       print_strings (r);
8645       return -1;
8646     }
8647     {
8648       char expected[] = "";
8649       if (strcmp (r[0], expected) != 0) {
8650         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8651         return -1;
8652       }
8653     }
8654     if (!r[1]) {
8655       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8656       print_strings (r);
8657       return -1;
8658     }
8659     {
8660       char expected[] = "Result4";
8661       if (strcmp (r[1], expected) != 0) {
8662         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8663         return -1;
8664       }
8665     }
8666     if (r[2] != NULL) {
8667       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
8668       print_strings (r);
8669       return -1;
8670     }
8671     for (i = 0; r[i] != NULL; ++i)
8672       free (r[i]);
8673     free (r);
8674   }
8675   return 0;
8676 }
8677
8678 static int test_command_lines_4_skip (void)
8679 {
8680   const char *str;
8681
8682   str = getenv ("TEST_ONLY");
8683   if (str)
8684     return strstr (str, "command_lines") == NULL;
8685   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
8686   if (str && strcmp (str, "1") == 0) return 1;
8687   str = getenv ("SKIP_TEST_COMMAND_LINES");
8688   if (str && strcmp (str, "1") == 0) return 1;
8689   return 0;
8690 }
8691
8692 static int test_command_lines_4 (void)
8693 {
8694   if (test_command_lines_4_skip ()) {
8695     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
8696     return 0;
8697   }
8698
8699   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
8700   {
8701     char device[] = "/dev/sda";
8702     int r;
8703     suppress_error = 0;
8704     r = guestfs_blockdev_setrw (g, device);
8705     if (r == -1)
8706       return -1;
8707   }
8708   {
8709     int r;
8710     suppress_error = 0;
8711     r = guestfs_umount_all (g);
8712     if (r == -1)
8713       return -1;
8714   }
8715   {
8716     int r;
8717     suppress_error = 0;
8718     r = guestfs_lvm_remove_all (g);
8719     if (r == -1)
8720       return -1;
8721   }
8722   {
8723     char device[] = "/dev/sda";
8724     char lines_0[] = ",";
8725     char *lines[] = {
8726       lines_0,
8727       NULL
8728     };
8729     int r;
8730     suppress_error = 0;
8731     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8732     if (r == -1)
8733       return -1;
8734   }
8735   {
8736     char fstype[] = "ext2";
8737     char device[] = "/dev/sda1";
8738     int r;
8739     suppress_error = 0;
8740     r = guestfs_mkfs (g, fstype, device);
8741     if (r == -1)
8742       return -1;
8743   }
8744   {
8745     char device[] = "/dev/sda1";
8746     char mountpoint[] = "/";
8747     int r;
8748     suppress_error = 0;
8749     r = guestfs_mount (g, device, mountpoint);
8750     if (r == -1)
8751       return -1;
8752   }
8753   /* TestOutputList for command_lines (4) */
8754   {
8755     char remotefilename[] = "/test-command";
8756     int r;
8757     suppress_error = 0;
8758     r = guestfs_upload (g, "test-command", remotefilename);
8759     if (r == -1)
8760       return -1;
8761   }
8762   {
8763     char path[] = "/test-command";
8764     int r;
8765     suppress_error = 0;
8766     r = guestfs_chmod (g, 493, path);
8767     if (r == -1)
8768       return -1;
8769   }
8770   {
8771     char arguments_0[] = "/test-command";
8772     char arguments_1[] = "5";
8773     char *arguments[] = {
8774       arguments_0,
8775       arguments_1,
8776       NULL
8777     };
8778     char **r;
8779     int i;
8780     suppress_error = 0;
8781     r = guestfs_command_lines (g, arguments);
8782     if (r == NULL)
8783       return -1;
8784     if (!r[0]) {
8785       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8786       print_strings (r);
8787       return -1;
8788     }
8789     {
8790       char expected[] = "";
8791       if (strcmp (r[0], expected) != 0) {
8792         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8793         return -1;
8794       }
8795     }
8796     if (!r[1]) {
8797       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8798       print_strings (r);
8799       return -1;
8800     }
8801     {
8802       char expected[] = "Result5";
8803       if (strcmp (r[1], expected) != 0) {
8804         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8805         return -1;
8806       }
8807     }
8808     if (!r[2]) {
8809       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8810       print_strings (r);
8811       return -1;
8812     }
8813     {
8814       char expected[] = "";
8815       if (strcmp (r[2], expected) != 0) {
8816         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8817         return -1;
8818       }
8819     }
8820     if (r[3] != NULL) {
8821       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
8822       print_strings (r);
8823       return -1;
8824     }
8825     for (i = 0; r[i] != NULL; ++i)
8826       free (r[i]);
8827     free (r);
8828   }
8829   return 0;
8830 }
8831
8832 static int test_command_lines_5_skip (void)
8833 {
8834   const char *str;
8835
8836   str = getenv ("TEST_ONLY");
8837   if (str)
8838     return strstr (str, "command_lines") == NULL;
8839   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
8840   if (str && strcmp (str, "1") == 0) return 1;
8841   str = getenv ("SKIP_TEST_COMMAND_LINES");
8842   if (str && strcmp (str, "1") == 0) return 1;
8843   return 0;
8844 }
8845
8846 static int test_command_lines_5 (void)
8847 {
8848   if (test_command_lines_5_skip ()) {
8849     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
8850     return 0;
8851   }
8852
8853   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
8854   {
8855     char device[] = "/dev/sda";
8856     int r;
8857     suppress_error = 0;
8858     r = guestfs_blockdev_setrw (g, device);
8859     if (r == -1)
8860       return -1;
8861   }
8862   {
8863     int r;
8864     suppress_error = 0;
8865     r = guestfs_umount_all (g);
8866     if (r == -1)
8867       return -1;
8868   }
8869   {
8870     int r;
8871     suppress_error = 0;
8872     r = guestfs_lvm_remove_all (g);
8873     if (r == -1)
8874       return -1;
8875   }
8876   {
8877     char device[] = "/dev/sda";
8878     char lines_0[] = ",";
8879     char *lines[] = {
8880       lines_0,
8881       NULL
8882     };
8883     int r;
8884     suppress_error = 0;
8885     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8886     if (r == -1)
8887       return -1;
8888   }
8889   {
8890     char fstype[] = "ext2";
8891     char device[] = "/dev/sda1";
8892     int r;
8893     suppress_error = 0;
8894     r = guestfs_mkfs (g, fstype, device);
8895     if (r == -1)
8896       return -1;
8897   }
8898   {
8899     char device[] = "/dev/sda1";
8900     char mountpoint[] = "/";
8901     int r;
8902     suppress_error = 0;
8903     r = guestfs_mount (g, device, mountpoint);
8904     if (r == -1)
8905       return -1;
8906   }
8907   /* TestOutputList for command_lines (5) */
8908   {
8909     char remotefilename[] = "/test-command";
8910     int r;
8911     suppress_error = 0;
8912     r = guestfs_upload (g, "test-command", remotefilename);
8913     if (r == -1)
8914       return -1;
8915   }
8916   {
8917     char path[] = "/test-command";
8918     int r;
8919     suppress_error = 0;
8920     r = guestfs_chmod (g, 493, path);
8921     if (r == -1)
8922       return -1;
8923   }
8924   {
8925     char arguments_0[] = "/test-command";
8926     char arguments_1[] = "6";
8927     char *arguments[] = {
8928       arguments_0,
8929       arguments_1,
8930       NULL
8931     };
8932     char **r;
8933     int i;
8934     suppress_error = 0;
8935     r = guestfs_command_lines (g, arguments);
8936     if (r == NULL)
8937       return -1;
8938     if (!r[0]) {
8939       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8940       print_strings (r);
8941       return -1;
8942     }
8943     {
8944       char expected[] = "";
8945       if (strcmp (r[0], expected) != 0) {
8946         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8947         return -1;
8948       }
8949     }
8950     if (!r[1]) {
8951       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8952       print_strings (r);
8953       return -1;
8954     }
8955     {
8956       char expected[] = "";
8957       if (strcmp (r[1], expected) != 0) {
8958         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8959         return -1;
8960       }
8961     }
8962     if (!r[2]) {
8963       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8964       print_strings (r);
8965       return -1;
8966     }
8967     {
8968       char expected[] = "Result6";
8969       if (strcmp (r[2], expected) != 0) {
8970         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8971         return -1;
8972       }
8973     }
8974     if (!r[3]) {
8975       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8976       print_strings (r);
8977       return -1;
8978     }
8979     {
8980       char expected[] = "";
8981       if (strcmp (r[3], expected) != 0) {
8982         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8983         return -1;
8984       }
8985     }
8986     if (r[4] != NULL) {
8987       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8988       print_strings (r);
8989       return -1;
8990     }
8991     for (i = 0; r[i] != NULL; ++i)
8992       free (r[i]);
8993     free (r);
8994   }
8995   return 0;
8996 }
8997
8998 static int test_command_lines_6_skip (void)
8999 {
9000   const char *str;
9001
9002   str = getenv ("TEST_ONLY");
9003   if (str)
9004     return strstr (str, "command_lines") == NULL;
9005   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
9006   if (str && strcmp (str, "1") == 0) return 1;
9007   str = getenv ("SKIP_TEST_COMMAND_LINES");
9008   if (str && strcmp (str, "1") == 0) return 1;
9009   return 0;
9010 }
9011
9012 static int test_command_lines_6 (void)
9013 {
9014   if (test_command_lines_6_skip ()) {
9015     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
9016     return 0;
9017   }
9018
9019   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
9020   {
9021     char device[] = "/dev/sda";
9022     int r;
9023     suppress_error = 0;
9024     r = guestfs_blockdev_setrw (g, device);
9025     if (r == -1)
9026       return -1;
9027   }
9028   {
9029     int r;
9030     suppress_error = 0;
9031     r = guestfs_umount_all (g);
9032     if (r == -1)
9033       return -1;
9034   }
9035   {
9036     int r;
9037     suppress_error = 0;
9038     r = guestfs_lvm_remove_all (g);
9039     if (r == -1)
9040       return -1;
9041   }
9042   {
9043     char device[] = "/dev/sda";
9044     char lines_0[] = ",";
9045     char *lines[] = {
9046       lines_0,
9047       NULL
9048     };
9049     int r;
9050     suppress_error = 0;
9051     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9052     if (r == -1)
9053       return -1;
9054   }
9055   {
9056     char fstype[] = "ext2";
9057     char device[] = "/dev/sda1";
9058     int r;
9059     suppress_error = 0;
9060     r = guestfs_mkfs (g, fstype, device);
9061     if (r == -1)
9062       return -1;
9063   }
9064   {
9065     char device[] = "/dev/sda1";
9066     char mountpoint[] = "/";
9067     int r;
9068     suppress_error = 0;
9069     r = guestfs_mount (g, device, mountpoint);
9070     if (r == -1)
9071       return -1;
9072   }
9073   /* TestOutputList for command_lines (6) */
9074   {
9075     char remotefilename[] = "/test-command";
9076     int r;
9077     suppress_error = 0;
9078     r = guestfs_upload (g, "test-command", remotefilename);
9079     if (r == -1)
9080       return -1;
9081   }
9082   {
9083     char path[] = "/test-command";
9084     int r;
9085     suppress_error = 0;
9086     r = guestfs_chmod (g, 493, path);
9087     if (r == -1)
9088       return -1;
9089   }
9090   {
9091     char arguments_0[] = "/test-command";
9092     char arguments_1[] = "7";
9093     char *arguments[] = {
9094       arguments_0,
9095       arguments_1,
9096       NULL
9097     };
9098     char **r;
9099     int i;
9100     suppress_error = 0;
9101     r = guestfs_command_lines (g, arguments);
9102     if (r == NULL)
9103       return -1;
9104     if (r[0] != NULL) {
9105       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
9106       print_strings (r);
9107       return -1;
9108     }
9109     for (i = 0; r[i] != NULL; ++i)
9110       free (r[i]);
9111     free (r);
9112   }
9113   return 0;
9114 }
9115
9116 static int test_command_lines_7_skip (void)
9117 {
9118   const char *str;
9119
9120   str = getenv ("TEST_ONLY");
9121   if (str)
9122     return strstr (str, "command_lines") == NULL;
9123   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
9124   if (str && strcmp (str, "1") == 0) return 1;
9125   str = getenv ("SKIP_TEST_COMMAND_LINES");
9126   if (str && strcmp (str, "1") == 0) return 1;
9127   return 0;
9128 }
9129
9130 static int test_command_lines_7 (void)
9131 {
9132   if (test_command_lines_7_skip ()) {
9133     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
9134     return 0;
9135   }
9136
9137   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
9138   {
9139     char device[] = "/dev/sda";
9140     int r;
9141     suppress_error = 0;
9142     r = guestfs_blockdev_setrw (g, device);
9143     if (r == -1)
9144       return -1;
9145   }
9146   {
9147     int r;
9148     suppress_error = 0;
9149     r = guestfs_umount_all (g);
9150     if (r == -1)
9151       return -1;
9152   }
9153   {
9154     int r;
9155     suppress_error = 0;
9156     r = guestfs_lvm_remove_all (g);
9157     if (r == -1)
9158       return -1;
9159   }
9160   {
9161     char device[] = "/dev/sda";
9162     char lines_0[] = ",";
9163     char *lines[] = {
9164       lines_0,
9165       NULL
9166     };
9167     int r;
9168     suppress_error = 0;
9169     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9170     if (r == -1)
9171       return -1;
9172   }
9173   {
9174     char fstype[] = "ext2";
9175     char device[] = "/dev/sda1";
9176     int r;
9177     suppress_error = 0;
9178     r = guestfs_mkfs (g, fstype, device);
9179     if (r == -1)
9180       return -1;
9181   }
9182   {
9183     char device[] = "/dev/sda1";
9184     char mountpoint[] = "/";
9185     int r;
9186     suppress_error = 0;
9187     r = guestfs_mount (g, device, mountpoint);
9188     if (r == -1)
9189       return -1;
9190   }
9191   /* TestOutputList for command_lines (7) */
9192   {
9193     char remotefilename[] = "/test-command";
9194     int r;
9195     suppress_error = 0;
9196     r = guestfs_upload (g, "test-command", remotefilename);
9197     if (r == -1)
9198       return -1;
9199   }
9200   {
9201     char path[] = "/test-command";
9202     int r;
9203     suppress_error = 0;
9204     r = guestfs_chmod (g, 493, path);
9205     if (r == -1)
9206       return -1;
9207   }
9208   {
9209     char arguments_0[] = "/test-command";
9210     char arguments_1[] = "8";
9211     char *arguments[] = {
9212       arguments_0,
9213       arguments_1,
9214       NULL
9215     };
9216     char **r;
9217     int i;
9218     suppress_error = 0;
9219     r = guestfs_command_lines (g, arguments);
9220     if (r == NULL)
9221       return -1;
9222     if (!r[0]) {
9223       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
9224       print_strings (r);
9225       return -1;
9226     }
9227     {
9228       char expected[] = "";
9229       if (strcmp (r[0], expected) != 0) {
9230         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9231         return -1;
9232       }
9233     }
9234     if (r[1] != NULL) {
9235       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
9236       print_strings (r);
9237       return -1;
9238     }
9239     for (i = 0; r[i] != NULL; ++i)
9240       free (r[i]);
9241     free (r);
9242   }
9243   return 0;
9244 }
9245
9246 static int test_command_lines_8_skip (void)
9247 {
9248   const char *str;
9249
9250   str = getenv ("TEST_ONLY");
9251   if (str)
9252     return strstr (str, "command_lines") == NULL;
9253   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
9254   if (str && strcmp (str, "1") == 0) return 1;
9255   str = getenv ("SKIP_TEST_COMMAND_LINES");
9256   if (str && strcmp (str, "1") == 0) return 1;
9257   return 0;
9258 }
9259
9260 static int test_command_lines_8 (void)
9261 {
9262   if (test_command_lines_8_skip ()) {
9263     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
9264     return 0;
9265   }
9266
9267   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
9268   {
9269     char device[] = "/dev/sda";
9270     int r;
9271     suppress_error = 0;
9272     r = guestfs_blockdev_setrw (g, device);
9273     if (r == -1)
9274       return -1;
9275   }
9276   {
9277     int r;
9278     suppress_error = 0;
9279     r = guestfs_umount_all (g);
9280     if (r == -1)
9281       return -1;
9282   }
9283   {
9284     int r;
9285     suppress_error = 0;
9286     r = guestfs_lvm_remove_all (g);
9287     if (r == -1)
9288       return -1;
9289   }
9290   {
9291     char device[] = "/dev/sda";
9292     char lines_0[] = ",";
9293     char *lines[] = {
9294       lines_0,
9295       NULL
9296     };
9297     int r;
9298     suppress_error = 0;
9299     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9300     if (r == -1)
9301       return -1;
9302   }
9303   {
9304     char fstype[] = "ext2";
9305     char device[] = "/dev/sda1";
9306     int r;
9307     suppress_error = 0;
9308     r = guestfs_mkfs (g, fstype, device);
9309     if (r == -1)
9310       return -1;
9311   }
9312   {
9313     char device[] = "/dev/sda1";
9314     char mountpoint[] = "/";
9315     int r;
9316     suppress_error = 0;
9317     r = guestfs_mount (g, device, mountpoint);
9318     if (r == -1)
9319       return -1;
9320   }
9321   /* TestOutputList for command_lines (8) */
9322   {
9323     char remotefilename[] = "/test-command";
9324     int r;
9325     suppress_error = 0;
9326     r = guestfs_upload (g, "test-command", remotefilename);
9327     if (r == -1)
9328       return -1;
9329   }
9330   {
9331     char path[] = "/test-command";
9332     int r;
9333     suppress_error = 0;
9334     r = guestfs_chmod (g, 493, path);
9335     if (r == -1)
9336       return -1;
9337   }
9338   {
9339     char arguments_0[] = "/test-command";
9340     char arguments_1[] = "9";
9341     char *arguments[] = {
9342       arguments_0,
9343       arguments_1,
9344       NULL
9345     };
9346     char **r;
9347     int i;
9348     suppress_error = 0;
9349     r = guestfs_command_lines (g, arguments);
9350     if (r == NULL)
9351       return -1;
9352     if (!r[0]) {
9353       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
9354       print_strings (r);
9355       return -1;
9356     }
9357     {
9358       char expected[] = "";
9359       if (strcmp (r[0], expected) != 0) {
9360         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9361         return -1;
9362       }
9363     }
9364     if (!r[1]) {
9365       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
9366       print_strings (r);
9367       return -1;
9368     }
9369     {
9370       char expected[] = "";
9371       if (strcmp (r[1], expected) != 0) {
9372         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9373         return -1;
9374       }
9375     }
9376     if (r[2] != NULL) {
9377       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
9378       print_strings (r);
9379       return -1;
9380     }
9381     for (i = 0; r[i] != NULL; ++i)
9382       free (r[i]);
9383     free (r);
9384   }
9385   return 0;
9386 }
9387
9388 static int test_command_lines_9_skip (void)
9389 {
9390   const char *str;
9391
9392   str = getenv ("TEST_ONLY");
9393   if (str)
9394     return strstr (str, "command_lines") == NULL;
9395   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
9396   if (str && strcmp (str, "1") == 0) return 1;
9397   str = getenv ("SKIP_TEST_COMMAND_LINES");
9398   if (str && strcmp (str, "1") == 0) return 1;
9399   return 0;
9400 }
9401
9402 static int test_command_lines_9 (void)
9403 {
9404   if (test_command_lines_9_skip ()) {
9405     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
9406     return 0;
9407   }
9408
9409   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
9410   {
9411     char device[] = "/dev/sda";
9412     int r;
9413     suppress_error = 0;
9414     r = guestfs_blockdev_setrw (g, device);
9415     if (r == -1)
9416       return -1;
9417   }
9418   {
9419     int r;
9420     suppress_error = 0;
9421     r = guestfs_umount_all (g);
9422     if (r == -1)
9423       return -1;
9424   }
9425   {
9426     int r;
9427     suppress_error = 0;
9428     r = guestfs_lvm_remove_all (g);
9429     if (r == -1)
9430       return -1;
9431   }
9432   {
9433     char device[] = "/dev/sda";
9434     char lines_0[] = ",";
9435     char *lines[] = {
9436       lines_0,
9437       NULL
9438     };
9439     int r;
9440     suppress_error = 0;
9441     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9442     if (r == -1)
9443       return -1;
9444   }
9445   {
9446     char fstype[] = "ext2";
9447     char device[] = "/dev/sda1";
9448     int r;
9449     suppress_error = 0;
9450     r = guestfs_mkfs (g, fstype, device);
9451     if (r == -1)
9452       return -1;
9453   }
9454   {
9455     char device[] = "/dev/sda1";
9456     char mountpoint[] = "/";
9457     int r;
9458     suppress_error = 0;
9459     r = guestfs_mount (g, device, mountpoint);
9460     if (r == -1)
9461       return -1;
9462   }
9463   /* TestOutputList for command_lines (9) */
9464   {
9465     char remotefilename[] = "/test-command";
9466     int r;
9467     suppress_error = 0;
9468     r = guestfs_upload (g, "test-command", remotefilename);
9469     if (r == -1)
9470       return -1;
9471   }
9472   {
9473     char path[] = "/test-command";
9474     int r;
9475     suppress_error = 0;
9476     r = guestfs_chmod (g, 493, path);
9477     if (r == -1)
9478       return -1;
9479   }
9480   {
9481     char arguments_0[] = "/test-command";
9482     char arguments_1[] = "10";
9483     char *arguments[] = {
9484       arguments_0,
9485       arguments_1,
9486       NULL
9487     };
9488     char **r;
9489     int i;
9490     suppress_error = 0;
9491     r = guestfs_command_lines (g, arguments);
9492     if (r == NULL)
9493       return -1;
9494     if (!r[0]) {
9495       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
9496       print_strings (r);
9497       return -1;
9498     }
9499     {
9500       char expected[] = "Result10-1";
9501       if (strcmp (r[0], expected) != 0) {
9502         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9503         return -1;
9504       }
9505     }
9506     if (!r[1]) {
9507       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
9508       print_strings (r);
9509       return -1;
9510     }
9511     {
9512       char expected[] = "Result10-2";
9513       if (strcmp (r[1], expected) != 0) {
9514         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9515         return -1;
9516       }
9517     }
9518     if (r[2] != NULL) {
9519       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
9520       print_strings (r);
9521       return -1;
9522     }
9523     for (i = 0; r[i] != NULL; ++i)
9524       free (r[i]);
9525     free (r);
9526   }
9527   return 0;
9528 }
9529
9530 static int test_command_lines_10_skip (void)
9531 {
9532   const char *str;
9533
9534   str = getenv ("TEST_ONLY");
9535   if (str)
9536     return strstr (str, "command_lines") == NULL;
9537   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
9538   if (str && strcmp (str, "1") == 0) return 1;
9539   str = getenv ("SKIP_TEST_COMMAND_LINES");
9540   if (str && strcmp (str, "1") == 0) return 1;
9541   return 0;
9542 }
9543
9544 static int test_command_lines_10 (void)
9545 {
9546   if (test_command_lines_10_skip ()) {
9547     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
9548     return 0;
9549   }
9550
9551   /* InitBasicFS for test_command_lines_10: 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   /* TestOutputList for command_lines (10) */
9606   {
9607     char remotefilename[] = "/test-command";
9608     int r;
9609     suppress_error = 0;
9610     r = guestfs_upload (g, "test-command", remotefilename);
9611     if (r == -1)
9612       return -1;
9613   }
9614   {
9615     char path[] = "/test-command";
9616     int r;
9617     suppress_error = 0;
9618     r = guestfs_chmod (g, 493, path);
9619     if (r == -1)
9620       return -1;
9621   }
9622   {
9623     char arguments_0[] = "/test-command";
9624     char arguments_1[] = "11";
9625     char *arguments[] = {
9626       arguments_0,
9627       arguments_1,
9628       NULL
9629     };
9630     char **r;
9631     int i;
9632     suppress_error = 0;
9633     r = guestfs_command_lines (g, arguments);
9634     if (r == NULL)
9635       return -1;
9636     if (!r[0]) {
9637       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
9638       print_strings (r);
9639       return -1;
9640     }
9641     {
9642       char expected[] = "Result11-1";
9643       if (strcmp (r[0], expected) != 0) {
9644         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9645         return -1;
9646       }
9647     }
9648     if (!r[1]) {
9649       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
9650       print_strings (r);
9651       return -1;
9652     }
9653     {
9654       char expected[] = "Result11-2";
9655       if (strcmp (r[1], expected) != 0) {
9656         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9657         return -1;
9658       }
9659     }
9660     if (r[2] != NULL) {
9661       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
9662       print_strings (r);
9663       return -1;
9664     }
9665     for (i = 0; r[i] != NULL; ++i)
9666       free (r[i]);
9667     free (r);
9668   }
9669   return 0;
9670 }
9671
9672 static int test_command_0_skip (void)
9673 {
9674   const char *str;
9675
9676   str = getenv ("TEST_ONLY");
9677   if (str)
9678     return strstr (str, "command") == NULL;
9679   str = getenv ("SKIP_TEST_COMMAND_0");
9680   if (str && strcmp (str, "1") == 0) return 1;
9681   str = getenv ("SKIP_TEST_COMMAND");
9682   if (str && strcmp (str, "1") == 0) return 1;
9683   return 0;
9684 }
9685
9686 static int test_command_0 (void)
9687 {
9688   if (test_command_0_skip ()) {
9689     printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
9690     return 0;
9691   }
9692
9693   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
9694   {
9695     char device[] = "/dev/sda";
9696     int r;
9697     suppress_error = 0;
9698     r = guestfs_blockdev_setrw (g, device);
9699     if (r == -1)
9700       return -1;
9701   }
9702   {
9703     int r;
9704     suppress_error = 0;
9705     r = guestfs_umount_all (g);
9706     if (r == -1)
9707       return -1;
9708   }
9709   {
9710     int r;
9711     suppress_error = 0;
9712     r = guestfs_lvm_remove_all (g);
9713     if (r == -1)
9714       return -1;
9715   }
9716   {
9717     char device[] = "/dev/sda";
9718     char lines_0[] = ",";
9719     char *lines[] = {
9720       lines_0,
9721       NULL
9722     };
9723     int r;
9724     suppress_error = 0;
9725     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9726     if (r == -1)
9727       return -1;
9728   }
9729   {
9730     char fstype[] = "ext2";
9731     char device[] = "/dev/sda1";
9732     int r;
9733     suppress_error = 0;
9734     r = guestfs_mkfs (g, fstype, device);
9735     if (r == -1)
9736       return -1;
9737   }
9738   {
9739     char device[] = "/dev/sda1";
9740     char mountpoint[] = "/";
9741     int r;
9742     suppress_error = 0;
9743     r = guestfs_mount (g, device, mountpoint);
9744     if (r == -1)
9745       return -1;
9746   }
9747   /* TestOutput for command (0) */
9748   char expected[] = "Result1";
9749   {
9750     char remotefilename[] = "/test-command";
9751     int r;
9752     suppress_error = 0;
9753     r = guestfs_upload (g, "test-command", remotefilename);
9754     if (r == -1)
9755       return -1;
9756   }
9757   {
9758     char path[] = "/test-command";
9759     int r;
9760     suppress_error = 0;
9761     r = guestfs_chmod (g, 493, path);
9762     if (r == -1)
9763       return -1;
9764   }
9765   {
9766     char arguments_0[] = "/test-command";
9767     char arguments_1[] = "1";
9768     char *arguments[] = {
9769       arguments_0,
9770       arguments_1,
9771       NULL
9772     };
9773     char *r;
9774     suppress_error = 0;
9775     r = guestfs_command (g, arguments);
9776     if (r == NULL)
9777       return -1;
9778     if (strcmp (r, expected) != 0) {
9779       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
9780       return -1;
9781     }
9782     free (r);
9783   }
9784   return 0;
9785 }
9786
9787 static int test_command_1_skip (void)
9788 {
9789   const char *str;
9790
9791   str = getenv ("TEST_ONLY");
9792   if (str)
9793     return strstr (str, "command") == NULL;
9794   str = getenv ("SKIP_TEST_COMMAND_1");
9795   if (str && strcmp (str, "1") == 0) return 1;
9796   str = getenv ("SKIP_TEST_COMMAND");
9797   if (str && strcmp (str, "1") == 0) return 1;
9798   return 0;
9799 }
9800
9801 static int test_command_1 (void)
9802 {
9803   if (test_command_1_skip ()) {
9804     printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
9805     return 0;
9806   }
9807
9808   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
9809   {
9810     char device[] = "/dev/sda";
9811     int r;
9812     suppress_error = 0;
9813     r = guestfs_blockdev_setrw (g, device);
9814     if (r == -1)
9815       return -1;
9816   }
9817   {
9818     int r;
9819     suppress_error = 0;
9820     r = guestfs_umount_all (g);
9821     if (r == -1)
9822       return -1;
9823   }
9824   {
9825     int r;
9826     suppress_error = 0;
9827     r = guestfs_lvm_remove_all (g);
9828     if (r == -1)
9829       return -1;
9830   }
9831   {
9832     char device[] = "/dev/sda";
9833     char lines_0[] = ",";
9834     char *lines[] = {
9835       lines_0,
9836       NULL
9837     };
9838     int r;
9839     suppress_error = 0;
9840     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9841     if (r == -1)
9842       return -1;
9843   }
9844   {
9845     char fstype[] = "ext2";
9846     char device[] = "/dev/sda1";
9847     int r;
9848     suppress_error = 0;
9849     r = guestfs_mkfs (g, fstype, device);
9850     if (r == -1)
9851       return -1;
9852   }
9853   {
9854     char device[] = "/dev/sda1";
9855     char mountpoint[] = "/";
9856     int r;
9857     suppress_error = 0;
9858     r = guestfs_mount (g, device, mountpoint);
9859     if (r == -1)
9860       return -1;
9861   }
9862   /* TestOutput for command (1) */
9863   char expected[] = "Result2\n";
9864   {
9865     char remotefilename[] = "/test-command";
9866     int r;
9867     suppress_error = 0;
9868     r = guestfs_upload (g, "test-command", remotefilename);
9869     if (r == -1)
9870       return -1;
9871   }
9872   {
9873     char path[] = "/test-command";
9874     int r;
9875     suppress_error = 0;
9876     r = guestfs_chmod (g, 493, path);
9877     if (r == -1)
9878       return -1;
9879   }
9880   {
9881     char arguments_0[] = "/test-command";
9882     char arguments_1[] = "2";
9883     char *arguments[] = {
9884       arguments_0,
9885       arguments_1,
9886       NULL
9887     };
9888     char *r;
9889     suppress_error = 0;
9890     r = guestfs_command (g, arguments);
9891     if (r == NULL)
9892       return -1;
9893     if (strcmp (r, expected) != 0) {
9894       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
9895       return -1;
9896     }
9897     free (r);
9898   }
9899   return 0;
9900 }
9901
9902 static int test_command_2_skip (void)
9903 {
9904   const char *str;
9905
9906   str = getenv ("TEST_ONLY");
9907   if (str)
9908     return strstr (str, "command") == NULL;
9909   str = getenv ("SKIP_TEST_COMMAND_2");
9910   if (str && strcmp (str, "1") == 0) return 1;
9911   str = getenv ("SKIP_TEST_COMMAND");
9912   if (str && strcmp (str, "1") == 0) return 1;
9913   return 0;
9914 }
9915
9916 static int test_command_2 (void)
9917 {
9918   if (test_command_2_skip ()) {
9919     printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
9920     return 0;
9921   }
9922
9923   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9924   {
9925     char device[] = "/dev/sda";
9926     int r;
9927     suppress_error = 0;
9928     r = guestfs_blockdev_setrw (g, device);
9929     if (r == -1)
9930       return -1;
9931   }
9932   {
9933     int r;
9934     suppress_error = 0;
9935     r = guestfs_umount_all (g);
9936     if (r == -1)
9937       return -1;
9938   }
9939   {
9940     int r;
9941     suppress_error = 0;
9942     r = guestfs_lvm_remove_all (g);
9943     if (r == -1)
9944       return -1;
9945   }
9946   {
9947     char device[] = "/dev/sda";
9948     char lines_0[] = ",";
9949     char *lines[] = {
9950       lines_0,
9951       NULL
9952     };
9953     int r;
9954     suppress_error = 0;
9955     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9956     if (r == -1)
9957       return -1;
9958   }
9959   {
9960     char fstype[] = "ext2";
9961     char device[] = "/dev/sda1";
9962     int r;
9963     suppress_error = 0;
9964     r = guestfs_mkfs (g, fstype, device);
9965     if (r == -1)
9966       return -1;
9967   }
9968   {
9969     char device[] = "/dev/sda1";
9970     char mountpoint[] = "/";
9971     int r;
9972     suppress_error = 0;
9973     r = guestfs_mount (g, device, mountpoint);
9974     if (r == -1)
9975       return -1;
9976   }
9977   /* TestOutput for command (2) */
9978   char expected[] = "\nResult3";
9979   {
9980     char remotefilename[] = "/test-command";
9981     int r;
9982     suppress_error = 0;
9983     r = guestfs_upload (g, "test-command", remotefilename);
9984     if (r == -1)
9985       return -1;
9986   }
9987   {
9988     char path[] = "/test-command";
9989     int r;
9990     suppress_error = 0;
9991     r = guestfs_chmod (g, 493, path);
9992     if (r == -1)
9993       return -1;
9994   }
9995   {
9996     char arguments_0[] = "/test-command";
9997     char arguments_1[] = "3";
9998     char *arguments[] = {
9999       arguments_0,
10000       arguments_1,
10001       NULL
10002     };
10003     char *r;
10004     suppress_error = 0;
10005     r = guestfs_command (g, arguments);
10006     if (r == NULL)
10007       return -1;
10008     if (strcmp (r, expected) != 0) {
10009       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
10010       return -1;
10011     }
10012     free (r);
10013   }
10014   return 0;
10015 }
10016
10017 static int test_command_3_skip (void)
10018 {
10019   const char *str;
10020
10021   str = getenv ("TEST_ONLY");
10022   if (str)
10023     return strstr (str, "command") == NULL;
10024   str = getenv ("SKIP_TEST_COMMAND_3");
10025   if (str && strcmp (str, "1") == 0) return 1;
10026   str = getenv ("SKIP_TEST_COMMAND");
10027   if (str && strcmp (str, "1") == 0) return 1;
10028   return 0;
10029 }
10030
10031 static int test_command_3 (void)
10032 {
10033   if (test_command_3_skip ()) {
10034     printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
10035     return 0;
10036   }
10037
10038   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
10039   {
10040     char device[] = "/dev/sda";
10041     int r;
10042     suppress_error = 0;
10043     r = guestfs_blockdev_setrw (g, device);
10044     if (r == -1)
10045       return -1;
10046   }
10047   {
10048     int r;
10049     suppress_error = 0;
10050     r = guestfs_umount_all (g);
10051     if (r == -1)
10052       return -1;
10053   }
10054   {
10055     int r;
10056     suppress_error = 0;
10057     r = guestfs_lvm_remove_all (g);
10058     if (r == -1)
10059       return -1;
10060   }
10061   {
10062     char device[] = "/dev/sda";
10063     char lines_0[] = ",";
10064     char *lines[] = {
10065       lines_0,
10066       NULL
10067     };
10068     int r;
10069     suppress_error = 0;
10070     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10071     if (r == -1)
10072       return -1;
10073   }
10074   {
10075     char fstype[] = "ext2";
10076     char device[] = "/dev/sda1";
10077     int r;
10078     suppress_error = 0;
10079     r = guestfs_mkfs (g, fstype, device);
10080     if (r == -1)
10081       return -1;
10082   }
10083   {
10084     char device[] = "/dev/sda1";
10085     char mountpoint[] = "/";
10086     int r;
10087     suppress_error = 0;
10088     r = guestfs_mount (g, device, mountpoint);
10089     if (r == -1)
10090       return -1;
10091   }
10092   /* TestOutput for command (3) */
10093   char expected[] = "\nResult4\n";
10094   {
10095     char remotefilename[] = "/test-command";
10096     int r;
10097     suppress_error = 0;
10098     r = guestfs_upload (g, "test-command", remotefilename);
10099     if (r == -1)
10100       return -1;
10101   }
10102   {
10103     char path[] = "/test-command";
10104     int r;
10105     suppress_error = 0;
10106     r = guestfs_chmod (g, 493, path);
10107     if (r == -1)
10108       return -1;
10109   }
10110   {
10111     char arguments_0[] = "/test-command";
10112     char arguments_1[] = "4";
10113     char *arguments[] = {
10114       arguments_0,
10115       arguments_1,
10116       NULL
10117     };
10118     char *r;
10119     suppress_error = 0;
10120     r = guestfs_command (g, arguments);
10121     if (r == NULL)
10122       return -1;
10123     if (strcmp (r, expected) != 0) {
10124       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
10125       return -1;
10126     }
10127     free (r);
10128   }
10129   return 0;
10130 }
10131
10132 static int test_command_4_skip (void)
10133 {
10134   const char *str;
10135
10136   str = getenv ("TEST_ONLY");
10137   if (str)
10138     return strstr (str, "command") == NULL;
10139   str = getenv ("SKIP_TEST_COMMAND_4");
10140   if (str && strcmp (str, "1") == 0) return 1;
10141   str = getenv ("SKIP_TEST_COMMAND");
10142   if (str && strcmp (str, "1") == 0) return 1;
10143   return 0;
10144 }
10145
10146 static int test_command_4 (void)
10147 {
10148   if (test_command_4_skip ()) {
10149     printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
10150     return 0;
10151   }
10152
10153   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
10154   {
10155     char device[] = "/dev/sda";
10156     int r;
10157     suppress_error = 0;
10158     r = guestfs_blockdev_setrw (g, device);
10159     if (r == -1)
10160       return -1;
10161   }
10162   {
10163     int r;
10164     suppress_error = 0;
10165     r = guestfs_umount_all (g);
10166     if (r == -1)
10167       return -1;
10168   }
10169   {
10170     int r;
10171     suppress_error = 0;
10172     r = guestfs_lvm_remove_all (g);
10173     if (r == -1)
10174       return -1;
10175   }
10176   {
10177     char device[] = "/dev/sda";
10178     char lines_0[] = ",";
10179     char *lines[] = {
10180       lines_0,
10181       NULL
10182     };
10183     int r;
10184     suppress_error = 0;
10185     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10186     if (r == -1)
10187       return -1;
10188   }
10189   {
10190     char fstype[] = "ext2";
10191     char device[] = "/dev/sda1";
10192     int r;
10193     suppress_error = 0;
10194     r = guestfs_mkfs (g, fstype, device);
10195     if (r == -1)
10196       return -1;
10197   }
10198   {
10199     char device[] = "/dev/sda1";
10200     char mountpoint[] = "/";
10201     int r;
10202     suppress_error = 0;
10203     r = guestfs_mount (g, device, mountpoint);
10204     if (r == -1)
10205       return -1;
10206   }
10207   /* TestOutput for command (4) */
10208   char expected[] = "\nResult5\n\n";
10209   {
10210     char remotefilename[] = "/test-command";
10211     int r;
10212     suppress_error = 0;
10213     r = guestfs_upload (g, "test-command", remotefilename);
10214     if (r == -1)
10215       return -1;
10216   }
10217   {
10218     char path[] = "/test-command";
10219     int r;
10220     suppress_error = 0;
10221     r = guestfs_chmod (g, 493, path);
10222     if (r == -1)
10223       return -1;
10224   }
10225   {
10226     char arguments_0[] = "/test-command";
10227     char arguments_1[] = "5";
10228     char *arguments[] = {
10229       arguments_0,
10230       arguments_1,
10231       NULL
10232     };
10233     char *r;
10234     suppress_error = 0;
10235     r = guestfs_command (g, arguments);
10236     if (r == NULL)
10237       return -1;
10238     if (strcmp (r, expected) != 0) {
10239       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
10240       return -1;
10241     }
10242     free (r);
10243   }
10244   return 0;
10245 }
10246
10247 static int test_command_5_skip (void)
10248 {
10249   const char *str;
10250
10251   str = getenv ("TEST_ONLY");
10252   if (str)
10253     return strstr (str, "command") == NULL;
10254   str = getenv ("SKIP_TEST_COMMAND_5");
10255   if (str && strcmp (str, "1") == 0) return 1;
10256   str = getenv ("SKIP_TEST_COMMAND");
10257   if (str && strcmp (str, "1") == 0) return 1;
10258   return 0;
10259 }
10260
10261 static int test_command_5 (void)
10262 {
10263   if (test_command_5_skip ()) {
10264     printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
10265     return 0;
10266   }
10267
10268   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
10269   {
10270     char device[] = "/dev/sda";
10271     int r;
10272     suppress_error = 0;
10273     r = guestfs_blockdev_setrw (g, device);
10274     if (r == -1)
10275       return -1;
10276   }
10277   {
10278     int r;
10279     suppress_error = 0;
10280     r = guestfs_umount_all (g);
10281     if (r == -1)
10282       return -1;
10283   }
10284   {
10285     int r;
10286     suppress_error = 0;
10287     r = guestfs_lvm_remove_all (g);
10288     if (r == -1)
10289       return -1;
10290   }
10291   {
10292     char device[] = "/dev/sda";
10293     char lines_0[] = ",";
10294     char *lines[] = {
10295       lines_0,
10296       NULL
10297     };
10298     int r;
10299     suppress_error = 0;
10300     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10301     if (r == -1)
10302       return -1;
10303   }
10304   {
10305     char fstype[] = "ext2";
10306     char device[] = "/dev/sda1";
10307     int r;
10308     suppress_error = 0;
10309     r = guestfs_mkfs (g, fstype, device);
10310     if (r == -1)
10311       return -1;
10312   }
10313   {
10314     char device[] = "/dev/sda1";
10315     char mountpoint[] = "/";
10316     int r;
10317     suppress_error = 0;
10318     r = guestfs_mount (g, device, mountpoint);
10319     if (r == -1)
10320       return -1;
10321   }
10322   /* TestOutput for command (5) */
10323   char expected[] = "\n\nResult6\n\n";
10324   {
10325     char remotefilename[] = "/test-command";
10326     int r;
10327     suppress_error = 0;
10328     r = guestfs_upload (g, "test-command", remotefilename);
10329     if (r == -1)
10330       return -1;
10331   }
10332   {
10333     char path[] = "/test-command";
10334     int r;
10335     suppress_error = 0;
10336     r = guestfs_chmod (g, 493, path);
10337     if (r == -1)
10338       return -1;
10339   }
10340   {
10341     char arguments_0[] = "/test-command";
10342     char arguments_1[] = "6";
10343     char *arguments[] = {
10344       arguments_0,
10345       arguments_1,
10346       NULL
10347     };
10348     char *r;
10349     suppress_error = 0;
10350     r = guestfs_command (g, arguments);
10351     if (r == NULL)
10352       return -1;
10353     if (strcmp (r, expected) != 0) {
10354       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
10355       return -1;
10356     }
10357     free (r);
10358   }
10359   return 0;
10360 }
10361
10362 static int test_command_6_skip (void)
10363 {
10364   const char *str;
10365
10366   str = getenv ("TEST_ONLY");
10367   if (str)
10368     return strstr (str, "command") == NULL;
10369   str = getenv ("SKIP_TEST_COMMAND_6");
10370   if (str && strcmp (str, "1") == 0) return 1;
10371   str = getenv ("SKIP_TEST_COMMAND");
10372   if (str && strcmp (str, "1") == 0) return 1;
10373   return 0;
10374 }
10375
10376 static int test_command_6 (void)
10377 {
10378   if (test_command_6_skip ()) {
10379     printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
10380     return 0;
10381   }
10382
10383   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
10384   {
10385     char device[] = "/dev/sda";
10386     int r;
10387     suppress_error = 0;
10388     r = guestfs_blockdev_setrw (g, device);
10389     if (r == -1)
10390       return -1;
10391   }
10392   {
10393     int r;
10394     suppress_error = 0;
10395     r = guestfs_umount_all (g);
10396     if (r == -1)
10397       return -1;
10398   }
10399   {
10400     int r;
10401     suppress_error = 0;
10402     r = guestfs_lvm_remove_all (g);
10403     if (r == -1)
10404       return -1;
10405   }
10406   {
10407     char device[] = "/dev/sda";
10408     char lines_0[] = ",";
10409     char *lines[] = {
10410       lines_0,
10411       NULL
10412     };
10413     int r;
10414     suppress_error = 0;
10415     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10416     if (r == -1)
10417       return -1;
10418   }
10419   {
10420     char fstype[] = "ext2";
10421     char device[] = "/dev/sda1";
10422     int r;
10423     suppress_error = 0;
10424     r = guestfs_mkfs (g, fstype, device);
10425     if (r == -1)
10426       return -1;
10427   }
10428   {
10429     char device[] = "/dev/sda1";
10430     char mountpoint[] = "/";
10431     int r;
10432     suppress_error = 0;
10433     r = guestfs_mount (g, device, mountpoint);
10434     if (r == -1)
10435       return -1;
10436   }
10437   /* TestOutput for command (6) */
10438   char expected[] = "";
10439   {
10440     char remotefilename[] = "/test-command";
10441     int r;
10442     suppress_error = 0;
10443     r = guestfs_upload (g, "test-command", remotefilename);
10444     if (r == -1)
10445       return -1;
10446   }
10447   {
10448     char path[] = "/test-command";
10449     int r;
10450     suppress_error = 0;
10451     r = guestfs_chmod (g, 493, path);
10452     if (r == -1)
10453       return -1;
10454   }
10455   {
10456     char arguments_0[] = "/test-command";
10457     char arguments_1[] = "7";
10458     char *arguments[] = {
10459       arguments_0,
10460       arguments_1,
10461       NULL
10462     };
10463     char *r;
10464     suppress_error = 0;
10465     r = guestfs_command (g, arguments);
10466     if (r == NULL)
10467       return -1;
10468     if (strcmp (r, expected) != 0) {
10469       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
10470       return -1;
10471     }
10472     free (r);
10473   }
10474   return 0;
10475 }
10476
10477 static int test_command_7_skip (void)
10478 {
10479   const char *str;
10480
10481   str = getenv ("TEST_ONLY");
10482   if (str)
10483     return strstr (str, "command") == NULL;
10484   str = getenv ("SKIP_TEST_COMMAND_7");
10485   if (str && strcmp (str, "1") == 0) return 1;
10486   str = getenv ("SKIP_TEST_COMMAND");
10487   if (str && strcmp (str, "1") == 0) return 1;
10488   return 0;
10489 }
10490
10491 static int test_command_7 (void)
10492 {
10493   if (test_command_7_skip ()) {
10494     printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
10495     return 0;
10496   }
10497
10498   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
10499   {
10500     char device[] = "/dev/sda";
10501     int r;
10502     suppress_error = 0;
10503     r = guestfs_blockdev_setrw (g, device);
10504     if (r == -1)
10505       return -1;
10506   }
10507   {
10508     int r;
10509     suppress_error = 0;
10510     r = guestfs_umount_all (g);
10511     if (r == -1)
10512       return -1;
10513   }
10514   {
10515     int r;
10516     suppress_error = 0;
10517     r = guestfs_lvm_remove_all (g);
10518     if (r == -1)
10519       return -1;
10520   }
10521   {
10522     char device[] = "/dev/sda";
10523     char lines_0[] = ",";
10524     char *lines[] = {
10525       lines_0,
10526       NULL
10527     };
10528     int r;
10529     suppress_error = 0;
10530     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10531     if (r == -1)
10532       return -1;
10533   }
10534   {
10535     char fstype[] = "ext2";
10536     char device[] = "/dev/sda1";
10537     int r;
10538     suppress_error = 0;
10539     r = guestfs_mkfs (g, fstype, device);
10540     if (r == -1)
10541       return -1;
10542   }
10543   {
10544     char device[] = "/dev/sda1";
10545     char mountpoint[] = "/";
10546     int r;
10547     suppress_error = 0;
10548     r = guestfs_mount (g, device, mountpoint);
10549     if (r == -1)
10550       return -1;
10551   }
10552   /* TestOutput for command (7) */
10553   char expected[] = "\n";
10554   {
10555     char remotefilename[] = "/test-command";
10556     int r;
10557     suppress_error = 0;
10558     r = guestfs_upload (g, "test-command", remotefilename);
10559     if (r == -1)
10560       return -1;
10561   }
10562   {
10563     char path[] = "/test-command";
10564     int r;
10565     suppress_error = 0;
10566     r = guestfs_chmod (g, 493, path);
10567     if (r == -1)
10568       return -1;
10569   }
10570   {
10571     char arguments_0[] = "/test-command";
10572     char arguments_1[] = "8";
10573     char *arguments[] = {
10574       arguments_0,
10575       arguments_1,
10576       NULL
10577     };
10578     char *r;
10579     suppress_error = 0;
10580     r = guestfs_command (g, arguments);
10581     if (r == NULL)
10582       return -1;
10583     if (strcmp (r, expected) != 0) {
10584       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
10585       return -1;
10586     }
10587     free (r);
10588   }
10589   return 0;
10590 }
10591
10592 static int test_command_8_skip (void)
10593 {
10594   const char *str;
10595
10596   str = getenv ("TEST_ONLY");
10597   if (str)
10598     return strstr (str, "command") == NULL;
10599   str = getenv ("SKIP_TEST_COMMAND_8");
10600   if (str && strcmp (str, "1") == 0) return 1;
10601   str = getenv ("SKIP_TEST_COMMAND");
10602   if (str && strcmp (str, "1") == 0) return 1;
10603   return 0;
10604 }
10605
10606 static int test_command_8 (void)
10607 {
10608   if (test_command_8_skip ()) {
10609     printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
10610     return 0;
10611   }
10612
10613   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
10614   {
10615     char device[] = "/dev/sda";
10616     int r;
10617     suppress_error = 0;
10618     r = guestfs_blockdev_setrw (g, device);
10619     if (r == -1)
10620       return -1;
10621   }
10622   {
10623     int r;
10624     suppress_error = 0;
10625     r = guestfs_umount_all (g);
10626     if (r == -1)
10627       return -1;
10628   }
10629   {
10630     int r;
10631     suppress_error = 0;
10632     r = guestfs_lvm_remove_all (g);
10633     if (r == -1)
10634       return -1;
10635   }
10636   {
10637     char device[] = "/dev/sda";
10638     char lines_0[] = ",";
10639     char *lines[] = {
10640       lines_0,
10641       NULL
10642     };
10643     int r;
10644     suppress_error = 0;
10645     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10646     if (r == -1)
10647       return -1;
10648   }
10649   {
10650     char fstype[] = "ext2";
10651     char device[] = "/dev/sda1";
10652     int r;
10653     suppress_error = 0;
10654     r = guestfs_mkfs (g, fstype, device);
10655     if (r == -1)
10656       return -1;
10657   }
10658   {
10659     char device[] = "/dev/sda1";
10660     char mountpoint[] = "/";
10661     int r;
10662     suppress_error = 0;
10663     r = guestfs_mount (g, device, mountpoint);
10664     if (r == -1)
10665       return -1;
10666   }
10667   /* TestOutput for command (8) */
10668   char expected[] = "\n\n";
10669   {
10670     char remotefilename[] = "/test-command";
10671     int r;
10672     suppress_error = 0;
10673     r = guestfs_upload (g, "test-command", remotefilename);
10674     if (r == -1)
10675       return -1;
10676   }
10677   {
10678     char path[] = "/test-command";
10679     int r;
10680     suppress_error = 0;
10681     r = guestfs_chmod (g, 493, path);
10682     if (r == -1)
10683       return -1;
10684   }
10685   {
10686     char arguments_0[] = "/test-command";
10687     char arguments_1[] = "9";
10688     char *arguments[] = {
10689       arguments_0,
10690       arguments_1,
10691       NULL
10692     };
10693     char *r;
10694     suppress_error = 0;
10695     r = guestfs_command (g, arguments);
10696     if (r == NULL)
10697       return -1;
10698     if (strcmp (r, expected) != 0) {
10699       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
10700       return -1;
10701     }
10702     free (r);
10703   }
10704   return 0;
10705 }
10706
10707 static int test_command_9_skip (void)
10708 {
10709   const char *str;
10710
10711   str = getenv ("TEST_ONLY");
10712   if (str)
10713     return strstr (str, "command") == NULL;
10714   str = getenv ("SKIP_TEST_COMMAND_9");
10715   if (str && strcmp (str, "1") == 0) return 1;
10716   str = getenv ("SKIP_TEST_COMMAND");
10717   if (str && strcmp (str, "1") == 0) return 1;
10718   return 0;
10719 }
10720
10721 static int test_command_9 (void)
10722 {
10723   if (test_command_9_skip ()) {
10724     printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
10725     return 0;
10726   }
10727
10728   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
10729   {
10730     char device[] = "/dev/sda";
10731     int r;
10732     suppress_error = 0;
10733     r = guestfs_blockdev_setrw (g, device);
10734     if (r == -1)
10735       return -1;
10736   }
10737   {
10738     int r;
10739     suppress_error = 0;
10740     r = guestfs_umount_all (g);
10741     if (r == -1)
10742       return -1;
10743   }
10744   {
10745     int r;
10746     suppress_error = 0;
10747     r = guestfs_lvm_remove_all (g);
10748     if (r == -1)
10749       return -1;
10750   }
10751   {
10752     char device[] = "/dev/sda";
10753     char lines_0[] = ",";
10754     char *lines[] = {
10755       lines_0,
10756       NULL
10757     };
10758     int r;
10759     suppress_error = 0;
10760     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10761     if (r == -1)
10762       return -1;
10763   }
10764   {
10765     char fstype[] = "ext2";
10766     char device[] = "/dev/sda1";
10767     int r;
10768     suppress_error = 0;
10769     r = guestfs_mkfs (g, fstype, device);
10770     if (r == -1)
10771       return -1;
10772   }
10773   {
10774     char device[] = "/dev/sda1";
10775     char mountpoint[] = "/";
10776     int r;
10777     suppress_error = 0;
10778     r = guestfs_mount (g, device, mountpoint);
10779     if (r == -1)
10780       return -1;
10781   }
10782   /* TestOutput for command (9) */
10783   char expected[] = "Result10-1\nResult10-2\n";
10784   {
10785     char remotefilename[] = "/test-command";
10786     int r;
10787     suppress_error = 0;
10788     r = guestfs_upload (g, "test-command", remotefilename);
10789     if (r == -1)
10790       return -1;
10791   }
10792   {
10793     char path[] = "/test-command";
10794     int r;
10795     suppress_error = 0;
10796     r = guestfs_chmod (g, 493, path);
10797     if (r == -1)
10798       return -1;
10799   }
10800   {
10801     char arguments_0[] = "/test-command";
10802     char arguments_1[] = "10";
10803     char *arguments[] = {
10804       arguments_0,
10805       arguments_1,
10806       NULL
10807     };
10808     char *r;
10809     suppress_error = 0;
10810     r = guestfs_command (g, arguments);
10811     if (r == NULL)
10812       return -1;
10813     if (strcmp (r, expected) != 0) {
10814       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
10815       return -1;
10816     }
10817     free (r);
10818   }
10819   return 0;
10820 }
10821
10822 static int test_command_10_skip (void)
10823 {
10824   const char *str;
10825
10826   str = getenv ("TEST_ONLY");
10827   if (str)
10828     return strstr (str, "command") == NULL;
10829   str = getenv ("SKIP_TEST_COMMAND_10");
10830   if (str && strcmp (str, "1") == 0) return 1;
10831   str = getenv ("SKIP_TEST_COMMAND");
10832   if (str && strcmp (str, "1") == 0) return 1;
10833   return 0;
10834 }
10835
10836 static int test_command_10 (void)
10837 {
10838   if (test_command_10_skip ()) {
10839     printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
10840     return 0;
10841   }
10842
10843   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
10844   {
10845     char device[] = "/dev/sda";
10846     int r;
10847     suppress_error = 0;
10848     r = guestfs_blockdev_setrw (g, device);
10849     if (r == -1)
10850       return -1;
10851   }
10852   {
10853     int r;
10854     suppress_error = 0;
10855     r = guestfs_umount_all (g);
10856     if (r == -1)
10857       return -1;
10858   }
10859   {
10860     int r;
10861     suppress_error = 0;
10862     r = guestfs_lvm_remove_all (g);
10863     if (r == -1)
10864       return -1;
10865   }
10866   {
10867     char device[] = "/dev/sda";
10868     char lines_0[] = ",";
10869     char *lines[] = {
10870       lines_0,
10871       NULL
10872     };
10873     int r;
10874     suppress_error = 0;
10875     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10876     if (r == -1)
10877       return -1;
10878   }
10879   {
10880     char fstype[] = "ext2";
10881     char device[] = "/dev/sda1";
10882     int r;
10883     suppress_error = 0;
10884     r = guestfs_mkfs (g, fstype, device);
10885     if (r == -1)
10886       return -1;
10887   }
10888   {
10889     char device[] = "/dev/sda1";
10890     char mountpoint[] = "/";
10891     int r;
10892     suppress_error = 0;
10893     r = guestfs_mount (g, device, mountpoint);
10894     if (r == -1)
10895       return -1;
10896   }
10897   /* TestOutput for command (10) */
10898   char expected[] = "Result11-1\nResult11-2";
10899   {
10900     char remotefilename[] = "/test-command";
10901     int r;
10902     suppress_error = 0;
10903     r = guestfs_upload (g, "test-command", remotefilename);
10904     if (r == -1)
10905       return -1;
10906   }
10907   {
10908     char path[] = "/test-command";
10909     int r;
10910     suppress_error = 0;
10911     r = guestfs_chmod (g, 493, path);
10912     if (r == -1)
10913       return -1;
10914   }
10915   {
10916     char arguments_0[] = "/test-command";
10917     char arguments_1[] = "11";
10918     char *arguments[] = {
10919       arguments_0,
10920       arguments_1,
10921       NULL
10922     };
10923     char *r;
10924     suppress_error = 0;
10925     r = guestfs_command (g, arguments);
10926     if (r == NULL)
10927       return -1;
10928     if (strcmp (r, expected) != 0) {
10929       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
10930       return -1;
10931     }
10932     free (r);
10933   }
10934   return 0;
10935 }
10936
10937 static int test_command_11_skip (void)
10938 {
10939   const char *str;
10940
10941   str = getenv ("TEST_ONLY");
10942   if (str)
10943     return strstr (str, "command") == NULL;
10944   str = getenv ("SKIP_TEST_COMMAND_11");
10945   if (str && strcmp (str, "1") == 0) return 1;
10946   str = getenv ("SKIP_TEST_COMMAND");
10947   if (str && strcmp (str, "1") == 0) return 1;
10948   return 0;
10949 }
10950
10951 static int test_command_11 (void)
10952 {
10953   if (test_command_11_skip ()) {
10954     printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
10955     return 0;
10956   }
10957
10958   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10959   {
10960     char device[] = "/dev/sda";
10961     int r;
10962     suppress_error = 0;
10963     r = guestfs_blockdev_setrw (g, device);
10964     if (r == -1)
10965       return -1;
10966   }
10967   {
10968     int r;
10969     suppress_error = 0;
10970     r = guestfs_umount_all (g);
10971     if (r == -1)
10972       return -1;
10973   }
10974   {
10975     int r;
10976     suppress_error = 0;
10977     r = guestfs_lvm_remove_all (g);
10978     if (r == -1)
10979       return -1;
10980   }
10981   {
10982     char device[] = "/dev/sda";
10983     char lines_0[] = ",";
10984     char *lines[] = {
10985       lines_0,
10986       NULL
10987     };
10988     int r;
10989     suppress_error = 0;
10990     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10991     if (r == -1)
10992       return -1;
10993   }
10994   {
10995     char fstype[] = "ext2";
10996     char device[] = "/dev/sda1";
10997     int r;
10998     suppress_error = 0;
10999     r = guestfs_mkfs (g, fstype, device);
11000     if (r == -1)
11001       return -1;
11002   }
11003   {
11004     char device[] = "/dev/sda1";
11005     char mountpoint[] = "/";
11006     int r;
11007     suppress_error = 0;
11008     r = guestfs_mount (g, device, mountpoint);
11009     if (r == -1)
11010       return -1;
11011   }
11012   /* TestLastFail for command (11) */
11013   {
11014     char remotefilename[] = "/test-command";
11015     int r;
11016     suppress_error = 0;
11017     r = guestfs_upload (g, "test-command", remotefilename);
11018     if (r == -1)
11019       return -1;
11020   }
11021   {
11022     char path[] = "/test-command";
11023     int r;
11024     suppress_error = 0;
11025     r = guestfs_chmod (g, 493, path);
11026     if (r == -1)
11027       return -1;
11028   }
11029   {
11030     char arguments_0[] = "/test-command";
11031     char *arguments[] = {
11032       arguments_0,
11033       NULL
11034     };
11035     char *r;
11036     suppress_error = 1;
11037     r = guestfs_command (g, arguments);
11038     if (r != NULL)
11039       return -1;
11040     free (r);
11041   }
11042   return 0;
11043 }
11044
11045 static int test_file_0_skip (void)
11046 {
11047   const char *str;
11048
11049   str = getenv ("TEST_ONLY");
11050   if (str)
11051     return strstr (str, "file") == NULL;
11052   str = getenv ("SKIP_TEST_FILE_0");
11053   if (str && strcmp (str, "1") == 0) return 1;
11054   str = getenv ("SKIP_TEST_FILE");
11055   if (str && strcmp (str, "1") == 0) return 1;
11056   return 0;
11057 }
11058
11059 static int test_file_0 (void)
11060 {
11061   if (test_file_0_skip ()) {
11062     printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
11063     return 0;
11064   }
11065
11066   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
11067   {
11068     char device[] = "/dev/sda";
11069     int r;
11070     suppress_error = 0;
11071     r = guestfs_blockdev_setrw (g, device);
11072     if (r == -1)
11073       return -1;
11074   }
11075   {
11076     int r;
11077     suppress_error = 0;
11078     r = guestfs_umount_all (g);
11079     if (r == -1)
11080       return -1;
11081   }
11082   {
11083     int r;
11084     suppress_error = 0;
11085     r = guestfs_lvm_remove_all (g);
11086     if (r == -1)
11087       return -1;
11088   }
11089   {
11090     char device[] = "/dev/sda";
11091     char lines_0[] = ",";
11092     char *lines[] = {
11093       lines_0,
11094       NULL
11095     };
11096     int r;
11097     suppress_error = 0;
11098     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11099     if (r == -1)
11100       return -1;
11101   }
11102   {
11103     char fstype[] = "ext2";
11104     char device[] = "/dev/sda1";
11105     int r;
11106     suppress_error = 0;
11107     r = guestfs_mkfs (g, fstype, device);
11108     if (r == -1)
11109       return -1;
11110   }
11111   {
11112     char device[] = "/dev/sda1";
11113     char mountpoint[] = "/";
11114     int r;
11115     suppress_error = 0;
11116     r = guestfs_mount (g, device, mountpoint);
11117     if (r == -1)
11118       return -1;
11119   }
11120   /* TestOutput for file (0) */
11121   char expected[] = "empty";
11122   {
11123     char path[] = "/new";
11124     int r;
11125     suppress_error = 0;
11126     r = guestfs_touch (g, path);
11127     if (r == -1)
11128       return -1;
11129   }
11130   {
11131     char path[] = "/new";
11132     char *r;
11133     suppress_error = 0;
11134     r = guestfs_file (g, path);
11135     if (r == NULL)
11136       return -1;
11137     if (strcmp (r, expected) != 0) {
11138       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11139       return -1;
11140     }
11141     free (r);
11142   }
11143   return 0;
11144 }
11145
11146 static int test_file_1_skip (void)
11147 {
11148   const char *str;
11149
11150   str = getenv ("TEST_ONLY");
11151   if (str)
11152     return strstr (str, "file") == NULL;
11153   str = getenv ("SKIP_TEST_FILE_1");
11154   if (str && strcmp (str, "1") == 0) return 1;
11155   str = getenv ("SKIP_TEST_FILE");
11156   if (str && strcmp (str, "1") == 0) return 1;
11157   return 0;
11158 }
11159
11160 static int test_file_1 (void)
11161 {
11162   if (test_file_1_skip ()) {
11163     printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
11164     return 0;
11165   }
11166
11167   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
11168   {
11169     char device[] = "/dev/sda";
11170     int r;
11171     suppress_error = 0;
11172     r = guestfs_blockdev_setrw (g, device);
11173     if (r == -1)
11174       return -1;
11175   }
11176   {
11177     int r;
11178     suppress_error = 0;
11179     r = guestfs_umount_all (g);
11180     if (r == -1)
11181       return -1;
11182   }
11183   {
11184     int r;
11185     suppress_error = 0;
11186     r = guestfs_lvm_remove_all (g);
11187     if (r == -1)
11188       return -1;
11189   }
11190   {
11191     char device[] = "/dev/sda";
11192     char lines_0[] = ",";
11193     char *lines[] = {
11194       lines_0,
11195       NULL
11196     };
11197     int r;
11198     suppress_error = 0;
11199     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11200     if (r == -1)
11201       return -1;
11202   }
11203   {
11204     char fstype[] = "ext2";
11205     char device[] = "/dev/sda1";
11206     int r;
11207     suppress_error = 0;
11208     r = guestfs_mkfs (g, fstype, device);
11209     if (r == -1)
11210       return -1;
11211   }
11212   {
11213     char device[] = "/dev/sda1";
11214     char mountpoint[] = "/";
11215     int r;
11216     suppress_error = 0;
11217     r = guestfs_mount (g, device, mountpoint);
11218     if (r == -1)
11219       return -1;
11220   }
11221   /* TestOutput for file (1) */
11222   char expected[] = "ASCII text";
11223   {
11224     char path[] = "/new";
11225     char content[] = "some content\n";
11226     int r;
11227     suppress_error = 0;
11228     r = guestfs_write_file (g, path, content, 0);
11229     if (r == -1)
11230       return -1;
11231   }
11232   {
11233     char path[] = "/new";
11234     char *r;
11235     suppress_error = 0;
11236     r = guestfs_file (g, path);
11237     if (r == NULL)
11238       return -1;
11239     if (strcmp (r, expected) != 0) {
11240       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11241       return -1;
11242     }
11243     free (r);
11244   }
11245   return 0;
11246 }
11247
11248 static int test_file_2_skip (void)
11249 {
11250   const char *str;
11251
11252   str = getenv ("TEST_ONLY");
11253   if (str)
11254     return strstr (str, "file") == NULL;
11255   str = getenv ("SKIP_TEST_FILE_2");
11256   if (str && strcmp (str, "1") == 0) return 1;
11257   str = getenv ("SKIP_TEST_FILE");
11258   if (str && strcmp (str, "1") == 0) return 1;
11259   return 0;
11260 }
11261
11262 static int test_file_2 (void)
11263 {
11264   if (test_file_2_skip ()) {
11265     printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
11266     return 0;
11267   }
11268
11269   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
11270   {
11271     char device[] = "/dev/sda";
11272     int r;
11273     suppress_error = 0;
11274     r = guestfs_blockdev_setrw (g, device);
11275     if (r == -1)
11276       return -1;
11277   }
11278   {
11279     int r;
11280     suppress_error = 0;
11281     r = guestfs_umount_all (g);
11282     if (r == -1)
11283       return -1;
11284   }
11285   {
11286     int r;
11287     suppress_error = 0;
11288     r = guestfs_lvm_remove_all (g);
11289     if (r == -1)
11290       return -1;
11291   }
11292   {
11293     char device[] = "/dev/sda";
11294     char lines_0[] = ",";
11295     char *lines[] = {
11296       lines_0,
11297       NULL
11298     };
11299     int r;
11300     suppress_error = 0;
11301     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11302     if (r == -1)
11303       return -1;
11304   }
11305   {
11306     char fstype[] = "ext2";
11307     char device[] = "/dev/sda1";
11308     int r;
11309     suppress_error = 0;
11310     r = guestfs_mkfs (g, fstype, device);
11311     if (r == -1)
11312       return -1;
11313   }
11314   {
11315     char device[] = "/dev/sda1";
11316     char mountpoint[] = "/";
11317     int r;
11318     suppress_error = 0;
11319     r = guestfs_mount (g, device, mountpoint);
11320     if (r == -1)
11321       return -1;
11322   }
11323   /* TestLastFail for file (2) */
11324   {
11325     char path[] = "/nofile";
11326     char *r;
11327     suppress_error = 1;
11328     r = guestfs_file (g, path);
11329     if (r != NULL)
11330       return -1;
11331     free (r);
11332   }
11333   return 0;
11334 }
11335
11336 static int test_umount_all_0_skip (void)
11337 {
11338   const char *str;
11339
11340   str = getenv ("TEST_ONLY");
11341   if (str)
11342     return strstr (str, "umount_all") == NULL;
11343   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
11344   if (str && strcmp (str, "1") == 0) return 1;
11345   str = getenv ("SKIP_TEST_UMOUNT_ALL");
11346   if (str && strcmp (str, "1") == 0) return 1;
11347   return 0;
11348 }
11349
11350 static int test_umount_all_0 (void)
11351 {
11352   if (test_umount_all_0_skip ()) {
11353     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
11354     return 0;
11355   }
11356
11357   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
11358   {
11359     char device[] = "/dev/sda";
11360     int r;
11361     suppress_error = 0;
11362     r = guestfs_blockdev_setrw (g, device);
11363     if (r == -1)
11364       return -1;
11365   }
11366   {
11367     int r;
11368     suppress_error = 0;
11369     r = guestfs_umount_all (g);
11370     if (r == -1)
11371       return -1;
11372   }
11373   {
11374     int r;
11375     suppress_error = 0;
11376     r = guestfs_lvm_remove_all (g);
11377     if (r == -1)
11378       return -1;
11379   }
11380   {
11381     char device[] = "/dev/sda";
11382     char lines_0[] = ",";
11383     char *lines[] = {
11384       lines_0,
11385       NULL
11386     };
11387     int r;
11388     suppress_error = 0;
11389     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11390     if (r == -1)
11391       return -1;
11392   }
11393   {
11394     char fstype[] = "ext2";
11395     char device[] = "/dev/sda1";
11396     int r;
11397     suppress_error = 0;
11398     r = guestfs_mkfs (g, fstype, device);
11399     if (r == -1)
11400       return -1;
11401   }
11402   {
11403     char device[] = "/dev/sda1";
11404     char mountpoint[] = "/";
11405     int r;
11406     suppress_error = 0;
11407     r = guestfs_mount (g, device, mountpoint);
11408     if (r == -1)
11409       return -1;
11410   }
11411   /* TestOutputList for umount_all (0) */
11412   {
11413     int r;
11414     suppress_error = 0;
11415     r = guestfs_umount_all (g);
11416     if (r == -1)
11417       return -1;
11418   }
11419   {
11420     char **r;
11421     int i;
11422     suppress_error = 0;
11423     r = guestfs_mounts (g);
11424     if (r == NULL)
11425       return -1;
11426     if (r[0] != NULL) {
11427       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
11428       print_strings (r);
11429       return -1;
11430     }
11431     for (i = 0; r[i] != NULL; ++i)
11432       free (r[i]);
11433     free (r);
11434   }
11435   return 0;
11436 }
11437
11438 static int test_umount_all_1_skip (void)
11439 {
11440   const char *str;
11441
11442   str = getenv ("TEST_ONLY");
11443   if (str)
11444     return strstr (str, "umount_all") == NULL;
11445   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
11446   if (str && strcmp (str, "1") == 0) return 1;
11447   str = getenv ("SKIP_TEST_UMOUNT_ALL");
11448   if (str && strcmp (str, "1") == 0) return 1;
11449   return 0;
11450 }
11451
11452 static int test_umount_all_1 (void)
11453 {
11454   if (test_umount_all_1_skip ()) {
11455     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
11456     return 0;
11457   }
11458
11459   /* InitNone|InitEmpty for test_umount_all_1 */
11460   {
11461     char device[] = "/dev/sda";
11462     int r;
11463     suppress_error = 0;
11464     r = guestfs_blockdev_setrw (g, device);
11465     if (r == -1)
11466       return -1;
11467   }
11468   {
11469     int r;
11470     suppress_error = 0;
11471     r = guestfs_umount_all (g);
11472     if (r == -1)
11473       return -1;
11474   }
11475   {
11476     int r;
11477     suppress_error = 0;
11478     r = guestfs_lvm_remove_all (g);
11479     if (r == -1)
11480       return -1;
11481   }
11482   /* TestOutputList for umount_all (1) */
11483   {
11484     char device[] = "/dev/sda";
11485     char lines_0[] = ",10";
11486     char lines_1[] = ",20";
11487     char lines_2[] = ",";
11488     char *lines[] = {
11489       lines_0,
11490       lines_1,
11491       lines_2,
11492       NULL
11493     };
11494     int r;
11495     suppress_error = 0;
11496     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11497     if (r == -1)
11498       return -1;
11499   }
11500   {
11501     char fstype[] = "ext2";
11502     char device[] = "/dev/sda1";
11503     int r;
11504     suppress_error = 0;
11505     r = guestfs_mkfs (g, fstype, device);
11506     if (r == -1)
11507       return -1;
11508   }
11509   {
11510     char fstype[] = "ext2";
11511     char device[] = "/dev/sda2";
11512     int r;
11513     suppress_error = 0;
11514     r = guestfs_mkfs (g, fstype, device);
11515     if (r == -1)
11516       return -1;
11517   }
11518   {
11519     char fstype[] = "ext2";
11520     char device[] = "/dev/sda3";
11521     int r;
11522     suppress_error = 0;
11523     r = guestfs_mkfs (g, fstype, device);
11524     if (r == -1)
11525       return -1;
11526   }
11527   {
11528     char device[] = "/dev/sda1";
11529     char mountpoint[] = "/";
11530     int r;
11531     suppress_error = 0;
11532     r = guestfs_mount (g, device, mountpoint);
11533     if (r == -1)
11534       return -1;
11535   }
11536   {
11537     char path[] = "/mp1";
11538     int r;
11539     suppress_error = 0;
11540     r = guestfs_mkdir (g, path);
11541     if (r == -1)
11542       return -1;
11543   }
11544   {
11545     char device[] = "/dev/sda2";
11546     char mountpoint[] = "/mp1";
11547     int r;
11548     suppress_error = 0;
11549     r = guestfs_mount (g, device, mountpoint);
11550     if (r == -1)
11551       return -1;
11552   }
11553   {
11554     char path[] = "/mp1/mp2";
11555     int r;
11556     suppress_error = 0;
11557     r = guestfs_mkdir (g, path);
11558     if (r == -1)
11559       return -1;
11560   }
11561   {
11562     char device[] = "/dev/sda3";
11563     char mountpoint[] = "/mp1/mp2";
11564     int r;
11565     suppress_error = 0;
11566     r = guestfs_mount (g, device, mountpoint);
11567     if (r == -1)
11568       return -1;
11569   }
11570   {
11571     char path[] = "/mp1/mp2/mp3";
11572     int r;
11573     suppress_error = 0;
11574     r = guestfs_mkdir (g, path);
11575     if (r == -1)
11576       return -1;
11577   }
11578   {
11579     int r;
11580     suppress_error = 0;
11581     r = guestfs_umount_all (g);
11582     if (r == -1)
11583       return -1;
11584   }
11585   {
11586     char **r;
11587     int i;
11588     suppress_error = 0;
11589     r = guestfs_mounts (g);
11590     if (r == NULL)
11591       return -1;
11592     if (r[0] != NULL) {
11593       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
11594       print_strings (r);
11595       return -1;
11596     }
11597     for (i = 0; r[i] != NULL; ++i)
11598       free (r[i]);
11599     free (r);
11600   }
11601   return 0;
11602 }
11603
11604 static int test_mounts_0_skip (void)
11605 {
11606   const char *str;
11607
11608   str = getenv ("TEST_ONLY");
11609   if (str)
11610     return strstr (str, "mounts") == NULL;
11611   str = getenv ("SKIP_TEST_MOUNTS_0");
11612   if (str && strcmp (str, "1") == 0) return 1;
11613   str = getenv ("SKIP_TEST_MOUNTS");
11614   if (str && strcmp (str, "1") == 0) return 1;
11615   return 0;
11616 }
11617
11618 static int test_mounts_0 (void)
11619 {
11620   if (test_mounts_0_skip ()) {
11621     printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
11622     return 0;
11623   }
11624
11625   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
11626   {
11627     char device[] = "/dev/sda";
11628     int r;
11629     suppress_error = 0;
11630     r = guestfs_blockdev_setrw (g, device);
11631     if (r == -1)
11632       return -1;
11633   }
11634   {
11635     int r;
11636     suppress_error = 0;
11637     r = guestfs_umount_all (g);
11638     if (r == -1)
11639       return -1;
11640   }
11641   {
11642     int r;
11643     suppress_error = 0;
11644     r = guestfs_lvm_remove_all (g);
11645     if (r == -1)
11646       return -1;
11647   }
11648   {
11649     char device[] = "/dev/sda";
11650     char lines_0[] = ",";
11651     char *lines[] = {
11652       lines_0,
11653       NULL
11654     };
11655     int r;
11656     suppress_error = 0;
11657     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11658     if (r == -1)
11659       return -1;
11660   }
11661   {
11662     char fstype[] = "ext2";
11663     char device[] = "/dev/sda1";
11664     int r;
11665     suppress_error = 0;
11666     r = guestfs_mkfs (g, fstype, device);
11667     if (r == -1)
11668       return -1;
11669   }
11670   {
11671     char device[] = "/dev/sda1";
11672     char mountpoint[] = "/";
11673     int r;
11674     suppress_error = 0;
11675     r = guestfs_mount (g, device, mountpoint);
11676     if (r == -1)
11677       return -1;
11678   }
11679   /* TestOutputListOfDevices for mounts (0) */
11680   {
11681     char **r;
11682     int i;
11683     suppress_error = 0;
11684     r = guestfs_mounts (g);
11685     if (r == NULL)
11686       return -1;
11687     if (!r[0]) {
11688       fprintf (stderr, "test_mounts_0: short list returned from command\n");
11689       print_strings (r);
11690       return -1;
11691     }
11692     {
11693       char expected[] = "/dev/sda1";
11694       r[0][5] = 's';
11695       if (strcmp (r[0], expected) != 0) {
11696         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11697         return -1;
11698       }
11699     }
11700     if (r[1] != NULL) {
11701       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
11702       print_strings (r);
11703       return -1;
11704     }
11705     for (i = 0; r[i] != NULL; ++i)
11706       free (r[i]);
11707     free (r);
11708   }
11709   return 0;
11710 }
11711
11712 static int test_umount_0_skip (void)
11713 {
11714   const char *str;
11715
11716   str = getenv ("TEST_ONLY");
11717   if (str)
11718     return strstr (str, "umount") == NULL;
11719   str = getenv ("SKIP_TEST_UMOUNT_0");
11720   if (str && strcmp (str, "1") == 0) return 1;
11721   str = getenv ("SKIP_TEST_UMOUNT");
11722   if (str && strcmp (str, "1") == 0) return 1;
11723   return 0;
11724 }
11725
11726 static int test_umount_0 (void)
11727 {
11728   if (test_umount_0_skip ()) {
11729     printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
11730     return 0;
11731   }
11732
11733   /* InitNone|InitEmpty for test_umount_0 */
11734   {
11735     char device[] = "/dev/sda";
11736     int r;
11737     suppress_error = 0;
11738     r = guestfs_blockdev_setrw (g, device);
11739     if (r == -1)
11740       return -1;
11741   }
11742   {
11743     int r;
11744     suppress_error = 0;
11745     r = guestfs_umount_all (g);
11746     if (r == -1)
11747       return -1;
11748   }
11749   {
11750     int r;
11751     suppress_error = 0;
11752     r = guestfs_lvm_remove_all (g);
11753     if (r == -1)
11754       return -1;
11755   }
11756   /* TestOutputListOfDevices for umount (0) */
11757   {
11758     char device[] = "/dev/sda";
11759     char lines_0[] = ",";
11760     char *lines[] = {
11761       lines_0,
11762       NULL
11763     };
11764     int r;
11765     suppress_error = 0;
11766     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11767     if (r == -1)
11768       return -1;
11769   }
11770   {
11771     char fstype[] = "ext2";
11772     char device[] = "/dev/sda1";
11773     int r;
11774     suppress_error = 0;
11775     r = guestfs_mkfs (g, fstype, device);
11776     if (r == -1)
11777       return -1;
11778   }
11779   {
11780     char device[] = "/dev/sda1";
11781     char mountpoint[] = "/";
11782     int r;
11783     suppress_error = 0;
11784     r = guestfs_mount (g, device, mountpoint);
11785     if (r == -1)
11786       return -1;
11787   }
11788   {
11789     char **r;
11790     int i;
11791     suppress_error = 0;
11792     r = guestfs_mounts (g);
11793     if (r == NULL)
11794       return -1;
11795     if (!r[0]) {
11796       fprintf (stderr, "test_umount_0: short list returned from command\n");
11797       print_strings (r);
11798       return -1;
11799     }
11800     {
11801       char expected[] = "/dev/sda1";
11802       r[0][5] = 's';
11803       if (strcmp (r[0], expected) != 0) {
11804         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11805         return -1;
11806       }
11807     }
11808     if (r[1] != NULL) {
11809       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
11810       print_strings (r);
11811       return -1;
11812     }
11813     for (i = 0; r[i] != NULL; ++i)
11814       free (r[i]);
11815     free (r);
11816   }
11817   return 0;
11818 }
11819
11820 static int test_umount_1_skip (void)
11821 {
11822   const char *str;
11823
11824   str = getenv ("TEST_ONLY");
11825   if (str)
11826     return strstr (str, "umount") == NULL;
11827   str = getenv ("SKIP_TEST_UMOUNT_1");
11828   if (str && strcmp (str, "1") == 0) return 1;
11829   str = getenv ("SKIP_TEST_UMOUNT");
11830   if (str && strcmp (str, "1") == 0) return 1;
11831   return 0;
11832 }
11833
11834 static int test_umount_1 (void)
11835 {
11836   if (test_umount_1_skip ()) {
11837     printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
11838     return 0;
11839   }
11840
11841   /* InitNone|InitEmpty for test_umount_1 */
11842   {
11843     char device[] = "/dev/sda";
11844     int r;
11845     suppress_error = 0;
11846     r = guestfs_blockdev_setrw (g, device);
11847     if (r == -1)
11848       return -1;
11849   }
11850   {
11851     int r;
11852     suppress_error = 0;
11853     r = guestfs_umount_all (g);
11854     if (r == -1)
11855       return -1;
11856   }
11857   {
11858     int r;
11859     suppress_error = 0;
11860     r = guestfs_lvm_remove_all (g);
11861     if (r == -1)
11862       return -1;
11863   }
11864   /* TestOutputList for umount (1) */
11865   {
11866     char device[] = "/dev/sda";
11867     char lines_0[] = ",";
11868     char *lines[] = {
11869       lines_0,
11870       NULL
11871     };
11872     int r;
11873     suppress_error = 0;
11874     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11875     if (r == -1)
11876       return -1;
11877   }
11878   {
11879     char fstype[] = "ext2";
11880     char device[] = "/dev/sda1";
11881     int r;
11882     suppress_error = 0;
11883     r = guestfs_mkfs (g, fstype, device);
11884     if (r == -1)
11885       return -1;
11886   }
11887   {
11888     char device[] = "/dev/sda1";
11889     char mountpoint[] = "/";
11890     int r;
11891     suppress_error = 0;
11892     r = guestfs_mount (g, device, mountpoint);
11893     if (r == -1)
11894       return -1;
11895   }
11896   {
11897     char pathordevice[] = "/";
11898     int r;
11899     suppress_error = 0;
11900     r = guestfs_umount (g, pathordevice);
11901     if (r == -1)
11902       return -1;
11903   }
11904   {
11905     char **r;
11906     int i;
11907     suppress_error = 0;
11908     r = guestfs_mounts (g);
11909     if (r == NULL)
11910       return -1;
11911     if (r[0] != NULL) {
11912       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
11913       print_strings (r);
11914       return -1;
11915     }
11916     for (i = 0; r[i] != NULL; ++i)
11917       free (r[i]);
11918     free (r);
11919   }
11920   return 0;
11921 }
11922
11923 static int test_write_file_0_skip (void)
11924 {
11925   const char *str;
11926
11927   str = getenv ("TEST_ONLY");
11928   if (str)
11929     return strstr (str, "write_file") == NULL;
11930   str = getenv ("SKIP_TEST_WRITE_FILE_0");
11931   if (str && strcmp (str, "1") == 0) return 1;
11932   str = getenv ("SKIP_TEST_WRITE_FILE");
11933   if (str && strcmp (str, "1") == 0) return 1;
11934   return 0;
11935 }
11936
11937 static int test_write_file_0 (void)
11938 {
11939   if (test_write_file_0_skip ()) {
11940     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
11941     return 0;
11942   }
11943
11944   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
11945   {
11946     char device[] = "/dev/sda";
11947     int r;
11948     suppress_error = 0;
11949     r = guestfs_blockdev_setrw (g, device);
11950     if (r == -1)
11951       return -1;
11952   }
11953   {
11954     int r;
11955     suppress_error = 0;
11956     r = guestfs_umount_all (g);
11957     if (r == -1)
11958       return -1;
11959   }
11960   {
11961     int r;
11962     suppress_error = 0;
11963     r = guestfs_lvm_remove_all (g);
11964     if (r == -1)
11965       return -1;
11966   }
11967   {
11968     char device[] = "/dev/sda";
11969     char lines_0[] = ",";
11970     char *lines[] = {
11971       lines_0,
11972       NULL
11973     };
11974     int r;
11975     suppress_error = 0;
11976     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11977     if (r == -1)
11978       return -1;
11979   }
11980   {
11981     char fstype[] = "ext2";
11982     char device[] = "/dev/sda1";
11983     int r;
11984     suppress_error = 0;
11985     r = guestfs_mkfs (g, fstype, device);
11986     if (r == -1)
11987       return -1;
11988   }
11989   {
11990     char device[] = "/dev/sda1";
11991     char mountpoint[] = "/";
11992     int r;
11993     suppress_error = 0;
11994     r = guestfs_mount (g, device, mountpoint);
11995     if (r == -1)
11996       return -1;
11997   }
11998   /* TestOutput for write_file (0) */
11999   char expected[] = "new file contents";
12000   {
12001     char path[] = "/new";
12002     char content[] = "new file contents";
12003     int r;
12004     suppress_error = 0;
12005     r = guestfs_write_file (g, path, content, 0);
12006     if (r == -1)
12007       return -1;
12008   }
12009   {
12010     char path[] = "/new";
12011     char *r;
12012     suppress_error = 0;
12013     r = guestfs_cat (g, path);
12014     if (r == NULL)
12015       return -1;
12016     if (strcmp (r, expected) != 0) {
12017       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12018       return -1;
12019     }
12020     free (r);
12021   }
12022   return 0;
12023 }
12024
12025 static int test_write_file_1_skip (void)
12026 {
12027   const char *str;
12028
12029   str = getenv ("TEST_ONLY");
12030   if (str)
12031     return strstr (str, "write_file") == NULL;
12032   str = getenv ("SKIP_TEST_WRITE_FILE_1");
12033   if (str && strcmp (str, "1") == 0) return 1;
12034   str = getenv ("SKIP_TEST_WRITE_FILE");
12035   if (str && strcmp (str, "1") == 0) return 1;
12036   return 0;
12037 }
12038
12039 static int test_write_file_1 (void)
12040 {
12041   if (test_write_file_1_skip ()) {
12042     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
12043     return 0;
12044   }
12045
12046   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
12047   {
12048     char device[] = "/dev/sda";
12049     int r;
12050     suppress_error = 0;
12051     r = guestfs_blockdev_setrw (g, device);
12052     if (r == -1)
12053       return -1;
12054   }
12055   {
12056     int r;
12057     suppress_error = 0;
12058     r = guestfs_umount_all (g);
12059     if (r == -1)
12060       return -1;
12061   }
12062   {
12063     int r;
12064     suppress_error = 0;
12065     r = guestfs_lvm_remove_all (g);
12066     if (r == -1)
12067       return -1;
12068   }
12069   {
12070     char device[] = "/dev/sda";
12071     char lines_0[] = ",";
12072     char *lines[] = {
12073       lines_0,
12074       NULL
12075     };
12076     int r;
12077     suppress_error = 0;
12078     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12079     if (r == -1)
12080       return -1;
12081   }
12082   {
12083     char fstype[] = "ext2";
12084     char device[] = "/dev/sda1";
12085     int r;
12086     suppress_error = 0;
12087     r = guestfs_mkfs (g, fstype, device);
12088     if (r == -1)
12089       return -1;
12090   }
12091   {
12092     char device[] = "/dev/sda1";
12093     char mountpoint[] = "/";
12094     int r;
12095     suppress_error = 0;
12096     r = guestfs_mount (g, device, mountpoint);
12097     if (r == -1)
12098       return -1;
12099   }
12100   /* TestOutput for write_file (1) */
12101   char expected[] = "\nnew file contents\n";
12102   {
12103     char path[] = "/new";
12104     char content[] = "\nnew file contents\n";
12105     int r;
12106     suppress_error = 0;
12107     r = guestfs_write_file (g, path, content, 0);
12108     if (r == -1)
12109       return -1;
12110   }
12111   {
12112     char path[] = "/new";
12113     char *r;
12114     suppress_error = 0;
12115     r = guestfs_cat (g, path);
12116     if (r == NULL)
12117       return -1;
12118     if (strcmp (r, expected) != 0) {
12119       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12120       return -1;
12121     }
12122     free (r);
12123   }
12124   return 0;
12125 }
12126
12127 static int test_write_file_2_skip (void)
12128 {
12129   const char *str;
12130
12131   str = getenv ("TEST_ONLY");
12132   if (str)
12133     return strstr (str, "write_file") == NULL;
12134   str = getenv ("SKIP_TEST_WRITE_FILE_2");
12135   if (str && strcmp (str, "1") == 0) return 1;
12136   str = getenv ("SKIP_TEST_WRITE_FILE");
12137   if (str && strcmp (str, "1") == 0) return 1;
12138   return 0;
12139 }
12140
12141 static int test_write_file_2 (void)
12142 {
12143   if (test_write_file_2_skip ()) {
12144     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
12145     return 0;
12146   }
12147
12148   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
12149   {
12150     char device[] = "/dev/sda";
12151     int r;
12152     suppress_error = 0;
12153     r = guestfs_blockdev_setrw (g, device);
12154     if (r == -1)
12155       return -1;
12156   }
12157   {
12158     int r;
12159     suppress_error = 0;
12160     r = guestfs_umount_all (g);
12161     if (r == -1)
12162       return -1;
12163   }
12164   {
12165     int r;
12166     suppress_error = 0;
12167     r = guestfs_lvm_remove_all (g);
12168     if (r == -1)
12169       return -1;
12170   }
12171   {
12172     char device[] = "/dev/sda";
12173     char lines_0[] = ",";
12174     char *lines[] = {
12175       lines_0,
12176       NULL
12177     };
12178     int r;
12179     suppress_error = 0;
12180     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12181     if (r == -1)
12182       return -1;
12183   }
12184   {
12185     char fstype[] = "ext2";
12186     char device[] = "/dev/sda1";
12187     int r;
12188     suppress_error = 0;
12189     r = guestfs_mkfs (g, fstype, device);
12190     if (r == -1)
12191       return -1;
12192   }
12193   {
12194     char device[] = "/dev/sda1";
12195     char mountpoint[] = "/";
12196     int r;
12197     suppress_error = 0;
12198     r = guestfs_mount (g, device, mountpoint);
12199     if (r == -1)
12200       return -1;
12201   }
12202   /* TestOutput for write_file (2) */
12203   char expected[] = "\n\n";
12204   {
12205     char path[] = "/new";
12206     char content[] = "\n\n";
12207     int r;
12208     suppress_error = 0;
12209     r = guestfs_write_file (g, path, content, 0);
12210     if (r == -1)
12211       return -1;
12212   }
12213   {
12214     char path[] = "/new";
12215     char *r;
12216     suppress_error = 0;
12217     r = guestfs_cat (g, path);
12218     if (r == NULL)
12219       return -1;
12220     if (strcmp (r, expected) != 0) {
12221       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
12222       return -1;
12223     }
12224     free (r);
12225   }
12226   return 0;
12227 }
12228
12229 static int test_write_file_3_skip (void)
12230 {
12231   const char *str;
12232
12233   str = getenv ("TEST_ONLY");
12234   if (str)
12235     return strstr (str, "write_file") == NULL;
12236   str = getenv ("SKIP_TEST_WRITE_FILE_3");
12237   if (str && strcmp (str, "1") == 0) return 1;
12238   str = getenv ("SKIP_TEST_WRITE_FILE");
12239   if (str && strcmp (str, "1") == 0) return 1;
12240   return 0;
12241 }
12242
12243 static int test_write_file_3 (void)
12244 {
12245   if (test_write_file_3_skip ()) {
12246     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
12247     return 0;
12248   }
12249
12250   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
12251   {
12252     char device[] = "/dev/sda";
12253     int r;
12254     suppress_error = 0;
12255     r = guestfs_blockdev_setrw (g, device);
12256     if (r == -1)
12257       return -1;
12258   }
12259   {
12260     int r;
12261     suppress_error = 0;
12262     r = guestfs_umount_all (g);
12263     if (r == -1)
12264       return -1;
12265   }
12266   {
12267     int r;
12268     suppress_error = 0;
12269     r = guestfs_lvm_remove_all (g);
12270     if (r == -1)
12271       return -1;
12272   }
12273   {
12274     char device[] = "/dev/sda";
12275     char lines_0[] = ",";
12276     char *lines[] = {
12277       lines_0,
12278       NULL
12279     };
12280     int r;
12281     suppress_error = 0;
12282     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12283     if (r == -1)
12284       return -1;
12285   }
12286   {
12287     char fstype[] = "ext2";
12288     char device[] = "/dev/sda1";
12289     int r;
12290     suppress_error = 0;
12291     r = guestfs_mkfs (g, fstype, device);
12292     if (r == -1)
12293       return -1;
12294   }
12295   {
12296     char device[] = "/dev/sda1";
12297     char mountpoint[] = "/";
12298     int r;
12299     suppress_error = 0;
12300     r = guestfs_mount (g, device, mountpoint);
12301     if (r == -1)
12302       return -1;
12303   }
12304   /* TestOutput for write_file (3) */
12305   char expected[] = "";
12306   {
12307     char path[] = "/new";
12308     char content[] = "";
12309     int r;
12310     suppress_error = 0;
12311     r = guestfs_write_file (g, path, content, 0);
12312     if (r == -1)
12313       return -1;
12314   }
12315   {
12316     char path[] = "/new";
12317     char *r;
12318     suppress_error = 0;
12319     r = guestfs_cat (g, path);
12320     if (r == NULL)
12321       return -1;
12322     if (strcmp (r, expected) != 0) {
12323       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
12324       return -1;
12325     }
12326     free (r);
12327   }
12328   return 0;
12329 }
12330
12331 static int test_write_file_4_skip (void)
12332 {
12333   const char *str;
12334
12335   str = getenv ("TEST_ONLY");
12336   if (str)
12337     return strstr (str, "write_file") == NULL;
12338   str = getenv ("SKIP_TEST_WRITE_FILE_4");
12339   if (str && strcmp (str, "1") == 0) return 1;
12340   str = getenv ("SKIP_TEST_WRITE_FILE");
12341   if (str && strcmp (str, "1") == 0) return 1;
12342   return 0;
12343 }
12344
12345 static int test_write_file_4 (void)
12346 {
12347   if (test_write_file_4_skip ()) {
12348     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
12349     return 0;
12350   }
12351
12352   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
12353   {
12354     char device[] = "/dev/sda";
12355     int r;
12356     suppress_error = 0;
12357     r = guestfs_blockdev_setrw (g, device);
12358     if (r == -1)
12359       return -1;
12360   }
12361   {
12362     int r;
12363     suppress_error = 0;
12364     r = guestfs_umount_all (g);
12365     if (r == -1)
12366       return -1;
12367   }
12368   {
12369     int r;
12370     suppress_error = 0;
12371     r = guestfs_lvm_remove_all (g);
12372     if (r == -1)
12373       return -1;
12374   }
12375   {
12376     char device[] = "/dev/sda";
12377     char lines_0[] = ",";
12378     char *lines[] = {
12379       lines_0,
12380       NULL
12381     };
12382     int r;
12383     suppress_error = 0;
12384     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12385     if (r == -1)
12386       return -1;
12387   }
12388   {
12389     char fstype[] = "ext2";
12390     char device[] = "/dev/sda1";
12391     int r;
12392     suppress_error = 0;
12393     r = guestfs_mkfs (g, fstype, device);
12394     if (r == -1)
12395       return -1;
12396   }
12397   {
12398     char device[] = "/dev/sda1";
12399     char mountpoint[] = "/";
12400     int r;
12401     suppress_error = 0;
12402     r = guestfs_mount (g, device, mountpoint);
12403     if (r == -1)
12404       return -1;
12405   }
12406   /* TestOutput for write_file (4) */
12407   char expected[] = "\n\n\n";
12408   {
12409     char path[] = "/new";
12410     char content[] = "\n\n\n";
12411     int r;
12412     suppress_error = 0;
12413     r = guestfs_write_file (g, path, content, 0);
12414     if (r == -1)
12415       return -1;
12416   }
12417   {
12418     char path[] = "/new";
12419     char *r;
12420     suppress_error = 0;
12421     r = guestfs_cat (g, path);
12422     if (r == NULL)
12423       return -1;
12424     if (strcmp (r, expected) != 0) {
12425       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
12426       return -1;
12427     }
12428     free (r);
12429   }
12430   return 0;
12431 }
12432
12433 static int test_write_file_5_skip (void)
12434 {
12435   const char *str;
12436
12437   str = getenv ("TEST_ONLY");
12438   if (str)
12439     return strstr (str, "write_file") == NULL;
12440   str = getenv ("SKIP_TEST_WRITE_FILE_5");
12441   if (str && strcmp (str, "1") == 0) return 1;
12442   str = getenv ("SKIP_TEST_WRITE_FILE");
12443   if (str && strcmp (str, "1") == 0) return 1;
12444   return 0;
12445 }
12446
12447 static int test_write_file_5 (void)
12448 {
12449   if (test_write_file_5_skip ()) {
12450     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
12451     return 0;
12452   }
12453
12454   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
12455   {
12456     char device[] = "/dev/sda";
12457     int r;
12458     suppress_error = 0;
12459     r = guestfs_blockdev_setrw (g, device);
12460     if (r == -1)
12461       return -1;
12462   }
12463   {
12464     int r;
12465     suppress_error = 0;
12466     r = guestfs_umount_all (g);
12467     if (r == -1)
12468       return -1;
12469   }
12470   {
12471     int r;
12472     suppress_error = 0;
12473     r = guestfs_lvm_remove_all (g);
12474     if (r == -1)
12475       return -1;
12476   }
12477   {
12478     char device[] = "/dev/sda";
12479     char lines_0[] = ",";
12480     char *lines[] = {
12481       lines_0,
12482       NULL
12483     };
12484     int r;
12485     suppress_error = 0;
12486     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12487     if (r == -1)
12488       return -1;
12489   }
12490   {
12491     char fstype[] = "ext2";
12492     char device[] = "/dev/sda1";
12493     int r;
12494     suppress_error = 0;
12495     r = guestfs_mkfs (g, fstype, device);
12496     if (r == -1)
12497       return -1;
12498   }
12499   {
12500     char device[] = "/dev/sda1";
12501     char mountpoint[] = "/";
12502     int r;
12503     suppress_error = 0;
12504     r = guestfs_mount (g, device, mountpoint);
12505     if (r == -1)
12506       return -1;
12507   }
12508   /* TestOutput for write_file (5) */
12509   char expected[] = "\n";
12510   {
12511     char path[] = "/new";
12512     char content[] = "\n";
12513     int r;
12514     suppress_error = 0;
12515     r = guestfs_write_file (g, path, content, 0);
12516     if (r == -1)
12517       return -1;
12518   }
12519   {
12520     char path[] = "/new";
12521     char *r;
12522     suppress_error = 0;
12523     r = guestfs_cat (g, path);
12524     if (r == NULL)
12525       return -1;
12526     if (strcmp (r, expected) != 0) {
12527       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
12528       return -1;
12529     }
12530     free (r);
12531   }
12532   return 0;
12533 }
12534
12535 static int test_mkfs_0_skip (void)
12536 {
12537   const char *str;
12538
12539   str = getenv ("TEST_ONLY");
12540   if (str)
12541     return strstr (str, "mkfs") == NULL;
12542   str = getenv ("SKIP_TEST_MKFS_0");
12543   if (str && strcmp (str, "1") == 0) return 1;
12544   str = getenv ("SKIP_TEST_MKFS");
12545   if (str && strcmp (str, "1") == 0) return 1;
12546   return 0;
12547 }
12548
12549 static int test_mkfs_0 (void)
12550 {
12551   if (test_mkfs_0_skip ()) {
12552     printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
12553     return 0;
12554   }
12555
12556   /* InitNone|InitEmpty for test_mkfs_0 */
12557   {
12558     char device[] = "/dev/sda";
12559     int r;
12560     suppress_error = 0;
12561     r = guestfs_blockdev_setrw (g, device);
12562     if (r == -1)
12563       return -1;
12564   }
12565   {
12566     int r;
12567     suppress_error = 0;
12568     r = guestfs_umount_all (g);
12569     if (r == -1)
12570       return -1;
12571   }
12572   {
12573     int r;
12574     suppress_error = 0;
12575     r = guestfs_lvm_remove_all (g);
12576     if (r == -1)
12577       return -1;
12578   }
12579   /* TestOutput for mkfs (0) */
12580   char expected[] = "new file contents";
12581   {
12582     char device[] = "/dev/sda";
12583     char lines_0[] = ",";
12584     char *lines[] = {
12585       lines_0,
12586       NULL
12587     };
12588     int r;
12589     suppress_error = 0;
12590     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12591     if (r == -1)
12592       return -1;
12593   }
12594   {
12595     char fstype[] = "ext2";
12596     char device[] = "/dev/sda1";
12597     int r;
12598     suppress_error = 0;
12599     r = guestfs_mkfs (g, fstype, device);
12600     if (r == -1)
12601       return -1;
12602   }
12603   {
12604     char device[] = "/dev/sda1";
12605     char mountpoint[] = "/";
12606     int r;
12607     suppress_error = 0;
12608     r = guestfs_mount (g, device, mountpoint);
12609     if (r == -1)
12610       return -1;
12611   }
12612   {
12613     char path[] = "/new";
12614     char content[] = "new file contents";
12615     int r;
12616     suppress_error = 0;
12617     r = guestfs_write_file (g, path, content, 0);
12618     if (r == -1)
12619       return -1;
12620   }
12621   {
12622     char path[] = "/new";
12623     char *r;
12624     suppress_error = 0;
12625     r = guestfs_cat (g, path);
12626     if (r == NULL)
12627       return -1;
12628     if (strcmp (r, expected) != 0) {
12629       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
12630       return -1;
12631     }
12632     free (r);
12633   }
12634   return 0;
12635 }
12636
12637 static int test_lvcreate_0_skip (void)
12638 {
12639   const char *str;
12640
12641   str = getenv ("TEST_ONLY");
12642   if (str)
12643     return strstr (str, "lvcreate") == NULL;
12644   str = getenv ("SKIP_TEST_LVCREATE_0");
12645   if (str && strcmp (str, "1") == 0) return 1;
12646   str = getenv ("SKIP_TEST_LVCREATE");
12647   if (str && strcmp (str, "1") == 0) return 1;
12648   return 0;
12649 }
12650
12651 static int test_lvcreate_0 (void)
12652 {
12653   if (test_lvcreate_0_skip ()) {
12654     printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
12655     return 0;
12656   }
12657
12658   /* InitNone|InitEmpty for test_lvcreate_0 */
12659   {
12660     char device[] = "/dev/sda";
12661     int r;
12662     suppress_error = 0;
12663     r = guestfs_blockdev_setrw (g, device);
12664     if (r == -1)
12665       return -1;
12666   }
12667   {
12668     int r;
12669     suppress_error = 0;
12670     r = guestfs_umount_all (g);
12671     if (r == -1)
12672       return -1;
12673   }
12674   {
12675     int r;
12676     suppress_error = 0;
12677     r = guestfs_lvm_remove_all (g);
12678     if (r == -1)
12679       return -1;
12680   }
12681   /* TestOutputList for lvcreate (0) */
12682   {
12683     char device[] = "/dev/sda";
12684     char lines_0[] = ",10";
12685     char lines_1[] = ",20";
12686     char lines_2[] = ",";
12687     char *lines[] = {
12688       lines_0,
12689       lines_1,
12690       lines_2,
12691       NULL
12692     };
12693     int r;
12694     suppress_error = 0;
12695     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12696     if (r == -1)
12697       return -1;
12698   }
12699   {
12700     char device[] = "/dev/sda1";
12701     int r;
12702     suppress_error = 0;
12703     r = guestfs_pvcreate (g, device);
12704     if (r == -1)
12705       return -1;
12706   }
12707   {
12708     char device[] = "/dev/sda2";
12709     int r;
12710     suppress_error = 0;
12711     r = guestfs_pvcreate (g, device);
12712     if (r == -1)
12713       return -1;
12714   }
12715   {
12716     char device[] = "/dev/sda3";
12717     int r;
12718     suppress_error = 0;
12719     r = guestfs_pvcreate (g, device);
12720     if (r == -1)
12721       return -1;
12722   }
12723   {
12724     char volgroup[] = "VG1";
12725     char physvols_0[] = "/dev/sda1";
12726     char physvols_1[] = "/dev/sda2";
12727     char *physvols[] = {
12728       physvols_0,
12729       physvols_1,
12730       NULL
12731     };
12732     int r;
12733     suppress_error = 0;
12734     r = guestfs_vgcreate (g, volgroup, physvols);
12735     if (r == -1)
12736       return -1;
12737   }
12738   {
12739     char volgroup[] = "VG2";
12740     char physvols_0[] = "/dev/sda3";
12741     char *physvols[] = {
12742       physvols_0,
12743       NULL
12744     };
12745     int r;
12746     suppress_error = 0;
12747     r = guestfs_vgcreate (g, volgroup, physvols);
12748     if (r == -1)
12749       return -1;
12750   }
12751   {
12752     char logvol[] = "LV1";
12753     char volgroup[] = "VG1";
12754     int r;
12755     suppress_error = 0;
12756     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12757     if (r == -1)
12758       return -1;
12759   }
12760   {
12761     char logvol[] = "LV2";
12762     char volgroup[] = "VG1";
12763     int r;
12764     suppress_error = 0;
12765     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12766     if (r == -1)
12767       return -1;
12768   }
12769   {
12770     char logvol[] = "LV3";
12771     char volgroup[] = "VG2";
12772     int r;
12773     suppress_error = 0;
12774     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12775     if (r == -1)
12776       return -1;
12777   }
12778   {
12779     char logvol[] = "LV4";
12780     char volgroup[] = "VG2";
12781     int r;
12782     suppress_error = 0;
12783     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12784     if (r == -1)
12785       return -1;
12786   }
12787   {
12788     char logvol[] = "LV5";
12789     char volgroup[] = "VG2";
12790     int r;
12791     suppress_error = 0;
12792     r = guestfs_lvcreate (g, logvol, volgroup, 50);
12793     if (r == -1)
12794       return -1;
12795   }
12796   {
12797     char **r;
12798     int i;
12799     suppress_error = 0;
12800     r = guestfs_lvs (g);
12801     if (r == NULL)
12802       return -1;
12803     if (!r[0]) {
12804       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12805       print_strings (r);
12806       return -1;
12807     }
12808     {
12809       char expected[] = "/dev/VG1/LV1";
12810       if (strcmp (r[0], expected) != 0) {
12811         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12812         return -1;
12813       }
12814     }
12815     if (!r[1]) {
12816       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12817       print_strings (r);
12818       return -1;
12819     }
12820     {
12821       char expected[] = "/dev/VG1/LV2";
12822       if (strcmp (r[1], expected) != 0) {
12823         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12824         return -1;
12825       }
12826     }
12827     if (!r[2]) {
12828       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12829       print_strings (r);
12830       return -1;
12831     }
12832     {
12833       char expected[] = "/dev/VG2/LV3";
12834       if (strcmp (r[2], expected) != 0) {
12835         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12836         return -1;
12837       }
12838     }
12839     if (!r[3]) {
12840       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12841       print_strings (r);
12842       return -1;
12843     }
12844     {
12845       char expected[] = "/dev/VG2/LV4";
12846       if (strcmp (r[3], expected) != 0) {
12847         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12848         return -1;
12849       }
12850     }
12851     if (!r[4]) {
12852       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12853       print_strings (r);
12854       return -1;
12855     }
12856     {
12857       char expected[] = "/dev/VG2/LV5";
12858       if (strcmp (r[4], expected) != 0) {
12859         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
12860         return -1;
12861       }
12862     }
12863     if (r[5] != NULL) {
12864       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
12865       print_strings (r);
12866       return -1;
12867     }
12868     for (i = 0; r[i] != NULL; ++i)
12869       free (r[i]);
12870     free (r);
12871   }
12872   return 0;
12873 }
12874
12875 static int test_vgcreate_0_skip (void)
12876 {
12877   const char *str;
12878
12879   str = getenv ("TEST_ONLY");
12880   if (str)
12881     return strstr (str, "vgcreate") == NULL;
12882   str = getenv ("SKIP_TEST_VGCREATE_0");
12883   if (str && strcmp (str, "1") == 0) return 1;
12884   str = getenv ("SKIP_TEST_VGCREATE");
12885   if (str && strcmp (str, "1") == 0) return 1;
12886   return 0;
12887 }
12888
12889 static int test_vgcreate_0 (void)
12890 {
12891   if (test_vgcreate_0_skip ()) {
12892     printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
12893     return 0;
12894   }
12895
12896   /* InitNone|InitEmpty for test_vgcreate_0 */
12897   {
12898     char device[] = "/dev/sda";
12899     int r;
12900     suppress_error = 0;
12901     r = guestfs_blockdev_setrw (g, device);
12902     if (r == -1)
12903       return -1;
12904   }
12905   {
12906     int r;
12907     suppress_error = 0;
12908     r = guestfs_umount_all (g);
12909     if (r == -1)
12910       return -1;
12911   }
12912   {
12913     int r;
12914     suppress_error = 0;
12915     r = guestfs_lvm_remove_all (g);
12916     if (r == -1)
12917       return -1;
12918   }
12919   /* TestOutputList for vgcreate (0) */
12920   {
12921     char device[] = "/dev/sda";
12922     char lines_0[] = ",10";
12923     char lines_1[] = ",20";
12924     char lines_2[] = ",";
12925     char *lines[] = {
12926       lines_0,
12927       lines_1,
12928       lines_2,
12929       NULL
12930     };
12931     int r;
12932     suppress_error = 0;
12933     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12934     if (r == -1)
12935       return -1;
12936   }
12937   {
12938     char device[] = "/dev/sda1";
12939     int r;
12940     suppress_error = 0;
12941     r = guestfs_pvcreate (g, device);
12942     if (r == -1)
12943       return -1;
12944   }
12945   {
12946     char device[] = "/dev/sda2";
12947     int r;
12948     suppress_error = 0;
12949     r = guestfs_pvcreate (g, device);
12950     if (r == -1)
12951       return -1;
12952   }
12953   {
12954     char device[] = "/dev/sda3";
12955     int r;
12956     suppress_error = 0;
12957     r = guestfs_pvcreate (g, device);
12958     if (r == -1)
12959       return -1;
12960   }
12961   {
12962     char volgroup[] = "VG1";
12963     char physvols_0[] = "/dev/sda1";
12964     char physvols_1[] = "/dev/sda2";
12965     char *physvols[] = {
12966       physvols_0,
12967       physvols_1,
12968       NULL
12969     };
12970     int r;
12971     suppress_error = 0;
12972     r = guestfs_vgcreate (g, volgroup, physvols);
12973     if (r == -1)
12974       return -1;
12975   }
12976   {
12977     char volgroup[] = "VG2";
12978     char physvols_0[] = "/dev/sda3";
12979     char *physvols[] = {
12980       physvols_0,
12981       NULL
12982     };
12983     int r;
12984     suppress_error = 0;
12985     r = guestfs_vgcreate (g, volgroup, physvols);
12986     if (r == -1)
12987       return -1;
12988   }
12989   {
12990     char **r;
12991     int i;
12992     suppress_error = 0;
12993     r = guestfs_vgs (g);
12994     if (r == NULL)
12995       return -1;
12996     if (!r[0]) {
12997       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12998       print_strings (r);
12999       return -1;
13000     }
13001     {
13002       char expected[] = "VG1";
13003       if (strcmp (r[0], expected) != 0) {
13004         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13005         return -1;
13006       }
13007     }
13008     if (!r[1]) {
13009       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
13010       print_strings (r);
13011       return -1;
13012     }
13013     {
13014       char expected[] = "VG2";
13015       if (strcmp (r[1], expected) != 0) {
13016         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13017         return -1;
13018       }
13019     }
13020     if (r[2] != NULL) {
13021       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
13022       print_strings (r);
13023       return -1;
13024     }
13025     for (i = 0; r[i] != NULL; ++i)
13026       free (r[i]);
13027     free (r);
13028   }
13029   return 0;
13030 }
13031
13032 static int test_pvcreate_0_skip (void)
13033 {
13034   const char *str;
13035
13036   str = getenv ("TEST_ONLY");
13037   if (str)
13038     return strstr (str, "pvcreate") == NULL;
13039   str = getenv ("SKIP_TEST_PVCREATE_0");
13040   if (str && strcmp (str, "1") == 0) return 1;
13041   str = getenv ("SKIP_TEST_PVCREATE");
13042   if (str && strcmp (str, "1") == 0) return 1;
13043   return 0;
13044 }
13045
13046 static int test_pvcreate_0 (void)
13047 {
13048   if (test_pvcreate_0_skip ()) {
13049     printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
13050     return 0;
13051   }
13052
13053   /* InitNone|InitEmpty for test_pvcreate_0 */
13054   {
13055     char device[] = "/dev/sda";
13056     int r;
13057     suppress_error = 0;
13058     r = guestfs_blockdev_setrw (g, device);
13059     if (r == -1)
13060       return -1;
13061   }
13062   {
13063     int r;
13064     suppress_error = 0;
13065     r = guestfs_umount_all (g);
13066     if (r == -1)
13067       return -1;
13068   }
13069   {
13070     int r;
13071     suppress_error = 0;
13072     r = guestfs_lvm_remove_all (g);
13073     if (r == -1)
13074       return -1;
13075   }
13076   /* TestOutputListOfDevices for pvcreate (0) */
13077   {
13078     char device[] = "/dev/sda";
13079     char lines_0[] = ",10";
13080     char lines_1[] = ",20";
13081     char lines_2[] = ",";
13082     char *lines[] = {
13083       lines_0,
13084       lines_1,
13085       lines_2,
13086       NULL
13087     };
13088     int r;
13089     suppress_error = 0;
13090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13091     if (r == -1)
13092       return -1;
13093   }
13094   {
13095     char device[] = "/dev/sda1";
13096     int r;
13097     suppress_error = 0;
13098     r = guestfs_pvcreate (g, device);
13099     if (r == -1)
13100       return -1;
13101   }
13102   {
13103     char device[] = "/dev/sda2";
13104     int r;
13105     suppress_error = 0;
13106     r = guestfs_pvcreate (g, device);
13107     if (r == -1)
13108       return -1;
13109   }
13110   {
13111     char device[] = "/dev/sda3";
13112     int r;
13113     suppress_error = 0;
13114     r = guestfs_pvcreate (g, device);
13115     if (r == -1)
13116       return -1;
13117   }
13118   {
13119     char **r;
13120     int i;
13121     suppress_error = 0;
13122     r = guestfs_pvs (g);
13123     if (r == NULL)
13124       return -1;
13125     if (!r[0]) {
13126       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
13127       print_strings (r);
13128       return -1;
13129     }
13130     {
13131       char expected[] = "/dev/sda1";
13132       r[0][5] = 's';
13133       if (strcmp (r[0], expected) != 0) {
13134         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13135         return -1;
13136       }
13137     }
13138     if (!r[1]) {
13139       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
13140       print_strings (r);
13141       return -1;
13142     }
13143     {
13144       char expected[] = "/dev/sda2";
13145       r[1][5] = 's';
13146       if (strcmp (r[1], expected) != 0) {
13147         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13148         return -1;
13149       }
13150     }
13151     if (!r[2]) {
13152       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
13153       print_strings (r);
13154       return -1;
13155     }
13156     {
13157       char expected[] = "/dev/sda3";
13158       r[2][5] = 's';
13159       if (strcmp (r[2], expected) != 0) {
13160         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13161         return -1;
13162       }
13163     }
13164     if (r[3] != NULL) {
13165       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
13166       print_strings (r);
13167       return -1;
13168     }
13169     for (i = 0; r[i] != NULL; ++i)
13170       free (r[i]);
13171     free (r);
13172   }
13173   return 0;
13174 }
13175
13176 static int test_is_dir_0_skip (void)
13177 {
13178   const char *str;
13179
13180   str = getenv ("TEST_ONLY");
13181   if (str)
13182     return strstr (str, "is_dir") == NULL;
13183   str = getenv ("SKIP_TEST_IS_DIR_0");
13184   if (str && strcmp (str, "1") == 0) return 1;
13185   str = getenv ("SKIP_TEST_IS_DIR");
13186   if (str && strcmp (str, "1") == 0) return 1;
13187   return 0;
13188 }
13189
13190 static int test_is_dir_0 (void)
13191 {
13192   if (test_is_dir_0_skip ()) {
13193     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
13194     return 0;
13195   }
13196
13197   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
13198   {
13199     char device[] = "/dev/sda";
13200     int r;
13201     suppress_error = 0;
13202     r = guestfs_blockdev_setrw (g, device);
13203     if (r == -1)
13204       return -1;
13205   }
13206   {
13207     int r;
13208     suppress_error = 0;
13209     r = guestfs_umount_all (g);
13210     if (r == -1)
13211       return -1;
13212   }
13213   {
13214     int r;
13215     suppress_error = 0;
13216     r = guestfs_lvm_remove_all (g);
13217     if (r == -1)
13218       return -1;
13219   }
13220   {
13221     char device[] = "/dev/sda";
13222     char lines_0[] = ",";
13223     char *lines[] = {
13224       lines_0,
13225       NULL
13226     };
13227     int r;
13228     suppress_error = 0;
13229     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13230     if (r == -1)
13231       return -1;
13232   }
13233   {
13234     char fstype[] = "ext2";
13235     char device[] = "/dev/sda1";
13236     int r;
13237     suppress_error = 0;
13238     r = guestfs_mkfs (g, fstype, device);
13239     if (r == -1)
13240       return -1;
13241   }
13242   {
13243     char device[] = "/dev/sda1";
13244     char mountpoint[] = "/";
13245     int r;
13246     suppress_error = 0;
13247     r = guestfs_mount (g, device, mountpoint);
13248     if (r == -1)
13249       return -1;
13250   }
13251   /* TestOutputFalse for is_dir (0) */
13252   {
13253     char path[] = "/new";
13254     int r;
13255     suppress_error = 0;
13256     r = guestfs_touch (g, path);
13257     if (r == -1)
13258       return -1;
13259   }
13260   {
13261     char path[] = "/new";
13262     int r;
13263     suppress_error = 0;
13264     r = guestfs_is_dir (g, path);
13265     if (r == -1)
13266       return -1;
13267     if (r) {
13268       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
13269       return -1;
13270     }
13271   }
13272   return 0;
13273 }
13274
13275 static int test_is_dir_1_skip (void)
13276 {
13277   const char *str;
13278
13279   str = getenv ("TEST_ONLY");
13280   if (str)
13281     return strstr (str, "is_dir") == NULL;
13282   str = getenv ("SKIP_TEST_IS_DIR_1");
13283   if (str && strcmp (str, "1") == 0) return 1;
13284   str = getenv ("SKIP_TEST_IS_DIR");
13285   if (str && strcmp (str, "1") == 0) return 1;
13286   return 0;
13287 }
13288
13289 static int test_is_dir_1 (void)
13290 {
13291   if (test_is_dir_1_skip ()) {
13292     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
13293     return 0;
13294   }
13295
13296   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
13297   {
13298     char device[] = "/dev/sda";
13299     int r;
13300     suppress_error = 0;
13301     r = guestfs_blockdev_setrw (g, device);
13302     if (r == -1)
13303       return -1;
13304   }
13305   {
13306     int r;
13307     suppress_error = 0;
13308     r = guestfs_umount_all (g);
13309     if (r == -1)
13310       return -1;
13311   }
13312   {
13313     int r;
13314     suppress_error = 0;
13315     r = guestfs_lvm_remove_all (g);
13316     if (r == -1)
13317       return -1;
13318   }
13319   {
13320     char device[] = "/dev/sda";
13321     char lines_0[] = ",";
13322     char *lines[] = {
13323       lines_0,
13324       NULL
13325     };
13326     int r;
13327     suppress_error = 0;
13328     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13329     if (r == -1)
13330       return -1;
13331   }
13332   {
13333     char fstype[] = "ext2";
13334     char device[] = "/dev/sda1";
13335     int r;
13336     suppress_error = 0;
13337     r = guestfs_mkfs (g, fstype, device);
13338     if (r == -1)
13339       return -1;
13340   }
13341   {
13342     char device[] = "/dev/sda1";
13343     char mountpoint[] = "/";
13344     int r;
13345     suppress_error = 0;
13346     r = guestfs_mount (g, device, mountpoint);
13347     if (r == -1)
13348       return -1;
13349   }
13350   /* TestOutputTrue for is_dir (1) */
13351   {
13352     char path[] = "/new";
13353     int r;
13354     suppress_error = 0;
13355     r = guestfs_mkdir (g, path);
13356     if (r == -1)
13357       return -1;
13358   }
13359   {
13360     char path[] = "/new";
13361     int r;
13362     suppress_error = 0;
13363     r = guestfs_is_dir (g, path);
13364     if (r == -1)
13365       return -1;
13366     if (!r) {
13367       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
13368       return -1;
13369     }
13370   }
13371   return 0;
13372 }
13373
13374 static int test_is_file_0_skip (void)
13375 {
13376   const char *str;
13377
13378   str = getenv ("TEST_ONLY");
13379   if (str)
13380     return strstr (str, "is_file") == NULL;
13381   str = getenv ("SKIP_TEST_IS_FILE_0");
13382   if (str && strcmp (str, "1") == 0) return 1;
13383   str = getenv ("SKIP_TEST_IS_FILE");
13384   if (str && strcmp (str, "1") == 0) return 1;
13385   return 0;
13386 }
13387
13388 static int test_is_file_0 (void)
13389 {
13390   if (test_is_file_0_skip ()) {
13391     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
13392     return 0;
13393   }
13394
13395   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
13396   {
13397     char device[] = "/dev/sda";
13398     int r;
13399     suppress_error = 0;
13400     r = guestfs_blockdev_setrw (g, device);
13401     if (r == -1)
13402       return -1;
13403   }
13404   {
13405     int r;
13406     suppress_error = 0;
13407     r = guestfs_umount_all (g);
13408     if (r == -1)
13409       return -1;
13410   }
13411   {
13412     int r;
13413     suppress_error = 0;
13414     r = guestfs_lvm_remove_all (g);
13415     if (r == -1)
13416       return -1;
13417   }
13418   {
13419     char device[] = "/dev/sda";
13420     char lines_0[] = ",";
13421     char *lines[] = {
13422       lines_0,
13423       NULL
13424     };
13425     int r;
13426     suppress_error = 0;
13427     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13428     if (r == -1)
13429       return -1;
13430   }
13431   {
13432     char fstype[] = "ext2";
13433     char device[] = "/dev/sda1";
13434     int r;
13435     suppress_error = 0;
13436     r = guestfs_mkfs (g, fstype, device);
13437     if (r == -1)
13438       return -1;
13439   }
13440   {
13441     char device[] = "/dev/sda1";
13442     char mountpoint[] = "/";
13443     int r;
13444     suppress_error = 0;
13445     r = guestfs_mount (g, device, mountpoint);
13446     if (r == -1)
13447       return -1;
13448   }
13449   /* TestOutputTrue for is_file (0) */
13450   {
13451     char path[] = "/new";
13452     int r;
13453     suppress_error = 0;
13454     r = guestfs_touch (g, path);
13455     if (r == -1)
13456       return -1;
13457   }
13458   {
13459     char path[] = "/new";
13460     int r;
13461     suppress_error = 0;
13462     r = guestfs_is_file (g, path);
13463     if (r == -1)
13464       return -1;
13465     if (!r) {
13466       fprintf (stderr, "test_is_file_0: expected true, got false\n");
13467       return -1;
13468     }
13469   }
13470   return 0;
13471 }
13472
13473 static int test_is_file_1_skip (void)
13474 {
13475   const char *str;
13476
13477   str = getenv ("TEST_ONLY");
13478   if (str)
13479     return strstr (str, "is_file") == NULL;
13480   str = getenv ("SKIP_TEST_IS_FILE_1");
13481   if (str && strcmp (str, "1") == 0) return 1;
13482   str = getenv ("SKIP_TEST_IS_FILE");
13483   if (str && strcmp (str, "1") == 0) return 1;
13484   return 0;
13485 }
13486
13487 static int test_is_file_1 (void)
13488 {
13489   if (test_is_file_1_skip ()) {
13490     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
13491     return 0;
13492   }
13493
13494   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
13495   {
13496     char device[] = "/dev/sda";
13497     int r;
13498     suppress_error = 0;
13499     r = guestfs_blockdev_setrw (g, device);
13500     if (r == -1)
13501       return -1;
13502   }
13503   {
13504     int r;
13505     suppress_error = 0;
13506     r = guestfs_umount_all (g);
13507     if (r == -1)
13508       return -1;
13509   }
13510   {
13511     int r;
13512     suppress_error = 0;
13513     r = guestfs_lvm_remove_all (g);
13514     if (r == -1)
13515       return -1;
13516   }
13517   {
13518     char device[] = "/dev/sda";
13519     char lines_0[] = ",";
13520     char *lines[] = {
13521       lines_0,
13522       NULL
13523     };
13524     int r;
13525     suppress_error = 0;
13526     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13527     if (r == -1)
13528       return -1;
13529   }
13530   {
13531     char fstype[] = "ext2";
13532     char device[] = "/dev/sda1";
13533     int r;
13534     suppress_error = 0;
13535     r = guestfs_mkfs (g, fstype, device);
13536     if (r == -1)
13537       return -1;
13538   }
13539   {
13540     char device[] = "/dev/sda1";
13541     char mountpoint[] = "/";
13542     int r;
13543     suppress_error = 0;
13544     r = guestfs_mount (g, device, mountpoint);
13545     if (r == -1)
13546       return -1;
13547   }
13548   /* TestOutputFalse for is_file (1) */
13549   {
13550     char path[] = "/new";
13551     int r;
13552     suppress_error = 0;
13553     r = guestfs_mkdir (g, path);
13554     if (r == -1)
13555       return -1;
13556   }
13557   {
13558     char path[] = "/new";
13559     int r;
13560     suppress_error = 0;
13561     r = guestfs_is_file (g, path);
13562     if (r == -1)
13563       return -1;
13564     if (r) {
13565       fprintf (stderr, "test_is_file_1: expected false, got true\n");
13566       return -1;
13567     }
13568   }
13569   return 0;
13570 }
13571
13572 static int test_exists_0_skip (void)
13573 {
13574   const char *str;
13575
13576   str = getenv ("TEST_ONLY");
13577   if (str)
13578     return strstr (str, "exists") == NULL;
13579   str = getenv ("SKIP_TEST_EXISTS_0");
13580   if (str && strcmp (str, "1") == 0) return 1;
13581   str = getenv ("SKIP_TEST_EXISTS");
13582   if (str && strcmp (str, "1") == 0) return 1;
13583   return 0;
13584 }
13585
13586 static int test_exists_0 (void)
13587 {
13588   if (test_exists_0_skip ()) {
13589     printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
13590     return 0;
13591   }
13592
13593   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
13594   {
13595     char device[] = "/dev/sda";
13596     int r;
13597     suppress_error = 0;
13598     r = guestfs_blockdev_setrw (g, device);
13599     if (r == -1)
13600       return -1;
13601   }
13602   {
13603     int r;
13604     suppress_error = 0;
13605     r = guestfs_umount_all (g);
13606     if (r == -1)
13607       return -1;
13608   }
13609   {
13610     int r;
13611     suppress_error = 0;
13612     r = guestfs_lvm_remove_all (g);
13613     if (r == -1)
13614       return -1;
13615   }
13616   {
13617     char device[] = "/dev/sda";
13618     char lines_0[] = ",";
13619     char *lines[] = {
13620       lines_0,
13621       NULL
13622     };
13623     int r;
13624     suppress_error = 0;
13625     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13626     if (r == -1)
13627       return -1;
13628   }
13629   {
13630     char fstype[] = "ext2";
13631     char device[] = "/dev/sda1";
13632     int r;
13633     suppress_error = 0;
13634     r = guestfs_mkfs (g, fstype, device);
13635     if (r == -1)
13636       return -1;
13637   }
13638   {
13639     char device[] = "/dev/sda1";
13640     char mountpoint[] = "/";
13641     int r;
13642     suppress_error = 0;
13643     r = guestfs_mount (g, device, mountpoint);
13644     if (r == -1)
13645       return -1;
13646   }
13647   /* TestOutputTrue for exists (0) */
13648   {
13649     char path[] = "/new";
13650     int r;
13651     suppress_error = 0;
13652     r = guestfs_touch (g, path);
13653     if (r == -1)
13654       return -1;
13655   }
13656   {
13657     char path[] = "/new";
13658     int r;
13659     suppress_error = 0;
13660     r = guestfs_exists (g, path);
13661     if (r == -1)
13662       return -1;
13663     if (!r) {
13664       fprintf (stderr, "test_exists_0: expected true, got false\n");
13665       return -1;
13666     }
13667   }
13668   return 0;
13669 }
13670
13671 static int test_exists_1_skip (void)
13672 {
13673   const char *str;
13674
13675   str = getenv ("TEST_ONLY");
13676   if (str)
13677     return strstr (str, "exists") == NULL;
13678   str = getenv ("SKIP_TEST_EXISTS_1");
13679   if (str && strcmp (str, "1") == 0) return 1;
13680   str = getenv ("SKIP_TEST_EXISTS");
13681   if (str && strcmp (str, "1") == 0) return 1;
13682   return 0;
13683 }
13684
13685 static int test_exists_1 (void)
13686 {
13687   if (test_exists_1_skip ()) {
13688     printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
13689     return 0;
13690   }
13691
13692   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
13693   {
13694     char device[] = "/dev/sda";
13695     int r;
13696     suppress_error = 0;
13697     r = guestfs_blockdev_setrw (g, device);
13698     if (r == -1)
13699       return -1;
13700   }
13701   {
13702     int r;
13703     suppress_error = 0;
13704     r = guestfs_umount_all (g);
13705     if (r == -1)
13706       return -1;
13707   }
13708   {
13709     int r;
13710     suppress_error = 0;
13711     r = guestfs_lvm_remove_all (g);
13712     if (r == -1)
13713       return -1;
13714   }
13715   {
13716     char device[] = "/dev/sda";
13717     char lines_0[] = ",";
13718     char *lines[] = {
13719       lines_0,
13720       NULL
13721     };
13722     int r;
13723     suppress_error = 0;
13724     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13725     if (r == -1)
13726       return -1;
13727   }
13728   {
13729     char fstype[] = "ext2";
13730     char device[] = "/dev/sda1";
13731     int r;
13732     suppress_error = 0;
13733     r = guestfs_mkfs (g, fstype, device);
13734     if (r == -1)
13735       return -1;
13736   }
13737   {
13738     char device[] = "/dev/sda1";
13739     char mountpoint[] = "/";
13740     int r;
13741     suppress_error = 0;
13742     r = guestfs_mount (g, device, mountpoint);
13743     if (r == -1)
13744       return -1;
13745   }
13746   /* TestOutputTrue for exists (1) */
13747   {
13748     char path[] = "/new";
13749     int r;
13750     suppress_error = 0;
13751     r = guestfs_mkdir (g, path);
13752     if (r == -1)
13753       return -1;
13754   }
13755   {
13756     char path[] = "/new";
13757     int r;
13758     suppress_error = 0;
13759     r = guestfs_exists (g, path);
13760     if (r == -1)
13761       return -1;
13762     if (!r) {
13763       fprintf (stderr, "test_exists_1: expected true, got false\n");
13764       return -1;
13765     }
13766   }
13767   return 0;
13768 }
13769
13770 static int test_mkdir_p_0_skip (void)
13771 {
13772   const char *str;
13773
13774   str = getenv ("TEST_ONLY");
13775   if (str)
13776     return strstr (str, "mkdir_p") == NULL;
13777   str = getenv ("SKIP_TEST_MKDIR_P_0");
13778   if (str && strcmp (str, "1") == 0) return 1;
13779   str = getenv ("SKIP_TEST_MKDIR_P");
13780   if (str && strcmp (str, "1") == 0) return 1;
13781   return 0;
13782 }
13783
13784 static int test_mkdir_p_0 (void)
13785 {
13786   if (test_mkdir_p_0_skip ()) {
13787     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
13788     return 0;
13789   }
13790
13791   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
13792   {
13793     char device[] = "/dev/sda";
13794     int r;
13795     suppress_error = 0;
13796     r = guestfs_blockdev_setrw (g, device);
13797     if (r == -1)
13798       return -1;
13799   }
13800   {
13801     int r;
13802     suppress_error = 0;
13803     r = guestfs_umount_all (g);
13804     if (r == -1)
13805       return -1;
13806   }
13807   {
13808     int r;
13809     suppress_error = 0;
13810     r = guestfs_lvm_remove_all (g);
13811     if (r == -1)
13812       return -1;
13813   }
13814   {
13815     char device[] = "/dev/sda";
13816     char lines_0[] = ",";
13817     char *lines[] = {
13818       lines_0,
13819       NULL
13820     };
13821     int r;
13822     suppress_error = 0;
13823     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13824     if (r == -1)
13825       return -1;
13826   }
13827   {
13828     char fstype[] = "ext2";
13829     char device[] = "/dev/sda1";
13830     int r;
13831     suppress_error = 0;
13832     r = guestfs_mkfs (g, fstype, device);
13833     if (r == -1)
13834       return -1;
13835   }
13836   {
13837     char device[] = "/dev/sda1";
13838     char mountpoint[] = "/";
13839     int r;
13840     suppress_error = 0;
13841     r = guestfs_mount (g, device, mountpoint);
13842     if (r == -1)
13843       return -1;
13844   }
13845   /* TestOutputTrue for mkdir_p (0) */
13846   {
13847     char path[] = "/new/foo/bar";
13848     int r;
13849     suppress_error = 0;
13850     r = guestfs_mkdir_p (g, path);
13851     if (r == -1)
13852       return -1;
13853   }
13854   {
13855     char path[] = "/new/foo/bar";
13856     int r;
13857     suppress_error = 0;
13858     r = guestfs_is_dir (g, path);
13859     if (r == -1)
13860       return -1;
13861     if (!r) {
13862       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
13863       return -1;
13864     }
13865   }
13866   return 0;
13867 }
13868
13869 static int test_mkdir_p_1_skip (void)
13870 {
13871   const char *str;
13872
13873   str = getenv ("TEST_ONLY");
13874   if (str)
13875     return strstr (str, "mkdir_p") == NULL;
13876   str = getenv ("SKIP_TEST_MKDIR_P_1");
13877   if (str && strcmp (str, "1") == 0) return 1;
13878   str = getenv ("SKIP_TEST_MKDIR_P");
13879   if (str && strcmp (str, "1") == 0) return 1;
13880   return 0;
13881 }
13882
13883 static int test_mkdir_p_1 (void)
13884 {
13885   if (test_mkdir_p_1_skip ()) {
13886     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
13887     return 0;
13888   }
13889
13890   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
13891   {
13892     char device[] = "/dev/sda";
13893     int r;
13894     suppress_error = 0;
13895     r = guestfs_blockdev_setrw (g, device);
13896     if (r == -1)
13897       return -1;
13898   }
13899   {
13900     int r;
13901     suppress_error = 0;
13902     r = guestfs_umount_all (g);
13903     if (r == -1)
13904       return -1;
13905   }
13906   {
13907     int r;
13908     suppress_error = 0;
13909     r = guestfs_lvm_remove_all (g);
13910     if (r == -1)
13911       return -1;
13912   }
13913   {
13914     char device[] = "/dev/sda";
13915     char lines_0[] = ",";
13916     char *lines[] = {
13917       lines_0,
13918       NULL
13919     };
13920     int r;
13921     suppress_error = 0;
13922     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13923     if (r == -1)
13924       return -1;
13925   }
13926   {
13927     char fstype[] = "ext2";
13928     char device[] = "/dev/sda1";
13929     int r;
13930     suppress_error = 0;
13931     r = guestfs_mkfs (g, fstype, device);
13932     if (r == -1)
13933       return -1;
13934   }
13935   {
13936     char device[] = "/dev/sda1";
13937     char mountpoint[] = "/";
13938     int r;
13939     suppress_error = 0;
13940     r = guestfs_mount (g, device, mountpoint);
13941     if (r == -1)
13942       return -1;
13943   }
13944   /* TestOutputTrue for mkdir_p (1) */
13945   {
13946     char path[] = "/new/foo/bar";
13947     int r;
13948     suppress_error = 0;
13949     r = guestfs_mkdir_p (g, path);
13950     if (r == -1)
13951       return -1;
13952   }
13953   {
13954     char path[] = "/new/foo";
13955     int r;
13956     suppress_error = 0;
13957     r = guestfs_is_dir (g, path);
13958     if (r == -1)
13959       return -1;
13960     if (!r) {
13961       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
13962       return -1;
13963     }
13964   }
13965   return 0;
13966 }
13967
13968 static int test_mkdir_p_2_skip (void)
13969 {
13970   const char *str;
13971
13972   str = getenv ("TEST_ONLY");
13973   if (str)
13974     return strstr (str, "mkdir_p") == NULL;
13975   str = getenv ("SKIP_TEST_MKDIR_P_2");
13976   if (str && strcmp (str, "1") == 0) return 1;
13977   str = getenv ("SKIP_TEST_MKDIR_P");
13978   if (str && strcmp (str, "1") == 0) return 1;
13979   return 0;
13980 }
13981
13982 static int test_mkdir_p_2 (void)
13983 {
13984   if (test_mkdir_p_2_skip ()) {
13985     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
13986     return 0;
13987   }
13988
13989   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
13990   {
13991     char device[] = "/dev/sda";
13992     int r;
13993     suppress_error = 0;
13994     r = guestfs_blockdev_setrw (g, device);
13995     if (r == -1)
13996       return -1;
13997   }
13998   {
13999     int r;
14000     suppress_error = 0;
14001     r = guestfs_umount_all (g);
14002     if (r == -1)
14003       return -1;
14004   }
14005   {
14006     int r;
14007     suppress_error = 0;
14008     r = guestfs_lvm_remove_all (g);
14009     if (r == -1)
14010       return -1;
14011   }
14012   {
14013     char device[] = "/dev/sda";
14014     char lines_0[] = ",";
14015     char *lines[] = {
14016       lines_0,
14017       NULL
14018     };
14019     int r;
14020     suppress_error = 0;
14021     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14022     if (r == -1)
14023       return -1;
14024   }
14025   {
14026     char fstype[] = "ext2";
14027     char device[] = "/dev/sda1";
14028     int r;
14029     suppress_error = 0;
14030     r = guestfs_mkfs (g, fstype, device);
14031     if (r == -1)
14032       return -1;
14033   }
14034   {
14035     char device[] = "/dev/sda1";
14036     char mountpoint[] = "/";
14037     int r;
14038     suppress_error = 0;
14039     r = guestfs_mount (g, device, mountpoint);
14040     if (r == -1)
14041       return -1;
14042   }
14043   /* TestOutputTrue for mkdir_p (2) */
14044   {
14045     char path[] = "/new/foo/bar";
14046     int r;
14047     suppress_error = 0;
14048     r = guestfs_mkdir_p (g, path);
14049     if (r == -1)
14050       return -1;
14051   }
14052   {
14053     char path[] = "/new";
14054     int r;
14055     suppress_error = 0;
14056     r = guestfs_is_dir (g, path);
14057     if (r == -1)
14058       return -1;
14059     if (!r) {
14060       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
14061       return -1;
14062     }
14063   }
14064   return 0;
14065 }
14066
14067 static int test_mkdir_p_3_skip (void)
14068 {
14069   const char *str;
14070
14071   str = getenv ("TEST_ONLY");
14072   if (str)
14073     return strstr (str, "mkdir_p") == NULL;
14074   str = getenv ("SKIP_TEST_MKDIR_P_3");
14075   if (str && strcmp (str, "1") == 0) return 1;
14076   str = getenv ("SKIP_TEST_MKDIR_P");
14077   if (str && strcmp (str, "1") == 0) return 1;
14078   return 0;
14079 }
14080
14081 static int test_mkdir_p_3 (void)
14082 {
14083   if (test_mkdir_p_3_skip ()) {
14084     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
14085     return 0;
14086   }
14087
14088   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
14089   {
14090     char device[] = "/dev/sda";
14091     int r;
14092     suppress_error = 0;
14093     r = guestfs_blockdev_setrw (g, device);
14094     if (r == -1)
14095       return -1;
14096   }
14097   {
14098     int r;
14099     suppress_error = 0;
14100     r = guestfs_umount_all (g);
14101     if (r == -1)
14102       return -1;
14103   }
14104   {
14105     int r;
14106     suppress_error = 0;
14107     r = guestfs_lvm_remove_all (g);
14108     if (r == -1)
14109       return -1;
14110   }
14111   {
14112     char device[] = "/dev/sda";
14113     char lines_0[] = ",";
14114     char *lines[] = {
14115       lines_0,
14116       NULL
14117     };
14118     int r;
14119     suppress_error = 0;
14120     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14121     if (r == -1)
14122       return -1;
14123   }
14124   {
14125     char fstype[] = "ext2";
14126     char device[] = "/dev/sda1";
14127     int r;
14128     suppress_error = 0;
14129     r = guestfs_mkfs (g, fstype, device);
14130     if (r == -1)
14131       return -1;
14132   }
14133   {
14134     char device[] = "/dev/sda1";
14135     char mountpoint[] = "/";
14136     int r;
14137     suppress_error = 0;
14138     r = guestfs_mount (g, device, mountpoint);
14139     if (r == -1)
14140       return -1;
14141   }
14142   /* TestRun for mkdir_p (3) */
14143   {
14144     char path[] = "/new";
14145     int r;
14146     suppress_error = 0;
14147     r = guestfs_mkdir (g, path);
14148     if (r == -1)
14149       return -1;
14150   }
14151   {
14152     char path[] = "/new";
14153     int r;
14154     suppress_error = 0;
14155     r = guestfs_mkdir_p (g, path);
14156     if (r == -1)
14157       return -1;
14158   }
14159   return 0;
14160 }
14161
14162 static int test_mkdir_p_4_skip (void)
14163 {
14164   const char *str;
14165
14166   str = getenv ("TEST_ONLY");
14167   if (str)
14168     return strstr (str, "mkdir_p") == NULL;
14169   str = getenv ("SKIP_TEST_MKDIR_P_4");
14170   if (str && strcmp (str, "1") == 0) return 1;
14171   str = getenv ("SKIP_TEST_MKDIR_P");
14172   if (str && strcmp (str, "1") == 0) return 1;
14173   return 0;
14174 }
14175
14176 static int test_mkdir_p_4 (void)
14177 {
14178   if (test_mkdir_p_4_skip ()) {
14179     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
14180     return 0;
14181   }
14182
14183   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
14184   {
14185     char device[] = "/dev/sda";
14186     int r;
14187     suppress_error = 0;
14188     r = guestfs_blockdev_setrw (g, device);
14189     if (r == -1)
14190       return -1;
14191   }
14192   {
14193     int r;
14194     suppress_error = 0;
14195     r = guestfs_umount_all (g);
14196     if (r == -1)
14197       return -1;
14198   }
14199   {
14200     int r;
14201     suppress_error = 0;
14202     r = guestfs_lvm_remove_all (g);
14203     if (r == -1)
14204       return -1;
14205   }
14206   {
14207     char device[] = "/dev/sda";
14208     char lines_0[] = ",";
14209     char *lines[] = {
14210       lines_0,
14211       NULL
14212     };
14213     int r;
14214     suppress_error = 0;
14215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14216     if (r == -1)
14217       return -1;
14218   }
14219   {
14220     char fstype[] = "ext2";
14221     char device[] = "/dev/sda1";
14222     int r;
14223     suppress_error = 0;
14224     r = guestfs_mkfs (g, fstype, device);
14225     if (r == -1)
14226       return -1;
14227   }
14228   {
14229     char device[] = "/dev/sda1";
14230     char mountpoint[] = "/";
14231     int r;
14232     suppress_error = 0;
14233     r = guestfs_mount (g, device, mountpoint);
14234     if (r == -1)
14235       return -1;
14236   }
14237   /* TestLastFail for mkdir_p (4) */
14238   {
14239     char path[] = "/new";
14240     int r;
14241     suppress_error = 0;
14242     r = guestfs_touch (g, path);
14243     if (r == -1)
14244       return -1;
14245   }
14246   {
14247     char path[] = "/new";
14248     int r;
14249     suppress_error = 1;
14250     r = guestfs_mkdir_p (g, path);
14251     if (r != -1)
14252       return -1;
14253   }
14254   return 0;
14255 }
14256
14257 static int test_mkdir_0_skip (void)
14258 {
14259   const char *str;
14260
14261   str = getenv ("TEST_ONLY");
14262   if (str)
14263     return strstr (str, "mkdir") == NULL;
14264   str = getenv ("SKIP_TEST_MKDIR_0");
14265   if (str && strcmp (str, "1") == 0) return 1;
14266   str = getenv ("SKIP_TEST_MKDIR");
14267   if (str && strcmp (str, "1") == 0) return 1;
14268   return 0;
14269 }
14270
14271 static int test_mkdir_0 (void)
14272 {
14273   if (test_mkdir_0_skip ()) {
14274     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
14275     return 0;
14276   }
14277
14278   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
14279   {
14280     char device[] = "/dev/sda";
14281     int r;
14282     suppress_error = 0;
14283     r = guestfs_blockdev_setrw (g, device);
14284     if (r == -1)
14285       return -1;
14286   }
14287   {
14288     int r;
14289     suppress_error = 0;
14290     r = guestfs_umount_all (g);
14291     if (r == -1)
14292       return -1;
14293   }
14294   {
14295     int r;
14296     suppress_error = 0;
14297     r = guestfs_lvm_remove_all (g);
14298     if (r == -1)
14299       return -1;
14300   }
14301   {
14302     char device[] = "/dev/sda";
14303     char lines_0[] = ",";
14304     char *lines[] = {
14305       lines_0,
14306       NULL
14307     };
14308     int r;
14309     suppress_error = 0;
14310     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14311     if (r == -1)
14312       return -1;
14313   }
14314   {
14315     char fstype[] = "ext2";
14316     char device[] = "/dev/sda1";
14317     int r;
14318     suppress_error = 0;
14319     r = guestfs_mkfs (g, fstype, device);
14320     if (r == -1)
14321       return -1;
14322   }
14323   {
14324     char device[] = "/dev/sda1";
14325     char mountpoint[] = "/";
14326     int r;
14327     suppress_error = 0;
14328     r = guestfs_mount (g, device, mountpoint);
14329     if (r == -1)
14330       return -1;
14331   }
14332   /* TestOutputTrue for mkdir (0) */
14333   {
14334     char path[] = "/new";
14335     int r;
14336     suppress_error = 0;
14337     r = guestfs_mkdir (g, path);
14338     if (r == -1)
14339       return -1;
14340   }
14341   {
14342     char path[] = "/new";
14343     int r;
14344     suppress_error = 0;
14345     r = guestfs_is_dir (g, path);
14346     if (r == -1)
14347       return -1;
14348     if (!r) {
14349       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
14350       return -1;
14351     }
14352   }
14353   return 0;
14354 }
14355
14356 static int test_mkdir_1_skip (void)
14357 {
14358   const char *str;
14359
14360   str = getenv ("TEST_ONLY");
14361   if (str)
14362     return strstr (str, "mkdir") == NULL;
14363   str = getenv ("SKIP_TEST_MKDIR_1");
14364   if (str && strcmp (str, "1") == 0) return 1;
14365   str = getenv ("SKIP_TEST_MKDIR");
14366   if (str && strcmp (str, "1") == 0) return 1;
14367   return 0;
14368 }
14369
14370 static int test_mkdir_1 (void)
14371 {
14372   if (test_mkdir_1_skip ()) {
14373     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
14374     return 0;
14375   }
14376
14377   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
14378   {
14379     char device[] = "/dev/sda";
14380     int r;
14381     suppress_error = 0;
14382     r = guestfs_blockdev_setrw (g, device);
14383     if (r == -1)
14384       return -1;
14385   }
14386   {
14387     int r;
14388     suppress_error = 0;
14389     r = guestfs_umount_all (g);
14390     if (r == -1)
14391       return -1;
14392   }
14393   {
14394     int r;
14395     suppress_error = 0;
14396     r = guestfs_lvm_remove_all (g);
14397     if (r == -1)
14398       return -1;
14399   }
14400   {
14401     char device[] = "/dev/sda";
14402     char lines_0[] = ",";
14403     char *lines[] = {
14404       lines_0,
14405       NULL
14406     };
14407     int r;
14408     suppress_error = 0;
14409     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14410     if (r == -1)
14411       return -1;
14412   }
14413   {
14414     char fstype[] = "ext2";
14415     char device[] = "/dev/sda1";
14416     int r;
14417     suppress_error = 0;
14418     r = guestfs_mkfs (g, fstype, device);
14419     if (r == -1)
14420       return -1;
14421   }
14422   {
14423     char device[] = "/dev/sda1";
14424     char mountpoint[] = "/";
14425     int r;
14426     suppress_error = 0;
14427     r = guestfs_mount (g, device, mountpoint);
14428     if (r == -1)
14429       return -1;
14430   }
14431   /* TestLastFail for mkdir (1) */
14432   {
14433     char path[] = "/new/foo/bar";
14434     int r;
14435     suppress_error = 1;
14436     r = guestfs_mkdir (g, path);
14437     if (r != -1)
14438       return -1;
14439   }
14440   return 0;
14441 }
14442
14443 static int test_rm_rf_0_skip (void)
14444 {
14445   const char *str;
14446
14447   str = getenv ("TEST_ONLY");
14448   if (str)
14449     return strstr (str, "rm_rf") == NULL;
14450   str = getenv ("SKIP_TEST_RM_RF_0");
14451   if (str && strcmp (str, "1") == 0) return 1;
14452   str = getenv ("SKIP_TEST_RM_RF");
14453   if (str && strcmp (str, "1") == 0) return 1;
14454   return 0;
14455 }
14456
14457 static int test_rm_rf_0 (void)
14458 {
14459   if (test_rm_rf_0_skip ()) {
14460     printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
14461     return 0;
14462   }
14463
14464   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
14465   {
14466     char device[] = "/dev/sda";
14467     int r;
14468     suppress_error = 0;
14469     r = guestfs_blockdev_setrw (g, device);
14470     if (r == -1)
14471       return -1;
14472   }
14473   {
14474     int r;
14475     suppress_error = 0;
14476     r = guestfs_umount_all (g);
14477     if (r == -1)
14478       return -1;
14479   }
14480   {
14481     int r;
14482     suppress_error = 0;
14483     r = guestfs_lvm_remove_all (g);
14484     if (r == -1)
14485       return -1;
14486   }
14487   {
14488     char device[] = "/dev/sda";
14489     char lines_0[] = ",";
14490     char *lines[] = {
14491       lines_0,
14492       NULL
14493     };
14494     int r;
14495     suppress_error = 0;
14496     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14497     if (r == -1)
14498       return -1;
14499   }
14500   {
14501     char fstype[] = "ext2";
14502     char device[] = "/dev/sda1";
14503     int r;
14504     suppress_error = 0;
14505     r = guestfs_mkfs (g, fstype, device);
14506     if (r == -1)
14507       return -1;
14508   }
14509   {
14510     char device[] = "/dev/sda1";
14511     char mountpoint[] = "/";
14512     int r;
14513     suppress_error = 0;
14514     r = guestfs_mount (g, device, mountpoint);
14515     if (r == -1)
14516       return -1;
14517   }
14518   /* TestOutputFalse for rm_rf (0) */
14519   {
14520     char path[] = "/new";
14521     int r;
14522     suppress_error = 0;
14523     r = guestfs_mkdir (g, path);
14524     if (r == -1)
14525       return -1;
14526   }
14527   {
14528     char path[] = "/new/foo";
14529     int r;
14530     suppress_error = 0;
14531     r = guestfs_mkdir (g, path);
14532     if (r == -1)
14533       return -1;
14534   }
14535   {
14536     char path[] = "/new/foo/bar";
14537     int r;
14538     suppress_error = 0;
14539     r = guestfs_touch (g, path);
14540     if (r == -1)
14541       return -1;
14542   }
14543   {
14544     char path[] = "/new";
14545     int r;
14546     suppress_error = 0;
14547     r = guestfs_rm_rf (g, path);
14548     if (r == -1)
14549       return -1;
14550   }
14551   {
14552     char path[] = "/new";
14553     int r;
14554     suppress_error = 0;
14555     r = guestfs_exists (g, path);
14556     if (r == -1)
14557       return -1;
14558     if (r) {
14559       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
14560       return -1;
14561     }
14562   }
14563   return 0;
14564 }
14565
14566 static int test_rmdir_0_skip (void)
14567 {
14568   const char *str;
14569
14570   str = getenv ("TEST_ONLY");
14571   if (str)
14572     return strstr (str, "rmdir") == NULL;
14573   str = getenv ("SKIP_TEST_RMDIR_0");
14574   if (str && strcmp (str, "1") == 0) return 1;
14575   str = getenv ("SKIP_TEST_RMDIR");
14576   if (str && strcmp (str, "1") == 0) return 1;
14577   return 0;
14578 }
14579
14580 static int test_rmdir_0 (void)
14581 {
14582   if (test_rmdir_0_skip ()) {
14583     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
14584     return 0;
14585   }
14586
14587   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
14588   {
14589     char device[] = "/dev/sda";
14590     int r;
14591     suppress_error = 0;
14592     r = guestfs_blockdev_setrw (g, device);
14593     if (r == -1)
14594       return -1;
14595   }
14596   {
14597     int r;
14598     suppress_error = 0;
14599     r = guestfs_umount_all (g);
14600     if (r == -1)
14601       return -1;
14602   }
14603   {
14604     int r;
14605     suppress_error = 0;
14606     r = guestfs_lvm_remove_all (g);
14607     if (r == -1)
14608       return -1;
14609   }
14610   {
14611     char device[] = "/dev/sda";
14612     char lines_0[] = ",";
14613     char *lines[] = {
14614       lines_0,
14615       NULL
14616     };
14617     int r;
14618     suppress_error = 0;
14619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14620     if (r == -1)
14621       return -1;
14622   }
14623   {
14624     char fstype[] = "ext2";
14625     char device[] = "/dev/sda1";
14626     int r;
14627     suppress_error = 0;
14628     r = guestfs_mkfs (g, fstype, device);
14629     if (r == -1)
14630       return -1;
14631   }
14632   {
14633     char device[] = "/dev/sda1";
14634     char mountpoint[] = "/";
14635     int r;
14636     suppress_error = 0;
14637     r = guestfs_mount (g, device, mountpoint);
14638     if (r == -1)
14639       return -1;
14640   }
14641   /* TestRun for rmdir (0) */
14642   {
14643     char path[] = "/new";
14644     int r;
14645     suppress_error = 0;
14646     r = guestfs_mkdir (g, path);
14647     if (r == -1)
14648       return -1;
14649   }
14650   {
14651     char path[] = "/new";
14652     int r;
14653     suppress_error = 0;
14654     r = guestfs_rmdir (g, path);
14655     if (r == -1)
14656       return -1;
14657   }
14658   return 0;
14659 }
14660
14661 static int test_rmdir_1_skip (void)
14662 {
14663   const char *str;
14664
14665   str = getenv ("TEST_ONLY");
14666   if (str)
14667     return strstr (str, "rmdir") == NULL;
14668   str = getenv ("SKIP_TEST_RMDIR_1");
14669   if (str && strcmp (str, "1") == 0) return 1;
14670   str = getenv ("SKIP_TEST_RMDIR");
14671   if (str && strcmp (str, "1") == 0) return 1;
14672   return 0;
14673 }
14674
14675 static int test_rmdir_1 (void)
14676 {
14677   if (test_rmdir_1_skip ()) {
14678     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
14679     return 0;
14680   }
14681
14682   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
14683   {
14684     char device[] = "/dev/sda";
14685     int r;
14686     suppress_error = 0;
14687     r = guestfs_blockdev_setrw (g, device);
14688     if (r == -1)
14689       return -1;
14690   }
14691   {
14692     int r;
14693     suppress_error = 0;
14694     r = guestfs_umount_all (g);
14695     if (r == -1)
14696       return -1;
14697   }
14698   {
14699     int r;
14700     suppress_error = 0;
14701     r = guestfs_lvm_remove_all (g);
14702     if (r == -1)
14703       return -1;
14704   }
14705   {
14706     char device[] = "/dev/sda";
14707     char lines_0[] = ",";
14708     char *lines[] = {
14709       lines_0,
14710       NULL
14711     };
14712     int r;
14713     suppress_error = 0;
14714     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14715     if (r == -1)
14716       return -1;
14717   }
14718   {
14719     char fstype[] = "ext2";
14720     char device[] = "/dev/sda1";
14721     int r;
14722     suppress_error = 0;
14723     r = guestfs_mkfs (g, fstype, device);
14724     if (r == -1)
14725       return -1;
14726   }
14727   {
14728     char device[] = "/dev/sda1";
14729     char mountpoint[] = "/";
14730     int r;
14731     suppress_error = 0;
14732     r = guestfs_mount (g, device, mountpoint);
14733     if (r == -1)
14734       return -1;
14735   }
14736   /* TestLastFail for rmdir (1) */
14737   {
14738     char path[] = "/new";
14739     int r;
14740     suppress_error = 1;
14741     r = guestfs_rmdir (g, path);
14742     if (r != -1)
14743       return -1;
14744   }
14745   return 0;
14746 }
14747
14748 static int test_rmdir_2_skip (void)
14749 {
14750   const char *str;
14751
14752   str = getenv ("TEST_ONLY");
14753   if (str)
14754     return strstr (str, "rmdir") == NULL;
14755   str = getenv ("SKIP_TEST_RMDIR_2");
14756   if (str && strcmp (str, "1") == 0) return 1;
14757   str = getenv ("SKIP_TEST_RMDIR");
14758   if (str && strcmp (str, "1") == 0) return 1;
14759   return 0;
14760 }
14761
14762 static int test_rmdir_2 (void)
14763 {
14764   if (test_rmdir_2_skip ()) {
14765     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
14766     return 0;
14767   }
14768
14769   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
14770   {
14771     char device[] = "/dev/sda";
14772     int r;
14773     suppress_error = 0;
14774     r = guestfs_blockdev_setrw (g, device);
14775     if (r == -1)
14776       return -1;
14777   }
14778   {
14779     int r;
14780     suppress_error = 0;
14781     r = guestfs_umount_all (g);
14782     if (r == -1)
14783       return -1;
14784   }
14785   {
14786     int r;
14787     suppress_error = 0;
14788     r = guestfs_lvm_remove_all (g);
14789     if (r == -1)
14790       return -1;
14791   }
14792   {
14793     char device[] = "/dev/sda";
14794     char lines_0[] = ",";
14795     char *lines[] = {
14796       lines_0,
14797       NULL
14798     };
14799     int r;
14800     suppress_error = 0;
14801     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14802     if (r == -1)
14803       return -1;
14804   }
14805   {
14806     char fstype[] = "ext2";
14807     char device[] = "/dev/sda1";
14808     int r;
14809     suppress_error = 0;
14810     r = guestfs_mkfs (g, fstype, device);
14811     if (r == -1)
14812       return -1;
14813   }
14814   {
14815     char device[] = "/dev/sda1";
14816     char mountpoint[] = "/";
14817     int r;
14818     suppress_error = 0;
14819     r = guestfs_mount (g, device, mountpoint);
14820     if (r == -1)
14821       return -1;
14822   }
14823   /* TestLastFail for rmdir (2) */
14824   {
14825     char path[] = "/new";
14826     int r;
14827     suppress_error = 0;
14828     r = guestfs_touch (g, path);
14829     if (r == -1)
14830       return -1;
14831   }
14832   {
14833     char path[] = "/new";
14834     int r;
14835     suppress_error = 1;
14836     r = guestfs_rmdir (g, path);
14837     if (r != -1)
14838       return -1;
14839   }
14840   return 0;
14841 }
14842
14843 static int test_rm_0_skip (void)
14844 {
14845   const char *str;
14846
14847   str = getenv ("TEST_ONLY");
14848   if (str)
14849     return strstr (str, "rm") == NULL;
14850   str = getenv ("SKIP_TEST_RM_0");
14851   if (str && strcmp (str, "1") == 0) return 1;
14852   str = getenv ("SKIP_TEST_RM");
14853   if (str && strcmp (str, "1") == 0) return 1;
14854   return 0;
14855 }
14856
14857 static int test_rm_0 (void)
14858 {
14859   if (test_rm_0_skip ()) {
14860     printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
14861     return 0;
14862   }
14863
14864   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
14865   {
14866     char device[] = "/dev/sda";
14867     int r;
14868     suppress_error = 0;
14869     r = guestfs_blockdev_setrw (g, device);
14870     if (r == -1)
14871       return -1;
14872   }
14873   {
14874     int r;
14875     suppress_error = 0;
14876     r = guestfs_umount_all (g);
14877     if (r == -1)
14878       return -1;
14879   }
14880   {
14881     int r;
14882     suppress_error = 0;
14883     r = guestfs_lvm_remove_all (g);
14884     if (r == -1)
14885       return -1;
14886   }
14887   {
14888     char device[] = "/dev/sda";
14889     char lines_0[] = ",";
14890     char *lines[] = {
14891       lines_0,
14892       NULL
14893     };
14894     int r;
14895     suppress_error = 0;
14896     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14897     if (r == -1)
14898       return -1;
14899   }
14900   {
14901     char fstype[] = "ext2";
14902     char device[] = "/dev/sda1";
14903     int r;
14904     suppress_error = 0;
14905     r = guestfs_mkfs (g, fstype, device);
14906     if (r == -1)
14907       return -1;
14908   }
14909   {
14910     char device[] = "/dev/sda1";
14911     char mountpoint[] = "/";
14912     int r;
14913     suppress_error = 0;
14914     r = guestfs_mount (g, device, mountpoint);
14915     if (r == -1)
14916       return -1;
14917   }
14918   /* TestRun for rm (0) */
14919   {
14920     char path[] = "/new";
14921     int r;
14922     suppress_error = 0;
14923     r = guestfs_touch (g, path);
14924     if (r == -1)
14925       return -1;
14926   }
14927   {
14928     char path[] = "/new";
14929     int r;
14930     suppress_error = 0;
14931     r = guestfs_rm (g, path);
14932     if (r == -1)
14933       return -1;
14934   }
14935   return 0;
14936 }
14937
14938 static int test_rm_1_skip (void)
14939 {
14940   const char *str;
14941
14942   str = getenv ("TEST_ONLY");
14943   if (str)
14944     return strstr (str, "rm") == NULL;
14945   str = getenv ("SKIP_TEST_RM_1");
14946   if (str && strcmp (str, "1") == 0) return 1;
14947   str = getenv ("SKIP_TEST_RM");
14948   if (str && strcmp (str, "1") == 0) return 1;
14949   return 0;
14950 }
14951
14952 static int test_rm_1 (void)
14953 {
14954   if (test_rm_1_skip ()) {
14955     printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
14956     return 0;
14957   }
14958
14959   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14960   {
14961     char device[] = "/dev/sda";
14962     int r;
14963     suppress_error = 0;
14964     r = guestfs_blockdev_setrw (g, device);
14965     if (r == -1)
14966       return -1;
14967   }
14968   {
14969     int r;
14970     suppress_error = 0;
14971     r = guestfs_umount_all (g);
14972     if (r == -1)
14973       return -1;
14974   }
14975   {
14976     int r;
14977     suppress_error = 0;
14978     r = guestfs_lvm_remove_all (g);
14979     if (r == -1)
14980       return -1;
14981   }
14982   {
14983     char device[] = "/dev/sda";
14984     char lines_0[] = ",";
14985     char *lines[] = {
14986       lines_0,
14987       NULL
14988     };
14989     int r;
14990     suppress_error = 0;
14991     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14992     if (r == -1)
14993       return -1;
14994   }
14995   {
14996     char fstype[] = "ext2";
14997     char device[] = "/dev/sda1";
14998     int r;
14999     suppress_error = 0;
15000     r = guestfs_mkfs (g, fstype, device);
15001     if (r == -1)
15002       return -1;
15003   }
15004   {
15005     char device[] = "/dev/sda1";
15006     char mountpoint[] = "/";
15007     int r;
15008     suppress_error = 0;
15009     r = guestfs_mount (g, device, mountpoint);
15010     if (r == -1)
15011       return -1;
15012   }
15013   /* TestLastFail for rm (1) */
15014   {
15015     char path[] = "/new";
15016     int r;
15017     suppress_error = 1;
15018     r = guestfs_rm (g, path);
15019     if (r != -1)
15020       return -1;
15021   }
15022   return 0;
15023 }
15024
15025 static int test_rm_2_skip (void)
15026 {
15027   const char *str;
15028
15029   str = getenv ("TEST_ONLY");
15030   if (str)
15031     return strstr (str, "rm") == NULL;
15032   str = getenv ("SKIP_TEST_RM_2");
15033   if (str && strcmp (str, "1") == 0) return 1;
15034   str = getenv ("SKIP_TEST_RM");
15035   if (str && strcmp (str, "1") == 0) return 1;
15036   return 0;
15037 }
15038
15039 static int test_rm_2 (void)
15040 {
15041   if (test_rm_2_skip ()) {
15042     printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
15043     return 0;
15044   }
15045
15046   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
15047   {
15048     char device[] = "/dev/sda";
15049     int r;
15050     suppress_error = 0;
15051     r = guestfs_blockdev_setrw (g, device);
15052     if (r == -1)
15053       return -1;
15054   }
15055   {
15056     int r;
15057     suppress_error = 0;
15058     r = guestfs_umount_all (g);
15059     if (r == -1)
15060       return -1;
15061   }
15062   {
15063     int r;
15064     suppress_error = 0;
15065     r = guestfs_lvm_remove_all (g);
15066     if (r == -1)
15067       return -1;
15068   }
15069   {
15070     char device[] = "/dev/sda";
15071     char lines_0[] = ",";
15072     char *lines[] = {
15073       lines_0,
15074       NULL
15075     };
15076     int r;
15077     suppress_error = 0;
15078     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15079     if (r == -1)
15080       return -1;
15081   }
15082   {
15083     char fstype[] = "ext2";
15084     char device[] = "/dev/sda1";
15085     int r;
15086     suppress_error = 0;
15087     r = guestfs_mkfs (g, fstype, device);
15088     if (r == -1)
15089       return -1;
15090   }
15091   {
15092     char device[] = "/dev/sda1";
15093     char mountpoint[] = "/";
15094     int r;
15095     suppress_error = 0;
15096     r = guestfs_mount (g, device, mountpoint);
15097     if (r == -1)
15098       return -1;
15099   }
15100   /* TestLastFail for rm (2) */
15101   {
15102     char path[] = "/new";
15103     int r;
15104     suppress_error = 0;
15105     r = guestfs_mkdir (g, path);
15106     if (r == -1)
15107       return -1;
15108   }
15109   {
15110     char path[] = "/new";
15111     int r;
15112     suppress_error = 1;
15113     r = guestfs_rm (g, path);
15114     if (r != -1)
15115       return -1;
15116   }
15117   return 0;
15118 }
15119
15120 static int test_read_lines_0_skip (void)
15121 {
15122   const char *str;
15123
15124   str = getenv ("TEST_ONLY");
15125   if (str)
15126     return strstr (str, "read_lines") == NULL;
15127   str = getenv ("SKIP_TEST_READ_LINES_0");
15128   if (str && strcmp (str, "1") == 0) return 1;
15129   str = getenv ("SKIP_TEST_READ_LINES");
15130   if (str && strcmp (str, "1") == 0) return 1;
15131   return 0;
15132 }
15133
15134 static int test_read_lines_0 (void)
15135 {
15136   if (test_read_lines_0_skip ()) {
15137     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
15138     return 0;
15139   }
15140
15141   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
15142   {
15143     char device[] = "/dev/sda";
15144     int r;
15145     suppress_error = 0;
15146     r = guestfs_blockdev_setrw (g, device);
15147     if (r == -1)
15148       return -1;
15149   }
15150   {
15151     int r;
15152     suppress_error = 0;
15153     r = guestfs_umount_all (g);
15154     if (r == -1)
15155       return -1;
15156   }
15157   {
15158     int r;
15159     suppress_error = 0;
15160     r = guestfs_lvm_remove_all (g);
15161     if (r == -1)
15162       return -1;
15163   }
15164   {
15165     char device[] = "/dev/sda";
15166     char lines_0[] = ",";
15167     char *lines[] = {
15168       lines_0,
15169       NULL
15170     };
15171     int r;
15172     suppress_error = 0;
15173     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15174     if (r == -1)
15175       return -1;
15176   }
15177   {
15178     char fstype[] = "ext2";
15179     char device[] = "/dev/sda1";
15180     int r;
15181     suppress_error = 0;
15182     r = guestfs_mkfs (g, fstype, device);
15183     if (r == -1)
15184       return -1;
15185   }
15186   {
15187     char device[] = "/dev/sda1";
15188     char mountpoint[] = "/";
15189     int r;
15190     suppress_error = 0;
15191     r = guestfs_mount (g, device, mountpoint);
15192     if (r == -1)
15193       return -1;
15194   }
15195   /* TestOutputList for read_lines (0) */
15196   {
15197     char path[] = "/new";
15198     char content[] = "line1\r\nline2\nline3";
15199     int r;
15200     suppress_error = 0;
15201     r = guestfs_write_file (g, path, content, 0);
15202     if (r == -1)
15203       return -1;
15204   }
15205   {
15206     char path[] = "/new";
15207     char **r;
15208     int i;
15209     suppress_error = 0;
15210     r = guestfs_read_lines (g, path);
15211     if (r == NULL)
15212       return -1;
15213     if (!r[0]) {
15214       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
15215       print_strings (r);
15216       return -1;
15217     }
15218     {
15219       char expected[] = "line1";
15220       if (strcmp (r[0], expected) != 0) {
15221         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15222         return -1;
15223       }
15224     }
15225     if (!r[1]) {
15226       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
15227       print_strings (r);
15228       return -1;
15229     }
15230     {
15231       char expected[] = "line2";
15232       if (strcmp (r[1], expected) != 0) {
15233         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15234         return -1;
15235       }
15236     }
15237     if (!r[2]) {
15238       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
15239       print_strings (r);
15240       return -1;
15241     }
15242     {
15243       char expected[] = "line3";
15244       if (strcmp (r[2], expected) != 0) {
15245         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15246         return -1;
15247       }
15248     }
15249     if (r[3] != NULL) {
15250       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
15251       print_strings (r);
15252       return -1;
15253     }
15254     for (i = 0; r[i] != NULL; ++i)
15255       free (r[i]);
15256     free (r);
15257   }
15258   return 0;
15259 }
15260
15261 static int test_read_lines_1_skip (void)
15262 {
15263   const char *str;
15264
15265   str = getenv ("TEST_ONLY");
15266   if (str)
15267     return strstr (str, "read_lines") == NULL;
15268   str = getenv ("SKIP_TEST_READ_LINES_1");
15269   if (str && strcmp (str, "1") == 0) return 1;
15270   str = getenv ("SKIP_TEST_READ_LINES");
15271   if (str && strcmp (str, "1") == 0) return 1;
15272   return 0;
15273 }
15274
15275 static int test_read_lines_1 (void)
15276 {
15277   if (test_read_lines_1_skip ()) {
15278     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
15279     return 0;
15280   }
15281
15282   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
15283   {
15284     char device[] = "/dev/sda";
15285     int r;
15286     suppress_error = 0;
15287     r = guestfs_blockdev_setrw (g, device);
15288     if (r == -1)
15289       return -1;
15290   }
15291   {
15292     int r;
15293     suppress_error = 0;
15294     r = guestfs_umount_all (g);
15295     if (r == -1)
15296       return -1;
15297   }
15298   {
15299     int r;
15300     suppress_error = 0;
15301     r = guestfs_lvm_remove_all (g);
15302     if (r == -1)
15303       return -1;
15304   }
15305   {
15306     char device[] = "/dev/sda";
15307     char lines_0[] = ",";
15308     char *lines[] = {
15309       lines_0,
15310       NULL
15311     };
15312     int r;
15313     suppress_error = 0;
15314     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15315     if (r == -1)
15316       return -1;
15317   }
15318   {
15319     char fstype[] = "ext2";
15320     char device[] = "/dev/sda1";
15321     int r;
15322     suppress_error = 0;
15323     r = guestfs_mkfs (g, fstype, device);
15324     if (r == -1)
15325       return -1;
15326   }
15327   {
15328     char device[] = "/dev/sda1";
15329     char mountpoint[] = "/";
15330     int r;
15331     suppress_error = 0;
15332     r = guestfs_mount (g, device, mountpoint);
15333     if (r == -1)
15334       return -1;
15335   }
15336   /* TestOutputList for read_lines (1) */
15337   {
15338     char path[] = "/new";
15339     char content[] = "";
15340     int r;
15341     suppress_error = 0;
15342     r = guestfs_write_file (g, path, content, 0);
15343     if (r == -1)
15344       return -1;
15345   }
15346   {
15347     char path[] = "/new";
15348     char **r;
15349     int i;
15350     suppress_error = 0;
15351     r = guestfs_read_lines (g, path);
15352     if (r == NULL)
15353       return -1;
15354     if (r[0] != NULL) {
15355       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
15356       print_strings (r);
15357       return -1;
15358     }
15359     for (i = 0; r[i] != NULL; ++i)
15360       free (r[i]);
15361     free (r);
15362   }
15363   return 0;
15364 }
15365
15366 static int test_lvs_0_skip (void)
15367 {
15368   const char *str;
15369
15370   str = getenv ("TEST_ONLY");
15371   if (str)
15372     return strstr (str, "lvs") == NULL;
15373   str = getenv ("SKIP_TEST_LVS_0");
15374   if (str && strcmp (str, "1") == 0) return 1;
15375   str = getenv ("SKIP_TEST_LVS");
15376   if (str && strcmp (str, "1") == 0) return 1;
15377   return 0;
15378 }
15379
15380 static int test_lvs_0 (void)
15381 {
15382   if (test_lvs_0_skip ()) {
15383     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
15384     return 0;
15385   }
15386
15387   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
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 device[] = "/dev/sda1";
15425     int r;
15426     suppress_error = 0;
15427     r = guestfs_pvcreate (g, device);
15428     if (r == -1)
15429       return -1;
15430   }
15431   {
15432     char volgroup[] = "VG";
15433     char physvols_0[] = "/dev/sda1";
15434     char *physvols[] = {
15435       physvols_0,
15436       NULL
15437     };
15438     int r;
15439     suppress_error = 0;
15440     r = guestfs_vgcreate (g, volgroup, physvols);
15441     if (r == -1)
15442       return -1;
15443   }
15444   {
15445     char logvol[] = "LV";
15446     char volgroup[] = "VG";
15447     int r;
15448     suppress_error = 0;
15449     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15450     if (r == -1)
15451       return -1;
15452   }
15453   {
15454     char fstype[] = "ext2";
15455     char device[] = "/dev/VG/LV";
15456     int r;
15457     suppress_error = 0;
15458     r = guestfs_mkfs (g, fstype, device);
15459     if (r == -1)
15460       return -1;
15461   }
15462   {
15463     char device[] = "/dev/VG/LV";
15464     char mountpoint[] = "/";
15465     int r;
15466     suppress_error = 0;
15467     r = guestfs_mount (g, device, mountpoint);
15468     if (r == -1)
15469       return -1;
15470   }
15471   /* TestOutputList for lvs (0) */
15472   {
15473     char **r;
15474     int i;
15475     suppress_error = 0;
15476     r = guestfs_lvs (g);
15477     if (r == NULL)
15478       return -1;
15479     if (!r[0]) {
15480       fprintf (stderr, "test_lvs_0: short list returned from command\n");
15481       print_strings (r);
15482       return -1;
15483     }
15484     {
15485       char expected[] = "/dev/VG/LV";
15486       if (strcmp (r[0], expected) != 0) {
15487         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15488         return -1;
15489       }
15490     }
15491     if (r[1] != NULL) {
15492       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
15493       print_strings (r);
15494       return -1;
15495     }
15496     for (i = 0; r[i] != NULL; ++i)
15497       free (r[i]);
15498     free (r);
15499   }
15500   return 0;
15501 }
15502
15503 static int test_lvs_1_skip (void)
15504 {
15505   const char *str;
15506
15507   str = getenv ("TEST_ONLY");
15508   if (str)
15509     return strstr (str, "lvs") == NULL;
15510   str = getenv ("SKIP_TEST_LVS_1");
15511   if (str && strcmp (str, "1") == 0) return 1;
15512   str = getenv ("SKIP_TEST_LVS");
15513   if (str && strcmp (str, "1") == 0) return 1;
15514   return 0;
15515 }
15516
15517 static int test_lvs_1 (void)
15518 {
15519   if (test_lvs_1_skip ()) {
15520     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
15521     return 0;
15522   }
15523
15524   /* InitNone|InitEmpty for test_lvs_1 */
15525   {
15526     char device[] = "/dev/sda";
15527     int r;
15528     suppress_error = 0;
15529     r = guestfs_blockdev_setrw (g, device);
15530     if (r == -1)
15531       return -1;
15532   }
15533   {
15534     int r;
15535     suppress_error = 0;
15536     r = guestfs_umount_all (g);
15537     if (r == -1)
15538       return -1;
15539   }
15540   {
15541     int r;
15542     suppress_error = 0;
15543     r = guestfs_lvm_remove_all (g);
15544     if (r == -1)
15545       return -1;
15546   }
15547   /* TestOutputList for lvs (1) */
15548   {
15549     char device[] = "/dev/sda";
15550     char lines_0[] = ",10";
15551     char lines_1[] = ",20";
15552     char lines_2[] = ",";
15553     char *lines[] = {
15554       lines_0,
15555       lines_1,
15556       lines_2,
15557       NULL
15558     };
15559     int r;
15560     suppress_error = 0;
15561     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15562     if (r == -1)
15563       return -1;
15564   }
15565   {
15566     char device[] = "/dev/sda1";
15567     int r;
15568     suppress_error = 0;
15569     r = guestfs_pvcreate (g, device);
15570     if (r == -1)
15571       return -1;
15572   }
15573   {
15574     char device[] = "/dev/sda2";
15575     int r;
15576     suppress_error = 0;
15577     r = guestfs_pvcreate (g, device);
15578     if (r == -1)
15579       return -1;
15580   }
15581   {
15582     char device[] = "/dev/sda3";
15583     int r;
15584     suppress_error = 0;
15585     r = guestfs_pvcreate (g, device);
15586     if (r == -1)
15587       return -1;
15588   }
15589   {
15590     char volgroup[] = "VG1";
15591     char physvols_0[] = "/dev/sda1";
15592     char physvols_1[] = "/dev/sda2";
15593     char *physvols[] = {
15594       physvols_0,
15595       physvols_1,
15596       NULL
15597     };
15598     int r;
15599     suppress_error = 0;
15600     r = guestfs_vgcreate (g, volgroup, physvols);
15601     if (r == -1)
15602       return -1;
15603   }
15604   {
15605     char volgroup[] = "VG2";
15606     char physvols_0[] = "/dev/sda3";
15607     char *physvols[] = {
15608       physvols_0,
15609       NULL
15610     };
15611     int r;
15612     suppress_error = 0;
15613     r = guestfs_vgcreate (g, volgroup, physvols);
15614     if (r == -1)
15615       return -1;
15616   }
15617   {
15618     char logvol[] = "LV1";
15619     char volgroup[] = "VG1";
15620     int r;
15621     suppress_error = 0;
15622     r = guestfs_lvcreate (g, logvol, volgroup, 50);
15623     if (r == -1)
15624       return -1;
15625   }
15626   {
15627     char logvol[] = "LV2";
15628     char volgroup[] = "VG1";
15629     int r;
15630     suppress_error = 0;
15631     r = guestfs_lvcreate (g, logvol, volgroup, 50);
15632     if (r == -1)
15633       return -1;
15634   }
15635   {
15636     char logvol[] = "LV3";
15637     char volgroup[] = "VG2";
15638     int r;
15639     suppress_error = 0;
15640     r = guestfs_lvcreate (g, logvol, volgroup, 50);
15641     if (r == -1)
15642       return -1;
15643   }
15644   {
15645     char **r;
15646     int i;
15647     suppress_error = 0;
15648     r = guestfs_lvs (g);
15649     if (r == NULL)
15650       return -1;
15651     if (!r[0]) {
15652       fprintf (stderr, "test_lvs_1: short list returned from command\n");
15653       print_strings (r);
15654       return -1;
15655     }
15656     {
15657       char expected[] = "/dev/VG1/LV1";
15658       if (strcmp (r[0], expected) != 0) {
15659         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15660         return -1;
15661       }
15662     }
15663     if (!r[1]) {
15664       fprintf (stderr, "test_lvs_1: short list returned from command\n");
15665       print_strings (r);
15666       return -1;
15667     }
15668     {
15669       char expected[] = "/dev/VG1/LV2";
15670       if (strcmp (r[1], expected) != 0) {
15671         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15672         return -1;
15673       }
15674     }
15675     if (!r[2]) {
15676       fprintf (stderr, "test_lvs_1: short list returned from command\n");
15677       print_strings (r);
15678       return -1;
15679     }
15680     {
15681       char expected[] = "/dev/VG2/LV3";
15682       if (strcmp (r[2], expected) != 0) {
15683         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15684         return -1;
15685       }
15686     }
15687     if (r[3] != NULL) {
15688       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
15689       print_strings (r);
15690       return -1;
15691     }
15692     for (i = 0; r[i] != NULL; ++i)
15693       free (r[i]);
15694     free (r);
15695   }
15696   return 0;
15697 }
15698
15699 static int test_vgs_0_skip (void)
15700 {
15701   const char *str;
15702
15703   str = getenv ("TEST_ONLY");
15704   if (str)
15705     return strstr (str, "vgs") == NULL;
15706   str = getenv ("SKIP_TEST_VGS_0");
15707   if (str && strcmp (str, "1") == 0) return 1;
15708   str = getenv ("SKIP_TEST_VGS");
15709   if (str && strcmp (str, "1") == 0) return 1;
15710   return 0;
15711 }
15712
15713 static int test_vgs_0 (void)
15714 {
15715   if (test_vgs_0_skip ()) {
15716     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
15717     return 0;
15718   }
15719
15720   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
15721   {
15722     char device[] = "/dev/sda";
15723     int r;
15724     suppress_error = 0;
15725     r = guestfs_blockdev_setrw (g, device);
15726     if (r == -1)
15727       return -1;
15728   }
15729   {
15730     int r;
15731     suppress_error = 0;
15732     r = guestfs_umount_all (g);
15733     if (r == -1)
15734       return -1;
15735   }
15736   {
15737     int r;
15738     suppress_error = 0;
15739     r = guestfs_lvm_remove_all (g);
15740     if (r == -1)
15741       return -1;
15742   }
15743   {
15744     char device[] = "/dev/sda";
15745     char lines_0[] = ",";
15746     char *lines[] = {
15747       lines_0,
15748       NULL
15749     };
15750     int r;
15751     suppress_error = 0;
15752     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15753     if (r == -1)
15754       return -1;
15755   }
15756   {
15757     char device[] = "/dev/sda1";
15758     int r;
15759     suppress_error = 0;
15760     r = guestfs_pvcreate (g, device);
15761     if (r == -1)
15762       return -1;
15763   }
15764   {
15765     char volgroup[] = "VG";
15766     char physvols_0[] = "/dev/sda1";
15767     char *physvols[] = {
15768       physvols_0,
15769       NULL
15770     };
15771     int r;
15772     suppress_error = 0;
15773     r = guestfs_vgcreate (g, volgroup, physvols);
15774     if (r == -1)
15775       return -1;
15776   }
15777   {
15778     char logvol[] = "LV";
15779     char volgroup[] = "VG";
15780     int r;
15781     suppress_error = 0;
15782     r = guestfs_lvcreate (g, logvol, volgroup, 8);
15783     if (r == -1)
15784       return -1;
15785   }
15786   {
15787     char fstype[] = "ext2";
15788     char device[] = "/dev/VG/LV";
15789     int r;
15790     suppress_error = 0;
15791     r = guestfs_mkfs (g, fstype, device);
15792     if (r == -1)
15793       return -1;
15794   }
15795   {
15796     char device[] = "/dev/VG/LV";
15797     char mountpoint[] = "/";
15798     int r;
15799     suppress_error = 0;
15800     r = guestfs_mount (g, device, mountpoint);
15801     if (r == -1)
15802       return -1;
15803   }
15804   /* TestOutputList for vgs (0) */
15805   {
15806     char **r;
15807     int i;
15808     suppress_error = 0;
15809     r = guestfs_vgs (g);
15810     if (r == NULL)
15811       return -1;
15812     if (!r[0]) {
15813       fprintf (stderr, "test_vgs_0: short list returned from command\n");
15814       print_strings (r);
15815       return -1;
15816     }
15817     {
15818       char expected[] = "VG";
15819       if (strcmp (r[0], expected) != 0) {
15820         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15821         return -1;
15822       }
15823     }
15824     if (r[1] != NULL) {
15825       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
15826       print_strings (r);
15827       return -1;
15828     }
15829     for (i = 0; r[i] != NULL; ++i)
15830       free (r[i]);
15831     free (r);
15832   }
15833   return 0;
15834 }
15835
15836 static int test_vgs_1_skip (void)
15837 {
15838   const char *str;
15839
15840   str = getenv ("TEST_ONLY");
15841   if (str)
15842     return strstr (str, "vgs") == NULL;
15843   str = getenv ("SKIP_TEST_VGS_1");
15844   if (str && strcmp (str, "1") == 0) return 1;
15845   str = getenv ("SKIP_TEST_VGS");
15846   if (str && strcmp (str, "1") == 0) return 1;
15847   return 0;
15848 }
15849
15850 static int test_vgs_1 (void)
15851 {
15852   if (test_vgs_1_skip ()) {
15853     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
15854     return 0;
15855   }
15856
15857   /* InitNone|InitEmpty for test_vgs_1 */
15858   {
15859     char device[] = "/dev/sda";
15860     int r;
15861     suppress_error = 0;
15862     r = guestfs_blockdev_setrw (g, device);
15863     if (r == -1)
15864       return -1;
15865   }
15866   {
15867     int r;
15868     suppress_error = 0;
15869     r = guestfs_umount_all (g);
15870     if (r == -1)
15871       return -1;
15872   }
15873   {
15874     int r;
15875     suppress_error = 0;
15876     r = guestfs_lvm_remove_all (g);
15877     if (r == -1)
15878       return -1;
15879   }
15880   /* TestOutputList for vgs (1) */
15881   {
15882     char device[] = "/dev/sda";
15883     char lines_0[] = ",10";
15884     char lines_1[] = ",20";
15885     char lines_2[] = ",";
15886     char *lines[] = {
15887       lines_0,
15888       lines_1,
15889       lines_2,
15890       NULL
15891     };
15892     int r;
15893     suppress_error = 0;
15894     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15895     if (r == -1)
15896       return -1;
15897   }
15898   {
15899     char device[] = "/dev/sda1";
15900     int r;
15901     suppress_error = 0;
15902     r = guestfs_pvcreate (g, device);
15903     if (r == -1)
15904       return -1;
15905   }
15906   {
15907     char device[] = "/dev/sda2";
15908     int r;
15909     suppress_error = 0;
15910     r = guestfs_pvcreate (g, device);
15911     if (r == -1)
15912       return -1;
15913   }
15914   {
15915     char device[] = "/dev/sda3";
15916     int r;
15917     suppress_error = 0;
15918     r = guestfs_pvcreate (g, device);
15919     if (r == -1)
15920       return -1;
15921   }
15922   {
15923     char volgroup[] = "VG1";
15924     char physvols_0[] = "/dev/sda1";
15925     char physvols_1[] = "/dev/sda2";
15926     char *physvols[] = {
15927       physvols_0,
15928       physvols_1,
15929       NULL
15930     };
15931     int r;
15932     suppress_error = 0;
15933     r = guestfs_vgcreate (g, volgroup, physvols);
15934     if (r == -1)
15935       return -1;
15936   }
15937   {
15938     char volgroup[] = "VG2";
15939     char physvols_0[] = "/dev/sda3";
15940     char *physvols[] = {
15941       physvols_0,
15942       NULL
15943     };
15944     int r;
15945     suppress_error = 0;
15946     r = guestfs_vgcreate (g, volgroup, physvols);
15947     if (r == -1)
15948       return -1;
15949   }
15950   {
15951     char **r;
15952     int i;
15953     suppress_error = 0;
15954     r = guestfs_vgs (g);
15955     if (r == NULL)
15956       return -1;
15957     if (!r[0]) {
15958       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15959       print_strings (r);
15960       return -1;
15961     }
15962     {
15963       char expected[] = "VG1";
15964       if (strcmp (r[0], expected) != 0) {
15965         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15966         return -1;
15967       }
15968     }
15969     if (!r[1]) {
15970       fprintf (stderr, "test_vgs_1: short list returned from command\n");
15971       print_strings (r);
15972       return -1;
15973     }
15974     {
15975       char expected[] = "VG2";
15976       if (strcmp (r[1], expected) != 0) {
15977         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15978         return -1;
15979       }
15980     }
15981     if (r[2] != NULL) {
15982       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15983       print_strings (r);
15984       return -1;
15985     }
15986     for (i = 0; r[i] != NULL; ++i)
15987       free (r[i]);
15988     free (r);
15989   }
15990   return 0;
15991 }
15992
15993 static int test_pvs_0_skip (void)
15994 {
15995   const char *str;
15996
15997   str = getenv ("TEST_ONLY");
15998   if (str)
15999     return strstr (str, "pvs") == NULL;
16000   str = getenv ("SKIP_TEST_PVS_0");
16001   if (str && strcmp (str, "1") == 0) return 1;
16002   str = getenv ("SKIP_TEST_PVS");
16003   if (str && strcmp (str, "1") == 0) return 1;
16004   return 0;
16005 }
16006
16007 static int test_pvs_0 (void)
16008 {
16009   if (test_pvs_0_skip ()) {
16010     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
16011     return 0;
16012   }
16013
16014   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
16015   {
16016     char device[] = "/dev/sda";
16017     int r;
16018     suppress_error = 0;
16019     r = guestfs_blockdev_setrw (g, device);
16020     if (r == -1)
16021       return -1;
16022   }
16023   {
16024     int r;
16025     suppress_error = 0;
16026     r = guestfs_umount_all (g);
16027     if (r == -1)
16028       return -1;
16029   }
16030   {
16031     int r;
16032     suppress_error = 0;
16033     r = guestfs_lvm_remove_all (g);
16034     if (r == -1)
16035       return -1;
16036   }
16037   {
16038     char device[] = "/dev/sda";
16039     char lines_0[] = ",";
16040     char *lines[] = {
16041       lines_0,
16042       NULL
16043     };
16044     int r;
16045     suppress_error = 0;
16046     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16047     if (r == -1)
16048       return -1;
16049   }
16050   {
16051     char device[] = "/dev/sda1";
16052     int r;
16053     suppress_error = 0;
16054     r = guestfs_pvcreate (g, device);
16055     if (r == -1)
16056       return -1;
16057   }
16058   {
16059     char volgroup[] = "VG";
16060     char physvols_0[] = "/dev/sda1";
16061     char *physvols[] = {
16062       physvols_0,
16063       NULL
16064     };
16065     int r;
16066     suppress_error = 0;
16067     r = guestfs_vgcreate (g, volgroup, physvols);
16068     if (r == -1)
16069       return -1;
16070   }
16071   {
16072     char logvol[] = "LV";
16073     char volgroup[] = "VG";
16074     int r;
16075     suppress_error = 0;
16076     r = guestfs_lvcreate (g, logvol, volgroup, 8);
16077     if (r == -1)
16078       return -1;
16079   }
16080   {
16081     char fstype[] = "ext2";
16082     char device[] = "/dev/VG/LV";
16083     int r;
16084     suppress_error = 0;
16085     r = guestfs_mkfs (g, fstype, device);
16086     if (r == -1)
16087       return -1;
16088   }
16089   {
16090     char device[] = "/dev/VG/LV";
16091     char mountpoint[] = "/";
16092     int r;
16093     suppress_error = 0;
16094     r = guestfs_mount (g, device, mountpoint);
16095     if (r == -1)
16096       return -1;
16097   }
16098   /* TestOutputListOfDevices for pvs (0) */
16099   {
16100     char **r;
16101     int i;
16102     suppress_error = 0;
16103     r = guestfs_pvs (g);
16104     if (r == NULL)
16105       return -1;
16106     if (!r[0]) {
16107       fprintf (stderr, "test_pvs_0: short list returned from command\n");
16108       print_strings (r);
16109       return -1;
16110     }
16111     {
16112       char expected[] = "/dev/sda1";
16113       r[0][5] = 's';
16114       if (strcmp (r[0], expected) != 0) {
16115         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16116         return -1;
16117       }
16118     }
16119     if (r[1] != NULL) {
16120       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
16121       print_strings (r);
16122       return -1;
16123     }
16124     for (i = 0; r[i] != NULL; ++i)
16125       free (r[i]);
16126     free (r);
16127   }
16128   return 0;
16129 }
16130
16131 static int test_pvs_1_skip (void)
16132 {
16133   const char *str;
16134
16135   str = getenv ("TEST_ONLY");
16136   if (str)
16137     return strstr (str, "pvs") == NULL;
16138   str = getenv ("SKIP_TEST_PVS_1");
16139   if (str && strcmp (str, "1") == 0) return 1;
16140   str = getenv ("SKIP_TEST_PVS");
16141   if (str && strcmp (str, "1") == 0) return 1;
16142   return 0;
16143 }
16144
16145 static int test_pvs_1 (void)
16146 {
16147   if (test_pvs_1_skip ()) {
16148     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
16149     return 0;
16150   }
16151
16152   /* InitNone|InitEmpty for test_pvs_1 */
16153   {
16154     char device[] = "/dev/sda";
16155     int r;
16156     suppress_error = 0;
16157     r = guestfs_blockdev_setrw (g, device);
16158     if (r == -1)
16159       return -1;
16160   }
16161   {
16162     int r;
16163     suppress_error = 0;
16164     r = guestfs_umount_all (g);
16165     if (r == -1)
16166       return -1;
16167   }
16168   {
16169     int r;
16170     suppress_error = 0;
16171     r = guestfs_lvm_remove_all (g);
16172     if (r == -1)
16173       return -1;
16174   }
16175   /* TestOutputListOfDevices for pvs (1) */
16176   {
16177     char device[] = "/dev/sda";
16178     char lines_0[] = ",10";
16179     char lines_1[] = ",20";
16180     char lines_2[] = ",";
16181     char *lines[] = {
16182       lines_0,
16183       lines_1,
16184       lines_2,
16185       NULL
16186     };
16187     int r;
16188     suppress_error = 0;
16189     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16190     if (r == -1)
16191       return -1;
16192   }
16193   {
16194     char device[] = "/dev/sda1";
16195     int r;
16196     suppress_error = 0;
16197     r = guestfs_pvcreate (g, device);
16198     if (r == -1)
16199       return -1;
16200   }
16201   {
16202     char device[] = "/dev/sda2";
16203     int r;
16204     suppress_error = 0;
16205     r = guestfs_pvcreate (g, device);
16206     if (r == -1)
16207       return -1;
16208   }
16209   {
16210     char device[] = "/dev/sda3";
16211     int r;
16212     suppress_error = 0;
16213     r = guestfs_pvcreate (g, device);
16214     if (r == -1)
16215       return -1;
16216   }
16217   {
16218     char **r;
16219     int i;
16220     suppress_error = 0;
16221     r = guestfs_pvs (g);
16222     if (r == NULL)
16223       return -1;
16224     if (!r[0]) {
16225       fprintf (stderr, "test_pvs_1: short list returned from command\n");
16226       print_strings (r);
16227       return -1;
16228     }
16229     {
16230       char expected[] = "/dev/sda1";
16231       r[0][5] = 's';
16232       if (strcmp (r[0], expected) != 0) {
16233         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16234         return -1;
16235       }
16236     }
16237     if (!r[1]) {
16238       fprintf (stderr, "test_pvs_1: short list returned from command\n");
16239       print_strings (r);
16240       return -1;
16241     }
16242     {
16243       char expected[] = "/dev/sda2";
16244       r[1][5] = 's';
16245       if (strcmp (r[1], expected) != 0) {
16246         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16247         return -1;
16248       }
16249     }
16250     if (!r[2]) {
16251       fprintf (stderr, "test_pvs_1: short list returned from command\n");
16252       print_strings (r);
16253       return -1;
16254     }
16255     {
16256       char expected[] = "/dev/sda3";
16257       r[2][5] = 's';
16258       if (strcmp (r[2], expected) != 0) {
16259         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16260         return -1;
16261       }
16262     }
16263     if (r[3] != NULL) {
16264       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
16265       print_strings (r);
16266       return -1;
16267     }
16268     for (i = 0; r[i] != NULL; ++i)
16269       free (r[i]);
16270     free (r);
16271   }
16272   return 0;
16273 }
16274
16275 static int test_list_partitions_0_skip (void)
16276 {
16277   const char *str;
16278
16279   str = getenv ("TEST_ONLY");
16280   if (str)
16281     return strstr (str, "list_partitions") == NULL;
16282   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
16283   if (str && strcmp (str, "1") == 0) return 1;
16284   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
16285   if (str && strcmp (str, "1") == 0) return 1;
16286   return 0;
16287 }
16288
16289 static int test_list_partitions_0 (void)
16290 {
16291   if (test_list_partitions_0_skip ()) {
16292     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
16293     return 0;
16294   }
16295
16296   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
16297   {
16298     char device[] = "/dev/sda";
16299     int r;
16300     suppress_error = 0;
16301     r = guestfs_blockdev_setrw (g, device);
16302     if (r == -1)
16303       return -1;
16304   }
16305   {
16306     int r;
16307     suppress_error = 0;
16308     r = guestfs_umount_all (g);
16309     if (r == -1)
16310       return -1;
16311   }
16312   {
16313     int r;
16314     suppress_error = 0;
16315     r = guestfs_lvm_remove_all (g);
16316     if (r == -1)
16317       return -1;
16318   }
16319   {
16320     char device[] = "/dev/sda";
16321     char lines_0[] = ",";
16322     char *lines[] = {
16323       lines_0,
16324       NULL
16325     };
16326     int r;
16327     suppress_error = 0;
16328     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16329     if (r == -1)
16330       return -1;
16331   }
16332   {
16333     char fstype[] = "ext2";
16334     char device[] = "/dev/sda1";
16335     int r;
16336     suppress_error = 0;
16337     r = guestfs_mkfs (g, fstype, device);
16338     if (r == -1)
16339       return -1;
16340   }
16341   {
16342     char device[] = "/dev/sda1";
16343     char mountpoint[] = "/";
16344     int r;
16345     suppress_error = 0;
16346     r = guestfs_mount (g, device, mountpoint);
16347     if (r == -1)
16348       return -1;
16349   }
16350   /* TestOutputListOfDevices for list_partitions (0) */
16351   {
16352     char **r;
16353     int i;
16354     suppress_error = 0;
16355     r = guestfs_list_partitions (g);
16356     if (r == NULL)
16357       return -1;
16358     if (!r[0]) {
16359       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
16360       print_strings (r);
16361       return -1;
16362     }
16363     {
16364       char expected[] = "/dev/sda1";
16365       r[0][5] = 's';
16366       if (strcmp (r[0], expected) != 0) {
16367         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16368         return -1;
16369       }
16370     }
16371     if (r[1] != NULL) {
16372       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
16373       print_strings (r);
16374       return -1;
16375     }
16376     for (i = 0; r[i] != NULL; ++i)
16377       free (r[i]);
16378     free (r);
16379   }
16380   return 0;
16381 }
16382
16383 static int test_list_partitions_1_skip (void)
16384 {
16385   const char *str;
16386
16387   str = getenv ("TEST_ONLY");
16388   if (str)
16389     return strstr (str, "list_partitions") == NULL;
16390   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
16391   if (str && strcmp (str, "1") == 0) return 1;
16392   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
16393   if (str && strcmp (str, "1") == 0) return 1;
16394   return 0;
16395 }
16396
16397 static int test_list_partitions_1 (void)
16398 {
16399   if (test_list_partitions_1_skip ()) {
16400     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
16401     return 0;
16402   }
16403
16404   /* InitNone|InitEmpty for test_list_partitions_1 */
16405   {
16406     char device[] = "/dev/sda";
16407     int r;
16408     suppress_error = 0;
16409     r = guestfs_blockdev_setrw (g, device);
16410     if (r == -1)
16411       return -1;
16412   }
16413   {
16414     int r;
16415     suppress_error = 0;
16416     r = guestfs_umount_all (g);
16417     if (r == -1)
16418       return -1;
16419   }
16420   {
16421     int r;
16422     suppress_error = 0;
16423     r = guestfs_lvm_remove_all (g);
16424     if (r == -1)
16425       return -1;
16426   }
16427   /* TestOutputListOfDevices for list_partitions (1) */
16428   {
16429     char device[] = "/dev/sda";
16430     char lines_0[] = ",10";
16431     char lines_1[] = ",20";
16432     char lines_2[] = ",";
16433     char *lines[] = {
16434       lines_0,
16435       lines_1,
16436       lines_2,
16437       NULL
16438     };
16439     int r;
16440     suppress_error = 0;
16441     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16442     if (r == -1)
16443       return -1;
16444   }
16445   {
16446     char **r;
16447     int i;
16448     suppress_error = 0;
16449     r = guestfs_list_partitions (g);
16450     if (r == NULL)
16451       return -1;
16452     if (!r[0]) {
16453       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
16454       print_strings (r);
16455       return -1;
16456     }
16457     {
16458       char expected[] = "/dev/sda1";
16459       r[0][5] = 's';
16460       if (strcmp (r[0], expected) != 0) {
16461         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16462         return -1;
16463       }
16464     }
16465     if (!r[1]) {
16466       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
16467       print_strings (r);
16468       return -1;
16469     }
16470     {
16471       char expected[] = "/dev/sda2";
16472       r[1][5] = 's';
16473       if (strcmp (r[1], expected) != 0) {
16474         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16475         return -1;
16476       }
16477     }
16478     if (!r[2]) {
16479       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
16480       print_strings (r);
16481       return -1;
16482     }
16483     {
16484       char expected[] = "/dev/sda3";
16485       r[2][5] = 's';
16486       if (strcmp (r[2], expected) != 0) {
16487         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16488         return -1;
16489       }
16490     }
16491     if (r[3] != NULL) {
16492       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
16493       print_strings (r);
16494       return -1;
16495     }
16496     for (i = 0; r[i] != NULL; ++i)
16497       free (r[i]);
16498     free (r);
16499   }
16500   return 0;
16501 }
16502
16503 static int test_list_devices_0_skip (void)
16504 {
16505   const char *str;
16506
16507   str = getenv ("TEST_ONLY");
16508   if (str)
16509     return strstr (str, "list_devices") == NULL;
16510   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
16511   if (str && strcmp (str, "1") == 0) return 1;
16512   str = getenv ("SKIP_TEST_LIST_DEVICES");
16513   if (str && strcmp (str, "1") == 0) return 1;
16514   return 0;
16515 }
16516
16517 static int test_list_devices_0 (void)
16518 {
16519   if (test_list_devices_0_skip ()) {
16520     printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
16521     return 0;
16522   }
16523
16524   /* InitNone|InitEmpty for test_list_devices_0 */
16525   {
16526     char device[] = "/dev/sda";
16527     int r;
16528     suppress_error = 0;
16529     r = guestfs_blockdev_setrw (g, device);
16530     if (r == -1)
16531       return -1;
16532   }
16533   {
16534     int r;
16535     suppress_error = 0;
16536     r = guestfs_umount_all (g);
16537     if (r == -1)
16538       return -1;
16539   }
16540   {
16541     int r;
16542     suppress_error = 0;
16543     r = guestfs_lvm_remove_all (g);
16544     if (r == -1)
16545       return -1;
16546   }
16547   /* TestOutputListOfDevices for list_devices (0) */
16548   {
16549     char **r;
16550     int i;
16551     suppress_error = 0;
16552     r = guestfs_list_devices (g);
16553     if (r == NULL)
16554       return -1;
16555     if (!r[0]) {
16556       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16557       print_strings (r);
16558       return -1;
16559     }
16560     {
16561       char expected[] = "/dev/sda";
16562       r[0][5] = 's';
16563       if (strcmp (r[0], expected) != 0) {
16564         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16565         return -1;
16566       }
16567     }
16568     if (!r[1]) {
16569       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16570       print_strings (r);
16571       return -1;
16572     }
16573     {
16574       char expected[] = "/dev/sdb";
16575       r[1][5] = 's';
16576       if (strcmp (r[1], expected) != 0) {
16577         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16578         return -1;
16579       }
16580     }
16581     if (!r[2]) {
16582       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16583       print_strings (r);
16584       return -1;
16585     }
16586     {
16587       char expected[] = "/dev/sdc";
16588       r[2][5] = 's';
16589       if (strcmp (r[2], expected) != 0) {
16590         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16591         return -1;
16592       }
16593     }
16594     if (!r[3]) {
16595       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16596       print_strings (r);
16597       return -1;
16598     }
16599     {
16600       char expected[] = "/dev/sdd";
16601       r[3][5] = 's';
16602       if (strcmp (r[3], expected) != 0) {
16603         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
16604         return -1;
16605       }
16606     }
16607     if (r[4] != NULL) {
16608       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
16609       print_strings (r);
16610       return -1;
16611     }
16612     for (i = 0; r[i] != NULL; ++i)
16613       free (r[i]);
16614     free (r);
16615   }
16616   return 0;
16617 }
16618
16619 static int test_ls_0_skip (void)
16620 {
16621   const char *str;
16622
16623   str = getenv ("TEST_ONLY");
16624   if (str)
16625     return strstr (str, "ls") == NULL;
16626   str = getenv ("SKIP_TEST_LS_0");
16627   if (str && strcmp (str, "1") == 0) return 1;
16628   str = getenv ("SKIP_TEST_LS");
16629   if (str && strcmp (str, "1") == 0) return 1;
16630   return 0;
16631 }
16632
16633 static int test_ls_0 (void)
16634 {
16635   if (test_ls_0_skip ()) {
16636     printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
16637     return 0;
16638   }
16639
16640   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
16641   {
16642     char device[] = "/dev/sda";
16643     int r;
16644     suppress_error = 0;
16645     r = guestfs_blockdev_setrw (g, device);
16646     if (r == -1)
16647       return -1;
16648   }
16649   {
16650     int r;
16651     suppress_error = 0;
16652     r = guestfs_umount_all (g);
16653     if (r == -1)
16654       return -1;
16655   }
16656   {
16657     int r;
16658     suppress_error = 0;
16659     r = guestfs_lvm_remove_all (g);
16660     if (r == -1)
16661       return -1;
16662   }
16663   {
16664     char device[] = "/dev/sda";
16665     char lines_0[] = ",";
16666     char *lines[] = {
16667       lines_0,
16668       NULL
16669     };
16670     int r;
16671     suppress_error = 0;
16672     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16673     if (r == -1)
16674       return -1;
16675   }
16676   {
16677     char fstype[] = "ext2";
16678     char device[] = "/dev/sda1";
16679     int r;
16680     suppress_error = 0;
16681     r = guestfs_mkfs (g, fstype, device);
16682     if (r == -1)
16683       return -1;
16684   }
16685   {
16686     char device[] = "/dev/sda1";
16687     char mountpoint[] = "/";
16688     int r;
16689     suppress_error = 0;
16690     r = guestfs_mount (g, device, mountpoint);
16691     if (r == -1)
16692       return -1;
16693   }
16694   /* TestOutputList for ls (0) */
16695   {
16696     char path[] = "/new";
16697     int r;
16698     suppress_error = 0;
16699     r = guestfs_touch (g, path);
16700     if (r == -1)
16701       return -1;
16702   }
16703   {
16704     char path[] = "/newer";
16705     int r;
16706     suppress_error = 0;
16707     r = guestfs_touch (g, path);
16708     if (r == -1)
16709       return -1;
16710   }
16711   {
16712     char path[] = "/newest";
16713     int r;
16714     suppress_error = 0;
16715     r = guestfs_touch (g, path);
16716     if (r == -1)
16717       return -1;
16718   }
16719   {
16720     char directory[] = "/";
16721     char **r;
16722     int i;
16723     suppress_error = 0;
16724     r = guestfs_ls (g, directory);
16725     if (r == NULL)
16726       return -1;
16727     if (!r[0]) {
16728       fprintf (stderr, "test_ls_0: short list returned from command\n");
16729       print_strings (r);
16730       return -1;
16731     }
16732     {
16733       char expected[] = "lost+found";
16734       if (strcmp (r[0], expected) != 0) {
16735         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16736         return -1;
16737       }
16738     }
16739     if (!r[1]) {
16740       fprintf (stderr, "test_ls_0: short list returned from command\n");
16741       print_strings (r);
16742       return -1;
16743     }
16744     {
16745       char expected[] = "new";
16746       if (strcmp (r[1], expected) != 0) {
16747         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16748         return -1;
16749       }
16750     }
16751     if (!r[2]) {
16752       fprintf (stderr, "test_ls_0: short list returned from command\n");
16753       print_strings (r);
16754       return -1;
16755     }
16756     {
16757       char expected[] = "newer";
16758       if (strcmp (r[2], expected) != 0) {
16759         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16760         return -1;
16761       }
16762     }
16763     if (!r[3]) {
16764       fprintf (stderr, "test_ls_0: short list returned from command\n");
16765       print_strings (r);
16766       return -1;
16767     }
16768     {
16769       char expected[] = "newest";
16770       if (strcmp (r[3], expected) != 0) {
16771         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
16772         return -1;
16773       }
16774     }
16775     if (r[4] != NULL) {
16776       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
16777       print_strings (r);
16778       return -1;
16779     }
16780     for (i = 0; r[i] != NULL; ++i)
16781       free (r[i]);
16782     free (r);
16783   }
16784   return 0;
16785 }
16786
16787 static int test_cat_0_skip (void)
16788 {
16789   const char *str;
16790
16791   str = getenv ("TEST_ONLY");
16792   if (str)
16793     return strstr (str, "cat") == NULL;
16794   str = getenv ("SKIP_TEST_CAT_0");
16795   if (str && strcmp (str, "1") == 0) return 1;
16796   str = getenv ("SKIP_TEST_CAT");
16797   if (str && strcmp (str, "1") == 0) return 1;
16798   return 0;
16799 }
16800
16801 static int test_cat_0 (void)
16802 {
16803   if (test_cat_0_skip ()) {
16804     printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
16805     return 0;
16806   }
16807
16808   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
16809   {
16810     char device[] = "/dev/sda";
16811     int r;
16812     suppress_error = 0;
16813     r = guestfs_blockdev_setrw (g, device);
16814     if (r == -1)
16815       return -1;
16816   }
16817   {
16818     int r;
16819     suppress_error = 0;
16820     r = guestfs_umount_all (g);
16821     if (r == -1)
16822       return -1;
16823   }
16824   {
16825     int r;
16826     suppress_error = 0;
16827     r = guestfs_lvm_remove_all (g);
16828     if (r == -1)
16829       return -1;
16830   }
16831   {
16832     char device[] = "/dev/sda";
16833     char lines_0[] = ",";
16834     char *lines[] = {
16835       lines_0,
16836       NULL
16837     };
16838     int r;
16839     suppress_error = 0;
16840     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16841     if (r == -1)
16842       return -1;
16843   }
16844   {
16845     char fstype[] = "ext2";
16846     char device[] = "/dev/sda1";
16847     int r;
16848     suppress_error = 0;
16849     r = guestfs_mkfs (g, fstype, device);
16850     if (r == -1)
16851       return -1;
16852   }
16853   {
16854     char device[] = "/dev/sda1";
16855     char mountpoint[] = "/";
16856     int r;
16857     suppress_error = 0;
16858     r = guestfs_mount (g, device, mountpoint);
16859     if (r == -1)
16860       return -1;
16861   }
16862   /* TestOutput for cat (0) */
16863   char expected[] = "new file contents";
16864   {
16865     char path[] = "/new";
16866     char content[] = "new file contents";
16867     int r;
16868     suppress_error = 0;
16869     r = guestfs_write_file (g, path, content, 0);
16870     if (r == -1)
16871       return -1;
16872   }
16873   {
16874     char path[] = "/new";
16875     char *r;
16876     suppress_error = 0;
16877     r = guestfs_cat (g, path);
16878     if (r == NULL)
16879       return -1;
16880     if (strcmp (r, expected) != 0) {
16881       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
16882       return -1;
16883     }
16884     free (r);
16885   }
16886   return 0;
16887 }
16888
16889 static int test_touch_0_skip (void)
16890 {
16891   const char *str;
16892
16893   str = getenv ("TEST_ONLY");
16894   if (str)
16895     return strstr (str, "touch") == NULL;
16896   str = getenv ("SKIP_TEST_TOUCH_0");
16897   if (str && strcmp (str, "1") == 0) return 1;
16898   str = getenv ("SKIP_TEST_TOUCH");
16899   if (str && strcmp (str, "1") == 0) return 1;
16900   return 0;
16901 }
16902
16903 static int test_touch_0 (void)
16904 {
16905   if (test_touch_0_skip ()) {
16906     printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
16907     return 0;
16908   }
16909
16910   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
16911   {
16912     char device[] = "/dev/sda";
16913     int r;
16914     suppress_error = 0;
16915     r = guestfs_blockdev_setrw (g, device);
16916     if (r == -1)
16917       return -1;
16918   }
16919   {
16920     int r;
16921     suppress_error = 0;
16922     r = guestfs_umount_all (g);
16923     if (r == -1)
16924       return -1;
16925   }
16926   {
16927     int r;
16928     suppress_error = 0;
16929     r = guestfs_lvm_remove_all (g);
16930     if (r == -1)
16931       return -1;
16932   }
16933   {
16934     char device[] = "/dev/sda";
16935     char lines_0[] = ",";
16936     char *lines[] = {
16937       lines_0,
16938       NULL
16939     };
16940     int r;
16941     suppress_error = 0;
16942     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16943     if (r == -1)
16944       return -1;
16945   }
16946   {
16947     char fstype[] = "ext2";
16948     char device[] = "/dev/sda1";
16949     int r;
16950     suppress_error = 0;
16951     r = guestfs_mkfs (g, fstype, device);
16952     if (r == -1)
16953       return -1;
16954   }
16955   {
16956     char device[] = "/dev/sda1";
16957     char mountpoint[] = "/";
16958     int r;
16959     suppress_error = 0;
16960     r = guestfs_mount (g, device, mountpoint);
16961     if (r == -1)
16962       return -1;
16963   }
16964   /* TestOutputTrue for touch (0) */
16965   {
16966     char path[] = "/new";
16967     int r;
16968     suppress_error = 0;
16969     r = guestfs_touch (g, path);
16970     if (r == -1)
16971       return -1;
16972   }
16973   {
16974     char path[] = "/new";
16975     int r;
16976     suppress_error = 0;
16977     r = guestfs_exists (g, path);
16978     if (r == -1)
16979       return -1;
16980     if (!r) {
16981       fprintf (stderr, "test_touch_0: expected true, got false\n");
16982       return -1;
16983     }
16984   }
16985   return 0;
16986 }
16987
16988 static int test_sync_0_skip (void)
16989 {
16990   const char *str;
16991
16992   str = getenv ("TEST_ONLY");
16993   if (str)
16994     return strstr (str, "sync") == NULL;
16995   str = getenv ("SKIP_TEST_SYNC_0");
16996   if (str && strcmp (str, "1") == 0) return 1;
16997   str = getenv ("SKIP_TEST_SYNC");
16998   if (str && strcmp (str, "1") == 0) return 1;
16999   return 0;
17000 }
17001
17002 static int test_sync_0 (void)
17003 {
17004   if (test_sync_0_skip ()) {
17005     printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
17006     return 0;
17007   }
17008
17009   /* InitNone|InitEmpty for test_sync_0 */
17010   {
17011     char device[] = "/dev/sda";
17012     int r;
17013     suppress_error = 0;
17014     r = guestfs_blockdev_setrw (g, device);
17015     if (r == -1)
17016       return -1;
17017   }
17018   {
17019     int r;
17020     suppress_error = 0;
17021     r = guestfs_umount_all (g);
17022     if (r == -1)
17023       return -1;
17024   }
17025   {
17026     int r;
17027     suppress_error = 0;
17028     r = guestfs_lvm_remove_all (g);
17029     if (r == -1)
17030       return -1;
17031   }
17032   /* TestRun for sync (0) */
17033   {
17034     int r;
17035     suppress_error = 0;
17036     r = guestfs_sync (g);
17037     if (r == -1)
17038       return -1;
17039   }
17040   return 0;
17041 }
17042
17043 static int test_mount_0_skip (void)
17044 {
17045   const char *str;
17046
17047   str = getenv ("TEST_ONLY");
17048   if (str)
17049     return strstr (str, "mount") == NULL;
17050   str = getenv ("SKIP_TEST_MOUNT_0");
17051   if (str && strcmp (str, "1") == 0) return 1;
17052   str = getenv ("SKIP_TEST_MOUNT");
17053   if (str && strcmp (str, "1") == 0) return 1;
17054   return 0;
17055 }
17056
17057 static int test_mount_0 (void)
17058 {
17059   if (test_mount_0_skip ()) {
17060     printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
17061     return 0;
17062   }
17063
17064   /* InitNone|InitEmpty for test_mount_0 */
17065   {
17066     char device[] = "/dev/sda";
17067     int r;
17068     suppress_error = 0;
17069     r = guestfs_blockdev_setrw (g, device);
17070     if (r == -1)
17071       return -1;
17072   }
17073   {
17074     int r;
17075     suppress_error = 0;
17076     r = guestfs_umount_all (g);
17077     if (r == -1)
17078       return -1;
17079   }
17080   {
17081     int r;
17082     suppress_error = 0;
17083     r = guestfs_lvm_remove_all (g);
17084     if (r == -1)
17085       return -1;
17086   }
17087   /* TestOutput for mount (0) */
17088   char expected[] = "new file contents";
17089   {
17090     char device[] = "/dev/sda";
17091     char lines_0[] = ",";
17092     char *lines[] = {
17093       lines_0,
17094       NULL
17095     };
17096     int r;
17097     suppress_error = 0;
17098     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17099     if (r == -1)
17100       return -1;
17101   }
17102   {
17103     char fstype[] = "ext2";
17104     char device[] = "/dev/sda1";
17105     int r;
17106     suppress_error = 0;
17107     r = guestfs_mkfs (g, fstype, device);
17108     if (r == -1)
17109       return -1;
17110   }
17111   {
17112     char device[] = "/dev/sda1";
17113     char mountpoint[] = "/";
17114     int r;
17115     suppress_error = 0;
17116     r = guestfs_mount (g, device, mountpoint);
17117     if (r == -1)
17118       return -1;
17119   }
17120   {
17121     char path[] = "/new";
17122     char content[] = "new file contents";
17123     int r;
17124     suppress_error = 0;
17125     r = guestfs_write_file (g, path, content, 0);
17126     if (r == -1)
17127       return -1;
17128   }
17129   {
17130     char path[] = "/new";
17131     char *r;
17132     suppress_error = 0;
17133     r = guestfs_cat (g, path);
17134     if (r == NULL)
17135       return -1;
17136     if (strcmp (r, expected) != 0) {
17137       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
17138       return -1;
17139     }
17140     free (r);
17141   }
17142   return 0;
17143 }
17144
17145 int main (int argc, char *argv[])
17146 {
17147   char c = 0;
17148   int failed = 0;
17149   const char *filename;
17150   int fd;
17151   int nr_tests, test_num = 0;
17152
17153   no_test_warnings ();
17154
17155   g = guestfs_create ();
17156   if (g == NULL) {
17157     printf ("guestfs_create FAILED\n");
17158     exit (1);
17159   }
17160
17161   guestfs_set_error_handler (g, print_error, NULL);
17162
17163   guestfs_set_path (g, "../appliance");
17164
17165   filename = "test1.img";
17166   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
17167   if (fd == -1) {
17168     perror (filename);
17169     exit (1);
17170   }
17171   if (lseek (fd, 524288000, SEEK_SET) == -1) {
17172     perror ("lseek");
17173     close (fd);
17174     unlink (filename);
17175     exit (1);
17176   }
17177   if (write (fd, &c, 1) == -1) {
17178     perror ("write");
17179     close (fd);
17180     unlink (filename);
17181     exit (1);
17182   }
17183   if (close (fd) == -1) {
17184     perror (filename);
17185     unlink (filename);
17186     exit (1);
17187   }
17188   if (guestfs_add_drive (g, filename) == -1) {
17189     printf ("guestfs_add_drive %s FAILED\n", filename);
17190     exit (1);
17191   }
17192
17193   filename = "test2.img";
17194   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
17195   if (fd == -1) {
17196     perror (filename);
17197     exit (1);
17198   }
17199   if (lseek (fd, 52428800, SEEK_SET) == -1) {
17200     perror ("lseek");
17201     close (fd);
17202     unlink (filename);
17203     exit (1);
17204   }
17205   if (write (fd, &c, 1) == -1) {
17206     perror ("write");
17207     close (fd);
17208     unlink (filename);
17209     exit (1);
17210   }
17211   if (close (fd) == -1) {
17212     perror (filename);
17213     unlink (filename);
17214     exit (1);
17215   }
17216   if (guestfs_add_drive (g, filename) == -1) {
17217     printf ("guestfs_add_drive %s FAILED\n", filename);
17218     exit (1);
17219   }
17220
17221   filename = "test3.img";
17222   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
17223   if (fd == -1) {
17224     perror (filename);
17225     exit (1);
17226   }
17227   if (lseek (fd, 10485760, SEEK_SET) == -1) {
17228     perror ("lseek");
17229     close (fd);
17230     unlink (filename);
17231     exit (1);
17232   }
17233   if (write (fd, &c, 1) == -1) {
17234     perror ("write");
17235     close (fd);
17236     unlink (filename);
17237     exit (1);
17238   }
17239   if (close (fd) == -1) {
17240     perror (filename);
17241     unlink (filename);
17242     exit (1);
17243   }
17244   if (guestfs_add_drive (g, filename) == -1) {
17245     printf ("guestfs_add_drive %s FAILED\n", filename);
17246     exit (1);
17247   }
17248
17249   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
17250     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
17251     exit (1);
17252   }
17253
17254   if (guestfs_launch (g) == -1) {
17255     printf ("guestfs_launch FAILED\n");
17256     exit (1);
17257   }
17258
17259   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
17260   alarm (600);
17261
17262   if (guestfs_wait_ready (g) == -1) {
17263     printf ("guestfs_wait_ready FAILED\n");
17264     exit (1);
17265   }
17266
17267   /* Cancel previous alarm. */
17268   alarm (0);
17269
17270   nr_tests = 156;
17271
17272   test_num++;
17273   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
17274   if (test_wc_c_0 () == -1) {
17275     printf ("test_wc_c_0 FAILED\n");
17276     failed++;
17277   }
17278   test_num++;
17279   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
17280   if (test_wc_w_0 () == -1) {
17281     printf ("test_wc_w_0 FAILED\n");
17282     failed++;
17283   }
17284   test_num++;
17285   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
17286   if (test_wc_l_0 () == -1) {
17287     printf ("test_wc_l_0 FAILED\n");
17288     failed++;
17289   }
17290   test_num++;
17291   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
17292   if (test_mkdtemp_0 () == -1) {
17293     printf ("test_mkdtemp_0 FAILED\n");
17294     failed++;
17295   }
17296   test_num++;
17297   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
17298   if (test_scrub_file_0 () == -1) {
17299     printf ("test_scrub_file_0 FAILED\n");
17300     failed++;
17301   }
17302   test_num++;
17303   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
17304   if (test_scrub_device_0 () == -1) {
17305     printf ("test_scrub_device_0 FAILED\n");
17306     failed++;
17307   }
17308   test_num++;
17309   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
17310   if (test_glob_expand_0 () == -1) {
17311     printf ("test_glob_expand_0 FAILED\n");
17312     failed++;
17313   }
17314   test_num++;
17315   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
17316   if (test_glob_expand_1 () == -1) {
17317     printf ("test_glob_expand_1 FAILED\n");
17318     failed++;
17319   }
17320   test_num++;
17321   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
17322   if (test_glob_expand_2 () == -1) {
17323     printf ("test_glob_expand_2 FAILED\n");
17324     failed++;
17325   }
17326   test_num++;
17327   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
17328   if (test_ntfs_3g_probe_0 () == -1) {
17329     printf ("test_ntfs_3g_probe_0 FAILED\n");
17330     failed++;
17331   }
17332   test_num++;
17333   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
17334   if (test_ntfs_3g_probe_1 () == -1) {
17335     printf ("test_ntfs_3g_probe_1 FAILED\n");
17336     failed++;
17337   }
17338   test_num++;
17339   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
17340   if (test_sleep_0 () == -1) {
17341     printf ("test_sleep_0 FAILED\n");
17342     failed++;
17343   }
17344   test_num++;
17345   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
17346   if (test_find_0 () == -1) {
17347     printf ("test_find_0 FAILED\n");
17348     failed++;
17349   }
17350   test_num++;
17351   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
17352   if (test_find_1 () == -1) {
17353     printf ("test_find_1 FAILED\n");
17354     failed++;
17355   }
17356   test_num++;
17357   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
17358   if (test_find_2 () == -1) {
17359     printf ("test_find_2 FAILED\n");
17360     failed++;
17361   }
17362   test_num++;
17363   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
17364   if (test_lvresize_0 () == -1) {
17365     printf ("test_lvresize_0 FAILED\n");
17366     failed++;
17367   }
17368   test_num++;
17369   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
17370   if (test_zerofree_0 () == -1) {
17371     printf ("test_zerofree_0 FAILED\n");
17372     failed++;
17373   }
17374   test_num++;
17375   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
17376   if (test_hexdump_0 () == -1) {
17377     printf ("test_hexdump_0 FAILED\n");
17378     failed++;
17379   }
17380   test_num++;
17381   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
17382   if (test_hexdump_1 () == -1) {
17383     printf ("test_hexdump_1 FAILED\n");
17384     failed++;
17385   }
17386   test_num++;
17387   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
17388   if (test_strings_e_0 () == -1) {
17389     printf ("test_strings_e_0 FAILED\n");
17390     failed++;
17391   }
17392   test_num++;
17393   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
17394   if (test_strings_e_1 () == -1) {
17395     printf ("test_strings_e_1 FAILED\n");
17396     failed++;
17397   }
17398   test_num++;
17399   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
17400   if (test_strings_0 () == -1) {
17401     printf ("test_strings_0 FAILED\n");
17402     failed++;
17403   }
17404   test_num++;
17405   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
17406   if (test_strings_1 () == -1) {
17407     printf ("test_strings_1 FAILED\n");
17408     failed++;
17409   }
17410   test_num++;
17411   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
17412   if (test_equal_0 () == -1) {
17413     printf ("test_equal_0 FAILED\n");
17414     failed++;
17415   }
17416   test_num++;
17417   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
17418   if (test_equal_1 () == -1) {
17419     printf ("test_equal_1 FAILED\n");
17420     failed++;
17421   }
17422   test_num++;
17423   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
17424   if (test_equal_2 () == -1) {
17425     printf ("test_equal_2 FAILED\n");
17426     failed++;
17427   }
17428   test_num++;
17429   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
17430   if (test_ping_daemon_0 () == -1) {
17431     printf ("test_ping_daemon_0 FAILED\n");
17432     failed++;
17433   }
17434   test_num++;
17435   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
17436   if (test_dmesg_0 () == -1) {
17437     printf ("test_dmesg_0 FAILED\n");
17438     failed++;
17439   }
17440   test_num++;
17441   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
17442   if (test_drop_caches_0 () == -1) {
17443     printf ("test_drop_caches_0 FAILED\n");
17444     failed++;
17445   }
17446   test_num++;
17447   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
17448   if (test_mv_0 () == -1) {
17449     printf ("test_mv_0 FAILED\n");
17450     failed++;
17451   }
17452   test_num++;
17453   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
17454   if (test_mv_1 () == -1) {
17455     printf ("test_mv_1 FAILED\n");
17456     failed++;
17457   }
17458   test_num++;
17459   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
17460   if (test_cp_a_0 () == -1) {
17461     printf ("test_cp_a_0 FAILED\n");
17462     failed++;
17463   }
17464   test_num++;
17465   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
17466   if (test_cp_0 () == -1) {
17467     printf ("test_cp_0 FAILED\n");
17468     failed++;
17469   }
17470   test_num++;
17471   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
17472   if (test_cp_1 () == -1) {
17473     printf ("test_cp_1 FAILED\n");
17474     failed++;
17475   }
17476   test_num++;
17477   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
17478   if (test_cp_2 () == -1) {
17479     printf ("test_cp_2 FAILED\n");
17480     failed++;
17481   }
17482   test_num++;
17483   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
17484   if (test_grub_install_0 () == -1) {
17485     printf ("test_grub_install_0 FAILED\n");
17486     failed++;
17487   }
17488   test_num++;
17489   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
17490   if (test_zero_0 () == -1) {
17491     printf ("test_zero_0 FAILED\n");
17492     failed++;
17493   }
17494   test_num++;
17495   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
17496   if (test_fsck_0 () == -1) {
17497     printf ("test_fsck_0 FAILED\n");
17498     failed++;
17499   }
17500   test_num++;
17501   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
17502   if (test_fsck_1 () == -1) {
17503     printf ("test_fsck_1 FAILED\n");
17504     failed++;
17505   }
17506   test_num++;
17507   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
17508   if (test_set_e2uuid_0 () == -1) {
17509     printf ("test_set_e2uuid_0 FAILED\n");
17510     failed++;
17511   }
17512   test_num++;
17513   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
17514   if (test_set_e2uuid_1 () == -1) {
17515     printf ("test_set_e2uuid_1 FAILED\n");
17516     failed++;
17517   }
17518   test_num++;
17519   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
17520   if (test_set_e2uuid_2 () == -1) {
17521     printf ("test_set_e2uuid_2 FAILED\n");
17522     failed++;
17523   }
17524   test_num++;
17525   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
17526   if (test_set_e2uuid_3 () == -1) {
17527     printf ("test_set_e2uuid_3 FAILED\n");
17528     failed++;
17529   }
17530   test_num++;
17531   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
17532   if (test_set_e2label_0 () == -1) {
17533     printf ("test_set_e2label_0 FAILED\n");
17534     failed++;
17535   }
17536   test_num++;
17537   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
17538   if (test_pvremove_0 () == -1) {
17539     printf ("test_pvremove_0 FAILED\n");
17540     failed++;
17541   }
17542   test_num++;
17543   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
17544   if (test_pvremove_1 () == -1) {
17545     printf ("test_pvremove_1 FAILED\n");
17546     failed++;
17547   }
17548   test_num++;
17549   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
17550   if (test_pvremove_2 () == -1) {
17551     printf ("test_pvremove_2 FAILED\n");
17552     failed++;
17553   }
17554   test_num++;
17555   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
17556   if (test_vgremove_0 () == -1) {
17557     printf ("test_vgremove_0 FAILED\n");
17558     failed++;
17559   }
17560   test_num++;
17561   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
17562   if (test_vgremove_1 () == -1) {
17563     printf ("test_vgremove_1 FAILED\n");
17564     failed++;
17565   }
17566   test_num++;
17567   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
17568   if (test_lvremove_0 () == -1) {
17569     printf ("test_lvremove_0 FAILED\n");
17570     failed++;
17571   }
17572   test_num++;
17573   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
17574   if (test_lvremove_1 () == -1) {
17575     printf ("test_lvremove_1 FAILED\n");
17576     failed++;
17577   }
17578   test_num++;
17579   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
17580   if (test_lvremove_2 () == -1) {
17581     printf ("test_lvremove_2 FAILED\n");
17582     failed++;
17583   }
17584   test_num++;
17585   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
17586   if (test_mount_ro_0 () == -1) {
17587     printf ("test_mount_ro_0 FAILED\n");
17588     failed++;
17589   }
17590   test_num++;
17591   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
17592   if (test_mount_ro_1 () == -1) {
17593     printf ("test_mount_ro_1 FAILED\n");
17594     failed++;
17595   }
17596   test_num++;
17597   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
17598   if (test_tgz_in_0 () == -1) {
17599     printf ("test_tgz_in_0 FAILED\n");
17600     failed++;
17601   }
17602   test_num++;
17603   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
17604   if (test_tar_in_0 () == -1) {
17605     printf ("test_tar_in_0 FAILED\n");
17606     failed++;
17607   }
17608   test_num++;
17609   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
17610   if (test_checksum_0 () == -1) {
17611     printf ("test_checksum_0 FAILED\n");
17612     failed++;
17613   }
17614   test_num++;
17615   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
17616   if (test_checksum_1 () == -1) {
17617     printf ("test_checksum_1 FAILED\n");
17618     failed++;
17619   }
17620   test_num++;
17621   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
17622   if (test_checksum_2 () == -1) {
17623     printf ("test_checksum_2 FAILED\n");
17624     failed++;
17625   }
17626   test_num++;
17627   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
17628   if (test_checksum_3 () == -1) {
17629     printf ("test_checksum_3 FAILED\n");
17630     failed++;
17631   }
17632   test_num++;
17633   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
17634   if (test_checksum_4 () == -1) {
17635     printf ("test_checksum_4 FAILED\n");
17636     failed++;
17637   }
17638   test_num++;
17639   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
17640   if (test_checksum_5 () == -1) {
17641     printf ("test_checksum_5 FAILED\n");
17642     failed++;
17643   }
17644   test_num++;
17645   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
17646   if (test_checksum_6 () == -1) {
17647     printf ("test_checksum_6 FAILED\n");
17648     failed++;
17649   }
17650   test_num++;
17651   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
17652   if (test_checksum_7 () == -1) {
17653     printf ("test_checksum_7 FAILED\n");
17654     failed++;
17655   }
17656   test_num++;
17657   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
17658   if (test_checksum_8 () == -1) {
17659     printf ("test_checksum_8 FAILED\n");
17660     failed++;
17661   }
17662   test_num++;
17663   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
17664   if (test_download_0 () == -1) {
17665     printf ("test_download_0 FAILED\n");
17666     failed++;
17667   }
17668   test_num++;
17669   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
17670   if (test_upload_0 () == -1) {
17671     printf ("test_upload_0 FAILED\n");
17672     failed++;
17673   }
17674   test_num++;
17675   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
17676   if (test_blockdev_rereadpt_0 () == -1) {
17677     printf ("test_blockdev_rereadpt_0 FAILED\n");
17678     failed++;
17679   }
17680   test_num++;
17681   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
17682   if (test_blockdev_flushbufs_0 () == -1) {
17683     printf ("test_blockdev_flushbufs_0 FAILED\n");
17684     failed++;
17685   }
17686   test_num++;
17687   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
17688   if (test_blockdev_getsize64_0 () == -1) {
17689     printf ("test_blockdev_getsize64_0 FAILED\n");
17690     failed++;
17691   }
17692   test_num++;
17693   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
17694   if (test_blockdev_getsz_0 () == -1) {
17695     printf ("test_blockdev_getsz_0 FAILED\n");
17696     failed++;
17697   }
17698   test_num++;
17699   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
17700   if (test_blockdev_getbsz_0 () == -1) {
17701     printf ("test_blockdev_getbsz_0 FAILED\n");
17702     failed++;
17703   }
17704   test_num++;
17705   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
17706   if (test_blockdev_getss_0 () == -1) {
17707     printf ("test_blockdev_getss_0 FAILED\n");
17708     failed++;
17709   }
17710   test_num++;
17711   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
17712   if (test_blockdev_getro_0 () == -1) {
17713     printf ("test_blockdev_getro_0 FAILED\n");
17714     failed++;
17715   }
17716   test_num++;
17717   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
17718   if (test_blockdev_setrw_0 () == -1) {
17719     printf ("test_blockdev_setrw_0 FAILED\n");
17720     failed++;
17721   }
17722   test_num++;
17723   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
17724   if (test_blockdev_setro_0 () == -1) {
17725     printf ("test_blockdev_setro_0 FAILED\n");
17726     failed++;
17727   }
17728   test_num++;
17729   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
17730   if (test_statvfs_0 () == -1) {
17731     printf ("test_statvfs_0 FAILED\n");
17732     failed++;
17733   }
17734   test_num++;
17735   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
17736   if (test_lstat_0 () == -1) {
17737     printf ("test_lstat_0 FAILED\n");
17738     failed++;
17739   }
17740   test_num++;
17741   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
17742   if (test_stat_0 () == -1) {
17743     printf ("test_stat_0 FAILED\n");
17744     failed++;
17745   }
17746   test_num++;
17747   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
17748   if (test_command_lines_0 () == -1) {
17749     printf ("test_command_lines_0 FAILED\n");
17750     failed++;
17751   }
17752   test_num++;
17753   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
17754   if (test_command_lines_1 () == -1) {
17755     printf ("test_command_lines_1 FAILED\n");
17756     failed++;
17757   }
17758   test_num++;
17759   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
17760   if (test_command_lines_2 () == -1) {
17761     printf ("test_command_lines_2 FAILED\n");
17762     failed++;
17763   }
17764   test_num++;
17765   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
17766   if (test_command_lines_3 () == -1) {
17767     printf ("test_command_lines_3 FAILED\n");
17768     failed++;
17769   }
17770   test_num++;
17771   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
17772   if (test_command_lines_4 () == -1) {
17773     printf ("test_command_lines_4 FAILED\n");
17774     failed++;
17775   }
17776   test_num++;
17777   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
17778   if (test_command_lines_5 () == -1) {
17779     printf ("test_command_lines_5 FAILED\n");
17780     failed++;
17781   }
17782   test_num++;
17783   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
17784   if (test_command_lines_6 () == -1) {
17785     printf ("test_command_lines_6 FAILED\n");
17786     failed++;
17787   }
17788   test_num++;
17789   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
17790   if (test_command_lines_7 () == -1) {
17791     printf ("test_command_lines_7 FAILED\n");
17792     failed++;
17793   }
17794   test_num++;
17795   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
17796   if (test_command_lines_8 () == -1) {
17797     printf ("test_command_lines_8 FAILED\n");
17798     failed++;
17799   }
17800   test_num++;
17801   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
17802   if (test_command_lines_9 () == -1) {
17803     printf ("test_command_lines_9 FAILED\n");
17804     failed++;
17805   }
17806   test_num++;
17807   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
17808   if (test_command_lines_10 () == -1) {
17809     printf ("test_command_lines_10 FAILED\n");
17810     failed++;
17811   }
17812   test_num++;
17813   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
17814   if (test_command_0 () == -1) {
17815     printf ("test_command_0 FAILED\n");
17816     failed++;
17817   }
17818   test_num++;
17819   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
17820   if (test_command_1 () == -1) {
17821     printf ("test_command_1 FAILED\n");
17822     failed++;
17823   }
17824   test_num++;
17825   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
17826   if (test_command_2 () == -1) {
17827     printf ("test_command_2 FAILED\n");
17828     failed++;
17829   }
17830   test_num++;
17831   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
17832   if (test_command_3 () == -1) {
17833     printf ("test_command_3 FAILED\n");
17834     failed++;
17835   }
17836   test_num++;
17837   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
17838   if (test_command_4 () == -1) {
17839     printf ("test_command_4 FAILED\n");
17840     failed++;
17841   }
17842   test_num++;
17843   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
17844   if (test_command_5 () == -1) {
17845     printf ("test_command_5 FAILED\n");
17846     failed++;
17847   }
17848   test_num++;
17849   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
17850   if (test_command_6 () == -1) {
17851     printf ("test_command_6 FAILED\n");
17852     failed++;
17853   }
17854   test_num++;
17855   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
17856   if (test_command_7 () == -1) {
17857     printf ("test_command_7 FAILED\n");
17858     failed++;
17859   }
17860   test_num++;
17861   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
17862   if (test_command_8 () == -1) {
17863     printf ("test_command_8 FAILED\n");
17864     failed++;
17865   }
17866   test_num++;
17867   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
17868   if (test_command_9 () == -1) {
17869     printf ("test_command_9 FAILED\n");
17870     failed++;
17871   }
17872   test_num++;
17873   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
17874   if (test_command_10 () == -1) {
17875     printf ("test_command_10 FAILED\n");
17876     failed++;
17877   }
17878   test_num++;
17879   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
17880   if (test_command_11 () == -1) {
17881     printf ("test_command_11 FAILED\n");
17882     failed++;
17883   }
17884   test_num++;
17885   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
17886   if (test_file_0 () == -1) {
17887     printf ("test_file_0 FAILED\n");
17888     failed++;
17889   }
17890   test_num++;
17891   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
17892   if (test_file_1 () == -1) {
17893     printf ("test_file_1 FAILED\n");
17894     failed++;
17895   }
17896   test_num++;
17897   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
17898   if (test_file_2 () == -1) {
17899     printf ("test_file_2 FAILED\n");
17900     failed++;
17901   }
17902   test_num++;
17903   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
17904   if (test_umount_all_0 () == -1) {
17905     printf ("test_umount_all_0 FAILED\n");
17906     failed++;
17907   }
17908   test_num++;
17909   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
17910   if (test_umount_all_1 () == -1) {
17911     printf ("test_umount_all_1 FAILED\n");
17912     failed++;
17913   }
17914   test_num++;
17915   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
17916   if (test_mounts_0 () == -1) {
17917     printf ("test_mounts_0 FAILED\n");
17918     failed++;
17919   }
17920   test_num++;
17921   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
17922   if (test_umount_0 () == -1) {
17923     printf ("test_umount_0 FAILED\n");
17924     failed++;
17925   }
17926   test_num++;
17927   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
17928   if (test_umount_1 () == -1) {
17929     printf ("test_umount_1 FAILED\n");
17930     failed++;
17931   }
17932   test_num++;
17933   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
17934   if (test_write_file_0 () == -1) {
17935     printf ("test_write_file_0 FAILED\n");
17936     failed++;
17937   }
17938   test_num++;
17939   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
17940   if (test_write_file_1 () == -1) {
17941     printf ("test_write_file_1 FAILED\n");
17942     failed++;
17943   }
17944   test_num++;
17945   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
17946   if (test_write_file_2 () == -1) {
17947     printf ("test_write_file_2 FAILED\n");
17948     failed++;
17949   }
17950   test_num++;
17951   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
17952   if (test_write_file_3 () == -1) {
17953     printf ("test_write_file_3 FAILED\n");
17954     failed++;
17955   }
17956   test_num++;
17957   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
17958   if (test_write_file_4 () == -1) {
17959     printf ("test_write_file_4 FAILED\n");
17960     failed++;
17961   }
17962   test_num++;
17963   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
17964   if (test_write_file_5 () == -1) {
17965     printf ("test_write_file_5 FAILED\n");
17966     failed++;
17967   }
17968   test_num++;
17969   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
17970   if (test_mkfs_0 () == -1) {
17971     printf ("test_mkfs_0 FAILED\n");
17972     failed++;
17973   }
17974   test_num++;
17975   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
17976   if (test_lvcreate_0 () == -1) {
17977     printf ("test_lvcreate_0 FAILED\n");
17978     failed++;
17979   }
17980   test_num++;
17981   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
17982   if (test_vgcreate_0 () == -1) {
17983     printf ("test_vgcreate_0 FAILED\n");
17984     failed++;
17985   }
17986   test_num++;
17987   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17988   if (test_pvcreate_0 () == -1) {
17989     printf ("test_pvcreate_0 FAILED\n");
17990     failed++;
17991   }
17992   test_num++;
17993   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17994   if (test_is_dir_0 () == -1) {
17995     printf ("test_is_dir_0 FAILED\n");
17996     failed++;
17997   }
17998   test_num++;
17999   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
18000   if (test_is_dir_1 () == -1) {
18001     printf ("test_is_dir_1 FAILED\n");
18002     failed++;
18003   }
18004   test_num++;
18005   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
18006   if (test_is_file_0 () == -1) {
18007     printf ("test_is_file_0 FAILED\n");
18008     failed++;
18009   }
18010   test_num++;
18011   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
18012   if (test_is_file_1 () == -1) {
18013     printf ("test_is_file_1 FAILED\n");
18014     failed++;
18015   }
18016   test_num++;
18017   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
18018   if (test_exists_0 () == -1) {
18019     printf ("test_exists_0 FAILED\n");
18020     failed++;
18021   }
18022   test_num++;
18023   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
18024   if (test_exists_1 () == -1) {
18025     printf ("test_exists_1 FAILED\n");
18026     failed++;
18027   }
18028   test_num++;
18029   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
18030   if (test_mkdir_p_0 () == -1) {
18031     printf ("test_mkdir_p_0 FAILED\n");
18032     failed++;
18033   }
18034   test_num++;
18035   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
18036   if (test_mkdir_p_1 () == -1) {
18037     printf ("test_mkdir_p_1 FAILED\n");
18038     failed++;
18039   }
18040   test_num++;
18041   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
18042   if (test_mkdir_p_2 () == -1) {
18043     printf ("test_mkdir_p_2 FAILED\n");
18044     failed++;
18045   }
18046   test_num++;
18047   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
18048   if (test_mkdir_p_3 () == -1) {
18049     printf ("test_mkdir_p_3 FAILED\n");
18050     failed++;
18051   }
18052   test_num++;
18053   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
18054   if (test_mkdir_p_4 () == -1) {
18055     printf ("test_mkdir_p_4 FAILED\n");
18056     failed++;
18057   }
18058   test_num++;
18059   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
18060   if (test_mkdir_0 () == -1) {
18061     printf ("test_mkdir_0 FAILED\n");
18062     failed++;
18063   }
18064   test_num++;
18065   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
18066   if (test_mkdir_1 () == -1) {
18067     printf ("test_mkdir_1 FAILED\n");
18068     failed++;
18069   }
18070   test_num++;
18071   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
18072   if (test_rm_rf_0 () == -1) {
18073     printf ("test_rm_rf_0 FAILED\n");
18074     failed++;
18075   }
18076   test_num++;
18077   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
18078   if (test_rmdir_0 () == -1) {
18079     printf ("test_rmdir_0 FAILED\n");
18080     failed++;
18081   }
18082   test_num++;
18083   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
18084   if (test_rmdir_1 () == -1) {
18085     printf ("test_rmdir_1 FAILED\n");
18086     failed++;
18087   }
18088   test_num++;
18089   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
18090   if (test_rmdir_2 () == -1) {
18091     printf ("test_rmdir_2 FAILED\n");
18092     failed++;
18093   }
18094   test_num++;
18095   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
18096   if (test_rm_0 () == -1) {
18097     printf ("test_rm_0 FAILED\n");
18098     failed++;
18099   }
18100   test_num++;
18101   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
18102   if (test_rm_1 () == -1) {
18103     printf ("test_rm_1 FAILED\n");
18104     failed++;
18105   }
18106   test_num++;
18107   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
18108   if (test_rm_2 () == -1) {
18109     printf ("test_rm_2 FAILED\n");
18110     failed++;
18111   }
18112   test_num++;
18113   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
18114   if (test_read_lines_0 () == -1) {
18115     printf ("test_read_lines_0 FAILED\n");
18116     failed++;
18117   }
18118   test_num++;
18119   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
18120   if (test_read_lines_1 () == -1) {
18121     printf ("test_read_lines_1 FAILED\n");
18122     failed++;
18123   }
18124   test_num++;
18125   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
18126   if (test_lvs_0 () == -1) {
18127     printf ("test_lvs_0 FAILED\n");
18128     failed++;
18129   }
18130   test_num++;
18131   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
18132   if (test_lvs_1 () == -1) {
18133     printf ("test_lvs_1 FAILED\n");
18134     failed++;
18135   }
18136   test_num++;
18137   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
18138   if (test_vgs_0 () == -1) {
18139     printf ("test_vgs_0 FAILED\n");
18140     failed++;
18141   }
18142   test_num++;
18143   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
18144   if (test_vgs_1 () == -1) {
18145     printf ("test_vgs_1 FAILED\n");
18146     failed++;
18147   }
18148   test_num++;
18149   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
18150   if (test_pvs_0 () == -1) {
18151     printf ("test_pvs_0 FAILED\n");
18152     failed++;
18153   }
18154   test_num++;
18155   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
18156   if (test_pvs_1 () == -1) {
18157     printf ("test_pvs_1 FAILED\n");
18158     failed++;
18159   }
18160   test_num++;
18161   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
18162   if (test_list_partitions_0 () == -1) {
18163     printf ("test_list_partitions_0 FAILED\n");
18164     failed++;
18165   }
18166   test_num++;
18167   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
18168   if (test_list_partitions_1 () == -1) {
18169     printf ("test_list_partitions_1 FAILED\n");
18170     failed++;
18171   }
18172   test_num++;
18173   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
18174   if (test_list_devices_0 () == -1) {
18175     printf ("test_list_devices_0 FAILED\n");
18176     failed++;
18177   }
18178   test_num++;
18179   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
18180   if (test_ls_0 () == -1) {
18181     printf ("test_ls_0 FAILED\n");
18182     failed++;
18183   }
18184   test_num++;
18185   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
18186   if (test_cat_0 () == -1) {
18187     printf ("test_cat_0 FAILED\n");
18188     failed++;
18189   }
18190   test_num++;
18191   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
18192   if (test_touch_0 () == -1) {
18193     printf ("test_touch_0 FAILED\n");
18194     failed++;
18195   }
18196   test_num++;
18197   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
18198   if (test_sync_0 () == -1) {
18199     printf ("test_sync_0 FAILED\n");
18200     failed++;
18201   }
18202   test_num++;
18203   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
18204   if (test_mount_0 () == -1) {
18205     printf ("test_mount_0 FAILED\n");
18206     failed++;
18207   }
18208
18209   guestfs_close (g);
18210   unlink ("test1.img");
18211   unlink ("test2.img");
18212   unlink ("test3.img");
18213
18214   if (failed > 0) {
18215     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
18216     exit (1);
18217   }
18218
18219   exit (0);
18220 }