capitests/tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 static void print_error (guestfs_h *g, void *data, const char *msg)
  35 {
  36   if (!suppress_error)
  37     fprintf (stderr, "%s\n", msg);
  38 }
  39
  40 static void print_strings (char * const * const argv)
  41 {
  42   int argc;
  43
  44   for (argc = 0; argv[argc] != NULL; ++argc)
  45     printf ("\t%s\n", argv[argc]);
  46 }
  47
  48 /*
  49 static void print_table (char * const * const argv)
  50 {
  51   int i;
  52
  53   for (i = 0; argv[i] != NULL; i += 2)
  54     printf ("%s: %s\n", argv[i], argv[i+1]);
  55 }
  56 */
  57
  58 static void no_test_warnings (void)
  59 {
  60   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  61   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  62   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  63   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  64   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  65   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
 156 }
 157
 158 static int test_du_0_skip (void)
 159 {
 160   const char *str;
 161
 162   str = getenv ("TEST_ONLY");
 163   if (str)
 164     return strstr (str, "du") == NULL;
 165   str = getenv ("SKIP_TEST_DU_0");
 166   if (str && strcmp (str, "1") == 0) return 1;
 167   str = getenv ("SKIP_TEST_DU");
 168   if (str && strcmp (str, "1") == 0) return 1;
 169   return 0;
 170 }
 171
 172 static int test_du_0 (void)
 173 {
 174   if (test_du_0_skip ()) {
 175     printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
 176     return 0;
 177   }
 178
 179   /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
 180   {
 181     char device[] = "/dev/sda";
 182     int r;
 183     suppress_error = 0;
 184     r = guestfs_blockdev_setrw (g, device);
 185     if (r == -1)
 186       return -1;
 187   }
 188   {
 189     int r;
 190     suppress_error = 0;
 191     r = guestfs_umount_all (g);
 192     if (r == -1)
 193       return -1;
 194   }
 195   {
 196     int r;
 197     suppress_error = 0;
 198     r = guestfs_lvm_remove_all (g);
 199     if (r == -1)
 200       return -1;
 201   }
 202   {
 203     char device[] = "/dev/sda";
 204     char lines_0[] = ",";
 205     char *lines[] = {
 206       lines_0,
 207       NULL
 208     };
 209     int r;
 210     suppress_error = 0;
 211     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 212     if (r == -1)
 213       return -1;
 214   }
 215   {
 216     char fstype[] = "ext2";
 217     char device[] = "/dev/sda1";
 218     int r;
 219     suppress_error = 0;
 220     r = guestfs_mkfs (g, fstype, device);
 221     if (r == -1)
 222       return -1;
 223   }
 224   {
 225     char device[] = "/dev/sda1";
 226     char mountpoint[] = "/";
 227     int r;
 228     suppress_error = 0;
 229     r = guestfs_mount (g, device, mountpoint);
 230     if (r == -1)
 231       return -1;
 232   }
 233   /* TestOutputInt for du (0) */
 234   {
 235     char path[] = "/p";
 236     int r;
 237     suppress_error = 0;
 238     r = guestfs_mkdir (g, path);
 239     if (r == -1)
 240       return -1;
 241   }
 242   {
 243     char path[] = "/p";
 244     int64_t r;
 245     suppress_error = 0;
 246     r = guestfs_du (g, path);
 247     if (r == -1)
 248       return -1;
 249     if (r != 1) {
 250       fprintf (stderr, "test_du_0: expected 1 but got %d\n",               (int) r);
 251       return -1;
 252     }
 253   }
 254   return 0;
 255 }
 256
 257 static int test_tail_n_0_skip (void)
 258 {
 259   const char *str;
 260
 261   str = getenv ("TEST_ONLY");
 262   if (str)
 263     return strstr (str, "tail_n") == NULL;
 264   str = getenv ("SKIP_TEST_TAIL_N_0");
 265   if (str && strcmp (str, "1") == 0) return 1;
 266   str = getenv ("SKIP_TEST_TAIL_N");
 267   if (str && strcmp (str, "1") == 0) return 1;
 268   return 0;
 269 }
 270
 271 static int test_tail_n_0 (void)
 272 {
 273   if (test_tail_n_0_skip ()) {
 274     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
 275     return 0;
 276   }
 277
 278   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
 279   {
 280     char device[] = "/dev/sda";
 281     int r;
 282     suppress_error = 0;
 283     r = guestfs_blockdev_setrw (g, device);
 284     if (r == -1)
 285       return -1;
 286   }
 287   {
 288     int r;
 289     suppress_error = 0;
 290     r = guestfs_umount_all (g);
 291     if (r == -1)
 292       return -1;
 293   }
 294   {
 295     int r;
 296     suppress_error = 0;
 297     r = guestfs_lvm_remove_all (g);
 298     if (r == -1)
 299       return -1;
 300   }
 301   {
 302     char device[] = "/dev/sda";
 303     char lines_0[] = ",";
 304     char *lines[] = {
 305       lines_0,
 306       NULL
 307     };
 308     int r;
 309     suppress_error = 0;
 310     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 311     if (r == -1)
 312       return -1;
 313   }
 314   {
 315     char fstype[] = "ext2";
 316     char device[] = "/dev/sda1";
 317     int r;
 318     suppress_error = 0;
 319     r = guestfs_mkfs (g, fstype, device);
 320     if (r == -1)
 321       return -1;
 322   }
 323   {
 324     char device[] = "/dev/sda1";
 325     char mountpoint[] = "/";
 326     int r;
 327     suppress_error = 0;
 328     r = guestfs_mount (g, device, mountpoint);
 329     if (r == -1)
 330       return -1;
 331   }
 332   /* TestOutputList for tail_n (0) */
 333   {
 334     char options[] = "ro";
 335     char vfstype[] = "squashfs";
 336     char device[] = "/dev/sdd";
 337     char mountpoint[] = "/";
 338     int r;
 339     suppress_error = 0;
 340     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 341     if (r == -1)
 342       return -1;
 343   }
 344   {
 345     char path[] = "/10klines";
 346     char **r;
 347     int i;
 348     suppress_error = 0;
 349     r = guestfs_tail_n (g, 3, path);
 350     if (r == NULL)
 351       return -1;
 352     if (!r[0]) {
 353       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 354       print_strings (r);
 355       return -1;
 356     }
 357     {
 358       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 359       if (strcmp (r[0], expected) != 0) {
 360         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 361         return -1;
 362       }
 363     }
 364     if (!r[1]) {
 365       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 366       print_strings (r);
 367       return -1;
 368     }
 369     {
 370       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 371       if (strcmp (r[1], expected) != 0) {
 372         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 373         return -1;
 374       }
 375     }
 376     if (!r[2]) {
 377       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 378       print_strings (r);
 379       return -1;
 380     }
 381     {
 382       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 383       if (strcmp (r[2], expected) != 0) {
 384         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 385         return -1;
 386       }
 387     }
 388     if (r[3] != NULL) {
 389       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
 390       print_strings (r);
 391       return -1;
 392     }
 393     for (i = 0; r[i] != NULL; ++i)
 394       free (r[i]);
 395     free (r);
 396   }
 397   return 0;
 398 }
 399
 400 static int test_tail_n_1_skip (void)
 401 {
 402   const char *str;
 403
 404   str = getenv ("TEST_ONLY");
 405   if (str)
 406     return strstr (str, "tail_n") == NULL;
 407   str = getenv ("SKIP_TEST_TAIL_N_1");
 408   if (str && strcmp (str, "1") == 0) return 1;
 409   str = getenv ("SKIP_TEST_TAIL_N");
 410   if (str && strcmp (str, "1") == 0) return 1;
 411   return 0;
 412 }
 413
 414 static int test_tail_n_1 (void)
 415 {
 416   if (test_tail_n_1_skip ()) {
 417     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
 418     return 0;
 419   }
 420
 421   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
 422   {
 423     char device[] = "/dev/sda";
 424     int r;
 425     suppress_error = 0;
 426     r = guestfs_blockdev_setrw (g, device);
 427     if (r == -1)
 428       return -1;
 429   }
 430   {
 431     int r;
 432     suppress_error = 0;
 433     r = guestfs_umount_all (g);
 434     if (r == -1)
 435       return -1;
 436   }
 437   {
 438     int r;
 439     suppress_error = 0;
 440     r = guestfs_lvm_remove_all (g);
 441     if (r == -1)
 442       return -1;
 443   }
 444   {
 445     char device[] = "/dev/sda";
 446     char lines_0[] = ",";
 447     char *lines[] = {
 448       lines_0,
 449       NULL
 450     };
 451     int r;
 452     suppress_error = 0;
 453     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 454     if (r == -1)
 455       return -1;
 456   }
 457   {
 458     char fstype[] = "ext2";
 459     char device[] = "/dev/sda1";
 460     int r;
 461     suppress_error = 0;
 462     r = guestfs_mkfs (g, fstype, device);
 463     if (r == -1)
 464       return -1;
 465   }
 466   {
 467     char device[] = "/dev/sda1";
 468     char mountpoint[] = "/";
 469     int r;
 470     suppress_error = 0;
 471     r = guestfs_mount (g, device, mountpoint);
 472     if (r == -1)
 473       return -1;
 474   }
 475   /* TestOutputList for tail_n (1) */
 476   {
 477     char options[] = "ro";
 478     char vfstype[] = "squashfs";
 479     char device[] = "/dev/sdd";
 480     char mountpoint[] = "/";
 481     int r;
 482     suppress_error = 0;
 483     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 484     if (r == -1)
 485       return -1;
 486   }
 487   {
 488     char path[] = "/10klines";
 489     char **r;
 490     int i;
 491     suppress_error = 0;
 492     r = guestfs_tail_n (g, -9998, path);
 493     if (r == NULL)
 494       return -1;
 495     if (!r[0]) {
 496       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 497       print_strings (r);
 498       return -1;
 499     }
 500     {
 501       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 502       if (strcmp (r[0], expected) != 0) {
 503         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 504         return -1;
 505       }
 506     }
 507     if (!r[1]) {
 508       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 509       print_strings (r);
 510       return -1;
 511     }
 512     {
 513       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 514       if (strcmp (r[1], expected) != 0) {
 515         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 516         return -1;
 517       }
 518     }
 519     if (!r[2]) {
 520       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 521       print_strings (r);
 522       return -1;
 523     }
 524     {
 525       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 526       if (strcmp (r[2], expected) != 0) {
 527         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 528         return -1;
 529       }
 530     }
 531     if (r[3] != NULL) {
 532       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
 533       print_strings (r);
 534       return -1;
 535     }
 536     for (i = 0; r[i] != NULL; ++i)
 537       free (r[i]);
 538     free (r);
 539   }
 540   return 0;
 541 }
 542
 543 static int test_tail_n_2_skip (void)
 544 {
 545   const char *str;
 546
 547   str = getenv ("TEST_ONLY");
 548   if (str)
 549     return strstr (str, "tail_n") == NULL;
 550   str = getenv ("SKIP_TEST_TAIL_N_2");
 551   if (str && strcmp (str, "1") == 0) return 1;
 552   str = getenv ("SKIP_TEST_TAIL_N");
 553   if (str && strcmp (str, "1") == 0) return 1;
 554   return 0;
 555 }
 556
 557 static int test_tail_n_2 (void)
 558 {
 559   if (test_tail_n_2_skip ()) {
 560     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
 561     return 0;
 562   }
 563
 564   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
 565   {
 566     char device[] = "/dev/sda";
 567     int r;
 568     suppress_error = 0;
 569     r = guestfs_blockdev_setrw (g, device);
 570     if (r == -1)
 571       return -1;
 572   }
 573   {
 574     int r;
 575     suppress_error = 0;
 576     r = guestfs_umount_all (g);
 577     if (r == -1)
 578       return -1;
 579   }
 580   {
 581     int r;
 582     suppress_error = 0;
 583     r = guestfs_lvm_remove_all (g);
 584     if (r == -1)
 585       return -1;
 586   }
 587   {
 588     char device[] = "/dev/sda";
 589     char lines_0[] = ",";
 590     char *lines[] = {
 591       lines_0,
 592       NULL
 593     };
 594     int r;
 595     suppress_error = 0;
 596     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 597     if (r == -1)
 598       return -1;
 599   }
 600   {
 601     char fstype[] = "ext2";
 602     char device[] = "/dev/sda1";
 603     int r;
 604     suppress_error = 0;
 605     r = guestfs_mkfs (g, fstype, device);
 606     if (r == -1)
 607       return -1;
 608   }
 609   {
 610     char device[] = "/dev/sda1";
 611     char mountpoint[] = "/";
 612     int r;
 613     suppress_error = 0;
 614     r = guestfs_mount (g, device, mountpoint);
 615     if (r == -1)
 616       return -1;
 617   }
 618   /* TestOutputList for tail_n (2) */
 619   {
 620     char options[] = "ro";
 621     char vfstype[] = "squashfs";
 622     char device[] = "/dev/sdd";
 623     char mountpoint[] = "/";
 624     int r;
 625     suppress_error = 0;
 626     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 627     if (r == -1)
 628       return -1;
 629   }
 630   {
 631     char path[] = "/10klines";
 632     char **r;
 633     int i;
 634     suppress_error = 0;
 635     r = guestfs_tail_n (g, 0, path);
 636     if (r == NULL)
 637       return -1;
 638     if (r[0] != NULL) {
 639       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
 640       print_strings (r);
 641       return -1;
 642     }
 643     for (i = 0; r[i] != NULL; ++i)
 644       free (r[i]);
 645     free (r);
 646   }
 647   return 0;
 648 }
 649
 650 static int test_tail_0_skip (void)
 651 {
 652   const char *str;
 653
 654   str = getenv ("TEST_ONLY");
 655   if (str)
 656     return strstr (str, "tail") == NULL;
 657   str = getenv ("SKIP_TEST_TAIL_0");
 658   if (str && strcmp (str, "1") == 0) return 1;
 659   str = getenv ("SKIP_TEST_TAIL");
 660   if (str && strcmp (str, "1") == 0) return 1;
 661   return 0;
 662 }
 663
 664 static int test_tail_0 (void)
 665 {
 666   if (test_tail_0_skip ()) {
 667     printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
 668     return 0;
 669   }
 670
 671   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
 672   {
 673     char device[] = "/dev/sda";
 674     int r;
 675     suppress_error = 0;
 676     r = guestfs_blockdev_setrw (g, device);
 677     if (r == -1)
 678       return -1;
 679   }
 680   {
 681     int r;
 682     suppress_error = 0;
 683     r = guestfs_umount_all (g);
 684     if (r == -1)
 685       return -1;
 686   }
 687   {
 688     int r;
 689     suppress_error = 0;
 690     r = guestfs_lvm_remove_all (g);
 691     if (r == -1)
 692       return -1;
 693   }
 694   {
 695     char device[] = "/dev/sda";
 696     char lines_0[] = ",";
 697     char *lines[] = {
 698       lines_0,
 699       NULL
 700     };
 701     int r;
 702     suppress_error = 0;
 703     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 704     if (r == -1)
 705       return -1;
 706   }
 707   {
 708     char fstype[] = "ext2";
 709     char device[] = "/dev/sda1";
 710     int r;
 711     suppress_error = 0;
 712     r = guestfs_mkfs (g, fstype, device);
 713     if (r == -1)
 714       return -1;
 715   }
 716   {
 717     char device[] = "/dev/sda1";
 718     char mountpoint[] = "/";
 719     int r;
 720     suppress_error = 0;
 721     r = guestfs_mount (g, device, mountpoint);
 722     if (r == -1)
 723       return -1;
 724   }
 725   /* TestOutputList for tail (0) */
 726   {
 727     char options[] = "ro";
 728     char vfstype[] = "squashfs";
 729     char device[] = "/dev/sdd";
 730     char mountpoint[] = "/";
 731     int r;
 732     suppress_error = 0;
 733     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 734     if (r == -1)
 735       return -1;
 736   }
 737   {
 738     char path[] = "/10klines";
 739     char **r;
 740     int i;
 741     suppress_error = 0;
 742     r = guestfs_tail (g, path);
 743     if (r == NULL)
 744       return -1;
 745     if (!r[0]) {
 746       fprintf (stderr, "test_tail_0: short list returned from command\n");
 747       print_strings (r);
 748       return -1;
 749     }
 750     {
 751       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
 752       if (strcmp (r[0], expected) != 0) {
 753         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 754         return -1;
 755       }
 756     }
 757     if (!r[1]) {
 758       fprintf (stderr, "test_tail_0: short list returned from command\n");
 759       print_strings (r);
 760       return -1;
 761     }
 762     {
 763       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
 764       if (strcmp (r[1], expected) != 0) {
 765         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 766         return -1;
 767       }
 768     }
 769     if (!r[2]) {
 770       fprintf (stderr, "test_tail_0: short list returned from command\n");
 771       print_strings (r);
 772       return -1;
 773     }
 774     {
 775       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
 776       if (strcmp (r[2], expected) != 0) {
 777         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 778         return -1;
 779       }
 780     }
 781     if (!r[3]) {
 782       fprintf (stderr, "test_tail_0: short list returned from command\n");
 783       print_strings (r);
 784       return -1;
 785     }
 786     {
 787       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
 788       if (strcmp (r[3], expected) != 0) {
 789         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 790         return -1;
 791       }
 792     }
 793     if (!r[4]) {
 794       fprintf (stderr, "test_tail_0: short list returned from command\n");
 795       print_strings (r);
 796       return -1;
 797     }
 798     {
 799       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
 800       if (strcmp (r[4], expected) != 0) {
 801         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
 802         return -1;
 803       }
 804     }
 805     if (!r[5]) {
 806       fprintf (stderr, "test_tail_0: short list returned from command\n");
 807       print_strings (r);
 808       return -1;
 809     }
 810     {
 811       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
 812       if (strcmp (r[5], expected) != 0) {
 813         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
 814         return -1;
 815       }
 816     }
 817     if (!r[6]) {
 818       fprintf (stderr, "test_tail_0: short list returned from command\n");
 819       print_strings (r);
 820       return -1;
 821     }
 822     {
 823       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
 824       if (strcmp (r[6], expected) != 0) {
 825         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
 826         return -1;
 827       }
 828     }
 829     if (!r[7]) {
 830       fprintf (stderr, "test_tail_0: short list returned from command\n");
 831       print_strings (r);
 832       return -1;
 833     }
 834     {
 835       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 836       if (strcmp (r[7], expected) != 0) {
 837         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
 838         return -1;
 839       }
 840     }
 841     if (!r[8]) {
 842       fprintf (stderr, "test_tail_0: short list returned from command\n");
 843       print_strings (r);
 844       return -1;
 845     }
 846     {
 847       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 848       if (strcmp (r[8], expected) != 0) {
 849         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
 850         return -1;
 851       }
 852     }
 853     if (!r[9]) {
 854       fprintf (stderr, "test_tail_0: short list returned from command\n");
 855       print_strings (r);
 856       return -1;
 857     }
 858     {
 859       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 860       if (strcmp (r[9], expected) != 0) {
 861         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
 862         return -1;
 863       }
 864     }
 865     if (r[10] != NULL) {
 866       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
 867       print_strings (r);
 868       return -1;
 869     }
 870     for (i = 0; r[i] != NULL; ++i)
 871       free (r[i]);
 872     free (r);
 873   }
 874   return 0;
 875 }
 876
 877 static int test_head_n_0_skip (void)
 878 {
 879   const char *str;
 880
 881   str = getenv ("TEST_ONLY");
 882   if (str)
 883     return strstr (str, "head_n") == NULL;
 884   str = getenv ("SKIP_TEST_HEAD_N_0");
 885   if (str && strcmp (str, "1") == 0) return 1;
 886   str = getenv ("SKIP_TEST_HEAD_N");
 887   if (str && strcmp (str, "1") == 0) return 1;
 888   return 0;
 889 }
 890
 891 static int test_head_n_0 (void)
 892 {
 893   if (test_head_n_0_skip ()) {
 894     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
 895     return 0;
 896   }
 897
 898   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
 899   {
 900     char device[] = "/dev/sda";
 901     int r;
 902     suppress_error = 0;
 903     r = guestfs_blockdev_setrw (g, device);
 904     if (r == -1)
 905       return -1;
 906   }
 907   {
 908     int r;
 909     suppress_error = 0;
 910     r = guestfs_umount_all (g);
 911     if (r == -1)
 912       return -1;
 913   }
 914   {
 915     int r;
 916     suppress_error = 0;
 917     r = guestfs_lvm_remove_all (g);
 918     if (r == -1)
 919       return -1;
 920   }
 921   {
 922     char device[] = "/dev/sda";
 923     char lines_0[] = ",";
 924     char *lines[] = {
 925       lines_0,
 926       NULL
 927     };
 928     int r;
 929     suppress_error = 0;
 930     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 931     if (r == -1)
 932       return -1;
 933   }
 934   {
 935     char fstype[] = "ext2";
 936     char device[] = "/dev/sda1";
 937     int r;
 938     suppress_error = 0;
 939     r = guestfs_mkfs (g, fstype, device);
 940     if (r == -1)
 941       return -1;
 942   }
 943   {
 944     char device[] = "/dev/sda1";
 945     char mountpoint[] = "/";
 946     int r;
 947     suppress_error = 0;
 948     r = guestfs_mount (g, device, mountpoint);
 949     if (r == -1)
 950       return -1;
 951   }
 952   /* TestOutputList for head_n (0) */
 953   {
 954     char options[] = "ro";
 955     char vfstype[] = "squashfs";
 956     char device[] = "/dev/sdd";
 957     char mountpoint[] = "/";
 958     int r;
 959     suppress_error = 0;
 960     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 961     if (r == -1)
 962       return -1;
 963   }
 964   {
 965     char path[] = "/10klines";
 966     char **r;
 967     int i;
 968     suppress_error = 0;
 969     r = guestfs_head_n (g, 3, path);
 970     if (r == NULL)
 971       return -1;
 972     if (!r[0]) {
 973       fprintf (stderr, "test_head_n_0: short list returned from command\n");
 974       print_strings (r);
 975       return -1;
 976     }
 977     {
 978       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
 979       if (strcmp (r[0], expected) != 0) {
 980         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 981         return -1;
 982       }
 983     }
 984     if (!r[1]) {
 985       fprintf (stderr, "test_head_n_0: short list returned from command\n");
 986       print_strings (r);
 987       return -1;
 988     }
 989     {
 990       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
 991       if (strcmp (r[1], expected) != 0) {
 992         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 993         return -1;
 994       }
 995     }
 996     if (!r[2]) {
 997       fprintf (stderr, "test_head_n_0: short list returned from command\n");
 998       print_strings (r);
 999       return -1;
1000     }
1001     {
1002       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1003       if (strcmp (r[2], expected) != 0) {
1004         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1005         return -1;
1006       }
1007     }
1008     if (r[3] != NULL) {
1009       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1010       print_strings (r);
1011       return -1;
1012     }
1013     for (i = 0; r[i] != NULL; ++i)
1014       free (r[i]);
1015     free (r);
1016   }
1017   return 0;
1018 }
1019
1020 static int test_head_n_1_skip (void)
1021 {
1022   const char *str;
1023
1024   str = getenv ("TEST_ONLY");
1025   if (str)
1026     return strstr (str, "head_n") == NULL;
1027   str = getenv ("SKIP_TEST_HEAD_N_1");
1028   if (str && strcmp (str, "1") == 0) return 1;
1029   str = getenv ("SKIP_TEST_HEAD_N");
1030   if (str && strcmp (str, "1") == 0) return 1;
1031   return 0;
1032 }
1033
1034 static int test_head_n_1 (void)
1035 {
1036   if (test_head_n_1_skip ()) {
1037     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1038     return 0;
1039   }
1040
1041   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1042   {
1043     char device[] = "/dev/sda";
1044     int r;
1045     suppress_error = 0;
1046     r = guestfs_blockdev_setrw (g, device);
1047     if (r == -1)
1048       return -1;
1049   }
1050   {
1051     int r;
1052     suppress_error = 0;
1053     r = guestfs_umount_all (g);
1054     if (r == -1)
1055       return -1;
1056   }
1057   {
1058     int r;
1059     suppress_error = 0;
1060     r = guestfs_lvm_remove_all (g);
1061     if (r == -1)
1062       return -1;
1063   }
1064   {
1065     char device[] = "/dev/sda";
1066     char lines_0[] = ",";
1067     char *lines[] = {
1068       lines_0,
1069       NULL
1070     };
1071     int r;
1072     suppress_error = 0;
1073     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1074     if (r == -1)
1075       return -1;
1076   }
1077   {
1078     char fstype[] = "ext2";
1079     char device[] = "/dev/sda1";
1080     int r;
1081     suppress_error = 0;
1082     r = guestfs_mkfs (g, fstype, device);
1083     if (r == -1)
1084       return -1;
1085   }
1086   {
1087     char device[] = "/dev/sda1";
1088     char mountpoint[] = "/";
1089     int r;
1090     suppress_error = 0;
1091     r = guestfs_mount (g, device, mountpoint);
1092     if (r == -1)
1093       return -1;
1094   }
1095   /* TestOutputList for head_n (1) */
1096   {
1097     char options[] = "ro";
1098     char vfstype[] = "squashfs";
1099     char device[] = "/dev/sdd";
1100     char mountpoint[] = "/";
1101     int r;
1102     suppress_error = 0;
1103     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1104     if (r == -1)
1105       return -1;
1106   }
1107   {
1108     char path[] = "/10klines";
1109     char **r;
1110     int i;
1111     suppress_error = 0;
1112     r = guestfs_head_n (g, -9997, path);
1113     if (r == NULL)
1114       return -1;
1115     if (!r[0]) {
1116       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1117       print_strings (r);
1118       return -1;
1119     }
1120     {
1121       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1122       if (strcmp (r[0], expected) != 0) {
1123         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1124         return -1;
1125       }
1126     }
1127     if (!r[1]) {
1128       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1129       print_strings (r);
1130       return -1;
1131     }
1132     {
1133       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1134       if (strcmp (r[1], expected) != 0) {
1135         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1136         return -1;
1137       }
1138     }
1139     if (!r[2]) {
1140       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1141       print_strings (r);
1142       return -1;
1143     }
1144     {
1145       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1146       if (strcmp (r[2], expected) != 0) {
1147         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1148         return -1;
1149       }
1150     }
1151     if (r[3] != NULL) {
1152       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1153       print_strings (r);
1154       return -1;
1155     }
1156     for (i = 0; r[i] != NULL; ++i)
1157       free (r[i]);
1158     free (r);
1159   }
1160   return 0;
1161 }
1162
1163 static int test_head_n_2_skip (void)
1164 {
1165   const char *str;
1166
1167   str = getenv ("TEST_ONLY");
1168   if (str)
1169     return strstr (str, "head_n") == NULL;
1170   str = getenv ("SKIP_TEST_HEAD_N_2");
1171   if (str && strcmp (str, "1") == 0) return 1;
1172   str = getenv ("SKIP_TEST_HEAD_N");
1173   if (str && strcmp (str, "1") == 0) return 1;
1174   return 0;
1175 }
1176
1177 static int test_head_n_2 (void)
1178 {
1179   if (test_head_n_2_skip ()) {
1180     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1181     return 0;
1182   }
1183
1184   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1185   {
1186     char device[] = "/dev/sda";
1187     int r;
1188     suppress_error = 0;
1189     r = guestfs_blockdev_setrw (g, device);
1190     if (r == -1)
1191       return -1;
1192   }
1193   {
1194     int r;
1195     suppress_error = 0;
1196     r = guestfs_umount_all (g);
1197     if (r == -1)
1198       return -1;
1199   }
1200   {
1201     int r;
1202     suppress_error = 0;
1203     r = guestfs_lvm_remove_all (g);
1204     if (r == -1)
1205       return -1;
1206   }
1207   {
1208     char device[] = "/dev/sda";
1209     char lines_0[] = ",";
1210     char *lines[] = {
1211       lines_0,
1212       NULL
1213     };
1214     int r;
1215     suppress_error = 0;
1216     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1217     if (r == -1)
1218       return -1;
1219   }
1220   {
1221     char fstype[] = "ext2";
1222     char device[] = "/dev/sda1";
1223     int r;
1224     suppress_error = 0;
1225     r = guestfs_mkfs (g, fstype, device);
1226     if (r == -1)
1227       return -1;
1228   }
1229   {
1230     char device[] = "/dev/sda1";
1231     char mountpoint[] = "/";
1232     int r;
1233     suppress_error = 0;
1234     r = guestfs_mount (g, device, mountpoint);
1235     if (r == -1)
1236       return -1;
1237   }
1238   /* TestOutputList for head_n (2) */
1239   {
1240     char options[] = "ro";
1241     char vfstype[] = "squashfs";
1242     char device[] = "/dev/sdd";
1243     char mountpoint[] = "/";
1244     int r;
1245     suppress_error = 0;
1246     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1247     if (r == -1)
1248       return -1;
1249   }
1250   {
1251     char path[] = "/10klines";
1252     char **r;
1253     int i;
1254     suppress_error = 0;
1255     r = guestfs_head_n (g, 0, path);
1256     if (r == NULL)
1257       return -1;
1258     if (r[0] != NULL) {
1259       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1260       print_strings (r);
1261       return -1;
1262     }
1263     for (i = 0; r[i] != NULL; ++i)
1264       free (r[i]);
1265     free (r);
1266   }
1267   return 0;
1268 }
1269
1270 static int test_head_0_skip (void)
1271 {
1272   const char *str;
1273
1274   str = getenv ("TEST_ONLY");
1275   if (str)
1276     return strstr (str, "head") == NULL;
1277   str = getenv ("SKIP_TEST_HEAD_0");
1278   if (str && strcmp (str, "1") == 0) return 1;
1279   str = getenv ("SKIP_TEST_HEAD");
1280   if (str && strcmp (str, "1") == 0) return 1;
1281   return 0;
1282 }
1283
1284 static int test_head_0 (void)
1285 {
1286   if (test_head_0_skip ()) {
1287     printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1288     return 0;
1289   }
1290
1291   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1292   {
1293     char device[] = "/dev/sda";
1294     int r;
1295     suppress_error = 0;
1296     r = guestfs_blockdev_setrw (g, device);
1297     if (r == -1)
1298       return -1;
1299   }
1300   {
1301     int r;
1302     suppress_error = 0;
1303     r = guestfs_umount_all (g);
1304     if (r == -1)
1305       return -1;
1306   }
1307   {
1308     int r;
1309     suppress_error = 0;
1310     r = guestfs_lvm_remove_all (g);
1311     if (r == -1)
1312       return -1;
1313   }
1314   {
1315     char device[] = "/dev/sda";
1316     char lines_0[] = ",";
1317     char *lines[] = {
1318       lines_0,
1319       NULL
1320     };
1321     int r;
1322     suppress_error = 0;
1323     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1324     if (r == -1)
1325       return -1;
1326   }
1327   {
1328     char fstype[] = "ext2";
1329     char device[] = "/dev/sda1";
1330     int r;
1331     suppress_error = 0;
1332     r = guestfs_mkfs (g, fstype, device);
1333     if (r == -1)
1334       return -1;
1335   }
1336   {
1337     char device[] = "/dev/sda1";
1338     char mountpoint[] = "/";
1339     int r;
1340     suppress_error = 0;
1341     r = guestfs_mount (g, device, mountpoint);
1342     if (r == -1)
1343       return -1;
1344   }
1345   /* TestOutputList for head (0) */
1346   {
1347     char options[] = "ro";
1348     char vfstype[] = "squashfs";
1349     char device[] = "/dev/sdd";
1350     char mountpoint[] = "/";
1351     int r;
1352     suppress_error = 0;
1353     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1354     if (r == -1)
1355       return -1;
1356   }
1357   {
1358     char path[] = "/10klines";
1359     char **r;
1360     int i;
1361     suppress_error = 0;
1362     r = guestfs_head (g, path);
1363     if (r == NULL)
1364       return -1;
1365     if (!r[0]) {
1366       fprintf (stderr, "test_head_0: short list returned from command\n");
1367       print_strings (r);
1368       return -1;
1369     }
1370     {
1371       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1372       if (strcmp (r[0], expected) != 0) {
1373         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1374         return -1;
1375       }
1376     }
1377     if (!r[1]) {
1378       fprintf (stderr, "test_head_0: short list returned from command\n");
1379       print_strings (r);
1380       return -1;
1381     }
1382     {
1383       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1384       if (strcmp (r[1], expected) != 0) {
1385         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1386         return -1;
1387       }
1388     }
1389     if (!r[2]) {
1390       fprintf (stderr, "test_head_0: short list returned from command\n");
1391       print_strings (r);
1392       return -1;
1393     }
1394     {
1395       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1396       if (strcmp (r[2], expected) != 0) {
1397         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1398         return -1;
1399       }
1400     }
1401     if (!r[3]) {
1402       fprintf (stderr, "test_head_0: short list returned from command\n");
1403       print_strings (r);
1404       return -1;
1405     }
1406     {
1407       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1408       if (strcmp (r[3], expected) != 0) {
1409         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1410         return -1;
1411       }
1412     }
1413     if (!r[4]) {
1414       fprintf (stderr, "test_head_0: short list returned from command\n");
1415       print_strings (r);
1416       return -1;
1417     }
1418     {
1419       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1420       if (strcmp (r[4], expected) != 0) {
1421         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1422         return -1;
1423       }
1424     }
1425     if (!r[5]) {
1426       fprintf (stderr, "test_head_0: short list returned from command\n");
1427       print_strings (r);
1428       return -1;
1429     }
1430     {
1431       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1432       if (strcmp (r[5], expected) != 0) {
1433         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1434         return -1;
1435       }
1436     }
1437     if (!r[6]) {
1438       fprintf (stderr, "test_head_0: short list returned from command\n");
1439       print_strings (r);
1440       return -1;
1441     }
1442     {
1443       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1444       if (strcmp (r[6], expected) != 0) {
1445         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1446         return -1;
1447       }
1448     }
1449     if (!r[7]) {
1450       fprintf (stderr, "test_head_0: short list returned from command\n");
1451       print_strings (r);
1452       return -1;
1453     }
1454     {
1455       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1456       if (strcmp (r[7], expected) != 0) {
1457         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1458         return -1;
1459       }
1460     }
1461     if (!r[8]) {
1462       fprintf (stderr, "test_head_0: short list returned from command\n");
1463       print_strings (r);
1464       return -1;
1465     }
1466     {
1467       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1468       if (strcmp (r[8], expected) != 0) {
1469         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1470         return -1;
1471       }
1472     }
1473     if (!r[9]) {
1474       fprintf (stderr, "test_head_0: short list returned from command\n");
1475       print_strings (r);
1476       return -1;
1477     }
1478     {
1479       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1480       if (strcmp (r[9], expected) != 0) {
1481         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1482         return -1;
1483       }
1484     }
1485     if (r[10] != NULL) {
1486       fprintf (stderr, "test_head_0: extra elements returned from command\n");
1487       print_strings (r);
1488       return -1;
1489     }
1490     for (i = 0; r[i] != NULL; ++i)
1491       free (r[i]);
1492     free (r);
1493   }
1494   return 0;
1495 }
1496
1497 static int test_wc_c_0_skip (void)
1498 {
1499   const char *str;
1500
1501   str = getenv ("TEST_ONLY");
1502   if (str)
1503     return strstr (str, "wc_c") == NULL;
1504   str = getenv ("SKIP_TEST_WC_C_0");
1505   if (str && strcmp (str, "1") == 0) return 1;
1506   str = getenv ("SKIP_TEST_WC_C");
1507   if (str && strcmp (str, "1") == 0) return 1;
1508   return 0;
1509 }
1510
1511 static int test_wc_c_0 (void)
1512 {
1513   if (test_wc_c_0_skip ()) {
1514     printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1515     return 0;
1516   }
1517
1518   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1519   {
1520     char device[] = "/dev/sda";
1521     int r;
1522     suppress_error = 0;
1523     r = guestfs_blockdev_setrw (g, device);
1524     if (r == -1)
1525       return -1;
1526   }
1527   {
1528     int r;
1529     suppress_error = 0;
1530     r = guestfs_umount_all (g);
1531     if (r == -1)
1532       return -1;
1533   }
1534   {
1535     int r;
1536     suppress_error = 0;
1537     r = guestfs_lvm_remove_all (g);
1538     if (r == -1)
1539       return -1;
1540   }
1541   {
1542     char device[] = "/dev/sda";
1543     char lines_0[] = ",";
1544     char *lines[] = {
1545       lines_0,
1546       NULL
1547     };
1548     int r;
1549     suppress_error = 0;
1550     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1551     if (r == -1)
1552       return -1;
1553   }
1554   {
1555     char fstype[] = "ext2";
1556     char device[] = "/dev/sda1";
1557     int r;
1558     suppress_error = 0;
1559     r = guestfs_mkfs (g, fstype, device);
1560     if (r == -1)
1561       return -1;
1562   }
1563   {
1564     char device[] = "/dev/sda1";
1565     char mountpoint[] = "/";
1566     int r;
1567     suppress_error = 0;
1568     r = guestfs_mount (g, device, mountpoint);
1569     if (r == -1)
1570       return -1;
1571   }
1572   /* TestOutputInt for wc_c (0) */
1573   {
1574     char options[] = "ro";
1575     char vfstype[] = "squashfs";
1576     char device[] = "/dev/sdd";
1577     char mountpoint[] = "/";
1578     int r;
1579     suppress_error = 0;
1580     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1581     if (r == -1)
1582       return -1;
1583   }
1584   {
1585     char path[] = "/100kallspaces";
1586     int r;
1587     suppress_error = 0;
1588     r = guestfs_wc_c (g, path);
1589     if (r == -1)
1590       return -1;
1591     if (r != 102400) {
1592       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
1593       return -1;
1594     }
1595   }
1596   return 0;
1597 }
1598
1599 static int test_wc_w_0_skip (void)
1600 {
1601   const char *str;
1602
1603   str = getenv ("TEST_ONLY");
1604   if (str)
1605     return strstr (str, "wc_w") == NULL;
1606   str = getenv ("SKIP_TEST_WC_W_0");
1607   if (str && strcmp (str, "1") == 0) return 1;
1608   str = getenv ("SKIP_TEST_WC_W");
1609   if (str && strcmp (str, "1") == 0) return 1;
1610   return 0;
1611 }
1612
1613 static int test_wc_w_0 (void)
1614 {
1615   if (test_wc_w_0_skip ()) {
1616     printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1617     return 0;
1618   }
1619
1620   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1621   {
1622     char device[] = "/dev/sda";
1623     int r;
1624     suppress_error = 0;
1625     r = guestfs_blockdev_setrw (g, device);
1626     if (r == -1)
1627       return -1;
1628   }
1629   {
1630     int r;
1631     suppress_error = 0;
1632     r = guestfs_umount_all (g);
1633     if (r == -1)
1634       return -1;
1635   }
1636   {
1637     int r;
1638     suppress_error = 0;
1639     r = guestfs_lvm_remove_all (g);
1640     if (r == -1)
1641       return -1;
1642   }
1643   {
1644     char device[] = "/dev/sda";
1645     char lines_0[] = ",";
1646     char *lines[] = {
1647       lines_0,
1648       NULL
1649     };
1650     int r;
1651     suppress_error = 0;
1652     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1653     if (r == -1)
1654       return -1;
1655   }
1656   {
1657     char fstype[] = "ext2";
1658     char device[] = "/dev/sda1";
1659     int r;
1660     suppress_error = 0;
1661     r = guestfs_mkfs (g, fstype, device);
1662     if (r == -1)
1663       return -1;
1664   }
1665   {
1666     char device[] = "/dev/sda1";
1667     char mountpoint[] = "/";
1668     int r;
1669     suppress_error = 0;
1670     r = guestfs_mount (g, device, mountpoint);
1671     if (r == -1)
1672       return -1;
1673   }
1674   /* TestOutputInt for wc_w (0) */
1675   {
1676     char options[] = "ro";
1677     char vfstype[] = "squashfs";
1678     char device[] = "/dev/sdd";
1679     char mountpoint[] = "/";
1680     int r;
1681     suppress_error = 0;
1682     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1683     if (r == -1)
1684       return -1;
1685   }
1686   {
1687     char path[] = "/10klines";
1688     int r;
1689     suppress_error = 0;
1690     r = guestfs_wc_w (g, path);
1691     if (r == -1)
1692       return -1;
1693     if (r != 10000) {
1694       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
1695       return -1;
1696     }
1697   }
1698   return 0;
1699 }
1700
1701 static int test_wc_l_0_skip (void)
1702 {
1703   const char *str;
1704
1705   str = getenv ("TEST_ONLY");
1706   if (str)
1707     return strstr (str, "wc_l") == NULL;
1708   str = getenv ("SKIP_TEST_WC_L_0");
1709   if (str && strcmp (str, "1") == 0) return 1;
1710   str = getenv ("SKIP_TEST_WC_L");
1711   if (str && strcmp (str, "1") == 0) return 1;
1712   return 0;
1713 }
1714
1715 static int test_wc_l_0 (void)
1716 {
1717   if (test_wc_l_0_skip ()) {
1718     printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
1719     return 0;
1720   }
1721
1722   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
1723   {
1724     char device[] = "/dev/sda";
1725     int r;
1726     suppress_error = 0;
1727     r = guestfs_blockdev_setrw (g, device);
1728     if (r == -1)
1729       return -1;
1730   }
1731   {
1732     int r;
1733     suppress_error = 0;
1734     r = guestfs_umount_all (g);
1735     if (r == -1)
1736       return -1;
1737   }
1738   {
1739     int r;
1740     suppress_error = 0;
1741     r = guestfs_lvm_remove_all (g);
1742     if (r == -1)
1743       return -1;
1744   }
1745   {
1746     char device[] = "/dev/sda";
1747     char lines_0[] = ",";
1748     char *lines[] = {
1749       lines_0,
1750       NULL
1751     };
1752     int r;
1753     suppress_error = 0;
1754     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1755     if (r == -1)
1756       return -1;
1757   }
1758   {
1759     char fstype[] = "ext2";
1760     char device[] = "/dev/sda1";
1761     int r;
1762     suppress_error = 0;
1763     r = guestfs_mkfs (g, fstype, device);
1764     if (r == -1)
1765       return -1;
1766   }
1767   {
1768     char device[] = "/dev/sda1";
1769     char mountpoint[] = "/";
1770     int r;
1771     suppress_error = 0;
1772     r = guestfs_mount (g, device, mountpoint);
1773     if (r == -1)
1774       return -1;
1775   }
1776   /* TestOutputInt for wc_l (0) */
1777   {
1778     char options[] = "ro";
1779     char vfstype[] = "squashfs";
1780     char device[] = "/dev/sdd";
1781     char mountpoint[] = "/";
1782     int r;
1783     suppress_error = 0;
1784     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1785     if (r == -1)
1786       return -1;
1787   }
1788   {
1789     char path[] = "/10klines";
1790     int r;
1791     suppress_error = 0;
1792     r = guestfs_wc_l (g, path);
1793     if (r == -1)
1794       return -1;
1795     if (r != 10000) {
1796       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
1797       return -1;
1798     }
1799   }
1800   return 0;
1801 }
1802
1803 static int test_mkdtemp_0_skip (void)
1804 {
1805   const char *str;
1806
1807   str = getenv ("TEST_ONLY");
1808   if (str)
1809     return strstr (str, "mkdtemp") == NULL;
1810   str = getenv ("SKIP_TEST_MKDTEMP_0");
1811   if (str && strcmp (str, "1") == 0) return 1;
1812   str = getenv ("SKIP_TEST_MKDTEMP");
1813   if (str && strcmp (str, "1") == 0) return 1;
1814   return 0;
1815 }
1816
1817 static int test_mkdtemp_0 (void)
1818 {
1819   if (test_mkdtemp_0_skip ()) {
1820     printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
1821     return 0;
1822   }
1823
1824   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
1825   {
1826     char device[] = "/dev/sda";
1827     int r;
1828     suppress_error = 0;
1829     r = guestfs_blockdev_setrw (g, device);
1830     if (r == -1)
1831       return -1;
1832   }
1833   {
1834     int r;
1835     suppress_error = 0;
1836     r = guestfs_umount_all (g);
1837     if (r == -1)
1838       return -1;
1839   }
1840   {
1841     int r;
1842     suppress_error = 0;
1843     r = guestfs_lvm_remove_all (g);
1844     if (r == -1)
1845       return -1;
1846   }
1847   {
1848     char device[] = "/dev/sda";
1849     char lines_0[] = ",";
1850     char *lines[] = {
1851       lines_0,
1852       NULL
1853     };
1854     int r;
1855     suppress_error = 0;
1856     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1857     if (r == -1)
1858       return -1;
1859   }
1860   {
1861     char fstype[] = "ext2";
1862     char device[] = "/dev/sda1";
1863     int r;
1864     suppress_error = 0;
1865     r = guestfs_mkfs (g, fstype, device);
1866     if (r == -1)
1867       return -1;
1868   }
1869   {
1870     char device[] = "/dev/sda1";
1871     char mountpoint[] = "/";
1872     int r;
1873     suppress_error = 0;
1874     r = guestfs_mount (g, device, mountpoint);
1875     if (r == -1)
1876       return -1;
1877   }
1878   /* TestRun for mkdtemp (0) */
1879   {
1880     char path[] = "/tmp";
1881     int r;
1882     suppress_error = 0;
1883     r = guestfs_mkdir (g, path);
1884     if (r == -1)
1885       return -1;
1886   }
1887   {
1888     char template[] = "/tmp/tmpXXXXXX";
1889     char *r;
1890     suppress_error = 0;
1891     r = guestfs_mkdtemp (g, template);
1892     if (r == NULL)
1893       return -1;
1894     free (r);
1895   }
1896   return 0;
1897 }
1898
1899 static int test_scrub_file_0_skip (void)
1900 {
1901   const char *str;
1902
1903   str = getenv ("TEST_ONLY");
1904   if (str)
1905     return strstr (str, "scrub_file") == NULL;
1906   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
1907   if (str && strcmp (str, "1") == 0) return 1;
1908   str = getenv ("SKIP_TEST_SCRUB_FILE");
1909   if (str && strcmp (str, "1") == 0) return 1;
1910   return 0;
1911 }
1912
1913 static int test_scrub_file_0 (void)
1914 {
1915   if (test_scrub_file_0_skip ()) {
1916     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
1917     return 0;
1918   }
1919
1920   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
1921   {
1922     char device[] = "/dev/sda";
1923     int r;
1924     suppress_error = 0;
1925     r = guestfs_blockdev_setrw (g, device);
1926     if (r == -1)
1927       return -1;
1928   }
1929   {
1930     int r;
1931     suppress_error = 0;
1932     r = guestfs_umount_all (g);
1933     if (r == -1)
1934       return -1;
1935   }
1936   {
1937     int r;
1938     suppress_error = 0;
1939     r = guestfs_lvm_remove_all (g);
1940     if (r == -1)
1941       return -1;
1942   }
1943   {
1944     char device[] = "/dev/sda";
1945     char lines_0[] = ",";
1946     char *lines[] = {
1947       lines_0,
1948       NULL
1949     };
1950     int r;
1951     suppress_error = 0;
1952     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1953     if (r == -1)
1954       return -1;
1955   }
1956   {
1957     char fstype[] = "ext2";
1958     char device[] = "/dev/sda1";
1959     int r;
1960     suppress_error = 0;
1961     r = guestfs_mkfs (g, fstype, device);
1962     if (r == -1)
1963       return -1;
1964   }
1965   {
1966     char device[] = "/dev/sda1";
1967     char mountpoint[] = "/";
1968     int r;
1969     suppress_error = 0;
1970     r = guestfs_mount (g, device, mountpoint);
1971     if (r == -1)
1972       return -1;
1973   }
1974   /* TestRun for scrub_file (0) */
1975   {
1976     char path[] = "/file";
1977     char content[] = "content";
1978     int r;
1979     suppress_error = 0;
1980     r = guestfs_write_file (g, path, content, 0);
1981     if (r == -1)
1982       return -1;
1983   }
1984   {
1985     char file[] = "/file";
1986     int r;
1987     suppress_error = 0;
1988     r = guestfs_scrub_file (g, file);
1989     if (r == -1)
1990       return -1;
1991   }
1992   return 0;
1993 }
1994
1995 static int test_scrub_device_0_skip (void)
1996 {
1997   const char *str;
1998
1999   str = getenv ("TEST_ONLY");
2000   if (str)
2001     return strstr (str, "scrub_device") == NULL;
2002   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2003   if (str && strcmp (str, "1") == 0) return 1;
2004   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2005   if (str && strcmp (str, "1") == 0) return 1;
2006   return 0;
2007 }
2008
2009 static int test_scrub_device_0 (void)
2010 {
2011   if (test_scrub_device_0_skip ()) {
2012     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2013     return 0;
2014   }
2015
2016   /* InitNone|InitEmpty for test_scrub_device_0 */
2017   {
2018     char device[] = "/dev/sda";
2019     int r;
2020     suppress_error = 0;
2021     r = guestfs_blockdev_setrw (g, device);
2022     if (r == -1)
2023       return -1;
2024   }
2025   {
2026     int r;
2027     suppress_error = 0;
2028     r = guestfs_umount_all (g);
2029     if (r == -1)
2030       return -1;
2031   }
2032   {
2033     int r;
2034     suppress_error = 0;
2035     r = guestfs_lvm_remove_all (g);
2036     if (r == -1)
2037       return -1;
2038   }
2039   /* TestRun for scrub_device (0) */
2040   {
2041     char device[] = "/dev/sdc";
2042     int r;
2043     suppress_error = 0;
2044     r = guestfs_scrub_device (g, device);
2045     if (r == -1)
2046       return -1;
2047   }
2048   return 0;
2049 }
2050
2051 static int test_glob_expand_0_skip (void)
2052 {
2053   const char *str;
2054
2055   str = getenv ("TEST_ONLY");
2056   if (str)
2057     return strstr (str, "glob_expand") == NULL;
2058   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2059   if (str && strcmp (str, "1") == 0) return 1;
2060   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2061   if (str && strcmp (str, "1") == 0) return 1;
2062   return 0;
2063 }
2064
2065 static int test_glob_expand_0 (void)
2066 {
2067   if (test_glob_expand_0_skip ()) {
2068     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2069     return 0;
2070   }
2071
2072   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2073   {
2074     char device[] = "/dev/sda";
2075     int r;
2076     suppress_error = 0;
2077     r = guestfs_blockdev_setrw (g, device);
2078     if (r == -1)
2079       return -1;
2080   }
2081   {
2082     int r;
2083     suppress_error = 0;
2084     r = guestfs_umount_all (g);
2085     if (r == -1)
2086       return -1;
2087   }
2088   {
2089     int r;
2090     suppress_error = 0;
2091     r = guestfs_lvm_remove_all (g);
2092     if (r == -1)
2093       return -1;
2094   }
2095   {
2096     char device[] = "/dev/sda";
2097     char lines_0[] = ",";
2098     char *lines[] = {
2099       lines_0,
2100       NULL
2101     };
2102     int r;
2103     suppress_error = 0;
2104     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2105     if (r == -1)
2106       return -1;
2107   }
2108   {
2109     char fstype[] = "ext2";
2110     char device[] = "/dev/sda1";
2111     int r;
2112     suppress_error = 0;
2113     r = guestfs_mkfs (g, fstype, device);
2114     if (r == -1)
2115       return -1;
2116   }
2117   {
2118     char device[] = "/dev/sda1";
2119     char mountpoint[] = "/";
2120     int r;
2121     suppress_error = 0;
2122     r = guestfs_mount (g, device, mountpoint);
2123     if (r == -1)
2124       return -1;
2125   }
2126   /* TestOutputList for glob_expand (0) */
2127   {
2128     char path[] = "/a/b/c";
2129     int r;
2130     suppress_error = 0;
2131     r = guestfs_mkdir_p (g, path);
2132     if (r == -1)
2133       return -1;
2134   }
2135   {
2136     char path[] = "/a/b/c/d";
2137     int r;
2138     suppress_error = 0;
2139     r = guestfs_touch (g, path);
2140     if (r == -1)
2141       return -1;
2142   }
2143   {
2144     char path[] = "/a/b/c/e";
2145     int r;
2146     suppress_error = 0;
2147     r = guestfs_touch (g, path);
2148     if (r == -1)
2149       return -1;
2150   }
2151   {
2152     char pattern[] = "/a/b/c/*";
2153     char **r;
2154     int i;
2155     suppress_error = 0;
2156     r = guestfs_glob_expand (g, pattern);
2157     if (r == NULL)
2158       return -1;
2159     if (!r[0]) {
2160       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2161       print_strings (r);
2162       return -1;
2163     }
2164     {
2165       char expected[] = "/a/b/c/d";
2166       if (strcmp (r[0], expected) != 0) {
2167         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2168         return -1;
2169       }
2170     }
2171     if (!r[1]) {
2172       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2173       print_strings (r);
2174       return -1;
2175     }
2176     {
2177       char expected[] = "/a/b/c/e";
2178       if (strcmp (r[1], expected) != 0) {
2179         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2180         return -1;
2181       }
2182     }
2183     if (r[2] != NULL) {
2184       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2185       print_strings (r);
2186       return -1;
2187     }
2188     for (i = 0; r[i] != NULL; ++i)
2189       free (r[i]);
2190     free (r);
2191   }
2192   return 0;
2193 }
2194
2195 static int test_glob_expand_1_skip (void)
2196 {
2197   const char *str;
2198
2199   str = getenv ("TEST_ONLY");
2200   if (str)
2201     return strstr (str, "glob_expand") == NULL;
2202   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2203   if (str && strcmp (str, "1") == 0) return 1;
2204   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2205   if (str && strcmp (str, "1") == 0) return 1;
2206   return 0;
2207 }
2208
2209 static int test_glob_expand_1 (void)
2210 {
2211   if (test_glob_expand_1_skip ()) {
2212     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2213     return 0;
2214   }
2215
2216   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2217   {
2218     char device[] = "/dev/sda";
2219     int r;
2220     suppress_error = 0;
2221     r = guestfs_blockdev_setrw (g, device);
2222     if (r == -1)
2223       return -1;
2224   }
2225   {
2226     int r;
2227     suppress_error = 0;
2228     r = guestfs_umount_all (g);
2229     if (r == -1)
2230       return -1;
2231   }
2232   {
2233     int r;
2234     suppress_error = 0;
2235     r = guestfs_lvm_remove_all (g);
2236     if (r == -1)
2237       return -1;
2238   }
2239   {
2240     char device[] = "/dev/sda";
2241     char lines_0[] = ",";
2242     char *lines[] = {
2243       lines_0,
2244       NULL
2245     };
2246     int r;
2247     suppress_error = 0;
2248     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2249     if (r == -1)
2250       return -1;
2251   }
2252   {
2253     char fstype[] = "ext2";
2254     char device[] = "/dev/sda1";
2255     int r;
2256     suppress_error = 0;
2257     r = guestfs_mkfs (g, fstype, device);
2258     if (r == -1)
2259       return -1;
2260   }
2261   {
2262     char device[] = "/dev/sda1";
2263     char mountpoint[] = "/";
2264     int r;
2265     suppress_error = 0;
2266     r = guestfs_mount (g, device, mountpoint);
2267     if (r == -1)
2268       return -1;
2269   }
2270   /* TestOutputList for glob_expand (1) */
2271   {
2272     char path[] = "/a/b/c";
2273     int r;
2274     suppress_error = 0;
2275     r = guestfs_mkdir_p (g, path);
2276     if (r == -1)
2277       return -1;
2278   }
2279   {
2280     char path[] = "/a/b/c/d";
2281     int r;
2282     suppress_error = 0;
2283     r = guestfs_touch (g, path);
2284     if (r == -1)
2285       return -1;
2286   }
2287   {
2288     char path[] = "/a/b/c/e";
2289     int r;
2290     suppress_error = 0;
2291     r = guestfs_touch (g, path);
2292     if (r == -1)
2293       return -1;
2294   }
2295   {
2296     char pattern[] = "/a/*/c/*";
2297     char **r;
2298     int i;
2299     suppress_error = 0;
2300     r = guestfs_glob_expand (g, pattern);
2301     if (r == NULL)
2302       return -1;
2303     if (!r[0]) {
2304       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2305       print_strings (r);
2306       return -1;
2307     }
2308     {
2309       char expected[] = "/a/b/c/d";
2310       if (strcmp (r[0], expected) != 0) {
2311         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2312         return -1;
2313       }
2314     }
2315     if (!r[1]) {
2316       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2317       print_strings (r);
2318       return -1;
2319     }
2320     {
2321       char expected[] = "/a/b/c/e";
2322       if (strcmp (r[1], expected) != 0) {
2323         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2324         return -1;
2325       }
2326     }
2327     if (r[2] != NULL) {
2328       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2329       print_strings (r);
2330       return -1;
2331     }
2332     for (i = 0; r[i] != NULL; ++i)
2333       free (r[i]);
2334     free (r);
2335   }
2336   return 0;
2337 }
2338
2339 static int test_glob_expand_2_skip (void)
2340 {
2341   const char *str;
2342
2343   str = getenv ("TEST_ONLY");
2344   if (str)
2345     return strstr (str, "glob_expand") == NULL;
2346   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2347   if (str && strcmp (str, "1") == 0) return 1;
2348   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2349   if (str && strcmp (str, "1") == 0) return 1;
2350   return 0;
2351 }
2352
2353 static int test_glob_expand_2 (void)
2354 {
2355   if (test_glob_expand_2_skip ()) {
2356     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2357     return 0;
2358   }
2359
2360   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2361   {
2362     char device[] = "/dev/sda";
2363     int r;
2364     suppress_error = 0;
2365     r = guestfs_blockdev_setrw (g, device);
2366     if (r == -1)
2367       return -1;
2368   }
2369   {
2370     int r;
2371     suppress_error = 0;
2372     r = guestfs_umount_all (g);
2373     if (r == -1)
2374       return -1;
2375   }
2376   {
2377     int r;
2378     suppress_error = 0;
2379     r = guestfs_lvm_remove_all (g);
2380     if (r == -1)
2381       return -1;
2382   }
2383   {
2384     char device[] = "/dev/sda";
2385     char lines_0[] = ",";
2386     char *lines[] = {
2387       lines_0,
2388       NULL
2389     };
2390     int r;
2391     suppress_error = 0;
2392     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2393     if (r == -1)
2394       return -1;
2395   }
2396   {
2397     char fstype[] = "ext2";
2398     char device[] = "/dev/sda1";
2399     int r;
2400     suppress_error = 0;
2401     r = guestfs_mkfs (g, fstype, device);
2402     if (r == -1)
2403       return -1;
2404   }
2405   {
2406     char device[] = "/dev/sda1";
2407     char mountpoint[] = "/";
2408     int r;
2409     suppress_error = 0;
2410     r = guestfs_mount (g, device, mountpoint);
2411     if (r == -1)
2412       return -1;
2413   }
2414   /* TestOutputList for glob_expand (2) */
2415   {
2416     char path[] = "/a/b/c";
2417     int r;
2418     suppress_error = 0;
2419     r = guestfs_mkdir_p (g, path);
2420     if (r == -1)
2421       return -1;
2422   }
2423   {
2424     char path[] = "/a/b/c/d";
2425     int r;
2426     suppress_error = 0;
2427     r = guestfs_touch (g, path);
2428     if (r == -1)
2429       return -1;
2430   }
2431   {
2432     char path[] = "/a/b/c/e";
2433     int r;
2434     suppress_error = 0;
2435     r = guestfs_touch (g, path);
2436     if (r == -1)
2437       return -1;
2438   }
2439   {
2440     char pattern[] = "/a/*/x/*";
2441     char **r;
2442     int i;
2443     suppress_error = 0;
2444     r = guestfs_glob_expand (g, pattern);
2445     if (r == NULL)
2446       return -1;
2447     if (r[0] != NULL) {
2448       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2449       print_strings (r);
2450       return -1;
2451     }
2452     for (i = 0; r[i] != NULL; ++i)
2453       free (r[i]);
2454     free (r);
2455   }
2456   return 0;
2457 }
2458
2459 static int test_ntfs_3g_probe_0_skip (void)
2460 {
2461   const char *str;
2462
2463   str = getenv ("TEST_ONLY");
2464   if (str)
2465     return strstr (str, "ntfs_3g_probe") == NULL;
2466   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2467   if (str && strcmp (str, "1") == 0) return 1;
2468   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2469   if (str && strcmp (str, "1") == 0) return 1;
2470   return 0;
2471 }
2472
2473 static int test_ntfs_3g_probe_0 (void)
2474 {
2475   if (test_ntfs_3g_probe_0_skip ()) {
2476     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2477     return 0;
2478   }
2479
2480   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2481   {
2482     char device[] = "/dev/sda";
2483     int r;
2484     suppress_error = 0;
2485     r = guestfs_blockdev_setrw (g, device);
2486     if (r == -1)
2487       return -1;
2488   }
2489   {
2490     int r;
2491     suppress_error = 0;
2492     r = guestfs_umount_all (g);
2493     if (r == -1)
2494       return -1;
2495   }
2496   {
2497     int r;
2498     suppress_error = 0;
2499     r = guestfs_lvm_remove_all (g);
2500     if (r == -1)
2501       return -1;
2502   }
2503   /* TestOutputInt for ntfs_3g_probe (0) */
2504   {
2505     char device[] = "/dev/sda";
2506     char lines_0[] = ",";
2507     char *lines[] = {
2508       lines_0,
2509       NULL
2510     };
2511     int r;
2512     suppress_error = 0;
2513     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2514     if (r == -1)
2515       return -1;
2516   }
2517   {
2518     char fstype[] = "ntfs";
2519     char device[] = "/dev/sda1";
2520     int r;
2521     suppress_error = 0;
2522     r = guestfs_mkfs (g, fstype, device);
2523     if (r == -1)
2524       return -1;
2525   }
2526   {
2527     char device[] = "/dev/sda1";
2528     int r;
2529     suppress_error = 0;
2530     r = guestfs_ntfs_3g_probe (g, 1, device);
2531     if (r == -1)
2532       return -1;
2533     if (r != 0) {
2534       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
2535       return -1;
2536     }
2537   }
2538   return 0;
2539 }
2540
2541 static int test_ntfs_3g_probe_1_skip (void)
2542 {
2543   const char *str;
2544
2545   str = getenv ("TEST_ONLY");
2546   if (str)
2547     return strstr (str, "ntfs_3g_probe") == NULL;
2548   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2549   if (str && strcmp (str, "1") == 0) return 1;
2550   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2551   if (str && strcmp (str, "1") == 0) return 1;
2552   return 0;
2553 }
2554
2555 static int test_ntfs_3g_probe_1 (void)
2556 {
2557   if (test_ntfs_3g_probe_1_skip ()) {
2558     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2559     return 0;
2560   }
2561
2562   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2563   {
2564     char device[] = "/dev/sda";
2565     int r;
2566     suppress_error = 0;
2567     r = guestfs_blockdev_setrw (g, device);
2568     if (r == -1)
2569       return -1;
2570   }
2571   {
2572     int r;
2573     suppress_error = 0;
2574     r = guestfs_umount_all (g);
2575     if (r == -1)
2576       return -1;
2577   }
2578   {
2579     int r;
2580     suppress_error = 0;
2581     r = guestfs_lvm_remove_all (g);
2582     if (r == -1)
2583       return -1;
2584   }
2585   /* TestOutputInt for ntfs_3g_probe (1) */
2586   {
2587     char device[] = "/dev/sda";
2588     char lines_0[] = ",";
2589     char *lines[] = {
2590       lines_0,
2591       NULL
2592     };
2593     int r;
2594     suppress_error = 0;
2595     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2596     if (r == -1)
2597       return -1;
2598   }
2599   {
2600     char fstype[] = "ext2";
2601     char device[] = "/dev/sda1";
2602     int r;
2603     suppress_error = 0;
2604     r = guestfs_mkfs (g, fstype, device);
2605     if (r == -1)
2606       return -1;
2607   }
2608   {
2609     char device[] = "/dev/sda1";
2610     int r;
2611     suppress_error = 0;
2612     r = guestfs_ntfs_3g_probe (g, 1, device);
2613     if (r == -1)
2614       return -1;
2615     if (r != 12) {
2616       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
2617       return -1;
2618     }
2619   }
2620   return 0;
2621 }
2622
2623 static int test_sleep_0_skip (void)
2624 {
2625   const char *str;
2626
2627   str = getenv ("TEST_ONLY");
2628   if (str)
2629     return strstr (str, "sleep") == NULL;
2630   str = getenv ("SKIP_TEST_SLEEP_0");
2631   if (str && strcmp (str, "1") == 0) return 1;
2632   str = getenv ("SKIP_TEST_SLEEP");
2633   if (str && strcmp (str, "1") == 0) return 1;
2634   return 0;
2635 }
2636
2637 static int test_sleep_0 (void)
2638 {
2639   if (test_sleep_0_skip ()) {
2640     printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
2641     return 0;
2642   }
2643
2644   /* InitNone|InitEmpty for test_sleep_0 */
2645   {
2646     char device[] = "/dev/sda";
2647     int r;
2648     suppress_error = 0;
2649     r = guestfs_blockdev_setrw (g, device);
2650     if (r == -1)
2651       return -1;
2652   }
2653   {
2654     int r;
2655     suppress_error = 0;
2656     r = guestfs_umount_all (g);
2657     if (r == -1)
2658       return -1;
2659   }
2660   {
2661     int r;
2662     suppress_error = 0;
2663     r = guestfs_lvm_remove_all (g);
2664     if (r == -1)
2665       return -1;
2666   }
2667   /* TestRun for sleep (0) */
2668   {
2669     int r;
2670     suppress_error = 0;
2671     r = guestfs_sleep (g, 1);
2672     if (r == -1)
2673       return -1;
2674   }
2675   return 0;
2676 }
2677
2678 static int test_find_0_skip (void)
2679 {
2680   const char *str;
2681
2682   str = getenv ("TEST_ONLY");
2683   if (str)
2684     return strstr (str, "find") == NULL;
2685   str = getenv ("SKIP_TEST_FIND_0");
2686   if (str && strcmp (str, "1") == 0) return 1;
2687   str = getenv ("SKIP_TEST_FIND");
2688   if (str && strcmp (str, "1") == 0) return 1;
2689   return 0;
2690 }
2691
2692 static int test_find_0 (void)
2693 {
2694   if (test_find_0_skip ()) {
2695     printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
2696     return 0;
2697   }
2698
2699   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
2700   {
2701     char device[] = "/dev/sda";
2702     int r;
2703     suppress_error = 0;
2704     r = guestfs_blockdev_setrw (g, device);
2705     if (r == -1)
2706       return -1;
2707   }
2708   {
2709     int r;
2710     suppress_error = 0;
2711     r = guestfs_umount_all (g);
2712     if (r == -1)
2713       return -1;
2714   }
2715   {
2716     int r;
2717     suppress_error = 0;
2718     r = guestfs_lvm_remove_all (g);
2719     if (r == -1)
2720       return -1;
2721   }
2722   {
2723     char device[] = "/dev/sda";
2724     char lines_0[] = ",";
2725     char *lines[] = {
2726       lines_0,
2727       NULL
2728     };
2729     int r;
2730     suppress_error = 0;
2731     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2732     if (r == -1)
2733       return -1;
2734   }
2735   {
2736     char fstype[] = "ext2";
2737     char device[] = "/dev/sda1";
2738     int r;
2739     suppress_error = 0;
2740     r = guestfs_mkfs (g, fstype, device);
2741     if (r == -1)
2742       return -1;
2743   }
2744   {
2745     char device[] = "/dev/sda1";
2746     char mountpoint[] = "/";
2747     int r;
2748     suppress_error = 0;
2749     r = guestfs_mount (g, device, mountpoint);
2750     if (r == -1)
2751       return -1;
2752   }
2753   /* TestOutputList for find (0) */
2754   {
2755     char directory[] = "/";
2756     char **r;
2757     int i;
2758     suppress_error = 0;
2759     r = guestfs_find (g, directory);
2760     if (r == NULL)
2761       return -1;
2762     if (!r[0]) {
2763       fprintf (stderr, "test_find_0: short list returned from command\n");
2764       print_strings (r);
2765       return -1;
2766     }
2767     {
2768       char expected[] = "lost+found";
2769       if (strcmp (r[0], expected) != 0) {
2770         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2771         return -1;
2772       }
2773     }
2774     if (r[1] != NULL) {
2775       fprintf (stderr, "test_find_0: extra elements returned from command\n");
2776       print_strings (r);
2777       return -1;
2778     }
2779     for (i = 0; r[i] != NULL; ++i)
2780       free (r[i]);
2781     free (r);
2782   }
2783   return 0;
2784 }
2785
2786 static int test_find_1_skip (void)
2787 {
2788   const char *str;
2789
2790   str = getenv ("TEST_ONLY");
2791   if (str)
2792     return strstr (str, "find") == NULL;
2793   str = getenv ("SKIP_TEST_FIND_1");
2794   if (str && strcmp (str, "1") == 0) return 1;
2795   str = getenv ("SKIP_TEST_FIND");
2796   if (str && strcmp (str, "1") == 0) return 1;
2797   return 0;
2798 }
2799
2800 static int test_find_1 (void)
2801 {
2802   if (test_find_1_skip ()) {
2803     printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
2804     return 0;
2805   }
2806
2807   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
2808   {
2809     char device[] = "/dev/sda";
2810     int r;
2811     suppress_error = 0;
2812     r = guestfs_blockdev_setrw (g, device);
2813     if (r == -1)
2814       return -1;
2815   }
2816   {
2817     int r;
2818     suppress_error = 0;
2819     r = guestfs_umount_all (g);
2820     if (r == -1)
2821       return -1;
2822   }
2823   {
2824     int r;
2825     suppress_error = 0;
2826     r = guestfs_lvm_remove_all (g);
2827     if (r == -1)
2828       return -1;
2829   }
2830   {
2831     char device[] = "/dev/sda";
2832     char lines_0[] = ",";
2833     char *lines[] = {
2834       lines_0,
2835       NULL
2836     };
2837     int r;
2838     suppress_error = 0;
2839     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2840     if (r == -1)
2841       return -1;
2842   }
2843   {
2844     char fstype[] = "ext2";
2845     char device[] = "/dev/sda1";
2846     int r;
2847     suppress_error = 0;
2848     r = guestfs_mkfs (g, fstype, device);
2849     if (r == -1)
2850       return -1;
2851   }
2852   {
2853     char device[] = "/dev/sda1";
2854     char mountpoint[] = "/";
2855     int r;
2856     suppress_error = 0;
2857     r = guestfs_mount (g, device, mountpoint);
2858     if (r == -1)
2859       return -1;
2860   }
2861   /* TestOutputList for find (1) */
2862   {
2863     char path[] = "/a";
2864     int r;
2865     suppress_error = 0;
2866     r = guestfs_touch (g, path);
2867     if (r == -1)
2868       return -1;
2869   }
2870   {
2871     char path[] = "/b";
2872     int r;
2873     suppress_error = 0;
2874     r = guestfs_mkdir (g, path);
2875     if (r == -1)
2876       return -1;
2877   }
2878   {
2879     char path[] = "/b/c";
2880     int r;
2881     suppress_error = 0;
2882     r = guestfs_touch (g, path);
2883     if (r == -1)
2884       return -1;
2885   }
2886   {
2887     char directory[] = "/";
2888     char **r;
2889     int i;
2890     suppress_error = 0;
2891     r = guestfs_find (g, directory);
2892     if (r == NULL)
2893       return -1;
2894     if (!r[0]) {
2895       fprintf (stderr, "test_find_1: short list returned from command\n");
2896       print_strings (r);
2897       return -1;
2898     }
2899     {
2900       char expected[] = "a";
2901       if (strcmp (r[0], expected) != 0) {
2902         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2903         return -1;
2904       }
2905     }
2906     if (!r[1]) {
2907       fprintf (stderr, "test_find_1: short list returned from command\n");
2908       print_strings (r);
2909       return -1;
2910     }
2911     {
2912       char expected[] = "b";
2913       if (strcmp (r[1], expected) != 0) {
2914         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2915         return -1;
2916       }
2917     }
2918     if (!r[2]) {
2919       fprintf (stderr, "test_find_1: short list returned from command\n");
2920       print_strings (r);
2921       return -1;
2922     }
2923     {
2924       char expected[] = "b/c";
2925       if (strcmp (r[2], expected) != 0) {
2926         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2927         return -1;
2928       }
2929     }
2930     if (!r[3]) {
2931       fprintf (stderr, "test_find_1: short list returned from command\n");
2932       print_strings (r);
2933       return -1;
2934     }
2935     {
2936       char expected[] = "lost+found";
2937       if (strcmp (r[3], expected) != 0) {
2938         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2939         return -1;
2940       }
2941     }
2942     if (r[4] != NULL) {
2943       fprintf (stderr, "test_find_1: extra elements returned from command\n");
2944       print_strings (r);
2945       return -1;
2946     }
2947     for (i = 0; r[i] != NULL; ++i)
2948       free (r[i]);
2949     free (r);
2950   }
2951   return 0;
2952 }
2953
2954 static int test_find_2_skip (void)
2955 {
2956   const char *str;
2957
2958   str = getenv ("TEST_ONLY");
2959   if (str)
2960     return strstr (str, "find") == NULL;
2961   str = getenv ("SKIP_TEST_FIND_2");
2962   if (str && strcmp (str, "1") == 0) return 1;
2963   str = getenv ("SKIP_TEST_FIND");
2964   if (str && strcmp (str, "1") == 0) return 1;
2965   return 0;
2966 }
2967
2968 static int test_find_2 (void)
2969 {
2970   if (test_find_2_skip ()) {
2971     printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
2972     return 0;
2973   }
2974
2975   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
2976   {
2977     char device[] = "/dev/sda";
2978     int r;
2979     suppress_error = 0;
2980     r = guestfs_blockdev_setrw (g, device);
2981     if (r == -1)
2982       return -1;
2983   }
2984   {
2985     int r;
2986     suppress_error = 0;
2987     r = guestfs_umount_all (g);
2988     if (r == -1)
2989       return -1;
2990   }
2991   {
2992     int r;
2993     suppress_error = 0;
2994     r = guestfs_lvm_remove_all (g);
2995     if (r == -1)
2996       return -1;
2997   }
2998   {
2999     char device[] = "/dev/sda";
3000     char lines_0[] = ",";
3001     char *lines[] = {
3002       lines_0,
3003       NULL
3004     };
3005     int r;
3006     suppress_error = 0;
3007     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3008     if (r == -1)
3009       return -1;
3010   }
3011   {
3012     char fstype[] = "ext2";
3013     char device[] = "/dev/sda1";
3014     int r;
3015     suppress_error = 0;
3016     r = guestfs_mkfs (g, fstype, device);
3017     if (r == -1)
3018       return -1;
3019   }
3020   {
3021     char device[] = "/dev/sda1";
3022     char mountpoint[] = "/";
3023     int r;
3024     suppress_error = 0;
3025     r = guestfs_mount (g, device, mountpoint);
3026     if (r == -1)
3027       return -1;
3028   }
3029   /* TestOutputList for find (2) */
3030   {
3031     char path[] = "/a/b/c";
3032     int r;
3033     suppress_error = 0;
3034     r = guestfs_mkdir_p (g, path);
3035     if (r == -1)
3036       return -1;
3037   }
3038   {
3039     char path[] = "/a/b/c/d";
3040     int r;
3041     suppress_error = 0;
3042     r = guestfs_touch (g, path);
3043     if (r == -1)
3044       return -1;
3045   }
3046   {
3047     char directory[] = "/a/b/";
3048     char **r;
3049     int i;
3050     suppress_error = 0;
3051     r = guestfs_find (g, directory);
3052     if (r == NULL)
3053       return -1;
3054     if (!r[0]) {
3055       fprintf (stderr, "test_find_2: short list returned from command\n");
3056       print_strings (r);
3057       return -1;
3058     }
3059     {
3060       char expected[] = "c";
3061       if (strcmp (r[0], expected) != 0) {
3062         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3063         return -1;
3064       }
3065     }
3066     if (!r[1]) {
3067       fprintf (stderr, "test_find_2: short list returned from command\n");
3068       print_strings (r);
3069       return -1;
3070     }
3071     {
3072       char expected[] = "c/d";
3073       if (strcmp (r[1], expected) != 0) {
3074         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3075         return -1;
3076       }
3077     }
3078     if (r[2] != NULL) {
3079       fprintf (stderr, "test_find_2: extra elements returned from command\n");
3080       print_strings (r);
3081       return -1;
3082     }
3083     for (i = 0; r[i] != NULL; ++i)
3084       free (r[i]);
3085     free (r);
3086   }
3087   return 0;
3088 }
3089
3090 static int test_lvresize_0_skip (void)
3091 {
3092   const char *str;
3093
3094   str = getenv ("TEST_ONLY");
3095   if (str)
3096     return strstr (str, "lvresize") == NULL;
3097   str = getenv ("SKIP_TEST_LVRESIZE_0");
3098   if (str && strcmp (str, "1") == 0) return 1;
3099   str = getenv ("SKIP_TEST_LVRESIZE");
3100   if (str && strcmp (str, "1") == 0) return 1;
3101   return 0;
3102 }
3103
3104 static int test_lvresize_0 (void)
3105 {
3106   if (test_lvresize_0_skip ()) {
3107     printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3108     return 0;
3109   }
3110
3111   /* InitNone|InitEmpty for test_lvresize_0 */
3112   {
3113     char device[] = "/dev/sda";
3114     int r;
3115     suppress_error = 0;
3116     r = guestfs_blockdev_setrw (g, device);
3117     if (r == -1)
3118       return -1;
3119   }
3120   {
3121     int r;
3122     suppress_error = 0;
3123     r = guestfs_umount_all (g);
3124     if (r == -1)
3125       return -1;
3126   }
3127   {
3128     int r;
3129     suppress_error = 0;
3130     r = guestfs_lvm_remove_all (g);
3131     if (r == -1)
3132       return -1;
3133   }
3134   /* TestOutput for lvresize (0) */
3135   char expected[] = "test content";
3136   {
3137     char device[] = "/dev/sda";
3138     char lines_0[] = ",";
3139     char *lines[] = {
3140       lines_0,
3141       NULL
3142     };
3143     int r;
3144     suppress_error = 0;
3145     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3146     if (r == -1)
3147       return -1;
3148   }
3149   {
3150     char device[] = "/dev/sda1";
3151     int r;
3152     suppress_error = 0;
3153     r = guestfs_pvcreate (g, device);
3154     if (r == -1)
3155       return -1;
3156   }
3157   {
3158     char volgroup[] = "VG";
3159     char physvols_0[] = "/dev/sda1";
3160     char *physvols[] = {
3161       physvols_0,
3162       NULL
3163     };
3164     int r;
3165     suppress_error = 0;
3166     r = guestfs_vgcreate (g, volgroup, physvols);
3167     if (r == -1)
3168       return -1;
3169   }
3170   {
3171     char logvol[] = "LV";
3172     char volgroup[] = "VG";
3173     int r;
3174     suppress_error = 0;
3175     r = guestfs_lvcreate (g, logvol, volgroup, 10);
3176     if (r == -1)
3177       return -1;
3178   }
3179   {
3180     char fstype[] = "ext2";
3181     char device[] = "/dev/VG/LV";
3182     int r;
3183     suppress_error = 0;
3184     r = guestfs_mkfs (g, fstype, device);
3185     if (r == -1)
3186       return -1;
3187   }
3188   {
3189     char device[] = "/dev/VG/LV";
3190     char mountpoint[] = "/";
3191     int r;
3192     suppress_error = 0;
3193     r = guestfs_mount (g, device, mountpoint);
3194     if (r == -1)
3195       return -1;
3196   }
3197   {
3198     char path[] = "/new";
3199     char content[] = "test content";
3200     int r;
3201     suppress_error = 0;
3202     r = guestfs_write_file (g, path, content, 0);
3203     if (r == -1)
3204       return -1;
3205   }
3206   {
3207     char pathordevice[] = "/";
3208     int r;
3209     suppress_error = 0;
3210     r = guestfs_umount (g, pathordevice);
3211     if (r == -1)
3212       return -1;
3213   }
3214   {
3215     char device[] = "/dev/VG/LV";
3216     int r;
3217     suppress_error = 0;
3218     r = guestfs_lvresize (g, device, 20);
3219     if (r == -1)
3220       return -1;
3221   }
3222   {
3223     char device[] = "/dev/VG/LV";
3224     int r;
3225     suppress_error = 0;
3226     r = guestfs_e2fsck_f (g, device);
3227     if (r == -1)
3228       return -1;
3229   }
3230   {
3231     char device[] = "/dev/VG/LV";
3232     int r;
3233     suppress_error = 0;
3234     r = guestfs_resize2fs (g, device);
3235     if (r == -1)
3236       return -1;
3237   }
3238   {
3239     char device[] = "/dev/VG/LV";
3240     char mountpoint[] = "/";
3241     int r;
3242     suppress_error = 0;
3243     r = guestfs_mount (g, device, mountpoint);
3244     if (r == -1)
3245       return -1;
3246   }
3247   {
3248     char path[] = "/new";
3249     char *r;
3250     suppress_error = 0;
3251     r = guestfs_cat (g, path);
3252     if (r == NULL)
3253       return -1;
3254     if (strcmp (r, expected) != 0) {
3255       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3256       return -1;
3257     }
3258     free (r);
3259   }
3260   return 0;
3261 }
3262
3263 static int test_zerofree_0_skip (void)
3264 {
3265   const char *str;
3266
3267   str = getenv ("TEST_ONLY");
3268   if (str)
3269     return strstr (str, "zerofree") == NULL;
3270   str = getenv ("SKIP_TEST_ZEROFREE_0");
3271   if (str && strcmp (str, "1") == 0) return 1;
3272   str = getenv ("SKIP_TEST_ZEROFREE");
3273   if (str && strcmp (str, "1") == 0) return 1;
3274   return 0;
3275 }
3276
3277 static int test_zerofree_0 (void)
3278 {
3279   if (test_zerofree_0_skip ()) {
3280     printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3281     return 0;
3282   }
3283
3284   /* InitNone|InitEmpty for test_zerofree_0 */
3285   {
3286     char device[] = "/dev/sda";
3287     int r;
3288     suppress_error = 0;
3289     r = guestfs_blockdev_setrw (g, device);
3290     if (r == -1)
3291       return -1;
3292   }
3293   {
3294     int r;
3295     suppress_error = 0;
3296     r = guestfs_umount_all (g);
3297     if (r == -1)
3298       return -1;
3299   }
3300   {
3301     int r;
3302     suppress_error = 0;
3303     r = guestfs_lvm_remove_all (g);
3304     if (r == -1)
3305       return -1;
3306   }
3307   /* TestOutput for zerofree (0) */
3308   char expected[] = "test file";
3309   {
3310     char device[] = "/dev/sda";
3311     char lines_0[] = ",";
3312     char *lines[] = {
3313       lines_0,
3314       NULL
3315     };
3316     int r;
3317     suppress_error = 0;
3318     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3319     if (r == -1)
3320       return -1;
3321   }
3322   {
3323     char fstype[] = "ext3";
3324     char device[] = "/dev/sda1";
3325     int r;
3326     suppress_error = 0;
3327     r = guestfs_mkfs (g, fstype, device);
3328     if (r == -1)
3329       return -1;
3330   }
3331   {
3332     char device[] = "/dev/sda1";
3333     char mountpoint[] = "/";
3334     int r;
3335     suppress_error = 0;
3336     r = guestfs_mount (g, device, mountpoint);
3337     if (r == -1)
3338       return -1;
3339   }
3340   {
3341     char path[] = "/new";
3342     char content[] = "test file";
3343     int r;
3344     suppress_error = 0;
3345     r = guestfs_write_file (g, path, content, 0);
3346     if (r == -1)
3347       return -1;
3348   }
3349   {
3350     char pathordevice[] = "/dev/sda1";
3351     int r;
3352     suppress_error = 0;
3353     r = guestfs_umount (g, pathordevice);
3354     if (r == -1)
3355       return -1;
3356   }
3357   {
3358     char device[] = "/dev/sda1";
3359     int r;
3360     suppress_error = 0;
3361     r = guestfs_zerofree (g, device);
3362     if (r == -1)
3363       return -1;
3364   }
3365   {
3366     char device[] = "/dev/sda1";
3367     char mountpoint[] = "/";
3368     int r;
3369     suppress_error = 0;
3370     r = guestfs_mount (g, device, mountpoint);
3371     if (r == -1)
3372       return -1;
3373   }
3374   {
3375     char path[] = "/new";
3376     char *r;
3377     suppress_error = 0;
3378     r = guestfs_cat (g, path);
3379     if (r == NULL)
3380       return -1;
3381     if (strcmp (r, expected) != 0) {
3382       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3383       return -1;
3384     }
3385     free (r);
3386   }
3387   return 0;
3388 }
3389
3390 static int test_hexdump_0_skip (void)
3391 {
3392   const char *str;
3393
3394   str = getenv ("TEST_ONLY");
3395   if (str)
3396     return strstr (str, "hexdump") == NULL;
3397   str = getenv ("SKIP_TEST_HEXDUMP_0");
3398   if (str && strcmp (str, "1") == 0) return 1;
3399   str = getenv ("SKIP_TEST_HEXDUMP");
3400   if (str && strcmp (str, "1") == 0) return 1;
3401   return 0;
3402 }
3403
3404 static int test_hexdump_0 (void)
3405 {
3406   if (test_hexdump_0_skip ()) {
3407     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3408     return 0;
3409   }
3410
3411   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3412   {
3413     char device[] = "/dev/sda";
3414     int r;
3415     suppress_error = 0;
3416     r = guestfs_blockdev_setrw (g, device);
3417     if (r == -1)
3418       return -1;
3419   }
3420   {
3421     int r;
3422     suppress_error = 0;
3423     r = guestfs_umount_all (g);
3424     if (r == -1)
3425       return -1;
3426   }
3427   {
3428     int r;
3429     suppress_error = 0;
3430     r = guestfs_lvm_remove_all (g);
3431     if (r == -1)
3432       return -1;
3433   }
3434   {
3435     char device[] = "/dev/sda";
3436     char lines_0[] = ",";
3437     char *lines[] = {
3438       lines_0,
3439       NULL
3440     };
3441     int r;
3442     suppress_error = 0;
3443     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3444     if (r == -1)
3445       return -1;
3446   }
3447   {
3448     char fstype[] = "ext2";
3449     char device[] = "/dev/sda1";
3450     int r;
3451     suppress_error = 0;
3452     r = guestfs_mkfs (g, fstype, device);
3453     if (r == -1)
3454       return -1;
3455   }
3456   {
3457     char device[] = "/dev/sda1";
3458     char mountpoint[] = "/";
3459     int r;
3460     suppress_error = 0;
3461     r = guestfs_mount (g, device, mountpoint);
3462     if (r == -1)
3463       return -1;
3464   }
3465   /* TestOutput for hexdump (0) */
3466   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
3467   {
3468     char path[] = "/new";
3469     char content[] = "hello\nworld\n";
3470     int r;
3471     suppress_error = 0;
3472     r = guestfs_write_file (g, path, content, 12);
3473     if (r == -1)
3474       return -1;
3475   }
3476   {
3477     char path[] = "/new";
3478     char *r;
3479     suppress_error = 0;
3480     r = guestfs_hexdump (g, path);
3481     if (r == NULL)
3482       return -1;
3483     if (strcmp (r, expected) != 0) {
3484       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3485       return -1;
3486     }
3487     free (r);
3488   }
3489   return 0;
3490 }
3491
3492 static int test_hexdump_1_skip (void)
3493 {
3494   const char *str;
3495
3496   str = getenv ("TEST_ONLY");
3497   if (str)
3498     return strstr (str, "hexdump") == NULL;
3499   str = getenv ("SKIP_TEST_HEXDUMP_1");
3500   if (str && strcmp (str, "1") == 0) return 1;
3501   str = getenv ("SKIP_TEST_HEXDUMP");
3502   if (str && strcmp (str, "1") == 0) return 1;
3503   return 0;
3504 }
3505
3506 static int test_hexdump_1 (void)
3507 {
3508   if (test_hexdump_1_skip ()) {
3509     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3510     return 0;
3511   }
3512
3513   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3514   {
3515     char device[] = "/dev/sda";
3516     int r;
3517     suppress_error = 0;
3518     r = guestfs_blockdev_setrw (g, device);
3519     if (r == -1)
3520       return -1;
3521   }
3522   {
3523     int r;
3524     suppress_error = 0;
3525     r = guestfs_umount_all (g);
3526     if (r == -1)
3527       return -1;
3528   }
3529   {
3530     int r;
3531     suppress_error = 0;
3532     r = guestfs_lvm_remove_all (g);
3533     if (r == -1)
3534       return -1;
3535   }
3536   {
3537     char device[] = "/dev/sda";
3538     char lines_0[] = ",";
3539     char *lines[] = {
3540       lines_0,
3541       NULL
3542     };
3543     int r;
3544     suppress_error = 0;
3545     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3546     if (r == -1)
3547       return -1;
3548   }
3549   {
3550     char fstype[] = "ext2";
3551     char device[] = "/dev/sda1";
3552     int r;
3553     suppress_error = 0;
3554     r = guestfs_mkfs (g, fstype, device);
3555     if (r == -1)
3556       return -1;
3557   }
3558   {
3559     char device[] = "/dev/sda1";
3560     char mountpoint[] = "/";
3561     int r;
3562     suppress_error = 0;
3563     r = guestfs_mount (g, device, mountpoint);
3564     if (r == -1)
3565       return -1;
3566   }
3567   /* TestRun for hexdump (1) */
3568   {
3569     char options[] = "ro";
3570     char vfstype[] = "squashfs";
3571     char device[] = "/dev/sdd";
3572     char mountpoint[] = "/";
3573     int r;
3574     suppress_error = 0;
3575     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3576     if (r == -1)
3577       return -1;
3578   }
3579   {
3580     char path[] = "/100krandom";
3581     char *r;
3582     suppress_error = 0;
3583     r = guestfs_hexdump (g, path);
3584     if (r == NULL)
3585       return -1;
3586     free (r);
3587   }
3588   return 0;
3589 }
3590
3591 static int test_strings_e_0_skip (void)
3592 {
3593   const char *str;
3594
3595   str = getenv ("TEST_ONLY");
3596   if (str)
3597     return strstr (str, "strings_e") == NULL;
3598   str = getenv ("SKIP_TEST_STRINGS_E_0");
3599   if (str && strcmp (str, "1") == 0) return 1;
3600   str = getenv ("SKIP_TEST_STRINGS_E");
3601   if (str && strcmp (str, "1") == 0) return 1;
3602   return 0;
3603 }
3604
3605 static int test_strings_e_0 (void)
3606 {
3607   if (test_strings_e_0_skip ()) {
3608     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3609     return 0;
3610   }
3611
3612   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3613   {
3614     char device[] = "/dev/sda";
3615     int r;
3616     suppress_error = 0;
3617     r = guestfs_blockdev_setrw (g, device);
3618     if (r == -1)
3619       return -1;
3620   }
3621   {
3622     int r;
3623     suppress_error = 0;
3624     r = guestfs_umount_all (g);
3625     if (r == -1)
3626       return -1;
3627   }
3628   {
3629     int r;
3630     suppress_error = 0;
3631     r = guestfs_lvm_remove_all (g);
3632     if (r == -1)
3633       return -1;
3634   }
3635   {
3636     char device[] = "/dev/sda";
3637     char lines_0[] = ",";
3638     char *lines[] = {
3639       lines_0,
3640       NULL
3641     };
3642     int r;
3643     suppress_error = 0;
3644     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3645     if (r == -1)
3646       return -1;
3647   }
3648   {
3649     char fstype[] = "ext2";
3650     char device[] = "/dev/sda1";
3651     int r;
3652     suppress_error = 0;
3653     r = guestfs_mkfs (g, fstype, device);
3654     if (r == -1)
3655       return -1;
3656   }
3657   {
3658     char device[] = "/dev/sda1";
3659     char mountpoint[] = "/";
3660     int r;
3661     suppress_error = 0;
3662     r = guestfs_mount (g, device, mountpoint);
3663     if (r == -1)
3664       return -1;
3665   }
3666   /* TestOutputList for strings_e (0) */
3667   {
3668     char path[] = "/new";
3669     char content[] = "hello\nworld\n";
3670     int r;
3671     suppress_error = 0;
3672     r = guestfs_write_file (g, path, content, 0);
3673     if (r == -1)
3674       return -1;
3675   }
3676   {
3677     char encoding[] = "b";
3678     char path[] = "/new";
3679     char **r;
3680     int i;
3681     suppress_error = 0;
3682     r = guestfs_strings_e (g, encoding, path);
3683     if (r == NULL)
3684       return -1;
3685     if (r[0] != NULL) {
3686       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
3687       print_strings (r);
3688       return -1;
3689     }
3690     for (i = 0; r[i] != NULL; ++i)
3691       free (r[i]);
3692     free (r);
3693   }
3694   return 0;
3695 }
3696
3697 static int test_strings_e_1_skip (void)
3698 {
3699   const char *str;
3700
3701   str = getenv ("TEST_ONLY");
3702   if (str)
3703     return strstr (str, "strings_e") == NULL;
3704   str = getenv ("SKIP_TEST_STRINGS_E_1");
3705   if (str && strcmp (str, "1") == 0) return 1;
3706   str = getenv ("SKIP_TEST_STRINGS_E");
3707   if (str && strcmp (str, "1") == 0) return 1;
3708   return 0;
3709 }
3710
3711 static int test_strings_e_1 (void)
3712 {
3713   if (test_strings_e_1_skip ()) {
3714     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
3715     return 0;
3716   }
3717
3718   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
3719   return 0;
3720 }
3721
3722 static int test_strings_0_skip (void)
3723 {
3724   const char *str;
3725
3726   str = getenv ("TEST_ONLY");
3727   if (str)
3728     return strstr (str, "strings") == NULL;
3729   str = getenv ("SKIP_TEST_STRINGS_0");
3730   if (str && strcmp (str, "1") == 0) return 1;
3731   str = getenv ("SKIP_TEST_STRINGS");
3732   if (str && strcmp (str, "1") == 0) return 1;
3733   return 0;
3734 }
3735
3736 static int test_strings_0 (void)
3737 {
3738   if (test_strings_0_skip ()) {
3739     printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
3740     return 0;
3741   }
3742
3743   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
3744   {
3745     char device[] = "/dev/sda";
3746     int r;
3747     suppress_error = 0;
3748     r = guestfs_blockdev_setrw (g, device);
3749     if (r == -1)
3750       return -1;
3751   }
3752   {
3753     int r;
3754     suppress_error = 0;
3755     r = guestfs_umount_all (g);
3756     if (r == -1)
3757       return -1;
3758   }
3759   {
3760     int r;
3761     suppress_error = 0;
3762     r = guestfs_lvm_remove_all (g);
3763     if (r == -1)
3764       return -1;
3765   }
3766   {
3767     char device[] = "/dev/sda";
3768     char lines_0[] = ",";
3769     char *lines[] = {
3770       lines_0,
3771       NULL
3772     };
3773     int r;
3774     suppress_error = 0;
3775     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3776     if (r == -1)
3777       return -1;
3778   }
3779   {
3780     char fstype[] = "ext2";
3781     char device[] = "/dev/sda1";
3782     int r;
3783     suppress_error = 0;
3784     r = guestfs_mkfs (g, fstype, device);
3785     if (r == -1)
3786       return -1;
3787   }
3788   {
3789     char device[] = "/dev/sda1";
3790     char mountpoint[] = "/";
3791     int r;
3792     suppress_error = 0;
3793     r = guestfs_mount (g, device, mountpoint);
3794     if (r == -1)
3795       return -1;
3796   }
3797   /* TestOutputList for strings (0) */
3798   {
3799     char path[] = "/new";
3800     char content[] = "hello\nworld\n";
3801     int r;
3802     suppress_error = 0;
3803     r = guestfs_write_file (g, path, content, 0);
3804     if (r == -1)
3805       return -1;
3806   }
3807   {
3808     char path[] = "/new";
3809     char **r;
3810     int i;
3811     suppress_error = 0;
3812     r = guestfs_strings (g, path);
3813     if (r == NULL)
3814       return -1;
3815     if (!r[0]) {
3816       fprintf (stderr, "test_strings_0: short list returned from command\n");
3817       print_strings (r);
3818       return -1;
3819     }
3820     {
3821       char expected[] = "hello";
3822       if (strcmp (r[0], expected) != 0) {
3823         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3824         return -1;
3825       }
3826     }
3827     if (!r[1]) {
3828       fprintf (stderr, "test_strings_0: short list returned from command\n");
3829       print_strings (r);
3830       return -1;
3831     }
3832     {
3833       char expected[] = "world";
3834       if (strcmp (r[1], expected) != 0) {
3835         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3836         return -1;
3837       }
3838     }
3839     if (r[2] != NULL) {
3840       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
3841       print_strings (r);
3842       return -1;
3843     }
3844     for (i = 0; r[i] != NULL; ++i)
3845       free (r[i]);
3846     free (r);
3847   }
3848   return 0;
3849 }
3850
3851 static int test_strings_1_skip (void)
3852 {
3853   const char *str;
3854
3855   str = getenv ("TEST_ONLY");
3856   if (str)
3857     return strstr (str, "strings") == NULL;
3858   str = getenv ("SKIP_TEST_STRINGS_1");
3859   if (str && strcmp (str, "1") == 0) return 1;
3860   str = getenv ("SKIP_TEST_STRINGS");
3861   if (str && strcmp (str, "1") == 0) return 1;
3862   return 0;
3863 }
3864
3865 static int test_strings_1 (void)
3866 {
3867   if (test_strings_1_skip ()) {
3868     printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
3869     return 0;
3870   }
3871
3872   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
3873   {
3874     char device[] = "/dev/sda";
3875     int r;
3876     suppress_error = 0;
3877     r = guestfs_blockdev_setrw (g, device);
3878     if (r == -1)
3879       return -1;
3880   }
3881   {
3882     int r;
3883     suppress_error = 0;
3884     r = guestfs_umount_all (g);
3885     if (r == -1)
3886       return -1;
3887   }
3888   {
3889     int r;
3890     suppress_error = 0;
3891     r = guestfs_lvm_remove_all (g);
3892     if (r == -1)
3893       return -1;
3894   }
3895   {
3896     char device[] = "/dev/sda";
3897     char lines_0[] = ",";
3898     char *lines[] = {
3899       lines_0,
3900       NULL
3901     };
3902     int r;
3903     suppress_error = 0;
3904     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3905     if (r == -1)
3906       return -1;
3907   }
3908   {
3909     char fstype[] = "ext2";
3910     char device[] = "/dev/sda1";
3911     int r;
3912     suppress_error = 0;
3913     r = guestfs_mkfs (g, fstype, device);
3914     if (r == -1)
3915       return -1;
3916   }
3917   {
3918     char device[] = "/dev/sda1";
3919     char mountpoint[] = "/";
3920     int r;
3921     suppress_error = 0;
3922     r = guestfs_mount (g, device, mountpoint);
3923     if (r == -1)
3924       return -1;
3925   }
3926   /* TestOutputList for strings (1) */
3927   {
3928     char path[] = "/new";
3929     int r;
3930     suppress_error = 0;
3931     r = guestfs_touch (g, path);
3932     if (r == -1)
3933       return -1;
3934   }
3935   {
3936     char path[] = "/new";
3937     char **r;
3938     int i;
3939     suppress_error = 0;
3940     r = guestfs_strings (g, path);
3941     if (r == NULL)
3942       return -1;
3943     if (r[0] != NULL) {
3944       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
3945       print_strings (r);
3946       return -1;
3947     }
3948     for (i = 0; r[i] != NULL; ++i)
3949       free (r[i]);
3950     free (r);
3951   }
3952   return 0;
3953 }
3954
3955 static int test_equal_0_skip (void)
3956 {
3957   const char *str;
3958
3959   str = getenv ("TEST_ONLY");
3960   if (str)
3961     return strstr (str, "equal") == NULL;
3962   str = getenv ("SKIP_TEST_EQUAL_0");
3963   if (str && strcmp (str, "1") == 0) return 1;
3964   str = getenv ("SKIP_TEST_EQUAL");
3965   if (str && strcmp (str, "1") == 0) return 1;
3966   return 0;
3967 }
3968
3969 static int test_equal_0 (void)
3970 {
3971   if (test_equal_0_skip ()) {
3972     printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
3973     return 0;
3974   }
3975
3976   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
3977   {
3978     char device[] = "/dev/sda";
3979     int r;
3980     suppress_error = 0;
3981     r = guestfs_blockdev_setrw (g, device);
3982     if (r == -1)
3983       return -1;
3984   }
3985   {
3986     int r;
3987     suppress_error = 0;
3988     r = guestfs_umount_all (g);
3989     if (r == -1)
3990       return -1;
3991   }
3992   {
3993     int r;
3994     suppress_error = 0;
3995     r = guestfs_lvm_remove_all (g);
3996     if (r == -1)
3997       return -1;
3998   }
3999   {
4000     char device[] = "/dev/sda";
4001     char lines_0[] = ",";
4002     char *lines[] = {
4003       lines_0,
4004       NULL
4005     };
4006     int r;
4007     suppress_error = 0;
4008     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4009     if (r == -1)
4010       return -1;
4011   }
4012   {
4013     char fstype[] = "ext2";
4014     char device[] = "/dev/sda1";
4015     int r;
4016     suppress_error = 0;
4017     r = guestfs_mkfs (g, fstype, device);
4018     if (r == -1)
4019       return -1;
4020   }
4021   {
4022     char device[] = "/dev/sda1";
4023     char mountpoint[] = "/";
4024     int r;
4025     suppress_error = 0;
4026     r = guestfs_mount (g, device, mountpoint);
4027     if (r == -1)
4028       return -1;
4029   }
4030   /* TestOutputTrue for equal (0) */
4031   {
4032     char path[] = "/file1";
4033     char content[] = "contents of a file";
4034     int r;
4035     suppress_error = 0;
4036     r = guestfs_write_file (g, path, content, 0);
4037     if (r == -1)
4038       return -1;
4039   }
4040   {
4041     char src[] = "/file1";
4042     char dest[] = "/file2";
4043     int r;
4044     suppress_error = 0;
4045     r = guestfs_cp (g, src, dest);
4046     if (r == -1)
4047       return -1;
4048   }
4049   {
4050     char file1[] = "/file1";
4051     char file2[] = "/file2";
4052     int r;
4053     suppress_error = 0;
4054     r = guestfs_equal (g, file1, file2);
4055     if (r == -1)
4056       return -1;
4057     if (!r) {
4058       fprintf (stderr, "test_equal_0: expected true, got false\n");
4059       return -1;
4060     }
4061   }
4062   return 0;
4063 }
4064
4065 static int test_equal_1_skip (void)
4066 {
4067   const char *str;
4068
4069   str = getenv ("TEST_ONLY");
4070   if (str)
4071     return strstr (str, "equal") == NULL;
4072   str = getenv ("SKIP_TEST_EQUAL_1");
4073   if (str && strcmp (str, "1") == 0) return 1;
4074   str = getenv ("SKIP_TEST_EQUAL");
4075   if (str && strcmp (str, "1") == 0) return 1;
4076   return 0;
4077 }
4078
4079 static int test_equal_1 (void)
4080 {
4081   if (test_equal_1_skip ()) {
4082     printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4083     return 0;
4084   }
4085
4086   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4087   {
4088     char device[] = "/dev/sda";
4089     int r;
4090     suppress_error = 0;
4091     r = guestfs_blockdev_setrw (g, device);
4092     if (r == -1)
4093       return -1;
4094   }
4095   {
4096     int r;
4097     suppress_error = 0;
4098     r = guestfs_umount_all (g);
4099     if (r == -1)
4100       return -1;
4101   }
4102   {
4103     int r;
4104     suppress_error = 0;
4105     r = guestfs_lvm_remove_all (g);
4106     if (r == -1)
4107       return -1;
4108   }
4109   {
4110     char device[] = "/dev/sda";
4111     char lines_0[] = ",";
4112     char *lines[] = {
4113       lines_0,
4114       NULL
4115     };
4116     int r;
4117     suppress_error = 0;
4118     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4119     if (r == -1)
4120       return -1;
4121   }
4122   {
4123     char fstype[] = "ext2";
4124     char device[] = "/dev/sda1";
4125     int r;
4126     suppress_error = 0;
4127     r = guestfs_mkfs (g, fstype, device);
4128     if (r == -1)
4129       return -1;
4130   }
4131   {
4132     char device[] = "/dev/sda1";
4133     char mountpoint[] = "/";
4134     int r;
4135     suppress_error = 0;
4136     r = guestfs_mount (g, device, mountpoint);
4137     if (r == -1)
4138       return -1;
4139   }
4140   /* TestOutputFalse for equal (1) */
4141   {
4142     char path[] = "/file1";
4143     char content[] = "contents of a file";
4144     int r;
4145     suppress_error = 0;
4146     r = guestfs_write_file (g, path, content, 0);
4147     if (r == -1)
4148       return -1;
4149   }
4150   {
4151     char path[] = "/file2";
4152     char content[] = "contents of another file";
4153     int r;
4154     suppress_error = 0;
4155     r = guestfs_write_file (g, path, content, 0);
4156     if (r == -1)
4157       return -1;
4158   }
4159   {
4160     char file1[] = "/file1";
4161     char file2[] = "/file2";
4162     int r;
4163     suppress_error = 0;
4164     r = guestfs_equal (g, file1, file2);
4165     if (r == -1)
4166       return -1;
4167     if (r) {
4168       fprintf (stderr, "test_equal_1: expected false, got true\n");
4169       return -1;
4170     }
4171   }
4172   return 0;
4173 }
4174
4175 static int test_equal_2_skip (void)
4176 {
4177   const char *str;
4178
4179   str = getenv ("TEST_ONLY");
4180   if (str)
4181     return strstr (str, "equal") == NULL;
4182   str = getenv ("SKIP_TEST_EQUAL_2");
4183   if (str && strcmp (str, "1") == 0) return 1;
4184   str = getenv ("SKIP_TEST_EQUAL");
4185   if (str && strcmp (str, "1") == 0) return 1;
4186   return 0;
4187 }
4188
4189 static int test_equal_2 (void)
4190 {
4191   if (test_equal_2_skip ()) {
4192     printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4193     return 0;
4194   }
4195
4196   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4197   {
4198     char device[] = "/dev/sda";
4199     int r;
4200     suppress_error = 0;
4201     r = guestfs_blockdev_setrw (g, device);
4202     if (r == -1)
4203       return -1;
4204   }
4205   {
4206     int r;
4207     suppress_error = 0;
4208     r = guestfs_umount_all (g);
4209     if (r == -1)
4210       return -1;
4211   }
4212   {
4213     int r;
4214     suppress_error = 0;
4215     r = guestfs_lvm_remove_all (g);
4216     if (r == -1)
4217       return -1;
4218   }
4219   {
4220     char device[] = "/dev/sda";
4221     char lines_0[] = ",";
4222     char *lines[] = {
4223       lines_0,
4224       NULL
4225     };
4226     int r;
4227     suppress_error = 0;
4228     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4229     if (r == -1)
4230       return -1;
4231   }
4232   {
4233     char fstype[] = "ext2";
4234     char device[] = "/dev/sda1";
4235     int r;
4236     suppress_error = 0;
4237     r = guestfs_mkfs (g, fstype, device);
4238     if (r == -1)
4239       return -1;
4240   }
4241   {
4242     char device[] = "/dev/sda1";
4243     char mountpoint[] = "/";
4244     int r;
4245     suppress_error = 0;
4246     r = guestfs_mount (g, device, mountpoint);
4247     if (r == -1)
4248       return -1;
4249   }
4250   /* TestLastFail for equal (2) */
4251   {
4252     char file1[] = "/file1";
4253     char file2[] = "/file2";
4254     int r;
4255     suppress_error = 1;
4256     r = guestfs_equal (g, file1, file2);
4257     if (r != -1)
4258       return -1;
4259   }
4260   return 0;
4261 }
4262
4263 static int test_ping_daemon_0_skip (void)
4264 {
4265   const char *str;
4266
4267   str = getenv ("TEST_ONLY");
4268   if (str)
4269     return strstr (str, "ping_daemon") == NULL;
4270   str = getenv ("SKIP_TEST_PING_DAEMON_0");
4271   if (str && strcmp (str, "1") == 0) return 1;
4272   str = getenv ("SKIP_TEST_PING_DAEMON");
4273   if (str && strcmp (str, "1") == 0) return 1;
4274   return 0;
4275 }
4276
4277 static int test_ping_daemon_0 (void)
4278 {
4279   if (test_ping_daemon_0_skip ()) {
4280     printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4281     return 0;
4282   }
4283
4284   /* InitNone|InitEmpty for test_ping_daemon_0 */
4285   {
4286     char device[] = "/dev/sda";
4287     int r;
4288     suppress_error = 0;
4289     r = guestfs_blockdev_setrw (g, device);
4290     if (r == -1)
4291       return -1;
4292   }
4293   {
4294     int r;
4295     suppress_error = 0;
4296     r = guestfs_umount_all (g);
4297     if (r == -1)
4298       return -1;
4299   }
4300   {
4301     int r;
4302     suppress_error = 0;
4303     r = guestfs_lvm_remove_all (g);
4304     if (r == -1)
4305       return -1;
4306   }
4307   /* TestRun for ping_daemon (0) */
4308   {
4309     int r;
4310     suppress_error = 0;
4311     r = guestfs_ping_daemon (g);
4312     if (r == -1)
4313       return -1;
4314   }
4315   return 0;
4316 }
4317
4318 static int test_dmesg_0_skip (void)
4319 {
4320   const char *str;
4321
4322   str = getenv ("TEST_ONLY");
4323   if (str)
4324     return strstr (str, "dmesg") == NULL;
4325   str = getenv ("SKIP_TEST_DMESG_0");
4326   if (str && strcmp (str, "1") == 0) return 1;
4327   str = getenv ("SKIP_TEST_DMESG");
4328   if (str && strcmp (str, "1") == 0) return 1;
4329   return 0;
4330 }
4331
4332 static int test_dmesg_0 (void)
4333 {
4334   if (test_dmesg_0_skip ()) {
4335     printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4336     return 0;
4337   }
4338
4339   /* InitNone|InitEmpty for test_dmesg_0 */
4340   {
4341     char device[] = "/dev/sda";
4342     int r;
4343     suppress_error = 0;
4344     r = guestfs_blockdev_setrw (g, device);
4345     if (r == -1)
4346       return -1;
4347   }
4348   {
4349     int r;
4350     suppress_error = 0;
4351     r = guestfs_umount_all (g);
4352     if (r == -1)
4353       return -1;
4354   }
4355   {
4356     int r;
4357     suppress_error = 0;
4358     r = guestfs_lvm_remove_all (g);
4359     if (r == -1)
4360       return -1;
4361   }
4362   /* TestRun for dmesg (0) */
4363   {
4364     char *r;
4365     suppress_error = 0;
4366     r = guestfs_dmesg (g);
4367     if (r == NULL)
4368       return -1;
4369     free (r);
4370   }
4371   return 0;
4372 }
4373
4374 static int test_drop_caches_0_skip (void)
4375 {
4376   const char *str;
4377
4378   str = getenv ("TEST_ONLY");
4379   if (str)
4380     return strstr (str, "drop_caches") == NULL;
4381   str = getenv ("SKIP_TEST_DROP_CACHES_0");
4382   if (str && strcmp (str, "1") == 0) return 1;
4383   str = getenv ("SKIP_TEST_DROP_CACHES");
4384   if (str && strcmp (str, "1") == 0) return 1;
4385   return 0;
4386 }
4387
4388 static int test_drop_caches_0 (void)
4389 {
4390   if (test_drop_caches_0_skip ()) {
4391     printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4392     return 0;
4393   }
4394
4395   /* InitNone|InitEmpty for test_drop_caches_0 */
4396   {
4397     char device[] = "/dev/sda";
4398     int r;
4399     suppress_error = 0;
4400     r = guestfs_blockdev_setrw (g, device);
4401     if (r == -1)
4402       return -1;
4403   }
4404   {
4405     int r;
4406     suppress_error = 0;
4407     r = guestfs_umount_all (g);
4408     if (r == -1)
4409       return -1;
4410   }
4411   {
4412     int r;
4413     suppress_error = 0;
4414     r = guestfs_lvm_remove_all (g);
4415     if (r == -1)
4416       return -1;
4417   }
4418   /* TestRun for drop_caches (0) */
4419   {
4420     int r;
4421     suppress_error = 0;
4422     r = guestfs_drop_caches (g, 3);
4423     if (r == -1)
4424       return -1;
4425   }
4426   return 0;
4427 }
4428
4429 static int test_mv_0_skip (void)
4430 {
4431   const char *str;
4432
4433   str = getenv ("TEST_ONLY");
4434   if (str)
4435     return strstr (str, "mv") == NULL;
4436   str = getenv ("SKIP_TEST_MV_0");
4437   if (str && strcmp (str, "1") == 0) return 1;
4438   str = getenv ("SKIP_TEST_MV");
4439   if (str && strcmp (str, "1") == 0) return 1;
4440   return 0;
4441 }
4442
4443 static int test_mv_0 (void)
4444 {
4445   if (test_mv_0_skip ()) {
4446     printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4447     return 0;
4448   }
4449
4450   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4451   {
4452     char device[] = "/dev/sda";
4453     int r;
4454     suppress_error = 0;
4455     r = guestfs_blockdev_setrw (g, device);
4456     if (r == -1)
4457       return -1;
4458   }
4459   {
4460     int r;
4461     suppress_error = 0;
4462     r = guestfs_umount_all (g);
4463     if (r == -1)
4464       return -1;
4465   }
4466   {
4467     int r;
4468     suppress_error = 0;
4469     r = guestfs_lvm_remove_all (g);
4470     if (r == -1)
4471       return -1;
4472   }
4473   {
4474     char device[] = "/dev/sda";
4475     char lines_0[] = ",";
4476     char *lines[] = {
4477       lines_0,
4478       NULL
4479     };
4480     int r;
4481     suppress_error = 0;
4482     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4483     if (r == -1)
4484       return -1;
4485   }
4486   {
4487     char fstype[] = "ext2";
4488     char device[] = "/dev/sda1";
4489     int r;
4490     suppress_error = 0;
4491     r = guestfs_mkfs (g, fstype, device);
4492     if (r == -1)
4493       return -1;
4494   }
4495   {
4496     char device[] = "/dev/sda1";
4497     char mountpoint[] = "/";
4498     int r;
4499     suppress_error = 0;
4500     r = guestfs_mount (g, device, mountpoint);
4501     if (r == -1)
4502       return -1;
4503   }
4504   /* TestOutput for mv (0) */
4505   char expected[] = "file content";
4506   {
4507     char path[] = "/old";
4508     char content[] = "file content";
4509     int r;
4510     suppress_error = 0;
4511     r = guestfs_write_file (g, path, content, 0);
4512     if (r == -1)
4513       return -1;
4514   }
4515   {
4516     char src[] = "/old";
4517     char dest[] = "/new";
4518     int r;
4519     suppress_error = 0;
4520     r = guestfs_mv (g, src, dest);
4521     if (r == -1)
4522       return -1;
4523   }
4524   {
4525     char path[] = "/new";
4526     char *r;
4527     suppress_error = 0;
4528     r = guestfs_cat (g, path);
4529     if (r == NULL)
4530       return -1;
4531     if (strcmp (r, expected) != 0) {
4532       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4533       return -1;
4534     }
4535     free (r);
4536   }
4537   return 0;
4538 }
4539
4540 static int test_mv_1_skip (void)
4541 {
4542   const char *str;
4543
4544   str = getenv ("TEST_ONLY");
4545   if (str)
4546     return strstr (str, "mv") == NULL;
4547   str = getenv ("SKIP_TEST_MV_1");
4548   if (str && strcmp (str, "1") == 0) return 1;
4549   str = getenv ("SKIP_TEST_MV");
4550   if (str && strcmp (str, "1") == 0) return 1;
4551   return 0;
4552 }
4553
4554 static int test_mv_1 (void)
4555 {
4556   if (test_mv_1_skip ()) {
4557     printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4558     return 0;
4559   }
4560
4561   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4562   {
4563     char device[] = "/dev/sda";
4564     int r;
4565     suppress_error = 0;
4566     r = guestfs_blockdev_setrw (g, device);
4567     if (r == -1)
4568       return -1;
4569   }
4570   {
4571     int r;
4572     suppress_error = 0;
4573     r = guestfs_umount_all (g);
4574     if (r == -1)
4575       return -1;
4576   }
4577   {
4578     int r;
4579     suppress_error = 0;
4580     r = guestfs_lvm_remove_all (g);
4581     if (r == -1)
4582       return -1;
4583   }
4584   {
4585     char device[] = "/dev/sda";
4586     char lines_0[] = ",";
4587     char *lines[] = {
4588       lines_0,
4589       NULL
4590     };
4591     int r;
4592     suppress_error = 0;
4593     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4594     if (r == -1)
4595       return -1;
4596   }
4597   {
4598     char fstype[] = "ext2";
4599     char device[] = "/dev/sda1";
4600     int r;
4601     suppress_error = 0;
4602     r = guestfs_mkfs (g, fstype, device);
4603     if (r == -1)
4604       return -1;
4605   }
4606   {
4607     char device[] = "/dev/sda1";
4608     char mountpoint[] = "/";
4609     int r;
4610     suppress_error = 0;
4611     r = guestfs_mount (g, device, mountpoint);
4612     if (r == -1)
4613       return -1;
4614   }
4615   /* TestOutputFalse for mv (1) */
4616   {
4617     char path[] = "/old";
4618     char content[] = "file content";
4619     int r;
4620     suppress_error = 0;
4621     r = guestfs_write_file (g, path, content, 0);
4622     if (r == -1)
4623       return -1;
4624   }
4625   {
4626     char src[] = "/old";
4627     char dest[] = "/new";
4628     int r;
4629     suppress_error = 0;
4630     r = guestfs_mv (g, src, dest);
4631     if (r == -1)
4632       return -1;
4633   }
4634   {
4635     char path[] = "/old";
4636     int r;
4637     suppress_error = 0;
4638     r = guestfs_is_file (g, path);
4639     if (r == -1)
4640       return -1;
4641     if (r) {
4642       fprintf (stderr, "test_mv_1: expected false, got true\n");
4643       return -1;
4644     }
4645   }
4646   return 0;
4647 }
4648
4649 static int test_cp_a_0_skip (void)
4650 {
4651   const char *str;
4652
4653   str = getenv ("TEST_ONLY");
4654   if (str)
4655     return strstr (str, "cp_a") == NULL;
4656   str = getenv ("SKIP_TEST_CP_A_0");
4657   if (str && strcmp (str, "1") == 0) return 1;
4658   str = getenv ("SKIP_TEST_CP_A");
4659   if (str && strcmp (str, "1") == 0) return 1;
4660   return 0;
4661 }
4662
4663 static int test_cp_a_0 (void)
4664 {
4665   if (test_cp_a_0_skip ()) {
4666     printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
4667     return 0;
4668   }
4669
4670   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
4671   {
4672     char device[] = "/dev/sda";
4673     int r;
4674     suppress_error = 0;
4675     r = guestfs_blockdev_setrw (g, device);
4676     if (r == -1)
4677       return -1;
4678   }
4679   {
4680     int r;
4681     suppress_error = 0;
4682     r = guestfs_umount_all (g);
4683     if (r == -1)
4684       return -1;
4685   }
4686   {
4687     int r;
4688     suppress_error = 0;
4689     r = guestfs_lvm_remove_all (g);
4690     if (r == -1)
4691       return -1;
4692   }
4693   {
4694     char device[] = "/dev/sda";
4695     char lines_0[] = ",";
4696     char *lines[] = {
4697       lines_0,
4698       NULL
4699     };
4700     int r;
4701     suppress_error = 0;
4702     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4703     if (r == -1)
4704       return -1;
4705   }
4706   {
4707     char fstype[] = "ext2";
4708     char device[] = "/dev/sda1";
4709     int r;
4710     suppress_error = 0;
4711     r = guestfs_mkfs (g, fstype, device);
4712     if (r == -1)
4713       return -1;
4714   }
4715   {
4716     char device[] = "/dev/sda1";
4717     char mountpoint[] = "/";
4718     int r;
4719     suppress_error = 0;
4720     r = guestfs_mount (g, device, mountpoint);
4721     if (r == -1)
4722       return -1;
4723   }
4724   /* TestOutput for cp_a (0) */
4725   char expected[] = "file content";
4726   {
4727     char path[] = "/olddir";
4728     int r;
4729     suppress_error = 0;
4730     r = guestfs_mkdir (g, path);
4731     if (r == -1)
4732       return -1;
4733   }
4734   {
4735     char path[] = "/newdir";
4736     int r;
4737     suppress_error = 0;
4738     r = guestfs_mkdir (g, path);
4739     if (r == -1)
4740       return -1;
4741   }
4742   {
4743     char path[] = "/olddir/file";
4744     char content[] = "file content";
4745     int r;
4746     suppress_error = 0;
4747     r = guestfs_write_file (g, path, content, 0);
4748     if (r == -1)
4749       return -1;
4750   }
4751   {
4752     char src[] = "/olddir";
4753     char dest[] = "/newdir";
4754     int r;
4755     suppress_error = 0;
4756     r = guestfs_cp_a (g, src, dest);
4757     if (r == -1)
4758       return -1;
4759   }
4760   {
4761     char path[] = "/newdir/olddir/file";
4762     char *r;
4763     suppress_error = 0;
4764     r = guestfs_cat (g, path);
4765     if (r == NULL)
4766       return -1;
4767     if (strcmp (r, expected) != 0) {
4768       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
4769       return -1;
4770     }
4771     free (r);
4772   }
4773   return 0;
4774 }
4775
4776 static int test_cp_0_skip (void)
4777 {
4778   const char *str;
4779
4780   str = getenv ("TEST_ONLY");
4781   if (str)
4782     return strstr (str, "cp") == NULL;
4783   str = getenv ("SKIP_TEST_CP_0");
4784   if (str && strcmp (str, "1") == 0) return 1;
4785   str = getenv ("SKIP_TEST_CP");
4786   if (str && strcmp (str, "1") == 0) return 1;
4787   return 0;
4788 }
4789
4790 static int test_cp_0 (void)
4791 {
4792   if (test_cp_0_skip ()) {
4793     printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
4794     return 0;
4795   }
4796
4797   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
4798   {
4799     char device[] = "/dev/sda";
4800     int r;
4801     suppress_error = 0;
4802     r = guestfs_blockdev_setrw (g, device);
4803     if (r == -1)
4804       return -1;
4805   }
4806   {
4807     int r;
4808     suppress_error = 0;
4809     r = guestfs_umount_all (g);
4810     if (r == -1)
4811       return -1;
4812   }
4813   {
4814     int r;
4815     suppress_error = 0;
4816     r = guestfs_lvm_remove_all (g);
4817     if (r == -1)
4818       return -1;
4819   }
4820   {
4821     char device[] = "/dev/sda";
4822     char lines_0[] = ",";
4823     char *lines[] = {
4824       lines_0,
4825       NULL
4826     };
4827     int r;
4828     suppress_error = 0;
4829     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4830     if (r == -1)
4831       return -1;
4832   }
4833   {
4834     char fstype[] = "ext2";
4835     char device[] = "/dev/sda1";
4836     int r;
4837     suppress_error = 0;
4838     r = guestfs_mkfs (g, fstype, device);
4839     if (r == -1)
4840       return -1;
4841   }
4842   {
4843     char device[] = "/dev/sda1";
4844     char mountpoint[] = "/";
4845     int r;
4846     suppress_error = 0;
4847     r = guestfs_mount (g, device, mountpoint);
4848     if (r == -1)
4849       return -1;
4850   }
4851   /* TestOutput for cp (0) */
4852   char expected[] = "file content";
4853   {
4854     char path[] = "/old";
4855     char content[] = "file content";
4856     int r;
4857     suppress_error = 0;
4858     r = guestfs_write_file (g, path, content, 0);
4859     if (r == -1)
4860       return -1;
4861   }
4862   {
4863     char src[] = "/old";
4864     char dest[] = "/new";
4865     int r;
4866     suppress_error = 0;
4867     r = guestfs_cp (g, src, dest);
4868     if (r == -1)
4869       return -1;
4870   }
4871   {
4872     char path[] = "/new";
4873     char *r;
4874     suppress_error = 0;
4875     r = guestfs_cat (g, path);
4876     if (r == NULL)
4877       return -1;
4878     if (strcmp (r, expected) != 0) {
4879       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
4880       return -1;
4881     }
4882     free (r);
4883   }
4884   return 0;
4885 }
4886
4887 static int test_cp_1_skip (void)
4888 {
4889   const char *str;
4890
4891   str = getenv ("TEST_ONLY");
4892   if (str)
4893     return strstr (str, "cp") == NULL;
4894   str = getenv ("SKIP_TEST_CP_1");
4895   if (str && strcmp (str, "1") == 0) return 1;
4896   str = getenv ("SKIP_TEST_CP");
4897   if (str && strcmp (str, "1") == 0) return 1;
4898   return 0;
4899 }
4900
4901 static int test_cp_1 (void)
4902 {
4903   if (test_cp_1_skip ()) {
4904     printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
4905     return 0;
4906   }
4907
4908   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
4909   {
4910     char device[] = "/dev/sda";
4911     int r;
4912     suppress_error = 0;
4913     r = guestfs_blockdev_setrw (g, device);
4914     if (r == -1)
4915       return -1;
4916   }
4917   {
4918     int r;
4919     suppress_error = 0;
4920     r = guestfs_umount_all (g);
4921     if (r == -1)
4922       return -1;
4923   }
4924   {
4925     int r;
4926     suppress_error = 0;
4927     r = guestfs_lvm_remove_all (g);
4928     if (r == -1)
4929       return -1;
4930   }
4931   {
4932     char device[] = "/dev/sda";
4933     char lines_0[] = ",";
4934     char *lines[] = {
4935       lines_0,
4936       NULL
4937     };
4938     int r;
4939     suppress_error = 0;
4940     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4941     if (r == -1)
4942       return -1;
4943   }
4944   {
4945     char fstype[] = "ext2";
4946     char device[] = "/dev/sda1";
4947     int r;
4948     suppress_error = 0;
4949     r = guestfs_mkfs (g, fstype, device);
4950     if (r == -1)
4951       return -1;
4952   }
4953   {
4954     char device[] = "/dev/sda1";
4955     char mountpoint[] = "/";
4956     int r;
4957     suppress_error = 0;
4958     r = guestfs_mount (g, device, mountpoint);
4959     if (r == -1)
4960       return -1;
4961   }
4962   /* TestOutputTrue for cp (1) */
4963   {
4964     char path[] = "/old";
4965     char content[] = "file content";
4966     int r;
4967     suppress_error = 0;
4968     r = guestfs_write_file (g, path, content, 0);
4969     if (r == -1)
4970       return -1;
4971   }
4972   {
4973     char src[] = "/old";
4974     char dest[] = "/new";
4975     int r;
4976     suppress_error = 0;
4977     r = guestfs_cp (g, src, dest);
4978     if (r == -1)
4979       return -1;
4980   }
4981   {
4982     char path[] = "/old";
4983     int r;
4984     suppress_error = 0;
4985     r = guestfs_is_file (g, path);
4986     if (r == -1)
4987       return -1;
4988     if (!r) {
4989       fprintf (stderr, "test_cp_1: expected true, got false\n");
4990       return -1;
4991     }
4992   }
4993   return 0;
4994 }
4995
4996 static int test_cp_2_skip (void)
4997 {
4998   const char *str;
4999
5000   str = getenv ("TEST_ONLY");
5001   if (str)
5002     return strstr (str, "cp") == NULL;
5003   str = getenv ("SKIP_TEST_CP_2");
5004   if (str && strcmp (str, "1") == 0) return 1;
5005   str = getenv ("SKIP_TEST_CP");
5006   if (str && strcmp (str, "1") == 0) return 1;
5007   return 0;
5008 }
5009
5010 static int test_cp_2 (void)
5011 {
5012   if (test_cp_2_skip ()) {
5013     printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5014     return 0;
5015   }
5016
5017   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5018   {
5019     char device[] = "/dev/sda";
5020     int r;
5021     suppress_error = 0;
5022     r = guestfs_blockdev_setrw (g, device);
5023     if (r == -1)
5024       return -1;
5025   }
5026   {
5027     int r;
5028     suppress_error = 0;
5029     r = guestfs_umount_all (g);
5030     if (r == -1)
5031       return -1;
5032   }
5033   {
5034     int r;
5035     suppress_error = 0;
5036     r = guestfs_lvm_remove_all (g);
5037     if (r == -1)
5038       return -1;
5039   }
5040   {
5041     char device[] = "/dev/sda";
5042     char lines_0[] = ",";
5043     char *lines[] = {
5044       lines_0,
5045       NULL
5046     };
5047     int r;
5048     suppress_error = 0;
5049     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5050     if (r == -1)
5051       return -1;
5052   }
5053   {
5054     char fstype[] = "ext2";
5055     char device[] = "/dev/sda1";
5056     int r;
5057     suppress_error = 0;
5058     r = guestfs_mkfs (g, fstype, device);
5059     if (r == -1)
5060       return -1;
5061   }
5062   {
5063     char device[] = "/dev/sda1";
5064     char mountpoint[] = "/";
5065     int r;
5066     suppress_error = 0;
5067     r = guestfs_mount (g, device, mountpoint);
5068     if (r == -1)
5069       return -1;
5070   }
5071   /* TestOutput for cp (2) */
5072   char expected[] = "file content";
5073   {
5074     char path[] = "/old";
5075     char content[] = "file content";
5076     int r;
5077     suppress_error = 0;
5078     r = guestfs_write_file (g, path, content, 0);
5079     if (r == -1)
5080       return -1;
5081   }
5082   {
5083     char path[] = "/dir";
5084     int r;
5085     suppress_error = 0;
5086     r = guestfs_mkdir (g, path);
5087     if (r == -1)
5088       return -1;
5089   }
5090   {
5091     char src[] = "/old";
5092     char dest[] = "/dir/new";
5093     int r;
5094     suppress_error = 0;
5095     r = guestfs_cp (g, src, dest);
5096     if (r == -1)
5097       return -1;
5098   }
5099   {
5100     char path[] = "/dir/new";
5101     char *r;
5102     suppress_error = 0;
5103     r = guestfs_cat (g, path);
5104     if (r == NULL)
5105       return -1;
5106     if (strcmp (r, expected) != 0) {
5107       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5108       return -1;
5109     }
5110     free (r);
5111   }
5112   return 0;
5113 }
5114
5115 static int test_grub_install_0_skip (void)
5116 {
5117   const char *str;
5118
5119   str = getenv ("TEST_ONLY");
5120   if (str)
5121     return strstr (str, "grub_install") == NULL;
5122   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5123   if (str && strcmp (str, "1") == 0) return 1;
5124   str = getenv ("SKIP_TEST_GRUB_INSTALL");
5125   if (str && strcmp (str, "1") == 0) return 1;
5126   return 0;
5127 }
5128
5129 static int test_grub_install_0 (void)
5130 {
5131   if (test_grub_install_0_skip ()) {
5132     printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5133     return 0;
5134   }
5135
5136   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5137   {
5138     char device[] = "/dev/sda";
5139     int r;
5140     suppress_error = 0;
5141     r = guestfs_blockdev_setrw (g, device);
5142     if (r == -1)
5143       return -1;
5144   }
5145   {
5146     int r;
5147     suppress_error = 0;
5148     r = guestfs_umount_all (g);
5149     if (r == -1)
5150       return -1;
5151   }
5152   {
5153     int r;
5154     suppress_error = 0;
5155     r = guestfs_lvm_remove_all (g);
5156     if (r == -1)
5157       return -1;
5158   }
5159   {
5160     char device[] = "/dev/sda";
5161     char lines_0[] = ",";
5162     char *lines[] = {
5163       lines_0,
5164       NULL
5165     };
5166     int r;
5167     suppress_error = 0;
5168     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5169     if (r == -1)
5170       return -1;
5171   }
5172   {
5173     char fstype[] = "ext2";
5174     char device[] = "/dev/sda1";
5175     int r;
5176     suppress_error = 0;
5177     r = guestfs_mkfs (g, fstype, device);
5178     if (r == -1)
5179       return -1;
5180   }
5181   {
5182     char device[] = "/dev/sda1";
5183     char mountpoint[] = "/";
5184     int r;
5185     suppress_error = 0;
5186     r = guestfs_mount (g, device, mountpoint);
5187     if (r == -1)
5188       return -1;
5189   }
5190   /* TestOutputTrue for grub_install (0) */
5191   {
5192     char root[] = "/";
5193     char device[] = "/dev/sda1";
5194     int r;
5195     suppress_error = 0;
5196     r = guestfs_grub_install (g, root, device);
5197     if (r == -1)
5198       return -1;
5199   }
5200   {
5201     char path[] = "/boot";
5202     int r;
5203     suppress_error = 0;
5204     r = guestfs_is_dir (g, path);
5205     if (r == -1)
5206       return -1;
5207     if (!r) {
5208       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5209       return -1;
5210     }
5211   }
5212   return 0;
5213 }
5214
5215 static int test_zero_0_skip (void)
5216 {
5217   const char *str;
5218
5219   str = getenv ("TEST_ONLY");
5220   if (str)
5221     return strstr (str, "zero") == NULL;
5222   str = getenv ("SKIP_TEST_ZERO_0");
5223   if (str && strcmp (str, "1") == 0) return 1;
5224   str = getenv ("SKIP_TEST_ZERO");
5225   if (str && strcmp (str, "1") == 0) return 1;
5226   return 0;
5227 }
5228
5229 static int test_zero_0 (void)
5230 {
5231   if (test_zero_0_skip ()) {
5232     printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5233     return 0;
5234   }
5235
5236   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5237   {
5238     char device[] = "/dev/sda";
5239     int r;
5240     suppress_error = 0;
5241     r = guestfs_blockdev_setrw (g, device);
5242     if (r == -1)
5243       return -1;
5244   }
5245   {
5246     int r;
5247     suppress_error = 0;
5248     r = guestfs_umount_all (g);
5249     if (r == -1)
5250       return -1;
5251   }
5252   {
5253     int r;
5254     suppress_error = 0;
5255     r = guestfs_lvm_remove_all (g);
5256     if (r == -1)
5257       return -1;
5258   }
5259   {
5260     char device[] = "/dev/sda";
5261     char lines_0[] = ",";
5262     char *lines[] = {
5263       lines_0,
5264       NULL
5265     };
5266     int r;
5267     suppress_error = 0;
5268     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5269     if (r == -1)
5270       return -1;
5271   }
5272   {
5273     char fstype[] = "ext2";
5274     char device[] = "/dev/sda1";
5275     int r;
5276     suppress_error = 0;
5277     r = guestfs_mkfs (g, fstype, device);
5278     if (r == -1)
5279       return -1;
5280   }
5281   {
5282     char device[] = "/dev/sda1";
5283     char mountpoint[] = "/";
5284     int r;
5285     suppress_error = 0;
5286     r = guestfs_mount (g, device, mountpoint);
5287     if (r == -1)
5288       return -1;
5289   }
5290   /* TestOutput for zero (0) */
5291   char expected[] = "data";
5292   {
5293     char pathordevice[] = "/dev/sda1";
5294     int r;
5295     suppress_error = 0;
5296     r = guestfs_umount (g, pathordevice);
5297     if (r == -1)
5298       return -1;
5299   }
5300   {
5301     char device[] = "/dev/sda1";
5302     int r;
5303     suppress_error = 0;
5304     r = guestfs_zero (g, device);
5305     if (r == -1)
5306       return -1;
5307   }
5308   {
5309     char path[] = "/dev/sda1";
5310     char *r;
5311     suppress_error = 0;
5312     r = guestfs_file (g, path);
5313     if (r == NULL)
5314       return -1;
5315     if (strcmp (r, expected) != 0) {
5316       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5317       return -1;
5318     }
5319     free (r);
5320   }
5321   return 0;
5322 }
5323
5324 static int test_fsck_0_skip (void)
5325 {
5326   const char *str;
5327
5328   str = getenv ("TEST_ONLY");
5329   if (str)
5330     return strstr (str, "fsck") == NULL;
5331   str = getenv ("SKIP_TEST_FSCK_0");
5332   if (str && strcmp (str, "1") == 0) return 1;
5333   str = getenv ("SKIP_TEST_FSCK");
5334   if (str && strcmp (str, "1") == 0) return 1;
5335   return 0;
5336 }
5337
5338 static int test_fsck_0 (void)
5339 {
5340   if (test_fsck_0_skip ()) {
5341     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5342     return 0;
5343   }
5344
5345   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5346   {
5347     char device[] = "/dev/sda";
5348     int r;
5349     suppress_error = 0;
5350     r = guestfs_blockdev_setrw (g, device);
5351     if (r == -1)
5352       return -1;
5353   }
5354   {
5355     int r;
5356     suppress_error = 0;
5357     r = guestfs_umount_all (g);
5358     if (r == -1)
5359       return -1;
5360   }
5361   {
5362     int r;
5363     suppress_error = 0;
5364     r = guestfs_lvm_remove_all (g);
5365     if (r == -1)
5366       return -1;
5367   }
5368   {
5369     char device[] = "/dev/sda";
5370     char lines_0[] = ",";
5371     char *lines[] = {
5372       lines_0,
5373       NULL
5374     };
5375     int r;
5376     suppress_error = 0;
5377     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5378     if (r == -1)
5379       return -1;
5380   }
5381   {
5382     char fstype[] = "ext2";
5383     char device[] = "/dev/sda1";
5384     int r;
5385     suppress_error = 0;
5386     r = guestfs_mkfs (g, fstype, device);
5387     if (r == -1)
5388       return -1;
5389   }
5390   {
5391     char device[] = "/dev/sda1";
5392     char mountpoint[] = "/";
5393     int r;
5394     suppress_error = 0;
5395     r = guestfs_mount (g, device, mountpoint);
5396     if (r == -1)
5397       return -1;
5398   }
5399   /* TestOutputInt for fsck (0) */
5400   {
5401     char pathordevice[] = "/dev/sda1";
5402     int r;
5403     suppress_error = 0;
5404     r = guestfs_umount (g, pathordevice);
5405     if (r == -1)
5406       return -1;
5407   }
5408   {
5409     char fstype[] = "ext2";
5410     char device[] = "/dev/sda1";
5411     int r;
5412     suppress_error = 0;
5413     r = guestfs_fsck (g, fstype, device);
5414     if (r == -1)
5415       return -1;
5416     if (r != 0) {
5417       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
5418       return -1;
5419     }
5420   }
5421   return 0;
5422 }
5423
5424 static int test_fsck_1_skip (void)
5425 {
5426   const char *str;
5427
5428   str = getenv ("TEST_ONLY");
5429   if (str)
5430     return strstr (str, "fsck") == NULL;
5431   str = getenv ("SKIP_TEST_FSCK_1");
5432   if (str && strcmp (str, "1") == 0) return 1;
5433   str = getenv ("SKIP_TEST_FSCK");
5434   if (str && strcmp (str, "1") == 0) return 1;
5435   return 0;
5436 }
5437
5438 static int test_fsck_1 (void)
5439 {
5440   if (test_fsck_1_skip ()) {
5441     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5442     return 0;
5443   }
5444
5445   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5446   {
5447     char device[] = "/dev/sda";
5448     int r;
5449     suppress_error = 0;
5450     r = guestfs_blockdev_setrw (g, device);
5451     if (r == -1)
5452       return -1;
5453   }
5454   {
5455     int r;
5456     suppress_error = 0;
5457     r = guestfs_umount_all (g);
5458     if (r == -1)
5459       return -1;
5460   }
5461   {
5462     int r;
5463     suppress_error = 0;
5464     r = guestfs_lvm_remove_all (g);
5465     if (r == -1)
5466       return -1;
5467   }
5468   {
5469     char device[] = "/dev/sda";
5470     char lines_0[] = ",";
5471     char *lines[] = {
5472       lines_0,
5473       NULL
5474     };
5475     int r;
5476     suppress_error = 0;
5477     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5478     if (r == -1)
5479       return -1;
5480   }
5481   {
5482     char fstype[] = "ext2";
5483     char device[] = "/dev/sda1";
5484     int r;
5485     suppress_error = 0;
5486     r = guestfs_mkfs (g, fstype, device);
5487     if (r == -1)
5488       return -1;
5489   }
5490   {
5491     char device[] = "/dev/sda1";
5492     char mountpoint[] = "/";
5493     int r;
5494     suppress_error = 0;
5495     r = guestfs_mount (g, device, mountpoint);
5496     if (r == -1)
5497       return -1;
5498   }
5499   /* TestOutputInt for fsck (1) */
5500   {
5501     char pathordevice[] = "/dev/sda1";
5502     int r;
5503     suppress_error = 0;
5504     r = guestfs_umount (g, pathordevice);
5505     if (r == -1)
5506       return -1;
5507   }
5508   {
5509     char device[] = "/dev/sda1";
5510     int r;
5511     suppress_error = 0;
5512     r = guestfs_zero (g, device);
5513     if (r == -1)
5514       return -1;
5515   }
5516   {
5517     char fstype[] = "ext2";
5518     char device[] = "/dev/sda1";
5519     int r;
5520     suppress_error = 0;
5521     r = guestfs_fsck (g, fstype, device);
5522     if (r == -1)
5523       return -1;
5524     if (r != 8) {
5525       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
5526       return -1;
5527     }
5528   }
5529   return 0;
5530 }
5531
5532 static int test_set_e2uuid_0_skip (void)
5533 {
5534   const char *str;
5535
5536   str = getenv ("TEST_ONLY");
5537   if (str)
5538     return strstr (str, "set_e2uuid") == NULL;
5539   str = getenv ("SKIP_TEST_SET_E2UUID_0");
5540   if (str && strcmp (str, "1") == 0) return 1;
5541   str = getenv ("SKIP_TEST_SET_E2UUID");
5542   if (str && strcmp (str, "1") == 0) return 1;
5543   return 0;
5544 }
5545
5546 static int test_set_e2uuid_0 (void)
5547 {
5548   if (test_set_e2uuid_0_skip ()) {
5549     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5550     return 0;
5551   }
5552
5553   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5554   {
5555     char device[] = "/dev/sda";
5556     int r;
5557     suppress_error = 0;
5558     r = guestfs_blockdev_setrw (g, device);
5559     if (r == -1)
5560       return -1;
5561   }
5562   {
5563     int r;
5564     suppress_error = 0;
5565     r = guestfs_umount_all (g);
5566     if (r == -1)
5567       return -1;
5568   }
5569   {
5570     int r;
5571     suppress_error = 0;
5572     r = guestfs_lvm_remove_all (g);
5573     if (r == -1)
5574       return -1;
5575   }
5576   {
5577     char device[] = "/dev/sda";
5578     char lines_0[] = ",";
5579     char *lines[] = {
5580       lines_0,
5581       NULL
5582     };
5583     int r;
5584     suppress_error = 0;
5585     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5586     if (r == -1)
5587       return -1;
5588   }
5589   {
5590     char fstype[] = "ext2";
5591     char device[] = "/dev/sda1";
5592     int r;
5593     suppress_error = 0;
5594     r = guestfs_mkfs (g, fstype, device);
5595     if (r == -1)
5596       return -1;
5597   }
5598   {
5599     char device[] = "/dev/sda1";
5600     char mountpoint[] = "/";
5601     int r;
5602     suppress_error = 0;
5603     r = guestfs_mount (g, device, mountpoint);
5604     if (r == -1)
5605       return -1;
5606   }
5607   /* TestOutput for set_e2uuid (0) */
5608   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5609   {
5610     char device[] = "/dev/sda1";
5611     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5612     int r;
5613     suppress_error = 0;
5614     r = guestfs_set_e2uuid (g, device, uuid);
5615     if (r == -1)
5616       return -1;
5617   }
5618   {
5619     char device[] = "/dev/sda1";
5620     char *r;
5621     suppress_error = 0;
5622     r = guestfs_get_e2uuid (g, device);
5623     if (r == NULL)
5624       return -1;
5625     if (strcmp (r, expected) != 0) {
5626       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5627       return -1;
5628     }
5629     free (r);
5630   }
5631   return 0;
5632 }
5633
5634 static int test_set_e2uuid_1_skip (void)
5635 {
5636   const char *str;
5637
5638   str = getenv ("TEST_ONLY");
5639   if (str)
5640     return strstr (str, "set_e2uuid") == NULL;
5641   str = getenv ("SKIP_TEST_SET_E2UUID_1");
5642   if (str && strcmp (str, "1") == 0) return 1;
5643   str = getenv ("SKIP_TEST_SET_E2UUID");
5644   if (str && strcmp (str, "1") == 0) return 1;
5645   return 0;
5646 }
5647
5648 static int test_set_e2uuid_1 (void)
5649 {
5650   if (test_set_e2uuid_1_skip ()) {
5651     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
5652     return 0;
5653   }
5654
5655   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
5656   {
5657     char device[] = "/dev/sda";
5658     int r;
5659     suppress_error = 0;
5660     r = guestfs_blockdev_setrw (g, device);
5661     if (r == -1)
5662       return -1;
5663   }
5664   {
5665     int r;
5666     suppress_error = 0;
5667     r = guestfs_umount_all (g);
5668     if (r == -1)
5669       return -1;
5670   }
5671   {
5672     int r;
5673     suppress_error = 0;
5674     r = guestfs_lvm_remove_all (g);
5675     if (r == -1)
5676       return -1;
5677   }
5678   {
5679     char device[] = "/dev/sda";
5680     char lines_0[] = ",";
5681     char *lines[] = {
5682       lines_0,
5683       NULL
5684     };
5685     int r;
5686     suppress_error = 0;
5687     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5688     if (r == -1)
5689       return -1;
5690   }
5691   {
5692     char fstype[] = "ext2";
5693     char device[] = "/dev/sda1";
5694     int r;
5695     suppress_error = 0;
5696     r = guestfs_mkfs (g, fstype, device);
5697     if (r == -1)
5698       return -1;
5699   }
5700   {
5701     char device[] = "/dev/sda1";
5702     char mountpoint[] = "/";
5703     int r;
5704     suppress_error = 0;
5705     r = guestfs_mount (g, device, mountpoint);
5706     if (r == -1)
5707       return -1;
5708   }
5709   /* TestOutput for set_e2uuid (1) */
5710   char expected[] = "";
5711   {
5712     char device[] = "/dev/sda1";
5713     char uuid[] = "clear";
5714     int r;
5715     suppress_error = 0;
5716     r = guestfs_set_e2uuid (g, device, uuid);
5717     if (r == -1)
5718       return -1;
5719   }
5720   {
5721     char device[] = "/dev/sda1";
5722     char *r;
5723     suppress_error = 0;
5724     r = guestfs_get_e2uuid (g, device);
5725     if (r == NULL)
5726       return -1;
5727     if (strcmp (r, expected) != 0) {
5728       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
5729       return -1;
5730     }
5731     free (r);
5732   }
5733   return 0;
5734 }
5735
5736 static int test_set_e2uuid_2_skip (void)
5737 {
5738   const char *str;
5739
5740   str = getenv ("TEST_ONLY");
5741   if (str)
5742     return strstr (str, "set_e2uuid") == NULL;
5743   str = getenv ("SKIP_TEST_SET_E2UUID_2");
5744   if (str && strcmp (str, "1") == 0) return 1;
5745   str = getenv ("SKIP_TEST_SET_E2UUID");
5746   if (str && strcmp (str, "1") == 0) return 1;
5747   return 0;
5748 }
5749
5750 static int test_set_e2uuid_2 (void)
5751 {
5752   if (test_set_e2uuid_2_skip ()) {
5753     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
5754     return 0;
5755   }
5756
5757   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
5758   {
5759     char device[] = "/dev/sda";
5760     int r;
5761     suppress_error = 0;
5762     r = guestfs_blockdev_setrw (g, device);
5763     if (r == -1)
5764       return -1;
5765   }
5766   {
5767     int r;
5768     suppress_error = 0;
5769     r = guestfs_umount_all (g);
5770     if (r == -1)
5771       return -1;
5772   }
5773   {
5774     int r;
5775     suppress_error = 0;
5776     r = guestfs_lvm_remove_all (g);
5777     if (r == -1)
5778       return -1;
5779   }
5780   {
5781     char device[] = "/dev/sda";
5782     char lines_0[] = ",";
5783     char *lines[] = {
5784       lines_0,
5785       NULL
5786     };
5787     int r;
5788     suppress_error = 0;
5789     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5790     if (r == -1)
5791       return -1;
5792   }
5793   {
5794     char fstype[] = "ext2";
5795     char device[] = "/dev/sda1";
5796     int r;
5797     suppress_error = 0;
5798     r = guestfs_mkfs (g, fstype, device);
5799     if (r == -1)
5800       return -1;
5801   }
5802   {
5803     char device[] = "/dev/sda1";
5804     char mountpoint[] = "/";
5805     int r;
5806     suppress_error = 0;
5807     r = guestfs_mount (g, device, mountpoint);
5808     if (r == -1)
5809       return -1;
5810   }
5811   /* TestRun for set_e2uuid (2) */
5812   {
5813     char device[] = "/dev/sda1";
5814     char uuid[] = "random";
5815     int r;
5816     suppress_error = 0;
5817     r = guestfs_set_e2uuid (g, device, uuid);
5818     if (r == -1)
5819       return -1;
5820   }
5821   return 0;
5822 }
5823
5824 static int test_set_e2uuid_3_skip (void)
5825 {
5826   const char *str;
5827
5828   str = getenv ("TEST_ONLY");
5829   if (str)
5830     return strstr (str, "set_e2uuid") == NULL;
5831   str = getenv ("SKIP_TEST_SET_E2UUID_3");
5832   if (str && strcmp (str, "1") == 0) return 1;
5833   str = getenv ("SKIP_TEST_SET_E2UUID");
5834   if (str && strcmp (str, "1") == 0) return 1;
5835   return 0;
5836 }
5837
5838 static int test_set_e2uuid_3 (void)
5839 {
5840   if (test_set_e2uuid_3_skip ()) {
5841     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
5842     return 0;
5843   }
5844
5845   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
5846   {
5847     char device[] = "/dev/sda";
5848     int r;
5849     suppress_error = 0;
5850     r = guestfs_blockdev_setrw (g, device);
5851     if (r == -1)
5852       return -1;
5853   }
5854   {
5855     int r;
5856     suppress_error = 0;
5857     r = guestfs_umount_all (g);
5858     if (r == -1)
5859       return -1;
5860   }
5861   {
5862     int r;
5863     suppress_error = 0;
5864     r = guestfs_lvm_remove_all (g);
5865     if (r == -1)
5866       return -1;
5867   }
5868   {
5869     char device[] = "/dev/sda";
5870     char lines_0[] = ",";
5871     char *lines[] = {
5872       lines_0,
5873       NULL
5874     };
5875     int r;
5876     suppress_error = 0;
5877     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5878     if (r == -1)
5879       return -1;
5880   }
5881   {
5882     char fstype[] = "ext2";
5883     char device[] = "/dev/sda1";
5884     int r;
5885     suppress_error = 0;
5886     r = guestfs_mkfs (g, fstype, device);
5887     if (r == -1)
5888       return -1;
5889   }
5890   {
5891     char device[] = "/dev/sda1";
5892     char mountpoint[] = "/";
5893     int r;
5894     suppress_error = 0;
5895     r = guestfs_mount (g, device, mountpoint);
5896     if (r == -1)
5897       return -1;
5898   }
5899   /* TestRun for set_e2uuid (3) */
5900   {
5901     char device[] = "/dev/sda1";
5902     char uuid[] = "time";
5903     int r;
5904     suppress_error = 0;
5905     r = guestfs_set_e2uuid (g, device, uuid);
5906     if (r == -1)
5907       return -1;
5908   }
5909   return 0;
5910 }
5911
5912 static int test_set_e2label_0_skip (void)
5913 {
5914   const char *str;
5915
5916   str = getenv ("TEST_ONLY");
5917   if (str)
5918     return strstr (str, "set_e2label") == NULL;
5919   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
5920   if (str && strcmp (str, "1") == 0) return 1;
5921   str = getenv ("SKIP_TEST_SET_E2LABEL");
5922   if (str && strcmp (str, "1") == 0) return 1;
5923   return 0;
5924 }
5925
5926 static int test_set_e2label_0 (void)
5927 {
5928   if (test_set_e2label_0_skip ()) {
5929     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
5930     return 0;
5931   }
5932
5933   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
5934   {
5935     char device[] = "/dev/sda";
5936     int r;
5937     suppress_error = 0;
5938     r = guestfs_blockdev_setrw (g, device);
5939     if (r == -1)
5940       return -1;
5941   }
5942   {
5943     int r;
5944     suppress_error = 0;
5945     r = guestfs_umount_all (g);
5946     if (r == -1)
5947       return -1;
5948   }
5949   {
5950     int r;
5951     suppress_error = 0;
5952     r = guestfs_lvm_remove_all (g);
5953     if (r == -1)
5954       return -1;
5955   }
5956   {
5957     char device[] = "/dev/sda";
5958     char lines_0[] = ",";
5959     char *lines[] = {
5960       lines_0,
5961       NULL
5962     };
5963     int r;
5964     suppress_error = 0;
5965     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5966     if (r == -1)
5967       return -1;
5968   }
5969   {
5970     char fstype[] = "ext2";
5971     char device[] = "/dev/sda1";
5972     int r;
5973     suppress_error = 0;
5974     r = guestfs_mkfs (g, fstype, device);
5975     if (r == -1)
5976       return -1;
5977   }
5978   {
5979     char device[] = "/dev/sda1";
5980     char mountpoint[] = "/";
5981     int r;
5982     suppress_error = 0;
5983     r = guestfs_mount (g, device, mountpoint);
5984     if (r == -1)
5985       return -1;
5986   }
5987   /* TestOutput for set_e2label (0) */
5988   char expected[] = "testlabel";
5989   {
5990     char device[] = "/dev/sda1";
5991     char label[] = "testlabel";
5992     int r;
5993     suppress_error = 0;
5994     r = guestfs_set_e2label (g, device, label);
5995     if (r == -1)
5996       return -1;
5997   }
5998   {
5999     char device[] = "/dev/sda1";
6000     char *r;
6001     suppress_error = 0;
6002     r = guestfs_get_e2label (g, device);
6003     if (r == NULL)
6004       return -1;
6005     if (strcmp (r, expected) != 0) {
6006       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6007       return -1;
6008     }
6009     free (r);
6010   }
6011   return 0;
6012 }
6013
6014 static int test_pvremove_0_skip (void)
6015 {
6016   const char *str;
6017
6018   str = getenv ("TEST_ONLY");
6019   if (str)
6020     return strstr (str, "pvremove") == NULL;
6021   str = getenv ("SKIP_TEST_PVREMOVE_0");
6022   if (str && strcmp (str, "1") == 0) return 1;
6023   str = getenv ("SKIP_TEST_PVREMOVE");
6024   if (str && strcmp (str, "1") == 0) return 1;
6025   return 0;
6026 }
6027
6028 static int test_pvremove_0 (void)
6029 {
6030   if (test_pvremove_0_skip ()) {
6031     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6032     return 0;
6033   }
6034
6035   /* InitNone|InitEmpty for test_pvremove_0 */
6036   {
6037     char device[] = "/dev/sda";
6038     int r;
6039     suppress_error = 0;
6040     r = guestfs_blockdev_setrw (g, device);
6041     if (r == -1)
6042       return -1;
6043   }
6044   {
6045     int r;
6046     suppress_error = 0;
6047     r = guestfs_umount_all (g);
6048     if (r == -1)
6049       return -1;
6050   }
6051   {
6052     int r;
6053     suppress_error = 0;
6054     r = guestfs_lvm_remove_all (g);
6055     if (r == -1)
6056       return -1;
6057   }
6058   /* TestOutputListOfDevices for pvremove (0) */
6059   {
6060     char device[] = "/dev/sda";
6061     char lines_0[] = ",";
6062     char *lines[] = {
6063       lines_0,
6064       NULL
6065     };
6066     int r;
6067     suppress_error = 0;
6068     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6069     if (r == -1)
6070       return -1;
6071   }
6072   {
6073     char device[] = "/dev/sda1";
6074     int r;
6075     suppress_error = 0;
6076     r = guestfs_pvcreate (g, device);
6077     if (r == -1)
6078       return -1;
6079   }
6080   {
6081     char volgroup[] = "VG";
6082     char physvols_0[] = "/dev/sda1";
6083     char *physvols[] = {
6084       physvols_0,
6085       NULL
6086     };
6087     int r;
6088     suppress_error = 0;
6089     r = guestfs_vgcreate (g, volgroup, physvols);
6090     if (r == -1)
6091       return -1;
6092   }
6093   {
6094     char logvol[] = "LV1";
6095     char volgroup[] = "VG";
6096     int r;
6097     suppress_error = 0;
6098     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6099     if (r == -1)
6100       return -1;
6101   }
6102   {
6103     char logvol[] = "LV2";
6104     char volgroup[] = "VG";
6105     int r;
6106     suppress_error = 0;
6107     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6108     if (r == -1)
6109       return -1;
6110   }
6111   {
6112     char vgname[] = "VG";
6113     int r;
6114     suppress_error = 0;
6115     r = guestfs_vgremove (g, vgname);
6116     if (r == -1)
6117       return -1;
6118   }
6119   {
6120     char device[] = "/dev/sda1";
6121     int r;
6122     suppress_error = 0;
6123     r = guestfs_pvremove (g, device);
6124     if (r == -1)
6125       return -1;
6126   }
6127   {
6128     char **r;
6129     int i;
6130     suppress_error = 0;
6131     r = guestfs_lvs (g);
6132     if (r == NULL)
6133       return -1;
6134     if (r[0] != NULL) {
6135       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6136       print_strings (r);
6137       return -1;
6138     }
6139     for (i = 0; r[i] != NULL; ++i)
6140       free (r[i]);
6141     free (r);
6142   }
6143   return 0;
6144 }
6145
6146 static int test_pvremove_1_skip (void)
6147 {
6148   const char *str;
6149
6150   str = getenv ("TEST_ONLY");
6151   if (str)
6152     return strstr (str, "pvremove") == NULL;
6153   str = getenv ("SKIP_TEST_PVREMOVE_1");
6154   if (str && strcmp (str, "1") == 0) return 1;
6155   str = getenv ("SKIP_TEST_PVREMOVE");
6156   if (str && strcmp (str, "1") == 0) return 1;
6157   return 0;
6158 }
6159
6160 static int test_pvremove_1 (void)
6161 {
6162   if (test_pvremove_1_skip ()) {
6163     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6164     return 0;
6165   }
6166
6167   /* InitNone|InitEmpty for test_pvremove_1 */
6168   {
6169     char device[] = "/dev/sda";
6170     int r;
6171     suppress_error = 0;
6172     r = guestfs_blockdev_setrw (g, device);
6173     if (r == -1)
6174       return -1;
6175   }
6176   {
6177     int r;
6178     suppress_error = 0;
6179     r = guestfs_umount_all (g);
6180     if (r == -1)
6181       return -1;
6182   }
6183   {
6184     int r;
6185     suppress_error = 0;
6186     r = guestfs_lvm_remove_all (g);
6187     if (r == -1)
6188       return -1;
6189   }
6190   /* TestOutputListOfDevices for pvremove (1) */
6191   {
6192     char device[] = "/dev/sda";
6193     char lines_0[] = ",";
6194     char *lines[] = {
6195       lines_0,
6196       NULL
6197     };
6198     int r;
6199     suppress_error = 0;
6200     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6201     if (r == -1)
6202       return -1;
6203   }
6204   {
6205     char device[] = "/dev/sda1";
6206     int r;
6207     suppress_error = 0;
6208     r = guestfs_pvcreate (g, device);
6209     if (r == -1)
6210       return -1;
6211   }
6212   {
6213     char volgroup[] = "VG";
6214     char physvols_0[] = "/dev/sda1";
6215     char *physvols[] = {
6216       physvols_0,
6217       NULL
6218     };
6219     int r;
6220     suppress_error = 0;
6221     r = guestfs_vgcreate (g, volgroup, physvols);
6222     if (r == -1)
6223       return -1;
6224   }
6225   {
6226     char logvol[] = "LV1";
6227     char volgroup[] = "VG";
6228     int r;
6229     suppress_error = 0;
6230     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6231     if (r == -1)
6232       return -1;
6233   }
6234   {
6235     char logvol[] = "LV2";
6236     char volgroup[] = "VG";
6237     int r;
6238     suppress_error = 0;
6239     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6240     if (r == -1)
6241       return -1;
6242   }
6243   {
6244     char vgname[] = "VG";
6245     int r;
6246     suppress_error = 0;
6247     r = guestfs_vgremove (g, vgname);
6248     if (r == -1)
6249       return -1;
6250   }
6251   {
6252     char device[] = "/dev/sda1";
6253     int r;
6254     suppress_error = 0;
6255     r = guestfs_pvremove (g, device);
6256     if (r == -1)
6257       return -1;
6258   }
6259   {
6260     char **r;
6261     int i;
6262     suppress_error = 0;
6263     r = guestfs_vgs (g);
6264     if (r == NULL)
6265       return -1;
6266     if (r[0] != NULL) {
6267       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6268       print_strings (r);
6269       return -1;
6270     }
6271     for (i = 0; r[i] != NULL; ++i)
6272       free (r[i]);
6273     free (r);
6274   }
6275   return 0;
6276 }
6277
6278 static int test_pvremove_2_skip (void)
6279 {
6280   const char *str;
6281
6282   str = getenv ("TEST_ONLY");
6283   if (str)
6284     return strstr (str, "pvremove") == NULL;
6285   str = getenv ("SKIP_TEST_PVREMOVE_2");
6286   if (str && strcmp (str, "1") == 0) return 1;
6287   str = getenv ("SKIP_TEST_PVREMOVE");
6288   if (str && strcmp (str, "1") == 0) return 1;
6289   return 0;
6290 }
6291
6292 static int test_pvremove_2 (void)
6293 {
6294   if (test_pvremove_2_skip ()) {
6295     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6296     return 0;
6297   }
6298
6299   /* InitNone|InitEmpty for test_pvremove_2 */
6300   {
6301     char device[] = "/dev/sda";
6302     int r;
6303     suppress_error = 0;
6304     r = guestfs_blockdev_setrw (g, device);
6305     if (r == -1)
6306       return -1;
6307   }
6308   {
6309     int r;
6310     suppress_error = 0;
6311     r = guestfs_umount_all (g);
6312     if (r == -1)
6313       return -1;
6314   }
6315   {
6316     int r;
6317     suppress_error = 0;
6318     r = guestfs_lvm_remove_all (g);
6319     if (r == -1)
6320       return -1;
6321   }
6322   /* TestOutputListOfDevices for pvremove (2) */
6323   {
6324     char device[] = "/dev/sda";
6325     char lines_0[] = ",";
6326     char *lines[] = {
6327       lines_0,
6328       NULL
6329     };
6330     int r;
6331     suppress_error = 0;
6332     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6333     if (r == -1)
6334       return -1;
6335   }
6336   {
6337     char device[] = "/dev/sda1";
6338     int r;
6339     suppress_error = 0;
6340     r = guestfs_pvcreate (g, device);
6341     if (r == -1)
6342       return -1;
6343   }
6344   {
6345     char volgroup[] = "VG";
6346     char physvols_0[] = "/dev/sda1";
6347     char *physvols[] = {
6348       physvols_0,
6349       NULL
6350     };
6351     int r;
6352     suppress_error = 0;
6353     r = guestfs_vgcreate (g, volgroup, physvols);
6354     if (r == -1)
6355       return -1;
6356   }
6357   {
6358     char logvol[] = "LV1";
6359     char volgroup[] = "VG";
6360     int r;
6361     suppress_error = 0;
6362     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6363     if (r == -1)
6364       return -1;
6365   }
6366   {
6367     char logvol[] = "LV2";
6368     char volgroup[] = "VG";
6369     int r;
6370     suppress_error = 0;
6371     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6372     if (r == -1)
6373       return -1;
6374   }
6375   {
6376     char vgname[] = "VG";
6377     int r;
6378     suppress_error = 0;
6379     r = guestfs_vgremove (g, vgname);
6380     if (r == -1)
6381       return -1;
6382   }
6383   {
6384     char device[] = "/dev/sda1";
6385     int r;
6386     suppress_error = 0;
6387     r = guestfs_pvremove (g, device);
6388     if (r == -1)
6389       return -1;
6390   }
6391   {
6392     char **r;
6393     int i;
6394     suppress_error = 0;
6395     r = guestfs_pvs (g);
6396     if (r == NULL)
6397       return -1;
6398     if (r[0] != NULL) {
6399       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6400       print_strings (r);
6401       return -1;
6402     }
6403     for (i = 0; r[i] != NULL; ++i)
6404       free (r[i]);
6405     free (r);
6406   }
6407   return 0;
6408 }
6409
6410 static int test_vgremove_0_skip (void)
6411 {
6412   const char *str;
6413
6414   str = getenv ("TEST_ONLY");
6415   if (str)
6416     return strstr (str, "vgremove") == NULL;
6417   str = getenv ("SKIP_TEST_VGREMOVE_0");
6418   if (str && strcmp (str, "1") == 0) return 1;
6419   str = getenv ("SKIP_TEST_VGREMOVE");
6420   if (str && strcmp (str, "1") == 0) return 1;
6421   return 0;
6422 }
6423
6424 static int test_vgremove_0 (void)
6425 {
6426   if (test_vgremove_0_skip ()) {
6427     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6428     return 0;
6429   }
6430
6431   /* InitNone|InitEmpty for test_vgremove_0 */
6432   {
6433     char device[] = "/dev/sda";
6434     int r;
6435     suppress_error = 0;
6436     r = guestfs_blockdev_setrw (g, device);
6437     if (r == -1)
6438       return -1;
6439   }
6440   {
6441     int r;
6442     suppress_error = 0;
6443     r = guestfs_umount_all (g);
6444     if (r == -1)
6445       return -1;
6446   }
6447   {
6448     int r;
6449     suppress_error = 0;
6450     r = guestfs_lvm_remove_all (g);
6451     if (r == -1)
6452       return -1;
6453   }
6454   /* TestOutputList for vgremove (0) */
6455   {
6456     char device[] = "/dev/sda";
6457     char lines_0[] = ",";
6458     char *lines[] = {
6459       lines_0,
6460       NULL
6461     };
6462     int r;
6463     suppress_error = 0;
6464     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6465     if (r == -1)
6466       return -1;
6467   }
6468   {
6469     char device[] = "/dev/sda1";
6470     int r;
6471     suppress_error = 0;
6472     r = guestfs_pvcreate (g, device);
6473     if (r == -1)
6474       return -1;
6475   }
6476   {
6477     char volgroup[] = "VG";
6478     char physvols_0[] = "/dev/sda1";
6479     char *physvols[] = {
6480       physvols_0,
6481       NULL
6482     };
6483     int r;
6484     suppress_error = 0;
6485     r = guestfs_vgcreate (g, volgroup, physvols);
6486     if (r == -1)
6487       return -1;
6488   }
6489   {
6490     char logvol[] = "LV1";
6491     char volgroup[] = "VG";
6492     int r;
6493     suppress_error = 0;
6494     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6495     if (r == -1)
6496       return -1;
6497   }
6498   {
6499     char logvol[] = "LV2";
6500     char volgroup[] = "VG";
6501     int r;
6502     suppress_error = 0;
6503     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6504     if (r == -1)
6505       return -1;
6506   }
6507   {
6508     char vgname[] = "VG";
6509     int r;
6510     suppress_error = 0;
6511     r = guestfs_vgremove (g, vgname);
6512     if (r == -1)
6513       return -1;
6514   }
6515   {
6516     char **r;
6517     int i;
6518     suppress_error = 0;
6519     r = guestfs_lvs (g);
6520     if (r == NULL)
6521       return -1;
6522     if (r[0] != NULL) {
6523       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6524       print_strings (r);
6525       return -1;
6526     }
6527     for (i = 0; r[i] != NULL; ++i)
6528       free (r[i]);
6529     free (r);
6530   }
6531   return 0;
6532 }
6533
6534 static int test_vgremove_1_skip (void)
6535 {
6536   const char *str;
6537
6538   str = getenv ("TEST_ONLY");
6539   if (str)
6540     return strstr (str, "vgremove") == NULL;
6541   str = getenv ("SKIP_TEST_VGREMOVE_1");
6542   if (str && strcmp (str, "1") == 0) return 1;
6543   str = getenv ("SKIP_TEST_VGREMOVE");
6544   if (str && strcmp (str, "1") == 0) return 1;
6545   return 0;
6546 }
6547
6548 static int test_vgremove_1 (void)
6549 {
6550   if (test_vgremove_1_skip ()) {
6551     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6552     return 0;
6553   }
6554
6555   /* InitNone|InitEmpty for test_vgremove_1 */
6556   {
6557     char device[] = "/dev/sda";
6558     int r;
6559     suppress_error = 0;
6560     r = guestfs_blockdev_setrw (g, device);
6561     if (r == -1)
6562       return -1;
6563   }
6564   {
6565     int r;
6566     suppress_error = 0;
6567     r = guestfs_umount_all (g);
6568     if (r == -1)
6569       return -1;
6570   }
6571   {
6572     int r;
6573     suppress_error = 0;
6574     r = guestfs_lvm_remove_all (g);
6575     if (r == -1)
6576       return -1;
6577   }
6578   /* TestOutputList for vgremove (1) */
6579   {
6580     char device[] = "/dev/sda";
6581     char lines_0[] = ",";
6582     char *lines[] = {
6583       lines_0,
6584       NULL
6585     };
6586     int r;
6587     suppress_error = 0;
6588     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6589     if (r == -1)
6590       return -1;
6591   }
6592   {
6593     char device[] = "/dev/sda1";
6594     int r;
6595     suppress_error = 0;
6596     r = guestfs_pvcreate (g, device);
6597     if (r == -1)
6598       return -1;
6599   }
6600   {
6601     char volgroup[] = "VG";
6602     char physvols_0[] = "/dev/sda1";
6603     char *physvols[] = {
6604       physvols_0,
6605       NULL
6606     };
6607     int r;
6608     suppress_error = 0;
6609     r = guestfs_vgcreate (g, volgroup, physvols);
6610     if (r == -1)
6611       return -1;
6612   }
6613   {
6614     char logvol[] = "LV1";
6615     char volgroup[] = "VG";
6616     int r;
6617     suppress_error = 0;
6618     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6619     if (r == -1)
6620       return -1;
6621   }
6622   {
6623     char logvol[] = "LV2";
6624     char volgroup[] = "VG";
6625     int r;
6626     suppress_error = 0;
6627     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6628     if (r == -1)
6629       return -1;
6630   }
6631   {
6632     char vgname[] = "VG";
6633     int r;
6634     suppress_error = 0;
6635     r = guestfs_vgremove (g, vgname);
6636     if (r == -1)
6637       return -1;
6638   }
6639   {
6640     char **r;
6641     int i;
6642     suppress_error = 0;
6643     r = guestfs_vgs (g);
6644     if (r == NULL)
6645       return -1;
6646     if (r[0] != NULL) {
6647       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
6648       print_strings (r);
6649       return -1;
6650     }
6651     for (i = 0; r[i] != NULL; ++i)
6652       free (r[i]);
6653     free (r);
6654   }
6655   return 0;
6656 }
6657
6658 static int test_lvremove_0_skip (void)
6659 {
6660   const char *str;
6661
6662   str = getenv ("TEST_ONLY");
6663   if (str)
6664     return strstr (str, "lvremove") == NULL;
6665   str = getenv ("SKIP_TEST_LVREMOVE_0");
6666   if (str && strcmp (str, "1") == 0) return 1;
6667   str = getenv ("SKIP_TEST_LVREMOVE");
6668   if (str && strcmp (str, "1") == 0) return 1;
6669   return 0;
6670 }
6671
6672 static int test_lvremove_0 (void)
6673 {
6674   if (test_lvremove_0_skip ()) {
6675     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
6676     return 0;
6677   }
6678
6679   /* InitNone|InitEmpty for test_lvremove_0 */
6680   {
6681     char device[] = "/dev/sda";
6682     int r;
6683     suppress_error = 0;
6684     r = guestfs_blockdev_setrw (g, device);
6685     if (r == -1)
6686       return -1;
6687   }
6688   {
6689     int r;
6690     suppress_error = 0;
6691     r = guestfs_umount_all (g);
6692     if (r == -1)
6693       return -1;
6694   }
6695   {
6696     int r;
6697     suppress_error = 0;
6698     r = guestfs_lvm_remove_all (g);
6699     if (r == -1)
6700       return -1;
6701   }
6702   /* TestOutputList for lvremove (0) */
6703   {
6704     char device[] = "/dev/sda";
6705     char lines_0[] = ",";
6706     char *lines[] = {
6707       lines_0,
6708       NULL
6709     };
6710     int r;
6711     suppress_error = 0;
6712     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6713     if (r == -1)
6714       return -1;
6715   }
6716   {
6717     char device[] = "/dev/sda1";
6718     int r;
6719     suppress_error = 0;
6720     r = guestfs_pvcreate (g, device);
6721     if (r == -1)
6722       return -1;
6723   }
6724   {
6725     char volgroup[] = "VG";
6726     char physvols_0[] = "/dev/sda1";
6727     char *physvols[] = {
6728       physvols_0,
6729       NULL
6730     };
6731     int r;
6732     suppress_error = 0;
6733     r = guestfs_vgcreate (g, volgroup, physvols);
6734     if (r == -1)
6735       return -1;
6736   }
6737   {
6738     char logvol[] = "LV1";
6739     char volgroup[] = "VG";
6740     int r;
6741     suppress_error = 0;
6742     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6743     if (r == -1)
6744       return -1;
6745   }
6746   {
6747     char logvol[] = "LV2";
6748     char volgroup[] = "VG";
6749     int r;
6750     suppress_error = 0;
6751     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6752     if (r == -1)
6753       return -1;
6754   }
6755   {
6756     char device[] = "/dev/VG/LV1";
6757     int r;
6758     suppress_error = 0;
6759     r = guestfs_lvremove (g, device);
6760     if (r == -1)
6761       return -1;
6762   }
6763   {
6764     char **r;
6765     int i;
6766     suppress_error = 0;
6767     r = guestfs_lvs (g);
6768     if (r == NULL)
6769       return -1;
6770     if (!r[0]) {
6771       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
6772       print_strings (r);
6773       return -1;
6774     }
6775     {
6776       char expected[] = "/dev/VG/LV2";
6777       if (strcmp (r[0], expected) != 0) {
6778         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6779         return -1;
6780       }
6781     }
6782     if (r[1] != NULL) {
6783       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
6784       print_strings (r);
6785       return -1;
6786     }
6787     for (i = 0; r[i] != NULL; ++i)
6788       free (r[i]);
6789     free (r);
6790   }
6791   return 0;
6792 }
6793
6794 static int test_lvremove_1_skip (void)
6795 {
6796   const char *str;
6797
6798   str = getenv ("TEST_ONLY");
6799   if (str)
6800     return strstr (str, "lvremove") == NULL;
6801   str = getenv ("SKIP_TEST_LVREMOVE_1");
6802   if (str && strcmp (str, "1") == 0) return 1;
6803   str = getenv ("SKIP_TEST_LVREMOVE");
6804   if (str && strcmp (str, "1") == 0) return 1;
6805   return 0;
6806 }
6807
6808 static int test_lvremove_1 (void)
6809 {
6810   if (test_lvremove_1_skip ()) {
6811     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
6812     return 0;
6813   }
6814
6815   /* InitNone|InitEmpty for test_lvremove_1 */
6816   {
6817     char device[] = "/dev/sda";
6818     int r;
6819     suppress_error = 0;
6820     r = guestfs_blockdev_setrw (g, device);
6821     if (r == -1)
6822       return -1;
6823   }
6824   {
6825     int r;
6826     suppress_error = 0;
6827     r = guestfs_umount_all (g);
6828     if (r == -1)
6829       return -1;
6830   }
6831   {
6832     int r;
6833     suppress_error = 0;
6834     r = guestfs_lvm_remove_all (g);
6835     if (r == -1)
6836       return -1;
6837   }
6838   /* TestOutputList for lvremove (1) */
6839   {
6840     char device[] = "/dev/sda";
6841     char lines_0[] = ",";
6842     char *lines[] = {
6843       lines_0,
6844       NULL
6845     };
6846     int r;
6847     suppress_error = 0;
6848     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6849     if (r == -1)
6850       return -1;
6851   }
6852   {
6853     char device[] = "/dev/sda1";
6854     int r;
6855     suppress_error = 0;
6856     r = guestfs_pvcreate (g, device);
6857     if (r == -1)
6858       return -1;
6859   }
6860   {
6861     char volgroup[] = "VG";
6862     char physvols_0[] = "/dev/sda1";
6863     char *physvols[] = {
6864       physvols_0,
6865       NULL
6866     };
6867     int r;
6868     suppress_error = 0;
6869     r = guestfs_vgcreate (g, volgroup, physvols);
6870     if (r == -1)
6871       return -1;
6872   }
6873   {
6874     char logvol[] = "LV1";
6875     char volgroup[] = "VG";
6876     int r;
6877     suppress_error = 0;
6878     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6879     if (r == -1)
6880       return -1;
6881   }
6882   {
6883     char logvol[] = "LV2";
6884     char volgroup[] = "VG";
6885     int r;
6886     suppress_error = 0;
6887     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6888     if (r == -1)
6889       return -1;
6890   }
6891   {
6892     char device[] = "/dev/VG";
6893     int r;
6894     suppress_error = 0;
6895     r = guestfs_lvremove (g, device);
6896     if (r == -1)
6897       return -1;
6898   }
6899   {
6900     char **r;
6901     int i;
6902     suppress_error = 0;
6903     r = guestfs_lvs (g);
6904     if (r == NULL)
6905       return -1;
6906     if (r[0] != NULL) {
6907       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
6908       print_strings (r);
6909       return -1;
6910     }
6911     for (i = 0; r[i] != NULL; ++i)
6912       free (r[i]);
6913     free (r);
6914   }
6915   return 0;
6916 }
6917
6918 static int test_lvremove_2_skip (void)
6919 {
6920   const char *str;
6921
6922   str = getenv ("TEST_ONLY");
6923   if (str)
6924     return strstr (str, "lvremove") == NULL;
6925   str = getenv ("SKIP_TEST_LVREMOVE_2");
6926   if (str && strcmp (str, "1") == 0) return 1;
6927   str = getenv ("SKIP_TEST_LVREMOVE");
6928   if (str && strcmp (str, "1") == 0) return 1;
6929   return 0;
6930 }
6931
6932 static int test_lvremove_2 (void)
6933 {
6934   if (test_lvremove_2_skip ()) {
6935     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
6936     return 0;
6937   }
6938
6939   /* InitNone|InitEmpty for test_lvremove_2 */
6940   {
6941     char device[] = "/dev/sda";
6942     int r;
6943     suppress_error = 0;
6944     r = guestfs_blockdev_setrw (g, device);
6945     if (r == -1)
6946       return -1;
6947   }
6948   {
6949     int r;
6950     suppress_error = 0;
6951     r = guestfs_umount_all (g);
6952     if (r == -1)
6953       return -1;
6954   }
6955   {
6956     int r;
6957     suppress_error = 0;
6958     r = guestfs_lvm_remove_all (g);
6959     if (r == -1)
6960       return -1;
6961   }
6962   /* TestOutputList for lvremove (2) */
6963   {
6964     char device[] = "/dev/sda";
6965     char lines_0[] = ",";
6966     char *lines[] = {
6967       lines_0,
6968       NULL
6969     };
6970     int r;
6971     suppress_error = 0;
6972     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6973     if (r == -1)
6974       return -1;
6975   }
6976   {
6977     char device[] = "/dev/sda1";
6978     int r;
6979     suppress_error = 0;
6980     r = guestfs_pvcreate (g, device);
6981     if (r == -1)
6982       return -1;
6983   }
6984   {
6985     char volgroup[] = "VG";
6986     char physvols_0[] = "/dev/sda1";
6987     char *physvols[] = {
6988       physvols_0,
6989       NULL
6990     };
6991     int r;
6992     suppress_error = 0;
6993     r = guestfs_vgcreate (g, volgroup, physvols);
6994     if (r == -1)
6995       return -1;
6996   }
6997   {
6998     char logvol[] = "LV1";
6999     char volgroup[] = "VG";
7000     int r;
7001     suppress_error = 0;
7002     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7003     if (r == -1)
7004       return -1;
7005   }
7006   {
7007     char logvol[] = "LV2";
7008     char volgroup[] = "VG";
7009     int r;
7010     suppress_error = 0;
7011     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7012     if (r == -1)
7013       return -1;
7014   }
7015   {
7016     char device[] = "/dev/VG";
7017     int r;
7018     suppress_error = 0;
7019     r = guestfs_lvremove (g, device);
7020     if (r == -1)
7021       return -1;
7022   }
7023   {
7024     char **r;
7025     int i;
7026     suppress_error = 0;
7027     r = guestfs_vgs (g);
7028     if (r == NULL)
7029       return -1;
7030     if (!r[0]) {
7031       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7032       print_strings (r);
7033       return -1;
7034     }
7035     {
7036       char expected[] = "VG";
7037       if (strcmp (r[0], expected) != 0) {
7038         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7039         return -1;
7040       }
7041     }
7042     if (r[1] != NULL) {
7043       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7044       print_strings (r);
7045       return -1;
7046     }
7047     for (i = 0; r[i] != NULL; ++i)
7048       free (r[i]);
7049     free (r);
7050   }
7051   return 0;
7052 }
7053
7054 static int test_mount_ro_0_skip (void)
7055 {
7056   const char *str;
7057
7058   str = getenv ("TEST_ONLY");
7059   if (str)
7060     return strstr (str, "mount_ro") == NULL;
7061   str = getenv ("SKIP_TEST_MOUNT_RO_0");
7062   if (str && strcmp (str, "1") == 0) return 1;
7063   str = getenv ("SKIP_TEST_MOUNT_RO");
7064   if (str && strcmp (str, "1") == 0) return 1;
7065   return 0;
7066 }
7067
7068 static int test_mount_ro_0 (void)
7069 {
7070   if (test_mount_ro_0_skip ()) {
7071     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7072     return 0;
7073   }
7074
7075   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7076   {
7077     char device[] = "/dev/sda";
7078     int r;
7079     suppress_error = 0;
7080     r = guestfs_blockdev_setrw (g, device);
7081     if (r == -1)
7082       return -1;
7083   }
7084   {
7085     int r;
7086     suppress_error = 0;
7087     r = guestfs_umount_all (g);
7088     if (r == -1)
7089       return -1;
7090   }
7091   {
7092     int r;
7093     suppress_error = 0;
7094     r = guestfs_lvm_remove_all (g);
7095     if (r == -1)
7096       return -1;
7097   }
7098   {
7099     char device[] = "/dev/sda";
7100     char lines_0[] = ",";
7101     char *lines[] = {
7102       lines_0,
7103       NULL
7104     };
7105     int r;
7106     suppress_error = 0;
7107     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7108     if (r == -1)
7109       return -1;
7110   }
7111   {
7112     char fstype[] = "ext2";
7113     char device[] = "/dev/sda1";
7114     int r;
7115     suppress_error = 0;
7116     r = guestfs_mkfs (g, fstype, device);
7117     if (r == -1)
7118       return -1;
7119   }
7120   {
7121     char device[] = "/dev/sda1";
7122     char mountpoint[] = "/";
7123     int r;
7124     suppress_error = 0;
7125     r = guestfs_mount (g, device, mountpoint);
7126     if (r == -1)
7127       return -1;
7128   }
7129   /* TestLastFail for mount_ro (0) */
7130   {
7131     char pathordevice[] = "/";
7132     int r;
7133     suppress_error = 0;
7134     r = guestfs_umount (g, pathordevice);
7135     if (r == -1)
7136       return -1;
7137   }
7138   {
7139     char device[] = "/dev/sda1";
7140     char mountpoint[] = "/";
7141     int r;
7142     suppress_error = 0;
7143     r = guestfs_mount_ro (g, device, mountpoint);
7144     if (r == -1)
7145       return -1;
7146   }
7147   {
7148     char path[] = "/new";
7149     int r;
7150     suppress_error = 1;
7151     r = guestfs_touch (g, path);
7152     if (r != -1)
7153       return -1;
7154   }
7155   return 0;
7156 }
7157
7158 static int test_mount_ro_1_skip (void)
7159 {
7160   const char *str;
7161
7162   str = getenv ("TEST_ONLY");
7163   if (str)
7164     return strstr (str, "mount_ro") == NULL;
7165   str = getenv ("SKIP_TEST_MOUNT_RO_1");
7166   if (str && strcmp (str, "1") == 0) return 1;
7167   str = getenv ("SKIP_TEST_MOUNT_RO");
7168   if (str && strcmp (str, "1") == 0) return 1;
7169   return 0;
7170 }
7171
7172 static int test_mount_ro_1 (void)
7173 {
7174   if (test_mount_ro_1_skip ()) {
7175     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7176     return 0;
7177   }
7178
7179   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7180   {
7181     char device[] = "/dev/sda";
7182     int r;
7183     suppress_error = 0;
7184     r = guestfs_blockdev_setrw (g, device);
7185     if (r == -1)
7186       return -1;
7187   }
7188   {
7189     int r;
7190     suppress_error = 0;
7191     r = guestfs_umount_all (g);
7192     if (r == -1)
7193       return -1;
7194   }
7195   {
7196     int r;
7197     suppress_error = 0;
7198     r = guestfs_lvm_remove_all (g);
7199     if (r == -1)
7200       return -1;
7201   }
7202   {
7203     char device[] = "/dev/sda";
7204     char lines_0[] = ",";
7205     char *lines[] = {
7206       lines_0,
7207       NULL
7208     };
7209     int r;
7210     suppress_error = 0;
7211     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7212     if (r == -1)
7213       return -1;
7214   }
7215   {
7216     char fstype[] = "ext2";
7217     char device[] = "/dev/sda1";
7218     int r;
7219     suppress_error = 0;
7220     r = guestfs_mkfs (g, fstype, device);
7221     if (r == -1)
7222       return -1;
7223   }
7224   {
7225     char device[] = "/dev/sda1";
7226     char mountpoint[] = "/";
7227     int r;
7228     suppress_error = 0;
7229     r = guestfs_mount (g, device, mountpoint);
7230     if (r == -1)
7231       return -1;
7232   }
7233   /* TestOutput for mount_ro (1) */
7234   char expected[] = "data";
7235   {
7236     char path[] = "/new";
7237     char content[] = "data";
7238     int r;
7239     suppress_error = 0;
7240     r = guestfs_write_file (g, path, content, 0);
7241     if (r == -1)
7242       return -1;
7243   }
7244   {
7245     char pathordevice[] = "/";
7246     int r;
7247     suppress_error = 0;
7248     r = guestfs_umount (g, pathordevice);
7249     if (r == -1)
7250       return -1;
7251   }
7252   {
7253     char device[] = "/dev/sda1";
7254     char mountpoint[] = "/";
7255     int r;
7256     suppress_error = 0;
7257     r = guestfs_mount_ro (g, device, mountpoint);
7258     if (r == -1)
7259       return -1;
7260   }
7261   {
7262     char path[] = "/new";
7263     char *r;
7264     suppress_error = 0;
7265     r = guestfs_cat (g, path);
7266     if (r == NULL)
7267       return -1;
7268     if (strcmp (r, expected) != 0) {
7269       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7270       return -1;
7271     }
7272     free (r);
7273   }
7274   return 0;
7275 }
7276
7277 static int test_tgz_in_0_skip (void)
7278 {
7279   const char *str;
7280
7281   str = getenv ("TEST_ONLY");
7282   if (str)
7283     return strstr (str, "tgz_in") == NULL;
7284   str = getenv ("SKIP_TEST_TGZ_IN_0");
7285   if (str && strcmp (str, "1") == 0) return 1;
7286   str = getenv ("SKIP_TEST_TGZ_IN");
7287   if (str && strcmp (str, "1") == 0) return 1;
7288   return 0;
7289 }
7290
7291 static int test_tgz_in_0 (void)
7292 {
7293   if (test_tgz_in_0_skip ()) {
7294     printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7295     return 0;
7296   }
7297
7298   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7299   {
7300     char device[] = "/dev/sda";
7301     int r;
7302     suppress_error = 0;
7303     r = guestfs_blockdev_setrw (g, device);
7304     if (r == -1)
7305       return -1;
7306   }
7307   {
7308     int r;
7309     suppress_error = 0;
7310     r = guestfs_umount_all (g);
7311     if (r == -1)
7312       return -1;
7313   }
7314   {
7315     int r;
7316     suppress_error = 0;
7317     r = guestfs_lvm_remove_all (g);
7318     if (r == -1)
7319       return -1;
7320   }
7321   {
7322     char device[] = "/dev/sda";
7323     char lines_0[] = ",";
7324     char *lines[] = {
7325       lines_0,
7326       NULL
7327     };
7328     int r;
7329     suppress_error = 0;
7330     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7331     if (r == -1)
7332       return -1;
7333   }
7334   {
7335     char fstype[] = "ext2";
7336     char device[] = "/dev/sda1";
7337     int r;
7338     suppress_error = 0;
7339     r = guestfs_mkfs (g, fstype, device);
7340     if (r == -1)
7341       return -1;
7342   }
7343   {
7344     char device[] = "/dev/sda1";
7345     char mountpoint[] = "/";
7346     int r;
7347     suppress_error = 0;
7348     r = guestfs_mount (g, device, mountpoint);
7349     if (r == -1)
7350       return -1;
7351   }
7352   /* TestOutput for tgz_in (0) */
7353   char expected[] = "hello\n";
7354   {
7355     char directory[] = "/";
7356     int r;
7357     suppress_error = 0;
7358     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7359     if (r == -1)
7360       return -1;
7361   }
7362   {
7363     char path[] = "/hello";
7364     char *r;
7365     suppress_error = 0;
7366     r = guestfs_cat (g, path);
7367     if (r == NULL)
7368       return -1;
7369     if (strcmp (r, expected) != 0) {
7370       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7371       return -1;
7372     }
7373     free (r);
7374   }
7375   return 0;
7376 }
7377
7378 static int test_tar_in_0_skip (void)
7379 {
7380   const char *str;
7381
7382   str = getenv ("TEST_ONLY");
7383   if (str)
7384     return strstr (str, "tar_in") == NULL;
7385   str = getenv ("SKIP_TEST_TAR_IN_0");
7386   if (str && strcmp (str, "1") == 0) return 1;
7387   str = getenv ("SKIP_TEST_TAR_IN");
7388   if (str && strcmp (str, "1") == 0) return 1;
7389   return 0;
7390 }
7391
7392 static int test_tar_in_0 (void)
7393 {
7394   if (test_tar_in_0_skip ()) {
7395     printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7396     return 0;
7397   }
7398
7399   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7400   {
7401     char device[] = "/dev/sda";
7402     int r;
7403     suppress_error = 0;
7404     r = guestfs_blockdev_setrw (g, device);
7405     if (r == -1)
7406       return -1;
7407   }
7408   {
7409     int r;
7410     suppress_error = 0;
7411     r = guestfs_umount_all (g);
7412     if (r == -1)
7413       return -1;
7414   }
7415   {
7416     int r;
7417     suppress_error = 0;
7418     r = guestfs_lvm_remove_all (g);
7419     if (r == -1)
7420       return -1;
7421   }
7422   {
7423     char device[] = "/dev/sda";
7424     char lines_0[] = ",";
7425     char *lines[] = {
7426       lines_0,
7427       NULL
7428     };
7429     int r;
7430     suppress_error = 0;
7431     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7432     if (r == -1)
7433       return -1;
7434   }
7435   {
7436     char fstype[] = "ext2";
7437     char device[] = "/dev/sda1";
7438     int r;
7439     suppress_error = 0;
7440     r = guestfs_mkfs (g, fstype, device);
7441     if (r == -1)
7442       return -1;
7443   }
7444   {
7445     char device[] = "/dev/sda1";
7446     char mountpoint[] = "/";
7447     int r;
7448     suppress_error = 0;
7449     r = guestfs_mount (g, device, mountpoint);
7450     if (r == -1)
7451       return -1;
7452   }
7453   /* TestOutput for tar_in (0) */
7454   char expected[] = "hello\n";
7455   {
7456     char directory[] = "/";
7457     int r;
7458     suppress_error = 0;
7459     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7460     if (r == -1)
7461       return -1;
7462   }
7463   {
7464     char path[] = "/hello";
7465     char *r;
7466     suppress_error = 0;
7467     r = guestfs_cat (g, path);
7468     if (r == NULL)
7469       return -1;
7470     if (strcmp (r, expected) != 0) {
7471       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7472       return -1;
7473     }
7474     free (r);
7475   }
7476   return 0;
7477 }
7478
7479 static int test_checksum_0_skip (void)
7480 {
7481   const char *str;
7482
7483   str = getenv ("TEST_ONLY");
7484   if (str)
7485     return strstr (str, "checksum") == NULL;
7486   str = getenv ("SKIP_TEST_CHECKSUM_0");
7487   if (str && strcmp (str, "1") == 0) return 1;
7488   str = getenv ("SKIP_TEST_CHECKSUM");
7489   if (str && strcmp (str, "1") == 0) return 1;
7490   return 0;
7491 }
7492
7493 static int test_checksum_0 (void)
7494 {
7495   if (test_checksum_0_skip ()) {
7496     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7497     return 0;
7498   }
7499
7500   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7501   {
7502     char device[] = "/dev/sda";
7503     int r;
7504     suppress_error = 0;
7505     r = guestfs_blockdev_setrw (g, device);
7506     if (r == -1)
7507       return -1;
7508   }
7509   {
7510     int r;
7511     suppress_error = 0;
7512     r = guestfs_umount_all (g);
7513     if (r == -1)
7514       return -1;
7515   }
7516   {
7517     int r;
7518     suppress_error = 0;
7519     r = guestfs_lvm_remove_all (g);
7520     if (r == -1)
7521       return -1;
7522   }
7523   {
7524     char device[] = "/dev/sda";
7525     char lines_0[] = ",";
7526     char *lines[] = {
7527       lines_0,
7528       NULL
7529     };
7530     int r;
7531     suppress_error = 0;
7532     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7533     if (r == -1)
7534       return -1;
7535   }
7536   {
7537     char fstype[] = "ext2";
7538     char device[] = "/dev/sda1";
7539     int r;
7540     suppress_error = 0;
7541     r = guestfs_mkfs (g, fstype, device);
7542     if (r == -1)
7543       return -1;
7544   }
7545   {
7546     char device[] = "/dev/sda1";
7547     char mountpoint[] = "/";
7548     int r;
7549     suppress_error = 0;
7550     r = guestfs_mount (g, device, mountpoint);
7551     if (r == -1)
7552       return -1;
7553   }
7554   /* TestOutput for checksum (0) */
7555   char expected[] = "935282863";
7556   {
7557     char path[] = "/new";
7558     char content[] = "test\n";
7559     int r;
7560     suppress_error = 0;
7561     r = guestfs_write_file (g, path, content, 0);
7562     if (r == -1)
7563       return -1;
7564   }
7565   {
7566     char csumtype[] = "crc";
7567     char path[] = "/new";
7568     char *r;
7569     suppress_error = 0;
7570     r = guestfs_checksum (g, csumtype, path);
7571     if (r == NULL)
7572       return -1;
7573     if (strcmp (r, expected) != 0) {
7574       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7575       return -1;
7576     }
7577     free (r);
7578   }
7579   return 0;
7580 }
7581
7582 static int test_checksum_1_skip (void)
7583 {
7584   const char *str;
7585
7586   str = getenv ("TEST_ONLY");
7587   if (str)
7588     return strstr (str, "checksum") == NULL;
7589   str = getenv ("SKIP_TEST_CHECKSUM_1");
7590   if (str && strcmp (str, "1") == 0) return 1;
7591   str = getenv ("SKIP_TEST_CHECKSUM");
7592   if (str && strcmp (str, "1") == 0) return 1;
7593   return 0;
7594 }
7595
7596 static int test_checksum_1 (void)
7597 {
7598   if (test_checksum_1_skip ()) {
7599     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7600     return 0;
7601   }
7602
7603   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7604   {
7605     char device[] = "/dev/sda";
7606     int r;
7607     suppress_error = 0;
7608     r = guestfs_blockdev_setrw (g, device);
7609     if (r == -1)
7610       return -1;
7611   }
7612   {
7613     int r;
7614     suppress_error = 0;
7615     r = guestfs_umount_all (g);
7616     if (r == -1)
7617       return -1;
7618   }
7619   {
7620     int r;
7621     suppress_error = 0;
7622     r = guestfs_lvm_remove_all (g);
7623     if (r == -1)
7624       return -1;
7625   }
7626   {
7627     char device[] = "/dev/sda";
7628     char lines_0[] = ",";
7629     char *lines[] = {
7630       lines_0,
7631       NULL
7632     };
7633     int r;
7634     suppress_error = 0;
7635     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7636     if (r == -1)
7637       return -1;
7638   }
7639   {
7640     char fstype[] = "ext2";
7641     char device[] = "/dev/sda1";
7642     int r;
7643     suppress_error = 0;
7644     r = guestfs_mkfs (g, fstype, device);
7645     if (r == -1)
7646       return -1;
7647   }
7648   {
7649     char device[] = "/dev/sda1";
7650     char mountpoint[] = "/";
7651     int r;
7652     suppress_error = 0;
7653     r = guestfs_mount (g, device, mountpoint);
7654     if (r == -1)
7655       return -1;
7656   }
7657   /* TestLastFail for checksum (1) */
7658   {
7659     char csumtype[] = "crc";
7660     char path[] = "/new";
7661     char *r;
7662     suppress_error = 1;
7663     r = guestfs_checksum (g, csumtype, path);
7664     if (r != NULL)
7665       return -1;
7666     free (r);
7667   }
7668   return 0;
7669 }
7670
7671 static int test_checksum_2_skip (void)
7672 {
7673   const char *str;
7674
7675   str = getenv ("TEST_ONLY");
7676   if (str)
7677     return strstr (str, "checksum") == NULL;
7678   str = getenv ("SKIP_TEST_CHECKSUM_2");
7679   if (str && strcmp (str, "1") == 0) return 1;
7680   str = getenv ("SKIP_TEST_CHECKSUM");
7681   if (str && strcmp (str, "1") == 0) return 1;
7682   return 0;
7683 }
7684
7685 static int test_checksum_2 (void)
7686 {
7687   if (test_checksum_2_skip ()) {
7688     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
7689     return 0;
7690   }
7691
7692   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
7693   {
7694     char device[] = "/dev/sda";
7695     int r;
7696     suppress_error = 0;
7697     r = guestfs_blockdev_setrw (g, device);
7698     if (r == -1)
7699       return -1;
7700   }
7701   {
7702     int r;
7703     suppress_error = 0;
7704     r = guestfs_umount_all (g);
7705     if (r == -1)
7706       return -1;
7707   }
7708   {
7709     int r;
7710     suppress_error = 0;
7711     r = guestfs_lvm_remove_all (g);
7712     if (r == -1)
7713       return -1;
7714   }
7715   {
7716     char device[] = "/dev/sda";
7717     char lines_0[] = ",";
7718     char *lines[] = {
7719       lines_0,
7720       NULL
7721     };
7722     int r;
7723     suppress_error = 0;
7724     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7725     if (r == -1)
7726       return -1;
7727   }
7728   {
7729     char fstype[] = "ext2";
7730     char device[] = "/dev/sda1";
7731     int r;
7732     suppress_error = 0;
7733     r = guestfs_mkfs (g, fstype, device);
7734     if (r == -1)
7735       return -1;
7736   }
7737   {
7738     char device[] = "/dev/sda1";
7739     char mountpoint[] = "/";
7740     int r;
7741     suppress_error = 0;
7742     r = guestfs_mount (g, device, mountpoint);
7743     if (r == -1)
7744       return -1;
7745   }
7746   /* TestOutput for checksum (2) */
7747   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
7748   {
7749     char path[] = "/new";
7750     char content[] = "test\n";
7751     int r;
7752     suppress_error = 0;
7753     r = guestfs_write_file (g, path, content, 0);
7754     if (r == -1)
7755       return -1;
7756   }
7757   {
7758     char csumtype[] = "md5";
7759     char path[] = "/new";
7760     char *r;
7761     suppress_error = 0;
7762     r = guestfs_checksum (g, csumtype, path);
7763     if (r == NULL)
7764       return -1;
7765     if (strcmp (r, expected) != 0) {
7766       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
7767       return -1;
7768     }
7769     free (r);
7770   }
7771   return 0;
7772 }
7773
7774 static int test_checksum_3_skip (void)
7775 {
7776   const char *str;
7777
7778   str = getenv ("TEST_ONLY");
7779   if (str)
7780     return strstr (str, "checksum") == NULL;
7781   str = getenv ("SKIP_TEST_CHECKSUM_3");
7782   if (str && strcmp (str, "1") == 0) return 1;
7783   str = getenv ("SKIP_TEST_CHECKSUM");
7784   if (str && strcmp (str, "1") == 0) return 1;
7785   return 0;
7786 }
7787
7788 static int test_checksum_3 (void)
7789 {
7790   if (test_checksum_3_skip ()) {
7791     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
7792     return 0;
7793   }
7794
7795   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
7796   {
7797     char device[] = "/dev/sda";
7798     int r;
7799     suppress_error = 0;
7800     r = guestfs_blockdev_setrw (g, device);
7801     if (r == -1)
7802       return -1;
7803   }
7804   {
7805     int r;
7806     suppress_error = 0;
7807     r = guestfs_umount_all (g);
7808     if (r == -1)
7809       return -1;
7810   }
7811   {
7812     int r;
7813     suppress_error = 0;
7814     r = guestfs_lvm_remove_all (g);
7815     if (r == -1)
7816       return -1;
7817   }
7818   {
7819     char device[] = "/dev/sda";
7820     char lines_0[] = ",";
7821     char *lines[] = {
7822       lines_0,
7823       NULL
7824     };
7825     int r;
7826     suppress_error = 0;
7827     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7828     if (r == -1)
7829       return -1;
7830   }
7831   {
7832     char fstype[] = "ext2";
7833     char device[] = "/dev/sda1";
7834     int r;
7835     suppress_error = 0;
7836     r = guestfs_mkfs (g, fstype, device);
7837     if (r == -1)
7838       return -1;
7839   }
7840   {
7841     char device[] = "/dev/sda1";
7842     char mountpoint[] = "/";
7843     int r;
7844     suppress_error = 0;
7845     r = guestfs_mount (g, device, mountpoint);
7846     if (r == -1)
7847       return -1;
7848   }
7849   /* TestOutput for checksum (3) */
7850   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
7851   {
7852     char path[] = "/new";
7853     char content[] = "test\n";
7854     int r;
7855     suppress_error = 0;
7856     r = guestfs_write_file (g, path, content, 0);
7857     if (r == -1)
7858       return -1;
7859   }
7860   {
7861     char csumtype[] = "sha1";
7862     char path[] = "/new";
7863     char *r;
7864     suppress_error = 0;
7865     r = guestfs_checksum (g, csumtype, path);
7866     if (r == NULL)
7867       return -1;
7868     if (strcmp (r, expected) != 0) {
7869       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
7870       return -1;
7871     }
7872     free (r);
7873   }
7874   return 0;
7875 }
7876
7877 static int test_checksum_4_skip (void)
7878 {
7879   const char *str;
7880
7881   str = getenv ("TEST_ONLY");
7882   if (str)
7883     return strstr (str, "checksum") == NULL;
7884   str = getenv ("SKIP_TEST_CHECKSUM_4");
7885   if (str && strcmp (str, "1") == 0) return 1;
7886   str = getenv ("SKIP_TEST_CHECKSUM");
7887   if (str && strcmp (str, "1") == 0) return 1;
7888   return 0;
7889 }
7890
7891 static int test_checksum_4 (void)
7892 {
7893   if (test_checksum_4_skip ()) {
7894     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
7895     return 0;
7896   }
7897
7898   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
7899   {
7900     char device[] = "/dev/sda";
7901     int r;
7902     suppress_error = 0;
7903     r = guestfs_blockdev_setrw (g, device);
7904     if (r == -1)
7905       return -1;
7906   }
7907   {
7908     int r;
7909     suppress_error = 0;
7910     r = guestfs_umount_all (g);
7911     if (r == -1)
7912       return -1;
7913   }
7914   {
7915     int r;
7916     suppress_error = 0;
7917     r = guestfs_lvm_remove_all (g);
7918     if (r == -1)
7919       return -1;
7920   }
7921   {
7922     char device[] = "/dev/sda";
7923     char lines_0[] = ",";
7924     char *lines[] = {
7925       lines_0,
7926       NULL
7927     };
7928     int r;
7929     suppress_error = 0;
7930     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7931     if (r == -1)
7932       return -1;
7933   }
7934   {
7935     char fstype[] = "ext2";
7936     char device[] = "/dev/sda1";
7937     int r;
7938     suppress_error = 0;
7939     r = guestfs_mkfs (g, fstype, device);
7940     if (r == -1)
7941       return -1;
7942   }
7943   {
7944     char device[] = "/dev/sda1";
7945     char mountpoint[] = "/";
7946     int r;
7947     suppress_error = 0;
7948     r = guestfs_mount (g, device, mountpoint);
7949     if (r == -1)
7950       return -1;
7951   }
7952   /* TestOutput for checksum (4) */
7953   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
7954   {
7955     char path[] = "/new";
7956     char content[] = "test\n";
7957     int r;
7958     suppress_error = 0;
7959     r = guestfs_write_file (g, path, content, 0);
7960     if (r == -1)
7961       return -1;
7962   }
7963   {
7964     char csumtype[] = "sha224";
7965     char path[] = "/new";
7966     char *r;
7967     suppress_error = 0;
7968     r = guestfs_checksum (g, csumtype, path);
7969     if (r == NULL)
7970       return -1;
7971     if (strcmp (r, expected) != 0) {
7972       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
7973       return -1;
7974     }
7975     free (r);
7976   }
7977   return 0;
7978 }
7979
7980 static int test_checksum_5_skip (void)
7981 {
7982   const char *str;
7983
7984   str = getenv ("TEST_ONLY");
7985   if (str)
7986     return strstr (str, "checksum") == NULL;
7987   str = getenv ("SKIP_TEST_CHECKSUM_5");
7988   if (str && strcmp (str, "1") == 0) return 1;
7989   str = getenv ("SKIP_TEST_CHECKSUM");
7990   if (str && strcmp (str, "1") == 0) return 1;
7991   return 0;
7992 }
7993
7994 static int test_checksum_5 (void)
7995 {
7996   if (test_checksum_5_skip ()) {
7997     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
7998     return 0;
7999   }
8000
8001   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8002   {
8003     char device[] = "/dev/sda";
8004     int r;
8005     suppress_error = 0;
8006     r = guestfs_blockdev_setrw (g, device);
8007     if (r == -1)
8008       return -1;
8009   }
8010   {
8011     int r;
8012     suppress_error = 0;
8013     r = guestfs_umount_all (g);
8014     if (r == -1)
8015       return -1;
8016   }
8017   {
8018     int r;
8019     suppress_error = 0;
8020     r = guestfs_lvm_remove_all (g);
8021     if (r == -1)
8022       return -1;
8023   }
8024   {
8025     char device[] = "/dev/sda";
8026     char lines_0[] = ",";
8027     char *lines[] = {
8028       lines_0,
8029       NULL
8030     };
8031     int r;
8032     suppress_error = 0;
8033     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8034     if (r == -1)
8035       return -1;
8036   }
8037   {
8038     char fstype[] = "ext2";
8039     char device[] = "/dev/sda1";
8040     int r;
8041     suppress_error = 0;
8042     r = guestfs_mkfs (g, fstype, device);
8043     if (r == -1)
8044       return -1;
8045   }
8046   {
8047     char device[] = "/dev/sda1";
8048     char mountpoint[] = "/";
8049     int r;
8050     suppress_error = 0;
8051     r = guestfs_mount (g, device, mountpoint);
8052     if (r == -1)
8053       return -1;
8054   }
8055   /* TestOutput for checksum (5) */
8056   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8057   {
8058     char path[] = "/new";
8059     char content[] = "test\n";
8060     int r;
8061     suppress_error = 0;
8062     r = guestfs_write_file (g, path, content, 0);
8063     if (r == -1)
8064       return -1;
8065   }
8066   {
8067     char csumtype[] = "sha256";
8068     char path[] = "/new";
8069     char *r;
8070     suppress_error = 0;
8071     r = guestfs_checksum (g, csumtype, path);
8072     if (r == NULL)
8073       return -1;
8074     if (strcmp (r, expected) != 0) {
8075       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8076       return -1;
8077     }
8078     free (r);
8079   }
8080   return 0;
8081 }
8082
8083 static int test_checksum_6_skip (void)
8084 {
8085   const char *str;
8086
8087   str = getenv ("TEST_ONLY");
8088   if (str)
8089     return strstr (str, "checksum") == NULL;
8090   str = getenv ("SKIP_TEST_CHECKSUM_6");
8091   if (str && strcmp (str, "1") == 0) return 1;
8092   str = getenv ("SKIP_TEST_CHECKSUM");
8093   if (str && strcmp (str, "1") == 0) return 1;
8094   return 0;
8095 }
8096
8097 static int test_checksum_6 (void)
8098 {
8099   if (test_checksum_6_skip ()) {
8100     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8101     return 0;
8102   }
8103
8104   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8105   {
8106     char device[] = "/dev/sda";
8107     int r;
8108     suppress_error = 0;
8109     r = guestfs_blockdev_setrw (g, device);
8110     if (r == -1)
8111       return -1;
8112   }
8113   {
8114     int r;
8115     suppress_error = 0;
8116     r = guestfs_umount_all (g);
8117     if (r == -1)
8118       return -1;
8119   }
8120   {
8121     int r;
8122     suppress_error = 0;
8123     r = guestfs_lvm_remove_all (g);
8124     if (r == -1)
8125       return -1;
8126   }
8127   {
8128     char device[] = "/dev/sda";
8129     char lines_0[] = ",";
8130     char *lines[] = {
8131       lines_0,
8132       NULL
8133     };
8134     int r;
8135     suppress_error = 0;
8136     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8137     if (r == -1)
8138       return -1;
8139   }
8140   {
8141     char fstype[] = "ext2";
8142     char device[] = "/dev/sda1";
8143     int r;
8144     suppress_error = 0;
8145     r = guestfs_mkfs (g, fstype, device);
8146     if (r == -1)
8147       return -1;
8148   }
8149   {
8150     char device[] = "/dev/sda1";
8151     char mountpoint[] = "/";
8152     int r;
8153     suppress_error = 0;
8154     r = guestfs_mount (g, device, mountpoint);
8155     if (r == -1)
8156       return -1;
8157   }
8158   /* TestOutput for checksum (6) */
8159   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8160   {
8161     char path[] = "/new";
8162     char content[] = "test\n";
8163     int r;
8164     suppress_error = 0;
8165     r = guestfs_write_file (g, path, content, 0);
8166     if (r == -1)
8167       return -1;
8168   }
8169   {
8170     char csumtype[] = "sha384";
8171     char path[] = "/new";
8172     char *r;
8173     suppress_error = 0;
8174     r = guestfs_checksum (g, csumtype, path);
8175     if (r == NULL)
8176       return -1;
8177     if (strcmp (r, expected) != 0) {
8178       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8179       return -1;
8180     }
8181     free (r);
8182   }
8183   return 0;
8184 }
8185
8186 static int test_checksum_7_skip (void)
8187 {
8188   const char *str;
8189
8190   str = getenv ("TEST_ONLY");
8191   if (str)
8192     return strstr (str, "checksum") == NULL;
8193   str = getenv ("SKIP_TEST_CHECKSUM_7");
8194   if (str && strcmp (str, "1") == 0) return 1;
8195   str = getenv ("SKIP_TEST_CHECKSUM");
8196   if (str && strcmp (str, "1") == 0) return 1;
8197   return 0;
8198 }
8199
8200 static int test_checksum_7 (void)
8201 {
8202   if (test_checksum_7_skip ()) {
8203     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8204     return 0;
8205   }
8206
8207   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8208   {
8209     char device[] = "/dev/sda";
8210     int r;
8211     suppress_error = 0;
8212     r = guestfs_blockdev_setrw (g, device);
8213     if (r == -1)
8214       return -1;
8215   }
8216   {
8217     int r;
8218     suppress_error = 0;
8219     r = guestfs_umount_all (g);
8220     if (r == -1)
8221       return -1;
8222   }
8223   {
8224     int r;
8225     suppress_error = 0;
8226     r = guestfs_lvm_remove_all (g);
8227     if (r == -1)
8228       return -1;
8229   }
8230   {
8231     char device[] = "/dev/sda";
8232     char lines_0[] = ",";
8233     char *lines[] = {
8234       lines_0,
8235       NULL
8236     };
8237     int r;
8238     suppress_error = 0;
8239     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8240     if (r == -1)
8241       return -1;
8242   }
8243   {
8244     char fstype[] = "ext2";
8245     char device[] = "/dev/sda1";
8246     int r;
8247     suppress_error = 0;
8248     r = guestfs_mkfs (g, fstype, device);
8249     if (r == -1)
8250       return -1;
8251   }
8252   {
8253     char device[] = "/dev/sda1";
8254     char mountpoint[] = "/";
8255     int r;
8256     suppress_error = 0;
8257     r = guestfs_mount (g, device, mountpoint);
8258     if (r == -1)
8259       return -1;
8260   }
8261   /* TestOutput for checksum (7) */
8262   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8263   {
8264     char path[] = "/new";
8265     char content[] = "test\n";
8266     int r;
8267     suppress_error = 0;
8268     r = guestfs_write_file (g, path, content, 0);
8269     if (r == -1)
8270       return -1;
8271   }
8272   {
8273     char csumtype[] = "sha512";
8274     char path[] = "/new";
8275     char *r;
8276     suppress_error = 0;
8277     r = guestfs_checksum (g, csumtype, path);
8278     if (r == NULL)
8279       return -1;
8280     if (strcmp (r, expected) != 0) {
8281       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8282       return -1;
8283     }
8284     free (r);
8285   }
8286   return 0;
8287 }
8288
8289 static int test_checksum_8_skip (void)
8290 {
8291   const char *str;
8292
8293   str = getenv ("TEST_ONLY");
8294   if (str)
8295     return strstr (str, "checksum") == NULL;
8296   str = getenv ("SKIP_TEST_CHECKSUM_8");
8297   if (str && strcmp (str, "1") == 0) return 1;
8298   str = getenv ("SKIP_TEST_CHECKSUM");
8299   if (str && strcmp (str, "1") == 0) return 1;
8300   return 0;
8301 }
8302
8303 static int test_checksum_8 (void)
8304 {
8305   if (test_checksum_8_skip ()) {
8306     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8307     return 0;
8308   }
8309
8310   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8311   {
8312     char device[] = "/dev/sda";
8313     int r;
8314     suppress_error = 0;
8315     r = guestfs_blockdev_setrw (g, device);
8316     if (r == -1)
8317       return -1;
8318   }
8319   {
8320     int r;
8321     suppress_error = 0;
8322     r = guestfs_umount_all (g);
8323     if (r == -1)
8324       return -1;
8325   }
8326   {
8327     int r;
8328     suppress_error = 0;
8329     r = guestfs_lvm_remove_all (g);
8330     if (r == -1)
8331       return -1;
8332   }
8333   {
8334     char device[] = "/dev/sda";
8335     char lines_0[] = ",";
8336     char *lines[] = {
8337       lines_0,
8338       NULL
8339     };
8340     int r;
8341     suppress_error = 0;
8342     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8343     if (r == -1)
8344       return -1;
8345   }
8346   {
8347     char fstype[] = "ext2";
8348     char device[] = "/dev/sda1";
8349     int r;
8350     suppress_error = 0;
8351     r = guestfs_mkfs (g, fstype, device);
8352     if (r == -1)
8353       return -1;
8354   }
8355   {
8356     char device[] = "/dev/sda1";
8357     char mountpoint[] = "/";
8358     int r;
8359     suppress_error = 0;
8360     r = guestfs_mount (g, device, mountpoint);
8361     if (r == -1)
8362       return -1;
8363   }
8364   /* TestOutput for checksum (8) */
8365   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8366   {
8367     char options[] = "ro";
8368     char vfstype[] = "squashfs";
8369     char device[] = "/dev/sdd";
8370     char mountpoint[] = "/";
8371     int r;
8372     suppress_error = 0;
8373     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8374     if (r == -1)
8375       return -1;
8376   }
8377   {
8378     char csumtype[] = "md5";
8379     char path[] = "/known-3";
8380     char *r;
8381     suppress_error = 0;
8382     r = guestfs_checksum (g, csumtype, path);
8383     if (r == NULL)
8384       return -1;
8385     if (strcmp (r, expected) != 0) {
8386       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8387       return -1;
8388     }
8389     free (r);
8390   }
8391   return 0;
8392 }
8393
8394 static int test_download_0_skip (void)
8395 {
8396   const char *str;
8397
8398   str = getenv ("TEST_ONLY");
8399   if (str)
8400     return strstr (str, "download") == NULL;
8401   str = getenv ("SKIP_TEST_DOWNLOAD_0");
8402   if (str && strcmp (str, "1") == 0) return 1;
8403   str = getenv ("SKIP_TEST_DOWNLOAD");
8404   if (str && strcmp (str, "1") == 0) return 1;
8405   return 0;
8406 }
8407
8408 static int test_download_0 (void)
8409 {
8410   if (test_download_0_skip ()) {
8411     printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8412     return 0;
8413   }
8414
8415   /* InitBasicFS for test_download_0: 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   /* TestOutput for download (0) */
8470   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8471   {
8472     char remotefilename[] = "/COPYING.LIB";
8473     int r;
8474     suppress_error = 0;
8475     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8476     if (r == -1)
8477       return -1;
8478   }
8479   {
8480     char remotefilename[] = "/COPYING.LIB";
8481     int r;
8482     suppress_error = 0;
8483     r = guestfs_download (g, remotefilename, "testdownload.tmp");
8484     if (r == -1)
8485       return -1;
8486   }
8487   {
8488     char remotefilename[] = "/upload";
8489     int r;
8490     suppress_error = 0;
8491     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8492     if (r == -1)
8493       return -1;
8494   }
8495   {
8496     char csumtype[] = "md5";
8497     char path[] = "/upload";
8498     char *r;
8499     suppress_error = 0;
8500     r = guestfs_checksum (g, csumtype, path);
8501     if (r == NULL)
8502       return -1;
8503     if (strcmp (r, expected) != 0) {
8504       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8505       return -1;
8506     }
8507     free (r);
8508   }
8509   return 0;
8510 }
8511
8512 static int test_upload_0_skip (void)
8513 {
8514   const char *str;
8515
8516   str = getenv ("TEST_ONLY");
8517   if (str)
8518     return strstr (str, "upload") == NULL;
8519   str = getenv ("SKIP_TEST_UPLOAD_0");
8520   if (str && strcmp (str, "1") == 0) return 1;
8521   str = getenv ("SKIP_TEST_UPLOAD");
8522   if (str && strcmp (str, "1") == 0) return 1;
8523   return 0;
8524 }
8525
8526 static int test_upload_0 (void)
8527 {
8528   if (test_upload_0_skip ()) {
8529     printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8530     return 0;
8531   }
8532
8533   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8534   {
8535     char device[] = "/dev/sda";
8536     int r;
8537     suppress_error = 0;
8538     r = guestfs_blockdev_setrw (g, device);
8539     if (r == -1)
8540       return -1;
8541   }
8542   {
8543     int r;
8544     suppress_error = 0;
8545     r = guestfs_umount_all (g);
8546     if (r == -1)
8547       return -1;
8548   }
8549   {
8550     int r;
8551     suppress_error = 0;
8552     r = guestfs_lvm_remove_all (g);
8553     if (r == -1)
8554       return -1;
8555   }
8556   {
8557     char device[] = "/dev/sda";
8558     char lines_0[] = ",";
8559     char *lines[] = {
8560       lines_0,
8561       NULL
8562     };
8563     int r;
8564     suppress_error = 0;
8565     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8566     if (r == -1)
8567       return -1;
8568   }
8569   {
8570     char fstype[] = "ext2";
8571     char device[] = "/dev/sda1";
8572     int r;
8573     suppress_error = 0;
8574     r = guestfs_mkfs (g, fstype, device);
8575     if (r == -1)
8576       return -1;
8577   }
8578   {
8579     char device[] = "/dev/sda1";
8580     char mountpoint[] = "/";
8581     int r;
8582     suppress_error = 0;
8583     r = guestfs_mount (g, device, mountpoint);
8584     if (r == -1)
8585       return -1;
8586   }
8587   /* TestOutput for upload (0) */
8588   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8589   {
8590     char remotefilename[] = "/COPYING.LIB";
8591     int r;
8592     suppress_error = 0;
8593     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8594     if (r == -1)
8595       return -1;
8596   }
8597   {
8598     char csumtype[] = "md5";
8599     char path[] = "/COPYING.LIB";
8600     char *r;
8601     suppress_error = 0;
8602     r = guestfs_checksum (g, csumtype, path);
8603     if (r == NULL)
8604       return -1;
8605     if (strcmp (r, expected) != 0) {
8606       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8607       return -1;
8608     }
8609     free (r);
8610   }
8611   return 0;
8612 }
8613
8614 static int test_blockdev_rereadpt_0_skip (void)
8615 {
8616   const char *str;
8617
8618   str = getenv ("TEST_ONLY");
8619   if (str)
8620     return strstr (str, "blockdev_rereadpt") == NULL;
8621   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8622   if (str && strcmp (str, "1") == 0) return 1;
8623   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8624   if (str && strcmp (str, "1") == 0) return 1;
8625   return 0;
8626 }
8627
8628 static int test_blockdev_rereadpt_0 (void)
8629 {
8630   if (test_blockdev_rereadpt_0_skip ()) {
8631     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8632     return 0;
8633   }
8634
8635   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
8636   {
8637     char device[] = "/dev/sda";
8638     int r;
8639     suppress_error = 0;
8640     r = guestfs_blockdev_setrw (g, device);
8641     if (r == -1)
8642       return -1;
8643   }
8644   {
8645     int r;
8646     suppress_error = 0;
8647     r = guestfs_umount_all (g);
8648     if (r == -1)
8649       return -1;
8650   }
8651   {
8652     int r;
8653     suppress_error = 0;
8654     r = guestfs_lvm_remove_all (g);
8655     if (r == -1)
8656       return -1;
8657   }
8658   /* TestRun for blockdev_rereadpt (0) */
8659   {
8660     char device[] = "/dev/sda";
8661     int r;
8662     suppress_error = 0;
8663     r = guestfs_blockdev_rereadpt (g, device);
8664     if (r == -1)
8665       return -1;
8666   }
8667   return 0;
8668 }
8669
8670 static int test_blockdev_flushbufs_0_skip (void)
8671 {
8672   const char *str;
8673
8674   str = getenv ("TEST_ONLY");
8675   if (str)
8676     return strstr (str, "blockdev_flushbufs") == NULL;
8677   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
8678   if (str && strcmp (str, "1") == 0) return 1;
8679   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
8680   if (str && strcmp (str, "1") == 0) return 1;
8681   return 0;
8682 }
8683
8684 static int test_blockdev_flushbufs_0 (void)
8685 {
8686   if (test_blockdev_flushbufs_0_skip ()) {
8687     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
8688     return 0;
8689   }
8690
8691   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
8692   {
8693     char device[] = "/dev/sda";
8694     int r;
8695     suppress_error = 0;
8696     r = guestfs_blockdev_setrw (g, device);
8697     if (r == -1)
8698       return -1;
8699   }
8700   {
8701     int r;
8702     suppress_error = 0;
8703     r = guestfs_umount_all (g);
8704     if (r == -1)
8705       return -1;
8706   }
8707   {
8708     int r;
8709     suppress_error = 0;
8710     r = guestfs_lvm_remove_all (g);
8711     if (r == -1)
8712       return -1;
8713   }
8714   /* TestRun for blockdev_flushbufs (0) */
8715   {
8716     char device[] = "/dev/sda";
8717     int r;
8718     suppress_error = 0;
8719     r = guestfs_blockdev_flushbufs (g, device);
8720     if (r == -1)
8721       return -1;
8722   }
8723   return 0;
8724 }
8725
8726 static int test_blockdev_getsize64_0_skip (void)
8727 {
8728   const char *str;
8729
8730   str = getenv ("TEST_ONLY");
8731   if (str)
8732     return strstr (str, "blockdev_getsize64") == NULL;
8733   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
8734   if (str && strcmp (str, "1") == 0) return 1;
8735   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
8736   if (str && strcmp (str, "1") == 0) return 1;
8737   return 0;
8738 }
8739
8740 static int test_blockdev_getsize64_0 (void)
8741 {
8742   if (test_blockdev_getsize64_0_skip ()) {
8743     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
8744     return 0;
8745   }
8746
8747   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
8748   {
8749     char device[] = "/dev/sda";
8750     int r;
8751     suppress_error = 0;
8752     r = guestfs_blockdev_setrw (g, device);
8753     if (r == -1)
8754       return -1;
8755   }
8756   {
8757     int r;
8758     suppress_error = 0;
8759     r = guestfs_umount_all (g);
8760     if (r == -1)
8761       return -1;
8762   }
8763   {
8764     int r;
8765     suppress_error = 0;
8766     r = guestfs_lvm_remove_all (g);
8767     if (r == -1)
8768       return -1;
8769   }
8770   /* TestOutputInt for blockdev_getsize64 (0) */
8771   {
8772     char device[] = "/dev/sda";
8773     int64_t r;
8774     suppress_error = 0;
8775     r = guestfs_blockdev_getsize64 (g, device);
8776     if (r == -1)
8777       return -1;
8778     if (r != 524288000) {
8779       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
8780       return -1;
8781     }
8782   }
8783   return 0;
8784 }
8785
8786 static int test_blockdev_getsz_0_skip (void)
8787 {
8788   const char *str;
8789
8790   str = getenv ("TEST_ONLY");
8791   if (str)
8792     return strstr (str, "blockdev_getsz") == NULL;
8793   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
8794   if (str && strcmp (str, "1") == 0) return 1;
8795   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
8796   if (str && strcmp (str, "1") == 0) return 1;
8797   return 0;
8798 }
8799
8800 static int test_blockdev_getsz_0 (void)
8801 {
8802   if (test_blockdev_getsz_0_skip ()) {
8803     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
8804     return 0;
8805   }
8806
8807   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
8808   {
8809     char device[] = "/dev/sda";
8810     int r;
8811     suppress_error = 0;
8812     r = guestfs_blockdev_setrw (g, device);
8813     if (r == -1)
8814       return -1;
8815   }
8816   {
8817     int r;
8818     suppress_error = 0;
8819     r = guestfs_umount_all (g);
8820     if (r == -1)
8821       return -1;
8822   }
8823   {
8824     int r;
8825     suppress_error = 0;
8826     r = guestfs_lvm_remove_all (g);
8827     if (r == -1)
8828       return -1;
8829   }
8830   /* TestOutputInt for blockdev_getsz (0) */
8831   {
8832     char device[] = "/dev/sda";
8833     int64_t r;
8834     suppress_error = 0;
8835     r = guestfs_blockdev_getsz (g, device);
8836     if (r == -1)
8837       return -1;
8838     if (r != 1024000) {
8839       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
8840       return -1;
8841     }
8842   }
8843   return 0;
8844 }
8845
8846 static int test_blockdev_getbsz_0_skip (void)
8847 {
8848   const char *str;
8849
8850   str = getenv ("TEST_ONLY");
8851   if (str)
8852     return strstr (str, "blockdev_getbsz") == NULL;
8853   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
8854   if (str && strcmp (str, "1") == 0) return 1;
8855   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
8856   if (str && strcmp (str, "1") == 0) return 1;
8857   return 0;
8858 }
8859
8860 static int test_blockdev_getbsz_0 (void)
8861 {
8862   if (test_blockdev_getbsz_0_skip ()) {
8863     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
8864     return 0;
8865   }
8866
8867   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
8868   {
8869     char device[] = "/dev/sda";
8870     int r;
8871     suppress_error = 0;
8872     r = guestfs_blockdev_setrw (g, device);
8873     if (r == -1)
8874       return -1;
8875   }
8876   {
8877     int r;
8878     suppress_error = 0;
8879     r = guestfs_umount_all (g);
8880     if (r == -1)
8881       return -1;
8882   }
8883   {
8884     int r;
8885     suppress_error = 0;
8886     r = guestfs_lvm_remove_all (g);
8887     if (r == -1)
8888       return -1;
8889   }
8890   /* TestOutputInt for blockdev_getbsz (0) */
8891   {
8892     char device[] = "/dev/sda";
8893     int r;
8894     suppress_error = 0;
8895     r = guestfs_blockdev_getbsz (g, device);
8896     if (r == -1)
8897       return -1;
8898     if (r != 4096) {
8899       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
8900       return -1;
8901     }
8902   }
8903   return 0;
8904 }
8905
8906 static int test_blockdev_getss_0_skip (void)
8907 {
8908   const char *str;
8909
8910   str = getenv ("TEST_ONLY");
8911   if (str)
8912     return strstr (str, "blockdev_getss") == NULL;
8913   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
8914   if (str && strcmp (str, "1") == 0) return 1;
8915   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
8916   if (str && strcmp (str, "1") == 0) return 1;
8917   return 0;
8918 }
8919
8920 static int test_blockdev_getss_0 (void)
8921 {
8922   if (test_blockdev_getss_0_skip ()) {
8923     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
8924     return 0;
8925   }
8926
8927   /* InitNone|InitEmpty for test_blockdev_getss_0 */
8928   {
8929     char device[] = "/dev/sda";
8930     int r;
8931     suppress_error = 0;
8932     r = guestfs_blockdev_setrw (g, device);
8933     if (r == -1)
8934       return -1;
8935   }
8936   {
8937     int r;
8938     suppress_error = 0;
8939     r = guestfs_umount_all (g);
8940     if (r == -1)
8941       return -1;
8942   }
8943   {
8944     int r;
8945     suppress_error = 0;
8946     r = guestfs_lvm_remove_all (g);
8947     if (r == -1)
8948       return -1;
8949   }
8950   /* TestOutputInt for blockdev_getss (0) */
8951   {
8952     char device[] = "/dev/sda";
8953     int r;
8954     suppress_error = 0;
8955     r = guestfs_blockdev_getss (g, device);
8956     if (r == -1)
8957       return -1;
8958     if (r != 512) {
8959       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
8960       return -1;
8961     }
8962   }
8963   return 0;
8964 }
8965
8966 static int test_blockdev_getro_0_skip (void)
8967 {
8968   const char *str;
8969
8970   str = getenv ("TEST_ONLY");
8971   if (str)
8972     return strstr (str, "blockdev_getro") == NULL;
8973   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
8974   if (str && strcmp (str, "1") == 0) return 1;
8975   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
8976   if (str && strcmp (str, "1") == 0) return 1;
8977   return 0;
8978 }
8979
8980 static int test_blockdev_getro_0 (void)
8981 {
8982   if (test_blockdev_getro_0_skip ()) {
8983     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
8984     return 0;
8985   }
8986
8987   /* InitNone|InitEmpty for test_blockdev_getro_0 */
8988   {
8989     char device[] = "/dev/sda";
8990     int r;
8991     suppress_error = 0;
8992     r = guestfs_blockdev_setrw (g, device);
8993     if (r == -1)
8994       return -1;
8995   }
8996   {
8997     int r;
8998     suppress_error = 0;
8999     r = guestfs_umount_all (g);
9000     if (r == -1)
9001       return -1;
9002   }
9003   {
9004     int r;
9005     suppress_error = 0;
9006     r = guestfs_lvm_remove_all (g);
9007     if (r == -1)
9008       return -1;
9009   }
9010   /* TestOutputTrue for blockdev_getro (0) */
9011   {
9012     char device[] = "/dev/sda";
9013     int r;
9014     suppress_error = 0;
9015     r = guestfs_blockdev_setro (g, device);
9016     if (r == -1)
9017       return -1;
9018   }
9019   {
9020     char device[] = "/dev/sda";
9021     int r;
9022     suppress_error = 0;
9023     r = guestfs_blockdev_getro (g, device);
9024     if (r == -1)
9025       return -1;
9026     if (!r) {
9027       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9028       return -1;
9029     }
9030   }
9031   return 0;
9032 }
9033
9034 static int test_blockdev_setrw_0_skip (void)
9035 {
9036   const char *str;
9037
9038   str = getenv ("TEST_ONLY");
9039   if (str)
9040     return strstr (str, "blockdev_setrw") == NULL;
9041   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9042   if (str && strcmp (str, "1") == 0) return 1;
9043   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9044   if (str && strcmp (str, "1") == 0) return 1;
9045   return 0;
9046 }
9047
9048 static int test_blockdev_setrw_0 (void)
9049 {
9050   if (test_blockdev_setrw_0_skip ()) {
9051     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9052     return 0;
9053   }
9054
9055   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9056   {
9057     char device[] = "/dev/sda";
9058     int r;
9059     suppress_error = 0;
9060     r = guestfs_blockdev_setrw (g, device);
9061     if (r == -1)
9062       return -1;
9063   }
9064   {
9065     int r;
9066     suppress_error = 0;
9067     r = guestfs_umount_all (g);
9068     if (r == -1)
9069       return -1;
9070   }
9071   {
9072     int r;
9073     suppress_error = 0;
9074     r = guestfs_lvm_remove_all (g);
9075     if (r == -1)
9076       return -1;
9077   }
9078   /* TestOutputFalse for blockdev_setrw (0) */
9079   {
9080     char device[] = "/dev/sda";
9081     int r;
9082     suppress_error = 0;
9083     r = guestfs_blockdev_setrw (g, device);
9084     if (r == -1)
9085       return -1;
9086   }
9087   {
9088     char device[] = "/dev/sda";
9089     int r;
9090     suppress_error = 0;
9091     r = guestfs_blockdev_getro (g, device);
9092     if (r == -1)
9093       return -1;
9094     if (r) {
9095       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9096       return -1;
9097     }
9098   }
9099   return 0;
9100 }
9101
9102 static int test_blockdev_setro_0_skip (void)
9103 {
9104   const char *str;
9105
9106   str = getenv ("TEST_ONLY");
9107   if (str)
9108     return strstr (str, "blockdev_setro") == NULL;
9109   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9110   if (str && strcmp (str, "1") == 0) return 1;
9111   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9112   if (str && strcmp (str, "1") == 0) return 1;
9113   return 0;
9114 }
9115
9116 static int test_blockdev_setro_0 (void)
9117 {
9118   if (test_blockdev_setro_0_skip ()) {
9119     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9120     return 0;
9121   }
9122
9123   /* InitNone|InitEmpty for test_blockdev_setro_0 */
9124   {
9125     char device[] = "/dev/sda";
9126     int r;
9127     suppress_error = 0;
9128     r = guestfs_blockdev_setrw (g, device);
9129     if (r == -1)
9130       return -1;
9131   }
9132   {
9133     int r;
9134     suppress_error = 0;
9135     r = guestfs_umount_all (g);
9136     if (r == -1)
9137       return -1;
9138   }
9139   {
9140     int r;
9141     suppress_error = 0;
9142     r = guestfs_lvm_remove_all (g);
9143     if (r == -1)
9144       return -1;
9145   }
9146   /* TestOutputTrue for blockdev_setro (0) */
9147   {
9148     char device[] = "/dev/sda";
9149     int r;
9150     suppress_error = 0;
9151     r = guestfs_blockdev_setro (g, device);
9152     if (r == -1)
9153       return -1;
9154   }
9155   {
9156     char device[] = "/dev/sda";
9157     int r;
9158     suppress_error = 0;
9159     r = guestfs_blockdev_getro (g, device);
9160     if (r == -1)
9161       return -1;
9162     if (!r) {
9163       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9164       return -1;
9165     }
9166   }
9167   return 0;
9168 }
9169
9170 static int test_statvfs_0_skip (void)
9171 {
9172   const char *str;
9173
9174   str = getenv ("TEST_ONLY");
9175   if (str)
9176     return strstr (str, "statvfs") == NULL;
9177   str = getenv ("SKIP_TEST_STATVFS_0");
9178   if (str && strcmp (str, "1") == 0) return 1;
9179   str = getenv ("SKIP_TEST_STATVFS");
9180   if (str && strcmp (str, "1") == 0) return 1;
9181   return 0;
9182 }
9183
9184 static int test_statvfs_0 (void)
9185 {
9186   if (test_statvfs_0_skip ()) {
9187     printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9188     return 0;
9189   }
9190
9191   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9192   {
9193     char device[] = "/dev/sda";
9194     int r;
9195     suppress_error = 0;
9196     r = guestfs_blockdev_setrw (g, device);
9197     if (r == -1)
9198       return -1;
9199   }
9200   {
9201     int r;
9202     suppress_error = 0;
9203     r = guestfs_umount_all (g);
9204     if (r == -1)
9205       return -1;
9206   }
9207   {
9208     int r;
9209     suppress_error = 0;
9210     r = guestfs_lvm_remove_all (g);
9211     if (r == -1)
9212       return -1;
9213   }
9214   {
9215     char device[] = "/dev/sda";
9216     char lines_0[] = ",";
9217     char *lines[] = {
9218       lines_0,
9219       NULL
9220     };
9221     int r;
9222     suppress_error = 0;
9223     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9224     if (r == -1)
9225       return -1;
9226   }
9227   {
9228     char fstype[] = "ext2";
9229     char device[] = "/dev/sda1";
9230     int r;
9231     suppress_error = 0;
9232     r = guestfs_mkfs (g, fstype, device);
9233     if (r == -1)
9234       return -1;
9235   }
9236   {
9237     char device[] = "/dev/sda1";
9238     char mountpoint[] = "/";
9239     int r;
9240     suppress_error = 0;
9241     r = guestfs_mount (g, device, mountpoint);
9242     if (r == -1)
9243       return -1;
9244   }
9245   /* TestOutputStruct for statvfs (0) */
9246   {
9247     char path[] = "/";
9248     struct guestfs_statvfs *r;
9249     suppress_error = 0;
9250     r = guestfs_statvfs (g, path);
9251     if (r == NULL)
9252       return -1;
9253     if (r->bfree != 487702) {
9254       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9255                (int) r->bfree);
9256       return -1;
9257     }
9258     if (r->blocks != 490020) {
9259       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9260                (int) r->blocks);
9261       return -1;
9262     }
9263     if (r->bsize != 1024) {
9264       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9265                (int) r->bsize);
9266       return -1;
9267     }
9268     free (r);
9269   }
9270   return 0;
9271 }
9272
9273 static int test_lstat_0_skip (void)
9274 {
9275   const char *str;
9276
9277   str = getenv ("TEST_ONLY");
9278   if (str)
9279     return strstr (str, "lstat") == NULL;
9280   str = getenv ("SKIP_TEST_LSTAT_0");
9281   if (str && strcmp (str, "1") == 0) return 1;
9282   str = getenv ("SKIP_TEST_LSTAT");
9283   if (str && strcmp (str, "1") == 0) return 1;
9284   return 0;
9285 }
9286
9287 static int test_lstat_0 (void)
9288 {
9289   if (test_lstat_0_skip ()) {
9290     printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9291     return 0;
9292   }
9293
9294   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9295   {
9296     char device[] = "/dev/sda";
9297     int r;
9298     suppress_error = 0;
9299     r = guestfs_blockdev_setrw (g, device);
9300     if (r == -1)
9301       return -1;
9302   }
9303   {
9304     int r;
9305     suppress_error = 0;
9306     r = guestfs_umount_all (g);
9307     if (r == -1)
9308       return -1;
9309   }
9310   {
9311     int r;
9312     suppress_error = 0;
9313     r = guestfs_lvm_remove_all (g);
9314     if (r == -1)
9315       return -1;
9316   }
9317   {
9318     char device[] = "/dev/sda";
9319     char lines_0[] = ",";
9320     char *lines[] = {
9321       lines_0,
9322       NULL
9323     };
9324     int r;
9325     suppress_error = 0;
9326     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9327     if (r == -1)
9328       return -1;
9329   }
9330   {
9331     char fstype[] = "ext2";
9332     char device[] = "/dev/sda1";
9333     int r;
9334     suppress_error = 0;
9335     r = guestfs_mkfs (g, fstype, device);
9336     if (r == -1)
9337       return -1;
9338   }
9339   {
9340     char device[] = "/dev/sda1";
9341     char mountpoint[] = "/";
9342     int r;
9343     suppress_error = 0;
9344     r = guestfs_mount (g, device, mountpoint);
9345     if (r == -1)
9346       return -1;
9347   }
9348   /* TestOutputStruct for lstat (0) */
9349   {
9350     char path[] = "/new";
9351     int r;
9352     suppress_error = 0;
9353     r = guestfs_touch (g, path);
9354     if (r == -1)
9355       return -1;
9356   }
9357   {
9358     char path[] = "/new";
9359     struct guestfs_stat *r;
9360     suppress_error = 0;
9361     r = guestfs_lstat (g, path);
9362     if (r == NULL)
9363       return -1;
9364     if (r->size != 0) {
9365       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9366                (int) r->size);
9367       return -1;
9368     }
9369     free (r);
9370   }
9371   return 0;
9372 }
9373
9374 static int test_stat_0_skip (void)
9375 {
9376   const char *str;
9377
9378   str = getenv ("TEST_ONLY");
9379   if (str)
9380     return strstr (str, "stat") == NULL;
9381   str = getenv ("SKIP_TEST_STAT_0");
9382   if (str && strcmp (str, "1") == 0) return 1;
9383   str = getenv ("SKIP_TEST_STAT");
9384   if (str && strcmp (str, "1") == 0) return 1;
9385   return 0;
9386 }
9387
9388 static int test_stat_0 (void)
9389 {
9390   if (test_stat_0_skip ()) {
9391     printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9392     return 0;
9393   }
9394
9395   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9396   {
9397     char device[] = "/dev/sda";
9398     int r;
9399     suppress_error = 0;
9400     r = guestfs_blockdev_setrw (g, device);
9401     if (r == -1)
9402       return -1;
9403   }
9404   {
9405     int r;
9406     suppress_error = 0;
9407     r = guestfs_umount_all (g);
9408     if (r == -1)
9409       return -1;
9410   }
9411   {
9412     int r;
9413     suppress_error = 0;
9414     r = guestfs_lvm_remove_all (g);
9415     if (r == -1)
9416       return -1;
9417   }
9418   {
9419     char device[] = "/dev/sda";
9420     char lines_0[] = ",";
9421     char *lines[] = {
9422       lines_0,
9423       NULL
9424     };
9425     int r;
9426     suppress_error = 0;
9427     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9428     if (r == -1)
9429       return -1;
9430   }
9431   {
9432     char fstype[] = "ext2";
9433     char device[] = "/dev/sda1";
9434     int r;
9435     suppress_error = 0;
9436     r = guestfs_mkfs (g, fstype, device);
9437     if (r == -1)
9438       return -1;
9439   }
9440   {
9441     char device[] = "/dev/sda1";
9442     char mountpoint[] = "/";
9443     int r;
9444     suppress_error = 0;
9445     r = guestfs_mount (g, device, mountpoint);
9446     if (r == -1)
9447       return -1;
9448   }
9449   /* TestOutputStruct for stat (0) */
9450   {
9451     char path[] = "/new";
9452     int r;
9453     suppress_error = 0;
9454     r = guestfs_touch (g, path);
9455     if (r == -1)
9456       return -1;
9457   }
9458   {
9459     char path[] = "/new";
9460     struct guestfs_stat *r;
9461     suppress_error = 0;
9462     r = guestfs_stat (g, path);
9463     if (r == NULL)
9464       return -1;
9465     if (r->size != 0) {
9466       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9467                (int) r->size);
9468       return -1;
9469     }
9470     free (r);
9471   }
9472   return 0;
9473 }
9474
9475 static int test_command_lines_0_skip (void)
9476 {
9477   const char *str;
9478
9479   str = getenv ("TEST_ONLY");
9480   if (str)
9481     return strstr (str, "command_lines") == NULL;
9482   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9483   if (str && strcmp (str, "1") == 0) return 1;
9484   str = getenv ("SKIP_TEST_COMMAND_LINES");
9485   if (str && strcmp (str, "1") == 0) return 1;
9486   return 0;
9487 }
9488
9489 static int test_command_lines_0 (void)
9490 {
9491   if (test_command_lines_0_skip ()) {
9492     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9493     return 0;
9494   }
9495
9496   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9497   {
9498     char device[] = "/dev/sda";
9499     int r;
9500     suppress_error = 0;
9501     r = guestfs_blockdev_setrw (g, device);
9502     if (r == -1)
9503       return -1;
9504   }
9505   {
9506     int r;
9507     suppress_error = 0;
9508     r = guestfs_umount_all (g);
9509     if (r == -1)
9510       return -1;
9511   }
9512   {
9513     int r;
9514     suppress_error = 0;
9515     r = guestfs_lvm_remove_all (g);
9516     if (r == -1)
9517       return -1;
9518   }
9519   {
9520     char device[] = "/dev/sda";
9521     char lines_0[] = ",";
9522     char *lines[] = {
9523       lines_0,
9524       NULL
9525     };
9526     int r;
9527     suppress_error = 0;
9528     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9529     if (r == -1)
9530       return -1;
9531   }
9532   {
9533     char fstype[] = "ext2";
9534     char device[] = "/dev/sda1";
9535     int r;
9536     suppress_error = 0;
9537     r = guestfs_mkfs (g, fstype, device);
9538     if (r == -1)
9539       return -1;
9540   }
9541   {
9542     char device[] = "/dev/sda1";
9543     char mountpoint[] = "/";
9544     int r;
9545     suppress_error = 0;
9546     r = guestfs_mount (g, device, mountpoint);
9547     if (r == -1)
9548       return -1;
9549   }
9550   /* TestOutputList for command_lines (0) */
9551   {
9552     char remotefilename[] = "/test-command";
9553     int r;
9554     suppress_error = 0;
9555     r = guestfs_upload (g, "test-command", remotefilename);
9556     if (r == -1)
9557       return -1;
9558   }
9559   {
9560     char path[] = "/test-command";
9561     int r;
9562     suppress_error = 0;
9563     r = guestfs_chmod (g, 493, path);
9564     if (r == -1)
9565       return -1;
9566   }
9567   {
9568     char arguments_0[] = "/test-command";
9569     char arguments_1[] = "1";
9570     char *arguments[] = {
9571       arguments_0,
9572       arguments_1,
9573       NULL
9574     };
9575     char **r;
9576     int i;
9577     suppress_error = 0;
9578     r = guestfs_command_lines (g, arguments);
9579     if (r == NULL)
9580       return -1;
9581     if (!r[0]) {
9582       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9583       print_strings (r);
9584       return -1;
9585     }
9586     {
9587       char expected[] = "Result1";
9588       if (strcmp (r[0], expected) != 0) {
9589         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9590         return -1;
9591       }
9592     }
9593     if (r[1] != NULL) {
9594       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9595       print_strings (r);
9596       return -1;
9597     }
9598     for (i = 0; r[i] != NULL; ++i)
9599       free (r[i]);
9600     free (r);
9601   }
9602   return 0;
9603 }
9604
9605 static int test_command_lines_1_skip (void)
9606 {
9607   const char *str;
9608
9609   str = getenv ("TEST_ONLY");
9610   if (str)
9611     return strstr (str, "command_lines") == NULL;
9612   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9613   if (str && strcmp (str, "1") == 0) return 1;
9614   str = getenv ("SKIP_TEST_COMMAND_LINES");
9615   if (str && strcmp (str, "1") == 0) return 1;
9616   return 0;
9617 }
9618
9619 static int test_command_lines_1 (void)
9620 {
9621   if (test_command_lines_1_skip ()) {
9622     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9623     return 0;
9624   }
9625
9626   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9627   {
9628     char device[] = "/dev/sda";
9629     int r;
9630     suppress_error = 0;
9631     r = guestfs_blockdev_setrw (g, device);
9632     if (r == -1)
9633       return -1;
9634   }
9635   {
9636     int r;
9637     suppress_error = 0;
9638     r = guestfs_umount_all (g);
9639     if (r == -1)
9640       return -1;
9641   }
9642   {
9643     int r;
9644     suppress_error = 0;
9645     r = guestfs_lvm_remove_all (g);
9646     if (r == -1)
9647       return -1;
9648   }
9649   {
9650     char device[] = "/dev/sda";
9651     char lines_0[] = ",";
9652     char *lines[] = {
9653       lines_0,
9654       NULL
9655     };
9656     int r;
9657     suppress_error = 0;
9658     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9659     if (r == -1)
9660       return -1;
9661   }
9662   {
9663     char fstype[] = "ext2";
9664     char device[] = "/dev/sda1";
9665     int r;
9666     suppress_error = 0;
9667     r = guestfs_mkfs (g, fstype, device);
9668     if (r == -1)
9669       return -1;
9670   }
9671   {
9672     char device[] = "/dev/sda1";
9673     char mountpoint[] = "/";
9674     int r;
9675     suppress_error = 0;
9676     r = guestfs_mount (g, device, mountpoint);
9677     if (r == -1)
9678       return -1;
9679   }
9680   /* TestOutputList for command_lines (1) */
9681   {
9682     char remotefilename[] = "/test-command";
9683     int r;
9684     suppress_error = 0;
9685     r = guestfs_upload (g, "test-command", remotefilename);
9686     if (r == -1)
9687       return -1;
9688   }
9689   {
9690     char path[] = "/test-command";
9691     int r;
9692     suppress_error = 0;
9693     r = guestfs_chmod (g, 493, path);
9694     if (r == -1)
9695       return -1;
9696   }
9697   {
9698     char arguments_0[] = "/test-command";
9699     char arguments_1[] = "2";
9700     char *arguments[] = {
9701       arguments_0,
9702       arguments_1,
9703       NULL
9704     };
9705     char **r;
9706     int i;
9707     suppress_error = 0;
9708     r = guestfs_command_lines (g, arguments);
9709     if (r == NULL)
9710       return -1;
9711     if (!r[0]) {
9712       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
9713       print_strings (r);
9714       return -1;
9715     }
9716     {
9717       char expected[] = "Result2";
9718       if (strcmp (r[0], expected) != 0) {
9719         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9720         return -1;
9721       }
9722     }
9723     if (r[1] != NULL) {
9724       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
9725       print_strings (r);
9726       return -1;
9727     }
9728     for (i = 0; r[i] != NULL; ++i)
9729       free (r[i]);
9730     free (r);
9731   }
9732   return 0;
9733 }
9734
9735 static int test_command_lines_2_skip (void)
9736 {
9737   const char *str;
9738
9739   str = getenv ("TEST_ONLY");
9740   if (str)
9741     return strstr (str, "command_lines") == NULL;
9742   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
9743   if (str && strcmp (str, "1") == 0) return 1;
9744   str = getenv ("SKIP_TEST_COMMAND_LINES");
9745   if (str && strcmp (str, "1") == 0) return 1;
9746   return 0;
9747 }
9748
9749 static int test_command_lines_2 (void)
9750 {
9751   if (test_command_lines_2_skip ()) {
9752     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
9753     return 0;
9754   }
9755
9756   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
9757   {
9758     char device[] = "/dev/sda";
9759     int r;
9760     suppress_error = 0;
9761     r = guestfs_blockdev_setrw (g, device);
9762     if (r == -1)
9763       return -1;
9764   }
9765   {
9766     int r;
9767     suppress_error = 0;
9768     r = guestfs_umount_all (g);
9769     if (r == -1)
9770       return -1;
9771   }
9772   {
9773     int r;
9774     suppress_error = 0;
9775     r = guestfs_lvm_remove_all (g);
9776     if (r == -1)
9777       return -1;
9778   }
9779   {
9780     char device[] = "/dev/sda";
9781     char lines_0[] = ",";
9782     char *lines[] = {
9783       lines_0,
9784       NULL
9785     };
9786     int r;
9787     suppress_error = 0;
9788     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9789     if (r == -1)
9790       return -1;
9791   }
9792   {
9793     char fstype[] = "ext2";
9794     char device[] = "/dev/sda1";
9795     int r;
9796     suppress_error = 0;
9797     r = guestfs_mkfs (g, fstype, device);
9798     if (r == -1)
9799       return -1;
9800   }
9801   {
9802     char device[] = "/dev/sda1";
9803     char mountpoint[] = "/";
9804     int r;
9805     suppress_error = 0;
9806     r = guestfs_mount (g, device, mountpoint);
9807     if (r == -1)
9808       return -1;
9809   }
9810   /* TestOutputList for command_lines (2) */
9811   {
9812     char remotefilename[] = "/test-command";
9813     int r;
9814     suppress_error = 0;
9815     r = guestfs_upload (g, "test-command", remotefilename);
9816     if (r == -1)
9817       return -1;
9818   }
9819   {
9820     char path[] = "/test-command";
9821     int r;
9822     suppress_error = 0;
9823     r = guestfs_chmod (g, 493, path);
9824     if (r == -1)
9825       return -1;
9826   }
9827   {
9828     char arguments_0[] = "/test-command";
9829     char arguments_1[] = "3";
9830     char *arguments[] = {
9831       arguments_0,
9832       arguments_1,
9833       NULL
9834     };
9835     char **r;
9836     int i;
9837     suppress_error = 0;
9838     r = guestfs_command_lines (g, arguments);
9839     if (r == NULL)
9840       return -1;
9841     if (!r[0]) {
9842       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9843       print_strings (r);
9844       return -1;
9845     }
9846     {
9847       char expected[] = "";
9848       if (strcmp (r[0], expected) != 0) {
9849         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9850         return -1;
9851       }
9852     }
9853     if (!r[1]) {
9854       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9855       print_strings (r);
9856       return -1;
9857     }
9858     {
9859       char expected[] = "Result3";
9860       if (strcmp (r[1], expected) != 0) {
9861         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9862         return -1;
9863       }
9864     }
9865     if (r[2] != NULL) {
9866       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
9867       print_strings (r);
9868       return -1;
9869     }
9870     for (i = 0; r[i] != NULL; ++i)
9871       free (r[i]);
9872     free (r);
9873   }
9874   return 0;
9875 }
9876
9877 static int test_command_lines_3_skip (void)
9878 {
9879   const char *str;
9880
9881   str = getenv ("TEST_ONLY");
9882   if (str)
9883     return strstr (str, "command_lines") == NULL;
9884   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
9885   if (str && strcmp (str, "1") == 0) return 1;
9886   str = getenv ("SKIP_TEST_COMMAND_LINES");
9887   if (str && strcmp (str, "1") == 0) return 1;
9888   return 0;
9889 }
9890
9891 static int test_command_lines_3 (void)
9892 {
9893   if (test_command_lines_3_skip ()) {
9894     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
9895     return 0;
9896   }
9897
9898   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
9899   {
9900     char device[] = "/dev/sda";
9901     int r;
9902     suppress_error = 0;
9903     r = guestfs_blockdev_setrw (g, device);
9904     if (r == -1)
9905       return -1;
9906   }
9907   {
9908     int r;
9909     suppress_error = 0;
9910     r = guestfs_umount_all (g);
9911     if (r == -1)
9912       return -1;
9913   }
9914   {
9915     int r;
9916     suppress_error = 0;
9917     r = guestfs_lvm_remove_all (g);
9918     if (r == -1)
9919       return -1;
9920   }
9921   {
9922     char device[] = "/dev/sda";
9923     char lines_0[] = ",";
9924     char *lines[] = {
9925       lines_0,
9926       NULL
9927     };
9928     int r;
9929     suppress_error = 0;
9930     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9931     if (r == -1)
9932       return -1;
9933   }
9934   {
9935     char fstype[] = "ext2";
9936     char device[] = "/dev/sda1";
9937     int r;
9938     suppress_error = 0;
9939     r = guestfs_mkfs (g, fstype, device);
9940     if (r == -1)
9941       return -1;
9942   }
9943   {
9944     char device[] = "/dev/sda1";
9945     char mountpoint[] = "/";
9946     int r;
9947     suppress_error = 0;
9948     r = guestfs_mount (g, device, mountpoint);
9949     if (r == -1)
9950       return -1;
9951   }
9952   /* TestOutputList for command_lines (3) */
9953   {
9954     char remotefilename[] = "/test-command";
9955     int r;
9956     suppress_error = 0;
9957     r = guestfs_upload (g, "test-command", remotefilename);
9958     if (r == -1)
9959       return -1;
9960   }
9961   {
9962     char path[] = "/test-command";
9963     int r;
9964     suppress_error = 0;
9965     r = guestfs_chmod (g, 493, path);
9966     if (r == -1)
9967       return -1;
9968   }
9969   {
9970     char arguments_0[] = "/test-command";
9971     char arguments_1[] = "4";
9972     char *arguments[] = {
9973       arguments_0,
9974       arguments_1,
9975       NULL
9976     };
9977     char **r;
9978     int i;
9979     suppress_error = 0;
9980     r = guestfs_command_lines (g, arguments);
9981     if (r == NULL)
9982       return -1;
9983     if (!r[0]) {
9984       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
9985       print_strings (r);
9986       return -1;
9987     }
9988     {
9989       char expected[] = "";
9990       if (strcmp (r[0], expected) != 0) {
9991         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9992         return -1;
9993       }
9994     }
9995     if (!r[1]) {
9996       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
9997       print_strings (r);
9998       return -1;
9999     }
10000     {
10001       char expected[] = "Result4";
10002       if (strcmp (r[1], expected) != 0) {
10003         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10004         return -1;
10005       }
10006     }
10007     if (r[2] != NULL) {
10008       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10009       print_strings (r);
10010       return -1;
10011     }
10012     for (i = 0; r[i] != NULL; ++i)
10013       free (r[i]);
10014     free (r);
10015   }
10016   return 0;
10017 }
10018
10019 static int test_command_lines_4_skip (void)
10020 {
10021   const char *str;
10022
10023   str = getenv ("TEST_ONLY");
10024   if (str)
10025     return strstr (str, "command_lines") == NULL;
10026   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10027   if (str && strcmp (str, "1") == 0) return 1;
10028   str = getenv ("SKIP_TEST_COMMAND_LINES");
10029   if (str && strcmp (str, "1") == 0) return 1;
10030   return 0;
10031 }
10032
10033 static int test_command_lines_4 (void)
10034 {
10035   if (test_command_lines_4_skip ()) {
10036     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10037     return 0;
10038   }
10039
10040   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10041   {
10042     char device[] = "/dev/sda";
10043     int r;
10044     suppress_error = 0;
10045     r = guestfs_blockdev_setrw (g, device);
10046     if (r == -1)
10047       return -1;
10048   }
10049   {
10050     int r;
10051     suppress_error = 0;
10052     r = guestfs_umount_all (g);
10053     if (r == -1)
10054       return -1;
10055   }
10056   {
10057     int r;
10058     suppress_error = 0;
10059     r = guestfs_lvm_remove_all (g);
10060     if (r == -1)
10061       return -1;
10062   }
10063   {
10064     char device[] = "/dev/sda";
10065     char lines_0[] = ",";
10066     char *lines[] = {
10067       lines_0,
10068       NULL
10069     };
10070     int r;
10071     suppress_error = 0;
10072     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10073     if (r == -1)
10074       return -1;
10075   }
10076   {
10077     char fstype[] = "ext2";
10078     char device[] = "/dev/sda1";
10079     int r;
10080     suppress_error = 0;
10081     r = guestfs_mkfs (g, fstype, device);
10082     if (r == -1)
10083       return -1;
10084   }
10085   {
10086     char device[] = "/dev/sda1";
10087     char mountpoint[] = "/";
10088     int r;
10089     suppress_error = 0;
10090     r = guestfs_mount (g, device, mountpoint);
10091     if (r == -1)
10092       return -1;
10093   }
10094   /* TestOutputList for command_lines (4) */
10095   {
10096     char remotefilename[] = "/test-command";
10097     int r;
10098     suppress_error = 0;
10099     r = guestfs_upload (g, "test-command", remotefilename);
10100     if (r == -1)
10101       return -1;
10102   }
10103   {
10104     char path[] = "/test-command";
10105     int r;
10106     suppress_error = 0;
10107     r = guestfs_chmod (g, 493, path);
10108     if (r == -1)
10109       return -1;
10110   }
10111   {
10112     char arguments_0[] = "/test-command";
10113     char arguments_1[] = "5";
10114     char *arguments[] = {
10115       arguments_0,
10116       arguments_1,
10117       NULL
10118     };
10119     char **r;
10120     int i;
10121     suppress_error = 0;
10122     r = guestfs_command_lines (g, arguments);
10123     if (r == NULL)
10124       return -1;
10125     if (!r[0]) {
10126       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10127       print_strings (r);
10128       return -1;
10129     }
10130     {
10131       char expected[] = "";
10132       if (strcmp (r[0], expected) != 0) {
10133         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10134         return -1;
10135       }
10136     }
10137     if (!r[1]) {
10138       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10139       print_strings (r);
10140       return -1;
10141     }
10142     {
10143       char expected[] = "Result5";
10144       if (strcmp (r[1], expected) != 0) {
10145         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10146         return -1;
10147       }
10148     }
10149     if (!r[2]) {
10150       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10151       print_strings (r);
10152       return -1;
10153     }
10154     {
10155       char expected[] = "";
10156       if (strcmp (r[2], expected) != 0) {
10157         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10158         return -1;
10159       }
10160     }
10161     if (r[3] != NULL) {
10162       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10163       print_strings (r);
10164       return -1;
10165     }
10166     for (i = 0; r[i] != NULL; ++i)
10167       free (r[i]);
10168     free (r);
10169   }
10170   return 0;
10171 }
10172
10173 static int test_command_lines_5_skip (void)
10174 {
10175   const char *str;
10176
10177   str = getenv ("TEST_ONLY");
10178   if (str)
10179     return strstr (str, "command_lines") == NULL;
10180   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10181   if (str && strcmp (str, "1") == 0) return 1;
10182   str = getenv ("SKIP_TEST_COMMAND_LINES");
10183   if (str && strcmp (str, "1") == 0) return 1;
10184   return 0;
10185 }
10186
10187 static int test_command_lines_5 (void)
10188 {
10189   if (test_command_lines_5_skip ()) {
10190     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10191     return 0;
10192   }
10193
10194   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10195   {
10196     char device[] = "/dev/sda";
10197     int r;
10198     suppress_error = 0;
10199     r = guestfs_blockdev_setrw (g, device);
10200     if (r == -1)
10201       return -1;
10202   }
10203   {
10204     int r;
10205     suppress_error = 0;
10206     r = guestfs_umount_all (g);
10207     if (r == -1)
10208       return -1;
10209   }
10210   {
10211     int r;
10212     suppress_error = 0;
10213     r = guestfs_lvm_remove_all (g);
10214     if (r == -1)
10215       return -1;
10216   }
10217   {
10218     char device[] = "/dev/sda";
10219     char lines_0[] = ",";
10220     char *lines[] = {
10221       lines_0,
10222       NULL
10223     };
10224     int r;
10225     suppress_error = 0;
10226     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10227     if (r == -1)
10228       return -1;
10229   }
10230   {
10231     char fstype[] = "ext2";
10232     char device[] = "/dev/sda1";
10233     int r;
10234     suppress_error = 0;
10235     r = guestfs_mkfs (g, fstype, device);
10236     if (r == -1)
10237       return -1;
10238   }
10239   {
10240     char device[] = "/dev/sda1";
10241     char mountpoint[] = "/";
10242     int r;
10243     suppress_error = 0;
10244     r = guestfs_mount (g, device, mountpoint);
10245     if (r == -1)
10246       return -1;
10247   }
10248   /* TestOutputList for command_lines (5) */
10249   {
10250     char remotefilename[] = "/test-command";
10251     int r;
10252     suppress_error = 0;
10253     r = guestfs_upload (g, "test-command", remotefilename);
10254     if (r == -1)
10255       return -1;
10256   }
10257   {
10258     char path[] = "/test-command";
10259     int r;
10260     suppress_error = 0;
10261     r = guestfs_chmod (g, 493, path);
10262     if (r == -1)
10263       return -1;
10264   }
10265   {
10266     char arguments_0[] = "/test-command";
10267     char arguments_1[] = "6";
10268     char *arguments[] = {
10269       arguments_0,
10270       arguments_1,
10271       NULL
10272     };
10273     char **r;
10274     int i;
10275     suppress_error = 0;
10276     r = guestfs_command_lines (g, arguments);
10277     if (r == NULL)
10278       return -1;
10279     if (!r[0]) {
10280       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10281       print_strings (r);
10282       return -1;
10283     }
10284     {
10285       char expected[] = "";
10286       if (strcmp (r[0], expected) != 0) {
10287         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10288         return -1;
10289       }
10290     }
10291     if (!r[1]) {
10292       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10293       print_strings (r);
10294       return -1;
10295     }
10296     {
10297       char expected[] = "";
10298       if (strcmp (r[1], expected) != 0) {
10299         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10300         return -1;
10301       }
10302     }
10303     if (!r[2]) {
10304       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10305       print_strings (r);
10306       return -1;
10307     }
10308     {
10309       char expected[] = "Result6";
10310       if (strcmp (r[2], expected) != 0) {
10311         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10312         return -1;
10313       }
10314     }
10315     if (!r[3]) {
10316       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10317       print_strings (r);
10318       return -1;
10319     }
10320     {
10321       char expected[] = "";
10322       if (strcmp (r[3], expected) != 0) {
10323         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10324         return -1;
10325       }
10326     }
10327     if (r[4] != NULL) {
10328       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10329       print_strings (r);
10330       return -1;
10331     }
10332     for (i = 0; r[i] != NULL; ++i)
10333       free (r[i]);
10334     free (r);
10335   }
10336   return 0;
10337 }
10338
10339 static int test_command_lines_6_skip (void)
10340 {
10341   const char *str;
10342
10343   str = getenv ("TEST_ONLY");
10344   if (str)
10345     return strstr (str, "command_lines") == NULL;
10346   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10347   if (str && strcmp (str, "1") == 0) return 1;
10348   str = getenv ("SKIP_TEST_COMMAND_LINES");
10349   if (str && strcmp (str, "1") == 0) return 1;
10350   return 0;
10351 }
10352
10353 static int test_command_lines_6 (void)
10354 {
10355   if (test_command_lines_6_skip ()) {
10356     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10357     return 0;
10358   }
10359
10360   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10361   {
10362     char device[] = "/dev/sda";
10363     int r;
10364     suppress_error = 0;
10365     r = guestfs_blockdev_setrw (g, device);
10366     if (r == -1)
10367       return -1;
10368   }
10369   {
10370     int r;
10371     suppress_error = 0;
10372     r = guestfs_umount_all (g);
10373     if (r == -1)
10374       return -1;
10375   }
10376   {
10377     int r;
10378     suppress_error = 0;
10379     r = guestfs_lvm_remove_all (g);
10380     if (r == -1)
10381       return -1;
10382   }
10383   {
10384     char device[] = "/dev/sda";
10385     char lines_0[] = ",";
10386     char *lines[] = {
10387       lines_0,
10388       NULL
10389     };
10390     int r;
10391     suppress_error = 0;
10392     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10393     if (r == -1)
10394       return -1;
10395   }
10396   {
10397     char fstype[] = "ext2";
10398     char device[] = "/dev/sda1";
10399     int r;
10400     suppress_error = 0;
10401     r = guestfs_mkfs (g, fstype, device);
10402     if (r == -1)
10403       return -1;
10404   }
10405   {
10406     char device[] = "/dev/sda1";
10407     char mountpoint[] = "/";
10408     int r;
10409     suppress_error = 0;
10410     r = guestfs_mount (g, device, mountpoint);
10411     if (r == -1)
10412       return -1;
10413   }
10414   /* TestOutputList for command_lines (6) */
10415   {
10416     char remotefilename[] = "/test-command";
10417     int r;
10418     suppress_error = 0;
10419     r = guestfs_upload (g, "test-command", remotefilename);
10420     if (r == -1)
10421       return -1;
10422   }
10423   {
10424     char path[] = "/test-command";
10425     int r;
10426     suppress_error = 0;
10427     r = guestfs_chmod (g, 493, path);
10428     if (r == -1)
10429       return -1;
10430   }
10431   {
10432     char arguments_0[] = "/test-command";
10433     char arguments_1[] = "7";
10434     char *arguments[] = {
10435       arguments_0,
10436       arguments_1,
10437       NULL
10438     };
10439     char **r;
10440     int i;
10441     suppress_error = 0;
10442     r = guestfs_command_lines (g, arguments);
10443     if (r == NULL)
10444       return -1;
10445     if (r[0] != NULL) {
10446       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10447       print_strings (r);
10448       return -1;
10449     }
10450     for (i = 0; r[i] != NULL; ++i)
10451       free (r[i]);
10452     free (r);
10453   }
10454   return 0;
10455 }
10456
10457 static int test_command_lines_7_skip (void)
10458 {
10459   const char *str;
10460
10461   str = getenv ("TEST_ONLY");
10462   if (str)
10463     return strstr (str, "command_lines") == NULL;
10464   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10465   if (str && strcmp (str, "1") == 0) return 1;
10466   str = getenv ("SKIP_TEST_COMMAND_LINES");
10467   if (str && strcmp (str, "1") == 0) return 1;
10468   return 0;
10469 }
10470
10471 static int test_command_lines_7 (void)
10472 {
10473   if (test_command_lines_7_skip ()) {
10474     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10475     return 0;
10476   }
10477
10478   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10479   {
10480     char device[] = "/dev/sda";
10481     int r;
10482     suppress_error = 0;
10483     r = guestfs_blockdev_setrw (g, device);
10484     if (r == -1)
10485       return -1;
10486   }
10487   {
10488     int r;
10489     suppress_error = 0;
10490     r = guestfs_umount_all (g);
10491     if (r == -1)
10492       return -1;
10493   }
10494   {
10495     int r;
10496     suppress_error = 0;
10497     r = guestfs_lvm_remove_all (g);
10498     if (r == -1)
10499       return -1;
10500   }
10501   {
10502     char device[] = "/dev/sda";
10503     char lines_0[] = ",";
10504     char *lines[] = {
10505       lines_0,
10506       NULL
10507     };
10508     int r;
10509     suppress_error = 0;
10510     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10511     if (r == -1)
10512       return -1;
10513   }
10514   {
10515     char fstype[] = "ext2";
10516     char device[] = "/dev/sda1";
10517     int r;
10518     suppress_error = 0;
10519     r = guestfs_mkfs (g, fstype, device);
10520     if (r == -1)
10521       return -1;
10522   }
10523   {
10524     char device[] = "/dev/sda1";
10525     char mountpoint[] = "/";
10526     int r;
10527     suppress_error = 0;
10528     r = guestfs_mount (g, device, mountpoint);
10529     if (r == -1)
10530       return -1;
10531   }
10532   /* TestOutputList for command_lines (7) */
10533   {
10534     char remotefilename[] = "/test-command";
10535     int r;
10536     suppress_error = 0;
10537     r = guestfs_upload (g, "test-command", remotefilename);
10538     if (r == -1)
10539       return -1;
10540   }
10541   {
10542     char path[] = "/test-command";
10543     int r;
10544     suppress_error = 0;
10545     r = guestfs_chmod (g, 493, path);
10546     if (r == -1)
10547       return -1;
10548   }
10549   {
10550     char arguments_0[] = "/test-command";
10551     char arguments_1[] = "8";
10552     char *arguments[] = {
10553       arguments_0,
10554       arguments_1,
10555       NULL
10556     };
10557     char **r;
10558     int i;
10559     suppress_error = 0;
10560     r = guestfs_command_lines (g, arguments);
10561     if (r == NULL)
10562       return -1;
10563     if (!r[0]) {
10564       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10565       print_strings (r);
10566       return -1;
10567     }
10568     {
10569       char expected[] = "";
10570       if (strcmp (r[0], expected) != 0) {
10571         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10572         return -1;
10573       }
10574     }
10575     if (r[1] != NULL) {
10576       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10577       print_strings (r);
10578       return -1;
10579     }
10580     for (i = 0; r[i] != NULL; ++i)
10581       free (r[i]);
10582     free (r);
10583   }
10584   return 0;
10585 }
10586
10587 static int test_command_lines_8_skip (void)
10588 {
10589   const char *str;
10590
10591   str = getenv ("TEST_ONLY");
10592   if (str)
10593     return strstr (str, "command_lines") == NULL;
10594   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10595   if (str && strcmp (str, "1") == 0) return 1;
10596   str = getenv ("SKIP_TEST_COMMAND_LINES");
10597   if (str && strcmp (str, "1") == 0) return 1;
10598   return 0;
10599 }
10600
10601 static int test_command_lines_8 (void)
10602 {
10603   if (test_command_lines_8_skip ()) {
10604     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10605     return 0;
10606   }
10607
10608   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10609   {
10610     char device[] = "/dev/sda";
10611     int r;
10612     suppress_error = 0;
10613     r = guestfs_blockdev_setrw (g, device);
10614     if (r == -1)
10615       return -1;
10616   }
10617   {
10618     int r;
10619     suppress_error = 0;
10620     r = guestfs_umount_all (g);
10621     if (r == -1)
10622       return -1;
10623   }
10624   {
10625     int r;
10626     suppress_error = 0;
10627     r = guestfs_lvm_remove_all (g);
10628     if (r == -1)
10629       return -1;
10630   }
10631   {
10632     char device[] = "/dev/sda";
10633     char lines_0[] = ",";
10634     char *lines[] = {
10635       lines_0,
10636       NULL
10637     };
10638     int r;
10639     suppress_error = 0;
10640     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10641     if (r == -1)
10642       return -1;
10643   }
10644   {
10645     char fstype[] = "ext2";
10646     char device[] = "/dev/sda1";
10647     int r;
10648     suppress_error = 0;
10649     r = guestfs_mkfs (g, fstype, device);
10650     if (r == -1)
10651       return -1;
10652   }
10653   {
10654     char device[] = "/dev/sda1";
10655     char mountpoint[] = "/";
10656     int r;
10657     suppress_error = 0;
10658     r = guestfs_mount (g, device, mountpoint);
10659     if (r == -1)
10660       return -1;
10661   }
10662   /* TestOutputList for command_lines (8) */
10663   {
10664     char remotefilename[] = "/test-command";
10665     int r;
10666     suppress_error = 0;
10667     r = guestfs_upload (g, "test-command", remotefilename);
10668     if (r == -1)
10669       return -1;
10670   }
10671   {
10672     char path[] = "/test-command";
10673     int r;
10674     suppress_error = 0;
10675     r = guestfs_chmod (g, 493, path);
10676     if (r == -1)
10677       return -1;
10678   }
10679   {
10680     char arguments_0[] = "/test-command";
10681     char arguments_1[] = "9";
10682     char *arguments[] = {
10683       arguments_0,
10684       arguments_1,
10685       NULL
10686     };
10687     char **r;
10688     int i;
10689     suppress_error = 0;
10690     r = guestfs_command_lines (g, arguments);
10691     if (r == NULL)
10692       return -1;
10693     if (!r[0]) {
10694       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10695       print_strings (r);
10696       return -1;
10697     }
10698     {
10699       char expected[] = "";
10700       if (strcmp (r[0], expected) != 0) {
10701         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10702         return -1;
10703       }
10704     }
10705     if (!r[1]) {
10706       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10707       print_strings (r);
10708       return -1;
10709     }
10710     {
10711       char expected[] = "";
10712       if (strcmp (r[1], expected) != 0) {
10713         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10714         return -1;
10715       }
10716     }
10717     if (r[2] != NULL) {
10718       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
10719       print_strings (r);
10720       return -1;
10721     }
10722     for (i = 0; r[i] != NULL; ++i)
10723       free (r[i]);
10724     free (r);
10725   }
10726   return 0;
10727 }
10728
10729 static int test_command_lines_9_skip (void)
10730 {
10731   const char *str;
10732
10733   str = getenv ("TEST_ONLY");
10734   if (str)
10735     return strstr (str, "command_lines") == NULL;
10736   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
10737   if (str && strcmp (str, "1") == 0) return 1;
10738   str = getenv ("SKIP_TEST_COMMAND_LINES");
10739   if (str && strcmp (str, "1") == 0) return 1;
10740   return 0;
10741 }
10742
10743 static int test_command_lines_9 (void)
10744 {
10745   if (test_command_lines_9_skip ()) {
10746     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
10747     return 0;
10748   }
10749
10750   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
10751   {
10752     char device[] = "/dev/sda";
10753     int r;
10754     suppress_error = 0;
10755     r = guestfs_blockdev_setrw (g, device);
10756     if (r == -1)
10757       return -1;
10758   }
10759   {
10760     int r;
10761     suppress_error = 0;
10762     r = guestfs_umount_all (g);
10763     if (r == -1)
10764       return -1;
10765   }
10766   {
10767     int r;
10768     suppress_error = 0;
10769     r = guestfs_lvm_remove_all (g);
10770     if (r == -1)
10771       return -1;
10772   }
10773   {
10774     char device[] = "/dev/sda";
10775     char lines_0[] = ",";
10776     char *lines[] = {
10777       lines_0,
10778       NULL
10779     };
10780     int r;
10781     suppress_error = 0;
10782     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10783     if (r == -1)
10784       return -1;
10785   }
10786   {
10787     char fstype[] = "ext2";
10788     char device[] = "/dev/sda1";
10789     int r;
10790     suppress_error = 0;
10791     r = guestfs_mkfs (g, fstype, device);
10792     if (r == -1)
10793       return -1;
10794   }
10795   {
10796     char device[] = "/dev/sda1";
10797     char mountpoint[] = "/";
10798     int r;
10799     suppress_error = 0;
10800     r = guestfs_mount (g, device, mountpoint);
10801     if (r == -1)
10802       return -1;
10803   }
10804   /* TestOutputList for command_lines (9) */
10805   {
10806     char remotefilename[] = "/test-command";
10807     int r;
10808     suppress_error = 0;
10809     r = guestfs_upload (g, "test-command", remotefilename);
10810     if (r == -1)
10811       return -1;
10812   }
10813   {
10814     char path[] = "/test-command";
10815     int r;
10816     suppress_error = 0;
10817     r = guestfs_chmod (g, 493, path);
10818     if (r == -1)
10819       return -1;
10820   }
10821   {
10822     char arguments_0[] = "/test-command";
10823     char arguments_1[] = "10";
10824     char *arguments[] = {
10825       arguments_0,
10826       arguments_1,
10827       NULL
10828     };
10829     char **r;
10830     int i;
10831     suppress_error = 0;
10832     r = guestfs_command_lines (g, arguments);
10833     if (r == NULL)
10834       return -1;
10835     if (!r[0]) {
10836       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10837       print_strings (r);
10838       return -1;
10839     }
10840     {
10841       char expected[] = "Result10-1";
10842       if (strcmp (r[0], expected) != 0) {
10843         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10844         return -1;
10845       }
10846     }
10847     if (!r[1]) {
10848       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10849       print_strings (r);
10850       return -1;
10851     }
10852     {
10853       char expected[] = "Result10-2";
10854       if (strcmp (r[1], expected) != 0) {
10855         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10856         return -1;
10857       }
10858     }
10859     if (r[2] != NULL) {
10860       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
10861       print_strings (r);
10862       return -1;
10863     }
10864     for (i = 0; r[i] != NULL; ++i)
10865       free (r[i]);
10866     free (r);
10867   }
10868   return 0;
10869 }
10870
10871 static int test_command_lines_10_skip (void)
10872 {
10873   const char *str;
10874
10875   str = getenv ("TEST_ONLY");
10876   if (str)
10877     return strstr (str, "command_lines") == NULL;
10878   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
10879   if (str && strcmp (str, "1") == 0) return 1;
10880   str = getenv ("SKIP_TEST_COMMAND_LINES");
10881   if (str && strcmp (str, "1") == 0) return 1;
10882   return 0;
10883 }
10884
10885 static int test_command_lines_10 (void)
10886 {
10887   if (test_command_lines_10_skip ()) {
10888     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
10889     return 0;
10890   }
10891
10892   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
10893   {
10894     char device[] = "/dev/sda";
10895     int r;
10896     suppress_error = 0;
10897     r = guestfs_blockdev_setrw (g, device);
10898     if (r == -1)
10899       return -1;
10900   }
10901   {
10902     int r;
10903     suppress_error = 0;
10904     r = guestfs_umount_all (g);
10905     if (r == -1)
10906       return -1;
10907   }
10908   {
10909     int r;
10910     suppress_error = 0;
10911     r = guestfs_lvm_remove_all (g);
10912     if (r == -1)
10913       return -1;
10914   }
10915   {
10916     char device[] = "/dev/sda";
10917     char lines_0[] = ",";
10918     char *lines[] = {
10919       lines_0,
10920       NULL
10921     };
10922     int r;
10923     suppress_error = 0;
10924     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10925     if (r == -1)
10926       return -1;
10927   }
10928   {
10929     char fstype[] = "ext2";
10930     char device[] = "/dev/sda1";
10931     int r;
10932     suppress_error = 0;
10933     r = guestfs_mkfs (g, fstype, device);
10934     if (r == -1)
10935       return -1;
10936   }
10937   {
10938     char device[] = "/dev/sda1";
10939     char mountpoint[] = "/";
10940     int r;
10941     suppress_error = 0;
10942     r = guestfs_mount (g, device, mountpoint);
10943     if (r == -1)
10944       return -1;
10945   }
10946   /* TestOutputList for command_lines (10) */
10947   {
10948     char remotefilename[] = "/test-command";
10949     int r;
10950     suppress_error = 0;
10951     r = guestfs_upload (g, "test-command", remotefilename);
10952     if (r == -1)
10953       return -1;
10954   }
10955   {
10956     char path[] = "/test-command";
10957     int r;
10958     suppress_error = 0;
10959     r = guestfs_chmod (g, 493, path);
10960     if (r == -1)
10961       return -1;
10962   }
10963   {
10964     char arguments_0[] = "/test-command";
10965     char arguments_1[] = "11";
10966     char *arguments[] = {
10967       arguments_0,
10968       arguments_1,
10969       NULL
10970     };
10971     char **r;
10972     int i;
10973     suppress_error = 0;
10974     r = guestfs_command_lines (g, arguments);
10975     if (r == NULL)
10976       return -1;
10977     if (!r[0]) {
10978       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10979       print_strings (r);
10980       return -1;
10981     }
10982     {
10983       char expected[] = "Result11-1";
10984       if (strcmp (r[0], expected) != 0) {
10985         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10986         return -1;
10987       }
10988     }
10989     if (!r[1]) {
10990       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10991       print_strings (r);
10992       return -1;
10993     }
10994     {
10995       char expected[] = "Result11-2";
10996       if (strcmp (r[1], expected) != 0) {
10997         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10998         return -1;
10999       }
11000     }
11001     if (r[2] != NULL) {
11002       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11003       print_strings (r);
11004       return -1;
11005     }
11006     for (i = 0; r[i] != NULL; ++i)
11007       free (r[i]);
11008     free (r);
11009   }
11010   return 0;
11011 }
11012
11013 static int test_command_0_skip (void)
11014 {
11015   const char *str;
11016
11017   str = getenv ("TEST_ONLY");
11018   if (str)
11019     return strstr (str, "command") == NULL;
11020   str = getenv ("SKIP_TEST_COMMAND_0");
11021   if (str && strcmp (str, "1") == 0) return 1;
11022   str = getenv ("SKIP_TEST_COMMAND");
11023   if (str && strcmp (str, "1") == 0) return 1;
11024   return 0;
11025 }
11026
11027 static int test_command_0 (void)
11028 {
11029   if (test_command_0_skip ()) {
11030     printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11031     return 0;
11032   }
11033
11034   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11035   {
11036     char device[] = "/dev/sda";
11037     int r;
11038     suppress_error = 0;
11039     r = guestfs_blockdev_setrw (g, device);
11040     if (r == -1)
11041       return -1;
11042   }
11043   {
11044     int r;
11045     suppress_error = 0;
11046     r = guestfs_umount_all (g);
11047     if (r == -1)
11048       return -1;
11049   }
11050   {
11051     int r;
11052     suppress_error = 0;
11053     r = guestfs_lvm_remove_all (g);
11054     if (r == -1)
11055       return -1;
11056   }
11057   {
11058     char device[] = "/dev/sda";
11059     char lines_0[] = ",";
11060     char *lines[] = {
11061       lines_0,
11062       NULL
11063     };
11064     int r;
11065     suppress_error = 0;
11066     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11067     if (r == -1)
11068       return -1;
11069   }
11070   {
11071     char fstype[] = "ext2";
11072     char device[] = "/dev/sda1";
11073     int r;
11074     suppress_error = 0;
11075     r = guestfs_mkfs (g, fstype, device);
11076     if (r == -1)
11077       return -1;
11078   }
11079   {
11080     char device[] = "/dev/sda1";
11081     char mountpoint[] = "/";
11082     int r;
11083     suppress_error = 0;
11084     r = guestfs_mount (g, device, mountpoint);
11085     if (r == -1)
11086       return -1;
11087   }
11088   /* TestOutput for command (0) */
11089   char expected[] = "Result1";
11090   {
11091     char remotefilename[] = "/test-command";
11092     int r;
11093     suppress_error = 0;
11094     r = guestfs_upload (g, "test-command", remotefilename);
11095     if (r == -1)
11096       return -1;
11097   }
11098   {
11099     char path[] = "/test-command";
11100     int r;
11101     suppress_error = 0;
11102     r = guestfs_chmod (g, 493, path);
11103     if (r == -1)
11104       return -1;
11105   }
11106   {
11107     char arguments_0[] = "/test-command";
11108     char arguments_1[] = "1";
11109     char *arguments[] = {
11110       arguments_0,
11111       arguments_1,
11112       NULL
11113     };
11114     char *r;
11115     suppress_error = 0;
11116     r = guestfs_command (g, arguments);
11117     if (r == NULL)
11118       return -1;
11119     if (strcmp (r, expected) != 0) {
11120       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11121       return -1;
11122     }
11123     free (r);
11124   }
11125   return 0;
11126 }
11127
11128 static int test_command_1_skip (void)
11129 {
11130   const char *str;
11131
11132   str = getenv ("TEST_ONLY");
11133   if (str)
11134     return strstr (str, "command") == NULL;
11135   str = getenv ("SKIP_TEST_COMMAND_1");
11136   if (str && strcmp (str, "1") == 0) return 1;
11137   str = getenv ("SKIP_TEST_COMMAND");
11138   if (str && strcmp (str, "1") == 0) return 1;
11139   return 0;
11140 }
11141
11142 static int test_command_1 (void)
11143 {
11144   if (test_command_1_skip ()) {
11145     printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11146     return 0;
11147   }
11148
11149   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11150   {
11151     char device[] = "/dev/sda";
11152     int r;
11153     suppress_error = 0;
11154     r = guestfs_blockdev_setrw (g, device);
11155     if (r == -1)
11156       return -1;
11157   }
11158   {
11159     int r;
11160     suppress_error = 0;
11161     r = guestfs_umount_all (g);
11162     if (r == -1)
11163       return -1;
11164   }
11165   {
11166     int r;
11167     suppress_error = 0;
11168     r = guestfs_lvm_remove_all (g);
11169     if (r == -1)
11170       return -1;
11171   }
11172   {
11173     char device[] = "/dev/sda";
11174     char lines_0[] = ",";
11175     char *lines[] = {
11176       lines_0,
11177       NULL
11178     };
11179     int r;
11180     suppress_error = 0;
11181     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11182     if (r == -1)
11183       return -1;
11184   }
11185   {
11186     char fstype[] = "ext2";
11187     char device[] = "/dev/sda1";
11188     int r;
11189     suppress_error = 0;
11190     r = guestfs_mkfs (g, fstype, device);
11191     if (r == -1)
11192       return -1;
11193   }
11194   {
11195     char device[] = "/dev/sda1";
11196     char mountpoint[] = "/";
11197     int r;
11198     suppress_error = 0;
11199     r = guestfs_mount (g, device, mountpoint);
11200     if (r == -1)
11201       return -1;
11202   }
11203   /* TestOutput for command (1) */
11204   char expected[] = "Result2\n";
11205   {
11206     char remotefilename[] = "/test-command";
11207     int r;
11208     suppress_error = 0;
11209     r = guestfs_upload (g, "test-command", remotefilename);
11210     if (r == -1)
11211       return -1;
11212   }
11213   {
11214     char path[] = "/test-command";
11215     int r;
11216     suppress_error = 0;
11217     r = guestfs_chmod (g, 493, path);
11218     if (r == -1)
11219       return -1;
11220   }
11221   {
11222     char arguments_0[] = "/test-command";
11223     char arguments_1[] = "2";
11224     char *arguments[] = {
11225       arguments_0,
11226       arguments_1,
11227       NULL
11228     };
11229     char *r;
11230     suppress_error = 0;
11231     r = guestfs_command (g, arguments);
11232     if (r == NULL)
11233       return -1;
11234     if (strcmp (r, expected) != 0) {
11235       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11236       return -1;
11237     }
11238     free (r);
11239   }
11240   return 0;
11241 }
11242
11243 static int test_command_2_skip (void)
11244 {
11245   const char *str;
11246
11247   str = getenv ("TEST_ONLY");
11248   if (str)
11249     return strstr (str, "command") == NULL;
11250   str = getenv ("SKIP_TEST_COMMAND_2");
11251   if (str && strcmp (str, "1") == 0) return 1;
11252   str = getenv ("SKIP_TEST_COMMAND");
11253   if (str && strcmp (str, "1") == 0) return 1;
11254   return 0;
11255 }
11256
11257 static int test_command_2 (void)
11258 {
11259   if (test_command_2_skip ()) {
11260     printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11261     return 0;
11262   }
11263
11264   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11265   {
11266     char device[] = "/dev/sda";
11267     int r;
11268     suppress_error = 0;
11269     r = guestfs_blockdev_setrw (g, device);
11270     if (r == -1)
11271       return -1;
11272   }
11273   {
11274     int r;
11275     suppress_error = 0;
11276     r = guestfs_umount_all (g);
11277     if (r == -1)
11278       return -1;
11279   }
11280   {
11281     int r;
11282     suppress_error = 0;
11283     r = guestfs_lvm_remove_all (g);
11284     if (r == -1)
11285       return -1;
11286   }
11287   {
11288     char device[] = "/dev/sda";
11289     char lines_0[] = ",";
11290     char *lines[] = {
11291       lines_0,
11292       NULL
11293     };
11294     int r;
11295     suppress_error = 0;
11296     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11297     if (r == -1)
11298       return -1;
11299   }
11300   {
11301     char fstype[] = "ext2";
11302     char device[] = "/dev/sda1";
11303     int r;
11304     suppress_error = 0;
11305     r = guestfs_mkfs (g, fstype, device);
11306     if (r == -1)
11307       return -1;
11308   }
11309   {
11310     char device[] = "/dev/sda1";
11311     char mountpoint[] = "/";
11312     int r;
11313     suppress_error = 0;
11314     r = guestfs_mount (g, device, mountpoint);
11315     if (r == -1)
11316       return -1;
11317   }
11318   /* TestOutput for command (2) */
11319   char expected[] = "\nResult3";
11320   {
11321     char remotefilename[] = "/test-command";
11322     int r;
11323     suppress_error = 0;
11324     r = guestfs_upload (g, "test-command", remotefilename);
11325     if (r == -1)
11326       return -1;
11327   }
11328   {
11329     char path[] = "/test-command";
11330     int r;
11331     suppress_error = 0;
11332     r = guestfs_chmod (g, 493, path);
11333     if (r == -1)
11334       return -1;
11335   }
11336   {
11337     char arguments_0[] = "/test-command";
11338     char arguments_1[] = "3";
11339     char *arguments[] = {
11340       arguments_0,
11341       arguments_1,
11342       NULL
11343     };
11344     char *r;
11345     suppress_error = 0;
11346     r = guestfs_command (g, arguments);
11347     if (r == NULL)
11348       return -1;
11349     if (strcmp (r, expected) != 0) {
11350       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11351       return -1;
11352     }
11353     free (r);
11354   }
11355   return 0;
11356 }
11357
11358 static int test_command_3_skip (void)
11359 {
11360   const char *str;
11361
11362   str = getenv ("TEST_ONLY");
11363   if (str)
11364     return strstr (str, "command") == NULL;
11365   str = getenv ("SKIP_TEST_COMMAND_3");
11366   if (str && strcmp (str, "1") == 0) return 1;
11367   str = getenv ("SKIP_TEST_COMMAND");
11368   if (str && strcmp (str, "1") == 0) return 1;
11369   return 0;
11370 }
11371
11372 static int test_command_3 (void)
11373 {
11374   if (test_command_3_skip ()) {
11375     printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11376     return 0;
11377   }
11378
11379   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11380   {
11381     char device[] = "/dev/sda";
11382     int r;
11383     suppress_error = 0;
11384     r = guestfs_blockdev_setrw (g, device);
11385     if (r == -1)
11386       return -1;
11387   }
11388   {
11389     int r;
11390     suppress_error = 0;
11391     r = guestfs_umount_all (g);
11392     if (r == -1)
11393       return -1;
11394   }
11395   {
11396     int r;
11397     suppress_error = 0;
11398     r = guestfs_lvm_remove_all (g);
11399     if (r == -1)
11400       return -1;
11401   }
11402   {
11403     char device[] = "/dev/sda";
11404     char lines_0[] = ",";
11405     char *lines[] = {
11406       lines_0,
11407       NULL
11408     };
11409     int r;
11410     suppress_error = 0;
11411     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11412     if (r == -1)
11413       return -1;
11414   }
11415   {
11416     char fstype[] = "ext2";
11417     char device[] = "/dev/sda1";
11418     int r;
11419     suppress_error = 0;
11420     r = guestfs_mkfs (g, fstype, device);
11421     if (r == -1)
11422       return -1;
11423   }
11424   {
11425     char device[] = "/dev/sda1";
11426     char mountpoint[] = "/";
11427     int r;
11428     suppress_error = 0;
11429     r = guestfs_mount (g, device, mountpoint);
11430     if (r == -1)
11431       return -1;
11432   }
11433   /* TestOutput for command (3) */
11434   char expected[] = "\nResult4\n";
11435   {
11436     char remotefilename[] = "/test-command";
11437     int r;
11438     suppress_error = 0;
11439     r = guestfs_upload (g, "test-command", remotefilename);
11440     if (r == -1)
11441       return -1;
11442   }
11443   {
11444     char path[] = "/test-command";
11445     int r;
11446     suppress_error = 0;
11447     r = guestfs_chmod (g, 493, path);
11448     if (r == -1)
11449       return -1;
11450   }
11451   {
11452     char arguments_0[] = "/test-command";
11453     char arguments_1[] = "4";
11454     char *arguments[] = {
11455       arguments_0,
11456       arguments_1,
11457       NULL
11458     };
11459     char *r;
11460     suppress_error = 0;
11461     r = guestfs_command (g, arguments);
11462     if (r == NULL)
11463       return -1;
11464     if (strcmp (r, expected) != 0) {
11465       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11466       return -1;
11467     }
11468     free (r);
11469   }
11470   return 0;
11471 }
11472
11473 static int test_command_4_skip (void)
11474 {
11475   const char *str;
11476
11477   str = getenv ("TEST_ONLY");
11478   if (str)
11479     return strstr (str, "command") == NULL;
11480   str = getenv ("SKIP_TEST_COMMAND_4");
11481   if (str && strcmp (str, "1") == 0) return 1;
11482   str = getenv ("SKIP_TEST_COMMAND");
11483   if (str && strcmp (str, "1") == 0) return 1;
11484   return 0;
11485 }
11486
11487 static int test_command_4 (void)
11488 {
11489   if (test_command_4_skip ()) {
11490     printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11491     return 0;
11492   }
11493
11494   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11495   {
11496     char device[] = "/dev/sda";
11497     int r;
11498     suppress_error = 0;
11499     r = guestfs_blockdev_setrw (g, device);
11500     if (r == -1)
11501       return -1;
11502   }
11503   {
11504     int r;
11505     suppress_error = 0;
11506     r = guestfs_umount_all (g);
11507     if (r == -1)
11508       return -1;
11509   }
11510   {
11511     int r;
11512     suppress_error = 0;
11513     r = guestfs_lvm_remove_all (g);
11514     if (r == -1)
11515       return -1;
11516   }
11517   {
11518     char device[] = "/dev/sda";
11519     char lines_0[] = ",";
11520     char *lines[] = {
11521       lines_0,
11522       NULL
11523     };
11524     int r;
11525     suppress_error = 0;
11526     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11527     if (r == -1)
11528       return -1;
11529   }
11530   {
11531     char fstype[] = "ext2";
11532     char device[] = "/dev/sda1";
11533     int r;
11534     suppress_error = 0;
11535     r = guestfs_mkfs (g, fstype, device);
11536     if (r == -1)
11537       return -1;
11538   }
11539   {
11540     char device[] = "/dev/sda1";
11541     char mountpoint[] = "/";
11542     int r;
11543     suppress_error = 0;
11544     r = guestfs_mount (g, device, mountpoint);
11545     if (r == -1)
11546       return -1;
11547   }
11548   /* TestOutput for command (4) */
11549   char expected[] = "\nResult5\n\n";
11550   {
11551     char remotefilename[] = "/test-command";
11552     int r;
11553     suppress_error = 0;
11554     r = guestfs_upload (g, "test-command", remotefilename);
11555     if (r == -1)
11556       return -1;
11557   }
11558   {
11559     char path[] = "/test-command";
11560     int r;
11561     suppress_error = 0;
11562     r = guestfs_chmod (g, 493, path);
11563     if (r == -1)
11564       return -1;
11565   }
11566   {
11567     char arguments_0[] = "/test-command";
11568     char arguments_1[] = "5";
11569     char *arguments[] = {
11570       arguments_0,
11571       arguments_1,
11572       NULL
11573     };
11574     char *r;
11575     suppress_error = 0;
11576     r = guestfs_command (g, arguments);
11577     if (r == NULL)
11578       return -1;
11579     if (strcmp (r, expected) != 0) {
11580       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11581       return -1;
11582     }
11583     free (r);
11584   }
11585   return 0;
11586 }
11587
11588 static int test_command_5_skip (void)
11589 {
11590   const char *str;
11591
11592   str = getenv ("TEST_ONLY");
11593   if (str)
11594     return strstr (str, "command") == NULL;
11595   str = getenv ("SKIP_TEST_COMMAND_5");
11596   if (str && strcmp (str, "1") == 0) return 1;
11597   str = getenv ("SKIP_TEST_COMMAND");
11598   if (str && strcmp (str, "1") == 0) return 1;
11599   return 0;
11600 }
11601
11602 static int test_command_5 (void)
11603 {
11604   if (test_command_5_skip ()) {
11605     printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11606     return 0;
11607   }
11608
11609   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11610   {
11611     char device[] = "/dev/sda";
11612     int r;
11613     suppress_error = 0;
11614     r = guestfs_blockdev_setrw (g, device);
11615     if (r == -1)
11616       return -1;
11617   }
11618   {
11619     int r;
11620     suppress_error = 0;
11621     r = guestfs_umount_all (g);
11622     if (r == -1)
11623       return -1;
11624   }
11625   {
11626     int r;
11627     suppress_error = 0;
11628     r = guestfs_lvm_remove_all (g);
11629     if (r == -1)
11630       return -1;
11631   }
11632   {
11633     char device[] = "/dev/sda";
11634     char lines_0[] = ",";
11635     char *lines[] = {
11636       lines_0,
11637       NULL
11638     };
11639     int r;
11640     suppress_error = 0;
11641     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11642     if (r == -1)
11643       return -1;
11644   }
11645   {
11646     char fstype[] = "ext2";
11647     char device[] = "/dev/sda1";
11648     int r;
11649     suppress_error = 0;
11650     r = guestfs_mkfs (g, fstype, device);
11651     if (r == -1)
11652       return -1;
11653   }
11654   {
11655     char device[] = "/dev/sda1";
11656     char mountpoint[] = "/";
11657     int r;
11658     suppress_error = 0;
11659     r = guestfs_mount (g, device, mountpoint);
11660     if (r == -1)
11661       return -1;
11662   }
11663   /* TestOutput for command (5) */
11664   char expected[] = "\n\nResult6\n\n";
11665   {
11666     char remotefilename[] = "/test-command";
11667     int r;
11668     suppress_error = 0;
11669     r = guestfs_upload (g, "test-command", remotefilename);
11670     if (r == -1)
11671       return -1;
11672   }
11673   {
11674     char path[] = "/test-command";
11675     int r;
11676     suppress_error = 0;
11677     r = guestfs_chmod (g, 493, path);
11678     if (r == -1)
11679       return -1;
11680   }
11681   {
11682     char arguments_0[] = "/test-command";
11683     char arguments_1[] = "6";
11684     char *arguments[] = {
11685       arguments_0,
11686       arguments_1,
11687       NULL
11688     };
11689     char *r;
11690     suppress_error = 0;
11691     r = guestfs_command (g, arguments);
11692     if (r == NULL)
11693       return -1;
11694     if (strcmp (r, expected) != 0) {
11695       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
11696       return -1;
11697     }
11698     free (r);
11699   }
11700   return 0;
11701 }
11702
11703 static int test_command_6_skip (void)
11704 {
11705   const char *str;
11706
11707   str = getenv ("TEST_ONLY");
11708   if (str)
11709     return strstr (str, "command") == NULL;
11710   str = getenv ("SKIP_TEST_COMMAND_6");
11711   if (str && strcmp (str, "1") == 0) return 1;
11712   str = getenv ("SKIP_TEST_COMMAND");
11713   if (str && strcmp (str, "1") == 0) return 1;
11714   return 0;
11715 }
11716
11717 static int test_command_6 (void)
11718 {
11719   if (test_command_6_skip ()) {
11720     printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
11721     return 0;
11722   }
11723
11724   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
11725   {
11726     char device[] = "/dev/sda";
11727     int r;
11728     suppress_error = 0;
11729     r = guestfs_blockdev_setrw (g, device);
11730     if (r == -1)
11731       return -1;
11732   }
11733   {
11734     int r;
11735     suppress_error = 0;
11736     r = guestfs_umount_all (g);
11737     if (r == -1)
11738       return -1;
11739   }
11740   {
11741     int r;
11742     suppress_error = 0;
11743     r = guestfs_lvm_remove_all (g);
11744     if (r == -1)
11745       return -1;
11746   }
11747   {
11748     char device[] = "/dev/sda";
11749     char lines_0[] = ",";
11750     char *lines[] = {
11751       lines_0,
11752       NULL
11753     };
11754     int r;
11755     suppress_error = 0;
11756     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11757     if (r == -1)
11758       return -1;
11759   }
11760   {
11761     char fstype[] = "ext2";
11762     char device[] = "/dev/sda1";
11763     int r;
11764     suppress_error = 0;
11765     r = guestfs_mkfs (g, fstype, device);
11766     if (r == -1)
11767       return -1;
11768   }
11769   {
11770     char device[] = "/dev/sda1";
11771     char mountpoint[] = "/";
11772     int r;
11773     suppress_error = 0;
11774     r = guestfs_mount (g, device, mountpoint);
11775     if (r == -1)
11776       return -1;
11777   }
11778   /* TestOutput for command (6) */
11779   char expected[] = "";
11780   {
11781     char remotefilename[] = "/test-command";
11782     int r;
11783     suppress_error = 0;
11784     r = guestfs_upload (g, "test-command", remotefilename);
11785     if (r == -1)
11786       return -1;
11787   }
11788   {
11789     char path[] = "/test-command";
11790     int r;
11791     suppress_error = 0;
11792     r = guestfs_chmod (g, 493, path);
11793     if (r == -1)
11794       return -1;
11795   }
11796   {
11797     char arguments_0[] = "/test-command";
11798     char arguments_1[] = "7";
11799     char *arguments[] = {
11800       arguments_0,
11801       arguments_1,
11802       NULL
11803     };
11804     char *r;
11805     suppress_error = 0;
11806     r = guestfs_command (g, arguments);
11807     if (r == NULL)
11808       return -1;
11809     if (strcmp (r, expected) != 0) {
11810       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
11811       return -1;
11812     }
11813     free (r);
11814   }
11815   return 0;
11816 }
11817
11818 static int test_command_7_skip (void)
11819 {
11820   const char *str;
11821
11822   str = getenv ("TEST_ONLY");
11823   if (str)
11824     return strstr (str, "command") == NULL;
11825   str = getenv ("SKIP_TEST_COMMAND_7");
11826   if (str && strcmp (str, "1") == 0) return 1;
11827   str = getenv ("SKIP_TEST_COMMAND");
11828   if (str && strcmp (str, "1") == 0) return 1;
11829   return 0;
11830 }
11831
11832 static int test_command_7 (void)
11833 {
11834   if (test_command_7_skip ()) {
11835     printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
11836     return 0;
11837   }
11838
11839   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
11840   {
11841     char device[] = "/dev/sda";
11842     int r;
11843     suppress_error = 0;
11844     r = guestfs_blockdev_setrw (g, device);
11845     if (r == -1)
11846       return -1;
11847   }
11848   {
11849     int r;
11850     suppress_error = 0;
11851     r = guestfs_umount_all (g);
11852     if (r == -1)
11853       return -1;
11854   }
11855   {
11856     int r;
11857     suppress_error = 0;
11858     r = guestfs_lvm_remove_all (g);
11859     if (r == -1)
11860       return -1;
11861   }
11862   {
11863     char device[] = "/dev/sda";
11864     char lines_0[] = ",";
11865     char *lines[] = {
11866       lines_0,
11867       NULL
11868     };
11869     int r;
11870     suppress_error = 0;
11871     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11872     if (r == -1)
11873       return -1;
11874   }
11875   {
11876     char fstype[] = "ext2";
11877     char device[] = "/dev/sda1";
11878     int r;
11879     suppress_error = 0;
11880     r = guestfs_mkfs (g, fstype, device);
11881     if (r == -1)
11882       return -1;
11883   }
11884   {
11885     char device[] = "/dev/sda1";
11886     char mountpoint[] = "/";
11887     int r;
11888     suppress_error = 0;
11889     r = guestfs_mount (g, device, mountpoint);
11890     if (r == -1)
11891       return -1;
11892   }
11893   /* TestOutput for command (7) */
11894   char expected[] = "\n";
11895   {
11896     char remotefilename[] = "/test-command";
11897     int r;
11898     suppress_error = 0;
11899     r = guestfs_upload (g, "test-command", remotefilename);
11900     if (r == -1)
11901       return -1;
11902   }
11903   {
11904     char path[] = "/test-command";
11905     int r;
11906     suppress_error = 0;
11907     r = guestfs_chmod (g, 493, path);
11908     if (r == -1)
11909       return -1;
11910   }
11911   {
11912     char arguments_0[] = "/test-command";
11913     char arguments_1[] = "8";
11914     char *arguments[] = {
11915       arguments_0,
11916       arguments_1,
11917       NULL
11918     };
11919     char *r;
11920     suppress_error = 0;
11921     r = guestfs_command (g, arguments);
11922     if (r == NULL)
11923       return -1;
11924     if (strcmp (r, expected) != 0) {
11925       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
11926       return -1;
11927     }
11928     free (r);
11929   }
11930   return 0;
11931 }
11932
11933 static int test_command_8_skip (void)
11934 {
11935   const char *str;
11936
11937   str = getenv ("TEST_ONLY");
11938   if (str)
11939     return strstr (str, "command") == NULL;
11940   str = getenv ("SKIP_TEST_COMMAND_8");
11941   if (str && strcmp (str, "1") == 0) return 1;
11942   str = getenv ("SKIP_TEST_COMMAND");
11943   if (str && strcmp (str, "1") == 0) return 1;
11944   return 0;
11945 }
11946
11947 static int test_command_8 (void)
11948 {
11949   if (test_command_8_skip ()) {
11950     printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
11951     return 0;
11952   }
11953
11954   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
11955   {
11956     char device[] = "/dev/sda";
11957     int r;
11958     suppress_error = 0;
11959     r = guestfs_blockdev_setrw (g, device);
11960     if (r == -1)
11961       return -1;
11962   }
11963   {
11964     int r;
11965     suppress_error = 0;
11966     r = guestfs_umount_all (g);
11967     if (r == -1)
11968       return -1;
11969   }
11970   {
11971     int r;
11972     suppress_error = 0;
11973     r = guestfs_lvm_remove_all (g);
11974     if (r == -1)
11975       return -1;
11976   }
11977   {
11978     char device[] = "/dev/sda";
11979     char lines_0[] = ",";
11980     char *lines[] = {
11981       lines_0,
11982       NULL
11983     };
11984     int r;
11985     suppress_error = 0;
11986     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11987     if (r == -1)
11988       return -1;
11989   }
11990   {
11991     char fstype[] = "ext2";
11992     char device[] = "/dev/sda1";
11993     int r;
11994     suppress_error = 0;
11995     r = guestfs_mkfs (g, fstype, device);
11996     if (r == -1)
11997       return -1;
11998   }
11999   {
12000     char device[] = "/dev/sda1";
12001     char mountpoint[] = "/";
12002     int r;
12003     suppress_error = 0;
12004     r = guestfs_mount (g, device, mountpoint);
12005     if (r == -1)
12006       return -1;
12007   }
12008   /* TestOutput for command (8) */
12009   char expected[] = "\n\n";
12010   {
12011     char remotefilename[] = "/test-command";
12012     int r;
12013     suppress_error = 0;
12014     r = guestfs_upload (g, "test-command", remotefilename);
12015     if (r == -1)
12016       return -1;
12017   }
12018   {
12019     char path[] = "/test-command";
12020     int r;
12021     suppress_error = 0;
12022     r = guestfs_chmod (g, 493, path);
12023     if (r == -1)
12024       return -1;
12025   }
12026   {
12027     char arguments_0[] = "/test-command";
12028     char arguments_1[] = "9";
12029     char *arguments[] = {
12030       arguments_0,
12031       arguments_1,
12032       NULL
12033     };
12034     char *r;
12035     suppress_error = 0;
12036     r = guestfs_command (g, arguments);
12037     if (r == NULL)
12038       return -1;
12039     if (strcmp (r, expected) != 0) {
12040       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12041       return -1;
12042     }
12043     free (r);
12044   }
12045   return 0;
12046 }
12047
12048 static int test_command_9_skip (void)
12049 {
12050   const char *str;
12051
12052   str = getenv ("TEST_ONLY");
12053   if (str)
12054     return strstr (str, "command") == NULL;
12055   str = getenv ("SKIP_TEST_COMMAND_9");
12056   if (str && strcmp (str, "1") == 0) return 1;
12057   str = getenv ("SKIP_TEST_COMMAND");
12058   if (str && strcmp (str, "1") == 0) return 1;
12059   return 0;
12060 }
12061
12062 static int test_command_9 (void)
12063 {
12064   if (test_command_9_skip ()) {
12065     printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12066     return 0;
12067   }
12068
12069   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12070   {
12071     char device[] = "/dev/sda";
12072     int r;
12073     suppress_error = 0;
12074     r = guestfs_blockdev_setrw (g, device);
12075     if (r == -1)
12076       return -1;
12077   }
12078   {
12079     int r;
12080     suppress_error = 0;
12081     r = guestfs_umount_all (g);
12082     if (r == -1)
12083       return -1;
12084   }
12085   {
12086     int r;
12087     suppress_error = 0;
12088     r = guestfs_lvm_remove_all (g);
12089     if (r == -1)
12090       return -1;
12091   }
12092   {
12093     char device[] = "/dev/sda";
12094     char lines_0[] = ",";
12095     char *lines[] = {
12096       lines_0,
12097       NULL
12098     };
12099     int r;
12100     suppress_error = 0;
12101     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12102     if (r == -1)
12103       return -1;
12104   }
12105   {
12106     char fstype[] = "ext2";
12107     char device[] = "/dev/sda1";
12108     int r;
12109     suppress_error = 0;
12110     r = guestfs_mkfs (g, fstype, device);
12111     if (r == -1)
12112       return -1;
12113   }
12114   {
12115     char device[] = "/dev/sda1";
12116     char mountpoint[] = "/";
12117     int r;
12118     suppress_error = 0;
12119     r = guestfs_mount (g, device, mountpoint);
12120     if (r == -1)
12121       return -1;
12122   }
12123   /* TestOutput for command (9) */
12124   char expected[] = "Result10-1\nResult10-2\n";
12125   {
12126     char remotefilename[] = "/test-command";
12127     int r;
12128     suppress_error = 0;
12129     r = guestfs_upload (g, "test-command", remotefilename);
12130     if (r == -1)
12131       return -1;
12132   }
12133   {
12134     char path[] = "/test-command";
12135     int r;
12136     suppress_error = 0;
12137     r = guestfs_chmod (g, 493, path);
12138     if (r == -1)
12139       return -1;
12140   }
12141   {
12142     char arguments_0[] = "/test-command";
12143     char arguments_1[] = "10";
12144     char *arguments[] = {
12145       arguments_0,
12146       arguments_1,
12147       NULL
12148     };
12149     char *r;
12150     suppress_error = 0;
12151     r = guestfs_command (g, arguments);
12152     if (r == NULL)
12153       return -1;
12154     if (strcmp (r, expected) != 0) {
12155       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12156       return -1;
12157     }
12158     free (r);
12159   }
12160   return 0;
12161 }
12162
12163 static int test_command_10_skip (void)
12164 {
12165   const char *str;
12166
12167   str = getenv ("TEST_ONLY");
12168   if (str)
12169     return strstr (str, "command") == NULL;
12170   str = getenv ("SKIP_TEST_COMMAND_10");
12171   if (str && strcmp (str, "1") == 0) return 1;
12172   str = getenv ("SKIP_TEST_COMMAND");
12173   if (str && strcmp (str, "1") == 0) return 1;
12174   return 0;
12175 }
12176
12177 static int test_command_10 (void)
12178 {
12179   if (test_command_10_skip ()) {
12180     printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12181     return 0;
12182   }
12183
12184   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12185   {
12186     char device[] = "/dev/sda";
12187     int r;
12188     suppress_error = 0;
12189     r = guestfs_blockdev_setrw (g, device);
12190     if (r == -1)
12191       return -1;
12192   }
12193   {
12194     int r;
12195     suppress_error = 0;
12196     r = guestfs_umount_all (g);
12197     if (r == -1)
12198       return -1;
12199   }
12200   {
12201     int r;
12202     suppress_error = 0;
12203     r = guestfs_lvm_remove_all (g);
12204     if (r == -1)
12205       return -1;
12206   }
12207   {
12208     char device[] = "/dev/sda";
12209     char lines_0[] = ",";
12210     char *lines[] = {
12211       lines_0,
12212       NULL
12213     };
12214     int r;
12215     suppress_error = 0;
12216     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12217     if (r == -1)
12218       return -1;
12219   }
12220   {
12221     char fstype[] = "ext2";
12222     char device[] = "/dev/sda1";
12223     int r;
12224     suppress_error = 0;
12225     r = guestfs_mkfs (g, fstype, device);
12226     if (r == -1)
12227       return -1;
12228   }
12229   {
12230     char device[] = "/dev/sda1";
12231     char mountpoint[] = "/";
12232     int r;
12233     suppress_error = 0;
12234     r = guestfs_mount (g, device, mountpoint);
12235     if (r == -1)
12236       return -1;
12237   }
12238   /* TestOutput for command (10) */
12239   char expected[] = "Result11-1\nResult11-2";
12240   {
12241     char remotefilename[] = "/test-command";
12242     int r;
12243     suppress_error = 0;
12244     r = guestfs_upload (g, "test-command", remotefilename);
12245     if (r == -1)
12246       return -1;
12247   }
12248   {
12249     char path[] = "/test-command";
12250     int r;
12251     suppress_error = 0;
12252     r = guestfs_chmod (g, 493, path);
12253     if (r == -1)
12254       return -1;
12255   }
12256   {
12257     char arguments_0[] = "/test-command";
12258     char arguments_1[] = "11";
12259     char *arguments[] = {
12260       arguments_0,
12261       arguments_1,
12262       NULL
12263     };
12264     char *r;
12265     suppress_error = 0;
12266     r = guestfs_command (g, arguments);
12267     if (r == NULL)
12268       return -1;
12269     if (strcmp (r, expected) != 0) {
12270       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12271       return -1;
12272     }
12273     free (r);
12274   }
12275   return 0;
12276 }
12277
12278 static int test_command_11_skip (void)
12279 {
12280   const char *str;
12281
12282   str = getenv ("TEST_ONLY");
12283   if (str)
12284     return strstr (str, "command") == NULL;
12285   str = getenv ("SKIP_TEST_COMMAND_11");
12286   if (str && strcmp (str, "1") == 0) return 1;
12287   str = getenv ("SKIP_TEST_COMMAND");
12288   if (str && strcmp (str, "1") == 0) return 1;
12289   return 0;
12290 }
12291
12292 static int test_command_11 (void)
12293 {
12294   if (test_command_11_skip ()) {
12295     printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12296     return 0;
12297   }
12298
12299   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12300   {
12301     char device[] = "/dev/sda";
12302     int r;
12303     suppress_error = 0;
12304     r = guestfs_blockdev_setrw (g, device);
12305     if (r == -1)
12306       return -1;
12307   }
12308   {
12309     int r;
12310     suppress_error = 0;
12311     r = guestfs_umount_all (g);
12312     if (r == -1)
12313       return -1;
12314   }
12315   {
12316     int r;
12317     suppress_error = 0;
12318     r = guestfs_lvm_remove_all (g);
12319     if (r == -1)
12320       return -1;
12321   }
12322   {
12323     char device[] = "/dev/sda";
12324     char lines_0[] = ",";
12325     char *lines[] = {
12326       lines_0,
12327       NULL
12328     };
12329     int r;
12330     suppress_error = 0;
12331     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12332     if (r == -1)
12333       return -1;
12334   }
12335   {
12336     char fstype[] = "ext2";
12337     char device[] = "/dev/sda1";
12338     int r;
12339     suppress_error = 0;
12340     r = guestfs_mkfs (g, fstype, device);
12341     if (r == -1)
12342       return -1;
12343   }
12344   {
12345     char device[] = "/dev/sda1";
12346     char mountpoint[] = "/";
12347     int r;
12348     suppress_error = 0;
12349     r = guestfs_mount (g, device, mountpoint);
12350     if (r == -1)
12351       return -1;
12352   }
12353   /* TestLastFail for command (11) */
12354   {
12355     char remotefilename[] = "/test-command";
12356     int r;
12357     suppress_error = 0;
12358     r = guestfs_upload (g, "test-command", remotefilename);
12359     if (r == -1)
12360       return -1;
12361   }
12362   {
12363     char path[] = "/test-command";
12364     int r;
12365     suppress_error = 0;
12366     r = guestfs_chmod (g, 493, path);
12367     if (r == -1)
12368       return -1;
12369   }
12370   {
12371     char arguments_0[] = "/test-command";
12372     char *arguments[] = {
12373       arguments_0,
12374       NULL
12375     };
12376     char *r;
12377     suppress_error = 1;
12378     r = guestfs_command (g, arguments);
12379     if (r != NULL)
12380       return -1;
12381     free (r);
12382   }
12383   return 0;
12384 }
12385
12386 static int test_file_0_skip (void)
12387 {
12388   const char *str;
12389
12390   str = getenv ("TEST_ONLY");
12391   if (str)
12392     return strstr (str, "file") == NULL;
12393   str = getenv ("SKIP_TEST_FILE_0");
12394   if (str && strcmp (str, "1") == 0) return 1;
12395   str = getenv ("SKIP_TEST_FILE");
12396   if (str && strcmp (str, "1") == 0) return 1;
12397   return 0;
12398 }
12399
12400 static int test_file_0 (void)
12401 {
12402   if (test_file_0_skip ()) {
12403     printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12404     return 0;
12405   }
12406
12407   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12408   {
12409     char device[] = "/dev/sda";
12410     int r;
12411     suppress_error = 0;
12412     r = guestfs_blockdev_setrw (g, device);
12413     if (r == -1)
12414       return -1;
12415   }
12416   {
12417     int r;
12418     suppress_error = 0;
12419     r = guestfs_umount_all (g);
12420     if (r == -1)
12421       return -1;
12422   }
12423   {
12424     int r;
12425     suppress_error = 0;
12426     r = guestfs_lvm_remove_all (g);
12427     if (r == -1)
12428       return -1;
12429   }
12430   {
12431     char device[] = "/dev/sda";
12432     char lines_0[] = ",";
12433     char *lines[] = {
12434       lines_0,
12435       NULL
12436     };
12437     int r;
12438     suppress_error = 0;
12439     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12440     if (r == -1)
12441       return -1;
12442   }
12443   {
12444     char fstype[] = "ext2";
12445     char device[] = "/dev/sda1";
12446     int r;
12447     suppress_error = 0;
12448     r = guestfs_mkfs (g, fstype, device);
12449     if (r == -1)
12450       return -1;
12451   }
12452   {
12453     char device[] = "/dev/sda1";
12454     char mountpoint[] = "/";
12455     int r;
12456     suppress_error = 0;
12457     r = guestfs_mount (g, device, mountpoint);
12458     if (r == -1)
12459       return -1;
12460   }
12461   /* TestOutput for file (0) */
12462   char expected[] = "empty";
12463   {
12464     char path[] = "/new";
12465     int r;
12466     suppress_error = 0;
12467     r = guestfs_touch (g, path);
12468     if (r == -1)
12469       return -1;
12470   }
12471   {
12472     char path[] = "/new";
12473     char *r;
12474     suppress_error = 0;
12475     r = guestfs_file (g, path);
12476     if (r == NULL)
12477       return -1;
12478     if (strcmp (r, expected) != 0) {
12479       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12480       return -1;
12481     }
12482     free (r);
12483   }
12484   return 0;
12485 }
12486
12487 static int test_file_1_skip (void)
12488 {
12489   const char *str;
12490
12491   str = getenv ("TEST_ONLY");
12492   if (str)
12493     return strstr (str, "file") == NULL;
12494   str = getenv ("SKIP_TEST_FILE_1");
12495   if (str && strcmp (str, "1") == 0) return 1;
12496   str = getenv ("SKIP_TEST_FILE");
12497   if (str && strcmp (str, "1") == 0) return 1;
12498   return 0;
12499 }
12500
12501 static int test_file_1 (void)
12502 {
12503   if (test_file_1_skip ()) {
12504     printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12505     return 0;
12506   }
12507
12508   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12509   {
12510     char device[] = "/dev/sda";
12511     int r;
12512     suppress_error = 0;
12513     r = guestfs_blockdev_setrw (g, device);
12514     if (r == -1)
12515       return -1;
12516   }
12517   {
12518     int r;
12519     suppress_error = 0;
12520     r = guestfs_umount_all (g);
12521     if (r == -1)
12522       return -1;
12523   }
12524   {
12525     int r;
12526     suppress_error = 0;
12527     r = guestfs_lvm_remove_all (g);
12528     if (r == -1)
12529       return -1;
12530   }
12531   {
12532     char device[] = "/dev/sda";
12533     char lines_0[] = ",";
12534     char *lines[] = {
12535       lines_0,
12536       NULL
12537     };
12538     int r;
12539     suppress_error = 0;
12540     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12541     if (r == -1)
12542       return -1;
12543   }
12544   {
12545     char fstype[] = "ext2";
12546     char device[] = "/dev/sda1";
12547     int r;
12548     suppress_error = 0;
12549     r = guestfs_mkfs (g, fstype, device);
12550     if (r == -1)
12551       return -1;
12552   }
12553   {
12554     char device[] = "/dev/sda1";
12555     char mountpoint[] = "/";
12556     int r;
12557     suppress_error = 0;
12558     r = guestfs_mount (g, device, mountpoint);
12559     if (r == -1)
12560       return -1;
12561   }
12562   /* TestOutput for file (1) */
12563   char expected[] = "ASCII text";
12564   {
12565     char path[] = "/new";
12566     char content[] = "some content\n";
12567     int r;
12568     suppress_error = 0;
12569     r = guestfs_write_file (g, path, content, 0);
12570     if (r == -1)
12571       return -1;
12572   }
12573   {
12574     char path[] = "/new";
12575     char *r;
12576     suppress_error = 0;
12577     r = guestfs_file (g, path);
12578     if (r == NULL)
12579       return -1;
12580     if (strcmp (r, expected) != 0) {
12581       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12582       return -1;
12583     }
12584     free (r);
12585   }
12586   return 0;
12587 }
12588
12589 static int test_file_2_skip (void)
12590 {
12591   const char *str;
12592
12593   str = getenv ("TEST_ONLY");
12594   if (str)
12595     return strstr (str, "file") == NULL;
12596   str = getenv ("SKIP_TEST_FILE_2");
12597   if (str && strcmp (str, "1") == 0) return 1;
12598   str = getenv ("SKIP_TEST_FILE");
12599   if (str && strcmp (str, "1") == 0) return 1;
12600   return 0;
12601 }
12602
12603 static int test_file_2 (void)
12604 {
12605   if (test_file_2_skip ()) {
12606     printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12607     return 0;
12608   }
12609
12610   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12611   {
12612     char device[] = "/dev/sda";
12613     int r;
12614     suppress_error = 0;
12615     r = guestfs_blockdev_setrw (g, device);
12616     if (r == -1)
12617       return -1;
12618   }
12619   {
12620     int r;
12621     suppress_error = 0;
12622     r = guestfs_umount_all (g);
12623     if (r == -1)
12624       return -1;
12625   }
12626   {
12627     int r;
12628     suppress_error = 0;
12629     r = guestfs_lvm_remove_all (g);
12630     if (r == -1)
12631       return -1;
12632   }
12633   {
12634     char device[] = "/dev/sda";
12635     char lines_0[] = ",";
12636     char *lines[] = {
12637       lines_0,
12638       NULL
12639     };
12640     int r;
12641     suppress_error = 0;
12642     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12643     if (r == -1)
12644       return -1;
12645   }
12646   {
12647     char fstype[] = "ext2";
12648     char device[] = "/dev/sda1";
12649     int r;
12650     suppress_error = 0;
12651     r = guestfs_mkfs (g, fstype, device);
12652     if (r == -1)
12653       return -1;
12654   }
12655   {
12656     char device[] = "/dev/sda1";
12657     char mountpoint[] = "/";
12658     int r;
12659     suppress_error = 0;
12660     r = guestfs_mount (g, device, mountpoint);
12661     if (r == -1)
12662       return -1;
12663   }
12664   /* TestLastFail for file (2) */
12665   {
12666     char path[] = "/nofile";
12667     char *r;
12668     suppress_error = 1;
12669     r = guestfs_file (g, path);
12670     if (r != NULL)
12671       return -1;
12672     free (r);
12673   }
12674   return 0;
12675 }
12676
12677 static int test_umount_all_0_skip (void)
12678 {
12679   const char *str;
12680
12681   str = getenv ("TEST_ONLY");
12682   if (str)
12683     return strstr (str, "umount_all") == NULL;
12684   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
12685   if (str && strcmp (str, "1") == 0) return 1;
12686   str = getenv ("SKIP_TEST_UMOUNT_ALL");
12687   if (str && strcmp (str, "1") == 0) return 1;
12688   return 0;
12689 }
12690
12691 static int test_umount_all_0 (void)
12692 {
12693   if (test_umount_all_0_skip ()) {
12694     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
12695     return 0;
12696   }
12697
12698   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
12699   {
12700     char device[] = "/dev/sda";
12701     int r;
12702     suppress_error = 0;
12703     r = guestfs_blockdev_setrw (g, device);
12704     if (r == -1)
12705       return -1;
12706   }
12707   {
12708     int r;
12709     suppress_error = 0;
12710     r = guestfs_umount_all (g);
12711     if (r == -1)
12712       return -1;
12713   }
12714   {
12715     int r;
12716     suppress_error = 0;
12717     r = guestfs_lvm_remove_all (g);
12718     if (r == -1)
12719       return -1;
12720   }
12721   {
12722     char device[] = "/dev/sda";
12723     char lines_0[] = ",";
12724     char *lines[] = {
12725       lines_0,
12726       NULL
12727     };
12728     int r;
12729     suppress_error = 0;
12730     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12731     if (r == -1)
12732       return -1;
12733   }
12734   {
12735     char fstype[] = "ext2";
12736     char device[] = "/dev/sda1";
12737     int r;
12738     suppress_error = 0;
12739     r = guestfs_mkfs (g, fstype, device);
12740     if (r == -1)
12741       return -1;
12742   }
12743   {
12744     char device[] = "/dev/sda1";
12745     char mountpoint[] = "/";
12746     int r;
12747     suppress_error = 0;
12748     r = guestfs_mount (g, device, mountpoint);
12749     if (r == -1)
12750       return -1;
12751   }
12752   /* TestOutputList for umount_all (0) */
12753   {
12754     int r;
12755     suppress_error = 0;
12756     r = guestfs_umount_all (g);
12757     if (r == -1)
12758       return -1;
12759   }
12760   {
12761     char **r;
12762     int i;
12763     suppress_error = 0;
12764     r = guestfs_mounts (g);
12765     if (r == NULL)
12766       return -1;
12767     if (r[0] != NULL) {
12768       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
12769       print_strings (r);
12770       return -1;
12771     }
12772     for (i = 0; r[i] != NULL; ++i)
12773       free (r[i]);
12774     free (r);
12775   }
12776   return 0;
12777 }
12778
12779 static int test_umount_all_1_skip (void)
12780 {
12781   const char *str;
12782
12783   str = getenv ("TEST_ONLY");
12784   if (str)
12785     return strstr (str, "umount_all") == NULL;
12786   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
12787   if (str && strcmp (str, "1") == 0) return 1;
12788   str = getenv ("SKIP_TEST_UMOUNT_ALL");
12789   if (str && strcmp (str, "1") == 0) return 1;
12790   return 0;
12791 }
12792
12793 static int test_umount_all_1 (void)
12794 {
12795   if (test_umount_all_1_skip ()) {
12796     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
12797     return 0;
12798   }
12799
12800   /* InitNone|InitEmpty for test_umount_all_1 */
12801   {
12802     char device[] = "/dev/sda";
12803     int r;
12804     suppress_error = 0;
12805     r = guestfs_blockdev_setrw (g, device);
12806     if (r == -1)
12807       return -1;
12808   }
12809   {
12810     int r;
12811     suppress_error = 0;
12812     r = guestfs_umount_all (g);
12813     if (r == -1)
12814       return -1;
12815   }
12816   {
12817     int r;
12818     suppress_error = 0;
12819     r = guestfs_lvm_remove_all (g);
12820     if (r == -1)
12821       return -1;
12822   }
12823   /* TestOutputList for umount_all (1) */
12824   {
12825     char device[] = "/dev/sda";
12826     char lines_0[] = ",10";
12827     char lines_1[] = ",20";
12828     char lines_2[] = ",";
12829     char *lines[] = {
12830       lines_0,
12831       lines_1,
12832       lines_2,
12833       NULL
12834     };
12835     int r;
12836     suppress_error = 0;
12837     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12838     if (r == -1)
12839       return -1;
12840   }
12841   {
12842     char fstype[] = "ext2";
12843     char device[] = "/dev/sda1";
12844     int r;
12845     suppress_error = 0;
12846     r = guestfs_mkfs (g, fstype, device);
12847     if (r == -1)
12848       return -1;
12849   }
12850   {
12851     char fstype[] = "ext2";
12852     char device[] = "/dev/sda2";
12853     int r;
12854     suppress_error = 0;
12855     r = guestfs_mkfs (g, fstype, device);
12856     if (r == -1)
12857       return -1;
12858   }
12859   {
12860     char fstype[] = "ext2";
12861     char device[] = "/dev/sda3";
12862     int r;
12863     suppress_error = 0;
12864     r = guestfs_mkfs (g, fstype, device);
12865     if (r == -1)
12866       return -1;
12867   }
12868   {
12869     char device[] = "/dev/sda1";
12870     char mountpoint[] = "/";
12871     int r;
12872     suppress_error = 0;
12873     r = guestfs_mount (g, device, mountpoint);
12874     if (r == -1)
12875       return -1;
12876   }
12877   {
12878     char path[] = "/mp1";
12879     int r;
12880     suppress_error = 0;
12881     r = guestfs_mkdir (g, path);
12882     if (r == -1)
12883       return -1;
12884   }
12885   {
12886     char device[] = "/dev/sda2";
12887     char mountpoint[] = "/mp1";
12888     int r;
12889     suppress_error = 0;
12890     r = guestfs_mount (g, device, mountpoint);
12891     if (r == -1)
12892       return -1;
12893   }
12894   {
12895     char path[] = "/mp1/mp2";
12896     int r;
12897     suppress_error = 0;
12898     r = guestfs_mkdir (g, path);
12899     if (r == -1)
12900       return -1;
12901   }
12902   {
12903     char device[] = "/dev/sda3";
12904     char mountpoint[] = "/mp1/mp2";
12905     int r;
12906     suppress_error = 0;
12907     r = guestfs_mount (g, device, mountpoint);
12908     if (r == -1)
12909       return -1;
12910   }
12911   {
12912     char path[] = "/mp1/mp2/mp3";
12913     int r;
12914     suppress_error = 0;
12915     r = guestfs_mkdir (g, path);
12916     if (r == -1)
12917       return -1;
12918   }
12919   {
12920     int r;
12921     suppress_error = 0;
12922     r = guestfs_umount_all (g);
12923     if (r == -1)
12924       return -1;
12925   }
12926   {
12927     char **r;
12928     int i;
12929     suppress_error = 0;
12930     r = guestfs_mounts (g);
12931     if (r == NULL)
12932       return -1;
12933     if (r[0] != NULL) {
12934       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
12935       print_strings (r);
12936       return -1;
12937     }
12938     for (i = 0; r[i] != NULL; ++i)
12939       free (r[i]);
12940     free (r);
12941   }
12942   return 0;
12943 }
12944
12945 static int test_mounts_0_skip (void)
12946 {
12947   const char *str;
12948
12949   str = getenv ("TEST_ONLY");
12950   if (str)
12951     return strstr (str, "mounts") == NULL;
12952   str = getenv ("SKIP_TEST_MOUNTS_0");
12953   if (str && strcmp (str, "1") == 0) return 1;
12954   str = getenv ("SKIP_TEST_MOUNTS");
12955   if (str && strcmp (str, "1") == 0) return 1;
12956   return 0;
12957 }
12958
12959 static int test_mounts_0 (void)
12960 {
12961   if (test_mounts_0_skip ()) {
12962     printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
12963     return 0;
12964   }
12965
12966   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
12967   {
12968     char device[] = "/dev/sda";
12969     int r;
12970     suppress_error = 0;
12971     r = guestfs_blockdev_setrw (g, device);
12972     if (r == -1)
12973       return -1;
12974   }
12975   {
12976     int r;
12977     suppress_error = 0;
12978     r = guestfs_umount_all (g);
12979     if (r == -1)
12980       return -1;
12981   }
12982   {
12983     int r;
12984     suppress_error = 0;
12985     r = guestfs_lvm_remove_all (g);
12986     if (r == -1)
12987       return -1;
12988   }
12989   {
12990     char device[] = "/dev/sda";
12991     char lines_0[] = ",";
12992     char *lines[] = {
12993       lines_0,
12994       NULL
12995     };
12996     int r;
12997     suppress_error = 0;
12998     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12999     if (r == -1)
13000       return -1;
13001   }
13002   {
13003     char fstype[] = "ext2";
13004     char device[] = "/dev/sda1";
13005     int r;
13006     suppress_error = 0;
13007     r = guestfs_mkfs (g, fstype, device);
13008     if (r == -1)
13009       return -1;
13010   }
13011   {
13012     char device[] = "/dev/sda1";
13013     char mountpoint[] = "/";
13014     int r;
13015     suppress_error = 0;
13016     r = guestfs_mount (g, device, mountpoint);
13017     if (r == -1)
13018       return -1;
13019   }
13020   /* TestOutputListOfDevices for mounts (0) */
13021   {
13022     char **r;
13023     int i;
13024     suppress_error = 0;
13025     r = guestfs_mounts (g);
13026     if (r == NULL)
13027       return -1;
13028     if (!r[0]) {
13029       fprintf (stderr, "test_mounts_0: short list returned from command\n");
13030       print_strings (r);
13031       return -1;
13032     }
13033     {
13034       char expected[] = "/dev/sda1";
13035       r[0][5] = 's';
13036       if (strcmp (r[0], expected) != 0) {
13037         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13038         return -1;
13039       }
13040     }
13041     if (r[1] != NULL) {
13042       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13043       print_strings (r);
13044       return -1;
13045     }
13046     for (i = 0; r[i] != NULL; ++i)
13047       free (r[i]);
13048     free (r);
13049   }
13050   return 0;
13051 }
13052
13053 static int test_umount_0_skip (void)
13054 {
13055   const char *str;
13056
13057   str = getenv ("TEST_ONLY");
13058   if (str)
13059     return strstr (str, "umount") == NULL;
13060   str = getenv ("SKIP_TEST_UMOUNT_0");
13061   if (str && strcmp (str, "1") == 0) return 1;
13062   str = getenv ("SKIP_TEST_UMOUNT");
13063   if (str && strcmp (str, "1") == 0) return 1;
13064   return 0;
13065 }
13066
13067 static int test_umount_0 (void)
13068 {
13069   if (test_umount_0_skip ()) {
13070     printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13071     return 0;
13072   }
13073
13074   /* InitNone|InitEmpty for test_umount_0 */
13075   {
13076     char device[] = "/dev/sda";
13077     int r;
13078     suppress_error = 0;
13079     r = guestfs_blockdev_setrw (g, device);
13080     if (r == -1)
13081       return -1;
13082   }
13083   {
13084     int r;
13085     suppress_error = 0;
13086     r = guestfs_umount_all (g);
13087     if (r == -1)
13088       return -1;
13089   }
13090   {
13091     int r;
13092     suppress_error = 0;
13093     r = guestfs_lvm_remove_all (g);
13094     if (r == -1)
13095       return -1;
13096   }
13097   /* TestOutputListOfDevices for umount (0) */
13098   {
13099     char device[] = "/dev/sda";
13100     char lines_0[] = ",";
13101     char *lines[] = {
13102       lines_0,
13103       NULL
13104     };
13105     int r;
13106     suppress_error = 0;
13107     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13108     if (r == -1)
13109       return -1;
13110   }
13111   {
13112     char fstype[] = "ext2";
13113     char device[] = "/dev/sda1";
13114     int r;
13115     suppress_error = 0;
13116     r = guestfs_mkfs (g, fstype, device);
13117     if (r == -1)
13118       return -1;
13119   }
13120   {
13121     char device[] = "/dev/sda1";
13122     char mountpoint[] = "/";
13123     int r;
13124     suppress_error = 0;
13125     r = guestfs_mount (g, device, mountpoint);
13126     if (r == -1)
13127       return -1;
13128   }
13129   {
13130     char **r;
13131     int i;
13132     suppress_error = 0;
13133     r = guestfs_mounts (g);
13134     if (r == NULL)
13135       return -1;
13136     if (!r[0]) {
13137       fprintf (stderr, "test_umount_0: short list returned from command\n");
13138       print_strings (r);
13139       return -1;
13140     }
13141     {
13142       char expected[] = "/dev/sda1";
13143       r[0][5] = 's';
13144       if (strcmp (r[0], expected) != 0) {
13145         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13146         return -1;
13147       }
13148     }
13149     if (r[1] != NULL) {
13150       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13151       print_strings (r);
13152       return -1;
13153     }
13154     for (i = 0; r[i] != NULL; ++i)
13155       free (r[i]);
13156     free (r);
13157   }
13158   return 0;
13159 }
13160
13161 static int test_umount_1_skip (void)
13162 {
13163   const char *str;
13164
13165   str = getenv ("TEST_ONLY");
13166   if (str)
13167     return strstr (str, "umount") == NULL;
13168   str = getenv ("SKIP_TEST_UMOUNT_1");
13169   if (str && strcmp (str, "1") == 0) return 1;
13170   str = getenv ("SKIP_TEST_UMOUNT");
13171   if (str && strcmp (str, "1") == 0) return 1;
13172   return 0;
13173 }
13174
13175 static int test_umount_1 (void)
13176 {
13177   if (test_umount_1_skip ()) {
13178     printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13179     return 0;
13180   }
13181
13182   /* InitNone|InitEmpty for test_umount_1 */
13183   {
13184     char device[] = "/dev/sda";
13185     int r;
13186     suppress_error = 0;
13187     r = guestfs_blockdev_setrw (g, device);
13188     if (r == -1)
13189       return -1;
13190   }
13191   {
13192     int r;
13193     suppress_error = 0;
13194     r = guestfs_umount_all (g);
13195     if (r == -1)
13196       return -1;
13197   }
13198   {
13199     int r;
13200     suppress_error = 0;
13201     r = guestfs_lvm_remove_all (g);
13202     if (r == -1)
13203       return -1;
13204   }
13205   /* TestOutputList for umount (1) */
13206   {
13207     char device[] = "/dev/sda";
13208     char lines_0[] = ",";
13209     char *lines[] = {
13210       lines_0,
13211       NULL
13212     };
13213     int r;
13214     suppress_error = 0;
13215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13216     if (r == -1)
13217       return -1;
13218   }
13219   {
13220     char fstype[] = "ext2";
13221     char device[] = "/dev/sda1";
13222     int r;
13223     suppress_error = 0;
13224     r = guestfs_mkfs (g, fstype, device);
13225     if (r == -1)
13226       return -1;
13227   }
13228   {
13229     char device[] = "/dev/sda1";
13230     char mountpoint[] = "/";
13231     int r;
13232     suppress_error = 0;
13233     r = guestfs_mount (g, device, mountpoint);
13234     if (r == -1)
13235       return -1;
13236   }
13237   {
13238     char pathordevice[] = "/";
13239     int r;
13240     suppress_error = 0;
13241     r = guestfs_umount (g, pathordevice);
13242     if (r == -1)
13243       return -1;
13244   }
13245   {
13246     char **r;
13247     int i;
13248     suppress_error = 0;
13249     r = guestfs_mounts (g);
13250     if (r == NULL)
13251       return -1;
13252     if (r[0] != NULL) {
13253       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13254       print_strings (r);
13255       return -1;
13256     }
13257     for (i = 0; r[i] != NULL; ++i)
13258       free (r[i]);
13259     free (r);
13260   }
13261   return 0;
13262 }
13263
13264 static int test_write_file_0_skip (void)
13265 {
13266   const char *str;
13267
13268   str = getenv ("TEST_ONLY");
13269   if (str)
13270     return strstr (str, "write_file") == NULL;
13271   str = getenv ("SKIP_TEST_WRITE_FILE_0");
13272   if (str && strcmp (str, "1") == 0) return 1;
13273   str = getenv ("SKIP_TEST_WRITE_FILE");
13274   if (str && strcmp (str, "1") == 0) return 1;
13275   return 0;
13276 }
13277
13278 static int test_write_file_0 (void)
13279 {
13280   if (test_write_file_0_skip ()) {
13281     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13282     return 0;
13283   }
13284
13285   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13286   {
13287     char device[] = "/dev/sda";
13288     int r;
13289     suppress_error = 0;
13290     r = guestfs_blockdev_setrw (g, device);
13291     if (r == -1)
13292       return -1;
13293   }
13294   {
13295     int r;
13296     suppress_error = 0;
13297     r = guestfs_umount_all (g);
13298     if (r == -1)
13299       return -1;
13300   }
13301   {
13302     int r;
13303     suppress_error = 0;
13304     r = guestfs_lvm_remove_all (g);
13305     if (r == -1)
13306       return -1;
13307   }
13308   {
13309     char device[] = "/dev/sda";
13310     char lines_0[] = ",";
13311     char *lines[] = {
13312       lines_0,
13313       NULL
13314     };
13315     int r;
13316     suppress_error = 0;
13317     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13318     if (r == -1)
13319       return -1;
13320   }
13321   {
13322     char fstype[] = "ext2";
13323     char device[] = "/dev/sda1";
13324     int r;
13325     suppress_error = 0;
13326     r = guestfs_mkfs (g, fstype, device);
13327     if (r == -1)
13328       return -1;
13329   }
13330   {
13331     char device[] = "/dev/sda1";
13332     char mountpoint[] = "/";
13333     int r;
13334     suppress_error = 0;
13335     r = guestfs_mount (g, device, mountpoint);
13336     if (r == -1)
13337       return -1;
13338   }
13339   /* TestOutput for write_file (0) */
13340   char expected[] = "new file contents";
13341   {
13342     char path[] = "/new";
13343     char content[] = "new file contents";
13344     int r;
13345     suppress_error = 0;
13346     r = guestfs_write_file (g, path, content, 0);
13347     if (r == -1)
13348       return -1;
13349   }
13350   {
13351     char path[] = "/new";
13352     char *r;
13353     suppress_error = 0;
13354     r = guestfs_cat (g, path);
13355     if (r == NULL)
13356       return -1;
13357     if (strcmp (r, expected) != 0) {
13358       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13359       return -1;
13360     }
13361     free (r);
13362   }
13363   return 0;
13364 }
13365
13366 static int test_write_file_1_skip (void)
13367 {
13368   const char *str;
13369
13370   str = getenv ("TEST_ONLY");
13371   if (str)
13372     return strstr (str, "write_file") == NULL;
13373   str = getenv ("SKIP_TEST_WRITE_FILE_1");
13374   if (str && strcmp (str, "1") == 0) return 1;
13375   str = getenv ("SKIP_TEST_WRITE_FILE");
13376   if (str && strcmp (str, "1") == 0) return 1;
13377   return 0;
13378 }
13379
13380 static int test_write_file_1 (void)
13381 {
13382   if (test_write_file_1_skip ()) {
13383     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13384     return 0;
13385   }
13386
13387   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13388   {
13389     char device[] = "/dev/sda";
13390     int r;
13391     suppress_error = 0;
13392     r = guestfs_blockdev_setrw (g, device);
13393     if (r == -1)
13394       return -1;
13395   }
13396   {
13397     int r;
13398     suppress_error = 0;
13399     r = guestfs_umount_all (g);
13400     if (r == -1)
13401       return -1;
13402   }
13403   {
13404     int r;
13405     suppress_error = 0;
13406     r = guestfs_lvm_remove_all (g);
13407     if (r == -1)
13408       return -1;
13409   }
13410   {
13411     char device[] = "/dev/sda";
13412     char lines_0[] = ",";
13413     char *lines[] = {
13414       lines_0,
13415       NULL
13416     };
13417     int r;
13418     suppress_error = 0;
13419     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13420     if (r == -1)
13421       return -1;
13422   }
13423   {
13424     char fstype[] = "ext2";
13425     char device[] = "/dev/sda1";
13426     int r;
13427     suppress_error = 0;
13428     r = guestfs_mkfs (g, fstype, device);
13429     if (r == -1)
13430       return -1;
13431   }
13432   {
13433     char device[] = "/dev/sda1";
13434     char mountpoint[] = "/";
13435     int r;
13436     suppress_error = 0;
13437     r = guestfs_mount (g, device, mountpoint);
13438     if (r == -1)
13439       return -1;
13440   }
13441   /* TestOutput for write_file (1) */
13442   char expected[] = "\nnew file contents\n";
13443   {
13444     char path[] = "/new";
13445     char content[] = "\nnew file contents\n";
13446     int r;
13447     suppress_error = 0;
13448     r = guestfs_write_file (g, path, content, 0);
13449     if (r == -1)
13450       return -1;
13451   }
13452   {
13453     char path[] = "/new";
13454     char *r;
13455     suppress_error = 0;
13456     r = guestfs_cat (g, path);
13457     if (r == NULL)
13458       return -1;
13459     if (strcmp (r, expected) != 0) {
13460       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13461       return -1;
13462     }
13463     free (r);
13464   }
13465   return 0;
13466 }
13467
13468 static int test_write_file_2_skip (void)
13469 {
13470   const char *str;
13471
13472   str = getenv ("TEST_ONLY");
13473   if (str)
13474     return strstr (str, "write_file") == NULL;
13475   str = getenv ("SKIP_TEST_WRITE_FILE_2");
13476   if (str && strcmp (str, "1") == 0) return 1;
13477   str = getenv ("SKIP_TEST_WRITE_FILE");
13478   if (str && strcmp (str, "1") == 0) return 1;
13479   return 0;
13480 }
13481
13482 static int test_write_file_2 (void)
13483 {
13484   if (test_write_file_2_skip ()) {
13485     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13486     return 0;
13487   }
13488
13489   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13490   {
13491     char device[] = "/dev/sda";
13492     int r;
13493     suppress_error = 0;
13494     r = guestfs_blockdev_setrw (g, device);
13495     if (r == -1)
13496       return -1;
13497   }
13498   {
13499     int r;
13500     suppress_error = 0;
13501     r = guestfs_umount_all (g);
13502     if (r == -1)
13503       return -1;
13504   }
13505   {
13506     int r;
13507     suppress_error = 0;
13508     r = guestfs_lvm_remove_all (g);
13509     if (r == -1)
13510       return -1;
13511   }
13512   {
13513     char device[] = "/dev/sda";
13514     char lines_0[] = ",";
13515     char *lines[] = {
13516       lines_0,
13517       NULL
13518     };
13519     int r;
13520     suppress_error = 0;
13521     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13522     if (r == -1)
13523       return -1;
13524   }
13525   {
13526     char fstype[] = "ext2";
13527     char device[] = "/dev/sda1";
13528     int r;
13529     suppress_error = 0;
13530     r = guestfs_mkfs (g, fstype, device);
13531     if (r == -1)
13532       return -1;
13533   }
13534   {
13535     char device[] = "/dev/sda1";
13536     char mountpoint[] = "/";
13537     int r;
13538     suppress_error = 0;
13539     r = guestfs_mount (g, device, mountpoint);
13540     if (r == -1)
13541       return -1;
13542   }
13543   /* TestOutput for write_file (2) */
13544   char expected[] = "\n\n";
13545   {
13546     char path[] = "/new";
13547     char content[] = "\n\n";
13548     int r;
13549     suppress_error = 0;
13550     r = guestfs_write_file (g, path, content, 0);
13551     if (r == -1)
13552       return -1;
13553   }
13554   {
13555     char path[] = "/new";
13556     char *r;
13557     suppress_error = 0;
13558     r = guestfs_cat (g, path);
13559     if (r == NULL)
13560       return -1;
13561     if (strcmp (r, expected) != 0) {
13562       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13563       return -1;
13564     }
13565     free (r);
13566   }
13567   return 0;
13568 }
13569
13570 static int test_write_file_3_skip (void)
13571 {
13572   const char *str;
13573
13574   str = getenv ("TEST_ONLY");
13575   if (str)
13576     return strstr (str, "write_file") == NULL;
13577   str = getenv ("SKIP_TEST_WRITE_FILE_3");
13578   if (str && strcmp (str, "1") == 0) return 1;
13579   str = getenv ("SKIP_TEST_WRITE_FILE");
13580   if (str && strcmp (str, "1") == 0) return 1;
13581   return 0;
13582 }
13583
13584 static int test_write_file_3 (void)
13585 {
13586   if (test_write_file_3_skip ()) {
13587     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13588     return 0;
13589   }
13590
13591   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13592   {
13593     char device[] = "/dev/sda";
13594     int r;
13595     suppress_error = 0;
13596     r = guestfs_blockdev_setrw (g, device);
13597     if (r == -1)
13598       return -1;
13599   }
13600   {
13601     int r;
13602     suppress_error = 0;
13603     r = guestfs_umount_all (g);
13604     if (r == -1)
13605       return -1;
13606   }
13607   {
13608     int r;
13609     suppress_error = 0;
13610     r = guestfs_lvm_remove_all (g);
13611     if (r == -1)
13612       return -1;
13613   }
13614   {
13615     char device[] = "/dev/sda";
13616     char lines_0[] = ",";
13617     char *lines[] = {
13618       lines_0,
13619       NULL
13620     };
13621     int r;
13622     suppress_error = 0;
13623     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13624     if (r == -1)
13625       return -1;
13626   }
13627   {
13628     char fstype[] = "ext2";
13629     char device[] = "/dev/sda1";
13630     int r;
13631     suppress_error = 0;
13632     r = guestfs_mkfs (g, fstype, device);
13633     if (r == -1)
13634       return -1;
13635   }
13636   {
13637     char device[] = "/dev/sda1";
13638     char mountpoint[] = "/";
13639     int r;
13640     suppress_error = 0;
13641     r = guestfs_mount (g, device, mountpoint);
13642     if (r == -1)
13643       return -1;
13644   }
13645   /* TestOutput for write_file (3) */
13646   char expected[] = "";
13647   {
13648     char path[] = "/new";
13649     char content[] = "";
13650     int r;
13651     suppress_error = 0;
13652     r = guestfs_write_file (g, path, content, 0);
13653     if (r == -1)
13654       return -1;
13655   }
13656   {
13657     char path[] = "/new";
13658     char *r;
13659     suppress_error = 0;
13660     r = guestfs_cat (g, path);
13661     if (r == NULL)
13662       return -1;
13663     if (strcmp (r, expected) != 0) {
13664       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
13665       return -1;
13666     }
13667     free (r);
13668   }
13669   return 0;
13670 }
13671
13672 static int test_write_file_4_skip (void)
13673 {
13674   const char *str;
13675
13676   str = getenv ("TEST_ONLY");
13677   if (str)
13678     return strstr (str, "write_file") == NULL;
13679   str = getenv ("SKIP_TEST_WRITE_FILE_4");
13680   if (str && strcmp (str, "1") == 0) return 1;
13681   str = getenv ("SKIP_TEST_WRITE_FILE");
13682   if (str && strcmp (str, "1") == 0) return 1;
13683   return 0;
13684 }
13685
13686 static int test_write_file_4 (void)
13687 {
13688   if (test_write_file_4_skip ()) {
13689     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
13690     return 0;
13691   }
13692
13693   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
13694   {
13695     char device[] = "/dev/sda";
13696     int r;
13697     suppress_error = 0;
13698     r = guestfs_blockdev_setrw (g, device);
13699     if (r == -1)
13700       return -1;
13701   }
13702   {
13703     int r;
13704     suppress_error = 0;
13705     r = guestfs_umount_all (g);
13706     if (r == -1)
13707       return -1;
13708   }
13709   {
13710     int r;
13711     suppress_error = 0;
13712     r = guestfs_lvm_remove_all (g);
13713     if (r == -1)
13714       return -1;
13715   }
13716   {
13717     char device[] = "/dev/sda";
13718     char lines_0[] = ",";
13719     char *lines[] = {
13720       lines_0,
13721       NULL
13722     };
13723     int r;
13724     suppress_error = 0;
13725     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13726     if (r == -1)
13727       return -1;
13728   }
13729   {
13730     char fstype[] = "ext2";
13731     char device[] = "/dev/sda1";
13732     int r;
13733     suppress_error = 0;
13734     r = guestfs_mkfs (g, fstype, device);
13735     if (r == -1)
13736       return -1;
13737   }
13738   {
13739     char device[] = "/dev/sda1";
13740     char mountpoint[] = "/";
13741     int r;
13742     suppress_error = 0;
13743     r = guestfs_mount (g, device, mountpoint);
13744     if (r == -1)
13745       return -1;
13746   }
13747   /* TestOutput for write_file (4) */
13748   char expected[] = "\n\n\n";
13749   {
13750     char path[] = "/new";
13751     char content[] = "\n\n\n";
13752     int r;
13753     suppress_error = 0;
13754     r = guestfs_write_file (g, path, content, 0);
13755     if (r == -1)
13756       return -1;
13757   }
13758   {
13759     char path[] = "/new";
13760     char *r;
13761     suppress_error = 0;
13762     r = guestfs_cat (g, path);
13763     if (r == NULL)
13764       return -1;
13765     if (strcmp (r, expected) != 0) {
13766       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
13767       return -1;
13768     }
13769     free (r);
13770   }
13771   return 0;
13772 }
13773
13774 static int test_write_file_5_skip (void)
13775 {
13776   const char *str;
13777
13778   str = getenv ("TEST_ONLY");
13779   if (str)
13780     return strstr (str, "write_file") == NULL;
13781   str = getenv ("SKIP_TEST_WRITE_FILE_5");
13782   if (str && strcmp (str, "1") == 0) return 1;
13783   str = getenv ("SKIP_TEST_WRITE_FILE");
13784   if (str && strcmp (str, "1") == 0) return 1;
13785   return 0;
13786 }
13787
13788 static int test_write_file_5 (void)
13789 {
13790   if (test_write_file_5_skip ()) {
13791     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
13792     return 0;
13793   }
13794
13795   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
13796   {
13797     char device[] = "/dev/sda";
13798     int r;
13799     suppress_error = 0;
13800     r = guestfs_blockdev_setrw (g, device);
13801     if (r == -1)
13802       return -1;
13803   }
13804   {
13805     int r;
13806     suppress_error = 0;
13807     r = guestfs_umount_all (g);
13808     if (r == -1)
13809       return -1;
13810   }
13811   {
13812     int r;
13813     suppress_error = 0;
13814     r = guestfs_lvm_remove_all (g);
13815     if (r == -1)
13816       return -1;
13817   }
13818   {
13819     char device[] = "/dev/sda";
13820     char lines_0[] = ",";
13821     char *lines[] = {
13822       lines_0,
13823       NULL
13824     };
13825     int r;
13826     suppress_error = 0;
13827     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13828     if (r == -1)
13829       return -1;
13830   }
13831   {
13832     char fstype[] = "ext2";
13833     char device[] = "/dev/sda1";
13834     int r;
13835     suppress_error = 0;
13836     r = guestfs_mkfs (g, fstype, device);
13837     if (r == -1)
13838       return -1;
13839   }
13840   {
13841     char device[] = "/dev/sda1";
13842     char mountpoint[] = "/";
13843     int r;
13844     suppress_error = 0;
13845     r = guestfs_mount (g, device, mountpoint);
13846     if (r == -1)
13847       return -1;
13848   }
13849   /* TestOutput for write_file (5) */
13850   char expected[] = "\n";
13851   {
13852     char path[] = "/new";
13853     char content[] = "\n";
13854     int r;
13855     suppress_error = 0;
13856     r = guestfs_write_file (g, path, content, 0);
13857     if (r == -1)
13858       return -1;
13859   }
13860   {
13861     char path[] = "/new";
13862     char *r;
13863     suppress_error = 0;
13864     r = guestfs_cat (g, path);
13865     if (r == NULL)
13866       return -1;
13867     if (strcmp (r, expected) != 0) {
13868       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
13869       return -1;
13870     }
13871     free (r);
13872   }
13873   return 0;
13874 }
13875
13876 static int test_mkfs_0_skip (void)
13877 {
13878   const char *str;
13879
13880   str = getenv ("TEST_ONLY");
13881   if (str)
13882     return strstr (str, "mkfs") == NULL;
13883   str = getenv ("SKIP_TEST_MKFS_0");
13884   if (str && strcmp (str, "1") == 0) return 1;
13885   str = getenv ("SKIP_TEST_MKFS");
13886   if (str && strcmp (str, "1") == 0) return 1;
13887   return 0;
13888 }
13889
13890 static int test_mkfs_0 (void)
13891 {
13892   if (test_mkfs_0_skip ()) {
13893     printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
13894     return 0;
13895   }
13896
13897   /* InitNone|InitEmpty for test_mkfs_0 */
13898   {
13899     char device[] = "/dev/sda";
13900     int r;
13901     suppress_error = 0;
13902     r = guestfs_blockdev_setrw (g, device);
13903     if (r == -1)
13904       return -1;
13905   }
13906   {
13907     int r;
13908     suppress_error = 0;
13909     r = guestfs_umount_all (g);
13910     if (r == -1)
13911       return -1;
13912   }
13913   {
13914     int r;
13915     suppress_error = 0;
13916     r = guestfs_lvm_remove_all (g);
13917     if (r == -1)
13918       return -1;
13919   }
13920   /* TestOutput for mkfs (0) */
13921   char expected[] = "new file contents";
13922   {
13923     char device[] = "/dev/sda";
13924     char lines_0[] = ",";
13925     char *lines[] = {
13926       lines_0,
13927       NULL
13928     };
13929     int r;
13930     suppress_error = 0;
13931     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13932     if (r == -1)
13933       return -1;
13934   }
13935   {
13936     char fstype[] = "ext2";
13937     char device[] = "/dev/sda1";
13938     int r;
13939     suppress_error = 0;
13940     r = guestfs_mkfs (g, fstype, device);
13941     if (r == -1)
13942       return -1;
13943   }
13944   {
13945     char device[] = "/dev/sda1";
13946     char mountpoint[] = "/";
13947     int r;
13948     suppress_error = 0;
13949     r = guestfs_mount (g, device, mountpoint);
13950     if (r == -1)
13951       return -1;
13952   }
13953   {
13954     char path[] = "/new";
13955     char content[] = "new file contents";
13956     int r;
13957     suppress_error = 0;
13958     r = guestfs_write_file (g, path, content, 0);
13959     if (r == -1)
13960       return -1;
13961   }
13962   {
13963     char path[] = "/new";
13964     char *r;
13965     suppress_error = 0;
13966     r = guestfs_cat (g, path);
13967     if (r == NULL)
13968       return -1;
13969     if (strcmp (r, expected) != 0) {
13970       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
13971       return -1;
13972     }
13973     free (r);
13974   }
13975   return 0;
13976 }
13977
13978 static int test_lvcreate_0_skip (void)
13979 {
13980   const char *str;
13981
13982   str = getenv ("TEST_ONLY");
13983   if (str)
13984     return strstr (str, "lvcreate") == NULL;
13985   str = getenv ("SKIP_TEST_LVCREATE_0");
13986   if (str && strcmp (str, "1") == 0) return 1;
13987   str = getenv ("SKIP_TEST_LVCREATE");
13988   if (str && strcmp (str, "1") == 0) return 1;
13989   return 0;
13990 }
13991
13992 static int test_lvcreate_0 (void)
13993 {
13994   if (test_lvcreate_0_skip ()) {
13995     printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
13996     return 0;
13997   }
13998
13999   /* InitNone|InitEmpty for test_lvcreate_0 */
14000   {
14001     char device[] = "/dev/sda";
14002     int r;
14003     suppress_error = 0;
14004     r = guestfs_blockdev_setrw (g, device);
14005     if (r == -1)
14006       return -1;
14007   }
14008   {
14009     int r;
14010     suppress_error = 0;
14011     r = guestfs_umount_all (g);
14012     if (r == -1)
14013       return -1;
14014   }
14015   {
14016     int r;
14017     suppress_error = 0;
14018     r = guestfs_lvm_remove_all (g);
14019     if (r == -1)
14020       return -1;
14021   }
14022   /* TestOutputList for lvcreate (0) */
14023   {
14024     char device[] = "/dev/sda";
14025     char lines_0[] = ",10";
14026     char lines_1[] = ",20";
14027     char lines_2[] = ",";
14028     char *lines[] = {
14029       lines_0,
14030       lines_1,
14031       lines_2,
14032       NULL
14033     };
14034     int r;
14035     suppress_error = 0;
14036     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14037     if (r == -1)
14038       return -1;
14039   }
14040   {
14041     char device[] = "/dev/sda1";
14042     int r;
14043     suppress_error = 0;
14044     r = guestfs_pvcreate (g, device);
14045     if (r == -1)
14046       return -1;
14047   }
14048   {
14049     char device[] = "/dev/sda2";
14050     int r;
14051     suppress_error = 0;
14052     r = guestfs_pvcreate (g, device);
14053     if (r == -1)
14054       return -1;
14055   }
14056   {
14057     char device[] = "/dev/sda3";
14058     int r;
14059     suppress_error = 0;
14060     r = guestfs_pvcreate (g, device);
14061     if (r == -1)
14062       return -1;
14063   }
14064   {
14065     char volgroup[] = "VG1";
14066     char physvols_0[] = "/dev/sda1";
14067     char physvols_1[] = "/dev/sda2";
14068     char *physvols[] = {
14069       physvols_0,
14070       physvols_1,
14071       NULL
14072     };
14073     int r;
14074     suppress_error = 0;
14075     r = guestfs_vgcreate (g, volgroup, physvols);
14076     if (r == -1)
14077       return -1;
14078   }
14079   {
14080     char volgroup[] = "VG2";
14081     char physvols_0[] = "/dev/sda3";
14082     char *physvols[] = {
14083       physvols_0,
14084       NULL
14085     };
14086     int r;
14087     suppress_error = 0;
14088     r = guestfs_vgcreate (g, volgroup, physvols);
14089     if (r == -1)
14090       return -1;
14091   }
14092   {
14093     char logvol[] = "LV1";
14094     char volgroup[] = "VG1";
14095     int r;
14096     suppress_error = 0;
14097     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14098     if (r == -1)
14099       return -1;
14100   }
14101   {
14102     char logvol[] = "LV2";
14103     char volgroup[] = "VG1";
14104     int r;
14105     suppress_error = 0;
14106     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14107     if (r == -1)
14108       return -1;
14109   }
14110   {
14111     char logvol[] = "LV3";
14112     char volgroup[] = "VG2";
14113     int r;
14114     suppress_error = 0;
14115     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14116     if (r == -1)
14117       return -1;
14118   }
14119   {
14120     char logvol[] = "LV4";
14121     char volgroup[] = "VG2";
14122     int r;
14123     suppress_error = 0;
14124     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14125     if (r == -1)
14126       return -1;
14127   }
14128   {
14129     char logvol[] = "LV5";
14130     char volgroup[] = "VG2";
14131     int r;
14132     suppress_error = 0;
14133     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14134     if (r == -1)
14135       return -1;
14136   }
14137   {
14138     char **r;
14139     int i;
14140     suppress_error = 0;
14141     r = guestfs_lvs (g);
14142     if (r == NULL)
14143       return -1;
14144     if (!r[0]) {
14145       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14146       print_strings (r);
14147       return -1;
14148     }
14149     {
14150       char expected[] = "/dev/VG1/LV1";
14151       if (strcmp (r[0], expected) != 0) {
14152         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14153         return -1;
14154       }
14155     }
14156     if (!r[1]) {
14157       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14158       print_strings (r);
14159       return -1;
14160     }
14161     {
14162       char expected[] = "/dev/VG1/LV2";
14163       if (strcmp (r[1], expected) != 0) {
14164         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14165         return -1;
14166       }
14167     }
14168     if (!r[2]) {
14169       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14170       print_strings (r);
14171       return -1;
14172     }
14173     {
14174       char expected[] = "/dev/VG2/LV3";
14175       if (strcmp (r[2], expected) != 0) {
14176         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14177         return -1;
14178       }
14179     }
14180     if (!r[3]) {
14181       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14182       print_strings (r);
14183       return -1;
14184     }
14185     {
14186       char expected[] = "/dev/VG2/LV4";
14187       if (strcmp (r[3], expected) != 0) {
14188         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14189         return -1;
14190       }
14191     }
14192     if (!r[4]) {
14193       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14194       print_strings (r);
14195       return -1;
14196     }
14197     {
14198       char expected[] = "/dev/VG2/LV5";
14199       if (strcmp (r[4], expected) != 0) {
14200         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14201         return -1;
14202       }
14203     }
14204     if (r[5] != NULL) {
14205       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14206       print_strings (r);
14207       return -1;
14208     }
14209     for (i = 0; r[i] != NULL; ++i)
14210       free (r[i]);
14211     free (r);
14212   }
14213   return 0;
14214 }
14215
14216 static int test_vgcreate_0_skip (void)
14217 {
14218   const char *str;
14219
14220   str = getenv ("TEST_ONLY");
14221   if (str)
14222     return strstr (str, "vgcreate") == NULL;
14223   str = getenv ("SKIP_TEST_VGCREATE_0");
14224   if (str && strcmp (str, "1") == 0) return 1;
14225   str = getenv ("SKIP_TEST_VGCREATE");
14226   if (str && strcmp (str, "1") == 0) return 1;
14227   return 0;
14228 }
14229
14230 static int test_vgcreate_0 (void)
14231 {
14232   if (test_vgcreate_0_skip ()) {
14233     printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14234     return 0;
14235   }
14236
14237   /* InitNone|InitEmpty for test_vgcreate_0 */
14238   {
14239     char device[] = "/dev/sda";
14240     int r;
14241     suppress_error = 0;
14242     r = guestfs_blockdev_setrw (g, device);
14243     if (r == -1)
14244       return -1;
14245   }
14246   {
14247     int r;
14248     suppress_error = 0;
14249     r = guestfs_umount_all (g);
14250     if (r == -1)
14251       return -1;
14252   }
14253   {
14254     int r;
14255     suppress_error = 0;
14256     r = guestfs_lvm_remove_all (g);
14257     if (r == -1)
14258       return -1;
14259   }
14260   /* TestOutputList for vgcreate (0) */
14261   {
14262     char device[] = "/dev/sda";
14263     char lines_0[] = ",10";
14264     char lines_1[] = ",20";
14265     char lines_2[] = ",";
14266     char *lines[] = {
14267       lines_0,
14268       lines_1,
14269       lines_2,
14270       NULL
14271     };
14272     int r;
14273     suppress_error = 0;
14274     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14275     if (r == -1)
14276       return -1;
14277   }
14278   {
14279     char device[] = "/dev/sda1";
14280     int r;
14281     suppress_error = 0;
14282     r = guestfs_pvcreate (g, device);
14283     if (r == -1)
14284       return -1;
14285   }
14286   {
14287     char device[] = "/dev/sda2";
14288     int r;
14289     suppress_error = 0;
14290     r = guestfs_pvcreate (g, device);
14291     if (r == -1)
14292       return -1;
14293   }
14294   {
14295     char device[] = "/dev/sda3";
14296     int r;
14297     suppress_error = 0;
14298     r = guestfs_pvcreate (g, device);
14299     if (r == -1)
14300       return -1;
14301   }
14302   {
14303     char volgroup[] = "VG1";
14304     char physvols_0[] = "/dev/sda1";
14305     char physvols_1[] = "/dev/sda2";
14306     char *physvols[] = {
14307       physvols_0,
14308       physvols_1,
14309       NULL
14310     };
14311     int r;
14312     suppress_error = 0;
14313     r = guestfs_vgcreate (g, volgroup, physvols);
14314     if (r == -1)
14315       return -1;
14316   }
14317   {
14318     char volgroup[] = "VG2";
14319     char physvols_0[] = "/dev/sda3";
14320     char *physvols[] = {
14321       physvols_0,
14322       NULL
14323     };
14324     int r;
14325     suppress_error = 0;
14326     r = guestfs_vgcreate (g, volgroup, physvols);
14327     if (r == -1)
14328       return -1;
14329   }
14330   {
14331     char **r;
14332     int i;
14333     suppress_error = 0;
14334     r = guestfs_vgs (g);
14335     if (r == NULL)
14336       return -1;
14337     if (!r[0]) {
14338       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14339       print_strings (r);
14340       return -1;
14341     }
14342     {
14343       char expected[] = "VG1";
14344       if (strcmp (r[0], expected) != 0) {
14345         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14346         return -1;
14347       }
14348     }
14349     if (!r[1]) {
14350       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14351       print_strings (r);
14352       return -1;
14353     }
14354     {
14355       char expected[] = "VG2";
14356       if (strcmp (r[1], expected) != 0) {
14357         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14358         return -1;
14359       }
14360     }
14361     if (r[2] != NULL) {
14362       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14363       print_strings (r);
14364       return -1;
14365     }
14366     for (i = 0; r[i] != NULL; ++i)
14367       free (r[i]);
14368     free (r);
14369   }
14370   return 0;
14371 }
14372
14373 static int test_pvcreate_0_skip (void)
14374 {
14375   const char *str;
14376
14377   str = getenv ("TEST_ONLY");
14378   if (str)
14379     return strstr (str, "pvcreate") == NULL;
14380   str = getenv ("SKIP_TEST_PVCREATE_0");
14381   if (str && strcmp (str, "1") == 0) return 1;
14382   str = getenv ("SKIP_TEST_PVCREATE");
14383   if (str && strcmp (str, "1") == 0) return 1;
14384   return 0;
14385 }
14386
14387 static int test_pvcreate_0 (void)
14388 {
14389   if (test_pvcreate_0_skip ()) {
14390     printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14391     return 0;
14392   }
14393
14394   /* InitNone|InitEmpty for test_pvcreate_0 */
14395   {
14396     char device[] = "/dev/sda";
14397     int r;
14398     suppress_error = 0;
14399     r = guestfs_blockdev_setrw (g, device);
14400     if (r == -1)
14401       return -1;
14402   }
14403   {
14404     int r;
14405     suppress_error = 0;
14406     r = guestfs_umount_all (g);
14407     if (r == -1)
14408       return -1;
14409   }
14410   {
14411     int r;
14412     suppress_error = 0;
14413     r = guestfs_lvm_remove_all (g);
14414     if (r == -1)
14415       return -1;
14416   }
14417   /* TestOutputListOfDevices for pvcreate (0) */
14418   {
14419     char device[] = "/dev/sda";
14420     char lines_0[] = ",10";
14421     char lines_1[] = ",20";
14422     char lines_2[] = ",";
14423     char *lines[] = {
14424       lines_0,
14425       lines_1,
14426       lines_2,
14427       NULL
14428     };
14429     int r;
14430     suppress_error = 0;
14431     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14432     if (r == -1)
14433       return -1;
14434   }
14435   {
14436     char device[] = "/dev/sda1";
14437     int r;
14438     suppress_error = 0;
14439     r = guestfs_pvcreate (g, device);
14440     if (r == -1)
14441       return -1;
14442   }
14443   {
14444     char device[] = "/dev/sda2";
14445     int r;
14446     suppress_error = 0;
14447     r = guestfs_pvcreate (g, device);
14448     if (r == -1)
14449       return -1;
14450   }
14451   {
14452     char device[] = "/dev/sda3";
14453     int r;
14454     suppress_error = 0;
14455     r = guestfs_pvcreate (g, device);
14456     if (r == -1)
14457       return -1;
14458   }
14459   {
14460     char **r;
14461     int i;
14462     suppress_error = 0;
14463     r = guestfs_pvs (g);
14464     if (r == NULL)
14465       return -1;
14466     if (!r[0]) {
14467       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14468       print_strings (r);
14469       return -1;
14470     }
14471     {
14472       char expected[] = "/dev/sda1";
14473       r[0][5] = 's';
14474       if (strcmp (r[0], expected) != 0) {
14475         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14476         return -1;
14477       }
14478     }
14479     if (!r[1]) {
14480       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14481       print_strings (r);
14482       return -1;
14483     }
14484     {
14485       char expected[] = "/dev/sda2";
14486       r[1][5] = 's';
14487       if (strcmp (r[1], expected) != 0) {
14488         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14489         return -1;
14490       }
14491     }
14492     if (!r[2]) {
14493       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14494       print_strings (r);
14495       return -1;
14496     }
14497     {
14498       char expected[] = "/dev/sda3";
14499       r[2][5] = 's';
14500       if (strcmp (r[2], expected) != 0) {
14501         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14502         return -1;
14503       }
14504     }
14505     if (r[3] != NULL) {
14506       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14507       print_strings (r);
14508       return -1;
14509     }
14510     for (i = 0; r[i] != NULL; ++i)
14511       free (r[i]);
14512     free (r);
14513   }
14514   return 0;
14515 }
14516
14517 static int test_is_dir_0_skip (void)
14518 {
14519   const char *str;
14520
14521   str = getenv ("TEST_ONLY");
14522   if (str)
14523     return strstr (str, "is_dir") == NULL;
14524   str = getenv ("SKIP_TEST_IS_DIR_0");
14525   if (str && strcmp (str, "1") == 0) return 1;
14526   str = getenv ("SKIP_TEST_IS_DIR");
14527   if (str && strcmp (str, "1") == 0) return 1;
14528   return 0;
14529 }
14530
14531 static int test_is_dir_0 (void)
14532 {
14533   if (test_is_dir_0_skip ()) {
14534     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14535     return 0;
14536   }
14537
14538   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14539   {
14540     char device[] = "/dev/sda";
14541     int r;
14542     suppress_error = 0;
14543     r = guestfs_blockdev_setrw (g, device);
14544     if (r == -1)
14545       return -1;
14546   }
14547   {
14548     int r;
14549     suppress_error = 0;
14550     r = guestfs_umount_all (g);
14551     if (r == -1)
14552       return -1;
14553   }
14554   {
14555     int r;
14556     suppress_error = 0;
14557     r = guestfs_lvm_remove_all (g);
14558     if (r == -1)
14559       return -1;
14560   }
14561   {
14562     char device[] = "/dev/sda";
14563     char lines_0[] = ",";
14564     char *lines[] = {
14565       lines_0,
14566       NULL
14567     };
14568     int r;
14569     suppress_error = 0;
14570     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14571     if (r == -1)
14572       return -1;
14573   }
14574   {
14575     char fstype[] = "ext2";
14576     char device[] = "/dev/sda1";
14577     int r;
14578     suppress_error = 0;
14579     r = guestfs_mkfs (g, fstype, device);
14580     if (r == -1)
14581       return -1;
14582   }
14583   {
14584     char device[] = "/dev/sda1";
14585     char mountpoint[] = "/";
14586     int r;
14587     suppress_error = 0;
14588     r = guestfs_mount (g, device, mountpoint);
14589     if (r == -1)
14590       return -1;
14591   }
14592   /* TestOutputFalse for is_dir (0) */
14593   {
14594     char path[] = "/new";
14595     int r;
14596     suppress_error = 0;
14597     r = guestfs_touch (g, path);
14598     if (r == -1)
14599       return -1;
14600   }
14601   {
14602     char path[] = "/new";
14603     int r;
14604     suppress_error = 0;
14605     r = guestfs_is_dir (g, path);
14606     if (r == -1)
14607       return -1;
14608     if (r) {
14609       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14610       return -1;
14611     }
14612   }
14613   return 0;
14614 }
14615
14616 static int test_is_dir_1_skip (void)
14617 {
14618   const char *str;
14619
14620   str = getenv ("TEST_ONLY");
14621   if (str)
14622     return strstr (str, "is_dir") == NULL;
14623   str = getenv ("SKIP_TEST_IS_DIR_1");
14624   if (str && strcmp (str, "1") == 0) return 1;
14625   str = getenv ("SKIP_TEST_IS_DIR");
14626   if (str && strcmp (str, "1") == 0) return 1;
14627   return 0;
14628 }
14629
14630 static int test_is_dir_1 (void)
14631 {
14632   if (test_is_dir_1_skip ()) {
14633     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
14634     return 0;
14635   }
14636
14637   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
14638   {
14639     char device[] = "/dev/sda";
14640     int r;
14641     suppress_error = 0;
14642     r = guestfs_blockdev_setrw (g, device);
14643     if (r == -1)
14644       return -1;
14645   }
14646   {
14647     int r;
14648     suppress_error = 0;
14649     r = guestfs_umount_all (g);
14650     if (r == -1)
14651       return -1;
14652   }
14653   {
14654     int r;
14655     suppress_error = 0;
14656     r = guestfs_lvm_remove_all (g);
14657     if (r == -1)
14658       return -1;
14659   }
14660   {
14661     char device[] = "/dev/sda";
14662     char lines_0[] = ",";
14663     char *lines[] = {
14664       lines_0,
14665       NULL
14666     };
14667     int r;
14668     suppress_error = 0;
14669     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14670     if (r == -1)
14671       return -1;
14672   }
14673   {
14674     char fstype[] = "ext2";
14675     char device[] = "/dev/sda1";
14676     int r;
14677     suppress_error = 0;
14678     r = guestfs_mkfs (g, fstype, device);
14679     if (r == -1)
14680       return -1;
14681   }
14682   {
14683     char device[] = "/dev/sda1";
14684     char mountpoint[] = "/";
14685     int r;
14686     suppress_error = 0;
14687     r = guestfs_mount (g, device, mountpoint);
14688     if (r == -1)
14689       return -1;
14690   }
14691   /* TestOutputTrue for is_dir (1) */
14692   {
14693     char path[] = "/new";
14694     int r;
14695     suppress_error = 0;
14696     r = guestfs_mkdir (g, path);
14697     if (r == -1)
14698       return -1;
14699   }
14700   {
14701     char path[] = "/new";
14702     int r;
14703     suppress_error = 0;
14704     r = guestfs_is_dir (g, path);
14705     if (r == -1)
14706       return -1;
14707     if (!r) {
14708       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
14709       return -1;
14710     }
14711   }
14712   return 0;
14713 }
14714
14715 static int test_is_file_0_skip (void)
14716 {
14717   const char *str;
14718
14719   str = getenv ("TEST_ONLY");
14720   if (str)
14721     return strstr (str, "is_file") == NULL;
14722   str = getenv ("SKIP_TEST_IS_FILE_0");
14723   if (str && strcmp (str, "1") == 0) return 1;
14724   str = getenv ("SKIP_TEST_IS_FILE");
14725   if (str && strcmp (str, "1") == 0) return 1;
14726   return 0;
14727 }
14728
14729 static int test_is_file_0 (void)
14730 {
14731   if (test_is_file_0_skip ()) {
14732     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
14733     return 0;
14734   }
14735
14736   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
14737   {
14738     char device[] = "/dev/sda";
14739     int r;
14740     suppress_error = 0;
14741     r = guestfs_blockdev_setrw (g, device);
14742     if (r == -1)
14743       return -1;
14744   }
14745   {
14746     int r;
14747     suppress_error = 0;
14748     r = guestfs_umount_all (g);
14749     if (r == -1)
14750       return -1;
14751   }
14752   {
14753     int r;
14754     suppress_error = 0;
14755     r = guestfs_lvm_remove_all (g);
14756     if (r == -1)
14757       return -1;
14758   }
14759   {
14760     char device[] = "/dev/sda";
14761     char lines_0[] = ",";
14762     char *lines[] = {
14763       lines_0,
14764       NULL
14765     };
14766     int r;
14767     suppress_error = 0;
14768     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14769     if (r == -1)
14770       return -1;
14771   }
14772   {
14773     char fstype[] = "ext2";
14774     char device[] = "/dev/sda1";
14775     int r;
14776     suppress_error = 0;
14777     r = guestfs_mkfs (g, fstype, device);
14778     if (r == -1)
14779       return -1;
14780   }
14781   {
14782     char device[] = "/dev/sda1";
14783     char mountpoint[] = "/";
14784     int r;
14785     suppress_error = 0;
14786     r = guestfs_mount (g, device, mountpoint);
14787     if (r == -1)
14788       return -1;
14789   }
14790   /* TestOutputTrue for is_file (0) */
14791   {
14792     char path[] = "/new";
14793     int r;
14794     suppress_error = 0;
14795     r = guestfs_touch (g, path);
14796     if (r == -1)
14797       return -1;
14798   }
14799   {
14800     char path[] = "/new";
14801     int r;
14802     suppress_error = 0;
14803     r = guestfs_is_file (g, path);
14804     if (r == -1)
14805       return -1;
14806     if (!r) {
14807       fprintf (stderr, "test_is_file_0: expected true, got false\n");
14808       return -1;
14809     }
14810   }
14811   return 0;
14812 }
14813
14814 static int test_is_file_1_skip (void)
14815 {
14816   const char *str;
14817
14818   str = getenv ("TEST_ONLY");
14819   if (str)
14820     return strstr (str, "is_file") == NULL;
14821   str = getenv ("SKIP_TEST_IS_FILE_1");
14822   if (str && strcmp (str, "1") == 0) return 1;
14823   str = getenv ("SKIP_TEST_IS_FILE");
14824   if (str && strcmp (str, "1") == 0) return 1;
14825   return 0;
14826 }
14827
14828 static int test_is_file_1 (void)
14829 {
14830   if (test_is_file_1_skip ()) {
14831     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
14832     return 0;
14833   }
14834
14835   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
14836   {
14837     char device[] = "/dev/sda";
14838     int r;
14839     suppress_error = 0;
14840     r = guestfs_blockdev_setrw (g, device);
14841     if (r == -1)
14842       return -1;
14843   }
14844   {
14845     int r;
14846     suppress_error = 0;
14847     r = guestfs_umount_all (g);
14848     if (r == -1)
14849       return -1;
14850   }
14851   {
14852     int r;
14853     suppress_error = 0;
14854     r = guestfs_lvm_remove_all (g);
14855     if (r == -1)
14856       return -1;
14857   }
14858   {
14859     char device[] = "/dev/sda";
14860     char lines_0[] = ",";
14861     char *lines[] = {
14862       lines_0,
14863       NULL
14864     };
14865     int r;
14866     suppress_error = 0;
14867     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14868     if (r == -1)
14869       return -1;
14870   }
14871   {
14872     char fstype[] = "ext2";
14873     char device[] = "/dev/sda1";
14874     int r;
14875     suppress_error = 0;
14876     r = guestfs_mkfs (g, fstype, device);
14877     if (r == -1)
14878       return -1;
14879   }
14880   {
14881     char device[] = "/dev/sda1";
14882     char mountpoint[] = "/";
14883     int r;
14884     suppress_error = 0;
14885     r = guestfs_mount (g, device, mountpoint);
14886     if (r == -1)
14887       return -1;
14888   }
14889   /* TestOutputFalse for is_file (1) */
14890   {
14891     char path[] = "/new";
14892     int r;
14893     suppress_error = 0;
14894     r = guestfs_mkdir (g, path);
14895     if (r == -1)
14896       return -1;
14897   }
14898   {
14899     char path[] = "/new";
14900     int r;
14901     suppress_error = 0;
14902     r = guestfs_is_file (g, path);
14903     if (r == -1)
14904       return -1;
14905     if (r) {
14906       fprintf (stderr, "test_is_file_1: expected false, got true\n");
14907       return -1;
14908     }
14909   }
14910   return 0;
14911 }
14912
14913 static int test_exists_0_skip (void)
14914 {
14915   const char *str;
14916
14917   str = getenv ("TEST_ONLY");
14918   if (str)
14919     return strstr (str, "exists") == NULL;
14920   str = getenv ("SKIP_TEST_EXISTS_0");
14921   if (str && strcmp (str, "1") == 0) return 1;
14922   str = getenv ("SKIP_TEST_EXISTS");
14923   if (str && strcmp (str, "1") == 0) return 1;
14924   return 0;
14925 }
14926
14927 static int test_exists_0 (void)
14928 {
14929   if (test_exists_0_skip ()) {
14930     printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
14931     return 0;
14932   }
14933
14934   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
14935   {
14936     char device[] = "/dev/sda";
14937     int r;
14938     suppress_error = 0;
14939     r = guestfs_blockdev_setrw (g, device);
14940     if (r == -1)
14941       return -1;
14942   }
14943   {
14944     int r;
14945     suppress_error = 0;
14946     r = guestfs_umount_all (g);
14947     if (r == -1)
14948       return -1;
14949   }
14950   {
14951     int r;
14952     suppress_error = 0;
14953     r = guestfs_lvm_remove_all (g);
14954     if (r == -1)
14955       return -1;
14956   }
14957   {
14958     char device[] = "/dev/sda";
14959     char lines_0[] = ",";
14960     char *lines[] = {
14961       lines_0,
14962       NULL
14963     };
14964     int r;
14965     suppress_error = 0;
14966     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14967     if (r == -1)
14968       return -1;
14969   }
14970   {
14971     char fstype[] = "ext2";
14972     char device[] = "/dev/sda1";
14973     int r;
14974     suppress_error = 0;
14975     r = guestfs_mkfs (g, fstype, device);
14976     if (r == -1)
14977       return -1;
14978   }
14979   {
14980     char device[] = "/dev/sda1";
14981     char mountpoint[] = "/";
14982     int r;
14983     suppress_error = 0;
14984     r = guestfs_mount (g, device, mountpoint);
14985     if (r == -1)
14986       return -1;
14987   }
14988   /* TestOutputTrue for exists (0) */
14989   {
14990     char path[] = "/new";
14991     int r;
14992     suppress_error = 0;
14993     r = guestfs_touch (g, path);
14994     if (r == -1)
14995       return -1;
14996   }
14997   {
14998     char path[] = "/new";
14999     int r;
15000     suppress_error = 0;
15001     r = guestfs_exists (g, path);
15002     if (r == -1)
15003       return -1;
15004     if (!r) {
15005       fprintf (stderr, "test_exists_0: expected true, got false\n");
15006       return -1;
15007     }
15008   }
15009   return 0;
15010 }
15011
15012 static int test_exists_1_skip (void)
15013 {
15014   const char *str;
15015
15016   str = getenv ("TEST_ONLY");
15017   if (str)
15018     return strstr (str, "exists") == NULL;
15019   str = getenv ("SKIP_TEST_EXISTS_1");
15020   if (str && strcmp (str, "1") == 0) return 1;
15021   str = getenv ("SKIP_TEST_EXISTS");
15022   if (str && strcmp (str, "1") == 0) return 1;
15023   return 0;
15024 }
15025
15026 static int test_exists_1 (void)
15027 {
15028   if (test_exists_1_skip ()) {
15029     printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15030     return 0;
15031   }
15032
15033   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15034   {
15035     char device[] = "/dev/sda";
15036     int r;
15037     suppress_error = 0;
15038     r = guestfs_blockdev_setrw (g, device);
15039     if (r == -1)
15040       return -1;
15041   }
15042   {
15043     int r;
15044     suppress_error = 0;
15045     r = guestfs_umount_all (g);
15046     if (r == -1)
15047       return -1;
15048   }
15049   {
15050     int r;
15051     suppress_error = 0;
15052     r = guestfs_lvm_remove_all (g);
15053     if (r == -1)
15054       return -1;
15055   }
15056   {
15057     char device[] = "/dev/sda";
15058     char lines_0[] = ",";
15059     char *lines[] = {
15060       lines_0,
15061       NULL
15062     };
15063     int r;
15064     suppress_error = 0;
15065     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15066     if (r == -1)
15067       return -1;
15068   }
15069   {
15070     char fstype[] = "ext2";
15071     char device[] = "/dev/sda1";
15072     int r;
15073     suppress_error = 0;
15074     r = guestfs_mkfs (g, fstype, device);
15075     if (r == -1)
15076       return -1;
15077   }
15078   {
15079     char device[] = "/dev/sda1";
15080     char mountpoint[] = "/";
15081     int r;
15082     suppress_error = 0;
15083     r = guestfs_mount (g, device, mountpoint);
15084     if (r == -1)
15085       return -1;
15086   }
15087   /* TestOutputTrue for exists (1) */
15088   {
15089     char path[] = "/new";
15090     int r;
15091     suppress_error = 0;
15092     r = guestfs_mkdir (g, path);
15093     if (r == -1)
15094       return -1;
15095   }
15096   {
15097     char path[] = "/new";
15098     int r;
15099     suppress_error = 0;
15100     r = guestfs_exists (g, path);
15101     if (r == -1)
15102       return -1;
15103     if (!r) {
15104       fprintf (stderr, "test_exists_1: expected true, got false\n");
15105       return -1;
15106     }
15107   }
15108   return 0;
15109 }
15110
15111 static int test_mkdir_p_0_skip (void)
15112 {
15113   const char *str;
15114
15115   str = getenv ("TEST_ONLY");
15116   if (str)
15117     return strstr (str, "mkdir_p") == NULL;
15118   str = getenv ("SKIP_TEST_MKDIR_P_0");
15119   if (str && strcmp (str, "1") == 0) return 1;
15120   str = getenv ("SKIP_TEST_MKDIR_P");
15121   if (str && strcmp (str, "1") == 0) return 1;
15122   return 0;
15123 }
15124
15125 static int test_mkdir_p_0 (void)
15126 {
15127   if (test_mkdir_p_0_skip ()) {
15128     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15129     return 0;
15130   }
15131
15132   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15133   {
15134     char device[] = "/dev/sda";
15135     int r;
15136     suppress_error = 0;
15137     r = guestfs_blockdev_setrw (g, device);
15138     if (r == -1)
15139       return -1;
15140   }
15141   {
15142     int r;
15143     suppress_error = 0;
15144     r = guestfs_umount_all (g);
15145     if (r == -1)
15146       return -1;
15147   }
15148   {
15149     int r;
15150     suppress_error = 0;
15151     r = guestfs_lvm_remove_all (g);
15152     if (r == -1)
15153       return -1;
15154   }
15155   {
15156     char device[] = "/dev/sda";
15157     char lines_0[] = ",";
15158     char *lines[] = {
15159       lines_0,
15160       NULL
15161     };
15162     int r;
15163     suppress_error = 0;
15164     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15165     if (r == -1)
15166       return -1;
15167   }
15168   {
15169     char fstype[] = "ext2";
15170     char device[] = "/dev/sda1";
15171     int r;
15172     suppress_error = 0;
15173     r = guestfs_mkfs (g, fstype, device);
15174     if (r == -1)
15175       return -1;
15176   }
15177   {
15178     char device[] = "/dev/sda1";
15179     char mountpoint[] = "/";
15180     int r;
15181     suppress_error = 0;
15182     r = guestfs_mount (g, device, mountpoint);
15183     if (r == -1)
15184       return -1;
15185   }
15186   /* TestOutputTrue for mkdir_p (0) */
15187   {
15188     char path[] = "/new/foo/bar";
15189     int r;
15190     suppress_error = 0;
15191     r = guestfs_mkdir_p (g, path);
15192     if (r == -1)
15193       return -1;
15194   }
15195   {
15196     char path[] = "/new/foo/bar";
15197     int r;
15198     suppress_error = 0;
15199     r = guestfs_is_dir (g, path);
15200     if (r == -1)
15201       return -1;
15202     if (!r) {
15203       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15204       return -1;
15205     }
15206   }
15207   return 0;
15208 }
15209
15210 static int test_mkdir_p_1_skip (void)
15211 {
15212   const char *str;
15213
15214   str = getenv ("TEST_ONLY");
15215   if (str)
15216     return strstr (str, "mkdir_p") == NULL;
15217   str = getenv ("SKIP_TEST_MKDIR_P_1");
15218   if (str && strcmp (str, "1") == 0) return 1;
15219   str = getenv ("SKIP_TEST_MKDIR_P");
15220   if (str && strcmp (str, "1") == 0) return 1;
15221   return 0;
15222 }
15223
15224 static int test_mkdir_p_1 (void)
15225 {
15226   if (test_mkdir_p_1_skip ()) {
15227     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15228     return 0;
15229   }
15230
15231   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15232   {
15233     char device[] = "/dev/sda";
15234     int r;
15235     suppress_error = 0;
15236     r = guestfs_blockdev_setrw (g, device);
15237     if (r == -1)
15238       return -1;
15239   }
15240   {
15241     int r;
15242     suppress_error = 0;
15243     r = guestfs_umount_all (g);
15244     if (r == -1)
15245       return -1;
15246   }
15247   {
15248     int r;
15249     suppress_error = 0;
15250     r = guestfs_lvm_remove_all (g);
15251     if (r == -1)
15252       return -1;
15253   }
15254   {
15255     char device[] = "/dev/sda";
15256     char lines_0[] = ",";
15257     char *lines[] = {
15258       lines_0,
15259       NULL
15260     };
15261     int r;
15262     suppress_error = 0;
15263     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15264     if (r == -1)
15265       return -1;
15266   }
15267   {
15268     char fstype[] = "ext2";
15269     char device[] = "/dev/sda1";
15270     int r;
15271     suppress_error = 0;
15272     r = guestfs_mkfs (g, fstype, device);
15273     if (r == -1)
15274       return -1;
15275   }
15276   {
15277     char device[] = "/dev/sda1";
15278     char mountpoint[] = "/";
15279     int r;
15280     suppress_error = 0;
15281     r = guestfs_mount (g, device, mountpoint);
15282     if (r == -1)
15283       return -1;
15284   }
15285   /* TestOutputTrue for mkdir_p (1) */
15286   {
15287     char path[] = "/new/foo/bar";
15288     int r;
15289     suppress_error = 0;
15290     r = guestfs_mkdir_p (g, path);
15291     if (r == -1)
15292       return -1;
15293   }
15294   {
15295     char path[] = "/new/foo";
15296     int r;
15297     suppress_error = 0;
15298     r = guestfs_is_dir (g, path);
15299     if (r == -1)
15300       return -1;
15301     if (!r) {
15302       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15303       return -1;
15304     }
15305   }
15306   return 0;
15307 }
15308
15309 static int test_mkdir_p_2_skip (void)
15310 {
15311   const char *str;
15312
15313   str = getenv ("TEST_ONLY");
15314   if (str)
15315     return strstr (str, "mkdir_p") == NULL;
15316   str = getenv ("SKIP_TEST_MKDIR_P_2");
15317   if (str && strcmp (str, "1") == 0) return 1;
15318   str = getenv ("SKIP_TEST_MKDIR_P");
15319   if (str && strcmp (str, "1") == 0) return 1;
15320   return 0;
15321 }
15322
15323 static int test_mkdir_p_2 (void)
15324 {
15325   if (test_mkdir_p_2_skip ()) {
15326     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15327     return 0;
15328   }
15329
15330   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15331   {
15332     char device[] = "/dev/sda";
15333     int r;
15334     suppress_error = 0;
15335     r = guestfs_blockdev_setrw (g, device);
15336     if (r == -1)
15337       return -1;
15338   }
15339   {
15340     int r;
15341     suppress_error = 0;
15342     r = guestfs_umount_all (g);
15343     if (r == -1)
15344       return -1;
15345   }
15346   {
15347     int r;
15348     suppress_error = 0;
15349     r = guestfs_lvm_remove_all (g);
15350     if (r == -1)
15351       return -1;
15352   }
15353   {
15354     char device[] = "/dev/sda";
15355     char lines_0[] = ",";
15356     char *lines[] = {
15357       lines_0,
15358       NULL
15359     };
15360     int r;
15361     suppress_error = 0;
15362     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15363     if (r == -1)
15364       return -1;
15365   }
15366   {
15367     char fstype[] = "ext2";
15368     char device[] = "/dev/sda1";
15369     int r;
15370     suppress_error = 0;
15371     r = guestfs_mkfs (g, fstype, device);
15372     if (r == -1)
15373       return -1;
15374   }
15375   {
15376     char device[] = "/dev/sda1";
15377     char mountpoint[] = "/";
15378     int r;
15379     suppress_error = 0;
15380     r = guestfs_mount (g, device, mountpoint);
15381     if (r == -1)
15382       return -1;
15383   }
15384   /* TestOutputTrue for mkdir_p (2) */
15385   {
15386     char path[] = "/new/foo/bar";
15387     int r;
15388     suppress_error = 0;
15389     r = guestfs_mkdir_p (g, path);
15390     if (r == -1)
15391       return -1;
15392   }
15393   {
15394     char path[] = "/new";
15395     int r;
15396     suppress_error = 0;
15397     r = guestfs_is_dir (g, path);
15398     if (r == -1)
15399       return -1;
15400     if (!r) {
15401       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15402       return -1;
15403     }
15404   }
15405   return 0;
15406 }
15407
15408 static int test_mkdir_p_3_skip (void)
15409 {
15410   const char *str;
15411
15412   str = getenv ("TEST_ONLY");
15413   if (str)
15414     return strstr (str, "mkdir_p") == NULL;
15415   str = getenv ("SKIP_TEST_MKDIR_P_3");
15416   if (str && strcmp (str, "1") == 0) return 1;
15417   str = getenv ("SKIP_TEST_MKDIR_P");
15418   if (str && strcmp (str, "1") == 0) return 1;
15419   return 0;
15420 }
15421
15422 static int test_mkdir_p_3 (void)
15423 {
15424   if (test_mkdir_p_3_skip ()) {
15425     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15426     return 0;
15427   }
15428
15429   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15430   {
15431     char device[] = "/dev/sda";
15432     int r;
15433     suppress_error = 0;
15434     r = guestfs_blockdev_setrw (g, device);
15435     if (r == -1)
15436       return -1;
15437   }
15438   {
15439     int r;
15440     suppress_error = 0;
15441     r = guestfs_umount_all (g);
15442     if (r == -1)
15443       return -1;
15444   }
15445   {
15446     int r;
15447     suppress_error = 0;
15448     r = guestfs_lvm_remove_all (g);
15449     if (r == -1)
15450       return -1;
15451   }
15452   {
15453     char device[] = "/dev/sda";
15454     char lines_0[] = ",";
15455     char *lines[] = {
15456       lines_0,
15457       NULL
15458     };
15459     int r;
15460     suppress_error = 0;
15461     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15462     if (r == -1)
15463       return -1;
15464   }
15465   {
15466     char fstype[] = "ext2";
15467     char device[] = "/dev/sda1";
15468     int r;
15469     suppress_error = 0;
15470     r = guestfs_mkfs (g, fstype, device);
15471     if (r == -1)
15472       return -1;
15473   }
15474   {
15475     char device[] = "/dev/sda1";
15476     char mountpoint[] = "/";
15477     int r;
15478     suppress_error = 0;
15479     r = guestfs_mount (g, device, mountpoint);
15480     if (r == -1)
15481       return -1;
15482   }
15483   /* TestRun for mkdir_p (3) */
15484   {
15485     char path[] = "/new";
15486     int r;
15487     suppress_error = 0;
15488     r = guestfs_mkdir (g, path);
15489     if (r == -1)
15490       return -1;
15491   }
15492   {
15493     char path[] = "/new";
15494     int r;
15495     suppress_error = 0;
15496     r = guestfs_mkdir_p (g, path);
15497     if (r == -1)
15498       return -1;
15499   }
15500   return 0;
15501 }
15502
15503 static int test_mkdir_p_4_skip (void)
15504 {
15505   const char *str;
15506
15507   str = getenv ("TEST_ONLY");
15508   if (str)
15509     return strstr (str, "mkdir_p") == NULL;
15510   str = getenv ("SKIP_TEST_MKDIR_P_4");
15511   if (str && strcmp (str, "1") == 0) return 1;
15512   str = getenv ("SKIP_TEST_MKDIR_P");
15513   if (str && strcmp (str, "1") == 0) return 1;
15514   return 0;
15515 }
15516
15517 static int test_mkdir_p_4 (void)
15518 {
15519   if (test_mkdir_p_4_skip ()) {
15520     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15521     return 0;
15522   }
15523
15524   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
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   {
15548     char device[] = "/dev/sda";
15549     char lines_0[] = ",";
15550     char *lines[] = {
15551       lines_0,
15552       NULL
15553     };
15554     int r;
15555     suppress_error = 0;
15556     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15557     if (r == -1)
15558       return -1;
15559   }
15560   {
15561     char fstype[] = "ext2";
15562     char device[] = "/dev/sda1";
15563     int r;
15564     suppress_error = 0;
15565     r = guestfs_mkfs (g, fstype, device);
15566     if (r == -1)
15567       return -1;
15568   }
15569   {
15570     char device[] = "/dev/sda1";
15571     char mountpoint[] = "/";
15572     int r;
15573     suppress_error = 0;
15574     r = guestfs_mount (g, device, mountpoint);
15575     if (r == -1)
15576       return -1;
15577   }
15578   /* TestLastFail for mkdir_p (4) */
15579   {
15580     char path[] = "/new";
15581     int r;
15582     suppress_error = 0;
15583     r = guestfs_touch (g, path);
15584     if (r == -1)
15585       return -1;
15586   }
15587   {
15588     char path[] = "/new";
15589     int r;
15590     suppress_error = 1;
15591     r = guestfs_mkdir_p (g, path);
15592     if (r != -1)
15593       return -1;
15594   }
15595   return 0;
15596 }
15597
15598 static int test_mkdir_0_skip (void)
15599 {
15600   const char *str;
15601
15602   str = getenv ("TEST_ONLY");
15603   if (str)
15604     return strstr (str, "mkdir") == NULL;
15605   str = getenv ("SKIP_TEST_MKDIR_0");
15606   if (str && strcmp (str, "1") == 0) return 1;
15607   str = getenv ("SKIP_TEST_MKDIR");
15608   if (str && strcmp (str, "1") == 0) return 1;
15609   return 0;
15610 }
15611
15612 static int test_mkdir_0 (void)
15613 {
15614   if (test_mkdir_0_skip ()) {
15615     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15616     return 0;
15617   }
15618
15619   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15620   {
15621     char device[] = "/dev/sda";
15622     int r;
15623     suppress_error = 0;
15624     r = guestfs_blockdev_setrw (g, device);
15625     if (r == -1)
15626       return -1;
15627   }
15628   {
15629     int r;
15630     suppress_error = 0;
15631     r = guestfs_umount_all (g);
15632     if (r == -1)
15633       return -1;
15634   }
15635   {
15636     int r;
15637     suppress_error = 0;
15638     r = guestfs_lvm_remove_all (g);
15639     if (r == -1)
15640       return -1;
15641   }
15642   {
15643     char device[] = "/dev/sda";
15644     char lines_0[] = ",";
15645     char *lines[] = {
15646       lines_0,
15647       NULL
15648     };
15649     int r;
15650     suppress_error = 0;
15651     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15652     if (r == -1)
15653       return -1;
15654   }
15655   {
15656     char fstype[] = "ext2";
15657     char device[] = "/dev/sda1";
15658     int r;
15659     suppress_error = 0;
15660     r = guestfs_mkfs (g, fstype, device);
15661     if (r == -1)
15662       return -1;
15663   }
15664   {
15665     char device[] = "/dev/sda1";
15666     char mountpoint[] = "/";
15667     int r;
15668     suppress_error = 0;
15669     r = guestfs_mount (g, device, mountpoint);
15670     if (r == -1)
15671       return -1;
15672   }
15673   /* TestOutputTrue for mkdir (0) */
15674   {
15675     char path[] = "/new";
15676     int r;
15677     suppress_error = 0;
15678     r = guestfs_mkdir (g, path);
15679     if (r == -1)
15680       return -1;
15681   }
15682   {
15683     char path[] = "/new";
15684     int r;
15685     suppress_error = 0;
15686     r = guestfs_is_dir (g, path);
15687     if (r == -1)
15688       return -1;
15689     if (!r) {
15690       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
15691       return -1;
15692     }
15693   }
15694   return 0;
15695 }
15696
15697 static int test_mkdir_1_skip (void)
15698 {
15699   const char *str;
15700
15701   str = getenv ("TEST_ONLY");
15702   if (str)
15703     return strstr (str, "mkdir") == NULL;
15704   str = getenv ("SKIP_TEST_MKDIR_1");
15705   if (str && strcmp (str, "1") == 0) return 1;
15706   str = getenv ("SKIP_TEST_MKDIR");
15707   if (str && strcmp (str, "1") == 0) return 1;
15708   return 0;
15709 }
15710
15711 static int test_mkdir_1 (void)
15712 {
15713   if (test_mkdir_1_skip ()) {
15714     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
15715     return 0;
15716   }
15717
15718   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
15719   {
15720     char device[] = "/dev/sda";
15721     int r;
15722     suppress_error = 0;
15723     r = guestfs_blockdev_setrw (g, device);
15724     if (r == -1)
15725       return -1;
15726   }
15727   {
15728     int r;
15729     suppress_error = 0;
15730     r = guestfs_umount_all (g);
15731     if (r == -1)
15732       return -1;
15733   }
15734   {
15735     int r;
15736     suppress_error = 0;
15737     r = guestfs_lvm_remove_all (g);
15738     if (r == -1)
15739       return -1;
15740   }
15741   {
15742     char device[] = "/dev/sda";
15743     char lines_0[] = ",";
15744     char *lines[] = {
15745       lines_0,
15746       NULL
15747     };
15748     int r;
15749     suppress_error = 0;
15750     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15751     if (r == -1)
15752       return -1;
15753   }
15754   {
15755     char fstype[] = "ext2";
15756     char device[] = "/dev/sda1";
15757     int r;
15758     suppress_error = 0;
15759     r = guestfs_mkfs (g, fstype, device);
15760     if (r == -1)
15761       return -1;
15762   }
15763   {
15764     char device[] = "/dev/sda1";
15765     char mountpoint[] = "/";
15766     int r;
15767     suppress_error = 0;
15768     r = guestfs_mount (g, device, mountpoint);
15769     if (r == -1)
15770       return -1;
15771   }
15772   /* TestLastFail for mkdir (1) */
15773   {
15774     char path[] = "/new/foo/bar";
15775     int r;
15776     suppress_error = 1;
15777     r = guestfs_mkdir (g, path);
15778     if (r != -1)
15779       return -1;
15780   }
15781   return 0;
15782 }
15783
15784 static int test_rm_rf_0_skip (void)
15785 {
15786   const char *str;
15787
15788   str = getenv ("TEST_ONLY");
15789   if (str)
15790     return strstr (str, "rm_rf") == NULL;
15791   str = getenv ("SKIP_TEST_RM_RF_0");
15792   if (str && strcmp (str, "1") == 0) return 1;
15793   str = getenv ("SKIP_TEST_RM_RF");
15794   if (str && strcmp (str, "1") == 0) return 1;
15795   return 0;
15796 }
15797
15798 static int test_rm_rf_0 (void)
15799 {
15800   if (test_rm_rf_0_skip ()) {
15801     printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
15802     return 0;
15803   }
15804
15805   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
15806   {
15807     char device[] = "/dev/sda";
15808     int r;
15809     suppress_error = 0;
15810     r = guestfs_blockdev_setrw (g, device);
15811     if (r == -1)
15812       return -1;
15813   }
15814   {
15815     int r;
15816     suppress_error = 0;
15817     r = guestfs_umount_all (g);
15818     if (r == -1)
15819       return -1;
15820   }
15821   {
15822     int r;
15823     suppress_error = 0;
15824     r = guestfs_lvm_remove_all (g);
15825     if (r == -1)
15826       return -1;
15827   }
15828   {
15829     char device[] = "/dev/sda";
15830     char lines_0[] = ",";
15831     char *lines[] = {
15832       lines_0,
15833       NULL
15834     };
15835     int r;
15836     suppress_error = 0;
15837     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15838     if (r == -1)
15839       return -1;
15840   }
15841   {
15842     char fstype[] = "ext2";
15843     char device[] = "/dev/sda1";
15844     int r;
15845     suppress_error = 0;
15846     r = guestfs_mkfs (g, fstype, device);
15847     if (r == -1)
15848       return -1;
15849   }
15850   {
15851     char device[] = "/dev/sda1";
15852     char mountpoint[] = "/";
15853     int r;
15854     suppress_error = 0;
15855     r = guestfs_mount (g, device, mountpoint);
15856     if (r == -1)
15857       return -1;
15858   }
15859   /* TestOutputFalse for rm_rf (0) */
15860   {
15861     char path[] = "/new";
15862     int r;
15863     suppress_error = 0;
15864     r = guestfs_mkdir (g, path);
15865     if (r == -1)
15866       return -1;
15867   }
15868   {
15869     char path[] = "/new/foo";
15870     int r;
15871     suppress_error = 0;
15872     r = guestfs_mkdir (g, path);
15873     if (r == -1)
15874       return -1;
15875   }
15876   {
15877     char path[] = "/new/foo/bar";
15878     int r;
15879     suppress_error = 0;
15880     r = guestfs_touch (g, path);
15881     if (r == -1)
15882       return -1;
15883   }
15884   {
15885     char path[] = "/new";
15886     int r;
15887     suppress_error = 0;
15888     r = guestfs_rm_rf (g, path);
15889     if (r == -1)
15890       return -1;
15891   }
15892   {
15893     char path[] = "/new";
15894     int r;
15895     suppress_error = 0;
15896     r = guestfs_exists (g, path);
15897     if (r == -1)
15898       return -1;
15899     if (r) {
15900       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
15901       return -1;
15902     }
15903   }
15904   return 0;
15905 }
15906
15907 static int test_rmdir_0_skip (void)
15908 {
15909   const char *str;
15910
15911   str = getenv ("TEST_ONLY");
15912   if (str)
15913     return strstr (str, "rmdir") == NULL;
15914   str = getenv ("SKIP_TEST_RMDIR_0");
15915   if (str && strcmp (str, "1") == 0) return 1;
15916   str = getenv ("SKIP_TEST_RMDIR");
15917   if (str && strcmp (str, "1") == 0) return 1;
15918   return 0;
15919 }
15920
15921 static int test_rmdir_0 (void)
15922 {
15923   if (test_rmdir_0_skip ()) {
15924     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
15925     return 0;
15926   }
15927
15928   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
15929   {
15930     char device[] = "/dev/sda";
15931     int r;
15932     suppress_error = 0;
15933     r = guestfs_blockdev_setrw (g, device);
15934     if (r == -1)
15935       return -1;
15936   }
15937   {
15938     int r;
15939     suppress_error = 0;
15940     r = guestfs_umount_all (g);
15941     if (r == -1)
15942       return -1;
15943   }
15944   {
15945     int r;
15946     suppress_error = 0;
15947     r = guestfs_lvm_remove_all (g);
15948     if (r == -1)
15949       return -1;
15950   }
15951   {
15952     char device[] = "/dev/sda";
15953     char lines_0[] = ",";
15954     char *lines[] = {
15955       lines_0,
15956       NULL
15957     };
15958     int r;
15959     suppress_error = 0;
15960     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15961     if (r == -1)
15962       return -1;
15963   }
15964   {
15965     char fstype[] = "ext2";
15966     char device[] = "/dev/sda1";
15967     int r;
15968     suppress_error = 0;
15969     r = guestfs_mkfs (g, fstype, device);
15970     if (r == -1)
15971       return -1;
15972   }
15973   {
15974     char device[] = "/dev/sda1";
15975     char mountpoint[] = "/";
15976     int r;
15977     suppress_error = 0;
15978     r = guestfs_mount (g, device, mountpoint);
15979     if (r == -1)
15980       return -1;
15981   }
15982   /* TestRun for rmdir (0) */
15983   {
15984     char path[] = "/new";
15985     int r;
15986     suppress_error = 0;
15987     r = guestfs_mkdir (g, path);
15988     if (r == -1)
15989       return -1;
15990   }
15991   {
15992     char path[] = "/new";
15993     int r;
15994     suppress_error = 0;
15995     r = guestfs_rmdir (g, path);
15996     if (r == -1)
15997       return -1;
15998   }
15999   return 0;
16000 }
16001
16002 static int test_rmdir_1_skip (void)
16003 {
16004   const char *str;
16005
16006   str = getenv ("TEST_ONLY");
16007   if (str)
16008     return strstr (str, "rmdir") == NULL;
16009   str = getenv ("SKIP_TEST_RMDIR_1");
16010   if (str && strcmp (str, "1") == 0) return 1;
16011   str = getenv ("SKIP_TEST_RMDIR");
16012   if (str && strcmp (str, "1") == 0) return 1;
16013   return 0;
16014 }
16015
16016 static int test_rmdir_1 (void)
16017 {
16018   if (test_rmdir_1_skip ()) {
16019     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16020     return 0;
16021   }
16022
16023   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16024   {
16025     char device[] = "/dev/sda";
16026     int r;
16027     suppress_error = 0;
16028     r = guestfs_blockdev_setrw (g, device);
16029     if (r == -1)
16030       return -1;
16031   }
16032   {
16033     int r;
16034     suppress_error = 0;
16035     r = guestfs_umount_all (g);
16036     if (r == -1)
16037       return -1;
16038   }
16039   {
16040     int r;
16041     suppress_error = 0;
16042     r = guestfs_lvm_remove_all (g);
16043     if (r == -1)
16044       return -1;
16045   }
16046   {
16047     char device[] = "/dev/sda";
16048     char lines_0[] = ",";
16049     char *lines[] = {
16050       lines_0,
16051       NULL
16052     };
16053     int r;
16054     suppress_error = 0;
16055     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16056     if (r == -1)
16057       return -1;
16058   }
16059   {
16060     char fstype[] = "ext2";
16061     char device[] = "/dev/sda1";
16062     int r;
16063     suppress_error = 0;
16064     r = guestfs_mkfs (g, fstype, device);
16065     if (r == -1)
16066       return -1;
16067   }
16068   {
16069     char device[] = "/dev/sda1";
16070     char mountpoint[] = "/";
16071     int r;
16072     suppress_error = 0;
16073     r = guestfs_mount (g, device, mountpoint);
16074     if (r == -1)
16075       return -1;
16076   }
16077   /* TestLastFail for rmdir (1) */
16078   {
16079     char path[] = "/new";
16080     int r;
16081     suppress_error = 1;
16082     r = guestfs_rmdir (g, path);
16083     if (r != -1)
16084       return -1;
16085   }
16086   return 0;
16087 }
16088
16089 static int test_rmdir_2_skip (void)
16090 {
16091   const char *str;
16092
16093   str = getenv ("TEST_ONLY");
16094   if (str)
16095     return strstr (str, "rmdir") == NULL;
16096   str = getenv ("SKIP_TEST_RMDIR_2");
16097   if (str && strcmp (str, "1") == 0) return 1;
16098   str = getenv ("SKIP_TEST_RMDIR");
16099   if (str && strcmp (str, "1") == 0) return 1;
16100   return 0;
16101 }
16102
16103 static int test_rmdir_2 (void)
16104 {
16105   if (test_rmdir_2_skip ()) {
16106     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16107     return 0;
16108   }
16109
16110   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16111   {
16112     char device[] = "/dev/sda";
16113     int r;
16114     suppress_error = 0;
16115     r = guestfs_blockdev_setrw (g, device);
16116     if (r == -1)
16117       return -1;
16118   }
16119   {
16120     int r;
16121     suppress_error = 0;
16122     r = guestfs_umount_all (g);
16123     if (r == -1)
16124       return -1;
16125   }
16126   {
16127     int r;
16128     suppress_error = 0;
16129     r = guestfs_lvm_remove_all (g);
16130     if (r == -1)
16131       return -1;
16132   }
16133   {
16134     char device[] = "/dev/sda";
16135     char lines_0[] = ",";
16136     char *lines[] = {
16137       lines_0,
16138       NULL
16139     };
16140     int r;
16141     suppress_error = 0;
16142     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16143     if (r == -1)
16144       return -1;
16145   }
16146   {
16147     char fstype[] = "ext2";
16148     char device[] = "/dev/sda1";
16149     int r;
16150     suppress_error = 0;
16151     r = guestfs_mkfs (g, fstype, device);
16152     if (r == -1)
16153       return -1;
16154   }
16155   {
16156     char device[] = "/dev/sda1";
16157     char mountpoint[] = "/";
16158     int r;
16159     suppress_error = 0;
16160     r = guestfs_mount (g, device, mountpoint);
16161     if (r == -1)
16162       return -1;
16163   }
16164   /* TestLastFail for rmdir (2) */
16165   {
16166     char path[] = "/new";
16167     int r;
16168     suppress_error = 0;
16169     r = guestfs_touch (g, path);
16170     if (r == -1)
16171       return -1;
16172   }
16173   {
16174     char path[] = "/new";
16175     int r;
16176     suppress_error = 1;
16177     r = guestfs_rmdir (g, path);
16178     if (r != -1)
16179       return -1;
16180   }
16181   return 0;
16182 }
16183
16184 static int test_rm_0_skip (void)
16185 {
16186   const char *str;
16187
16188   str = getenv ("TEST_ONLY");
16189   if (str)
16190     return strstr (str, "rm") == NULL;
16191   str = getenv ("SKIP_TEST_RM_0");
16192   if (str && strcmp (str, "1") == 0) return 1;
16193   str = getenv ("SKIP_TEST_RM");
16194   if (str && strcmp (str, "1") == 0) return 1;
16195   return 0;
16196 }
16197
16198 static int test_rm_0 (void)
16199 {
16200   if (test_rm_0_skip ()) {
16201     printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16202     return 0;
16203   }
16204
16205   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16206   {
16207     char device[] = "/dev/sda";
16208     int r;
16209     suppress_error = 0;
16210     r = guestfs_blockdev_setrw (g, device);
16211     if (r == -1)
16212       return -1;
16213   }
16214   {
16215     int r;
16216     suppress_error = 0;
16217     r = guestfs_umount_all (g);
16218     if (r == -1)
16219       return -1;
16220   }
16221   {
16222     int r;
16223     suppress_error = 0;
16224     r = guestfs_lvm_remove_all (g);
16225     if (r == -1)
16226       return -1;
16227   }
16228   {
16229     char device[] = "/dev/sda";
16230     char lines_0[] = ",";
16231     char *lines[] = {
16232       lines_0,
16233       NULL
16234     };
16235     int r;
16236     suppress_error = 0;
16237     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16238     if (r == -1)
16239       return -1;
16240   }
16241   {
16242     char fstype[] = "ext2";
16243     char device[] = "/dev/sda1";
16244     int r;
16245     suppress_error = 0;
16246     r = guestfs_mkfs (g, fstype, device);
16247     if (r == -1)
16248       return -1;
16249   }
16250   {
16251     char device[] = "/dev/sda1";
16252     char mountpoint[] = "/";
16253     int r;
16254     suppress_error = 0;
16255     r = guestfs_mount (g, device, mountpoint);
16256     if (r == -1)
16257       return -1;
16258   }
16259   /* TestRun for rm (0) */
16260   {
16261     char path[] = "/new";
16262     int r;
16263     suppress_error = 0;
16264     r = guestfs_touch (g, path);
16265     if (r == -1)
16266       return -1;
16267   }
16268   {
16269     char path[] = "/new";
16270     int r;
16271     suppress_error = 0;
16272     r = guestfs_rm (g, path);
16273     if (r == -1)
16274       return -1;
16275   }
16276   return 0;
16277 }
16278
16279 static int test_rm_1_skip (void)
16280 {
16281   const char *str;
16282
16283   str = getenv ("TEST_ONLY");
16284   if (str)
16285     return strstr (str, "rm") == NULL;
16286   str = getenv ("SKIP_TEST_RM_1");
16287   if (str && strcmp (str, "1") == 0) return 1;
16288   str = getenv ("SKIP_TEST_RM");
16289   if (str && strcmp (str, "1") == 0) return 1;
16290   return 0;
16291 }
16292
16293 static int test_rm_1 (void)
16294 {
16295   if (test_rm_1_skip ()) {
16296     printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16297     return 0;
16298   }
16299
16300   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16301   {
16302     char device[] = "/dev/sda";
16303     int r;
16304     suppress_error = 0;
16305     r = guestfs_blockdev_setrw (g, device);
16306     if (r == -1)
16307       return -1;
16308   }
16309   {
16310     int r;
16311     suppress_error = 0;
16312     r = guestfs_umount_all (g);
16313     if (r == -1)
16314       return -1;
16315   }
16316   {
16317     int r;
16318     suppress_error = 0;
16319     r = guestfs_lvm_remove_all (g);
16320     if (r == -1)
16321       return -1;
16322   }
16323   {
16324     char device[] = "/dev/sda";
16325     char lines_0[] = ",";
16326     char *lines[] = {
16327       lines_0,
16328       NULL
16329     };
16330     int r;
16331     suppress_error = 0;
16332     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16333     if (r == -1)
16334       return -1;
16335   }
16336   {
16337     char fstype[] = "ext2";
16338     char device[] = "/dev/sda1";
16339     int r;
16340     suppress_error = 0;
16341     r = guestfs_mkfs (g, fstype, device);
16342     if (r == -1)
16343       return -1;
16344   }
16345   {
16346     char device[] = "/dev/sda1";
16347     char mountpoint[] = "/";
16348     int r;
16349     suppress_error = 0;
16350     r = guestfs_mount (g, device, mountpoint);
16351     if (r == -1)
16352       return -1;
16353   }
16354   /* TestLastFail for rm (1) */
16355   {
16356     char path[] = "/new";
16357     int r;
16358     suppress_error = 1;
16359     r = guestfs_rm (g, path);
16360     if (r != -1)
16361       return -1;
16362   }
16363   return 0;
16364 }
16365
16366 static int test_rm_2_skip (void)
16367 {
16368   const char *str;
16369
16370   str = getenv ("TEST_ONLY");
16371   if (str)
16372     return strstr (str, "rm") == NULL;
16373   str = getenv ("SKIP_TEST_RM_2");
16374   if (str && strcmp (str, "1") == 0) return 1;
16375   str = getenv ("SKIP_TEST_RM");
16376   if (str && strcmp (str, "1") == 0) return 1;
16377   return 0;
16378 }
16379
16380 static int test_rm_2 (void)
16381 {
16382   if (test_rm_2_skip ()) {
16383     printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16384     return 0;
16385   }
16386
16387   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16388   {
16389     char device[] = "/dev/sda";
16390     int r;
16391     suppress_error = 0;
16392     r = guestfs_blockdev_setrw (g, device);
16393     if (r == -1)
16394       return -1;
16395   }
16396   {
16397     int r;
16398     suppress_error = 0;
16399     r = guestfs_umount_all (g);
16400     if (r == -1)
16401       return -1;
16402   }
16403   {
16404     int r;
16405     suppress_error = 0;
16406     r = guestfs_lvm_remove_all (g);
16407     if (r == -1)
16408       return -1;
16409   }
16410   {
16411     char device[] = "/dev/sda";
16412     char lines_0[] = ",";
16413     char *lines[] = {
16414       lines_0,
16415       NULL
16416     };
16417     int r;
16418     suppress_error = 0;
16419     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16420     if (r == -1)
16421       return -1;
16422   }
16423   {
16424     char fstype[] = "ext2";
16425     char device[] = "/dev/sda1";
16426     int r;
16427     suppress_error = 0;
16428     r = guestfs_mkfs (g, fstype, device);
16429     if (r == -1)
16430       return -1;
16431   }
16432   {
16433     char device[] = "/dev/sda1";
16434     char mountpoint[] = "/";
16435     int r;
16436     suppress_error = 0;
16437     r = guestfs_mount (g, device, mountpoint);
16438     if (r == -1)
16439       return -1;
16440   }
16441   /* TestLastFail for rm (2) */
16442   {
16443     char path[] = "/new";
16444     int r;
16445     suppress_error = 0;
16446     r = guestfs_mkdir (g, path);
16447     if (r == -1)
16448       return -1;
16449   }
16450   {
16451     char path[] = "/new";
16452     int r;
16453     suppress_error = 1;
16454     r = guestfs_rm (g, path);
16455     if (r != -1)
16456       return -1;
16457   }
16458   return 0;
16459 }
16460
16461 static int test_read_lines_0_skip (void)
16462 {
16463   const char *str;
16464
16465   str = getenv ("TEST_ONLY");
16466   if (str)
16467     return strstr (str, "read_lines") == NULL;
16468   str = getenv ("SKIP_TEST_READ_LINES_0");
16469   if (str && strcmp (str, "1") == 0) return 1;
16470   str = getenv ("SKIP_TEST_READ_LINES");
16471   if (str && strcmp (str, "1") == 0) return 1;
16472   return 0;
16473 }
16474
16475 static int test_read_lines_0 (void)
16476 {
16477   if (test_read_lines_0_skip ()) {
16478     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16479     return 0;
16480   }
16481
16482   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16483   {
16484     char device[] = "/dev/sda";
16485     int r;
16486     suppress_error = 0;
16487     r = guestfs_blockdev_setrw (g, device);
16488     if (r == -1)
16489       return -1;
16490   }
16491   {
16492     int r;
16493     suppress_error = 0;
16494     r = guestfs_umount_all (g);
16495     if (r == -1)
16496       return -1;
16497   }
16498   {
16499     int r;
16500     suppress_error = 0;
16501     r = guestfs_lvm_remove_all (g);
16502     if (r == -1)
16503       return -1;
16504   }
16505   {
16506     char device[] = "/dev/sda";
16507     char lines_0[] = ",";
16508     char *lines[] = {
16509       lines_0,
16510       NULL
16511     };
16512     int r;
16513     suppress_error = 0;
16514     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16515     if (r == -1)
16516       return -1;
16517   }
16518   {
16519     char fstype[] = "ext2";
16520     char device[] = "/dev/sda1";
16521     int r;
16522     suppress_error = 0;
16523     r = guestfs_mkfs (g, fstype, device);
16524     if (r == -1)
16525       return -1;
16526   }
16527   {
16528     char device[] = "/dev/sda1";
16529     char mountpoint[] = "/";
16530     int r;
16531     suppress_error = 0;
16532     r = guestfs_mount (g, device, mountpoint);
16533     if (r == -1)
16534       return -1;
16535   }
16536   /* TestOutputList for read_lines (0) */
16537   {
16538     char path[] = "/new";
16539     char content[] = "line1\r\nline2\nline3";
16540     int r;
16541     suppress_error = 0;
16542     r = guestfs_write_file (g, path, content, 0);
16543     if (r == -1)
16544       return -1;
16545   }
16546   {
16547     char path[] = "/new";
16548     char **r;
16549     int i;
16550     suppress_error = 0;
16551     r = guestfs_read_lines (g, path);
16552     if (r == NULL)
16553       return -1;
16554     if (!r[0]) {
16555       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16556       print_strings (r);
16557       return -1;
16558     }
16559     {
16560       char expected[] = "line1";
16561       if (strcmp (r[0], expected) != 0) {
16562         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16563         return -1;
16564       }
16565     }
16566     if (!r[1]) {
16567       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16568       print_strings (r);
16569       return -1;
16570     }
16571     {
16572       char expected[] = "line2";
16573       if (strcmp (r[1], expected) != 0) {
16574         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16575         return -1;
16576       }
16577     }
16578     if (!r[2]) {
16579       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16580       print_strings (r);
16581       return -1;
16582     }
16583     {
16584       char expected[] = "line3";
16585       if (strcmp (r[2], expected) != 0) {
16586         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16587         return -1;
16588       }
16589     }
16590     if (r[3] != NULL) {
16591       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16592       print_strings (r);
16593       return -1;
16594     }
16595     for (i = 0; r[i] != NULL; ++i)
16596       free (r[i]);
16597     free (r);
16598   }
16599   return 0;
16600 }
16601
16602 static int test_read_lines_1_skip (void)
16603 {
16604   const char *str;
16605
16606   str = getenv ("TEST_ONLY");
16607   if (str)
16608     return strstr (str, "read_lines") == NULL;
16609   str = getenv ("SKIP_TEST_READ_LINES_1");
16610   if (str && strcmp (str, "1") == 0) return 1;
16611   str = getenv ("SKIP_TEST_READ_LINES");
16612   if (str && strcmp (str, "1") == 0) return 1;
16613   return 0;
16614 }
16615
16616 static int test_read_lines_1 (void)
16617 {
16618   if (test_read_lines_1_skip ()) {
16619     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16620     return 0;
16621   }
16622
16623   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16624   {
16625     char device[] = "/dev/sda";
16626     int r;
16627     suppress_error = 0;
16628     r = guestfs_blockdev_setrw (g, device);
16629     if (r == -1)
16630       return -1;
16631   }
16632   {
16633     int r;
16634     suppress_error = 0;
16635     r = guestfs_umount_all (g);
16636     if (r == -1)
16637       return -1;
16638   }
16639   {
16640     int r;
16641     suppress_error = 0;
16642     r = guestfs_lvm_remove_all (g);
16643     if (r == -1)
16644       return -1;
16645   }
16646   {
16647     char device[] = "/dev/sda";
16648     char lines_0[] = ",";
16649     char *lines[] = {
16650       lines_0,
16651       NULL
16652     };
16653     int r;
16654     suppress_error = 0;
16655     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16656     if (r == -1)
16657       return -1;
16658   }
16659   {
16660     char fstype[] = "ext2";
16661     char device[] = "/dev/sda1";
16662     int r;
16663     suppress_error = 0;
16664     r = guestfs_mkfs (g, fstype, device);
16665     if (r == -1)
16666       return -1;
16667   }
16668   {
16669     char device[] = "/dev/sda1";
16670     char mountpoint[] = "/";
16671     int r;
16672     suppress_error = 0;
16673     r = guestfs_mount (g, device, mountpoint);
16674     if (r == -1)
16675       return -1;
16676   }
16677   /* TestOutputList for read_lines (1) */
16678   {
16679     char path[] = "/new";
16680     char content[] = "";
16681     int r;
16682     suppress_error = 0;
16683     r = guestfs_write_file (g, path, content, 0);
16684     if (r == -1)
16685       return -1;
16686   }
16687   {
16688     char path[] = "/new";
16689     char **r;
16690     int i;
16691     suppress_error = 0;
16692     r = guestfs_read_lines (g, path);
16693     if (r == NULL)
16694       return -1;
16695     if (r[0] != NULL) {
16696       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
16697       print_strings (r);
16698       return -1;
16699     }
16700     for (i = 0; r[i] != NULL; ++i)
16701       free (r[i]);
16702     free (r);
16703   }
16704   return 0;
16705 }
16706
16707 static int test_lvs_0_skip (void)
16708 {
16709   const char *str;
16710
16711   str = getenv ("TEST_ONLY");
16712   if (str)
16713     return strstr (str, "lvs") == NULL;
16714   str = getenv ("SKIP_TEST_LVS_0");
16715   if (str && strcmp (str, "1") == 0) return 1;
16716   str = getenv ("SKIP_TEST_LVS");
16717   if (str && strcmp (str, "1") == 0) return 1;
16718   return 0;
16719 }
16720
16721 static int test_lvs_0 (void)
16722 {
16723   if (test_lvs_0_skip ()) {
16724     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
16725     return 0;
16726   }
16727
16728   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
16729   {
16730     char device[] = "/dev/sda";
16731     int r;
16732     suppress_error = 0;
16733     r = guestfs_blockdev_setrw (g, device);
16734     if (r == -1)
16735       return -1;
16736   }
16737   {
16738     int r;
16739     suppress_error = 0;
16740     r = guestfs_umount_all (g);
16741     if (r == -1)
16742       return -1;
16743   }
16744   {
16745     int r;
16746     suppress_error = 0;
16747     r = guestfs_lvm_remove_all (g);
16748     if (r == -1)
16749       return -1;
16750   }
16751   {
16752     char device[] = "/dev/sda";
16753     char lines_0[] = ",";
16754     char *lines[] = {
16755       lines_0,
16756       NULL
16757     };
16758     int r;
16759     suppress_error = 0;
16760     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16761     if (r == -1)
16762       return -1;
16763   }
16764   {
16765     char device[] = "/dev/sda1";
16766     int r;
16767     suppress_error = 0;
16768     r = guestfs_pvcreate (g, device);
16769     if (r == -1)
16770       return -1;
16771   }
16772   {
16773     char volgroup[] = "VG";
16774     char physvols_0[] = "/dev/sda1";
16775     char *physvols[] = {
16776       physvols_0,
16777       NULL
16778     };
16779     int r;
16780     suppress_error = 0;
16781     r = guestfs_vgcreate (g, volgroup, physvols);
16782     if (r == -1)
16783       return -1;
16784   }
16785   {
16786     char logvol[] = "LV";
16787     char volgroup[] = "VG";
16788     int r;
16789     suppress_error = 0;
16790     r = guestfs_lvcreate (g, logvol, volgroup, 8);
16791     if (r == -1)
16792       return -1;
16793   }
16794   {
16795     char fstype[] = "ext2";
16796     char device[] = "/dev/VG/LV";
16797     int r;
16798     suppress_error = 0;
16799     r = guestfs_mkfs (g, fstype, device);
16800     if (r == -1)
16801       return -1;
16802   }
16803   {
16804     char device[] = "/dev/VG/LV";
16805     char mountpoint[] = "/";
16806     int r;
16807     suppress_error = 0;
16808     r = guestfs_mount (g, device, mountpoint);
16809     if (r == -1)
16810       return -1;
16811   }
16812   /* TestOutputList for lvs (0) */
16813   {
16814     char **r;
16815     int i;
16816     suppress_error = 0;
16817     r = guestfs_lvs (g);
16818     if (r == NULL)
16819       return -1;
16820     if (!r[0]) {
16821       fprintf (stderr, "test_lvs_0: short list returned from command\n");
16822       print_strings (r);
16823       return -1;
16824     }
16825     {
16826       char expected[] = "/dev/VG/LV";
16827       if (strcmp (r[0], expected) != 0) {
16828         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16829         return -1;
16830       }
16831     }
16832     if (r[1] != NULL) {
16833       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
16834       print_strings (r);
16835       return -1;
16836     }
16837     for (i = 0; r[i] != NULL; ++i)
16838       free (r[i]);
16839     free (r);
16840   }
16841   return 0;
16842 }
16843
16844 static int test_lvs_1_skip (void)
16845 {
16846   const char *str;
16847
16848   str = getenv ("TEST_ONLY");
16849   if (str)
16850     return strstr (str, "lvs") == NULL;
16851   str = getenv ("SKIP_TEST_LVS_1");
16852   if (str && strcmp (str, "1") == 0) return 1;
16853   str = getenv ("SKIP_TEST_LVS");
16854   if (str && strcmp (str, "1") == 0) return 1;
16855   return 0;
16856 }
16857
16858 static int test_lvs_1 (void)
16859 {
16860   if (test_lvs_1_skip ()) {
16861     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
16862     return 0;
16863   }
16864
16865   /* InitNone|InitEmpty for test_lvs_1 */
16866   {
16867     char device[] = "/dev/sda";
16868     int r;
16869     suppress_error = 0;
16870     r = guestfs_blockdev_setrw (g, device);
16871     if (r == -1)
16872       return -1;
16873   }
16874   {
16875     int r;
16876     suppress_error = 0;
16877     r = guestfs_umount_all (g);
16878     if (r == -1)
16879       return -1;
16880   }
16881   {
16882     int r;
16883     suppress_error = 0;
16884     r = guestfs_lvm_remove_all (g);
16885     if (r == -1)
16886       return -1;
16887   }
16888   /* TestOutputList for lvs (1) */
16889   {
16890     char device[] = "/dev/sda";
16891     char lines_0[] = ",10";
16892     char lines_1[] = ",20";
16893     char lines_2[] = ",";
16894     char *lines[] = {
16895       lines_0,
16896       lines_1,
16897       lines_2,
16898       NULL
16899     };
16900     int r;
16901     suppress_error = 0;
16902     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16903     if (r == -1)
16904       return -1;
16905   }
16906   {
16907     char device[] = "/dev/sda1";
16908     int r;
16909     suppress_error = 0;
16910     r = guestfs_pvcreate (g, device);
16911     if (r == -1)
16912       return -1;
16913   }
16914   {
16915     char device[] = "/dev/sda2";
16916     int r;
16917     suppress_error = 0;
16918     r = guestfs_pvcreate (g, device);
16919     if (r == -1)
16920       return -1;
16921   }
16922   {
16923     char device[] = "/dev/sda3";
16924     int r;
16925     suppress_error = 0;
16926     r = guestfs_pvcreate (g, device);
16927     if (r == -1)
16928       return -1;
16929   }
16930   {
16931     char volgroup[] = "VG1";
16932     char physvols_0[] = "/dev/sda1";
16933     char physvols_1[] = "/dev/sda2";
16934     char *physvols[] = {
16935       physvols_0,
16936       physvols_1,
16937       NULL
16938     };
16939     int r;
16940     suppress_error = 0;
16941     r = guestfs_vgcreate (g, volgroup, physvols);
16942     if (r == -1)
16943       return -1;
16944   }
16945   {
16946     char volgroup[] = "VG2";
16947     char physvols_0[] = "/dev/sda3";
16948     char *physvols[] = {
16949       physvols_0,
16950       NULL
16951     };
16952     int r;
16953     suppress_error = 0;
16954     r = guestfs_vgcreate (g, volgroup, physvols);
16955     if (r == -1)
16956       return -1;
16957   }
16958   {
16959     char logvol[] = "LV1";
16960     char volgroup[] = "VG1";
16961     int r;
16962     suppress_error = 0;
16963     r = guestfs_lvcreate (g, logvol, volgroup, 50);
16964     if (r == -1)
16965       return -1;
16966   }
16967   {
16968     char logvol[] = "LV2";
16969     char volgroup[] = "VG1";
16970     int r;
16971     suppress_error = 0;
16972     r = guestfs_lvcreate (g, logvol, volgroup, 50);
16973     if (r == -1)
16974       return -1;
16975   }
16976   {
16977     char logvol[] = "LV3";
16978     char volgroup[] = "VG2";
16979     int r;
16980     suppress_error = 0;
16981     r = guestfs_lvcreate (g, logvol, volgroup, 50);
16982     if (r == -1)
16983       return -1;
16984   }
16985   {
16986     char **r;
16987     int i;
16988     suppress_error = 0;
16989     r = guestfs_lvs (g);
16990     if (r == NULL)
16991       return -1;
16992     if (!r[0]) {
16993       fprintf (stderr, "test_lvs_1: short list returned from command\n");
16994       print_strings (r);
16995       return -1;
16996     }
16997     {
16998       char expected[] = "/dev/VG1/LV1";
16999       if (strcmp (r[0], expected) != 0) {
17000         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17001         return -1;
17002       }
17003     }
17004     if (!r[1]) {
17005       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17006       print_strings (r);
17007       return -1;
17008     }
17009     {
17010       char expected[] = "/dev/VG1/LV2";
17011       if (strcmp (r[1], expected) != 0) {
17012         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17013         return -1;
17014       }
17015     }
17016     if (!r[2]) {
17017       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17018       print_strings (r);
17019       return -1;
17020     }
17021     {
17022       char expected[] = "/dev/VG2/LV3";
17023       if (strcmp (r[2], expected) != 0) {
17024         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17025         return -1;
17026       }
17027     }
17028     if (r[3] != NULL) {
17029       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17030       print_strings (r);
17031       return -1;
17032     }
17033     for (i = 0; r[i] != NULL; ++i)
17034       free (r[i]);
17035     free (r);
17036   }
17037   return 0;
17038 }
17039
17040 static int test_vgs_0_skip (void)
17041 {
17042   const char *str;
17043
17044   str = getenv ("TEST_ONLY");
17045   if (str)
17046     return strstr (str, "vgs") == NULL;
17047   str = getenv ("SKIP_TEST_VGS_0");
17048   if (str && strcmp (str, "1") == 0) return 1;
17049   str = getenv ("SKIP_TEST_VGS");
17050   if (str && strcmp (str, "1") == 0) return 1;
17051   return 0;
17052 }
17053
17054 static int test_vgs_0 (void)
17055 {
17056   if (test_vgs_0_skip ()) {
17057     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17058     return 0;
17059   }
17060
17061   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17062   {
17063     char device[] = "/dev/sda";
17064     int r;
17065     suppress_error = 0;
17066     r = guestfs_blockdev_setrw (g, device);
17067     if (r == -1)
17068       return -1;
17069   }
17070   {
17071     int r;
17072     suppress_error = 0;
17073     r = guestfs_umount_all (g);
17074     if (r == -1)
17075       return -1;
17076   }
17077   {
17078     int r;
17079     suppress_error = 0;
17080     r = guestfs_lvm_remove_all (g);
17081     if (r == -1)
17082       return -1;
17083   }
17084   {
17085     char device[] = "/dev/sda";
17086     char lines_0[] = ",";
17087     char *lines[] = {
17088       lines_0,
17089       NULL
17090     };
17091     int r;
17092     suppress_error = 0;
17093     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17094     if (r == -1)
17095       return -1;
17096   }
17097   {
17098     char device[] = "/dev/sda1";
17099     int r;
17100     suppress_error = 0;
17101     r = guestfs_pvcreate (g, device);
17102     if (r == -1)
17103       return -1;
17104   }
17105   {
17106     char volgroup[] = "VG";
17107     char physvols_0[] = "/dev/sda1";
17108     char *physvols[] = {
17109       physvols_0,
17110       NULL
17111     };
17112     int r;
17113     suppress_error = 0;
17114     r = guestfs_vgcreate (g, volgroup, physvols);
17115     if (r == -1)
17116       return -1;
17117   }
17118   {
17119     char logvol[] = "LV";
17120     char volgroup[] = "VG";
17121     int r;
17122     suppress_error = 0;
17123     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17124     if (r == -1)
17125       return -1;
17126   }
17127   {
17128     char fstype[] = "ext2";
17129     char device[] = "/dev/VG/LV";
17130     int r;
17131     suppress_error = 0;
17132     r = guestfs_mkfs (g, fstype, device);
17133     if (r == -1)
17134       return -1;
17135   }
17136   {
17137     char device[] = "/dev/VG/LV";
17138     char mountpoint[] = "/";
17139     int r;
17140     suppress_error = 0;
17141     r = guestfs_mount (g, device, mountpoint);
17142     if (r == -1)
17143       return -1;
17144   }
17145   /* TestOutputList for vgs (0) */
17146   {
17147     char **r;
17148     int i;
17149     suppress_error = 0;
17150     r = guestfs_vgs (g);
17151     if (r == NULL)
17152       return -1;
17153     if (!r[0]) {
17154       fprintf (stderr, "test_vgs_0: short list returned from command\n");
17155       print_strings (r);
17156       return -1;
17157     }
17158     {
17159       char expected[] = "VG";
17160       if (strcmp (r[0], expected) != 0) {
17161         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17162         return -1;
17163       }
17164     }
17165     if (r[1] != NULL) {
17166       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17167       print_strings (r);
17168       return -1;
17169     }
17170     for (i = 0; r[i] != NULL; ++i)
17171       free (r[i]);
17172     free (r);
17173   }
17174   return 0;
17175 }
17176
17177 static int test_vgs_1_skip (void)
17178 {
17179   const char *str;
17180
17181   str = getenv ("TEST_ONLY");
17182   if (str)
17183     return strstr (str, "vgs") == NULL;
17184   str = getenv ("SKIP_TEST_VGS_1");
17185   if (str && strcmp (str, "1") == 0) return 1;
17186   str = getenv ("SKIP_TEST_VGS");
17187   if (str && strcmp (str, "1") == 0) return 1;
17188   return 0;
17189 }
17190
17191 static int test_vgs_1 (void)
17192 {
17193   if (test_vgs_1_skip ()) {
17194     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17195     return 0;
17196   }
17197
17198   /* InitNone|InitEmpty for test_vgs_1 */
17199   {
17200     char device[] = "/dev/sda";
17201     int r;
17202     suppress_error = 0;
17203     r = guestfs_blockdev_setrw (g, device);
17204     if (r == -1)
17205       return -1;
17206   }
17207   {
17208     int r;
17209     suppress_error = 0;
17210     r = guestfs_umount_all (g);
17211     if (r == -1)
17212       return -1;
17213   }
17214   {
17215     int r;
17216     suppress_error = 0;
17217     r = guestfs_lvm_remove_all (g);
17218     if (r == -1)
17219       return -1;
17220   }
17221   /* TestOutputList for vgs (1) */
17222   {
17223     char device[] = "/dev/sda";
17224     char lines_0[] = ",10";
17225     char lines_1[] = ",20";
17226     char lines_2[] = ",";
17227     char *lines[] = {
17228       lines_0,
17229       lines_1,
17230       lines_2,
17231       NULL
17232     };
17233     int r;
17234     suppress_error = 0;
17235     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17236     if (r == -1)
17237       return -1;
17238   }
17239   {
17240     char device[] = "/dev/sda1";
17241     int r;
17242     suppress_error = 0;
17243     r = guestfs_pvcreate (g, device);
17244     if (r == -1)
17245       return -1;
17246   }
17247   {
17248     char device[] = "/dev/sda2";
17249     int r;
17250     suppress_error = 0;
17251     r = guestfs_pvcreate (g, device);
17252     if (r == -1)
17253       return -1;
17254   }
17255   {
17256     char device[] = "/dev/sda3";
17257     int r;
17258     suppress_error = 0;
17259     r = guestfs_pvcreate (g, device);
17260     if (r == -1)
17261       return -1;
17262   }
17263   {
17264     char volgroup[] = "VG1";
17265     char physvols_0[] = "/dev/sda1";
17266     char physvols_1[] = "/dev/sda2";
17267     char *physvols[] = {
17268       physvols_0,
17269       physvols_1,
17270       NULL
17271     };
17272     int r;
17273     suppress_error = 0;
17274     r = guestfs_vgcreate (g, volgroup, physvols);
17275     if (r == -1)
17276       return -1;
17277   }
17278   {
17279     char volgroup[] = "VG2";
17280     char physvols_0[] = "/dev/sda3";
17281     char *physvols[] = {
17282       physvols_0,
17283       NULL
17284     };
17285     int r;
17286     suppress_error = 0;
17287     r = guestfs_vgcreate (g, volgroup, physvols);
17288     if (r == -1)
17289       return -1;
17290   }
17291   {
17292     char **r;
17293     int i;
17294     suppress_error = 0;
17295     r = guestfs_vgs (g);
17296     if (r == NULL)
17297       return -1;
17298     if (!r[0]) {
17299       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17300       print_strings (r);
17301       return -1;
17302     }
17303     {
17304       char expected[] = "VG1";
17305       if (strcmp (r[0], expected) != 0) {
17306         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17307         return -1;
17308       }
17309     }
17310     if (!r[1]) {
17311       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17312       print_strings (r);
17313       return -1;
17314     }
17315     {
17316       char expected[] = "VG2";
17317       if (strcmp (r[1], expected) != 0) {
17318         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17319         return -1;
17320       }
17321     }
17322     if (r[2] != NULL) {
17323       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17324       print_strings (r);
17325       return -1;
17326     }
17327     for (i = 0; r[i] != NULL; ++i)
17328       free (r[i]);
17329     free (r);
17330   }
17331   return 0;
17332 }
17333
17334 static int test_pvs_0_skip (void)
17335 {
17336   const char *str;
17337
17338   str = getenv ("TEST_ONLY");
17339   if (str)
17340     return strstr (str, "pvs") == NULL;
17341   str = getenv ("SKIP_TEST_PVS_0");
17342   if (str && strcmp (str, "1") == 0) return 1;
17343   str = getenv ("SKIP_TEST_PVS");
17344   if (str && strcmp (str, "1") == 0) return 1;
17345   return 0;
17346 }
17347
17348 static int test_pvs_0 (void)
17349 {
17350   if (test_pvs_0_skip ()) {
17351     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17352     return 0;
17353   }
17354
17355   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17356   {
17357     char device[] = "/dev/sda";
17358     int r;
17359     suppress_error = 0;
17360     r = guestfs_blockdev_setrw (g, device);
17361     if (r == -1)
17362       return -1;
17363   }
17364   {
17365     int r;
17366     suppress_error = 0;
17367     r = guestfs_umount_all (g);
17368     if (r == -1)
17369       return -1;
17370   }
17371   {
17372     int r;
17373     suppress_error = 0;
17374     r = guestfs_lvm_remove_all (g);
17375     if (r == -1)
17376       return -1;
17377   }
17378   {
17379     char device[] = "/dev/sda";
17380     char lines_0[] = ",";
17381     char *lines[] = {
17382       lines_0,
17383       NULL
17384     };
17385     int r;
17386     suppress_error = 0;
17387     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17388     if (r == -1)
17389       return -1;
17390   }
17391   {
17392     char device[] = "/dev/sda1";
17393     int r;
17394     suppress_error = 0;
17395     r = guestfs_pvcreate (g, device);
17396     if (r == -1)
17397       return -1;
17398   }
17399   {
17400     char volgroup[] = "VG";
17401     char physvols_0[] = "/dev/sda1";
17402     char *physvols[] = {
17403       physvols_0,
17404       NULL
17405     };
17406     int r;
17407     suppress_error = 0;
17408     r = guestfs_vgcreate (g, volgroup, physvols);
17409     if (r == -1)
17410       return -1;
17411   }
17412   {
17413     char logvol[] = "LV";
17414     char volgroup[] = "VG";
17415     int r;
17416     suppress_error = 0;
17417     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17418     if (r == -1)
17419       return -1;
17420   }
17421   {
17422     char fstype[] = "ext2";
17423     char device[] = "/dev/VG/LV";
17424     int r;
17425     suppress_error = 0;
17426     r = guestfs_mkfs (g, fstype, device);
17427     if (r == -1)
17428       return -1;
17429   }
17430   {
17431     char device[] = "/dev/VG/LV";
17432     char mountpoint[] = "/";
17433     int r;
17434     suppress_error = 0;
17435     r = guestfs_mount (g, device, mountpoint);
17436     if (r == -1)
17437       return -1;
17438   }
17439   /* TestOutputListOfDevices for pvs (0) */
17440   {
17441     char **r;
17442     int i;
17443     suppress_error = 0;
17444     r = guestfs_pvs (g);
17445     if (r == NULL)
17446       return -1;
17447     if (!r[0]) {
17448       fprintf (stderr, "test_pvs_0: short list returned from command\n");
17449       print_strings (r);
17450       return -1;
17451     }
17452     {
17453       char expected[] = "/dev/sda1";
17454       r[0][5] = 's';
17455       if (strcmp (r[0], expected) != 0) {
17456         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17457         return -1;
17458       }
17459     }
17460     if (r[1] != NULL) {
17461       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17462       print_strings (r);
17463       return -1;
17464     }
17465     for (i = 0; r[i] != NULL; ++i)
17466       free (r[i]);
17467     free (r);
17468   }
17469   return 0;
17470 }
17471
17472 static int test_pvs_1_skip (void)
17473 {
17474   const char *str;
17475
17476   str = getenv ("TEST_ONLY");
17477   if (str)
17478     return strstr (str, "pvs") == NULL;
17479   str = getenv ("SKIP_TEST_PVS_1");
17480   if (str && strcmp (str, "1") == 0) return 1;
17481   str = getenv ("SKIP_TEST_PVS");
17482   if (str && strcmp (str, "1") == 0) return 1;
17483   return 0;
17484 }
17485
17486 static int test_pvs_1 (void)
17487 {
17488   if (test_pvs_1_skip ()) {
17489     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17490     return 0;
17491   }
17492
17493   /* InitNone|InitEmpty for test_pvs_1 */
17494   {
17495     char device[] = "/dev/sda";
17496     int r;
17497     suppress_error = 0;
17498     r = guestfs_blockdev_setrw (g, device);
17499     if (r == -1)
17500       return -1;
17501   }
17502   {
17503     int r;
17504     suppress_error = 0;
17505     r = guestfs_umount_all (g);
17506     if (r == -1)
17507       return -1;
17508   }
17509   {
17510     int r;
17511     suppress_error = 0;
17512     r = guestfs_lvm_remove_all (g);
17513     if (r == -1)
17514       return -1;
17515   }
17516   /* TestOutputListOfDevices for pvs (1) */
17517   {
17518     char device[] = "/dev/sda";
17519     char lines_0[] = ",10";
17520     char lines_1[] = ",20";
17521     char lines_2[] = ",";
17522     char *lines[] = {
17523       lines_0,
17524       lines_1,
17525       lines_2,
17526       NULL
17527     };
17528     int r;
17529     suppress_error = 0;
17530     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17531     if (r == -1)
17532       return -1;
17533   }
17534   {
17535     char device[] = "/dev/sda1";
17536     int r;
17537     suppress_error = 0;
17538     r = guestfs_pvcreate (g, device);
17539     if (r == -1)
17540       return -1;
17541   }
17542   {
17543     char device[] = "/dev/sda2";
17544     int r;
17545     suppress_error = 0;
17546     r = guestfs_pvcreate (g, device);
17547     if (r == -1)
17548       return -1;
17549   }
17550   {
17551     char device[] = "/dev/sda3";
17552     int r;
17553     suppress_error = 0;
17554     r = guestfs_pvcreate (g, device);
17555     if (r == -1)
17556       return -1;
17557   }
17558   {
17559     char **r;
17560     int i;
17561     suppress_error = 0;
17562     r = guestfs_pvs (g);
17563     if (r == NULL)
17564       return -1;
17565     if (!r[0]) {
17566       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17567       print_strings (r);
17568       return -1;
17569     }
17570     {
17571       char expected[] = "/dev/sda1";
17572       r[0][5] = 's';
17573       if (strcmp (r[0], expected) != 0) {
17574         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17575         return -1;
17576       }
17577     }
17578     if (!r[1]) {
17579       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17580       print_strings (r);
17581       return -1;
17582     }
17583     {
17584       char expected[] = "/dev/sda2";
17585       r[1][5] = 's';
17586       if (strcmp (r[1], expected) != 0) {
17587         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17588         return -1;
17589       }
17590     }
17591     if (!r[2]) {
17592       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17593       print_strings (r);
17594       return -1;
17595     }
17596     {
17597       char expected[] = "/dev/sda3";
17598       r[2][5] = 's';
17599       if (strcmp (r[2], expected) != 0) {
17600         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17601         return -1;
17602       }
17603     }
17604     if (r[3] != NULL) {
17605       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17606       print_strings (r);
17607       return -1;
17608     }
17609     for (i = 0; r[i] != NULL; ++i)
17610       free (r[i]);
17611     free (r);
17612   }
17613   return 0;
17614 }
17615
17616 static int test_list_partitions_0_skip (void)
17617 {
17618   const char *str;
17619
17620   str = getenv ("TEST_ONLY");
17621   if (str)
17622     return strstr (str, "list_partitions") == NULL;
17623   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17624   if (str && strcmp (str, "1") == 0) return 1;
17625   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17626   if (str && strcmp (str, "1") == 0) return 1;
17627   return 0;
17628 }
17629
17630 static int test_list_partitions_0 (void)
17631 {
17632   if (test_list_partitions_0_skip ()) {
17633     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
17634     return 0;
17635   }
17636
17637   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
17638   {
17639     char device[] = "/dev/sda";
17640     int r;
17641     suppress_error = 0;
17642     r = guestfs_blockdev_setrw (g, device);
17643     if (r == -1)
17644       return -1;
17645   }
17646   {
17647     int r;
17648     suppress_error = 0;
17649     r = guestfs_umount_all (g);
17650     if (r == -1)
17651       return -1;
17652   }
17653   {
17654     int r;
17655     suppress_error = 0;
17656     r = guestfs_lvm_remove_all (g);
17657     if (r == -1)
17658       return -1;
17659   }
17660   {
17661     char device[] = "/dev/sda";
17662     char lines_0[] = ",";
17663     char *lines[] = {
17664       lines_0,
17665       NULL
17666     };
17667     int r;
17668     suppress_error = 0;
17669     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17670     if (r == -1)
17671       return -1;
17672   }
17673   {
17674     char fstype[] = "ext2";
17675     char device[] = "/dev/sda1";
17676     int r;
17677     suppress_error = 0;
17678     r = guestfs_mkfs (g, fstype, device);
17679     if (r == -1)
17680       return -1;
17681   }
17682   {
17683     char device[] = "/dev/sda1";
17684     char mountpoint[] = "/";
17685     int r;
17686     suppress_error = 0;
17687     r = guestfs_mount (g, device, mountpoint);
17688     if (r == -1)
17689       return -1;
17690   }
17691   /* TestOutputListOfDevices for list_partitions (0) */
17692   {
17693     char **r;
17694     int i;
17695     suppress_error = 0;
17696     r = guestfs_list_partitions (g);
17697     if (r == NULL)
17698       return -1;
17699     if (!r[0]) {
17700       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
17701       print_strings (r);
17702       return -1;
17703     }
17704     {
17705       char expected[] = "/dev/sda1";
17706       r[0][5] = 's';
17707       if (strcmp (r[0], expected) != 0) {
17708         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17709         return -1;
17710       }
17711     }
17712     if (r[1] != NULL) {
17713       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
17714       print_strings (r);
17715       return -1;
17716     }
17717     for (i = 0; r[i] != NULL; ++i)
17718       free (r[i]);
17719     free (r);
17720   }
17721   return 0;
17722 }
17723
17724 static int test_list_partitions_1_skip (void)
17725 {
17726   const char *str;
17727
17728   str = getenv ("TEST_ONLY");
17729   if (str)
17730     return strstr (str, "list_partitions") == NULL;
17731   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
17732   if (str && strcmp (str, "1") == 0) return 1;
17733   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17734   if (str && strcmp (str, "1") == 0) return 1;
17735   return 0;
17736 }
17737
17738 static int test_list_partitions_1 (void)
17739 {
17740   if (test_list_partitions_1_skip ()) {
17741     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
17742     return 0;
17743   }
17744
17745   /* InitNone|InitEmpty for test_list_partitions_1 */
17746   {
17747     char device[] = "/dev/sda";
17748     int r;
17749     suppress_error = 0;
17750     r = guestfs_blockdev_setrw (g, device);
17751     if (r == -1)
17752       return -1;
17753   }
17754   {
17755     int r;
17756     suppress_error = 0;
17757     r = guestfs_umount_all (g);
17758     if (r == -1)
17759       return -1;
17760   }
17761   {
17762     int r;
17763     suppress_error = 0;
17764     r = guestfs_lvm_remove_all (g);
17765     if (r == -1)
17766       return -1;
17767   }
17768   /* TestOutputListOfDevices for list_partitions (1) */
17769   {
17770     char device[] = "/dev/sda";
17771     char lines_0[] = ",10";
17772     char lines_1[] = ",20";
17773     char lines_2[] = ",";
17774     char *lines[] = {
17775       lines_0,
17776       lines_1,
17777       lines_2,
17778       NULL
17779     };
17780     int r;
17781     suppress_error = 0;
17782     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17783     if (r == -1)
17784       return -1;
17785   }
17786   {
17787     char **r;
17788     int i;
17789     suppress_error = 0;
17790     r = guestfs_list_partitions (g);
17791     if (r == NULL)
17792       return -1;
17793     if (!r[0]) {
17794       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17795       print_strings (r);
17796       return -1;
17797     }
17798     {
17799       char expected[] = "/dev/sda1";
17800       r[0][5] = 's';
17801       if (strcmp (r[0], expected) != 0) {
17802         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17803         return -1;
17804       }
17805     }
17806     if (!r[1]) {
17807       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17808       print_strings (r);
17809       return -1;
17810     }
17811     {
17812       char expected[] = "/dev/sda2";
17813       r[1][5] = 's';
17814       if (strcmp (r[1], expected) != 0) {
17815         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17816         return -1;
17817       }
17818     }
17819     if (!r[2]) {
17820       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17821       print_strings (r);
17822       return -1;
17823     }
17824     {
17825       char expected[] = "/dev/sda3";
17826       r[2][5] = 's';
17827       if (strcmp (r[2], expected) != 0) {
17828         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17829         return -1;
17830       }
17831     }
17832     if (r[3] != NULL) {
17833       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
17834       print_strings (r);
17835       return -1;
17836     }
17837     for (i = 0; r[i] != NULL; ++i)
17838       free (r[i]);
17839     free (r);
17840   }
17841   return 0;
17842 }
17843
17844 static int test_list_devices_0_skip (void)
17845 {
17846   const char *str;
17847
17848   str = getenv ("TEST_ONLY");
17849   if (str)
17850     return strstr (str, "list_devices") == NULL;
17851   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
17852   if (str && strcmp (str, "1") == 0) return 1;
17853   str = getenv ("SKIP_TEST_LIST_DEVICES");
17854   if (str && strcmp (str, "1") == 0) return 1;
17855   return 0;
17856 }
17857
17858 static int test_list_devices_0 (void)
17859 {
17860   if (test_list_devices_0_skip ()) {
17861     printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
17862     return 0;
17863   }
17864
17865   /* InitNone|InitEmpty for test_list_devices_0 */
17866   {
17867     char device[] = "/dev/sda";
17868     int r;
17869     suppress_error = 0;
17870     r = guestfs_blockdev_setrw (g, device);
17871     if (r == -1)
17872       return -1;
17873   }
17874   {
17875     int r;
17876     suppress_error = 0;
17877     r = guestfs_umount_all (g);
17878     if (r == -1)
17879       return -1;
17880   }
17881   {
17882     int r;
17883     suppress_error = 0;
17884     r = guestfs_lvm_remove_all (g);
17885     if (r == -1)
17886       return -1;
17887   }
17888   /* TestOutputListOfDevices for list_devices (0) */
17889   {
17890     char **r;
17891     int i;
17892     suppress_error = 0;
17893     r = guestfs_list_devices (g);
17894     if (r == NULL)
17895       return -1;
17896     if (!r[0]) {
17897       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17898       print_strings (r);
17899       return -1;
17900     }
17901     {
17902       char expected[] = "/dev/sda";
17903       r[0][5] = 's';
17904       if (strcmp (r[0], expected) != 0) {
17905         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17906         return -1;
17907       }
17908     }
17909     if (!r[1]) {
17910       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17911       print_strings (r);
17912       return -1;
17913     }
17914     {
17915       char expected[] = "/dev/sdb";
17916       r[1][5] = 's';
17917       if (strcmp (r[1], expected) != 0) {
17918         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17919         return -1;
17920       }
17921     }
17922     if (!r[2]) {
17923       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17924       print_strings (r);
17925       return -1;
17926     }
17927     {
17928       char expected[] = "/dev/sdc";
17929       r[2][5] = 's';
17930       if (strcmp (r[2], expected) != 0) {
17931         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17932         return -1;
17933       }
17934     }
17935     if (!r[3]) {
17936       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17937       print_strings (r);
17938       return -1;
17939     }
17940     {
17941       char expected[] = "/dev/sdd";
17942       r[3][5] = 's';
17943       if (strcmp (r[3], expected) != 0) {
17944         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
17945         return -1;
17946       }
17947     }
17948     if (r[4] != NULL) {
17949       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
17950       print_strings (r);
17951       return -1;
17952     }
17953     for (i = 0; r[i] != NULL; ++i)
17954       free (r[i]);
17955     free (r);
17956   }
17957   return 0;
17958 }
17959
17960 static int test_ls_0_skip (void)
17961 {
17962   const char *str;
17963
17964   str = getenv ("TEST_ONLY");
17965   if (str)
17966     return strstr (str, "ls") == NULL;
17967   str = getenv ("SKIP_TEST_LS_0");
17968   if (str && strcmp (str, "1") == 0) return 1;
17969   str = getenv ("SKIP_TEST_LS");
17970   if (str && strcmp (str, "1") == 0) return 1;
17971   return 0;
17972 }
17973
17974 static int test_ls_0 (void)
17975 {
17976   if (test_ls_0_skip ()) {
17977     printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
17978     return 0;
17979   }
17980
17981   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
17982   {
17983     char device[] = "/dev/sda";
17984     int r;
17985     suppress_error = 0;
17986     r = guestfs_blockdev_setrw (g, device);
17987     if (r == -1)
17988       return -1;
17989   }
17990   {
17991     int r;
17992     suppress_error = 0;
17993     r = guestfs_umount_all (g);
17994     if (r == -1)
17995       return -1;
17996   }
17997   {
17998     int r;
17999     suppress_error = 0;
18000     r = guestfs_lvm_remove_all (g);
18001     if (r == -1)
18002       return -1;
18003   }
18004   {
18005     char device[] = "/dev/sda";
18006     char lines_0[] = ",";
18007     char *lines[] = {
18008       lines_0,
18009       NULL
18010     };
18011     int r;
18012     suppress_error = 0;
18013     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18014     if (r == -1)
18015       return -1;
18016   }
18017   {
18018     char fstype[] = "ext2";
18019     char device[] = "/dev/sda1";
18020     int r;
18021     suppress_error = 0;
18022     r = guestfs_mkfs (g, fstype, device);
18023     if (r == -1)
18024       return -1;
18025   }
18026   {
18027     char device[] = "/dev/sda1";
18028     char mountpoint[] = "/";
18029     int r;
18030     suppress_error = 0;
18031     r = guestfs_mount (g, device, mountpoint);
18032     if (r == -1)
18033       return -1;
18034   }
18035   /* TestOutputList for ls (0) */
18036   {
18037     char path[] = "/new";
18038     int r;
18039     suppress_error = 0;
18040     r = guestfs_touch (g, path);
18041     if (r == -1)
18042       return -1;
18043   }
18044   {
18045     char path[] = "/newer";
18046     int r;
18047     suppress_error = 0;
18048     r = guestfs_touch (g, path);
18049     if (r == -1)
18050       return -1;
18051   }
18052   {
18053     char path[] = "/newest";
18054     int r;
18055     suppress_error = 0;
18056     r = guestfs_touch (g, path);
18057     if (r == -1)
18058       return -1;
18059   }
18060   {
18061     char directory[] = "/";
18062     char **r;
18063     int i;
18064     suppress_error = 0;
18065     r = guestfs_ls (g, directory);
18066     if (r == NULL)
18067       return -1;
18068     if (!r[0]) {
18069       fprintf (stderr, "test_ls_0: short list returned from command\n");
18070       print_strings (r);
18071       return -1;
18072     }
18073     {
18074       char expected[] = "lost+found";
18075       if (strcmp (r[0], expected) != 0) {
18076         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18077         return -1;
18078       }
18079     }
18080     if (!r[1]) {
18081       fprintf (stderr, "test_ls_0: short list returned from command\n");
18082       print_strings (r);
18083       return -1;
18084     }
18085     {
18086       char expected[] = "new";
18087       if (strcmp (r[1], expected) != 0) {
18088         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18089         return -1;
18090       }
18091     }
18092     if (!r[2]) {
18093       fprintf (stderr, "test_ls_0: short list returned from command\n");
18094       print_strings (r);
18095       return -1;
18096     }
18097     {
18098       char expected[] = "newer";
18099       if (strcmp (r[2], expected) != 0) {
18100         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18101         return -1;
18102       }
18103     }
18104     if (!r[3]) {
18105       fprintf (stderr, "test_ls_0: short list returned from command\n");
18106       print_strings (r);
18107       return -1;
18108     }
18109     {
18110       char expected[] = "newest";
18111       if (strcmp (r[3], expected) != 0) {
18112         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18113         return -1;
18114       }
18115     }
18116     if (r[4] != NULL) {
18117       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18118       print_strings (r);
18119       return -1;
18120     }
18121     for (i = 0; r[i] != NULL; ++i)
18122       free (r[i]);
18123     free (r);
18124   }
18125   return 0;
18126 }
18127
18128 static int test_cat_0_skip (void)
18129 {
18130   const char *str;
18131
18132   str = getenv ("TEST_ONLY");
18133   if (str)
18134     return strstr (str, "cat") == NULL;
18135   str = getenv ("SKIP_TEST_CAT_0");
18136   if (str && strcmp (str, "1") == 0) return 1;
18137   str = getenv ("SKIP_TEST_CAT");
18138   if (str && strcmp (str, "1") == 0) return 1;
18139   return 0;
18140 }
18141
18142 static int test_cat_0 (void)
18143 {
18144   if (test_cat_0_skip ()) {
18145     printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18146     return 0;
18147   }
18148
18149   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18150   {
18151     char device[] = "/dev/sda";
18152     int r;
18153     suppress_error = 0;
18154     r = guestfs_blockdev_setrw (g, device);
18155     if (r == -1)
18156       return -1;
18157   }
18158   {
18159     int r;
18160     suppress_error = 0;
18161     r = guestfs_umount_all (g);
18162     if (r == -1)
18163       return -1;
18164   }
18165   {
18166     int r;
18167     suppress_error = 0;
18168     r = guestfs_lvm_remove_all (g);
18169     if (r == -1)
18170       return -1;
18171   }
18172   {
18173     char device[] = "/dev/sda";
18174     char lines_0[] = ",";
18175     char *lines[] = {
18176       lines_0,
18177       NULL
18178     };
18179     int r;
18180     suppress_error = 0;
18181     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18182     if (r == -1)
18183       return -1;
18184   }
18185   {
18186     char fstype[] = "ext2";
18187     char device[] = "/dev/sda1";
18188     int r;
18189     suppress_error = 0;
18190     r = guestfs_mkfs (g, fstype, device);
18191     if (r == -1)
18192       return -1;
18193   }
18194   {
18195     char device[] = "/dev/sda1";
18196     char mountpoint[] = "/";
18197     int r;
18198     suppress_error = 0;
18199     r = guestfs_mount (g, device, mountpoint);
18200     if (r == -1)
18201       return -1;
18202   }
18203   /* TestOutput for cat (0) */
18204   char expected[] = "new file contents";
18205   {
18206     char path[] = "/new";
18207     char content[] = "new file contents";
18208     int r;
18209     suppress_error = 0;
18210     r = guestfs_write_file (g, path, content, 0);
18211     if (r == -1)
18212       return -1;
18213   }
18214   {
18215     char path[] = "/new";
18216     char *r;
18217     suppress_error = 0;
18218     r = guestfs_cat (g, path);
18219     if (r == NULL)
18220       return -1;
18221     if (strcmp (r, expected) != 0) {
18222       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18223       return -1;
18224     }
18225     free (r);
18226   }
18227   return 0;
18228 }
18229
18230 static int test_touch_0_skip (void)
18231 {
18232   const char *str;
18233
18234   str = getenv ("TEST_ONLY");
18235   if (str)
18236     return strstr (str, "touch") == NULL;
18237   str = getenv ("SKIP_TEST_TOUCH_0");
18238   if (str && strcmp (str, "1") == 0) return 1;
18239   str = getenv ("SKIP_TEST_TOUCH");
18240   if (str && strcmp (str, "1") == 0) return 1;
18241   return 0;
18242 }
18243
18244 static int test_touch_0 (void)
18245 {
18246   if (test_touch_0_skip ()) {
18247     printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18248     return 0;
18249   }
18250
18251   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18252   {
18253     char device[] = "/dev/sda";
18254     int r;
18255     suppress_error = 0;
18256     r = guestfs_blockdev_setrw (g, device);
18257     if (r == -1)
18258       return -1;
18259   }
18260   {
18261     int r;
18262     suppress_error = 0;
18263     r = guestfs_umount_all (g);
18264     if (r == -1)
18265       return -1;
18266   }
18267   {
18268     int r;
18269     suppress_error = 0;
18270     r = guestfs_lvm_remove_all (g);
18271     if (r == -1)
18272       return -1;
18273   }
18274   {
18275     char device[] = "/dev/sda";
18276     char lines_0[] = ",";
18277     char *lines[] = {
18278       lines_0,
18279       NULL
18280     };
18281     int r;
18282     suppress_error = 0;
18283     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18284     if (r == -1)
18285       return -1;
18286   }
18287   {
18288     char fstype[] = "ext2";
18289     char device[] = "/dev/sda1";
18290     int r;
18291     suppress_error = 0;
18292     r = guestfs_mkfs (g, fstype, device);
18293     if (r == -1)
18294       return -1;
18295   }
18296   {
18297     char device[] = "/dev/sda1";
18298     char mountpoint[] = "/";
18299     int r;
18300     suppress_error = 0;
18301     r = guestfs_mount (g, device, mountpoint);
18302     if (r == -1)
18303       return -1;
18304   }
18305   /* TestOutputTrue for touch (0) */
18306   {
18307     char path[] = "/new";
18308     int r;
18309     suppress_error = 0;
18310     r = guestfs_touch (g, path);
18311     if (r == -1)
18312       return -1;
18313   }
18314   {
18315     char path[] = "/new";
18316     int r;
18317     suppress_error = 0;
18318     r = guestfs_exists (g, path);
18319     if (r == -1)
18320       return -1;
18321     if (!r) {
18322       fprintf (stderr, "test_touch_0: expected true, got false\n");
18323       return -1;
18324     }
18325   }
18326   return 0;
18327 }
18328
18329 static int test_sync_0_skip (void)
18330 {
18331   const char *str;
18332
18333   str = getenv ("TEST_ONLY");
18334   if (str)
18335     return strstr (str, "sync") == NULL;
18336   str = getenv ("SKIP_TEST_SYNC_0");
18337   if (str && strcmp (str, "1") == 0) return 1;
18338   str = getenv ("SKIP_TEST_SYNC");
18339   if (str && strcmp (str, "1") == 0) return 1;
18340   return 0;
18341 }
18342
18343 static int test_sync_0 (void)
18344 {
18345   if (test_sync_0_skip ()) {
18346     printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18347     return 0;
18348   }
18349
18350   /* InitNone|InitEmpty for test_sync_0 */
18351   {
18352     char device[] = "/dev/sda";
18353     int r;
18354     suppress_error = 0;
18355     r = guestfs_blockdev_setrw (g, device);
18356     if (r == -1)
18357       return -1;
18358   }
18359   {
18360     int r;
18361     suppress_error = 0;
18362     r = guestfs_umount_all (g);
18363     if (r == -1)
18364       return -1;
18365   }
18366   {
18367     int r;
18368     suppress_error = 0;
18369     r = guestfs_lvm_remove_all (g);
18370     if (r == -1)
18371       return -1;
18372   }
18373   /* TestRun for sync (0) */
18374   {
18375     int r;
18376     suppress_error = 0;
18377     r = guestfs_sync (g);
18378     if (r == -1)
18379       return -1;
18380   }
18381   return 0;
18382 }
18383
18384 static int test_mount_0_skip (void)
18385 {
18386   const char *str;
18387
18388   str = getenv ("TEST_ONLY");
18389   if (str)
18390     return strstr (str, "mount") == NULL;
18391   str = getenv ("SKIP_TEST_MOUNT_0");
18392   if (str && strcmp (str, "1") == 0) return 1;
18393   str = getenv ("SKIP_TEST_MOUNT");
18394   if (str && strcmp (str, "1") == 0) return 1;
18395   return 0;
18396 }
18397
18398 static int test_mount_0 (void)
18399 {
18400   if (test_mount_0_skip ()) {
18401     printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18402     return 0;
18403   }
18404
18405   /* InitNone|InitEmpty for test_mount_0 */
18406   {
18407     char device[] = "/dev/sda";
18408     int r;
18409     suppress_error = 0;
18410     r = guestfs_blockdev_setrw (g, device);
18411     if (r == -1)
18412       return -1;
18413   }
18414   {
18415     int r;
18416     suppress_error = 0;
18417     r = guestfs_umount_all (g);
18418     if (r == -1)
18419       return -1;
18420   }
18421   {
18422     int r;
18423     suppress_error = 0;
18424     r = guestfs_lvm_remove_all (g);
18425     if (r == -1)
18426       return -1;
18427   }
18428   /* TestOutput for mount (0) */
18429   char expected[] = "new file contents";
18430   {
18431     char device[] = "/dev/sda";
18432     char lines_0[] = ",";
18433     char *lines[] = {
18434       lines_0,
18435       NULL
18436     };
18437     int r;
18438     suppress_error = 0;
18439     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18440     if (r == -1)
18441       return -1;
18442   }
18443   {
18444     char fstype[] = "ext2";
18445     char device[] = "/dev/sda1";
18446     int r;
18447     suppress_error = 0;
18448     r = guestfs_mkfs (g, fstype, device);
18449     if (r == -1)
18450       return -1;
18451   }
18452   {
18453     char device[] = "/dev/sda1";
18454     char mountpoint[] = "/";
18455     int r;
18456     suppress_error = 0;
18457     r = guestfs_mount (g, device, mountpoint);
18458     if (r == -1)
18459       return -1;
18460   }
18461   {
18462     char path[] = "/new";
18463     char content[] = "new file contents";
18464     int r;
18465     suppress_error = 0;
18466     r = guestfs_write_file (g, path, content, 0);
18467     if (r == -1)
18468       return -1;
18469   }
18470   {
18471     char path[] = "/new";
18472     char *r;
18473     suppress_error = 0;
18474     r = guestfs_cat (g, path);
18475     if (r == NULL)
18476       return -1;
18477     if (strcmp (r, expected) != 0) {
18478       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18479       return -1;
18480     }
18481     free (r);
18482   }
18483   return 0;
18484 }
18485
18486 int main (int argc, char *argv[])
18487 {
18488   char c = 0;
18489   int failed = 0;
18490   const char *filename;
18491   int fd;
18492   int nr_tests, test_num = 0;
18493
18494   no_test_warnings ();
18495
18496   g = guestfs_create ();
18497   if (g == NULL) {
18498     printf ("guestfs_create FAILED\n");
18499     exit (1);
18500   }
18501
18502   guestfs_set_error_handler (g, print_error, NULL);
18503
18504   guestfs_set_path (g, "../appliance");
18505
18506   filename = "test1.img";
18507   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18508   if (fd == -1) {
18509     perror (filename);
18510     exit (1);
18511   }
18512   if (lseek (fd, 524288000, SEEK_SET) == -1) {
18513     perror ("lseek");
18514     close (fd);
18515     unlink (filename);
18516     exit (1);
18517   }
18518   if (write (fd, &c, 1) == -1) {
18519     perror ("write");
18520     close (fd);
18521     unlink (filename);
18522     exit (1);
18523   }
18524   if (close (fd) == -1) {
18525     perror (filename);
18526     unlink (filename);
18527     exit (1);
18528   }
18529   if (guestfs_add_drive (g, filename) == -1) {
18530     printf ("guestfs_add_drive %s FAILED\n", filename);
18531     exit (1);
18532   }
18533
18534   filename = "test2.img";
18535   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18536   if (fd == -1) {
18537     perror (filename);
18538     exit (1);
18539   }
18540   if (lseek (fd, 52428800, SEEK_SET) == -1) {
18541     perror ("lseek");
18542     close (fd);
18543     unlink (filename);
18544     exit (1);
18545   }
18546   if (write (fd, &c, 1) == -1) {
18547     perror ("write");
18548     close (fd);
18549     unlink (filename);
18550     exit (1);
18551   }
18552   if (close (fd) == -1) {
18553     perror (filename);
18554     unlink (filename);
18555     exit (1);
18556   }
18557   if (guestfs_add_drive (g, filename) == -1) {
18558     printf ("guestfs_add_drive %s FAILED\n", filename);
18559     exit (1);
18560   }
18561
18562   filename = "test3.img";
18563   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18564   if (fd == -1) {
18565     perror (filename);
18566     exit (1);
18567   }
18568   if (lseek (fd, 10485760, SEEK_SET) == -1) {
18569     perror ("lseek");
18570     close (fd);
18571     unlink (filename);
18572     exit (1);
18573   }
18574   if (write (fd, &c, 1) == -1) {
18575     perror ("write");
18576     close (fd);
18577     unlink (filename);
18578     exit (1);
18579   }
18580   if (close (fd) == -1) {
18581     perror (filename);
18582     unlink (filename);
18583     exit (1);
18584   }
18585   if (guestfs_add_drive (g, filename) == -1) {
18586     printf ("guestfs_add_drive %s FAILED\n", filename);
18587     exit (1);
18588   }
18589
18590   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18591     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18592     exit (1);
18593   }
18594
18595   if (guestfs_launch (g) == -1) {
18596     printf ("guestfs_launch FAILED\n");
18597     exit (1);
18598   }
18599
18600   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18601   alarm (600);
18602
18603   if (guestfs_wait_ready (g) == -1) {
18604     printf ("guestfs_wait_ready FAILED\n");
18605     exit (1);
18606   }
18607
18608   /* Cancel previous alarm. */
18609   alarm (0);
18610
18611   nr_tests = 165;
18612
18613   test_num++;
18614   printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
18615   if (test_du_0 () == -1) {
18616     printf ("test_du_0 FAILED\n");
18617     failed++;
18618   }
18619   test_num++;
18620   printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
18621   if (test_tail_n_0 () == -1) {
18622     printf ("test_tail_n_0 FAILED\n");
18623     failed++;
18624   }
18625   test_num++;
18626   printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
18627   if (test_tail_n_1 () == -1) {
18628     printf ("test_tail_n_1 FAILED\n");
18629     failed++;
18630   }
18631   test_num++;
18632   printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
18633   if (test_tail_n_2 () == -1) {
18634     printf ("test_tail_n_2 FAILED\n");
18635     failed++;
18636   }
18637   test_num++;
18638   printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
18639   if (test_tail_0 () == -1) {
18640     printf ("test_tail_0 FAILED\n");
18641     failed++;
18642   }
18643   test_num++;
18644   printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
18645   if (test_head_n_0 () == -1) {
18646     printf ("test_head_n_0 FAILED\n");
18647     failed++;
18648   }
18649   test_num++;
18650   printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
18651   if (test_head_n_1 () == -1) {
18652     printf ("test_head_n_1 FAILED\n");
18653     failed++;
18654   }
18655   test_num++;
18656   printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
18657   if (test_head_n_2 () == -1) {
18658     printf ("test_head_n_2 FAILED\n");
18659     failed++;
18660   }
18661   test_num++;
18662   printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
18663   if (test_head_0 () == -1) {
18664     printf ("test_head_0 FAILED\n");
18665     failed++;
18666   }
18667   test_num++;
18668   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
18669   if (test_wc_c_0 () == -1) {
18670     printf ("test_wc_c_0 FAILED\n");
18671     failed++;
18672   }
18673   test_num++;
18674   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
18675   if (test_wc_w_0 () == -1) {
18676     printf ("test_wc_w_0 FAILED\n");
18677     failed++;
18678   }
18679   test_num++;
18680   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
18681   if (test_wc_l_0 () == -1) {
18682     printf ("test_wc_l_0 FAILED\n");
18683     failed++;
18684   }
18685   test_num++;
18686   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
18687   if (test_mkdtemp_0 () == -1) {
18688     printf ("test_mkdtemp_0 FAILED\n");
18689     failed++;
18690   }
18691   test_num++;
18692   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
18693   if (test_scrub_file_0 () == -1) {
18694     printf ("test_scrub_file_0 FAILED\n");
18695     failed++;
18696   }
18697   test_num++;
18698   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
18699   if (test_scrub_device_0 () == -1) {
18700     printf ("test_scrub_device_0 FAILED\n");
18701     failed++;
18702   }
18703   test_num++;
18704   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
18705   if (test_glob_expand_0 () == -1) {
18706     printf ("test_glob_expand_0 FAILED\n");
18707     failed++;
18708   }
18709   test_num++;
18710   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
18711   if (test_glob_expand_1 () == -1) {
18712     printf ("test_glob_expand_1 FAILED\n");
18713     failed++;
18714   }
18715   test_num++;
18716   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
18717   if (test_glob_expand_2 () == -1) {
18718     printf ("test_glob_expand_2 FAILED\n");
18719     failed++;
18720   }
18721   test_num++;
18722   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
18723   if (test_ntfs_3g_probe_0 () == -1) {
18724     printf ("test_ntfs_3g_probe_0 FAILED\n");
18725     failed++;
18726   }
18727   test_num++;
18728   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
18729   if (test_ntfs_3g_probe_1 () == -1) {
18730     printf ("test_ntfs_3g_probe_1 FAILED\n");
18731     failed++;
18732   }
18733   test_num++;
18734   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
18735   if (test_sleep_0 () == -1) {
18736     printf ("test_sleep_0 FAILED\n");
18737     failed++;
18738   }
18739   test_num++;
18740   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
18741   if (test_find_0 () == -1) {
18742     printf ("test_find_0 FAILED\n");
18743     failed++;
18744   }
18745   test_num++;
18746   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
18747   if (test_find_1 () == -1) {
18748     printf ("test_find_1 FAILED\n");
18749     failed++;
18750   }
18751   test_num++;
18752   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
18753   if (test_find_2 () == -1) {
18754     printf ("test_find_2 FAILED\n");
18755     failed++;
18756   }
18757   test_num++;
18758   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
18759   if (test_lvresize_0 () == -1) {
18760     printf ("test_lvresize_0 FAILED\n");
18761     failed++;
18762   }
18763   test_num++;
18764   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
18765   if (test_zerofree_0 () == -1) {
18766     printf ("test_zerofree_0 FAILED\n");
18767     failed++;
18768   }
18769   test_num++;
18770   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
18771   if (test_hexdump_0 () == -1) {
18772     printf ("test_hexdump_0 FAILED\n");
18773     failed++;
18774   }
18775   test_num++;
18776   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
18777   if (test_hexdump_1 () == -1) {
18778     printf ("test_hexdump_1 FAILED\n");
18779     failed++;
18780   }
18781   test_num++;
18782   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
18783   if (test_strings_e_0 () == -1) {
18784     printf ("test_strings_e_0 FAILED\n");
18785     failed++;
18786   }
18787   test_num++;
18788   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
18789   if (test_strings_e_1 () == -1) {
18790     printf ("test_strings_e_1 FAILED\n");
18791     failed++;
18792   }
18793   test_num++;
18794   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
18795   if (test_strings_0 () == -1) {
18796     printf ("test_strings_0 FAILED\n");
18797     failed++;
18798   }
18799   test_num++;
18800   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
18801   if (test_strings_1 () == -1) {
18802     printf ("test_strings_1 FAILED\n");
18803     failed++;
18804   }
18805   test_num++;
18806   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
18807   if (test_equal_0 () == -1) {
18808     printf ("test_equal_0 FAILED\n");
18809     failed++;
18810   }
18811   test_num++;
18812   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
18813   if (test_equal_1 () == -1) {
18814     printf ("test_equal_1 FAILED\n");
18815     failed++;
18816   }
18817   test_num++;
18818   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
18819   if (test_equal_2 () == -1) {
18820     printf ("test_equal_2 FAILED\n");
18821     failed++;
18822   }
18823   test_num++;
18824   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
18825   if (test_ping_daemon_0 () == -1) {
18826     printf ("test_ping_daemon_0 FAILED\n");
18827     failed++;
18828   }
18829   test_num++;
18830   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
18831   if (test_dmesg_0 () == -1) {
18832     printf ("test_dmesg_0 FAILED\n");
18833     failed++;
18834   }
18835   test_num++;
18836   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
18837   if (test_drop_caches_0 () == -1) {
18838     printf ("test_drop_caches_0 FAILED\n");
18839     failed++;
18840   }
18841   test_num++;
18842   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
18843   if (test_mv_0 () == -1) {
18844     printf ("test_mv_0 FAILED\n");
18845     failed++;
18846   }
18847   test_num++;
18848   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
18849   if (test_mv_1 () == -1) {
18850     printf ("test_mv_1 FAILED\n");
18851     failed++;
18852   }
18853   test_num++;
18854   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
18855   if (test_cp_a_0 () == -1) {
18856     printf ("test_cp_a_0 FAILED\n");
18857     failed++;
18858   }
18859   test_num++;
18860   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
18861   if (test_cp_0 () == -1) {
18862     printf ("test_cp_0 FAILED\n");
18863     failed++;
18864   }
18865   test_num++;
18866   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
18867   if (test_cp_1 () == -1) {
18868     printf ("test_cp_1 FAILED\n");
18869     failed++;
18870   }
18871   test_num++;
18872   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
18873   if (test_cp_2 () == -1) {
18874     printf ("test_cp_2 FAILED\n");
18875     failed++;
18876   }
18877   test_num++;
18878   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
18879   if (test_grub_install_0 () == -1) {
18880     printf ("test_grub_install_0 FAILED\n");
18881     failed++;
18882   }
18883   test_num++;
18884   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
18885   if (test_zero_0 () == -1) {
18886     printf ("test_zero_0 FAILED\n");
18887     failed++;
18888   }
18889   test_num++;
18890   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
18891   if (test_fsck_0 () == -1) {
18892     printf ("test_fsck_0 FAILED\n");
18893     failed++;
18894   }
18895   test_num++;
18896   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
18897   if (test_fsck_1 () == -1) {
18898     printf ("test_fsck_1 FAILED\n");
18899     failed++;
18900   }
18901   test_num++;
18902   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
18903   if (test_set_e2uuid_0 () == -1) {
18904     printf ("test_set_e2uuid_0 FAILED\n");
18905     failed++;
18906   }
18907   test_num++;
18908   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
18909   if (test_set_e2uuid_1 () == -1) {
18910     printf ("test_set_e2uuid_1 FAILED\n");
18911     failed++;
18912   }
18913   test_num++;
18914   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
18915   if (test_set_e2uuid_2 () == -1) {
18916     printf ("test_set_e2uuid_2 FAILED\n");
18917     failed++;
18918   }
18919   test_num++;
18920   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
18921   if (test_set_e2uuid_3 () == -1) {
18922     printf ("test_set_e2uuid_3 FAILED\n");
18923     failed++;
18924   }
18925   test_num++;
18926   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
18927   if (test_set_e2label_0 () == -1) {
18928     printf ("test_set_e2label_0 FAILED\n");
18929     failed++;
18930   }
18931   test_num++;
18932   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
18933   if (test_pvremove_0 () == -1) {
18934     printf ("test_pvremove_0 FAILED\n");
18935     failed++;
18936   }
18937   test_num++;
18938   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
18939   if (test_pvremove_1 () == -1) {
18940     printf ("test_pvremove_1 FAILED\n");
18941     failed++;
18942   }
18943   test_num++;
18944   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
18945   if (test_pvremove_2 () == -1) {
18946     printf ("test_pvremove_2 FAILED\n");
18947     failed++;
18948   }
18949   test_num++;
18950   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
18951   if (test_vgremove_0 () == -1) {
18952     printf ("test_vgremove_0 FAILED\n");
18953     failed++;
18954   }
18955   test_num++;
18956   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
18957   if (test_vgremove_1 () == -1) {
18958     printf ("test_vgremove_1 FAILED\n");
18959     failed++;
18960   }
18961   test_num++;
18962   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
18963   if (test_lvremove_0 () == -1) {
18964     printf ("test_lvremove_0 FAILED\n");
18965     failed++;
18966   }
18967   test_num++;
18968   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
18969   if (test_lvremove_1 () == -1) {
18970     printf ("test_lvremove_1 FAILED\n");
18971     failed++;
18972   }
18973   test_num++;
18974   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
18975   if (test_lvremove_2 () == -1) {
18976     printf ("test_lvremove_2 FAILED\n");
18977     failed++;
18978   }
18979   test_num++;
18980   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
18981   if (test_mount_ro_0 () == -1) {
18982     printf ("test_mount_ro_0 FAILED\n");
18983     failed++;
18984   }
18985   test_num++;
18986   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
18987   if (test_mount_ro_1 () == -1) {
18988     printf ("test_mount_ro_1 FAILED\n");
18989     failed++;
18990   }
18991   test_num++;
18992   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
18993   if (test_tgz_in_0 () == -1) {
18994     printf ("test_tgz_in_0 FAILED\n");
18995     failed++;
18996   }
18997   test_num++;
18998   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
18999   if (test_tar_in_0 () == -1) {
19000     printf ("test_tar_in_0 FAILED\n");
19001     failed++;
19002   }
19003   test_num++;
19004   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19005   if (test_checksum_0 () == -1) {
19006     printf ("test_checksum_0 FAILED\n");
19007     failed++;
19008   }
19009   test_num++;
19010   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19011   if (test_checksum_1 () == -1) {
19012     printf ("test_checksum_1 FAILED\n");
19013     failed++;
19014   }
19015   test_num++;
19016   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19017   if (test_checksum_2 () == -1) {
19018     printf ("test_checksum_2 FAILED\n");
19019     failed++;
19020   }
19021   test_num++;
19022   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19023   if (test_checksum_3 () == -1) {
19024     printf ("test_checksum_3 FAILED\n");
19025     failed++;
19026   }
19027   test_num++;
19028   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19029   if (test_checksum_4 () == -1) {
19030     printf ("test_checksum_4 FAILED\n");
19031     failed++;
19032   }
19033   test_num++;
19034   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19035   if (test_checksum_5 () == -1) {
19036     printf ("test_checksum_5 FAILED\n");
19037     failed++;
19038   }
19039   test_num++;
19040   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19041   if (test_checksum_6 () == -1) {
19042     printf ("test_checksum_6 FAILED\n");
19043     failed++;
19044   }
19045   test_num++;
19046   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19047   if (test_checksum_7 () == -1) {
19048     printf ("test_checksum_7 FAILED\n");
19049     failed++;
19050   }
19051   test_num++;
19052   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19053   if (test_checksum_8 () == -1) {
19054     printf ("test_checksum_8 FAILED\n");
19055     failed++;
19056   }
19057   test_num++;
19058   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19059   if (test_download_0 () == -1) {
19060     printf ("test_download_0 FAILED\n");
19061     failed++;
19062   }
19063   test_num++;
19064   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19065   if (test_upload_0 () == -1) {
19066     printf ("test_upload_0 FAILED\n");
19067     failed++;
19068   }
19069   test_num++;
19070   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19071   if (test_blockdev_rereadpt_0 () == -1) {
19072     printf ("test_blockdev_rereadpt_0 FAILED\n");
19073     failed++;
19074   }
19075   test_num++;
19076   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19077   if (test_blockdev_flushbufs_0 () == -1) {
19078     printf ("test_blockdev_flushbufs_0 FAILED\n");
19079     failed++;
19080   }
19081   test_num++;
19082   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19083   if (test_blockdev_getsize64_0 () == -1) {
19084     printf ("test_blockdev_getsize64_0 FAILED\n");
19085     failed++;
19086   }
19087   test_num++;
19088   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19089   if (test_blockdev_getsz_0 () == -1) {
19090     printf ("test_blockdev_getsz_0 FAILED\n");
19091     failed++;
19092   }
19093   test_num++;
19094   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19095   if (test_blockdev_getbsz_0 () == -1) {
19096     printf ("test_blockdev_getbsz_0 FAILED\n");
19097     failed++;
19098   }
19099   test_num++;
19100   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19101   if (test_blockdev_getss_0 () == -1) {
19102     printf ("test_blockdev_getss_0 FAILED\n");
19103     failed++;
19104   }
19105   test_num++;
19106   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19107   if (test_blockdev_getro_0 () == -1) {
19108     printf ("test_blockdev_getro_0 FAILED\n");
19109     failed++;
19110   }
19111   test_num++;
19112   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19113   if (test_blockdev_setrw_0 () == -1) {
19114     printf ("test_blockdev_setrw_0 FAILED\n");
19115     failed++;
19116   }
19117   test_num++;
19118   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19119   if (test_blockdev_setro_0 () == -1) {
19120     printf ("test_blockdev_setro_0 FAILED\n");
19121     failed++;
19122   }
19123   test_num++;
19124   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19125   if (test_statvfs_0 () == -1) {
19126     printf ("test_statvfs_0 FAILED\n");
19127     failed++;
19128   }
19129   test_num++;
19130   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19131   if (test_lstat_0 () == -1) {
19132     printf ("test_lstat_0 FAILED\n");
19133     failed++;
19134   }
19135   test_num++;
19136   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19137   if (test_stat_0 () == -1) {
19138     printf ("test_stat_0 FAILED\n");
19139     failed++;
19140   }
19141   test_num++;
19142   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19143   if (test_command_lines_0 () == -1) {
19144     printf ("test_command_lines_0 FAILED\n");
19145     failed++;
19146   }
19147   test_num++;
19148   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19149   if (test_command_lines_1 () == -1) {
19150     printf ("test_command_lines_1 FAILED\n");
19151     failed++;
19152   }
19153   test_num++;
19154   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19155   if (test_command_lines_2 () == -1) {
19156     printf ("test_command_lines_2 FAILED\n");
19157     failed++;
19158   }
19159   test_num++;
19160   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19161   if (test_command_lines_3 () == -1) {
19162     printf ("test_command_lines_3 FAILED\n");
19163     failed++;
19164   }
19165   test_num++;
19166   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19167   if (test_command_lines_4 () == -1) {
19168     printf ("test_command_lines_4 FAILED\n");
19169     failed++;
19170   }
19171   test_num++;
19172   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19173   if (test_command_lines_5 () == -1) {
19174     printf ("test_command_lines_5 FAILED\n");
19175     failed++;
19176   }
19177   test_num++;
19178   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19179   if (test_command_lines_6 () == -1) {
19180     printf ("test_command_lines_6 FAILED\n");
19181     failed++;
19182   }
19183   test_num++;
19184   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19185   if (test_command_lines_7 () == -1) {
19186     printf ("test_command_lines_7 FAILED\n");
19187     failed++;
19188   }
19189   test_num++;
19190   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19191   if (test_command_lines_8 () == -1) {
19192     printf ("test_command_lines_8 FAILED\n");
19193     failed++;
19194   }
19195   test_num++;
19196   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19197   if (test_command_lines_9 () == -1) {
19198     printf ("test_command_lines_9 FAILED\n");
19199     failed++;
19200   }
19201   test_num++;
19202   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19203   if (test_command_lines_10 () == -1) {
19204     printf ("test_command_lines_10 FAILED\n");
19205     failed++;
19206   }
19207   test_num++;
19208   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19209   if (test_command_0 () == -1) {
19210     printf ("test_command_0 FAILED\n");
19211     failed++;
19212   }
19213   test_num++;
19214   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19215   if (test_command_1 () == -1) {
19216     printf ("test_command_1 FAILED\n");
19217     failed++;
19218   }
19219   test_num++;
19220   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19221   if (test_command_2 () == -1) {
19222     printf ("test_command_2 FAILED\n");
19223     failed++;
19224   }
19225   test_num++;
19226   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19227   if (test_command_3 () == -1) {
19228     printf ("test_command_3 FAILED\n");
19229     failed++;
19230   }
19231   test_num++;
19232   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19233   if (test_command_4 () == -1) {
19234     printf ("test_command_4 FAILED\n");
19235     failed++;
19236   }
19237   test_num++;
19238   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19239   if (test_command_5 () == -1) {
19240     printf ("test_command_5 FAILED\n");
19241     failed++;
19242   }
19243   test_num++;
19244   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19245   if (test_command_6 () == -1) {
19246     printf ("test_command_6 FAILED\n");
19247     failed++;
19248   }
19249   test_num++;
19250   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19251   if (test_command_7 () == -1) {
19252     printf ("test_command_7 FAILED\n");
19253     failed++;
19254   }
19255   test_num++;
19256   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19257   if (test_command_8 () == -1) {
19258     printf ("test_command_8 FAILED\n");
19259     failed++;
19260   }
19261   test_num++;
19262   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19263   if (test_command_9 () == -1) {
19264     printf ("test_command_9 FAILED\n");
19265     failed++;
19266   }
19267   test_num++;
19268   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19269   if (test_command_10 () == -1) {
19270     printf ("test_command_10 FAILED\n");
19271     failed++;
19272   }
19273   test_num++;
19274   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19275   if (test_command_11 () == -1) {
19276     printf ("test_command_11 FAILED\n");
19277     failed++;
19278   }
19279   test_num++;
19280   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19281   if (test_file_0 () == -1) {
19282     printf ("test_file_0 FAILED\n");
19283     failed++;
19284   }
19285   test_num++;
19286   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19287   if (test_file_1 () == -1) {
19288     printf ("test_file_1 FAILED\n");
19289     failed++;
19290   }
19291   test_num++;
19292   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19293   if (test_file_2 () == -1) {
19294     printf ("test_file_2 FAILED\n");
19295     failed++;
19296   }
19297   test_num++;
19298   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19299   if (test_umount_all_0 () == -1) {
19300     printf ("test_umount_all_0 FAILED\n");
19301     failed++;
19302   }
19303   test_num++;
19304   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19305   if (test_umount_all_1 () == -1) {
19306     printf ("test_umount_all_1 FAILED\n");
19307     failed++;
19308   }
19309   test_num++;
19310   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19311   if (test_mounts_0 () == -1) {
19312     printf ("test_mounts_0 FAILED\n");
19313     failed++;
19314   }
19315   test_num++;
19316   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19317   if (test_umount_0 () == -1) {
19318     printf ("test_umount_0 FAILED\n");
19319     failed++;
19320   }
19321   test_num++;
19322   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19323   if (test_umount_1 () == -1) {
19324     printf ("test_umount_1 FAILED\n");
19325     failed++;
19326   }
19327   test_num++;
19328   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19329   if (test_write_file_0 () == -1) {
19330     printf ("test_write_file_0 FAILED\n");
19331     failed++;
19332   }
19333   test_num++;
19334   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19335   if (test_write_file_1 () == -1) {
19336     printf ("test_write_file_1 FAILED\n");
19337     failed++;
19338   }
19339   test_num++;
19340   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19341   if (test_write_file_2 () == -1) {
19342     printf ("test_write_file_2 FAILED\n");
19343     failed++;
19344   }
19345   test_num++;
19346   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19347   if (test_write_file_3 () == -1) {
19348     printf ("test_write_file_3 FAILED\n");
19349     failed++;
19350   }
19351   test_num++;
19352   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19353   if (test_write_file_4 () == -1) {
19354     printf ("test_write_file_4 FAILED\n");
19355     failed++;
19356   }
19357   test_num++;
19358   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19359   if (test_write_file_5 () == -1) {
19360     printf ("test_write_file_5 FAILED\n");
19361     failed++;
19362   }
19363   test_num++;
19364   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19365   if (test_mkfs_0 () == -1) {
19366     printf ("test_mkfs_0 FAILED\n");
19367     failed++;
19368   }
19369   test_num++;
19370   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19371   if (test_lvcreate_0 () == -1) {
19372     printf ("test_lvcreate_0 FAILED\n");
19373     failed++;
19374   }
19375   test_num++;
19376   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19377   if (test_vgcreate_0 () == -1) {
19378     printf ("test_vgcreate_0 FAILED\n");
19379     failed++;
19380   }
19381   test_num++;
19382   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19383   if (test_pvcreate_0 () == -1) {
19384     printf ("test_pvcreate_0 FAILED\n");
19385     failed++;
19386   }
19387   test_num++;
19388   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19389   if (test_is_dir_0 () == -1) {
19390     printf ("test_is_dir_0 FAILED\n");
19391     failed++;
19392   }
19393   test_num++;
19394   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19395   if (test_is_dir_1 () == -1) {
19396     printf ("test_is_dir_1 FAILED\n");
19397     failed++;
19398   }
19399   test_num++;
19400   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19401   if (test_is_file_0 () == -1) {
19402     printf ("test_is_file_0 FAILED\n");
19403     failed++;
19404   }
19405   test_num++;
19406   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19407   if (test_is_file_1 () == -1) {
19408     printf ("test_is_file_1 FAILED\n");
19409     failed++;
19410   }
19411   test_num++;
19412   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19413   if (test_exists_0 () == -1) {
19414     printf ("test_exists_0 FAILED\n");
19415     failed++;
19416   }
19417   test_num++;
19418   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19419   if (test_exists_1 () == -1) {
19420     printf ("test_exists_1 FAILED\n");
19421     failed++;
19422   }
19423   test_num++;
19424   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19425   if (test_mkdir_p_0 () == -1) {
19426     printf ("test_mkdir_p_0 FAILED\n");
19427     failed++;
19428   }
19429   test_num++;
19430   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19431   if (test_mkdir_p_1 () == -1) {
19432     printf ("test_mkdir_p_1 FAILED\n");
19433     failed++;
19434   }
19435   test_num++;
19436   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19437   if (test_mkdir_p_2 () == -1) {
19438     printf ("test_mkdir_p_2 FAILED\n");
19439     failed++;
19440   }
19441   test_num++;
19442   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19443   if (test_mkdir_p_3 () == -1) {
19444     printf ("test_mkdir_p_3 FAILED\n");
19445     failed++;
19446   }
19447   test_num++;
19448   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19449   if (test_mkdir_p_4 () == -1) {
19450     printf ("test_mkdir_p_4 FAILED\n");
19451     failed++;
19452   }
19453   test_num++;
19454   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19455   if (test_mkdir_0 () == -1) {
19456     printf ("test_mkdir_0 FAILED\n");
19457     failed++;
19458   }
19459   test_num++;
19460   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19461   if (test_mkdir_1 () == -1) {
19462     printf ("test_mkdir_1 FAILED\n");
19463     failed++;
19464   }
19465   test_num++;
19466   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19467   if (test_rm_rf_0 () == -1) {
19468     printf ("test_rm_rf_0 FAILED\n");
19469     failed++;
19470   }
19471   test_num++;
19472   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19473   if (test_rmdir_0 () == -1) {
19474     printf ("test_rmdir_0 FAILED\n");
19475     failed++;
19476   }
19477   test_num++;
19478   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19479   if (test_rmdir_1 () == -1) {
19480     printf ("test_rmdir_1 FAILED\n");
19481     failed++;
19482   }
19483   test_num++;
19484   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19485   if (test_rmdir_2 () == -1) {
19486     printf ("test_rmdir_2 FAILED\n");
19487     failed++;
19488   }
19489   test_num++;
19490   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19491   if (test_rm_0 () == -1) {
19492     printf ("test_rm_0 FAILED\n");
19493     failed++;
19494   }
19495   test_num++;
19496   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19497   if (test_rm_1 () == -1) {
19498     printf ("test_rm_1 FAILED\n");
19499     failed++;
19500   }
19501   test_num++;
19502   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19503   if (test_rm_2 () == -1) {
19504     printf ("test_rm_2 FAILED\n");
19505     failed++;
19506   }
19507   test_num++;
19508   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19509   if (test_read_lines_0 () == -1) {
19510     printf ("test_read_lines_0 FAILED\n");
19511     failed++;
19512   }
19513   test_num++;
19514   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19515   if (test_read_lines_1 () == -1) {
19516     printf ("test_read_lines_1 FAILED\n");
19517     failed++;
19518   }
19519   test_num++;
19520   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19521   if (test_lvs_0 () == -1) {
19522     printf ("test_lvs_0 FAILED\n");
19523     failed++;
19524   }
19525   test_num++;
19526   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19527   if (test_lvs_1 () == -1) {
19528     printf ("test_lvs_1 FAILED\n");
19529     failed++;
19530   }
19531   test_num++;
19532   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19533   if (test_vgs_0 () == -1) {
19534     printf ("test_vgs_0 FAILED\n");
19535     failed++;
19536   }
19537   test_num++;
19538   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19539   if (test_vgs_1 () == -1) {
19540     printf ("test_vgs_1 FAILED\n");
19541     failed++;
19542   }
19543   test_num++;
19544   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19545   if (test_pvs_0 () == -1) {
19546     printf ("test_pvs_0 FAILED\n");
19547     failed++;
19548   }
19549   test_num++;
19550   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19551   if (test_pvs_1 () == -1) {
19552     printf ("test_pvs_1 FAILED\n");
19553     failed++;
19554   }
19555   test_num++;
19556   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19557   if (test_list_partitions_0 () == -1) {
19558     printf ("test_list_partitions_0 FAILED\n");
19559     failed++;
19560   }
19561   test_num++;
19562   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19563   if (test_list_partitions_1 () == -1) {
19564     printf ("test_list_partitions_1 FAILED\n");
19565     failed++;
19566   }
19567   test_num++;
19568   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19569   if (test_list_devices_0 () == -1) {
19570     printf ("test_list_devices_0 FAILED\n");
19571     failed++;
19572   }
19573   test_num++;
19574   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19575   if (test_ls_0 () == -1) {
19576     printf ("test_ls_0 FAILED\n");
19577     failed++;
19578   }
19579   test_num++;
19580   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19581   if (test_cat_0 () == -1) {
19582     printf ("test_cat_0 FAILED\n");
19583     failed++;
19584   }
19585   test_num++;
19586   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19587   if (test_touch_0 () == -1) {
19588     printf ("test_touch_0 FAILED\n");
19589     failed++;
19590   }
19591   test_num++;
19592   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19593   if (test_sync_0 () == -1) {
19594     printf ("test_sync_0 FAILED\n");
19595     failed++;
19596   }
19597   test_num++;
19598   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19599   if (test_mount_0 () == -1) {
19600     printf ("test_mount_0 FAILED\n");
19601     failed++;
19602   }
19603
19604   guestfs_close (g);
19605   unlink ("test1.img");
19606   unlink ("test2.img");
19607   unlink ("test3.img");
19608
19609   if (failed > 0) {
19610     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
19611     exit (1);
19612   }
19613
19614   exit (0);
19615 }