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_set_memsize\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_get_memsize\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 156   fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
 157   fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
 158   fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
 159 }
 160
 161 static int test_mkswap_U_0_skip (void)
 162 {
 163   const char *str;
 164
 165   str = getenv ("TEST_ONLY");
 166   if (str)
 167     return strstr (str, "mkswap_U") == NULL;
 168   str = getenv ("SKIP_TEST_MKSWAP_U_0");
 169   if (str && strcmp (str, "1") == 0) return 1;
 170   str = getenv ("SKIP_TEST_MKSWAP_U");
 171   if (str && strcmp (str, "1") == 0) return 1;
 172   return 0;
 173 }
 174
 175 static int test_mkswap_U_0 (void)
 176 {
 177   if (test_mkswap_U_0_skip ()) {
 178     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
 179     return 0;
 180   }
 181
 182   /* InitNone|InitEmpty for test_mkswap_U_0 */
 183   {
 184     char device[] = "/dev/sda";
 185     int r;
 186     suppress_error = 0;
 187     r = guestfs_blockdev_setrw (g, device);
 188     if (r == -1)
 189       return -1;
 190   }
 191   {
 192     int r;
 193     suppress_error = 0;
 194     r = guestfs_umount_all (g);
 195     if (r == -1)
 196       return -1;
 197   }
 198   {
 199     int r;
 200     suppress_error = 0;
 201     r = guestfs_lvm_remove_all (g);
 202     if (r == -1)
 203       return -1;
 204   }
 205   /* TestRun for mkswap_U (0) */
 206   {
 207     char device[] = "/dev/sda";
 208     char lines_0[] = ",";
 209     char *lines[] = {
 210       lines_0,
 211       NULL
 212     };
 213     int r;
 214     suppress_error = 0;
 215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 216     if (r == -1)
 217       return -1;
 218   }
 219   {
 220     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
 221     char device[] = "/dev/sda1";
 222     int r;
 223     suppress_error = 0;
 224     r = guestfs_mkswap_U (g, uuid, device);
 225     if (r == -1)
 226       return -1;
 227   }
 228   return 0;
 229 }
 230
 231 static int test_mkswap_L_0_skip (void)
 232 {
 233   const char *str;
 234
 235   str = getenv ("TEST_ONLY");
 236   if (str)
 237     return strstr (str, "mkswap_L") == NULL;
 238   str = getenv ("SKIP_TEST_MKSWAP_L_0");
 239   if (str && strcmp (str, "1") == 0) return 1;
 240   str = getenv ("SKIP_TEST_MKSWAP_L");
 241   if (str && strcmp (str, "1") == 0) return 1;
 242   return 0;
 243 }
 244
 245 static int test_mkswap_L_0 (void)
 246 {
 247   if (test_mkswap_L_0_skip ()) {
 248     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
 249     return 0;
 250   }
 251
 252   /* InitNone|InitEmpty for test_mkswap_L_0 */
 253   {
 254     char device[] = "/dev/sda";
 255     int r;
 256     suppress_error = 0;
 257     r = guestfs_blockdev_setrw (g, device);
 258     if (r == -1)
 259       return -1;
 260   }
 261   {
 262     int r;
 263     suppress_error = 0;
 264     r = guestfs_umount_all (g);
 265     if (r == -1)
 266       return -1;
 267   }
 268   {
 269     int r;
 270     suppress_error = 0;
 271     r = guestfs_lvm_remove_all (g);
 272     if (r == -1)
 273       return -1;
 274   }
 275   /* TestRun for mkswap_L (0) */
 276   {
 277     char device[] = "/dev/sda";
 278     char lines_0[] = ",";
 279     char *lines[] = {
 280       lines_0,
 281       NULL
 282     };
 283     int r;
 284     suppress_error = 0;
 285     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 286     if (r == -1)
 287       return -1;
 288   }
 289   {
 290     char label[] = "hello";
 291     char device[] = "/dev/sda1";
 292     int r;
 293     suppress_error = 0;
 294     r = guestfs_mkswap_L (g, label, device);
 295     if (r == -1)
 296       return -1;
 297   }
 298   return 0;
 299 }
 300
 301 static int test_mkswap_0_skip (void)
 302 {
 303   const char *str;
 304
 305   str = getenv ("TEST_ONLY");
 306   if (str)
 307     return strstr (str, "mkswap") == NULL;
 308   str = getenv ("SKIP_TEST_MKSWAP_0");
 309   if (str && strcmp (str, "1") == 0) return 1;
 310   str = getenv ("SKIP_TEST_MKSWAP");
 311   if (str && strcmp (str, "1") == 0) return 1;
 312   return 0;
 313 }
 314
 315 static int test_mkswap_0 (void)
 316 {
 317   if (test_mkswap_0_skip ()) {
 318     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_0");
 319     return 0;
 320   }
 321
 322   /* InitNone|InitEmpty for test_mkswap_0 */
 323   {
 324     char device[] = "/dev/sda";
 325     int r;
 326     suppress_error = 0;
 327     r = guestfs_blockdev_setrw (g, device);
 328     if (r == -1)
 329       return -1;
 330   }
 331   {
 332     int r;
 333     suppress_error = 0;
 334     r = guestfs_umount_all (g);
 335     if (r == -1)
 336       return -1;
 337   }
 338   {
 339     int r;
 340     suppress_error = 0;
 341     r = guestfs_lvm_remove_all (g);
 342     if (r == -1)
 343       return -1;
 344   }
 345   /* TestRun for mkswap (0) */
 346   {
 347     char device[] = "/dev/sda";
 348     char lines_0[] = ",";
 349     char *lines[] = {
 350       lines_0,
 351       NULL
 352     };
 353     int r;
 354     suppress_error = 0;
 355     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 356     if (r == -1)
 357       return -1;
 358   }
 359   {
 360     char device[] = "/dev/sda1";
 361     int r;
 362     suppress_error = 0;
 363     r = guestfs_mkswap (g, device);
 364     if (r == -1)
 365       return -1;
 366   }
 367   return 0;
 368 }
 369
 370 static int test_initrd_list_0_skip (void)
 371 {
 372   const char *str;
 373
 374   str = getenv ("TEST_ONLY");
 375   if (str)
 376     return strstr (str, "initrd_list") == NULL;
 377   str = getenv ("SKIP_TEST_INITRD_LIST_0");
 378   if (str && strcmp (str, "1") == 0) return 1;
 379   str = getenv ("SKIP_TEST_INITRD_LIST");
 380   if (str && strcmp (str, "1") == 0) return 1;
 381   return 0;
 382 }
 383
 384 static int test_initrd_list_0 (void)
 385 {
 386   if (test_initrd_list_0_skip ()) {
 387     printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
 388     return 0;
 389   }
 390
 391   /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
 392   {
 393     char device[] = "/dev/sda";
 394     int r;
 395     suppress_error = 0;
 396     r = guestfs_blockdev_setrw (g, device);
 397     if (r == -1)
 398       return -1;
 399   }
 400   {
 401     int r;
 402     suppress_error = 0;
 403     r = guestfs_umount_all (g);
 404     if (r == -1)
 405       return -1;
 406   }
 407   {
 408     int r;
 409     suppress_error = 0;
 410     r = guestfs_lvm_remove_all (g);
 411     if (r == -1)
 412       return -1;
 413   }
 414   {
 415     char device[] = "/dev/sda";
 416     char lines_0[] = ",";
 417     char *lines[] = {
 418       lines_0,
 419       NULL
 420     };
 421     int r;
 422     suppress_error = 0;
 423     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 424     if (r == -1)
 425       return -1;
 426   }
 427   {
 428     char fstype[] = "ext2";
 429     char device[] = "/dev/sda1";
 430     int r;
 431     suppress_error = 0;
 432     r = guestfs_mkfs (g, fstype, device);
 433     if (r == -1)
 434       return -1;
 435   }
 436   {
 437     char device[] = "/dev/sda1";
 438     char mountpoint[] = "/";
 439     int r;
 440     suppress_error = 0;
 441     r = guestfs_mount (g, device, mountpoint);
 442     if (r == -1)
 443       return -1;
 444   }
 445   /* TestOutputList for initrd_list (0) */
 446   {
 447     char options[] = "ro";
 448     char vfstype[] = "squashfs";
 449     char device[] = "/dev/sdd";
 450     char mountpoint[] = "/";
 451     int r;
 452     suppress_error = 0;
 453     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 454     if (r == -1)
 455       return -1;
 456   }
 457   {
 458     char path[] = "/initrd";
 459     char **r;
 460     int i;
 461     suppress_error = 0;
 462     r = guestfs_initrd_list (g, path);
 463     if (r == NULL)
 464       return -1;
 465     if (!r[0]) {
 466       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 467       print_strings (r);
 468       return -1;
 469     }
 470     {
 471       char expected[] = "empty";
 472       if (strcmp (r[0], expected) != 0) {
 473         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 474         return -1;
 475       }
 476     }
 477     if (!r[1]) {
 478       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 479       print_strings (r);
 480       return -1;
 481     }
 482     {
 483       char expected[] = "known-1";
 484       if (strcmp (r[1], expected) != 0) {
 485         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 486         return -1;
 487       }
 488     }
 489     if (!r[2]) {
 490       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 491       print_strings (r);
 492       return -1;
 493     }
 494     {
 495       char expected[] = "known-2";
 496       if (strcmp (r[2], expected) != 0) {
 497         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 498         return -1;
 499       }
 500     }
 501     if (!r[3]) {
 502       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 503       print_strings (r);
 504       return -1;
 505     }
 506     {
 507       char expected[] = "known-3";
 508       if (strcmp (r[3], expected) != 0) {
 509         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 510         return -1;
 511       }
 512     }
 513     if (r[4] != NULL) {
 514       fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
 515       print_strings (r);
 516       return -1;
 517     }
 518     for (i = 0; r[i] != NULL; ++i)
 519       free (r[i]);
 520     free (r);
 521   }
 522   return 0;
 523 }
 524
 525 static int test_du_0_skip (void)
 526 {
 527   const char *str;
 528
 529   str = getenv ("TEST_ONLY");
 530   if (str)
 531     return strstr (str, "du") == NULL;
 532   str = getenv ("SKIP_TEST_DU_0");
 533   if (str && strcmp (str, "1") == 0) return 1;
 534   str = getenv ("SKIP_TEST_DU");
 535   if (str && strcmp (str, "1") == 0) return 1;
 536   return 0;
 537 }
 538
 539 static int test_du_0 (void)
 540 {
 541   if (test_du_0_skip ()) {
 542     printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
 543     return 0;
 544   }
 545
 546   /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
 547   {
 548     char device[] = "/dev/sda";
 549     int r;
 550     suppress_error = 0;
 551     r = guestfs_blockdev_setrw (g, device);
 552     if (r == -1)
 553       return -1;
 554   }
 555   {
 556     int r;
 557     suppress_error = 0;
 558     r = guestfs_umount_all (g);
 559     if (r == -1)
 560       return -1;
 561   }
 562   {
 563     int r;
 564     suppress_error = 0;
 565     r = guestfs_lvm_remove_all (g);
 566     if (r == -1)
 567       return -1;
 568   }
 569   {
 570     char device[] = "/dev/sda";
 571     char lines_0[] = ",";
 572     char *lines[] = {
 573       lines_0,
 574       NULL
 575     };
 576     int r;
 577     suppress_error = 0;
 578     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 579     if (r == -1)
 580       return -1;
 581   }
 582   {
 583     char fstype[] = "ext2";
 584     char device[] = "/dev/sda1";
 585     int r;
 586     suppress_error = 0;
 587     r = guestfs_mkfs (g, fstype, device);
 588     if (r == -1)
 589       return -1;
 590   }
 591   {
 592     char device[] = "/dev/sda1";
 593     char mountpoint[] = "/";
 594     int r;
 595     suppress_error = 0;
 596     r = guestfs_mount (g, device, mountpoint);
 597     if (r == -1)
 598       return -1;
 599   }
 600   /* TestOutputInt for du (0) */
 601   {
 602     char path[] = "/p";
 603     int r;
 604     suppress_error = 0;
 605     r = guestfs_mkdir (g, path);
 606     if (r == -1)
 607       return -1;
 608   }
 609   {
 610     char path[] = "/p";
 611     int64_t r;
 612     suppress_error = 0;
 613     r = guestfs_du (g, path);
 614     if (r == -1)
 615       return -1;
 616     if (r != 1) {
 617       fprintf (stderr, "test_du_0: expected 1 but got %d\n",               (int) r);
 618       return -1;
 619     }
 620   }
 621   return 0;
 622 }
 623
 624 static int test_tail_n_0_skip (void)
 625 {
 626   const char *str;
 627
 628   str = getenv ("TEST_ONLY");
 629   if (str)
 630     return strstr (str, "tail_n") == NULL;
 631   str = getenv ("SKIP_TEST_TAIL_N_0");
 632   if (str && strcmp (str, "1") == 0) return 1;
 633   str = getenv ("SKIP_TEST_TAIL_N");
 634   if (str && strcmp (str, "1") == 0) return 1;
 635   return 0;
 636 }
 637
 638 static int test_tail_n_0 (void)
 639 {
 640   if (test_tail_n_0_skip ()) {
 641     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
 642     return 0;
 643   }
 644
 645   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
 646   {
 647     char device[] = "/dev/sda";
 648     int r;
 649     suppress_error = 0;
 650     r = guestfs_blockdev_setrw (g, device);
 651     if (r == -1)
 652       return -1;
 653   }
 654   {
 655     int r;
 656     suppress_error = 0;
 657     r = guestfs_umount_all (g);
 658     if (r == -1)
 659       return -1;
 660   }
 661   {
 662     int r;
 663     suppress_error = 0;
 664     r = guestfs_lvm_remove_all (g);
 665     if (r == -1)
 666       return -1;
 667   }
 668   {
 669     char device[] = "/dev/sda";
 670     char lines_0[] = ",";
 671     char *lines[] = {
 672       lines_0,
 673       NULL
 674     };
 675     int r;
 676     suppress_error = 0;
 677     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 678     if (r == -1)
 679       return -1;
 680   }
 681   {
 682     char fstype[] = "ext2";
 683     char device[] = "/dev/sda1";
 684     int r;
 685     suppress_error = 0;
 686     r = guestfs_mkfs (g, fstype, device);
 687     if (r == -1)
 688       return -1;
 689   }
 690   {
 691     char device[] = "/dev/sda1";
 692     char mountpoint[] = "/";
 693     int r;
 694     suppress_error = 0;
 695     r = guestfs_mount (g, device, mountpoint);
 696     if (r == -1)
 697       return -1;
 698   }
 699   /* TestOutputList for tail_n (0) */
 700   {
 701     char options[] = "ro";
 702     char vfstype[] = "squashfs";
 703     char device[] = "/dev/sdd";
 704     char mountpoint[] = "/";
 705     int r;
 706     suppress_error = 0;
 707     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 708     if (r == -1)
 709       return -1;
 710   }
 711   {
 712     char path[] = "/10klines";
 713     char **r;
 714     int i;
 715     suppress_error = 0;
 716     r = guestfs_tail_n (g, 3, path);
 717     if (r == NULL)
 718       return -1;
 719     if (!r[0]) {
 720       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 721       print_strings (r);
 722       return -1;
 723     }
 724     {
 725       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 726       if (strcmp (r[0], expected) != 0) {
 727         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 728         return -1;
 729       }
 730     }
 731     if (!r[1]) {
 732       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 733       print_strings (r);
 734       return -1;
 735     }
 736     {
 737       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 738       if (strcmp (r[1], expected) != 0) {
 739         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 740         return -1;
 741       }
 742     }
 743     if (!r[2]) {
 744       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 745       print_strings (r);
 746       return -1;
 747     }
 748     {
 749       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 750       if (strcmp (r[2], expected) != 0) {
 751         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 752         return -1;
 753       }
 754     }
 755     if (r[3] != NULL) {
 756       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
 757       print_strings (r);
 758       return -1;
 759     }
 760     for (i = 0; r[i] != NULL; ++i)
 761       free (r[i]);
 762     free (r);
 763   }
 764   return 0;
 765 }
 766
 767 static int test_tail_n_1_skip (void)
 768 {
 769   const char *str;
 770
 771   str = getenv ("TEST_ONLY");
 772   if (str)
 773     return strstr (str, "tail_n") == NULL;
 774   str = getenv ("SKIP_TEST_TAIL_N_1");
 775   if (str && strcmp (str, "1") == 0) return 1;
 776   str = getenv ("SKIP_TEST_TAIL_N");
 777   if (str && strcmp (str, "1") == 0) return 1;
 778   return 0;
 779 }
 780
 781 static int test_tail_n_1 (void)
 782 {
 783   if (test_tail_n_1_skip ()) {
 784     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
 785     return 0;
 786   }
 787
 788   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
 789   {
 790     char device[] = "/dev/sda";
 791     int r;
 792     suppress_error = 0;
 793     r = guestfs_blockdev_setrw (g, device);
 794     if (r == -1)
 795       return -1;
 796   }
 797   {
 798     int r;
 799     suppress_error = 0;
 800     r = guestfs_umount_all (g);
 801     if (r == -1)
 802       return -1;
 803   }
 804   {
 805     int r;
 806     suppress_error = 0;
 807     r = guestfs_lvm_remove_all (g);
 808     if (r == -1)
 809       return -1;
 810   }
 811   {
 812     char device[] = "/dev/sda";
 813     char lines_0[] = ",";
 814     char *lines[] = {
 815       lines_0,
 816       NULL
 817     };
 818     int r;
 819     suppress_error = 0;
 820     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 821     if (r == -1)
 822       return -1;
 823   }
 824   {
 825     char fstype[] = "ext2";
 826     char device[] = "/dev/sda1";
 827     int r;
 828     suppress_error = 0;
 829     r = guestfs_mkfs (g, fstype, device);
 830     if (r == -1)
 831       return -1;
 832   }
 833   {
 834     char device[] = "/dev/sda1";
 835     char mountpoint[] = "/";
 836     int r;
 837     suppress_error = 0;
 838     r = guestfs_mount (g, device, mountpoint);
 839     if (r == -1)
 840       return -1;
 841   }
 842   /* TestOutputList for tail_n (1) */
 843   {
 844     char options[] = "ro";
 845     char vfstype[] = "squashfs";
 846     char device[] = "/dev/sdd";
 847     char mountpoint[] = "/";
 848     int r;
 849     suppress_error = 0;
 850     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 851     if (r == -1)
 852       return -1;
 853   }
 854   {
 855     char path[] = "/10klines";
 856     char **r;
 857     int i;
 858     suppress_error = 0;
 859     r = guestfs_tail_n (g, -9998, path);
 860     if (r == NULL)
 861       return -1;
 862     if (!r[0]) {
 863       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 864       print_strings (r);
 865       return -1;
 866     }
 867     {
 868       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 869       if (strcmp (r[0], expected) != 0) {
 870         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 871         return -1;
 872       }
 873     }
 874     if (!r[1]) {
 875       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 876       print_strings (r);
 877       return -1;
 878     }
 879     {
 880       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 881       if (strcmp (r[1], expected) != 0) {
 882         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 883         return -1;
 884       }
 885     }
 886     if (!r[2]) {
 887       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 888       print_strings (r);
 889       return -1;
 890     }
 891     {
 892       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 893       if (strcmp (r[2], expected) != 0) {
 894         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 895         return -1;
 896       }
 897     }
 898     if (r[3] != NULL) {
 899       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
 900       print_strings (r);
 901       return -1;
 902     }
 903     for (i = 0; r[i] != NULL; ++i)
 904       free (r[i]);
 905     free (r);
 906   }
 907   return 0;
 908 }
 909
 910 static int test_tail_n_2_skip (void)
 911 {
 912   const char *str;
 913
 914   str = getenv ("TEST_ONLY");
 915   if (str)
 916     return strstr (str, "tail_n") == NULL;
 917   str = getenv ("SKIP_TEST_TAIL_N_2");
 918   if (str && strcmp (str, "1") == 0) return 1;
 919   str = getenv ("SKIP_TEST_TAIL_N");
 920   if (str && strcmp (str, "1") == 0) return 1;
 921   return 0;
 922 }
 923
 924 static int test_tail_n_2 (void)
 925 {
 926   if (test_tail_n_2_skip ()) {
 927     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
 928     return 0;
 929   }
 930
 931   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
 932   {
 933     char device[] = "/dev/sda";
 934     int r;
 935     suppress_error = 0;
 936     r = guestfs_blockdev_setrw (g, device);
 937     if (r == -1)
 938       return -1;
 939   }
 940   {
 941     int r;
 942     suppress_error = 0;
 943     r = guestfs_umount_all (g);
 944     if (r == -1)
 945       return -1;
 946   }
 947   {
 948     int r;
 949     suppress_error = 0;
 950     r = guestfs_lvm_remove_all (g);
 951     if (r == -1)
 952       return -1;
 953   }
 954   {
 955     char device[] = "/dev/sda";
 956     char lines_0[] = ",";
 957     char *lines[] = {
 958       lines_0,
 959       NULL
 960     };
 961     int r;
 962     suppress_error = 0;
 963     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 964     if (r == -1)
 965       return -1;
 966   }
 967   {
 968     char fstype[] = "ext2";
 969     char device[] = "/dev/sda1";
 970     int r;
 971     suppress_error = 0;
 972     r = guestfs_mkfs (g, fstype, device);
 973     if (r == -1)
 974       return -1;
 975   }
 976   {
 977     char device[] = "/dev/sda1";
 978     char mountpoint[] = "/";
 979     int r;
 980     suppress_error = 0;
 981     r = guestfs_mount (g, device, mountpoint);
 982     if (r == -1)
 983       return -1;
 984   }
 985   /* TestOutputList for tail_n (2) */
 986   {
 987     char options[] = "ro";
 988     char vfstype[] = "squashfs";
 989     char device[] = "/dev/sdd";
 990     char mountpoint[] = "/";
 991     int r;
 992     suppress_error = 0;
 993     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 994     if (r == -1)
 995       return -1;
 996   }
 997   {
 998     char path[] = "/10klines";
 999     char **r;
1000     int i;
1001     suppress_error = 0;
1002     r = guestfs_tail_n (g, 0, path);
1003     if (r == NULL)
1004       return -1;
1005     if (r[0] != NULL) {
1006       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1007       print_strings (r);
1008       return -1;
1009     }
1010     for (i = 0; r[i] != NULL; ++i)
1011       free (r[i]);
1012     free (r);
1013   }
1014   return 0;
1015 }
1016
1017 static int test_tail_0_skip (void)
1018 {
1019   const char *str;
1020
1021   str = getenv ("TEST_ONLY");
1022   if (str)
1023     return strstr (str, "tail") == NULL;
1024   str = getenv ("SKIP_TEST_TAIL_0");
1025   if (str && strcmp (str, "1") == 0) return 1;
1026   str = getenv ("SKIP_TEST_TAIL");
1027   if (str && strcmp (str, "1") == 0) return 1;
1028   return 0;
1029 }
1030
1031 static int test_tail_0 (void)
1032 {
1033   if (test_tail_0_skip ()) {
1034     printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
1035     return 0;
1036   }
1037
1038   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1039   {
1040     char device[] = "/dev/sda";
1041     int r;
1042     suppress_error = 0;
1043     r = guestfs_blockdev_setrw (g, device);
1044     if (r == -1)
1045       return -1;
1046   }
1047   {
1048     int r;
1049     suppress_error = 0;
1050     r = guestfs_umount_all (g);
1051     if (r == -1)
1052       return -1;
1053   }
1054   {
1055     int r;
1056     suppress_error = 0;
1057     r = guestfs_lvm_remove_all (g);
1058     if (r == -1)
1059       return -1;
1060   }
1061   {
1062     char device[] = "/dev/sda";
1063     char lines_0[] = ",";
1064     char *lines[] = {
1065       lines_0,
1066       NULL
1067     };
1068     int r;
1069     suppress_error = 0;
1070     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1071     if (r == -1)
1072       return -1;
1073   }
1074   {
1075     char fstype[] = "ext2";
1076     char device[] = "/dev/sda1";
1077     int r;
1078     suppress_error = 0;
1079     r = guestfs_mkfs (g, fstype, device);
1080     if (r == -1)
1081       return -1;
1082   }
1083   {
1084     char device[] = "/dev/sda1";
1085     char mountpoint[] = "/";
1086     int r;
1087     suppress_error = 0;
1088     r = guestfs_mount (g, device, mountpoint);
1089     if (r == -1)
1090       return -1;
1091   }
1092   /* TestOutputList for tail (0) */
1093   {
1094     char options[] = "ro";
1095     char vfstype[] = "squashfs";
1096     char device[] = "/dev/sdd";
1097     char mountpoint[] = "/";
1098     int r;
1099     suppress_error = 0;
1100     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1101     if (r == -1)
1102       return -1;
1103   }
1104   {
1105     char path[] = "/10klines";
1106     char **r;
1107     int i;
1108     suppress_error = 0;
1109     r = guestfs_tail (g, path);
1110     if (r == NULL)
1111       return -1;
1112     if (!r[0]) {
1113       fprintf (stderr, "test_tail_0: short list returned from command\n");
1114       print_strings (r);
1115       return -1;
1116     }
1117     {
1118       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1119       if (strcmp (r[0], expected) != 0) {
1120         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1121         return -1;
1122       }
1123     }
1124     if (!r[1]) {
1125       fprintf (stderr, "test_tail_0: short list returned from command\n");
1126       print_strings (r);
1127       return -1;
1128     }
1129     {
1130       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1131       if (strcmp (r[1], expected) != 0) {
1132         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1133         return -1;
1134       }
1135     }
1136     if (!r[2]) {
1137       fprintf (stderr, "test_tail_0: short list returned from command\n");
1138       print_strings (r);
1139       return -1;
1140     }
1141     {
1142       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1143       if (strcmp (r[2], expected) != 0) {
1144         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1145         return -1;
1146       }
1147     }
1148     if (!r[3]) {
1149       fprintf (stderr, "test_tail_0: short list returned from command\n");
1150       print_strings (r);
1151       return -1;
1152     }
1153     {
1154       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1155       if (strcmp (r[3], expected) != 0) {
1156         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1157         return -1;
1158       }
1159     }
1160     if (!r[4]) {
1161       fprintf (stderr, "test_tail_0: short list returned from command\n");
1162       print_strings (r);
1163       return -1;
1164     }
1165     {
1166       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1167       if (strcmp (r[4], expected) != 0) {
1168         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1169         return -1;
1170       }
1171     }
1172     if (!r[5]) {
1173       fprintf (stderr, "test_tail_0: short list returned from command\n");
1174       print_strings (r);
1175       return -1;
1176     }
1177     {
1178       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1179       if (strcmp (r[5], expected) != 0) {
1180         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1181         return -1;
1182       }
1183     }
1184     if (!r[6]) {
1185       fprintf (stderr, "test_tail_0: short list returned from command\n");
1186       print_strings (r);
1187       return -1;
1188     }
1189     {
1190       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1191       if (strcmp (r[6], expected) != 0) {
1192         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1193         return -1;
1194       }
1195     }
1196     if (!r[7]) {
1197       fprintf (stderr, "test_tail_0: short list returned from command\n");
1198       print_strings (r);
1199       return -1;
1200     }
1201     {
1202       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1203       if (strcmp (r[7], expected) != 0) {
1204         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1205         return -1;
1206       }
1207     }
1208     if (!r[8]) {
1209       fprintf (stderr, "test_tail_0: short list returned from command\n");
1210       print_strings (r);
1211       return -1;
1212     }
1213     {
1214       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1215       if (strcmp (r[8], expected) != 0) {
1216         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1217         return -1;
1218       }
1219     }
1220     if (!r[9]) {
1221       fprintf (stderr, "test_tail_0: short list returned from command\n");
1222       print_strings (r);
1223       return -1;
1224     }
1225     {
1226       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1227       if (strcmp (r[9], expected) != 0) {
1228         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1229         return -1;
1230       }
1231     }
1232     if (r[10] != NULL) {
1233       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1234       print_strings (r);
1235       return -1;
1236     }
1237     for (i = 0; r[i] != NULL; ++i)
1238       free (r[i]);
1239     free (r);
1240   }
1241   return 0;
1242 }
1243
1244 static int test_head_n_0_skip (void)
1245 {
1246   const char *str;
1247
1248   str = getenv ("TEST_ONLY");
1249   if (str)
1250     return strstr (str, "head_n") == NULL;
1251   str = getenv ("SKIP_TEST_HEAD_N_0");
1252   if (str && strcmp (str, "1") == 0) return 1;
1253   str = getenv ("SKIP_TEST_HEAD_N");
1254   if (str && strcmp (str, "1") == 0) return 1;
1255   return 0;
1256 }
1257
1258 static int test_head_n_0 (void)
1259 {
1260   if (test_head_n_0_skip ()) {
1261     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1262     return 0;
1263   }
1264
1265   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1266   {
1267     char device[] = "/dev/sda";
1268     int r;
1269     suppress_error = 0;
1270     r = guestfs_blockdev_setrw (g, device);
1271     if (r == -1)
1272       return -1;
1273   }
1274   {
1275     int r;
1276     suppress_error = 0;
1277     r = guestfs_umount_all (g);
1278     if (r == -1)
1279       return -1;
1280   }
1281   {
1282     int r;
1283     suppress_error = 0;
1284     r = guestfs_lvm_remove_all (g);
1285     if (r == -1)
1286       return -1;
1287   }
1288   {
1289     char device[] = "/dev/sda";
1290     char lines_0[] = ",";
1291     char *lines[] = {
1292       lines_0,
1293       NULL
1294     };
1295     int r;
1296     suppress_error = 0;
1297     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1298     if (r == -1)
1299       return -1;
1300   }
1301   {
1302     char fstype[] = "ext2";
1303     char device[] = "/dev/sda1";
1304     int r;
1305     suppress_error = 0;
1306     r = guestfs_mkfs (g, fstype, device);
1307     if (r == -1)
1308       return -1;
1309   }
1310   {
1311     char device[] = "/dev/sda1";
1312     char mountpoint[] = "/";
1313     int r;
1314     suppress_error = 0;
1315     r = guestfs_mount (g, device, mountpoint);
1316     if (r == -1)
1317       return -1;
1318   }
1319   /* TestOutputList for head_n (0) */
1320   {
1321     char options[] = "ro";
1322     char vfstype[] = "squashfs";
1323     char device[] = "/dev/sdd";
1324     char mountpoint[] = "/";
1325     int r;
1326     suppress_error = 0;
1327     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1328     if (r == -1)
1329       return -1;
1330   }
1331   {
1332     char path[] = "/10klines";
1333     char **r;
1334     int i;
1335     suppress_error = 0;
1336     r = guestfs_head_n (g, 3, path);
1337     if (r == NULL)
1338       return -1;
1339     if (!r[0]) {
1340       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1341       print_strings (r);
1342       return -1;
1343     }
1344     {
1345       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1346       if (strcmp (r[0], expected) != 0) {
1347         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1348         return -1;
1349       }
1350     }
1351     if (!r[1]) {
1352       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1353       print_strings (r);
1354       return -1;
1355     }
1356     {
1357       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1358       if (strcmp (r[1], expected) != 0) {
1359         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1360         return -1;
1361       }
1362     }
1363     if (!r[2]) {
1364       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1365       print_strings (r);
1366       return -1;
1367     }
1368     {
1369       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1370       if (strcmp (r[2], expected) != 0) {
1371         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1372         return -1;
1373       }
1374     }
1375     if (r[3] != NULL) {
1376       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1377       print_strings (r);
1378       return -1;
1379     }
1380     for (i = 0; r[i] != NULL; ++i)
1381       free (r[i]);
1382     free (r);
1383   }
1384   return 0;
1385 }
1386
1387 static int test_head_n_1_skip (void)
1388 {
1389   const char *str;
1390
1391   str = getenv ("TEST_ONLY");
1392   if (str)
1393     return strstr (str, "head_n") == NULL;
1394   str = getenv ("SKIP_TEST_HEAD_N_1");
1395   if (str && strcmp (str, "1") == 0) return 1;
1396   str = getenv ("SKIP_TEST_HEAD_N");
1397   if (str && strcmp (str, "1") == 0) return 1;
1398   return 0;
1399 }
1400
1401 static int test_head_n_1 (void)
1402 {
1403   if (test_head_n_1_skip ()) {
1404     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1405     return 0;
1406   }
1407
1408   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1409   {
1410     char device[] = "/dev/sda";
1411     int r;
1412     suppress_error = 0;
1413     r = guestfs_blockdev_setrw (g, device);
1414     if (r == -1)
1415       return -1;
1416   }
1417   {
1418     int r;
1419     suppress_error = 0;
1420     r = guestfs_umount_all (g);
1421     if (r == -1)
1422       return -1;
1423   }
1424   {
1425     int r;
1426     suppress_error = 0;
1427     r = guestfs_lvm_remove_all (g);
1428     if (r == -1)
1429       return -1;
1430   }
1431   {
1432     char device[] = "/dev/sda";
1433     char lines_0[] = ",";
1434     char *lines[] = {
1435       lines_0,
1436       NULL
1437     };
1438     int r;
1439     suppress_error = 0;
1440     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1441     if (r == -1)
1442       return -1;
1443   }
1444   {
1445     char fstype[] = "ext2";
1446     char device[] = "/dev/sda1";
1447     int r;
1448     suppress_error = 0;
1449     r = guestfs_mkfs (g, fstype, device);
1450     if (r == -1)
1451       return -1;
1452   }
1453   {
1454     char device[] = "/dev/sda1";
1455     char mountpoint[] = "/";
1456     int r;
1457     suppress_error = 0;
1458     r = guestfs_mount (g, device, mountpoint);
1459     if (r == -1)
1460       return -1;
1461   }
1462   /* TestOutputList for head_n (1) */
1463   {
1464     char options[] = "ro";
1465     char vfstype[] = "squashfs";
1466     char device[] = "/dev/sdd";
1467     char mountpoint[] = "/";
1468     int r;
1469     suppress_error = 0;
1470     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1471     if (r == -1)
1472       return -1;
1473   }
1474   {
1475     char path[] = "/10klines";
1476     char **r;
1477     int i;
1478     suppress_error = 0;
1479     r = guestfs_head_n (g, -9997, path);
1480     if (r == NULL)
1481       return -1;
1482     if (!r[0]) {
1483       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1484       print_strings (r);
1485       return -1;
1486     }
1487     {
1488       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1489       if (strcmp (r[0], expected) != 0) {
1490         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1491         return -1;
1492       }
1493     }
1494     if (!r[1]) {
1495       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1496       print_strings (r);
1497       return -1;
1498     }
1499     {
1500       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1501       if (strcmp (r[1], expected) != 0) {
1502         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1503         return -1;
1504       }
1505     }
1506     if (!r[2]) {
1507       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1508       print_strings (r);
1509       return -1;
1510     }
1511     {
1512       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1513       if (strcmp (r[2], expected) != 0) {
1514         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1515         return -1;
1516       }
1517     }
1518     if (r[3] != NULL) {
1519       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1520       print_strings (r);
1521       return -1;
1522     }
1523     for (i = 0; r[i] != NULL; ++i)
1524       free (r[i]);
1525     free (r);
1526   }
1527   return 0;
1528 }
1529
1530 static int test_head_n_2_skip (void)
1531 {
1532   const char *str;
1533
1534   str = getenv ("TEST_ONLY");
1535   if (str)
1536     return strstr (str, "head_n") == NULL;
1537   str = getenv ("SKIP_TEST_HEAD_N_2");
1538   if (str && strcmp (str, "1") == 0) return 1;
1539   str = getenv ("SKIP_TEST_HEAD_N");
1540   if (str && strcmp (str, "1") == 0) return 1;
1541   return 0;
1542 }
1543
1544 static int test_head_n_2 (void)
1545 {
1546   if (test_head_n_2_skip ()) {
1547     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1548     return 0;
1549   }
1550
1551   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1552   {
1553     char device[] = "/dev/sda";
1554     int r;
1555     suppress_error = 0;
1556     r = guestfs_blockdev_setrw (g, device);
1557     if (r == -1)
1558       return -1;
1559   }
1560   {
1561     int r;
1562     suppress_error = 0;
1563     r = guestfs_umount_all (g);
1564     if (r == -1)
1565       return -1;
1566   }
1567   {
1568     int r;
1569     suppress_error = 0;
1570     r = guestfs_lvm_remove_all (g);
1571     if (r == -1)
1572       return -1;
1573   }
1574   {
1575     char device[] = "/dev/sda";
1576     char lines_0[] = ",";
1577     char *lines[] = {
1578       lines_0,
1579       NULL
1580     };
1581     int r;
1582     suppress_error = 0;
1583     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1584     if (r == -1)
1585       return -1;
1586   }
1587   {
1588     char fstype[] = "ext2";
1589     char device[] = "/dev/sda1";
1590     int r;
1591     suppress_error = 0;
1592     r = guestfs_mkfs (g, fstype, device);
1593     if (r == -1)
1594       return -1;
1595   }
1596   {
1597     char device[] = "/dev/sda1";
1598     char mountpoint[] = "/";
1599     int r;
1600     suppress_error = 0;
1601     r = guestfs_mount (g, device, mountpoint);
1602     if (r == -1)
1603       return -1;
1604   }
1605   /* TestOutputList for head_n (2) */
1606   {
1607     char options[] = "ro";
1608     char vfstype[] = "squashfs";
1609     char device[] = "/dev/sdd";
1610     char mountpoint[] = "/";
1611     int r;
1612     suppress_error = 0;
1613     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1614     if (r == -1)
1615       return -1;
1616   }
1617   {
1618     char path[] = "/10klines";
1619     char **r;
1620     int i;
1621     suppress_error = 0;
1622     r = guestfs_head_n (g, 0, path);
1623     if (r == NULL)
1624       return -1;
1625     if (r[0] != NULL) {
1626       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1627       print_strings (r);
1628       return -1;
1629     }
1630     for (i = 0; r[i] != NULL; ++i)
1631       free (r[i]);
1632     free (r);
1633   }
1634   return 0;
1635 }
1636
1637 static int test_head_0_skip (void)
1638 {
1639   const char *str;
1640
1641   str = getenv ("TEST_ONLY");
1642   if (str)
1643     return strstr (str, "head") == NULL;
1644   str = getenv ("SKIP_TEST_HEAD_0");
1645   if (str && strcmp (str, "1") == 0) return 1;
1646   str = getenv ("SKIP_TEST_HEAD");
1647   if (str && strcmp (str, "1") == 0) return 1;
1648   return 0;
1649 }
1650
1651 static int test_head_0 (void)
1652 {
1653   if (test_head_0_skip ()) {
1654     printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1655     return 0;
1656   }
1657
1658   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1659   {
1660     char device[] = "/dev/sda";
1661     int r;
1662     suppress_error = 0;
1663     r = guestfs_blockdev_setrw (g, device);
1664     if (r == -1)
1665       return -1;
1666   }
1667   {
1668     int r;
1669     suppress_error = 0;
1670     r = guestfs_umount_all (g);
1671     if (r == -1)
1672       return -1;
1673   }
1674   {
1675     int r;
1676     suppress_error = 0;
1677     r = guestfs_lvm_remove_all (g);
1678     if (r == -1)
1679       return -1;
1680   }
1681   {
1682     char device[] = "/dev/sda";
1683     char lines_0[] = ",";
1684     char *lines[] = {
1685       lines_0,
1686       NULL
1687     };
1688     int r;
1689     suppress_error = 0;
1690     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1691     if (r == -1)
1692       return -1;
1693   }
1694   {
1695     char fstype[] = "ext2";
1696     char device[] = "/dev/sda1";
1697     int r;
1698     suppress_error = 0;
1699     r = guestfs_mkfs (g, fstype, device);
1700     if (r == -1)
1701       return -1;
1702   }
1703   {
1704     char device[] = "/dev/sda1";
1705     char mountpoint[] = "/";
1706     int r;
1707     suppress_error = 0;
1708     r = guestfs_mount (g, device, mountpoint);
1709     if (r == -1)
1710       return -1;
1711   }
1712   /* TestOutputList for head (0) */
1713   {
1714     char options[] = "ro";
1715     char vfstype[] = "squashfs";
1716     char device[] = "/dev/sdd";
1717     char mountpoint[] = "/";
1718     int r;
1719     suppress_error = 0;
1720     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1721     if (r == -1)
1722       return -1;
1723   }
1724   {
1725     char path[] = "/10klines";
1726     char **r;
1727     int i;
1728     suppress_error = 0;
1729     r = guestfs_head (g, path);
1730     if (r == NULL)
1731       return -1;
1732     if (!r[0]) {
1733       fprintf (stderr, "test_head_0: short list returned from command\n");
1734       print_strings (r);
1735       return -1;
1736     }
1737     {
1738       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1739       if (strcmp (r[0], expected) != 0) {
1740         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1741         return -1;
1742       }
1743     }
1744     if (!r[1]) {
1745       fprintf (stderr, "test_head_0: short list returned from command\n");
1746       print_strings (r);
1747       return -1;
1748     }
1749     {
1750       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1751       if (strcmp (r[1], expected) != 0) {
1752         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1753         return -1;
1754       }
1755     }
1756     if (!r[2]) {
1757       fprintf (stderr, "test_head_0: short list returned from command\n");
1758       print_strings (r);
1759       return -1;
1760     }
1761     {
1762       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1763       if (strcmp (r[2], expected) != 0) {
1764         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1765         return -1;
1766       }
1767     }
1768     if (!r[3]) {
1769       fprintf (stderr, "test_head_0: short list returned from command\n");
1770       print_strings (r);
1771       return -1;
1772     }
1773     {
1774       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1775       if (strcmp (r[3], expected) != 0) {
1776         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1777         return -1;
1778       }
1779     }
1780     if (!r[4]) {
1781       fprintf (stderr, "test_head_0: short list returned from command\n");
1782       print_strings (r);
1783       return -1;
1784     }
1785     {
1786       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1787       if (strcmp (r[4], expected) != 0) {
1788         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1789         return -1;
1790       }
1791     }
1792     if (!r[5]) {
1793       fprintf (stderr, "test_head_0: short list returned from command\n");
1794       print_strings (r);
1795       return -1;
1796     }
1797     {
1798       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1799       if (strcmp (r[5], expected) != 0) {
1800         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1801         return -1;
1802       }
1803     }
1804     if (!r[6]) {
1805       fprintf (stderr, "test_head_0: short list returned from command\n");
1806       print_strings (r);
1807       return -1;
1808     }
1809     {
1810       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1811       if (strcmp (r[6], expected) != 0) {
1812         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1813         return -1;
1814       }
1815     }
1816     if (!r[7]) {
1817       fprintf (stderr, "test_head_0: short list returned from command\n");
1818       print_strings (r);
1819       return -1;
1820     }
1821     {
1822       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1823       if (strcmp (r[7], expected) != 0) {
1824         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1825         return -1;
1826       }
1827     }
1828     if (!r[8]) {
1829       fprintf (stderr, "test_head_0: short list returned from command\n");
1830       print_strings (r);
1831       return -1;
1832     }
1833     {
1834       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1835       if (strcmp (r[8], expected) != 0) {
1836         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1837         return -1;
1838       }
1839     }
1840     if (!r[9]) {
1841       fprintf (stderr, "test_head_0: short list returned from command\n");
1842       print_strings (r);
1843       return -1;
1844     }
1845     {
1846       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1847       if (strcmp (r[9], expected) != 0) {
1848         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1849         return -1;
1850       }
1851     }
1852     if (r[10] != NULL) {
1853       fprintf (stderr, "test_head_0: extra elements returned from command\n");
1854       print_strings (r);
1855       return -1;
1856     }
1857     for (i = 0; r[i] != NULL; ++i)
1858       free (r[i]);
1859     free (r);
1860   }
1861   return 0;
1862 }
1863
1864 static int test_wc_c_0_skip (void)
1865 {
1866   const char *str;
1867
1868   str = getenv ("TEST_ONLY");
1869   if (str)
1870     return strstr (str, "wc_c") == NULL;
1871   str = getenv ("SKIP_TEST_WC_C_0");
1872   if (str && strcmp (str, "1") == 0) return 1;
1873   str = getenv ("SKIP_TEST_WC_C");
1874   if (str && strcmp (str, "1") == 0) return 1;
1875   return 0;
1876 }
1877
1878 static int test_wc_c_0 (void)
1879 {
1880   if (test_wc_c_0_skip ()) {
1881     printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1882     return 0;
1883   }
1884
1885   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1886   {
1887     char device[] = "/dev/sda";
1888     int r;
1889     suppress_error = 0;
1890     r = guestfs_blockdev_setrw (g, device);
1891     if (r == -1)
1892       return -1;
1893   }
1894   {
1895     int r;
1896     suppress_error = 0;
1897     r = guestfs_umount_all (g);
1898     if (r == -1)
1899       return -1;
1900   }
1901   {
1902     int r;
1903     suppress_error = 0;
1904     r = guestfs_lvm_remove_all (g);
1905     if (r == -1)
1906       return -1;
1907   }
1908   {
1909     char device[] = "/dev/sda";
1910     char lines_0[] = ",";
1911     char *lines[] = {
1912       lines_0,
1913       NULL
1914     };
1915     int r;
1916     suppress_error = 0;
1917     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1918     if (r == -1)
1919       return -1;
1920   }
1921   {
1922     char fstype[] = "ext2";
1923     char device[] = "/dev/sda1";
1924     int r;
1925     suppress_error = 0;
1926     r = guestfs_mkfs (g, fstype, device);
1927     if (r == -1)
1928       return -1;
1929   }
1930   {
1931     char device[] = "/dev/sda1";
1932     char mountpoint[] = "/";
1933     int r;
1934     suppress_error = 0;
1935     r = guestfs_mount (g, device, mountpoint);
1936     if (r == -1)
1937       return -1;
1938   }
1939   /* TestOutputInt for wc_c (0) */
1940   {
1941     char options[] = "ro";
1942     char vfstype[] = "squashfs";
1943     char device[] = "/dev/sdd";
1944     char mountpoint[] = "/";
1945     int r;
1946     suppress_error = 0;
1947     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1948     if (r == -1)
1949       return -1;
1950   }
1951   {
1952     char path[] = "/100kallspaces";
1953     int r;
1954     suppress_error = 0;
1955     r = guestfs_wc_c (g, path);
1956     if (r == -1)
1957       return -1;
1958     if (r != 102400) {
1959       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
1960       return -1;
1961     }
1962   }
1963   return 0;
1964 }
1965
1966 static int test_wc_w_0_skip (void)
1967 {
1968   const char *str;
1969
1970   str = getenv ("TEST_ONLY");
1971   if (str)
1972     return strstr (str, "wc_w") == NULL;
1973   str = getenv ("SKIP_TEST_WC_W_0");
1974   if (str && strcmp (str, "1") == 0) return 1;
1975   str = getenv ("SKIP_TEST_WC_W");
1976   if (str && strcmp (str, "1") == 0) return 1;
1977   return 0;
1978 }
1979
1980 static int test_wc_w_0 (void)
1981 {
1982   if (test_wc_w_0_skip ()) {
1983     printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1984     return 0;
1985   }
1986
1987   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1988   {
1989     char device[] = "/dev/sda";
1990     int r;
1991     suppress_error = 0;
1992     r = guestfs_blockdev_setrw (g, device);
1993     if (r == -1)
1994       return -1;
1995   }
1996   {
1997     int r;
1998     suppress_error = 0;
1999     r = guestfs_umount_all (g);
2000     if (r == -1)
2001       return -1;
2002   }
2003   {
2004     int r;
2005     suppress_error = 0;
2006     r = guestfs_lvm_remove_all (g);
2007     if (r == -1)
2008       return -1;
2009   }
2010   {
2011     char device[] = "/dev/sda";
2012     char lines_0[] = ",";
2013     char *lines[] = {
2014       lines_0,
2015       NULL
2016     };
2017     int r;
2018     suppress_error = 0;
2019     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2020     if (r == -1)
2021       return -1;
2022   }
2023   {
2024     char fstype[] = "ext2";
2025     char device[] = "/dev/sda1";
2026     int r;
2027     suppress_error = 0;
2028     r = guestfs_mkfs (g, fstype, device);
2029     if (r == -1)
2030       return -1;
2031   }
2032   {
2033     char device[] = "/dev/sda1";
2034     char mountpoint[] = "/";
2035     int r;
2036     suppress_error = 0;
2037     r = guestfs_mount (g, device, mountpoint);
2038     if (r == -1)
2039       return -1;
2040   }
2041   /* TestOutputInt for wc_w (0) */
2042   {
2043     char options[] = "ro";
2044     char vfstype[] = "squashfs";
2045     char device[] = "/dev/sdd";
2046     char mountpoint[] = "/";
2047     int r;
2048     suppress_error = 0;
2049     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2050     if (r == -1)
2051       return -1;
2052   }
2053   {
2054     char path[] = "/10klines";
2055     int r;
2056     suppress_error = 0;
2057     r = guestfs_wc_w (g, path);
2058     if (r == -1)
2059       return -1;
2060     if (r != 10000) {
2061       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
2062       return -1;
2063     }
2064   }
2065   return 0;
2066 }
2067
2068 static int test_wc_l_0_skip (void)
2069 {
2070   const char *str;
2071
2072   str = getenv ("TEST_ONLY");
2073   if (str)
2074     return strstr (str, "wc_l") == NULL;
2075   str = getenv ("SKIP_TEST_WC_L_0");
2076   if (str && strcmp (str, "1") == 0) return 1;
2077   str = getenv ("SKIP_TEST_WC_L");
2078   if (str && strcmp (str, "1") == 0) return 1;
2079   return 0;
2080 }
2081
2082 static int test_wc_l_0 (void)
2083 {
2084   if (test_wc_l_0_skip ()) {
2085     printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
2086     return 0;
2087   }
2088
2089   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2090   {
2091     char device[] = "/dev/sda";
2092     int r;
2093     suppress_error = 0;
2094     r = guestfs_blockdev_setrw (g, device);
2095     if (r == -1)
2096       return -1;
2097   }
2098   {
2099     int r;
2100     suppress_error = 0;
2101     r = guestfs_umount_all (g);
2102     if (r == -1)
2103       return -1;
2104   }
2105   {
2106     int r;
2107     suppress_error = 0;
2108     r = guestfs_lvm_remove_all (g);
2109     if (r == -1)
2110       return -1;
2111   }
2112   {
2113     char device[] = "/dev/sda";
2114     char lines_0[] = ",";
2115     char *lines[] = {
2116       lines_0,
2117       NULL
2118     };
2119     int r;
2120     suppress_error = 0;
2121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2122     if (r == -1)
2123       return -1;
2124   }
2125   {
2126     char fstype[] = "ext2";
2127     char device[] = "/dev/sda1";
2128     int r;
2129     suppress_error = 0;
2130     r = guestfs_mkfs (g, fstype, device);
2131     if (r == -1)
2132       return -1;
2133   }
2134   {
2135     char device[] = "/dev/sda1";
2136     char mountpoint[] = "/";
2137     int r;
2138     suppress_error = 0;
2139     r = guestfs_mount (g, device, mountpoint);
2140     if (r == -1)
2141       return -1;
2142   }
2143   /* TestOutputInt for wc_l (0) */
2144   {
2145     char options[] = "ro";
2146     char vfstype[] = "squashfs";
2147     char device[] = "/dev/sdd";
2148     char mountpoint[] = "/";
2149     int r;
2150     suppress_error = 0;
2151     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2152     if (r == -1)
2153       return -1;
2154   }
2155   {
2156     char path[] = "/10klines";
2157     int r;
2158     suppress_error = 0;
2159     r = guestfs_wc_l (g, path);
2160     if (r == -1)
2161       return -1;
2162     if (r != 10000) {
2163       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
2164       return -1;
2165     }
2166   }
2167   return 0;
2168 }
2169
2170 static int test_mkdtemp_0_skip (void)
2171 {
2172   const char *str;
2173
2174   str = getenv ("TEST_ONLY");
2175   if (str)
2176     return strstr (str, "mkdtemp") == NULL;
2177   str = getenv ("SKIP_TEST_MKDTEMP_0");
2178   if (str && strcmp (str, "1") == 0) return 1;
2179   str = getenv ("SKIP_TEST_MKDTEMP");
2180   if (str && strcmp (str, "1") == 0) return 1;
2181   return 0;
2182 }
2183
2184 static int test_mkdtemp_0 (void)
2185 {
2186   if (test_mkdtemp_0_skip ()) {
2187     printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2188     return 0;
2189   }
2190
2191   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2192   {
2193     char device[] = "/dev/sda";
2194     int r;
2195     suppress_error = 0;
2196     r = guestfs_blockdev_setrw (g, device);
2197     if (r == -1)
2198       return -1;
2199   }
2200   {
2201     int r;
2202     suppress_error = 0;
2203     r = guestfs_umount_all (g);
2204     if (r == -1)
2205       return -1;
2206   }
2207   {
2208     int r;
2209     suppress_error = 0;
2210     r = guestfs_lvm_remove_all (g);
2211     if (r == -1)
2212       return -1;
2213   }
2214   {
2215     char device[] = "/dev/sda";
2216     char lines_0[] = ",";
2217     char *lines[] = {
2218       lines_0,
2219       NULL
2220     };
2221     int r;
2222     suppress_error = 0;
2223     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2224     if (r == -1)
2225       return -1;
2226   }
2227   {
2228     char fstype[] = "ext2";
2229     char device[] = "/dev/sda1";
2230     int r;
2231     suppress_error = 0;
2232     r = guestfs_mkfs (g, fstype, device);
2233     if (r == -1)
2234       return -1;
2235   }
2236   {
2237     char device[] = "/dev/sda1";
2238     char mountpoint[] = "/";
2239     int r;
2240     suppress_error = 0;
2241     r = guestfs_mount (g, device, mountpoint);
2242     if (r == -1)
2243       return -1;
2244   }
2245   /* TestRun for mkdtemp (0) */
2246   {
2247     char path[] = "/tmp";
2248     int r;
2249     suppress_error = 0;
2250     r = guestfs_mkdir (g, path);
2251     if (r == -1)
2252       return -1;
2253   }
2254   {
2255     char template[] = "/tmp/tmpXXXXXX";
2256     char *r;
2257     suppress_error = 0;
2258     r = guestfs_mkdtemp (g, template);
2259     if (r == NULL)
2260       return -1;
2261     free (r);
2262   }
2263   return 0;
2264 }
2265
2266 static int test_scrub_file_0_skip (void)
2267 {
2268   const char *str;
2269
2270   str = getenv ("TEST_ONLY");
2271   if (str)
2272     return strstr (str, "scrub_file") == NULL;
2273   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2274   if (str && strcmp (str, "1") == 0) return 1;
2275   str = getenv ("SKIP_TEST_SCRUB_FILE");
2276   if (str && strcmp (str, "1") == 0) return 1;
2277   return 0;
2278 }
2279
2280 static int test_scrub_file_0 (void)
2281 {
2282   if (test_scrub_file_0_skip ()) {
2283     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2284     return 0;
2285   }
2286
2287   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2288   {
2289     char device[] = "/dev/sda";
2290     int r;
2291     suppress_error = 0;
2292     r = guestfs_blockdev_setrw (g, device);
2293     if (r == -1)
2294       return -1;
2295   }
2296   {
2297     int r;
2298     suppress_error = 0;
2299     r = guestfs_umount_all (g);
2300     if (r == -1)
2301       return -1;
2302   }
2303   {
2304     int r;
2305     suppress_error = 0;
2306     r = guestfs_lvm_remove_all (g);
2307     if (r == -1)
2308       return -1;
2309   }
2310   {
2311     char device[] = "/dev/sda";
2312     char lines_0[] = ",";
2313     char *lines[] = {
2314       lines_0,
2315       NULL
2316     };
2317     int r;
2318     suppress_error = 0;
2319     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2320     if (r == -1)
2321       return -1;
2322   }
2323   {
2324     char fstype[] = "ext2";
2325     char device[] = "/dev/sda1";
2326     int r;
2327     suppress_error = 0;
2328     r = guestfs_mkfs (g, fstype, device);
2329     if (r == -1)
2330       return -1;
2331   }
2332   {
2333     char device[] = "/dev/sda1";
2334     char mountpoint[] = "/";
2335     int r;
2336     suppress_error = 0;
2337     r = guestfs_mount (g, device, mountpoint);
2338     if (r == -1)
2339       return -1;
2340   }
2341   /* TestRun for scrub_file (0) */
2342   {
2343     char path[] = "/file";
2344     char content[] = "content";
2345     int r;
2346     suppress_error = 0;
2347     r = guestfs_write_file (g, path, content, 0);
2348     if (r == -1)
2349       return -1;
2350   }
2351   {
2352     char file[] = "/file";
2353     int r;
2354     suppress_error = 0;
2355     r = guestfs_scrub_file (g, file);
2356     if (r == -1)
2357       return -1;
2358   }
2359   return 0;
2360 }
2361
2362 static int test_scrub_device_0_skip (void)
2363 {
2364   const char *str;
2365
2366   str = getenv ("TEST_ONLY");
2367   if (str)
2368     return strstr (str, "scrub_device") == NULL;
2369   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2370   if (str && strcmp (str, "1") == 0) return 1;
2371   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2372   if (str && strcmp (str, "1") == 0) return 1;
2373   return 0;
2374 }
2375
2376 static int test_scrub_device_0 (void)
2377 {
2378   if (test_scrub_device_0_skip ()) {
2379     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2380     return 0;
2381   }
2382
2383   /* InitNone|InitEmpty for test_scrub_device_0 */
2384   {
2385     char device[] = "/dev/sda";
2386     int r;
2387     suppress_error = 0;
2388     r = guestfs_blockdev_setrw (g, device);
2389     if (r == -1)
2390       return -1;
2391   }
2392   {
2393     int r;
2394     suppress_error = 0;
2395     r = guestfs_umount_all (g);
2396     if (r == -1)
2397       return -1;
2398   }
2399   {
2400     int r;
2401     suppress_error = 0;
2402     r = guestfs_lvm_remove_all (g);
2403     if (r == -1)
2404       return -1;
2405   }
2406   /* TestRun for scrub_device (0) */
2407   {
2408     char device[] = "/dev/sdc";
2409     int r;
2410     suppress_error = 0;
2411     r = guestfs_scrub_device (g, device);
2412     if (r == -1)
2413       return -1;
2414   }
2415   return 0;
2416 }
2417
2418 static int test_glob_expand_0_skip (void)
2419 {
2420   const char *str;
2421
2422   str = getenv ("TEST_ONLY");
2423   if (str)
2424     return strstr (str, "glob_expand") == NULL;
2425   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2426   if (str && strcmp (str, "1") == 0) return 1;
2427   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2428   if (str && strcmp (str, "1") == 0) return 1;
2429   return 0;
2430 }
2431
2432 static int test_glob_expand_0 (void)
2433 {
2434   if (test_glob_expand_0_skip ()) {
2435     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2436     return 0;
2437   }
2438
2439   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2440   {
2441     char device[] = "/dev/sda";
2442     int r;
2443     suppress_error = 0;
2444     r = guestfs_blockdev_setrw (g, device);
2445     if (r == -1)
2446       return -1;
2447   }
2448   {
2449     int r;
2450     suppress_error = 0;
2451     r = guestfs_umount_all (g);
2452     if (r == -1)
2453       return -1;
2454   }
2455   {
2456     int r;
2457     suppress_error = 0;
2458     r = guestfs_lvm_remove_all (g);
2459     if (r == -1)
2460       return -1;
2461   }
2462   {
2463     char device[] = "/dev/sda";
2464     char lines_0[] = ",";
2465     char *lines[] = {
2466       lines_0,
2467       NULL
2468     };
2469     int r;
2470     suppress_error = 0;
2471     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2472     if (r == -1)
2473       return -1;
2474   }
2475   {
2476     char fstype[] = "ext2";
2477     char device[] = "/dev/sda1";
2478     int r;
2479     suppress_error = 0;
2480     r = guestfs_mkfs (g, fstype, device);
2481     if (r == -1)
2482       return -1;
2483   }
2484   {
2485     char device[] = "/dev/sda1";
2486     char mountpoint[] = "/";
2487     int r;
2488     suppress_error = 0;
2489     r = guestfs_mount (g, device, mountpoint);
2490     if (r == -1)
2491       return -1;
2492   }
2493   /* TestOutputList for glob_expand (0) */
2494   {
2495     char path[] = "/a/b/c";
2496     int r;
2497     suppress_error = 0;
2498     r = guestfs_mkdir_p (g, path);
2499     if (r == -1)
2500       return -1;
2501   }
2502   {
2503     char path[] = "/a/b/c/d";
2504     int r;
2505     suppress_error = 0;
2506     r = guestfs_touch (g, path);
2507     if (r == -1)
2508       return -1;
2509   }
2510   {
2511     char path[] = "/a/b/c/e";
2512     int r;
2513     suppress_error = 0;
2514     r = guestfs_touch (g, path);
2515     if (r == -1)
2516       return -1;
2517   }
2518   {
2519     char pattern[] = "/a/b/c/*";
2520     char **r;
2521     int i;
2522     suppress_error = 0;
2523     r = guestfs_glob_expand (g, pattern);
2524     if (r == NULL)
2525       return -1;
2526     if (!r[0]) {
2527       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2528       print_strings (r);
2529       return -1;
2530     }
2531     {
2532       char expected[] = "/a/b/c/d";
2533       if (strcmp (r[0], expected) != 0) {
2534         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2535         return -1;
2536       }
2537     }
2538     if (!r[1]) {
2539       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2540       print_strings (r);
2541       return -1;
2542     }
2543     {
2544       char expected[] = "/a/b/c/e";
2545       if (strcmp (r[1], expected) != 0) {
2546         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2547         return -1;
2548       }
2549     }
2550     if (r[2] != NULL) {
2551       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2552       print_strings (r);
2553       return -1;
2554     }
2555     for (i = 0; r[i] != NULL; ++i)
2556       free (r[i]);
2557     free (r);
2558   }
2559   return 0;
2560 }
2561
2562 static int test_glob_expand_1_skip (void)
2563 {
2564   const char *str;
2565
2566   str = getenv ("TEST_ONLY");
2567   if (str)
2568     return strstr (str, "glob_expand") == NULL;
2569   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2570   if (str && strcmp (str, "1") == 0) return 1;
2571   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2572   if (str && strcmp (str, "1") == 0) return 1;
2573   return 0;
2574 }
2575
2576 static int test_glob_expand_1 (void)
2577 {
2578   if (test_glob_expand_1_skip ()) {
2579     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2580     return 0;
2581   }
2582
2583   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2584   {
2585     char device[] = "/dev/sda";
2586     int r;
2587     suppress_error = 0;
2588     r = guestfs_blockdev_setrw (g, device);
2589     if (r == -1)
2590       return -1;
2591   }
2592   {
2593     int r;
2594     suppress_error = 0;
2595     r = guestfs_umount_all (g);
2596     if (r == -1)
2597       return -1;
2598   }
2599   {
2600     int r;
2601     suppress_error = 0;
2602     r = guestfs_lvm_remove_all (g);
2603     if (r == -1)
2604       return -1;
2605   }
2606   {
2607     char device[] = "/dev/sda";
2608     char lines_0[] = ",";
2609     char *lines[] = {
2610       lines_0,
2611       NULL
2612     };
2613     int r;
2614     suppress_error = 0;
2615     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2616     if (r == -1)
2617       return -1;
2618   }
2619   {
2620     char fstype[] = "ext2";
2621     char device[] = "/dev/sda1";
2622     int r;
2623     suppress_error = 0;
2624     r = guestfs_mkfs (g, fstype, device);
2625     if (r == -1)
2626       return -1;
2627   }
2628   {
2629     char device[] = "/dev/sda1";
2630     char mountpoint[] = "/";
2631     int r;
2632     suppress_error = 0;
2633     r = guestfs_mount (g, device, mountpoint);
2634     if (r == -1)
2635       return -1;
2636   }
2637   /* TestOutputList for glob_expand (1) */
2638   {
2639     char path[] = "/a/b/c";
2640     int r;
2641     suppress_error = 0;
2642     r = guestfs_mkdir_p (g, path);
2643     if (r == -1)
2644       return -1;
2645   }
2646   {
2647     char path[] = "/a/b/c/d";
2648     int r;
2649     suppress_error = 0;
2650     r = guestfs_touch (g, path);
2651     if (r == -1)
2652       return -1;
2653   }
2654   {
2655     char path[] = "/a/b/c/e";
2656     int r;
2657     suppress_error = 0;
2658     r = guestfs_touch (g, path);
2659     if (r == -1)
2660       return -1;
2661   }
2662   {
2663     char pattern[] = "/a/*/c/*";
2664     char **r;
2665     int i;
2666     suppress_error = 0;
2667     r = guestfs_glob_expand (g, pattern);
2668     if (r == NULL)
2669       return -1;
2670     if (!r[0]) {
2671       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2672       print_strings (r);
2673       return -1;
2674     }
2675     {
2676       char expected[] = "/a/b/c/d";
2677       if (strcmp (r[0], expected) != 0) {
2678         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2679         return -1;
2680       }
2681     }
2682     if (!r[1]) {
2683       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2684       print_strings (r);
2685       return -1;
2686     }
2687     {
2688       char expected[] = "/a/b/c/e";
2689       if (strcmp (r[1], expected) != 0) {
2690         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2691         return -1;
2692       }
2693     }
2694     if (r[2] != NULL) {
2695       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2696       print_strings (r);
2697       return -1;
2698     }
2699     for (i = 0; r[i] != NULL; ++i)
2700       free (r[i]);
2701     free (r);
2702   }
2703   return 0;
2704 }
2705
2706 static int test_glob_expand_2_skip (void)
2707 {
2708   const char *str;
2709
2710   str = getenv ("TEST_ONLY");
2711   if (str)
2712     return strstr (str, "glob_expand") == NULL;
2713   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2714   if (str && strcmp (str, "1") == 0) return 1;
2715   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2716   if (str && strcmp (str, "1") == 0) return 1;
2717   return 0;
2718 }
2719
2720 static int test_glob_expand_2 (void)
2721 {
2722   if (test_glob_expand_2_skip ()) {
2723     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2724     return 0;
2725   }
2726
2727   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2728   {
2729     char device[] = "/dev/sda";
2730     int r;
2731     suppress_error = 0;
2732     r = guestfs_blockdev_setrw (g, device);
2733     if (r == -1)
2734       return -1;
2735   }
2736   {
2737     int r;
2738     suppress_error = 0;
2739     r = guestfs_umount_all (g);
2740     if (r == -1)
2741       return -1;
2742   }
2743   {
2744     int r;
2745     suppress_error = 0;
2746     r = guestfs_lvm_remove_all (g);
2747     if (r == -1)
2748       return -1;
2749   }
2750   {
2751     char device[] = "/dev/sda";
2752     char lines_0[] = ",";
2753     char *lines[] = {
2754       lines_0,
2755       NULL
2756     };
2757     int r;
2758     suppress_error = 0;
2759     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2760     if (r == -1)
2761       return -1;
2762   }
2763   {
2764     char fstype[] = "ext2";
2765     char device[] = "/dev/sda1";
2766     int r;
2767     suppress_error = 0;
2768     r = guestfs_mkfs (g, fstype, device);
2769     if (r == -1)
2770       return -1;
2771   }
2772   {
2773     char device[] = "/dev/sda1";
2774     char mountpoint[] = "/";
2775     int r;
2776     suppress_error = 0;
2777     r = guestfs_mount (g, device, mountpoint);
2778     if (r == -1)
2779       return -1;
2780   }
2781   /* TestOutputList for glob_expand (2) */
2782   {
2783     char path[] = "/a/b/c";
2784     int r;
2785     suppress_error = 0;
2786     r = guestfs_mkdir_p (g, path);
2787     if (r == -1)
2788       return -1;
2789   }
2790   {
2791     char path[] = "/a/b/c/d";
2792     int r;
2793     suppress_error = 0;
2794     r = guestfs_touch (g, path);
2795     if (r == -1)
2796       return -1;
2797   }
2798   {
2799     char path[] = "/a/b/c/e";
2800     int r;
2801     suppress_error = 0;
2802     r = guestfs_touch (g, path);
2803     if (r == -1)
2804       return -1;
2805   }
2806   {
2807     char pattern[] = "/a/*/x/*";
2808     char **r;
2809     int i;
2810     suppress_error = 0;
2811     r = guestfs_glob_expand (g, pattern);
2812     if (r == NULL)
2813       return -1;
2814     if (r[0] != NULL) {
2815       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2816       print_strings (r);
2817       return -1;
2818     }
2819     for (i = 0; r[i] != NULL; ++i)
2820       free (r[i]);
2821     free (r);
2822   }
2823   return 0;
2824 }
2825
2826 static int test_ntfs_3g_probe_0_skip (void)
2827 {
2828   const char *str;
2829
2830   str = getenv ("TEST_ONLY");
2831   if (str)
2832     return strstr (str, "ntfs_3g_probe") == NULL;
2833   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2834   if (str && strcmp (str, "1") == 0) return 1;
2835   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2836   if (str && strcmp (str, "1") == 0) return 1;
2837   return 0;
2838 }
2839
2840 static int test_ntfs_3g_probe_0 (void)
2841 {
2842   if (test_ntfs_3g_probe_0_skip ()) {
2843     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2844     return 0;
2845   }
2846
2847   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2848   {
2849     char device[] = "/dev/sda";
2850     int r;
2851     suppress_error = 0;
2852     r = guestfs_blockdev_setrw (g, device);
2853     if (r == -1)
2854       return -1;
2855   }
2856   {
2857     int r;
2858     suppress_error = 0;
2859     r = guestfs_umount_all (g);
2860     if (r == -1)
2861       return -1;
2862   }
2863   {
2864     int r;
2865     suppress_error = 0;
2866     r = guestfs_lvm_remove_all (g);
2867     if (r == -1)
2868       return -1;
2869   }
2870   /* TestOutputInt for ntfs_3g_probe (0) */
2871   {
2872     char device[] = "/dev/sda";
2873     char lines_0[] = ",";
2874     char *lines[] = {
2875       lines_0,
2876       NULL
2877     };
2878     int r;
2879     suppress_error = 0;
2880     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2881     if (r == -1)
2882       return -1;
2883   }
2884   {
2885     char fstype[] = "ntfs";
2886     char device[] = "/dev/sda1";
2887     int r;
2888     suppress_error = 0;
2889     r = guestfs_mkfs (g, fstype, device);
2890     if (r == -1)
2891       return -1;
2892   }
2893   {
2894     char device[] = "/dev/sda1";
2895     int r;
2896     suppress_error = 0;
2897     r = guestfs_ntfs_3g_probe (g, 1, device);
2898     if (r == -1)
2899       return -1;
2900     if (r != 0) {
2901       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
2902       return -1;
2903     }
2904   }
2905   return 0;
2906 }
2907
2908 static int test_ntfs_3g_probe_1_skip (void)
2909 {
2910   const char *str;
2911
2912   str = getenv ("TEST_ONLY");
2913   if (str)
2914     return strstr (str, "ntfs_3g_probe") == NULL;
2915   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2916   if (str && strcmp (str, "1") == 0) return 1;
2917   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2918   if (str && strcmp (str, "1") == 0) return 1;
2919   return 0;
2920 }
2921
2922 static int test_ntfs_3g_probe_1 (void)
2923 {
2924   if (test_ntfs_3g_probe_1_skip ()) {
2925     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2926     return 0;
2927   }
2928
2929   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2930   {
2931     char device[] = "/dev/sda";
2932     int r;
2933     suppress_error = 0;
2934     r = guestfs_blockdev_setrw (g, device);
2935     if (r == -1)
2936       return -1;
2937   }
2938   {
2939     int r;
2940     suppress_error = 0;
2941     r = guestfs_umount_all (g);
2942     if (r == -1)
2943       return -1;
2944   }
2945   {
2946     int r;
2947     suppress_error = 0;
2948     r = guestfs_lvm_remove_all (g);
2949     if (r == -1)
2950       return -1;
2951   }
2952   /* TestOutputInt for ntfs_3g_probe (1) */
2953   {
2954     char device[] = "/dev/sda";
2955     char lines_0[] = ",";
2956     char *lines[] = {
2957       lines_0,
2958       NULL
2959     };
2960     int r;
2961     suppress_error = 0;
2962     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2963     if (r == -1)
2964       return -1;
2965   }
2966   {
2967     char fstype[] = "ext2";
2968     char device[] = "/dev/sda1";
2969     int r;
2970     suppress_error = 0;
2971     r = guestfs_mkfs (g, fstype, device);
2972     if (r == -1)
2973       return -1;
2974   }
2975   {
2976     char device[] = "/dev/sda1";
2977     int r;
2978     suppress_error = 0;
2979     r = guestfs_ntfs_3g_probe (g, 1, device);
2980     if (r == -1)
2981       return -1;
2982     if (r != 12) {
2983       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
2984       return -1;
2985     }
2986   }
2987   return 0;
2988 }
2989
2990 static int test_sleep_0_skip (void)
2991 {
2992   const char *str;
2993
2994   str = getenv ("TEST_ONLY");
2995   if (str)
2996     return strstr (str, "sleep") == NULL;
2997   str = getenv ("SKIP_TEST_SLEEP_0");
2998   if (str && strcmp (str, "1") == 0) return 1;
2999   str = getenv ("SKIP_TEST_SLEEP");
3000   if (str && strcmp (str, "1") == 0) return 1;
3001   return 0;
3002 }
3003
3004 static int test_sleep_0 (void)
3005 {
3006   if (test_sleep_0_skip ()) {
3007     printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
3008     return 0;
3009   }
3010
3011   /* InitNone|InitEmpty for test_sleep_0 */
3012   {
3013     char device[] = "/dev/sda";
3014     int r;
3015     suppress_error = 0;
3016     r = guestfs_blockdev_setrw (g, device);
3017     if (r == -1)
3018       return -1;
3019   }
3020   {
3021     int r;
3022     suppress_error = 0;
3023     r = guestfs_umount_all (g);
3024     if (r == -1)
3025       return -1;
3026   }
3027   {
3028     int r;
3029     suppress_error = 0;
3030     r = guestfs_lvm_remove_all (g);
3031     if (r == -1)
3032       return -1;
3033   }
3034   /* TestRun for sleep (0) */
3035   {
3036     int r;
3037     suppress_error = 0;
3038     r = guestfs_sleep (g, 1);
3039     if (r == -1)
3040       return -1;
3041   }
3042   return 0;
3043 }
3044
3045 static int test_find_0_skip (void)
3046 {
3047   const char *str;
3048
3049   str = getenv ("TEST_ONLY");
3050   if (str)
3051     return strstr (str, "find") == NULL;
3052   str = getenv ("SKIP_TEST_FIND_0");
3053   if (str && strcmp (str, "1") == 0) return 1;
3054   str = getenv ("SKIP_TEST_FIND");
3055   if (str && strcmp (str, "1") == 0) return 1;
3056   return 0;
3057 }
3058
3059 static int test_find_0 (void)
3060 {
3061   if (test_find_0_skip ()) {
3062     printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
3063     return 0;
3064   }
3065
3066   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3067   {
3068     char device[] = "/dev/sda";
3069     int r;
3070     suppress_error = 0;
3071     r = guestfs_blockdev_setrw (g, device);
3072     if (r == -1)
3073       return -1;
3074   }
3075   {
3076     int r;
3077     suppress_error = 0;
3078     r = guestfs_umount_all (g);
3079     if (r == -1)
3080       return -1;
3081   }
3082   {
3083     int r;
3084     suppress_error = 0;
3085     r = guestfs_lvm_remove_all (g);
3086     if (r == -1)
3087       return -1;
3088   }
3089   {
3090     char device[] = "/dev/sda";
3091     char lines_0[] = ",";
3092     char *lines[] = {
3093       lines_0,
3094       NULL
3095     };
3096     int r;
3097     suppress_error = 0;
3098     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3099     if (r == -1)
3100       return -1;
3101   }
3102   {
3103     char fstype[] = "ext2";
3104     char device[] = "/dev/sda1";
3105     int r;
3106     suppress_error = 0;
3107     r = guestfs_mkfs (g, fstype, device);
3108     if (r == -1)
3109       return -1;
3110   }
3111   {
3112     char device[] = "/dev/sda1";
3113     char mountpoint[] = "/";
3114     int r;
3115     suppress_error = 0;
3116     r = guestfs_mount (g, device, mountpoint);
3117     if (r == -1)
3118       return -1;
3119   }
3120   /* TestOutputList for find (0) */
3121   {
3122     char directory[] = "/";
3123     char **r;
3124     int i;
3125     suppress_error = 0;
3126     r = guestfs_find (g, directory);
3127     if (r == NULL)
3128       return -1;
3129     if (!r[0]) {
3130       fprintf (stderr, "test_find_0: short list returned from command\n");
3131       print_strings (r);
3132       return -1;
3133     }
3134     {
3135       char expected[] = "lost+found";
3136       if (strcmp (r[0], expected) != 0) {
3137         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3138         return -1;
3139       }
3140     }
3141     if (r[1] != NULL) {
3142       fprintf (stderr, "test_find_0: extra elements returned from command\n");
3143       print_strings (r);
3144       return -1;
3145     }
3146     for (i = 0; r[i] != NULL; ++i)
3147       free (r[i]);
3148     free (r);
3149   }
3150   return 0;
3151 }
3152
3153 static int test_find_1_skip (void)
3154 {
3155   const char *str;
3156
3157   str = getenv ("TEST_ONLY");
3158   if (str)
3159     return strstr (str, "find") == NULL;
3160   str = getenv ("SKIP_TEST_FIND_1");
3161   if (str && strcmp (str, "1") == 0) return 1;
3162   str = getenv ("SKIP_TEST_FIND");
3163   if (str && strcmp (str, "1") == 0) return 1;
3164   return 0;
3165 }
3166
3167 static int test_find_1 (void)
3168 {
3169   if (test_find_1_skip ()) {
3170     printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
3171     return 0;
3172   }
3173
3174   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3175   {
3176     char device[] = "/dev/sda";
3177     int r;
3178     suppress_error = 0;
3179     r = guestfs_blockdev_setrw (g, device);
3180     if (r == -1)
3181       return -1;
3182   }
3183   {
3184     int r;
3185     suppress_error = 0;
3186     r = guestfs_umount_all (g);
3187     if (r == -1)
3188       return -1;
3189   }
3190   {
3191     int r;
3192     suppress_error = 0;
3193     r = guestfs_lvm_remove_all (g);
3194     if (r == -1)
3195       return -1;
3196   }
3197   {
3198     char device[] = "/dev/sda";
3199     char lines_0[] = ",";
3200     char *lines[] = {
3201       lines_0,
3202       NULL
3203     };
3204     int r;
3205     suppress_error = 0;
3206     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3207     if (r == -1)
3208       return -1;
3209   }
3210   {
3211     char fstype[] = "ext2";
3212     char device[] = "/dev/sda1";
3213     int r;
3214     suppress_error = 0;
3215     r = guestfs_mkfs (g, fstype, device);
3216     if (r == -1)
3217       return -1;
3218   }
3219   {
3220     char device[] = "/dev/sda1";
3221     char mountpoint[] = "/";
3222     int r;
3223     suppress_error = 0;
3224     r = guestfs_mount (g, device, mountpoint);
3225     if (r == -1)
3226       return -1;
3227   }
3228   /* TestOutputList for find (1) */
3229   {
3230     char path[] = "/a";
3231     int r;
3232     suppress_error = 0;
3233     r = guestfs_touch (g, path);
3234     if (r == -1)
3235       return -1;
3236   }
3237   {
3238     char path[] = "/b";
3239     int r;
3240     suppress_error = 0;
3241     r = guestfs_mkdir (g, path);
3242     if (r == -1)
3243       return -1;
3244   }
3245   {
3246     char path[] = "/b/c";
3247     int r;
3248     suppress_error = 0;
3249     r = guestfs_touch (g, path);
3250     if (r == -1)
3251       return -1;
3252   }
3253   {
3254     char directory[] = "/";
3255     char **r;
3256     int i;
3257     suppress_error = 0;
3258     r = guestfs_find (g, directory);
3259     if (r == NULL)
3260       return -1;
3261     if (!r[0]) {
3262       fprintf (stderr, "test_find_1: short list returned from command\n");
3263       print_strings (r);
3264       return -1;
3265     }
3266     {
3267       char expected[] = "a";
3268       if (strcmp (r[0], expected) != 0) {
3269         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3270         return -1;
3271       }
3272     }
3273     if (!r[1]) {
3274       fprintf (stderr, "test_find_1: short list returned from command\n");
3275       print_strings (r);
3276       return -1;
3277     }
3278     {
3279       char expected[] = "b";
3280       if (strcmp (r[1], expected) != 0) {
3281         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3282         return -1;
3283       }
3284     }
3285     if (!r[2]) {
3286       fprintf (stderr, "test_find_1: short list returned from command\n");
3287       print_strings (r);
3288       return -1;
3289     }
3290     {
3291       char expected[] = "b/c";
3292       if (strcmp (r[2], expected) != 0) {
3293         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3294         return -1;
3295       }
3296     }
3297     if (!r[3]) {
3298       fprintf (stderr, "test_find_1: short list returned from command\n");
3299       print_strings (r);
3300       return -1;
3301     }
3302     {
3303       char expected[] = "lost+found";
3304       if (strcmp (r[3], expected) != 0) {
3305         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3306         return -1;
3307       }
3308     }
3309     if (r[4] != NULL) {
3310       fprintf (stderr, "test_find_1: extra elements returned from command\n");
3311       print_strings (r);
3312       return -1;
3313     }
3314     for (i = 0; r[i] != NULL; ++i)
3315       free (r[i]);
3316     free (r);
3317   }
3318   return 0;
3319 }
3320
3321 static int test_find_2_skip (void)
3322 {
3323   const char *str;
3324
3325   str = getenv ("TEST_ONLY");
3326   if (str)
3327     return strstr (str, "find") == NULL;
3328   str = getenv ("SKIP_TEST_FIND_2");
3329   if (str && strcmp (str, "1") == 0) return 1;
3330   str = getenv ("SKIP_TEST_FIND");
3331   if (str && strcmp (str, "1") == 0) return 1;
3332   return 0;
3333 }
3334
3335 static int test_find_2 (void)
3336 {
3337   if (test_find_2_skip ()) {
3338     printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3339     return 0;
3340   }
3341
3342   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3343   {
3344     char device[] = "/dev/sda";
3345     int r;
3346     suppress_error = 0;
3347     r = guestfs_blockdev_setrw (g, device);
3348     if (r == -1)
3349       return -1;
3350   }
3351   {
3352     int r;
3353     suppress_error = 0;
3354     r = guestfs_umount_all (g);
3355     if (r == -1)
3356       return -1;
3357   }
3358   {
3359     int r;
3360     suppress_error = 0;
3361     r = guestfs_lvm_remove_all (g);
3362     if (r == -1)
3363       return -1;
3364   }
3365   {
3366     char device[] = "/dev/sda";
3367     char lines_0[] = ",";
3368     char *lines[] = {
3369       lines_0,
3370       NULL
3371     };
3372     int r;
3373     suppress_error = 0;
3374     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3375     if (r == -1)
3376       return -1;
3377   }
3378   {
3379     char fstype[] = "ext2";
3380     char device[] = "/dev/sda1";
3381     int r;
3382     suppress_error = 0;
3383     r = guestfs_mkfs (g, fstype, device);
3384     if (r == -1)
3385       return -1;
3386   }
3387   {
3388     char device[] = "/dev/sda1";
3389     char mountpoint[] = "/";
3390     int r;
3391     suppress_error = 0;
3392     r = guestfs_mount (g, device, mountpoint);
3393     if (r == -1)
3394       return -1;
3395   }
3396   /* TestOutputList for find (2) */
3397   {
3398     char path[] = "/a/b/c";
3399     int r;
3400     suppress_error = 0;
3401     r = guestfs_mkdir_p (g, path);
3402     if (r == -1)
3403       return -1;
3404   }
3405   {
3406     char path[] = "/a/b/c/d";
3407     int r;
3408     suppress_error = 0;
3409     r = guestfs_touch (g, path);
3410     if (r == -1)
3411       return -1;
3412   }
3413   {
3414     char directory[] = "/a/b/";
3415     char **r;
3416     int i;
3417     suppress_error = 0;
3418     r = guestfs_find (g, directory);
3419     if (r == NULL)
3420       return -1;
3421     if (!r[0]) {
3422       fprintf (stderr, "test_find_2: short list returned from command\n");
3423       print_strings (r);
3424       return -1;
3425     }
3426     {
3427       char expected[] = "c";
3428       if (strcmp (r[0], expected) != 0) {
3429         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3430         return -1;
3431       }
3432     }
3433     if (!r[1]) {
3434       fprintf (stderr, "test_find_2: short list returned from command\n");
3435       print_strings (r);
3436       return -1;
3437     }
3438     {
3439       char expected[] = "c/d";
3440       if (strcmp (r[1], expected) != 0) {
3441         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3442         return -1;
3443       }
3444     }
3445     if (r[2] != NULL) {
3446       fprintf (stderr, "test_find_2: extra elements returned from command\n");
3447       print_strings (r);
3448       return -1;
3449     }
3450     for (i = 0; r[i] != NULL; ++i)
3451       free (r[i]);
3452     free (r);
3453   }
3454   return 0;
3455 }
3456
3457 static int test_lvresize_0_skip (void)
3458 {
3459   const char *str;
3460
3461   str = getenv ("TEST_ONLY");
3462   if (str)
3463     return strstr (str, "lvresize") == NULL;
3464   str = getenv ("SKIP_TEST_LVRESIZE_0");
3465   if (str && strcmp (str, "1") == 0) return 1;
3466   str = getenv ("SKIP_TEST_LVRESIZE");
3467   if (str && strcmp (str, "1") == 0) return 1;
3468   return 0;
3469 }
3470
3471 static int test_lvresize_0 (void)
3472 {
3473   if (test_lvresize_0_skip ()) {
3474     printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3475     return 0;
3476   }
3477
3478   /* InitNone|InitEmpty for test_lvresize_0 */
3479   {
3480     char device[] = "/dev/sda";
3481     int r;
3482     suppress_error = 0;
3483     r = guestfs_blockdev_setrw (g, device);
3484     if (r == -1)
3485       return -1;
3486   }
3487   {
3488     int r;
3489     suppress_error = 0;
3490     r = guestfs_umount_all (g);
3491     if (r == -1)
3492       return -1;
3493   }
3494   {
3495     int r;
3496     suppress_error = 0;
3497     r = guestfs_lvm_remove_all (g);
3498     if (r == -1)
3499       return -1;
3500   }
3501   /* TestOutput for lvresize (0) */
3502   char expected[] = "test content";
3503   {
3504     char device[] = "/dev/sda";
3505     char lines_0[] = ",";
3506     char *lines[] = {
3507       lines_0,
3508       NULL
3509     };
3510     int r;
3511     suppress_error = 0;
3512     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3513     if (r == -1)
3514       return -1;
3515   }
3516   {
3517     char device[] = "/dev/sda1";
3518     int r;
3519     suppress_error = 0;
3520     r = guestfs_pvcreate (g, device);
3521     if (r == -1)
3522       return -1;
3523   }
3524   {
3525     char volgroup[] = "VG";
3526     char physvols_0[] = "/dev/sda1";
3527     char *physvols[] = {
3528       physvols_0,
3529       NULL
3530     };
3531     int r;
3532     suppress_error = 0;
3533     r = guestfs_vgcreate (g, volgroup, physvols);
3534     if (r == -1)
3535       return -1;
3536   }
3537   {
3538     char logvol[] = "LV";
3539     char volgroup[] = "VG";
3540     int r;
3541     suppress_error = 0;
3542     r = guestfs_lvcreate (g, logvol, volgroup, 10);
3543     if (r == -1)
3544       return -1;
3545   }
3546   {
3547     char fstype[] = "ext2";
3548     char device[] = "/dev/VG/LV";
3549     int r;
3550     suppress_error = 0;
3551     r = guestfs_mkfs (g, fstype, device);
3552     if (r == -1)
3553       return -1;
3554   }
3555   {
3556     char device[] = "/dev/VG/LV";
3557     char mountpoint[] = "/";
3558     int r;
3559     suppress_error = 0;
3560     r = guestfs_mount (g, device, mountpoint);
3561     if (r == -1)
3562       return -1;
3563   }
3564   {
3565     char path[] = "/new";
3566     char content[] = "test content";
3567     int r;
3568     suppress_error = 0;
3569     r = guestfs_write_file (g, path, content, 0);
3570     if (r == -1)
3571       return -1;
3572   }
3573   {
3574     char pathordevice[] = "/";
3575     int r;
3576     suppress_error = 0;
3577     r = guestfs_umount (g, pathordevice);
3578     if (r == -1)
3579       return -1;
3580   }
3581   {
3582     char device[] = "/dev/VG/LV";
3583     int r;
3584     suppress_error = 0;
3585     r = guestfs_lvresize (g, device, 20);
3586     if (r == -1)
3587       return -1;
3588   }
3589   {
3590     char device[] = "/dev/VG/LV";
3591     int r;
3592     suppress_error = 0;
3593     r = guestfs_e2fsck_f (g, device);
3594     if (r == -1)
3595       return -1;
3596   }
3597   {
3598     char device[] = "/dev/VG/LV";
3599     int r;
3600     suppress_error = 0;
3601     r = guestfs_resize2fs (g, device);
3602     if (r == -1)
3603       return -1;
3604   }
3605   {
3606     char device[] = "/dev/VG/LV";
3607     char mountpoint[] = "/";
3608     int r;
3609     suppress_error = 0;
3610     r = guestfs_mount (g, device, mountpoint);
3611     if (r == -1)
3612       return -1;
3613   }
3614   {
3615     char path[] = "/new";
3616     char *r;
3617     suppress_error = 0;
3618     r = guestfs_cat (g, path);
3619     if (r == NULL)
3620       return -1;
3621     if (strcmp (r, expected) != 0) {
3622       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3623       return -1;
3624     }
3625     free (r);
3626   }
3627   return 0;
3628 }
3629
3630 static int test_zerofree_0_skip (void)
3631 {
3632   const char *str;
3633
3634   str = getenv ("TEST_ONLY");
3635   if (str)
3636     return strstr (str, "zerofree") == NULL;
3637   str = getenv ("SKIP_TEST_ZEROFREE_0");
3638   if (str && strcmp (str, "1") == 0) return 1;
3639   str = getenv ("SKIP_TEST_ZEROFREE");
3640   if (str && strcmp (str, "1") == 0) return 1;
3641   return 0;
3642 }
3643
3644 static int test_zerofree_0 (void)
3645 {
3646   if (test_zerofree_0_skip ()) {
3647     printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3648     return 0;
3649   }
3650
3651   /* InitNone|InitEmpty for test_zerofree_0 */
3652   {
3653     char device[] = "/dev/sda";
3654     int r;
3655     suppress_error = 0;
3656     r = guestfs_blockdev_setrw (g, device);
3657     if (r == -1)
3658       return -1;
3659   }
3660   {
3661     int r;
3662     suppress_error = 0;
3663     r = guestfs_umount_all (g);
3664     if (r == -1)
3665       return -1;
3666   }
3667   {
3668     int r;
3669     suppress_error = 0;
3670     r = guestfs_lvm_remove_all (g);
3671     if (r == -1)
3672       return -1;
3673   }
3674   /* TestOutput for zerofree (0) */
3675   char expected[] = "test file";
3676   {
3677     char device[] = "/dev/sda";
3678     char lines_0[] = ",";
3679     char *lines[] = {
3680       lines_0,
3681       NULL
3682     };
3683     int r;
3684     suppress_error = 0;
3685     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3686     if (r == -1)
3687       return -1;
3688   }
3689   {
3690     char fstype[] = "ext3";
3691     char device[] = "/dev/sda1";
3692     int r;
3693     suppress_error = 0;
3694     r = guestfs_mkfs (g, fstype, device);
3695     if (r == -1)
3696       return -1;
3697   }
3698   {
3699     char device[] = "/dev/sda1";
3700     char mountpoint[] = "/";
3701     int r;
3702     suppress_error = 0;
3703     r = guestfs_mount (g, device, mountpoint);
3704     if (r == -1)
3705       return -1;
3706   }
3707   {
3708     char path[] = "/new";
3709     char content[] = "test file";
3710     int r;
3711     suppress_error = 0;
3712     r = guestfs_write_file (g, path, content, 0);
3713     if (r == -1)
3714       return -1;
3715   }
3716   {
3717     char pathordevice[] = "/dev/sda1";
3718     int r;
3719     suppress_error = 0;
3720     r = guestfs_umount (g, pathordevice);
3721     if (r == -1)
3722       return -1;
3723   }
3724   {
3725     char device[] = "/dev/sda1";
3726     int r;
3727     suppress_error = 0;
3728     r = guestfs_zerofree (g, device);
3729     if (r == -1)
3730       return -1;
3731   }
3732   {
3733     char device[] = "/dev/sda1";
3734     char mountpoint[] = "/";
3735     int r;
3736     suppress_error = 0;
3737     r = guestfs_mount (g, device, mountpoint);
3738     if (r == -1)
3739       return -1;
3740   }
3741   {
3742     char path[] = "/new";
3743     char *r;
3744     suppress_error = 0;
3745     r = guestfs_cat (g, path);
3746     if (r == NULL)
3747       return -1;
3748     if (strcmp (r, expected) != 0) {
3749       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3750       return -1;
3751     }
3752     free (r);
3753   }
3754   return 0;
3755 }
3756
3757 static int test_hexdump_0_skip (void)
3758 {
3759   const char *str;
3760
3761   str = getenv ("TEST_ONLY");
3762   if (str)
3763     return strstr (str, "hexdump") == NULL;
3764   str = getenv ("SKIP_TEST_HEXDUMP_0");
3765   if (str && strcmp (str, "1") == 0) return 1;
3766   str = getenv ("SKIP_TEST_HEXDUMP");
3767   if (str && strcmp (str, "1") == 0) return 1;
3768   return 0;
3769 }
3770
3771 static int test_hexdump_0 (void)
3772 {
3773   if (test_hexdump_0_skip ()) {
3774     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3775     return 0;
3776   }
3777
3778   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3779   {
3780     char device[] = "/dev/sda";
3781     int r;
3782     suppress_error = 0;
3783     r = guestfs_blockdev_setrw (g, device);
3784     if (r == -1)
3785       return -1;
3786   }
3787   {
3788     int r;
3789     suppress_error = 0;
3790     r = guestfs_umount_all (g);
3791     if (r == -1)
3792       return -1;
3793   }
3794   {
3795     int r;
3796     suppress_error = 0;
3797     r = guestfs_lvm_remove_all (g);
3798     if (r == -1)
3799       return -1;
3800   }
3801   {
3802     char device[] = "/dev/sda";
3803     char lines_0[] = ",";
3804     char *lines[] = {
3805       lines_0,
3806       NULL
3807     };
3808     int r;
3809     suppress_error = 0;
3810     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3811     if (r == -1)
3812       return -1;
3813   }
3814   {
3815     char fstype[] = "ext2";
3816     char device[] = "/dev/sda1";
3817     int r;
3818     suppress_error = 0;
3819     r = guestfs_mkfs (g, fstype, device);
3820     if (r == -1)
3821       return -1;
3822   }
3823   {
3824     char device[] = "/dev/sda1";
3825     char mountpoint[] = "/";
3826     int r;
3827     suppress_error = 0;
3828     r = guestfs_mount (g, device, mountpoint);
3829     if (r == -1)
3830       return -1;
3831   }
3832   /* TestOutput for hexdump (0) */
3833   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
3834   {
3835     char path[] = "/new";
3836     char content[] = "hello\nworld\n";
3837     int r;
3838     suppress_error = 0;
3839     r = guestfs_write_file (g, path, content, 12);
3840     if (r == -1)
3841       return -1;
3842   }
3843   {
3844     char path[] = "/new";
3845     char *r;
3846     suppress_error = 0;
3847     r = guestfs_hexdump (g, path);
3848     if (r == NULL)
3849       return -1;
3850     if (strcmp (r, expected) != 0) {
3851       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3852       return -1;
3853     }
3854     free (r);
3855   }
3856   return 0;
3857 }
3858
3859 static int test_hexdump_1_skip (void)
3860 {
3861   const char *str;
3862
3863   str = getenv ("TEST_ONLY");
3864   if (str)
3865     return strstr (str, "hexdump") == NULL;
3866   str = getenv ("SKIP_TEST_HEXDUMP_1");
3867   if (str && strcmp (str, "1") == 0) return 1;
3868   str = getenv ("SKIP_TEST_HEXDUMP");
3869   if (str && strcmp (str, "1") == 0) return 1;
3870   return 0;
3871 }
3872
3873 static int test_hexdump_1 (void)
3874 {
3875   if (test_hexdump_1_skip ()) {
3876     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3877     return 0;
3878   }
3879
3880   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3881   {
3882     char device[] = "/dev/sda";
3883     int r;
3884     suppress_error = 0;
3885     r = guestfs_blockdev_setrw (g, device);
3886     if (r == -1)
3887       return -1;
3888   }
3889   {
3890     int r;
3891     suppress_error = 0;
3892     r = guestfs_umount_all (g);
3893     if (r == -1)
3894       return -1;
3895   }
3896   {
3897     int r;
3898     suppress_error = 0;
3899     r = guestfs_lvm_remove_all (g);
3900     if (r == -1)
3901       return -1;
3902   }
3903   {
3904     char device[] = "/dev/sda";
3905     char lines_0[] = ",";
3906     char *lines[] = {
3907       lines_0,
3908       NULL
3909     };
3910     int r;
3911     suppress_error = 0;
3912     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3913     if (r == -1)
3914       return -1;
3915   }
3916   {
3917     char fstype[] = "ext2";
3918     char device[] = "/dev/sda1";
3919     int r;
3920     suppress_error = 0;
3921     r = guestfs_mkfs (g, fstype, device);
3922     if (r == -1)
3923       return -1;
3924   }
3925   {
3926     char device[] = "/dev/sda1";
3927     char mountpoint[] = "/";
3928     int r;
3929     suppress_error = 0;
3930     r = guestfs_mount (g, device, mountpoint);
3931     if (r == -1)
3932       return -1;
3933   }
3934   /* TestRun for hexdump (1) */
3935   {
3936     char options[] = "ro";
3937     char vfstype[] = "squashfs";
3938     char device[] = "/dev/sdd";
3939     char mountpoint[] = "/";
3940     int r;
3941     suppress_error = 0;
3942     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3943     if (r == -1)
3944       return -1;
3945   }
3946   {
3947     char path[] = "/100krandom";
3948     char *r;
3949     suppress_error = 0;
3950     r = guestfs_hexdump (g, path);
3951     if (r == NULL)
3952       return -1;
3953     free (r);
3954   }
3955   return 0;
3956 }
3957
3958 static int test_strings_e_0_skip (void)
3959 {
3960   const char *str;
3961
3962   str = getenv ("TEST_ONLY");
3963   if (str)
3964     return strstr (str, "strings_e") == NULL;
3965   str = getenv ("SKIP_TEST_STRINGS_E_0");
3966   if (str && strcmp (str, "1") == 0) return 1;
3967   str = getenv ("SKIP_TEST_STRINGS_E");
3968   if (str && strcmp (str, "1") == 0) return 1;
3969   return 0;
3970 }
3971
3972 static int test_strings_e_0 (void)
3973 {
3974   if (test_strings_e_0_skip ()) {
3975     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3976     return 0;
3977   }
3978
3979   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3980   {
3981     char device[] = "/dev/sda";
3982     int r;
3983     suppress_error = 0;
3984     r = guestfs_blockdev_setrw (g, device);
3985     if (r == -1)
3986       return -1;
3987   }
3988   {
3989     int r;
3990     suppress_error = 0;
3991     r = guestfs_umount_all (g);
3992     if (r == -1)
3993       return -1;
3994   }
3995   {
3996     int r;
3997     suppress_error = 0;
3998     r = guestfs_lvm_remove_all (g);
3999     if (r == -1)
4000       return -1;
4001   }
4002   {
4003     char device[] = "/dev/sda";
4004     char lines_0[] = ",";
4005     char *lines[] = {
4006       lines_0,
4007       NULL
4008     };
4009     int r;
4010     suppress_error = 0;
4011     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4012     if (r == -1)
4013       return -1;
4014   }
4015   {
4016     char fstype[] = "ext2";
4017     char device[] = "/dev/sda1";
4018     int r;
4019     suppress_error = 0;
4020     r = guestfs_mkfs (g, fstype, device);
4021     if (r == -1)
4022       return -1;
4023   }
4024   {
4025     char device[] = "/dev/sda1";
4026     char mountpoint[] = "/";
4027     int r;
4028     suppress_error = 0;
4029     r = guestfs_mount (g, device, mountpoint);
4030     if (r == -1)
4031       return -1;
4032   }
4033   /* TestOutputList for strings_e (0) */
4034   {
4035     char path[] = "/new";
4036     char content[] = "hello\nworld\n";
4037     int r;
4038     suppress_error = 0;
4039     r = guestfs_write_file (g, path, content, 0);
4040     if (r == -1)
4041       return -1;
4042   }
4043   {
4044     char encoding[] = "b";
4045     char path[] = "/new";
4046     char **r;
4047     int i;
4048     suppress_error = 0;
4049     r = guestfs_strings_e (g, encoding, path);
4050     if (r == NULL)
4051       return -1;
4052     if (r[0] != NULL) {
4053       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
4054       print_strings (r);
4055       return -1;
4056     }
4057     for (i = 0; r[i] != NULL; ++i)
4058       free (r[i]);
4059     free (r);
4060   }
4061   return 0;
4062 }
4063
4064 static int test_strings_e_1_skip (void)
4065 {
4066   const char *str;
4067
4068   str = getenv ("TEST_ONLY");
4069   if (str)
4070     return strstr (str, "strings_e") == NULL;
4071   str = getenv ("SKIP_TEST_STRINGS_E_1");
4072   if (str && strcmp (str, "1") == 0) return 1;
4073   str = getenv ("SKIP_TEST_STRINGS_E");
4074   if (str && strcmp (str, "1") == 0) return 1;
4075   return 0;
4076 }
4077
4078 static int test_strings_e_1 (void)
4079 {
4080   if (test_strings_e_1_skip ()) {
4081     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
4082     return 0;
4083   }
4084
4085   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
4086   return 0;
4087 }
4088
4089 static int test_strings_0_skip (void)
4090 {
4091   const char *str;
4092
4093   str = getenv ("TEST_ONLY");
4094   if (str)
4095     return strstr (str, "strings") == NULL;
4096   str = getenv ("SKIP_TEST_STRINGS_0");
4097   if (str && strcmp (str, "1") == 0) return 1;
4098   str = getenv ("SKIP_TEST_STRINGS");
4099   if (str && strcmp (str, "1") == 0) return 1;
4100   return 0;
4101 }
4102
4103 static int test_strings_0 (void)
4104 {
4105   if (test_strings_0_skip ()) {
4106     printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
4107     return 0;
4108   }
4109
4110   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
4111   {
4112     char device[] = "/dev/sda";
4113     int r;
4114     suppress_error = 0;
4115     r = guestfs_blockdev_setrw (g, device);
4116     if (r == -1)
4117       return -1;
4118   }
4119   {
4120     int r;
4121     suppress_error = 0;
4122     r = guestfs_umount_all (g);
4123     if (r == -1)
4124       return -1;
4125   }
4126   {
4127     int r;
4128     suppress_error = 0;
4129     r = guestfs_lvm_remove_all (g);
4130     if (r == -1)
4131       return -1;
4132   }
4133   {
4134     char device[] = "/dev/sda";
4135     char lines_0[] = ",";
4136     char *lines[] = {
4137       lines_0,
4138       NULL
4139     };
4140     int r;
4141     suppress_error = 0;
4142     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4143     if (r == -1)
4144       return -1;
4145   }
4146   {
4147     char fstype[] = "ext2";
4148     char device[] = "/dev/sda1";
4149     int r;
4150     suppress_error = 0;
4151     r = guestfs_mkfs (g, fstype, device);
4152     if (r == -1)
4153       return -1;
4154   }
4155   {
4156     char device[] = "/dev/sda1";
4157     char mountpoint[] = "/";
4158     int r;
4159     suppress_error = 0;
4160     r = guestfs_mount (g, device, mountpoint);
4161     if (r == -1)
4162       return -1;
4163   }
4164   /* TestOutputList for strings (0) */
4165   {
4166     char path[] = "/new";
4167     char content[] = "hello\nworld\n";
4168     int r;
4169     suppress_error = 0;
4170     r = guestfs_write_file (g, path, content, 0);
4171     if (r == -1)
4172       return -1;
4173   }
4174   {
4175     char path[] = "/new";
4176     char **r;
4177     int i;
4178     suppress_error = 0;
4179     r = guestfs_strings (g, path);
4180     if (r == NULL)
4181       return -1;
4182     if (!r[0]) {
4183       fprintf (stderr, "test_strings_0: short list returned from command\n");
4184       print_strings (r);
4185       return -1;
4186     }
4187     {
4188       char expected[] = "hello";
4189       if (strcmp (r[0], expected) != 0) {
4190         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4191         return -1;
4192       }
4193     }
4194     if (!r[1]) {
4195       fprintf (stderr, "test_strings_0: short list returned from command\n");
4196       print_strings (r);
4197       return -1;
4198     }
4199     {
4200       char expected[] = "world";
4201       if (strcmp (r[1], expected) != 0) {
4202         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
4203         return -1;
4204       }
4205     }
4206     if (r[2] != NULL) {
4207       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4208       print_strings (r);
4209       return -1;
4210     }
4211     for (i = 0; r[i] != NULL; ++i)
4212       free (r[i]);
4213     free (r);
4214   }
4215   return 0;
4216 }
4217
4218 static int test_strings_1_skip (void)
4219 {
4220   const char *str;
4221
4222   str = getenv ("TEST_ONLY");
4223   if (str)
4224     return strstr (str, "strings") == NULL;
4225   str = getenv ("SKIP_TEST_STRINGS_1");
4226   if (str && strcmp (str, "1") == 0) return 1;
4227   str = getenv ("SKIP_TEST_STRINGS");
4228   if (str && strcmp (str, "1") == 0) return 1;
4229   return 0;
4230 }
4231
4232 static int test_strings_1 (void)
4233 {
4234   if (test_strings_1_skip ()) {
4235     printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
4236     return 0;
4237   }
4238
4239   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4240   {
4241     char device[] = "/dev/sda";
4242     int r;
4243     suppress_error = 0;
4244     r = guestfs_blockdev_setrw (g, device);
4245     if (r == -1)
4246       return -1;
4247   }
4248   {
4249     int r;
4250     suppress_error = 0;
4251     r = guestfs_umount_all (g);
4252     if (r == -1)
4253       return -1;
4254   }
4255   {
4256     int r;
4257     suppress_error = 0;
4258     r = guestfs_lvm_remove_all (g);
4259     if (r == -1)
4260       return -1;
4261   }
4262   {
4263     char device[] = "/dev/sda";
4264     char lines_0[] = ",";
4265     char *lines[] = {
4266       lines_0,
4267       NULL
4268     };
4269     int r;
4270     suppress_error = 0;
4271     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4272     if (r == -1)
4273       return -1;
4274   }
4275   {
4276     char fstype[] = "ext2";
4277     char device[] = "/dev/sda1";
4278     int r;
4279     suppress_error = 0;
4280     r = guestfs_mkfs (g, fstype, device);
4281     if (r == -1)
4282       return -1;
4283   }
4284   {
4285     char device[] = "/dev/sda1";
4286     char mountpoint[] = "/";
4287     int r;
4288     suppress_error = 0;
4289     r = guestfs_mount (g, device, mountpoint);
4290     if (r == -1)
4291       return -1;
4292   }
4293   /* TestOutputList for strings (1) */
4294   {
4295     char path[] = "/new";
4296     int r;
4297     suppress_error = 0;
4298     r = guestfs_touch (g, path);
4299     if (r == -1)
4300       return -1;
4301   }
4302   {
4303     char path[] = "/new";
4304     char **r;
4305     int i;
4306     suppress_error = 0;
4307     r = guestfs_strings (g, path);
4308     if (r == NULL)
4309       return -1;
4310     if (r[0] != NULL) {
4311       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4312       print_strings (r);
4313       return -1;
4314     }
4315     for (i = 0; r[i] != NULL; ++i)
4316       free (r[i]);
4317     free (r);
4318   }
4319   return 0;
4320 }
4321
4322 static int test_equal_0_skip (void)
4323 {
4324   const char *str;
4325
4326   str = getenv ("TEST_ONLY");
4327   if (str)
4328     return strstr (str, "equal") == NULL;
4329   str = getenv ("SKIP_TEST_EQUAL_0");
4330   if (str && strcmp (str, "1") == 0) return 1;
4331   str = getenv ("SKIP_TEST_EQUAL");
4332   if (str && strcmp (str, "1") == 0) return 1;
4333   return 0;
4334 }
4335
4336 static int test_equal_0 (void)
4337 {
4338   if (test_equal_0_skip ()) {
4339     printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
4340     return 0;
4341   }
4342
4343   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4344   {
4345     char device[] = "/dev/sda";
4346     int r;
4347     suppress_error = 0;
4348     r = guestfs_blockdev_setrw (g, device);
4349     if (r == -1)
4350       return -1;
4351   }
4352   {
4353     int r;
4354     suppress_error = 0;
4355     r = guestfs_umount_all (g);
4356     if (r == -1)
4357       return -1;
4358   }
4359   {
4360     int r;
4361     suppress_error = 0;
4362     r = guestfs_lvm_remove_all (g);
4363     if (r == -1)
4364       return -1;
4365   }
4366   {
4367     char device[] = "/dev/sda";
4368     char lines_0[] = ",";
4369     char *lines[] = {
4370       lines_0,
4371       NULL
4372     };
4373     int r;
4374     suppress_error = 0;
4375     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4376     if (r == -1)
4377       return -1;
4378   }
4379   {
4380     char fstype[] = "ext2";
4381     char device[] = "/dev/sda1";
4382     int r;
4383     suppress_error = 0;
4384     r = guestfs_mkfs (g, fstype, device);
4385     if (r == -1)
4386       return -1;
4387   }
4388   {
4389     char device[] = "/dev/sda1";
4390     char mountpoint[] = "/";
4391     int r;
4392     suppress_error = 0;
4393     r = guestfs_mount (g, device, mountpoint);
4394     if (r == -1)
4395       return -1;
4396   }
4397   /* TestOutputTrue for equal (0) */
4398   {
4399     char path[] = "/file1";
4400     char content[] = "contents of a file";
4401     int r;
4402     suppress_error = 0;
4403     r = guestfs_write_file (g, path, content, 0);
4404     if (r == -1)
4405       return -1;
4406   }
4407   {
4408     char src[] = "/file1";
4409     char dest[] = "/file2";
4410     int r;
4411     suppress_error = 0;
4412     r = guestfs_cp (g, src, dest);
4413     if (r == -1)
4414       return -1;
4415   }
4416   {
4417     char file1[] = "/file1";
4418     char file2[] = "/file2";
4419     int r;
4420     suppress_error = 0;
4421     r = guestfs_equal (g, file1, file2);
4422     if (r == -1)
4423       return -1;
4424     if (!r) {
4425       fprintf (stderr, "test_equal_0: expected true, got false\n");
4426       return -1;
4427     }
4428   }
4429   return 0;
4430 }
4431
4432 static int test_equal_1_skip (void)
4433 {
4434   const char *str;
4435
4436   str = getenv ("TEST_ONLY");
4437   if (str)
4438     return strstr (str, "equal") == NULL;
4439   str = getenv ("SKIP_TEST_EQUAL_1");
4440   if (str && strcmp (str, "1") == 0) return 1;
4441   str = getenv ("SKIP_TEST_EQUAL");
4442   if (str && strcmp (str, "1") == 0) return 1;
4443   return 0;
4444 }
4445
4446 static int test_equal_1 (void)
4447 {
4448   if (test_equal_1_skip ()) {
4449     printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4450     return 0;
4451   }
4452
4453   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4454   {
4455     char device[] = "/dev/sda";
4456     int r;
4457     suppress_error = 0;
4458     r = guestfs_blockdev_setrw (g, device);
4459     if (r == -1)
4460       return -1;
4461   }
4462   {
4463     int r;
4464     suppress_error = 0;
4465     r = guestfs_umount_all (g);
4466     if (r == -1)
4467       return -1;
4468   }
4469   {
4470     int r;
4471     suppress_error = 0;
4472     r = guestfs_lvm_remove_all (g);
4473     if (r == -1)
4474       return -1;
4475   }
4476   {
4477     char device[] = "/dev/sda";
4478     char lines_0[] = ",";
4479     char *lines[] = {
4480       lines_0,
4481       NULL
4482     };
4483     int r;
4484     suppress_error = 0;
4485     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4486     if (r == -1)
4487       return -1;
4488   }
4489   {
4490     char fstype[] = "ext2";
4491     char device[] = "/dev/sda1";
4492     int r;
4493     suppress_error = 0;
4494     r = guestfs_mkfs (g, fstype, device);
4495     if (r == -1)
4496       return -1;
4497   }
4498   {
4499     char device[] = "/dev/sda1";
4500     char mountpoint[] = "/";
4501     int r;
4502     suppress_error = 0;
4503     r = guestfs_mount (g, device, mountpoint);
4504     if (r == -1)
4505       return -1;
4506   }
4507   /* TestOutputFalse for equal (1) */
4508   {
4509     char path[] = "/file1";
4510     char content[] = "contents of a file";
4511     int r;
4512     suppress_error = 0;
4513     r = guestfs_write_file (g, path, content, 0);
4514     if (r == -1)
4515       return -1;
4516   }
4517   {
4518     char path[] = "/file2";
4519     char content[] = "contents of another file";
4520     int r;
4521     suppress_error = 0;
4522     r = guestfs_write_file (g, path, content, 0);
4523     if (r == -1)
4524       return -1;
4525   }
4526   {
4527     char file1[] = "/file1";
4528     char file2[] = "/file2";
4529     int r;
4530     suppress_error = 0;
4531     r = guestfs_equal (g, file1, file2);
4532     if (r == -1)
4533       return -1;
4534     if (r) {
4535       fprintf (stderr, "test_equal_1: expected false, got true\n");
4536       return -1;
4537     }
4538   }
4539   return 0;
4540 }
4541
4542 static int test_equal_2_skip (void)
4543 {
4544   const char *str;
4545
4546   str = getenv ("TEST_ONLY");
4547   if (str)
4548     return strstr (str, "equal") == NULL;
4549   str = getenv ("SKIP_TEST_EQUAL_2");
4550   if (str && strcmp (str, "1") == 0) return 1;
4551   str = getenv ("SKIP_TEST_EQUAL");
4552   if (str && strcmp (str, "1") == 0) return 1;
4553   return 0;
4554 }
4555
4556 static int test_equal_2 (void)
4557 {
4558   if (test_equal_2_skip ()) {
4559     printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4560     return 0;
4561   }
4562
4563   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4564   {
4565     char device[] = "/dev/sda";
4566     int r;
4567     suppress_error = 0;
4568     r = guestfs_blockdev_setrw (g, device);
4569     if (r == -1)
4570       return -1;
4571   }
4572   {
4573     int r;
4574     suppress_error = 0;
4575     r = guestfs_umount_all (g);
4576     if (r == -1)
4577       return -1;
4578   }
4579   {
4580     int r;
4581     suppress_error = 0;
4582     r = guestfs_lvm_remove_all (g);
4583     if (r == -1)
4584       return -1;
4585   }
4586   {
4587     char device[] = "/dev/sda";
4588     char lines_0[] = ",";
4589     char *lines[] = {
4590       lines_0,
4591       NULL
4592     };
4593     int r;
4594     suppress_error = 0;
4595     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4596     if (r == -1)
4597       return -1;
4598   }
4599   {
4600     char fstype[] = "ext2";
4601     char device[] = "/dev/sda1";
4602     int r;
4603     suppress_error = 0;
4604     r = guestfs_mkfs (g, fstype, device);
4605     if (r == -1)
4606       return -1;
4607   }
4608   {
4609     char device[] = "/dev/sda1";
4610     char mountpoint[] = "/";
4611     int r;
4612     suppress_error = 0;
4613     r = guestfs_mount (g, device, mountpoint);
4614     if (r == -1)
4615       return -1;
4616   }
4617   /* TestLastFail for equal (2) */
4618   {
4619     char file1[] = "/file1";
4620     char file2[] = "/file2";
4621     int r;
4622     suppress_error = 1;
4623     r = guestfs_equal (g, file1, file2);
4624     if (r != -1)
4625       return -1;
4626   }
4627   return 0;
4628 }
4629
4630 static int test_ping_daemon_0_skip (void)
4631 {
4632   const char *str;
4633
4634   str = getenv ("TEST_ONLY");
4635   if (str)
4636     return strstr (str, "ping_daemon") == NULL;
4637   str = getenv ("SKIP_TEST_PING_DAEMON_0");
4638   if (str && strcmp (str, "1") == 0) return 1;
4639   str = getenv ("SKIP_TEST_PING_DAEMON");
4640   if (str && strcmp (str, "1") == 0) return 1;
4641   return 0;
4642 }
4643
4644 static int test_ping_daemon_0 (void)
4645 {
4646   if (test_ping_daemon_0_skip ()) {
4647     printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4648     return 0;
4649   }
4650
4651   /* InitNone|InitEmpty for test_ping_daemon_0 */
4652   {
4653     char device[] = "/dev/sda";
4654     int r;
4655     suppress_error = 0;
4656     r = guestfs_blockdev_setrw (g, device);
4657     if (r == -1)
4658       return -1;
4659   }
4660   {
4661     int r;
4662     suppress_error = 0;
4663     r = guestfs_umount_all (g);
4664     if (r == -1)
4665       return -1;
4666   }
4667   {
4668     int r;
4669     suppress_error = 0;
4670     r = guestfs_lvm_remove_all (g);
4671     if (r == -1)
4672       return -1;
4673   }
4674   /* TestRun for ping_daemon (0) */
4675   {
4676     int r;
4677     suppress_error = 0;
4678     r = guestfs_ping_daemon (g);
4679     if (r == -1)
4680       return -1;
4681   }
4682   return 0;
4683 }
4684
4685 static int test_dmesg_0_skip (void)
4686 {
4687   const char *str;
4688
4689   str = getenv ("TEST_ONLY");
4690   if (str)
4691     return strstr (str, "dmesg") == NULL;
4692   str = getenv ("SKIP_TEST_DMESG_0");
4693   if (str && strcmp (str, "1") == 0) return 1;
4694   str = getenv ("SKIP_TEST_DMESG");
4695   if (str && strcmp (str, "1") == 0) return 1;
4696   return 0;
4697 }
4698
4699 static int test_dmesg_0 (void)
4700 {
4701   if (test_dmesg_0_skip ()) {
4702     printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4703     return 0;
4704   }
4705
4706   /* InitNone|InitEmpty for test_dmesg_0 */
4707   {
4708     char device[] = "/dev/sda";
4709     int r;
4710     suppress_error = 0;
4711     r = guestfs_blockdev_setrw (g, device);
4712     if (r == -1)
4713       return -1;
4714   }
4715   {
4716     int r;
4717     suppress_error = 0;
4718     r = guestfs_umount_all (g);
4719     if (r == -1)
4720       return -1;
4721   }
4722   {
4723     int r;
4724     suppress_error = 0;
4725     r = guestfs_lvm_remove_all (g);
4726     if (r == -1)
4727       return -1;
4728   }
4729   /* TestRun for dmesg (0) */
4730   {
4731     char *r;
4732     suppress_error = 0;
4733     r = guestfs_dmesg (g);
4734     if (r == NULL)
4735       return -1;
4736     free (r);
4737   }
4738   return 0;
4739 }
4740
4741 static int test_drop_caches_0_skip (void)
4742 {
4743   const char *str;
4744
4745   str = getenv ("TEST_ONLY");
4746   if (str)
4747     return strstr (str, "drop_caches") == NULL;
4748   str = getenv ("SKIP_TEST_DROP_CACHES_0");
4749   if (str && strcmp (str, "1") == 0) return 1;
4750   str = getenv ("SKIP_TEST_DROP_CACHES");
4751   if (str && strcmp (str, "1") == 0) return 1;
4752   return 0;
4753 }
4754
4755 static int test_drop_caches_0 (void)
4756 {
4757   if (test_drop_caches_0_skip ()) {
4758     printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4759     return 0;
4760   }
4761
4762   /* InitNone|InitEmpty for test_drop_caches_0 */
4763   {
4764     char device[] = "/dev/sda";
4765     int r;
4766     suppress_error = 0;
4767     r = guestfs_blockdev_setrw (g, device);
4768     if (r == -1)
4769       return -1;
4770   }
4771   {
4772     int r;
4773     suppress_error = 0;
4774     r = guestfs_umount_all (g);
4775     if (r == -1)
4776       return -1;
4777   }
4778   {
4779     int r;
4780     suppress_error = 0;
4781     r = guestfs_lvm_remove_all (g);
4782     if (r == -1)
4783       return -1;
4784   }
4785   /* TestRun for drop_caches (0) */
4786   {
4787     int r;
4788     suppress_error = 0;
4789     r = guestfs_drop_caches (g, 3);
4790     if (r == -1)
4791       return -1;
4792   }
4793   return 0;
4794 }
4795
4796 static int test_mv_0_skip (void)
4797 {
4798   const char *str;
4799
4800   str = getenv ("TEST_ONLY");
4801   if (str)
4802     return strstr (str, "mv") == NULL;
4803   str = getenv ("SKIP_TEST_MV_0");
4804   if (str && strcmp (str, "1") == 0) return 1;
4805   str = getenv ("SKIP_TEST_MV");
4806   if (str && strcmp (str, "1") == 0) return 1;
4807   return 0;
4808 }
4809
4810 static int test_mv_0 (void)
4811 {
4812   if (test_mv_0_skip ()) {
4813     printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4814     return 0;
4815   }
4816
4817   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4818   {
4819     char device[] = "/dev/sda";
4820     int r;
4821     suppress_error = 0;
4822     r = guestfs_blockdev_setrw (g, device);
4823     if (r == -1)
4824       return -1;
4825   }
4826   {
4827     int r;
4828     suppress_error = 0;
4829     r = guestfs_umount_all (g);
4830     if (r == -1)
4831       return -1;
4832   }
4833   {
4834     int r;
4835     suppress_error = 0;
4836     r = guestfs_lvm_remove_all (g);
4837     if (r == -1)
4838       return -1;
4839   }
4840   {
4841     char device[] = "/dev/sda";
4842     char lines_0[] = ",";
4843     char *lines[] = {
4844       lines_0,
4845       NULL
4846     };
4847     int r;
4848     suppress_error = 0;
4849     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4850     if (r == -1)
4851       return -1;
4852   }
4853   {
4854     char fstype[] = "ext2";
4855     char device[] = "/dev/sda1";
4856     int r;
4857     suppress_error = 0;
4858     r = guestfs_mkfs (g, fstype, device);
4859     if (r == -1)
4860       return -1;
4861   }
4862   {
4863     char device[] = "/dev/sda1";
4864     char mountpoint[] = "/";
4865     int r;
4866     suppress_error = 0;
4867     r = guestfs_mount (g, device, mountpoint);
4868     if (r == -1)
4869       return -1;
4870   }
4871   /* TestOutput for mv (0) */
4872   char expected[] = "file content";
4873   {
4874     char path[] = "/old";
4875     char content[] = "file content";
4876     int r;
4877     suppress_error = 0;
4878     r = guestfs_write_file (g, path, content, 0);
4879     if (r == -1)
4880       return -1;
4881   }
4882   {
4883     char src[] = "/old";
4884     char dest[] = "/new";
4885     int r;
4886     suppress_error = 0;
4887     r = guestfs_mv (g, src, dest);
4888     if (r == -1)
4889       return -1;
4890   }
4891   {
4892     char path[] = "/new";
4893     char *r;
4894     suppress_error = 0;
4895     r = guestfs_cat (g, path);
4896     if (r == NULL)
4897       return -1;
4898     if (strcmp (r, expected) != 0) {
4899       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4900       return -1;
4901     }
4902     free (r);
4903   }
4904   return 0;
4905 }
4906
4907 static int test_mv_1_skip (void)
4908 {
4909   const char *str;
4910
4911   str = getenv ("TEST_ONLY");
4912   if (str)
4913     return strstr (str, "mv") == NULL;
4914   str = getenv ("SKIP_TEST_MV_1");
4915   if (str && strcmp (str, "1") == 0) return 1;
4916   str = getenv ("SKIP_TEST_MV");
4917   if (str && strcmp (str, "1") == 0) return 1;
4918   return 0;
4919 }
4920
4921 static int test_mv_1 (void)
4922 {
4923   if (test_mv_1_skip ()) {
4924     printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4925     return 0;
4926   }
4927
4928   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4929   {
4930     char device[] = "/dev/sda";
4931     int r;
4932     suppress_error = 0;
4933     r = guestfs_blockdev_setrw (g, device);
4934     if (r == -1)
4935       return -1;
4936   }
4937   {
4938     int r;
4939     suppress_error = 0;
4940     r = guestfs_umount_all (g);
4941     if (r == -1)
4942       return -1;
4943   }
4944   {
4945     int r;
4946     suppress_error = 0;
4947     r = guestfs_lvm_remove_all (g);
4948     if (r == -1)
4949       return -1;
4950   }
4951   {
4952     char device[] = "/dev/sda";
4953     char lines_0[] = ",";
4954     char *lines[] = {
4955       lines_0,
4956       NULL
4957     };
4958     int r;
4959     suppress_error = 0;
4960     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4961     if (r == -1)
4962       return -1;
4963   }
4964   {
4965     char fstype[] = "ext2";
4966     char device[] = "/dev/sda1";
4967     int r;
4968     suppress_error = 0;
4969     r = guestfs_mkfs (g, fstype, device);
4970     if (r == -1)
4971       return -1;
4972   }
4973   {
4974     char device[] = "/dev/sda1";
4975     char mountpoint[] = "/";
4976     int r;
4977     suppress_error = 0;
4978     r = guestfs_mount (g, device, mountpoint);
4979     if (r == -1)
4980       return -1;
4981   }
4982   /* TestOutputFalse for mv (1) */
4983   {
4984     char path[] = "/old";
4985     char content[] = "file content";
4986     int r;
4987     suppress_error = 0;
4988     r = guestfs_write_file (g, path, content, 0);
4989     if (r == -1)
4990       return -1;
4991   }
4992   {
4993     char src[] = "/old";
4994     char dest[] = "/new";
4995     int r;
4996     suppress_error = 0;
4997     r = guestfs_mv (g, src, dest);
4998     if (r == -1)
4999       return -1;
5000   }
5001   {
5002     char path[] = "/old";
5003     int r;
5004     suppress_error = 0;
5005     r = guestfs_is_file (g, path);
5006     if (r == -1)
5007       return -1;
5008     if (r) {
5009       fprintf (stderr, "test_mv_1: expected false, got true\n");
5010       return -1;
5011     }
5012   }
5013   return 0;
5014 }
5015
5016 static int test_cp_a_0_skip (void)
5017 {
5018   const char *str;
5019
5020   str = getenv ("TEST_ONLY");
5021   if (str)
5022     return strstr (str, "cp_a") == NULL;
5023   str = getenv ("SKIP_TEST_CP_A_0");
5024   if (str && strcmp (str, "1") == 0) return 1;
5025   str = getenv ("SKIP_TEST_CP_A");
5026   if (str && strcmp (str, "1") == 0) return 1;
5027   return 0;
5028 }
5029
5030 static int test_cp_a_0 (void)
5031 {
5032   if (test_cp_a_0_skip ()) {
5033     printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
5034     return 0;
5035   }
5036
5037   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
5038   {
5039     char device[] = "/dev/sda";
5040     int r;
5041     suppress_error = 0;
5042     r = guestfs_blockdev_setrw (g, device);
5043     if (r == -1)
5044       return -1;
5045   }
5046   {
5047     int r;
5048     suppress_error = 0;
5049     r = guestfs_umount_all (g);
5050     if (r == -1)
5051       return -1;
5052   }
5053   {
5054     int r;
5055     suppress_error = 0;
5056     r = guestfs_lvm_remove_all (g);
5057     if (r == -1)
5058       return -1;
5059   }
5060   {
5061     char device[] = "/dev/sda";
5062     char lines_0[] = ",";
5063     char *lines[] = {
5064       lines_0,
5065       NULL
5066     };
5067     int r;
5068     suppress_error = 0;
5069     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5070     if (r == -1)
5071       return -1;
5072   }
5073   {
5074     char fstype[] = "ext2";
5075     char device[] = "/dev/sda1";
5076     int r;
5077     suppress_error = 0;
5078     r = guestfs_mkfs (g, fstype, device);
5079     if (r == -1)
5080       return -1;
5081   }
5082   {
5083     char device[] = "/dev/sda1";
5084     char mountpoint[] = "/";
5085     int r;
5086     suppress_error = 0;
5087     r = guestfs_mount (g, device, mountpoint);
5088     if (r == -1)
5089       return -1;
5090   }
5091   /* TestOutput for cp_a (0) */
5092   char expected[] = "file content";
5093   {
5094     char path[] = "/olddir";
5095     int r;
5096     suppress_error = 0;
5097     r = guestfs_mkdir (g, path);
5098     if (r == -1)
5099       return -1;
5100   }
5101   {
5102     char path[] = "/newdir";
5103     int r;
5104     suppress_error = 0;
5105     r = guestfs_mkdir (g, path);
5106     if (r == -1)
5107       return -1;
5108   }
5109   {
5110     char path[] = "/olddir/file";
5111     char content[] = "file content";
5112     int r;
5113     suppress_error = 0;
5114     r = guestfs_write_file (g, path, content, 0);
5115     if (r == -1)
5116       return -1;
5117   }
5118   {
5119     char src[] = "/olddir";
5120     char dest[] = "/newdir";
5121     int r;
5122     suppress_error = 0;
5123     r = guestfs_cp_a (g, src, dest);
5124     if (r == -1)
5125       return -1;
5126   }
5127   {
5128     char path[] = "/newdir/olddir/file";
5129     char *r;
5130     suppress_error = 0;
5131     r = guestfs_cat (g, path);
5132     if (r == NULL)
5133       return -1;
5134     if (strcmp (r, expected) != 0) {
5135       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
5136       return -1;
5137     }
5138     free (r);
5139   }
5140   return 0;
5141 }
5142
5143 static int test_cp_0_skip (void)
5144 {
5145   const char *str;
5146
5147   str = getenv ("TEST_ONLY");
5148   if (str)
5149     return strstr (str, "cp") == NULL;
5150   str = getenv ("SKIP_TEST_CP_0");
5151   if (str && strcmp (str, "1") == 0) return 1;
5152   str = getenv ("SKIP_TEST_CP");
5153   if (str && strcmp (str, "1") == 0) return 1;
5154   return 0;
5155 }
5156
5157 static int test_cp_0 (void)
5158 {
5159   if (test_cp_0_skip ()) {
5160     printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
5161     return 0;
5162   }
5163
5164   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
5165   {
5166     char device[] = "/dev/sda";
5167     int r;
5168     suppress_error = 0;
5169     r = guestfs_blockdev_setrw (g, device);
5170     if (r == -1)
5171       return -1;
5172   }
5173   {
5174     int r;
5175     suppress_error = 0;
5176     r = guestfs_umount_all (g);
5177     if (r == -1)
5178       return -1;
5179   }
5180   {
5181     int r;
5182     suppress_error = 0;
5183     r = guestfs_lvm_remove_all (g);
5184     if (r == -1)
5185       return -1;
5186   }
5187   {
5188     char device[] = "/dev/sda";
5189     char lines_0[] = ",";
5190     char *lines[] = {
5191       lines_0,
5192       NULL
5193     };
5194     int r;
5195     suppress_error = 0;
5196     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5197     if (r == -1)
5198       return -1;
5199   }
5200   {
5201     char fstype[] = "ext2";
5202     char device[] = "/dev/sda1";
5203     int r;
5204     suppress_error = 0;
5205     r = guestfs_mkfs (g, fstype, device);
5206     if (r == -1)
5207       return -1;
5208   }
5209   {
5210     char device[] = "/dev/sda1";
5211     char mountpoint[] = "/";
5212     int r;
5213     suppress_error = 0;
5214     r = guestfs_mount (g, device, mountpoint);
5215     if (r == -1)
5216       return -1;
5217   }
5218   /* TestOutput for cp (0) */
5219   char expected[] = "file content";
5220   {
5221     char path[] = "/old";
5222     char content[] = "file content";
5223     int r;
5224     suppress_error = 0;
5225     r = guestfs_write_file (g, path, content, 0);
5226     if (r == -1)
5227       return -1;
5228   }
5229   {
5230     char src[] = "/old";
5231     char dest[] = "/new";
5232     int r;
5233     suppress_error = 0;
5234     r = guestfs_cp (g, src, dest);
5235     if (r == -1)
5236       return -1;
5237   }
5238   {
5239     char path[] = "/new";
5240     char *r;
5241     suppress_error = 0;
5242     r = guestfs_cat (g, path);
5243     if (r == NULL)
5244       return -1;
5245     if (strcmp (r, expected) != 0) {
5246       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5247       return -1;
5248     }
5249     free (r);
5250   }
5251   return 0;
5252 }
5253
5254 static int test_cp_1_skip (void)
5255 {
5256   const char *str;
5257
5258   str = getenv ("TEST_ONLY");
5259   if (str)
5260     return strstr (str, "cp") == NULL;
5261   str = getenv ("SKIP_TEST_CP_1");
5262   if (str && strcmp (str, "1") == 0) return 1;
5263   str = getenv ("SKIP_TEST_CP");
5264   if (str && strcmp (str, "1") == 0) return 1;
5265   return 0;
5266 }
5267
5268 static int test_cp_1 (void)
5269 {
5270   if (test_cp_1_skip ()) {
5271     printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
5272     return 0;
5273   }
5274
5275   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5276   {
5277     char device[] = "/dev/sda";
5278     int r;
5279     suppress_error = 0;
5280     r = guestfs_blockdev_setrw (g, device);
5281     if (r == -1)
5282       return -1;
5283   }
5284   {
5285     int r;
5286     suppress_error = 0;
5287     r = guestfs_umount_all (g);
5288     if (r == -1)
5289       return -1;
5290   }
5291   {
5292     int r;
5293     suppress_error = 0;
5294     r = guestfs_lvm_remove_all (g);
5295     if (r == -1)
5296       return -1;
5297   }
5298   {
5299     char device[] = "/dev/sda";
5300     char lines_0[] = ",";
5301     char *lines[] = {
5302       lines_0,
5303       NULL
5304     };
5305     int r;
5306     suppress_error = 0;
5307     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5308     if (r == -1)
5309       return -1;
5310   }
5311   {
5312     char fstype[] = "ext2";
5313     char device[] = "/dev/sda1";
5314     int r;
5315     suppress_error = 0;
5316     r = guestfs_mkfs (g, fstype, device);
5317     if (r == -1)
5318       return -1;
5319   }
5320   {
5321     char device[] = "/dev/sda1";
5322     char mountpoint[] = "/";
5323     int r;
5324     suppress_error = 0;
5325     r = guestfs_mount (g, device, mountpoint);
5326     if (r == -1)
5327       return -1;
5328   }
5329   /* TestOutputTrue for cp (1) */
5330   {
5331     char path[] = "/old";
5332     char content[] = "file content";
5333     int r;
5334     suppress_error = 0;
5335     r = guestfs_write_file (g, path, content, 0);
5336     if (r == -1)
5337       return -1;
5338   }
5339   {
5340     char src[] = "/old";
5341     char dest[] = "/new";
5342     int r;
5343     suppress_error = 0;
5344     r = guestfs_cp (g, src, dest);
5345     if (r == -1)
5346       return -1;
5347   }
5348   {
5349     char path[] = "/old";
5350     int r;
5351     suppress_error = 0;
5352     r = guestfs_is_file (g, path);
5353     if (r == -1)
5354       return -1;
5355     if (!r) {
5356       fprintf (stderr, "test_cp_1: expected true, got false\n");
5357       return -1;
5358     }
5359   }
5360   return 0;
5361 }
5362
5363 static int test_cp_2_skip (void)
5364 {
5365   const char *str;
5366
5367   str = getenv ("TEST_ONLY");
5368   if (str)
5369     return strstr (str, "cp") == NULL;
5370   str = getenv ("SKIP_TEST_CP_2");
5371   if (str && strcmp (str, "1") == 0) return 1;
5372   str = getenv ("SKIP_TEST_CP");
5373   if (str && strcmp (str, "1") == 0) return 1;
5374   return 0;
5375 }
5376
5377 static int test_cp_2 (void)
5378 {
5379   if (test_cp_2_skip ()) {
5380     printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5381     return 0;
5382   }
5383
5384   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5385   {
5386     char device[] = "/dev/sda";
5387     int r;
5388     suppress_error = 0;
5389     r = guestfs_blockdev_setrw (g, device);
5390     if (r == -1)
5391       return -1;
5392   }
5393   {
5394     int r;
5395     suppress_error = 0;
5396     r = guestfs_umount_all (g);
5397     if (r == -1)
5398       return -1;
5399   }
5400   {
5401     int r;
5402     suppress_error = 0;
5403     r = guestfs_lvm_remove_all (g);
5404     if (r == -1)
5405       return -1;
5406   }
5407   {
5408     char device[] = "/dev/sda";
5409     char lines_0[] = ",";
5410     char *lines[] = {
5411       lines_0,
5412       NULL
5413     };
5414     int r;
5415     suppress_error = 0;
5416     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5417     if (r == -1)
5418       return -1;
5419   }
5420   {
5421     char fstype[] = "ext2";
5422     char device[] = "/dev/sda1";
5423     int r;
5424     suppress_error = 0;
5425     r = guestfs_mkfs (g, fstype, device);
5426     if (r == -1)
5427       return -1;
5428   }
5429   {
5430     char device[] = "/dev/sda1";
5431     char mountpoint[] = "/";
5432     int r;
5433     suppress_error = 0;
5434     r = guestfs_mount (g, device, mountpoint);
5435     if (r == -1)
5436       return -1;
5437   }
5438   /* TestOutput for cp (2) */
5439   char expected[] = "file content";
5440   {
5441     char path[] = "/old";
5442     char content[] = "file content";
5443     int r;
5444     suppress_error = 0;
5445     r = guestfs_write_file (g, path, content, 0);
5446     if (r == -1)
5447       return -1;
5448   }
5449   {
5450     char path[] = "/dir";
5451     int r;
5452     suppress_error = 0;
5453     r = guestfs_mkdir (g, path);
5454     if (r == -1)
5455       return -1;
5456   }
5457   {
5458     char src[] = "/old";
5459     char dest[] = "/dir/new";
5460     int r;
5461     suppress_error = 0;
5462     r = guestfs_cp (g, src, dest);
5463     if (r == -1)
5464       return -1;
5465   }
5466   {
5467     char path[] = "/dir/new";
5468     char *r;
5469     suppress_error = 0;
5470     r = guestfs_cat (g, path);
5471     if (r == NULL)
5472       return -1;
5473     if (strcmp (r, expected) != 0) {
5474       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5475       return -1;
5476     }
5477     free (r);
5478   }
5479   return 0;
5480 }
5481
5482 static int test_grub_install_0_skip (void)
5483 {
5484   const char *str;
5485
5486   str = getenv ("TEST_ONLY");
5487   if (str)
5488     return strstr (str, "grub_install") == NULL;
5489   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5490   if (str && strcmp (str, "1") == 0) return 1;
5491   str = getenv ("SKIP_TEST_GRUB_INSTALL");
5492   if (str && strcmp (str, "1") == 0) return 1;
5493   return 0;
5494 }
5495
5496 static int test_grub_install_0 (void)
5497 {
5498   if (test_grub_install_0_skip ()) {
5499     printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5500     return 0;
5501   }
5502
5503   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5504   {
5505     char device[] = "/dev/sda";
5506     int r;
5507     suppress_error = 0;
5508     r = guestfs_blockdev_setrw (g, device);
5509     if (r == -1)
5510       return -1;
5511   }
5512   {
5513     int r;
5514     suppress_error = 0;
5515     r = guestfs_umount_all (g);
5516     if (r == -1)
5517       return -1;
5518   }
5519   {
5520     int r;
5521     suppress_error = 0;
5522     r = guestfs_lvm_remove_all (g);
5523     if (r == -1)
5524       return -1;
5525   }
5526   {
5527     char device[] = "/dev/sda";
5528     char lines_0[] = ",";
5529     char *lines[] = {
5530       lines_0,
5531       NULL
5532     };
5533     int r;
5534     suppress_error = 0;
5535     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5536     if (r == -1)
5537       return -1;
5538   }
5539   {
5540     char fstype[] = "ext2";
5541     char device[] = "/dev/sda1";
5542     int r;
5543     suppress_error = 0;
5544     r = guestfs_mkfs (g, fstype, device);
5545     if (r == -1)
5546       return -1;
5547   }
5548   {
5549     char device[] = "/dev/sda1";
5550     char mountpoint[] = "/";
5551     int r;
5552     suppress_error = 0;
5553     r = guestfs_mount (g, device, mountpoint);
5554     if (r == -1)
5555       return -1;
5556   }
5557   /* TestOutputTrue for grub_install (0) */
5558   {
5559     char root[] = "/";
5560     char device[] = "/dev/sda1";
5561     int r;
5562     suppress_error = 0;
5563     r = guestfs_grub_install (g, root, device);
5564     if (r == -1)
5565       return -1;
5566   }
5567   {
5568     char path[] = "/boot";
5569     int r;
5570     suppress_error = 0;
5571     r = guestfs_is_dir (g, path);
5572     if (r == -1)
5573       return -1;
5574     if (!r) {
5575       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5576       return -1;
5577     }
5578   }
5579   return 0;
5580 }
5581
5582 static int test_zero_0_skip (void)
5583 {
5584   const char *str;
5585
5586   str = getenv ("TEST_ONLY");
5587   if (str)
5588     return strstr (str, "zero") == NULL;
5589   str = getenv ("SKIP_TEST_ZERO_0");
5590   if (str && strcmp (str, "1") == 0) return 1;
5591   str = getenv ("SKIP_TEST_ZERO");
5592   if (str && strcmp (str, "1") == 0) return 1;
5593   return 0;
5594 }
5595
5596 static int test_zero_0 (void)
5597 {
5598   if (test_zero_0_skip ()) {
5599     printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5600     return 0;
5601   }
5602
5603   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5604   {
5605     char device[] = "/dev/sda";
5606     int r;
5607     suppress_error = 0;
5608     r = guestfs_blockdev_setrw (g, device);
5609     if (r == -1)
5610       return -1;
5611   }
5612   {
5613     int r;
5614     suppress_error = 0;
5615     r = guestfs_umount_all (g);
5616     if (r == -1)
5617       return -1;
5618   }
5619   {
5620     int r;
5621     suppress_error = 0;
5622     r = guestfs_lvm_remove_all (g);
5623     if (r == -1)
5624       return -1;
5625   }
5626   {
5627     char device[] = "/dev/sda";
5628     char lines_0[] = ",";
5629     char *lines[] = {
5630       lines_0,
5631       NULL
5632     };
5633     int r;
5634     suppress_error = 0;
5635     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5636     if (r == -1)
5637       return -1;
5638   }
5639   {
5640     char fstype[] = "ext2";
5641     char device[] = "/dev/sda1";
5642     int r;
5643     suppress_error = 0;
5644     r = guestfs_mkfs (g, fstype, device);
5645     if (r == -1)
5646       return -1;
5647   }
5648   {
5649     char device[] = "/dev/sda1";
5650     char mountpoint[] = "/";
5651     int r;
5652     suppress_error = 0;
5653     r = guestfs_mount (g, device, mountpoint);
5654     if (r == -1)
5655       return -1;
5656   }
5657   /* TestOutput for zero (0) */
5658   char expected[] = "data";
5659   {
5660     char pathordevice[] = "/dev/sda1";
5661     int r;
5662     suppress_error = 0;
5663     r = guestfs_umount (g, pathordevice);
5664     if (r == -1)
5665       return -1;
5666   }
5667   {
5668     char device[] = "/dev/sda1";
5669     int r;
5670     suppress_error = 0;
5671     r = guestfs_zero (g, device);
5672     if (r == -1)
5673       return -1;
5674   }
5675   {
5676     char path[] = "/dev/sda1";
5677     char *r;
5678     suppress_error = 0;
5679     r = guestfs_file (g, path);
5680     if (r == NULL)
5681       return -1;
5682     if (strcmp (r, expected) != 0) {
5683       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5684       return -1;
5685     }
5686     free (r);
5687   }
5688   return 0;
5689 }
5690
5691 static int test_fsck_0_skip (void)
5692 {
5693   const char *str;
5694
5695   str = getenv ("TEST_ONLY");
5696   if (str)
5697     return strstr (str, "fsck") == NULL;
5698   str = getenv ("SKIP_TEST_FSCK_0");
5699   if (str && strcmp (str, "1") == 0) return 1;
5700   str = getenv ("SKIP_TEST_FSCK");
5701   if (str && strcmp (str, "1") == 0) return 1;
5702   return 0;
5703 }
5704
5705 static int test_fsck_0 (void)
5706 {
5707   if (test_fsck_0_skip ()) {
5708     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5709     return 0;
5710   }
5711
5712   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5713   {
5714     char device[] = "/dev/sda";
5715     int r;
5716     suppress_error = 0;
5717     r = guestfs_blockdev_setrw (g, device);
5718     if (r == -1)
5719       return -1;
5720   }
5721   {
5722     int r;
5723     suppress_error = 0;
5724     r = guestfs_umount_all (g);
5725     if (r == -1)
5726       return -1;
5727   }
5728   {
5729     int r;
5730     suppress_error = 0;
5731     r = guestfs_lvm_remove_all (g);
5732     if (r == -1)
5733       return -1;
5734   }
5735   {
5736     char device[] = "/dev/sda";
5737     char lines_0[] = ",";
5738     char *lines[] = {
5739       lines_0,
5740       NULL
5741     };
5742     int r;
5743     suppress_error = 0;
5744     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5745     if (r == -1)
5746       return -1;
5747   }
5748   {
5749     char fstype[] = "ext2";
5750     char device[] = "/dev/sda1";
5751     int r;
5752     suppress_error = 0;
5753     r = guestfs_mkfs (g, fstype, device);
5754     if (r == -1)
5755       return -1;
5756   }
5757   {
5758     char device[] = "/dev/sda1";
5759     char mountpoint[] = "/";
5760     int r;
5761     suppress_error = 0;
5762     r = guestfs_mount (g, device, mountpoint);
5763     if (r == -1)
5764       return -1;
5765   }
5766   /* TestOutputInt for fsck (0) */
5767   {
5768     char pathordevice[] = "/dev/sda1";
5769     int r;
5770     suppress_error = 0;
5771     r = guestfs_umount (g, pathordevice);
5772     if (r == -1)
5773       return -1;
5774   }
5775   {
5776     char fstype[] = "ext2";
5777     char device[] = "/dev/sda1";
5778     int r;
5779     suppress_error = 0;
5780     r = guestfs_fsck (g, fstype, device);
5781     if (r == -1)
5782       return -1;
5783     if (r != 0) {
5784       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
5785       return -1;
5786     }
5787   }
5788   return 0;
5789 }
5790
5791 static int test_fsck_1_skip (void)
5792 {
5793   const char *str;
5794
5795   str = getenv ("TEST_ONLY");
5796   if (str)
5797     return strstr (str, "fsck") == NULL;
5798   str = getenv ("SKIP_TEST_FSCK_1");
5799   if (str && strcmp (str, "1") == 0) return 1;
5800   str = getenv ("SKIP_TEST_FSCK");
5801   if (str && strcmp (str, "1") == 0) return 1;
5802   return 0;
5803 }
5804
5805 static int test_fsck_1 (void)
5806 {
5807   if (test_fsck_1_skip ()) {
5808     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5809     return 0;
5810   }
5811
5812   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5813   {
5814     char device[] = "/dev/sda";
5815     int r;
5816     suppress_error = 0;
5817     r = guestfs_blockdev_setrw (g, device);
5818     if (r == -1)
5819       return -1;
5820   }
5821   {
5822     int r;
5823     suppress_error = 0;
5824     r = guestfs_umount_all (g);
5825     if (r == -1)
5826       return -1;
5827   }
5828   {
5829     int r;
5830     suppress_error = 0;
5831     r = guestfs_lvm_remove_all (g);
5832     if (r == -1)
5833       return -1;
5834   }
5835   {
5836     char device[] = "/dev/sda";
5837     char lines_0[] = ",";
5838     char *lines[] = {
5839       lines_0,
5840       NULL
5841     };
5842     int r;
5843     suppress_error = 0;
5844     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5845     if (r == -1)
5846       return -1;
5847   }
5848   {
5849     char fstype[] = "ext2";
5850     char device[] = "/dev/sda1";
5851     int r;
5852     suppress_error = 0;
5853     r = guestfs_mkfs (g, fstype, device);
5854     if (r == -1)
5855       return -1;
5856   }
5857   {
5858     char device[] = "/dev/sda1";
5859     char mountpoint[] = "/";
5860     int r;
5861     suppress_error = 0;
5862     r = guestfs_mount (g, device, mountpoint);
5863     if (r == -1)
5864       return -1;
5865   }
5866   /* TestOutputInt for fsck (1) */
5867   {
5868     char pathordevice[] = "/dev/sda1";
5869     int r;
5870     suppress_error = 0;
5871     r = guestfs_umount (g, pathordevice);
5872     if (r == -1)
5873       return -1;
5874   }
5875   {
5876     char device[] = "/dev/sda1";
5877     int r;
5878     suppress_error = 0;
5879     r = guestfs_zero (g, device);
5880     if (r == -1)
5881       return -1;
5882   }
5883   {
5884     char fstype[] = "ext2";
5885     char device[] = "/dev/sda1";
5886     int r;
5887     suppress_error = 0;
5888     r = guestfs_fsck (g, fstype, device);
5889     if (r == -1)
5890       return -1;
5891     if (r != 8) {
5892       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
5893       return -1;
5894     }
5895   }
5896   return 0;
5897 }
5898
5899 static int test_set_e2uuid_0_skip (void)
5900 {
5901   const char *str;
5902
5903   str = getenv ("TEST_ONLY");
5904   if (str)
5905     return strstr (str, "set_e2uuid") == NULL;
5906   str = getenv ("SKIP_TEST_SET_E2UUID_0");
5907   if (str && strcmp (str, "1") == 0) return 1;
5908   str = getenv ("SKIP_TEST_SET_E2UUID");
5909   if (str && strcmp (str, "1") == 0) return 1;
5910   return 0;
5911 }
5912
5913 static int test_set_e2uuid_0 (void)
5914 {
5915   if (test_set_e2uuid_0_skip ()) {
5916     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5917     return 0;
5918   }
5919
5920   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5921   {
5922     char device[] = "/dev/sda";
5923     int r;
5924     suppress_error = 0;
5925     r = guestfs_blockdev_setrw (g, device);
5926     if (r == -1)
5927       return -1;
5928   }
5929   {
5930     int r;
5931     suppress_error = 0;
5932     r = guestfs_umount_all (g);
5933     if (r == -1)
5934       return -1;
5935   }
5936   {
5937     int r;
5938     suppress_error = 0;
5939     r = guestfs_lvm_remove_all (g);
5940     if (r == -1)
5941       return -1;
5942   }
5943   {
5944     char device[] = "/dev/sda";
5945     char lines_0[] = ",";
5946     char *lines[] = {
5947       lines_0,
5948       NULL
5949     };
5950     int r;
5951     suppress_error = 0;
5952     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5953     if (r == -1)
5954       return -1;
5955   }
5956   {
5957     char fstype[] = "ext2";
5958     char device[] = "/dev/sda1";
5959     int r;
5960     suppress_error = 0;
5961     r = guestfs_mkfs (g, fstype, device);
5962     if (r == -1)
5963       return -1;
5964   }
5965   {
5966     char device[] = "/dev/sda1";
5967     char mountpoint[] = "/";
5968     int r;
5969     suppress_error = 0;
5970     r = guestfs_mount (g, device, mountpoint);
5971     if (r == -1)
5972       return -1;
5973   }
5974   /* TestOutput for set_e2uuid (0) */
5975   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5976   {
5977     char device[] = "/dev/sda1";
5978     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5979     int r;
5980     suppress_error = 0;
5981     r = guestfs_set_e2uuid (g, device, uuid);
5982     if (r == -1)
5983       return -1;
5984   }
5985   {
5986     char device[] = "/dev/sda1";
5987     char *r;
5988     suppress_error = 0;
5989     r = guestfs_get_e2uuid (g, device);
5990     if (r == NULL)
5991       return -1;
5992     if (strcmp (r, expected) != 0) {
5993       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5994       return -1;
5995     }
5996     free (r);
5997   }
5998   return 0;
5999 }
6000
6001 static int test_set_e2uuid_1_skip (void)
6002 {
6003   const char *str;
6004
6005   str = getenv ("TEST_ONLY");
6006   if (str)
6007     return strstr (str, "set_e2uuid") == NULL;
6008   str = getenv ("SKIP_TEST_SET_E2UUID_1");
6009   if (str && strcmp (str, "1") == 0) return 1;
6010   str = getenv ("SKIP_TEST_SET_E2UUID");
6011   if (str && strcmp (str, "1") == 0) return 1;
6012   return 0;
6013 }
6014
6015 static int test_set_e2uuid_1 (void)
6016 {
6017   if (test_set_e2uuid_1_skip ()) {
6018     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
6019     return 0;
6020   }
6021
6022   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
6023   {
6024     char device[] = "/dev/sda";
6025     int r;
6026     suppress_error = 0;
6027     r = guestfs_blockdev_setrw (g, device);
6028     if (r == -1)
6029       return -1;
6030   }
6031   {
6032     int r;
6033     suppress_error = 0;
6034     r = guestfs_umount_all (g);
6035     if (r == -1)
6036       return -1;
6037   }
6038   {
6039     int r;
6040     suppress_error = 0;
6041     r = guestfs_lvm_remove_all (g);
6042     if (r == -1)
6043       return -1;
6044   }
6045   {
6046     char device[] = "/dev/sda";
6047     char lines_0[] = ",";
6048     char *lines[] = {
6049       lines_0,
6050       NULL
6051     };
6052     int r;
6053     suppress_error = 0;
6054     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6055     if (r == -1)
6056       return -1;
6057   }
6058   {
6059     char fstype[] = "ext2";
6060     char device[] = "/dev/sda1";
6061     int r;
6062     suppress_error = 0;
6063     r = guestfs_mkfs (g, fstype, device);
6064     if (r == -1)
6065       return -1;
6066   }
6067   {
6068     char device[] = "/dev/sda1";
6069     char mountpoint[] = "/";
6070     int r;
6071     suppress_error = 0;
6072     r = guestfs_mount (g, device, mountpoint);
6073     if (r == -1)
6074       return -1;
6075   }
6076   /* TestOutput for set_e2uuid (1) */
6077   char expected[] = "";
6078   {
6079     char device[] = "/dev/sda1";
6080     char uuid[] = "clear";
6081     int r;
6082     suppress_error = 0;
6083     r = guestfs_set_e2uuid (g, device, uuid);
6084     if (r == -1)
6085       return -1;
6086   }
6087   {
6088     char device[] = "/dev/sda1";
6089     char *r;
6090     suppress_error = 0;
6091     r = guestfs_get_e2uuid (g, device);
6092     if (r == NULL)
6093       return -1;
6094     if (strcmp (r, expected) != 0) {
6095       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
6096       return -1;
6097     }
6098     free (r);
6099   }
6100   return 0;
6101 }
6102
6103 static int test_set_e2uuid_2_skip (void)
6104 {
6105   const char *str;
6106
6107   str = getenv ("TEST_ONLY");
6108   if (str)
6109     return strstr (str, "set_e2uuid") == NULL;
6110   str = getenv ("SKIP_TEST_SET_E2UUID_2");
6111   if (str && strcmp (str, "1") == 0) return 1;
6112   str = getenv ("SKIP_TEST_SET_E2UUID");
6113   if (str && strcmp (str, "1") == 0) return 1;
6114   return 0;
6115 }
6116
6117 static int test_set_e2uuid_2 (void)
6118 {
6119   if (test_set_e2uuid_2_skip ()) {
6120     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
6121     return 0;
6122   }
6123
6124   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
6125   {
6126     char device[] = "/dev/sda";
6127     int r;
6128     suppress_error = 0;
6129     r = guestfs_blockdev_setrw (g, device);
6130     if (r == -1)
6131       return -1;
6132   }
6133   {
6134     int r;
6135     suppress_error = 0;
6136     r = guestfs_umount_all (g);
6137     if (r == -1)
6138       return -1;
6139   }
6140   {
6141     int r;
6142     suppress_error = 0;
6143     r = guestfs_lvm_remove_all (g);
6144     if (r == -1)
6145       return -1;
6146   }
6147   {
6148     char device[] = "/dev/sda";
6149     char lines_0[] = ",";
6150     char *lines[] = {
6151       lines_0,
6152       NULL
6153     };
6154     int r;
6155     suppress_error = 0;
6156     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6157     if (r == -1)
6158       return -1;
6159   }
6160   {
6161     char fstype[] = "ext2";
6162     char device[] = "/dev/sda1";
6163     int r;
6164     suppress_error = 0;
6165     r = guestfs_mkfs (g, fstype, device);
6166     if (r == -1)
6167       return -1;
6168   }
6169   {
6170     char device[] = "/dev/sda1";
6171     char mountpoint[] = "/";
6172     int r;
6173     suppress_error = 0;
6174     r = guestfs_mount (g, device, mountpoint);
6175     if (r == -1)
6176       return -1;
6177   }
6178   /* TestRun for set_e2uuid (2) */
6179   {
6180     char device[] = "/dev/sda1";
6181     char uuid[] = "random";
6182     int r;
6183     suppress_error = 0;
6184     r = guestfs_set_e2uuid (g, device, uuid);
6185     if (r == -1)
6186       return -1;
6187   }
6188   return 0;
6189 }
6190
6191 static int test_set_e2uuid_3_skip (void)
6192 {
6193   const char *str;
6194
6195   str = getenv ("TEST_ONLY");
6196   if (str)
6197     return strstr (str, "set_e2uuid") == NULL;
6198   str = getenv ("SKIP_TEST_SET_E2UUID_3");
6199   if (str && strcmp (str, "1") == 0) return 1;
6200   str = getenv ("SKIP_TEST_SET_E2UUID");
6201   if (str && strcmp (str, "1") == 0) return 1;
6202   return 0;
6203 }
6204
6205 static int test_set_e2uuid_3 (void)
6206 {
6207   if (test_set_e2uuid_3_skip ()) {
6208     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6209     return 0;
6210   }
6211
6212   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6213   {
6214     char device[] = "/dev/sda";
6215     int r;
6216     suppress_error = 0;
6217     r = guestfs_blockdev_setrw (g, device);
6218     if (r == -1)
6219       return -1;
6220   }
6221   {
6222     int r;
6223     suppress_error = 0;
6224     r = guestfs_umount_all (g);
6225     if (r == -1)
6226       return -1;
6227   }
6228   {
6229     int r;
6230     suppress_error = 0;
6231     r = guestfs_lvm_remove_all (g);
6232     if (r == -1)
6233       return -1;
6234   }
6235   {
6236     char device[] = "/dev/sda";
6237     char lines_0[] = ",";
6238     char *lines[] = {
6239       lines_0,
6240       NULL
6241     };
6242     int r;
6243     suppress_error = 0;
6244     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6245     if (r == -1)
6246       return -1;
6247   }
6248   {
6249     char fstype[] = "ext2";
6250     char device[] = "/dev/sda1";
6251     int r;
6252     suppress_error = 0;
6253     r = guestfs_mkfs (g, fstype, device);
6254     if (r == -1)
6255       return -1;
6256   }
6257   {
6258     char device[] = "/dev/sda1";
6259     char mountpoint[] = "/";
6260     int r;
6261     suppress_error = 0;
6262     r = guestfs_mount (g, device, mountpoint);
6263     if (r == -1)
6264       return -1;
6265   }
6266   /* TestRun for set_e2uuid (3) */
6267   {
6268     char device[] = "/dev/sda1";
6269     char uuid[] = "time";
6270     int r;
6271     suppress_error = 0;
6272     r = guestfs_set_e2uuid (g, device, uuid);
6273     if (r == -1)
6274       return -1;
6275   }
6276   return 0;
6277 }
6278
6279 static int test_set_e2label_0_skip (void)
6280 {
6281   const char *str;
6282
6283   str = getenv ("TEST_ONLY");
6284   if (str)
6285     return strstr (str, "set_e2label") == NULL;
6286   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6287   if (str && strcmp (str, "1") == 0) return 1;
6288   str = getenv ("SKIP_TEST_SET_E2LABEL");
6289   if (str && strcmp (str, "1") == 0) return 1;
6290   return 0;
6291 }
6292
6293 static int test_set_e2label_0 (void)
6294 {
6295   if (test_set_e2label_0_skip ()) {
6296     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6297     return 0;
6298   }
6299
6300   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6301   {
6302     char device[] = "/dev/sda";
6303     int r;
6304     suppress_error = 0;
6305     r = guestfs_blockdev_setrw (g, device);
6306     if (r == -1)
6307       return -1;
6308   }
6309   {
6310     int r;
6311     suppress_error = 0;
6312     r = guestfs_umount_all (g);
6313     if (r == -1)
6314       return -1;
6315   }
6316   {
6317     int r;
6318     suppress_error = 0;
6319     r = guestfs_lvm_remove_all (g);
6320     if (r == -1)
6321       return -1;
6322   }
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 fstype[] = "ext2";
6338     char device[] = "/dev/sda1";
6339     int r;
6340     suppress_error = 0;
6341     r = guestfs_mkfs (g, fstype, device);
6342     if (r == -1)
6343       return -1;
6344   }
6345   {
6346     char device[] = "/dev/sda1";
6347     char mountpoint[] = "/";
6348     int r;
6349     suppress_error = 0;
6350     r = guestfs_mount (g, device, mountpoint);
6351     if (r == -1)
6352       return -1;
6353   }
6354   /* TestOutput for set_e2label (0) */
6355   char expected[] = "testlabel";
6356   {
6357     char device[] = "/dev/sda1";
6358     char label[] = "testlabel";
6359     int r;
6360     suppress_error = 0;
6361     r = guestfs_set_e2label (g, device, label);
6362     if (r == -1)
6363       return -1;
6364   }
6365   {
6366     char device[] = "/dev/sda1";
6367     char *r;
6368     suppress_error = 0;
6369     r = guestfs_get_e2label (g, device);
6370     if (r == NULL)
6371       return -1;
6372     if (strcmp (r, expected) != 0) {
6373       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6374       return -1;
6375     }
6376     free (r);
6377   }
6378   return 0;
6379 }
6380
6381 static int test_pvremove_0_skip (void)
6382 {
6383   const char *str;
6384
6385   str = getenv ("TEST_ONLY");
6386   if (str)
6387     return strstr (str, "pvremove") == NULL;
6388   str = getenv ("SKIP_TEST_PVREMOVE_0");
6389   if (str && strcmp (str, "1") == 0) return 1;
6390   str = getenv ("SKIP_TEST_PVREMOVE");
6391   if (str && strcmp (str, "1") == 0) return 1;
6392   return 0;
6393 }
6394
6395 static int test_pvremove_0 (void)
6396 {
6397   if (test_pvremove_0_skip ()) {
6398     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6399     return 0;
6400   }
6401
6402   /* InitNone|InitEmpty for test_pvremove_0 */
6403   {
6404     char device[] = "/dev/sda";
6405     int r;
6406     suppress_error = 0;
6407     r = guestfs_blockdev_setrw (g, device);
6408     if (r == -1)
6409       return -1;
6410   }
6411   {
6412     int r;
6413     suppress_error = 0;
6414     r = guestfs_umount_all (g);
6415     if (r == -1)
6416       return -1;
6417   }
6418   {
6419     int r;
6420     suppress_error = 0;
6421     r = guestfs_lvm_remove_all (g);
6422     if (r == -1)
6423       return -1;
6424   }
6425   /* TestOutputListOfDevices for pvremove (0) */
6426   {
6427     char device[] = "/dev/sda";
6428     char lines_0[] = ",";
6429     char *lines[] = {
6430       lines_0,
6431       NULL
6432     };
6433     int r;
6434     suppress_error = 0;
6435     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6436     if (r == -1)
6437       return -1;
6438   }
6439   {
6440     char device[] = "/dev/sda1";
6441     int r;
6442     suppress_error = 0;
6443     r = guestfs_pvcreate (g, device);
6444     if (r == -1)
6445       return -1;
6446   }
6447   {
6448     char volgroup[] = "VG";
6449     char physvols_0[] = "/dev/sda1";
6450     char *physvols[] = {
6451       physvols_0,
6452       NULL
6453     };
6454     int r;
6455     suppress_error = 0;
6456     r = guestfs_vgcreate (g, volgroup, physvols);
6457     if (r == -1)
6458       return -1;
6459   }
6460   {
6461     char logvol[] = "LV1";
6462     char volgroup[] = "VG";
6463     int r;
6464     suppress_error = 0;
6465     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6466     if (r == -1)
6467       return -1;
6468   }
6469   {
6470     char logvol[] = "LV2";
6471     char volgroup[] = "VG";
6472     int r;
6473     suppress_error = 0;
6474     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6475     if (r == -1)
6476       return -1;
6477   }
6478   {
6479     char vgname[] = "VG";
6480     int r;
6481     suppress_error = 0;
6482     r = guestfs_vgremove (g, vgname);
6483     if (r == -1)
6484       return -1;
6485   }
6486   {
6487     char device[] = "/dev/sda1";
6488     int r;
6489     suppress_error = 0;
6490     r = guestfs_pvremove (g, device);
6491     if (r == -1)
6492       return -1;
6493   }
6494   {
6495     char **r;
6496     int i;
6497     suppress_error = 0;
6498     r = guestfs_lvs (g);
6499     if (r == NULL)
6500       return -1;
6501     if (r[0] != NULL) {
6502       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6503       print_strings (r);
6504       return -1;
6505     }
6506     for (i = 0; r[i] != NULL; ++i)
6507       free (r[i]);
6508     free (r);
6509   }
6510   return 0;
6511 }
6512
6513 static int test_pvremove_1_skip (void)
6514 {
6515   const char *str;
6516
6517   str = getenv ("TEST_ONLY");
6518   if (str)
6519     return strstr (str, "pvremove") == NULL;
6520   str = getenv ("SKIP_TEST_PVREMOVE_1");
6521   if (str && strcmp (str, "1") == 0) return 1;
6522   str = getenv ("SKIP_TEST_PVREMOVE");
6523   if (str && strcmp (str, "1") == 0) return 1;
6524   return 0;
6525 }
6526
6527 static int test_pvremove_1 (void)
6528 {
6529   if (test_pvremove_1_skip ()) {
6530     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6531     return 0;
6532   }
6533
6534   /* InitNone|InitEmpty for test_pvremove_1 */
6535   {
6536     char device[] = "/dev/sda";
6537     int r;
6538     suppress_error = 0;
6539     r = guestfs_blockdev_setrw (g, device);
6540     if (r == -1)
6541       return -1;
6542   }
6543   {
6544     int r;
6545     suppress_error = 0;
6546     r = guestfs_umount_all (g);
6547     if (r == -1)
6548       return -1;
6549   }
6550   {
6551     int r;
6552     suppress_error = 0;
6553     r = guestfs_lvm_remove_all (g);
6554     if (r == -1)
6555       return -1;
6556   }
6557   /* TestOutputListOfDevices for pvremove (1) */
6558   {
6559     char device[] = "/dev/sda";
6560     char lines_0[] = ",";
6561     char *lines[] = {
6562       lines_0,
6563       NULL
6564     };
6565     int r;
6566     suppress_error = 0;
6567     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6568     if (r == -1)
6569       return -1;
6570   }
6571   {
6572     char device[] = "/dev/sda1";
6573     int r;
6574     suppress_error = 0;
6575     r = guestfs_pvcreate (g, device);
6576     if (r == -1)
6577       return -1;
6578   }
6579   {
6580     char volgroup[] = "VG";
6581     char physvols_0[] = "/dev/sda1";
6582     char *physvols[] = {
6583       physvols_0,
6584       NULL
6585     };
6586     int r;
6587     suppress_error = 0;
6588     r = guestfs_vgcreate (g, volgroup, physvols);
6589     if (r == -1)
6590       return -1;
6591   }
6592   {
6593     char logvol[] = "LV1";
6594     char volgroup[] = "VG";
6595     int r;
6596     suppress_error = 0;
6597     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6598     if (r == -1)
6599       return -1;
6600   }
6601   {
6602     char logvol[] = "LV2";
6603     char volgroup[] = "VG";
6604     int r;
6605     suppress_error = 0;
6606     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6607     if (r == -1)
6608       return -1;
6609   }
6610   {
6611     char vgname[] = "VG";
6612     int r;
6613     suppress_error = 0;
6614     r = guestfs_vgremove (g, vgname);
6615     if (r == -1)
6616       return -1;
6617   }
6618   {
6619     char device[] = "/dev/sda1";
6620     int r;
6621     suppress_error = 0;
6622     r = guestfs_pvremove (g, device);
6623     if (r == -1)
6624       return -1;
6625   }
6626   {
6627     char **r;
6628     int i;
6629     suppress_error = 0;
6630     r = guestfs_vgs (g);
6631     if (r == NULL)
6632       return -1;
6633     if (r[0] != NULL) {
6634       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6635       print_strings (r);
6636       return -1;
6637     }
6638     for (i = 0; r[i] != NULL; ++i)
6639       free (r[i]);
6640     free (r);
6641   }
6642   return 0;
6643 }
6644
6645 static int test_pvremove_2_skip (void)
6646 {
6647   const char *str;
6648
6649   str = getenv ("TEST_ONLY");
6650   if (str)
6651     return strstr (str, "pvremove") == NULL;
6652   str = getenv ("SKIP_TEST_PVREMOVE_2");
6653   if (str && strcmp (str, "1") == 0) return 1;
6654   str = getenv ("SKIP_TEST_PVREMOVE");
6655   if (str && strcmp (str, "1") == 0) return 1;
6656   return 0;
6657 }
6658
6659 static int test_pvremove_2 (void)
6660 {
6661   if (test_pvremove_2_skip ()) {
6662     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6663     return 0;
6664   }
6665
6666   /* InitNone|InitEmpty for test_pvremove_2 */
6667   {
6668     char device[] = "/dev/sda";
6669     int r;
6670     suppress_error = 0;
6671     r = guestfs_blockdev_setrw (g, device);
6672     if (r == -1)
6673       return -1;
6674   }
6675   {
6676     int r;
6677     suppress_error = 0;
6678     r = guestfs_umount_all (g);
6679     if (r == -1)
6680       return -1;
6681   }
6682   {
6683     int r;
6684     suppress_error = 0;
6685     r = guestfs_lvm_remove_all (g);
6686     if (r == -1)
6687       return -1;
6688   }
6689   /* TestOutputListOfDevices for pvremove (2) */
6690   {
6691     char device[] = "/dev/sda";
6692     char lines_0[] = ",";
6693     char *lines[] = {
6694       lines_0,
6695       NULL
6696     };
6697     int r;
6698     suppress_error = 0;
6699     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6700     if (r == -1)
6701       return -1;
6702   }
6703   {
6704     char device[] = "/dev/sda1";
6705     int r;
6706     suppress_error = 0;
6707     r = guestfs_pvcreate (g, device);
6708     if (r == -1)
6709       return -1;
6710   }
6711   {
6712     char volgroup[] = "VG";
6713     char physvols_0[] = "/dev/sda1";
6714     char *physvols[] = {
6715       physvols_0,
6716       NULL
6717     };
6718     int r;
6719     suppress_error = 0;
6720     r = guestfs_vgcreate (g, volgroup, physvols);
6721     if (r == -1)
6722       return -1;
6723   }
6724   {
6725     char logvol[] = "LV1";
6726     char volgroup[] = "VG";
6727     int r;
6728     suppress_error = 0;
6729     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6730     if (r == -1)
6731       return -1;
6732   }
6733   {
6734     char logvol[] = "LV2";
6735     char volgroup[] = "VG";
6736     int r;
6737     suppress_error = 0;
6738     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6739     if (r == -1)
6740       return -1;
6741   }
6742   {
6743     char vgname[] = "VG";
6744     int r;
6745     suppress_error = 0;
6746     r = guestfs_vgremove (g, vgname);
6747     if (r == -1)
6748       return -1;
6749   }
6750   {
6751     char device[] = "/dev/sda1";
6752     int r;
6753     suppress_error = 0;
6754     r = guestfs_pvremove (g, device);
6755     if (r == -1)
6756       return -1;
6757   }
6758   {
6759     char **r;
6760     int i;
6761     suppress_error = 0;
6762     r = guestfs_pvs (g);
6763     if (r == NULL)
6764       return -1;
6765     if (r[0] != NULL) {
6766       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6767       print_strings (r);
6768       return -1;
6769     }
6770     for (i = 0; r[i] != NULL; ++i)
6771       free (r[i]);
6772     free (r);
6773   }
6774   return 0;
6775 }
6776
6777 static int test_vgremove_0_skip (void)
6778 {
6779   const char *str;
6780
6781   str = getenv ("TEST_ONLY");
6782   if (str)
6783     return strstr (str, "vgremove") == NULL;
6784   str = getenv ("SKIP_TEST_VGREMOVE_0");
6785   if (str && strcmp (str, "1") == 0) return 1;
6786   str = getenv ("SKIP_TEST_VGREMOVE");
6787   if (str && strcmp (str, "1") == 0) return 1;
6788   return 0;
6789 }
6790
6791 static int test_vgremove_0 (void)
6792 {
6793   if (test_vgremove_0_skip ()) {
6794     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6795     return 0;
6796   }
6797
6798   /* InitNone|InitEmpty for test_vgremove_0 */
6799   {
6800     char device[] = "/dev/sda";
6801     int r;
6802     suppress_error = 0;
6803     r = guestfs_blockdev_setrw (g, device);
6804     if (r == -1)
6805       return -1;
6806   }
6807   {
6808     int r;
6809     suppress_error = 0;
6810     r = guestfs_umount_all (g);
6811     if (r == -1)
6812       return -1;
6813   }
6814   {
6815     int r;
6816     suppress_error = 0;
6817     r = guestfs_lvm_remove_all (g);
6818     if (r == -1)
6819       return -1;
6820   }
6821   /* TestOutputList for vgremove (0) */
6822   {
6823     char device[] = "/dev/sda";
6824     char lines_0[] = ",";
6825     char *lines[] = {
6826       lines_0,
6827       NULL
6828     };
6829     int r;
6830     suppress_error = 0;
6831     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6832     if (r == -1)
6833       return -1;
6834   }
6835   {
6836     char device[] = "/dev/sda1";
6837     int r;
6838     suppress_error = 0;
6839     r = guestfs_pvcreate (g, device);
6840     if (r == -1)
6841       return -1;
6842   }
6843   {
6844     char volgroup[] = "VG";
6845     char physvols_0[] = "/dev/sda1";
6846     char *physvols[] = {
6847       physvols_0,
6848       NULL
6849     };
6850     int r;
6851     suppress_error = 0;
6852     r = guestfs_vgcreate (g, volgroup, physvols);
6853     if (r == -1)
6854       return -1;
6855   }
6856   {
6857     char logvol[] = "LV1";
6858     char volgroup[] = "VG";
6859     int r;
6860     suppress_error = 0;
6861     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6862     if (r == -1)
6863       return -1;
6864   }
6865   {
6866     char logvol[] = "LV2";
6867     char volgroup[] = "VG";
6868     int r;
6869     suppress_error = 0;
6870     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6871     if (r == -1)
6872       return -1;
6873   }
6874   {
6875     char vgname[] = "VG";
6876     int r;
6877     suppress_error = 0;
6878     r = guestfs_vgremove (g, vgname);
6879     if (r == -1)
6880       return -1;
6881   }
6882   {
6883     char **r;
6884     int i;
6885     suppress_error = 0;
6886     r = guestfs_lvs (g);
6887     if (r == NULL)
6888       return -1;
6889     if (r[0] != NULL) {
6890       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6891       print_strings (r);
6892       return -1;
6893     }
6894     for (i = 0; r[i] != NULL; ++i)
6895       free (r[i]);
6896     free (r);
6897   }
6898   return 0;
6899 }
6900
6901 static int test_vgremove_1_skip (void)
6902 {
6903   const char *str;
6904
6905   str = getenv ("TEST_ONLY");
6906   if (str)
6907     return strstr (str, "vgremove") == NULL;
6908   str = getenv ("SKIP_TEST_VGREMOVE_1");
6909   if (str && strcmp (str, "1") == 0) return 1;
6910   str = getenv ("SKIP_TEST_VGREMOVE");
6911   if (str && strcmp (str, "1") == 0) return 1;
6912   return 0;
6913 }
6914
6915 static int test_vgremove_1 (void)
6916 {
6917   if (test_vgremove_1_skip ()) {
6918     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6919     return 0;
6920   }
6921
6922   /* InitNone|InitEmpty for test_vgremove_1 */
6923   {
6924     char device[] = "/dev/sda";
6925     int r;
6926     suppress_error = 0;
6927     r = guestfs_blockdev_setrw (g, device);
6928     if (r == -1)
6929       return -1;
6930   }
6931   {
6932     int r;
6933     suppress_error = 0;
6934     r = guestfs_umount_all (g);
6935     if (r == -1)
6936       return -1;
6937   }
6938   {
6939     int r;
6940     suppress_error = 0;
6941     r = guestfs_lvm_remove_all (g);
6942     if (r == -1)
6943       return -1;
6944   }
6945   /* TestOutputList for vgremove (1) */
6946   {
6947     char device[] = "/dev/sda";
6948     char lines_0[] = ",";
6949     char *lines[] = {
6950       lines_0,
6951       NULL
6952     };
6953     int r;
6954     suppress_error = 0;
6955     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6956     if (r == -1)
6957       return -1;
6958   }
6959   {
6960     char device[] = "/dev/sda1";
6961     int r;
6962     suppress_error = 0;
6963     r = guestfs_pvcreate (g, device);
6964     if (r == -1)
6965       return -1;
6966   }
6967   {
6968     char volgroup[] = "VG";
6969     char physvols_0[] = "/dev/sda1";
6970     char *physvols[] = {
6971       physvols_0,
6972       NULL
6973     };
6974     int r;
6975     suppress_error = 0;
6976     r = guestfs_vgcreate (g, volgroup, physvols);
6977     if (r == -1)
6978       return -1;
6979   }
6980   {
6981     char logvol[] = "LV1";
6982     char volgroup[] = "VG";
6983     int r;
6984     suppress_error = 0;
6985     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6986     if (r == -1)
6987       return -1;
6988   }
6989   {
6990     char logvol[] = "LV2";
6991     char volgroup[] = "VG";
6992     int r;
6993     suppress_error = 0;
6994     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6995     if (r == -1)
6996       return -1;
6997   }
6998   {
6999     char vgname[] = "VG";
7000     int r;
7001     suppress_error = 0;
7002     r = guestfs_vgremove (g, vgname);
7003     if (r == -1)
7004       return -1;
7005   }
7006   {
7007     char **r;
7008     int i;
7009     suppress_error = 0;
7010     r = guestfs_vgs (g);
7011     if (r == NULL)
7012       return -1;
7013     if (r[0] != NULL) {
7014       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
7015       print_strings (r);
7016       return -1;
7017     }
7018     for (i = 0; r[i] != NULL; ++i)
7019       free (r[i]);
7020     free (r);
7021   }
7022   return 0;
7023 }
7024
7025 static int test_lvremove_0_skip (void)
7026 {
7027   const char *str;
7028
7029   str = getenv ("TEST_ONLY");
7030   if (str)
7031     return strstr (str, "lvremove") == NULL;
7032   str = getenv ("SKIP_TEST_LVREMOVE_0");
7033   if (str && strcmp (str, "1") == 0) return 1;
7034   str = getenv ("SKIP_TEST_LVREMOVE");
7035   if (str && strcmp (str, "1") == 0) return 1;
7036   return 0;
7037 }
7038
7039 static int test_lvremove_0 (void)
7040 {
7041   if (test_lvremove_0_skip ()) {
7042     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
7043     return 0;
7044   }
7045
7046   /* InitNone|InitEmpty for test_lvremove_0 */
7047   {
7048     char device[] = "/dev/sda";
7049     int r;
7050     suppress_error = 0;
7051     r = guestfs_blockdev_setrw (g, device);
7052     if (r == -1)
7053       return -1;
7054   }
7055   {
7056     int r;
7057     suppress_error = 0;
7058     r = guestfs_umount_all (g);
7059     if (r == -1)
7060       return -1;
7061   }
7062   {
7063     int r;
7064     suppress_error = 0;
7065     r = guestfs_lvm_remove_all (g);
7066     if (r == -1)
7067       return -1;
7068   }
7069   /* TestOutputList for lvremove (0) */
7070   {
7071     char device[] = "/dev/sda";
7072     char lines_0[] = ",";
7073     char *lines[] = {
7074       lines_0,
7075       NULL
7076     };
7077     int r;
7078     suppress_error = 0;
7079     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7080     if (r == -1)
7081       return -1;
7082   }
7083   {
7084     char device[] = "/dev/sda1";
7085     int r;
7086     suppress_error = 0;
7087     r = guestfs_pvcreate (g, device);
7088     if (r == -1)
7089       return -1;
7090   }
7091   {
7092     char volgroup[] = "VG";
7093     char physvols_0[] = "/dev/sda1";
7094     char *physvols[] = {
7095       physvols_0,
7096       NULL
7097     };
7098     int r;
7099     suppress_error = 0;
7100     r = guestfs_vgcreate (g, volgroup, physvols);
7101     if (r == -1)
7102       return -1;
7103   }
7104   {
7105     char logvol[] = "LV1";
7106     char volgroup[] = "VG";
7107     int r;
7108     suppress_error = 0;
7109     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7110     if (r == -1)
7111       return -1;
7112   }
7113   {
7114     char logvol[] = "LV2";
7115     char volgroup[] = "VG";
7116     int r;
7117     suppress_error = 0;
7118     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7119     if (r == -1)
7120       return -1;
7121   }
7122   {
7123     char device[] = "/dev/VG/LV1";
7124     int r;
7125     suppress_error = 0;
7126     r = guestfs_lvremove (g, device);
7127     if (r == -1)
7128       return -1;
7129   }
7130   {
7131     char **r;
7132     int i;
7133     suppress_error = 0;
7134     r = guestfs_lvs (g);
7135     if (r == NULL)
7136       return -1;
7137     if (!r[0]) {
7138       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
7139       print_strings (r);
7140       return -1;
7141     }
7142     {
7143       char expected[] = "/dev/VG/LV2";
7144       if (strcmp (r[0], expected) != 0) {
7145         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7146         return -1;
7147       }
7148     }
7149     if (r[1] != NULL) {
7150       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
7151       print_strings (r);
7152       return -1;
7153     }
7154     for (i = 0; r[i] != NULL; ++i)
7155       free (r[i]);
7156     free (r);
7157   }
7158   return 0;
7159 }
7160
7161 static int test_lvremove_1_skip (void)
7162 {
7163   const char *str;
7164
7165   str = getenv ("TEST_ONLY");
7166   if (str)
7167     return strstr (str, "lvremove") == NULL;
7168   str = getenv ("SKIP_TEST_LVREMOVE_1");
7169   if (str && strcmp (str, "1") == 0) return 1;
7170   str = getenv ("SKIP_TEST_LVREMOVE");
7171   if (str && strcmp (str, "1") == 0) return 1;
7172   return 0;
7173 }
7174
7175 static int test_lvremove_1 (void)
7176 {
7177   if (test_lvremove_1_skip ()) {
7178     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
7179     return 0;
7180   }
7181
7182   /* InitNone|InitEmpty for test_lvremove_1 */
7183   {
7184     char device[] = "/dev/sda";
7185     int r;
7186     suppress_error = 0;
7187     r = guestfs_blockdev_setrw (g, device);
7188     if (r == -1)
7189       return -1;
7190   }
7191   {
7192     int r;
7193     suppress_error = 0;
7194     r = guestfs_umount_all (g);
7195     if (r == -1)
7196       return -1;
7197   }
7198   {
7199     int r;
7200     suppress_error = 0;
7201     r = guestfs_lvm_remove_all (g);
7202     if (r == -1)
7203       return -1;
7204   }
7205   /* TestOutputList for lvremove (1) */
7206   {
7207     char device[] = "/dev/sda";
7208     char lines_0[] = ",";
7209     char *lines[] = {
7210       lines_0,
7211       NULL
7212     };
7213     int r;
7214     suppress_error = 0;
7215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7216     if (r == -1)
7217       return -1;
7218   }
7219   {
7220     char device[] = "/dev/sda1";
7221     int r;
7222     suppress_error = 0;
7223     r = guestfs_pvcreate (g, device);
7224     if (r == -1)
7225       return -1;
7226   }
7227   {
7228     char volgroup[] = "VG";
7229     char physvols_0[] = "/dev/sda1";
7230     char *physvols[] = {
7231       physvols_0,
7232       NULL
7233     };
7234     int r;
7235     suppress_error = 0;
7236     r = guestfs_vgcreate (g, volgroup, physvols);
7237     if (r == -1)
7238       return -1;
7239   }
7240   {
7241     char logvol[] = "LV1";
7242     char volgroup[] = "VG";
7243     int r;
7244     suppress_error = 0;
7245     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7246     if (r == -1)
7247       return -1;
7248   }
7249   {
7250     char logvol[] = "LV2";
7251     char volgroup[] = "VG";
7252     int r;
7253     suppress_error = 0;
7254     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7255     if (r == -1)
7256       return -1;
7257   }
7258   {
7259     char device[] = "/dev/VG";
7260     int r;
7261     suppress_error = 0;
7262     r = guestfs_lvremove (g, device);
7263     if (r == -1)
7264       return -1;
7265   }
7266   {
7267     char **r;
7268     int i;
7269     suppress_error = 0;
7270     r = guestfs_lvs (g);
7271     if (r == NULL)
7272       return -1;
7273     if (r[0] != NULL) {
7274       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7275       print_strings (r);
7276       return -1;
7277     }
7278     for (i = 0; r[i] != NULL; ++i)
7279       free (r[i]);
7280     free (r);
7281   }
7282   return 0;
7283 }
7284
7285 static int test_lvremove_2_skip (void)
7286 {
7287   const char *str;
7288
7289   str = getenv ("TEST_ONLY");
7290   if (str)
7291     return strstr (str, "lvremove") == NULL;
7292   str = getenv ("SKIP_TEST_LVREMOVE_2");
7293   if (str && strcmp (str, "1") == 0) return 1;
7294   str = getenv ("SKIP_TEST_LVREMOVE");
7295   if (str && strcmp (str, "1") == 0) return 1;
7296   return 0;
7297 }
7298
7299 static int test_lvremove_2 (void)
7300 {
7301   if (test_lvremove_2_skip ()) {
7302     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
7303     return 0;
7304   }
7305
7306   /* InitNone|InitEmpty for test_lvremove_2 */
7307   {
7308     char device[] = "/dev/sda";
7309     int r;
7310     suppress_error = 0;
7311     r = guestfs_blockdev_setrw (g, device);
7312     if (r == -1)
7313       return -1;
7314   }
7315   {
7316     int r;
7317     suppress_error = 0;
7318     r = guestfs_umount_all (g);
7319     if (r == -1)
7320       return -1;
7321   }
7322   {
7323     int r;
7324     suppress_error = 0;
7325     r = guestfs_lvm_remove_all (g);
7326     if (r == -1)
7327       return -1;
7328   }
7329   /* TestOutputList for lvremove (2) */
7330   {
7331     char device[] = "/dev/sda";
7332     char lines_0[] = ",";
7333     char *lines[] = {
7334       lines_0,
7335       NULL
7336     };
7337     int r;
7338     suppress_error = 0;
7339     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7340     if (r == -1)
7341       return -1;
7342   }
7343   {
7344     char device[] = "/dev/sda1";
7345     int r;
7346     suppress_error = 0;
7347     r = guestfs_pvcreate (g, device);
7348     if (r == -1)
7349       return -1;
7350   }
7351   {
7352     char volgroup[] = "VG";
7353     char physvols_0[] = "/dev/sda1";
7354     char *physvols[] = {
7355       physvols_0,
7356       NULL
7357     };
7358     int r;
7359     suppress_error = 0;
7360     r = guestfs_vgcreate (g, volgroup, physvols);
7361     if (r == -1)
7362       return -1;
7363   }
7364   {
7365     char logvol[] = "LV1";
7366     char volgroup[] = "VG";
7367     int r;
7368     suppress_error = 0;
7369     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7370     if (r == -1)
7371       return -1;
7372   }
7373   {
7374     char logvol[] = "LV2";
7375     char volgroup[] = "VG";
7376     int r;
7377     suppress_error = 0;
7378     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7379     if (r == -1)
7380       return -1;
7381   }
7382   {
7383     char device[] = "/dev/VG";
7384     int r;
7385     suppress_error = 0;
7386     r = guestfs_lvremove (g, device);
7387     if (r == -1)
7388       return -1;
7389   }
7390   {
7391     char **r;
7392     int i;
7393     suppress_error = 0;
7394     r = guestfs_vgs (g);
7395     if (r == NULL)
7396       return -1;
7397     if (!r[0]) {
7398       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7399       print_strings (r);
7400       return -1;
7401     }
7402     {
7403       char expected[] = "VG";
7404       if (strcmp (r[0], expected) != 0) {
7405         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7406         return -1;
7407       }
7408     }
7409     if (r[1] != NULL) {
7410       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7411       print_strings (r);
7412       return -1;
7413     }
7414     for (i = 0; r[i] != NULL; ++i)
7415       free (r[i]);
7416     free (r);
7417   }
7418   return 0;
7419 }
7420
7421 static int test_mount_ro_0_skip (void)
7422 {
7423   const char *str;
7424
7425   str = getenv ("TEST_ONLY");
7426   if (str)
7427     return strstr (str, "mount_ro") == NULL;
7428   str = getenv ("SKIP_TEST_MOUNT_RO_0");
7429   if (str && strcmp (str, "1") == 0) return 1;
7430   str = getenv ("SKIP_TEST_MOUNT_RO");
7431   if (str && strcmp (str, "1") == 0) return 1;
7432   return 0;
7433 }
7434
7435 static int test_mount_ro_0 (void)
7436 {
7437   if (test_mount_ro_0_skip ()) {
7438     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7439     return 0;
7440   }
7441
7442   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7443   {
7444     char device[] = "/dev/sda";
7445     int r;
7446     suppress_error = 0;
7447     r = guestfs_blockdev_setrw (g, device);
7448     if (r == -1)
7449       return -1;
7450   }
7451   {
7452     int r;
7453     suppress_error = 0;
7454     r = guestfs_umount_all (g);
7455     if (r == -1)
7456       return -1;
7457   }
7458   {
7459     int r;
7460     suppress_error = 0;
7461     r = guestfs_lvm_remove_all (g);
7462     if (r == -1)
7463       return -1;
7464   }
7465   {
7466     char device[] = "/dev/sda";
7467     char lines_0[] = ",";
7468     char *lines[] = {
7469       lines_0,
7470       NULL
7471     };
7472     int r;
7473     suppress_error = 0;
7474     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7475     if (r == -1)
7476       return -1;
7477   }
7478   {
7479     char fstype[] = "ext2";
7480     char device[] = "/dev/sda1";
7481     int r;
7482     suppress_error = 0;
7483     r = guestfs_mkfs (g, fstype, device);
7484     if (r == -1)
7485       return -1;
7486   }
7487   {
7488     char device[] = "/dev/sda1";
7489     char mountpoint[] = "/";
7490     int r;
7491     suppress_error = 0;
7492     r = guestfs_mount (g, device, mountpoint);
7493     if (r == -1)
7494       return -1;
7495   }
7496   /* TestLastFail for mount_ro (0) */
7497   {
7498     char pathordevice[] = "/";
7499     int r;
7500     suppress_error = 0;
7501     r = guestfs_umount (g, pathordevice);
7502     if (r == -1)
7503       return -1;
7504   }
7505   {
7506     char device[] = "/dev/sda1";
7507     char mountpoint[] = "/";
7508     int r;
7509     suppress_error = 0;
7510     r = guestfs_mount_ro (g, device, mountpoint);
7511     if (r == -1)
7512       return -1;
7513   }
7514   {
7515     char path[] = "/new";
7516     int r;
7517     suppress_error = 1;
7518     r = guestfs_touch (g, path);
7519     if (r != -1)
7520       return -1;
7521   }
7522   return 0;
7523 }
7524
7525 static int test_mount_ro_1_skip (void)
7526 {
7527   const char *str;
7528
7529   str = getenv ("TEST_ONLY");
7530   if (str)
7531     return strstr (str, "mount_ro") == NULL;
7532   str = getenv ("SKIP_TEST_MOUNT_RO_1");
7533   if (str && strcmp (str, "1") == 0) return 1;
7534   str = getenv ("SKIP_TEST_MOUNT_RO");
7535   if (str && strcmp (str, "1") == 0) return 1;
7536   return 0;
7537 }
7538
7539 static int test_mount_ro_1 (void)
7540 {
7541   if (test_mount_ro_1_skip ()) {
7542     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7543     return 0;
7544   }
7545
7546   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7547   {
7548     char device[] = "/dev/sda";
7549     int r;
7550     suppress_error = 0;
7551     r = guestfs_blockdev_setrw (g, device);
7552     if (r == -1)
7553       return -1;
7554   }
7555   {
7556     int r;
7557     suppress_error = 0;
7558     r = guestfs_umount_all (g);
7559     if (r == -1)
7560       return -1;
7561   }
7562   {
7563     int r;
7564     suppress_error = 0;
7565     r = guestfs_lvm_remove_all (g);
7566     if (r == -1)
7567       return -1;
7568   }
7569   {
7570     char device[] = "/dev/sda";
7571     char lines_0[] = ",";
7572     char *lines[] = {
7573       lines_0,
7574       NULL
7575     };
7576     int r;
7577     suppress_error = 0;
7578     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7579     if (r == -1)
7580       return -1;
7581   }
7582   {
7583     char fstype[] = "ext2";
7584     char device[] = "/dev/sda1";
7585     int r;
7586     suppress_error = 0;
7587     r = guestfs_mkfs (g, fstype, device);
7588     if (r == -1)
7589       return -1;
7590   }
7591   {
7592     char device[] = "/dev/sda1";
7593     char mountpoint[] = "/";
7594     int r;
7595     suppress_error = 0;
7596     r = guestfs_mount (g, device, mountpoint);
7597     if (r == -1)
7598       return -1;
7599   }
7600   /* TestOutput for mount_ro (1) */
7601   char expected[] = "data";
7602   {
7603     char path[] = "/new";
7604     char content[] = "data";
7605     int r;
7606     suppress_error = 0;
7607     r = guestfs_write_file (g, path, content, 0);
7608     if (r == -1)
7609       return -1;
7610   }
7611   {
7612     char pathordevice[] = "/";
7613     int r;
7614     suppress_error = 0;
7615     r = guestfs_umount (g, pathordevice);
7616     if (r == -1)
7617       return -1;
7618   }
7619   {
7620     char device[] = "/dev/sda1";
7621     char mountpoint[] = "/";
7622     int r;
7623     suppress_error = 0;
7624     r = guestfs_mount_ro (g, device, mountpoint);
7625     if (r == -1)
7626       return -1;
7627   }
7628   {
7629     char path[] = "/new";
7630     char *r;
7631     suppress_error = 0;
7632     r = guestfs_cat (g, path);
7633     if (r == NULL)
7634       return -1;
7635     if (strcmp (r, expected) != 0) {
7636       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7637       return -1;
7638     }
7639     free (r);
7640   }
7641   return 0;
7642 }
7643
7644 static int test_tgz_in_0_skip (void)
7645 {
7646   const char *str;
7647
7648   str = getenv ("TEST_ONLY");
7649   if (str)
7650     return strstr (str, "tgz_in") == NULL;
7651   str = getenv ("SKIP_TEST_TGZ_IN_0");
7652   if (str && strcmp (str, "1") == 0) return 1;
7653   str = getenv ("SKIP_TEST_TGZ_IN");
7654   if (str && strcmp (str, "1") == 0) return 1;
7655   return 0;
7656 }
7657
7658 static int test_tgz_in_0 (void)
7659 {
7660   if (test_tgz_in_0_skip ()) {
7661     printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7662     return 0;
7663   }
7664
7665   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7666   {
7667     char device[] = "/dev/sda";
7668     int r;
7669     suppress_error = 0;
7670     r = guestfs_blockdev_setrw (g, device);
7671     if (r == -1)
7672       return -1;
7673   }
7674   {
7675     int r;
7676     suppress_error = 0;
7677     r = guestfs_umount_all (g);
7678     if (r == -1)
7679       return -1;
7680   }
7681   {
7682     int r;
7683     suppress_error = 0;
7684     r = guestfs_lvm_remove_all (g);
7685     if (r == -1)
7686       return -1;
7687   }
7688   {
7689     char device[] = "/dev/sda";
7690     char lines_0[] = ",";
7691     char *lines[] = {
7692       lines_0,
7693       NULL
7694     };
7695     int r;
7696     suppress_error = 0;
7697     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7698     if (r == -1)
7699       return -1;
7700   }
7701   {
7702     char fstype[] = "ext2";
7703     char device[] = "/dev/sda1";
7704     int r;
7705     suppress_error = 0;
7706     r = guestfs_mkfs (g, fstype, device);
7707     if (r == -1)
7708       return -1;
7709   }
7710   {
7711     char device[] = "/dev/sda1";
7712     char mountpoint[] = "/";
7713     int r;
7714     suppress_error = 0;
7715     r = guestfs_mount (g, device, mountpoint);
7716     if (r == -1)
7717       return -1;
7718   }
7719   /* TestOutput for tgz_in (0) */
7720   char expected[] = "hello\n";
7721   {
7722     char directory[] = "/";
7723     int r;
7724     suppress_error = 0;
7725     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7726     if (r == -1)
7727       return -1;
7728   }
7729   {
7730     char path[] = "/hello";
7731     char *r;
7732     suppress_error = 0;
7733     r = guestfs_cat (g, path);
7734     if (r == NULL)
7735       return -1;
7736     if (strcmp (r, expected) != 0) {
7737       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7738       return -1;
7739     }
7740     free (r);
7741   }
7742   return 0;
7743 }
7744
7745 static int test_tar_in_0_skip (void)
7746 {
7747   const char *str;
7748
7749   str = getenv ("TEST_ONLY");
7750   if (str)
7751     return strstr (str, "tar_in") == NULL;
7752   str = getenv ("SKIP_TEST_TAR_IN_0");
7753   if (str && strcmp (str, "1") == 0) return 1;
7754   str = getenv ("SKIP_TEST_TAR_IN");
7755   if (str && strcmp (str, "1") == 0) return 1;
7756   return 0;
7757 }
7758
7759 static int test_tar_in_0 (void)
7760 {
7761   if (test_tar_in_0_skip ()) {
7762     printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7763     return 0;
7764   }
7765
7766   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7767   {
7768     char device[] = "/dev/sda";
7769     int r;
7770     suppress_error = 0;
7771     r = guestfs_blockdev_setrw (g, device);
7772     if (r == -1)
7773       return -1;
7774   }
7775   {
7776     int r;
7777     suppress_error = 0;
7778     r = guestfs_umount_all (g);
7779     if (r == -1)
7780       return -1;
7781   }
7782   {
7783     int r;
7784     suppress_error = 0;
7785     r = guestfs_lvm_remove_all (g);
7786     if (r == -1)
7787       return -1;
7788   }
7789   {
7790     char device[] = "/dev/sda";
7791     char lines_0[] = ",";
7792     char *lines[] = {
7793       lines_0,
7794       NULL
7795     };
7796     int r;
7797     suppress_error = 0;
7798     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7799     if (r == -1)
7800       return -1;
7801   }
7802   {
7803     char fstype[] = "ext2";
7804     char device[] = "/dev/sda1";
7805     int r;
7806     suppress_error = 0;
7807     r = guestfs_mkfs (g, fstype, device);
7808     if (r == -1)
7809       return -1;
7810   }
7811   {
7812     char device[] = "/dev/sda1";
7813     char mountpoint[] = "/";
7814     int r;
7815     suppress_error = 0;
7816     r = guestfs_mount (g, device, mountpoint);
7817     if (r == -1)
7818       return -1;
7819   }
7820   /* TestOutput for tar_in (0) */
7821   char expected[] = "hello\n";
7822   {
7823     char directory[] = "/";
7824     int r;
7825     suppress_error = 0;
7826     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7827     if (r == -1)
7828       return -1;
7829   }
7830   {
7831     char path[] = "/hello";
7832     char *r;
7833     suppress_error = 0;
7834     r = guestfs_cat (g, path);
7835     if (r == NULL)
7836       return -1;
7837     if (strcmp (r, expected) != 0) {
7838       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7839       return -1;
7840     }
7841     free (r);
7842   }
7843   return 0;
7844 }
7845
7846 static int test_checksum_0_skip (void)
7847 {
7848   const char *str;
7849
7850   str = getenv ("TEST_ONLY");
7851   if (str)
7852     return strstr (str, "checksum") == NULL;
7853   str = getenv ("SKIP_TEST_CHECKSUM_0");
7854   if (str && strcmp (str, "1") == 0) return 1;
7855   str = getenv ("SKIP_TEST_CHECKSUM");
7856   if (str && strcmp (str, "1") == 0) return 1;
7857   return 0;
7858 }
7859
7860 static int test_checksum_0 (void)
7861 {
7862   if (test_checksum_0_skip ()) {
7863     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7864     return 0;
7865   }
7866
7867   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7868   {
7869     char device[] = "/dev/sda";
7870     int r;
7871     suppress_error = 0;
7872     r = guestfs_blockdev_setrw (g, device);
7873     if (r == -1)
7874       return -1;
7875   }
7876   {
7877     int r;
7878     suppress_error = 0;
7879     r = guestfs_umount_all (g);
7880     if (r == -1)
7881       return -1;
7882   }
7883   {
7884     int r;
7885     suppress_error = 0;
7886     r = guestfs_lvm_remove_all (g);
7887     if (r == -1)
7888       return -1;
7889   }
7890   {
7891     char device[] = "/dev/sda";
7892     char lines_0[] = ",";
7893     char *lines[] = {
7894       lines_0,
7895       NULL
7896     };
7897     int r;
7898     suppress_error = 0;
7899     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7900     if (r == -1)
7901       return -1;
7902   }
7903   {
7904     char fstype[] = "ext2";
7905     char device[] = "/dev/sda1";
7906     int r;
7907     suppress_error = 0;
7908     r = guestfs_mkfs (g, fstype, device);
7909     if (r == -1)
7910       return -1;
7911   }
7912   {
7913     char device[] = "/dev/sda1";
7914     char mountpoint[] = "/";
7915     int r;
7916     suppress_error = 0;
7917     r = guestfs_mount (g, device, mountpoint);
7918     if (r == -1)
7919       return -1;
7920   }
7921   /* TestOutput for checksum (0) */
7922   char expected[] = "935282863";
7923   {
7924     char path[] = "/new";
7925     char content[] = "test\n";
7926     int r;
7927     suppress_error = 0;
7928     r = guestfs_write_file (g, path, content, 0);
7929     if (r == -1)
7930       return -1;
7931   }
7932   {
7933     char csumtype[] = "crc";
7934     char path[] = "/new";
7935     char *r;
7936     suppress_error = 0;
7937     r = guestfs_checksum (g, csumtype, path);
7938     if (r == NULL)
7939       return -1;
7940     if (strcmp (r, expected) != 0) {
7941       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7942       return -1;
7943     }
7944     free (r);
7945   }
7946   return 0;
7947 }
7948
7949 static int test_checksum_1_skip (void)
7950 {
7951   const char *str;
7952
7953   str = getenv ("TEST_ONLY");
7954   if (str)
7955     return strstr (str, "checksum") == NULL;
7956   str = getenv ("SKIP_TEST_CHECKSUM_1");
7957   if (str && strcmp (str, "1") == 0) return 1;
7958   str = getenv ("SKIP_TEST_CHECKSUM");
7959   if (str && strcmp (str, "1") == 0) return 1;
7960   return 0;
7961 }
7962
7963 static int test_checksum_1 (void)
7964 {
7965   if (test_checksum_1_skip ()) {
7966     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7967     return 0;
7968   }
7969
7970   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7971   {
7972     char device[] = "/dev/sda";
7973     int r;
7974     suppress_error = 0;
7975     r = guestfs_blockdev_setrw (g, device);
7976     if (r == -1)
7977       return -1;
7978   }
7979   {
7980     int r;
7981     suppress_error = 0;
7982     r = guestfs_umount_all (g);
7983     if (r == -1)
7984       return -1;
7985   }
7986   {
7987     int r;
7988     suppress_error = 0;
7989     r = guestfs_lvm_remove_all (g);
7990     if (r == -1)
7991       return -1;
7992   }
7993   {
7994     char device[] = "/dev/sda";
7995     char lines_0[] = ",";
7996     char *lines[] = {
7997       lines_0,
7998       NULL
7999     };
8000     int r;
8001     suppress_error = 0;
8002     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8003     if (r == -1)
8004       return -1;
8005   }
8006   {
8007     char fstype[] = "ext2";
8008     char device[] = "/dev/sda1";
8009     int r;
8010     suppress_error = 0;
8011     r = guestfs_mkfs (g, fstype, device);
8012     if (r == -1)
8013       return -1;
8014   }
8015   {
8016     char device[] = "/dev/sda1";
8017     char mountpoint[] = "/";
8018     int r;
8019     suppress_error = 0;
8020     r = guestfs_mount (g, device, mountpoint);
8021     if (r == -1)
8022       return -1;
8023   }
8024   /* TestLastFail for checksum (1) */
8025   {
8026     char csumtype[] = "crc";
8027     char path[] = "/new";
8028     char *r;
8029     suppress_error = 1;
8030     r = guestfs_checksum (g, csumtype, path);
8031     if (r != NULL)
8032       return -1;
8033     free (r);
8034   }
8035   return 0;
8036 }
8037
8038 static int test_checksum_2_skip (void)
8039 {
8040   const char *str;
8041
8042   str = getenv ("TEST_ONLY");
8043   if (str)
8044     return strstr (str, "checksum") == NULL;
8045   str = getenv ("SKIP_TEST_CHECKSUM_2");
8046   if (str && strcmp (str, "1") == 0) return 1;
8047   str = getenv ("SKIP_TEST_CHECKSUM");
8048   if (str && strcmp (str, "1") == 0) return 1;
8049   return 0;
8050 }
8051
8052 static int test_checksum_2 (void)
8053 {
8054   if (test_checksum_2_skip ()) {
8055     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
8056     return 0;
8057   }
8058
8059   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
8060   {
8061     char device[] = "/dev/sda";
8062     int r;
8063     suppress_error = 0;
8064     r = guestfs_blockdev_setrw (g, device);
8065     if (r == -1)
8066       return -1;
8067   }
8068   {
8069     int r;
8070     suppress_error = 0;
8071     r = guestfs_umount_all (g);
8072     if (r == -1)
8073       return -1;
8074   }
8075   {
8076     int r;
8077     suppress_error = 0;
8078     r = guestfs_lvm_remove_all (g);
8079     if (r == -1)
8080       return -1;
8081   }
8082   {
8083     char device[] = "/dev/sda";
8084     char lines_0[] = ",";
8085     char *lines[] = {
8086       lines_0,
8087       NULL
8088     };
8089     int r;
8090     suppress_error = 0;
8091     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8092     if (r == -1)
8093       return -1;
8094   }
8095   {
8096     char fstype[] = "ext2";
8097     char device[] = "/dev/sda1";
8098     int r;
8099     suppress_error = 0;
8100     r = guestfs_mkfs (g, fstype, device);
8101     if (r == -1)
8102       return -1;
8103   }
8104   {
8105     char device[] = "/dev/sda1";
8106     char mountpoint[] = "/";
8107     int r;
8108     suppress_error = 0;
8109     r = guestfs_mount (g, device, mountpoint);
8110     if (r == -1)
8111       return -1;
8112   }
8113   /* TestOutput for checksum (2) */
8114   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
8115   {
8116     char path[] = "/new";
8117     char content[] = "test\n";
8118     int r;
8119     suppress_error = 0;
8120     r = guestfs_write_file (g, path, content, 0);
8121     if (r == -1)
8122       return -1;
8123   }
8124   {
8125     char csumtype[] = "md5";
8126     char path[] = "/new";
8127     char *r;
8128     suppress_error = 0;
8129     r = guestfs_checksum (g, csumtype, path);
8130     if (r == NULL)
8131       return -1;
8132     if (strcmp (r, expected) != 0) {
8133       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
8134       return -1;
8135     }
8136     free (r);
8137   }
8138   return 0;
8139 }
8140
8141 static int test_checksum_3_skip (void)
8142 {
8143   const char *str;
8144
8145   str = getenv ("TEST_ONLY");
8146   if (str)
8147     return strstr (str, "checksum") == NULL;
8148   str = getenv ("SKIP_TEST_CHECKSUM_3");
8149   if (str && strcmp (str, "1") == 0) return 1;
8150   str = getenv ("SKIP_TEST_CHECKSUM");
8151   if (str && strcmp (str, "1") == 0) return 1;
8152   return 0;
8153 }
8154
8155 static int test_checksum_3 (void)
8156 {
8157   if (test_checksum_3_skip ()) {
8158     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
8159     return 0;
8160   }
8161
8162   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
8163   {
8164     char device[] = "/dev/sda";
8165     int r;
8166     suppress_error = 0;
8167     r = guestfs_blockdev_setrw (g, device);
8168     if (r == -1)
8169       return -1;
8170   }
8171   {
8172     int r;
8173     suppress_error = 0;
8174     r = guestfs_umount_all (g);
8175     if (r == -1)
8176       return -1;
8177   }
8178   {
8179     int r;
8180     suppress_error = 0;
8181     r = guestfs_lvm_remove_all (g);
8182     if (r == -1)
8183       return -1;
8184   }
8185   {
8186     char device[] = "/dev/sda";
8187     char lines_0[] = ",";
8188     char *lines[] = {
8189       lines_0,
8190       NULL
8191     };
8192     int r;
8193     suppress_error = 0;
8194     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8195     if (r == -1)
8196       return -1;
8197   }
8198   {
8199     char fstype[] = "ext2";
8200     char device[] = "/dev/sda1";
8201     int r;
8202     suppress_error = 0;
8203     r = guestfs_mkfs (g, fstype, device);
8204     if (r == -1)
8205       return -1;
8206   }
8207   {
8208     char device[] = "/dev/sda1";
8209     char mountpoint[] = "/";
8210     int r;
8211     suppress_error = 0;
8212     r = guestfs_mount (g, device, mountpoint);
8213     if (r == -1)
8214       return -1;
8215   }
8216   /* TestOutput for checksum (3) */
8217   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8218   {
8219     char path[] = "/new";
8220     char content[] = "test\n";
8221     int r;
8222     suppress_error = 0;
8223     r = guestfs_write_file (g, path, content, 0);
8224     if (r == -1)
8225       return -1;
8226   }
8227   {
8228     char csumtype[] = "sha1";
8229     char path[] = "/new";
8230     char *r;
8231     suppress_error = 0;
8232     r = guestfs_checksum (g, csumtype, path);
8233     if (r == NULL)
8234       return -1;
8235     if (strcmp (r, expected) != 0) {
8236       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8237       return -1;
8238     }
8239     free (r);
8240   }
8241   return 0;
8242 }
8243
8244 static int test_checksum_4_skip (void)
8245 {
8246   const char *str;
8247
8248   str = getenv ("TEST_ONLY");
8249   if (str)
8250     return strstr (str, "checksum") == NULL;
8251   str = getenv ("SKIP_TEST_CHECKSUM_4");
8252   if (str && strcmp (str, "1") == 0) return 1;
8253   str = getenv ("SKIP_TEST_CHECKSUM");
8254   if (str && strcmp (str, "1") == 0) return 1;
8255   return 0;
8256 }
8257
8258 static int test_checksum_4 (void)
8259 {
8260   if (test_checksum_4_skip ()) {
8261     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
8262     return 0;
8263   }
8264
8265   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8266   {
8267     char device[] = "/dev/sda";
8268     int r;
8269     suppress_error = 0;
8270     r = guestfs_blockdev_setrw (g, device);
8271     if (r == -1)
8272       return -1;
8273   }
8274   {
8275     int r;
8276     suppress_error = 0;
8277     r = guestfs_umount_all (g);
8278     if (r == -1)
8279       return -1;
8280   }
8281   {
8282     int r;
8283     suppress_error = 0;
8284     r = guestfs_lvm_remove_all (g);
8285     if (r == -1)
8286       return -1;
8287   }
8288   {
8289     char device[] = "/dev/sda";
8290     char lines_0[] = ",";
8291     char *lines[] = {
8292       lines_0,
8293       NULL
8294     };
8295     int r;
8296     suppress_error = 0;
8297     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8298     if (r == -1)
8299       return -1;
8300   }
8301   {
8302     char fstype[] = "ext2";
8303     char device[] = "/dev/sda1";
8304     int r;
8305     suppress_error = 0;
8306     r = guestfs_mkfs (g, fstype, device);
8307     if (r == -1)
8308       return -1;
8309   }
8310   {
8311     char device[] = "/dev/sda1";
8312     char mountpoint[] = "/";
8313     int r;
8314     suppress_error = 0;
8315     r = guestfs_mount (g, device, mountpoint);
8316     if (r == -1)
8317       return -1;
8318   }
8319   /* TestOutput for checksum (4) */
8320   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8321   {
8322     char path[] = "/new";
8323     char content[] = "test\n";
8324     int r;
8325     suppress_error = 0;
8326     r = guestfs_write_file (g, path, content, 0);
8327     if (r == -1)
8328       return -1;
8329   }
8330   {
8331     char csumtype[] = "sha224";
8332     char path[] = "/new";
8333     char *r;
8334     suppress_error = 0;
8335     r = guestfs_checksum (g, csumtype, path);
8336     if (r == NULL)
8337       return -1;
8338     if (strcmp (r, expected) != 0) {
8339       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8340       return -1;
8341     }
8342     free (r);
8343   }
8344   return 0;
8345 }
8346
8347 static int test_checksum_5_skip (void)
8348 {
8349   const char *str;
8350
8351   str = getenv ("TEST_ONLY");
8352   if (str)
8353     return strstr (str, "checksum") == NULL;
8354   str = getenv ("SKIP_TEST_CHECKSUM_5");
8355   if (str && strcmp (str, "1") == 0) return 1;
8356   str = getenv ("SKIP_TEST_CHECKSUM");
8357   if (str && strcmp (str, "1") == 0) return 1;
8358   return 0;
8359 }
8360
8361 static int test_checksum_5 (void)
8362 {
8363   if (test_checksum_5_skip ()) {
8364     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8365     return 0;
8366   }
8367
8368   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8369   {
8370     char device[] = "/dev/sda";
8371     int r;
8372     suppress_error = 0;
8373     r = guestfs_blockdev_setrw (g, device);
8374     if (r == -1)
8375       return -1;
8376   }
8377   {
8378     int r;
8379     suppress_error = 0;
8380     r = guestfs_umount_all (g);
8381     if (r == -1)
8382       return -1;
8383   }
8384   {
8385     int r;
8386     suppress_error = 0;
8387     r = guestfs_lvm_remove_all (g);
8388     if (r == -1)
8389       return -1;
8390   }
8391   {
8392     char device[] = "/dev/sda";
8393     char lines_0[] = ",";
8394     char *lines[] = {
8395       lines_0,
8396       NULL
8397     };
8398     int r;
8399     suppress_error = 0;
8400     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8401     if (r == -1)
8402       return -1;
8403   }
8404   {
8405     char fstype[] = "ext2";
8406     char device[] = "/dev/sda1";
8407     int r;
8408     suppress_error = 0;
8409     r = guestfs_mkfs (g, fstype, device);
8410     if (r == -1)
8411       return -1;
8412   }
8413   {
8414     char device[] = "/dev/sda1";
8415     char mountpoint[] = "/";
8416     int r;
8417     suppress_error = 0;
8418     r = guestfs_mount (g, device, mountpoint);
8419     if (r == -1)
8420       return -1;
8421   }
8422   /* TestOutput for checksum (5) */
8423   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8424   {
8425     char path[] = "/new";
8426     char content[] = "test\n";
8427     int r;
8428     suppress_error = 0;
8429     r = guestfs_write_file (g, path, content, 0);
8430     if (r == -1)
8431       return -1;
8432   }
8433   {
8434     char csumtype[] = "sha256";
8435     char path[] = "/new";
8436     char *r;
8437     suppress_error = 0;
8438     r = guestfs_checksum (g, csumtype, path);
8439     if (r == NULL)
8440       return -1;
8441     if (strcmp (r, expected) != 0) {
8442       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8443       return -1;
8444     }
8445     free (r);
8446   }
8447   return 0;
8448 }
8449
8450 static int test_checksum_6_skip (void)
8451 {
8452   const char *str;
8453
8454   str = getenv ("TEST_ONLY");
8455   if (str)
8456     return strstr (str, "checksum") == NULL;
8457   str = getenv ("SKIP_TEST_CHECKSUM_6");
8458   if (str && strcmp (str, "1") == 0) return 1;
8459   str = getenv ("SKIP_TEST_CHECKSUM");
8460   if (str && strcmp (str, "1") == 0) return 1;
8461   return 0;
8462 }
8463
8464 static int test_checksum_6 (void)
8465 {
8466   if (test_checksum_6_skip ()) {
8467     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8468     return 0;
8469   }
8470
8471   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8472   {
8473     char device[] = "/dev/sda";
8474     int r;
8475     suppress_error = 0;
8476     r = guestfs_blockdev_setrw (g, device);
8477     if (r == -1)
8478       return -1;
8479   }
8480   {
8481     int r;
8482     suppress_error = 0;
8483     r = guestfs_umount_all (g);
8484     if (r == -1)
8485       return -1;
8486   }
8487   {
8488     int r;
8489     suppress_error = 0;
8490     r = guestfs_lvm_remove_all (g);
8491     if (r == -1)
8492       return -1;
8493   }
8494   {
8495     char device[] = "/dev/sda";
8496     char lines_0[] = ",";
8497     char *lines[] = {
8498       lines_0,
8499       NULL
8500     };
8501     int r;
8502     suppress_error = 0;
8503     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8504     if (r == -1)
8505       return -1;
8506   }
8507   {
8508     char fstype[] = "ext2";
8509     char device[] = "/dev/sda1";
8510     int r;
8511     suppress_error = 0;
8512     r = guestfs_mkfs (g, fstype, device);
8513     if (r == -1)
8514       return -1;
8515   }
8516   {
8517     char device[] = "/dev/sda1";
8518     char mountpoint[] = "/";
8519     int r;
8520     suppress_error = 0;
8521     r = guestfs_mount (g, device, mountpoint);
8522     if (r == -1)
8523       return -1;
8524   }
8525   /* TestOutput for checksum (6) */
8526   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8527   {
8528     char path[] = "/new";
8529     char content[] = "test\n";
8530     int r;
8531     suppress_error = 0;
8532     r = guestfs_write_file (g, path, content, 0);
8533     if (r == -1)
8534       return -1;
8535   }
8536   {
8537     char csumtype[] = "sha384";
8538     char path[] = "/new";
8539     char *r;
8540     suppress_error = 0;
8541     r = guestfs_checksum (g, csumtype, path);
8542     if (r == NULL)
8543       return -1;
8544     if (strcmp (r, expected) != 0) {
8545       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8546       return -1;
8547     }
8548     free (r);
8549   }
8550   return 0;
8551 }
8552
8553 static int test_checksum_7_skip (void)
8554 {
8555   const char *str;
8556
8557   str = getenv ("TEST_ONLY");
8558   if (str)
8559     return strstr (str, "checksum") == NULL;
8560   str = getenv ("SKIP_TEST_CHECKSUM_7");
8561   if (str && strcmp (str, "1") == 0) return 1;
8562   str = getenv ("SKIP_TEST_CHECKSUM");
8563   if (str && strcmp (str, "1") == 0) return 1;
8564   return 0;
8565 }
8566
8567 static int test_checksum_7 (void)
8568 {
8569   if (test_checksum_7_skip ()) {
8570     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8571     return 0;
8572   }
8573
8574   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8575   {
8576     char device[] = "/dev/sda";
8577     int r;
8578     suppress_error = 0;
8579     r = guestfs_blockdev_setrw (g, device);
8580     if (r == -1)
8581       return -1;
8582   }
8583   {
8584     int r;
8585     suppress_error = 0;
8586     r = guestfs_umount_all (g);
8587     if (r == -1)
8588       return -1;
8589   }
8590   {
8591     int r;
8592     suppress_error = 0;
8593     r = guestfs_lvm_remove_all (g);
8594     if (r == -1)
8595       return -1;
8596   }
8597   {
8598     char device[] = "/dev/sda";
8599     char lines_0[] = ",";
8600     char *lines[] = {
8601       lines_0,
8602       NULL
8603     };
8604     int r;
8605     suppress_error = 0;
8606     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8607     if (r == -1)
8608       return -1;
8609   }
8610   {
8611     char fstype[] = "ext2";
8612     char device[] = "/dev/sda1";
8613     int r;
8614     suppress_error = 0;
8615     r = guestfs_mkfs (g, fstype, device);
8616     if (r == -1)
8617       return -1;
8618   }
8619   {
8620     char device[] = "/dev/sda1";
8621     char mountpoint[] = "/";
8622     int r;
8623     suppress_error = 0;
8624     r = guestfs_mount (g, device, mountpoint);
8625     if (r == -1)
8626       return -1;
8627   }
8628   /* TestOutput for checksum (7) */
8629   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8630   {
8631     char path[] = "/new";
8632     char content[] = "test\n";
8633     int r;
8634     suppress_error = 0;
8635     r = guestfs_write_file (g, path, content, 0);
8636     if (r == -1)
8637       return -1;
8638   }
8639   {
8640     char csumtype[] = "sha512";
8641     char path[] = "/new";
8642     char *r;
8643     suppress_error = 0;
8644     r = guestfs_checksum (g, csumtype, path);
8645     if (r == NULL)
8646       return -1;
8647     if (strcmp (r, expected) != 0) {
8648       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8649       return -1;
8650     }
8651     free (r);
8652   }
8653   return 0;
8654 }
8655
8656 static int test_checksum_8_skip (void)
8657 {
8658   const char *str;
8659
8660   str = getenv ("TEST_ONLY");
8661   if (str)
8662     return strstr (str, "checksum") == NULL;
8663   str = getenv ("SKIP_TEST_CHECKSUM_8");
8664   if (str && strcmp (str, "1") == 0) return 1;
8665   str = getenv ("SKIP_TEST_CHECKSUM");
8666   if (str && strcmp (str, "1") == 0) return 1;
8667   return 0;
8668 }
8669
8670 static int test_checksum_8 (void)
8671 {
8672   if (test_checksum_8_skip ()) {
8673     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8674     return 0;
8675   }
8676
8677   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8678   {
8679     char device[] = "/dev/sda";
8680     int r;
8681     suppress_error = 0;
8682     r = guestfs_blockdev_setrw (g, device);
8683     if (r == -1)
8684       return -1;
8685   }
8686   {
8687     int r;
8688     suppress_error = 0;
8689     r = guestfs_umount_all (g);
8690     if (r == -1)
8691       return -1;
8692   }
8693   {
8694     int r;
8695     suppress_error = 0;
8696     r = guestfs_lvm_remove_all (g);
8697     if (r == -1)
8698       return -1;
8699   }
8700   {
8701     char device[] = "/dev/sda";
8702     char lines_0[] = ",";
8703     char *lines[] = {
8704       lines_0,
8705       NULL
8706     };
8707     int r;
8708     suppress_error = 0;
8709     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8710     if (r == -1)
8711       return -1;
8712   }
8713   {
8714     char fstype[] = "ext2";
8715     char device[] = "/dev/sda1";
8716     int r;
8717     suppress_error = 0;
8718     r = guestfs_mkfs (g, fstype, device);
8719     if (r == -1)
8720       return -1;
8721   }
8722   {
8723     char device[] = "/dev/sda1";
8724     char mountpoint[] = "/";
8725     int r;
8726     suppress_error = 0;
8727     r = guestfs_mount (g, device, mountpoint);
8728     if (r == -1)
8729       return -1;
8730   }
8731   /* TestOutput for checksum (8) */
8732   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8733   {
8734     char options[] = "ro";
8735     char vfstype[] = "squashfs";
8736     char device[] = "/dev/sdd";
8737     char mountpoint[] = "/";
8738     int r;
8739     suppress_error = 0;
8740     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8741     if (r == -1)
8742       return -1;
8743   }
8744   {
8745     char csumtype[] = "md5";
8746     char path[] = "/known-3";
8747     char *r;
8748     suppress_error = 0;
8749     r = guestfs_checksum (g, csumtype, path);
8750     if (r == NULL)
8751       return -1;
8752     if (strcmp (r, expected) != 0) {
8753       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8754       return -1;
8755     }
8756     free (r);
8757   }
8758   return 0;
8759 }
8760
8761 static int test_download_0_skip (void)
8762 {
8763   const char *str;
8764
8765   str = getenv ("TEST_ONLY");
8766   if (str)
8767     return strstr (str, "download") == NULL;
8768   str = getenv ("SKIP_TEST_DOWNLOAD_0");
8769   if (str && strcmp (str, "1") == 0) return 1;
8770   str = getenv ("SKIP_TEST_DOWNLOAD");
8771   if (str && strcmp (str, "1") == 0) return 1;
8772   return 0;
8773 }
8774
8775 static int test_download_0 (void)
8776 {
8777   if (test_download_0_skip ()) {
8778     printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8779     return 0;
8780   }
8781
8782   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8783   {
8784     char device[] = "/dev/sda";
8785     int r;
8786     suppress_error = 0;
8787     r = guestfs_blockdev_setrw (g, device);
8788     if (r == -1)
8789       return -1;
8790   }
8791   {
8792     int r;
8793     suppress_error = 0;
8794     r = guestfs_umount_all (g);
8795     if (r == -1)
8796       return -1;
8797   }
8798   {
8799     int r;
8800     suppress_error = 0;
8801     r = guestfs_lvm_remove_all (g);
8802     if (r == -1)
8803       return -1;
8804   }
8805   {
8806     char device[] = "/dev/sda";
8807     char lines_0[] = ",";
8808     char *lines[] = {
8809       lines_0,
8810       NULL
8811     };
8812     int r;
8813     suppress_error = 0;
8814     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8815     if (r == -1)
8816       return -1;
8817   }
8818   {
8819     char fstype[] = "ext2";
8820     char device[] = "/dev/sda1";
8821     int r;
8822     suppress_error = 0;
8823     r = guestfs_mkfs (g, fstype, device);
8824     if (r == -1)
8825       return -1;
8826   }
8827   {
8828     char device[] = "/dev/sda1";
8829     char mountpoint[] = "/";
8830     int r;
8831     suppress_error = 0;
8832     r = guestfs_mount (g, device, mountpoint);
8833     if (r == -1)
8834       return -1;
8835   }
8836   /* TestOutput for download (0) */
8837   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8838   {
8839     char remotefilename[] = "/COPYING.LIB";
8840     int r;
8841     suppress_error = 0;
8842     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8843     if (r == -1)
8844       return -1;
8845   }
8846   {
8847     char remotefilename[] = "/COPYING.LIB";
8848     int r;
8849     suppress_error = 0;
8850     r = guestfs_download (g, remotefilename, "testdownload.tmp");
8851     if (r == -1)
8852       return -1;
8853   }
8854   {
8855     char remotefilename[] = "/upload";
8856     int r;
8857     suppress_error = 0;
8858     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8859     if (r == -1)
8860       return -1;
8861   }
8862   {
8863     char csumtype[] = "md5";
8864     char path[] = "/upload";
8865     char *r;
8866     suppress_error = 0;
8867     r = guestfs_checksum (g, csumtype, path);
8868     if (r == NULL)
8869       return -1;
8870     if (strcmp (r, expected) != 0) {
8871       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8872       return -1;
8873     }
8874     free (r);
8875   }
8876   return 0;
8877 }
8878
8879 static int test_upload_0_skip (void)
8880 {
8881   const char *str;
8882
8883   str = getenv ("TEST_ONLY");
8884   if (str)
8885     return strstr (str, "upload") == NULL;
8886   str = getenv ("SKIP_TEST_UPLOAD_0");
8887   if (str && strcmp (str, "1") == 0) return 1;
8888   str = getenv ("SKIP_TEST_UPLOAD");
8889   if (str && strcmp (str, "1") == 0) return 1;
8890   return 0;
8891 }
8892
8893 static int test_upload_0 (void)
8894 {
8895   if (test_upload_0_skip ()) {
8896     printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8897     return 0;
8898   }
8899
8900   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8901   {
8902     char device[] = "/dev/sda";
8903     int r;
8904     suppress_error = 0;
8905     r = guestfs_blockdev_setrw (g, device);
8906     if (r == -1)
8907       return -1;
8908   }
8909   {
8910     int r;
8911     suppress_error = 0;
8912     r = guestfs_umount_all (g);
8913     if (r == -1)
8914       return -1;
8915   }
8916   {
8917     int r;
8918     suppress_error = 0;
8919     r = guestfs_lvm_remove_all (g);
8920     if (r == -1)
8921       return -1;
8922   }
8923   {
8924     char device[] = "/dev/sda";
8925     char lines_0[] = ",";
8926     char *lines[] = {
8927       lines_0,
8928       NULL
8929     };
8930     int r;
8931     suppress_error = 0;
8932     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8933     if (r == -1)
8934       return -1;
8935   }
8936   {
8937     char fstype[] = "ext2";
8938     char device[] = "/dev/sda1";
8939     int r;
8940     suppress_error = 0;
8941     r = guestfs_mkfs (g, fstype, device);
8942     if (r == -1)
8943       return -1;
8944   }
8945   {
8946     char device[] = "/dev/sda1";
8947     char mountpoint[] = "/";
8948     int r;
8949     suppress_error = 0;
8950     r = guestfs_mount (g, device, mountpoint);
8951     if (r == -1)
8952       return -1;
8953   }
8954   /* TestOutput for upload (0) */
8955   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8956   {
8957     char remotefilename[] = "/COPYING.LIB";
8958     int r;
8959     suppress_error = 0;
8960     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8961     if (r == -1)
8962       return -1;
8963   }
8964   {
8965     char csumtype[] = "md5";
8966     char path[] = "/COPYING.LIB";
8967     char *r;
8968     suppress_error = 0;
8969     r = guestfs_checksum (g, csumtype, path);
8970     if (r == NULL)
8971       return -1;
8972     if (strcmp (r, expected) != 0) {
8973       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8974       return -1;
8975     }
8976     free (r);
8977   }
8978   return 0;
8979 }
8980
8981 static int test_blockdev_rereadpt_0_skip (void)
8982 {
8983   const char *str;
8984
8985   str = getenv ("TEST_ONLY");
8986   if (str)
8987     return strstr (str, "blockdev_rereadpt") == NULL;
8988   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8989   if (str && strcmp (str, "1") == 0) return 1;
8990   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8991   if (str && strcmp (str, "1") == 0) return 1;
8992   return 0;
8993 }
8994
8995 static int test_blockdev_rereadpt_0 (void)
8996 {
8997   if (test_blockdev_rereadpt_0_skip ()) {
8998     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8999     return 0;
9000   }
9001
9002   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
9003   {
9004     char device[] = "/dev/sda";
9005     int r;
9006     suppress_error = 0;
9007     r = guestfs_blockdev_setrw (g, device);
9008     if (r == -1)
9009       return -1;
9010   }
9011   {
9012     int r;
9013     suppress_error = 0;
9014     r = guestfs_umount_all (g);
9015     if (r == -1)
9016       return -1;
9017   }
9018   {
9019     int r;
9020     suppress_error = 0;
9021     r = guestfs_lvm_remove_all (g);
9022     if (r == -1)
9023       return -1;
9024   }
9025   /* TestRun for blockdev_rereadpt (0) */
9026   {
9027     char device[] = "/dev/sda";
9028     int r;
9029     suppress_error = 0;
9030     r = guestfs_blockdev_rereadpt (g, device);
9031     if (r == -1)
9032       return -1;
9033   }
9034   return 0;
9035 }
9036
9037 static int test_blockdev_flushbufs_0_skip (void)
9038 {
9039   const char *str;
9040
9041   str = getenv ("TEST_ONLY");
9042   if (str)
9043     return strstr (str, "blockdev_flushbufs") == NULL;
9044   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
9045   if (str && strcmp (str, "1") == 0) return 1;
9046   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
9047   if (str && strcmp (str, "1") == 0) return 1;
9048   return 0;
9049 }
9050
9051 static int test_blockdev_flushbufs_0 (void)
9052 {
9053   if (test_blockdev_flushbufs_0_skip ()) {
9054     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
9055     return 0;
9056   }
9057
9058   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
9059   {
9060     char device[] = "/dev/sda";
9061     int r;
9062     suppress_error = 0;
9063     r = guestfs_blockdev_setrw (g, device);
9064     if (r == -1)
9065       return -1;
9066   }
9067   {
9068     int r;
9069     suppress_error = 0;
9070     r = guestfs_umount_all (g);
9071     if (r == -1)
9072       return -1;
9073   }
9074   {
9075     int r;
9076     suppress_error = 0;
9077     r = guestfs_lvm_remove_all (g);
9078     if (r == -1)
9079       return -1;
9080   }
9081   /* TestRun for blockdev_flushbufs (0) */
9082   {
9083     char device[] = "/dev/sda";
9084     int r;
9085     suppress_error = 0;
9086     r = guestfs_blockdev_flushbufs (g, device);
9087     if (r == -1)
9088       return -1;
9089   }
9090   return 0;
9091 }
9092
9093 static int test_blockdev_getsize64_0_skip (void)
9094 {
9095   const char *str;
9096
9097   str = getenv ("TEST_ONLY");
9098   if (str)
9099     return strstr (str, "blockdev_getsize64") == NULL;
9100   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
9101   if (str && strcmp (str, "1") == 0) return 1;
9102   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
9103   if (str && strcmp (str, "1") == 0) return 1;
9104   return 0;
9105 }
9106
9107 static int test_blockdev_getsize64_0 (void)
9108 {
9109   if (test_blockdev_getsize64_0_skip ()) {
9110     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
9111     return 0;
9112   }
9113
9114   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
9115   {
9116     char device[] = "/dev/sda";
9117     int r;
9118     suppress_error = 0;
9119     r = guestfs_blockdev_setrw (g, device);
9120     if (r == -1)
9121       return -1;
9122   }
9123   {
9124     int r;
9125     suppress_error = 0;
9126     r = guestfs_umount_all (g);
9127     if (r == -1)
9128       return -1;
9129   }
9130   {
9131     int r;
9132     suppress_error = 0;
9133     r = guestfs_lvm_remove_all (g);
9134     if (r == -1)
9135       return -1;
9136   }
9137   /* TestOutputInt for blockdev_getsize64 (0) */
9138   {
9139     char device[] = "/dev/sda";
9140     int64_t r;
9141     suppress_error = 0;
9142     r = guestfs_blockdev_getsize64 (g, device);
9143     if (r == -1)
9144       return -1;
9145     if (r != 524288000) {
9146       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
9147       return -1;
9148     }
9149   }
9150   return 0;
9151 }
9152
9153 static int test_blockdev_getsz_0_skip (void)
9154 {
9155   const char *str;
9156
9157   str = getenv ("TEST_ONLY");
9158   if (str)
9159     return strstr (str, "blockdev_getsz") == NULL;
9160   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
9161   if (str && strcmp (str, "1") == 0) return 1;
9162   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
9163   if (str && strcmp (str, "1") == 0) return 1;
9164   return 0;
9165 }
9166
9167 static int test_blockdev_getsz_0 (void)
9168 {
9169   if (test_blockdev_getsz_0_skip ()) {
9170     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
9171     return 0;
9172   }
9173
9174   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
9175   {
9176     char device[] = "/dev/sda";
9177     int r;
9178     suppress_error = 0;
9179     r = guestfs_blockdev_setrw (g, device);
9180     if (r == -1)
9181       return -1;
9182   }
9183   {
9184     int r;
9185     suppress_error = 0;
9186     r = guestfs_umount_all (g);
9187     if (r == -1)
9188       return -1;
9189   }
9190   {
9191     int r;
9192     suppress_error = 0;
9193     r = guestfs_lvm_remove_all (g);
9194     if (r == -1)
9195       return -1;
9196   }
9197   /* TestOutputInt for blockdev_getsz (0) */
9198   {
9199     char device[] = "/dev/sda";
9200     int64_t r;
9201     suppress_error = 0;
9202     r = guestfs_blockdev_getsz (g, device);
9203     if (r == -1)
9204       return -1;
9205     if (r != 1024000) {
9206       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
9207       return -1;
9208     }
9209   }
9210   return 0;
9211 }
9212
9213 static int test_blockdev_getbsz_0_skip (void)
9214 {
9215   const char *str;
9216
9217   str = getenv ("TEST_ONLY");
9218   if (str)
9219     return strstr (str, "blockdev_getbsz") == NULL;
9220   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9221   if (str && strcmp (str, "1") == 0) return 1;
9222   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9223   if (str && strcmp (str, "1") == 0) return 1;
9224   return 0;
9225 }
9226
9227 static int test_blockdev_getbsz_0 (void)
9228 {
9229   if (test_blockdev_getbsz_0_skip ()) {
9230     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9231     return 0;
9232   }
9233
9234   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9235   {
9236     char device[] = "/dev/sda";
9237     int r;
9238     suppress_error = 0;
9239     r = guestfs_blockdev_setrw (g, device);
9240     if (r == -1)
9241       return -1;
9242   }
9243   {
9244     int r;
9245     suppress_error = 0;
9246     r = guestfs_umount_all (g);
9247     if (r == -1)
9248       return -1;
9249   }
9250   {
9251     int r;
9252     suppress_error = 0;
9253     r = guestfs_lvm_remove_all (g);
9254     if (r == -1)
9255       return -1;
9256   }
9257   /* TestOutputInt for blockdev_getbsz (0) */
9258   {
9259     char device[] = "/dev/sda";
9260     int r;
9261     suppress_error = 0;
9262     r = guestfs_blockdev_getbsz (g, device);
9263     if (r == -1)
9264       return -1;
9265     if (r != 4096) {
9266       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
9267       return -1;
9268     }
9269   }
9270   return 0;
9271 }
9272
9273 static int test_blockdev_getss_0_skip (void)
9274 {
9275   const char *str;
9276
9277   str = getenv ("TEST_ONLY");
9278   if (str)
9279     return strstr (str, "blockdev_getss") == NULL;
9280   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9281   if (str && strcmp (str, "1") == 0) return 1;
9282   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9283   if (str && strcmp (str, "1") == 0) return 1;
9284   return 0;
9285 }
9286
9287 static int test_blockdev_getss_0 (void)
9288 {
9289   if (test_blockdev_getss_0_skip ()) {
9290     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9291     return 0;
9292   }
9293
9294   /* InitNone|InitEmpty for test_blockdev_getss_0 */
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   /* TestOutputInt for blockdev_getss (0) */
9318   {
9319     char device[] = "/dev/sda";
9320     int r;
9321     suppress_error = 0;
9322     r = guestfs_blockdev_getss (g, device);
9323     if (r == -1)
9324       return -1;
9325     if (r != 512) {
9326       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
9327       return -1;
9328     }
9329   }
9330   return 0;
9331 }
9332
9333 static int test_blockdev_getro_0_skip (void)
9334 {
9335   const char *str;
9336
9337   str = getenv ("TEST_ONLY");
9338   if (str)
9339     return strstr (str, "blockdev_getro") == NULL;
9340   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9341   if (str && strcmp (str, "1") == 0) return 1;
9342   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9343   if (str && strcmp (str, "1") == 0) return 1;
9344   return 0;
9345 }
9346
9347 static int test_blockdev_getro_0 (void)
9348 {
9349   if (test_blockdev_getro_0_skip ()) {
9350     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9351     return 0;
9352   }
9353
9354   /* InitNone|InitEmpty for test_blockdev_getro_0 */
9355   {
9356     char device[] = "/dev/sda";
9357     int r;
9358     suppress_error = 0;
9359     r = guestfs_blockdev_setrw (g, device);
9360     if (r == -1)
9361       return -1;
9362   }
9363   {
9364     int r;
9365     suppress_error = 0;
9366     r = guestfs_umount_all (g);
9367     if (r == -1)
9368       return -1;
9369   }
9370   {
9371     int r;
9372     suppress_error = 0;
9373     r = guestfs_lvm_remove_all (g);
9374     if (r == -1)
9375       return -1;
9376   }
9377   /* TestOutputTrue for blockdev_getro (0) */
9378   {
9379     char device[] = "/dev/sda";
9380     int r;
9381     suppress_error = 0;
9382     r = guestfs_blockdev_setro (g, device);
9383     if (r == -1)
9384       return -1;
9385   }
9386   {
9387     char device[] = "/dev/sda";
9388     int r;
9389     suppress_error = 0;
9390     r = guestfs_blockdev_getro (g, device);
9391     if (r == -1)
9392       return -1;
9393     if (!r) {
9394       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9395       return -1;
9396     }
9397   }
9398   return 0;
9399 }
9400
9401 static int test_blockdev_setrw_0_skip (void)
9402 {
9403   const char *str;
9404
9405   str = getenv ("TEST_ONLY");
9406   if (str)
9407     return strstr (str, "blockdev_setrw") == NULL;
9408   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9409   if (str && strcmp (str, "1") == 0) return 1;
9410   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9411   if (str && strcmp (str, "1") == 0) return 1;
9412   return 0;
9413 }
9414
9415 static int test_blockdev_setrw_0 (void)
9416 {
9417   if (test_blockdev_setrw_0_skip ()) {
9418     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9419     return 0;
9420   }
9421
9422   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9423   {
9424     char device[] = "/dev/sda";
9425     int r;
9426     suppress_error = 0;
9427     r = guestfs_blockdev_setrw (g, device);
9428     if (r == -1)
9429       return -1;
9430   }
9431   {
9432     int r;
9433     suppress_error = 0;
9434     r = guestfs_umount_all (g);
9435     if (r == -1)
9436       return -1;
9437   }
9438   {
9439     int r;
9440     suppress_error = 0;
9441     r = guestfs_lvm_remove_all (g);
9442     if (r == -1)
9443       return -1;
9444   }
9445   /* TestOutputFalse for blockdev_setrw (0) */
9446   {
9447     char device[] = "/dev/sda";
9448     int r;
9449     suppress_error = 0;
9450     r = guestfs_blockdev_setrw (g, device);
9451     if (r == -1)
9452       return -1;
9453   }
9454   {
9455     char device[] = "/dev/sda";
9456     int r;
9457     suppress_error = 0;
9458     r = guestfs_blockdev_getro (g, device);
9459     if (r == -1)
9460       return -1;
9461     if (r) {
9462       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9463       return -1;
9464     }
9465   }
9466   return 0;
9467 }
9468
9469 static int test_blockdev_setro_0_skip (void)
9470 {
9471   const char *str;
9472
9473   str = getenv ("TEST_ONLY");
9474   if (str)
9475     return strstr (str, "blockdev_setro") == NULL;
9476   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9477   if (str && strcmp (str, "1") == 0) return 1;
9478   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9479   if (str && strcmp (str, "1") == 0) return 1;
9480   return 0;
9481 }
9482
9483 static int test_blockdev_setro_0 (void)
9484 {
9485   if (test_blockdev_setro_0_skip ()) {
9486     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9487     return 0;
9488   }
9489
9490   /* InitNone|InitEmpty for test_blockdev_setro_0 */
9491   {
9492     char device[] = "/dev/sda";
9493     int r;
9494     suppress_error = 0;
9495     r = guestfs_blockdev_setrw (g, device);
9496     if (r == -1)
9497       return -1;
9498   }
9499   {
9500     int r;
9501     suppress_error = 0;
9502     r = guestfs_umount_all (g);
9503     if (r == -1)
9504       return -1;
9505   }
9506   {
9507     int r;
9508     suppress_error = 0;
9509     r = guestfs_lvm_remove_all (g);
9510     if (r == -1)
9511       return -1;
9512   }
9513   /* TestOutputTrue for blockdev_setro (0) */
9514   {
9515     char device[] = "/dev/sda";
9516     int r;
9517     suppress_error = 0;
9518     r = guestfs_blockdev_setro (g, device);
9519     if (r == -1)
9520       return -1;
9521   }
9522   {
9523     char device[] = "/dev/sda";
9524     int r;
9525     suppress_error = 0;
9526     r = guestfs_blockdev_getro (g, device);
9527     if (r == -1)
9528       return -1;
9529     if (!r) {
9530       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9531       return -1;
9532     }
9533   }
9534   return 0;
9535 }
9536
9537 static int test_statvfs_0_skip (void)
9538 {
9539   const char *str;
9540
9541   str = getenv ("TEST_ONLY");
9542   if (str)
9543     return strstr (str, "statvfs") == NULL;
9544   str = getenv ("SKIP_TEST_STATVFS_0");
9545   if (str && strcmp (str, "1") == 0) return 1;
9546   str = getenv ("SKIP_TEST_STATVFS");
9547   if (str && strcmp (str, "1") == 0) return 1;
9548   return 0;
9549 }
9550
9551 static int test_statvfs_0 (void)
9552 {
9553   if (test_statvfs_0_skip ()) {
9554     printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9555     return 0;
9556   }
9557
9558   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9559   {
9560     char device[] = "/dev/sda";
9561     int r;
9562     suppress_error = 0;
9563     r = guestfs_blockdev_setrw (g, device);
9564     if (r == -1)
9565       return -1;
9566   }
9567   {
9568     int r;
9569     suppress_error = 0;
9570     r = guestfs_umount_all (g);
9571     if (r == -1)
9572       return -1;
9573   }
9574   {
9575     int r;
9576     suppress_error = 0;
9577     r = guestfs_lvm_remove_all (g);
9578     if (r == -1)
9579       return -1;
9580   }
9581   {
9582     char device[] = "/dev/sda";
9583     char lines_0[] = ",";
9584     char *lines[] = {
9585       lines_0,
9586       NULL
9587     };
9588     int r;
9589     suppress_error = 0;
9590     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9591     if (r == -1)
9592       return -1;
9593   }
9594   {
9595     char fstype[] = "ext2";
9596     char device[] = "/dev/sda1";
9597     int r;
9598     suppress_error = 0;
9599     r = guestfs_mkfs (g, fstype, device);
9600     if (r == -1)
9601       return -1;
9602   }
9603   {
9604     char device[] = "/dev/sda1";
9605     char mountpoint[] = "/";
9606     int r;
9607     suppress_error = 0;
9608     r = guestfs_mount (g, device, mountpoint);
9609     if (r == -1)
9610       return -1;
9611   }
9612   /* TestOutputStruct for statvfs (0) */
9613   {
9614     char path[] = "/";
9615     struct guestfs_statvfs *r;
9616     suppress_error = 0;
9617     r = guestfs_statvfs (g, path);
9618     if (r == NULL)
9619       return -1;
9620     if (r->bfree != 487702) {
9621       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9622                (int) r->bfree);
9623       return -1;
9624     }
9625     if (r->blocks != 490020) {
9626       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9627                (int) r->blocks);
9628       return -1;
9629     }
9630     if (r->bsize != 1024) {
9631       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9632                (int) r->bsize);
9633       return -1;
9634     }
9635     free (r);
9636   }
9637   return 0;
9638 }
9639
9640 static int test_lstat_0_skip (void)
9641 {
9642   const char *str;
9643
9644   str = getenv ("TEST_ONLY");
9645   if (str)
9646     return strstr (str, "lstat") == NULL;
9647   str = getenv ("SKIP_TEST_LSTAT_0");
9648   if (str && strcmp (str, "1") == 0) return 1;
9649   str = getenv ("SKIP_TEST_LSTAT");
9650   if (str && strcmp (str, "1") == 0) return 1;
9651   return 0;
9652 }
9653
9654 static int test_lstat_0 (void)
9655 {
9656   if (test_lstat_0_skip ()) {
9657     printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9658     return 0;
9659   }
9660
9661   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9662   {
9663     char device[] = "/dev/sda";
9664     int r;
9665     suppress_error = 0;
9666     r = guestfs_blockdev_setrw (g, device);
9667     if (r == -1)
9668       return -1;
9669   }
9670   {
9671     int r;
9672     suppress_error = 0;
9673     r = guestfs_umount_all (g);
9674     if (r == -1)
9675       return -1;
9676   }
9677   {
9678     int r;
9679     suppress_error = 0;
9680     r = guestfs_lvm_remove_all (g);
9681     if (r == -1)
9682       return -1;
9683   }
9684   {
9685     char device[] = "/dev/sda";
9686     char lines_0[] = ",";
9687     char *lines[] = {
9688       lines_0,
9689       NULL
9690     };
9691     int r;
9692     suppress_error = 0;
9693     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9694     if (r == -1)
9695       return -1;
9696   }
9697   {
9698     char fstype[] = "ext2";
9699     char device[] = "/dev/sda1";
9700     int r;
9701     suppress_error = 0;
9702     r = guestfs_mkfs (g, fstype, device);
9703     if (r == -1)
9704       return -1;
9705   }
9706   {
9707     char device[] = "/dev/sda1";
9708     char mountpoint[] = "/";
9709     int r;
9710     suppress_error = 0;
9711     r = guestfs_mount (g, device, mountpoint);
9712     if (r == -1)
9713       return -1;
9714   }
9715   /* TestOutputStruct for lstat (0) */
9716   {
9717     char path[] = "/new";
9718     int r;
9719     suppress_error = 0;
9720     r = guestfs_touch (g, path);
9721     if (r == -1)
9722       return -1;
9723   }
9724   {
9725     char path[] = "/new";
9726     struct guestfs_stat *r;
9727     suppress_error = 0;
9728     r = guestfs_lstat (g, path);
9729     if (r == NULL)
9730       return -1;
9731     if (r->size != 0) {
9732       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9733                (int) r->size);
9734       return -1;
9735     }
9736     free (r);
9737   }
9738   return 0;
9739 }
9740
9741 static int test_stat_0_skip (void)
9742 {
9743   const char *str;
9744
9745   str = getenv ("TEST_ONLY");
9746   if (str)
9747     return strstr (str, "stat") == NULL;
9748   str = getenv ("SKIP_TEST_STAT_0");
9749   if (str && strcmp (str, "1") == 0) return 1;
9750   str = getenv ("SKIP_TEST_STAT");
9751   if (str && strcmp (str, "1") == 0) return 1;
9752   return 0;
9753 }
9754
9755 static int test_stat_0 (void)
9756 {
9757   if (test_stat_0_skip ()) {
9758     printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9759     return 0;
9760   }
9761
9762   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9763   {
9764     char device[] = "/dev/sda";
9765     int r;
9766     suppress_error = 0;
9767     r = guestfs_blockdev_setrw (g, device);
9768     if (r == -1)
9769       return -1;
9770   }
9771   {
9772     int r;
9773     suppress_error = 0;
9774     r = guestfs_umount_all (g);
9775     if (r == -1)
9776       return -1;
9777   }
9778   {
9779     int r;
9780     suppress_error = 0;
9781     r = guestfs_lvm_remove_all (g);
9782     if (r == -1)
9783       return -1;
9784   }
9785   {
9786     char device[] = "/dev/sda";
9787     char lines_0[] = ",";
9788     char *lines[] = {
9789       lines_0,
9790       NULL
9791     };
9792     int r;
9793     suppress_error = 0;
9794     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9795     if (r == -1)
9796       return -1;
9797   }
9798   {
9799     char fstype[] = "ext2";
9800     char device[] = "/dev/sda1";
9801     int r;
9802     suppress_error = 0;
9803     r = guestfs_mkfs (g, fstype, device);
9804     if (r == -1)
9805       return -1;
9806   }
9807   {
9808     char device[] = "/dev/sda1";
9809     char mountpoint[] = "/";
9810     int r;
9811     suppress_error = 0;
9812     r = guestfs_mount (g, device, mountpoint);
9813     if (r == -1)
9814       return -1;
9815   }
9816   /* TestOutputStruct for stat (0) */
9817   {
9818     char path[] = "/new";
9819     int r;
9820     suppress_error = 0;
9821     r = guestfs_touch (g, path);
9822     if (r == -1)
9823       return -1;
9824   }
9825   {
9826     char path[] = "/new";
9827     struct guestfs_stat *r;
9828     suppress_error = 0;
9829     r = guestfs_stat (g, path);
9830     if (r == NULL)
9831       return -1;
9832     if (r->size != 0) {
9833       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9834                (int) r->size);
9835       return -1;
9836     }
9837     free (r);
9838   }
9839   return 0;
9840 }
9841
9842 static int test_command_lines_0_skip (void)
9843 {
9844   const char *str;
9845
9846   str = getenv ("TEST_ONLY");
9847   if (str)
9848     return strstr (str, "command_lines") == NULL;
9849   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9850   if (str && strcmp (str, "1") == 0) return 1;
9851   str = getenv ("SKIP_TEST_COMMAND_LINES");
9852   if (str && strcmp (str, "1") == 0) return 1;
9853   return 0;
9854 }
9855
9856 static int test_command_lines_0 (void)
9857 {
9858   if (test_command_lines_0_skip ()) {
9859     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9860     return 0;
9861   }
9862
9863   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9864   {
9865     char device[] = "/dev/sda";
9866     int r;
9867     suppress_error = 0;
9868     r = guestfs_blockdev_setrw (g, device);
9869     if (r == -1)
9870       return -1;
9871   }
9872   {
9873     int r;
9874     suppress_error = 0;
9875     r = guestfs_umount_all (g);
9876     if (r == -1)
9877       return -1;
9878   }
9879   {
9880     int r;
9881     suppress_error = 0;
9882     r = guestfs_lvm_remove_all (g);
9883     if (r == -1)
9884       return -1;
9885   }
9886   {
9887     char device[] = "/dev/sda";
9888     char lines_0[] = ",";
9889     char *lines[] = {
9890       lines_0,
9891       NULL
9892     };
9893     int r;
9894     suppress_error = 0;
9895     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9896     if (r == -1)
9897       return -1;
9898   }
9899   {
9900     char fstype[] = "ext2";
9901     char device[] = "/dev/sda1";
9902     int r;
9903     suppress_error = 0;
9904     r = guestfs_mkfs (g, fstype, device);
9905     if (r == -1)
9906       return -1;
9907   }
9908   {
9909     char device[] = "/dev/sda1";
9910     char mountpoint[] = "/";
9911     int r;
9912     suppress_error = 0;
9913     r = guestfs_mount (g, device, mountpoint);
9914     if (r == -1)
9915       return -1;
9916   }
9917   /* TestOutputList for command_lines (0) */
9918   {
9919     char remotefilename[] = "/test-command";
9920     int r;
9921     suppress_error = 0;
9922     r = guestfs_upload (g, "test-command", remotefilename);
9923     if (r == -1)
9924       return -1;
9925   }
9926   {
9927     char path[] = "/test-command";
9928     int r;
9929     suppress_error = 0;
9930     r = guestfs_chmod (g, 493, path);
9931     if (r == -1)
9932       return -1;
9933   }
9934   {
9935     char arguments_0[] = "/test-command";
9936     char arguments_1[] = "1";
9937     char *arguments[] = {
9938       arguments_0,
9939       arguments_1,
9940       NULL
9941     };
9942     char **r;
9943     int i;
9944     suppress_error = 0;
9945     r = guestfs_command_lines (g, arguments);
9946     if (r == NULL)
9947       return -1;
9948     if (!r[0]) {
9949       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9950       print_strings (r);
9951       return -1;
9952     }
9953     {
9954       char expected[] = "Result1";
9955       if (strcmp (r[0], expected) != 0) {
9956         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9957         return -1;
9958       }
9959     }
9960     if (r[1] != NULL) {
9961       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9962       print_strings (r);
9963       return -1;
9964     }
9965     for (i = 0; r[i] != NULL; ++i)
9966       free (r[i]);
9967     free (r);
9968   }
9969   return 0;
9970 }
9971
9972 static int test_command_lines_1_skip (void)
9973 {
9974   const char *str;
9975
9976   str = getenv ("TEST_ONLY");
9977   if (str)
9978     return strstr (str, "command_lines") == NULL;
9979   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9980   if (str && strcmp (str, "1") == 0) return 1;
9981   str = getenv ("SKIP_TEST_COMMAND_LINES");
9982   if (str && strcmp (str, "1") == 0) return 1;
9983   return 0;
9984 }
9985
9986 static int test_command_lines_1 (void)
9987 {
9988   if (test_command_lines_1_skip ()) {
9989     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9990     return 0;
9991   }
9992
9993   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9994   {
9995     char device[] = "/dev/sda";
9996     int r;
9997     suppress_error = 0;
9998     r = guestfs_blockdev_setrw (g, device);
9999     if (r == -1)
10000       return -1;
10001   }
10002   {
10003     int r;
10004     suppress_error = 0;
10005     r = guestfs_umount_all (g);
10006     if (r == -1)
10007       return -1;
10008   }
10009   {
10010     int r;
10011     suppress_error = 0;
10012     r = guestfs_lvm_remove_all (g);
10013     if (r == -1)
10014       return -1;
10015   }
10016   {
10017     char device[] = "/dev/sda";
10018     char lines_0[] = ",";
10019     char *lines[] = {
10020       lines_0,
10021       NULL
10022     };
10023     int r;
10024     suppress_error = 0;
10025     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10026     if (r == -1)
10027       return -1;
10028   }
10029   {
10030     char fstype[] = "ext2";
10031     char device[] = "/dev/sda1";
10032     int r;
10033     suppress_error = 0;
10034     r = guestfs_mkfs (g, fstype, device);
10035     if (r == -1)
10036       return -1;
10037   }
10038   {
10039     char device[] = "/dev/sda1";
10040     char mountpoint[] = "/";
10041     int r;
10042     suppress_error = 0;
10043     r = guestfs_mount (g, device, mountpoint);
10044     if (r == -1)
10045       return -1;
10046   }
10047   /* TestOutputList for command_lines (1) */
10048   {
10049     char remotefilename[] = "/test-command";
10050     int r;
10051     suppress_error = 0;
10052     r = guestfs_upload (g, "test-command", remotefilename);
10053     if (r == -1)
10054       return -1;
10055   }
10056   {
10057     char path[] = "/test-command";
10058     int r;
10059     suppress_error = 0;
10060     r = guestfs_chmod (g, 493, path);
10061     if (r == -1)
10062       return -1;
10063   }
10064   {
10065     char arguments_0[] = "/test-command";
10066     char arguments_1[] = "2";
10067     char *arguments[] = {
10068       arguments_0,
10069       arguments_1,
10070       NULL
10071     };
10072     char **r;
10073     int i;
10074     suppress_error = 0;
10075     r = guestfs_command_lines (g, arguments);
10076     if (r == NULL)
10077       return -1;
10078     if (!r[0]) {
10079       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
10080       print_strings (r);
10081       return -1;
10082     }
10083     {
10084       char expected[] = "Result2";
10085       if (strcmp (r[0], expected) != 0) {
10086         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10087         return -1;
10088       }
10089     }
10090     if (r[1] != NULL) {
10091       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
10092       print_strings (r);
10093       return -1;
10094     }
10095     for (i = 0; r[i] != NULL; ++i)
10096       free (r[i]);
10097     free (r);
10098   }
10099   return 0;
10100 }
10101
10102 static int test_command_lines_2_skip (void)
10103 {
10104   const char *str;
10105
10106   str = getenv ("TEST_ONLY");
10107   if (str)
10108     return strstr (str, "command_lines") == NULL;
10109   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
10110   if (str && strcmp (str, "1") == 0) return 1;
10111   str = getenv ("SKIP_TEST_COMMAND_LINES");
10112   if (str && strcmp (str, "1") == 0) return 1;
10113   return 0;
10114 }
10115
10116 static int test_command_lines_2 (void)
10117 {
10118   if (test_command_lines_2_skip ()) {
10119     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
10120     return 0;
10121   }
10122
10123   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
10124   {
10125     char device[] = "/dev/sda";
10126     int r;
10127     suppress_error = 0;
10128     r = guestfs_blockdev_setrw (g, device);
10129     if (r == -1)
10130       return -1;
10131   }
10132   {
10133     int r;
10134     suppress_error = 0;
10135     r = guestfs_umount_all (g);
10136     if (r == -1)
10137       return -1;
10138   }
10139   {
10140     int r;
10141     suppress_error = 0;
10142     r = guestfs_lvm_remove_all (g);
10143     if (r == -1)
10144       return -1;
10145   }
10146   {
10147     char device[] = "/dev/sda";
10148     char lines_0[] = ",";
10149     char *lines[] = {
10150       lines_0,
10151       NULL
10152     };
10153     int r;
10154     suppress_error = 0;
10155     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10156     if (r == -1)
10157       return -1;
10158   }
10159   {
10160     char fstype[] = "ext2";
10161     char device[] = "/dev/sda1";
10162     int r;
10163     suppress_error = 0;
10164     r = guestfs_mkfs (g, fstype, device);
10165     if (r == -1)
10166       return -1;
10167   }
10168   {
10169     char device[] = "/dev/sda1";
10170     char mountpoint[] = "/";
10171     int r;
10172     suppress_error = 0;
10173     r = guestfs_mount (g, device, mountpoint);
10174     if (r == -1)
10175       return -1;
10176   }
10177   /* TestOutputList for command_lines (2) */
10178   {
10179     char remotefilename[] = "/test-command";
10180     int r;
10181     suppress_error = 0;
10182     r = guestfs_upload (g, "test-command", remotefilename);
10183     if (r == -1)
10184       return -1;
10185   }
10186   {
10187     char path[] = "/test-command";
10188     int r;
10189     suppress_error = 0;
10190     r = guestfs_chmod (g, 493, path);
10191     if (r == -1)
10192       return -1;
10193   }
10194   {
10195     char arguments_0[] = "/test-command";
10196     char arguments_1[] = "3";
10197     char *arguments[] = {
10198       arguments_0,
10199       arguments_1,
10200       NULL
10201     };
10202     char **r;
10203     int i;
10204     suppress_error = 0;
10205     r = guestfs_command_lines (g, arguments);
10206     if (r == NULL)
10207       return -1;
10208     if (!r[0]) {
10209       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10210       print_strings (r);
10211       return -1;
10212     }
10213     {
10214       char expected[] = "";
10215       if (strcmp (r[0], expected) != 0) {
10216         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10217         return -1;
10218       }
10219     }
10220     if (!r[1]) {
10221       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10222       print_strings (r);
10223       return -1;
10224     }
10225     {
10226       char expected[] = "Result3";
10227       if (strcmp (r[1], expected) != 0) {
10228         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10229         return -1;
10230       }
10231     }
10232     if (r[2] != NULL) {
10233       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10234       print_strings (r);
10235       return -1;
10236     }
10237     for (i = 0; r[i] != NULL; ++i)
10238       free (r[i]);
10239     free (r);
10240   }
10241   return 0;
10242 }
10243
10244 static int test_command_lines_3_skip (void)
10245 {
10246   const char *str;
10247
10248   str = getenv ("TEST_ONLY");
10249   if (str)
10250     return strstr (str, "command_lines") == NULL;
10251   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10252   if (str && strcmp (str, "1") == 0) return 1;
10253   str = getenv ("SKIP_TEST_COMMAND_LINES");
10254   if (str && strcmp (str, "1") == 0) return 1;
10255   return 0;
10256 }
10257
10258 static int test_command_lines_3 (void)
10259 {
10260   if (test_command_lines_3_skip ()) {
10261     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
10262     return 0;
10263   }
10264
10265   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10266   {
10267     char device[] = "/dev/sda";
10268     int r;
10269     suppress_error = 0;
10270     r = guestfs_blockdev_setrw (g, device);
10271     if (r == -1)
10272       return -1;
10273   }
10274   {
10275     int r;
10276     suppress_error = 0;
10277     r = guestfs_umount_all (g);
10278     if (r == -1)
10279       return -1;
10280   }
10281   {
10282     int r;
10283     suppress_error = 0;
10284     r = guestfs_lvm_remove_all (g);
10285     if (r == -1)
10286       return -1;
10287   }
10288   {
10289     char device[] = "/dev/sda";
10290     char lines_0[] = ",";
10291     char *lines[] = {
10292       lines_0,
10293       NULL
10294     };
10295     int r;
10296     suppress_error = 0;
10297     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10298     if (r == -1)
10299       return -1;
10300   }
10301   {
10302     char fstype[] = "ext2";
10303     char device[] = "/dev/sda1";
10304     int r;
10305     suppress_error = 0;
10306     r = guestfs_mkfs (g, fstype, device);
10307     if (r == -1)
10308       return -1;
10309   }
10310   {
10311     char device[] = "/dev/sda1";
10312     char mountpoint[] = "/";
10313     int r;
10314     suppress_error = 0;
10315     r = guestfs_mount (g, device, mountpoint);
10316     if (r == -1)
10317       return -1;
10318   }
10319   /* TestOutputList for command_lines (3) */
10320   {
10321     char remotefilename[] = "/test-command";
10322     int r;
10323     suppress_error = 0;
10324     r = guestfs_upload (g, "test-command", remotefilename);
10325     if (r == -1)
10326       return -1;
10327   }
10328   {
10329     char path[] = "/test-command";
10330     int r;
10331     suppress_error = 0;
10332     r = guestfs_chmod (g, 493, path);
10333     if (r == -1)
10334       return -1;
10335   }
10336   {
10337     char arguments_0[] = "/test-command";
10338     char arguments_1[] = "4";
10339     char *arguments[] = {
10340       arguments_0,
10341       arguments_1,
10342       NULL
10343     };
10344     char **r;
10345     int i;
10346     suppress_error = 0;
10347     r = guestfs_command_lines (g, arguments);
10348     if (r == NULL)
10349       return -1;
10350     if (!r[0]) {
10351       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10352       print_strings (r);
10353       return -1;
10354     }
10355     {
10356       char expected[] = "";
10357       if (strcmp (r[0], expected) != 0) {
10358         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10359         return -1;
10360       }
10361     }
10362     if (!r[1]) {
10363       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10364       print_strings (r);
10365       return -1;
10366     }
10367     {
10368       char expected[] = "Result4";
10369       if (strcmp (r[1], expected) != 0) {
10370         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10371         return -1;
10372       }
10373     }
10374     if (r[2] != NULL) {
10375       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10376       print_strings (r);
10377       return -1;
10378     }
10379     for (i = 0; r[i] != NULL; ++i)
10380       free (r[i]);
10381     free (r);
10382   }
10383   return 0;
10384 }
10385
10386 static int test_command_lines_4_skip (void)
10387 {
10388   const char *str;
10389
10390   str = getenv ("TEST_ONLY");
10391   if (str)
10392     return strstr (str, "command_lines") == NULL;
10393   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10394   if (str && strcmp (str, "1") == 0) return 1;
10395   str = getenv ("SKIP_TEST_COMMAND_LINES");
10396   if (str && strcmp (str, "1") == 0) return 1;
10397   return 0;
10398 }
10399
10400 static int test_command_lines_4 (void)
10401 {
10402   if (test_command_lines_4_skip ()) {
10403     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10404     return 0;
10405   }
10406
10407   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10408   {
10409     char device[] = "/dev/sda";
10410     int r;
10411     suppress_error = 0;
10412     r = guestfs_blockdev_setrw (g, device);
10413     if (r == -1)
10414       return -1;
10415   }
10416   {
10417     int r;
10418     suppress_error = 0;
10419     r = guestfs_umount_all (g);
10420     if (r == -1)
10421       return -1;
10422   }
10423   {
10424     int r;
10425     suppress_error = 0;
10426     r = guestfs_lvm_remove_all (g);
10427     if (r == -1)
10428       return -1;
10429   }
10430   {
10431     char device[] = "/dev/sda";
10432     char lines_0[] = ",";
10433     char *lines[] = {
10434       lines_0,
10435       NULL
10436     };
10437     int r;
10438     suppress_error = 0;
10439     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10440     if (r == -1)
10441       return -1;
10442   }
10443   {
10444     char fstype[] = "ext2";
10445     char device[] = "/dev/sda1";
10446     int r;
10447     suppress_error = 0;
10448     r = guestfs_mkfs (g, fstype, device);
10449     if (r == -1)
10450       return -1;
10451   }
10452   {
10453     char device[] = "/dev/sda1";
10454     char mountpoint[] = "/";
10455     int r;
10456     suppress_error = 0;
10457     r = guestfs_mount (g, device, mountpoint);
10458     if (r == -1)
10459       return -1;
10460   }
10461   /* TestOutputList for command_lines (4) */
10462   {
10463     char remotefilename[] = "/test-command";
10464     int r;
10465     suppress_error = 0;
10466     r = guestfs_upload (g, "test-command", remotefilename);
10467     if (r == -1)
10468       return -1;
10469   }
10470   {
10471     char path[] = "/test-command";
10472     int r;
10473     suppress_error = 0;
10474     r = guestfs_chmod (g, 493, path);
10475     if (r == -1)
10476       return -1;
10477   }
10478   {
10479     char arguments_0[] = "/test-command";
10480     char arguments_1[] = "5";
10481     char *arguments[] = {
10482       arguments_0,
10483       arguments_1,
10484       NULL
10485     };
10486     char **r;
10487     int i;
10488     suppress_error = 0;
10489     r = guestfs_command_lines (g, arguments);
10490     if (r == NULL)
10491       return -1;
10492     if (!r[0]) {
10493       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10494       print_strings (r);
10495       return -1;
10496     }
10497     {
10498       char expected[] = "";
10499       if (strcmp (r[0], expected) != 0) {
10500         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10501         return -1;
10502       }
10503     }
10504     if (!r[1]) {
10505       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10506       print_strings (r);
10507       return -1;
10508     }
10509     {
10510       char expected[] = "Result5";
10511       if (strcmp (r[1], expected) != 0) {
10512         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10513         return -1;
10514       }
10515     }
10516     if (!r[2]) {
10517       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10518       print_strings (r);
10519       return -1;
10520     }
10521     {
10522       char expected[] = "";
10523       if (strcmp (r[2], expected) != 0) {
10524         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10525         return -1;
10526       }
10527     }
10528     if (r[3] != NULL) {
10529       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10530       print_strings (r);
10531       return -1;
10532     }
10533     for (i = 0; r[i] != NULL; ++i)
10534       free (r[i]);
10535     free (r);
10536   }
10537   return 0;
10538 }
10539
10540 static int test_command_lines_5_skip (void)
10541 {
10542   const char *str;
10543
10544   str = getenv ("TEST_ONLY");
10545   if (str)
10546     return strstr (str, "command_lines") == NULL;
10547   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10548   if (str && strcmp (str, "1") == 0) return 1;
10549   str = getenv ("SKIP_TEST_COMMAND_LINES");
10550   if (str && strcmp (str, "1") == 0) return 1;
10551   return 0;
10552 }
10553
10554 static int test_command_lines_5 (void)
10555 {
10556   if (test_command_lines_5_skip ()) {
10557     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10558     return 0;
10559   }
10560
10561   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10562   {
10563     char device[] = "/dev/sda";
10564     int r;
10565     suppress_error = 0;
10566     r = guestfs_blockdev_setrw (g, device);
10567     if (r == -1)
10568       return -1;
10569   }
10570   {
10571     int r;
10572     suppress_error = 0;
10573     r = guestfs_umount_all (g);
10574     if (r == -1)
10575       return -1;
10576   }
10577   {
10578     int r;
10579     suppress_error = 0;
10580     r = guestfs_lvm_remove_all (g);
10581     if (r == -1)
10582       return -1;
10583   }
10584   {
10585     char device[] = "/dev/sda";
10586     char lines_0[] = ",";
10587     char *lines[] = {
10588       lines_0,
10589       NULL
10590     };
10591     int r;
10592     suppress_error = 0;
10593     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10594     if (r == -1)
10595       return -1;
10596   }
10597   {
10598     char fstype[] = "ext2";
10599     char device[] = "/dev/sda1";
10600     int r;
10601     suppress_error = 0;
10602     r = guestfs_mkfs (g, fstype, device);
10603     if (r == -1)
10604       return -1;
10605   }
10606   {
10607     char device[] = "/dev/sda1";
10608     char mountpoint[] = "/";
10609     int r;
10610     suppress_error = 0;
10611     r = guestfs_mount (g, device, mountpoint);
10612     if (r == -1)
10613       return -1;
10614   }
10615   /* TestOutputList for command_lines (5) */
10616   {
10617     char remotefilename[] = "/test-command";
10618     int r;
10619     suppress_error = 0;
10620     r = guestfs_upload (g, "test-command", remotefilename);
10621     if (r == -1)
10622       return -1;
10623   }
10624   {
10625     char path[] = "/test-command";
10626     int r;
10627     suppress_error = 0;
10628     r = guestfs_chmod (g, 493, path);
10629     if (r == -1)
10630       return -1;
10631   }
10632   {
10633     char arguments_0[] = "/test-command";
10634     char arguments_1[] = "6";
10635     char *arguments[] = {
10636       arguments_0,
10637       arguments_1,
10638       NULL
10639     };
10640     char **r;
10641     int i;
10642     suppress_error = 0;
10643     r = guestfs_command_lines (g, arguments);
10644     if (r == NULL)
10645       return -1;
10646     if (!r[0]) {
10647       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10648       print_strings (r);
10649       return -1;
10650     }
10651     {
10652       char expected[] = "";
10653       if (strcmp (r[0], expected) != 0) {
10654         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10655         return -1;
10656       }
10657     }
10658     if (!r[1]) {
10659       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10660       print_strings (r);
10661       return -1;
10662     }
10663     {
10664       char expected[] = "";
10665       if (strcmp (r[1], expected) != 0) {
10666         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10667         return -1;
10668       }
10669     }
10670     if (!r[2]) {
10671       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10672       print_strings (r);
10673       return -1;
10674     }
10675     {
10676       char expected[] = "Result6";
10677       if (strcmp (r[2], expected) != 0) {
10678         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10679         return -1;
10680       }
10681     }
10682     if (!r[3]) {
10683       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10684       print_strings (r);
10685       return -1;
10686     }
10687     {
10688       char expected[] = "";
10689       if (strcmp (r[3], expected) != 0) {
10690         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10691         return -1;
10692       }
10693     }
10694     if (r[4] != NULL) {
10695       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10696       print_strings (r);
10697       return -1;
10698     }
10699     for (i = 0; r[i] != NULL; ++i)
10700       free (r[i]);
10701     free (r);
10702   }
10703   return 0;
10704 }
10705
10706 static int test_command_lines_6_skip (void)
10707 {
10708   const char *str;
10709
10710   str = getenv ("TEST_ONLY");
10711   if (str)
10712     return strstr (str, "command_lines") == NULL;
10713   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10714   if (str && strcmp (str, "1") == 0) return 1;
10715   str = getenv ("SKIP_TEST_COMMAND_LINES");
10716   if (str && strcmp (str, "1") == 0) return 1;
10717   return 0;
10718 }
10719
10720 static int test_command_lines_6 (void)
10721 {
10722   if (test_command_lines_6_skip ()) {
10723     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10724     return 0;
10725   }
10726
10727   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10728   {
10729     char device[] = "/dev/sda";
10730     int r;
10731     suppress_error = 0;
10732     r = guestfs_blockdev_setrw (g, device);
10733     if (r == -1)
10734       return -1;
10735   }
10736   {
10737     int r;
10738     suppress_error = 0;
10739     r = guestfs_umount_all (g);
10740     if (r == -1)
10741       return -1;
10742   }
10743   {
10744     int r;
10745     suppress_error = 0;
10746     r = guestfs_lvm_remove_all (g);
10747     if (r == -1)
10748       return -1;
10749   }
10750   {
10751     char device[] = "/dev/sda";
10752     char lines_0[] = ",";
10753     char *lines[] = {
10754       lines_0,
10755       NULL
10756     };
10757     int r;
10758     suppress_error = 0;
10759     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10760     if (r == -1)
10761       return -1;
10762   }
10763   {
10764     char fstype[] = "ext2";
10765     char device[] = "/dev/sda1";
10766     int r;
10767     suppress_error = 0;
10768     r = guestfs_mkfs (g, fstype, device);
10769     if (r == -1)
10770       return -1;
10771   }
10772   {
10773     char device[] = "/dev/sda1";
10774     char mountpoint[] = "/";
10775     int r;
10776     suppress_error = 0;
10777     r = guestfs_mount (g, device, mountpoint);
10778     if (r == -1)
10779       return -1;
10780   }
10781   /* TestOutputList for command_lines (6) */
10782   {
10783     char remotefilename[] = "/test-command";
10784     int r;
10785     suppress_error = 0;
10786     r = guestfs_upload (g, "test-command", remotefilename);
10787     if (r == -1)
10788       return -1;
10789   }
10790   {
10791     char path[] = "/test-command";
10792     int r;
10793     suppress_error = 0;
10794     r = guestfs_chmod (g, 493, path);
10795     if (r == -1)
10796       return -1;
10797   }
10798   {
10799     char arguments_0[] = "/test-command";
10800     char arguments_1[] = "7";
10801     char *arguments[] = {
10802       arguments_0,
10803       arguments_1,
10804       NULL
10805     };
10806     char **r;
10807     int i;
10808     suppress_error = 0;
10809     r = guestfs_command_lines (g, arguments);
10810     if (r == NULL)
10811       return -1;
10812     if (r[0] != NULL) {
10813       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10814       print_strings (r);
10815       return -1;
10816     }
10817     for (i = 0; r[i] != NULL; ++i)
10818       free (r[i]);
10819     free (r);
10820   }
10821   return 0;
10822 }
10823
10824 static int test_command_lines_7_skip (void)
10825 {
10826   const char *str;
10827
10828   str = getenv ("TEST_ONLY");
10829   if (str)
10830     return strstr (str, "command_lines") == NULL;
10831   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10832   if (str && strcmp (str, "1") == 0) return 1;
10833   str = getenv ("SKIP_TEST_COMMAND_LINES");
10834   if (str && strcmp (str, "1") == 0) return 1;
10835   return 0;
10836 }
10837
10838 static int test_command_lines_7 (void)
10839 {
10840   if (test_command_lines_7_skip ()) {
10841     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10842     return 0;
10843   }
10844
10845   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10846   {
10847     char device[] = "/dev/sda";
10848     int r;
10849     suppress_error = 0;
10850     r = guestfs_blockdev_setrw (g, device);
10851     if (r == -1)
10852       return -1;
10853   }
10854   {
10855     int r;
10856     suppress_error = 0;
10857     r = guestfs_umount_all (g);
10858     if (r == -1)
10859       return -1;
10860   }
10861   {
10862     int r;
10863     suppress_error = 0;
10864     r = guestfs_lvm_remove_all (g);
10865     if (r == -1)
10866       return -1;
10867   }
10868   {
10869     char device[] = "/dev/sda";
10870     char lines_0[] = ",";
10871     char *lines[] = {
10872       lines_0,
10873       NULL
10874     };
10875     int r;
10876     suppress_error = 0;
10877     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10878     if (r == -1)
10879       return -1;
10880   }
10881   {
10882     char fstype[] = "ext2";
10883     char device[] = "/dev/sda1";
10884     int r;
10885     suppress_error = 0;
10886     r = guestfs_mkfs (g, fstype, device);
10887     if (r == -1)
10888       return -1;
10889   }
10890   {
10891     char device[] = "/dev/sda1";
10892     char mountpoint[] = "/";
10893     int r;
10894     suppress_error = 0;
10895     r = guestfs_mount (g, device, mountpoint);
10896     if (r == -1)
10897       return -1;
10898   }
10899   /* TestOutputList for command_lines (7) */
10900   {
10901     char remotefilename[] = "/test-command";
10902     int r;
10903     suppress_error = 0;
10904     r = guestfs_upload (g, "test-command", remotefilename);
10905     if (r == -1)
10906       return -1;
10907   }
10908   {
10909     char path[] = "/test-command";
10910     int r;
10911     suppress_error = 0;
10912     r = guestfs_chmod (g, 493, path);
10913     if (r == -1)
10914       return -1;
10915   }
10916   {
10917     char arguments_0[] = "/test-command";
10918     char arguments_1[] = "8";
10919     char *arguments[] = {
10920       arguments_0,
10921       arguments_1,
10922       NULL
10923     };
10924     char **r;
10925     int i;
10926     suppress_error = 0;
10927     r = guestfs_command_lines (g, arguments);
10928     if (r == NULL)
10929       return -1;
10930     if (!r[0]) {
10931       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10932       print_strings (r);
10933       return -1;
10934     }
10935     {
10936       char expected[] = "";
10937       if (strcmp (r[0], expected) != 0) {
10938         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10939         return -1;
10940       }
10941     }
10942     if (r[1] != NULL) {
10943       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10944       print_strings (r);
10945       return -1;
10946     }
10947     for (i = 0; r[i] != NULL; ++i)
10948       free (r[i]);
10949     free (r);
10950   }
10951   return 0;
10952 }
10953
10954 static int test_command_lines_8_skip (void)
10955 {
10956   const char *str;
10957
10958   str = getenv ("TEST_ONLY");
10959   if (str)
10960     return strstr (str, "command_lines") == NULL;
10961   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10962   if (str && strcmp (str, "1") == 0) return 1;
10963   str = getenv ("SKIP_TEST_COMMAND_LINES");
10964   if (str && strcmp (str, "1") == 0) return 1;
10965   return 0;
10966 }
10967
10968 static int test_command_lines_8 (void)
10969 {
10970   if (test_command_lines_8_skip ()) {
10971     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10972     return 0;
10973   }
10974
10975   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10976   {
10977     char device[] = "/dev/sda";
10978     int r;
10979     suppress_error = 0;
10980     r = guestfs_blockdev_setrw (g, device);
10981     if (r == -1)
10982       return -1;
10983   }
10984   {
10985     int r;
10986     suppress_error = 0;
10987     r = guestfs_umount_all (g);
10988     if (r == -1)
10989       return -1;
10990   }
10991   {
10992     int r;
10993     suppress_error = 0;
10994     r = guestfs_lvm_remove_all (g);
10995     if (r == -1)
10996       return -1;
10997   }
10998   {
10999     char device[] = "/dev/sda";
11000     char lines_0[] = ",";
11001     char *lines[] = {
11002       lines_0,
11003       NULL
11004     };
11005     int r;
11006     suppress_error = 0;
11007     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11008     if (r == -1)
11009       return -1;
11010   }
11011   {
11012     char fstype[] = "ext2";
11013     char device[] = "/dev/sda1";
11014     int r;
11015     suppress_error = 0;
11016     r = guestfs_mkfs (g, fstype, device);
11017     if (r == -1)
11018       return -1;
11019   }
11020   {
11021     char device[] = "/dev/sda1";
11022     char mountpoint[] = "/";
11023     int r;
11024     suppress_error = 0;
11025     r = guestfs_mount (g, device, mountpoint);
11026     if (r == -1)
11027       return -1;
11028   }
11029   /* TestOutputList for command_lines (8) */
11030   {
11031     char remotefilename[] = "/test-command";
11032     int r;
11033     suppress_error = 0;
11034     r = guestfs_upload (g, "test-command", remotefilename);
11035     if (r == -1)
11036       return -1;
11037   }
11038   {
11039     char path[] = "/test-command";
11040     int r;
11041     suppress_error = 0;
11042     r = guestfs_chmod (g, 493, path);
11043     if (r == -1)
11044       return -1;
11045   }
11046   {
11047     char arguments_0[] = "/test-command";
11048     char arguments_1[] = "9";
11049     char *arguments[] = {
11050       arguments_0,
11051       arguments_1,
11052       NULL
11053     };
11054     char **r;
11055     int i;
11056     suppress_error = 0;
11057     r = guestfs_command_lines (g, arguments);
11058     if (r == NULL)
11059       return -1;
11060     if (!r[0]) {
11061       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11062       print_strings (r);
11063       return -1;
11064     }
11065     {
11066       char expected[] = "";
11067       if (strcmp (r[0], expected) != 0) {
11068         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11069         return -1;
11070       }
11071     }
11072     if (!r[1]) {
11073       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11074       print_strings (r);
11075       return -1;
11076     }
11077     {
11078       char expected[] = "";
11079       if (strcmp (r[1], expected) != 0) {
11080         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11081         return -1;
11082       }
11083     }
11084     if (r[2] != NULL) {
11085       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
11086       print_strings (r);
11087       return -1;
11088     }
11089     for (i = 0; r[i] != NULL; ++i)
11090       free (r[i]);
11091     free (r);
11092   }
11093   return 0;
11094 }
11095
11096 static int test_command_lines_9_skip (void)
11097 {
11098   const char *str;
11099
11100   str = getenv ("TEST_ONLY");
11101   if (str)
11102     return strstr (str, "command_lines") == NULL;
11103   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
11104   if (str && strcmp (str, "1") == 0) return 1;
11105   str = getenv ("SKIP_TEST_COMMAND_LINES");
11106   if (str && strcmp (str, "1") == 0) return 1;
11107   return 0;
11108 }
11109
11110 static int test_command_lines_9 (void)
11111 {
11112   if (test_command_lines_9_skip ()) {
11113     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
11114     return 0;
11115   }
11116
11117   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
11118   {
11119     char device[] = "/dev/sda";
11120     int r;
11121     suppress_error = 0;
11122     r = guestfs_blockdev_setrw (g, device);
11123     if (r == -1)
11124       return -1;
11125   }
11126   {
11127     int r;
11128     suppress_error = 0;
11129     r = guestfs_umount_all (g);
11130     if (r == -1)
11131       return -1;
11132   }
11133   {
11134     int r;
11135     suppress_error = 0;
11136     r = guestfs_lvm_remove_all (g);
11137     if (r == -1)
11138       return -1;
11139   }
11140   {
11141     char device[] = "/dev/sda";
11142     char lines_0[] = ",";
11143     char *lines[] = {
11144       lines_0,
11145       NULL
11146     };
11147     int r;
11148     suppress_error = 0;
11149     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11150     if (r == -1)
11151       return -1;
11152   }
11153   {
11154     char fstype[] = "ext2";
11155     char device[] = "/dev/sda1";
11156     int r;
11157     suppress_error = 0;
11158     r = guestfs_mkfs (g, fstype, device);
11159     if (r == -1)
11160       return -1;
11161   }
11162   {
11163     char device[] = "/dev/sda1";
11164     char mountpoint[] = "/";
11165     int r;
11166     suppress_error = 0;
11167     r = guestfs_mount (g, device, mountpoint);
11168     if (r == -1)
11169       return -1;
11170   }
11171   /* TestOutputList for command_lines (9) */
11172   {
11173     char remotefilename[] = "/test-command";
11174     int r;
11175     suppress_error = 0;
11176     r = guestfs_upload (g, "test-command", remotefilename);
11177     if (r == -1)
11178       return -1;
11179   }
11180   {
11181     char path[] = "/test-command";
11182     int r;
11183     suppress_error = 0;
11184     r = guestfs_chmod (g, 493, path);
11185     if (r == -1)
11186       return -1;
11187   }
11188   {
11189     char arguments_0[] = "/test-command";
11190     char arguments_1[] = "10";
11191     char *arguments[] = {
11192       arguments_0,
11193       arguments_1,
11194       NULL
11195     };
11196     char **r;
11197     int i;
11198     suppress_error = 0;
11199     r = guestfs_command_lines (g, arguments);
11200     if (r == NULL)
11201       return -1;
11202     if (!r[0]) {
11203       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11204       print_strings (r);
11205       return -1;
11206     }
11207     {
11208       char expected[] = "Result10-1";
11209       if (strcmp (r[0], expected) != 0) {
11210         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11211         return -1;
11212       }
11213     }
11214     if (!r[1]) {
11215       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11216       print_strings (r);
11217       return -1;
11218     }
11219     {
11220       char expected[] = "Result10-2";
11221       if (strcmp (r[1], expected) != 0) {
11222         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11223         return -1;
11224       }
11225     }
11226     if (r[2] != NULL) {
11227       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11228       print_strings (r);
11229       return -1;
11230     }
11231     for (i = 0; r[i] != NULL; ++i)
11232       free (r[i]);
11233     free (r);
11234   }
11235   return 0;
11236 }
11237
11238 static int test_command_lines_10_skip (void)
11239 {
11240   const char *str;
11241
11242   str = getenv ("TEST_ONLY");
11243   if (str)
11244     return strstr (str, "command_lines") == NULL;
11245   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11246   if (str && strcmp (str, "1") == 0) return 1;
11247   str = getenv ("SKIP_TEST_COMMAND_LINES");
11248   if (str && strcmp (str, "1") == 0) return 1;
11249   return 0;
11250 }
11251
11252 static int test_command_lines_10 (void)
11253 {
11254   if (test_command_lines_10_skip ()) {
11255     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
11256     return 0;
11257   }
11258
11259   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11260   {
11261     char device[] = "/dev/sda";
11262     int r;
11263     suppress_error = 0;
11264     r = guestfs_blockdev_setrw (g, device);
11265     if (r == -1)
11266       return -1;
11267   }
11268   {
11269     int r;
11270     suppress_error = 0;
11271     r = guestfs_umount_all (g);
11272     if (r == -1)
11273       return -1;
11274   }
11275   {
11276     int r;
11277     suppress_error = 0;
11278     r = guestfs_lvm_remove_all (g);
11279     if (r == -1)
11280       return -1;
11281   }
11282   {
11283     char device[] = "/dev/sda";
11284     char lines_0[] = ",";
11285     char *lines[] = {
11286       lines_0,
11287       NULL
11288     };
11289     int r;
11290     suppress_error = 0;
11291     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11292     if (r == -1)
11293       return -1;
11294   }
11295   {
11296     char fstype[] = "ext2";
11297     char device[] = "/dev/sda1";
11298     int r;
11299     suppress_error = 0;
11300     r = guestfs_mkfs (g, fstype, device);
11301     if (r == -1)
11302       return -1;
11303   }
11304   {
11305     char device[] = "/dev/sda1";
11306     char mountpoint[] = "/";
11307     int r;
11308     suppress_error = 0;
11309     r = guestfs_mount (g, device, mountpoint);
11310     if (r == -1)
11311       return -1;
11312   }
11313   /* TestOutputList for command_lines (10) */
11314   {
11315     char remotefilename[] = "/test-command";
11316     int r;
11317     suppress_error = 0;
11318     r = guestfs_upload (g, "test-command", remotefilename);
11319     if (r == -1)
11320       return -1;
11321   }
11322   {
11323     char path[] = "/test-command";
11324     int r;
11325     suppress_error = 0;
11326     r = guestfs_chmod (g, 493, path);
11327     if (r == -1)
11328       return -1;
11329   }
11330   {
11331     char arguments_0[] = "/test-command";
11332     char arguments_1[] = "11";
11333     char *arguments[] = {
11334       arguments_0,
11335       arguments_1,
11336       NULL
11337     };
11338     char **r;
11339     int i;
11340     suppress_error = 0;
11341     r = guestfs_command_lines (g, arguments);
11342     if (r == NULL)
11343       return -1;
11344     if (!r[0]) {
11345       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11346       print_strings (r);
11347       return -1;
11348     }
11349     {
11350       char expected[] = "Result11-1";
11351       if (strcmp (r[0], expected) != 0) {
11352         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11353         return -1;
11354       }
11355     }
11356     if (!r[1]) {
11357       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11358       print_strings (r);
11359       return -1;
11360     }
11361     {
11362       char expected[] = "Result11-2";
11363       if (strcmp (r[1], expected) != 0) {
11364         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11365         return -1;
11366       }
11367     }
11368     if (r[2] != NULL) {
11369       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11370       print_strings (r);
11371       return -1;
11372     }
11373     for (i = 0; r[i] != NULL; ++i)
11374       free (r[i]);
11375     free (r);
11376   }
11377   return 0;
11378 }
11379
11380 static int test_command_0_skip (void)
11381 {
11382   const char *str;
11383
11384   str = getenv ("TEST_ONLY");
11385   if (str)
11386     return strstr (str, "command") == NULL;
11387   str = getenv ("SKIP_TEST_COMMAND_0");
11388   if (str && strcmp (str, "1") == 0) return 1;
11389   str = getenv ("SKIP_TEST_COMMAND");
11390   if (str && strcmp (str, "1") == 0) return 1;
11391   return 0;
11392 }
11393
11394 static int test_command_0 (void)
11395 {
11396   if (test_command_0_skip ()) {
11397     printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11398     return 0;
11399   }
11400
11401   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11402   {
11403     char device[] = "/dev/sda";
11404     int r;
11405     suppress_error = 0;
11406     r = guestfs_blockdev_setrw (g, device);
11407     if (r == -1)
11408       return -1;
11409   }
11410   {
11411     int r;
11412     suppress_error = 0;
11413     r = guestfs_umount_all (g);
11414     if (r == -1)
11415       return -1;
11416   }
11417   {
11418     int r;
11419     suppress_error = 0;
11420     r = guestfs_lvm_remove_all (g);
11421     if (r == -1)
11422       return -1;
11423   }
11424   {
11425     char device[] = "/dev/sda";
11426     char lines_0[] = ",";
11427     char *lines[] = {
11428       lines_0,
11429       NULL
11430     };
11431     int r;
11432     suppress_error = 0;
11433     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11434     if (r == -1)
11435       return -1;
11436   }
11437   {
11438     char fstype[] = "ext2";
11439     char device[] = "/dev/sda1";
11440     int r;
11441     suppress_error = 0;
11442     r = guestfs_mkfs (g, fstype, device);
11443     if (r == -1)
11444       return -1;
11445   }
11446   {
11447     char device[] = "/dev/sda1";
11448     char mountpoint[] = "/";
11449     int r;
11450     suppress_error = 0;
11451     r = guestfs_mount (g, device, mountpoint);
11452     if (r == -1)
11453       return -1;
11454   }
11455   /* TestOutput for command (0) */
11456   char expected[] = "Result1";
11457   {
11458     char remotefilename[] = "/test-command";
11459     int r;
11460     suppress_error = 0;
11461     r = guestfs_upload (g, "test-command", remotefilename);
11462     if (r == -1)
11463       return -1;
11464   }
11465   {
11466     char path[] = "/test-command";
11467     int r;
11468     suppress_error = 0;
11469     r = guestfs_chmod (g, 493, path);
11470     if (r == -1)
11471       return -1;
11472   }
11473   {
11474     char arguments_0[] = "/test-command";
11475     char arguments_1[] = "1";
11476     char *arguments[] = {
11477       arguments_0,
11478       arguments_1,
11479       NULL
11480     };
11481     char *r;
11482     suppress_error = 0;
11483     r = guestfs_command (g, arguments);
11484     if (r == NULL)
11485       return -1;
11486     if (strcmp (r, expected) != 0) {
11487       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11488       return -1;
11489     }
11490     free (r);
11491   }
11492   return 0;
11493 }
11494
11495 static int test_command_1_skip (void)
11496 {
11497   const char *str;
11498
11499   str = getenv ("TEST_ONLY");
11500   if (str)
11501     return strstr (str, "command") == NULL;
11502   str = getenv ("SKIP_TEST_COMMAND_1");
11503   if (str && strcmp (str, "1") == 0) return 1;
11504   str = getenv ("SKIP_TEST_COMMAND");
11505   if (str && strcmp (str, "1") == 0) return 1;
11506   return 0;
11507 }
11508
11509 static int test_command_1 (void)
11510 {
11511   if (test_command_1_skip ()) {
11512     printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11513     return 0;
11514   }
11515
11516   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11517   {
11518     char device[] = "/dev/sda";
11519     int r;
11520     suppress_error = 0;
11521     r = guestfs_blockdev_setrw (g, device);
11522     if (r == -1)
11523       return -1;
11524   }
11525   {
11526     int r;
11527     suppress_error = 0;
11528     r = guestfs_umount_all (g);
11529     if (r == -1)
11530       return -1;
11531   }
11532   {
11533     int r;
11534     suppress_error = 0;
11535     r = guestfs_lvm_remove_all (g);
11536     if (r == -1)
11537       return -1;
11538   }
11539   {
11540     char device[] = "/dev/sda";
11541     char lines_0[] = ",";
11542     char *lines[] = {
11543       lines_0,
11544       NULL
11545     };
11546     int r;
11547     suppress_error = 0;
11548     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11549     if (r == -1)
11550       return -1;
11551   }
11552   {
11553     char fstype[] = "ext2";
11554     char device[] = "/dev/sda1";
11555     int r;
11556     suppress_error = 0;
11557     r = guestfs_mkfs (g, fstype, device);
11558     if (r == -1)
11559       return -1;
11560   }
11561   {
11562     char device[] = "/dev/sda1";
11563     char mountpoint[] = "/";
11564     int r;
11565     suppress_error = 0;
11566     r = guestfs_mount (g, device, mountpoint);
11567     if (r == -1)
11568       return -1;
11569   }
11570   /* TestOutput for command (1) */
11571   char expected[] = "Result2\n";
11572   {
11573     char remotefilename[] = "/test-command";
11574     int r;
11575     suppress_error = 0;
11576     r = guestfs_upload (g, "test-command", remotefilename);
11577     if (r == -1)
11578       return -1;
11579   }
11580   {
11581     char path[] = "/test-command";
11582     int r;
11583     suppress_error = 0;
11584     r = guestfs_chmod (g, 493, path);
11585     if (r == -1)
11586       return -1;
11587   }
11588   {
11589     char arguments_0[] = "/test-command";
11590     char arguments_1[] = "2";
11591     char *arguments[] = {
11592       arguments_0,
11593       arguments_1,
11594       NULL
11595     };
11596     char *r;
11597     suppress_error = 0;
11598     r = guestfs_command (g, arguments);
11599     if (r == NULL)
11600       return -1;
11601     if (strcmp (r, expected) != 0) {
11602       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11603       return -1;
11604     }
11605     free (r);
11606   }
11607   return 0;
11608 }
11609
11610 static int test_command_2_skip (void)
11611 {
11612   const char *str;
11613
11614   str = getenv ("TEST_ONLY");
11615   if (str)
11616     return strstr (str, "command") == NULL;
11617   str = getenv ("SKIP_TEST_COMMAND_2");
11618   if (str && strcmp (str, "1") == 0) return 1;
11619   str = getenv ("SKIP_TEST_COMMAND");
11620   if (str && strcmp (str, "1") == 0) return 1;
11621   return 0;
11622 }
11623
11624 static int test_command_2 (void)
11625 {
11626   if (test_command_2_skip ()) {
11627     printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11628     return 0;
11629   }
11630
11631   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11632   {
11633     char device[] = "/dev/sda";
11634     int r;
11635     suppress_error = 0;
11636     r = guestfs_blockdev_setrw (g, device);
11637     if (r == -1)
11638       return -1;
11639   }
11640   {
11641     int r;
11642     suppress_error = 0;
11643     r = guestfs_umount_all (g);
11644     if (r == -1)
11645       return -1;
11646   }
11647   {
11648     int r;
11649     suppress_error = 0;
11650     r = guestfs_lvm_remove_all (g);
11651     if (r == -1)
11652       return -1;
11653   }
11654   {
11655     char device[] = "/dev/sda";
11656     char lines_0[] = ",";
11657     char *lines[] = {
11658       lines_0,
11659       NULL
11660     };
11661     int r;
11662     suppress_error = 0;
11663     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11664     if (r == -1)
11665       return -1;
11666   }
11667   {
11668     char fstype[] = "ext2";
11669     char device[] = "/dev/sda1";
11670     int r;
11671     suppress_error = 0;
11672     r = guestfs_mkfs (g, fstype, device);
11673     if (r == -1)
11674       return -1;
11675   }
11676   {
11677     char device[] = "/dev/sda1";
11678     char mountpoint[] = "/";
11679     int r;
11680     suppress_error = 0;
11681     r = guestfs_mount (g, device, mountpoint);
11682     if (r == -1)
11683       return -1;
11684   }
11685   /* TestOutput for command (2) */
11686   char expected[] = "\nResult3";
11687   {
11688     char remotefilename[] = "/test-command";
11689     int r;
11690     suppress_error = 0;
11691     r = guestfs_upload (g, "test-command", remotefilename);
11692     if (r == -1)
11693       return -1;
11694   }
11695   {
11696     char path[] = "/test-command";
11697     int r;
11698     suppress_error = 0;
11699     r = guestfs_chmod (g, 493, path);
11700     if (r == -1)
11701       return -1;
11702   }
11703   {
11704     char arguments_0[] = "/test-command";
11705     char arguments_1[] = "3";
11706     char *arguments[] = {
11707       arguments_0,
11708       arguments_1,
11709       NULL
11710     };
11711     char *r;
11712     suppress_error = 0;
11713     r = guestfs_command (g, arguments);
11714     if (r == NULL)
11715       return -1;
11716     if (strcmp (r, expected) != 0) {
11717       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11718       return -1;
11719     }
11720     free (r);
11721   }
11722   return 0;
11723 }
11724
11725 static int test_command_3_skip (void)
11726 {
11727   const char *str;
11728
11729   str = getenv ("TEST_ONLY");
11730   if (str)
11731     return strstr (str, "command") == NULL;
11732   str = getenv ("SKIP_TEST_COMMAND_3");
11733   if (str && strcmp (str, "1") == 0) return 1;
11734   str = getenv ("SKIP_TEST_COMMAND");
11735   if (str && strcmp (str, "1") == 0) return 1;
11736   return 0;
11737 }
11738
11739 static int test_command_3 (void)
11740 {
11741   if (test_command_3_skip ()) {
11742     printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11743     return 0;
11744   }
11745
11746   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11747   {
11748     char device[] = "/dev/sda";
11749     int r;
11750     suppress_error = 0;
11751     r = guestfs_blockdev_setrw (g, device);
11752     if (r == -1)
11753       return -1;
11754   }
11755   {
11756     int r;
11757     suppress_error = 0;
11758     r = guestfs_umount_all (g);
11759     if (r == -1)
11760       return -1;
11761   }
11762   {
11763     int r;
11764     suppress_error = 0;
11765     r = guestfs_lvm_remove_all (g);
11766     if (r == -1)
11767       return -1;
11768   }
11769   {
11770     char device[] = "/dev/sda";
11771     char lines_0[] = ",";
11772     char *lines[] = {
11773       lines_0,
11774       NULL
11775     };
11776     int r;
11777     suppress_error = 0;
11778     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11779     if (r == -1)
11780       return -1;
11781   }
11782   {
11783     char fstype[] = "ext2";
11784     char device[] = "/dev/sda1";
11785     int r;
11786     suppress_error = 0;
11787     r = guestfs_mkfs (g, fstype, device);
11788     if (r == -1)
11789       return -1;
11790   }
11791   {
11792     char device[] = "/dev/sda1";
11793     char mountpoint[] = "/";
11794     int r;
11795     suppress_error = 0;
11796     r = guestfs_mount (g, device, mountpoint);
11797     if (r == -1)
11798       return -1;
11799   }
11800   /* TestOutput for command (3) */
11801   char expected[] = "\nResult4\n";
11802   {
11803     char remotefilename[] = "/test-command";
11804     int r;
11805     suppress_error = 0;
11806     r = guestfs_upload (g, "test-command", remotefilename);
11807     if (r == -1)
11808       return -1;
11809   }
11810   {
11811     char path[] = "/test-command";
11812     int r;
11813     suppress_error = 0;
11814     r = guestfs_chmod (g, 493, path);
11815     if (r == -1)
11816       return -1;
11817   }
11818   {
11819     char arguments_0[] = "/test-command";
11820     char arguments_1[] = "4";
11821     char *arguments[] = {
11822       arguments_0,
11823       arguments_1,
11824       NULL
11825     };
11826     char *r;
11827     suppress_error = 0;
11828     r = guestfs_command (g, arguments);
11829     if (r == NULL)
11830       return -1;
11831     if (strcmp (r, expected) != 0) {
11832       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11833       return -1;
11834     }
11835     free (r);
11836   }
11837   return 0;
11838 }
11839
11840 static int test_command_4_skip (void)
11841 {
11842   const char *str;
11843
11844   str = getenv ("TEST_ONLY");
11845   if (str)
11846     return strstr (str, "command") == NULL;
11847   str = getenv ("SKIP_TEST_COMMAND_4");
11848   if (str && strcmp (str, "1") == 0) return 1;
11849   str = getenv ("SKIP_TEST_COMMAND");
11850   if (str && strcmp (str, "1") == 0) return 1;
11851   return 0;
11852 }
11853
11854 static int test_command_4 (void)
11855 {
11856   if (test_command_4_skip ()) {
11857     printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11858     return 0;
11859   }
11860
11861   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11862   {
11863     char device[] = "/dev/sda";
11864     int r;
11865     suppress_error = 0;
11866     r = guestfs_blockdev_setrw (g, device);
11867     if (r == -1)
11868       return -1;
11869   }
11870   {
11871     int r;
11872     suppress_error = 0;
11873     r = guestfs_umount_all (g);
11874     if (r == -1)
11875       return -1;
11876   }
11877   {
11878     int r;
11879     suppress_error = 0;
11880     r = guestfs_lvm_remove_all (g);
11881     if (r == -1)
11882       return -1;
11883   }
11884   {
11885     char device[] = "/dev/sda";
11886     char lines_0[] = ",";
11887     char *lines[] = {
11888       lines_0,
11889       NULL
11890     };
11891     int r;
11892     suppress_error = 0;
11893     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11894     if (r == -1)
11895       return -1;
11896   }
11897   {
11898     char fstype[] = "ext2";
11899     char device[] = "/dev/sda1";
11900     int r;
11901     suppress_error = 0;
11902     r = guestfs_mkfs (g, fstype, device);
11903     if (r == -1)
11904       return -1;
11905   }
11906   {
11907     char device[] = "/dev/sda1";
11908     char mountpoint[] = "/";
11909     int r;
11910     suppress_error = 0;
11911     r = guestfs_mount (g, device, mountpoint);
11912     if (r == -1)
11913       return -1;
11914   }
11915   /* TestOutput for command (4) */
11916   char expected[] = "\nResult5\n\n";
11917   {
11918     char remotefilename[] = "/test-command";
11919     int r;
11920     suppress_error = 0;
11921     r = guestfs_upload (g, "test-command", remotefilename);
11922     if (r == -1)
11923       return -1;
11924   }
11925   {
11926     char path[] = "/test-command";
11927     int r;
11928     suppress_error = 0;
11929     r = guestfs_chmod (g, 493, path);
11930     if (r == -1)
11931       return -1;
11932   }
11933   {
11934     char arguments_0[] = "/test-command";
11935     char arguments_1[] = "5";
11936     char *arguments[] = {
11937       arguments_0,
11938       arguments_1,
11939       NULL
11940     };
11941     char *r;
11942     suppress_error = 0;
11943     r = guestfs_command (g, arguments);
11944     if (r == NULL)
11945       return -1;
11946     if (strcmp (r, expected) != 0) {
11947       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11948       return -1;
11949     }
11950     free (r);
11951   }
11952   return 0;
11953 }
11954
11955 static int test_command_5_skip (void)
11956 {
11957   const char *str;
11958
11959   str = getenv ("TEST_ONLY");
11960   if (str)
11961     return strstr (str, "command") == NULL;
11962   str = getenv ("SKIP_TEST_COMMAND_5");
11963   if (str && strcmp (str, "1") == 0) return 1;
11964   str = getenv ("SKIP_TEST_COMMAND");
11965   if (str && strcmp (str, "1") == 0) return 1;
11966   return 0;
11967 }
11968
11969 static int test_command_5 (void)
11970 {
11971   if (test_command_5_skip ()) {
11972     printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11973     return 0;
11974   }
11975
11976   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11977   {
11978     char device[] = "/dev/sda";
11979     int r;
11980     suppress_error = 0;
11981     r = guestfs_blockdev_setrw (g, device);
11982     if (r == -1)
11983       return -1;
11984   }
11985   {
11986     int r;
11987     suppress_error = 0;
11988     r = guestfs_umount_all (g);
11989     if (r == -1)
11990       return -1;
11991   }
11992   {
11993     int r;
11994     suppress_error = 0;
11995     r = guestfs_lvm_remove_all (g);
11996     if (r == -1)
11997       return -1;
11998   }
11999   {
12000     char device[] = "/dev/sda";
12001     char lines_0[] = ",";
12002     char *lines[] = {
12003       lines_0,
12004       NULL
12005     };
12006     int r;
12007     suppress_error = 0;
12008     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12009     if (r == -1)
12010       return -1;
12011   }
12012   {
12013     char fstype[] = "ext2";
12014     char device[] = "/dev/sda1";
12015     int r;
12016     suppress_error = 0;
12017     r = guestfs_mkfs (g, fstype, device);
12018     if (r == -1)
12019       return -1;
12020   }
12021   {
12022     char device[] = "/dev/sda1";
12023     char mountpoint[] = "/";
12024     int r;
12025     suppress_error = 0;
12026     r = guestfs_mount (g, device, mountpoint);
12027     if (r == -1)
12028       return -1;
12029   }
12030   /* TestOutput for command (5) */
12031   char expected[] = "\n\nResult6\n\n";
12032   {
12033     char remotefilename[] = "/test-command";
12034     int r;
12035     suppress_error = 0;
12036     r = guestfs_upload (g, "test-command", remotefilename);
12037     if (r == -1)
12038       return -1;
12039   }
12040   {
12041     char path[] = "/test-command";
12042     int r;
12043     suppress_error = 0;
12044     r = guestfs_chmod (g, 493, path);
12045     if (r == -1)
12046       return -1;
12047   }
12048   {
12049     char arguments_0[] = "/test-command";
12050     char arguments_1[] = "6";
12051     char *arguments[] = {
12052       arguments_0,
12053       arguments_1,
12054       NULL
12055     };
12056     char *r;
12057     suppress_error = 0;
12058     r = guestfs_command (g, arguments);
12059     if (r == NULL)
12060       return -1;
12061     if (strcmp (r, expected) != 0) {
12062       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
12063       return -1;
12064     }
12065     free (r);
12066   }
12067   return 0;
12068 }
12069
12070 static int test_command_6_skip (void)
12071 {
12072   const char *str;
12073
12074   str = getenv ("TEST_ONLY");
12075   if (str)
12076     return strstr (str, "command") == NULL;
12077   str = getenv ("SKIP_TEST_COMMAND_6");
12078   if (str && strcmp (str, "1") == 0) return 1;
12079   str = getenv ("SKIP_TEST_COMMAND");
12080   if (str && strcmp (str, "1") == 0) return 1;
12081   return 0;
12082 }
12083
12084 static int test_command_6 (void)
12085 {
12086   if (test_command_6_skip ()) {
12087     printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
12088     return 0;
12089   }
12090
12091   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
12092   {
12093     char device[] = "/dev/sda";
12094     int r;
12095     suppress_error = 0;
12096     r = guestfs_blockdev_setrw (g, device);
12097     if (r == -1)
12098       return -1;
12099   }
12100   {
12101     int r;
12102     suppress_error = 0;
12103     r = guestfs_umount_all (g);
12104     if (r == -1)
12105       return -1;
12106   }
12107   {
12108     int r;
12109     suppress_error = 0;
12110     r = guestfs_lvm_remove_all (g);
12111     if (r == -1)
12112       return -1;
12113   }
12114   {
12115     char device[] = "/dev/sda";
12116     char lines_0[] = ",";
12117     char *lines[] = {
12118       lines_0,
12119       NULL
12120     };
12121     int r;
12122     suppress_error = 0;
12123     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12124     if (r == -1)
12125       return -1;
12126   }
12127   {
12128     char fstype[] = "ext2";
12129     char device[] = "/dev/sda1";
12130     int r;
12131     suppress_error = 0;
12132     r = guestfs_mkfs (g, fstype, device);
12133     if (r == -1)
12134       return -1;
12135   }
12136   {
12137     char device[] = "/dev/sda1";
12138     char mountpoint[] = "/";
12139     int r;
12140     suppress_error = 0;
12141     r = guestfs_mount (g, device, mountpoint);
12142     if (r == -1)
12143       return -1;
12144   }
12145   /* TestOutput for command (6) */
12146   char expected[] = "";
12147   {
12148     char remotefilename[] = "/test-command";
12149     int r;
12150     suppress_error = 0;
12151     r = guestfs_upload (g, "test-command", remotefilename);
12152     if (r == -1)
12153       return -1;
12154   }
12155   {
12156     char path[] = "/test-command";
12157     int r;
12158     suppress_error = 0;
12159     r = guestfs_chmod (g, 493, path);
12160     if (r == -1)
12161       return -1;
12162   }
12163   {
12164     char arguments_0[] = "/test-command";
12165     char arguments_1[] = "7";
12166     char *arguments[] = {
12167       arguments_0,
12168       arguments_1,
12169       NULL
12170     };
12171     char *r;
12172     suppress_error = 0;
12173     r = guestfs_command (g, arguments);
12174     if (r == NULL)
12175       return -1;
12176     if (strcmp (r, expected) != 0) {
12177       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
12178       return -1;
12179     }
12180     free (r);
12181   }
12182   return 0;
12183 }
12184
12185 static int test_command_7_skip (void)
12186 {
12187   const char *str;
12188
12189   str = getenv ("TEST_ONLY");
12190   if (str)
12191     return strstr (str, "command") == NULL;
12192   str = getenv ("SKIP_TEST_COMMAND_7");
12193   if (str && strcmp (str, "1") == 0) return 1;
12194   str = getenv ("SKIP_TEST_COMMAND");
12195   if (str && strcmp (str, "1") == 0) return 1;
12196   return 0;
12197 }
12198
12199 static int test_command_7 (void)
12200 {
12201   if (test_command_7_skip ()) {
12202     printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
12203     return 0;
12204   }
12205
12206   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
12207   {
12208     char device[] = "/dev/sda";
12209     int r;
12210     suppress_error = 0;
12211     r = guestfs_blockdev_setrw (g, device);
12212     if (r == -1)
12213       return -1;
12214   }
12215   {
12216     int r;
12217     suppress_error = 0;
12218     r = guestfs_umount_all (g);
12219     if (r == -1)
12220       return -1;
12221   }
12222   {
12223     int r;
12224     suppress_error = 0;
12225     r = guestfs_lvm_remove_all (g);
12226     if (r == -1)
12227       return -1;
12228   }
12229   {
12230     char device[] = "/dev/sda";
12231     char lines_0[] = ",";
12232     char *lines[] = {
12233       lines_0,
12234       NULL
12235     };
12236     int r;
12237     suppress_error = 0;
12238     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12239     if (r == -1)
12240       return -1;
12241   }
12242   {
12243     char fstype[] = "ext2";
12244     char device[] = "/dev/sda1";
12245     int r;
12246     suppress_error = 0;
12247     r = guestfs_mkfs (g, fstype, device);
12248     if (r == -1)
12249       return -1;
12250   }
12251   {
12252     char device[] = "/dev/sda1";
12253     char mountpoint[] = "/";
12254     int r;
12255     suppress_error = 0;
12256     r = guestfs_mount (g, device, mountpoint);
12257     if (r == -1)
12258       return -1;
12259   }
12260   /* TestOutput for command (7) */
12261   char expected[] = "\n";
12262   {
12263     char remotefilename[] = "/test-command";
12264     int r;
12265     suppress_error = 0;
12266     r = guestfs_upload (g, "test-command", remotefilename);
12267     if (r == -1)
12268       return -1;
12269   }
12270   {
12271     char path[] = "/test-command";
12272     int r;
12273     suppress_error = 0;
12274     r = guestfs_chmod (g, 493, path);
12275     if (r == -1)
12276       return -1;
12277   }
12278   {
12279     char arguments_0[] = "/test-command";
12280     char arguments_1[] = "8";
12281     char *arguments[] = {
12282       arguments_0,
12283       arguments_1,
12284       NULL
12285     };
12286     char *r;
12287     suppress_error = 0;
12288     r = guestfs_command (g, arguments);
12289     if (r == NULL)
12290       return -1;
12291     if (strcmp (r, expected) != 0) {
12292       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12293       return -1;
12294     }
12295     free (r);
12296   }
12297   return 0;
12298 }
12299
12300 static int test_command_8_skip (void)
12301 {
12302   const char *str;
12303
12304   str = getenv ("TEST_ONLY");
12305   if (str)
12306     return strstr (str, "command") == NULL;
12307   str = getenv ("SKIP_TEST_COMMAND_8");
12308   if (str && strcmp (str, "1") == 0) return 1;
12309   str = getenv ("SKIP_TEST_COMMAND");
12310   if (str && strcmp (str, "1") == 0) return 1;
12311   return 0;
12312 }
12313
12314 static int test_command_8 (void)
12315 {
12316   if (test_command_8_skip ()) {
12317     printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
12318     return 0;
12319   }
12320
12321   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12322   {
12323     char device[] = "/dev/sda";
12324     int r;
12325     suppress_error = 0;
12326     r = guestfs_blockdev_setrw (g, device);
12327     if (r == -1)
12328       return -1;
12329   }
12330   {
12331     int r;
12332     suppress_error = 0;
12333     r = guestfs_umount_all (g);
12334     if (r == -1)
12335       return -1;
12336   }
12337   {
12338     int r;
12339     suppress_error = 0;
12340     r = guestfs_lvm_remove_all (g);
12341     if (r == -1)
12342       return -1;
12343   }
12344   {
12345     char device[] = "/dev/sda";
12346     char lines_0[] = ",";
12347     char *lines[] = {
12348       lines_0,
12349       NULL
12350     };
12351     int r;
12352     suppress_error = 0;
12353     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12354     if (r == -1)
12355       return -1;
12356   }
12357   {
12358     char fstype[] = "ext2";
12359     char device[] = "/dev/sda1";
12360     int r;
12361     suppress_error = 0;
12362     r = guestfs_mkfs (g, fstype, device);
12363     if (r == -1)
12364       return -1;
12365   }
12366   {
12367     char device[] = "/dev/sda1";
12368     char mountpoint[] = "/";
12369     int r;
12370     suppress_error = 0;
12371     r = guestfs_mount (g, device, mountpoint);
12372     if (r == -1)
12373       return -1;
12374   }
12375   /* TestOutput for command (8) */
12376   char expected[] = "\n\n";
12377   {
12378     char remotefilename[] = "/test-command";
12379     int r;
12380     suppress_error = 0;
12381     r = guestfs_upload (g, "test-command", remotefilename);
12382     if (r == -1)
12383       return -1;
12384   }
12385   {
12386     char path[] = "/test-command";
12387     int r;
12388     suppress_error = 0;
12389     r = guestfs_chmod (g, 493, path);
12390     if (r == -1)
12391       return -1;
12392   }
12393   {
12394     char arguments_0[] = "/test-command";
12395     char arguments_1[] = "9";
12396     char *arguments[] = {
12397       arguments_0,
12398       arguments_1,
12399       NULL
12400     };
12401     char *r;
12402     suppress_error = 0;
12403     r = guestfs_command (g, arguments);
12404     if (r == NULL)
12405       return -1;
12406     if (strcmp (r, expected) != 0) {
12407       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12408       return -1;
12409     }
12410     free (r);
12411   }
12412   return 0;
12413 }
12414
12415 static int test_command_9_skip (void)
12416 {
12417   const char *str;
12418
12419   str = getenv ("TEST_ONLY");
12420   if (str)
12421     return strstr (str, "command") == NULL;
12422   str = getenv ("SKIP_TEST_COMMAND_9");
12423   if (str && strcmp (str, "1") == 0) return 1;
12424   str = getenv ("SKIP_TEST_COMMAND");
12425   if (str && strcmp (str, "1") == 0) return 1;
12426   return 0;
12427 }
12428
12429 static int test_command_9 (void)
12430 {
12431   if (test_command_9_skip ()) {
12432     printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12433     return 0;
12434   }
12435
12436   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12437   {
12438     char device[] = "/dev/sda";
12439     int r;
12440     suppress_error = 0;
12441     r = guestfs_blockdev_setrw (g, device);
12442     if (r == -1)
12443       return -1;
12444   }
12445   {
12446     int r;
12447     suppress_error = 0;
12448     r = guestfs_umount_all (g);
12449     if (r == -1)
12450       return -1;
12451   }
12452   {
12453     int r;
12454     suppress_error = 0;
12455     r = guestfs_lvm_remove_all (g);
12456     if (r == -1)
12457       return -1;
12458   }
12459   {
12460     char device[] = "/dev/sda";
12461     char lines_0[] = ",";
12462     char *lines[] = {
12463       lines_0,
12464       NULL
12465     };
12466     int r;
12467     suppress_error = 0;
12468     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12469     if (r == -1)
12470       return -1;
12471   }
12472   {
12473     char fstype[] = "ext2";
12474     char device[] = "/dev/sda1";
12475     int r;
12476     suppress_error = 0;
12477     r = guestfs_mkfs (g, fstype, device);
12478     if (r == -1)
12479       return -1;
12480   }
12481   {
12482     char device[] = "/dev/sda1";
12483     char mountpoint[] = "/";
12484     int r;
12485     suppress_error = 0;
12486     r = guestfs_mount (g, device, mountpoint);
12487     if (r == -1)
12488       return -1;
12489   }
12490   /* TestOutput for command (9) */
12491   char expected[] = "Result10-1\nResult10-2\n";
12492   {
12493     char remotefilename[] = "/test-command";
12494     int r;
12495     suppress_error = 0;
12496     r = guestfs_upload (g, "test-command", remotefilename);
12497     if (r == -1)
12498       return -1;
12499   }
12500   {
12501     char path[] = "/test-command";
12502     int r;
12503     suppress_error = 0;
12504     r = guestfs_chmod (g, 493, path);
12505     if (r == -1)
12506       return -1;
12507   }
12508   {
12509     char arguments_0[] = "/test-command";
12510     char arguments_1[] = "10";
12511     char *arguments[] = {
12512       arguments_0,
12513       arguments_1,
12514       NULL
12515     };
12516     char *r;
12517     suppress_error = 0;
12518     r = guestfs_command (g, arguments);
12519     if (r == NULL)
12520       return -1;
12521     if (strcmp (r, expected) != 0) {
12522       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12523       return -1;
12524     }
12525     free (r);
12526   }
12527   return 0;
12528 }
12529
12530 static int test_command_10_skip (void)
12531 {
12532   const char *str;
12533
12534   str = getenv ("TEST_ONLY");
12535   if (str)
12536     return strstr (str, "command") == NULL;
12537   str = getenv ("SKIP_TEST_COMMAND_10");
12538   if (str && strcmp (str, "1") == 0) return 1;
12539   str = getenv ("SKIP_TEST_COMMAND");
12540   if (str && strcmp (str, "1") == 0) return 1;
12541   return 0;
12542 }
12543
12544 static int test_command_10 (void)
12545 {
12546   if (test_command_10_skip ()) {
12547     printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12548     return 0;
12549   }
12550
12551   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12552   {
12553     char device[] = "/dev/sda";
12554     int r;
12555     suppress_error = 0;
12556     r = guestfs_blockdev_setrw (g, device);
12557     if (r == -1)
12558       return -1;
12559   }
12560   {
12561     int r;
12562     suppress_error = 0;
12563     r = guestfs_umount_all (g);
12564     if (r == -1)
12565       return -1;
12566   }
12567   {
12568     int r;
12569     suppress_error = 0;
12570     r = guestfs_lvm_remove_all (g);
12571     if (r == -1)
12572       return -1;
12573   }
12574   {
12575     char device[] = "/dev/sda";
12576     char lines_0[] = ",";
12577     char *lines[] = {
12578       lines_0,
12579       NULL
12580     };
12581     int r;
12582     suppress_error = 0;
12583     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12584     if (r == -1)
12585       return -1;
12586   }
12587   {
12588     char fstype[] = "ext2";
12589     char device[] = "/dev/sda1";
12590     int r;
12591     suppress_error = 0;
12592     r = guestfs_mkfs (g, fstype, device);
12593     if (r == -1)
12594       return -1;
12595   }
12596   {
12597     char device[] = "/dev/sda1";
12598     char mountpoint[] = "/";
12599     int r;
12600     suppress_error = 0;
12601     r = guestfs_mount (g, device, mountpoint);
12602     if (r == -1)
12603       return -1;
12604   }
12605   /* TestOutput for command (10) */
12606   char expected[] = "Result11-1\nResult11-2";
12607   {
12608     char remotefilename[] = "/test-command";
12609     int r;
12610     suppress_error = 0;
12611     r = guestfs_upload (g, "test-command", remotefilename);
12612     if (r == -1)
12613       return -1;
12614   }
12615   {
12616     char path[] = "/test-command";
12617     int r;
12618     suppress_error = 0;
12619     r = guestfs_chmod (g, 493, path);
12620     if (r == -1)
12621       return -1;
12622   }
12623   {
12624     char arguments_0[] = "/test-command";
12625     char arguments_1[] = "11";
12626     char *arguments[] = {
12627       arguments_0,
12628       arguments_1,
12629       NULL
12630     };
12631     char *r;
12632     suppress_error = 0;
12633     r = guestfs_command (g, arguments);
12634     if (r == NULL)
12635       return -1;
12636     if (strcmp (r, expected) != 0) {
12637       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12638       return -1;
12639     }
12640     free (r);
12641   }
12642   return 0;
12643 }
12644
12645 static int test_command_11_skip (void)
12646 {
12647   const char *str;
12648
12649   str = getenv ("TEST_ONLY");
12650   if (str)
12651     return strstr (str, "command") == NULL;
12652   str = getenv ("SKIP_TEST_COMMAND_11");
12653   if (str && strcmp (str, "1") == 0) return 1;
12654   str = getenv ("SKIP_TEST_COMMAND");
12655   if (str && strcmp (str, "1") == 0) return 1;
12656   return 0;
12657 }
12658
12659 static int test_command_11 (void)
12660 {
12661   if (test_command_11_skip ()) {
12662     printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12663     return 0;
12664   }
12665
12666   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12667   {
12668     char device[] = "/dev/sda";
12669     int r;
12670     suppress_error = 0;
12671     r = guestfs_blockdev_setrw (g, device);
12672     if (r == -1)
12673       return -1;
12674   }
12675   {
12676     int r;
12677     suppress_error = 0;
12678     r = guestfs_umount_all (g);
12679     if (r == -1)
12680       return -1;
12681   }
12682   {
12683     int r;
12684     suppress_error = 0;
12685     r = guestfs_lvm_remove_all (g);
12686     if (r == -1)
12687       return -1;
12688   }
12689   {
12690     char device[] = "/dev/sda";
12691     char lines_0[] = ",";
12692     char *lines[] = {
12693       lines_0,
12694       NULL
12695     };
12696     int r;
12697     suppress_error = 0;
12698     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12699     if (r == -1)
12700       return -1;
12701   }
12702   {
12703     char fstype[] = "ext2";
12704     char device[] = "/dev/sda1";
12705     int r;
12706     suppress_error = 0;
12707     r = guestfs_mkfs (g, fstype, device);
12708     if (r == -1)
12709       return -1;
12710   }
12711   {
12712     char device[] = "/dev/sda1";
12713     char mountpoint[] = "/";
12714     int r;
12715     suppress_error = 0;
12716     r = guestfs_mount (g, device, mountpoint);
12717     if (r == -1)
12718       return -1;
12719   }
12720   /* TestLastFail for command (11) */
12721   {
12722     char remotefilename[] = "/test-command";
12723     int r;
12724     suppress_error = 0;
12725     r = guestfs_upload (g, "test-command", remotefilename);
12726     if (r == -1)
12727       return -1;
12728   }
12729   {
12730     char path[] = "/test-command";
12731     int r;
12732     suppress_error = 0;
12733     r = guestfs_chmod (g, 493, path);
12734     if (r == -1)
12735       return -1;
12736   }
12737   {
12738     char arguments_0[] = "/test-command";
12739     char *arguments[] = {
12740       arguments_0,
12741       NULL
12742     };
12743     char *r;
12744     suppress_error = 1;
12745     r = guestfs_command (g, arguments);
12746     if (r != NULL)
12747       return -1;
12748     free (r);
12749   }
12750   return 0;
12751 }
12752
12753 static int test_file_0_skip (void)
12754 {
12755   const char *str;
12756
12757   str = getenv ("TEST_ONLY");
12758   if (str)
12759     return strstr (str, "file") == NULL;
12760   str = getenv ("SKIP_TEST_FILE_0");
12761   if (str && strcmp (str, "1") == 0) return 1;
12762   str = getenv ("SKIP_TEST_FILE");
12763   if (str && strcmp (str, "1") == 0) return 1;
12764   return 0;
12765 }
12766
12767 static int test_file_0 (void)
12768 {
12769   if (test_file_0_skip ()) {
12770     printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12771     return 0;
12772   }
12773
12774   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12775   {
12776     char device[] = "/dev/sda";
12777     int r;
12778     suppress_error = 0;
12779     r = guestfs_blockdev_setrw (g, device);
12780     if (r == -1)
12781       return -1;
12782   }
12783   {
12784     int r;
12785     suppress_error = 0;
12786     r = guestfs_umount_all (g);
12787     if (r == -1)
12788       return -1;
12789   }
12790   {
12791     int r;
12792     suppress_error = 0;
12793     r = guestfs_lvm_remove_all (g);
12794     if (r == -1)
12795       return -1;
12796   }
12797   {
12798     char device[] = "/dev/sda";
12799     char lines_0[] = ",";
12800     char *lines[] = {
12801       lines_0,
12802       NULL
12803     };
12804     int r;
12805     suppress_error = 0;
12806     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12807     if (r == -1)
12808       return -1;
12809   }
12810   {
12811     char fstype[] = "ext2";
12812     char device[] = "/dev/sda1";
12813     int r;
12814     suppress_error = 0;
12815     r = guestfs_mkfs (g, fstype, device);
12816     if (r == -1)
12817       return -1;
12818   }
12819   {
12820     char device[] = "/dev/sda1";
12821     char mountpoint[] = "/";
12822     int r;
12823     suppress_error = 0;
12824     r = guestfs_mount (g, device, mountpoint);
12825     if (r == -1)
12826       return -1;
12827   }
12828   /* TestOutput for file (0) */
12829   char expected[] = "empty";
12830   {
12831     char path[] = "/new";
12832     int r;
12833     suppress_error = 0;
12834     r = guestfs_touch (g, path);
12835     if (r == -1)
12836       return -1;
12837   }
12838   {
12839     char path[] = "/new";
12840     char *r;
12841     suppress_error = 0;
12842     r = guestfs_file (g, path);
12843     if (r == NULL)
12844       return -1;
12845     if (strcmp (r, expected) != 0) {
12846       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12847       return -1;
12848     }
12849     free (r);
12850   }
12851   return 0;
12852 }
12853
12854 static int test_file_1_skip (void)
12855 {
12856   const char *str;
12857
12858   str = getenv ("TEST_ONLY");
12859   if (str)
12860     return strstr (str, "file") == NULL;
12861   str = getenv ("SKIP_TEST_FILE_1");
12862   if (str && strcmp (str, "1") == 0) return 1;
12863   str = getenv ("SKIP_TEST_FILE");
12864   if (str && strcmp (str, "1") == 0) return 1;
12865   return 0;
12866 }
12867
12868 static int test_file_1 (void)
12869 {
12870   if (test_file_1_skip ()) {
12871     printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12872     return 0;
12873   }
12874
12875   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12876   {
12877     char device[] = "/dev/sda";
12878     int r;
12879     suppress_error = 0;
12880     r = guestfs_blockdev_setrw (g, device);
12881     if (r == -1)
12882       return -1;
12883   }
12884   {
12885     int r;
12886     suppress_error = 0;
12887     r = guestfs_umount_all (g);
12888     if (r == -1)
12889       return -1;
12890   }
12891   {
12892     int r;
12893     suppress_error = 0;
12894     r = guestfs_lvm_remove_all (g);
12895     if (r == -1)
12896       return -1;
12897   }
12898   {
12899     char device[] = "/dev/sda";
12900     char lines_0[] = ",";
12901     char *lines[] = {
12902       lines_0,
12903       NULL
12904     };
12905     int r;
12906     suppress_error = 0;
12907     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12908     if (r == -1)
12909       return -1;
12910   }
12911   {
12912     char fstype[] = "ext2";
12913     char device[] = "/dev/sda1";
12914     int r;
12915     suppress_error = 0;
12916     r = guestfs_mkfs (g, fstype, device);
12917     if (r == -1)
12918       return -1;
12919   }
12920   {
12921     char device[] = "/dev/sda1";
12922     char mountpoint[] = "/";
12923     int r;
12924     suppress_error = 0;
12925     r = guestfs_mount (g, device, mountpoint);
12926     if (r == -1)
12927       return -1;
12928   }
12929   /* TestOutput for file (1) */
12930   char expected[] = "ASCII text";
12931   {
12932     char path[] = "/new";
12933     char content[] = "some content\n";
12934     int r;
12935     suppress_error = 0;
12936     r = guestfs_write_file (g, path, content, 0);
12937     if (r == -1)
12938       return -1;
12939   }
12940   {
12941     char path[] = "/new";
12942     char *r;
12943     suppress_error = 0;
12944     r = guestfs_file (g, path);
12945     if (r == NULL)
12946       return -1;
12947     if (strcmp (r, expected) != 0) {
12948       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12949       return -1;
12950     }
12951     free (r);
12952   }
12953   return 0;
12954 }
12955
12956 static int test_file_2_skip (void)
12957 {
12958   const char *str;
12959
12960   str = getenv ("TEST_ONLY");
12961   if (str)
12962     return strstr (str, "file") == NULL;
12963   str = getenv ("SKIP_TEST_FILE_2");
12964   if (str && strcmp (str, "1") == 0) return 1;
12965   str = getenv ("SKIP_TEST_FILE");
12966   if (str && strcmp (str, "1") == 0) return 1;
12967   return 0;
12968 }
12969
12970 static int test_file_2 (void)
12971 {
12972   if (test_file_2_skip ()) {
12973     printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12974     return 0;
12975   }
12976
12977   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12978   {
12979     char device[] = "/dev/sda";
12980     int r;
12981     suppress_error = 0;
12982     r = guestfs_blockdev_setrw (g, device);
12983     if (r == -1)
12984       return -1;
12985   }
12986   {
12987     int r;
12988     suppress_error = 0;
12989     r = guestfs_umount_all (g);
12990     if (r == -1)
12991       return -1;
12992   }
12993   {
12994     int r;
12995     suppress_error = 0;
12996     r = guestfs_lvm_remove_all (g);
12997     if (r == -1)
12998       return -1;
12999   }
13000   {
13001     char device[] = "/dev/sda";
13002     char lines_0[] = ",";
13003     char *lines[] = {
13004       lines_0,
13005       NULL
13006     };
13007     int r;
13008     suppress_error = 0;
13009     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13010     if (r == -1)
13011       return -1;
13012   }
13013   {
13014     char fstype[] = "ext2";
13015     char device[] = "/dev/sda1";
13016     int r;
13017     suppress_error = 0;
13018     r = guestfs_mkfs (g, fstype, device);
13019     if (r == -1)
13020       return -1;
13021   }
13022   {
13023     char device[] = "/dev/sda1";
13024     char mountpoint[] = "/";
13025     int r;
13026     suppress_error = 0;
13027     r = guestfs_mount (g, device, mountpoint);
13028     if (r == -1)
13029       return -1;
13030   }
13031   /* TestLastFail for file (2) */
13032   {
13033     char path[] = "/nofile";
13034     char *r;
13035     suppress_error = 1;
13036     r = guestfs_file (g, path);
13037     if (r != NULL)
13038       return -1;
13039     free (r);
13040   }
13041   return 0;
13042 }
13043
13044 static int test_umount_all_0_skip (void)
13045 {
13046   const char *str;
13047
13048   str = getenv ("TEST_ONLY");
13049   if (str)
13050     return strstr (str, "umount_all") == NULL;
13051   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
13052   if (str && strcmp (str, "1") == 0) return 1;
13053   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13054   if (str && strcmp (str, "1") == 0) return 1;
13055   return 0;
13056 }
13057
13058 static int test_umount_all_0 (void)
13059 {
13060   if (test_umount_all_0_skip ()) {
13061     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
13062     return 0;
13063   }
13064
13065   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
13066   {
13067     char device[] = "/dev/sda";
13068     int r;
13069     suppress_error = 0;
13070     r = guestfs_blockdev_setrw (g, device);
13071     if (r == -1)
13072       return -1;
13073   }
13074   {
13075     int r;
13076     suppress_error = 0;
13077     r = guestfs_umount_all (g);
13078     if (r == -1)
13079       return -1;
13080   }
13081   {
13082     int r;
13083     suppress_error = 0;
13084     r = guestfs_lvm_remove_all (g);
13085     if (r == -1)
13086       return -1;
13087   }
13088   {
13089     char device[] = "/dev/sda";
13090     char lines_0[] = ",";
13091     char *lines[] = {
13092       lines_0,
13093       NULL
13094     };
13095     int r;
13096     suppress_error = 0;
13097     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13098     if (r == -1)
13099       return -1;
13100   }
13101   {
13102     char fstype[] = "ext2";
13103     char device[] = "/dev/sda1";
13104     int r;
13105     suppress_error = 0;
13106     r = guestfs_mkfs (g, fstype, device);
13107     if (r == -1)
13108       return -1;
13109   }
13110   {
13111     char device[] = "/dev/sda1";
13112     char mountpoint[] = "/";
13113     int r;
13114     suppress_error = 0;
13115     r = guestfs_mount (g, device, mountpoint);
13116     if (r == -1)
13117       return -1;
13118   }
13119   /* TestOutputList for umount_all (0) */
13120   {
13121     int r;
13122     suppress_error = 0;
13123     r = guestfs_umount_all (g);
13124     if (r == -1)
13125       return -1;
13126   }
13127   {
13128     char **r;
13129     int i;
13130     suppress_error = 0;
13131     r = guestfs_mounts (g);
13132     if (r == NULL)
13133       return -1;
13134     if (r[0] != NULL) {
13135       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
13136       print_strings (r);
13137       return -1;
13138     }
13139     for (i = 0; r[i] != NULL; ++i)
13140       free (r[i]);
13141     free (r);
13142   }
13143   return 0;
13144 }
13145
13146 static int test_umount_all_1_skip (void)
13147 {
13148   const char *str;
13149
13150   str = getenv ("TEST_ONLY");
13151   if (str)
13152     return strstr (str, "umount_all") == NULL;
13153   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
13154   if (str && strcmp (str, "1") == 0) return 1;
13155   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13156   if (str && strcmp (str, "1") == 0) return 1;
13157   return 0;
13158 }
13159
13160 static int test_umount_all_1 (void)
13161 {
13162   if (test_umount_all_1_skip ()) {
13163     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
13164     return 0;
13165   }
13166
13167   /* InitNone|InitEmpty for test_umount_all_1 */
13168   {
13169     char device[] = "/dev/sda";
13170     int r;
13171     suppress_error = 0;
13172     r = guestfs_blockdev_setrw (g, device);
13173     if (r == -1)
13174       return -1;
13175   }
13176   {
13177     int r;
13178     suppress_error = 0;
13179     r = guestfs_umount_all (g);
13180     if (r == -1)
13181       return -1;
13182   }
13183   {
13184     int r;
13185     suppress_error = 0;
13186     r = guestfs_lvm_remove_all (g);
13187     if (r == -1)
13188       return -1;
13189   }
13190   /* TestOutputList for umount_all (1) */
13191   {
13192     char device[] = "/dev/sda";
13193     char lines_0[] = ",10";
13194     char lines_1[] = ",20";
13195     char lines_2[] = ",";
13196     char *lines[] = {
13197       lines_0,
13198       lines_1,
13199       lines_2,
13200       NULL
13201     };
13202     int r;
13203     suppress_error = 0;
13204     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13205     if (r == -1)
13206       return -1;
13207   }
13208   {
13209     char fstype[] = "ext2";
13210     char device[] = "/dev/sda1";
13211     int r;
13212     suppress_error = 0;
13213     r = guestfs_mkfs (g, fstype, device);
13214     if (r == -1)
13215       return -1;
13216   }
13217   {
13218     char fstype[] = "ext2";
13219     char device[] = "/dev/sda2";
13220     int r;
13221     suppress_error = 0;
13222     r = guestfs_mkfs (g, fstype, device);
13223     if (r == -1)
13224       return -1;
13225   }
13226   {
13227     char fstype[] = "ext2";
13228     char device[] = "/dev/sda3";
13229     int r;
13230     suppress_error = 0;
13231     r = guestfs_mkfs (g, fstype, device);
13232     if (r == -1)
13233       return -1;
13234   }
13235   {
13236     char device[] = "/dev/sda1";
13237     char mountpoint[] = "/";
13238     int r;
13239     suppress_error = 0;
13240     r = guestfs_mount (g, device, mountpoint);
13241     if (r == -1)
13242       return -1;
13243   }
13244   {
13245     char path[] = "/mp1";
13246     int r;
13247     suppress_error = 0;
13248     r = guestfs_mkdir (g, path);
13249     if (r == -1)
13250       return -1;
13251   }
13252   {
13253     char device[] = "/dev/sda2";
13254     char mountpoint[] = "/mp1";
13255     int r;
13256     suppress_error = 0;
13257     r = guestfs_mount (g, device, mountpoint);
13258     if (r == -1)
13259       return -1;
13260   }
13261   {
13262     char path[] = "/mp1/mp2";
13263     int r;
13264     suppress_error = 0;
13265     r = guestfs_mkdir (g, path);
13266     if (r == -1)
13267       return -1;
13268   }
13269   {
13270     char device[] = "/dev/sda3";
13271     char mountpoint[] = "/mp1/mp2";
13272     int r;
13273     suppress_error = 0;
13274     r = guestfs_mount (g, device, mountpoint);
13275     if (r == -1)
13276       return -1;
13277   }
13278   {
13279     char path[] = "/mp1/mp2/mp3";
13280     int r;
13281     suppress_error = 0;
13282     r = guestfs_mkdir (g, path);
13283     if (r == -1)
13284       return -1;
13285   }
13286   {
13287     int r;
13288     suppress_error = 0;
13289     r = guestfs_umount_all (g);
13290     if (r == -1)
13291       return -1;
13292   }
13293   {
13294     char **r;
13295     int i;
13296     suppress_error = 0;
13297     r = guestfs_mounts (g);
13298     if (r == NULL)
13299       return -1;
13300     if (r[0] != NULL) {
13301       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13302       print_strings (r);
13303       return -1;
13304     }
13305     for (i = 0; r[i] != NULL; ++i)
13306       free (r[i]);
13307     free (r);
13308   }
13309   return 0;
13310 }
13311
13312 static int test_mounts_0_skip (void)
13313 {
13314   const char *str;
13315
13316   str = getenv ("TEST_ONLY");
13317   if (str)
13318     return strstr (str, "mounts") == NULL;
13319   str = getenv ("SKIP_TEST_MOUNTS_0");
13320   if (str && strcmp (str, "1") == 0) return 1;
13321   str = getenv ("SKIP_TEST_MOUNTS");
13322   if (str && strcmp (str, "1") == 0) return 1;
13323   return 0;
13324 }
13325
13326 static int test_mounts_0 (void)
13327 {
13328   if (test_mounts_0_skip ()) {
13329     printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
13330     return 0;
13331   }
13332
13333   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13334   {
13335     char device[] = "/dev/sda";
13336     int r;
13337     suppress_error = 0;
13338     r = guestfs_blockdev_setrw (g, device);
13339     if (r == -1)
13340       return -1;
13341   }
13342   {
13343     int r;
13344     suppress_error = 0;
13345     r = guestfs_umount_all (g);
13346     if (r == -1)
13347       return -1;
13348   }
13349   {
13350     int r;
13351     suppress_error = 0;
13352     r = guestfs_lvm_remove_all (g);
13353     if (r == -1)
13354       return -1;
13355   }
13356   {
13357     char device[] = "/dev/sda";
13358     char lines_0[] = ",";
13359     char *lines[] = {
13360       lines_0,
13361       NULL
13362     };
13363     int r;
13364     suppress_error = 0;
13365     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13366     if (r == -1)
13367       return -1;
13368   }
13369   {
13370     char fstype[] = "ext2";
13371     char device[] = "/dev/sda1";
13372     int r;
13373     suppress_error = 0;
13374     r = guestfs_mkfs (g, fstype, device);
13375     if (r == -1)
13376       return -1;
13377   }
13378   {
13379     char device[] = "/dev/sda1";
13380     char mountpoint[] = "/";
13381     int r;
13382     suppress_error = 0;
13383     r = guestfs_mount (g, device, mountpoint);
13384     if (r == -1)
13385       return -1;
13386   }
13387   /* TestOutputListOfDevices for mounts (0) */
13388   {
13389     char **r;
13390     int i;
13391     suppress_error = 0;
13392     r = guestfs_mounts (g);
13393     if (r == NULL)
13394       return -1;
13395     if (!r[0]) {
13396       fprintf (stderr, "test_mounts_0: short list returned from command\n");
13397       print_strings (r);
13398       return -1;
13399     }
13400     {
13401       char expected[] = "/dev/sda1";
13402       r[0][5] = 's';
13403       if (strcmp (r[0], expected) != 0) {
13404         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13405         return -1;
13406       }
13407     }
13408     if (r[1] != NULL) {
13409       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13410       print_strings (r);
13411       return -1;
13412     }
13413     for (i = 0; r[i] != NULL; ++i)
13414       free (r[i]);
13415     free (r);
13416   }
13417   return 0;
13418 }
13419
13420 static int test_umount_0_skip (void)
13421 {
13422   const char *str;
13423
13424   str = getenv ("TEST_ONLY");
13425   if (str)
13426     return strstr (str, "umount") == NULL;
13427   str = getenv ("SKIP_TEST_UMOUNT_0");
13428   if (str && strcmp (str, "1") == 0) return 1;
13429   str = getenv ("SKIP_TEST_UMOUNT");
13430   if (str && strcmp (str, "1") == 0) return 1;
13431   return 0;
13432 }
13433
13434 static int test_umount_0 (void)
13435 {
13436   if (test_umount_0_skip ()) {
13437     printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13438     return 0;
13439   }
13440
13441   /* InitNone|InitEmpty for test_umount_0 */
13442   {
13443     char device[] = "/dev/sda";
13444     int r;
13445     suppress_error = 0;
13446     r = guestfs_blockdev_setrw (g, device);
13447     if (r == -1)
13448       return -1;
13449   }
13450   {
13451     int r;
13452     suppress_error = 0;
13453     r = guestfs_umount_all (g);
13454     if (r == -1)
13455       return -1;
13456   }
13457   {
13458     int r;
13459     suppress_error = 0;
13460     r = guestfs_lvm_remove_all (g);
13461     if (r == -1)
13462       return -1;
13463   }
13464   /* TestOutputListOfDevices for umount (0) */
13465   {
13466     char device[] = "/dev/sda";
13467     char lines_0[] = ",";
13468     char *lines[] = {
13469       lines_0,
13470       NULL
13471     };
13472     int r;
13473     suppress_error = 0;
13474     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13475     if (r == -1)
13476       return -1;
13477   }
13478   {
13479     char fstype[] = "ext2";
13480     char device[] = "/dev/sda1";
13481     int r;
13482     suppress_error = 0;
13483     r = guestfs_mkfs (g, fstype, device);
13484     if (r == -1)
13485       return -1;
13486   }
13487   {
13488     char device[] = "/dev/sda1";
13489     char mountpoint[] = "/";
13490     int r;
13491     suppress_error = 0;
13492     r = guestfs_mount (g, device, mountpoint);
13493     if (r == -1)
13494       return -1;
13495   }
13496   {
13497     char **r;
13498     int i;
13499     suppress_error = 0;
13500     r = guestfs_mounts (g);
13501     if (r == NULL)
13502       return -1;
13503     if (!r[0]) {
13504       fprintf (stderr, "test_umount_0: short list returned from command\n");
13505       print_strings (r);
13506       return -1;
13507     }
13508     {
13509       char expected[] = "/dev/sda1";
13510       r[0][5] = 's';
13511       if (strcmp (r[0], expected) != 0) {
13512         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13513         return -1;
13514       }
13515     }
13516     if (r[1] != NULL) {
13517       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13518       print_strings (r);
13519       return -1;
13520     }
13521     for (i = 0; r[i] != NULL; ++i)
13522       free (r[i]);
13523     free (r);
13524   }
13525   return 0;
13526 }
13527
13528 static int test_umount_1_skip (void)
13529 {
13530   const char *str;
13531
13532   str = getenv ("TEST_ONLY");
13533   if (str)
13534     return strstr (str, "umount") == NULL;
13535   str = getenv ("SKIP_TEST_UMOUNT_1");
13536   if (str && strcmp (str, "1") == 0) return 1;
13537   str = getenv ("SKIP_TEST_UMOUNT");
13538   if (str && strcmp (str, "1") == 0) return 1;
13539   return 0;
13540 }
13541
13542 static int test_umount_1 (void)
13543 {
13544   if (test_umount_1_skip ()) {
13545     printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13546     return 0;
13547   }
13548
13549   /* InitNone|InitEmpty for test_umount_1 */
13550   {
13551     char device[] = "/dev/sda";
13552     int r;
13553     suppress_error = 0;
13554     r = guestfs_blockdev_setrw (g, device);
13555     if (r == -1)
13556       return -1;
13557   }
13558   {
13559     int r;
13560     suppress_error = 0;
13561     r = guestfs_umount_all (g);
13562     if (r == -1)
13563       return -1;
13564   }
13565   {
13566     int r;
13567     suppress_error = 0;
13568     r = guestfs_lvm_remove_all (g);
13569     if (r == -1)
13570       return -1;
13571   }
13572   /* TestOutputList for umount (1) */
13573   {
13574     char device[] = "/dev/sda";
13575     char lines_0[] = ",";
13576     char *lines[] = {
13577       lines_0,
13578       NULL
13579     };
13580     int r;
13581     suppress_error = 0;
13582     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13583     if (r == -1)
13584       return -1;
13585   }
13586   {
13587     char fstype[] = "ext2";
13588     char device[] = "/dev/sda1";
13589     int r;
13590     suppress_error = 0;
13591     r = guestfs_mkfs (g, fstype, device);
13592     if (r == -1)
13593       return -1;
13594   }
13595   {
13596     char device[] = "/dev/sda1";
13597     char mountpoint[] = "/";
13598     int r;
13599     suppress_error = 0;
13600     r = guestfs_mount (g, device, mountpoint);
13601     if (r == -1)
13602       return -1;
13603   }
13604   {
13605     char pathordevice[] = "/";
13606     int r;
13607     suppress_error = 0;
13608     r = guestfs_umount (g, pathordevice);
13609     if (r == -1)
13610       return -1;
13611   }
13612   {
13613     char **r;
13614     int i;
13615     suppress_error = 0;
13616     r = guestfs_mounts (g);
13617     if (r == NULL)
13618       return -1;
13619     if (r[0] != NULL) {
13620       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13621       print_strings (r);
13622       return -1;
13623     }
13624     for (i = 0; r[i] != NULL; ++i)
13625       free (r[i]);
13626     free (r);
13627   }
13628   return 0;
13629 }
13630
13631 static int test_write_file_0_skip (void)
13632 {
13633   const char *str;
13634
13635   str = getenv ("TEST_ONLY");
13636   if (str)
13637     return strstr (str, "write_file") == NULL;
13638   str = getenv ("SKIP_TEST_WRITE_FILE_0");
13639   if (str && strcmp (str, "1") == 0) return 1;
13640   str = getenv ("SKIP_TEST_WRITE_FILE");
13641   if (str && strcmp (str, "1") == 0) return 1;
13642   return 0;
13643 }
13644
13645 static int test_write_file_0 (void)
13646 {
13647   if (test_write_file_0_skip ()) {
13648     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13649     return 0;
13650   }
13651
13652   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13653   {
13654     char device[] = "/dev/sda";
13655     int r;
13656     suppress_error = 0;
13657     r = guestfs_blockdev_setrw (g, device);
13658     if (r == -1)
13659       return -1;
13660   }
13661   {
13662     int r;
13663     suppress_error = 0;
13664     r = guestfs_umount_all (g);
13665     if (r == -1)
13666       return -1;
13667   }
13668   {
13669     int r;
13670     suppress_error = 0;
13671     r = guestfs_lvm_remove_all (g);
13672     if (r == -1)
13673       return -1;
13674   }
13675   {
13676     char device[] = "/dev/sda";
13677     char lines_0[] = ",";
13678     char *lines[] = {
13679       lines_0,
13680       NULL
13681     };
13682     int r;
13683     suppress_error = 0;
13684     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13685     if (r == -1)
13686       return -1;
13687   }
13688   {
13689     char fstype[] = "ext2";
13690     char device[] = "/dev/sda1";
13691     int r;
13692     suppress_error = 0;
13693     r = guestfs_mkfs (g, fstype, device);
13694     if (r == -1)
13695       return -1;
13696   }
13697   {
13698     char device[] = "/dev/sda1";
13699     char mountpoint[] = "/";
13700     int r;
13701     suppress_error = 0;
13702     r = guestfs_mount (g, device, mountpoint);
13703     if (r == -1)
13704       return -1;
13705   }
13706   /* TestOutput for write_file (0) */
13707   char expected[] = "new file contents";
13708   {
13709     char path[] = "/new";
13710     char content[] = "new file contents";
13711     int r;
13712     suppress_error = 0;
13713     r = guestfs_write_file (g, path, content, 0);
13714     if (r == -1)
13715       return -1;
13716   }
13717   {
13718     char path[] = "/new";
13719     char *r;
13720     suppress_error = 0;
13721     r = guestfs_cat (g, path);
13722     if (r == NULL)
13723       return -1;
13724     if (strcmp (r, expected) != 0) {
13725       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13726       return -1;
13727     }
13728     free (r);
13729   }
13730   return 0;
13731 }
13732
13733 static int test_write_file_1_skip (void)
13734 {
13735   const char *str;
13736
13737   str = getenv ("TEST_ONLY");
13738   if (str)
13739     return strstr (str, "write_file") == NULL;
13740   str = getenv ("SKIP_TEST_WRITE_FILE_1");
13741   if (str && strcmp (str, "1") == 0) return 1;
13742   str = getenv ("SKIP_TEST_WRITE_FILE");
13743   if (str && strcmp (str, "1") == 0) return 1;
13744   return 0;
13745 }
13746
13747 static int test_write_file_1 (void)
13748 {
13749   if (test_write_file_1_skip ()) {
13750     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13751     return 0;
13752   }
13753
13754   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13755   {
13756     char device[] = "/dev/sda";
13757     int r;
13758     suppress_error = 0;
13759     r = guestfs_blockdev_setrw (g, device);
13760     if (r == -1)
13761       return -1;
13762   }
13763   {
13764     int r;
13765     suppress_error = 0;
13766     r = guestfs_umount_all (g);
13767     if (r == -1)
13768       return -1;
13769   }
13770   {
13771     int r;
13772     suppress_error = 0;
13773     r = guestfs_lvm_remove_all (g);
13774     if (r == -1)
13775       return -1;
13776   }
13777   {
13778     char device[] = "/dev/sda";
13779     char lines_0[] = ",";
13780     char *lines[] = {
13781       lines_0,
13782       NULL
13783     };
13784     int r;
13785     suppress_error = 0;
13786     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13787     if (r == -1)
13788       return -1;
13789   }
13790   {
13791     char fstype[] = "ext2";
13792     char device[] = "/dev/sda1";
13793     int r;
13794     suppress_error = 0;
13795     r = guestfs_mkfs (g, fstype, device);
13796     if (r == -1)
13797       return -1;
13798   }
13799   {
13800     char device[] = "/dev/sda1";
13801     char mountpoint[] = "/";
13802     int r;
13803     suppress_error = 0;
13804     r = guestfs_mount (g, device, mountpoint);
13805     if (r == -1)
13806       return -1;
13807   }
13808   /* TestOutput for write_file (1) */
13809   char expected[] = "\nnew file contents\n";
13810   {
13811     char path[] = "/new";
13812     char content[] = "\nnew file contents\n";
13813     int r;
13814     suppress_error = 0;
13815     r = guestfs_write_file (g, path, content, 0);
13816     if (r == -1)
13817       return -1;
13818   }
13819   {
13820     char path[] = "/new";
13821     char *r;
13822     suppress_error = 0;
13823     r = guestfs_cat (g, path);
13824     if (r == NULL)
13825       return -1;
13826     if (strcmp (r, expected) != 0) {
13827       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13828       return -1;
13829     }
13830     free (r);
13831   }
13832   return 0;
13833 }
13834
13835 static int test_write_file_2_skip (void)
13836 {
13837   const char *str;
13838
13839   str = getenv ("TEST_ONLY");
13840   if (str)
13841     return strstr (str, "write_file") == NULL;
13842   str = getenv ("SKIP_TEST_WRITE_FILE_2");
13843   if (str && strcmp (str, "1") == 0) return 1;
13844   str = getenv ("SKIP_TEST_WRITE_FILE");
13845   if (str && strcmp (str, "1") == 0) return 1;
13846   return 0;
13847 }
13848
13849 static int test_write_file_2 (void)
13850 {
13851   if (test_write_file_2_skip ()) {
13852     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13853     return 0;
13854   }
13855
13856   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13857   {
13858     char device[] = "/dev/sda";
13859     int r;
13860     suppress_error = 0;
13861     r = guestfs_blockdev_setrw (g, device);
13862     if (r == -1)
13863       return -1;
13864   }
13865   {
13866     int r;
13867     suppress_error = 0;
13868     r = guestfs_umount_all (g);
13869     if (r == -1)
13870       return -1;
13871   }
13872   {
13873     int r;
13874     suppress_error = 0;
13875     r = guestfs_lvm_remove_all (g);
13876     if (r == -1)
13877       return -1;
13878   }
13879   {
13880     char device[] = "/dev/sda";
13881     char lines_0[] = ",";
13882     char *lines[] = {
13883       lines_0,
13884       NULL
13885     };
13886     int r;
13887     suppress_error = 0;
13888     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13889     if (r == -1)
13890       return -1;
13891   }
13892   {
13893     char fstype[] = "ext2";
13894     char device[] = "/dev/sda1";
13895     int r;
13896     suppress_error = 0;
13897     r = guestfs_mkfs (g, fstype, device);
13898     if (r == -1)
13899       return -1;
13900   }
13901   {
13902     char device[] = "/dev/sda1";
13903     char mountpoint[] = "/";
13904     int r;
13905     suppress_error = 0;
13906     r = guestfs_mount (g, device, mountpoint);
13907     if (r == -1)
13908       return -1;
13909   }
13910   /* TestOutput for write_file (2) */
13911   char expected[] = "\n\n";
13912   {
13913     char path[] = "/new";
13914     char content[] = "\n\n";
13915     int r;
13916     suppress_error = 0;
13917     r = guestfs_write_file (g, path, content, 0);
13918     if (r == -1)
13919       return -1;
13920   }
13921   {
13922     char path[] = "/new";
13923     char *r;
13924     suppress_error = 0;
13925     r = guestfs_cat (g, path);
13926     if (r == NULL)
13927       return -1;
13928     if (strcmp (r, expected) != 0) {
13929       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13930       return -1;
13931     }
13932     free (r);
13933   }
13934   return 0;
13935 }
13936
13937 static int test_write_file_3_skip (void)
13938 {
13939   const char *str;
13940
13941   str = getenv ("TEST_ONLY");
13942   if (str)
13943     return strstr (str, "write_file") == NULL;
13944   str = getenv ("SKIP_TEST_WRITE_FILE_3");
13945   if (str && strcmp (str, "1") == 0) return 1;
13946   str = getenv ("SKIP_TEST_WRITE_FILE");
13947   if (str && strcmp (str, "1") == 0) return 1;
13948   return 0;
13949 }
13950
13951 static int test_write_file_3 (void)
13952 {
13953   if (test_write_file_3_skip ()) {
13954     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13955     return 0;
13956   }
13957
13958   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13959   {
13960     char device[] = "/dev/sda";
13961     int r;
13962     suppress_error = 0;
13963     r = guestfs_blockdev_setrw (g, device);
13964     if (r == -1)
13965       return -1;
13966   }
13967   {
13968     int r;
13969     suppress_error = 0;
13970     r = guestfs_umount_all (g);
13971     if (r == -1)
13972       return -1;
13973   }
13974   {
13975     int r;
13976     suppress_error = 0;
13977     r = guestfs_lvm_remove_all (g);
13978     if (r == -1)
13979       return -1;
13980   }
13981   {
13982     char device[] = "/dev/sda";
13983     char lines_0[] = ",";
13984     char *lines[] = {
13985       lines_0,
13986       NULL
13987     };
13988     int r;
13989     suppress_error = 0;
13990     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13991     if (r == -1)
13992       return -1;
13993   }
13994   {
13995     char fstype[] = "ext2";
13996     char device[] = "/dev/sda1";
13997     int r;
13998     suppress_error = 0;
13999     r = guestfs_mkfs (g, fstype, device);
14000     if (r == -1)
14001       return -1;
14002   }
14003   {
14004     char device[] = "/dev/sda1";
14005     char mountpoint[] = "/";
14006     int r;
14007     suppress_error = 0;
14008     r = guestfs_mount (g, device, mountpoint);
14009     if (r == -1)
14010       return -1;
14011   }
14012   /* TestOutput for write_file (3) */
14013   char expected[] = "";
14014   {
14015     char path[] = "/new";
14016     char content[] = "";
14017     int r;
14018     suppress_error = 0;
14019     r = guestfs_write_file (g, path, content, 0);
14020     if (r == -1)
14021       return -1;
14022   }
14023   {
14024     char path[] = "/new";
14025     char *r;
14026     suppress_error = 0;
14027     r = guestfs_cat (g, path);
14028     if (r == NULL)
14029       return -1;
14030     if (strcmp (r, expected) != 0) {
14031       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
14032       return -1;
14033     }
14034     free (r);
14035   }
14036   return 0;
14037 }
14038
14039 static int test_write_file_4_skip (void)
14040 {
14041   const char *str;
14042
14043   str = getenv ("TEST_ONLY");
14044   if (str)
14045     return strstr (str, "write_file") == NULL;
14046   str = getenv ("SKIP_TEST_WRITE_FILE_4");
14047   if (str && strcmp (str, "1") == 0) return 1;
14048   str = getenv ("SKIP_TEST_WRITE_FILE");
14049   if (str && strcmp (str, "1") == 0) return 1;
14050   return 0;
14051 }
14052
14053 static int test_write_file_4 (void)
14054 {
14055   if (test_write_file_4_skip ()) {
14056     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
14057     return 0;
14058   }
14059
14060   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
14061   {
14062     char device[] = "/dev/sda";
14063     int r;
14064     suppress_error = 0;
14065     r = guestfs_blockdev_setrw (g, device);
14066     if (r == -1)
14067       return -1;
14068   }
14069   {
14070     int r;
14071     suppress_error = 0;
14072     r = guestfs_umount_all (g);
14073     if (r == -1)
14074       return -1;
14075   }
14076   {
14077     int r;
14078     suppress_error = 0;
14079     r = guestfs_lvm_remove_all (g);
14080     if (r == -1)
14081       return -1;
14082   }
14083   {
14084     char device[] = "/dev/sda";
14085     char lines_0[] = ",";
14086     char *lines[] = {
14087       lines_0,
14088       NULL
14089     };
14090     int r;
14091     suppress_error = 0;
14092     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14093     if (r == -1)
14094       return -1;
14095   }
14096   {
14097     char fstype[] = "ext2";
14098     char device[] = "/dev/sda1";
14099     int r;
14100     suppress_error = 0;
14101     r = guestfs_mkfs (g, fstype, device);
14102     if (r == -1)
14103       return -1;
14104   }
14105   {
14106     char device[] = "/dev/sda1";
14107     char mountpoint[] = "/";
14108     int r;
14109     suppress_error = 0;
14110     r = guestfs_mount (g, device, mountpoint);
14111     if (r == -1)
14112       return -1;
14113   }
14114   /* TestOutput for write_file (4) */
14115   char expected[] = "\n\n\n";
14116   {
14117     char path[] = "/new";
14118     char content[] = "\n\n\n";
14119     int r;
14120     suppress_error = 0;
14121     r = guestfs_write_file (g, path, content, 0);
14122     if (r == -1)
14123       return -1;
14124   }
14125   {
14126     char path[] = "/new";
14127     char *r;
14128     suppress_error = 0;
14129     r = guestfs_cat (g, path);
14130     if (r == NULL)
14131       return -1;
14132     if (strcmp (r, expected) != 0) {
14133       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
14134       return -1;
14135     }
14136     free (r);
14137   }
14138   return 0;
14139 }
14140
14141 static int test_write_file_5_skip (void)
14142 {
14143   const char *str;
14144
14145   str = getenv ("TEST_ONLY");
14146   if (str)
14147     return strstr (str, "write_file") == NULL;
14148   str = getenv ("SKIP_TEST_WRITE_FILE_5");
14149   if (str && strcmp (str, "1") == 0) return 1;
14150   str = getenv ("SKIP_TEST_WRITE_FILE");
14151   if (str && strcmp (str, "1") == 0) return 1;
14152   return 0;
14153 }
14154
14155 static int test_write_file_5 (void)
14156 {
14157   if (test_write_file_5_skip ()) {
14158     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
14159     return 0;
14160   }
14161
14162   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
14163   {
14164     char device[] = "/dev/sda";
14165     int r;
14166     suppress_error = 0;
14167     r = guestfs_blockdev_setrw (g, device);
14168     if (r == -1)
14169       return -1;
14170   }
14171   {
14172     int r;
14173     suppress_error = 0;
14174     r = guestfs_umount_all (g);
14175     if (r == -1)
14176       return -1;
14177   }
14178   {
14179     int r;
14180     suppress_error = 0;
14181     r = guestfs_lvm_remove_all (g);
14182     if (r == -1)
14183       return -1;
14184   }
14185   {
14186     char device[] = "/dev/sda";
14187     char lines_0[] = ",";
14188     char *lines[] = {
14189       lines_0,
14190       NULL
14191     };
14192     int r;
14193     suppress_error = 0;
14194     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14195     if (r == -1)
14196       return -1;
14197   }
14198   {
14199     char fstype[] = "ext2";
14200     char device[] = "/dev/sda1";
14201     int r;
14202     suppress_error = 0;
14203     r = guestfs_mkfs (g, fstype, device);
14204     if (r == -1)
14205       return -1;
14206   }
14207   {
14208     char device[] = "/dev/sda1";
14209     char mountpoint[] = "/";
14210     int r;
14211     suppress_error = 0;
14212     r = guestfs_mount (g, device, mountpoint);
14213     if (r == -1)
14214       return -1;
14215   }
14216   /* TestOutput for write_file (5) */
14217   char expected[] = "\n";
14218   {
14219     char path[] = "/new";
14220     char content[] = "\n";
14221     int r;
14222     suppress_error = 0;
14223     r = guestfs_write_file (g, path, content, 0);
14224     if (r == -1)
14225       return -1;
14226   }
14227   {
14228     char path[] = "/new";
14229     char *r;
14230     suppress_error = 0;
14231     r = guestfs_cat (g, path);
14232     if (r == NULL)
14233       return -1;
14234     if (strcmp (r, expected) != 0) {
14235       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14236       return -1;
14237     }
14238     free (r);
14239   }
14240   return 0;
14241 }
14242
14243 static int test_mkfs_0_skip (void)
14244 {
14245   const char *str;
14246
14247   str = getenv ("TEST_ONLY");
14248   if (str)
14249     return strstr (str, "mkfs") == NULL;
14250   str = getenv ("SKIP_TEST_MKFS_0");
14251   if (str && strcmp (str, "1") == 0) return 1;
14252   str = getenv ("SKIP_TEST_MKFS");
14253   if (str && strcmp (str, "1") == 0) return 1;
14254   return 0;
14255 }
14256
14257 static int test_mkfs_0 (void)
14258 {
14259   if (test_mkfs_0_skip ()) {
14260     printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
14261     return 0;
14262   }
14263
14264   /* InitNone|InitEmpty for test_mkfs_0 */
14265   {
14266     char device[] = "/dev/sda";
14267     int r;
14268     suppress_error = 0;
14269     r = guestfs_blockdev_setrw (g, device);
14270     if (r == -1)
14271       return -1;
14272   }
14273   {
14274     int r;
14275     suppress_error = 0;
14276     r = guestfs_umount_all (g);
14277     if (r == -1)
14278       return -1;
14279   }
14280   {
14281     int r;
14282     suppress_error = 0;
14283     r = guestfs_lvm_remove_all (g);
14284     if (r == -1)
14285       return -1;
14286   }
14287   /* TestOutput for mkfs (0) */
14288   char expected[] = "new file contents";
14289   {
14290     char device[] = "/dev/sda";
14291     char lines_0[] = ",";
14292     char *lines[] = {
14293       lines_0,
14294       NULL
14295     };
14296     int r;
14297     suppress_error = 0;
14298     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14299     if (r == -1)
14300       return -1;
14301   }
14302   {
14303     char fstype[] = "ext2";
14304     char device[] = "/dev/sda1";
14305     int r;
14306     suppress_error = 0;
14307     r = guestfs_mkfs (g, fstype, device);
14308     if (r == -1)
14309       return -1;
14310   }
14311   {
14312     char device[] = "/dev/sda1";
14313     char mountpoint[] = "/";
14314     int r;
14315     suppress_error = 0;
14316     r = guestfs_mount (g, device, mountpoint);
14317     if (r == -1)
14318       return -1;
14319   }
14320   {
14321     char path[] = "/new";
14322     char content[] = "new file contents";
14323     int r;
14324     suppress_error = 0;
14325     r = guestfs_write_file (g, path, content, 0);
14326     if (r == -1)
14327       return -1;
14328   }
14329   {
14330     char path[] = "/new";
14331     char *r;
14332     suppress_error = 0;
14333     r = guestfs_cat (g, path);
14334     if (r == NULL)
14335       return -1;
14336     if (strcmp (r, expected) != 0) {
14337       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14338       return -1;
14339     }
14340     free (r);
14341   }
14342   return 0;
14343 }
14344
14345 static int test_lvcreate_0_skip (void)
14346 {
14347   const char *str;
14348
14349   str = getenv ("TEST_ONLY");
14350   if (str)
14351     return strstr (str, "lvcreate") == NULL;
14352   str = getenv ("SKIP_TEST_LVCREATE_0");
14353   if (str && strcmp (str, "1") == 0) return 1;
14354   str = getenv ("SKIP_TEST_LVCREATE");
14355   if (str && strcmp (str, "1") == 0) return 1;
14356   return 0;
14357 }
14358
14359 static int test_lvcreate_0 (void)
14360 {
14361   if (test_lvcreate_0_skip ()) {
14362     printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14363     return 0;
14364   }
14365
14366   /* InitNone|InitEmpty for test_lvcreate_0 */
14367   {
14368     char device[] = "/dev/sda";
14369     int r;
14370     suppress_error = 0;
14371     r = guestfs_blockdev_setrw (g, device);
14372     if (r == -1)
14373       return -1;
14374   }
14375   {
14376     int r;
14377     suppress_error = 0;
14378     r = guestfs_umount_all (g);
14379     if (r == -1)
14380       return -1;
14381   }
14382   {
14383     int r;
14384     suppress_error = 0;
14385     r = guestfs_lvm_remove_all (g);
14386     if (r == -1)
14387       return -1;
14388   }
14389   /* TestOutputList for lvcreate (0) */
14390   {
14391     char device[] = "/dev/sda";
14392     char lines_0[] = ",10";
14393     char lines_1[] = ",20";
14394     char lines_2[] = ",";
14395     char *lines[] = {
14396       lines_0,
14397       lines_1,
14398       lines_2,
14399       NULL
14400     };
14401     int r;
14402     suppress_error = 0;
14403     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14404     if (r == -1)
14405       return -1;
14406   }
14407   {
14408     char device[] = "/dev/sda1";
14409     int r;
14410     suppress_error = 0;
14411     r = guestfs_pvcreate (g, device);
14412     if (r == -1)
14413       return -1;
14414   }
14415   {
14416     char device[] = "/dev/sda2";
14417     int r;
14418     suppress_error = 0;
14419     r = guestfs_pvcreate (g, device);
14420     if (r == -1)
14421       return -1;
14422   }
14423   {
14424     char device[] = "/dev/sda3";
14425     int r;
14426     suppress_error = 0;
14427     r = guestfs_pvcreate (g, device);
14428     if (r == -1)
14429       return -1;
14430   }
14431   {
14432     char volgroup[] = "VG1";
14433     char physvols_0[] = "/dev/sda1";
14434     char physvols_1[] = "/dev/sda2";
14435     char *physvols[] = {
14436       physvols_0,
14437       physvols_1,
14438       NULL
14439     };
14440     int r;
14441     suppress_error = 0;
14442     r = guestfs_vgcreate (g, volgroup, physvols);
14443     if (r == -1)
14444       return -1;
14445   }
14446   {
14447     char volgroup[] = "VG2";
14448     char physvols_0[] = "/dev/sda3";
14449     char *physvols[] = {
14450       physvols_0,
14451       NULL
14452     };
14453     int r;
14454     suppress_error = 0;
14455     r = guestfs_vgcreate (g, volgroup, physvols);
14456     if (r == -1)
14457       return -1;
14458   }
14459   {
14460     char logvol[] = "LV1";
14461     char volgroup[] = "VG1";
14462     int r;
14463     suppress_error = 0;
14464     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14465     if (r == -1)
14466       return -1;
14467   }
14468   {
14469     char logvol[] = "LV2";
14470     char volgroup[] = "VG1";
14471     int r;
14472     suppress_error = 0;
14473     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14474     if (r == -1)
14475       return -1;
14476   }
14477   {
14478     char logvol[] = "LV3";
14479     char volgroup[] = "VG2";
14480     int r;
14481     suppress_error = 0;
14482     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14483     if (r == -1)
14484       return -1;
14485   }
14486   {
14487     char logvol[] = "LV4";
14488     char volgroup[] = "VG2";
14489     int r;
14490     suppress_error = 0;
14491     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14492     if (r == -1)
14493       return -1;
14494   }
14495   {
14496     char logvol[] = "LV5";
14497     char volgroup[] = "VG2";
14498     int r;
14499     suppress_error = 0;
14500     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14501     if (r == -1)
14502       return -1;
14503   }
14504   {
14505     char **r;
14506     int i;
14507     suppress_error = 0;
14508     r = guestfs_lvs (g);
14509     if (r == NULL)
14510       return -1;
14511     if (!r[0]) {
14512       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14513       print_strings (r);
14514       return -1;
14515     }
14516     {
14517       char expected[] = "/dev/VG1/LV1";
14518       if (strcmp (r[0], expected) != 0) {
14519         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14520         return -1;
14521       }
14522     }
14523     if (!r[1]) {
14524       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14525       print_strings (r);
14526       return -1;
14527     }
14528     {
14529       char expected[] = "/dev/VG1/LV2";
14530       if (strcmp (r[1], expected) != 0) {
14531         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14532         return -1;
14533       }
14534     }
14535     if (!r[2]) {
14536       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14537       print_strings (r);
14538       return -1;
14539     }
14540     {
14541       char expected[] = "/dev/VG2/LV3";
14542       if (strcmp (r[2], expected) != 0) {
14543         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14544         return -1;
14545       }
14546     }
14547     if (!r[3]) {
14548       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14549       print_strings (r);
14550       return -1;
14551     }
14552     {
14553       char expected[] = "/dev/VG2/LV4";
14554       if (strcmp (r[3], expected) != 0) {
14555         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14556         return -1;
14557       }
14558     }
14559     if (!r[4]) {
14560       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14561       print_strings (r);
14562       return -1;
14563     }
14564     {
14565       char expected[] = "/dev/VG2/LV5";
14566       if (strcmp (r[4], expected) != 0) {
14567         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14568         return -1;
14569       }
14570     }
14571     if (r[5] != NULL) {
14572       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14573       print_strings (r);
14574       return -1;
14575     }
14576     for (i = 0; r[i] != NULL; ++i)
14577       free (r[i]);
14578     free (r);
14579   }
14580   return 0;
14581 }
14582
14583 static int test_vgcreate_0_skip (void)
14584 {
14585   const char *str;
14586
14587   str = getenv ("TEST_ONLY");
14588   if (str)
14589     return strstr (str, "vgcreate") == NULL;
14590   str = getenv ("SKIP_TEST_VGCREATE_0");
14591   if (str && strcmp (str, "1") == 0) return 1;
14592   str = getenv ("SKIP_TEST_VGCREATE");
14593   if (str && strcmp (str, "1") == 0) return 1;
14594   return 0;
14595 }
14596
14597 static int test_vgcreate_0 (void)
14598 {
14599   if (test_vgcreate_0_skip ()) {
14600     printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14601     return 0;
14602   }
14603
14604   /* InitNone|InitEmpty for test_vgcreate_0 */
14605   {
14606     char device[] = "/dev/sda";
14607     int r;
14608     suppress_error = 0;
14609     r = guestfs_blockdev_setrw (g, device);
14610     if (r == -1)
14611       return -1;
14612   }
14613   {
14614     int r;
14615     suppress_error = 0;
14616     r = guestfs_umount_all (g);
14617     if (r == -1)
14618       return -1;
14619   }
14620   {
14621     int r;
14622     suppress_error = 0;
14623     r = guestfs_lvm_remove_all (g);
14624     if (r == -1)
14625       return -1;
14626   }
14627   /* TestOutputList for vgcreate (0) */
14628   {
14629     char device[] = "/dev/sda";
14630     char lines_0[] = ",10";
14631     char lines_1[] = ",20";
14632     char lines_2[] = ",";
14633     char *lines[] = {
14634       lines_0,
14635       lines_1,
14636       lines_2,
14637       NULL
14638     };
14639     int r;
14640     suppress_error = 0;
14641     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14642     if (r == -1)
14643       return -1;
14644   }
14645   {
14646     char device[] = "/dev/sda1";
14647     int r;
14648     suppress_error = 0;
14649     r = guestfs_pvcreate (g, device);
14650     if (r == -1)
14651       return -1;
14652   }
14653   {
14654     char device[] = "/dev/sda2";
14655     int r;
14656     suppress_error = 0;
14657     r = guestfs_pvcreate (g, device);
14658     if (r == -1)
14659       return -1;
14660   }
14661   {
14662     char device[] = "/dev/sda3";
14663     int r;
14664     suppress_error = 0;
14665     r = guestfs_pvcreate (g, device);
14666     if (r == -1)
14667       return -1;
14668   }
14669   {
14670     char volgroup[] = "VG1";
14671     char physvols_0[] = "/dev/sda1";
14672     char physvols_1[] = "/dev/sda2";
14673     char *physvols[] = {
14674       physvols_0,
14675       physvols_1,
14676       NULL
14677     };
14678     int r;
14679     suppress_error = 0;
14680     r = guestfs_vgcreate (g, volgroup, physvols);
14681     if (r == -1)
14682       return -1;
14683   }
14684   {
14685     char volgroup[] = "VG2";
14686     char physvols_0[] = "/dev/sda3";
14687     char *physvols[] = {
14688       physvols_0,
14689       NULL
14690     };
14691     int r;
14692     suppress_error = 0;
14693     r = guestfs_vgcreate (g, volgroup, physvols);
14694     if (r == -1)
14695       return -1;
14696   }
14697   {
14698     char **r;
14699     int i;
14700     suppress_error = 0;
14701     r = guestfs_vgs (g);
14702     if (r == NULL)
14703       return -1;
14704     if (!r[0]) {
14705       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14706       print_strings (r);
14707       return -1;
14708     }
14709     {
14710       char expected[] = "VG1";
14711       if (strcmp (r[0], expected) != 0) {
14712         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14713         return -1;
14714       }
14715     }
14716     if (!r[1]) {
14717       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14718       print_strings (r);
14719       return -1;
14720     }
14721     {
14722       char expected[] = "VG2";
14723       if (strcmp (r[1], expected) != 0) {
14724         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14725         return -1;
14726       }
14727     }
14728     if (r[2] != NULL) {
14729       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14730       print_strings (r);
14731       return -1;
14732     }
14733     for (i = 0; r[i] != NULL; ++i)
14734       free (r[i]);
14735     free (r);
14736   }
14737   return 0;
14738 }
14739
14740 static int test_pvcreate_0_skip (void)
14741 {
14742   const char *str;
14743
14744   str = getenv ("TEST_ONLY");
14745   if (str)
14746     return strstr (str, "pvcreate") == NULL;
14747   str = getenv ("SKIP_TEST_PVCREATE_0");
14748   if (str && strcmp (str, "1") == 0) return 1;
14749   str = getenv ("SKIP_TEST_PVCREATE");
14750   if (str && strcmp (str, "1") == 0) return 1;
14751   return 0;
14752 }
14753
14754 static int test_pvcreate_0 (void)
14755 {
14756   if (test_pvcreate_0_skip ()) {
14757     printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14758     return 0;
14759   }
14760
14761   /* InitNone|InitEmpty for test_pvcreate_0 */
14762   {
14763     char device[] = "/dev/sda";
14764     int r;
14765     suppress_error = 0;
14766     r = guestfs_blockdev_setrw (g, device);
14767     if (r == -1)
14768       return -1;
14769   }
14770   {
14771     int r;
14772     suppress_error = 0;
14773     r = guestfs_umount_all (g);
14774     if (r == -1)
14775       return -1;
14776   }
14777   {
14778     int r;
14779     suppress_error = 0;
14780     r = guestfs_lvm_remove_all (g);
14781     if (r == -1)
14782       return -1;
14783   }
14784   /* TestOutputListOfDevices for pvcreate (0) */
14785   {
14786     char device[] = "/dev/sda";
14787     char lines_0[] = ",10";
14788     char lines_1[] = ",20";
14789     char lines_2[] = ",";
14790     char *lines[] = {
14791       lines_0,
14792       lines_1,
14793       lines_2,
14794       NULL
14795     };
14796     int r;
14797     suppress_error = 0;
14798     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14799     if (r == -1)
14800       return -1;
14801   }
14802   {
14803     char device[] = "/dev/sda1";
14804     int r;
14805     suppress_error = 0;
14806     r = guestfs_pvcreate (g, device);
14807     if (r == -1)
14808       return -1;
14809   }
14810   {
14811     char device[] = "/dev/sda2";
14812     int r;
14813     suppress_error = 0;
14814     r = guestfs_pvcreate (g, device);
14815     if (r == -1)
14816       return -1;
14817   }
14818   {
14819     char device[] = "/dev/sda3";
14820     int r;
14821     suppress_error = 0;
14822     r = guestfs_pvcreate (g, device);
14823     if (r == -1)
14824       return -1;
14825   }
14826   {
14827     char **r;
14828     int i;
14829     suppress_error = 0;
14830     r = guestfs_pvs (g);
14831     if (r == NULL)
14832       return -1;
14833     if (!r[0]) {
14834       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14835       print_strings (r);
14836       return -1;
14837     }
14838     {
14839       char expected[] = "/dev/sda1";
14840       r[0][5] = 's';
14841       if (strcmp (r[0], expected) != 0) {
14842         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14843         return -1;
14844       }
14845     }
14846     if (!r[1]) {
14847       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14848       print_strings (r);
14849       return -1;
14850     }
14851     {
14852       char expected[] = "/dev/sda2";
14853       r[1][5] = 's';
14854       if (strcmp (r[1], expected) != 0) {
14855         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14856         return -1;
14857       }
14858     }
14859     if (!r[2]) {
14860       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14861       print_strings (r);
14862       return -1;
14863     }
14864     {
14865       char expected[] = "/dev/sda3";
14866       r[2][5] = 's';
14867       if (strcmp (r[2], expected) != 0) {
14868         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14869         return -1;
14870       }
14871     }
14872     if (r[3] != NULL) {
14873       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14874       print_strings (r);
14875       return -1;
14876     }
14877     for (i = 0; r[i] != NULL; ++i)
14878       free (r[i]);
14879     free (r);
14880   }
14881   return 0;
14882 }
14883
14884 static int test_is_dir_0_skip (void)
14885 {
14886   const char *str;
14887
14888   str = getenv ("TEST_ONLY");
14889   if (str)
14890     return strstr (str, "is_dir") == NULL;
14891   str = getenv ("SKIP_TEST_IS_DIR_0");
14892   if (str && strcmp (str, "1") == 0) return 1;
14893   str = getenv ("SKIP_TEST_IS_DIR");
14894   if (str && strcmp (str, "1") == 0) return 1;
14895   return 0;
14896 }
14897
14898 static int test_is_dir_0 (void)
14899 {
14900   if (test_is_dir_0_skip ()) {
14901     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14902     return 0;
14903   }
14904
14905   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14906   {
14907     char device[] = "/dev/sda";
14908     int r;
14909     suppress_error = 0;
14910     r = guestfs_blockdev_setrw (g, device);
14911     if (r == -1)
14912       return -1;
14913   }
14914   {
14915     int r;
14916     suppress_error = 0;
14917     r = guestfs_umount_all (g);
14918     if (r == -1)
14919       return -1;
14920   }
14921   {
14922     int r;
14923     suppress_error = 0;
14924     r = guestfs_lvm_remove_all (g);
14925     if (r == -1)
14926       return -1;
14927   }
14928   {
14929     char device[] = "/dev/sda";
14930     char lines_0[] = ",";
14931     char *lines[] = {
14932       lines_0,
14933       NULL
14934     };
14935     int r;
14936     suppress_error = 0;
14937     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14938     if (r == -1)
14939       return -1;
14940   }
14941   {
14942     char fstype[] = "ext2";
14943     char device[] = "/dev/sda1";
14944     int r;
14945     suppress_error = 0;
14946     r = guestfs_mkfs (g, fstype, device);
14947     if (r == -1)
14948       return -1;
14949   }
14950   {
14951     char device[] = "/dev/sda1";
14952     char mountpoint[] = "/";
14953     int r;
14954     suppress_error = 0;
14955     r = guestfs_mount (g, device, mountpoint);
14956     if (r == -1)
14957       return -1;
14958   }
14959   /* TestOutputFalse for is_dir (0) */
14960   {
14961     char path[] = "/new";
14962     int r;
14963     suppress_error = 0;
14964     r = guestfs_touch (g, path);
14965     if (r == -1)
14966       return -1;
14967   }
14968   {
14969     char path[] = "/new";
14970     int r;
14971     suppress_error = 0;
14972     r = guestfs_is_dir (g, path);
14973     if (r == -1)
14974       return -1;
14975     if (r) {
14976       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14977       return -1;
14978     }
14979   }
14980   return 0;
14981 }
14982
14983 static int test_is_dir_1_skip (void)
14984 {
14985   const char *str;
14986
14987   str = getenv ("TEST_ONLY");
14988   if (str)
14989     return strstr (str, "is_dir") == NULL;
14990   str = getenv ("SKIP_TEST_IS_DIR_1");
14991   if (str && strcmp (str, "1") == 0) return 1;
14992   str = getenv ("SKIP_TEST_IS_DIR");
14993   if (str && strcmp (str, "1") == 0) return 1;
14994   return 0;
14995 }
14996
14997 static int test_is_dir_1 (void)
14998 {
14999   if (test_is_dir_1_skip ()) {
15000     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
15001     return 0;
15002   }
15003
15004   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
15005   {
15006     char device[] = "/dev/sda";
15007     int r;
15008     suppress_error = 0;
15009     r = guestfs_blockdev_setrw (g, device);
15010     if (r == -1)
15011       return -1;
15012   }
15013   {
15014     int r;
15015     suppress_error = 0;
15016     r = guestfs_umount_all (g);
15017     if (r == -1)
15018       return -1;
15019   }
15020   {
15021     int r;
15022     suppress_error = 0;
15023     r = guestfs_lvm_remove_all (g);
15024     if (r == -1)
15025       return -1;
15026   }
15027   {
15028     char device[] = "/dev/sda";
15029     char lines_0[] = ",";
15030     char *lines[] = {
15031       lines_0,
15032       NULL
15033     };
15034     int r;
15035     suppress_error = 0;
15036     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15037     if (r == -1)
15038       return -1;
15039   }
15040   {
15041     char fstype[] = "ext2";
15042     char device[] = "/dev/sda1";
15043     int r;
15044     suppress_error = 0;
15045     r = guestfs_mkfs (g, fstype, device);
15046     if (r == -1)
15047       return -1;
15048   }
15049   {
15050     char device[] = "/dev/sda1";
15051     char mountpoint[] = "/";
15052     int r;
15053     suppress_error = 0;
15054     r = guestfs_mount (g, device, mountpoint);
15055     if (r == -1)
15056       return -1;
15057   }
15058   /* TestOutputTrue for is_dir (1) */
15059   {
15060     char path[] = "/new";
15061     int r;
15062     suppress_error = 0;
15063     r = guestfs_mkdir (g, path);
15064     if (r == -1)
15065       return -1;
15066   }
15067   {
15068     char path[] = "/new";
15069     int r;
15070     suppress_error = 0;
15071     r = guestfs_is_dir (g, path);
15072     if (r == -1)
15073       return -1;
15074     if (!r) {
15075       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
15076       return -1;
15077     }
15078   }
15079   return 0;
15080 }
15081
15082 static int test_is_file_0_skip (void)
15083 {
15084   const char *str;
15085
15086   str = getenv ("TEST_ONLY");
15087   if (str)
15088     return strstr (str, "is_file") == NULL;
15089   str = getenv ("SKIP_TEST_IS_FILE_0");
15090   if (str && strcmp (str, "1") == 0) return 1;
15091   str = getenv ("SKIP_TEST_IS_FILE");
15092   if (str && strcmp (str, "1") == 0) return 1;
15093   return 0;
15094 }
15095
15096 static int test_is_file_0 (void)
15097 {
15098   if (test_is_file_0_skip ()) {
15099     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
15100     return 0;
15101   }
15102
15103   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
15104   {
15105     char device[] = "/dev/sda";
15106     int r;
15107     suppress_error = 0;
15108     r = guestfs_blockdev_setrw (g, device);
15109     if (r == -1)
15110       return -1;
15111   }
15112   {
15113     int r;
15114     suppress_error = 0;
15115     r = guestfs_umount_all (g);
15116     if (r == -1)
15117       return -1;
15118   }
15119   {
15120     int r;
15121     suppress_error = 0;
15122     r = guestfs_lvm_remove_all (g);
15123     if (r == -1)
15124       return -1;
15125   }
15126   {
15127     char device[] = "/dev/sda";
15128     char lines_0[] = ",";
15129     char *lines[] = {
15130       lines_0,
15131       NULL
15132     };
15133     int r;
15134     suppress_error = 0;
15135     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15136     if (r == -1)
15137       return -1;
15138   }
15139   {
15140     char fstype[] = "ext2";
15141     char device[] = "/dev/sda1";
15142     int r;
15143     suppress_error = 0;
15144     r = guestfs_mkfs (g, fstype, device);
15145     if (r == -1)
15146       return -1;
15147   }
15148   {
15149     char device[] = "/dev/sda1";
15150     char mountpoint[] = "/";
15151     int r;
15152     suppress_error = 0;
15153     r = guestfs_mount (g, device, mountpoint);
15154     if (r == -1)
15155       return -1;
15156   }
15157   /* TestOutputTrue for is_file (0) */
15158   {
15159     char path[] = "/new";
15160     int r;
15161     suppress_error = 0;
15162     r = guestfs_touch (g, path);
15163     if (r == -1)
15164       return -1;
15165   }
15166   {
15167     char path[] = "/new";
15168     int r;
15169     suppress_error = 0;
15170     r = guestfs_is_file (g, path);
15171     if (r == -1)
15172       return -1;
15173     if (!r) {
15174       fprintf (stderr, "test_is_file_0: expected true, got false\n");
15175       return -1;
15176     }
15177   }
15178   return 0;
15179 }
15180
15181 static int test_is_file_1_skip (void)
15182 {
15183   const char *str;
15184
15185   str = getenv ("TEST_ONLY");
15186   if (str)
15187     return strstr (str, "is_file") == NULL;
15188   str = getenv ("SKIP_TEST_IS_FILE_1");
15189   if (str && strcmp (str, "1") == 0) return 1;
15190   str = getenv ("SKIP_TEST_IS_FILE");
15191   if (str && strcmp (str, "1") == 0) return 1;
15192   return 0;
15193 }
15194
15195 static int test_is_file_1 (void)
15196 {
15197   if (test_is_file_1_skip ()) {
15198     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
15199     return 0;
15200   }
15201
15202   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
15203   {
15204     char device[] = "/dev/sda";
15205     int r;
15206     suppress_error = 0;
15207     r = guestfs_blockdev_setrw (g, device);
15208     if (r == -1)
15209       return -1;
15210   }
15211   {
15212     int r;
15213     suppress_error = 0;
15214     r = guestfs_umount_all (g);
15215     if (r == -1)
15216       return -1;
15217   }
15218   {
15219     int r;
15220     suppress_error = 0;
15221     r = guestfs_lvm_remove_all (g);
15222     if (r == -1)
15223       return -1;
15224   }
15225   {
15226     char device[] = "/dev/sda";
15227     char lines_0[] = ",";
15228     char *lines[] = {
15229       lines_0,
15230       NULL
15231     };
15232     int r;
15233     suppress_error = 0;
15234     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15235     if (r == -1)
15236       return -1;
15237   }
15238   {
15239     char fstype[] = "ext2";
15240     char device[] = "/dev/sda1";
15241     int r;
15242     suppress_error = 0;
15243     r = guestfs_mkfs (g, fstype, device);
15244     if (r == -1)
15245       return -1;
15246   }
15247   {
15248     char device[] = "/dev/sda1";
15249     char mountpoint[] = "/";
15250     int r;
15251     suppress_error = 0;
15252     r = guestfs_mount (g, device, mountpoint);
15253     if (r == -1)
15254       return -1;
15255   }
15256   /* TestOutputFalse for is_file (1) */
15257   {
15258     char path[] = "/new";
15259     int r;
15260     suppress_error = 0;
15261     r = guestfs_mkdir (g, path);
15262     if (r == -1)
15263       return -1;
15264   }
15265   {
15266     char path[] = "/new";
15267     int r;
15268     suppress_error = 0;
15269     r = guestfs_is_file (g, path);
15270     if (r == -1)
15271       return -1;
15272     if (r) {
15273       fprintf (stderr, "test_is_file_1: expected false, got true\n");
15274       return -1;
15275     }
15276   }
15277   return 0;
15278 }
15279
15280 static int test_exists_0_skip (void)
15281 {
15282   const char *str;
15283
15284   str = getenv ("TEST_ONLY");
15285   if (str)
15286     return strstr (str, "exists") == NULL;
15287   str = getenv ("SKIP_TEST_EXISTS_0");
15288   if (str && strcmp (str, "1") == 0) return 1;
15289   str = getenv ("SKIP_TEST_EXISTS");
15290   if (str && strcmp (str, "1") == 0) return 1;
15291   return 0;
15292 }
15293
15294 static int test_exists_0 (void)
15295 {
15296   if (test_exists_0_skip ()) {
15297     printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
15298     return 0;
15299   }
15300
15301   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15302   {
15303     char device[] = "/dev/sda";
15304     int r;
15305     suppress_error = 0;
15306     r = guestfs_blockdev_setrw (g, device);
15307     if (r == -1)
15308       return -1;
15309   }
15310   {
15311     int r;
15312     suppress_error = 0;
15313     r = guestfs_umount_all (g);
15314     if (r == -1)
15315       return -1;
15316   }
15317   {
15318     int r;
15319     suppress_error = 0;
15320     r = guestfs_lvm_remove_all (g);
15321     if (r == -1)
15322       return -1;
15323   }
15324   {
15325     char device[] = "/dev/sda";
15326     char lines_0[] = ",";
15327     char *lines[] = {
15328       lines_0,
15329       NULL
15330     };
15331     int r;
15332     suppress_error = 0;
15333     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15334     if (r == -1)
15335       return -1;
15336   }
15337   {
15338     char fstype[] = "ext2";
15339     char device[] = "/dev/sda1";
15340     int r;
15341     suppress_error = 0;
15342     r = guestfs_mkfs (g, fstype, device);
15343     if (r == -1)
15344       return -1;
15345   }
15346   {
15347     char device[] = "/dev/sda1";
15348     char mountpoint[] = "/";
15349     int r;
15350     suppress_error = 0;
15351     r = guestfs_mount (g, device, mountpoint);
15352     if (r == -1)
15353       return -1;
15354   }
15355   /* TestOutputTrue for exists (0) */
15356   {
15357     char path[] = "/new";
15358     int r;
15359     suppress_error = 0;
15360     r = guestfs_touch (g, path);
15361     if (r == -1)
15362       return -1;
15363   }
15364   {
15365     char path[] = "/new";
15366     int r;
15367     suppress_error = 0;
15368     r = guestfs_exists (g, path);
15369     if (r == -1)
15370       return -1;
15371     if (!r) {
15372       fprintf (stderr, "test_exists_0: expected true, got false\n");
15373       return -1;
15374     }
15375   }
15376   return 0;
15377 }
15378
15379 static int test_exists_1_skip (void)
15380 {
15381   const char *str;
15382
15383   str = getenv ("TEST_ONLY");
15384   if (str)
15385     return strstr (str, "exists") == NULL;
15386   str = getenv ("SKIP_TEST_EXISTS_1");
15387   if (str && strcmp (str, "1") == 0) return 1;
15388   str = getenv ("SKIP_TEST_EXISTS");
15389   if (str && strcmp (str, "1") == 0) return 1;
15390   return 0;
15391 }
15392
15393 static int test_exists_1 (void)
15394 {
15395   if (test_exists_1_skip ()) {
15396     printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15397     return 0;
15398   }
15399
15400   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15401   {
15402     char device[] = "/dev/sda";
15403     int r;
15404     suppress_error = 0;
15405     r = guestfs_blockdev_setrw (g, device);
15406     if (r == -1)
15407       return -1;
15408   }
15409   {
15410     int r;
15411     suppress_error = 0;
15412     r = guestfs_umount_all (g);
15413     if (r == -1)
15414       return -1;
15415   }
15416   {
15417     int r;
15418     suppress_error = 0;
15419     r = guestfs_lvm_remove_all (g);
15420     if (r == -1)
15421       return -1;
15422   }
15423   {
15424     char device[] = "/dev/sda";
15425     char lines_0[] = ",";
15426     char *lines[] = {
15427       lines_0,
15428       NULL
15429     };
15430     int r;
15431     suppress_error = 0;
15432     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15433     if (r == -1)
15434       return -1;
15435   }
15436   {
15437     char fstype[] = "ext2";
15438     char device[] = "/dev/sda1";
15439     int r;
15440     suppress_error = 0;
15441     r = guestfs_mkfs (g, fstype, device);
15442     if (r == -1)
15443       return -1;
15444   }
15445   {
15446     char device[] = "/dev/sda1";
15447     char mountpoint[] = "/";
15448     int r;
15449     suppress_error = 0;
15450     r = guestfs_mount (g, device, mountpoint);
15451     if (r == -1)
15452       return -1;
15453   }
15454   /* TestOutputTrue for exists (1) */
15455   {
15456     char path[] = "/new";
15457     int r;
15458     suppress_error = 0;
15459     r = guestfs_mkdir (g, path);
15460     if (r == -1)
15461       return -1;
15462   }
15463   {
15464     char path[] = "/new";
15465     int r;
15466     suppress_error = 0;
15467     r = guestfs_exists (g, path);
15468     if (r == -1)
15469       return -1;
15470     if (!r) {
15471       fprintf (stderr, "test_exists_1: expected true, got false\n");
15472       return -1;
15473     }
15474   }
15475   return 0;
15476 }
15477
15478 static int test_mkdir_p_0_skip (void)
15479 {
15480   const char *str;
15481
15482   str = getenv ("TEST_ONLY");
15483   if (str)
15484     return strstr (str, "mkdir_p") == NULL;
15485   str = getenv ("SKIP_TEST_MKDIR_P_0");
15486   if (str && strcmp (str, "1") == 0) return 1;
15487   str = getenv ("SKIP_TEST_MKDIR_P");
15488   if (str && strcmp (str, "1") == 0) return 1;
15489   return 0;
15490 }
15491
15492 static int test_mkdir_p_0 (void)
15493 {
15494   if (test_mkdir_p_0_skip ()) {
15495     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15496     return 0;
15497   }
15498
15499   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15500   {
15501     char device[] = "/dev/sda";
15502     int r;
15503     suppress_error = 0;
15504     r = guestfs_blockdev_setrw (g, device);
15505     if (r == -1)
15506       return -1;
15507   }
15508   {
15509     int r;
15510     suppress_error = 0;
15511     r = guestfs_umount_all (g);
15512     if (r == -1)
15513       return -1;
15514   }
15515   {
15516     int r;
15517     suppress_error = 0;
15518     r = guestfs_lvm_remove_all (g);
15519     if (r == -1)
15520       return -1;
15521   }
15522   {
15523     char device[] = "/dev/sda";
15524     char lines_0[] = ",";
15525     char *lines[] = {
15526       lines_0,
15527       NULL
15528     };
15529     int r;
15530     suppress_error = 0;
15531     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15532     if (r == -1)
15533       return -1;
15534   }
15535   {
15536     char fstype[] = "ext2";
15537     char device[] = "/dev/sda1";
15538     int r;
15539     suppress_error = 0;
15540     r = guestfs_mkfs (g, fstype, device);
15541     if (r == -1)
15542       return -1;
15543   }
15544   {
15545     char device[] = "/dev/sda1";
15546     char mountpoint[] = "/";
15547     int r;
15548     suppress_error = 0;
15549     r = guestfs_mount (g, device, mountpoint);
15550     if (r == -1)
15551       return -1;
15552   }
15553   /* TestOutputTrue for mkdir_p (0) */
15554   {
15555     char path[] = "/new/foo/bar";
15556     int r;
15557     suppress_error = 0;
15558     r = guestfs_mkdir_p (g, path);
15559     if (r == -1)
15560       return -1;
15561   }
15562   {
15563     char path[] = "/new/foo/bar";
15564     int r;
15565     suppress_error = 0;
15566     r = guestfs_is_dir (g, path);
15567     if (r == -1)
15568       return -1;
15569     if (!r) {
15570       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15571       return -1;
15572     }
15573   }
15574   return 0;
15575 }
15576
15577 static int test_mkdir_p_1_skip (void)
15578 {
15579   const char *str;
15580
15581   str = getenv ("TEST_ONLY");
15582   if (str)
15583     return strstr (str, "mkdir_p") == NULL;
15584   str = getenv ("SKIP_TEST_MKDIR_P_1");
15585   if (str && strcmp (str, "1") == 0) return 1;
15586   str = getenv ("SKIP_TEST_MKDIR_P");
15587   if (str && strcmp (str, "1") == 0) return 1;
15588   return 0;
15589 }
15590
15591 static int test_mkdir_p_1 (void)
15592 {
15593   if (test_mkdir_p_1_skip ()) {
15594     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15595     return 0;
15596   }
15597
15598   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15599   {
15600     char device[] = "/dev/sda";
15601     int r;
15602     suppress_error = 0;
15603     r = guestfs_blockdev_setrw (g, device);
15604     if (r == -1)
15605       return -1;
15606   }
15607   {
15608     int r;
15609     suppress_error = 0;
15610     r = guestfs_umount_all (g);
15611     if (r == -1)
15612       return -1;
15613   }
15614   {
15615     int r;
15616     suppress_error = 0;
15617     r = guestfs_lvm_remove_all (g);
15618     if (r == -1)
15619       return -1;
15620   }
15621   {
15622     char device[] = "/dev/sda";
15623     char lines_0[] = ",";
15624     char *lines[] = {
15625       lines_0,
15626       NULL
15627     };
15628     int r;
15629     suppress_error = 0;
15630     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15631     if (r == -1)
15632       return -1;
15633   }
15634   {
15635     char fstype[] = "ext2";
15636     char device[] = "/dev/sda1";
15637     int r;
15638     suppress_error = 0;
15639     r = guestfs_mkfs (g, fstype, device);
15640     if (r == -1)
15641       return -1;
15642   }
15643   {
15644     char device[] = "/dev/sda1";
15645     char mountpoint[] = "/";
15646     int r;
15647     suppress_error = 0;
15648     r = guestfs_mount (g, device, mountpoint);
15649     if (r == -1)
15650       return -1;
15651   }
15652   /* TestOutputTrue for mkdir_p (1) */
15653   {
15654     char path[] = "/new/foo/bar";
15655     int r;
15656     suppress_error = 0;
15657     r = guestfs_mkdir_p (g, path);
15658     if (r == -1)
15659       return -1;
15660   }
15661   {
15662     char path[] = "/new/foo";
15663     int r;
15664     suppress_error = 0;
15665     r = guestfs_is_dir (g, path);
15666     if (r == -1)
15667       return -1;
15668     if (!r) {
15669       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15670       return -1;
15671     }
15672   }
15673   return 0;
15674 }
15675
15676 static int test_mkdir_p_2_skip (void)
15677 {
15678   const char *str;
15679
15680   str = getenv ("TEST_ONLY");
15681   if (str)
15682     return strstr (str, "mkdir_p") == NULL;
15683   str = getenv ("SKIP_TEST_MKDIR_P_2");
15684   if (str && strcmp (str, "1") == 0) return 1;
15685   str = getenv ("SKIP_TEST_MKDIR_P");
15686   if (str && strcmp (str, "1") == 0) return 1;
15687   return 0;
15688 }
15689
15690 static int test_mkdir_p_2 (void)
15691 {
15692   if (test_mkdir_p_2_skip ()) {
15693     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15694     return 0;
15695   }
15696
15697   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15698   {
15699     char device[] = "/dev/sda";
15700     int r;
15701     suppress_error = 0;
15702     r = guestfs_blockdev_setrw (g, device);
15703     if (r == -1)
15704       return -1;
15705   }
15706   {
15707     int r;
15708     suppress_error = 0;
15709     r = guestfs_umount_all (g);
15710     if (r == -1)
15711       return -1;
15712   }
15713   {
15714     int r;
15715     suppress_error = 0;
15716     r = guestfs_lvm_remove_all (g);
15717     if (r == -1)
15718       return -1;
15719   }
15720   {
15721     char device[] = "/dev/sda";
15722     char lines_0[] = ",";
15723     char *lines[] = {
15724       lines_0,
15725       NULL
15726     };
15727     int r;
15728     suppress_error = 0;
15729     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15730     if (r == -1)
15731       return -1;
15732   }
15733   {
15734     char fstype[] = "ext2";
15735     char device[] = "/dev/sda1";
15736     int r;
15737     suppress_error = 0;
15738     r = guestfs_mkfs (g, fstype, device);
15739     if (r == -1)
15740       return -1;
15741   }
15742   {
15743     char device[] = "/dev/sda1";
15744     char mountpoint[] = "/";
15745     int r;
15746     suppress_error = 0;
15747     r = guestfs_mount (g, device, mountpoint);
15748     if (r == -1)
15749       return -1;
15750   }
15751   /* TestOutputTrue for mkdir_p (2) */
15752   {
15753     char path[] = "/new/foo/bar";
15754     int r;
15755     suppress_error = 0;
15756     r = guestfs_mkdir_p (g, path);
15757     if (r == -1)
15758       return -1;
15759   }
15760   {
15761     char path[] = "/new";
15762     int r;
15763     suppress_error = 0;
15764     r = guestfs_is_dir (g, path);
15765     if (r == -1)
15766       return -1;
15767     if (!r) {
15768       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15769       return -1;
15770     }
15771   }
15772   return 0;
15773 }
15774
15775 static int test_mkdir_p_3_skip (void)
15776 {
15777   const char *str;
15778
15779   str = getenv ("TEST_ONLY");
15780   if (str)
15781     return strstr (str, "mkdir_p") == NULL;
15782   str = getenv ("SKIP_TEST_MKDIR_P_3");
15783   if (str && strcmp (str, "1") == 0) return 1;
15784   str = getenv ("SKIP_TEST_MKDIR_P");
15785   if (str && strcmp (str, "1") == 0) return 1;
15786   return 0;
15787 }
15788
15789 static int test_mkdir_p_3 (void)
15790 {
15791   if (test_mkdir_p_3_skip ()) {
15792     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15793     return 0;
15794   }
15795
15796   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15797   {
15798     char device[] = "/dev/sda";
15799     int r;
15800     suppress_error = 0;
15801     r = guestfs_blockdev_setrw (g, device);
15802     if (r == -1)
15803       return -1;
15804   }
15805   {
15806     int r;
15807     suppress_error = 0;
15808     r = guestfs_umount_all (g);
15809     if (r == -1)
15810       return -1;
15811   }
15812   {
15813     int r;
15814     suppress_error = 0;
15815     r = guestfs_lvm_remove_all (g);
15816     if (r == -1)
15817       return -1;
15818   }
15819   {
15820     char device[] = "/dev/sda";
15821     char lines_0[] = ",";
15822     char *lines[] = {
15823       lines_0,
15824       NULL
15825     };
15826     int r;
15827     suppress_error = 0;
15828     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15829     if (r == -1)
15830       return -1;
15831   }
15832   {
15833     char fstype[] = "ext2";
15834     char device[] = "/dev/sda1";
15835     int r;
15836     suppress_error = 0;
15837     r = guestfs_mkfs (g, fstype, device);
15838     if (r == -1)
15839       return -1;
15840   }
15841   {
15842     char device[] = "/dev/sda1";
15843     char mountpoint[] = "/";
15844     int r;
15845     suppress_error = 0;
15846     r = guestfs_mount (g, device, mountpoint);
15847     if (r == -1)
15848       return -1;
15849   }
15850   /* TestRun for mkdir_p (3) */
15851   {
15852     char path[] = "/new";
15853     int r;
15854     suppress_error = 0;
15855     r = guestfs_mkdir (g, path);
15856     if (r == -1)
15857       return -1;
15858   }
15859   {
15860     char path[] = "/new";
15861     int r;
15862     suppress_error = 0;
15863     r = guestfs_mkdir_p (g, path);
15864     if (r == -1)
15865       return -1;
15866   }
15867   return 0;
15868 }
15869
15870 static int test_mkdir_p_4_skip (void)
15871 {
15872   const char *str;
15873
15874   str = getenv ("TEST_ONLY");
15875   if (str)
15876     return strstr (str, "mkdir_p") == NULL;
15877   str = getenv ("SKIP_TEST_MKDIR_P_4");
15878   if (str && strcmp (str, "1") == 0) return 1;
15879   str = getenv ("SKIP_TEST_MKDIR_P");
15880   if (str && strcmp (str, "1") == 0) return 1;
15881   return 0;
15882 }
15883
15884 static int test_mkdir_p_4 (void)
15885 {
15886   if (test_mkdir_p_4_skip ()) {
15887     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15888     return 0;
15889   }
15890
15891   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15892   {
15893     char device[] = "/dev/sda";
15894     int r;
15895     suppress_error = 0;
15896     r = guestfs_blockdev_setrw (g, device);
15897     if (r == -1)
15898       return -1;
15899   }
15900   {
15901     int r;
15902     suppress_error = 0;
15903     r = guestfs_umount_all (g);
15904     if (r == -1)
15905       return -1;
15906   }
15907   {
15908     int r;
15909     suppress_error = 0;
15910     r = guestfs_lvm_remove_all (g);
15911     if (r == -1)
15912       return -1;
15913   }
15914   {
15915     char device[] = "/dev/sda";
15916     char lines_0[] = ",";
15917     char *lines[] = {
15918       lines_0,
15919       NULL
15920     };
15921     int r;
15922     suppress_error = 0;
15923     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15924     if (r == -1)
15925       return -1;
15926   }
15927   {
15928     char fstype[] = "ext2";
15929     char device[] = "/dev/sda1";
15930     int r;
15931     suppress_error = 0;
15932     r = guestfs_mkfs (g, fstype, device);
15933     if (r == -1)
15934       return -1;
15935   }
15936   {
15937     char device[] = "/dev/sda1";
15938     char mountpoint[] = "/";
15939     int r;
15940     suppress_error = 0;
15941     r = guestfs_mount (g, device, mountpoint);
15942     if (r == -1)
15943       return -1;
15944   }
15945   /* TestLastFail for mkdir_p (4) */
15946   {
15947     char path[] = "/new";
15948     int r;
15949     suppress_error = 0;
15950     r = guestfs_touch (g, path);
15951     if (r == -1)
15952       return -1;
15953   }
15954   {
15955     char path[] = "/new";
15956     int r;
15957     suppress_error = 1;
15958     r = guestfs_mkdir_p (g, path);
15959     if (r != -1)
15960       return -1;
15961   }
15962   return 0;
15963 }
15964
15965 static int test_mkdir_0_skip (void)
15966 {
15967   const char *str;
15968
15969   str = getenv ("TEST_ONLY");
15970   if (str)
15971     return strstr (str, "mkdir") == NULL;
15972   str = getenv ("SKIP_TEST_MKDIR_0");
15973   if (str && strcmp (str, "1") == 0) return 1;
15974   str = getenv ("SKIP_TEST_MKDIR");
15975   if (str && strcmp (str, "1") == 0) return 1;
15976   return 0;
15977 }
15978
15979 static int test_mkdir_0 (void)
15980 {
15981   if (test_mkdir_0_skip ()) {
15982     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15983     return 0;
15984   }
15985
15986   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15987   {
15988     char device[] = "/dev/sda";
15989     int r;
15990     suppress_error = 0;
15991     r = guestfs_blockdev_setrw (g, device);
15992     if (r == -1)
15993       return -1;
15994   }
15995   {
15996     int r;
15997     suppress_error = 0;
15998     r = guestfs_umount_all (g);
15999     if (r == -1)
16000       return -1;
16001   }
16002   {
16003     int r;
16004     suppress_error = 0;
16005     r = guestfs_lvm_remove_all (g);
16006     if (r == -1)
16007       return -1;
16008   }
16009   {
16010     char device[] = "/dev/sda";
16011     char lines_0[] = ",";
16012     char *lines[] = {
16013       lines_0,
16014       NULL
16015     };
16016     int r;
16017     suppress_error = 0;
16018     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16019     if (r == -1)
16020       return -1;
16021   }
16022   {
16023     char fstype[] = "ext2";
16024     char device[] = "/dev/sda1";
16025     int r;
16026     suppress_error = 0;
16027     r = guestfs_mkfs (g, fstype, device);
16028     if (r == -1)
16029       return -1;
16030   }
16031   {
16032     char device[] = "/dev/sda1";
16033     char mountpoint[] = "/";
16034     int r;
16035     suppress_error = 0;
16036     r = guestfs_mount (g, device, mountpoint);
16037     if (r == -1)
16038       return -1;
16039   }
16040   /* TestOutputTrue for mkdir (0) */
16041   {
16042     char path[] = "/new";
16043     int r;
16044     suppress_error = 0;
16045     r = guestfs_mkdir (g, path);
16046     if (r == -1)
16047       return -1;
16048   }
16049   {
16050     char path[] = "/new";
16051     int r;
16052     suppress_error = 0;
16053     r = guestfs_is_dir (g, path);
16054     if (r == -1)
16055       return -1;
16056     if (!r) {
16057       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
16058       return -1;
16059     }
16060   }
16061   return 0;
16062 }
16063
16064 static int test_mkdir_1_skip (void)
16065 {
16066   const char *str;
16067
16068   str = getenv ("TEST_ONLY");
16069   if (str)
16070     return strstr (str, "mkdir") == NULL;
16071   str = getenv ("SKIP_TEST_MKDIR_1");
16072   if (str && strcmp (str, "1") == 0) return 1;
16073   str = getenv ("SKIP_TEST_MKDIR");
16074   if (str && strcmp (str, "1") == 0) return 1;
16075   return 0;
16076 }
16077
16078 static int test_mkdir_1 (void)
16079 {
16080   if (test_mkdir_1_skip ()) {
16081     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
16082     return 0;
16083   }
16084
16085   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
16086   {
16087     char device[] = "/dev/sda";
16088     int r;
16089     suppress_error = 0;
16090     r = guestfs_blockdev_setrw (g, device);
16091     if (r == -1)
16092       return -1;
16093   }
16094   {
16095     int r;
16096     suppress_error = 0;
16097     r = guestfs_umount_all (g);
16098     if (r == -1)
16099       return -1;
16100   }
16101   {
16102     int r;
16103     suppress_error = 0;
16104     r = guestfs_lvm_remove_all (g);
16105     if (r == -1)
16106       return -1;
16107   }
16108   {
16109     char device[] = "/dev/sda";
16110     char lines_0[] = ",";
16111     char *lines[] = {
16112       lines_0,
16113       NULL
16114     };
16115     int r;
16116     suppress_error = 0;
16117     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16118     if (r == -1)
16119       return -1;
16120   }
16121   {
16122     char fstype[] = "ext2";
16123     char device[] = "/dev/sda1";
16124     int r;
16125     suppress_error = 0;
16126     r = guestfs_mkfs (g, fstype, device);
16127     if (r == -1)
16128       return -1;
16129   }
16130   {
16131     char device[] = "/dev/sda1";
16132     char mountpoint[] = "/";
16133     int r;
16134     suppress_error = 0;
16135     r = guestfs_mount (g, device, mountpoint);
16136     if (r == -1)
16137       return -1;
16138   }
16139   /* TestLastFail for mkdir (1) */
16140   {
16141     char path[] = "/new/foo/bar";
16142     int r;
16143     suppress_error = 1;
16144     r = guestfs_mkdir (g, path);
16145     if (r != -1)
16146       return -1;
16147   }
16148   return 0;
16149 }
16150
16151 static int test_rm_rf_0_skip (void)
16152 {
16153   const char *str;
16154
16155   str = getenv ("TEST_ONLY");
16156   if (str)
16157     return strstr (str, "rm_rf") == NULL;
16158   str = getenv ("SKIP_TEST_RM_RF_0");
16159   if (str && strcmp (str, "1") == 0) return 1;
16160   str = getenv ("SKIP_TEST_RM_RF");
16161   if (str && strcmp (str, "1") == 0) return 1;
16162   return 0;
16163 }
16164
16165 static int test_rm_rf_0 (void)
16166 {
16167   if (test_rm_rf_0_skip ()) {
16168     printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
16169     return 0;
16170   }
16171
16172   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
16173   {
16174     char device[] = "/dev/sda";
16175     int r;
16176     suppress_error = 0;
16177     r = guestfs_blockdev_setrw (g, device);
16178     if (r == -1)
16179       return -1;
16180   }
16181   {
16182     int r;
16183     suppress_error = 0;
16184     r = guestfs_umount_all (g);
16185     if (r == -1)
16186       return -1;
16187   }
16188   {
16189     int r;
16190     suppress_error = 0;
16191     r = guestfs_lvm_remove_all (g);
16192     if (r == -1)
16193       return -1;
16194   }
16195   {
16196     char device[] = "/dev/sda";
16197     char lines_0[] = ",";
16198     char *lines[] = {
16199       lines_0,
16200       NULL
16201     };
16202     int r;
16203     suppress_error = 0;
16204     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16205     if (r == -1)
16206       return -1;
16207   }
16208   {
16209     char fstype[] = "ext2";
16210     char device[] = "/dev/sda1";
16211     int r;
16212     suppress_error = 0;
16213     r = guestfs_mkfs (g, fstype, device);
16214     if (r == -1)
16215       return -1;
16216   }
16217   {
16218     char device[] = "/dev/sda1";
16219     char mountpoint[] = "/";
16220     int r;
16221     suppress_error = 0;
16222     r = guestfs_mount (g, device, mountpoint);
16223     if (r == -1)
16224       return -1;
16225   }
16226   /* TestOutputFalse for rm_rf (0) */
16227   {
16228     char path[] = "/new";
16229     int r;
16230     suppress_error = 0;
16231     r = guestfs_mkdir (g, path);
16232     if (r == -1)
16233       return -1;
16234   }
16235   {
16236     char path[] = "/new/foo";
16237     int r;
16238     suppress_error = 0;
16239     r = guestfs_mkdir (g, path);
16240     if (r == -1)
16241       return -1;
16242   }
16243   {
16244     char path[] = "/new/foo/bar";
16245     int r;
16246     suppress_error = 0;
16247     r = guestfs_touch (g, path);
16248     if (r == -1)
16249       return -1;
16250   }
16251   {
16252     char path[] = "/new";
16253     int r;
16254     suppress_error = 0;
16255     r = guestfs_rm_rf (g, path);
16256     if (r == -1)
16257       return -1;
16258   }
16259   {
16260     char path[] = "/new";
16261     int r;
16262     suppress_error = 0;
16263     r = guestfs_exists (g, path);
16264     if (r == -1)
16265       return -1;
16266     if (r) {
16267       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16268       return -1;
16269     }
16270   }
16271   return 0;
16272 }
16273
16274 static int test_rmdir_0_skip (void)
16275 {
16276   const char *str;
16277
16278   str = getenv ("TEST_ONLY");
16279   if (str)
16280     return strstr (str, "rmdir") == NULL;
16281   str = getenv ("SKIP_TEST_RMDIR_0");
16282   if (str && strcmp (str, "1") == 0) return 1;
16283   str = getenv ("SKIP_TEST_RMDIR");
16284   if (str && strcmp (str, "1") == 0) return 1;
16285   return 0;
16286 }
16287
16288 static int test_rmdir_0 (void)
16289 {
16290   if (test_rmdir_0_skip ()) {
16291     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
16292     return 0;
16293   }
16294
16295   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16296   {
16297     char device[] = "/dev/sda";
16298     int r;
16299     suppress_error = 0;
16300     r = guestfs_blockdev_setrw (g, device);
16301     if (r == -1)
16302       return -1;
16303   }
16304   {
16305     int r;
16306     suppress_error = 0;
16307     r = guestfs_umount_all (g);
16308     if (r == -1)
16309       return -1;
16310   }
16311   {
16312     int r;
16313     suppress_error = 0;
16314     r = guestfs_lvm_remove_all (g);
16315     if (r == -1)
16316       return -1;
16317   }
16318   {
16319     char device[] = "/dev/sda";
16320     char lines_0[] = ",";
16321     char *lines[] = {
16322       lines_0,
16323       NULL
16324     };
16325     int r;
16326     suppress_error = 0;
16327     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16328     if (r == -1)
16329       return -1;
16330   }
16331   {
16332     char fstype[] = "ext2";
16333     char device[] = "/dev/sda1";
16334     int r;
16335     suppress_error = 0;
16336     r = guestfs_mkfs (g, fstype, device);
16337     if (r == -1)
16338       return -1;
16339   }
16340   {
16341     char device[] = "/dev/sda1";
16342     char mountpoint[] = "/";
16343     int r;
16344     suppress_error = 0;
16345     r = guestfs_mount (g, device, mountpoint);
16346     if (r == -1)
16347       return -1;
16348   }
16349   /* TestRun for rmdir (0) */
16350   {
16351     char path[] = "/new";
16352     int r;
16353     suppress_error = 0;
16354     r = guestfs_mkdir (g, path);
16355     if (r == -1)
16356       return -1;
16357   }
16358   {
16359     char path[] = "/new";
16360     int r;
16361     suppress_error = 0;
16362     r = guestfs_rmdir (g, path);
16363     if (r == -1)
16364       return -1;
16365   }
16366   return 0;
16367 }
16368
16369 static int test_rmdir_1_skip (void)
16370 {
16371   const char *str;
16372
16373   str = getenv ("TEST_ONLY");
16374   if (str)
16375     return strstr (str, "rmdir") == NULL;
16376   str = getenv ("SKIP_TEST_RMDIR_1");
16377   if (str && strcmp (str, "1") == 0) return 1;
16378   str = getenv ("SKIP_TEST_RMDIR");
16379   if (str && strcmp (str, "1") == 0) return 1;
16380   return 0;
16381 }
16382
16383 static int test_rmdir_1 (void)
16384 {
16385   if (test_rmdir_1_skip ()) {
16386     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16387     return 0;
16388   }
16389
16390   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16391   {
16392     char device[] = "/dev/sda";
16393     int r;
16394     suppress_error = 0;
16395     r = guestfs_blockdev_setrw (g, device);
16396     if (r == -1)
16397       return -1;
16398   }
16399   {
16400     int r;
16401     suppress_error = 0;
16402     r = guestfs_umount_all (g);
16403     if (r == -1)
16404       return -1;
16405   }
16406   {
16407     int r;
16408     suppress_error = 0;
16409     r = guestfs_lvm_remove_all (g);
16410     if (r == -1)
16411       return -1;
16412   }
16413   {
16414     char device[] = "/dev/sda";
16415     char lines_0[] = ",";
16416     char *lines[] = {
16417       lines_0,
16418       NULL
16419     };
16420     int r;
16421     suppress_error = 0;
16422     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16423     if (r == -1)
16424       return -1;
16425   }
16426   {
16427     char fstype[] = "ext2";
16428     char device[] = "/dev/sda1";
16429     int r;
16430     suppress_error = 0;
16431     r = guestfs_mkfs (g, fstype, device);
16432     if (r == -1)
16433       return -1;
16434   }
16435   {
16436     char device[] = "/dev/sda1";
16437     char mountpoint[] = "/";
16438     int r;
16439     suppress_error = 0;
16440     r = guestfs_mount (g, device, mountpoint);
16441     if (r == -1)
16442       return -1;
16443   }
16444   /* TestLastFail for rmdir (1) */
16445   {
16446     char path[] = "/new";
16447     int r;
16448     suppress_error = 1;
16449     r = guestfs_rmdir (g, path);
16450     if (r != -1)
16451       return -1;
16452   }
16453   return 0;
16454 }
16455
16456 static int test_rmdir_2_skip (void)
16457 {
16458   const char *str;
16459
16460   str = getenv ("TEST_ONLY");
16461   if (str)
16462     return strstr (str, "rmdir") == NULL;
16463   str = getenv ("SKIP_TEST_RMDIR_2");
16464   if (str && strcmp (str, "1") == 0) return 1;
16465   str = getenv ("SKIP_TEST_RMDIR");
16466   if (str && strcmp (str, "1") == 0) return 1;
16467   return 0;
16468 }
16469
16470 static int test_rmdir_2 (void)
16471 {
16472   if (test_rmdir_2_skip ()) {
16473     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16474     return 0;
16475   }
16476
16477   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16478   {
16479     char device[] = "/dev/sda";
16480     int r;
16481     suppress_error = 0;
16482     r = guestfs_blockdev_setrw (g, device);
16483     if (r == -1)
16484       return -1;
16485   }
16486   {
16487     int r;
16488     suppress_error = 0;
16489     r = guestfs_umount_all (g);
16490     if (r == -1)
16491       return -1;
16492   }
16493   {
16494     int r;
16495     suppress_error = 0;
16496     r = guestfs_lvm_remove_all (g);
16497     if (r == -1)
16498       return -1;
16499   }
16500   {
16501     char device[] = "/dev/sda";
16502     char lines_0[] = ",";
16503     char *lines[] = {
16504       lines_0,
16505       NULL
16506     };
16507     int r;
16508     suppress_error = 0;
16509     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16510     if (r == -1)
16511       return -1;
16512   }
16513   {
16514     char fstype[] = "ext2";
16515     char device[] = "/dev/sda1";
16516     int r;
16517     suppress_error = 0;
16518     r = guestfs_mkfs (g, fstype, device);
16519     if (r == -1)
16520       return -1;
16521   }
16522   {
16523     char device[] = "/dev/sda1";
16524     char mountpoint[] = "/";
16525     int r;
16526     suppress_error = 0;
16527     r = guestfs_mount (g, device, mountpoint);
16528     if (r == -1)
16529       return -1;
16530   }
16531   /* TestLastFail for rmdir (2) */
16532   {
16533     char path[] = "/new";
16534     int r;
16535     suppress_error = 0;
16536     r = guestfs_touch (g, path);
16537     if (r == -1)
16538       return -1;
16539   }
16540   {
16541     char path[] = "/new";
16542     int r;
16543     suppress_error = 1;
16544     r = guestfs_rmdir (g, path);
16545     if (r != -1)
16546       return -1;
16547   }
16548   return 0;
16549 }
16550
16551 static int test_rm_0_skip (void)
16552 {
16553   const char *str;
16554
16555   str = getenv ("TEST_ONLY");
16556   if (str)
16557     return strstr (str, "rm") == NULL;
16558   str = getenv ("SKIP_TEST_RM_0");
16559   if (str && strcmp (str, "1") == 0) return 1;
16560   str = getenv ("SKIP_TEST_RM");
16561   if (str && strcmp (str, "1") == 0) return 1;
16562   return 0;
16563 }
16564
16565 static int test_rm_0 (void)
16566 {
16567   if (test_rm_0_skip ()) {
16568     printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16569     return 0;
16570   }
16571
16572   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16573   {
16574     char device[] = "/dev/sda";
16575     int r;
16576     suppress_error = 0;
16577     r = guestfs_blockdev_setrw (g, device);
16578     if (r == -1)
16579       return -1;
16580   }
16581   {
16582     int r;
16583     suppress_error = 0;
16584     r = guestfs_umount_all (g);
16585     if (r == -1)
16586       return -1;
16587   }
16588   {
16589     int r;
16590     suppress_error = 0;
16591     r = guestfs_lvm_remove_all (g);
16592     if (r == -1)
16593       return -1;
16594   }
16595   {
16596     char device[] = "/dev/sda";
16597     char lines_0[] = ",";
16598     char *lines[] = {
16599       lines_0,
16600       NULL
16601     };
16602     int r;
16603     suppress_error = 0;
16604     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16605     if (r == -1)
16606       return -1;
16607   }
16608   {
16609     char fstype[] = "ext2";
16610     char device[] = "/dev/sda1";
16611     int r;
16612     suppress_error = 0;
16613     r = guestfs_mkfs (g, fstype, device);
16614     if (r == -1)
16615       return -1;
16616   }
16617   {
16618     char device[] = "/dev/sda1";
16619     char mountpoint[] = "/";
16620     int r;
16621     suppress_error = 0;
16622     r = guestfs_mount (g, device, mountpoint);
16623     if (r == -1)
16624       return -1;
16625   }
16626   /* TestRun for rm (0) */
16627   {
16628     char path[] = "/new";
16629     int r;
16630     suppress_error = 0;
16631     r = guestfs_touch (g, path);
16632     if (r == -1)
16633       return -1;
16634   }
16635   {
16636     char path[] = "/new";
16637     int r;
16638     suppress_error = 0;
16639     r = guestfs_rm (g, path);
16640     if (r == -1)
16641       return -1;
16642   }
16643   return 0;
16644 }
16645
16646 static int test_rm_1_skip (void)
16647 {
16648   const char *str;
16649
16650   str = getenv ("TEST_ONLY");
16651   if (str)
16652     return strstr (str, "rm") == NULL;
16653   str = getenv ("SKIP_TEST_RM_1");
16654   if (str && strcmp (str, "1") == 0) return 1;
16655   str = getenv ("SKIP_TEST_RM");
16656   if (str && strcmp (str, "1") == 0) return 1;
16657   return 0;
16658 }
16659
16660 static int test_rm_1 (void)
16661 {
16662   if (test_rm_1_skip ()) {
16663     printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16664     return 0;
16665   }
16666
16667   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16668   {
16669     char device[] = "/dev/sda";
16670     int r;
16671     suppress_error = 0;
16672     r = guestfs_blockdev_setrw (g, device);
16673     if (r == -1)
16674       return -1;
16675   }
16676   {
16677     int r;
16678     suppress_error = 0;
16679     r = guestfs_umount_all (g);
16680     if (r == -1)
16681       return -1;
16682   }
16683   {
16684     int r;
16685     suppress_error = 0;
16686     r = guestfs_lvm_remove_all (g);
16687     if (r == -1)
16688       return -1;
16689   }
16690   {
16691     char device[] = "/dev/sda";
16692     char lines_0[] = ",";
16693     char *lines[] = {
16694       lines_0,
16695       NULL
16696     };
16697     int r;
16698     suppress_error = 0;
16699     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16700     if (r == -1)
16701       return -1;
16702   }
16703   {
16704     char fstype[] = "ext2";
16705     char device[] = "/dev/sda1";
16706     int r;
16707     suppress_error = 0;
16708     r = guestfs_mkfs (g, fstype, device);
16709     if (r == -1)
16710       return -1;
16711   }
16712   {
16713     char device[] = "/dev/sda1";
16714     char mountpoint[] = "/";
16715     int r;
16716     suppress_error = 0;
16717     r = guestfs_mount (g, device, mountpoint);
16718     if (r == -1)
16719       return -1;
16720   }
16721   /* TestLastFail for rm (1) */
16722   {
16723     char path[] = "/new";
16724     int r;
16725     suppress_error = 1;
16726     r = guestfs_rm (g, path);
16727     if (r != -1)
16728       return -1;
16729   }
16730   return 0;
16731 }
16732
16733 static int test_rm_2_skip (void)
16734 {
16735   const char *str;
16736
16737   str = getenv ("TEST_ONLY");
16738   if (str)
16739     return strstr (str, "rm") == NULL;
16740   str = getenv ("SKIP_TEST_RM_2");
16741   if (str && strcmp (str, "1") == 0) return 1;
16742   str = getenv ("SKIP_TEST_RM");
16743   if (str && strcmp (str, "1") == 0) return 1;
16744   return 0;
16745 }
16746
16747 static int test_rm_2 (void)
16748 {
16749   if (test_rm_2_skip ()) {
16750     printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16751     return 0;
16752   }
16753
16754   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16755   {
16756     char device[] = "/dev/sda";
16757     int r;
16758     suppress_error = 0;
16759     r = guestfs_blockdev_setrw (g, device);
16760     if (r == -1)
16761       return -1;
16762   }
16763   {
16764     int r;
16765     suppress_error = 0;
16766     r = guestfs_umount_all (g);
16767     if (r == -1)
16768       return -1;
16769   }
16770   {
16771     int r;
16772     suppress_error = 0;
16773     r = guestfs_lvm_remove_all (g);
16774     if (r == -1)
16775       return -1;
16776   }
16777   {
16778     char device[] = "/dev/sda";
16779     char lines_0[] = ",";
16780     char *lines[] = {
16781       lines_0,
16782       NULL
16783     };
16784     int r;
16785     suppress_error = 0;
16786     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16787     if (r == -1)
16788       return -1;
16789   }
16790   {
16791     char fstype[] = "ext2";
16792     char device[] = "/dev/sda1";
16793     int r;
16794     suppress_error = 0;
16795     r = guestfs_mkfs (g, fstype, device);
16796     if (r == -1)
16797       return -1;
16798   }
16799   {
16800     char device[] = "/dev/sda1";
16801     char mountpoint[] = "/";
16802     int r;
16803     suppress_error = 0;
16804     r = guestfs_mount (g, device, mountpoint);
16805     if (r == -1)
16806       return -1;
16807   }
16808   /* TestLastFail for rm (2) */
16809   {
16810     char path[] = "/new";
16811     int r;
16812     suppress_error = 0;
16813     r = guestfs_mkdir (g, path);
16814     if (r == -1)
16815       return -1;
16816   }
16817   {
16818     char path[] = "/new";
16819     int r;
16820     suppress_error = 1;
16821     r = guestfs_rm (g, path);
16822     if (r != -1)
16823       return -1;
16824   }
16825   return 0;
16826 }
16827
16828 static int test_read_lines_0_skip (void)
16829 {
16830   const char *str;
16831
16832   str = getenv ("TEST_ONLY");
16833   if (str)
16834     return strstr (str, "read_lines") == NULL;
16835   str = getenv ("SKIP_TEST_READ_LINES_0");
16836   if (str && strcmp (str, "1") == 0) return 1;
16837   str = getenv ("SKIP_TEST_READ_LINES");
16838   if (str && strcmp (str, "1") == 0) return 1;
16839   return 0;
16840 }
16841
16842 static int test_read_lines_0 (void)
16843 {
16844   if (test_read_lines_0_skip ()) {
16845     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16846     return 0;
16847   }
16848
16849   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16850   {
16851     char device[] = "/dev/sda";
16852     int r;
16853     suppress_error = 0;
16854     r = guestfs_blockdev_setrw (g, device);
16855     if (r == -1)
16856       return -1;
16857   }
16858   {
16859     int r;
16860     suppress_error = 0;
16861     r = guestfs_umount_all (g);
16862     if (r == -1)
16863       return -1;
16864   }
16865   {
16866     int r;
16867     suppress_error = 0;
16868     r = guestfs_lvm_remove_all (g);
16869     if (r == -1)
16870       return -1;
16871   }
16872   {
16873     char device[] = "/dev/sda";
16874     char lines_0[] = ",";
16875     char *lines[] = {
16876       lines_0,
16877       NULL
16878     };
16879     int r;
16880     suppress_error = 0;
16881     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16882     if (r == -1)
16883       return -1;
16884   }
16885   {
16886     char fstype[] = "ext2";
16887     char device[] = "/dev/sda1";
16888     int r;
16889     suppress_error = 0;
16890     r = guestfs_mkfs (g, fstype, device);
16891     if (r == -1)
16892       return -1;
16893   }
16894   {
16895     char device[] = "/dev/sda1";
16896     char mountpoint[] = "/";
16897     int r;
16898     suppress_error = 0;
16899     r = guestfs_mount (g, device, mountpoint);
16900     if (r == -1)
16901       return -1;
16902   }
16903   /* TestOutputList for read_lines (0) */
16904   {
16905     char path[] = "/new";
16906     char content[] = "line1\r\nline2\nline3";
16907     int r;
16908     suppress_error = 0;
16909     r = guestfs_write_file (g, path, content, 0);
16910     if (r == -1)
16911       return -1;
16912   }
16913   {
16914     char path[] = "/new";
16915     char **r;
16916     int i;
16917     suppress_error = 0;
16918     r = guestfs_read_lines (g, path);
16919     if (r == NULL)
16920       return -1;
16921     if (!r[0]) {
16922       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16923       print_strings (r);
16924       return -1;
16925     }
16926     {
16927       char expected[] = "line1";
16928       if (strcmp (r[0], expected) != 0) {
16929         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16930         return -1;
16931       }
16932     }
16933     if (!r[1]) {
16934       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16935       print_strings (r);
16936       return -1;
16937     }
16938     {
16939       char expected[] = "line2";
16940       if (strcmp (r[1], expected) != 0) {
16941         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16942         return -1;
16943       }
16944     }
16945     if (!r[2]) {
16946       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16947       print_strings (r);
16948       return -1;
16949     }
16950     {
16951       char expected[] = "line3";
16952       if (strcmp (r[2], expected) != 0) {
16953         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16954         return -1;
16955       }
16956     }
16957     if (r[3] != NULL) {
16958       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16959       print_strings (r);
16960       return -1;
16961     }
16962     for (i = 0; r[i] != NULL; ++i)
16963       free (r[i]);
16964     free (r);
16965   }
16966   return 0;
16967 }
16968
16969 static int test_read_lines_1_skip (void)
16970 {
16971   const char *str;
16972
16973   str = getenv ("TEST_ONLY");
16974   if (str)
16975     return strstr (str, "read_lines") == NULL;
16976   str = getenv ("SKIP_TEST_READ_LINES_1");
16977   if (str && strcmp (str, "1") == 0) return 1;
16978   str = getenv ("SKIP_TEST_READ_LINES");
16979   if (str && strcmp (str, "1") == 0) return 1;
16980   return 0;
16981 }
16982
16983 static int test_read_lines_1 (void)
16984 {
16985   if (test_read_lines_1_skip ()) {
16986     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16987     return 0;
16988   }
16989
16990   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16991   {
16992     char device[] = "/dev/sda";
16993     int r;
16994     suppress_error = 0;
16995     r = guestfs_blockdev_setrw (g, device);
16996     if (r == -1)
16997       return -1;
16998   }
16999   {
17000     int r;
17001     suppress_error = 0;
17002     r = guestfs_umount_all (g);
17003     if (r == -1)
17004       return -1;
17005   }
17006   {
17007     int r;
17008     suppress_error = 0;
17009     r = guestfs_lvm_remove_all (g);
17010     if (r == -1)
17011       return -1;
17012   }
17013   {
17014     char device[] = "/dev/sda";
17015     char lines_0[] = ",";
17016     char *lines[] = {
17017       lines_0,
17018       NULL
17019     };
17020     int r;
17021     suppress_error = 0;
17022     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17023     if (r == -1)
17024       return -1;
17025   }
17026   {
17027     char fstype[] = "ext2";
17028     char device[] = "/dev/sda1";
17029     int r;
17030     suppress_error = 0;
17031     r = guestfs_mkfs (g, fstype, device);
17032     if (r == -1)
17033       return -1;
17034   }
17035   {
17036     char device[] = "/dev/sda1";
17037     char mountpoint[] = "/";
17038     int r;
17039     suppress_error = 0;
17040     r = guestfs_mount (g, device, mountpoint);
17041     if (r == -1)
17042       return -1;
17043   }
17044   /* TestOutputList for read_lines (1) */
17045   {
17046     char path[] = "/new";
17047     char content[] = "";
17048     int r;
17049     suppress_error = 0;
17050     r = guestfs_write_file (g, path, content, 0);
17051     if (r == -1)
17052       return -1;
17053   }
17054   {
17055     char path[] = "/new";
17056     char **r;
17057     int i;
17058     suppress_error = 0;
17059     r = guestfs_read_lines (g, path);
17060     if (r == NULL)
17061       return -1;
17062     if (r[0] != NULL) {
17063       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
17064       print_strings (r);
17065       return -1;
17066     }
17067     for (i = 0; r[i] != NULL; ++i)
17068       free (r[i]);
17069     free (r);
17070   }
17071   return 0;
17072 }
17073
17074 static int test_lvs_0_skip (void)
17075 {
17076   const char *str;
17077
17078   str = getenv ("TEST_ONLY");
17079   if (str)
17080     return strstr (str, "lvs") == NULL;
17081   str = getenv ("SKIP_TEST_LVS_0");
17082   if (str && strcmp (str, "1") == 0) return 1;
17083   str = getenv ("SKIP_TEST_LVS");
17084   if (str && strcmp (str, "1") == 0) return 1;
17085   return 0;
17086 }
17087
17088 static int test_lvs_0 (void)
17089 {
17090   if (test_lvs_0_skip ()) {
17091     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
17092     return 0;
17093   }
17094
17095   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
17096   {
17097     char device[] = "/dev/sda";
17098     int r;
17099     suppress_error = 0;
17100     r = guestfs_blockdev_setrw (g, device);
17101     if (r == -1)
17102       return -1;
17103   }
17104   {
17105     int r;
17106     suppress_error = 0;
17107     r = guestfs_umount_all (g);
17108     if (r == -1)
17109       return -1;
17110   }
17111   {
17112     int r;
17113     suppress_error = 0;
17114     r = guestfs_lvm_remove_all (g);
17115     if (r == -1)
17116       return -1;
17117   }
17118   {
17119     char device[] = "/dev/sda";
17120     char lines_0[] = ",";
17121     char *lines[] = {
17122       lines_0,
17123       NULL
17124     };
17125     int r;
17126     suppress_error = 0;
17127     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17128     if (r == -1)
17129       return -1;
17130   }
17131   {
17132     char device[] = "/dev/sda1";
17133     int r;
17134     suppress_error = 0;
17135     r = guestfs_pvcreate (g, device);
17136     if (r == -1)
17137       return -1;
17138   }
17139   {
17140     char volgroup[] = "VG";
17141     char physvols_0[] = "/dev/sda1";
17142     char *physvols[] = {
17143       physvols_0,
17144       NULL
17145     };
17146     int r;
17147     suppress_error = 0;
17148     r = guestfs_vgcreate (g, volgroup, physvols);
17149     if (r == -1)
17150       return -1;
17151   }
17152   {
17153     char logvol[] = "LV";
17154     char volgroup[] = "VG";
17155     int r;
17156     suppress_error = 0;
17157     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17158     if (r == -1)
17159       return -1;
17160   }
17161   {
17162     char fstype[] = "ext2";
17163     char device[] = "/dev/VG/LV";
17164     int r;
17165     suppress_error = 0;
17166     r = guestfs_mkfs (g, fstype, device);
17167     if (r == -1)
17168       return -1;
17169   }
17170   {
17171     char device[] = "/dev/VG/LV";
17172     char mountpoint[] = "/";
17173     int r;
17174     suppress_error = 0;
17175     r = guestfs_mount (g, device, mountpoint);
17176     if (r == -1)
17177       return -1;
17178   }
17179   /* TestOutputList for lvs (0) */
17180   {
17181     char **r;
17182     int i;
17183     suppress_error = 0;
17184     r = guestfs_lvs (g);
17185     if (r == NULL)
17186       return -1;
17187     if (!r[0]) {
17188       fprintf (stderr, "test_lvs_0: short list returned from command\n");
17189       print_strings (r);
17190       return -1;
17191     }
17192     {
17193       char expected[] = "/dev/VG/LV";
17194       if (strcmp (r[0], expected) != 0) {
17195         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17196         return -1;
17197       }
17198     }
17199     if (r[1] != NULL) {
17200       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
17201       print_strings (r);
17202       return -1;
17203     }
17204     for (i = 0; r[i] != NULL; ++i)
17205       free (r[i]);
17206     free (r);
17207   }
17208   return 0;
17209 }
17210
17211 static int test_lvs_1_skip (void)
17212 {
17213   const char *str;
17214
17215   str = getenv ("TEST_ONLY");
17216   if (str)
17217     return strstr (str, "lvs") == NULL;
17218   str = getenv ("SKIP_TEST_LVS_1");
17219   if (str && strcmp (str, "1") == 0) return 1;
17220   str = getenv ("SKIP_TEST_LVS");
17221   if (str && strcmp (str, "1") == 0) return 1;
17222   return 0;
17223 }
17224
17225 static int test_lvs_1 (void)
17226 {
17227   if (test_lvs_1_skip ()) {
17228     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
17229     return 0;
17230   }
17231
17232   /* InitNone|InitEmpty for test_lvs_1 */
17233   {
17234     char device[] = "/dev/sda";
17235     int r;
17236     suppress_error = 0;
17237     r = guestfs_blockdev_setrw (g, device);
17238     if (r == -1)
17239       return -1;
17240   }
17241   {
17242     int r;
17243     suppress_error = 0;
17244     r = guestfs_umount_all (g);
17245     if (r == -1)
17246       return -1;
17247   }
17248   {
17249     int r;
17250     suppress_error = 0;
17251     r = guestfs_lvm_remove_all (g);
17252     if (r == -1)
17253       return -1;
17254   }
17255   /* TestOutputList for lvs (1) */
17256   {
17257     char device[] = "/dev/sda";
17258     char lines_0[] = ",10";
17259     char lines_1[] = ",20";
17260     char lines_2[] = ",";
17261     char *lines[] = {
17262       lines_0,
17263       lines_1,
17264       lines_2,
17265       NULL
17266     };
17267     int r;
17268     suppress_error = 0;
17269     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17270     if (r == -1)
17271       return -1;
17272   }
17273   {
17274     char device[] = "/dev/sda1";
17275     int r;
17276     suppress_error = 0;
17277     r = guestfs_pvcreate (g, device);
17278     if (r == -1)
17279       return -1;
17280   }
17281   {
17282     char device[] = "/dev/sda2";
17283     int r;
17284     suppress_error = 0;
17285     r = guestfs_pvcreate (g, device);
17286     if (r == -1)
17287       return -1;
17288   }
17289   {
17290     char device[] = "/dev/sda3";
17291     int r;
17292     suppress_error = 0;
17293     r = guestfs_pvcreate (g, device);
17294     if (r == -1)
17295       return -1;
17296   }
17297   {
17298     char volgroup[] = "VG1";
17299     char physvols_0[] = "/dev/sda1";
17300     char physvols_1[] = "/dev/sda2";
17301     char *physvols[] = {
17302       physvols_0,
17303       physvols_1,
17304       NULL
17305     };
17306     int r;
17307     suppress_error = 0;
17308     r = guestfs_vgcreate (g, volgroup, physvols);
17309     if (r == -1)
17310       return -1;
17311   }
17312   {
17313     char volgroup[] = "VG2";
17314     char physvols_0[] = "/dev/sda3";
17315     char *physvols[] = {
17316       physvols_0,
17317       NULL
17318     };
17319     int r;
17320     suppress_error = 0;
17321     r = guestfs_vgcreate (g, volgroup, physvols);
17322     if (r == -1)
17323       return -1;
17324   }
17325   {
17326     char logvol[] = "LV1";
17327     char volgroup[] = "VG1";
17328     int r;
17329     suppress_error = 0;
17330     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17331     if (r == -1)
17332       return -1;
17333   }
17334   {
17335     char logvol[] = "LV2";
17336     char volgroup[] = "VG1";
17337     int r;
17338     suppress_error = 0;
17339     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17340     if (r == -1)
17341       return -1;
17342   }
17343   {
17344     char logvol[] = "LV3";
17345     char volgroup[] = "VG2";
17346     int r;
17347     suppress_error = 0;
17348     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17349     if (r == -1)
17350       return -1;
17351   }
17352   {
17353     char **r;
17354     int i;
17355     suppress_error = 0;
17356     r = guestfs_lvs (g);
17357     if (r == NULL)
17358       return -1;
17359     if (!r[0]) {
17360       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17361       print_strings (r);
17362       return -1;
17363     }
17364     {
17365       char expected[] = "/dev/VG1/LV1";
17366       if (strcmp (r[0], expected) != 0) {
17367         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17368         return -1;
17369       }
17370     }
17371     if (!r[1]) {
17372       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17373       print_strings (r);
17374       return -1;
17375     }
17376     {
17377       char expected[] = "/dev/VG1/LV2";
17378       if (strcmp (r[1], expected) != 0) {
17379         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17380         return -1;
17381       }
17382     }
17383     if (!r[2]) {
17384       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17385       print_strings (r);
17386       return -1;
17387     }
17388     {
17389       char expected[] = "/dev/VG2/LV3";
17390       if (strcmp (r[2], expected) != 0) {
17391         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17392         return -1;
17393       }
17394     }
17395     if (r[3] != NULL) {
17396       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17397       print_strings (r);
17398       return -1;
17399     }
17400     for (i = 0; r[i] != NULL; ++i)
17401       free (r[i]);
17402     free (r);
17403   }
17404   return 0;
17405 }
17406
17407 static int test_vgs_0_skip (void)
17408 {
17409   const char *str;
17410
17411   str = getenv ("TEST_ONLY");
17412   if (str)
17413     return strstr (str, "vgs") == NULL;
17414   str = getenv ("SKIP_TEST_VGS_0");
17415   if (str && strcmp (str, "1") == 0) return 1;
17416   str = getenv ("SKIP_TEST_VGS");
17417   if (str && strcmp (str, "1") == 0) return 1;
17418   return 0;
17419 }
17420
17421 static int test_vgs_0 (void)
17422 {
17423   if (test_vgs_0_skip ()) {
17424     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17425     return 0;
17426   }
17427
17428   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17429   {
17430     char device[] = "/dev/sda";
17431     int r;
17432     suppress_error = 0;
17433     r = guestfs_blockdev_setrw (g, device);
17434     if (r == -1)
17435       return -1;
17436   }
17437   {
17438     int r;
17439     suppress_error = 0;
17440     r = guestfs_umount_all (g);
17441     if (r == -1)
17442       return -1;
17443   }
17444   {
17445     int r;
17446     suppress_error = 0;
17447     r = guestfs_lvm_remove_all (g);
17448     if (r == -1)
17449       return -1;
17450   }
17451   {
17452     char device[] = "/dev/sda";
17453     char lines_0[] = ",";
17454     char *lines[] = {
17455       lines_0,
17456       NULL
17457     };
17458     int r;
17459     suppress_error = 0;
17460     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17461     if (r == -1)
17462       return -1;
17463   }
17464   {
17465     char device[] = "/dev/sda1";
17466     int r;
17467     suppress_error = 0;
17468     r = guestfs_pvcreate (g, device);
17469     if (r == -1)
17470       return -1;
17471   }
17472   {
17473     char volgroup[] = "VG";
17474     char physvols_0[] = "/dev/sda1";
17475     char *physvols[] = {
17476       physvols_0,
17477       NULL
17478     };
17479     int r;
17480     suppress_error = 0;
17481     r = guestfs_vgcreate (g, volgroup, physvols);
17482     if (r == -1)
17483       return -1;
17484   }
17485   {
17486     char logvol[] = "LV";
17487     char volgroup[] = "VG";
17488     int r;
17489     suppress_error = 0;
17490     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17491     if (r == -1)
17492       return -1;
17493   }
17494   {
17495     char fstype[] = "ext2";
17496     char device[] = "/dev/VG/LV";
17497     int r;
17498     suppress_error = 0;
17499     r = guestfs_mkfs (g, fstype, device);
17500     if (r == -1)
17501       return -1;
17502   }
17503   {
17504     char device[] = "/dev/VG/LV";
17505     char mountpoint[] = "/";
17506     int r;
17507     suppress_error = 0;
17508     r = guestfs_mount (g, device, mountpoint);
17509     if (r == -1)
17510       return -1;
17511   }
17512   /* TestOutputList for vgs (0) */
17513   {
17514     char **r;
17515     int i;
17516     suppress_error = 0;
17517     r = guestfs_vgs (g);
17518     if (r == NULL)
17519       return -1;
17520     if (!r[0]) {
17521       fprintf (stderr, "test_vgs_0: short list returned from command\n");
17522       print_strings (r);
17523       return -1;
17524     }
17525     {
17526       char expected[] = "VG";
17527       if (strcmp (r[0], expected) != 0) {
17528         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17529         return -1;
17530       }
17531     }
17532     if (r[1] != NULL) {
17533       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17534       print_strings (r);
17535       return -1;
17536     }
17537     for (i = 0; r[i] != NULL; ++i)
17538       free (r[i]);
17539     free (r);
17540   }
17541   return 0;
17542 }
17543
17544 static int test_vgs_1_skip (void)
17545 {
17546   const char *str;
17547
17548   str = getenv ("TEST_ONLY");
17549   if (str)
17550     return strstr (str, "vgs") == NULL;
17551   str = getenv ("SKIP_TEST_VGS_1");
17552   if (str && strcmp (str, "1") == 0) return 1;
17553   str = getenv ("SKIP_TEST_VGS");
17554   if (str && strcmp (str, "1") == 0) return 1;
17555   return 0;
17556 }
17557
17558 static int test_vgs_1 (void)
17559 {
17560   if (test_vgs_1_skip ()) {
17561     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17562     return 0;
17563   }
17564
17565   /* InitNone|InitEmpty for test_vgs_1 */
17566   {
17567     char device[] = "/dev/sda";
17568     int r;
17569     suppress_error = 0;
17570     r = guestfs_blockdev_setrw (g, device);
17571     if (r == -1)
17572       return -1;
17573   }
17574   {
17575     int r;
17576     suppress_error = 0;
17577     r = guestfs_umount_all (g);
17578     if (r == -1)
17579       return -1;
17580   }
17581   {
17582     int r;
17583     suppress_error = 0;
17584     r = guestfs_lvm_remove_all (g);
17585     if (r == -1)
17586       return -1;
17587   }
17588   /* TestOutputList for vgs (1) */
17589   {
17590     char device[] = "/dev/sda";
17591     char lines_0[] = ",10";
17592     char lines_1[] = ",20";
17593     char lines_2[] = ",";
17594     char *lines[] = {
17595       lines_0,
17596       lines_1,
17597       lines_2,
17598       NULL
17599     };
17600     int r;
17601     suppress_error = 0;
17602     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17603     if (r == -1)
17604       return -1;
17605   }
17606   {
17607     char device[] = "/dev/sda1";
17608     int r;
17609     suppress_error = 0;
17610     r = guestfs_pvcreate (g, device);
17611     if (r == -1)
17612       return -1;
17613   }
17614   {
17615     char device[] = "/dev/sda2";
17616     int r;
17617     suppress_error = 0;
17618     r = guestfs_pvcreate (g, device);
17619     if (r == -1)
17620       return -1;
17621   }
17622   {
17623     char device[] = "/dev/sda3";
17624     int r;
17625     suppress_error = 0;
17626     r = guestfs_pvcreate (g, device);
17627     if (r == -1)
17628       return -1;
17629   }
17630   {
17631     char volgroup[] = "VG1";
17632     char physvols_0[] = "/dev/sda1";
17633     char physvols_1[] = "/dev/sda2";
17634     char *physvols[] = {
17635       physvols_0,
17636       physvols_1,
17637       NULL
17638     };
17639     int r;
17640     suppress_error = 0;
17641     r = guestfs_vgcreate (g, volgroup, physvols);
17642     if (r == -1)
17643       return -1;
17644   }
17645   {
17646     char volgroup[] = "VG2";
17647     char physvols_0[] = "/dev/sda3";
17648     char *physvols[] = {
17649       physvols_0,
17650       NULL
17651     };
17652     int r;
17653     suppress_error = 0;
17654     r = guestfs_vgcreate (g, volgroup, physvols);
17655     if (r == -1)
17656       return -1;
17657   }
17658   {
17659     char **r;
17660     int i;
17661     suppress_error = 0;
17662     r = guestfs_vgs (g);
17663     if (r == NULL)
17664       return -1;
17665     if (!r[0]) {
17666       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17667       print_strings (r);
17668       return -1;
17669     }
17670     {
17671       char expected[] = "VG1";
17672       if (strcmp (r[0], expected) != 0) {
17673         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17674         return -1;
17675       }
17676     }
17677     if (!r[1]) {
17678       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17679       print_strings (r);
17680       return -1;
17681     }
17682     {
17683       char expected[] = "VG2";
17684       if (strcmp (r[1], expected) != 0) {
17685         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17686         return -1;
17687       }
17688     }
17689     if (r[2] != NULL) {
17690       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17691       print_strings (r);
17692       return -1;
17693     }
17694     for (i = 0; r[i] != NULL; ++i)
17695       free (r[i]);
17696     free (r);
17697   }
17698   return 0;
17699 }
17700
17701 static int test_pvs_0_skip (void)
17702 {
17703   const char *str;
17704
17705   str = getenv ("TEST_ONLY");
17706   if (str)
17707     return strstr (str, "pvs") == NULL;
17708   str = getenv ("SKIP_TEST_PVS_0");
17709   if (str && strcmp (str, "1") == 0) return 1;
17710   str = getenv ("SKIP_TEST_PVS");
17711   if (str && strcmp (str, "1") == 0) return 1;
17712   return 0;
17713 }
17714
17715 static int test_pvs_0 (void)
17716 {
17717   if (test_pvs_0_skip ()) {
17718     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17719     return 0;
17720   }
17721
17722   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17723   {
17724     char device[] = "/dev/sda";
17725     int r;
17726     suppress_error = 0;
17727     r = guestfs_blockdev_setrw (g, device);
17728     if (r == -1)
17729       return -1;
17730   }
17731   {
17732     int r;
17733     suppress_error = 0;
17734     r = guestfs_umount_all (g);
17735     if (r == -1)
17736       return -1;
17737   }
17738   {
17739     int r;
17740     suppress_error = 0;
17741     r = guestfs_lvm_remove_all (g);
17742     if (r == -1)
17743       return -1;
17744   }
17745   {
17746     char device[] = "/dev/sda";
17747     char lines_0[] = ",";
17748     char *lines[] = {
17749       lines_0,
17750       NULL
17751     };
17752     int r;
17753     suppress_error = 0;
17754     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17755     if (r == -1)
17756       return -1;
17757   }
17758   {
17759     char device[] = "/dev/sda1";
17760     int r;
17761     suppress_error = 0;
17762     r = guestfs_pvcreate (g, device);
17763     if (r == -1)
17764       return -1;
17765   }
17766   {
17767     char volgroup[] = "VG";
17768     char physvols_0[] = "/dev/sda1";
17769     char *physvols[] = {
17770       physvols_0,
17771       NULL
17772     };
17773     int r;
17774     suppress_error = 0;
17775     r = guestfs_vgcreate (g, volgroup, physvols);
17776     if (r == -1)
17777       return -1;
17778   }
17779   {
17780     char logvol[] = "LV";
17781     char volgroup[] = "VG";
17782     int r;
17783     suppress_error = 0;
17784     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17785     if (r == -1)
17786       return -1;
17787   }
17788   {
17789     char fstype[] = "ext2";
17790     char device[] = "/dev/VG/LV";
17791     int r;
17792     suppress_error = 0;
17793     r = guestfs_mkfs (g, fstype, device);
17794     if (r == -1)
17795       return -1;
17796   }
17797   {
17798     char device[] = "/dev/VG/LV";
17799     char mountpoint[] = "/";
17800     int r;
17801     suppress_error = 0;
17802     r = guestfs_mount (g, device, mountpoint);
17803     if (r == -1)
17804       return -1;
17805   }
17806   /* TestOutputListOfDevices for pvs (0) */
17807   {
17808     char **r;
17809     int i;
17810     suppress_error = 0;
17811     r = guestfs_pvs (g);
17812     if (r == NULL)
17813       return -1;
17814     if (!r[0]) {
17815       fprintf (stderr, "test_pvs_0: short list returned from command\n");
17816       print_strings (r);
17817       return -1;
17818     }
17819     {
17820       char expected[] = "/dev/sda1";
17821       r[0][5] = 's';
17822       if (strcmp (r[0], expected) != 0) {
17823         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17824         return -1;
17825       }
17826     }
17827     if (r[1] != NULL) {
17828       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17829       print_strings (r);
17830       return -1;
17831     }
17832     for (i = 0; r[i] != NULL; ++i)
17833       free (r[i]);
17834     free (r);
17835   }
17836   return 0;
17837 }
17838
17839 static int test_pvs_1_skip (void)
17840 {
17841   const char *str;
17842
17843   str = getenv ("TEST_ONLY");
17844   if (str)
17845     return strstr (str, "pvs") == NULL;
17846   str = getenv ("SKIP_TEST_PVS_1");
17847   if (str && strcmp (str, "1") == 0) return 1;
17848   str = getenv ("SKIP_TEST_PVS");
17849   if (str && strcmp (str, "1") == 0) return 1;
17850   return 0;
17851 }
17852
17853 static int test_pvs_1 (void)
17854 {
17855   if (test_pvs_1_skip ()) {
17856     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17857     return 0;
17858   }
17859
17860   /* InitNone|InitEmpty for test_pvs_1 */
17861   {
17862     char device[] = "/dev/sda";
17863     int r;
17864     suppress_error = 0;
17865     r = guestfs_blockdev_setrw (g, device);
17866     if (r == -1)
17867       return -1;
17868   }
17869   {
17870     int r;
17871     suppress_error = 0;
17872     r = guestfs_umount_all (g);
17873     if (r == -1)
17874       return -1;
17875   }
17876   {
17877     int r;
17878     suppress_error = 0;
17879     r = guestfs_lvm_remove_all (g);
17880     if (r == -1)
17881       return -1;
17882   }
17883   /* TestOutputListOfDevices for pvs (1) */
17884   {
17885     char device[] = "/dev/sda";
17886     char lines_0[] = ",10";
17887     char lines_1[] = ",20";
17888     char lines_2[] = ",";
17889     char *lines[] = {
17890       lines_0,
17891       lines_1,
17892       lines_2,
17893       NULL
17894     };
17895     int r;
17896     suppress_error = 0;
17897     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17898     if (r == -1)
17899       return -1;
17900   }
17901   {
17902     char device[] = "/dev/sda1";
17903     int r;
17904     suppress_error = 0;
17905     r = guestfs_pvcreate (g, device);
17906     if (r == -1)
17907       return -1;
17908   }
17909   {
17910     char device[] = "/dev/sda2";
17911     int r;
17912     suppress_error = 0;
17913     r = guestfs_pvcreate (g, device);
17914     if (r == -1)
17915       return -1;
17916   }
17917   {
17918     char device[] = "/dev/sda3";
17919     int r;
17920     suppress_error = 0;
17921     r = guestfs_pvcreate (g, device);
17922     if (r == -1)
17923       return -1;
17924   }
17925   {
17926     char **r;
17927     int i;
17928     suppress_error = 0;
17929     r = guestfs_pvs (g);
17930     if (r == NULL)
17931       return -1;
17932     if (!r[0]) {
17933       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17934       print_strings (r);
17935       return -1;
17936     }
17937     {
17938       char expected[] = "/dev/sda1";
17939       r[0][5] = 's';
17940       if (strcmp (r[0], expected) != 0) {
17941         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17942         return -1;
17943       }
17944     }
17945     if (!r[1]) {
17946       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17947       print_strings (r);
17948       return -1;
17949     }
17950     {
17951       char expected[] = "/dev/sda2";
17952       r[1][5] = 's';
17953       if (strcmp (r[1], expected) != 0) {
17954         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17955         return -1;
17956       }
17957     }
17958     if (!r[2]) {
17959       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17960       print_strings (r);
17961       return -1;
17962     }
17963     {
17964       char expected[] = "/dev/sda3";
17965       r[2][5] = 's';
17966       if (strcmp (r[2], expected) != 0) {
17967         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17968         return -1;
17969       }
17970     }
17971     if (r[3] != NULL) {
17972       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17973       print_strings (r);
17974       return -1;
17975     }
17976     for (i = 0; r[i] != NULL; ++i)
17977       free (r[i]);
17978     free (r);
17979   }
17980   return 0;
17981 }
17982
17983 static int test_list_partitions_0_skip (void)
17984 {
17985   const char *str;
17986
17987   str = getenv ("TEST_ONLY");
17988   if (str)
17989     return strstr (str, "list_partitions") == NULL;
17990   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17991   if (str && strcmp (str, "1") == 0) return 1;
17992   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17993   if (str && strcmp (str, "1") == 0) return 1;
17994   return 0;
17995 }
17996
17997 static int test_list_partitions_0 (void)
17998 {
17999   if (test_list_partitions_0_skip ()) {
18000     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
18001     return 0;
18002   }
18003
18004   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
18005   {
18006     char device[] = "/dev/sda";
18007     int r;
18008     suppress_error = 0;
18009     r = guestfs_blockdev_setrw (g, device);
18010     if (r == -1)
18011       return -1;
18012   }
18013   {
18014     int r;
18015     suppress_error = 0;
18016     r = guestfs_umount_all (g);
18017     if (r == -1)
18018       return -1;
18019   }
18020   {
18021     int r;
18022     suppress_error = 0;
18023     r = guestfs_lvm_remove_all (g);
18024     if (r == -1)
18025       return -1;
18026   }
18027   {
18028     char device[] = "/dev/sda";
18029     char lines_0[] = ",";
18030     char *lines[] = {
18031       lines_0,
18032       NULL
18033     };
18034     int r;
18035     suppress_error = 0;
18036     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18037     if (r == -1)
18038       return -1;
18039   }
18040   {
18041     char fstype[] = "ext2";
18042     char device[] = "/dev/sda1";
18043     int r;
18044     suppress_error = 0;
18045     r = guestfs_mkfs (g, fstype, device);
18046     if (r == -1)
18047       return -1;
18048   }
18049   {
18050     char device[] = "/dev/sda1";
18051     char mountpoint[] = "/";
18052     int r;
18053     suppress_error = 0;
18054     r = guestfs_mount (g, device, mountpoint);
18055     if (r == -1)
18056       return -1;
18057   }
18058   /* TestOutputListOfDevices for list_partitions (0) */
18059   {
18060     char **r;
18061     int i;
18062     suppress_error = 0;
18063     r = guestfs_list_partitions (g);
18064     if (r == NULL)
18065       return -1;
18066     if (!r[0]) {
18067       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
18068       print_strings (r);
18069       return -1;
18070     }
18071     {
18072       char expected[] = "/dev/sda1";
18073       r[0][5] = 's';
18074       if (strcmp (r[0], expected) != 0) {
18075         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18076         return -1;
18077       }
18078     }
18079     if (r[1] != NULL) {
18080       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
18081       print_strings (r);
18082       return -1;
18083     }
18084     for (i = 0; r[i] != NULL; ++i)
18085       free (r[i]);
18086     free (r);
18087   }
18088   return 0;
18089 }
18090
18091 static int test_list_partitions_1_skip (void)
18092 {
18093   const char *str;
18094
18095   str = getenv ("TEST_ONLY");
18096   if (str)
18097     return strstr (str, "list_partitions") == NULL;
18098   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
18099   if (str && strcmp (str, "1") == 0) return 1;
18100   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18101   if (str && strcmp (str, "1") == 0) return 1;
18102   return 0;
18103 }
18104
18105 static int test_list_partitions_1 (void)
18106 {
18107   if (test_list_partitions_1_skip ()) {
18108     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
18109     return 0;
18110   }
18111
18112   /* InitNone|InitEmpty for test_list_partitions_1 */
18113   {
18114     char device[] = "/dev/sda";
18115     int r;
18116     suppress_error = 0;
18117     r = guestfs_blockdev_setrw (g, device);
18118     if (r == -1)
18119       return -1;
18120   }
18121   {
18122     int r;
18123     suppress_error = 0;
18124     r = guestfs_umount_all (g);
18125     if (r == -1)
18126       return -1;
18127   }
18128   {
18129     int r;
18130     suppress_error = 0;
18131     r = guestfs_lvm_remove_all (g);
18132     if (r == -1)
18133       return -1;
18134   }
18135   /* TestOutputListOfDevices for list_partitions (1) */
18136   {
18137     char device[] = "/dev/sda";
18138     char lines_0[] = ",10";
18139     char lines_1[] = ",20";
18140     char lines_2[] = ",";
18141     char *lines[] = {
18142       lines_0,
18143       lines_1,
18144       lines_2,
18145       NULL
18146     };
18147     int r;
18148     suppress_error = 0;
18149     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18150     if (r == -1)
18151       return -1;
18152   }
18153   {
18154     char **r;
18155     int i;
18156     suppress_error = 0;
18157     r = guestfs_list_partitions (g);
18158     if (r == NULL)
18159       return -1;
18160     if (!r[0]) {
18161       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18162       print_strings (r);
18163       return -1;
18164     }
18165     {
18166       char expected[] = "/dev/sda1";
18167       r[0][5] = 's';
18168       if (strcmp (r[0], expected) != 0) {
18169         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18170         return -1;
18171       }
18172     }
18173     if (!r[1]) {
18174       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18175       print_strings (r);
18176       return -1;
18177     }
18178     {
18179       char expected[] = "/dev/sda2";
18180       r[1][5] = 's';
18181       if (strcmp (r[1], expected) != 0) {
18182         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18183         return -1;
18184       }
18185     }
18186     if (!r[2]) {
18187       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18188       print_strings (r);
18189       return -1;
18190     }
18191     {
18192       char expected[] = "/dev/sda3";
18193       r[2][5] = 's';
18194       if (strcmp (r[2], expected) != 0) {
18195         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18196         return -1;
18197       }
18198     }
18199     if (r[3] != NULL) {
18200       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
18201       print_strings (r);
18202       return -1;
18203     }
18204     for (i = 0; r[i] != NULL; ++i)
18205       free (r[i]);
18206     free (r);
18207   }
18208   return 0;
18209 }
18210
18211 static int test_list_devices_0_skip (void)
18212 {
18213   const char *str;
18214
18215   str = getenv ("TEST_ONLY");
18216   if (str)
18217     return strstr (str, "list_devices") == NULL;
18218   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18219   if (str && strcmp (str, "1") == 0) return 1;
18220   str = getenv ("SKIP_TEST_LIST_DEVICES");
18221   if (str && strcmp (str, "1") == 0) return 1;
18222   return 0;
18223 }
18224
18225 static int test_list_devices_0 (void)
18226 {
18227   if (test_list_devices_0_skip ()) {
18228     printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
18229     return 0;
18230   }
18231
18232   /* InitNone|InitEmpty for test_list_devices_0 */
18233   {
18234     char device[] = "/dev/sda";
18235     int r;
18236     suppress_error = 0;
18237     r = guestfs_blockdev_setrw (g, device);
18238     if (r == -1)
18239       return -1;
18240   }
18241   {
18242     int r;
18243     suppress_error = 0;
18244     r = guestfs_umount_all (g);
18245     if (r == -1)
18246       return -1;
18247   }
18248   {
18249     int r;
18250     suppress_error = 0;
18251     r = guestfs_lvm_remove_all (g);
18252     if (r == -1)
18253       return -1;
18254   }
18255   /* TestOutputListOfDevices for list_devices (0) */
18256   {
18257     char **r;
18258     int i;
18259     suppress_error = 0;
18260     r = guestfs_list_devices (g);
18261     if (r == NULL)
18262       return -1;
18263     if (!r[0]) {
18264       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18265       print_strings (r);
18266       return -1;
18267     }
18268     {
18269       char expected[] = "/dev/sda";
18270       r[0][5] = 's';
18271       if (strcmp (r[0], expected) != 0) {
18272         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18273         return -1;
18274       }
18275     }
18276     if (!r[1]) {
18277       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18278       print_strings (r);
18279       return -1;
18280     }
18281     {
18282       char expected[] = "/dev/sdb";
18283       r[1][5] = 's';
18284       if (strcmp (r[1], expected) != 0) {
18285         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18286         return -1;
18287       }
18288     }
18289     if (!r[2]) {
18290       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18291       print_strings (r);
18292       return -1;
18293     }
18294     {
18295       char expected[] = "/dev/sdc";
18296       r[2][5] = 's';
18297       if (strcmp (r[2], expected) != 0) {
18298         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18299         return -1;
18300       }
18301     }
18302     if (!r[3]) {
18303       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18304       print_strings (r);
18305       return -1;
18306     }
18307     {
18308       char expected[] = "/dev/sdd";
18309       r[3][5] = 's';
18310       if (strcmp (r[3], expected) != 0) {
18311         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18312         return -1;
18313       }
18314     }
18315     if (r[4] != NULL) {
18316       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18317       print_strings (r);
18318       return -1;
18319     }
18320     for (i = 0; r[i] != NULL; ++i)
18321       free (r[i]);
18322     free (r);
18323   }
18324   return 0;
18325 }
18326
18327 static int test_ls_0_skip (void)
18328 {
18329   const char *str;
18330
18331   str = getenv ("TEST_ONLY");
18332   if (str)
18333     return strstr (str, "ls") == NULL;
18334   str = getenv ("SKIP_TEST_LS_0");
18335   if (str && strcmp (str, "1") == 0) return 1;
18336   str = getenv ("SKIP_TEST_LS");
18337   if (str && strcmp (str, "1") == 0) return 1;
18338   return 0;
18339 }
18340
18341 static int test_ls_0 (void)
18342 {
18343   if (test_ls_0_skip ()) {
18344     printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
18345     return 0;
18346   }
18347
18348   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18349   {
18350     char device[] = "/dev/sda";
18351     int r;
18352     suppress_error = 0;
18353     r = guestfs_blockdev_setrw (g, device);
18354     if (r == -1)
18355       return -1;
18356   }
18357   {
18358     int r;
18359     suppress_error = 0;
18360     r = guestfs_umount_all (g);
18361     if (r == -1)
18362       return -1;
18363   }
18364   {
18365     int r;
18366     suppress_error = 0;
18367     r = guestfs_lvm_remove_all (g);
18368     if (r == -1)
18369       return -1;
18370   }
18371   {
18372     char device[] = "/dev/sda";
18373     char lines_0[] = ",";
18374     char *lines[] = {
18375       lines_0,
18376       NULL
18377     };
18378     int r;
18379     suppress_error = 0;
18380     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18381     if (r == -1)
18382       return -1;
18383   }
18384   {
18385     char fstype[] = "ext2";
18386     char device[] = "/dev/sda1";
18387     int r;
18388     suppress_error = 0;
18389     r = guestfs_mkfs (g, fstype, device);
18390     if (r == -1)
18391       return -1;
18392   }
18393   {
18394     char device[] = "/dev/sda1";
18395     char mountpoint[] = "/";
18396     int r;
18397     suppress_error = 0;
18398     r = guestfs_mount (g, device, mountpoint);
18399     if (r == -1)
18400       return -1;
18401   }
18402   /* TestOutputList for ls (0) */
18403   {
18404     char path[] = "/new";
18405     int r;
18406     suppress_error = 0;
18407     r = guestfs_touch (g, path);
18408     if (r == -1)
18409       return -1;
18410   }
18411   {
18412     char path[] = "/newer";
18413     int r;
18414     suppress_error = 0;
18415     r = guestfs_touch (g, path);
18416     if (r == -1)
18417       return -1;
18418   }
18419   {
18420     char path[] = "/newest";
18421     int r;
18422     suppress_error = 0;
18423     r = guestfs_touch (g, path);
18424     if (r == -1)
18425       return -1;
18426   }
18427   {
18428     char directory[] = "/";
18429     char **r;
18430     int i;
18431     suppress_error = 0;
18432     r = guestfs_ls (g, directory);
18433     if (r == NULL)
18434       return -1;
18435     if (!r[0]) {
18436       fprintf (stderr, "test_ls_0: short list returned from command\n");
18437       print_strings (r);
18438       return -1;
18439     }
18440     {
18441       char expected[] = "lost+found";
18442       if (strcmp (r[0], expected) != 0) {
18443         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18444         return -1;
18445       }
18446     }
18447     if (!r[1]) {
18448       fprintf (stderr, "test_ls_0: short list returned from command\n");
18449       print_strings (r);
18450       return -1;
18451     }
18452     {
18453       char expected[] = "new";
18454       if (strcmp (r[1], expected) != 0) {
18455         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18456         return -1;
18457       }
18458     }
18459     if (!r[2]) {
18460       fprintf (stderr, "test_ls_0: short list returned from command\n");
18461       print_strings (r);
18462       return -1;
18463     }
18464     {
18465       char expected[] = "newer";
18466       if (strcmp (r[2], expected) != 0) {
18467         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18468         return -1;
18469       }
18470     }
18471     if (!r[3]) {
18472       fprintf (stderr, "test_ls_0: short list returned from command\n");
18473       print_strings (r);
18474       return -1;
18475     }
18476     {
18477       char expected[] = "newest";
18478       if (strcmp (r[3], expected) != 0) {
18479         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18480         return -1;
18481       }
18482     }
18483     if (r[4] != NULL) {
18484       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18485       print_strings (r);
18486       return -1;
18487     }
18488     for (i = 0; r[i] != NULL; ++i)
18489       free (r[i]);
18490     free (r);
18491   }
18492   return 0;
18493 }
18494
18495 static int test_cat_0_skip (void)
18496 {
18497   const char *str;
18498
18499   str = getenv ("TEST_ONLY");
18500   if (str)
18501     return strstr (str, "cat") == NULL;
18502   str = getenv ("SKIP_TEST_CAT_0");
18503   if (str && strcmp (str, "1") == 0) return 1;
18504   str = getenv ("SKIP_TEST_CAT");
18505   if (str && strcmp (str, "1") == 0) return 1;
18506   return 0;
18507 }
18508
18509 static int test_cat_0 (void)
18510 {
18511   if (test_cat_0_skip ()) {
18512     printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18513     return 0;
18514   }
18515
18516   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18517   {
18518     char device[] = "/dev/sda";
18519     int r;
18520     suppress_error = 0;
18521     r = guestfs_blockdev_setrw (g, device);
18522     if (r == -1)
18523       return -1;
18524   }
18525   {
18526     int r;
18527     suppress_error = 0;
18528     r = guestfs_umount_all (g);
18529     if (r == -1)
18530       return -1;
18531   }
18532   {
18533     int r;
18534     suppress_error = 0;
18535     r = guestfs_lvm_remove_all (g);
18536     if (r == -1)
18537       return -1;
18538   }
18539   {
18540     char device[] = "/dev/sda";
18541     char lines_0[] = ",";
18542     char *lines[] = {
18543       lines_0,
18544       NULL
18545     };
18546     int r;
18547     suppress_error = 0;
18548     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18549     if (r == -1)
18550       return -1;
18551   }
18552   {
18553     char fstype[] = "ext2";
18554     char device[] = "/dev/sda1";
18555     int r;
18556     suppress_error = 0;
18557     r = guestfs_mkfs (g, fstype, device);
18558     if (r == -1)
18559       return -1;
18560   }
18561   {
18562     char device[] = "/dev/sda1";
18563     char mountpoint[] = "/";
18564     int r;
18565     suppress_error = 0;
18566     r = guestfs_mount (g, device, mountpoint);
18567     if (r == -1)
18568       return -1;
18569   }
18570   /* TestOutput for cat (0) */
18571   char expected[] = "new file contents";
18572   {
18573     char path[] = "/new";
18574     char content[] = "new file contents";
18575     int r;
18576     suppress_error = 0;
18577     r = guestfs_write_file (g, path, content, 0);
18578     if (r == -1)
18579       return -1;
18580   }
18581   {
18582     char path[] = "/new";
18583     char *r;
18584     suppress_error = 0;
18585     r = guestfs_cat (g, path);
18586     if (r == NULL)
18587       return -1;
18588     if (strcmp (r, expected) != 0) {
18589       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18590       return -1;
18591     }
18592     free (r);
18593   }
18594   return 0;
18595 }
18596
18597 static int test_touch_0_skip (void)
18598 {
18599   const char *str;
18600
18601   str = getenv ("TEST_ONLY");
18602   if (str)
18603     return strstr (str, "touch") == NULL;
18604   str = getenv ("SKIP_TEST_TOUCH_0");
18605   if (str && strcmp (str, "1") == 0) return 1;
18606   str = getenv ("SKIP_TEST_TOUCH");
18607   if (str && strcmp (str, "1") == 0) return 1;
18608   return 0;
18609 }
18610
18611 static int test_touch_0 (void)
18612 {
18613   if (test_touch_0_skip ()) {
18614     printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18615     return 0;
18616   }
18617
18618   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18619   {
18620     char device[] = "/dev/sda";
18621     int r;
18622     suppress_error = 0;
18623     r = guestfs_blockdev_setrw (g, device);
18624     if (r == -1)
18625       return -1;
18626   }
18627   {
18628     int r;
18629     suppress_error = 0;
18630     r = guestfs_umount_all (g);
18631     if (r == -1)
18632       return -1;
18633   }
18634   {
18635     int r;
18636     suppress_error = 0;
18637     r = guestfs_lvm_remove_all (g);
18638     if (r == -1)
18639       return -1;
18640   }
18641   {
18642     char device[] = "/dev/sda";
18643     char lines_0[] = ",";
18644     char *lines[] = {
18645       lines_0,
18646       NULL
18647     };
18648     int r;
18649     suppress_error = 0;
18650     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18651     if (r == -1)
18652       return -1;
18653   }
18654   {
18655     char fstype[] = "ext2";
18656     char device[] = "/dev/sda1";
18657     int r;
18658     suppress_error = 0;
18659     r = guestfs_mkfs (g, fstype, device);
18660     if (r == -1)
18661       return -1;
18662   }
18663   {
18664     char device[] = "/dev/sda1";
18665     char mountpoint[] = "/";
18666     int r;
18667     suppress_error = 0;
18668     r = guestfs_mount (g, device, mountpoint);
18669     if (r == -1)
18670       return -1;
18671   }
18672   /* TestOutputTrue for touch (0) */
18673   {
18674     char path[] = "/new";
18675     int r;
18676     suppress_error = 0;
18677     r = guestfs_touch (g, path);
18678     if (r == -1)
18679       return -1;
18680   }
18681   {
18682     char path[] = "/new";
18683     int r;
18684     suppress_error = 0;
18685     r = guestfs_exists (g, path);
18686     if (r == -1)
18687       return -1;
18688     if (!r) {
18689       fprintf (stderr, "test_touch_0: expected true, got false\n");
18690       return -1;
18691     }
18692   }
18693   return 0;
18694 }
18695
18696 static int test_sync_0_skip (void)
18697 {
18698   const char *str;
18699
18700   str = getenv ("TEST_ONLY");
18701   if (str)
18702     return strstr (str, "sync") == NULL;
18703   str = getenv ("SKIP_TEST_SYNC_0");
18704   if (str && strcmp (str, "1") == 0) return 1;
18705   str = getenv ("SKIP_TEST_SYNC");
18706   if (str && strcmp (str, "1") == 0) return 1;
18707   return 0;
18708 }
18709
18710 static int test_sync_0 (void)
18711 {
18712   if (test_sync_0_skip ()) {
18713     printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18714     return 0;
18715   }
18716
18717   /* InitNone|InitEmpty for test_sync_0 */
18718   {
18719     char device[] = "/dev/sda";
18720     int r;
18721     suppress_error = 0;
18722     r = guestfs_blockdev_setrw (g, device);
18723     if (r == -1)
18724       return -1;
18725   }
18726   {
18727     int r;
18728     suppress_error = 0;
18729     r = guestfs_umount_all (g);
18730     if (r == -1)
18731       return -1;
18732   }
18733   {
18734     int r;
18735     suppress_error = 0;
18736     r = guestfs_lvm_remove_all (g);
18737     if (r == -1)
18738       return -1;
18739   }
18740   /* TestRun for sync (0) */
18741   {
18742     int r;
18743     suppress_error = 0;
18744     r = guestfs_sync (g);
18745     if (r == -1)
18746       return -1;
18747   }
18748   return 0;
18749 }
18750
18751 static int test_mount_0_skip (void)
18752 {
18753   const char *str;
18754
18755   str = getenv ("TEST_ONLY");
18756   if (str)
18757     return strstr (str, "mount") == NULL;
18758   str = getenv ("SKIP_TEST_MOUNT_0");
18759   if (str && strcmp (str, "1") == 0) return 1;
18760   str = getenv ("SKIP_TEST_MOUNT");
18761   if (str && strcmp (str, "1") == 0) return 1;
18762   return 0;
18763 }
18764
18765 static int test_mount_0 (void)
18766 {
18767   if (test_mount_0_skip ()) {
18768     printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18769     return 0;
18770   }
18771
18772   /* InitNone|InitEmpty for test_mount_0 */
18773   {
18774     char device[] = "/dev/sda";
18775     int r;
18776     suppress_error = 0;
18777     r = guestfs_blockdev_setrw (g, device);
18778     if (r == -1)
18779       return -1;
18780   }
18781   {
18782     int r;
18783     suppress_error = 0;
18784     r = guestfs_umount_all (g);
18785     if (r == -1)
18786       return -1;
18787   }
18788   {
18789     int r;
18790     suppress_error = 0;
18791     r = guestfs_lvm_remove_all (g);
18792     if (r == -1)
18793       return -1;
18794   }
18795   /* TestOutput for mount (0) */
18796   char expected[] = "new file contents";
18797   {
18798     char device[] = "/dev/sda";
18799     char lines_0[] = ",";
18800     char *lines[] = {
18801       lines_0,
18802       NULL
18803     };
18804     int r;
18805     suppress_error = 0;
18806     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18807     if (r == -1)
18808       return -1;
18809   }
18810   {
18811     char fstype[] = "ext2";
18812     char device[] = "/dev/sda1";
18813     int r;
18814     suppress_error = 0;
18815     r = guestfs_mkfs (g, fstype, device);
18816     if (r == -1)
18817       return -1;
18818   }
18819   {
18820     char device[] = "/dev/sda1";
18821     char mountpoint[] = "/";
18822     int r;
18823     suppress_error = 0;
18824     r = guestfs_mount (g, device, mountpoint);
18825     if (r == -1)
18826       return -1;
18827   }
18828   {
18829     char path[] = "/new";
18830     char content[] = "new file contents";
18831     int r;
18832     suppress_error = 0;
18833     r = guestfs_write_file (g, path, content, 0);
18834     if (r == -1)
18835       return -1;
18836   }
18837   {
18838     char path[] = "/new";
18839     char *r;
18840     suppress_error = 0;
18841     r = guestfs_cat (g, path);
18842     if (r == NULL)
18843       return -1;
18844     if (strcmp (r, expected) != 0) {
18845       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18846       return -1;
18847     }
18848     free (r);
18849   }
18850   return 0;
18851 }
18852
18853 int main (int argc, char *argv[])
18854 {
18855   char c = 0;
18856   int failed = 0;
18857   const char *filename;
18858   int fd;
18859   int nr_tests, test_num = 0;
18860
18861   no_test_warnings ();
18862
18863   g = guestfs_create ();
18864   if (g == NULL) {
18865     printf ("guestfs_create FAILED\n");
18866     exit (1);
18867   }
18868
18869   guestfs_set_error_handler (g, print_error, NULL);
18870
18871   guestfs_set_path (g, "../appliance");
18872
18873   filename = "test1.img";
18874   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18875   if (fd == -1) {
18876     perror (filename);
18877     exit (1);
18878   }
18879   if (lseek (fd, 524288000, SEEK_SET) == -1) {
18880     perror ("lseek");
18881     close (fd);
18882     unlink (filename);
18883     exit (1);
18884   }
18885   if (write (fd, &c, 1) == -1) {
18886     perror ("write");
18887     close (fd);
18888     unlink (filename);
18889     exit (1);
18890   }
18891   if (close (fd) == -1) {
18892     perror (filename);
18893     unlink (filename);
18894     exit (1);
18895   }
18896   if (guestfs_add_drive (g, filename) == -1) {
18897     printf ("guestfs_add_drive %s FAILED\n", filename);
18898     exit (1);
18899   }
18900
18901   filename = "test2.img";
18902   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18903   if (fd == -1) {
18904     perror (filename);
18905     exit (1);
18906   }
18907   if (lseek (fd, 52428800, SEEK_SET) == -1) {
18908     perror ("lseek");
18909     close (fd);
18910     unlink (filename);
18911     exit (1);
18912   }
18913   if (write (fd, &c, 1) == -1) {
18914     perror ("write");
18915     close (fd);
18916     unlink (filename);
18917     exit (1);
18918   }
18919   if (close (fd) == -1) {
18920     perror (filename);
18921     unlink (filename);
18922     exit (1);
18923   }
18924   if (guestfs_add_drive (g, filename) == -1) {
18925     printf ("guestfs_add_drive %s FAILED\n", filename);
18926     exit (1);
18927   }
18928
18929   filename = "test3.img";
18930   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18931   if (fd == -1) {
18932     perror (filename);
18933     exit (1);
18934   }
18935   if (lseek (fd, 10485760, SEEK_SET) == -1) {
18936     perror ("lseek");
18937     close (fd);
18938     unlink (filename);
18939     exit (1);
18940   }
18941   if (write (fd, &c, 1) == -1) {
18942     perror ("write");
18943     close (fd);
18944     unlink (filename);
18945     exit (1);
18946   }
18947   if (close (fd) == -1) {
18948     perror (filename);
18949     unlink (filename);
18950     exit (1);
18951   }
18952   if (guestfs_add_drive (g, filename) == -1) {
18953     printf ("guestfs_add_drive %s FAILED\n", filename);
18954     exit (1);
18955   }
18956
18957   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18958     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18959     exit (1);
18960   }
18961
18962   if (guestfs_launch (g) == -1) {
18963     printf ("guestfs_launch FAILED\n");
18964     exit (1);
18965   }
18966
18967   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18968   alarm (600);
18969
18970   if (guestfs_wait_ready (g) == -1) {
18971     printf ("guestfs_wait_ready FAILED\n");
18972     exit (1);
18973   }
18974
18975   /* Cancel previous alarm. */
18976   alarm (0);
18977
18978   nr_tests = 169;
18979
18980   test_num++;
18981   printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests);
18982   if (test_mkswap_U_0 () == -1) {
18983     printf ("test_mkswap_U_0 FAILED\n");
18984     failed++;
18985   }
18986   test_num++;
18987   printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests);
18988   if (test_mkswap_L_0 () == -1) {
18989     printf ("test_mkswap_L_0 FAILED\n");
18990     failed++;
18991   }
18992   test_num++;
18993   printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests);
18994   if (test_mkswap_0 () == -1) {
18995     printf ("test_mkswap_0 FAILED\n");
18996     failed++;
18997   }
18998   test_num++;
18999   printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
19000   if (test_initrd_list_0 () == -1) {
19001     printf ("test_initrd_list_0 FAILED\n");
19002     failed++;
19003   }
19004   test_num++;
19005   printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
19006   if (test_du_0 () == -1) {
19007     printf ("test_du_0 FAILED\n");
19008     failed++;
19009   }
19010   test_num++;
19011   printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
19012   if (test_tail_n_0 () == -1) {
19013     printf ("test_tail_n_0 FAILED\n");
19014     failed++;
19015   }
19016   test_num++;
19017   printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
19018   if (test_tail_n_1 () == -1) {
19019     printf ("test_tail_n_1 FAILED\n");
19020     failed++;
19021   }
19022   test_num++;
19023   printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
19024   if (test_tail_n_2 () == -1) {
19025     printf ("test_tail_n_2 FAILED\n");
19026     failed++;
19027   }
19028   test_num++;
19029   printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
19030   if (test_tail_0 () == -1) {
19031     printf ("test_tail_0 FAILED\n");
19032     failed++;
19033   }
19034   test_num++;
19035   printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
19036   if (test_head_n_0 () == -1) {
19037     printf ("test_head_n_0 FAILED\n");
19038     failed++;
19039   }
19040   test_num++;
19041   printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
19042   if (test_head_n_1 () == -1) {
19043     printf ("test_head_n_1 FAILED\n");
19044     failed++;
19045   }
19046   test_num++;
19047   printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
19048   if (test_head_n_2 () == -1) {
19049     printf ("test_head_n_2 FAILED\n");
19050     failed++;
19051   }
19052   test_num++;
19053   printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
19054   if (test_head_0 () == -1) {
19055     printf ("test_head_0 FAILED\n");
19056     failed++;
19057   }
19058   test_num++;
19059   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
19060   if (test_wc_c_0 () == -1) {
19061     printf ("test_wc_c_0 FAILED\n");
19062     failed++;
19063   }
19064   test_num++;
19065   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
19066   if (test_wc_w_0 () == -1) {
19067     printf ("test_wc_w_0 FAILED\n");
19068     failed++;
19069   }
19070   test_num++;
19071   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
19072   if (test_wc_l_0 () == -1) {
19073     printf ("test_wc_l_0 FAILED\n");
19074     failed++;
19075   }
19076   test_num++;
19077   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
19078   if (test_mkdtemp_0 () == -1) {
19079     printf ("test_mkdtemp_0 FAILED\n");
19080     failed++;
19081   }
19082   test_num++;
19083   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
19084   if (test_scrub_file_0 () == -1) {
19085     printf ("test_scrub_file_0 FAILED\n");
19086     failed++;
19087   }
19088   test_num++;
19089   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
19090   if (test_scrub_device_0 () == -1) {
19091     printf ("test_scrub_device_0 FAILED\n");
19092     failed++;
19093   }
19094   test_num++;
19095   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
19096   if (test_glob_expand_0 () == -1) {
19097     printf ("test_glob_expand_0 FAILED\n");
19098     failed++;
19099   }
19100   test_num++;
19101   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
19102   if (test_glob_expand_1 () == -1) {
19103     printf ("test_glob_expand_1 FAILED\n");
19104     failed++;
19105   }
19106   test_num++;
19107   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
19108   if (test_glob_expand_2 () == -1) {
19109     printf ("test_glob_expand_2 FAILED\n");
19110     failed++;
19111   }
19112   test_num++;
19113   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
19114   if (test_ntfs_3g_probe_0 () == -1) {
19115     printf ("test_ntfs_3g_probe_0 FAILED\n");
19116     failed++;
19117   }
19118   test_num++;
19119   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
19120   if (test_ntfs_3g_probe_1 () == -1) {
19121     printf ("test_ntfs_3g_probe_1 FAILED\n");
19122     failed++;
19123   }
19124   test_num++;
19125   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
19126   if (test_sleep_0 () == -1) {
19127     printf ("test_sleep_0 FAILED\n");
19128     failed++;
19129   }
19130   test_num++;
19131   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
19132   if (test_find_0 () == -1) {
19133     printf ("test_find_0 FAILED\n");
19134     failed++;
19135   }
19136   test_num++;
19137   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
19138   if (test_find_1 () == -1) {
19139     printf ("test_find_1 FAILED\n");
19140     failed++;
19141   }
19142   test_num++;
19143   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
19144   if (test_find_2 () == -1) {
19145     printf ("test_find_2 FAILED\n");
19146     failed++;
19147   }
19148   test_num++;
19149   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
19150   if (test_lvresize_0 () == -1) {
19151     printf ("test_lvresize_0 FAILED\n");
19152     failed++;
19153   }
19154   test_num++;
19155   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
19156   if (test_zerofree_0 () == -1) {
19157     printf ("test_zerofree_0 FAILED\n");
19158     failed++;
19159   }
19160   test_num++;
19161   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
19162   if (test_hexdump_0 () == -1) {
19163     printf ("test_hexdump_0 FAILED\n");
19164     failed++;
19165   }
19166   test_num++;
19167   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
19168   if (test_hexdump_1 () == -1) {
19169     printf ("test_hexdump_1 FAILED\n");
19170     failed++;
19171   }
19172   test_num++;
19173   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
19174   if (test_strings_e_0 () == -1) {
19175     printf ("test_strings_e_0 FAILED\n");
19176     failed++;
19177   }
19178   test_num++;
19179   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
19180   if (test_strings_e_1 () == -1) {
19181     printf ("test_strings_e_1 FAILED\n");
19182     failed++;
19183   }
19184   test_num++;
19185   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
19186   if (test_strings_0 () == -1) {
19187     printf ("test_strings_0 FAILED\n");
19188     failed++;
19189   }
19190   test_num++;
19191   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
19192   if (test_strings_1 () == -1) {
19193     printf ("test_strings_1 FAILED\n");
19194     failed++;
19195   }
19196   test_num++;
19197   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
19198   if (test_equal_0 () == -1) {
19199     printf ("test_equal_0 FAILED\n");
19200     failed++;
19201   }
19202   test_num++;
19203   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
19204   if (test_equal_1 () == -1) {
19205     printf ("test_equal_1 FAILED\n");
19206     failed++;
19207   }
19208   test_num++;
19209   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
19210   if (test_equal_2 () == -1) {
19211     printf ("test_equal_2 FAILED\n");
19212     failed++;
19213   }
19214   test_num++;
19215   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
19216   if (test_ping_daemon_0 () == -1) {
19217     printf ("test_ping_daemon_0 FAILED\n");
19218     failed++;
19219   }
19220   test_num++;
19221   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
19222   if (test_dmesg_0 () == -1) {
19223     printf ("test_dmesg_0 FAILED\n");
19224     failed++;
19225   }
19226   test_num++;
19227   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
19228   if (test_drop_caches_0 () == -1) {
19229     printf ("test_drop_caches_0 FAILED\n");
19230     failed++;
19231   }
19232   test_num++;
19233   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19234   if (test_mv_0 () == -1) {
19235     printf ("test_mv_0 FAILED\n");
19236     failed++;
19237   }
19238   test_num++;
19239   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19240   if (test_mv_1 () == -1) {
19241     printf ("test_mv_1 FAILED\n");
19242     failed++;
19243   }
19244   test_num++;
19245   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19246   if (test_cp_a_0 () == -1) {
19247     printf ("test_cp_a_0 FAILED\n");
19248     failed++;
19249   }
19250   test_num++;
19251   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19252   if (test_cp_0 () == -1) {
19253     printf ("test_cp_0 FAILED\n");
19254     failed++;
19255   }
19256   test_num++;
19257   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19258   if (test_cp_1 () == -1) {
19259     printf ("test_cp_1 FAILED\n");
19260     failed++;
19261   }
19262   test_num++;
19263   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19264   if (test_cp_2 () == -1) {
19265     printf ("test_cp_2 FAILED\n");
19266     failed++;
19267   }
19268   test_num++;
19269   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19270   if (test_grub_install_0 () == -1) {
19271     printf ("test_grub_install_0 FAILED\n");
19272     failed++;
19273   }
19274   test_num++;
19275   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19276   if (test_zero_0 () == -1) {
19277     printf ("test_zero_0 FAILED\n");
19278     failed++;
19279   }
19280   test_num++;
19281   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19282   if (test_fsck_0 () == -1) {
19283     printf ("test_fsck_0 FAILED\n");
19284     failed++;
19285   }
19286   test_num++;
19287   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19288   if (test_fsck_1 () == -1) {
19289     printf ("test_fsck_1 FAILED\n");
19290     failed++;
19291   }
19292   test_num++;
19293   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19294   if (test_set_e2uuid_0 () == -1) {
19295     printf ("test_set_e2uuid_0 FAILED\n");
19296     failed++;
19297   }
19298   test_num++;
19299   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19300   if (test_set_e2uuid_1 () == -1) {
19301     printf ("test_set_e2uuid_1 FAILED\n");
19302     failed++;
19303   }
19304   test_num++;
19305   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19306   if (test_set_e2uuid_2 () == -1) {
19307     printf ("test_set_e2uuid_2 FAILED\n");
19308     failed++;
19309   }
19310   test_num++;
19311   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19312   if (test_set_e2uuid_3 () == -1) {
19313     printf ("test_set_e2uuid_3 FAILED\n");
19314     failed++;
19315   }
19316   test_num++;
19317   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19318   if (test_set_e2label_0 () == -1) {
19319     printf ("test_set_e2label_0 FAILED\n");
19320     failed++;
19321   }
19322   test_num++;
19323   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19324   if (test_pvremove_0 () == -1) {
19325     printf ("test_pvremove_0 FAILED\n");
19326     failed++;
19327   }
19328   test_num++;
19329   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19330   if (test_pvremove_1 () == -1) {
19331     printf ("test_pvremove_1 FAILED\n");
19332     failed++;
19333   }
19334   test_num++;
19335   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19336   if (test_pvremove_2 () == -1) {
19337     printf ("test_pvremove_2 FAILED\n");
19338     failed++;
19339   }
19340   test_num++;
19341   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19342   if (test_vgremove_0 () == -1) {
19343     printf ("test_vgremove_0 FAILED\n");
19344     failed++;
19345   }
19346   test_num++;
19347   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19348   if (test_vgremove_1 () == -1) {
19349     printf ("test_vgremove_1 FAILED\n");
19350     failed++;
19351   }
19352   test_num++;
19353   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19354   if (test_lvremove_0 () == -1) {
19355     printf ("test_lvremove_0 FAILED\n");
19356     failed++;
19357   }
19358   test_num++;
19359   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19360   if (test_lvremove_1 () == -1) {
19361     printf ("test_lvremove_1 FAILED\n");
19362     failed++;
19363   }
19364   test_num++;
19365   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19366   if (test_lvremove_2 () == -1) {
19367     printf ("test_lvremove_2 FAILED\n");
19368     failed++;
19369   }
19370   test_num++;
19371   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19372   if (test_mount_ro_0 () == -1) {
19373     printf ("test_mount_ro_0 FAILED\n");
19374     failed++;
19375   }
19376   test_num++;
19377   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19378   if (test_mount_ro_1 () == -1) {
19379     printf ("test_mount_ro_1 FAILED\n");
19380     failed++;
19381   }
19382   test_num++;
19383   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19384   if (test_tgz_in_0 () == -1) {
19385     printf ("test_tgz_in_0 FAILED\n");
19386     failed++;
19387   }
19388   test_num++;
19389   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19390   if (test_tar_in_0 () == -1) {
19391     printf ("test_tar_in_0 FAILED\n");
19392     failed++;
19393   }
19394   test_num++;
19395   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19396   if (test_checksum_0 () == -1) {
19397     printf ("test_checksum_0 FAILED\n");
19398     failed++;
19399   }
19400   test_num++;
19401   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19402   if (test_checksum_1 () == -1) {
19403     printf ("test_checksum_1 FAILED\n");
19404     failed++;
19405   }
19406   test_num++;
19407   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19408   if (test_checksum_2 () == -1) {
19409     printf ("test_checksum_2 FAILED\n");
19410     failed++;
19411   }
19412   test_num++;
19413   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19414   if (test_checksum_3 () == -1) {
19415     printf ("test_checksum_3 FAILED\n");
19416     failed++;
19417   }
19418   test_num++;
19419   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19420   if (test_checksum_4 () == -1) {
19421     printf ("test_checksum_4 FAILED\n");
19422     failed++;
19423   }
19424   test_num++;
19425   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19426   if (test_checksum_5 () == -1) {
19427     printf ("test_checksum_5 FAILED\n");
19428     failed++;
19429   }
19430   test_num++;
19431   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19432   if (test_checksum_6 () == -1) {
19433     printf ("test_checksum_6 FAILED\n");
19434     failed++;
19435   }
19436   test_num++;
19437   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19438   if (test_checksum_7 () == -1) {
19439     printf ("test_checksum_7 FAILED\n");
19440     failed++;
19441   }
19442   test_num++;
19443   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19444   if (test_checksum_8 () == -1) {
19445     printf ("test_checksum_8 FAILED\n");
19446     failed++;
19447   }
19448   test_num++;
19449   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19450   if (test_download_0 () == -1) {
19451     printf ("test_download_0 FAILED\n");
19452     failed++;
19453   }
19454   test_num++;
19455   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19456   if (test_upload_0 () == -1) {
19457     printf ("test_upload_0 FAILED\n");
19458     failed++;
19459   }
19460   test_num++;
19461   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19462   if (test_blockdev_rereadpt_0 () == -1) {
19463     printf ("test_blockdev_rereadpt_0 FAILED\n");
19464     failed++;
19465   }
19466   test_num++;
19467   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19468   if (test_blockdev_flushbufs_0 () == -1) {
19469     printf ("test_blockdev_flushbufs_0 FAILED\n");
19470     failed++;
19471   }
19472   test_num++;
19473   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19474   if (test_blockdev_getsize64_0 () == -1) {
19475     printf ("test_blockdev_getsize64_0 FAILED\n");
19476     failed++;
19477   }
19478   test_num++;
19479   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19480   if (test_blockdev_getsz_0 () == -1) {
19481     printf ("test_blockdev_getsz_0 FAILED\n");
19482     failed++;
19483   }
19484   test_num++;
19485   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19486   if (test_blockdev_getbsz_0 () == -1) {
19487     printf ("test_blockdev_getbsz_0 FAILED\n");
19488     failed++;
19489   }
19490   test_num++;
19491   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19492   if (test_blockdev_getss_0 () == -1) {
19493     printf ("test_blockdev_getss_0 FAILED\n");
19494     failed++;
19495   }
19496   test_num++;
19497   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19498   if (test_blockdev_getro_0 () == -1) {
19499     printf ("test_blockdev_getro_0 FAILED\n");
19500     failed++;
19501   }
19502   test_num++;
19503   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19504   if (test_blockdev_setrw_0 () == -1) {
19505     printf ("test_blockdev_setrw_0 FAILED\n");
19506     failed++;
19507   }
19508   test_num++;
19509   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19510   if (test_blockdev_setro_0 () == -1) {
19511     printf ("test_blockdev_setro_0 FAILED\n");
19512     failed++;
19513   }
19514   test_num++;
19515   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19516   if (test_statvfs_0 () == -1) {
19517     printf ("test_statvfs_0 FAILED\n");
19518     failed++;
19519   }
19520   test_num++;
19521   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19522   if (test_lstat_0 () == -1) {
19523     printf ("test_lstat_0 FAILED\n");
19524     failed++;
19525   }
19526   test_num++;
19527   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19528   if (test_stat_0 () == -1) {
19529     printf ("test_stat_0 FAILED\n");
19530     failed++;
19531   }
19532   test_num++;
19533   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19534   if (test_command_lines_0 () == -1) {
19535     printf ("test_command_lines_0 FAILED\n");
19536     failed++;
19537   }
19538   test_num++;
19539   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19540   if (test_command_lines_1 () == -1) {
19541     printf ("test_command_lines_1 FAILED\n");
19542     failed++;
19543   }
19544   test_num++;
19545   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19546   if (test_command_lines_2 () == -1) {
19547     printf ("test_command_lines_2 FAILED\n");
19548     failed++;
19549   }
19550   test_num++;
19551   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19552   if (test_command_lines_3 () == -1) {
19553     printf ("test_command_lines_3 FAILED\n");
19554     failed++;
19555   }
19556   test_num++;
19557   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19558   if (test_command_lines_4 () == -1) {
19559     printf ("test_command_lines_4 FAILED\n");
19560     failed++;
19561   }
19562   test_num++;
19563   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19564   if (test_command_lines_5 () == -1) {
19565     printf ("test_command_lines_5 FAILED\n");
19566     failed++;
19567   }
19568   test_num++;
19569   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19570   if (test_command_lines_6 () == -1) {
19571     printf ("test_command_lines_6 FAILED\n");
19572     failed++;
19573   }
19574   test_num++;
19575   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19576   if (test_command_lines_7 () == -1) {
19577     printf ("test_command_lines_7 FAILED\n");
19578     failed++;
19579   }
19580   test_num++;
19581   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19582   if (test_command_lines_8 () == -1) {
19583     printf ("test_command_lines_8 FAILED\n");
19584     failed++;
19585   }
19586   test_num++;
19587   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19588   if (test_command_lines_9 () == -1) {
19589     printf ("test_command_lines_9 FAILED\n");
19590     failed++;
19591   }
19592   test_num++;
19593   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19594   if (test_command_lines_10 () == -1) {
19595     printf ("test_command_lines_10 FAILED\n");
19596     failed++;
19597   }
19598   test_num++;
19599   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19600   if (test_command_0 () == -1) {
19601     printf ("test_command_0 FAILED\n");
19602     failed++;
19603   }
19604   test_num++;
19605   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19606   if (test_command_1 () == -1) {
19607     printf ("test_command_1 FAILED\n");
19608     failed++;
19609   }
19610   test_num++;
19611   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19612   if (test_command_2 () == -1) {
19613     printf ("test_command_2 FAILED\n");
19614     failed++;
19615   }
19616   test_num++;
19617   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19618   if (test_command_3 () == -1) {
19619     printf ("test_command_3 FAILED\n");
19620     failed++;
19621   }
19622   test_num++;
19623   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19624   if (test_command_4 () == -1) {
19625     printf ("test_command_4 FAILED\n");
19626     failed++;
19627   }
19628   test_num++;
19629   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19630   if (test_command_5 () == -1) {
19631     printf ("test_command_5 FAILED\n");
19632     failed++;
19633   }
19634   test_num++;
19635   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19636   if (test_command_6 () == -1) {
19637     printf ("test_command_6 FAILED\n");
19638     failed++;
19639   }
19640   test_num++;
19641   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19642   if (test_command_7 () == -1) {
19643     printf ("test_command_7 FAILED\n");
19644     failed++;
19645   }
19646   test_num++;
19647   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19648   if (test_command_8 () == -1) {
19649     printf ("test_command_8 FAILED\n");
19650     failed++;
19651   }
19652   test_num++;
19653   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19654   if (test_command_9 () == -1) {
19655     printf ("test_command_9 FAILED\n");
19656     failed++;
19657   }
19658   test_num++;
19659   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19660   if (test_command_10 () == -1) {
19661     printf ("test_command_10 FAILED\n");
19662     failed++;
19663   }
19664   test_num++;
19665   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19666   if (test_command_11 () == -1) {
19667     printf ("test_command_11 FAILED\n");
19668     failed++;
19669   }
19670   test_num++;
19671   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19672   if (test_file_0 () == -1) {
19673     printf ("test_file_0 FAILED\n");
19674     failed++;
19675   }
19676   test_num++;
19677   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19678   if (test_file_1 () == -1) {
19679     printf ("test_file_1 FAILED\n");
19680     failed++;
19681   }
19682   test_num++;
19683   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19684   if (test_file_2 () == -1) {
19685     printf ("test_file_2 FAILED\n");
19686     failed++;
19687   }
19688   test_num++;
19689   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19690   if (test_umount_all_0 () == -1) {
19691     printf ("test_umount_all_0 FAILED\n");
19692     failed++;
19693   }
19694   test_num++;
19695   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19696   if (test_umount_all_1 () == -1) {
19697     printf ("test_umount_all_1 FAILED\n");
19698     failed++;
19699   }
19700   test_num++;
19701   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19702   if (test_mounts_0 () == -1) {
19703     printf ("test_mounts_0 FAILED\n");
19704     failed++;
19705   }
19706   test_num++;
19707   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19708   if (test_umount_0 () == -1) {
19709     printf ("test_umount_0 FAILED\n");
19710     failed++;
19711   }
19712   test_num++;
19713   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19714   if (test_umount_1 () == -1) {
19715     printf ("test_umount_1 FAILED\n");
19716     failed++;
19717   }
19718   test_num++;
19719   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19720   if (test_write_file_0 () == -1) {
19721     printf ("test_write_file_0 FAILED\n");
19722     failed++;
19723   }
19724   test_num++;
19725   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19726   if (test_write_file_1 () == -1) {
19727     printf ("test_write_file_1 FAILED\n");
19728     failed++;
19729   }
19730   test_num++;
19731   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19732   if (test_write_file_2 () == -1) {
19733     printf ("test_write_file_2 FAILED\n");
19734     failed++;
19735   }
19736   test_num++;
19737   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19738   if (test_write_file_3 () == -1) {
19739     printf ("test_write_file_3 FAILED\n");
19740     failed++;
19741   }
19742   test_num++;
19743   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19744   if (test_write_file_4 () == -1) {
19745     printf ("test_write_file_4 FAILED\n");
19746     failed++;
19747   }
19748   test_num++;
19749   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19750   if (test_write_file_5 () == -1) {
19751     printf ("test_write_file_5 FAILED\n");
19752     failed++;
19753   }
19754   test_num++;
19755   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19756   if (test_mkfs_0 () == -1) {
19757     printf ("test_mkfs_0 FAILED\n");
19758     failed++;
19759   }
19760   test_num++;
19761   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19762   if (test_lvcreate_0 () == -1) {
19763     printf ("test_lvcreate_0 FAILED\n");
19764     failed++;
19765   }
19766   test_num++;
19767   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19768   if (test_vgcreate_0 () == -1) {
19769     printf ("test_vgcreate_0 FAILED\n");
19770     failed++;
19771   }
19772   test_num++;
19773   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19774   if (test_pvcreate_0 () == -1) {
19775     printf ("test_pvcreate_0 FAILED\n");
19776     failed++;
19777   }
19778   test_num++;
19779   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19780   if (test_is_dir_0 () == -1) {
19781     printf ("test_is_dir_0 FAILED\n");
19782     failed++;
19783   }
19784   test_num++;
19785   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19786   if (test_is_dir_1 () == -1) {
19787     printf ("test_is_dir_1 FAILED\n");
19788     failed++;
19789   }
19790   test_num++;
19791   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19792   if (test_is_file_0 () == -1) {
19793     printf ("test_is_file_0 FAILED\n");
19794     failed++;
19795   }
19796   test_num++;
19797   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19798   if (test_is_file_1 () == -1) {
19799     printf ("test_is_file_1 FAILED\n");
19800     failed++;
19801   }
19802   test_num++;
19803   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19804   if (test_exists_0 () == -1) {
19805     printf ("test_exists_0 FAILED\n");
19806     failed++;
19807   }
19808   test_num++;
19809   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19810   if (test_exists_1 () == -1) {
19811     printf ("test_exists_1 FAILED\n");
19812     failed++;
19813   }
19814   test_num++;
19815   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19816   if (test_mkdir_p_0 () == -1) {
19817     printf ("test_mkdir_p_0 FAILED\n");
19818     failed++;
19819   }
19820   test_num++;
19821   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19822   if (test_mkdir_p_1 () == -1) {
19823     printf ("test_mkdir_p_1 FAILED\n");
19824     failed++;
19825   }
19826   test_num++;
19827   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19828   if (test_mkdir_p_2 () == -1) {
19829     printf ("test_mkdir_p_2 FAILED\n");
19830     failed++;
19831   }
19832   test_num++;
19833   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19834   if (test_mkdir_p_3 () == -1) {
19835     printf ("test_mkdir_p_3 FAILED\n");
19836     failed++;
19837   }
19838   test_num++;
19839   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19840   if (test_mkdir_p_4 () == -1) {
19841     printf ("test_mkdir_p_4 FAILED\n");
19842     failed++;
19843   }
19844   test_num++;
19845   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19846   if (test_mkdir_0 () == -1) {
19847     printf ("test_mkdir_0 FAILED\n");
19848     failed++;
19849   }
19850   test_num++;
19851   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19852   if (test_mkdir_1 () == -1) {
19853     printf ("test_mkdir_1 FAILED\n");
19854     failed++;
19855   }
19856   test_num++;
19857   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19858   if (test_rm_rf_0 () == -1) {
19859     printf ("test_rm_rf_0 FAILED\n");
19860     failed++;
19861   }
19862   test_num++;
19863   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19864   if (test_rmdir_0 () == -1) {
19865     printf ("test_rmdir_0 FAILED\n");
19866     failed++;
19867   }
19868   test_num++;
19869   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19870   if (test_rmdir_1 () == -1) {
19871     printf ("test_rmdir_1 FAILED\n");
19872     failed++;
19873   }
19874   test_num++;
19875   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19876   if (test_rmdir_2 () == -1) {
19877     printf ("test_rmdir_2 FAILED\n");
19878     failed++;
19879   }
19880   test_num++;
19881   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19882   if (test_rm_0 () == -1) {
19883     printf ("test_rm_0 FAILED\n");
19884     failed++;
19885   }
19886   test_num++;
19887   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19888   if (test_rm_1 () == -1) {
19889     printf ("test_rm_1 FAILED\n");
19890     failed++;
19891   }
19892   test_num++;
19893   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19894   if (test_rm_2 () == -1) {
19895     printf ("test_rm_2 FAILED\n");
19896     failed++;
19897   }
19898   test_num++;
19899   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19900   if (test_read_lines_0 () == -1) {
19901     printf ("test_read_lines_0 FAILED\n");
19902     failed++;
19903   }
19904   test_num++;
19905   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19906   if (test_read_lines_1 () == -1) {
19907     printf ("test_read_lines_1 FAILED\n");
19908     failed++;
19909   }
19910   test_num++;
19911   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19912   if (test_lvs_0 () == -1) {
19913     printf ("test_lvs_0 FAILED\n");
19914     failed++;
19915   }
19916   test_num++;
19917   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19918   if (test_lvs_1 () == -1) {
19919     printf ("test_lvs_1 FAILED\n");
19920     failed++;
19921   }
19922   test_num++;
19923   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19924   if (test_vgs_0 () == -1) {
19925     printf ("test_vgs_0 FAILED\n");
19926     failed++;
19927   }
19928   test_num++;
19929   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19930   if (test_vgs_1 () == -1) {
19931     printf ("test_vgs_1 FAILED\n");
19932     failed++;
19933   }
19934   test_num++;
19935   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19936   if (test_pvs_0 () == -1) {
19937     printf ("test_pvs_0 FAILED\n");
19938     failed++;
19939   }
19940   test_num++;
19941   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19942   if (test_pvs_1 () == -1) {
19943     printf ("test_pvs_1 FAILED\n");
19944     failed++;
19945   }
19946   test_num++;
19947   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19948   if (test_list_partitions_0 () == -1) {
19949     printf ("test_list_partitions_0 FAILED\n");
19950     failed++;
19951   }
19952   test_num++;
19953   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19954   if (test_list_partitions_1 () == -1) {
19955     printf ("test_list_partitions_1 FAILED\n");
19956     failed++;
19957   }
19958   test_num++;
19959   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19960   if (test_list_devices_0 () == -1) {
19961     printf ("test_list_devices_0 FAILED\n");
19962     failed++;
19963   }
19964   test_num++;
19965   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19966   if (test_ls_0 () == -1) {
19967     printf ("test_ls_0 FAILED\n");
19968     failed++;
19969   }
19970   test_num++;
19971   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19972   if (test_cat_0 () == -1) {
19973     printf ("test_cat_0 FAILED\n");
19974     failed++;
19975   }
19976   test_num++;
19977   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19978   if (test_touch_0 () == -1) {
19979     printf ("test_touch_0 FAILED\n");
19980     failed++;
19981   }
19982   test_num++;
19983   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19984   if (test_sync_0 () == -1) {
19985     printf ("test_sync_0 FAILED\n");
19986     failed++;
19987   }
19988   test_num++;
19989   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19990   if (test_mount_0 () == -1) {
19991     printf ("test_mount_0 FAILED\n");
19992     failed++;
19993   }
19994
19995   guestfs_close (g);
19996   unlink ("test1.img");
19997   unlink ("test2.img");
19998   unlink ("test3.img");
19999
20000   if (failed > 0) {
20001     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
20002     exit (1);
20003   }
20004
20005   exit (0);
20006 }