capitests/tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 static void print_error (guestfs_h *g, void *data, const char *msg)
  35 {
  36   if (!suppress_error)
  37     fprintf (stderr, "%s\n", msg);
  38 }
  39
  40 static void print_strings (char * const * const argv)
  41 {
  42   int argc;
  43
  44   for (argc = 0; argv[argc] != NULL; ++argc)
  45     printf ("\t%s\n", argv[argc]);
  46 }
  47
  48 /*
  49 static void print_table (char * const * const argv)
  50 {
  51   int i;
  52
  53   for (i = 0; argv[i] != NULL; i += 2)
  54     printf ("%s: %s\n", argv[i], argv[i+1]);
  55 }
  56 */
  57
  58 static void no_test_warnings (void)
  59 {
  60   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  61   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  62   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  63   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  64   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  65   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
 156   fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
 157 }
 158
 159 static int test_mkswap_U_0_skip (void)
 160 {
 161   const char *str;
 162
 163   str = getenv ("TEST_ONLY");
 164   if (str)
 165     return strstr (str, "mkswap_U") == NULL;
 166   str = getenv ("SKIP_TEST_MKSWAP_U_0");
 167   if (str && strcmp (str, "1") == 0) return 1;
 168   str = getenv ("SKIP_TEST_MKSWAP_U");
 169   if (str && strcmp (str, "1") == 0) return 1;
 170   return 0;
 171 }
 172
 173 static int test_mkswap_U_0 (void)
 174 {
 175   if (test_mkswap_U_0_skip ()) {
 176     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
 177     return 0;
 178   }
 179
 180   /* InitNone|InitEmpty for test_mkswap_U_0 */
 181   {
 182     char device[] = "/dev/sda";
 183     int r;
 184     suppress_error = 0;
 185     r = guestfs_blockdev_setrw (g, device);
 186     if (r == -1)
 187       return -1;
 188   }
 189   {
 190     int r;
 191     suppress_error = 0;
 192     r = guestfs_umount_all (g);
 193     if (r == -1)
 194       return -1;
 195   }
 196   {
 197     int r;
 198     suppress_error = 0;
 199     r = guestfs_lvm_remove_all (g);
 200     if (r == -1)
 201       return -1;
 202   }
 203   /* TestRun for mkswap_U (0) */
 204   {
 205     char device[] = "/dev/sda";
 206     char lines_0[] = ",";
 207     char *lines[] = {
 208       lines_0,
 209       NULL
 210     };
 211     int r;
 212     suppress_error = 0;
 213     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 214     if (r == -1)
 215       return -1;
 216   }
 217   {
 218     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
 219     char device[] = "/dev/sda1";
 220     int r;
 221     suppress_error = 0;
 222     r = guestfs_mkswap_U (g, uuid, device);
 223     if (r == -1)
 224       return -1;
 225   }
 226   return 0;
 227 }
 228
 229 static int test_mkswap_L_0_skip (void)
 230 {
 231   const char *str;
 232
 233   str = getenv ("TEST_ONLY");
 234   if (str)
 235     return strstr (str, "mkswap_L") == NULL;
 236   str = getenv ("SKIP_TEST_MKSWAP_L_0");
 237   if (str && strcmp (str, "1") == 0) return 1;
 238   str = getenv ("SKIP_TEST_MKSWAP_L");
 239   if (str && strcmp (str, "1") == 0) return 1;
 240   return 0;
 241 }
 242
 243 static int test_mkswap_L_0 (void)
 244 {
 245   if (test_mkswap_L_0_skip ()) {
 246     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
 247     return 0;
 248   }
 249
 250   /* InitNone|InitEmpty for test_mkswap_L_0 */
 251   {
 252     char device[] = "/dev/sda";
 253     int r;
 254     suppress_error = 0;
 255     r = guestfs_blockdev_setrw (g, device);
 256     if (r == -1)
 257       return -1;
 258   }
 259   {
 260     int r;
 261     suppress_error = 0;
 262     r = guestfs_umount_all (g);
 263     if (r == -1)
 264       return -1;
 265   }
 266   {
 267     int r;
 268     suppress_error = 0;
 269     r = guestfs_lvm_remove_all (g);
 270     if (r == -1)
 271       return -1;
 272   }
 273   /* TestRun for mkswap_L (0) */
 274   {
 275     char device[] = "/dev/sda";
 276     char lines_0[] = ",";
 277     char *lines[] = {
 278       lines_0,
 279       NULL
 280     };
 281     int r;
 282     suppress_error = 0;
 283     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 284     if (r == -1)
 285       return -1;
 286   }
 287   {
 288     char label[] = "hello";
 289     char device[] = "/dev/sda1";
 290     int r;
 291     suppress_error = 0;
 292     r = guestfs_mkswap_L (g, label, device);
 293     if (r == -1)
 294       return -1;
 295   }
 296   return 0;
 297 }
 298
 299 static int test_mkswap_0_skip (void)
 300 {
 301   const char *str;
 302
 303   str = getenv ("TEST_ONLY");
 304   if (str)
 305     return strstr (str, "mkswap") == NULL;
 306   str = getenv ("SKIP_TEST_MKSWAP_0");
 307   if (str && strcmp (str, "1") == 0) return 1;
 308   str = getenv ("SKIP_TEST_MKSWAP");
 309   if (str && strcmp (str, "1") == 0) return 1;
 310   return 0;
 311 }
 312
 313 static int test_mkswap_0 (void)
 314 {
 315   if (test_mkswap_0_skip ()) {
 316     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_0");
 317     return 0;
 318   }
 319
 320   /* InitNone|InitEmpty for test_mkswap_0 */
 321   {
 322     char device[] = "/dev/sda";
 323     int r;
 324     suppress_error = 0;
 325     r = guestfs_blockdev_setrw (g, device);
 326     if (r == -1)
 327       return -1;
 328   }
 329   {
 330     int r;
 331     suppress_error = 0;
 332     r = guestfs_umount_all (g);
 333     if (r == -1)
 334       return -1;
 335   }
 336   {
 337     int r;
 338     suppress_error = 0;
 339     r = guestfs_lvm_remove_all (g);
 340     if (r == -1)
 341       return -1;
 342   }
 343   /* TestRun for mkswap (0) */
 344   {
 345     char device[] = "/dev/sda";
 346     char lines_0[] = ",";
 347     char *lines[] = {
 348       lines_0,
 349       NULL
 350     };
 351     int r;
 352     suppress_error = 0;
 353     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 354     if (r == -1)
 355       return -1;
 356   }
 357   {
 358     char device[] = "/dev/sda1";
 359     int r;
 360     suppress_error = 0;
 361     r = guestfs_mkswap (g, device);
 362     if (r == -1)
 363       return -1;
 364   }
 365   return 0;
 366 }
 367
 368 static int test_initrd_list_0_skip (void)
 369 {
 370   const char *str;
 371
 372   str = getenv ("TEST_ONLY");
 373   if (str)
 374     return strstr (str, "initrd_list") == NULL;
 375   str = getenv ("SKIP_TEST_INITRD_LIST_0");
 376   if (str && strcmp (str, "1") == 0) return 1;
 377   str = getenv ("SKIP_TEST_INITRD_LIST");
 378   if (str && strcmp (str, "1") == 0) return 1;
 379   return 0;
 380 }
 381
 382 static int test_initrd_list_0 (void)
 383 {
 384   if (test_initrd_list_0_skip ()) {
 385     printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
 386     return 0;
 387   }
 388
 389   /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
 390   {
 391     char device[] = "/dev/sda";
 392     int r;
 393     suppress_error = 0;
 394     r = guestfs_blockdev_setrw (g, device);
 395     if (r == -1)
 396       return -1;
 397   }
 398   {
 399     int r;
 400     suppress_error = 0;
 401     r = guestfs_umount_all (g);
 402     if (r == -1)
 403       return -1;
 404   }
 405   {
 406     int r;
 407     suppress_error = 0;
 408     r = guestfs_lvm_remove_all (g);
 409     if (r == -1)
 410       return -1;
 411   }
 412   {
 413     char device[] = "/dev/sda";
 414     char lines_0[] = ",";
 415     char *lines[] = {
 416       lines_0,
 417       NULL
 418     };
 419     int r;
 420     suppress_error = 0;
 421     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 422     if (r == -1)
 423       return -1;
 424   }
 425   {
 426     char fstype[] = "ext2";
 427     char device[] = "/dev/sda1";
 428     int r;
 429     suppress_error = 0;
 430     r = guestfs_mkfs (g, fstype, device);
 431     if (r == -1)
 432       return -1;
 433   }
 434   {
 435     char device[] = "/dev/sda1";
 436     char mountpoint[] = "/";
 437     int r;
 438     suppress_error = 0;
 439     r = guestfs_mount (g, device, mountpoint);
 440     if (r == -1)
 441       return -1;
 442   }
 443   /* TestOutputList for initrd_list (0) */
 444   {
 445     char options[] = "ro";
 446     char vfstype[] = "squashfs";
 447     char device[] = "/dev/sdd";
 448     char mountpoint[] = "/";
 449     int r;
 450     suppress_error = 0;
 451     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 452     if (r == -1)
 453       return -1;
 454   }
 455   {
 456     char path[] = "/initrd";
 457     char **r;
 458     int i;
 459     suppress_error = 0;
 460     r = guestfs_initrd_list (g, path);
 461     if (r == NULL)
 462       return -1;
 463     if (!r[0]) {
 464       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 465       print_strings (r);
 466       return -1;
 467     }
 468     {
 469       char expected[] = "empty";
 470       if (strcmp (r[0], expected) != 0) {
 471         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 472         return -1;
 473       }
 474     }
 475     if (!r[1]) {
 476       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 477       print_strings (r);
 478       return -1;
 479     }
 480     {
 481       char expected[] = "known-1";
 482       if (strcmp (r[1], expected) != 0) {
 483         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 484         return -1;
 485       }
 486     }
 487     if (!r[2]) {
 488       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 489       print_strings (r);
 490       return -1;
 491     }
 492     {
 493       char expected[] = "known-2";
 494       if (strcmp (r[2], expected) != 0) {
 495         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 496         return -1;
 497       }
 498     }
 499     if (!r[3]) {
 500       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 501       print_strings (r);
 502       return -1;
 503     }
 504     {
 505       char expected[] = "known-3";
 506       if (strcmp (r[3], expected) != 0) {
 507         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 508         return -1;
 509       }
 510     }
 511     if (r[4] != NULL) {
 512       fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
 513       print_strings (r);
 514       return -1;
 515     }
 516     for (i = 0; r[i] != NULL; ++i)
 517       free (r[i]);
 518     free (r);
 519   }
 520   return 0;
 521 }
 522
 523 static int test_du_0_skip (void)
 524 {
 525   const char *str;
 526
 527   str = getenv ("TEST_ONLY");
 528   if (str)
 529     return strstr (str, "du") == NULL;
 530   str = getenv ("SKIP_TEST_DU_0");
 531   if (str && strcmp (str, "1") == 0) return 1;
 532   str = getenv ("SKIP_TEST_DU");
 533   if (str && strcmp (str, "1") == 0) return 1;
 534   return 0;
 535 }
 536
 537 static int test_du_0 (void)
 538 {
 539   if (test_du_0_skip ()) {
 540     printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
 541     return 0;
 542   }
 543
 544   /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
 545   {
 546     char device[] = "/dev/sda";
 547     int r;
 548     suppress_error = 0;
 549     r = guestfs_blockdev_setrw (g, device);
 550     if (r == -1)
 551       return -1;
 552   }
 553   {
 554     int r;
 555     suppress_error = 0;
 556     r = guestfs_umount_all (g);
 557     if (r == -1)
 558       return -1;
 559   }
 560   {
 561     int r;
 562     suppress_error = 0;
 563     r = guestfs_lvm_remove_all (g);
 564     if (r == -1)
 565       return -1;
 566   }
 567   {
 568     char device[] = "/dev/sda";
 569     char lines_0[] = ",";
 570     char *lines[] = {
 571       lines_0,
 572       NULL
 573     };
 574     int r;
 575     suppress_error = 0;
 576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 577     if (r == -1)
 578       return -1;
 579   }
 580   {
 581     char fstype[] = "ext2";
 582     char device[] = "/dev/sda1";
 583     int r;
 584     suppress_error = 0;
 585     r = guestfs_mkfs (g, fstype, device);
 586     if (r == -1)
 587       return -1;
 588   }
 589   {
 590     char device[] = "/dev/sda1";
 591     char mountpoint[] = "/";
 592     int r;
 593     suppress_error = 0;
 594     r = guestfs_mount (g, device, mountpoint);
 595     if (r == -1)
 596       return -1;
 597   }
 598   /* TestOutputInt for du (0) */
 599   {
 600     char path[] = "/p";
 601     int r;
 602     suppress_error = 0;
 603     r = guestfs_mkdir (g, path);
 604     if (r == -1)
 605       return -1;
 606   }
 607   {
 608     char path[] = "/p";
 609     int64_t r;
 610     suppress_error = 0;
 611     r = guestfs_du (g, path);
 612     if (r == -1)
 613       return -1;
 614     if (r != 1) {
 615       fprintf (stderr, "test_du_0: expected 1 but got %d\n",               (int) r);
 616       return -1;
 617     }
 618   }
 619   return 0;
 620 }
 621
 622 static int test_tail_n_0_skip (void)
 623 {
 624   const char *str;
 625
 626   str = getenv ("TEST_ONLY");
 627   if (str)
 628     return strstr (str, "tail_n") == NULL;
 629   str = getenv ("SKIP_TEST_TAIL_N_0");
 630   if (str && strcmp (str, "1") == 0) return 1;
 631   str = getenv ("SKIP_TEST_TAIL_N");
 632   if (str && strcmp (str, "1") == 0) return 1;
 633   return 0;
 634 }
 635
 636 static int test_tail_n_0 (void)
 637 {
 638   if (test_tail_n_0_skip ()) {
 639     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
 640     return 0;
 641   }
 642
 643   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
 644   {
 645     char device[] = "/dev/sda";
 646     int r;
 647     suppress_error = 0;
 648     r = guestfs_blockdev_setrw (g, device);
 649     if (r == -1)
 650       return -1;
 651   }
 652   {
 653     int r;
 654     suppress_error = 0;
 655     r = guestfs_umount_all (g);
 656     if (r == -1)
 657       return -1;
 658   }
 659   {
 660     int r;
 661     suppress_error = 0;
 662     r = guestfs_lvm_remove_all (g);
 663     if (r == -1)
 664       return -1;
 665   }
 666   {
 667     char device[] = "/dev/sda";
 668     char lines_0[] = ",";
 669     char *lines[] = {
 670       lines_0,
 671       NULL
 672     };
 673     int r;
 674     suppress_error = 0;
 675     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 676     if (r == -1)
 677       return -1;
 678   }
 679   {
 680     char fstype[] = "ext2";
 681     char device[] = "/dev/sda1";
 682     int r;
 683     suppress_error = 0;
 684     r = guestfs_mkfs (g, fstype, device);
 685     if (r == -1)
 686       return -1;
 687   }
 688   {
 689     char device[] = "/dev/sda1";
 690     char mountpoint[] = "/";
 691     int r;
 692     suppress_error = 0;
 693     r = guestfs_mount (g, device, mountpoint);
 694     if (r == -1)
 695       return -1;
 696   }
 697   /* TestOutputList for tail_n (0) */
 698   {
 699     char options[] = "ro";
 700     char vfstype[] = "squashfs";
 701     char device[] = "/dev/sdd";
 702     char mountpoint[] = "/";
 703     int r;
 704     suppress_error = 0;
 705     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 706     if (r == -1)
 707       return -1;
 708   }
 709   {
 710     char path[] = "/10klines";
 711     char **r;
 712     int i;
 713     suppress_error = 0;
 714     r = guestfs_tail_n (g, 3, path);
 715     if (r == NULL)
 716       return -1;
 717     if (!r[0]) {
 718       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 719       print_strings (r);
 720       return -1;
 721     }
 722     {
 723       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 724       if (strcmp (r[0], expected) != 0) {
 725         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 726         return -1;
 727       }
 728     }
 729     if (!r[1]) {
 730       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 731       print_strings (r);
 732       return -1;
 733     }
 734     {
 735       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 736       if (strcmp (r[1], expected) != 0) {
 737         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 738         return -1;
 739       }
 740     }
 741     if (!r[2]) {
 742       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 743       print_strings (r);
 744       return -1;
 745     }
 746     {
 747       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 748       if (strcmp (r[2], expected) != 0) {
 749         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 750         return -1;
 751       }
 752     }
 753     if (r[3] != NULL) {
 754       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
 755       print_strings (r);
 756       return -1;
 757     }
 758     for (i = 0; r[i] != NULL; ++i)
 759       free (r[i]);
 760     free (r);
 761   }
 762   return 0;
 763 }
 764
 765 static int test_tail_n_1_skip (void)
 766 {
 767   const char *str;
 768
 769   str = getenv ("TEST_ONLY");
 770   if (str)
 771     return strstr (str, "tail_n") == NULL;
 772   str = getenv ("SKIP_TEST_TAIL_N_1");
 773   if (str && strcmp (str, "1") == 0) return 1;
 774   str = getenv ("SKIP_TEST_TAIL_N");
 775   if (str && strcmp (str, "1") == 0) return 1;
 776   return 0;
 777 }
 778
 779 static int test_tail_n_1 (void)
 780 {
 781   if (test_tail_n_1_skip ()) {
 782     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
 783     return 0;
 784   }
 785
 786   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
 787   {
 788     char device[] = "/dev/sda";
 789     int r;
 790     suppress_error = 0;
 791     r = guestfs_blockdev_setrw (g, device);
 792     if (r == -1)
 793       return -1;
 794   }
 795   {
 796     int r;
 797     suppress_error = 0;
 798     r = guestfs_umount_all (g);
 799     if (r == -1)
 800       return -1;
 801   }
 802   {
 803     int r;
 804     suppress_error = 0;
 805     r = guestfs_lvm_remove_all (g);
 806     if (r == -1)
 807       return -1;
 808   }
 809   {
 810     char device[] = "/dev/sda";
 811     char lines_0[] = ",";
 812     char *lines[] = {
 813       lines_0,
 814       NULL
 815     };
 816     int r;
 817     suppress_error = 0;
 818     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 819     if (r == -1)
 820       return -1;
 821   }
 822   {
 823     char fstype[] = "ext2";
 824     char device[] = "/dev/sda1";
 825     int r;
 826     suppress_error = 0;
 827     r = guestfs_mkfs (g, fstype, device);
 828     if (r == -1)
 829       return -1;
 830   }
 831   {
 832     char device[] = "/dev/sda1";
 833     char mountpoint[] = "/";
 834     int r;
 835     suppress_error = 0;
 836     r = guestfs_mount (g, device, mountpoint);
 837     if (r == -1)
 838       return -1;
 839   }
 840   /* TestOutputList for tail_n (1) */
 841   {
 842     char options[] = "ro";
 843     char vfstype[] = "squashfs";
 844     char device[] = "/dev/sdd";
 845     char mountpoint[] = "/";
 846     int r;
 847     suppress_error = 0;
 848     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 849     if (r == -1)
 850       return -1;
 851   }
 852   {
 853     char path[] = "/10klines";
 854     char **r;
 855     int i;
 856     suppress_error = 0;
 857     r = guestfs_tail_n (g, -9998, path);
 858     if (r == NULL)
 859       return -1;
 860     if (!r[0]) {
 861       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 862       print_strings (r);
 863       return -1;
 864     }
 865     {
 866       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 867       if (strcmp (r[0], expected) != 0) {
 868         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 869         return -1;
 870       }
 871     }
 872     if (!r[1]) {
 873       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 874       print_strings (r);
 875       return -1;
 876     }
 877     {
 878       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 879       if (strcmp (r[1], expected) != 0) {
 880         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 881         return -1;
 882       }
 883     }
 884     if (!r[2]) {
 885       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 886       print_strings (r);
 887       return -1;
 888     }
 889     {
 890       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 891       if (strcmp (r[2], expected) != 0) {
 892         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 893         return -1;
 894       }
 895     }
 896     if (r[3] != NULL) {
 897       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
 898       print_strings (r);
 899       return -1;
 900     }
 901     for (i = 0; r[i] != NULL; ++i)
 902       free (r[i]);
 903     free (r);
 904   }
 905   return 0;
 906 }
 907
 908 static int test_tail_n_2_skip (void)
 909 {
 910   const char *str;
 911
 912   str = getenv ("TEST_ONLY");
 913   if (str)
 914     return strstr (str, "tail_n") == NULL;
 915   str = getenv ("SKIP_TEST_TAIL_N_2");
 916   if (str && strcmp (str, "1") == 0) return 1;
 917   str = getenv ("SKIP_TEST_TAIL_N");
 918   if (str && strcmp (str, "1") == 0) return 1;
 919   return 0;
 920 }
 921
 922 static int test_tail_n_2 (void)
 923 {
 924   if (test_tail_n_2_skip ()) {
 925     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
 926     return 0;
 927   }
 928
 929   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
 930   {
 931     char device[] = "/dev/sda";
 932     int r;
 933     suppress_error = 0;
 934     r = guestfs_blockdev_setrw (g, device);
 935     if (r == -1)
 936       return -1;
 937   }
 938   {
 939     int r;
 940     suppress_error = 0;
 941     r = guestfs_umount_all (g);
 942     if (r == -1)
 943       return -1;
 944   }
 945   {
 946     int r;
 947     suppress_error = 0;
 948     r = guestfs_lvm_remove_all (g);
 949     if (r == -1)
 950       return -1;
 951   }
 952   {
 953     char device[] = "/dev/sda";
 954     char lines_0[] = ",";
 955     char *lines[] = {
 956       lines_0,
 957       NULL
 958     };
 959     int r;
 960     suppress_error = 0;
 961     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 962     if (r == -1)
 963       return -1;
 964   }
 965   {
 966     char fstype[] = "ext2";
 967     char device[] = "/dev/sda1";
 968     int r;
 969     suppress_error = 0;
 970     r = guestfs_mkfs (g, fstype, device);
 971     if (r == -1)
 972       return -1;
 973   }
 974   {
 975     char device[] = "/dev/sda1";
 976     char mountpoint[] = "/";
 977     int r;
 978     suppress_error = 0;
 979     r = guestfs_mount (g, device, mountpoint);
 980     if (r == -1)
 981       return -1;
 982   }
 983   /* TestOutputList for tail_n (2) */
 984   {
 985     char options[] = "ro";
 986     char vfstype[] = "squashfs";
 987     char device[] = "/dev/sdd";
 988     char mountpoint[] = "/";
 989     int r;
 990     suppress_error = 0;
 991     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 992     if (r == -1)
 993       return -1;
 994   }
 995   {
 996     char path[] = "/10klines";
 997     char **r;
 998     int i;
 999     suppress_error = 0;
1000     r = guestfs_tail_n (g, 0, path);
1001     if (r == NULL)
1002       return -1;
1003     if (r[0] != NULL) {
1004       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1005       print_strings (r);
1006       return -1;
1007     }
1008     for (i = 0; r[i] != NULL; ++i)
1009       free (r[i]);
1010     free (r);
1011   }
1012   return 0;
1013 }
1014
1015 static int test_tail_0_skip (void)
1016 {
1017   const char *str;
1018
1019   str = getenv ("TEST_ONLY");
1020   if (str)
1021     return strstr (str, "tail") == NULL;
1022   str = getenv ("SKIP_TEST_TAIL_0");
1023   if (str && strcmp (str, "1") == 0) return 1;
1024   str = getenv ("SKIP_TEST_TAIL");
1025   if (str && strcmp (str, "1") == 0) return 1;
1026   return 0;
1027 }
1028
1029 static int test_tail_0 (void)
1030 {
1031   if (test_tail_0_skip ()) {
1032     printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
1033     return 0;
1034   }
1035
1036   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1037   {
1038     char device[] = "/dev/sda";
1039     int r;
1040     suppress_error = 0;
1041     r = guestfs_blockdev_setrw (g, device);
1042     if (r == -1)
1043       return -1;
1044   }
1045   {
1046     int r;
1047     suppress_error = 0;
1048     r = guestfs_umount_all (g);
1049     if (r == -1)
1050       return -1;
1051   }
1052   {
1053     int r;
1054     suppress_error = 0;
1055     r = guestfs_lvm_remove_all (g);
1056     if (r == -1)
1057       return -1;
1058   }
1059   {
1060     char device[] = "/dev/sda";
1061     char lines_0[] = ",";
1062     char *lines[] = {
1063       lines_0,
1064       NULL
1065     };
1066     int r;
1067     suppress_error = 0;
1068     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1069     if (r == -1)
1070       return -1;
1071   }
1072   {
1073     char fstype[] = "ext2";
1074     char device[] = "/dev/sda1";
1075     int r;
1076     suppress_error = 0;
1077     r = guestfs_mkfs (g, fstype, device);
1078     if (r == -1)
1079       return -1;
1080   }
1081   {
1082     char device[] = "/dev/sda1";
1083     char mountpoint[] = "/";
1084     int r;
1085     suppress_error = 0;
1086     r = guestfs_mount (g, device, mountpoint);
1087     if (r == -1)
1088       return -1;
1089   }
1090   /* TestOutputList for tail (0) */
1091   {
1092     char options[] = "ro";
1093     char vfstype[] = "squashfs";
1094     char device[] = "/dev/sdd";
1095     char mountpoint[] = "/";
1096     int r;
1097     suppress_error = 0;
1098     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1099     if (r == -1)
1100       return -1;
1101   }
1102   {
1103     char path[] = "/10klines";
1104     char **r;
1105     int i;
1106     suppress_error = 0;
1107     r = guestfs_tail (g, path);
1108     if (r == NULL)
1109       return -1;
1110     if (!r[0]) {
1111       fprintf (stderr, "test_tail_0: short list returned from command\n");
1112       print_strings (r);
1113       return -1;
1114     }
1115     {
1116       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1117       if (strcmp (r[0], expected) != 0) {
1118         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1119         return -1;
1120       }
1121     }
1122     if (!r[1]) {
1123       fprintf (stderr, "test_tail_0: short list returned from command\n");
1124       print_strings (r);
1125       return -1;
1126     }
1127     {
1128       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1129       if (strcmp (r[1], expected) != 0) {
1130         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1131         return -1;
1132       }
1133     }
1134     if (!r[2]) {
1135       fprintf (stderr, "test_tail_0: short list returned from command\n");
1136       print_strings (r);
1137       return -1;
1138     }
1139     {
1140       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1141       if (strcmp (r[2], expected) != 0) {
1142         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1143         return -1;
1144       }
1145     }
1146     if (!r[3]) {
1147       fprintf (stderr, "test_tail_0: short list returned from command\n");
1148       print_strings (r);
1149       return -1;
1150     }
1151     {
1152       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1153       if (strcmp (r[3], expected) != 0) {
1154         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1155         return -1;
1156       }
1157     }
1158     if (!r[4]) {
1159       fprintf (stderr, "test_tail_0: short list returned from command\n");
1160       print_strings (r);
1161       return -1;
1162     }
1163     {
1164       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1165       if (strcmp (r[4], expected) != 0) {
1166         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1167         return -1;
1168       }
1169     }
1170     if (!r[5]) {
1171       fprintf (stderr, "test_tail_0: short list returned from command\n");
1172       print_strings (r);
1173       return -1;
1174     }
1175     {
1176       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1177       if (strcmp (r[5], expected) != 0) {
1178         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1179         return -1;
1180       }
1181     }
1182     if (!r[6]) {
1183       fprintf (stderr, "test_tail_0: short list returned from command\n");
1184       print_strings (r);
1185       return -1;
1186     }
1187     {
1188       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1189       if (strcmp (r[6], expected) != 0) {
1190         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1191         return -1;
1192       }
1193     }
1194     if (!r[7]) {
1195       fprintf (stderr, "test_tail_0: short list returned from command\n");
1196       print_strings (r);
1197       return -1;
1198     }
1199     {
1200       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1201       if (strcmp (r[7], expected) != 0) {
1202         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1203         return -1;
1204       }
1205     }
1206     if (!r[8]) {
1207       fprintf (stderr, "test_tail_0: short list returned from command\n");
1208       print_strings (r);
1209       return -1;
1210     }
1211     {
1212       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1213       if (strcmp (r[8], expected) != 0) {
1214         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1215         return -1;
1216       }
1217     }
1218     if (!r[9]) {
1219       fprintf (stderr, "test_tail_0: short list returned from command\n");
1220       print_strings (r);
1221       return -1;
1222     }
1223     {
1224       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1225       if (strcmp (r[9], expected) != 0) {
1226         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1227         return -1;
1228       }
1229     }
1230     if (r[10] != NULL) {
1231       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1232       print_strings (r);
1233       return -1;
1234     }
1235     for (i = 0; r[i] != NULL; ++i)
1236       free (r[i]);
1237     free (r);
1238   }
1239   return 0;
1240 }
1241
1242 static int test_head_n_0_skip (void)
1243 {
1244   const char *str;
1245
1246   str = getenv ("TEST_ONLY");
1247   if (str)
1248     return strstr (str, "head_n") == NULL;
1249   str = getenv ("SKIP_TEST_HEAD_N_0");
1250   if (str && strcmp (str, "1") == 0) return 1;
1251   str = getenv ("SKIP_TEST_HEAD_N");
1252   if (str && strcmp (str, "1") == 0) return 1;
1253   return 0;
1254 }
1255
1256 static int test_head_n_0 (void)
1257 {
1258   if (test_head_n_0_skip ()) {
1259     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1260     return 0;
1261   }
1262
1263   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1264   {
1265     char device[] = "/dev/sda";
1266     int r;
1267     suppress_error = 0;
1268     r = guestfs_blockdev_setrw (g, device);
1269     if (r == -1)
1270       return -1;
1271   }
1272   {
1273     int r;
1274     suppress_error = 0;
1275     r = guestfs_umount_all (g);
1276     if (r == -1)
1277       return -1;
1278   }
1279   {
1280     int r;
1281     suppress_error = 0;
1282     r = guestfs_lvm_remove_all (g);
1283     if (r == -1)
1284       return -1;
1285   }
1286   {
1287     char device[] = "/dev/sda";
1288     char lines_0[] = ",";
1289     char *lines[] = {
1290       lines_0,
1291       NULL
1292     };
1293     int r;
1294     suppress_error = 0;
1295     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1296     if (r == -1)
1297       return -1;
1298   }
1299   {
1300     char fstype[] = "ext2";
1301     char device[] = "/dev/sda1";
1302     int r;
1303     suppress_error = 0;
1304     r = guestfs_mkfs (g, fstype, device);
1305     if (r == -1)
1306       return -1;
1307   }
1308   {
1309     char device[] = "/dev/sda1";
1310     char mountpoint[] = "/";
1311     int r;
1312     suppress_error = 0;
1313     r = guestfs_mount (g, device, mountpoint);
1314     if (r == -1)
1315       return -1;
1316   }
1317   /* TestOutputList for head_n (0) */
1318   {
1319     char options[] = "ro";
1320     char vfstype[] = "squashfs";
1321     char device[] = "/dev/sdd";
1322     char mountpoint[] = "/";
1323     int r;
1324     suppress_error = 0;
1325     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1326     if (r == -1)
1327       return -1;
1328   }
1329   {
1330     char path[] = "/10klines";
1331     char **r;
1332     int i;
1333     suppress_error = 0;
1334     r = guestfs_head_n (g, 3, path);
1335     if (r == NULL)
1336       return -1;
1337     if (!r[0]) {
1338       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1339       print_strings (r);
1340       return -1;
1341     }
1342     {
1343       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1344       if (strcmp (r[0], expected) != 0) {
1345         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1346         return -1;
1347       }
1348     }
1349     if (!r[1]) {
1350       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1351       print_strings (r);
1352       return -1;
1353     }
1354     {
1355       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1356       if (strcmp (r[1], expected) != 0) {
1357         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1358         return -1;
1359       }
1360     }
1361     if (!r[2]) {
1362       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1363       print_strings (r);
1364       return -1;
1365     }
1366     {
1367       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1368       if (strcmp (r[2], expected) != 0) {
1369         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1370         return -1;
1371       }
1372     }
1373     if (r[3] != NULL) {
1374       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1375       print_strings (r);
1376       return -1;
1377     }
1378     for (i = 0; r[i] != NULL; ++i)
1379       free (r[i]);
1380     free (r);
1381   }
1382   return 0;
1383 }
1384
1385 static int test_head_n_1_skip (void)
1386 {
1387   const char *str;
1388
1389   str = getenv ("TEST_ONLY");
1390   if (str)
1391     return strstr (str, "head_n") == NULL;
1392   str = getenv ("SKIP_TEST_HEAD_N_1");
1393   if (str && strcmp (str, "1") == 0) return 1;
1394   str = getenv ("SKIP_TEST_HEAD_N");
1395   if (str && strcmp (str, "1") == 0) return 1;
1396   return 0;
1397 }
1398
1399 static int test_head_n_1 (void)
1400 {
1401   if (test_head_n_1_skip ()) {
1402     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1403     return 0;
1404   }
1405
1406   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1407   {
1408     char device[] = "/dev/sda";
1409     int r;
1410     suppress_error = 0;
1411     r = guestfs_blockdev_setrw (g, device);
1412     if (r == -1)
1413       return -1;
1414   }
1415   {
1416     int r;
1417     suppress_error = 0;
1418     r = guestfs_umount_all (g);
1419     if (r == -1)
1420       return -1;
1421   }
1422   {
1423     int r;
1424     suppress_error = 0;
1425     r = guestfs_lvm_remove_all (g);
1426     if (r == -1)
1427       return -1;
1428   }
1429   {
1430     char device[] = "/dev/sda";
1431     char lines_0[] = ",";
1432     char *lines[] = {
1433       lines_0,
1434       NULL
1435     };
1436     int r;
1437     suppress_error = 0;
1438     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1439     if (r == -1)
1440       return -1;
1441   }
1442   {
1443     char fstype[] = "ext2";
1444     char device[] = "/dev/sda1";
1445     int r;
1446     suppress_error = 0;
1447     r = guestfs_mkfs (g, fstype, device);
1448     if (r == -1)
1449       return -1;
1450   }
1451   {
1452     char device[] = "/dev/sda1";
1453     char mountpoint[] = "/";
1454     int r;
1455     suppress_error = 0;
1456     r = guestfs_mount (g, device, mountpoint);
1457     if (r == -1)
1458       return -1;
1459   }
1460   /* TestOutputList for head_n (1) */
1461   {
1462     char options[] = "ro";
1463     char vfstype[] = "squashfs";
1464     char device[] = "/dev/sdd";
1465     char mountpoint[] = "/";
1466     int r;
1467     suppress_error = 0;
1468     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1469     if (r == -1)
1470       return -1;
1471   }
1472   {
1473     char path[] = "/10klines";
1474     char **r;
1475     int i;
1476     suppress_error = 0;
1477     r = guestfs_head_n (g, -9997, path);
1478     if (r == NULL)
1479       return -1;
1480     if (!r[0]) {
1481       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1482       print_strings (r);
1483       return -1;
1484     }
1485     {
1486       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1487       if (strcmp (r[0], expected) != 0) {
1488         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1489         return -1;
1490       }
1491     }
1492     if (!r[1]) {
1493       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1494       print_strings (r);
1495       return -1;
1496     }
1497     {
1498       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1499       if (strcmp (r[1], expected) != 0) {
1500         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1501         return -1;
1502       }
1503     }
1504     if (!r[2]) {
1505       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1506       print_strings (r);
1507       return -1;
1508     }
1509     {
1510       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1511       if (strcmp (r[2], expected) != 0) {
1512         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1513         return -1;
1514       }
1515     }
1516     if (r[3] != NULL) {
1517       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1518       print_strings (r);
1519       return -1;
1520     }
1521     for (i = 0; r[i] != NULL; ++i)
1522       free (r[i]);
1523     free (r);
1524   }
1525   return 0;
1526 }
1527
1528 static int test_head_n_2_skip (void)
1529 {
1530   const char *str;
1531
1532   str = getenv ("TEST_ONLY");
1533   if (str)
1534     return strstr (str, "head_n") == NULL;
1535   str = getenv ("SKIP_TEST_HEAD_N_2");
1536   if (str && strcmp (str, "1") == 0) return 1;
1537   str = getenv ("SKIP_TEST_HEAD_N");
1538   if (str && strcmp (str, "1") == 0) return 1;
1539   return 0;
1540 }
1541
1542 static int test_head_n_2 (void)
1543 {
1544   if (test_head_n_2_skip ()) {
1545     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1546     return 0;
1547   }
1548
1549   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1550   {
1551     char device[] = "/dev/sda";
1552     int r;
1553     suppress_error = 0;
1554     r = guestfs_blockdev_setrw (g, device);
1555     if (r == -1)
1556       return -1;
1557   }
1558   {
1559     int r;
1560     suppress_error = 0;
1561     r = guestfs_umount_all (g);
1562     if (r == -1)
1563       return -1;
1564   }
1565   {
1566     int r;
1567     suppress_error = 0;
1568     r = guestfs_lvm_remove_all (g);
1569     if (r == -1)
1570       return -1;
1571   }
1572   {
1573     char device[] = "/dev/sda";
1574     char lines_0[] = ",";
1575     char *lines[] = {
1576       lines_0,
1577       NULL
1578     };
1579     int r;
1580     suppress_error = 0;
1581     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1582     if (r == -1)
1583       return -1;
1584   }
1585   {
1586     char fstype[] = "ext2";
1587     char device[] = "/dev/sda1";
1588     int r;
1589     suppress_error = 0;
1590     r = guestfs_mkfs (g, fstype, device);
1591     if (r == -1)
1592       return -1;
1593   }
1594   {
1595     char device[] = "/dev/sda1";
1596     char mountpoint[] = "/";
1597     int r;
1598     suppress_error = 0;
1599     r = guestfs_mount (g, device, mountpoint);
1600     if (r == -1)
1601       return -1;
1602   }
1603   /* TestOutputList for head_n (2) */
1604   {
1605     char options[] = "ro";
1606     char vfstype[] = "squashfs";
1607     char device[] = "/dev/sdd";
1608     char mountpoint[] = "/";
1609     int r;
1610     suppress_error = 0;
1611     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1612     if (r == -1)
1613       return -1;
1614   }
1615   {
1616     char path[] = "/10klines";
1617     char **r;
1618     int i;
1619     suppress_error = 0;
1620     r = guestfs_head_n (g, 0, path);
1621     if (r == NULL)
1622       return -1;
1623     if (r[0] != NULL) {
1624       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1625       print_strings (r);
1626       return -1;
1627     }
1628     for (i = 0; r[i] != NULL; ++i)
1629       free (r[i]);
1630     free (r);
1631   }
1632   return 0;
1633 }
1634
1635 static int test_head_0_skip (void)
1636 {
1637   const char *str;
1638
1639   str = getenv ("TEST_ONLY");
1640   if (str)
1641     return strstr (str, "head") == NULL;
1642   str = getenv ("SKIP_TEST_HEAD_0");
1643   if (str && strcmp (str, "1") == 0) return 1;
1644   str = getenv ("SKIP_TEST_HEAD");
1645   if (str && strcmp (str, "1") == 0) return 1;
1646   return 0;
1647 }
1648
1649 static int test_head_0 (void)
1650 {
1651   if (test_head_0_skip ()) {
1652     printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1653     return 0;
1654   }
1655
1656   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1657   {
1658     char device[] = "/dev/sda";
1659     int r;
1660     suppress_error = 0;
1661     r = guestfs_blockdev_setrw (g, device);
1662     if (r == -1)
1663       return -1;
1664   }
1665   {
1666     int r;
1667     suppress_error = 0;
1668     r = guestfs_umount_all (g);
1669     if (r == -1)
1670       return -1;
1671   }
1672   {
1673     int r;
1674     suppress_error = 0;
1675     r = guestfs_lvm_remove_all (g);
1676     if (r == -1)
1677       return -1;
1678   }
1679   {
1680     char device[] = "/dev/sda";
1681     char lines_0[] = ",";
1682     char *lines[] = {
1683       lines_0,
1684       NULL
1685     };
1686     int r;
1687     suppress_error = 0;
1688     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1689     if (r == -1)
1690       return -1;
1691   }
1692   {
1693     char fstype[] = "ext2";
1694     char device[] = "/dev/sda1";
1695     int r;
1696     suppress_error = 0;
1697     r = guestfs_mkfs (g, fstype, device);
1698     if (r == -1)
1699       return -1;
1700   }
1701   {
1702     char device[] = "/dev/sda1";
1703     char mountpoint[] = "/";
1704     int r;
1705     suppress_error = 0;
1706     r = guestfs_mount (g, device, mountpoint);
1707     if (r == -1)
1708       return -1;
1709   }
1710   /* TestOutputList for head (0) */
1711   {
1712     char options[] = "ro";
1713     char vfstype[] = "squashfs";
1714     char device[] = "/dev/sdd";
1715     char mountpoint[] = "/";
1716     int r;
1717     suppress_error = 0;
1718     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1719     if (r == -1)
1720       return -1;
1721   }
1722   {
1723     char path[] = "/10klines";
1724     char **r;
1725     int i;
1726     suppress_error = 0;
1727     r = guestfs_head (g, path);
1728     if (r == NULL)
1729       return -1;
1730     if (!r[0]) {
1731       fprintf (stderr, "test_head_0: short list returned from command\n");
1732       print_strings (r);
1733       return -1;
1734     }
1735     {
1736       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1737       if (strcmp (r[0], expected) != 0) {
1738         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1739         return -1;
1740       }
1741     }
1742     if (!r[1]) {
1743       fprintf (stderr, "test_head_0: short list returned from command\n");
1744       print_strings (r);
1745       return -1;
1746     }
1747     {
1748       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1749       if (strcmp (r[1], expected) != 0) {
1750         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1751         return -1;
1752       }
1753     }
1754     if (!r[2]) {
1755       fprintf (stderr, "test_head_0: short list returned from command\n");
1756       print_strings (r);
1757       return -1;
1758     }
1759     {
1760       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1761       if (strcmp (r[2], expected) != 0) {
1762         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1763         return -1;
1764       }
1765     }
1766     if (!r[3]) {
1767       fprintf (stderr, "test_head_0: short list returned from command\n");
1768       print_strings (r);
1769       return -1;
1770     }
1771     {
1772       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1773       if (strcmp (r[3], expected) != 0) {
1774         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1775         return -1;
1776       }
1777     }
1778     if (!r[4]) {
1779       fprintf (stderr, "test_head_0: short list returned from command\n");
1780       print_strings (r);
1781       return -1;
1782     }
1783     {
1784       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1785       if (strcmp (r[4], expected) != 0) {
1786         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1787         return -1;
1788       }
1789     }
1790     if (!r[5]) {
1791       fprintf (stderr, "test_head_0: short list returned from command\n");
1792       print_strings (r);
1793       return -1;
1794     }
1795     {
1796       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1797       if (strcmp (r[5], expected) != 0) {
1798         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1799         return -1;
1800       }
1801     }
1802     if (!r[6]) {
1803       fprintf (stderr, "test_head_0: short list returned from command\n");
1804       print_strings (r);
1805       return -1;
1806     }
1807     {
1808       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1809       if (strcmp (r[6], expected) != 0) {
1810         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1811         return -1;
1812       }
1813     }
1814     if (!r[7]) {
1815       fprintf (stderr, "test_head_0: short list returned from command\n");
1816       print_strings (r);
1817       return -1;
1818     }
1819     {
1820       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1821       if (strcmp (r[7], expected) != 0) {
1822         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1823         return -1;
1824       }
1825     }
1826     if (!r[8]) {
1827       fprintf (stderr, "test_head_0: short list returned from command\n");
1828       print_strings (r);
1829       return -1;
1830     }
1831     {
1832       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1833       if (strcmp (r[8], expected) != 0) {
1834         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1835         return -1;
1836       }
1837     }
1838     if (!r[9]) {
1839       fprintf (stderr, "test_head_0: short list returned from command\n");
1840       print_strings (r);
1841       return -1;
1842     }
1843     {
1844       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1845       if (strcmp (r[9], expected) != 0) {
1846         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1847         return -1;
1848       }
1849     }
1850     if (r[10] != NULL) {
1851       fprintf (stderr, "test_head_0: extra elements returned from command\n");
1852       print_strings (r);
1853       return -1;
1854     }
1855     for (i = 0; r[i] != NULL; ++i)
1856       free (r[i]);
1857     free (r);
1858   }
1859   return 0;
1860 }
1861
1862 static int test_wc_c_0_skip (void)
1863 {
1864   const char *str;
1865
1866   str = getenv ("TEST_ONLY");
1867   if (str)
1868     return strstr (str, "wc_c") == NULL;
1869   str = getenv ("SKIP_TEST_WC_C_0");
1870   if (str && strcmp (str, "1") == 0) return 1;
1871   str = getenv ("SKIP_TEST_WC_C");
1872   if (str && strcmp (str, "1") == 0) return 1;
1873   return 0;
1874 }
1875
1876 static int test_wc_c_0 (void)
1877 {
1878   if (test_wc_c_0_skip ()) {
1879     printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1880     return 0;
1881   }
1882
1883   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1884   {
1885     char device[] = "/dev/sda";
1886     int r;
1887     suppress_error = 0;
1888     r = guestfs_blockdev_setrw (g, device);
1889     if (r == -1)
1890       return -1;
1891   }
1892   {
1893     int r;
1894     suppress_error = 0;
1895     r = guestfs_umount_all (g);
1896     if (r == -1)
1897       return -1;
1898   }
1899   {
1900     int r;
1901     suppress_error = 0;
1902     r = guestfs_lvm_remove_all (g);
1903     if (r == -1)
1904       return -1;
1905   }
1906   {
1907     char device[] = "/dev/sda";
1908     char lines_0[] = ",";
1909     char *lines[] = {
1910       lines_0,
1911       NULL
1912     };
1913     int r;
1914     suppress_error = 0;
1915     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1916     if (r == -1)
1917       return -1;
1918   }
1919   {
1920     char fstype[] = "ext2";
1921     char device[] = "/dev/sda1";
1922     int r;
1923     suppress_error = 0;
1924     r = guestfs_mkfs (g, fstype, device);
1925     if (r == -1)
1926       return -1;
1927   }
1928   {
1929     char device[] = "/dev/sda1";
1930     char mountpoint[] = "/";
1931     int r;
1932     suppress_error = 0;
1933     r = guestfs_mount (g, device, mountpoint);
1934     if (r == -1)
1935       return -1;
1936   }
1937   /* TestOutputInt for wc_c (0) */
1938   {
1939     char options[] = "ro";
1940     char vfstype[] = "squashfs";
1941     char device[] = "/dev/sdd";
1942     char mountpoint[] = "/";
1943     int r;
1944     suppress_error = 0;
1945     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1946     if (r == -1)
1947       return -1;
1948   }
1949   {
1950     char path[] = "/100kallspaces";
1951     int r;
1952     suppress_error = 0;
1953     r = guestfs_wc_c (g, path);
1954     if (r == -1)
1955       return -1;
1956     if (r != 102400) {
1957       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
1958       return -1;
1959     }
1960   }
1961   return 0;
1962 }
1963
1964 static int test_wc_w_0_skip (void)
1965 {
1966   const char *str;
1967
1968   str = getenv ("TEST_ONLY");
1969   if (str)
1970     return strstr (str, "wc_w") == NULL;
1971   str = getenv ("SKIP_TEST_WC_W_0");
1972   if (str && strcmp (str, "1") == 0) return 1;
1973   str = getenv ("SKIP_TEST_WC_W");
1974   if (str && strcmp (str, "1") == 0) return 1;
1975   return 0;
1976 }
1977
1978 static int test_wc_w_0 (void)
1979 {
1980   if (test_wc_w_0_skip ()) {
1981     printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1982     return 0;
1983   }
1984
1985   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1986   {
1987     char device[] = "/dev/sda";
1988     int r;
1989     suppress_error = 0;
1990     r = guestfs_blockdev_setrw (g, device);
1991     if (r == -1)
1992       return -1;
1993   }
1994   {
1995     int r;
1996     suppress_error = 0;
1997     r = guestfs_umount_all (g);
1998     if (r == -1)
1999       return -1;
2000   }
2001   {
2002     int r;
2003     suppress_error = 0;
2004     r = guestfs_lvm_remove_all (g);
2005     if (r == -1)
2006       return -1;
2007   }
2008   {
2009     char device[] = "/dev/sda";
2010     char lines_0[] = ",";
2011     char *lines[] = {
2012       lines_0,
2013       NULL
2014     };
2015     int r;
2016     suppress_error = 0;
2017     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2018     if (r == -1)
2019       return -1;
2020   }
2021   {
2022     char fstype[] = "ext2";
2023     char device[] = "/dev/sda1";
2024     int r;
2025     suppress_error = 0;
2026     r = guestfs_mkfs (g, fstype, device);
2027     if (r == -1)
2028       return -1;
2029   }
2030   {
2031     char device[] = "/dev/sda1";
2032     char mountpoint[] = "/";
2033     int r;
2034     suppress_error = 0;
2035     r = guestfs_mount (g, device, mountpoint);
2036     if (r == -1)
2037       return -1;
2038   }
2039   /* TestOutputInt for wc_w (0) */
2040   {
2041     char options[] = "ro";
2042     char vfstype[] = "squashfs";
2043     char device[] = "/dev/sdd";
2044     char mountpoint[] = "/";
2045     int r;
2046     suppress_error = 0;
2047     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2048     if (r == -1)
2049       return -1;
2050   }
2051   {
2052     char path[] = "/10klines";
2053     int r;
2054     suppress_error = 0;
2055     r = guestfs_wc_w (g, path);
2056     if (r == -1)
2057       return -1;
2058     if (r != 10000) {
2059       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
2060       return -1;
2061     }
2062   }
2063   return 0;
2064 }
2065
2066 static int test_wc_l_0_skip (void)
2067 {
2068   const char *str;
2069
2070   str = getenv ("TEST_ONLY");
2071   if (str)
2072     return strstr (str, "wc_l") == NULL;
2073   str = getenv ("SKIP_TEST_WC_L_0");
2074   if (str && strcmp (str, "1") == 0) return 1;
2075   str = getenv ("SKIP_TEST_WC_L");
2076   if (str && strcmp (str, "1") == 0) return 1;
2077   return 0;
2078 }
2079
2080 static int test_wc_l_0 (void)
2081 {
2082   if (test_wc_l_0_skip ()) {
2083     printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
2084     return 0;
2085   }
2086
2087   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2088   {
2089     char device[] = "/dev/sda";
2090     int r;
2091     suppress_error = 0;
2092     r = guestfs_blockdev_setrw (g, device);
2093     if (r == -1)
2094       return -1;
2095   }
2096   {
2097     int r;
2098     suppress_error = 0;
2099     r = guestfs_umount_all (g);
2100     if (r == -1)
2101       return -1;
2102   }
2103   {
2104     int r;
2105     suppress_error = 0;
2106     r = guestfs_lvm_remove_all (g);
2107     if (r == -1)
2108       return -1;
2109   }
2110   {
2111     char device[] = "/dev/sda";
2112     char lines_0[] = ",";
2113     char *lines[] = {
2114       lines_0,
2115       NULL
2116     };
2117     int r;
2118     suppress_error = 0;
2119     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2120     if (r == -1)
2121       return -1;
2122   }
2123   {
2124     char fstype[] = "ext2";
2125     char device[] = "/dev/sda1";
2126     int r;
2127     suppress_error = 0;
2128     r = guestfs_mkfs (g, fstype, device);
2129     if (r == -1)
2130       return -1;
2131   }
2132   {
2133     char device[] = "/dev/sda1";
2134     char mountpoint[] = "/";
2135     int r;
2136     suppress_error = 0;
2137     r = guestfs_mount (g, device, mountpoint);
2138     if (r == -1)
2139       return -1;
2140   }
2141   /* TestOutputInt for wc_l (0) */
2142   {
2143     char options[] = "ro";
2144     char vfstype[] = "squashfs";
2145     char device[] = "/dev/sdd";
2146     char mountpoint[] = "/";
2147     int r;
2148     suppress_error = 0;
2149     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2150     if (r == -1)
2151       return -1;
2152   }
2153   {
2154     char path[] = "/10klines";
2155     int r;
2156     suppress_error = 0;
2157     r = guestfs_wc_l (g, path);
2158     if (r == -1)
2159       return -1;
2160     if (r != 10000) {
2161       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
2162       return -1;
2163     }
2164   }
2165   return 0;
2166 }
2167
2168 static int test_mkdtemp_0_skip (void)
2169 {
2170   const char *str;
2171
2172   str = getenv ("TEST_ONLY");
2173   if (str)
2174     return strstr (str, "mkdtemp") == NULL;
2175   str = getenv ("SKIP_TEST_MKDTEMP_0");
2176   if (str && strcmp (str, "1") == 0) return 1;
2177   str = getenv ("SKIP_TEST_MKDTEMP");
2178   if (str && strcmp (str, "1") == 0) return 1;
2179   return 0;
2180 }
2181
2182 static int test_mkdtemp_0 (void)
2183 {
2184   if (test_mkdtemp_0_skip ()) {
2185     printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2186     return 0;
2187   }
2188
2189   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2190   {
2191     char device[] = "/dev/sda";
2192     int r;
2193     suppress_error = 0;
2194     r = guestfs_blockdev_setrw (g, device);
2195     if (r == -1)
2196       return -1;
2197   }
2198   {
2199     int r;
2200     suppress_error = 0;
2201     r = guestfs_umount_all (g);
2202     if (r == -1)
2203       return -1;
2204   }
2205   {
2206     int r;
2207     suppress_error = 0;
2208     r = guestfs_lvm_remove_all (g);
2209     if (r == -1)
2210       return -1;
2211   }
2212   {
2213     char device[] = "/dev/sda";
2214     char lines_0[] = ",";
2215     char *lines[] = {
2216       lines_0,
2217       NULL
2218     };
2219     int r;
2220     suppress_error = 0;
2221     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2222     if (r == -1)
2223       return -1;
2224   }
2225   {
2226     char fstype[] = "ext2";
2227     char device[] = "/dev/sda1";
2228     int r;
2229     suppress_error = 0;
2230     r = guestfs_mkfs (g, fstype, device);
2231     if (r == -1)
2232       return -1;
2233   }
2234   {
2235     char device[] = "/dev/sda1";
2236     char mountpoint[] = "/";
2237     int r;
2238     suppress_error = 0;
2239     r = guestfs_mount (g, device, mountpoint);
2240     if (r == -1)
2241       return -1;
2242   }
2243   /* TestRun for mkdtemp (0) */
2244   {
2245     char path[] = "/tmp";
2246     int r;
2247     suppress_error = 0;
2248     r = guestfs_mkdir (g, path);
2249     if (r == -1)
2250       return -1;
2251   }
2252   {
2253     char template[] = "/tmp/tmpXXXXXX";
2254     char *r;
2255     suppress_error = 0;
2256     r = guestfs_mkdtemp (g, template);
2257     if (r == NULL)
2258       return -1;
2259     free (r);
2260   }
2261   return 0;
2262 }
2263
2264 static int test_scrub_file_0_skip (void)
2265 {
2266   const char *str;
2267
2268   str = getenv ("TEST_ONLY");
2269   if (str)
2270     return strstr (str, "scrub_file") == NULL;
2271   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2272   if (str && strcmp (str, "1") == 0) return 1;
2273   str = getenv ("SKIP_TEST_SCRUB_FILE");
2274   if (str && strcmp (str, "1") == 0) return 1;
2275   return 0;
2276 }
2277
2278 static int test_scrub_file_0 (void)
2279 {
2280   if (test_scrub_file_0_skip ()) {
2281     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2282     return 0;
2283   }
2284
2285   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2286   {
2287     char device[] = "/dev/sda";
2288     int r;
2289     suppress_error = 0;
2290     r = guestfs_blockdev_setrw (g, device);
2291     if (r == -1)
2292       return -1;
2293   }
2294   {
2295     int r;
2296     suppress_error = 0;
2297     r = guestfs_umount_all (g);
2298     if (r == -1)
2299       return -1;
2300   }
2301   {
2302     int r;
2303     suppress_error = 0;
2304     r = guestfs_lvm_remove_all (g);
2305     if (r == -1)
2306       return -1;
2307   }
2308   {
2309     char device[] = "/dev/sda";
2310     char lines_0[] = ",";
2311     char *lines[] = {
2312       lines_0,
2313       NULL
2314     };
2315     int r;
2316     suppress_error = 0;
2317     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2318     if (r == -1)
2319       return -1;
2320   }
2321   {
2322     char fstype[] = "ext2";
2323     char device[] = "/dev/sda1";
2324     int r;
2325     suppress_error = 0;
2326     r = guestfs_mkfs (g, fstype, device);
2327     if (r == -1)
2328       return -1;
2329   }
2330   {
2331     char device[] = "/dev/sda1";
2332     char mountpoint[] = "/";
2333     int r;
2334     suppress_error = 0;
2335     r = guestfs_mount (g, device, mountpoint);
2336     if (r == -1)
2337       return -1;
2338   }
2339   /* TestRun for scrub_file (0) */
2340   {
2341     char path[] = "/file";
2342     char content[] = "content";
2343     int r;
2344     suppress_error = 0;
2345     r = guestfs_write_file (g, path, content, 0);
2346     if (r == -1)
2347       return -1;
2348   }
2349   {
2350     char file[] = "/file";
2351     int r;
2352     suppress_error = 0;
2353     r = guestfs_scrub_file (g, file);
2354     if (r == -1)
2355       return -1;
2356   }
2357   return 0;
2358 }
2359
2360 static int test_scrub_device_0_skip (void)
2361 {
2362   const char *str;
2363
2364   str = getenv ("TEST_ONLY");
2365   if (str)
2366     return strstr (str, "scrub_device") == NULL;
2367   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2368   if (str && strcmp (str, "1") == 0) return 1;
2369   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2370   if (str && strcmp (str, "1") == 0) return 1;
2371   return 0;
2372 }
2373
2374 static int test_scrub_device_0 (void)
2375 {
2376   if (test_scrub_device_0_skip ()) {
2377     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2378     return 0;
2379   }
2380
2381   /* InitNone|InitEmpty for test_scrub_device_0 */
2382   {
2383     char device[] = "/dev/sda";
2384     int r;
2385     suppress_error = 0;
2386     r = guestfs_blockdev_setrw (g, device);
2387     if (r == -1)
2388       return -1;
2389   }
2390   {
2391     int r;
2392     suppress_error = 0;
2393     r = guestfs_umount_all (g);
2394     if (r == -1)
2395       return -1;
2396   }
2397   {
2398     int r;
2399     suppress_error = 0;
2400     r = guestfs_lvm_remove_all (g);
2401     if (r == -1)
2402       return -1;
2403   }
2404   /* TestRun for scrub_device (0) */
2405   {
2406     char device[] = "/dev/sdc";
2407     int r;
2408     suppress_error = 0;
2409     r = guestfs_scrub_device (g, device);
2410     if (r == -1)
2411       return -1;
2412   }
2413   return 0;
2414 }
2415
2416 static int test_glob_expand_0_skip (void)
2417 {
2418   const char *str;
2419
2420   str = getenv ("TEST_ONLY");
2421   if (str)
2422     return strstr (str, "glob_expand") == NULL;
2423   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2424   if (str && strcmp (str, "1") == 0) return 1;
2425   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2426   if (str && strcmp (str, "1") == 0) return 1;
2427   return 0;
2428 }
2429
2430 static int test_glob_expand_0 (void)
2431 {
2432   if (test_glob_expand_0_skip ()) {
2433     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2434     return 0;
2435   }
2436
2437   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2438   {
2439     char device[] = "/dev/sda";
2440     int r;
2441     suppress_error = 0;
2442     r = guestfs_blockdev_setrw (g, device);
2443     if (r == -1)
2444       return -1;
2445   }
2446   {
2447     int r;
2448     suppress_error = 0;
2449     r = guestfs_umount_all (g);
2450     if (r == -1)
2451       return -1;
2452   }
2453   {
2454     int r;
2455     suppress_error = 0;
2456     r = guestfs_lvm_remove_all (g);
2457     if (r == -1)
2458       return -1;
2459   }
2460   {
2461     char device[] = "/dev/sda";
2462     char lines_0[] = ",";
2463     char *lines[] = {
2464       lines_0,
2465       NULL
2466     };
2467     int r;
2468     suppress_error = 0;
2469     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2470     if (r == -1)
2471       return -1;
2472   }
2473   {
2474     char fstype[] = "ext2";
2475     char device[] = "/dev/sda1";
2476     int r;
2477     suppress_error = 0;
2478     r = guestfs_mkfs (g, fstype, device);
2479     if (r == -1)
2480       return -1;
2481   }
2482   {
2483     char device[] = "/dev/sda1";
2484     char mountpoint[] = "/";
2485     int r;
2486     suppress_error = 0;
2487     r = guestfs_mount (g, device, mountpoint);
2488     if (r == -1)
2489       return -1;
2490   }
2491   /* TestOutputList for glob_expand (0) */
2492   {
2493     char path[] = "/a/b/c";
2494     int r;
2495     suppress_error = 0;
2496     r = guestfs_mkdir_p (g, path);
2497     if (r == -1)
2498       return -1;
2499   }
2500   {
2501     char path[] = "/a/b/c/d";
2502     int r;
2503     suppress_error = 0;
2504     r = guestfs_touch (g, path);
2505     if (r == -1)
2506       return -1;
2507   }
2508   {
2509     char path[] = "/a/b/c/e";
2510     int r;
2511     suppress_error = 0;
2512     r = guestfs_touch (g, path);
2513     if (r == -1)
2514       return -1;
2515   }
2516   {
2517     char pattern[] = "/a/b/c/*";
2518     char **r;
2519     int i;
2520     suppress_error = 0;
2521     r = guestfs_glob_expand (g, pattern);
2522     if (r == NULL)
2523       return -1;
2524     if (!r[0]) {
2525       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2526       print_strings (r);
2527       return -1;
2528     }
2529     {
2530       char expected[] = "/a/b/c/d";
2531       if (strcmp (r[0], expected) != 0) {
2532         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2533         return -1;
2534       }
2535     }
2536     if (!r[1]) {
2537       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2538       print_strings (r);
2539       return -1;
2540     }
2541     {
2542       char expected[] = "/a/b/c/e";
2543       if (strcmp (r[1], expected) != 0) {
2544         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2545         return -1;
2546       }
2547     }
2548     if (r[2] != NULL) {
2549       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2550       print_strings (r);
2551       return -1;
2552     }
2553     for (i = 0; r[i] != NULL; ++i)
2554       free (r[i]);
2555     free (r);
2556   }
2557   return 0;
2558 }
2559
2560 static int test_glob_expand_1_skip (void)
2561 {
2562   const char *str;
2563
2564   str = getenv ("TEST_ONLY");
2565   if (str)
2566     return strstr (str, "glob_expand") == NULL;
2567   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2568   if (str && strcmp (str, "1") == 0) return 1;
2569   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2570   if (str && strcmp (str, "1") == 0) return 1;
2571   return 0;
2572 }
2573
2574 static int test_glob_expand_1 (void)
2575 {
2576   if (test_glob_expand_1_skip ()) {
2577     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2578     return 0;
2579   }
2580
2581   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2582   {
2583     char device[] = "/dev/sda";
2584     int r;
2585     suppress_error = 0;
2586     r = guestfs_blockdev_setrw (g, device);
2587     if (r == -1)
2588       return -1;
2589   }
2590   {
2591     int r;
2592     suppress_error = 0;
2593     r = guestfs_umount_all (g);
2594     if (r == -1)
2595       return -1;
2596   }
2597   {
2598     int r;
2599     suppress_error = 0;
2600     r = guestfs_lvm_remove_all (g);
2601     if (r == -1)
2602       return -1;
2603   }
2604   {
2605     char device[] = "/dev/sda";
2606     char lines_0[] = ",";
2607     char *lines[] = {
2608       lines_0,
2609       NULL
2610     };
2611     int r;
2612     suppress_error = 0;
2613     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2614     if (r == -1)
2615       return -1;
2616   }
2617   {
2618     char fstype[] = "ext2";
2619     char device[] = "/dev/sda1";
2620     int r;
2621     suppress_error = 0;
2622     r = guestfs_mkfs (g, fstype, device);
2623     if (r == -1)
2624       return -1;
2625   }
2626   {
2627     char device[] = "/dev/sda1";
2628     char mountpoint[] = "/";
2629     int r;
2630     suppress_error = 0;
2631     r = guestfs_mount (g, device, mountpoint);
2632     if (r == -1)
2633       return -1;
2634   }
2635   /* TestOutputList for glob_expand (1) */
2636   {
2637     char path[] = "/a/b/c";
2638     int r;
2639     suppress_error = 0;
2640     r = guestfs_mkdir_p (g, path);
2641     if (r == -1)
2642       return -1;
2643   }
2644   {
2645     char path[] = "/a/b/c/d";
2646     int r;
2647     suppress_error = 0;
2648     r = guestfs_touch (g, path);
2649     if (r == -1)
2650       return -1;
2651   }
2652   {
2653     char path[] = "/a/b/c/e";
2654     int r;
2655     suppress_error = 0;
2656     r = guestfs_touch (g, path);
2657     if (r == -1)
2658       return -1;
2659   }
2660   {
2661     char pattern[] = "/a/*/c/*";
2662     char **r;
2663     int i;
2664     suppress_error = 0;
2665     r = guestfs_glob_expand (g, pattern);
2666     if (r == NULL)
2667       return -1;
2668     if (!r[0]) {
2669       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2670       print_strings (r);
2671       return -1;
2672     }
2673     {
2674       char expected[] = "/a/b/c/d";
2675       if (strcmp (r[0], expected) != 0) {
2676         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2677         return -1;
2678       }
2679     }
2680     if (!r[1]) {
2681       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2682       print_strings (r);
2683       return -1;
2684     }
2685     {
2686       char expected[] = "/a/b/c/e";
2687       if (strcmp (r[1], expected) != 0) {
2688         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2689         return -1;
2690       }
2691     }
2692     if (r[2] != NULL) {
2693       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2694       print_strings (r);
2695       return -1;
2696     }
2697     for (i = 0; r[i] != NULL; ++i)
2698       free (r[i]);
2699     free (r);
2700   }
2701   return 0;
2702 }
2703
2704 static int test_glob_expand_2_skip (void)
2705 {
2706   const char *str;
2707
2708   str = getenv ("TEST_ONLY");
2709   if (str)
2710     return strstr (str, "glob_expand") == NULL;
2711   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2712   if (str && strcmp (str, "1") == 0) return 1;
2713   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2714   if (str && strcmp (str, "1") == 0) return 1;
2715   return 0;
2716 }
2717
2718 static int test_glob_expand_2 (void)
2719 {
2720   if (test_glob_expand_2_skip ()) {
2721     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2722     return 0;
2723   }
2724
2725   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2726   {
2727     char device[] = "/dev/sda";
2728     int r;
2729     suppress_error = 0;
2730     r = guestfs_blockdev_setrw (g, device);
2731     if (r == -1)
2732       return -1;
2733   }
2734   {
2735     int r;
2736     suppress_error = 0;
2737     r = guestfs_umount_all (g);
2738     if (r == -1)
2739       return -1;
2740   }
2741   {
2742     int r;
2743     suppress_error = 0;
2744     r = guestfs_lvm_remove_all (g);
2745     if (r == -1)
2746       return -1;
2747   }
2748   {
2749     char device[] = "/dev/sda";
2750     char lines_0[] = ",";
2751     char *lines[] = {
2752       lines_0,
2753       NULL
2754     };
2755     int r;
2756     suppress_error = 0;
2757     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2758     if (r == -1)
2759       return -1;
2760   }
2761   {
2762     char fstype[] = "ext2";
2763     char device[] = "/dev/sda1";
2764     int r;
2765     suppress_error = 0;
2766     r = guestfs_mkfs (g, fstype, device);
2767     if (r == -1)
2768       return -1;
2769   }
2770   {
2771     char device[] = "/dev/sda1";
2772     char mountpoint[] = "/";
2773     int r;
2774     suppress_error = 0;
2775     r = guestfs_mount (g, device, mountpoint);
2776     if (r == -1)
2777       return -1;
2778   }
2779   /* TestOutputList for glob_expand (2) */
2780   {
2781     char path[] = "/a/b/c";
2782     int r;
2783     suppress_error = 0;
2784     r = guestfs_mkdir_p (g, path);
2785     if (r == -1)
2786       return -1;
2787   }
2788   {
2789     char path[] = "/a/b/c/d";
2790     int r;
2791     suppress_error = 0;
2792     r = guestfs_touch (g, path);
2793     if (r == -1)
2794       return -1;
2795   }
2796   {
2797     char path[] = "/a/b/c/e";
2798     int r;
2799     suppress_error = 0;
2800     r = guestfs_touch (g, path);
2801     if (r == -1)
2802       return -1;
2803   }
2804   {
2805     char pattern[] = "/a/*/x/*";
2806     char **r;
2807     int i;
2808     suppress_error = 0;
2809     r = guestfs_glob_expand (g, pattern);
2810     if (r == NULL)
2811       return -1;
2812     if (r[0] != NULL) {
2813       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2814       print_strings (r);
2815       return -1;
2816     }
2817     for (i = 0; r[i] != NULL; ++i)
2818       free (r[i]);
2819     free (r);
2820   }
2821   return 0;
2822 }
2823
2824 static int test_ntfs_3g_probe_0_skip (void)
2825 {
2826   const char *str;
2827
2828   str = getenv ("TEST_ONLY");
2829   if (str)
2830     return strstr (str, "ntfs_3g_probe") == NULL;
2831   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2832   if (str && strcmp (str, "1") == 0) return 1;
2833   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2834   if (str && strcmp (str, "1") == 0) return 1;
2835   return 0;
2836 }
2837
2838 static int test_ntfs_3g_probe_0 (void)
2839 {
2840   if (test_ntfs_3g_probe_0_skip ()) {
2841     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2842     return 0;
2843   }
2844
2845   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2846   {
2847     char device[] = "/dev/sda";
2848     int r;
2849     suppress_error = 0;
2850     r = guestfs_blockdev_setrw (g, device);
2851     if (r == -1)
2852       return -1;
2853   }
2854   {
2855     int r;
2856     suppress_error = 0;
2857     r = guestfs_umount_all (g);
2858     if (r == -1)
2859       return -1;
2860   }
2861   {
2862     int r;
2863     suppress_error = 0;
2864     r = guestfs_lvm_remove_all (g);
2865     if (r == -1)
2866       return -1;
2867   }
2868   /* TestOutputInt for ntfs_3g_probe (0) */
2869   {
2870     char device[] = "/dev/sda";
2871     char lines_0[] = ",";
2872     char *lines[] = {
2873       lines_0,
2874       NULL
2875     };
2876     int r;
2877     suppress_error = 0;
2878     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2879     if (r == -1)
2880       return -1;
2881   }
2882   {
2883     char fstype[] = "ntfs";
2884     char device[] = "/dev/sda1";
2885     int r;
2886     suppress_error = 0;
2887     r = guestfs_mkfs (g, fstype, device);
2888     if (r == -1)
2889       return -1;
2890   }
2891   {
2892     char device[] = "/dev/sda1";
2893     int r;
2894     suppress_error = 0;
2895     r = guestfs_ntfs_3g_probe (g, 1, device);
2896     if (r == -1)
2897       return -1;
2898     if (r != 0) {
2899       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
2900       return -1;
2901     }
2902   }
2903   return 0;
2904 }
2905
2906 static int test_ntfs_3g_probe_1_skip (void)
2907 {
2908   const char *str;
2909
2910   str = getenv ("TEST_ONLY");
2911   if (str)
2912     return strstr (str, "ntfs_3g_probe") == NULL;
2913   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2914   if (str && strcmp (str, "1") == 0) return 1;
2915   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2916   if (str && strcmp (str, "1") == 0) return 1;
2917   return 0;
2918 }
2919
2920 static int test_ntfs_3g_probe_1 (void)
2921 {
2922   if (test_ntfs_3g_probe_1_skip ()) {
2923     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2924     return 0;
2925   }
2926
2927   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2928   {
2929     char device[] = "/dev/sda";
2930     int r;
2931     suppress_error = 0;
2932     r = guestfs_blockdev_setrw (g, device);
2933     if (r == -1)
2934       return -1;
2935   }
2936   {
2937     int r;
2938     suppress_error = 0;
2939     r = guestfs_umount_all (g);
2940     if (r == -1)
2941       return -1;
2942   }
2943   {
2944     int r;
2945     suppress_error = 0;
2946     r = guestfs_lvm_remove_all (g);
2947     if (r == -1)
2948       return -1;
2949   }
2950   /* TestOutputInt for ntfs_3g_probe (1) */
2951   {
2952     char device[] = "/dev/sda";
2953     char lines_0[] = ",";
2954     char *lines[] = {
2955       lines_0,
2956       NULL
2957     };
2958     int r;
2959     suppress_error = 0;
2960     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2961     if (r == -1)
2962       return -1;
2963   }
2964   {
2965     char fstype[] = "ext2";
2966     char device[] = "/dev/sda1";
2967     int r;
2968     suppress_error = 0;
2969     r = guestfs_mkfs (g, fstype, device);
2970     if (r == -1)
2971       return -1;
2972   }
2973   {
2974     char device[] = "/dev/sda1";
2975     int r;
2976     suppress_error = 0;
2977     r = guestfs_ntfs_3g_probe (g, 1, device);
2978     if (r == -1)
2979       return -1;
2980     if (r != 12) {
2981       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
2982       return -1;
2983     }
2984   }
2985   return 0;
2986 }
2987
2988 static int test_sleep_0_skip (void)
2989 {
2990   const char *str;
2991
2992   str = getenv ("TEST_ONLY");
2993   if (str)
2994     return strstr (str, "sleep") == NULL;
2995   str = getenv ("SKIP_TEST_SLEEP_0");
2996   if (str && strcmp (str, "1") == 0) return 1;
2997   str = getenv ("SKIP_TEST_SLEEP");
2998   if (str && strcmp (str, "1") == 0) return 1;
2999   return 0;
3000 }
3001
3002 static int test_sleep_0 (void)
3003 {
3004   if (test_sleep_0_skip ()) {
3005     printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
3006     return 0;
3007   }
3008
3009   /* InitNone|InitEmpty for test_sleep_0 */
3010   {
3011     char device[] = "/dev/sda";
3012     int r;
3013     suppress_error = 0;
3014     r = guestfs_blockdev_setrw (g, device);
3015     if (r == -1)
3016       return -1;
3017   }
3018   {
3019     int r;
3020     suppress_error = 0;
3021     r = guestfs_umount_all (g);
3022     if (r == -1)
3023       return -1;
3024   }
3025   {
3026     int r;
3027     suppress_error = 0;
3028     r = guestfs_lvm_remove_all (g);
3029     if (r == -1)
3030       return -1;
3031   }
3032   /* TestRun for sleep (0) */
3033   {
3034     int r;
3035     suppress_error = 0;
3036     r = guestfs_sleep (g, 1);
3037     if (r == -1)
3038       return -1;
3039   }
3040   return 0;
3041 }
3042
3043 static int test_find_0_skip (void)
3044 {
3045   const char *str;
3046
3047   str = getenv ("TEST_ONLY");
3048   if (str)
3049     return strstr (str, "find") == NULL;
3050   str = getenv ("SKIP_TEST_FIND_0");
3051   if (str && strcmp (str, "1") == 0) return 1;
3052   str = getenv ("SKIP_TEST_FIND");
3053   if (str && strcmp (str, "1") == 0) return 1;
3054   return 0;
3055 }
3056
3057 static int test_find_0 (void)
3058 {
3059   if (test_find_0_skip ()) {
3060     printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
3061     return 0;
3062   }
3063
3064   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3065   {
3066     char device[] = "/dev/sda";
3067     int r;
3068     suppress_error = 0;
3069     r = guestfs_blockdev_setrw (g, device);
3070     if (r == -1)
3071       return -1;
3072   }
3073   {
3074     int r;
3075     suppress_error = 0;
3076     r = guestfs_umount_all (g);
3077     if (r == -1)
3078       return -1;
3079   }
3080   {
3081     int r;
3082     suppress_error = 0;
3083     r = guestfs_lvm_remove_all (g);
3084     if (r == -1)
3085       return -1;
3086   }
3087   {
3088     char device[] = "/dev/sda";
3089     char lines_0[] = ",";
3090     char *lines[] = {
3091       lines_0,
3092       NULL
3093     };
3094     int r;
3095     suppress_error = 0;
3096     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3097     if (r == -1)
3098       return -1;
3099   }
3100   {
3101     char fstype[] = "ext2";
3102     char device[] = "/dev/sda1";
3103     int r;
3104     suppress_error = 0;
3105     r = guestfs_mkfs (g, fstype, device);
3106     if (r == -1)
3107       return -1;
3108   }
3109   {
3110     char device[] = "/dev/sda1";
3111     char mountpoint[] = "/";
3112     int r;
3113     suppress_error = 0;
3114     r = guestfs_mount (g, device, mountpoint);
3115     if (r == -1)
3116       return -1;
3117   }
3118   /* TestOutputList for find (0) */
3119   {
3120     char directory[] = "/";
3121     char **r;
3122     int i;
3123     suppress_error = 0;
3124     r = guestfs_find (g, directory);
3125     if (r == NULL)
3126       return -1;
3127     if (!r[0]) {
3128       fprintf (stderr, "test_find_0: short list returned from command\n");
3129       print_strings (r);
3130       return -1;
3131     }
3132     {
3133       char expected[] = "lost+found";
3134       if (strcmp (r[0], expected) != 0) {
3135         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3136         return -1;
3137       }
3138     }
3139     if (r[1] != NULL) {
3140       fprintf (stderr, "test_find_0: extra elements returned from command\n");
3141       print_strings (r);
3142       return -1;
3143     }
3144     for (i = 0; r[i] != NULL; ++i)
3145       free (r[i]);
3146     free (r);
3147   }
3148   return 0;
3149 }
3150
3151 static int test_find_1_skip (void)
3152 {
3153   const char *str;
3154
3155   str = getenv ("TEST_ONLY");
3156   if (str)
3157     return strstr (str, "find") == NULL;
3158   str = getenv ("SKIP_TEST_FIND_1");
3159   if (str && strcmp (str, "1") == 0) return 1;
3160   str = getenv ("SKIP_TEST_FIND");
3161   if (str && strcmp (str, "1") == 0) return 1;
3162   return 0;
3163 }
3164
3165 static int test_find_1 (void)
3166 {
3167   if (test_find_1_skip ()) {
3168     printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
3169     return 0;
3170   }
3171
3172   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3173   {
3174     char device[] = "/dev/sda";
3175     int r;
3176     suppress_error = 0;
3177     r = guestfs_blockdev_setrw (g, device);
3178     if (r == -1)
3179       return -1;
3180   }
3181   {
3182     int r;
3183     suppress_error = 0;
3184     r = guestfs_umount_all (g);
3185     if (r == -1)
3186       return -1;
3187   }
3188   {
3189     int r;
3190     suppress_error = 0;
3191     r = guestfs_lvm_remove_all (g);
3192     if (r == -1)
3193       return -1;
3194   }
3195   {
3196     char device[] = "/dev/sda";
3197     char lines_0[] = ",";
3198     char *lines[] = {
3199       lines_0,
3200       NULL
3201     };
3202     int r;
3203     suppress_error = 0;
3204     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3205     if (r == -1)
3206       return -1;
3207   }
3208   {
3209     char fstype[] = "ext2";
3210     char device[] = "/dev/sda1";
3211     int r;
3212     suppress_error = 0;
3213     r = guestfs_mkfs (g, fstype, device);
3214     if (r == -1)
3215       return -1;
3216   }
3217   {
3218     char device[] = "/dev/sda1";
3219     char mountpoint[] = "/";
3220     int r;
3221     suppress_error = 0;
3222     r = guestfs_mount (g, device, mountpoint);
3223     if (r == -1)
3224       return -1;
3225   }
3226   /* TestOutputList for find (1) */
3227   {
3228     char path[] = "/a";
3229     int r;
3230     suppress_error = 0;
3231     r = guestfs_touch (g, path);
3232     if (r == -1)
3233       return -1;
3234   }
3235   {
3236     char path[] = "/b";
3237     int r;
3238     suppress_error = 0;
3239     r = guestfs_mkdir (g, path);
3240     if (r == -1)
3241       return -1;
3242   }
3243   {
3244     char path[] = "/b/c";
3245     int r;
3246     suppress_error = 0;
3247     r = guestfs_touch (g, path);
3248     if (r == -1)
3249       return -1;
3250   }
3251   {
3252     char directory[] = "/";
3253     char **r;
3254     int i;
3255     suppress_error = 0;
3256     r = guestfs_find (g, directory);
3257     if (r == NULL)
3258       return -1;
3259     if (!r[0]) {
3260       fprintf (stderr, "test_find_1: short list returned from command\n");
3261       print_strings (r);
3262       return -1;
3263     }
3264     {
3265       char expected[] = "a";
3266       if (strcmp (r[0], expected) != 0) {
3267         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3268         return -1;
3269       }
3270     }
3271     if (!r[1]) {
3272       fprintf (stderr, "test_find_1: short list returned from command\n");
3273       print_strings (r);
3274       return -1;
3275     }
3276     {
3277       char expected[] = "b";
3278       if (strcmp (r[1], expected) != 0) {
3279         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3280         return -1;
3281       }
3282     }
3283     if (!r[2]) {
3284       fprintf (stderr, "test_find_1: short list returned from command\n");
3285       print_strings (r);
3286       return -1;
3287     }
3288     {
3289       char expected[] = "b/c";
3290       if (strcmp (r[2], expected) != 0) {
3291         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3292         return -1;
3293       }
3294     }
3295     if (!r[3]) {
3296       fprintf (stderr, "test_find_1: short list returned from command\n");
3297       print_strings (r);
3298       return -1;
3299     }
3300     {
3301       char expected[] = "lost+found";
3302       if (strcmp (r[3], expected) != 0) {
3303         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3304         return -1;
3305       }
3306     }
3307     if (r[4] != NULL) {
3308       fprintf (stderr, "test_find_1: extra elements returned from command\n");
3309       print_strings (r);
3310       return -1;
3311     }
3312     for (i = 0; r[i] != NULL; ++i)
3313       free (r[i]);
3314     free (r);
3315   }
3316   return 0;
3317 }
3318
3319 static int test_find_2_skip (void)
3320 {
3321   const char *str;
3322
3323   str = getenv ("TEST_ONLY");
3324   if (str)
3325     return strstr (str, "find") == NULL;
3326   str = getenv ("SKIP_TEST_FIND_2");
3327   if (str && strcmp (str, "1") == 0) return 1;
3328   str = getenv ("SKIP_TEST_FIND");
3329   if (str && strcmp (str, "1") == 0) return 1;
3330   return 0;
3331 }
3332
3333 static int test_find_2 (void)
3334 {
3335   if (test_find_2_skip ()) {
3336     printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3337     return 0;
3338   }
3339
3340   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3341   {
3342     char device[] = "/dev/sda";
3343     int r;
3344     suppress_error = 0;
3345     r = guestfs_blockdev_setrw (g, device);
3346     if (r == -1)
3347       return -1;
3348   }
3349   {
3350     int r;
3351     suppress_error = 0;
3352     r = guestfs_umount_all (g);
3353     if (r == -1)
3354       return -1;
3355   }
3356   {
3357     int r;
3358     suppress_error = 0;
3359     r = guestfs_lvm_remove_all (g);
3360     if (r == -1)
3361       return -1;
3362   }
3363   {
3364     char device[] = "/dev/sda";
3365     char lines_0[] = ",";
3366     char *lines[] = {
3367       lines_0,
3368       NULL
3369     };
3370     int r;
3371     suppress_error = 0;
3372     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3373     if (r == -1)
3374       return -1;
3375   }
3376   {
3377     char fstype[] = "ext2";
3378     char device[] = "/dev/sda1";
3379     int r;
3380     suppress_error = 0;
3381     r = guestfs_mkfs (g, fstype, device);
3382     if (r == -1)
3383       return -1;
3384   }
3385   {
3386     char device[] = "/dev/sda1";
3387     char mountpoint[] = "/";
3388     int r;
3389     suppress_error = 0;
3390     r = guestfs_mount (g, device, mountpoint);
3391     if (r == -1)
3392       return -1;
3393   }
3394   /* TestOutputList for find (2) */
3395   {
3396     char path[] = "/a/b/c";
3397     int r;
3398     suppress_error = 0;
3399     r = guestfs_mkdir_p (g, path);
3400     if (r == -1)
3401       return -1;
3402   }
3403   {
3404     char path[] = "/a/b/c/d";
3405     int r;
3406     suppress_error = 0;
3407     r = guestfs_touch (g, path);
3408     if (r == -1)
3409       return -1;
3410   }
3411   {
3412     char directory[] = "/a/b/";
3413     char **r;
3414     int i;
3415     suppress_error = 0;
3416     r = guestfs_find (g, directory);
3417     if (r == NULL)
3418       return -1;
3419     if (!r[0]) {
3420       fprintf (stderr, "test_find_2: short list returned from command\n");
3421       print_strings (r);
3422       return -1;
3423     }
3424     {
3425       char expected[] = "c";
3426       if (strcmp (r[0], expected) != 0) {
3427         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3428         return -1;
3429       }
3430     }
3431     if (!r[1]) {
3432       fprintf (stderr, "test_find_2: short list returned from command\n");
3433       print_strings (r);
3434       return -1;
3435     }
3436     {
3437       char expected[] = "c/d";
3438       if (strcmp (r[1], expected) != 0) {
3439         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3440         return -1;
3441       }
3442     }
3443     if (r[2] != NULL) {
3444       fprintf (stderr, "test_find_2: extra elements returned from command\n");
3445       print_strings (r);
3446       return -1;
3447     }
3448     for (i = 0; r[i] != NULL; ++i)
3449       free (r[i]);
3450     free (r);
3451   }
3452   return 0;
3453 }
3454
3455 static int test_lvresize_0_skip (void)
3456 {
3457   const char *str;
3458
3459   str = getenv ("TEST_ONLY");
3460   if (str)
3461     return strstr (str, "lvresize") == NULL;
3462   str = getenv ("SKIP_TEST_LVRESIZE_0");
3463   if (str && strcmp (str, "1") == 0) return 1;
3464   str = getenv ("SKIP_TEST_LVRESIZE");
3465   if (str && strcmp (str, "1") == 0) return 1;
3466   return 0;
3467 }
3468
3469 static int test_lvresize_0 (void)
3470 {
3471   if (test_lvresize_0_skip ()) {
3472     printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3473     return 0;
3474   }
3475
3476   /* InitNone|InitEmpty for test_lvresize_0 */
3477   {
3478     char device[] = "/dev/sda";
3479     int r;
3480     suppress_error = 0;
3481     r = guestfs_blockdev_setrw (g, device);
3482     if (r == -1)
3483       return -1;
3484   }
3485   {
3486     int r;
3487     suppress_error = 0;
3488     r = guestfs_umount_all (g);
3489     if (r == -1)
3490       return -1;
3491   }
3492   {
3493     int r;
3494     suppress_error = 0;
3495     r = guestfs_lvm_remove_all (g);
3496     if (r == -1)
3497       return -1;
3498   }
3499   /* TestOutput for lvresize (0) */
3500   char expected[] = "test content";
3501   {
3502     char device[] = "/dev/sda";
3503     char lines_0[] = ",";
3504     char *lines[] = {
3505       lines_0,
3506       NULL
3507     };
3508     int r;
3509     suppress_error = 0;
3510     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3511     if (r == -1)
3512       return -1;
3513   }
3514   {
3515     char device[] = "/dev/sda1";
3516     int r;
3517     suppress_error = 0;
3518     r = guestfs_pvcreate (g, device);
3519     if (r == -1)
3520       return -1;
3521   }
3522   {
3523     char volgroup[] = "VG";
3524     char physvols_0[] = "/dev/sda1";
3525     char *physvols[] = {
3526       physvols_0,
3527       NULL
3528     };
3529     int r;
3530     suppress_error = 0;
3531     r = guestfs_vgcreate (g, volgroup, physvols);
3532     if (r == -1)
3533       return -1;
3534   }
3535   {
3536     char logvol[] = "LV";
3537     char volgroup[] = "VG";
3538     int r;
3539     suppress_error = 0;
3540     r = guestfs_lvcreate (g, logvol, volgroup, 10);
3541     if (r == -1)
3542       return -1;
3543   }
3544   {
3545     char fstype[] = "ext2";
3546     char device[] = "/dev/VG/LV";
3547     int r;
3548     suppress_error = 0;
3549     r = guestfs_mkfs (g, fstype, device);
3550     if (r == -1)
3551       return -1;
3552   }
3553   {
3554     char device[] = "/dev/VG/LV";
3555     char mountpoint[] = "/";
3556     int r;
3557     suppress_error = 0;
3558     r = guestfs_mount (g, device, mountpoint);
3559     if (r == -1)
3560       return -1;
3561   }
3562   {
3563     char path[] = "/new";
3564     char content[] = "test content";
3565     int r;
3566     suppress_error = 0;
3567     r = guestfs_write_file (g, path, content, 0);
3568     if (r == -1)
3569       return -1;
3570   }
3571   {
3572     char pathordevice[] = "/";
3573     int r;
3574     suppress_error = 0;
3575     r = guestfs_umount (g, pathordevice);
3576     if (r == -1)
3577       return -1;
3578   }
3579   {
3580     char device[] = "/dev/VG/LV";
3581     int r;
3582     suppress_error = 0;
3583     r = guestfs_lvresize (g, device, 20);
3584     if (r == -1)
3585       return -1;
3586   }
3587   {
3588     char device[] = "/dev/VG/LV";
3589     int r;
3590     suppress_error = 0;
3591     r = guestfs_e2fsck_f (g, device);
3592     if (r == -1)
3593       return -1;
3594   }
3595   {
3596     char device[] = "/dev/VG/LV";
3597     int r;
3598     suppress_error = 0;
3599     r = guestfs_resize2fs (g, device);
3600     if (r == -1)
3601       return -1;
3602   }
3603   {
3604     char device[] = "/dev/VG/LV";
3605     char mountpoint[] = "/";
3606     int r;
3607     suppress_error = 0;
3608     r = guestfs_mount (g, device, mountpoint);
3609     if (r == -1)
3610       return -1;
3611   }
3612   {
3613     char path[] = "/new";
3614     char *r;
3615     suppress_error = 0;
3616     r = guestfs_cat (g, path);
3617     if (r == NULL)
3618       return -1;
3619     if (strcmp (r, expected) != 0) {
3620       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3621       return -1;
3622     }
3623     free (r);
3624   }
3625   return 0;
3626 }
3627
3628 static int test_zerofree_0_skip (void)
3629 {
3630   const char *str;
3631
3632   str = getenv ("TEST_ONLY");
3633   if (str)
3634     return strstr (str, "zerofree") == NULL;
3635   str = getenv ("SKIP_TEST_ZEROFREE_0");
3636   if (str && strcmp (str, "1") == 0) return 1;
3637   str = getenv ("SKIP_TEST_ZEROFREE");
3638   if (str && strcmp (str, "1") == 0) return 1;
3639   return 0;
3640 }
3641
3642 static int test_zerofree_0 (void)
3643 {
3644   if (test_zerofree_0_skip ()) {
3645     printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3646     return 0;
3647   }
3648
3649   /* InitNone|InitEmpty for test_zerofree_0 */
3650   {
3651     char device[] = "/dev/sda";
3652     int r;
3653     suppress_error = 0;
3654     r = guestfs_blockdev_setrw (g, device);
3655     if (r == -1)
3656       return -1;
3657   }
3658   {
3659     int r;
3660     suppress_error = 0;
3661     r = guestfs_umount_all (g);
3662     if (r == -1)
3663       return -1;
3664   }
3665   {
3666     int r;
3667     suppress_error = 0;
3668     r = guestfs_lvm_remove_all (g);
3669     if (r == -1)
3670       return -1;
3671   }
3672   /* TestOutput for zerofree (0) */
3673   char expected[] = "test file";
3674   {
3675     char device[] = "/dev/sda";
3676     char lines_0[] = ",";
3677     char *lines[] = {
3678       lines_0,
3679       NULL
3680     };
3681     int r;
3682     suppress_error = 0;
3683     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3684     if (r == -1)
3685       return -1;
3686   }
3687   {
3688     char fstype[] = "ext3";
3689     char device[] = "/dev/sda1";
3690     int r;
3691     suppress_error = 0;
3692     r = guestfs_mkfs (g, fstype, device);
3693     if (r == -1)
3694       return -1;
3695   }
3696   {
3697     char device[] = "/dev/sda1";
3698     char mountpoint[] = "/";
3699     int r;
3700     suppress_error = 0;
3701     r = guestfs_mount (g, device, mountpoint);
3702     if (r == -1)
3703       return -1;
3704   }
3705   {
3706     char path[] = "/new";
3707     char content[] = "test file";
3708     int r;
3709     suppress_error = 0;
3710     r = guestfs_write_file (g, path, content, 0);
3711     if (r == -1)
3712       return -1;
3713   }
3714   {
3715     char pathordevice[] = "/dev/sda1";
3716     int r;
3717     suppress_error = 0;
3718     r = guestfs_umount (g, pathordevice);
3719     if (r == -1)
3720       return -1;
3721   }
3722   {
3723     char device[] = "/dev/sda1";
3724     int r;
3725     suppress_error = 0;
3726     r = guestfs_zerofree (g, device);
3727     if (r == -1)
3728       return -1;
3729   }
3730   {
3731     char device[] = "/dev/sda1";
3732     char mountpoint[] = "/";
3733     int r;
3734     suppress_error = 0;
3735     r = guestfs_mount (g, device, mountpoint);
3736     if (r == -1)
3737       return -1;
3738   }
3739   {
3740     char path[] = "/new";
3741     char *r;
3742     suppress_error = 0;
3743     r = guestfs_cat (g, path);
3744     if (r == NULL)
3745       return -1;
3746     if (strcmp (r, expected) != 0) {
3747       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3748       return -1;
3749     }
3750     free (r);
3751   }
3752   return 0;
3753 }
3754
3755 static int test_hexdump_0_skip (void)
3756 {
3757   const char *str;
3758
3759   str = getenv ("TEST_ONLY");
3760   if (str)
3761     return strstr (str, "hexdump") == NULL;
3762   str = getenv ("SKIP_TEST_HEXDUMP_0");
3763   if (str && strcmp (str, "1") == 0) return 1;
3764   str = getenv ("SKIP_TEST_HEXDUMP");
3765   if (str && strcmp (str, "1") == 0) return 1;
3766   return 0;
3767 }
3768
3769 static int test_hexdump_0 (void)
3770 {
3771   if (test_hexdump_0_skip ()) {
3772     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3773     return 0;
3774   }
3775
3776   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3777   {
3778     char device[] = "/dev/sda";
3779     int r;
3780     suppress_error = 0;
3781     r = guestfs_blockdev_setrw (g, device);
3782     if (r == -1)
3783       return -1;
3784   }
3785   {
3786     int r;
3787     suppress_error = 0;
3788     r = guestfs_umount_all (g);
3789     if (r == -1)
3790       return -1;
3791   }
3792   {
3793     int r;
3794     suppress_error = 0;
3795     r = guestfs_lvm_remove_all (g);
3796     if (r == -1)
3797       return -1;
3798   }
3799   {
3800     char device[] = "/dev/sda";
3801     char lines_0[] = ",";
3802     char *lines[] = {
3803       lines_0,
3804       NULL
3805     };
3806     int r;
3807     suppress_error = 0;
3808     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3809     if (r == -1)
3810       return -1;
3811   }
3812   {
3813     char fstype[] = "ext2";
3814     char device[] = "/dev/sda1";
3815     int r;
3816     suppress_error = 0;
3817     r = guestfs_mkfs (g, fstype, device);
3818     if (r == -1)
3819       return -1;
3820   }
3821   {
3822     char device[] = "/dev/sda1";
3823     char mountpoint[] = "/";
3824     int r;
3825     suppress_error = 0;
3826     r = guestfs_mount (g, device, mountpoint);
3827     if (r == -1)
3828       return -1;
3829   }
3830   /* TestOutput for hexdump (0) */
3831   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
3832   {
3833     char path[] = "/new";
3834     char content[] = "hello\nworld\n";
3835     int r;
3836     suppress_error = 0;
3837     r = guestfs_write_file (g, path, content, 12);
3838     if (r == -1)
3839       return -1;
3840   }
3841   {
3842     char path[] = "/new";
3843     char *r;
3844     suppress_error = 0;
3845     r = guestfs_hexdump (g, path);
3846     if (r == NULL)
3847       return -1;
3848     if (strcmp (r, expected) != 0) {
3849       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3850       return -1;
3851     }
3852     free (r);
3853   }
3854   return 0;
3855 }
3856
3857 static int test_hexdump_1_skip (void)
3858 {
3859   const char *str;
3860
3861   str = getenv ("TEST_ONLY");
3862   if (str)
3863     return strstr (str, "hexdump") == NULL;
3864   str = getenv ("SKIP_TEST_HEXDUMP_1");
3865   if (str && strcmp (str, "1") == 0) return 1;
3866   str = getenv ("SKIP_TEST_HEXDUMP");
3867   if (str && strcmp (str, "1") == 0) return 1;
3868   return 0;
3869 }
3870
3871 static int test_hexdump_1 (void)
3872 {
3873   if (test_hexdump_1_skip ()) {
3874     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3875     return 0;
3876   }
3877
3878   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3879   {
3880     char device[] = "/dev/sda";
3881     int r;
3882     suppress_error = 0;
3883     r = guestfs_blockdev_setrw (g, device);
3884     if (r == -1)
3885       return -1;
3886   }
3887   {
3888     int r;
3889     suppress_error = 0;
3890     r = guestfs_umount_all (g);
3891     if (r == -1)
3892       return -1;
3893   }
3894   {
3895     int r;
3896     suppress_error = 0;
3897     r = guestfs_lvm_remove_all (g);
3898     if (r == -1)
3899       return -1;
3900   }
3901   {
3902     char device[] = "/dev/sda";
3903     char lines_0[] = ",";
3904     char *lines[] = {
3905       lines_0,
3906       NULL
3907     };
3908     int r;
3909     suppress_error = 0;
3910     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3911     if (r == -1)
3912       return -1;
3913   }
3914   {
3915     char fstype[] = "ext2";
3916     char device[] = "/dev/sda1";
3917     int r;
3918     suppress_error = 0;
3919     r = guestfs_mkfs (g, fstype, device);
3920     if (r == -1)
3921       return -1;
3922   }
3923   {
3924     char device[] = "/dev/sda1";
3925     char mountpoint[] = "/";
3926     int r;
3927     suppress_error = 0;
3928     r = guestfs_mount (g, device, mountpoint);
3929     if (r == -1)
3930       return -1;
3931   }
3932   /* TestRun for hexdump (1) */
3933   {
3934     char options[] = "ro";
3935     char vfstype[] = "squashfs";
3936     char device[] = "/dev/sdd";
3937     char mountpoint[] = "/";
3938     int r;
3939     suppress_error = 0;
3940     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3941     if (r == -1)
3942       return -1;
3943   }
3944   {
3945     char path[] = "/100krandom";
3946     char *r;
3947     suppress_error = 0;
3948     r = guestfs_hexdump (g, path);
3949     if (r == NULL)
3950       return -1;
3951     free (r);
3952   }
3953   return 0;
3954 }
3955
3956 static int test_strings_e_0_skip (void)
3957 {
3958   const char *str;
3959
3960   str = getenv ("TEST_ONLY");
3961   if (str)
3962     return strstr (str, "strings_e") == NULL;
3963   str = getenv ("SKIP_TEST_STRINGS_E_0");
3964   if (str && strcmp (str, "1") == 0) return 1;
3965   str = getenv ("SKIP_TEST_STRINGS_E");
3966   if (str && strcmp (str, "1") == 0) return 1;
3967   return 0;
3968 }
3969
3970 static int test_strings_e_0 (void)
3971 {
3972   if (test_strings_e_0_skip ()) {
3973     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3974     return 0;
3975   }
3976
3977   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3978   {
3979     char device[] = "/dev/sda";
3980     int r;
3981     suppress_error = 0;
3982     r = guestfs_blockdev_setrw (g, device);
3983     if (r == -1)
3984       return -1;
3985   }
3986   {
3987     int r;
3988     suppress_error = 0;
3989     r = guestfs_umount_all (g);
3990     if (r == -1)
3991       return -1;
3992   }
3993   {
3994     int r;
3995     suppress_error = 0;
3996     r = guestfs_lvm_remove_all (g);
3997     if (r == -1)
3998       return -1;
3999   }
4000   {
4001     char device[] = "/dev/sda";
4002     char lines_0[] = ",";
4003     char *lines[] = {
4004       lines_0,
4005       NULL
4006     };
4007     int r;
4008     suppress_error = 0;
4009     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4010     if (r == -1)
4011       return -1;
4012   }
4013   {
4014     char fstype[] = "ext2";
4015     char device[] = "/dev/sda1";
4016     int r;
4017     suppress_error = 0;
4018     r = guestfs_mkfs (g, fstype, device);
4019     if (r == -1)
4020       return -1;
4021   }
4022   {
4023     char device[] = "/dev/sda1";
4024     char mountpoint[] = "/";
4025     int r;
4026     suppress_error = 0;
4027     r = guestfs_mount (g, device, mountpoint);
4028     if (r == -1)
4029       return -1;
4030   }
4031   /* TestOutputList for strings_e (0) */
4032   {
4033     char path[] = "/new";
4034     char content[] = "hello\nworld\n";
4035     int r;
4036     suppress_error = 0;
4037     r = guestfs_write_file (g, path, content, 0);
4038     if (r == -1)
4039       return -1;
4040   }
4041   {
4042     char encoding[] = "b";
4043     char path[] = "/new";
4044     char **r;
4045     int i;
4046     suppress_error = 0;
4047     r = guestfs_strings_e (g, encoding, path);
4048     if (r == NULL)
4049       return -1;
4050     if (r[0] != NULL) {
4051       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
4052       print_strings (r);
4053       return -1;
4054     }
4055     for (i = 0; r[i] != NULL; ++i)
4056       free (r[i]);
4057     free (r);
4058   }
4059   return 0;
4060 }
4061
4062 static int test_strings_e_1_skip (void)
4063 {
4064   const char *str;
4065
4066   str = getenv ("TEST_ONLY");
4067   if (str)
4068     return strstr (str, "strings_e") == NULL;
4069   str = getenv ("SKIP_TEST_STRINGS_E_1");
4070   if (str && strcmp (str, "1") == 0) return 1;
4071   str = getenv ("SKIP_TEST_STRINGS_E");
4072   if (str && strcmp (str, "1") == 0) return 1;
4073   return 0;
4074 }
4075
4076 static int test_strings_e_1 (void)
4077 {
4078   if (test_strings_e_1_skip ()) {
4079     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
4080     return 0;
4081   }
4082
4083   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
4084   return 0;
4085 }
4086
4087 static int test_strings_0_skip (void)
4088 {
4089   const char *str;
4090
4091   str = getenv ("TEST_ONLY");
4092   if (str)
4093     return strstr (str, "strings") == NULL;
4094   str = getenv ("SKIP_TEST_STRINGS_0");
4095   if (str && strcmp (str, "1") == 0) return 1;
4096   str = getenv ("SKIP_TEST_STRINGS");
4097   if (str && strcmp (str, "1") == 0) return 1;
4098   return 0;
4099 }
4100
4101 static int test_strings_0 (void)
4102 {
4103   if (test_strings_0_skip ()) {
4104     printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
4105     return 0;
4106   }
4107
4108   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
4109   {
4110     char device[] = "/dev/sda";
4111     int r;
4112     suppress_error = 0;
4113     r = guestfs_blockdev_setrw (g, device);
4114     if (r == -1)
4115       return -1;
4116   }
4117   {
4118     int r;
4119     suppress_error = 0;
4120     r = guestfs_umount_all (g);
4121     if (r == -1)
4122       return -1;
4123   }
4124   {
4125     int r;
4126     suppress_error = 0;
4127     r = guestfs_lvm_remove_all (g);
4128     if (r == -1)
4129       return -1;
4130   }
4131   {
4132     char device[] = "/dev/sda";
4133     char lines_0[] = ",";
4134     char *lines[] = {
4135       lines_0,
4136       NULL
4137     };
4138     int r;
4139     suppress_error = 0;
4140     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4141     if (r == -1)
4142       return -1;
4143   }
4144   {
4145     char fstype[] = "ext2";
4146     char device[] = "/dev/sda1";
4147     int r;
4148     suppress_error = 0;
4149     r = guestfs_mkfs (g, fstype, device);
4150     if (r == -1)
4151       return -1;
4152   }
4153   {
4154     char device[] = "/dev/sda1";
4155     char mountpoint[] = "/";
4156     int r;
4157     suppress_error = 0;
4158     r = guestfs_mount (g, device, mountpoint);
4159     if (r == -1)
4160       return -1;
4161   }
4162   /* TestOutputList for strings (0) */
4163   {
4164     char path[] = "/new";
4165     char content[] = "hello\nworld\n";
4166     int r;
4167     suppress_error = 0;
4168     r = guestfs_write_file (g, path, content, 0);
4169     if (r == -1)
4170       return -1;
4171   }
4172   {
4173     char path[] = "/new";
4174     char **r;
4175     int i;
4176     suppress_error = 0;
4177     r = guestfs_strings (g, path);
4178     if (r == NULL)
4179       return -1;
4180     if (!r[0]) {
4181       fprintf (stderr, "test_strings_0: short list returned from command\n");
4182       print_strings (r);
4183       return -1;
4184     }
4185     {
4186       char expected[] = "hello";
4187       if (strcmp (r[0], expected) != 0) {
4188         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4189         return -1;
4190       }
4191     }
4192     if (!r[1]) {
4193       fprintf (stderr, "test_strings_0: short list returned from command\n");
4194       print_strings (r);
4195       return -1;
4196     }
4197     {
4198       char expected[] = "world";
4199       if (strcmp (r[1], expected) != 0) {
4200         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
4201         return -1;
4202       }
4203     }
4204     if (r[2] != NULL) {
4205       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4206       print_strings (r);
4207       return -1;
4208     }
4209     for (i = 0; r[i] != NULL; ++i)
4210       free (r[i]);
4211     free (r);
4212   }
4213   return 0;
4214 }
4215
4216 static int test_strings_1_skip (void)
4217 {
4218   const char *str;
4219
4220   str = getenv ("TEST_ONLY");
4221   if (str)
4222     return strstr (str, "strings") == NULL;
4223   str = getenv ("SKIP_TEST_STRINGS_1");
4224   if (str && strcmp (str, "1") == 0) return 1;
4225   str = getenv ("SKIP_TEST_STRINGS");
4226   if (str && strcmp (str, "1") == 0) return 1;
4227   return 0;
4228 }
4229
4230 static int test_strings_1 (void)
4231 {
4232   if (test_strings_1_skip ()) {
4233     printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
4234     return 0;
4235   }
4236
4237   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4238   {
4239     char device[] = "/dev/sda";
4240     int r;
4241     suppress_error = 0;
4242     r = guestfs_blockdev_setrw (g, device);
4243     if (r == -1)
4244       return -1;
4245   }
4246   {
4247     int r;
4248     suppress_error = 0;
4249     r = guestfs_umount_all (g);
4250     if (r == -1)
4251       return -1;
4252   }
4253   {
4254     int r;
4255     suppress_error = 0;
4256     r = guestfs_lvm_remove_all (g);
4257     if (r == -1)
4258       return -1;
4259   }
4260   {
4261     char device[] = "/dev/sda";
4262     char lines_0[] = ",";
4263     char *lines[] = {
4264       lines_0,
4265       NULL
4266     };
4267     int r;
4268     suppress_error = 0;
4269     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4270     if (r == -1)
4271       return -1;
4272   }
4273   {
4274     char fstype[] = "ext2";
4275     char device[] = "/dev/sda1";
4276     int r;
4277     suppress_error = 0;
4278     r = guestfs_mkfs (g, fstype, device);
4279     if (r == -1)
4280       return -1;
4281   }
4282   {
4283     char device[] = "/dev/sda1";
4284     char mountpoint[] = "/";
4285     int r;
4286     suppress_error = 0;
4287     r = guestfs_mount (g, device, mountpoint);
4288     if (r == -1)
4289       return -1;
4290   }
4291   /* TestOutputList for strings (1) */
4292   {
4293     char path[] = "/new";
4294     int r;
4295     suppress_error = 0;
4296     r = guestfs_touch (g, path);
4297     if (r == -1)
4298       return -1;
4299   }
4300   {
4301     char path[] = "/new";
4302     char **r;
4303     int i;
4304     suppress_error = 0;
4305     r = guestfs_strings (g, path);
4306     if (r == NULL)
4307       return -1;
4308     if (r[0] != NULL) {
4309       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4310       print_strings (r);
4311       return -1;
4312     }
4313     for (i = 0; r[i] != NULL; ++i)
4314       free (r[i]);
4315     free (r);
4316   }
4317   return 0;
4318 }
4319
4320 static int test_equal_0_skip (void)
4321 {
4322   const char *str;
4323
4324   str = getenv ("TEST_ONLY");
4325   if (str)
4326     return strstr (str, "equal") == NULL;
4327   str = getenv ("SKIP_TEST_EQUAL_0");
4328   if (str && strcmp (str, "1") == 0) return 1;
4329   str = getenv ("SKIP_TEST_EQUAL");
4330   if (str && strcmp (str, "1") == 0) return 1;
4331   return 0;
4332 }
4333
4334 static int test_equal_0 (void)
4335 {
4336   if (test_equal_0_skip ()) {
4337     printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
4338     return 0;
4339   }
4340
4341   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4342   {
4343     char device[] = "/dev/sda";
4344     int r;
4345     suppress_error = 0;
4346     r = guestfs_blockdev_setrw (g, device);
4347     if (r == -1)
4348       return -1;
4349   }
4350   {
4351     int r;
4352     suppress_error = 0;
4353     r = guestfs_umount_all (g);
4354     if (r == -1)
4355       return -1;
4356   }
4357   {
4358     int r;
4359     suppress_error = 0;
4360     r = guestfs_lvm_remove_all (g);
4361     if (r == -1)
4362       return -1;
4363   }
4364   {
4365     char device[] = "/dev/sda";
4366     char lines_0[] = ",";
4367     char *lines[] = {
4368       lines_0,
4369       NULL
4370     };
4371     int r;
4372     suppress_error = 0;
4373     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4374     if (r == -1)
4375       return -1;
4376   }
4377   {
4378     char fstype[] = "ext2";
4379     char device[] = "/dev/sda1";
4380     int r;
4381     suppress_error = 0;
4382     r = guestfs_mkfs (g, fstype, device);
4383     if (r == -1)
4384       return -1;
4385   }
4386   {
4387     char device[] = "/dev/sda1";
4388     char mountpoint[] = "/";
4389     int r;
4390     suppress_error = 0;
4391     r = guestfs_mount (g, device, mountpoint);
4392     if (r == -1)
4393       return -1;
4394   }
4395   /* TestOutputTrue for equal (0) */
4396   {
4397     char path[] = "/file1";
4398     char content[] = "contents of a file";
4399     int r;
4400     suppress_error = 0;
4401     r = guestfs_write_file (g, path, content, 0);
4402     if (r == -1)
4403       return -1;
4404   }
4405   {
4406     char src[] = "/file1";
4407     char dest[] = "/file2";
4408     int r;
4409     suppress_error = 0;
4410     r = guestfs_cp (g, src, dest);
4411     if (r == -1)
4412       return -1;
4413   }
4414   {
4415     char file1[] = "/file1";
4416     char file2[] = "/file2";
4417     int r;
4418     suppress_error = 0;
4419     r = guestfs_equal (g, file1, file2);
4420     if (r == -1)
4421       return -1;
4422     if (!r) {
4423       fprintf (stderr, "test_equal_0: expected true, got false\n");
4424       return -1;
4425     }
4426   }
4427   return 0;
4428 }
4429
4430 static int test_equal_1_skip (void)
4431 {
4432   const char *str;
4433
4434   str = getenv ("TEST_ONLY");
4435   if (str)
4436     return strstr (str, "equal") == NULL;
4437   str = getenv ("SKIP_TEST_EQUAL_1");
4438   if (str && strcmp (str, "1") == 0) return 1;
4439   str = getenv ("SKIP_TEST_EQUAL");
4440   if (str && strcmp (str, "1") == 0) return 1;
4441   return 0;
4442 }
4443
4444 static int test_equal_1 (void)
4445 {
4446   if (test_equal_1_skip ()) {
4447     printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4448     return 0;
4449   }
4450
4451   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4452   {
4453     char device[] = "/dev/sda";
4454     int r;
4455     suppress_error = 0;
4456     r = guestfs_blockdev_setrw (g, device);
4457     if (r == -1)
4458       return -1;
4459   }
4460   {
4461     int r;
4462     suppress_error = 0;
4463     r = guestfs_umount_all (g);
4464     if (r == -1)
4465       return -1;
4466   }
4467   {
4468     int r;
4469     suppress_error = 0;
4470     r = guestfs_lvm_remove_all (g);
4471     if (r == -1)
4472       return -1;
4473   }
4474   {
4475     char device[] = "/dev/sda";
4476     char lines_0[] = ",";
4477     char *lines[] = {
4478       lines_0,
4479       NULL
4480     };
4481     int r;
4482     suppress_error = 0;
4483     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4484     if (r == -1)
4485       return -1;
4486   }
4487   {
4488     char fstype[] = "ext2";
4489     char device[] = "/dev/sda1";
4490     int r;
4491     suppress_error = 0;
4492     r = guestfs_mkfs (g, fstype, device);
4493     if (r == -1)
4494       return -1;
4495   }
4496   {
4497     char device[] = "/dev/sda1";
4498     char mountpoint[] = "/";
4499     int r;
4500     suppress_error = 0;
4501     r = guestfs_mount (g, device, mountpoint);
4502     if (r == -1)
4503       return -1;
4504   }
4505   /* TestOutputFalse for equal (1) */
4506   {
4507     char path[] = "/file1";
4508     char content[] = "contents of a file";
4509     int r;
4510     suppress_error = 0;
4511     r = guestfs_write_file (g, path, content, 0);
4512     if (r == -1)
4513       return -1;
4514   }
4515   {
4516     char path[] = "/file2";
4517     char content[] = "contents of another file";
4518     int r;
4519     suppress_error = 0;
4520     r = guestfs_write_file (g, path, content, 0);
4521     if (r == -1)
4522       return -1;
4523   }
4524   {
4525     char file1[] = "/file1";
4526     char file2[] = "/file2";
4527     int r;
4528     suppress_error = 0;
4529     r = guestfs_equal (g, file1, file2);
4530     if (r == -1)
4531       return -1;
4532     if (r) {
4533       fprintf (stderr, "test_equal_1: expected false, got true\n");
4534       return -1;
4535     }
4536   }
4537   return 0;
4538 }
4539
4540 static int test_equal_2_skip (void)
4541 {
4542   const char *str;
4543
4544   str = getenv ("TEST_ONLY");
4545   if (str)
4546     return strstr (str, "equal") == NULL;
4547   str = getenv ("SKIP_TEST_EQUAL_2");
4548   if (str && strcmp (str, "1") == 0) return 1;
4549   str = getenv ("SKIP_TEST_EQUAL");
4550   if (str && strcmp (str, "1") == 0) return 1;
4551   return 0;
4552 }
4553
4554 static int test_equal_2 (void)
4555 {
4556   if (test_equal_2_skip ()) {
4557     printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4558     return 0;
4559   }
4560
4561   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4562   {
4563     char device[] = "/dev/sda";
4564     int r;
4565     suppress_error = 0;
4566     r = guestfs_blockdev_setrw (g, device);
4567     if (r == -1)
4568       return -1;
4569   }
4570   {
4571     int r;
4572     suppress_error = 0;
4573     r = guestfs_umount_all (g);
4574     if (r == -1)
4575       return -1;
4576   }
4577   {
4578     int r;
4579     suppress_error = 0;
4580     r = guestfs_lvm_remove_all (g);
4581     if (r == -1)
4582       return -1;
4583   }
4584   {
4585     char device[] = "/dev/sda";
4586     char lines_0[] = ",";
4587     char *lines[] = {
4588       lines_0,
4589       NULL
4590     };
4591     int r;
4592     suppress_error = 0;
4593     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4594     if (r == -1)
4595       return -1;
4596   }
4597   {
4598     char fstype[] = "ext2";
4599     char device[] = "/dev/sda1";
4600     int r;
4601     suppress_error = 0;
4602     r = guestfs_mkfs (g, fstype, device);
4603     if (r == -1)
4604       return -1;
4605   }
4606   {
4607     char device[] = "/dev/sda1";
4608     char mountpoint[] = "/";
4609     int r;
4610     suppress_error = 0;
4611     r = guestfs_mount (g, device, mountpoint);
4612     if (r == -1)
4613       return -1;
4614   }
4615   /* TestLastFail for equal (2) */
4616   {
4617     char file1[] = "/file1";
4618     char file2[] = "/file2";
4619     int r;
4620     suppress_error = 1;
4621     r = guestfs_equal (g, file1, file2);
4622     if (r != -1)
4623       return -1;
4624   }
4625   return 0;
4626 }
4627
4628 static int test_ping_daemon_0_skip (void)
4629 {
4630   const char *str;
4631
4632   str = getenv ("TEST_ONLY");
4633   if (str)
4634     return strstr (str, "ping_daemon") == NULL;
4635   str = getenv ("SKIP_TEST_PING_DAEMON_0");
4636   if (str && strcmp (str, "1") == 0) return 1;
4637   str = getenv ("SKIP_TEST_PING_DAEMON");
4638   if (str && strcmp (str, "1") == 0) return 1;
4639   return 0;
4640 }
4641
4642 static int test_ping_daemon_0 (void)
4643 {
4644   if (test_ping_daemon_0_skip ()) {
4645     printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4646     return 0;
4647   }
4648
4649   /* InitNone|InitEmpty for test_ping_daemon_0 */
4650   {
4651     char device[] = "/dev/sda";
4652     int r;
4653     suppress_error = 0;
4654     r = guestfs_blockdev_setrw (g, device);
4655     if (r == -1)
4656       return -1;
4657   }
4658   {
4659     int r;
4660     suppress_error = 0;
4661     r = guestfs_umount_all (g);
4662     if (r == -1)
4663       return -1;
4664   }
4665   {
4666     int r;
4667     suppress_error = 0;
4668     r = guestfs_lvm_remove_all (g);
4669     if (r == -1)
4670       return -1;
4671   }
4672   /* TestRun for ping_daemon (0) */
4673   {
4674     int r;
4675     suppress_error = 0;
4676     r = guestfs_ping_daemon (g);
4677     if (r == -1)
4678       return -1;
4679   }
4680   return 0;
4681 }
4682
4683 static int test_dmesg_0_skip (void)
4684 {
4685   const char *str;
4686
4687   str = getenv ("TEST_ONLY");
4688   if (str)
4689     return strstr (str, "dmesg") == NULL;
4690   str = getenv ("SKIP_TEST_DMESG_0");
4691   if (str && strcmp (str, "1") == 0) return 1;
4692   str = getenv ("SKIP_TEST_DMESG");
4693   if (str && strcmp (str, "1") == 0) return 1;
4694   return 0;
4695 }
4696
4697 static int test_dmesg_0 (void)
4698 {
4699   if (test_dmesg_0_skip ()) {
4700     printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4701     return 0;
4702   }
4703
4704   /* InitNone|InitEmpty for test_dmesg_0 */
4705   {
4706     char device[] = "/dev/sda";
4707     int r;
4708     suppress_error = 0;
4709     r = guestfs_blockdev_setrw (g, device);
4710     if (r == -1)
4711       return -1;
4712   }
4713   {
4714     int r;
4715     suppress_error = 0;
4716     r = guestfs_umount_all (g);
4717     if (r == -1)
4718       return -1;
4719   }
4720   {
4721     int r;
4722     suppress_error = 0;
4723     r = guestfs_lvm_remove_all (g);
4724     if (r == -1)
4725       return -1;
4726   }
4727   /* TestRun for dmesg (0) */
4728   {
4729     char *r;
4730     suppress_error = 0;
4731     r = guestfs_dmesg (g);
4732     if (r == NULL)
4733       return -1;
4734     free (r);
4735   }
4736   return 0;
4737 }
4738
4739 static int test_drop_caches_0_skip (void)
4740 {
4741   const char *str;
4742
4743   str = getenv ("TEST_ONLY");
4744   if (str)
4745     return strstr (str, "drop_caches") == NULL;
4746   str = getenv ("SKIP_TEST_DROP_CACHES_0");
4747   if (str && strcmp (str, "1") == 0) return 1;
4748   str = getenv ("SKIP_TEST_DROP_CACHES");
4749   if (str && strcmp (str, "1") == 0) return 1;
4750   return 0;
4751 }
4752
4753 static int test_drop_caches_0 (void)
4754 {
4755   if (test_drop_caches_0_skip ()) {
4756     printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4757     return 0;
4758   }
4759
4760   /* InitNone|InitEmpty for test_drop_caches_0 */
4761   {
4762     char device[] = "/dev/sda";
4763     int r;
4764     suppress_error = 0;
4765     r = guestfs_blockdev_setrw (g, device);
4766     if (r == -1)
4767       return -1;
4768   }
4769   {
4770     int r;
4771     suppress_error = 0;
4772     r = guestfs_umount_all (g);
4773     if (r == -1)
4774       return -1;
4775   }
4776   {
4777     int r;
4778     suppress_error = 0;
4779     r = guestfs_lvm_remove_all (g);
4780     if (r == -1)
4781       return -1;
4782   }
4783   /* TestRun for drop_caches (0) */
4784   {
4785     int r;
4786     suppress_error = 0;
4787     r = guestfs_drop_caches (g, 3);
4788     if (r == -1)
4789       return -1;
4790   }
4791   return 0;
4792 }
4793
4794 static int test_mv_0_skip (void)
4795 {
4796   const char *str;
4797
4798   str = getenv ("TEST_ONLY");
4799   if (str)
4800     return strstr (str, "mv") == NULL;
4801   str = getenv ("SKIP_TEST_MV_0");
4802   if (str && strcmp (str, "1") == 0) return 1;
4803   str = getenv ("SKIP_TEST_MV");
4804   if (str && strcmp (str, "1") == 0) return 1;
4805   return 0;
4806 }
4807
4808 static int test_mv_0 (void)
4809 {
4810   if (test_mv_0_skip ()) {
4811     printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4812     return 0;
4813   }
4814
4815   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4816   {
4817     char device[] = "/dev/sda";
4818     int r;
4819     suppress_error = 0;
4820     r = guestfs_blockdev_setrw (g, device);
4821     if (r == -1)
4822       return -1;
4823   }
4824   {
4825     int r;
4826     suppress_error = 0;
4827     r = guestfs_umount_all (g);
4828     if (r == -1)
4829       return -1;
4830   }
4831   {
4832     int r;
4833     suppress_error = 0;
4834     r = guestfs_lvm_remove_all (g);
4835     if (r == -1)
4836       return -1;
4837   }
4838   {
4839     char device[] = "/dev/sda";
4840     char lines_0[] = ",";
4841     char *lines[] = {
4842       lines_0,
4843       NULL
4844     };
4845     int r;
4846     suppress_error = 0;
4847     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4848     if (r == -1)
4849       return -1;
4850   }
4851   {
4852     char fstype[] = "ext2";
4853     char device[] = "/dev/sda1";
4854     int r;
4855     suppress_error = 0;
4856     r = guestfs_mkfs (g, fstype, device);
4857     if (r == -1)
4858       return -1;
4859   }
4860   {
4861     char device[] = "/dev/sda1";
4862     char mountpoint[] = "/";
4863     int r;
4864     suppress_error = 0;
4865     r = guestfs_mount (g, device, mountpoint);
4866     if (r == -1)
4867       return -1;
4868   }
4869   /* TestOutput for mv (0) */
4870   char expected[] = "file content";
4871   {
4872     char path[] = "/old";
4873     char content[] = "file content";
4874     int r;
4875     suppress_error = 0;
4876     r = guestfs_write_file (g, path, content, 0);
4877     if (r == -1)
4878       return -1;
4879   }
4880   {
4881     char src[] = "/old";
4882     char dest[] = "/new";
4883     int r;
4884     suppress_error = 0;
4885     r = guestfs_mv (g, src, dest);
4886     if (r == -1)
4887       return -1;
4888   }
4889   {
4890     char path[] = "/new";
4891     char *r;
4892     suppress_error = 0;
4893     r = guestfs_cat (g, path);
4894     if (r == NULL)
4895       return -1;
4896     if (strcmp (r, expected) != 0) {
4897       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4898       return -1;
4899     }
4900     free (r);
4901   }
4902   return 0;
4903 }
4904
4905 static int test_mv_1_skip (void)
4906 {
4907   const char *str;
4908
4909   str = getenv ("TEST_ONLY");
4910   if (str)
4911     return strstr (str, "mv") == NULL;
4912   str = getenv ("SKIP_TEST_MV_1");
4913   if (str && strcmp (str, "1") == 0) return 1;
4914   str = getenv ("SKIP_TEST_MV");
4915   if (str && strcmp (str, "1") == 0) return 1;
4916   return 0;
4917 }
4918
4919 static int test_mv_1 (void)
4920 {
4921   if (test_mv_1_skip ()) {
4922     printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4923     return 0;
4924   }
4925
4926   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4927   {
4928     char device[] = "/dev/sda";
4929     int r;
4930     suppress_error = 0;
4931     r = guestfs_blockdev_setrw (g, device);
4932     if (r == -1)
4933       return -1;
4934   }
4935   {
4936     int r;
4937     suppress_error = 0;
4938     r = guestfs_umount_all (g);
4939     if (r == -1)
4940       return -1;
4941   }
4942   {
4943     int r;
4944     suppress_error = 0;
4945     r = guestfs_lvm_remove_all (g);
4946     if (r == -1)
4947       return -1;
4948   }
4949   {
4950     char device[] = "/dev/sda";
4951     char lines_0[] = ",";
4952     char *lines[] = {
4953       lines_0,
4954       NULL
4955     };
4956     int r;
4957     suppress_error = 0;
4958     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4959     if (r == -1)
4960       return -1;
4961   }
4962   {
4963     char fstype[] = "ext2";
4964     char device[] = "/dev/sda1";
4965     int r;
4966     suppress_error = 0;
4967     r = guestfs_mkfs (g, fstype, device);
4968     if (r == -1)
4969       return -1;
4970   }
4971   {
4972     char device[] = "/dev/sda1";
4973     char mountpoint[] = "/";
4974     int r;
4975     suppress_error = 0;
4976     r = guestfs_mount (g, device, mountpoint);
4977     if (r == -1)
4978       return -1;
4979   }
4980   /* TestOutputFalse for mv (1) */
4981   {
4982     char path[] = "/old";
4983     char content[] = "file content";
4984     int r;
4985     suppress_error = 0;
4986     r = guestfs_write_file (g, path, content, 0);
4987     if (r == -1)
4988       return -1;
4989   }
4990   {
4991     char src[] = "/old";
4992     char dest[] = "/new";
4993     int r;
4994     suppress_error = 0;
4995     r = guestfs_mv (g, src, dest);
4996     if (r == -1)
4997       return -1;
4998   }
4999   {
5000     char path[] = "/old";
5001     int r;
5002     suppress_error = 0;
5003     r = guestfs_is_file (g, path);
5004     if (r == -1)
5005       return -1;
5006     if (r) {
5007       fprintf (stderr, "test_mv_1: expected false, got true\n");
5008       return -1;
5009     }
5010   }
5011   return 0;
5012 }
5013
5014 static int test_cp_a_0_skip (void)
5015 {
5016   const char *str;
5017
5018   str = getenv ("TEST_ONLY");
5019   if (str)
5020     return strstr (str, "cp_a") == NULL;
5021   str = getenv ("SKIP_TEST_CP_A_0");
5022   if (str && strcmp (str, "1") == 0) return 1;
5023   str = getenv ("SKIP_TEST_CP_A");
5024   if (str && strcmp (str, "1") == 0) return 1;
5025   return 0;
5026 }
5027
5028 static int test_cp_a_0 (void)
5029 {
5030   if (test_cp_a_0_skip ()) {
5031     printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
5032     return 0;
5033   }
5034
5035   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
5036   {
5037     char device[] = "/dev/sda";
5038     int r;
5039     suppress_error = 0;
5040     r = guestfs_blockdev_setrw (g, device);
5041     if (r == -1)
5042       return -1;
5043   }
5044   {
5045     int r;
5046     suppress_error = 0;
5047     r = guestfs_umount_all (g);
5048     if (r == -1)
5049       return -1;
5050   }
5051   {
5052     int r;
5053     suppress_error = 0;
5054     r = guestfs_lvm_remove_all (g);
5055     if (r == -1)
5056       return -1;
5057   }
5058   {
5059     char device[] = "/dev/sda";
5060     char lines_0[] = ",";
5061     char *lines[] = {
5062       lines_0,
5063       NULL
5064     };
5065     int r;
5066     suppress_error = 0;
5067     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5068     if (r == -1)
5069       return -1;
5070   }
5071   {
5072     char fstype[] = "ext2";
5073     char device[] = "/dev/sda1";
5074     int r;
5075     suppress_error = 0;
5076     r = guestfs_mkfs (g, fstype, device);
5077     if (r == -1)
5078       return -1;
5079   }
5080   {
5081     char device[] = "/dev/sda1";
5082     char mountpoint[] = "/";
5083     int r;
5084     suppress_error = 0;
5085     r = guestfs_mount (g, device, mountpoint);
5086     if (r == -1)
5087       return -1;
5088   }
5089   /* TestOutput for cp_a (0) */
5090   char expected[] = "file content";
5091   {
5092     char path[] = "/olddir";
5093     int r;
5094     suppress_error = 0;
5095     r = guestfs_mkdir (g, path);
5096     if (r == -1)
5097       return -1;
5098   }
5099   {
5100     char path[] = "/newdir";
5101     int r;
5102     suppress_error = 0;
5103     r = guestfs_mkdir (g, path);
5104     if (r == -1)
5105       return -1;
5106   }
5107   {
5108     char path[] = "/olddir/file";
5109     char content[] = "file content";
5110     int r;
5111     suppress_error = 0;
5112     r = guestfs_write_file (g, path, content, 0);
5113     if (r == -1)
5114       return -1;
5115   }
5116   {
5117     char src[] = "/olddir";
5118     char dest[] = "/newdir";
5119     int r;
5120     suppress_error = 0;
5121     r = guestfs_cp_a (g, src, dest);
5122     if (r == -1)
5123       return -1;
5124   }
5125   {
5126     char path[] = "/newdir/olddir/file";
5127     char *r;
5128     suppress_error = 0;
5129     r = guestfs_cat (g, path);
5130     if (r == NULL)
5131       return -1;
5132     if (strcmp (r, expected) != 0) {
5133       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
5134       return -1;
5135     }
5136     free (r);
5137   }
5138   return 0;
5139 }
5140
5141 static int test_cp_0_skip (void)
5142 {
5143   const char *str;
5144
5145   str = getenv ("TEST_ONLY");
5146   if (str)
5147     return strstr (str, "cp") == NULL;
5148   str = getenv ("SKIP_TEST_CP_0");
5149   if (str && strcmp (str, "1") == 0) return 1;
5150   str = getenv ("SKIP_TEST_CP");
5151   if (str && strcmp (str, "1") == 0) return 1;
5152   return 0;
5153 }
5154
5155 static int test_cp_0 (void)
5156 {
5157   if (test_cp_0_skip ()) {
5158     printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
5159     return 0;
5160   }
5161
5162   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
5163   {
5164     char device[] = "/dev/sda";
5165     int r;
5166     suppress_error = 0;
5167     r = guestfs_blockdev_setrw (g, device);
5168     if (r == -1)
5169       return -1;
5170   }
5171   {
5172     int r;
5173     suppress_error = 0;
5174     r = guestfs_umount_all (g);
5175     if (r == -1)
5176       return -1;
5177   }
5178   {
5179     int r;
5180     suppress_error = 0;
5181     r = guestfs_lvm_remove_all (g);
5182     if (r == -1)
5183       return -1;
5184   }
5185   {
5186     char device[] = "/dev/sda";
5187     char lines_0[] = ",";
5188     char *lines[] = {
5189       lines_0,
5190       NULL
5191     };
5192     int r;
5193     suppress_error = 0;
5194     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5195     if (r == -1)
5196       return -1;
5197   }
5198   {
5199     char fstype[] = "ext2";
5200     char device[] = "/dev/sda1";
5201     int r;
5202     suppress_error = 0;
5203     r = guestfs_mkfs (g, fstype, device);
5204     if (r == -1)
5205       return -1;
5206   }
5207   {
5208     char device[] = "/dev/sda1";
5209     char mountpoint[] = "/";
5210     int r;
5211     suppress_error = 0;
5212     r = guestfs_mount (g, device, mountpoint);
5213     if (r == -1)
5214       return -1;
5215   }
5216   /* TestOutput for cp (0) */
5217   char expected[] = "file content";
5218   {
5219     char path[] = "/old";
5220     char content[] = "file content";
5221     int r;
5222     suppress_error = 0;
5223     r = guestfs_write_file (g, path, content, 0);
5224     if (r == -1)
5225       return -1;
5226   }
5227   {
5228     char src[] = "/old";
5229     char dest[] = "/new";
5230     int r;
5231     suppress_error = 0;
5232     r = guestfs_cp (g, src, dest);
5233     if (r == -1)
5234       return -1;
5235   }
5236   {
5237     char path[] = "/new";
5238     char *r;
5239     suppress_error = 0;
5240     r = guestfs_cat (g, path);
5241     if (r == NULL)
5242       return -1;
5243     if (strcmp (r, expected) != 0) {
5244       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5245       return -1;
5246     }
5247     free (r);
5248   }
5249   return 0;
5250 }
5251
5252 static int test_cp_1_skip (void)
5253 {
5254   const char *str;
5255
5256   str = getenv ("TEST_ONLY");
5257   if (str)
5258     return strstr (str, "cp") == NULL;
5259   str = getenv ("SKIP_TEST_CP_1");
5260   if (str && strcmp (str, "1") == 0) return 1;
5261   str = getenv ("SKIP_TEST_CP");
5262   if (str && strcmp (str, "1") == 0) return 1;
5263   return 0;
5264 }
5265
5266 static int test_cp_1 (void)
5267 {
5268   if (test_cp_1_skip ()) {
5269     printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
5270     return 0;
5271   }
5272
5273   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5274   {
5275     char device[] = "/dev/sda";
5276     int r;
5277     suppress_error = 0;
5278     r = guestfs_blockdev_setrw (g, device);
5279     if (r == -1)
5280       return -1;
5281   }
5282   {
5283     int r;
5284     suppress_error = 0;
5285     r = guestfs_umount_all (g);
5286     if (r == -1)
5287       return -1;
5288   }
5289   {
5290     int r;
5291     suppress_error = 0;
5292     r = guestfs_lvm_remove_all (g);
5293     if (r == -1)
5294       return -1;
5295   }
5296   {
5297     char device[] = "/dev/sda";
5298     char lines_0[] = ",";
5299     char *lines[] = {
5300       lines_0,
5301       NULL
5302     };
5303     int r;
5304     suppress_error = 0;
5305     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5306     if (r == -1)
5307       return -1;
5308   }
5309   {
5310     char fstype[] = "ext2";
5311     char device[] = "/dev/sda1";
5312     int r;
5313     suppress_error = 0;
5314     r = guestfs_mkfs (g, fstype, device);
5315     if (r == -1)
5316       return -1;
5317   }
5318   {
5319     char device[] = "/dev/sda1";
5320     char mountpoint[] = "/";
5321     int r;
5322     suppress_error = 0;
5323     r = guestfs_mount (g, device, mountpoint);
5324     if (r == -1)
5325       return -1;
5326   }
5327   /* TestOutputTrue for cp (1) */
5328   {
5329     char path[] = "/old";
5330     char content[] = "file content";
5331     int r;
5332     suppress_error = 0;
5333     r = guestfs_write_file (g, path, content, 0);
5334     if (r == -1)
5335       return -1;
5336   }
5337   {
5338     char src[] = "/old";
5339     char dest[] = "/new";
5340     int r;
5341     suppress_error = 0;
5342     r = guestfs_cp (g, src, dest);
5343     if (r == -1)
5344       return -1;
5345   }
5346   {
5347     char path[] = "/old";
5348     int r;
5349     suppress_error = 0;
5350     r = guestfs_is_file (g, path);
5351     if (r == -1)
5352       return -1;
5353     if (!r) {
5354       fprintf (stderr, "test_cp_1: expected true, got false\n");
5355       return -1;
5356     }
5357   }
5358   return 0;
5359 }
5360
5361 static int test_cp_2_skip (void)
5362 {
5363   const char *str;
5364
5365   str = getenv ("TEST_ONLY");
5366   if (str)
5367     return strstr (str, "cp") == NULL;
5368   str = getenv ("SKIP_TEST_CP_2");
5369   if (str && strcmp (str, "1") == 0) return 1;
5370   str = getenv ("SKIP_TEST_CP");
5371   if (str && strcmp (str, "1") == 0) return 1;
5372   return 0;
5373 }
5374
5375 static int test_cp_2 (void)
5376 {
5377   if (test_cp_2_skip ()) {
5378     printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5379     return 0;
5380   }
5381
5382   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5383   {
5384     char device[] = "/dev/sda";
5385     int r;
5386     suppress_error = 0;
5387     r = guestfs_blockdev_setrw (g, device);
5388     if (r == -1)
5389       return -1;
5390   }
5391   {
5392     int r;
5393     suppress_error = 0;
5394     r = guestfs_umount_all (g);
5395     if (r == -1)
5396       return -1;
5397   }
5398   {
5399     int r;
5400     suppress_error = 0;
5401     r = guestfs_lvm_remove_all (g);
5402     if (r == -1)
5403       return -1;
5404   }
5405   {
5406     char device[] = "/dev/sda";
5407     char lines_0[] = ",";
5408     char *lines[] = {
5409       lines_0,
5410       NULL
5411     };
5412     int r;
5413     suppress_error = 0;
5414     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5415     if (r == -1)
5416       return -1;
5417   }
5418   {
5419     char fstype[] = "ext2";
5420     char device[] = "/dev/sda1";
5421     int r;
5422     suppress_error = 0;
5423     r = guestfs_mkfs (g, fstype, device);
5424     if (r == -1)
5425       return -1;
5426   }
5427   {
5428     char device[] = "/dev/sda1";
5429     char mountpoint[] = "/";
5430     int r;
5431     suppress_error = 0;
5432     r = guestfs_mount (g, device, mountpoint);
5433     if (r == -1)
5434       return -1;
5435   }
5436   /* TestOutput for cp (2) */
5437   char expected[] = "file content";
5438   {
5439     char path[] = "/old";
5440     char content[] = "file content";
5441     int r;
5442     suppress_error = 0;
5443     r = guestfs_write_file (g, path, content, 0);
5444     if (r == -1)
5445       return -1;
5446   }
5447   {
5448     char path[] = "/dir";
5449     int r;
5450     suppress_error = 0;
5451     r = guestfs_mkdir (g, path);
5452     if (r == -1)
5453       return -1;
5454   }
5455   {
5456     char src[] = "/old";
5457     char dest[] = "/dir/new";
5458     int r;
5459     suppress_error = 0;
5460     r = guestfs_cp (g, src, dest);
5461     if (r == -1)
5462       return -1;
5463   }
5464   {
5465     char path[] = "/dir/new";
5466     char *r;
5467     suppress_error = 0;
5468     r = guestfs_cat (g, path);
5469     if (r == NULL)
5470       return -1;
5471     if (strcmp (r, expected) != 0) {
5472       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5473       return -1;
5474     }
5475     free (r);
5476   }
5477   return 0;
5478 }
5479
5480 static int test_grub_install_0_skip (void)
5481 {
5482   const char *str;
5483
5484   str = getenv ("TEST_ONLY");
5485   if (str)
5486     return strstr (str, "grub_install") == NULL;
5487   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5488   if (str && strcmp (str, "1") == 0) return 1;
5489   str = getenv ("SKIP_TEST_GRUB_INSTALL");
5490   if (str && strcmp (str, "1") == 0) return 1;
5491   return 0;
5492 }
5493
5494 static int test_grub_install_0 (void)
5495 {
5496   if (test_grub_install_0_skip ()) {
5497     printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5498     return 0;
5499   }
5500
5501   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5502   {
5503     char device[] = "/dev/sda";
5504     int r;
5505     suppress_error = 0;
5506     r = guestfs_blockdev_setrw (g, device);
5507     if (r == -1)
5508       return -1;
5509   }
5510   {
5511     int r;
5512     suppress_error = 0;
5513     r = guestfs_umount_all (g);
5514     if (r == -1)
5515       return -1;
5516   }
5517   {
5518     int r;
5519     suppress_error = 0;
5520     r = guestfs_lvm_remove_all (g);
5521     if (r == -1)
5522       return -1;
5523   }
5524   {
5525     char device[] = "/dev/sda";
5526     char lines_0[] = ",";
5527     char *lines[] = {
5528       lines_0,
5529       NULL
5530     };
5531     int r;
5532     suppress_error = 0;
5533     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5534     if (r == -1)
5535       return -1;
5536   }
5537   {
5538     char fstype[] = "ext2";
5539     char device[] = "/dev/sda1";
5540     int r;
5541     suppress_error = 0;
5542     r = guestfs_mkfs (g, fstype, device);
5543     if (r == -1)
5544       return -1;
5545   }
5546   {
5547     char device[] = "/dev/sda1";
5548     char mountpoint[] = "/";
5549     int r;
5550     suppress_error = 0;
5551     r = guestfs_mount (g, device, mountpoint);
5552     if (r == -1)
5553       return -1;
5554   }
5555   /* TestOutputTrue for grub_install (0) */
5556   {
5557     char root[] = "/";
5558     char device[] = "/dev/sda1";
5559     int r;
5560     suppress_error = 0;
5561     r = guestfs_grub_install (g, root, device);
5562     if (r == -1)
5563       return -1;
5564   }
5565   {
5566     char path[] = "/boot";
5567     int r;
5568     suppress_error = 0;
5569     r = guestfs_is_dir (g, path);
5570     if (r == -1)
5571       return -1;
5572     if (!r) {
5573       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5574       return -1;
5575     }
5576   }
5577   return 0;
5578 }
5579
5580 static int test_zero_0_skip (void)
5581 {
5582   const char *str;
5583
5584   str = getenv ("TEST_ONLY");
5585   if (str)
5586     return strstr (str, "zero") == NULL;
5587   str = getenv ("SKIP_TEST_ZERO_0");
5588   if (str && strcmp (str, "1") == 0) return 1;
5589   str = getenv ("SKIP_TEST_ZERO");
5590   if (str && strcmp (str, "1") == 0) return 1;
5591   return 0;
5592 }
5593
5594 static int test_zero_0 (void)
5595 {
5596   if (test_zero_0_skip ()) {
5597     printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5598     return 0;
5599   }
5600
5601   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5602   {
5603     char device[] = "/dev/sda";
5604     int r;
5605     suppress_error = 0;
5606     r = guestfs_blockdev_setrw (g, device);
5607     if (r == -1)
5608       return -1;
5609   }
5610   {
5611     int r;
5612     suppress_error = 0;
5613     r = guestfs_umount_all (g);
5614     if (r == -1)
5615       return -1;
5616   }
5617   {
5618     int r;
5619     suppress_error = 0;
5620     r = guestfs_lvm_remove_all (g);
5621     if (r == -1)
5622       return -1;
5623   }
5624   {
5625     char device[] = "/dev/sda";
5626     char lines_0[] = ",";
5627     char *lines[] = {
5628       lines_0,
5629       NULL
5630     };
5631     int r;
5632     suppress_error = 0;
5633     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5634     if (r == -1)
5635       return -1;
5636   }
5637   {
5638     char fstype[] = "ext2";
5639     char device[] = "/dev/sda1";
5640     int r;
5641     suppress_error = 0;
5642     r = guestfs_mkfs (g, fstype, device);
5643     if (r == -1)
5644       return -1;
5645   }
5646   {
5647     char device[] = "/dev/sda1";
5648     char mountpoint[] = "/";
5649     int r;
5650     suppress_error = 0;
5651     r = guestfs_mount (g, device, mountpoint);
5652     if (r == -1)
5653       return -1;
5654   }
5655   /* TestOutput for zero (0) */
5656   char expected[] = "data";
5657   {
5658     char pathordevice[] = "/dev/sda1";
5659     int r;
5660     suppress_error = 0;
5661     r = guestfs_umount (g, pathordevice);
5662     if (r == -1)
5663       return -1;
5664   }
5665   {
5666     char device[] = "/dev/sda1";
5667     int r;
5668     suppress_error = 0;
5669     r = guestfs_zero (g, device);
5670     if (r == -1)
5671       return -1;
5672   }
5673   {
5674     char path[] = "/dev/sda1";
5675     char *r;
5676     suppress_error = 0;
5677     r = guestfs_file (g, path);
5678     if (r == NULL)
5679       return -1;
5680     if (strcmp (r, expected) != 0) {
5681       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5682       return -1;
5683     }
5684     free (r);
5685   }
5686   return 0;
5687 }
5688
5689 static int test_fsck_0_skip (void)
5690 {
5691   const char *str;
5692
5693   str = getenv ("TEST_ONLY");
5694   if (str)
5695     return strstr (str, "fsck") == NULL;
5696   str = getenv ("SKIP_TEST_FSCK_0");
5697   if (str && strcmp (str, "1") == 0) return 1;
5698   str = getenv ("SKIP_TEST_FSCK");
5699   if (str && strcmp (str, "1") == 0) return 1;
5700   return 0;
5701 }
5702
5703 static int test_fsck_0 (void)
5704 {
5705   if (test_fsck_0_skip ()) {
5706     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5707     return 0;
5708   }
5709
5710   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5711   {
5712     char device[] = "/dev/sda";
5713     int r;
5714     suppress_error = 0;
5715     r = guestfs_blockdev_setrw (g, device);
5716     if (r == -1)
5717       return -1;
5718   }
5719   {
5720     int r;
5721     suppress_error = 0;
5722     r = guestfs_umount_all (g);
5723     if (r == -1)
5724       return -1;
5725   }
5726   {
5727     int r;
5728     suppress_error = 0;
5729     r = guestfs_lvm_remove_all (g);
5730     if (r == -1)
5731       return -1;
5732   }
5733   {
5734     char device[] = "/dev/sda";
5735     char lines_0[] = ",";
5736     char *lines[] = {
5737       lines_0,
5738       NULL
5739     };
5740     int r;
5741     suppress_error = 0;
5742     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5743     if (r == -1)
5744       return -1;
5745   }
5746   {
5747     char fstype[] = "ext2";
5748     char device[] = "/dev/sda1";
5749     int r;
5750     suppress_error = 0;
5751     r = guestfs_mkfs (g, fstype, device);
5752     if (r == -1)
5753       return -1;
5754   }
5755   {
5756     char device[] = "/dev/sda1";
5757     char mountpoint[] = "/";
5758     int r;
5759     suppress_error = 0;
5760     r = guestfs_mount (g, device, mountpoint);
5761     if (r == -1)
5762       return -1;
5763   }
5764   /* TestOutputInt for fsck (0) */
5765   {
5766     char pathordevice[] = "/dev/sda1";
5767     int r;
5768     suppress_error = 0;
5769     r = guestfs_umount (g, pathordevice);
5770     if (r == -1)
5771       return -1;
5772   }
5773   {
5774     char fstype[] = "ext2";
5775     char device[] = "/dev/sda1";
5776     int r;
5777     suppress_error = 0;
5778     r = guestfs_fsck (g, fstype, device);
5779     if (r == -1)
5780       return -1;
5781     if (r != 0) {
5782       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
5783       return -1;
5784     }
5785   }
5786   return 0;
5787 }
5788
5789 static int test_fsck_1_skip (void)
5790 {
5791   const char *str;
5792
5793   str = getenv ("TEST_ONLY");
5794   if (str)
5795     return strstr (str, "fsck") == NULL;
5796   str = getenv ("SKIP_TEST_FSCK_1");
5797   if (str && strcmp (str, "1") == 0) return 1;
5798   str = getenv ("SKIP_TEST_FSCK");
5799   if (str && strcmp (str, "1") == 0) return 1;
5800   return 0;
5801 }
5802
5803 static int test_fsck_1 (void)
5804 {
5805   if (test_fsck_1_skip ()) {
5806     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5807     return 0;
5808   }
5809
5810   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5811   {
5812     char device[] = "/dev/sda";
5813     int r;
5814     suppress_error = 0;
5815     r = guestfs_blockdev_setrw (g, device);
5816     if (r == -1)
5817       return -1;
5818   }
5819   {
5820     int r;
5821     suppress_error = 0;
5822     r = guestfs_umount_all (g);
5823     if (r == -1)
5824       return -1;
5825   }
5826   {
5827     int r;
5828     suppress_error = 0;
5829     r = guestfs_lvm_remove_all (g);
5830     if (r == -1)
5831       return -1;
5832   }
5833   {
5834     char device[] = "/dev/sda";
5835     char lines_0[] = ",";
5836     char *lines[] = {
5837       lines_0,
5838       NULL
5839     };
5840     int r;
5841     suppress_error = 0;
5842     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5843     if (r == -1)
5844       return -1;
5845   }
5846   {
5847     char fstype[] = "ext2";
5848     char device[] = "/dev/sda1";
5849     int r;
5850     suppress_error = 0;
5851     r = guestfs_mkfs (g, fstype, device);
5852     if (r == -1)
5853       return -1;
5854   }
5855   {
5856     char device[] = "/dev/sda1";
5857     char mountpoint[] = "/";
5858     int r;
5859     suppress_error = 0;
5860     r = guestfs_mount (g, device, mountpoint);
5861     if (r == -1)
5862       return -1;
5863   }
5864   /* TestOutputInt for fsck (1) */
5865   {
5866     char pathordevice[] = "/dev/sda1";
5867     int r;
5868     suppress_error = 0;
5869     r = guestfs_umount (g, pathordevice);
5870     if (r == -1)
5871       return -1;
5872   }
5873   {
5874     char device[] = "/dev/sda1";
5875     int r;
5876     suppress_error = 0;
5877     r = guestfs_zero (g, device);
5878     if (r == -1)
5879       return -1;
5880   }
5881   {
5882     char fstype[] = "ext2";
5883     char device[] = "/dev/sda1";
5884     int r;
5885     suppress_error = 0;
5886     r = guestfs_fsck (g, fstype, device);
5887     if (r == -1)
5888       return -1;
5889     if (r != 8) {
5890       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
5891       return -1;
5892     }
5893   }
5894   return 0;
5895 }
5896
5897 static int test_set_e2uuid_0_skip (void)
5898 {
5899   const char *str;
5900
5901   str = getenv ("TEST_ONLY");
5902   if (str)
5903     return strstr (str, "set_e2uuid") == NULL;
5904   str = getenv ("SKIP_TEST_SET_E2UUID_0");
5905   if (str && strcmp (str, "1") == 0) return 1;
5906   str = getenv ("SKIP_TEST_SET_E2UUID");
5907   if (str && strcmp (str, "1") == 0) return 1;
5908   return 0;
5909 }
5910
5911 static int test_set_e2uuid_0 (void)
5912 {
5913   if (test_set_e2uuid_0_skip ()) {
5914     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5915     return 0;
5916   }
5917
5918   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5919   {
5920     char device[] = "/dev/sda";
5921     int r;
5922     suppress_error = 0;
5923     r = guestfs_blockdev_setrw (g, device);
5924     if (r == -1)
5925       return -1;
5926   }
5927   {
5928     int r;
5929     suppress_error = 0;
5930     r = guestfs_umount_all (g);
5931     if (r == -1)
5932       return -1;
5933   }
5934   {
5935     int r;
5936     suppress_error = 0;
5937     r = guestfs_lvm_remove_all (g);
5938     if (r == -1)
5939       return -1;
5940   }
5941   {
5942     char device[] = "/dev/sda";
5943     char lines_0[] = ",";
5944     char *lines[] = {
5945       lines_0,
5946       NULL
5947     };
5948     int r;
5949     suppress_error = 0;
5950     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5951     if (r == -1)
5952       return -1;
5953   }
5954   {
5955     char fstype[] = "ext2";
5956     char device[] = "/dev/sda1";
5957     int r;
5958     suppress_error = 0;
5959     r = guestfs_mkfs (g, fstype, device);
5960     if (r == -1)
5961       return -1;
5962   }
5963   {
5964     char device[] = "/dev/sda1";
5965     char mountpoint[] = "/";
5966     int r;
5967     suppress_error = 0;
5968     r = guestfs_mount (g, device, mountpoint);
5969     if (r == -1)
5970       return -1;
5971   }
5972   /* TestOutput for set_e2uuid (0) */
5973   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5974   {
5975     char device[] = "/dev/sda1";
5976     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5977     int r;
5978     suppress_error = 0;
5979     r = guestfs_set_e2uuid (g, device, uuid);
5980     if (r == -1)
5981       return -1;
5982   }
5983   {
5984     char device[] = "/dev/sda1";
5985     char *r;
5986     suppress_error = 0;
5987     r = guestfs_get_e2uuid (g, device);
5988     if (r == NULL)
5989       return -1;
5990     if (strcmp (r, expected) != 0) {
5991       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5992       return -1;
5993     }
5994     free (r);
5995   }
5996   return 0;
5997 }
5998
5999 static int test_set_e2uuid_1_skip (void)
6000 {
6001   const char *str;
6002
6003   str = getenv ("TEST_ONLY");
6004   if (str)
6005     return strstr (str, "set_e2uuid") == NULL;
6006   str = getenv ("SKIP_TEST_SET_E2UUID_1");
6007   if (str && strcmp (str, "1") == 0) return 1;
6008   str = getenv ("SKIP_TEST_SET_E2UUID");
6009   if (str && strcmp (str, "1") == 0) return 1;
6010   return 0;
6011 }
6012
6013 static int test_set_e2uuid_1 (void)
6014 {
6015   if (test_set_e2uuid_1_skip ()) {
6016     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
6017     return 0;
6018   }
6019
6020   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
6021   {
6022     char device[] = "/dev/sda";
6023     int r;
6024     suppress_error = 0;
6025     r = guestfs_blockdev_setrw (g, device);
6026     if (r == -1)
6027       return -1;
6028   }
6029   {
6030     int r;
6031     suppress_error = 0;
6032     r = guestfs_umount_all (g);
6033     if (r == -1)
6034       return -1;
6035   }
6036   {
6037     int r;
6038     suppress_error = 0;
6039     r = guestfs_lvm_remove_all (g);
6040     if (r == -1)
6041       return -1;
6042   }
6043   {
6044     char device[] = "/dev/sda";
6045     char lines_0[] = ",";
6046     char *lines[] = {
6047       lines_0,
6048       NULL
6049     };
6050     int r;
6051     suppress_error = 0;
6052     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6053     if (r == -1)
6054       return -1;
6055   }
6056   {
6057     char fstype[] = "ext2";
6058     char device[] = "/dev/sda1";
6059     int r;
6060     suppress_error = 0;
6061     r = guestfs_mkfs (g, fstype, device);
6062     if (r == -1)
6063       return -1;
6064   }
6065   {
6066     char device[] = "/dev/sda1";
6067     char mountpoint[] = "/";
6068     int r;
6069     suppress_error = 0;
6070     r = guestfs_mount (g, device, mountpoint);
6071     if (r == -1)
6072       return -1;
6073   }
6074   /* TestOutput for set_e2uuid (1) */
6075   char expected[] = "";
6076   {
6077     char device[] = "/dev/sda1";
6078     char uuid[] = "clear";
6079     int r;
6080     suppress_error = 0;
6081     r = guestfs_set_e2uuid (g, device, uuid);
6082     if (r == -1)
6083       return -1;
6084   }
6085   {
6086     char device[] = "/dev/sda1";
6087     char *r;
6088     suppress_error = 0;
6089     r = guestfs_get_e2uuid (g, device);
6090     if (r == NULL)
6091       return -1;
6092     if (strcmp (r, expected) != 0) {
6093       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
6094       return -1;
6095     }
6096     free (r);
6097   }
6098   return 0;
6099 }
6100
6101 static int test_set_e2uuid_2_skip (void)
6102 {
6103   const char *str;
6104
6105   str = getenv ("TEST_ONLY");
6106   if (str)
6107     return strstr (str, "set_e2uuid") == NULL;
6108   str = getenv ("SKIP_TEST_SET_E2UUID_2");
6109   if (str && strcmp (str, "1") == 0) return 1;
6110   str = getenv ("SKIP_TEST_SET_E2UUID");
6111   if (str && strcmp (str, "1") == 0) return 1;
6112   return 0;
6113 }
6114
6115 static int test_set_e2uuid_2 (void)
6116 {
6117   if (test_set_e2uuid_2_skip ()) {
6118     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
6119     return 0;
6120   }
6121
6122   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
6123   {
6124     char device[] = "/dev/sda";
6125     int r;
6126     suppress_error = 0;
6127     r = guestfs_blockdev_setrw (g, device);
6128     if (r == -1)
6129       return -1;
6130   }
6131   {
6132     int r;
6133     suppress_error = 0;
6134     r = guestfs_umount_all (g);
6135     if (r == -1)
6136       return -1;
6137   }
6138   {
6139     int r;
6140     suppress_error = 0;
6141     r = guestfs_lvm_remove_all (g);
6142     if (r == -1)
6143       return -1;
6144   }
6145   {
6146     char device[] = "/dev/sda";
6147     char lines_0[] = ",";
6148     char *lines[] = {
6149       lines_0,
6150       NULL
6151     };
6152     int r;
6153     suppress_error = 0;
6154     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6155     if (r == -1)
6156       return -1;
6157   }
6158   {
6159     char fstype[] = "ext2";
6160     char device[] = "/dev/sda1";
6161     int r;
6162     suppress_error = 0;
6163     r = guestfs_mkfs (g, fstype, device);
6164     if (r == -1)
6165       return -1;
6166   }
6167   {
6168     char device[] = "/dev/sda1";
6169     char mountpoint[] = "/";
6170     int r;
6171     suppress_error = 0;
6172     r = guestfs_mount (g, device, mountpoint);
6173     if (r == -1)
6174       return -1;
6175   }
6176   /* TestRun for set_e2uuid (2) */
6177   {
6178     char device[] = "/dev/sda1";
6179     char uuid[] = "random";
6180     int r;
6181     suppress_error = 0;
6182     r = guestfs_set_e2uuid (g, device, uuid);
6183     if (r == -1)
6184       return -1;
6185   }
6186   return 0;
6187 }
6188
6189 static int test_set_e2uuid_3_skip (void)
6190 {
6191   const char *str;
6192
6193   str = getenv ("TEST_ONLY");
6194   if (str)
6195     return strstr (str, "set_e2uuid") == NULL;
6196   str = getenv ("SKIP_TEST_SET_E2UUID_3");
6197   if (str && strcmp (str, "1") == 0) return 1;
6198   str = getenv ("SKIP_TEST_SET_E2UUID");
6199   if (str && strcmp (str, "1") == 0) return 1;
6200   return 0;
6201 }
6202
6203 static int test_set_e2uuid_3 (void)
6204 {
6205   if (test_set_e2uuid_3_skip ()) {
6206     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6207     return 0;
6208   }
6209
6210   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6211   {
6212     char device[] = "/dev/sda";
6213     int r;
6214     suppress_error = 0;
6215     r = guestfs_blockdev_setrw (g, device);
6216     if (r == -1)
6217       return -1;
6218   }
6219   {
6220     int r;
6221     suppress_error = 0;
6222     r = guestfs_umount_all (g);
6223     if (r == -1)
6224       return -1;
6225   }
6226   {
6227     int r;
6228     suppress_error = 0;
6229     r = guestfs_lvm_remove_all (g);
6230     if (r == -1)
6231       return -1;
6232   }
6233   {
6234     char device[] = "/dev/sda";
6235     char lines_0[] = ",";
6236     char *lines[] = {
6237       lines_0,
6238       NULL
6239     };
6240     int r;
6241     suppress_error = 0;
6242     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6243     if (r == -1)
6244       return -1;
6245   }
6246   {
6247     char fstype[] = "ext2";
6248     char device[] = "/dev/sda1";
6249     int r;
6250     suppress_error = 0;
6251     r = guestfs_mkfs (g, fstype, device);
6252     if (r == -1)
6253       return -1;
6254   }
6255   {
6256     char device[] = "/dev/sda1";
6257     char mountpoint[] = "/";
6258     int r;
6259     suppress_error = 0;
6260     r = guestfs_mount (g, device, mountpoint);
6261     if (r == -1)
6262       return -1;
6263   }
6264   /* TestRun for set_e2uuid (3) */
6265   {
6266     char device[] = "/dev/sda1";
6267     char uuid[] = "time";
6268     int r;
6269     suppress_error = 0;
6270     r = guestfs_set_e2uuid (g, device, uuid);
6271     if (r == -1)
6272       return -1;
6273   }
6274   return 0;
6275 }
6276
6277 static int test_set_e2label_0_skip (void)
6278 {
6279   const char *str;
6280
6281   str = getenv ("TEST_ONLY");
6282   if (str)
6283     return strstr (str, "set_e2label") == NULL;
6284   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6285   if (str && strcmp (str, "1") == 0) return 1;
6286   str = getenv ("SKIP_TEST_SET_E2LABEL");
6287   if (str && strcmp (str, "1") == 0) return 1;
6288   return 0;
6289 }
6290
6291 static int test_set_e2label_0 (void)
6292 {
6293   if (test_set_e2label_0_skip ()) {
6294     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6295     return 0;
6296   }
6297
6298   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6299   {
6300     char device[] = "/dev/sda";
6301     int r;
6302     suppress_error = 0;
6303     r = guestfs_blockdev_setrw (g, device);
6304     if (r == -1)
6305       return -1;
6306   }
6307   {
6308     int r;
6309     suppress_error = 0;
6310     r = guestfs_umount_all (g);
6311     if (r == -1)
6312       return -1;
6313   }
6314   {
6315     int r;
6316     suppress_error = 0;
6317     r = guestfs_lvm_remove_all (g);
6318     if (r == -1)
6319       return -1;
6320   }
6321   {
6322     char device[] = "/dev/sda";
6323     char lines_0[] = ",";
6324     char *lines[] = {
6325       lines_0,
6326       NULL
6327     };
6328     int r;
6329     suppress_error = 0;
6330     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6331     if (r == -1)
6332       return -1;
6333   }
6334   {
6335     char fstype[] = "ext2";
6336     char device[] = "/dev/sda1";
6337     int r;
6338     suppress_error = 0;
6339     r = guestfs_mkfs (g, fstype, device);
6340     if (r == -1)
6341       return -1;
6342   }
6343   {
6344     char device[] = "/dev/sda1";
6345     char mountpoint[] = "/";
6346     int r;
6347     suppress_error = 0;
6348     r = guestfs_mount (g, device, mountpoint);
6349     if (r == -1)
6350       return -1;
6351   }
6352   /* TestOutput for set_e2label (0) */
6353   char expected[] = "testlabel";
6354   {
6355     char device[] = "/dev/sda1";
6356     char label[] = "testlabel";
6357     int r;
6358     suppress_error = 0;
6359     r = guestfs_set_e2label (g, device, label);
6360     if (r == -1)
6361       return -1;
6362   }
6363   {
6364     char device[] = "/dev/sda1";
6365     char *r;
6366     suppress_error = 0;
6367     r = guestfs_get_e2label (g, device);
6368     if (r == NULL)
6369       return -1;
6370     if (strcmp (r, expected) != 0) {
6371       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6372       return -1;
6373     }
6374     free (r);
6375   }
6376   return 0;
6377 }
6378
6379 static int test_pvremove_0_skip (void)
6380 {
6381   const char *str;
6382
6383   str = getenv ("TEST_ONLY");
6384   if (str)
6385     return strstr (str, "pvremove") == NULL;
6386   str = getenv ("SKIP_TEST_PVREMOVE_0");
6387   if (str && strcmp (str, "1") == 0) return 1;
6388   str = getenv ("SKIP_TEST_PVREMOVE");
6389   if (str && strcmp (str, "1") == 0) return 1;
6390   return 0;
6391 }
6392
6393 static int test_pvremove_0 (void)
6394 {
6395   if (test_pvremove_0_skip ()) {
6396     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6397     return 0;
6398   }
6399
6400   /* InitNone|InitEmpty for test_pvremove_0 */
6401   {
6402     char device[] = "/dev/sda";
6403     int r;
6404     suppress_error = 0;
6405     r = guestfs_blockdev_setrw (g, device);
6406     if (r == -1)
6407       return -1;
6408   }
6409   {
6410     int r;
6411     suppress_error = 0;
6412     r = guestfs_umount_all (g);
6413     if (r == -1)
6414       return -1;
6415   }
6416   {
6417     int r;
6418     suppress_error = 0;
6419     r = guestfs_lvm_remove_all (g);
6420     if (r == -1)
6421       return -1;
6422   }
6423   /* TestOutputListOfDevices for pvremove (0) */
6424   {
6425     char device[] = "/dev/sda";
6426     char lines_0[] = ",";
6427     char *lines[] = {
6428       lines_0,
6429       NULL
6430     };
6431     int r;
6432     suppress_error = 0;
6433     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6434     if (r == -1)
6435       return -1;
6436   }
6437   {
6438     char device[] = "/dev/sda1";
6439     int r;
6440     suppress_error = 0;
6441     r = guestfs_pvcreate (g, device);
6442     if (r == -1)
6443       return -1;
6444   }
6445   {
6446     char volgroup[] = "VG";
6447     char physvols_0[] = "/dev/sda1";
6448     char *physvols[] = {
6449       physvols_0,
6450       NULL
6451     };
6452     int r;
6453     suppress_error = 0;
6454     r = guestfs_vgcreate (g, volgroup, physvols);
6455     if (r == -1)
6456       return -1;
6457   }
6458   {
6459     char logvol[] = "LV1";
6460     char volgroup[] = "VG";
6461     int r;
6462     suppress_error = 0;
6463     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6464     if (r == -1)
6465       return -1;
6466   }
6467   {
6468     char logvol[] = "LV2";
6469     char volgroup[] = "VG";
6470     int r;
6471     suppress_error = 0;
6472     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6473     if (r == -1)
6474       return -1;
6475   }
6476   {
6477     char vgname[] = "VG";
6478     int r;
6479     suppress_error = 0;
6480     r = guestfs_vgremove (g, vgname);
6481     if (r == -1)
6482       return -1;
6483   }
6484   {
6485     char device[] = "/dev/sda1";
6486     int r;
6487     suppress_error = 0;
6488     r = guestfs_pvremove (g, device);
6489     if (r == -1)
6490       return -1;
6491   }
6492   {
6493     char **r;
6494     int i;
6495     suppress_error = 0;
6496     r = guestfs_lvs (g);
6497     if (r == NULL)
6498       return -1;
6499     if (r[0] != NULL) {
6500       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6501       print_strings (r);
6502       return -1;
6503     }
6504     for (i = 0; r[i] != NULL; ++i)
6505       free (r[i]);
6506     free (r);
6507   }
6508   return 0;
6509 }
6510
6511 static int test_pvremove_1_skip (void)
6512 {
6513   const char *str;
6514
6515   str = getenv ("TEST_ONLY");
6516   if (str)
6517     return strstr (str, "pvremove") == NULL;
6518   str = getenv ("SKIP_TEST_PVREMOVE_1");
6519   if (str && strcmp (str, "1") == 0) return 1;
6520   str = getenv ("SKIP_TEST_PVREMOVE");
6521   if (str && strcmp (str, "1") == 0) return 1;
6522   return 0;
6523 }
6524
6525 static int test_pvremove_1 (void)
6526 {
6527   if (test_pvremove_1_skip ()) {
6528     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6529     return 0;
6530   }
6531
6532   /* InitNone|InitEmpty for test_pvremove_1 */
6533   {
6534     char device[] = "/dev/sda";
6535     int r;
6536     suppress_error = 0;
6537     r = guestfs_blockdev_setrw (g, device);
6538     if (r == -1)
6539       return -1;
6540   }
6541   {
6542     int r;
6543     suppress_error = 0;
6544     r = guestfs_umount_all (g);
6545     if (r == -1)
6546       return -1;
6547   }
6548   {
6549     int r;
6550     suppress_error = 0;
6551     r = guestfs_lvm_remove_all (g);
6552     if (r == -1)
6553       return -1;
6554   }
6555   /* TestOutputListOfDevices for pvremove (1) */
6556   {
6557     char device[] = "/dev/sda";
6558     char lines_0[] = ",";
6559     char *lines[] = {
6560       lines_0,
6561       NULL
6562     };
6563     int r;
6564     suppress_error = 0;
6565     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6566     if (r == -1)
6567       return -1;
6568   }
6569   {
6570     char device[] = "/dev/sda1";
6571     int r;
6572     suppress_error = 0;
6573     r = guestfs_pvcreate (g, device);
6574     if (r == -1)
6575       return -1;
6576   }
6577   {
6578     char volgroup[] = "VG";
6579     char physvols_0[] = "/dev/sda1";
6580     char *physvols[] = {
6581       physvols_0,
6582       NULL
6583     };
6584     int r;
6585     suppress_error = 0;
6586     r = guestfs_vgcreate (g, volgroup, physvols);
6587     if (r == -1)
6588       return -1;
6589   }
6590   {
6591     char logvol[] = "LV1";
6592     char volgroup[] = "VG";
6593     int r;
6594     suppress_error = 0;
6595     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6596     if (r == -1)
6597       return -1;
6598   }
6599   {
6600     char logvol[] = "LV2";
6601     char volgroup[] = "VG";
6602     int r;
6603     suppress_error = 0;
6604     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6605     if (r == -1)
6606       return -1;
6607   }
6608   {
6609     char vgname[] = "VG";
6610     int r;
6611     suppress_error = 0;
6612     r = guestfs_vgremove (g, vgname);
6613     if (r == -1)
6614       return -1;
6615   }
6616   {
6617     char device[] = "/dev/sda1";
6618     int r;
6619     suppress_error = 0;
6620     r = guestfs_pvremove (g, device);
6621     if (r == -1)
6622       return -1;
6623   }
6624   {
6625     char **r;
6626     int i;
6627     suppress_error = 0;
6628     r = guestfs_vgs (g);
6629     if (r == NULL)
6630       return -1;
6631     if (r[0] != NULL) {
6632       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6633       print_strings (r);
6634       return -1;
6635     }
6636     for (i = 0; r[i] != NULL; ++i)
6637       free (r[i]);
6638     free (r);
6639   }
6640   return 0;
6641 }
6642
6643 static int test_pvremove_2_skip (void)
6644 {
6645   const char *str;
6646
6647   str = getenv ("TEST_ONLY");
6648   if (str)
6649     return strstr (str, "pvremove") == NULL;
6650   str = getenv ("SKIP_TEST_PVREMOVE_2");
6651   if (str && strcmp (str, "1") == 0) return 1;
6652   str = getenv ("SKIP_TEST_PVREMOVE");
6653   if (str && strcmp (str, "1") == 0) return 1;
6654   return 0;
6655 }
6656
6657 static int test_pvremove_2 (void)
6658 {
6659   if (test_pvremove_2_skip ()) {
6660     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6661     return 0;
6662   }
6663
6664   /* InitNone|InitEmpty for test_pvremove_2 */
6665   {
6666     char device[] = "/dev/sda";
6667     int r;
6668     suppress_error = 0;
6669     r = guestfs_blockdev_setrw (g, device);
6670     if (r == -1)
6671       return -1;
6672   }
6673   {
6674     int r;
6675     suppress_error = 0;
6676     r = guestfs_umount_all (g);
6677     if (r == -1)
6678       return -1;
6679   }
6680   {
6681     int r;
6682     suppress_error = 0;
6683     r = guestfs_lvm_remove_all (g);
6684     if (r == -1)
6685       return -1;
6686   }
6687   /* TestOutputListOfDevices for pvremove (2) */
6688   {
6689     char device[] = "/dev/sda";
6690     char lines_0[] = ",";
6691     char *lines[] = {
6692       lines_0,
6693       NULL
6694     };
6695     int r;
6696     suppress_error = 0;
6697     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6698     if (r == -1)
6699       return -1;
6700   }
6701   {
6702     char device[] = "/dev/sda1";
6703     int r;
6704     suppress_error = 0;
6705     r = guestfs_pvcreate (g, device);
6706     if (r == -1)
6707       return -1;
6708   }
6709   {
6710     char volgroup[] = "VG";
6711     char physvols_0[] = "/dev/sda1";
6712     char *physvols[] = {
6713       physvols_0,
6714       NULL
6715     };
6716     int r;
6717     suppress_error = 0;
6718     r = guestfs_vgcreate (g, volgroup, physvols);
6719     if (r == -1)
6720       return -1;
6721   }
6722   {
6723     char logvol[] = "LV1";
6724     char volgroup[] = "VG";
6725     int r;
6726     suppress_error = 0;
6727     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6728     if (r == -1)
6729       return -1;
6730   }
6731   {
6732     char logvol[] = "LV2";
6733     char volgroup[] = "VG";
6734     int r;
6735     suppress_error = 0;
6736     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6737     if (r == -1)
6738       return -1;
6739   }
6740   {
6741     char vgname[] = "VG";
6742     int r;
6743     suppress_error = 0;
6744     r = guestfs_vgremove (g, vgname);
6745     if (r == -1)
6746       return -1;
6747   }
6748   {
6749     char device[] = "/dev/sda1";
6750     int r;
6751     suppress_error = 0;
6752     r = guestfs_pvremove (g, device);
6753     if (r == -1)
6754       return -1;
6755   }
6756   {
6757     char **r;
6758     int i;
6759     suppress_error = 0;
6760     r = guestfs_pvs (g);
6761     if (r == NULL)
6762       return -1;
6763     if (r[0] != NULL) {
6764       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6765       print_strings (r);
6766       return -1;
6767     }
6768     for (i = 0; r[i] != NULL; ++i)
6769       free (r[i]);
6770     free (r);
6771   }
6772   return 0;
6773 }
6774
6775 static int test_vgremove_0_skip (void)
6776 {
6777   const char *str;
6778
6779   str = getenv ("TEST_ONLY");
6780   if (str)
6781     return strstr (str, "vgremove") == NULL;
6782   str = getenv ("SKIP_TEST_VGREMOVE_0");
6783   if (str && strcmp (str, "1") == 0) return 1;
6784   str = getenv ("SKIP_TEST_VGREMOVE");
6785   if (str && strcmp (str, "1") == 0) return 1;
6786   return 0;
6787 }
6788
6789 static int test_vgremove_0 (void)
6790 {
6791   if (test_vgremove_0_skip ()) {
6792     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6793     return 0;
6794   }
6795
6796   /* InitNone|InitEmpty for test_vgremove_0 */
6797   {
6798     char device[] = "/dev/sda";
6799     int r;
6800     suppress_error = 0;
6801     r = guestfs_blockdev_setrw (g, device);
6802     if (r == -1)
6803       return -1;
6804   }
6805   {
6806     int r;
6807     suppress_error = 0;
6808     r = guestfs_umount_all (g);
6809     if (r == -1)
6810       return -1;
6811   }
6812   {
6813     int r;
6814     suppress_error = 0;
6815     r = guestfs_lvm_remove_all (g);
6816     if (r == -1)
6817       return -1;
6818   }
6819   /* TestOutputList for vgremove (0) */
6820   {
6821     char device[] = "/dev/sda";
6822     char lines_0[] = ",";
6823     char *lines[] = {
6824       lines_0,
6825       NULL
6826     };
6827     int r;
6828     suppress_error = 0;
6829     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6830     if (r == -1)
6831       return -1;
6832   }
6833   {
6834     char device[] = "/dev/sda1";
6835     int r;
6836     suppress_error = 0;
6837     r = guestfs_pvcreate (g, device);
6838     if (r == -1)
6839       return -1;
6840   }
6841   {
6842     char volgroup[] = "VG";
6843     char physvols_0[] = "/dev/sda1";
6844     char *physvols[] = {
6845       physvols_0,
6846       NULL
6847     };
6848     int r;
6849     suppress_error = 0;
6850     r = guestfs_vgcreate (g, volgroup, physvols);
6851     if (r == -1)
6852       return -1;
6853   }
6854   {
6855     char logvol[] = "LV1";
6856     char volgroup[] = "VG";
6857     int r;
6858     suppress_error = 0;
6859     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6860     if (r == -1)
6861       return -1;
6862   }
6863   {
6864     char logvol[] = "LV2";
6865     char volgroup[] = "VG";
6866     int r;
6867     suppress_error = 0;
6868     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6869     if (r == -1)
6870       return -1;
6871   }
6872   {
6873     char vgname[] = "VG";
6874     int r;
6875     suppress_error = 0;
6876     r = guestfs_vgremove (g, vgname);
6877     if (r == -1)
6878       return -1;
6879   }
6880   {
6881     char **r;
6882     int i;
6883     suppress_error = 0;
6884     r = guestfs_lvs (g);
6885     if (r == NULL)
6886       return -1;
6887     if (r[0] != NULL) {
6888       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6889       print_strings (r);
6890       return -1;
6891     }
6892     for (i = 0; r[i] != NULL; ++i)
6893       free (r[i]);
6894     free (r);
6895   }
6896   return 0;
6897 }
6898
6899 static int test_vgremove_1_skip (void)
6900 {
6901   const char *str;
6902
6903   str = getenv ("TEST_ONLY");
6904   if (str)
6905     return strstr (str, "vgremove") == NULL;
6906   str = getenv ("SKIP_TEST_VGREMOVE_1");
6907   if (str && strcmp (str, "1") == 0) return 1;
6908   str = getenv ("SKIP_TEST_VGREMOVE");
6909   if (str && strcmp (str, "1") == 0) return 1;
6910   return 0;
6911 }
6912
6913 static int test_vgremove_1 (void)
6914 {
6915   if (test_vgremove_1_skip ()) {
6916     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6917     return 0;
6918   }
6919
6920   /* InitNone|InitEmpty for test_vgremove_1 */
6921   {
6922     char device[] = "/dev/sda";
6923     int r;
6924     suppress_error = 0;
6925     r = guestfs_blockdev_setrw (g, device);
6926     if (r == -1)
6927       return -1;
6928   }
6929   {
6930     int r;
6931     suppress_error = 0;
6932     r = guestfs_umount_all (g);
6933     if (r == -1)
6934       return -1;
6935   }
6936   {
6937     int r;
6938     suppress_error = 0;
6939     r = guestfs_lvm_remove_all (g);
6940     if (r == -1)
6941       return -1;
6942   }
6943   /* TestOutputList for vgremove (1) */
6944   {
6945     char device[] = "/dev/sda";
6946     char lines_0[] = ",";
6947     char *lines[] = {
6948       lines_0,
6949       NULL
6950     };
6951     int r;
6952     suppress_error = 0;
6953     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6954     if (r == -1)
6955       return -1;
6956   }
6957   {
6958     char device[] = "/dev/sda1";
6959     int r;
6960     suppress_error = 0;
6961     r = guestfs_pvcreate (g, device);
6962     if (r == -1)
6963       return -1;
6964   }
6965   {
6966     char volgroup[] = "VG";
6967     char physvols_0[] = "/dev/sda1";
6968     char *physvols[] = {
6969       physvols_0,
6970       NULL
6971     };
6972     int r;
6973     suppress_error = 0;
6974     r = guestfs_vgcreate (g, volgroup, physvols);
6975     if (r == -1)
6976       return -1;
6977   }
6978   {
6979     char logvol[] = "LV1";
6980     char volgroup[] = "VG";
6981     int r;
6982     suppress_error = 0;
6983     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6984     if (r == -1)
6985       return -1;
6986   }
6987   {
6988     char logvol[] = "LV2";
6989     char volgroup[] = "VG";
6990     int r;
6991     suppress_error = 0;
6992     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6993     if (r == -1)
6994       return -1;
6995   }
6996   {
6997     char vgname[] = "VG";
6998     int r;
6999     suppress_error = 0;
7000     r = guestfs_vgremove (g, vgname);
7001     if (r == -1)
7002       return -1;
7003   }
7004   {
7005     char **r;
7006     int i;
7007     suppress_error = 0;
7008     r = guestfs_vgs (g);
7009     if (r == NULL)
7010       return -1;
7011     if (r[0] != NULL) {
7012       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
7013       print_strings (r);
7014       return -1;
7015     }
7016     for (i = 0; r[i] != NULL; ++i)
7017       free (r[i]);
7018     free (r);
7019   }
7020   return 0;
7021 }
7022
7023 static int test_lvremove_0_skip (void)
7024 {
7025   const char *str;
7026
7027   str = getenv ("TEST_ONLY");
7028   if (str)
7029     return strstr (str, "lvremove") == NULL;
7030   str = getenv ("SKIP_TEST_LVREMOVE_0");
7031   if (str && strcmp (str, "1") == 0) return 1;
7032   str = getenv ("SKIP_TEST_LVREMOVE");
7033   if (str && strcmp (str, "1") == 0) return 1;
7034   return 0;
7035 }
7036
7037 static int test_lvremove_0 (void)
7038 {
7039   if (test_lvremove_0_skip ()) {
7040     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
7041     return 0;
7042   }
7043
7044   /* InitNone|InitEmpty for test_lvremove_0 */
7045   {
7046     char device[] = "/dev/sda";
7047     int r;
7048     suppress_error = 0;
7049     r = guestfs_blockdev_setrw (g, device);
7050     if (r == -1)
7051       return -1;
7052   }
7053   {
7054     int r;
7055     suppress_error = 0;
7056     r = guestfs_umount_all (g);
7057     if (r == -1)
7058       return -1;
7059   }
7060   {
7061     int r;
7062     suppress_error = 0;
7063     r = guestfs_lvm_remove_all (g);
7064     if (r == -1)
7065       return -1;
7066   }
7067   /* TestOutputList for lvremove (0) */
7068   {
7069     char device[] = "/dev/sda";
7070     char lines_0[] = ",";
7071     char *lines[] = {
7072       lines_0,
7073       NULL
7074     };
7075     int r;
7076     suppress_error = 0;
7077     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7078     if (r == -1)
7079       return -1;
7080   }
7081   {
7082     char device[] = "/dev/sda1";
7083     int r;
7084     suppress_error = 0;
7085     r = guestfs_pvcreate (g, device);
7086     if (r == -1)
7087       return -1;
7088   }
7089   {
7090     char volgroup[] = "VG";
7091     char physvols_0[] = "/dev/sda1";
7092     char *physvols[] = {
7093       physvols_0,
7094       NULL
7095     };
7096     int r;
7097     suppress_error = 0;
7098     r = guestfs_vgcreate (g, volgroup, physvols);
7099     if (r == -1)
7100       return -1;
7101   }
7102   {
7103     char logvol[] = "LV1";
7104     char volgroup[] = "VG";
7105     int r;
7106     suppress_error = 0;
7107     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7108     if (r == -1)
7109       return -1;
7110   }
7111   {
7112     char logvol[] = "LV2";
7113     char volgroup[] = "VG";
7114     int r;
7115     suppress_error = 0;
7116     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7117     if (r == -1)
7118       return -1;
7119   }
7120   {
7121     char device[] = "/dev/VG/LV1";
7122     int r;
7123     suppress_error = 0;
7124     r = guestfs_lvremove (g, device);
7125     if (r == -1)
7126       return -1;
7127   }
7128   {
7129     char **r;
7130     int i;
7131     suppress_error = 0;
7132     r = guestfs_lvs (g);
7133     if (r == NULL)
7134       return -1;
7135     if (!r[0]) {
7136       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
7137       print_strings (r);
7138       return -1;
7139     }
7140     {
7141       char expected[] = "/dev/VG/LV2";
7142       if (strcmp (r[0], expected) != 0) {
7143         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7144         return -1;
7145       }
7146     }
7147     if (r[1] != NULL) {
7148       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
7149       print_strings (r);
7150       return -1;
7151     }
7152     for (i = 0; r[i] != NULL; ++i)
7153       free (r[i]);
7154     free (r);
7155   }
7156   return 0;
7157 }
7158
7159 static int test_lvremove_1_skip (void)
7160 {
7161   const char *str;
7162
7163   str = getenv ("TEST_ONLY");
7164   if (str)
7165     return strstr (str, "lvremove") == NULL;
7166   str = getenv ("SKIP_TEST_LVREMOVE_1");
7167   if (str && strcmp (str, "1") == 0) return 1;
7168   str = getenv ("SKIP_TEST_LVREMOVE");
7169   if (str && strcmp (str, "1") == 0) return 1;
7170   return 0;
7171 }
7172
7173 static int test_lvremove_1 (void)
7174 {
7175   if (test_lvremove_1_skip ()) {
7176     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
7177     return 0;
7178   }
7179
7180   /* InitNone|InitEmpty for test_lvremove_1 */
7181   {
7182     char device[] = "/dev/sda";
7183     int r;
7184     suppress_error = 0;
7185     r = guestfs_blockdev_setrw (g, device);
7186     if (r == -1)
7187       return -1;
7188   }
7189   {
7190     int r;
7191     suppress_error = 0;
7192     r = guestfs_umount_all (g);
7193     if (r == -1)
7194       return -1;
7195   }
7196   {
7197     int r;
7198     suppress_error = 0;
7199     r = guestfs_lvm_remove_all (g);
7200     if (r == -1)
7201       return -1;
7202   }
7203   /* TestOutputList for lvremove (1) */
7204   {
7205     char device[] = "/dev/sda";
7206     char lines_0[] = ",";
7207     char *lines[] = {
7208       lines_0,
7209       NULL
7210     };
7211     int r;
7212     suppress_error = 0;
7213     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7214     if (r == -1)
7215       return -1;
7216   }
7217   {
7218     char device[] = "/dev/sda1";
7219     int r;
7220     suppress_error = 0;
7221     r = guestfs_pvcreate (g, device);
7222     if (r == -1)
7223       return -1;
7224   }
7225   {
7226     char volgroup[] = "VG";
7227     char physvols_0[] = "/dev/sda1";
7228     char *physvols[] = {
7229       physvols_0,
7230       NULL
7231     };
7232     int r;
7233     suppress_error = 0;
7234     r = guestfs_vgcreate (g, volgroup, physvols);
7235     if (r == -1)
7236       return -1;
7237   }
7238   {
7239     char logvol[] = "LV1";
7240     char volgroup[] = "VG";
7241     int r;
7242     suppress_error = 0;
7243     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7244     if (r == -1)
7245       return -1;
7246   }
7247   {
7248     char logvol[] = "LV2";
7249     char volgroup[] = "VG";
7250     int r;
7251     suppress_error = 0;
7252     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7253     if (r == -1)
7254       return -1;
7255   }
7256   {
7257     char device[] = "/dev/VG";
7258     int r;
7259     suppress_error = 0;
7260     r = guestfs_lvremove (g, device);
7261     if (r == -1)
7262       return -1;
7263   }
7264   {
7265     char **r;
7266     int i;
7267     suppress_error = 0;
7268     r = guestfs_lvs (g);
7269     if (r == NULL)
7270       return -1;
7271     if (r[0] != NULL) {
7272       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7273       print_strings (r);
7274       return -1;
7275     }
7276     for (i = 0; r[i] != NULL; ++i)
7277       free (r[i]);
7278     free (r);
7279   }
7280   return 0;
7281 }
7282
7283 static int test_lvremove_2_skip (void)
7284 {
7285   const char *str;
7286
7287   str = getenv ("TEST_ONLY");
7288   if (str)
7289     return strstr (str, "lvremove") == NULL;
7290   str = getenv ("SKIP_TEST_LVREMOVE_2");
7291   if (str && strcmp (str, "1") == 0) return 1;
7292   str = getenv ("SKIP_TEST_LVREMOVE");
7293   if (str && strcmp (str, "1") == 0) return 1;
7294   return 0;
7295 }
7296
7297 static int test_lvremove_2 (void)
7298 {
7299   if (test_lvremove_2_skip ()) {
7300     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
7301     return 0;
7302   }
7303
7304   /* InitNone|InitEmpty for test_lvremove_2 */
7305   {
7306     char device[] = "/dev/sda";
7307     int r;
7308     suppress_error = 0;
7309     r = guestfs_blockdev_setrw (g, device);
7310     if (r == -1)
7311       return -1;
7312   }
7313   {
7314     int r;
7315     suppress_error = 0;
7316     r = guestfs_umount_all (g);
7317     if (r == -1)
7318       return -1;
7319   }
7320   {
7321     int r;
7322     suppress_error = 0;
7323     r = guestfs_lvm_remove_all (g);
7324     if (r == -1)
7325       return -1;
7326   }
7327   /* TestOutputList for lvremove (2) */
7328   {
7329     char device[] = "/dev/sda";
7330     char lines_0[] = ",";
7331     char *lines[] = {
7332       lines_0,
7333       NULL
7334     };
7335     int r;
7336     suppress_error = 0;
7337     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7338     if (r == -1)
7339       return -1;
7340   }
7341   {
7342     char device[] = "/dev/sda1";
7343     int r;
7344     suppress_error = 0;
7345     r = guestfs_pvcreate (g, device);
7346     if (r == -1)
7347       return -1;
7348   }
7349   {
7350     char volgroup[] = "VG";
7351     char physvols_0[] = "/dev/sda1";
7352     char *physvols[] = {
7353       physvols_0,
7354       NULL
7355     };
7356     int r;
7357     suppress_error = 0;
7358     r = guestfs_vgcreate (g, volgroup, physvols);
7359     if (r == -1)
7360       return -1;
7361   }
7362   {
7363     char logvol[] = "LV1";
7364     char volgroup[] = "VG";
7365     int r;
7366     suppress_error = 0;
7367     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7368     if (r == -1)
7369       return -1;
7370   }
7371   {
7372     char logvol[] = "LV2";
7373     char volgroup[] = "VG";
7374     int r;
7375     suppress_error = 0;
7376     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7377     if (r == -1)
7378       return -1;
7379   }
7380   {
7381     char device[] = "/dev/VG";
7382     int r;
7383     suppress_error = 0;
7384     r = guestfs_lvremove (g, device);
7385     if (r == -1)
7386       return -1;
7387   }
7388   {
7389     char **r;
7390     int i;
7391     suppress_error = 0;
7392     r = guestfs_vgs (g);
7393     if (r == NULL)
7394       return -1;
7395     if (!r[0]) {
7396       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7397       print_strings (r);
7398       return -1;
7399     }
7400     {
7401       char expected[] = "VG";
7402       if (strcmp (r[0], expected) != 0) {
7403         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7404         return -1;
7405       }
7406     }
7407     if (r[1] != NULL) {
7408       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7409       print_strings (r);
7410       return -1;
7411     }
7412     for (i = 0; r[i] != NULL; ++i)
7413       free (r[i]);
7414     free (r);
7415   }
7416   return 0;
7417 }
7418
7419 static int test_mount_ro_0_skip (void)
7420 {
7421   const char *str;
7422
7423   str = getenv ("TEST_ONLY");
7424   if (str)
7425     return strstr (str, "mount_ro") == NULL;
7426   str = getenv ("SKIP_TEST_MOUNT_RO_0");
7427   if (str && strcmp (str, "1") == 0) return 1;
7428   str = getenv ("SKIP_TEST_MOUNT_RO");
7429   if (str && strcmp (str, "1") == 0) return 1;
7430   return 0;
7431 }
7432
7433 static int test_mount_ro_0 (void)
7434 {
7435   if (test_mount_ro_0_skip ()) {
7436     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7437     return 0;
7438   }
7439
7440   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7441   {
7442     char device[] = "/dev/sda";
7443     int r;
7444     suppress_error = 0;
7445     r = guestfs_blockdev_setrw (g, device);
7446     if (r == -1)
7447       return -1;
7448   }
7449   {
7450     int r;
7451     suppress_error = 0;
7452     r = guestfs_umount_all (g);
7453     if (r == -1)
7454       return -1;
7455   }
7456   {
7457     int r;
7458     suppress_error = 0;
7459     r = guestfs_lvm_remove_all (g);
7460     if (r == -1)
7461       return -1;
7462   }
7463   {
7464     char device[] = "/dev/sda";
7465     char lines_0[] = ",";
7466     char *lines[] = {
7467       lines_0,
7468       NULL
7469     };
7470     int r;
7471     suppress_error = 0;
7472     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7473     if (r == -1)
7474       return -1;
7475   }
7476   {
7477     char fstype[] = "ext2";
7478     char device[] = "/dev/sda1";
7479     int r;
7480     suppress_error = 0;
7481     r = guestfs_mkfs (g, fstype, device);
7482     if (r == -1)
7483       return -1;
7484   }
7485   {
7486     char device[] = "/dev/sda1";
7487     char mountpoint[] = "/";
7488     int r;
7489     suppress_error = 0;
7490     r = guestfs_mount (g, device, mountpoint);
7491     if (r == -1)
7492       return -1;
7493   }
7494   /* TestLastFail for mount_ro (0) */
7495   {
7496     char pathordevice[] = "/";
7497     int r;
7498     suppress_error = 0;
7499     r = guestfs_umount (g, pathordevice);
7500     if (r == -1)
7501       return -1;
7502   }
7503   {
7504     char device[] = "/dev/sda1";
7505     char mountpoint[] = "/";
7506     int r;
7507     suppress_error = 0;
7508     r = guestfs_mount_ro (g, device, mountpoint);
7509     if (r == -1)
7510       return -1;
7511   }
7512   {
7513     char path[] = "/new";
7514     int r;
7515     suppress_error = 1;
7516     r = guestfs_touch (g, path);
7517     if (r != -1)
7518       return -1;
7519   }
7520   return 0;
7521 }
7522
7523 static int test_mount_ro_1_skip (void)
7524 {
7525   const char *str;
7526
7527   str = getenv ("TEST_ONLY");
7528   if (str)
7529     return strstr (str, "mount_ro") == NULL;
7530   str = getenv ("SKIP_TEST_MOUNT_RO_1");
7531   if (str && strcmp (str, "1") == 0) return 1;
7532   str = getenv ("SKIP_TEST_MOUNT_RO");
7533   if (str && strcmp (str, "1") == 0) return 1;
7534   return 0;
7535 }
7536
7537 static int test_mount_ro_1 (void)
7538 {
7539   if (test_mount_ro_1_skip ()) {
7540     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7541     return 0;
7542   }
7543
7544   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7545   {
7546     char device[] = "/dev/sda";
7547     int r;
7548     suppress_error = 0;
7549     r = guestfs_blockdev_setrw (g, device);
7550     if (r == -1)
7551       return -1;
7552   }
7553   {
7554     int r;
7555     suppress_error = 0;
7556     r = guestfs_umount_all (g);
7557     if (r == -1)
7558       return -1;
7559   }
7560   {
7561     int r;
7562     suppress_error = 0;
7563     r = guestfs_lvm_remove_all (g);
7564     if (r == -1)
7565       return -1;
7566   }
7567   {
7568     char device[] = "/dev/sda";
7569     char lines_0[] = ",";
7570     char *lines[] = {
7571       lines_0,
7572       NULL
7573     };
7574     int r;
7575     suppress_error = 0;
7576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7577     if (r == -1)
7578       return -1;
7579   }
7580   {
7581     char fstype[] = "ext2";
7582     char device[] = "/dev/sda1";
7583     int r;
7584     suppress_error = 0;
7585     r = guestfs_mkfs (g, fstype, device);
7586     if (r == -1)
7587       return -1;
7588   }
7589   {
7590     char device[] = "/dev/sda1";
7591     char mountpoint[] = "/";
7592     int r;
7593     suppress_error = 0;
7594     r = guestfs_mount (g, device, mountpoint);
7595     if (r == -1)
7596       return -1;
7597   }
7598   /* TestOutput for mount_ro (1) */
7599   char expected[] = "data";
7600   {
7601     char path[] = "/new";
7602     char content[] = "data";
7603     int r;
7604     suppress_error = 0;
7605     r = guestfs_write_file (g, path, content, 0);
7606     if (r == -1)
7607       return -1;
7608   }
7609   {
7610     char pathordevice[] = "/";
7611     int r;
7612     suppress_error = 0;
7613     r = guestfs_umount (g, pathordevice);
7614     if (r == -1)
7615       return -1;
7616   }
7617   {
7618     char device[] = "/dev/sda1";
7619     char mountpoint[] = "/";
7620     int r;
7621     suppress_error = 0;
7622     r = guestfs_mount_ro (g, device, mountpoint);
7623     if (r == -1)
7624       return -1;
7625   }
7626   {
7627     char path[] = "/new";
7628     char *r;
7629     suppress_error = 0;
7630     r = guestfs_cat (g, path);
7631     if (r == NULL)
7632       return -1;
7633     if (strcmp (r, expected) != 0) {
7634       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7635       return -1;
7636     }
7637     free (r);
7638   }
7639   return 0;
7640 }
7641
7642 static int test_tgz_in_0_skip (void)
7643 {
7644   const char *str;
7645
7646   str = getenv ("TEST_ONLY");
7647   if (str)
7648     return strstr (str, "tgz_in") == NULL;
7649   str = getenv ("SKIP_TEST_TGZ_IN_0");
7650   if (str && strcmp (str, "1") == 0) return 1;
7651   str = getenv ("SKIP_TEST_TGZ_IN");
7652   if (str && strcmp (str, "1") == 0) return 1;
7653   return 0;
7654 }
7655
7656 static int test_tgz_in_0 (void)
7657 {
7658   if (test_tgz_in_0_skip ()) {
7659     printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7660     return 0;
7661   }
7662
7663   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7664   {
7665     char device[] = "/dev/sda";
7666     int r;
7667     suppress_error = 0;
7668     r = guestfs_blockdev_setrw (g, device);
7669     if (r == -1)
7670       return -1;
7671   }
7672   {
7673     int r;
7674     suppress_error = 0;
7675     r = guestfs_umount_all (g);
7676     if (r == -1)
7677       return -1;
7678   }
7679   {
7680     int r;
7681     suppress_error = 0;
7682     r = guestfs_lvm_remove_all (g);
7683     if (r == -1)
7684       return -1;
7685   }
7686   {
7687     char device[] = "/dev/sda";
7688     char lines_0[] = ",";
7689     char *lines[] = {
7690       lines_0,
7691       NULL
7692     };
7693     int r;
7694     suppress_error = 0;
7695     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7696     if (r == -1)
7697       return -1;
7698   }
7699   {
7700     char fstype[] = "ext2";
7701     char device[] = "/dev/sda1";
7702     int r;
7703     suppress_error = 0;
7704     r = guestfs_mkfs (g, fstype, device);
7705     if (r == -1)
7706       return -1;
7707   }
7708   {
7709     char device[] = "/dev/sda1";
7710     char mountpoint[] = "/";
7711     int r;
7712     suppress_error = 0;
7713     r = guestfs_mount (g, device, mountpoint);
7714     if (r == -1)
7715       return -1;
7716   }
7717   /* TestOutput for tgz_in (0) */
7718   char expected[] = "hello\n";
7719   {
7720     char directory[] = "/";
7721     int r;
7722     suppress_error = 0;
7723     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7724     if (r == -1)
7725       return -1;
7726   }
7727   {
7728     char path[] = "/hello";
7729     char *r;
7730     suppress_error = 0;
7731     r = guestfs_cat (g, path);
7732     if (r == NULL)
7733       return -1;
7734     if (strcmp (r, expected) != 0) {
7735       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7736       return -1;
7737     }
7738     free (r);
7739   }
7740   return 0;
7741 }
7742
7743 static int test_tar_in_0_skip (void)
7744 {
7745   const char *str;
7746
7747   str = getenv ("TEST_ONLY");
7748   if (str)
7749     return strstr (str, "tar_in") == NULL;
7750   str = getenv ("SKIP_TEST_TAR_IN_0");
7751   if (str && strcmp (str, "1") == 0) return 1;
7752   str = getenv ("SKIP_TEST_TAR_IN");
7753   if (str && strcmp (str, "1") == 0) return 1;
7754   return 0;
7755 }
7756
7757 static int test_tar_in_0 (void)
7758 {
7759   if (test_tar_in_0_skip ()) {
7760     printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7761     return 0;
7762   }
7763
7764   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7765   {
7766     char device[] = "/dev/sda";
7767     int r;
7768     suppress_error = 0;
7769     r = guestfs_blockdev_setrw (g, device);
7770     if (r == -1)
7771       return -1;
7772   }
7773   {
7774     int r;
7775     suppress_error = 0;
7776     r = guestfs_umount_all (g);
7777     if (r == -1)
7778       return -1;
7779   }
7780   {
7781     int r;
7782     suppress_error = 0;
7783     r = guestfs_lvm_remove_all (g);
7784     if (r == -1)
7785       return -1;
7786   }
7787   {
7788     char device[] = "/dev/sda";
7789     char lines_0[] = ",";
7790     char *lines[] = {
7791       lines_0,
7792       NULL
7793     };
7794     int r;
7795     suppress_error = 0;
7796     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7797     if (r == -1)
7798       return -1;
7799   }
7800   {
7801     char fstype[] = "ext2";
7802     char device[] = "/dev/sda1";
7803     int r;
7804     suppress_error = 0;
7805     r = guestfs_mkfs (g, fstype, device);
7806     if (r == -1)
7807       return -1;
7808   }
7809   {
7810     char device[] = "/dev/sda1";
7811     char mountpoint[] = "/";
7812     int r;
7813     suppress_error = 0;
7814     r = guestfs_mount (g, device, mountpoint);
7815     if (r == -1)
7816       return -1;
7817   }
7818   /* TestOutput for tar_in (0) */
7819   char expected[] = "hello\n";
7820   {
7821     char directory[] = "/";
7822     int r;
7823     suppress_error = 0;
7824     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7825     if (r == -1)
7826       return -1;
7827   }
7828   {
7829     char path[] = "/hello";
7830     char *r;
7831     suppress_error = 0;
7832     r = guestfs_cat (g, path);
7833     if (r == NULL)
7834       return -1;
7835     if (strcmp (r, expected) != 0) {
7836       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7837       return -1;
7838     }
7839     free (r);
7840   }
7841   return 0;
7842 }
7843
7844 static int test_checksum_0_skip (void)
7845 {
7846   const char *str;
7847
7848   str = getenv ("TEST_ONLY");
7849   if (str)
7850     return strstr (str, "checksum") == NULL;
7851   str = getenv ("SKIP_TEST_CHECKSUM_0");
7852   if (str && strcmp (str, "1") == 0) return 1;
7853   str = getenv ("SKIP_TEST_CHECKSUM");
7854   if (str && strcmp (str, "1") == 0) return 1;
7855   return 0;
7856 }
7857
7858 static int test_checksum_0 (void)
7859 {
7860   if (test_checksum_0_skip ()) {
7861     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7862     return 0;
7863   }
7864
7865   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7866   {
7867     char device[] = "/dev/sda";
7868     int r;
7869     suppress_error = 0;
7870     r = guestfs_blockdev_setrw (g, device);
7871     if (r == -1)
7872       return -1;
7873   }
7874   {
7875     int r;
7876     suppress_error = 0;
7877     r = guestfs_umount_all (g);
7878     if (r == -1)
7879       return -1;
7880   }
7881   {
7882     int r;
7883     suppress_error = 0;
7884     r = guestfs_lvm_remove_all (g);
7885     if (r == -1)
7886       return -1;
7887   }
7888   {
7889     char device[] = "/dev/sda";
7890     char lines_0[] = ",";
7891     char *lines[] = {
7892       lines_0,
7893       NULL
7894     };
7895     int r;
7896     suppress_error = 0;
7897     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7898     if (r == -1)
7899       return -1;
7900   }
7901   {
7902     char fstype[] = "ext2";
7903     char device[] = "/dev/sda1";
7904     int r;
7905     suppress_error = 0;
7906     r = guestfs_mkfs (g, fstype, device);
7907     if (r == -1)
7908       return -1;
7909   }
7910   {
7911     char device[] = "/dev/sda1";
7912     char mountpoint[] = "/";
7913     int r;
7914     suppress_error = 0;
7915     r = guestfs_mount (g, device, mountpoint);
7916     if (r == -1)
7917       return -1;
7918   }
7919   /* TestOutput for checksum (0) */
7920   char expected[] = "935282863";
7921   {
7922     char path[] = "/new";
7923     char content[] = "test\n";
7924     int r;
7925     suppress_error = 0;
7926     r = guestfs_write_file (g, path, content, 0);
7927     if (r == -1)
7928       return -1;
7929   }
7930   {
7931     char csumtype[] = "crc";
7932     char path[] = "/new";
7933     char *r;
7934     suppress_error = 0;
7935     r = guestfs_checksum (g, csumtype, path);
7936     if (r == NULL)
7937       return -1;
7938     if (strcmp (r, expected) != 0) {
7939       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7940       return -1;
7941     }
7942     free (r);
7943   }
7944   return 0;
7945 }
7946
7947 static int test_checksum_1_skip (void)
7948 {
7949   const char *str;
7950
7951   str = getenv ("TEST_ONLY");
7952   if (str)
7953     return strstr (str, "checksum") == NULL;
7954   str = getenv ("SKIP_TEST_CHECKSUM_1");
7955   if (str && strcmp (str, "1") == 0) return 1;
7956   str = getenv ("SKIP_TEST_CHECKSUM");
7957   if (str && strcmp (str, "1") == 0) return 1;
7958   return 0;
7959 }
7960
7961 static int test_checksum_1 (void)
7962 {
7963   if (test_checksum_1_skip ()) {
7964     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7965     return 0;
7966   }
7967
7968   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7969   {
7970     char device[] = "/dev/sda";
7971     int r;
7972     suppress_error = 0;
7973     r = guestfs_blockdev_setrw (g, device);
7974     if (r == -1)
7975       return -1;
7976   }
7977   {
7978     int r;
7979     suppress_error = 0;
7980     r = guestfs_umount_all (g);
7981     if (r == -1)
7982       return -1;
7983   }
7984   {
7985     int r;
7986     suppress_error = 0;
7987     r = guestfs_lvm_remove_all (g);
7988     if (r == -1)
7989       return -1;
7990   }
7991   {
7992     char device[] = "/dev/sda";
7993     char lines_0[] = ",";
7994     char *lines[] = {
7995       lines_0,
7996       NULL
7997     };
7998     int r;
7999     suppress_error = 0;
8000     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8001     if (r == -1)
8002       return -1;
8003   }
8004   {
8005     char fstype[] = "ext2";
8006     char device[] = "/dev/sda1";
8007     int r;
8008     suppress_error = 0;
8009     r = guestfs_mkfs (g, fstype, device);
8010     if (r == -1)
8011       return -1;
8012   }
8013   {
8014     char device[] = "/dev/sda1";
8015     char mountpoint[] = "/";
8016     int r;
8017     suppress_error = 0;
8018     r = guestfs_mount (g, device, mountpoint);
8019     if (r == -1)
8020       return -1;
8021   }
8022   /* TestLastFail for checksum (1) */
8023   {
8024     char csumtype[] = "crc";
8025     char path[] = "/new";
8026     char *r;
8027     suppress_error = 1;
8028     r = guestfs_checksum (g, csumtype, path);
8029     if (r != NULL)
8030       return -1;
8031     free (r);
8032   }
8033   return 0;
8034 }
8035
8036 static int test_checksum_2_skip (void)
8037 {
8038   const char *str;
8039
8040   str = getenv ("TEST_ONLY");
8041   if (str)
8042     return strstr (str, "checksum") == NULL;
8043   str = getenv ("SKIP_TEST_CHECKSUM_2");
8044   if (str && strcmp (str, "1") == 0) return 1;
8045   str = getenv ("SKIP_TEST_CHECKSUM");
8046   if (str && strcmp (str, "1") == 0) return 1;
8047   return 0;
8048 }
8049
8050 static int test_checksum_2 (void)
8051 {
8052   if (test_checksum_2_skip ()) {
8053     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
8054     return 0;
8055   }
8056
8057   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
8058   {
8059     char device[] = "/dev/sda";
8060     int r;
8061     suppress_error = 0;
8062     r = guestfs_blockdev_setrw (g, device);
8063     if (r == -1)
8064       return -1;
8065   }
8066   {
8067     int r;
8068     suppress_error = 0;
8069     r = guestfs_umount_all (g);
8070     if (r == -1)
8071       return -1;
8072   }
8073   {
8074     int r;
8075     suppress_error = 0;
8076     r = guestfs_lvm_remove_all (g);
8077     if (r == -1)
8078       return -1;
8079   }
8080   {
8081     char device[] = "/dev/sda";
8082     char lines_0[] = ",";
8083     char *lines[] = {
8084       lines_0,
8085       NULL
8086     };
8087     int r;
8088     suppress_error = 0;
8089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8090     if (r == -1)
8091       return -1;
8092   }
8093   {
8094     char fstype[] = "ext2";
8095     char device[] = "/dev/sda1";
8096     int r;
8097     suppress_error = 0;
8098     r = guestfs_mkfs (g, fstype, device);
8099     if (r == -1)
8100       return -1;
8101   }
8102   {
8103     char device[] = "/dev/sda1";
8104     char mountpoint[] = "/";
8105     int r;
8106     suppress_error = 0;
8107     r = guestfs_mount (g, device, mountpoint);
8108     if (r == -1)
8109       return -1;
8110   }
8111   /* TestOutput for checksum (2) */
8112   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
8113   {
8114     char path[] = "/new";
8115     char content[] = "test\n";
8116     int r;
8117     suppress_error = 0;
8118     r = guestfs_write_file (g, path, content, 0);
8119     if (r == -1)
8120       return -1;
8121   }
8122   {
8123     char csumtype[] = "md5";
8124     char path[] = "/new";
8125     char *r;
8126     suppress_error = 0;
8127     r = guestfs_checksum (g, csumtype, path);
8128     if (r == NULL)
8129       return -1;
8130     if (strcmp (r, expected) != 0) {
8131       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
8132       return -1;
8133     }
8134     free (r);
8135   }
8136   return 0;
8137 }
8138
8139 static int test_checksum_3_skip (void)
8140 {
8141   const char *str;
8142
8143   str = getenv ("TEST_ONLY");
8144   if (str)
8145     return strstr (str, "checksum") == NULL;
8146   str = getenv ("SKIP_TEST_CHECKSUM_3");
8147   if (str && strcmp (str, "1") == 0) return 1;
8148   str = getenv ("SKIP_TEST_CHECKSUM");
8149   if (str && strcmp (str, "1") == 0) return 1;
8150   return 0;
8151 }
8152
8153 static int test_checksum_3 (void)
8154 {
8155   if (test_checksum_3_skip ()) {
8156     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
8157     return 0;
8158   }
8159
8160   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
8161   {
8162     char device[] = "/dev/sda";
8163     int r;
8164     suppress_error = 0;
8165     r = guestfs_blockdev_setrw (g, device);
8166     if (r == -1)
8167       return -1;
8168   }
8169   {
8170     int r;
8171     suppress_error = 0;
8172     r = guestfs_umount_all (g);
8173     if (r == -1)
8174       return -1;
8175   }
8176   {
8177     int r;
8178     suppress_error = 0;
8179     r = guestfs_lvm_remove_all (g);
8180     if (r == -1)
8181       return -1;
8182   }
8183   {
8184     char device[] = "/dev/sda";
8185     char lines_0[] = ",";
8186     char *lines[] = {
8187       lines_0,
8188       NULL
8189     };
8190     int r;
8191     suppress_error = 0;
8192     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8193     if (r == -1)
8194       return -1;
8195   }
8196   {
8197     char fstype[] = "ext2";
8198     char device[] = "/dev/sda1";
8199     int r;
8200     suppress_error = 0;
8201     r = guestfs_mkfs (g, fstype, device);
8202     if (r == -1)
8203       return -1;
8204   }
8205   {
8206     char device[] = "/dev/sda1";
8207     char mountpoint[] = "/";
8208     int r;
8209     suppress_error = 0;
8210     r = guestfs_mount (g, device, mountpoint);
8211     if (r == -1)
8212       return -1;
8213   }
8214   /* TestOutput for checksum (3) */
8215   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8216   {
8217     char path[] = "/new";
8218     char content[] = "test\n";
8219     int r;
8220     suppress_error = 0;
8221     r = guestfs_write_file (g, path, content, 0);
8222     if (r == -1)
8223       return -1;
8224   }
8225   {
8226     char csumtype[] = "sha1";
8227     char path[] = "/new";
8228     char *r;
8229     suppress_error = 0;
8230     r = guestfs_checksum (g, csumtype, path);
8231     if (r == NULL)
8232       return -1;
8233     if (strcmp (r, expected) != 0) {
8234       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8235       return -1;
8236     }
8237     free (r);
8238   }
8239   return 0;
8240 }
8241
8242 static int test_checksum_4_skip (void)
8243 {
8244   const char *str;
8245
8246   str = getenv ("TEST_ONLY");
8247   if (str)
8248     return strstr (str, "checksum") == NULL;
8249   str = getenv ("SKIP_TEST_CHECKSUM_4");
8250   if (str && strcmp (str, "1") == 0) return 1;
8251   str = getenv ("SKIP_TEST_CHECKSUM");
8252   if (str && strcmp (str, "1") == 0) return 1;
8253   return 0;
8254 }
8255
8256 static int test_checksum_4 (void)
8257 {
8258   if (test_checksum_4_skip ()) {
8259     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
8260     return 0;
8261   }
8262
8263   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8264   {
8265     char device[] = "/dev/sda";
8266     int r;
8267     suppress_error = 0;
8268     r = guestfs_blockdev_setrw (g, device);
8269     if (r == -1)
8270       return -1;
8271   }
8272   {
8273     int r;
8274     suppress_error = 0;
8275     r = guestfs_umount_all (g);
8276     if (r == -1)
8277       return -1;
8278   }
8279   {
8280     int r;
8281     suppress_error = 0;
8282     r = guestfs_lvm_remove_all (g);
8283     if (r == -1)
8284       return -1;
8285   }
8286   {
8287     char device[] = "/dev/sda";
8288     char lines_0[] = ",";
8289     char *lines[] = {
8290       lines_0,
8291       NULL
8292     };
8293     int r;
8294     suppress_error = 0;
8295     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8296     if (r == -1)
8297       return -1;
8298   }
8299   {
8300     char fstype[] = "ext2";
8301     char device[] = "/dev/sda1";
8302     int r;
8303     suppress_error = 0;
8304     r = guestfs_mkfs (g, fstype, device);
8305     if (r == -1)
8306       return -1;
8307   }
8308   {
8309     char device[] = "/dev/sda1";
8310     char mountpoint[] = "/";
8311     int r;
8312     suppress_error = 0;
8313     r = guestfs_mount (g, device, mountpoint);
8314     if (r == -1)
8315       return -1;
8316   }
8317   /* TestOutput for checksum (4) */
8318   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8319   {
8320     char path[] = "/new";
8321     char content[] = "test\n";
8322     int r;
8323     suppress_error = 0;
8324     r = guestfs_write_file (g, path, content, 0);
8325     if (r == -1)
8326       return -1;
8327   }
8328   {
8329     char csumtype[] = "sha224";
8330     char path[] = "/new";
8331     char *r;
8332     suppress_error = 0;
8333     r = guestfs_checksum (g, csumtype, path);
8334     if (r == NULL)
8335       return -1;
8336     if (strcmp (r, expected) != 0) {
8337       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8338       return -1;
8339     }
8340     free (r);
8341   }
8342   return 0;
8343 }
8344
8345 static int test_checksum_5_skip (void)
8346 {
8347   const char *str;
8348
8349   str = getenv ("TEST_ONLY");
8350   if (str)
8351     return strstr (str, "checksum") == NULL;
8352   str = getenv ("SKIP_TEST_CHECKSUM_5");
8353   if (str && strcmp (str, "1") == 0) return 1;
8354   str = getenv ("SKIP_TEST_CHECKSUM");
8355   if (str && strcmp (str, "1") == 0) return 1;
8356   return 0;
8357 }
8358
8359 static int test_checksum_5 (void)
8360 {
8361   if (test_checksum_5_skip ()) {
8362     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8363     return 0;
8364   }
8365
8366   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8367   {
8368     char device[] = "/dev/sda";
8369     int r;
8370     suppress_error = 0;
8371     r = guestfs_blockdev_setrw (g, device);
8372     if (r == -1)
8373       return -1;
8374   }
8375   {
8376     int r;
8377     suppress_error = 0;
8378     r = guestfs_umount_all (g);
8379     if (r == -1)
8380       return -1;
8381   }
8382   {
8383     int r;
8384     suppress_error = 0;
8385     r = guestfs_lvm_remove_all (g);
8386     if (r == -1)
8387       return -1;
8388   }
8389   {
8390     char device[] = "/dev/sda";
8391     char lines_0[] = ",";
8392     char *lines[] = {
8393       lines_0,
8394       NULL
8395     };
8396     int r;
8397     suppress_error = 0;
8398     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8399     if (r == -1)
8400       return -1;
8401   }
8402   {
8403     char fstype[] = "ext2";
8404     char device[] = "/dev/sda1";
8405     int r;
8406     suppress_error = 0;
8407     r = guestfs_mkfs (g, fstype, device);
8408     if (r == -1)
8409       return -1;
8410   }
8411   {
8412     char device[] = "/dev/sda1";
8413     char mountpoint[] = "/";
8414     int r;
8415     suppress_error = 0;
8416     r = guestfs_mount (g, device, mountpoint);
8417     if (r == -1)
8418       return -1;
8419   }
8420   /* TestOutput for checksum (5) */
8421   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8422   {
8423     char path[] = "/new";
8424     char content[] = "test\n";
8425     int r;
8426     suppress_error = 0;
8427     r = guestfs_write_file (g, path, content, 0);
8428     if (r == -1)
8429       return -1;
8430   }
8431   {
8432     char csumtype[] = "sha256";
8433     char path[] = "/new";
8434     char *r;
8435     suppress_error = 0;
8436     r = guestfs_checksum (g, csumtype, path);
8437     if (r == NULL)
8438       return -1;
8439     if (strcmp (r, expected) != 0) {
8440       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8441       return -1;
8442     }
8443     free (r);
8444   }
8445   return 0;
8446 }
8447
8448 static int test_checksum_6_skip (void)
8449 {
8450   const char *str;
8451
8452   str = getenv ("TEST_ONLY");
8453   if (str)
8454     return strstr (str, "checksum") == NULL;
8455   str = getenv ("SKIP_TEST_CHECKSUM_6");
8456   if (str && strcmp (str, "1") == 0) return 1;
8457   str = getenv ("SKIP_TEST_CHECKSUM");
8458   if (str && strcmp (str, "1") == 0) return 1;
8459   return 0;
8460 }
8461
8462 static int test_checksum_6 (void)
8463 {
8464   if (test_checksum_6_skip ()) {
8465     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8466     return 0;
8467   }
8468
8469   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8470   {
8471     char device[] = "/dev/sda";
8472     int r;
8473     suppress_error = 0;
8474     r = guestfs_blockdev_setrw (g, device);
8475     if (r == -1)
8476       return -1;
8477   }
8478   {
8479     int r;
8480     suppress_error = 0;
8481     r = guestfs_umount_all (g);
8482     if (r == -1)
8483       return -1;
8484   }
8485   {
8486     int r;
8487     suppress_error = 0;
8488     r = guestfs_lvm_remove_all (g);
8489     if (r == -1)
8490       return -1;
8491   }
8492   {
8493     char device[] = "/dev/sda";
8494     char lines_0[] = ",";
8495     char *lines[] = {
8496       lines_0,
8497       NULL
8498     };
8499     int r;
8500     suppress_error = 0;
8501     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8502     if (r == -1)
8503       return -1;
8504   }
8505   {
8506     char fstype[] = "ext2";
8507     char device[] = "/dev/sda1";
8508     int r;
8509     suppress_error = 0;
8510     r = guestfs_mkfs (g, fstype, device);
8511     if (r == -1)
8512       return -1;
8513   }
8514   {
8515     char device[] = "/dev/sda1";
8516     char mountpoint[] = "/";
8517     int r;
8518     suppress_error = 0;
8519     r = guestfs_mount (g, device, mountpoint);
8520     if (r == -1)
8521       return -1;
8522   }
8523   /* TestOutput for checksum (6) */
8524   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8525   {
8526     char path[] = "/new";
8527     char content[] = "test\n";
8528     int r;
8529     suppress_error = 0;
8530     r = guestfs_write_file (g, path, content, 0);
8531     if (r == -1)
8532       return -1;
8533   }
8534   {
8535     char csumtype[] = "sha384";
8536     char path[] = "/new";
8537     char *r;
8538     suppress_error = 0;
8539     r = guestfs_checksum (g, csumtype, path);
8540     if (r == NULL)
8541       return -1;
8542     if (strcmp (r, expected) != 0) {
8543       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8544       return -1;
8545     }
8546     free (r);
8547   }
8548   return 0;
8549 }
8550
8551 static int test_checksum_7_skip (void)
8552 {
8553   const char *str;
8554
8555   str = getenv ("TEST_ONLY");
8556   if (str)
8557     return strstr (str, "checksum") == NULL;
8558   str = getenv ("SKIP_TEST_CHECKSUM_7");
8559   if (str && strcmp (str, "1") == 0) return 1;
8560   str = getenv ("SKIP_TEST_CHECKSUM");
8561   if (str && strcmp (str, "1") == 0) return 1;
8562   return 0;
8563 }
8564
8565 static int test_checksum_7 (void)
8566 {
8567   if (test_checksum_7_skip ()) {
8568     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8569     return 0;
8570   }
8571
8572   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8573   {
8574     char device[] = "/dev/sda";
8575     int r;
8576     suppress_error = 0;
8577     r = guestfs_blockdev_setrw (g, device);
8578     if (r == -1)
8579       return -1;
8580   }
8581   {
8582     int r;
8583     suppress_error = 0;
8584     r = guestfs_umount_all (g);
8585     if (r == -1)
8586       return -1;
8587   }
8588   {
8589     int r;
8590     suppress_error = 0;
8591     r = guestfs_lvm_remove_all (g);
8592     if (r == -1)
8593       return -1;
8594   }
8595   {
8596     char device[] = "/dev/sda";
8597     char lines_0[] = ",";
8598     char *lines[] = {
8599       lines_0,
8600       NULL
8601     };
8602     int r;
8603     suppress_error = 0;
8604     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8605     if (r == -1)
8606       return -1;
8607   }
8608   {
8609     char fstype[] = "ext2";
8610     char device[] = "/dev/sda1";
8611     int r;
8612     suppress_error = 0;
8613     r = guestfs_mkfs (g, fstype, device);
8614     if (r == -1)
8615       return -1;
8616   }
8617   {
8618     char device[] = "/dev/sda1";
8619     char mountpoint[] = "/";
8620     int r;
8621     suppress_error = 0;
8622     r = guestfs_mount (g, device, mountpoint);
8623     if (r == -1)
8624       return -1;
8625   }
8626   /* TestOutput for checksum (7) */
8627   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8628   {
8629     char path[] = "/new";
8630     char content[] = "test\n";
8631     int r;
8632     suppress_error = 0;
8633     r = guestfs_write_file (g, path, content, 0);
8634     if (r == -1)
8635       return -1;
8636   }
8637   {
8638     char csumtype[] = "sha512";
8639     char path[] = "/new";
8640     char *r;
8641     suppress_error = 0;
8642     r = guestfs_checksum (g, csumtype, path);
8643     if (r == NULL)
8644       return -1;
8645     if (strcmp (r, expected) != 0) {
8646       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8647       return -1;
8648     }
8649     free (r);
8650   }
8651   return 0;
8652 }
8653
8654 static int test_checksum_8_skip (void)
8655 {
8656   const char *str;
8657
8658   str = getenv ("TEST_ONLY");
8659   if (str)
8660     return strstr (str, "checksum") == NULL;
8661   str = getenv ("SKIP_TEST_CHECKSUM_8");
8662   if (str && strcmp (str, "1") == 0) return 1;
8663   str = getenv ("SKIP_TEST_CHECKSUM");
8664   if (str && strcmp (str, "1") == 0) return 1;
8665   return 0;
8666 }
8667
8668 static int test_checksum_8 (void)
8669 {
8670   if (test_checksum_8_skip ()) {
8671     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8672     return 0;
8673   }
8674
8675   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8676   {
8677     char device[] = "/dev/sda";
8678     int r;
8679     suppress_error = 0;
8680     r = guestfs_blockdev_setrw (g, device);
8681     if (r == -1)
8682       return -1;
8683   }
8684   {
8685     int r;
8686     suppress_error = 0;
8687     r = guestfs_umount_all (g);
8688     if (r == -1)
8689       return -1;
8690   }
8691   {
8692     int r;
8693     suppress_error = 0;
8694     r = guestfs_lvm_remove_all (g);
8695     if (r == -1)
8696       return -1;
8697   }
8698   {
8699     char device[] = "/dev/sda";
8700     char lines_0[] = ",";
8701     char *lines[] = {
8702       lines_0,
8703       NULL
8704     };
8705     int r;
8706     suppress_error = 0;
8707     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8708     if (r == -1)
8709       return -1;
8710   }
8711   {
8712     char fstype[] = "ext2";
8713     char device[] = "/dev/sda1";
8714     int r;
8715     suppress_error = 0;
8716     r = guestfs_mkfs (g, fstype, device);
8717     if (r == -1)
8718       return -1;
8719   }
8720   {
8721     char device[] = "/dev/sda1";
8722     char mountpoint[] = "/";
8723     int r;
8724     suppress_error = 0;
8725     r = guestfs_mount (g, device, mountpoint);
8726     if (r == -1)
8727       return -1;
8728   }
8729   /* TestOutput for checksum (8) */
8730   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8731   {
8732     char options[] = "ro";
8733     char vfstype[] = "squashfs";
8734     char device[] = "/dev/sdd";
8735     char mountpoint[] = "/";
8736     int r;
8737     suppress_error = 0;
8738     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8739     if (r == -1)
8740       return -1;
8741   }
8742   {
8743     char csumtype[] = "md5";
8744     char path[] = "/known-3";
8745     char *r;
8746     suppress_error = 0;
8747     r = guestfs_checksum (g, csumtype, path);
8748     if (r == NULL)
8749       return -1;
8750     if (strcmp (r, expected) != 0) {
8751       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8752       return -1;
8753     }
8754     free (r);
8755   }
8756   return 0;
8757 }
8758
8759 static int test_download_0_skip (void)
8760 {
8761   const char *str;
8762
8763   str = getenv ("TEST_ONLY");
8764   if (str)
8765     return strstr (str, "download") == NULL;
8766   str = getenv ("SKIP_TEST_DOWNLOAD_0");
8767   if (str && strcmp (str, "1") == 0) return 1;
8768   str = getenv ("SKIP_TEST_DOWNLOAD");
8769   if (str && strcmp (str, "1") == 0) return 1;
8770   return 0;
8771 }
8772
8773 static int test_download_0 (void)
8774 {
8775   if (test_download_0_skip ()) {
8776     printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8777     return 0;
8778   }
8779
8780   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8781   {
8782     char device[] = "/dev/sda";
8783     int r;
8784     suppress_error = 0;
8785     r = guestfs_blockdev_setrw (g, device);
8786     if (r == -1)
8787       return -1;
8788   }
8789   {
8790     int r;
8791     suppress_error = 0;
8792     r = guestfs_umount_all (g);
8793     if (r == -1)
8794       return -1;
8795   }
8796   {
8797     int r;
8798     suppress_error = 0;
8799     r = guestfs_lvm_remove_all (g);
8800     if (r == -1)
8801       return -1;
8802   }
8803   {
8804     char device[] = "/dev/sda";
8805     char lines_0[] = ",";
8806     char *lines[] = {
8807       lines_0,
8808       NULL
8809     };
8810     int r;
8811     suppress_error = 0;
8812     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8813     if (r == -1)
8814       return -1;
8815   }
8816   {
8817     char fstype[] = "ext2";
8818     char device[] = "/dev/sda1";
8819     int r;
8820     suppress_error = 0;
8821     r = guestfs_mkfs (g, fstype, device);
8822     if (r == -1)
8823       return -1;
8824   }
8825   {
8826     char device[] = "/dev/sda1";
8827     char mountpoint[] = "/";
8828     int r;
8829     suppress_error = 0;
8830     r = guestfs_mount (g, device, mountpoint);
8831     if (r == -1)
8832       return -1;
8833   }
8834   /* TestOutput for download (0) */
8835   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8836   {
8837     char remotefilename[] = "/COPYING.LIB";
8838     int r;
8839     suppress_error = 0;
8840     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8841     if (r == -1)
8842       return -1;
8843   }
8844   {
8845     char remotefilename[] = "/COPYING.LIB";
8846     int r;
8847     suppress_error = 0;
8848     r = guestfs_download (g, remotefilename, "testdownload.tmp");
8849     if (r == -1)
8850       return -1;
8851   }
8852   {
8853     char remotefilename[] = "/upload";
8854     int r;
8855     suppress_error = 0;
8856     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8857     if (r == -1)
8858       return -1;
8859   }
8860   {
8861     char csumtype[] = "md5";
8862     char path[] = "/upload";
8863     char *r;
8864     suppress_error = 0;
8865     r = guestfs_checksum (g, csumtype, path);
8866     if (r == NULL)
8867       return -1;
8868     if (strcmp (r, expected) != 0) {
8869       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8870       return -1;
8871     }
8872     free (r);
8873   }
8874   return 0;
8875 }
8876
8877 static int test_upload_0_skip (void)
8878 {
8879   const char *str;
8880
8881   str = getenv ("TEST_ONLY");
8882   if (str)
8883     return strstr (str, "upload") == NULL;
8884   str = getenv ("SKIP_TEST_UPLOAD_0");
8885   if (str && strcmp (str, "1") == 0) return 1;
8886   str = getenv ("SKIP_TEST_UPLOAD");
8887   if (str && strcmp (str, "1") == 0) return 1;
8888   return 0;
8889 }
8890
8891 static int test_upload_0 (void)
8892 {
8893   if (test_upload_0_skip ()) {
8894     printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8895     return 0;
8896   }
8897
8898   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8899   {
8900     char device[] = "/dev/sda";
8901     int r;
8902     suppress_error = 0;
8903     r = guestfs_blockdev_setrw (g, device);
8904     if (r == -1)
8905       return -1;
8906   }
8907   {
8908     int r;
8909     suppress_error = 0;
8910     r = guestfs_umount_all (g);
8911     if (r == -1)
8912       return -1;
8913   }
8914   {
8915     int r;
8916     suppress_error = 0;
8917     r = guestfs_lvm_remove_all (g);
8918     if (r == -1)
8919       return -1;
8920   }
8921   {
8922     char device[] = "/dev/sda";
8923     char lines_0[] = ",";
8924     char *lines[] = {
8925       lines_0,
8926       NULL
8927     };
8928     int r;
8929     suppress_error = 0;
8930     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8931     if (r == -1)
8932       return -1;
8933   }
8934   {
8935     char fstype[] = "ext2";
8936     char device[] = "/dev/sda1";
8937     int r;
8938     suppress_error = 0;
8939     r = guestfs_mkfs (g, fstype, device);
8940     if (r == -1)
8941       return -1;
8942   }
8943   {
8944     char device[] = "/dev/sda1";
8945     char mountpoint[] = "/";
8946     int r;
8947     suppress_error = 0;
8948     r = guestfs_mount (g, device, mountpoint);
8949     if (r == -1)
8950       return -1;
8951   }
8952   /* TestOutput for upload (0) */
8953   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8954   {
8955     char remotefilename[] = "/COPYING.LIB";
8956     int r;
8957     suppress_error = 0;
8958     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8959     if (r == -1)
8960       return -1;
8961   }
8962   {
8963     char csumtype[] = "md5";
8964     char path[] = "/COPYING.LIB";
8965     char *r;
8966     suppress_error = 0;
8967     r = guestfs_checksum (g, csumtype, path);
8968     if (r == NULL)
8969       return -1;
8970     if (strcmp (r, expected) != 0) {
8971       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8972       return -1;
8973     }
8974     free (r);
8975   }
8976   return 0;
8977 }
8978
8979 static int test_blockdev_rereadpt_0_skip (void)
8980 {
8981   const char *str;
8982
8983   str = getenv ("TEST_ONLY");
8984   if (str)
8985     return strstr (str, "blockdev_rereadpt") == NULL;
8986   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8987   if (str && strcmp (str, "1") == 0) return 1;
8988   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8989   if (str && strcmp (str, "1") == 0) return 1;
8990   return 0;
8991 }
8992
8993 static int test_blockdev_rereadpt_0 (void)
8994 {
8995   if (test_blockdev_rereadpt_0_skip ()) {
8996     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8997     return 0;
8998   }
8999
9000   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
9001   {
9002     char device[] = "/dev/sda";
9003     int r;
9004     suppress_error = 0;
9005     r = guestfs_blockdev_setrw (g, device);
9006     if (r == -1)
9007       return -1;
9008   }
9009   {
9010     int r;
9011     suppress_error = 0;
9012     r = guestfs_umount_all (g);
9013     if (r == -1)
9014       return -1;
9015   }
9016   {
9017     int r;
9018     suppress_error = 0;
9019     r = guestfs_lvm_remove_all (g);
9020     if (r == -1)
9021       return -1;
9022   }
9023   /* TestRun for blockdev_rereadpt (0) */
9024   {
9025     char device[] = "/dev/sda";
9026     int r;
9027     suppress_error = 0;
9028     r = guestfs_blockdev_rereadpt (g, device);
9029     if (r == -1)
9030       return -1;
9031   }
9032   return 0;
9033 }
9034
9035 static int test_blockdev_flushbufs_0_skip (void)
9036 {
9037   const char *str;
9038
9039   str = getenv ("TEST_ONLY");
9040   if (str)
9041     return strstr (str, "blockdev_flushbufs") == NULL;
9042   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
9043   if (str && strcmp (str, "1") == 0) return 1;
9044   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
9045   if (str && strcmp (str, "1") == 0) return 1;
9046   return 0;
9047 }
9048
9049 static int test_blockdev_flushbufs_0 (void)
9050 {
9051   if (test_blockdev_flushbufs_0_skip ()) {
9052     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
9053     return 0;
9054   }
9055
9056   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
9057   {
9058     char device[] = "/dev/sda";
9059     int r;
9060     suppress_error = 0;
9061     r = guestfs_blockdev_setrw (g, device);
9062     if (r == -1)
9063       return -1;
9064   }
9065   {
9066     int r;
9067     suppress_error = 0;
9068     r = guestfs_umount_all (g);
9069     if (r == -1)
9070       return -1;
9071   }
9072   {
9073     int r;
9074     suppress_error = 0;
9075     r = guestfs_lvm_remove_all (g);
9076     if (r == -1)
9077       return -1;
9078   }
9079   /* TestRun for blockdev_flushbufs (0) */
9080   {
9081     char device[] = "/dev/sda";
9082     int r;
9083     suppress_error = 0;
9084     r = guestfs_blockdev_flushbufs (g, device);
9085     if (r == -1)
9086       return -1;
9087   }
9088   return 0;
9089 }
9090
9091 static int test_blockdev_getsize64_0_skip (void)
9092 {
9093   const char *str;
9094
9095   str = getenv ("TEST_ONLY");
9096   if (str)
9097     return strstr (str, "blockdev_getsize64") == NULL;
9098   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
9099   if (str && strcmp (str, "1") == 0) return 1;
9100   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
9101   if (str && strcmp (str, "1") == 0) return 1;
9102   return 0;
9103 }
9104
9105 static int test_blockdev_getsize64_0 (void)
9106 {
9107   if (test_blockdev_getsize64_0_skip ()) {
9108     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
9109     return 0;
9110   }
9111
9112   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
9113   {
9114     char device[] = "/dev/sda";
9115     int r;
9116     suppress_error = 0;
9117     r = guestfs_blockdev_setrw (g, device);
9118     if (r == -1)
9119       return -1;
9120   }
9121   {
9122     int r;
9123     suppress_error = 0;
9124     r = guestfs_umount_all (g);
9125     if (r == -1)
9126       return -1;
9127   }
9128   {
9129     int r;
9130     suppress_error = 0;
9131     r = guestfs_lvm_remove_all (g);
9132     if (r == -1)
9133       return -1;
9134   }
9135   /* TestOutputInt for blockdev_getsize64 (0) */
9136   {
9137     char device[] = "/dev/sda";
9138     int64_t r;
9139     suppress_error = 0;
9140     r = guestfs_blockdev_getsize64 (g, device);
9141     if (r == -1)
9142       return -1;
9143     if (r != 524288000) {
9144       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
9145       return -1;
9146     }
9147   }
9148   return 0;
9149 }
9150
9151 static int test_blockdev_getsz_0_skip (void)
9152 {
9153   const char *str;
9154
9155   str = getenv ("TEST_ONLY");
9156   if (str)
9157     return strstr (str, "blockdev_getsz") == NULL;
9158   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
9159   if (str && strcmp (str, "1") == 0) return 1;
9160   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
9161   if (str && strcmp (str, "1") == 0) return 1;
9162   return 0;
9163 }
9164
9165 static int test_blockdev_getsz_0 (void)
9166 {
9167   if (test_blockdev_getsz_0_skip ()) {
9168     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
9169     return 0;
9170   }
9171
9172   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
9173   {
9174     char device[] = "/dev/sda";
9175     int r;
9176     suppress_error = 0;
9177     r = guestfs_blockdev_setrw (g, device);
9178     if (r == -1)
9179       return -1;
9180   }
9181   {
9182     int r;
9183     suppress_error = 0;
9184     r = guestfs_umount_all (g);
9185     if (r == -1)
9186       return -1;
9187   }
9188   {
9189     int r;
9190     suppress_error = 0;
9191     r = guestfs_lvm_remove_all (g);
9192     if (r == -1)
9193       return -1;
9194   }
9195   /* TestOutputInt for blockdev_getsz (0) */
9196   {
9197     char device[] = "/dev/sda";
9198     int64_t r;
9199     suppress_error = 0;
9200     r = guestfs_blockdev_getsz (g, device);
9201     if (r == -1)
9202       return -1;
9203     if (r != 1024000) {
9204       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
9205       return -1;
9206     }
9207   }
9208   return 0;
9209 }
9210
9211 static int test_blockdev_getbsz_0_skip (void)
9212 {
9213   const char *str;
9214
9215   str = getenv ("TEST_ONLY");
9216   if (str)
9217     return strstr (str, "blockdev_getbsz") == NULL;
9218   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9219   if (str && strcmp (str, "1") == 0) return 1;
9220   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9221   if (str && strcmp (str, "1") == 0) return 1;
9222   return 0;
9223 }
9224
9225 static int test_blockdev_getbsz_0 (void)
9226 {
9227   if (test_blockdev_getbsz_0_skip ()) {
9228     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9229     return 0;
9230   }
9231
9232   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9233   {
9234     char device[] = "/dev/sda";
9235     int r;
9236     suppress_error = 0;
9237     r = guestfs_blockdev_setrw (g, device);
9238     if (r == -1)
9239       return -1;
9240   }
9241   {
9242     int r;
9243     suppress_error = 0;
9244     r = guestfs_umount_all (g);
9245     if (r == -1)
9246       return -1;
9247   }
9248   {
9249     int r;
9250     suppress_error = 0;
9251     r = guestfs_lvm_remove_all (g);
9252     if (r == -1)
9253       return -1;
9254   }
9255   /* TestOutputInt for blockdev_getbsz (0) */
9256   {
9257     char device[] = "/dev/sda";
9258     int r;
9259     suppress_error = 0;
9260     r = guestfs_blockdev_getbsz (g, device);
9261     if (r == -1)
9262       return -1;
9263     if (r != 4096) {
9264       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
9265       return -1;
9266     }
9267   }
9268   return 0;
9269 }
9270
9271 static int test_blockdev_getss_0_skip (void)
9272 {
9273   const char *str;
9274
9275   str = getenv ("TEST_ONLY");
9276   if (str)
9277     return strstr (str, "blockdev_getss") == NULL;
9278   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9279   if (str && strcmp (str, "1") == 0) return 1;
9280   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9281   if (str && strcmp (str, "1") == 0) return 1;
9282   return 0;
9283 }
9284
9285 static int test_blockdev_getss_0 (void)
9286 {
9287   if (test_blockdev_getss_0_skip ()) {
9288     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9289     return 0;
9290   }
9291
9292   /* InitNone|InitEmpty for test_blockdev_getss_0 */
9293   {
9294     char device[] = "/dev/sda";
9295     int r;
9296     suppress_error = 0;
9297     r = guestfs_blockdev_setrw (g, device);
9298     if (r == -1)
9299       return -1;
9300   }
9301   {
9302     int r;
9303     suppress_error = 0;
9304     r = guestfs_umount_all (g);
9305     if (r == -1)
9306       return -1;
9307   }
9308   {
9309     int r;
9310     suppress_error = 0;
9311     r = guestfs_lvm_remove_all (g);
9312     if (r == -1)
9313       return -1;
9314   }
9315   /* TestOutputInt for blockdev_getss (0) */
9316   {
9317     char device[] = "/dev/sda";
9318     int r;
9319     suppress_error = 0;
9320     r = guestfs_blockdev_getss (g, device);
9321     if (r == -1)
9322       return -1;
9323     if (r != 512) {
9324       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
9325       return -1;
9326     }
9327   }
9328   return 0;
9329 }
9330
9331 static int test_blockdev_getro_0_skip (void)
9332 {
9333   const char *str;
9334
9335   str = getenv ("TEST_ONLY");
9336   if (str)
9337     return strstr (str, "blockdev_getro") == NULL;
9338   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9339   if (str && strcmp (str, "1") == 0) return 1;
9340   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9341   if (str && strcmp (str, "1") == 0) return 1;
9342   return 0;
9343 }
9344
9345 static int test_blockdev_getro_0 (void)
9346 {
9347   if (test_blockdev_getro_0_skip ()) {
9348     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9349     return 0;
9350   }
9351
9352   /* InitNone|InitEmpty for test_blockdev_getro_0 */
9353   {
9354     char device[] = "/dev/sda";
9355     int r;
9356     suppress_error = 0;
9357     r = guestfs_blockdev_setrw (g, device);
9358     if (r == -1)
9359       return -1;
9360   }
9361   {
9362     int r;
9363     suppress_error = 0;
9364     r = guestfs_umount_all (g);
9365     if (r == -1)
9366       return -1;
9367   }
9368   {
9369     int r;
9370     suppress_error = 0;
9371     r = guestfs_lvm_remove_all (g);
9372     if (r == -1)
9373       return -1;
9374   }
9375   /* TestOutputTrue for blockdev_getro (0) */
9376   {
9377     char device[] = "/dev/sda";
9378     int r;
9379     suppress_error = 0;
9380     r = guestfs_blockdev_setro (g, device);
9381     if (r == -1)
9382       return -1;
9383   }
9384   {
9385     char device[] = "/dev/sda";
9386     int r;
9387     suppress_error = 0;
9388     r = guestfs_blockdev_getro (g, device);
9389     if (r == -1)
9390       return -1;
9391     if (!r) {
9392       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9393       return -1;
9394     }
9395   }
9396   return 0;
9397 }
9398
9399 static int test_blockdev_setrw_0_skip (void)
9400 {
9401   const char *str;
9402
9403   str = getenv ("TEST_ONLY");
9404   if (str)
9405     return strstr (str, "blockdev_setrw") == NULL;
9406   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9407   if (str && strcmp (str, "1") == 0) return 1;
9408   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9409   if (str && strcmp (str, "1") == 0) return 1;
9410   return 0;
9411 }
9412
9413 static int test_blockdev_setrw_0 (void)
9414 {
9415   if (test_blockdev_setrw_0_skip ()) {
9416     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9417     return 0;
9418   }
9419
9420   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9421   {
9422     char device[] = "/dev/sda";
9423     int r;
9424     suppress_error = 0;
9425     r = guestfs_blockdev_setrw (g, device);
9426     if (r == -1)
9427       return -1;
9428   }
9429   {
9430     int r;
9431     suppress_error = 0;
9432     r = guestfs_umount_all (g);
9433     if (r == -1)
9434       return -1;
9435   }
9436   {
9437     int r;
9438     suppress_error = 0;
9439     r = guestfs_lvm_remove_all (g);
9440     if (r == -1)
9441       return -1;
9442   }
9443   /* TestOutputFalse for blockdev_setrw (0) */
9444   {
9445     char device[] = "/dev/sda";
9446     int r;
9447     suppress_error = 0;
9448     r = guestfs_blockdev_setrw (g, device);
9449     if (r == -1)
9450       return -1;
9451   }
9452   {
9453     char device[] = "/dev/sda";
9454     int r;
9455     suppress_error = 0;
9456     r = guestfs_blockdev_getro (g, device);
9457     if (r == -1)
9458       return -1;
9459     if (r) {
9460       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9461       return -1;
9462     }
9463   }
9464   return 0;
9465 }
9466
9467 static int test_blockdev_setro_0_skip (void)
9468 {
9469   const char *str;
9470
9471   str = getenv ("TEST_ONLY");
9472   if (str)
9473     return strstr (str, "blockdev_setro") == NULL;
9474   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9475   if (str && strcmp (str, "1") == 0) return 1;
9476   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9477   if (str && strcmp (str, "1") == 0) return 1;
9478   return 0;
9479 }
9480
9481 static int test_blockdev_setro_0 (void)
9482 {
9483   if (test_blockdev_setro_0_skip ()) {
9484     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9485     return 0;
9486   }
9487
9488   /* InitNone|InitEmpty for test_blockdev_setro_0 */
9489   {
9490     char device[] = "/dev/sda";
9491     int r;
9492     suppress_error = 0;
9493     r = guestfs_blockdev_setrw (g, device);
9494     if (r == -1)
9495       return -1;
9496   }
9497   {
9498     int r;
9499     suppress_error = 0;
9500     r = guestfs_umount_all (g);
9501     if (r == -1)
9502       return -1;
9503   }
9504   {
9505     int r;
9506     suppress_error = 0;
9507     r = guestfs_lvm_remove_all (g);
9508     if (r == -1)
9509       return -1;
9510   }
9511   /* TestOutputTrue for blockdev_setro (0) */
9512   {
9513     char device[] = "/dev/sda";
9514     int r;
9515     suppress_error = 0;
9516     r = guestfs_blockdev_setro (g, device);
9517     if (r == -1)
9518       return -1;
9519   }
9520   {
9521     char device[] = "/dev/sda";
9522     int r;
9523     suppress_error = 0;
9524     r = guestfs_blockdev_getro (g, device);
9525     if (r == -1)
9526       return -1;
9527     if (!r) {
9528       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9529       return -1;
9530     }
9531   }
9532   return 0;
9533 }
9534
9535 static int test_statvfs_0_skip (void)
9536 {
9537   const char *str;
9538
9539   str = getenv ("TEST_ONLY");
9540   if (str)
9541     return strstr (str, "statvfs") == NULL;
9542   str = getenv ("SKIP_TEST_STATVFS_0");
9543   if (str && strcmp (str, "1") == 0) return 1;
9544   str = getenv ("SKIP_TEST_STATVFS");
9545   if (str && strcmp (str, "1") == 0) return 1;
9546   return 0;
9547 }
9548
9549 static int test_statvfs_0 (void)
9550 {
9551   if (test_statvfs_0_skip ()) {
9552     printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9553     return 0;
9554   }
9555
9556   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9557   {
9558     char device[] = "/dev/sda";
9559     int r;
9560     suppress_error = 0;
9561     r = guestfs_blockdev_setrw (g, device);
9562     if (r == -1)
9563       return -1;
9564   }
9565   {
9566     int r;
9567     suppress_error = 0;
9568     r = guestfs_umount_all (g);
9569     if (r == -1)
9570       return -1;
9571   }
9572   {
9573     int r;
9574     suppress_error = 0;
9575     r = guestfs_lvm_remove_all (g);
9576     if (r == -1)
9577       return -1;
9578   }
9579   {
9580     char device[] = "/dev/sda";
9581     char lines_0[] = ",";
9582     char *lines[] = {
9583       lines_0,
9584       NULL
9585     };
9586     int r;
9587     suppress_error = 0;
9588     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9589     if (r == -1)
9590       return -1;
9591   }
9592   {
9593     char fstype[] = "ext2";
9594     char device[] = "/dev/sda1";
9595     int r;
9596     suppress_error = 0;
9597     r = guestfs_mkfs (g, fstype, device);
9598     if (r == -1)
9599       return -1;
9600   }
9601   {
9602     char device[] = "/dev/sda1";
9603     char mountpoint[] = "/";
9604     int r;
9605     suppress_error = 0;
9606     r = guestfs_mount (g, device, mountpoint);
9607     if (r == -1)
9608       return -1;
9609   }
9610   /* TestOutputStruct for statvfs (0) */
9611   {
9612     char path[] = "/";
9613     struct guestfs_statvfs *r;
9614     suppress_error = 0;
9615     r = guestfs_statvfs (g, path);
9616     if (r == NULL)
9617       return -1;
9618     if (r->bfree != 487702) {
9619       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9620                (int) r->bfree);
9621       return -1;
9622     }
9623     if (r->blocks != 490020) {
9624       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9625                (int) r->blocks);
9626       return -1;
9627     }
9628     if (r->bsize != 1024) {
9629       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9630                (int) r->bsize);
9631       return -1;
9632     }
9633     free (r);
9634   }
9635   return 0;
9636 }
9637
9638 static int test_lstat_0_skip (void)
9639 {
9640   const char *str;
9641
9642   str = getenv ("TEST_ONLY");
9643   if (str)
9644     return strstr (str, "lstat") == NULL;
9645   str = getenv ("SKIP_TEST_LSTAT_0");
9646   if (str && strcmp (str, "1") == 0) return 1;
9647   str = getenv ("SKIP_TEST_LSTAT");
9648   if (str && strcmp (str, "1") == 0) return 1;
9649   return 0;
9650 }
9651
9652 static int test_lstat_0 (void)
9653 {
9654   if (test_lstat_0_skip ()) {
9655     printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9656     return 0;
9657   }
9658
9659   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9660   {
9661     char device[] = "/dev/sda";
9662     int r;
9663     suppress_error = 0;
9664     r = guestfs_blockdev_setrw (g, device);
9665     if (r == -1)
9666       return -1;
9667   }
9668   {
9669     int r;
9670     suppress_error = 0;
9671     r = guestfs_umount_all (g);
9672     if (r == -1)
9673       return -1;
9674   }
9675   {
9676     int r;
9677     suppress_error = 0;
9678     r = guestfs_lvm_remove_all (g);
9679     if (r == -1)
9680       return -1;
9681   }
9682   {
9683     char device[] = "/dev/sda";
9684     char lines_0[] = ",";
9685     char *lines[] = {
9686       lines_0,
9687       NULL
9688     };
9689     int r;
9690     suppress_error = 0;
9691     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9692     if (r == -1)
9693       return -1;
9694   }
9695   {
9696     char fstype[] = "ext2";
9697     char device[] = "/dev/sda1";
9698     int r;
9699     suppress_error = 0;
9700     r = guestfs_mkfs (g, fstype, device);
9701     if (r == -1)
9702       return -1;
9703   }
9704   {
9705     char device[] = "/dev/sda1";
9706     char mountpoint[] = "/";
9707     int r;
9708     suppress_error = 0;
9709     r = guestfs_mount (g, device, mountpoint);
9710     if (r == -1)
9711       return -1;
9712   }
9713   /* TestOutputStruct for lstat (0) */
9714   {
9715     char path[] = "/new";
9716     int r;
9717     suppress_error = 0;
9718     r = guestfs_touch (g, path);
9719     if (r == -1)
9720       return -1;
9721   }
9722   {
9723     char path[] = "/new";
9724     struct guestfs_stat *r;
9725     suppress_error = 0;
9726     r = guestfs_lstat (g, path);
9727     if (r == NULL)
9728       return -1;
9729     if (r->size != 0) {
9730       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9731                (int) r->size);
9732       return -1;
9733     }
9734     free (r);
9735   }
9736   return 0;
9737 }
9738
9739 static int test_stat_0_skip (void)
9740 {
9741   const char *str;
9742
9743   str = getenv ("TEST_ONLY");
9744   if (str)
9745     return strstr (str, "stat") == NULL;
9746   str = getenv ("SKIP_TEST_STAT_0");
9747   if (str && strcmp (str, "1") == 0) return 1;
9748   str = getenv ("SKIP_TEST_STAT");
9749   if (str && strcmp (str, "1") == 0) return 1;
9750   return 0;
9751 }
9752
9753 static int test_stat_0 (void)
9754 {
9755   if (test_stat_0_skip ()) {
9756     printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9757     return 0;
9758   }
9759
9760   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9761   {
9762     char device[] = "/dev/sda";
9763     int r;
9764     suppress_error = 0;
9765     r = guestfs_blockdev_setrw (g, device);
9766     if (r == -1)
9767       return -1;
9768   }
9769   {
9770     int r;
9771     suppress_error = 0;
9772     r = guestfs_umount_all (g);
9773     if (r == -1)
9774       return -1;
9775   }
9776   {
9777     int r;
9778     suppress_error = 0;
9779     r = guestfs_lvm_remove_all (g);
9780     if (r == -1)
9781       return -1;
9782   }
9783   {
9784     char device[] = "/dev/sda";
9785     char lines_0[] = ",";
9786     char *lines[] = {
9787       lines_0,
9788       NULL
9789     };
9790     int r;
9791     suppress_error = 0;
9792     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9793     if (r == -1)
9794       return -1;
9795   }
9796   {
9797     char fstype[] = "ext2";
9798     char device[] = "/dev/sda1";
9799     int r;
9800     suppress_error = 0;
9801     r = guestfs_mkfs (g, fstype, device);
9802     if (r == -1)
9803       return -1;
9804   }
9805   {
9806     char device[] = "/dev/sda1";
9807     char mountpoint[] = "/";
9808     int r;
9809     suppress_error = 0;
9810     r = guestfs_mount (g, device, mountpoint);
9811     if (r == -1)
9812       return -1;
9813   }
9814   /* TestOutputStruct for stat (0) */
9815   {
9816     char path[] = "/new";
9817     int r;
9818     suppress_error = 0;
9819     r = guestfs_touch (g, path);
9820     if (r == -1)
9821       return -1;
9822   }
9823   {
9824     char path[] = "/new";
9825     struct guestfs_stat *r;
9826     suppress_error = 0;
9827     r = guestfs_stat (g, path);
9828     if (r == NULL)
9829       return -1;
9830     if (r->size != 0) {
9831       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9832                (int) r->size);
9833       return -1;
9834     }
9835     free (r);
9836   }
9837   return 0;
9838 }
9839
9840 static int test_command_lines_0_skip (void)
9841 {
9842   const char *str;
9843
9844   str = getenv ("TEST_ONLY");
9845   if (str)
9846     return strstr (str, "command_lines") == NULL;
9847   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9848   if (str && strcmp (str, "1") == 0) return 1;
9849   str = getenv ("SKIP_TEST_COMMAND_LINES");
9850   if (str && strcmp (str, "1") == 0) return 1;
9851   return 0;
9852 }
9853
9854 static int test_command_lines_0 (void)
9855 {
9856   if (test_command_lines_0_skip ()) {
9857     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9858     return 0;
9859   }
9860
9861   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9862   {
9863     char device[] = "/dev/sda";
9864     int r;
9865     suppress_error = 0;
9866     r = guestfs_blockdev_setrw (g, device);
9867     if (r == -1)
9868       return -1;
9869   }
9870   {
9871     int r;
9872     suppress_error = 0;
9873     r = guestfs_umount_all (g);
9874     if (r == -1)
9875       return -1;
9876   }
9877   {
9878     int r;
9879     suppress_error = 0;
9880     r = guestfs_lvm_remove_all (g);
9881     if (r == -1)
9882       return -1;
9883   }
9884   {
9885     char device[] = "/dev/sda";
9886     char lines_0[] = ",";
9887     char *lines[] = {
9888       lines_0,
9889       NULL
9890     };
9891     int r;
9892     suppress_error = 0;
9893     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9894     if (r == -1)
9895       return -1;
9896   }
9897   {
9898     char fstype[] = "ext2";
9899     char device[] = "/dev/sda1";
9900     int r;
9901     suppress_error = 0;
9902     r = guestfs_mkfs (g, fstype, device);
9903     if (r == -1)
9904       return -1;
9905   }
9906   {
9907     char device[] = "/dev/sda1";
9908     char mountpoint[] = "/";
9909     int r;
9910     suppress_error = 0;
9911     r = guestfs_mount (g, device, mountpoint);
9912     if (r == -1)
9913       return -1;
9914   }
9915   /* TestOutputList for command_lines (0) */
9916   {
9917     char remotefilename[] = "/test-command";
9918     int r;
9919     suppress_error = 0;
9920     r = guestfs_upload (g, "test-command", remotefilename);
9921     if (r == -1)
9922       return -1;
9923   }
9924   {
9925     char path[] = "/test-command";
9926     int r;
9927     suppress_error = 0;
9928     r = guestfs_chmod (g, 493, path);
9929     if (r == -1)
9930       return -1;
9931   }
9932   {
9933     char arguments_0[] = "/test-command";
9934     char arguments_1[] = "1";
9935     char *arguments[] = {
9936       arguments_0,
9937       arguments_1,
9938       NULL
9939     };
9940     char **r;
9941     int i;
9942     suppress_error = 0;
9943     r = guestfs_command_lines (g, arguments);
9944     if (r == NULL)
9945       return -1;
9946     if (!r[0]) {
9947       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9948       print_strings (r);
9949       return -1;
9950     }
9951     {
9952       char expected[] = "Result1";
9953       if (strcmp (r[0], expected) != 0) {
9954         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9955         return -1;
9956       }
9957     }
9958     if (r[1] != NULL) {
9959       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9960       print_strings (r);
9961       return -1;
9962     }
9963     for (i = 0; r[i] != NULL; ++i)
9964       free (r[i]);
9965     free (r);
9966   }
9967   return 0;
9968 }
9969
9970 static int test_command_lines_1_skip (void)
9971 {
9972   const char *str;
9973
9974   str = getenv ("TEST_ONLY");
9975   if (str)
9976     return strstr (str, "command_lines") == NULL;
9977   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9978   if (str && strcmp (str, "1") == 0) return 1;
9979   str = getenv ("SKIP_TEST_COMMAND_LINES");
9980   if (str && strcmp (str, "1") == 0) return 1;
9981   return 0;
9982 }
9983
9984 static int test_command_lines_1 (void)
9985 {
9986   if (test_command_lines_1_skip ()) {
9987     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9988     return 0;
9989   }
9990
9991   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9992   {
9993     char device[] = "/dev/sda";
9994     int r;
9995     suppress_error = 0;
9996     r = guestfs_blockdev_setrw (g, device);
9997     if (r == -1)
9998       return -1;
9999   }
10000   {
10001     int r;
10002     suppress_error = 0;
10003     r = guestfs_umount_all (g);
10004     if (r == -1)
10005       return -1;
10006   }
10007   {
10008     int r;
10009     suppress_error = 0;
10010     r = guestfs_lvm_remove_all (g);
10011     if (r == -1)
10012       return -1;
10013   }
10014   {
10015     char device[] = "/dev/sda";
10016     char lines_0[] = ",";
10017     char *lines[] = {
10018       lines_0,
10019       NULL
10020     };
10021     int r;
10022     suppress_error = 0;
10023     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10024     if (r == -1)
10025       return -1;
10026   }
10027   {
10028     char fstype[] = "ext2";
10029     char device[] = "/dev/sda1";
10030     int r;
10031     suppress_error = 0;
10032     r = guestfs_mkfs (g, fstype, device);
10033     if (r == -1)
10034       return -1;
10035   }
10036   {
10037     char device[] = "/dev/sda1";
10038     char mountpoint[] = "/";
10039     int r;
10040     suppress_error = 0;
10041     r = guestfs_mount (g, device, mountpoint);
10042     if (r == -1)
10043       return -1;
10044   }
10045   /* TestOutputList for command_lines (1) */
10046   {
10047     char remotefilename[] = "/test-command";
10048     int r;
10049     suppress_error = 0;
10050     r = guestfs_upload (g, "test-command", remotefilename);
10051     if (r == -1)
10052       return -1;
10053   }
10054   {
10055     char path[] = "/test-command";
10056     int r;
10057     suppress_error = 0;
10058     r = guestfs_chmod (g, 493, path);
10059     if (r == -1)
10060       return -1;
10061   }
10062   {
10063     char arguments_0[] = "/test-command";
10064     char arguments_1[] = "2";
10065     char *arguments[] = {
10066       arguments_0,
10067       arguments_1,
10068       NULL
10069     };
10070     char **r;
10071     int i;
10072     suppress_error = 0;
10073     r = guestfs_command_lines (g, arguments);
10074     if (r == NULL)
10075       return -1;
10076     if (!r[0]) {
10077       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
10078       print_strings (r);
10079       return -1;
10080     }
10081     {
10082       char expected[] = "Result2";
10083       if (strcmp (r[0], expected) != 0) {
10084         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10085         return -1;
10086       }
10087     }
10088     if (r[1] != NULL) {
10089       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
10090       print_strings (r);
10091       return -1;
10092     }
10093     for (i = 0; r[i] != NULL; ++i)
10094       free (r[i]);
10095     free (r);
10096   }
10097   return 0;
10098 }
10099
10100 static int test_command_lines_2_skip (void)
10101 {
10102   const char *str;
10103
10104   str = getenv ("TEST_ONLY");
10105   if (str)
10106     return strstr (str, "command_lines") == NULL;
10107   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
10108   if (str && strcmp (str, "1") == 0) return 1;
10109   str = getenv ("SKIP_TEST_COMMAND_LINES");
10110   if (str && strcmp (str, "1") == 0) return 1;
10111   return 0;
10112 }
10113
10114 static int test_command_lines_2 (void)
10115 {
10116   if (test_command_lines_2_skip ()) {
10117     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
10118     return 0;
10119   }
10120
10121   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
10122   {
10123     char device[] = "/dev/sda";
10124     int r;
10125     suppress_error = 0;
10126     r = guestfs_blockdev_setrw (g, device);
10127     if (r == -1)
10128       return -1;
10129   }
10130   {
10131     int r;
10132     suppress_error = 0;
10133     r = guestfs_umount_all (g);
10134     if (r == -1)
10135       return -1;
10136   }
10137   {
10138     int r;
10139     suppress_error = 0;
10140     r = guestfs_lvm_remove_all (g);
10141     if (r == -1)
10142       return -1;
10143   }
10144   {
10145     char device[] = "/dev/sda";
10146     char lines_0[] = ",";
10147     char *lines[] = {
10148       lines_0,
10149       NULL
10150     };
10151     int r;
10152     suppress_error = 0;
10153     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10154     if (r == -1)
10155       return -1;
10156   }
10157   {
10158     char fstype[] = "ext2";
10159     char device[] = "/dev/sda1";
10160     int r;
10161     suppress_error = 0;
10162     r = guestfs_mkfs (g, fstype, device);
10163     if (r == -1)
10164       return -1;
10165   }
10166   {
10167     char device[] = "/dev/sda1";
10168     char mountpoint[] = "/";
10169     int r;
10170     suppress_error = 0;
10171     r = guestfs_mount (g, device, mountpoint);
10172     if (r == -1)
10173       return -1;
10174   }
10175   /* TestOutputList for command_lines (2) */
10176   {
10177     char remotefilename[] = "/test-command";
10178     int r;
10179     suppress_error = 0;
10180     r = guestfs_upload (g, "test-command", remotefilename);
10181     if (r == -1)
10182       return -1;
10183   }
10184   {
10185     char path[] = "/test-command";
10186     int r;
10187     suppress_error = 0;
10188     r = guestfs_chmod (g, 493, path);
10189     if (r == -1)
10190       return -1;
10191   }
10192   {
10193     char arguments_0[] = "/test-command";
10194     char arguments_1[] = "3";
10195     char *arguments[] = {
10196       arguments_0,
10197       arguments_1,
10198       NULL
10199     };
10200     char **r;
10201     int i;
10202     suppress_error = 0;
10203     r = guestfs_command_lines (g, arguments);
10204     if (r == NULL)
10205       return -1;
10206     if (!r[0]) {
10207       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10208       print_strings (r);
10209       return -1;
10210     }
10211     {
10212       char expected[] = "";
10213       if (strcmp (r[0], expected) != 0) {
10214         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10215         return -1;
10216       }
10217     }
10218     if (!r[1]) {
10219       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10220       print_strings (r);
10221       return -1;
10222     }
10223     {
10224       char expected[] = "Result3";
10225       if (strcmp (r[1], expected) != 0) {
10226         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10227         return -1;
10228       }
10229     }
10230     if (r[2] != NULL) {
10231       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10232       print_strings (r);
10233       return -1;
10234     }
10235     for (i = 0; r[i] != NULL; ++i)
10236       free (r[i]);
10237     free (r);
10238   }
10239   return 0;
10240 }
10241
10242 static int test_command_lines_3_skip (void)
10243 {
10244   const char *str;
10245
10246   str = getenv ("TEST_ONLY");
10247   if (str)
10248     return strstr (str, "command_lines") == NULL;
10249   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10250   if (str && strcmp (str, "1") == 0) return 1;
10251   str = getenv ("SKIP_TEST_COMMAND_LINES");
10252   if (str && strcmp (str, "1") == 0) return 1;
10253   return 0;
10254 }
10255
10256 static int test_command_lines_3 (void)
10257 {
10258   if (test_command_lines_3_skip ()) {
10259     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
10260     return 0;
10261   }
10262
10263   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10264   {
10265     char device[] = "/dev/sda";
10266     int r;
10267     suppress_error = 0;
10268     r = guestfs_blockdev_setrw (g, device);
10269     if (r == -1)
10270       return -1;
10271   }
10272   {
10273     int r;
10274     suppress_error = 0;
10275     r = guestfs_umount_all (g);
10276     if (r == -1)
10277       return -1;
10278   }
10279   {
10280     int r;
10281     suppress_error = 0;
10282     r = guestfs_lvm_remove_all (g);
10283     if (r == -1)
10284       return -1;
10285   }
10286   {
10287     char device[] = "/dev/sda";
10288     char lines_0[] = ",";
10289     char *lines[] = {
10290       lines_0,
10291       NULL
10292     };
10293     int r;
10294     suppress_error = 0;
10295     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10296     if (r == -1)
10297       return -1;
10298   }
10299   {
10300     char fstype[] = "ext2";
10301     char device[] = "/dev/sda1";
10302     int r;
10303     suppress_error = 0;
10304     r = guestfs_mkfs (g, fstype, device);
10305     if (r == -1)
10306       return -1;
10307   }
10308   {
10309     char device[] = "/dev/sda1";
10310     char mountpoint[] = "/";
10311     int r;
10312     suppress_error = 0;
10313     r = guestfs_mount (g, device, mountpoint);
10314     if (r == -1)
10315       return -1;
10316   }
10317   /* TestOutputList for command_lines (3) */
10318   {
10319     char remotefilename[] = "/test-command";
10320     int r;
10321     suppress_error = 0;
10322     r = guestfs_upload (g, "test-command", remotefilename);
10323     if (r == -1)
10324       return -1;
10325   }
10326   {
10327     char path[] = "/test-command";
10328     int r;
10329     suppress_error = 0;
10330     r = guestfs_chmod (g, 493, path);
10331     if (r == -1)
10332       return -1;
10333   }
10334   {
10335     char arguments_0[] = "/test-command";
10336     char arguments_1[] = "4";
10337     char *arguments[] = {
10338       arguments_0,
10339       arguments_1,
10340       NULL
10341     };
10342     char **r;
10343     int i;
10344     suppress_error = 0;
10345     r = guestfs_command_lines (g, arguments);
10346     if (r == NULL)
10347       return -1;
10348     if (!r[0]) {
10349       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10350       print_strings (r);
10351       return -1;
10352     }
10353     {
10354       char expected[] = "";
10355       if (strcmp (r[0], expected) != 0) {
10356         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10357         return -1;
10358       }
10359     }
10360     if (!r[1]) {
10361       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10362       print_strings (r);
10363       return -1;
10364     }
10365     {
10366       char expected[] = "Result4";
10367       if (strcmp (r[1], expected) != 0) {
10368         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10369         return -1;
10370       }
10371     }
10372     if (r[2] != NULL) {
10373       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10374       print_strings (r);
10375       return -1;
10376     }
10377     for (i = 0; r[i] != NULL; ++i)
10378       free (r[i]);
10379     free (r);
10380   }
10381   return 0;
10382 }
10383
10384 static int test_command_lines_4_skip (void)
10385 {
10386   const char *str;
10387
10388   str = getenv ("TEST_ONLY");
10389   if (str)
10390     return strstr (str, "command_lines") == NULL;
10391   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10392   if (str && strcmp (str, "1") == 0) return 1;
10393   str = getenv ("SKIP_TEST_COMMAND_LINES");
10394   if (str && strcmp (str, "1") == 0) return 1;
10395   return 0;
10396 }
10397
10398 static int test_command_lines_4 (void)
10399 {
10400   if (test_command_lines_4_skip ()) {
10401     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10402     return 0;
10403   }
10404
10405   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10406   {
10407     char device[] = "/dev/sda";
10408     int r;
10409     suppress_error = 0;
10410     r = guestfs_blockdev_setrw (g, device);
10411     if (r == -1)
10412       return -1;
10413   }
10414   {
10415     int r;
10416     suppress_error = 0;
10417     r = guestfs_umount_all (g);
10418     if (r == -1)
10419       return -1;
10420   }
10421   {
10422     int r;
10423     suppress_error = 0;
10424     r = guestfs_lvm_remove_all (g);
10425     if (r == -1)
10426       return -1;
10427   }
10428   {
10429     char device[] = "/dev/sda";
10430     char lines_0[] = ",";
10431     char *lines[] = {
10432       lines_0,
10433       NULL
10434     };
10435     int r;
10436     suppress_error = 0;
10437     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10438     if (r == -1)
10439       return -1;
10440   }
10441   {
10442     char fstype[] = "ext2";
10443     char device[] = "/dev/sda1";
10444     int r;
10445     suppress_error = 0;
10446     r = guestfs_mkfs (g, fstype, device);
10447     if (r == -1)
10448       return -1;
10449   }
10450   {
10451     char device[] = "/dev/sda1";
10452     char mountpoint[] = "/";
10453     int r;
10454     suppress_error = 0;
10455     r = guestfs_mount (g, device, mountpoint);
10456     if (r == -1)
10457       return -1;
10458   }
10459   /* TestOutputList for command_lines (4) */
10460   {
10461     char remotefilename[] = "/test-command";
10462     int r;
10463     suppress_error = 0;
10464     r = guestfs_upload (g, "test-command", remotefilename);
10465     if (r == -1)
10466       return -1;
10467   }
10468   {
10469     char path[] = "/test-command";
10470     int r;
10471     suppress_error = 0;
10472     r = guestfs_chmod (g, 493, path);
10473     if (r == -1)
10474       return -1;
10475   }
10476   {
10477     char arguments_0[] = "/test-command";
10478     char arguments_1[] = "5";
10479     char *arguments[] = {
10480       arguments_0,
10481       arguments_1,
10482       NULL
10483     };
10484     char **r;
10485     int i;
10486     suppress_error = 0;
10487     r = guestfs_command_lines (g, arguments);
10488     if (r == NULL)
10489       return -1;
10490     if (!r[0]) {
10491       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10492       print_strings (r);
10493       return -1;
10494     }
10495     {
10496       char expected[] = "";
10497       if (strcmp (r[0], expected) != 0) {
10498         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10499         return -1;
10500       }
10501     }
10502     if (!r[1]) {
10503       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10504       print_strings (r);
10505       return -1;
10506     }
10507     {
10508       char expected[] = "Result5";
10509       if (strcmp (r[1], expected) != 0) {
10510         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10511         return -1;
10512       }
10513     }
10514     if (!r[2]) {
10515       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10516       print_strings (r);
10517       return -1;
10518     }
10519     {
10520       char expected[] = "";
10521       if (strcmp (r[2], expected) != 0) {
10522         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10523         return -1;
10524       }
10525     }
10526     if (r[3] != NULL) {
10527       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10528       print_strings (r);
10529       return -1;
10530     }
10531     for (i = 0; r[i] != NULL; ++i)
10532       free (r[i]);
10533     free (r);
10534   }
10535   return 0;
10536 }
10537
10538 static int test_command_lines_5_skip (void)
10539 {
10540   const char *str;
10541
10542   str = getenv ("TEST_ONLY");
10543   if (str)
10544     return strstr (str, "command_lines") == NULL;
10545   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10546   if (str && strcmp (str, "1") == 0) return 1;
10547   str = getenv ("SKIP_TEST_COMMAND_LINES");
10548   if (str && strcmp (str, "1") == 0) return 1;
10549   return 0;
10550 }
10551
10552 static int test_command_lines_5 (void)
10553 {
10554   if (test_command_lines_5_skip ()) {
10555     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10556     return 0;
10557   }
10558
10559   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10560   {
10561     char device[] = "/dev/sda";
10562     int r;
10563     suppress_error = 0;
10564     r = guestfs_blockdev_setrw (g, device);
10565     if (r == -1)
10566       return -1;
10567   }
10568   {
10569     int r;
10570     suppress_error = 0;
10571     r = guestfs_umount_all (g);
10572     if (r == -1)
10573       return -1;
10574   }
10575   {
10576     int r;
10577     suppress_error = 0;
10578     r = guestfs_lvm_remove_all (g);
10579     if (r == -1)
10580       return -1;
10581   }
10582   {
10583     char device[] = "/dev/sda";
10584     char lines_0[] = ",";
10585     char *lines[] = {
10586       lines_0,
10587       NULL
10588     };
10589     int r;
10590     suppress_error = 0;
10591     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10592     if (r == -1)
10593       return -1;
10594   }
10595   {
10596     char fstype[] = "ext2";
10597     char device[] = "/dev/sda1";
10598     int r;
10599     suppress_error = 0;
10600     r = guestfs_mkfs (g, fstype, device);
10601     if (r == -1)
10602       return -1;
10603   }
10604   {
10605     char device[] = "/dev/sda1";
10606     char mountpoint[] = "/";
10607     int r;
10608     suppress_error = 0;
10609     r = guestfs_mount (g, device, mountpoint);
10610     if (r == -1)
10611       return -1;
10612   }
10613   /* TestOutputList for command_lines (5) */
10614   {
10615     char remotefilename[] = "/test-command";
10616     int r;
10617     suppress_error = 0;
10618     r = guestfs_upload (g, "test-command", remotefilename);
10619     if (r == -1)
10620       return -1;
10621   }
10622   {
10623     char path[] = "/test-command";
10624     int r;
10625     suppress_error = 0;
10626     r = guestfs_chmod (g, 493, path);
10627     if (r == -1)
10628       return -1;
10629   }
10630   {
10631     char arguments_0[] = "/test-command";
10632     char arguments_1[] = "6";
10633     char *arguments[] = {
10634       arguments_0,
10635       arguments_1,
10636       NULL
10637     };
10638     char **r;
10639     int i;
10640     suppress_error = 0;
10641     r = guestfs_command_lines (g, arguments);
10642     if (r == NULL)
10643       return -1;
10644     if (!r[0]) {
10645       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10646       print_strings (r);
10647       return -1;
10648     }
10649     {
10650       char expected[] = "";
10651       if (strcmp (r[0], expected) != 0) {
10652         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10653         return -1;
10654       }
10655     }
10656     if (!r[1]) {
10657       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10658       print_strings (r);
10659       return -1;
10660     }
10661     {
10662       char expected[] = "";
10663       if (strcmp (r[1], expected) != 0) {
10664         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10665         return -1;
10666       }
10667     }
10668     if (!r[2]) {
10669       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10670       print_strings (r);
10671       return -1;
10672     }
10673     {
10674       char expected[] = "Result6";
10675       if (strcmp (r[2], expected) != 0) {
10676         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10677         return -1;
10678       }
10679     }
10680     if (!r[3]) {
10681       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10682       print_strings (r);
10683       return -1;
10684     }
10685     {
10686       char expected[] = "";
10687       if (strcmp (r[3], expected) != 0) {
10688         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10689         return -1;
10690       }
10691     }
10692     if (r[4] != NULL) {
10693       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10694       print_strings (r);
10695       return -1;
10696     }
10697     for (i = 0; r[i] != NULL; ++i)
10698       free (r[i]);
10699     free (r);
10700   }
10701   return 0;
10702 }
10703
10704 static int test_command_lines_6_skip (void)
10705 {
10706   const char *str;
10707
10708   str = getenv ("TEST_ONLY");
10709   if (str)
10710     return strstr (str, "command_lines") == NULL;
10711   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10712   if (str && strcmp (str, "1") == 0) return 1;
10713   str = getenv ("SKIP_TEST_COMMAND_LINES");
10714   if (str && strcmp (str, "1") == 0) return 1;
10715   return 0;
10716 }
10717
10718 static int test_command_lines_6 (void)
10719 {
10720   if (test_command_lines_6_skip ()) {
10721     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10722     return 0;
10723   }
10724
10725   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10726   {
10727     char device[] = "/dev/sda";
10728     int r;
10729     suppress_error = 0;
10730     r = guestfs_blockdev_setrw (g, device);
10731     if (r == -1)
10732       return -1;
10733   }
10734   {
10735     int r;
10736     suppress_error = 0;
10737     r = guestfs_umount_all (g);
10738     if (r == -1)
10739       return -1;
10740   }
10741   {
10742     int r;
10743     suppress_error = 0;
10744     r = guestfs_lvm_remove_all (g);
10745     if (r == -1)
10746       return -1;
10747   }
10748   {
10749     char device[] = "/dev/sda";
10750     char lines_0[] = ",";
10751     char *lines[] = {
10752       lines_0,
10753       NULL
10754     };
10755     int r;
10756     suppress_error = 0;
10757     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10758     if (r == -1)
10759       return -1;
10760   }
10761   {
10762     char fstype[] = "ext2";
10763     char device[] = "/dev/sda1";
10764     int r;
10765     suppress_error = 0;
10766     r = guestfs_mkfs (g, fstype, device);
10767     if (r == -1)
10768       return -1;
10769   }
10770   {
10771     char device[] = "/dev/sda1";
10772     char mountpoint[] = "/";
10773     int r;
10774     suppress_error = 0;
10775     r = guestfs_mount (g, device, mountpoint);
10776     if (r == -1)
10777       return -1;
10778   }
10779   /* TestOutputList for command_lines (6) */
10780   {
10781     char remotefilename[] = "/test-command";
10782     int r;
10783     suppress_error = 0;
10784     r = guestfs_upload (g, "test-command", remotefilename);
10785     if (r == -1)
10786       return -1;
10787   }
10788   {
10789     char path[] = "/test-command";
10790     int r;
10791     suppress_error = 0;
10792     r = guestfs_chmod (g, 493, path);
10793     if (r == -1)
10794       return -1;
10795   }
10796   {
10797     char arguments_0[] = "/test-command";
10798     char arguments_1[] = "7";
10799     char *arguments[] = {
10800       arguments_0,
10801       arguments_1,
10802       NULL
10803     };
10804     char **r;
10805     int i;
10806     suppress_error = 0;
10807     r = guestfs_command_lines (g, arguments);
10808     if (r == NULL)
10809       return -1;
10810     if (r[0] != NULL) {
10811       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10812       print_strings (r);
10813       return -1;
10814     }
10815     for (i = 0; r[i] != NULL; ++i)
10816       free (r[i]);
10817     free (r);
10818   }
10819   return 0;
10820 }
10821
10822 static int test_command_lines_7_skip (void)
10823 {
10824   const char *str;
10825
10826   str = getenv ("TEST_ONLY");
10827   if (str)
10828     return strstr (str, "command_lines") == NULL;
10829   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10830   if (str && strcmp (str, "1") == 0) return 1;
10831   str = getenv ("SKIP_TEST_COMMAND_LINES");
10832   if (str && strcmp (str, "1") == 0) return 1;
10833   return 0;
10834 }
10835
10836 static int test_command_lines_7 (void)
10837 {
10838   if (test_command_lines_7_skip ()) {
10839     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10840     return 0;
10841   }
10842
10843   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10844   {
10845     char device[] = "/dev/sda";
10846     int r;
10847     suppress_error = 0;
10848     r = guestfs_blockdev_setrw (g, device);
10849     if (r == -1)
10850       return -1;
10851   }
10852   {
10853     int r;
10854     suppress_error = 0;
10855     r = guestfs_umount_all (g);
10856     if (r == -1)
10857       return -1;
10858   }
10859   {
10860     int r;
10861     suppress_error = 0;
10862     r = guestfs_lvm_remove_all (g);
10863     if (r == -1)
10864       return -1;
10865   }
10866   {
10867     char device[] = "/dev/sda";
10868     char lines_0[] = ",";
10869     char *lines[] = {
10870       lines_0,
10871       NULL
10872     };
10873     int r;
10874     suppress_error = 0;
10875     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10876     if (r == -1)
10877       return -1;
10878   }
10879   {
10880     char fstype[] = "ext2";
10881     char device[] = "/dev/sda1";
10882     int r;
10883     suppress_error = 0;
10884     r = guestfs_mkfs (g, fstype, device);
10885     if (r == -1)
10886       return -1;
10887   }
10888   {
10889     char device[] = "/dev/sda1";
10890     char mountpoint[] = "/";
10891     int r;
10892     suppress_error = 0;
10893     r = guestfs_mount (g, device, mountpoint);
10894     if (r == -1)
10895       return -1;
10896   }
10897   /* TestOutputList for command_lines (7) */
10898   {
10899     char remotefilename[] = "/test-command";
10900     int r;
10901     suppress_error = 0;
10902     r = guestfs_upload (g, "test-command", remotefilename);
10903     if (r == -1)
10904       return -1;
10905   }
10906   {
10907     char path[] = "/test-command";
10908     int r;
10909     suppress_error = 0;
10910     r = guestfs_chmod (g, 493, path);
10911     if (r == -1)
10912       return -1;
10913   }
10914   {
10915     char arguments_0[] = "/test-command";
10916     char arguments_1[] = "8";
10917     char *arguments[] = {
10918       arguments_0,
10919       arguments_1,
10920       NULL
10921     };
10922     char **r;
10923     int i;
10924     suppress_error = 0;
10925     r = guestfs_command_lines (g, arguments);
10926     if (r == NULL)
10927       return -1;
10928     if (!r[0]) {
10929       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10930       print_strings (r);
10931       return -1;
10932     }
10933     {
10934       char expected[] = "";
10935       if (strcmp (r[0], expected) != 0) {
10936         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10937         return -1;
10938       }
10939     }
10940     if (r[1] != NULL) {
10941       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10942       print_strings (r);
10943       return -1;
10944     }
10945     for (i = 0; r[i] != NULL; ++i)
10946       free (r[i]);
10947     free (r);
10948   }
10949   return 0;
10950 }
10951
10952 static int test_command_lines_8_skip (void)
10953 {
10954   const char *str;
10955
10956   str = getenv ("TEST_ONLY");
10957   if (str)
10958     return strstr (str, "command_lines") == NULL;
10959   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10960   if (str && strcmp (str, "1") == 0) return 1;
10961   str = getenv ("SKIP_TEST_COMMAND_LINES");
10962   if (str && strcmp (str, "1") == 0) return 1;
10963   return 0;
10964 }
10965
10966 static int test_command_lines_8 (void)
10967 {
10968   if (test_command_lines_8_skip ()) {
10969     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10970     return 0;
10971   }
10972
10973   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10974   {
10975     char device[] = "/dev/sda";
10976     int r;
10977     suppress_error = 0;
10978     r = guestfs_blockdev_setrw (g, device);
10979     if (r == -1)
10980       return -1;
10981   }
10982   {
10983     int r;
10984     suppress_error = 0;
10985     r = guestfs_umount_all (g);
10986     if (r == -1)
10987       return -1;
10988   }
10989   {
10990     int r;
10991     suppress_error = 0;
10992     r = guestfs_lvm_remove_all (g);
10993     if (r == -1)
10994       return -1;
10995   }
10996   {
10997     char device[] = "/dev/sda";
10998     char lines_0[] = ",";
10999     char *lines[] = {
11000       lines_0,
11001       NULL
11002     };
11003     int r;
11004     suppress_error = 0;
11005     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11006     if (r == -1)
11007       return -1;
11008   }
11009   {
11010     char fstype[] = "ext2";
11011     char device[] = "/dev/sda1";
11012     int r;
11013     suppress_error = 0;
11014     r = guestfs_mkfs (g, fstype, device);
11015     if (r == -1)
11016       return -1;
11017   }
11018   {
11019     char device[] = "/dev/sda1";
11020     char mountpoint[] = "/";
11021     int r;
11022     suppress_error = 0;
11023     r = guestfs_mount (g, device, mountpoint);
11024     if (r == -1)
11025       return -1;
11026   }
11027   /* TestOutputList for command_lines (8) */
11028   {
11029     char remotefilename[] = "/test-command";
11030     int r;
11031     suppress_error = 0;
11032     r = guestfs_upload (g, "test-command", remotefilename);
11033     if (r == -1)
11034       return -1;
11035   }
11036   {
11037     char path[] = "/test-command";
11038     int r;
11039     suppress_error = 0;
11040     r = guestfs_chmod (g, 493, path);
11041     if (r == -1)
11042       return -1;
11043   }
11044   {
11045     char arguments_0[] = "/test-command";
11046     char arguments_1[] = "9";
11047     char *arguments[] = {
11048       arguments_0,
11049       arguments_1,
11050       NULL
11051     };
11052     char **r;
11053     int i;
11054     suppress_error = 0;
11055     r = guestfs_command_lines (g, arguments);
11056     if (r == NULL)
11057       return -1;
11058     if (!r[0]) {
11059       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11060       print_strings (r);
11061       return -1;
11062     }
11063     {
11064       char expected[] = "";
11065       if (strcmp (r[0], expected) != 0) {
11066         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11067         return -1;
11068       }
11069     }
11070     if (!r[1]) {
11071       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11072       print_strings (r);
11073       return -1;
11074     }
11075     {
11076       char expected[] = "";
11077       if (strcmp (r[1], expected) != 0) {
11078         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11079         return -1;
11080       }
11081     }
11082     if (r[2] != NULL) {
11083       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
11084       print_strings (r);
11085       return -1;
11086     }
11087     for (i = 0; r[i] != NULL; ++i)
11088       free (r[i]);
11089     free (r);
11090   }
11091   return 0;
11092 }
11093
11094 static int test_command_lines_9_skip (void)
11095 {
11096   const char *str;
11097
11098   str = getenv ("TEST_ONLY");
11099   if (str)
11100     return strstr (str, "command_lines") == NULL;
11101   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
11102   if (str && strcmp (str, "1") == 0) return 1;
11103   str = getenv ("SKIP_TEST_COMMAND_LINES");
11104   if (str && strcmp (str, "1") == 0) return 1;
11105   return 0;
11106 }
11107
11108 static int test_command_lines_9 (void)
11109 {
11110   if (test_command_lines_9_skip ()) {
11111     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
11112     return 0;
11113   }
11114
11115   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
11116   {
11117     char device[] = "/dev/sda";
11118     int r;
11119     suppress_error = 0;
11120     r = guestfs_blockdev_setrw (g, device);
11121     if (r == -1)
11122       return -1;
11123   }
11124   {
11125     int r;
11126     suppress_error = 0;
11127     r = guestfs_umount_all (g);
11128     if (r == -1)
11129       return -1;
11130   }
11131   {
11132     int r;
11133     suppress_error = 0;
11134     r = guestfs_lvm_remove_all (g);
11135     if (r == -1)
11136       return -1;
11137   }
11138   {
11139     char device[] = "/dev/sda";
11140     char lines_0[] = ",";
11141     char *lines[] = {
11142       lines_0,
11143       NULL
11144     };
11145     int r;
11146     suppress_error = 0;
11147     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11148     if (r == -1)
11149       return -1;
11150   }
11151   {
11152     char fstype[] = "ext2";
11153     char device[] = "/dev/sda1";
11154     int r;
11155     suppress_error = 0;
11156     r = guestfs_mkfs (g, fstype, device);
11157     if (r == -1)
11158       return -1;
11159   }
11160   {
11161     char device[] = "/dev/sda1";
11162     char mountpoint[] = "/";
11163     int r;
11164     suppress_error = 0;
11165     r = guestfs_mount (g, device, mountpoint);
11166     if (r == -1)
11167       return -1;
11168   }
11169   /* TestOutputList for command_lines (9) */
11170   {
11171     char remotefilename[] = "/test-command";
11172     int r;
11173     suppress_error = 0;
11174     r = guestfs_upload (g, "test-command", remotefilename);
11175     if (r == -1)
11176       return -1;
11177   }
11178   {
11179     char path[] = "/test-command";
11180     int r;
11181     suppress_error = 0;
11182     r = guestfs_chmod (g, 493, path);
11183     if (r == -1)
11184       return -1;
11185   }
11186   {
11187     char arguments_0[] = "/test-command";
11188     char arguments_1[] = "10";
11189     char *arguments[] = {
11190       arguments_0,
11191       arguments_1,
11192       NULL
11193     };
11194     char **r;
11195     int i;
11196     suppress_error = 0;
11197     r = guestfs_command_lines (g, arguments);
11198     if (r == NULL)
11199       return -1;
11200     if (!r[0]) {
11201       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11202       print_strings (r);
11203       return -1;
11204     }
11205     {
11206       char expected[] = "Result10-1";
11207       if (strcmp (r[0], expected) != 0) {
11208         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11209         return -1;
11210       }
11211     }
11212     if (!r[1]) {
11213       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11214       print_strings (r);
11215       return -1;
11216     }
11217     {
11218       char expected[] = "Result10-2";
11219       if (strcmp (r[1], expected) != 0) {
11220         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11221         return -1;
11222       }
11223     }
11224     if (r[2] != NULL) {
11225       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11226       print_strings (r);
11227       return -1;
11228     }
11229     for (i = 0; r[i] != NULL; ++i)
11230       free (r[i]);
11231     free (r);
11232   }
11233   return 0;
11234 }
11235
11236 static int test_command_lines_10_skip (void)
11237 {
11238   const char *str;
11239
11240   str = getenv ("TEST_ONLY");
11241   if (str)
11242     return strstr (str, "command_lines") == NULL;
11243   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11244   if (str && strcmp (str, "1") == 0) return 1;
11245   str = getenv ("SKIP_TEST_COMMAND_LINES");
11246   if (str && strcmp (str, "1") == 0) return 1;
11247   return 0;
11248 }
11249
11250 static int test_command_lines_10 (void)
11251 {
11252   if (test_command_lines_10_skip ()) {
11253     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
11254     return 0;
11255   }
11256
11257   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11258   {
11259     char device[] = "/dev/sda";
11260     int r;
11261     suppress_error = 0;
11262     r = guestfs_blockdev_setrw (g, device);
11263     if (r == -1)
11264       return -1;
11265   }
11266   {
11267     int r;
11268     suppress_error = 0;
11269     r = guestfs_umount_all (g);
11270     if (r == -1)
11271       return -1;
11272   }
11273   {
11274     int r;
11275     suppress_error = 0;
11276     r = guestfs_lvm_remove_all (g);
11277     if (r == -1)
11278       return -1;
11279   }
11280   {
11281     char device[] = "/dev/sda";
11282     char lines_0[] = ",";
11283     char *lines[] = {
11284       lines_0,
11285       NULL
11286     };
11287     int r;
11288     suppress_error = 0;
11289     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11290     if (r == -1)
11291       return -1;
11292   }
11293   {
11294     char fstype[] = "ext2";
11295     char device[] = "/dev/sda1";
11296     int r;
11297     suppress_error = 0;
11298     r = guestfs_mkfs (g, fstype, device);
11299     if (r == -1)
11300       return -1;
11301   }
11302   {
11303     char device[] = "/dev/sda1";
11304     char mountpoint[] = "/";
11305     int r;
11306     suppress_error = 0;
11307     r = guestfs_mount (g, device, mountpoint);
11308     if (r == -1)
11309       return -1;
11310   }
11311   /* TestOutputList for command_lines (10) */
11312   {
11313     char remotefilename[] = "/test-command";
11314     int r;
11315     suppress_error = 0;
11316     r = guestfs_upload (g, "test-command", remotefilename);
11317     if (r == -1)
11318       return -1;
11319   }
11320   {
11321     char path[] = "/test-command";
11322     int r;
11323     suppress_error = 0;
11324     r = guestfs_chmod (g, 493, path);
11325     if (r == -1)
11326       return -1;
11327   }
11328   {
11329     char arguments_0[] = "/test-command";
11330     char arguments_1[] = "11";
11331     char *arguments[] = {
11332       arguments_0,
11333       arguments_1,
11334       NULL
11335     };
11336     char **r;
11337     int i;
11338     suppress_error = 0;
11339     r = guestfs_command_lines (g, arguments);
11340     if (r == NULL)
11341       return -1;
11342     if (!r[0]) {
11343       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11344       print_strings (r);
11345       return -1;
11346     }
11347     {
11348       char expected[] = "Result11-1";
11349       if (strcmp (r[0], expected) != 0) {
11350         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11351         return -1;
11352       }
11353     }
11354     if (!r[1]) {
11355       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11356       print_strings (r);
11357       return -1;
11358     }
11359     {
11360       char expected[] = "Result11-2";
11361       if (strcmp (r[1], expected) != 0) {
11362         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11363         return -1;
11364       }
11365     }
11366     if (r[2] != NULL) {
11367       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11368       print_strings (r);
11369       return -1;
11370     }
11371     for (i = 0; r[i] != NULL; ++i)
11372       free (r[i]);
11373     free (r);
11374   }
11375   return 0;
11376 }
11377
11378 static int test_command_0_skip (void)
11379 {
11380   const char *str;
11381
11382   str = getenv ("TEST_ONLY");
11383   if (str)
11384     return strstr (str, "command") == NULL;
11385   str = getenv ("SKIP_TEST_COMMAND_0");
11386   if (str && strcmp (str, "1") == 0) return 1;
11387   str = getenv ("SKIP_TEST_COMMAND");
11388   if (str && strcmp (str, "1") == 0) return 1;
11389   return 0;
11390 }
11391
11392 static int test_command_0 (void)
11393 {
11394   if (test_command_0_skip ()) {
11395     printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11396     return 0;
11397   }
11398
11399   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11400   {
11401     char device[] = "/dev/sda";
11402     int r;
11403     suppress_error = 0;
11404     r = guestfs_blockdev_setrw (g, device);
11405     if (r == -1)
11406       return -1;
11407   }
11408   {
11409     int r;
11410     suppress_error = 0;
11411     r = guestfs_umount_all (g);
11412     if (r == -1)
11413       return -1;
11414   }
11415   {
11416     int r;
11417     suppress_error = 0;
11418     r = guestfs_lvm_remove_all (g);
11419     if (r == -1)
11420       return -1;
11421   }
11422   {
11423     char device[] = "/dev/sda";
11424     char lines_0[] = ",";
11425     char *lines[] = {
11426       lines_0,
11427       NULL
11428     };
11429     int r;
11430     suppress_error = 0;
11431     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11432     if (r == -1)
11433       return -1;
11434   }
11435   {
11436     char fstype[] = "ext2";
11437     char device[] = "/dev/sda1";
11438     int r;
11439     suppress_error = 0;
11440     r = guestfs_mkfs (g, fstype, device);
11441     if (r == -1)
11442       return -1;
11443   }
11444   {
11445     char device[] = "/dev/sda1";
11446     char mountpoint[] = "/";
11447     int r;
11448     suppress_error = 0;
11449     r = guestfs_mount (g, device, mountpoint);
11450     if (r == -1)
11451       return -1;
11452   }
11453   /* TestOutput for command (0) */
11454   char expected[] = "Result1";
11455   {
11456     char remotefilename[] = "/test-command";
11457     int r;
11458     suppress_error = 0;
11459     r = guestfs_upload (g, "test-command", remotefilename);
11460     if (r == -1)
11461       return -1;
11462   }
11463   {
11464     char path[] = "/test-command";
11465     int r;
11466     suppress_error = 0;
11467     r = guestfs_chmod (g, 493, path);
11468     if (r == -1)
11469       return -1;
11470   }
11471   {
11472     char arguments_0[] = "/test-command";
11473     char arguments_1[] = "1";
11474     char *arguments[] = {
11475       arguments_0,
11476       arguments_1,
11477       NULL
11478     };
11479     char *r;
11480     suppress_error = 0;
11481     r = guestfs_command (g, arguments);
11482     if (r == NULL)
11483       return -1;
11484     if (strcmp (r, expected) != 0) {
11485       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11486       return -1;
11487     }
11488     free (r);
11489   }
11490   return 0;
11491 }
11492
11493 static int test_command_1_skip (void)
11494 {
11495   const char *str;
11496
11497   str = getenv ("TEST_ONLY");
11498   if (str)
11499     return strstr (str, "command") == NULL;
11500   str = getenv ("SKIP_TEST_COMMAND_1");
11501   if (str && strcmp (str, "1") == 0) return 1;
11502   str = getenv ("SKIP_TEST_COMMAND");
11503   if (str && strcmp (str, "1") == 0) return 1;
11504   return 0;
11505 }
11506
11507 static int test_command_1 (void)
11508 {
11509   if (test_command_1_skip ()) {
11510     printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11511     return 0;
11512   }
11513
11514   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11515   {
11516     char device[] = "/dev/sda";
11517     int r;
11518     suppress_error = 0;
11519     r = guestfs_blockdev_setrw (g, device);
11520     if (r == -1)
11521       return -1;
11522   }
11523   {
11524     int r;
11525     suppress_error = 0;
11526     r = guestfs_umount_all (g);
11527     if (r == -1)
11528       return -1;
11529   }
11530   {
11531     int r;
11532     suppress_error = 0;
11533     r = guestfs_lvm_remove_all (g);
11534     if (r == -1)
11535       return -1;
11536   }
11537   {
11538     char device[] = "/dev/sda";
11539     char lines_0[] = ",";
11540     char *lines[] = {
11541       lines_0,
11542       NULL
11543     };
11544     int r;
11545     suppress_error = 0;
11546     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11547     if (r == -1)
11548       return -1;
11549   }
11550   {
11551     char fstype[] = "ext2";
11552     char device[] = "/dev/sda1";
11553     int r;
11554     suppress_error = 0;
11555     r = guestfs_mkfs (g, fstype, device);
11556     if (r == -1)
11557       return -1;
11558   }
11559   {
11560     char device[] = "/dev/sda1";
11561     char mountpoint[] = "/";
11562     int r;
11563     suppress_error = 0;
11564     r = guestfs_mount (g, device, mountpoint);
11565     if (r == -1)
11566       return -1;
11567   }
11568   /* TestOutput for command (1) */
11569   char expected[] = "Result2\n";
11570   {
11571     char remotefilename[] = "/test-command";
11572     int r;
11573     suppress_error = 0;
11574     r = guestfs_upload (g, "test-command", remotefilename);
11575     if (r == -1)
11576       return -1;
11577   }
11578   {
11579     char path[] = "/test-command";
11580     int r;
11581     suppress_error = 0;
11582     r = guestfs_chmod (g, 493, path);
11583     if (r == -1)
11584       return -1;
11585   }
11586   {
11587     char arguments_0[] = "/test-command";
11588     char arguments_1[] = "2";
11589     char *arguments[] = {
11590       arguments_0,
11591       arguments_1,
11592       NULL
11593     };
11594     char *r;
11595     suppress_error = 0;
11596     r = guestfs_command (g, arguments);
11597     if (r == NULL)
11598       return -1;
11599     if (strcmp (r, expected) != 0) {
11600       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11601       return -1;
11602     }
11603     free (r);
11604   }
11605   return 0;
11606 }
11607
11608 static int test_command_2_skip (void)
11609 {
11610   const char *str;
11611
11612   str = getenv ("TEST_ONLY");
11613   if (str)
11614     return strstr (str, "command") == NULL;
11615   str = getenv ("SKIP_TEST_COMMAND_2");
11616   if (str && strcmp (str, "1") == 0) return 1;
11617   str = getenv ("SKIP_TEST_COMMAND");
11618   if (str && strcmp (str, "1") == 0) return 1;
11619   return 0;
11620 }
11621
11622 static int test_command_2 (void)
11623 {
11624   if (test_command_2_skip ()) {
11625     printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11626     return 0;
11627   }
11628
11629   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11630   {
11631     char device[] = "/dev/sda";
11632     int r;
11633     suppress_error = 0;
11634     r = guestfs_blockdev_setrw (g, device);
11635     if (r == -1)
11636       return -1;
11637   }
11638   {
11639     int r;
11640     suppress_error = 0;
11641     r = guestfs_umount_all (g);
11642     if (r == -1)
11643       return -1;
11644   }
11645   {
11646     int r;
11647     suppress_error = 0;
11648     r = guestfs_lvm_remove_all (g);
11649     if (r == -1)
11650       return -1;
11651   }
11652   {
11653     char device[] = "/dev/sda";
11654     char lines_0[] = ",";
11655     char *lines[] = {
11656       lines_0,
11657       NULL
11658     };
11659     int r;
11660     suppress_error = 0;
11661     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11662     if (r == -1)
11663       return -1;
11664   }
11665   {
11666     char fstype[] = "ext2";
11667     char device[] = "/dev/sda1";
11668     int r;
11669     suppress_error = 0;
11670     r = guestfs_mkfs (g, fstype, device);
11671     if (r == -1)
11672       return -1;
11673   }
11674   {
11675     char device[] = "/dev/sda1";
11676     char mountpoint[] = "/";
11677     int r;
11678     suppress_error = 0;
11679     r = guestfs_mount (g, device, mountpoint);
11680     if (r == -1)
11681       return -1;
11682   }
11683   /* TestOutput for command (2) */
11684   char expected[] = "\nResult3";
11685   {
11686     char remotefilename[] = "/test-command";
11687     int r;
11688     suppress_error = 0;
11689     r = guestfs_upload (g, "test-command", remotefilename);
11690     if (r == -1)
11691       return -1;
11692   }
11693   {
11694     char path[] = "/test-command";
11695     int r;
11696     suppress_error = 0;
11697     r = guestfs_chmod (g, 493, path);
11698     if (r == -1)
11699       return -1;
11700   }
11701   {
11702     char arguments_0[] = "/test-command";
11703     char arguments_1[] = "3";
11704     char *arguments[] = {
11705       arguments_0,
11706       arguments_1,
11707       NULL
11708     };
11709     char *r;
11710     suppress_error = 0;
11711     r = guestfs_command (g, arguments);
11712     if (r == NULL)
11713       return -1;
11714     if (strcmp (r, expected) != 0) {
11715       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11716       return -1;
11717     }
11718     free (r);
11719   }
11720   return 0;
11721 }
11722
11723 static int test_command_3_skip (void)
11724 {
11725   const char *str;
11726
11727   str = getenv ("TEST_ONLY");
11728   if (str)
11729     return strstr (str, "command") == NULL;
11730   str = getenv ("SKIP_TEST_COMMAND_3");
11731   if (str && strcmp (str, "1") == 0) return 1;
11732   str = getenv ("SKIP_TEST_COMMAND");
11733   if (str && strcmp (str, "1") == 0) return 1;
11734   return 0;
11735 }
11736
11737 static int test_command_3 (void)
11738 {
11739   if (test_command_3_skip ()) {
11740     printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11741     return 0;
11742   }
11743
11744   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11745   {
11746     char device[] = "/dev/sda";
11747     int r;
11748     suppress_error = 0;
11749     r = guestfs_blockdev_setrw (g, device);
11750     if (r == -1)
11751       return -1;
11752   }
11753   {
11754     int r;
11755     suppress_error = 0;
11756     r = guestfs_umount_all (g);
11757     if (r == -1)
11758       return -1;
11759   }
11760   {
11761     int r;
11762     suppress_error = 0;
11763     r = guestfs_lvm_remove_all (g);
11764     if (r == -1)
11765       return -1;
11766   }
11767   {
11768     char device[] = "/dev/sda";
11769     char lines_0[] = ",";
11770     char *lines[] = {
11771       lines_0,
11772       NULL
11773     };
11774     int r;
11775     suppress_error = 0;
11776     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11777     if (r == -1)
11778       return -1;
11779   }
11780   {
11781     char fstype[] = "ext2";
11782     char device[] = "/dev/sda1";
11783     int r;
11784     suppress_error = 0;
11785     r = guestfs_mkfs (g, fstype, device);
11786     if (r == -1)
11787       return -1;
11788   }
11789   {
11790     char device[] = "/dev/sda1";
11791     char mountpoint[] = "/";
11792     int r;
11793     suppress_error = 0;
11794     r = guestfs_mount (g, device, mountpoint);
11795     if (r == -1)
11796       return -1;
11797   }
11798   /* TestOutput for command (3) */
11799   char expected[] = "\nResult4\n";
11800   {
11801     char remotefilename[] = "/test-command";
11802     int r;
11803     suppress_error = 0;
11804     r = guestfs_upload (g, "test-command", remotefilename);
11805     if (r == -1)
11806       return -1;
11807   }
11808   {
11809     char path[] = "/test-command";
11810     int r;
11811     suppress_error = 0;
11812     r = guestfs_chmod (g, 493, path);
11813     if (r == -1)
11814       return -1;
11815   }
11816   {
11817     char arguments_0[] = "/test-command";
11818     char arguments_1[] = "4";
11819     char *arguments[] = {
11820       arguments_0,
11821       arguments_1,
11822       NULL
11823     };
11824     char *r;
11825     suppress_error = 0;
11826     r = guestfs_command (g, arguments);
11827     if (r == NULL)
11828       return -1;
11829     if (strcmp (r, expected) != 0) {
11830       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11831       return -1;
11832     }
11833     free (r);
11834   }
11835   return 0;
11836 }
11837
11838 static int test_command_4_skip (void)
11839 {
11840   const char *str;
11841
11842   str = getenv ("TEST_ONLY");
11843   if (str)
11844     return strstr (str, "command") == NULL;
11845   str = getenv ("SKIP_TEST_COMMAND_4");
11846   if (str && strcmp (str, "1") == 0) return 1;
11847   str = getenv ("SKIP_TEST_COMMAND");
11848   if (str && strcmp (str, "1") == 0) return 1;
11849   return 0;
11850 }
11851
11852 static int test_command_4 (void)
11853 {
11854   if (test_command_4_skip ()) {
11855     printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11856     return 0;
11857   }
11858
11859   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11860   {
11861     char device[] = "/dev/sda";
11862     int r;
11863     suppress_error = 0;
11864     r = guestfs_blockdev_setrw (g, device);
11865     if (r == -1)
11866       return -1;
11867   }
11868   {
11869     int r;
11870     suppress_error = 0;
11871     r = guestfs_umount_all (g);
11872     if (r == -1)
11873       return -1;
11874   }
11875   {
11876     int r;
11877     suppress_error = 0;
11878     r = guestfs_lvm_remove_all (g);
11879     if (r == -1)
11880       return -1;
11881   }
11882   {
11883     char device[] = "/dev/sda";
11884     char lines_0[] = ",";
11885     char *lines[] = {
11886       lines_0,
11887       NULL
11888     };
11889     int r;
11890     suppress_error = 0;
11891     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11892     if (r == -1)
11893       return -1;
11894   }
11895   {
11896     char fstype[] = "ext2";
11897     char device[] = "/dev/sda1";
11898     int r;
11899     suppress_error = 0;
11900     r = guestfs_mkfs (g, fstype, device);
11901     if (r == -1)
11902       return -1;
11903   }
11904   {
11905     char device[] = "/dev/sda1";
11906     char mountpoint[] = "/";
11907     int r;
11908     suppress_error = 0;
11909     r = guestfs_mount (g, device, mountpoint);
11910     if (r == -1)
11911       return -1;
11912   }
11913   /* TestOutput for command (4) */
11914   char expected[] = "\nResult5\n\n";
11915   {
11916     char remotefilename[] = "/test-command";
11917     int r;
11918     suppress_error = 0;
11919     r = guestfs_upload (g, "test-command", remotefilename);
11920     if (r == -1)
11921       return -1;
11922   }
11923   {
11924     char path[] = "/test-command";
11925     int r;
11926     suppress_error = 0;
11927     r = guestfs_chmod (g, 493, path);
11928     if (r == -1)
11929       return -1;
11930   }
11931   {
11932     char arguments_0[] = "/test-command";
11933     char arguments_1[] = "5";
11934     char *arguments[] = {
11935       arguments_0,
11936       arguments_1,
11937       NULL
11938     };
11939     char *r;
11940     suppress_error = 0;
11941     r = guestfs_command (g, arguments);
11942     if (r == NULL)
11943       return -1;
11944     if (strcmp (r, expected) != 0) {
11945       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11946       return -1;
11947     }
11948     free (r);
11949   }
11950   return 0;
11951 }
11952
11953 static int test_command_5_skip (void)
11954 {
11955   const char *str;
11956
11957   str = getenv ("TEST_ONLY");
11958   if (str)
11959     return strstr (str, "command") == NULL;
11960   str = getenv ("SKIP_TEST_COMMAND_5");
11961   if (str && strcmp (str, "1") == 0) return 1;
11962   str = getenv ("SKIP_TEST_COMMAND");
11963   if (str && strcmp (str, "1") == 0) return 1;
11964   return 0;
11965 }
11966
11967 static int test_command_5 (void)
11968 {
11969   if (test_command_5_skip ()) {
11970     printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11971     return 0;
11972   }
11973
11974   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11975   {
11976     char device[] = "/dev/sda";
11977     int r;
11978     suppress_error = 0;
11979     r = guestfs_blockdev_setrw (g, device);
11980     if (r == -1)
11981       return -1;
11982   }
11983   {
11984     int r;
11985     suppress_error = 0;
11986     r = guestfs_umount_all (g);
11987     if (r == -1)
11988       return -1;
11989   }
11990   {
11991     int r;
11992     suppress_error = 0;
11993     r = guestfs_lvm_remove_all (g);
11994     if (r == -1)
11995       return -1;
11996   }
11997   {
11998     char device[] = "/dev/sda";
11999     char lines_0[] = ",";
12000     char *lines[] = {
12001       lines_0,
12002       NULL
12003     };
12004     int r;
12005     suppress_error = 0;
12006     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12007     if (r == -1)
12008       return -1;
12009   }
12010   {
12011     char fstype[] = "ext2";
12012     char device[] = "/dev/sda1";
12013     int r;
12014     suppress_error = 0;
12015     r = guestfs_mkfs (g, fstype, device);
12016     if (r == -1)
12017       return -1;
12018   }
12019   {
12020     char device[] = "/dev/sda1";
12021     char mountpoint[] = "/";
12022     int r;
12023     suppress_error = 0;
12024     r = guestfs_mount (g, device, mountpoint);
12025     if (r == -1)
12026       return -1;
12027   }
12028   /* TestOutput for command (5) */
12029   char expected[] = "\n\nResult6\n\n";
12030   {
12031     char remotefilename[] = "/test-command";
12032     int r;
12033     suppress_error = 0;
12034     r = guestfs_upload (g, "test-command", remotefilename);
12035     if (r == -1)
12036       return -1;
12037   }
12038   {
12039     char path[] = "/test-command";
12040     int r;
12041     suppress_error = 0;
12042     r = guestfs_chmod (g, 493, path);
12043     if (r == -1)
12044       return -1;
12045   }
12046   {
12047     char arguments_0[] = "/test-command";
12048     char arguments_1[] = "6";
12049     char *arguments[] = {
12050       arguments_0,
12051       arguments_1,
12052       NULL
12053     };
12054     char *r;
12055     suppress_error = 0;
12056     r = guestfs_command (g, arguments);
12057     if (r == NULL)
12058       return -1;
12059     if (strcmp (r, expected) != 0) {
12060       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
12061       return -1;
12062     }
12063     free (r);
12064   }
12065   return 0;
12066 }
12067
12068 static int test_command_6_skip (void)
12069 {
12070   const char *str;
12071
12072   str = getenv ("TEST_ONLY");
12073   if (str)
12074     return strstr (str, "command") == NULL;
12075   str = getenv ("SKIP_TEST_COMMAND_6");
12076   if (str && strcmp (str, "1") == 0) return 1;
12077   str = getenv ("SKIP_TEST_COMMAND");
12078   if (str && strcmp (str, "1") == 0) return 1;
12079   return 0;
12080 }
12081
12082 static int test_command_6 (void)
12083 {
12084   if (test_command_6_skip ()) {
12085     printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
12086     return 0;
12087   }
12088
12089   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
12090   {
12091     char device[] = "/dev/sda";
12092     int r;
12093     suppress_error = 0;
12094     r = guestfs_blockdev_setrw (g, device);
12095     if (r == -1)
12096       return -1;
12097   }
12098   {
12099     int r;
12100     suppress_error = 0;
12101     r = guestfs_umount_all (g);
12102     if (r == -1)
12103       return -1;
12104   }
12105   {
12106     int r;
12107     suppress_error = 0;
12108     r = guestfs_lvm_remove_all (g);
12109     if (r == -1)
12110       return -1;
12111   }
12112   {
12113     char device[] = "/dev/sda";
12114     char lines_0[] = ",";
12115     char *lines[] = {
12116       lines_0,
12117       NULL
12118     };
12119     int r;
12120     suppress_error = 0;
12121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12122     if (r == -1)
12123       return -1;
12124   }
12125   {
12126     char fstype[] = "ext2";
12127     char device[] = "/dev/sda1";
12128     int r;
12129     suppress_error = 0;
12130     r = guestfs_mkfs (g, fstype, device);
12131     if (r == -1)
12132       return -1;
12133   }
12134   {
12135     char device[] = "/dev/sda1";
12136     char mountpoint[] = "/";
12137     int r;
12138     suppress_error = 0;
12139     r = guestfs_mount (g, device, mountpoint);
12140     if (r == -1)
12141       return -1;
12142   }
12143   /* TestOutput for command (6) */
12144   char expected[] = "";
12145   {
12146     char remotefilename[] = "/test-command";
12147     int r;
12148     suppress_error = 0;
12149     r = guestfs_upload (g, "test-command", remotefilename);
12150     if (r == -1)
12151       return -1;
12152   }
12153   {
12154     char path[] = "/test-command";
12155     int r;
12156     suppress_error = 0;
12157     r = guestfs_chmod (g, 493, path);
12158     if (r == -1)
12159       return -1;
12160   }
12161   {
12162     char arguments_0[] = "/test-command";
12163     char arguments_1[] = "7";
12164     char *arguments[] = {
12165       arguments_0,
12166       arguments_1,
12167       NULL
12168     };
12169     char *r;
12170     suppress_error = 0;
12171     r = guestfs_command (g, arguments);
12172     if (r == NULL)
12173       return -1;
12174     if (strcmp (r, expected) != 0) {
12175       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
12176       return -1;
12177     }
12178     free (r);
12179   }
12180   return 0;
12181 }
12182
12183 static int test_command_7_skip (void)
12184 {
12185   const char *str;
12186
12187   str = getenv ("TEST_ONLY");
12188   if (str)
12189     return strstr (str, "command") == NULL;
12190   str = getenv ("SKIP_TEST_COMMAND_7");
12191   if (str && strcmp (str, "1") == 0) return 1;
12192   str = getenv ("SKIP_TEST_COMMAND");
12193   if (str && strcmp (str, "1") == 0) return 1;
12194   return 0;
12195 }
12196
12197 static int test_command_7 (void)
12198 {
12199   if (test_command_7_skip ()) {
12200     printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
12201     return 0;
12202   }
12203
12204   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
12205   {
12206     char device[] = "/dev/sda";
12207     int r;
12208     suppress_error = 0;
12209     r = guestfs_blockdev_setrw (g, device);
12210     if (r == -1)
12211       return -1;
12212   }
12213   {
12214     int r;
12215     suppress_error = 0;
12216     r = guestfs_umount_all (g);
12217     if (r == -1)
12218       return -1;
12219   }
12220   {
12221     int r;
12222     suppress_error = 0;
12223     r = guestfs_lvm_remove_all (g);
12224     if (r == -1)
12225       return -1;
12226   }
12227   {
12228     char device[] = "/dev/sda";
12229     char lines_0[] = ",";
12230     char *lines[] = {
12231       lines_0,
12232       NULL
12233     };
12234     int r;
12235     suppress_error = 0;
12236     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12237     if (r == -1)
12238       return -1;
12239   }
12240   {
12241     char fstype[] = "ext2";
12242     char device[] = "/dev/sda1";
12243     int r;
12244     suppress_error = 0;
12245     r = guestfs_mkfs (g, fstype, device);
12246     if (r == -1)
12247       return -1;
12248   }
12249   {
12250     char device[] = "/dev/sda1";
12251     char mountpoint[] = "/";
12252     int r;
12253     suppress_error = 0;
12254     r = guestfs_mount (g, device, mountpoint);
12255     if (r == -1)
12256       return -1;
12257   }
12258   /* TestOutput for command (7) */
12259   char expected[] = "\n";
12260   {
12261     char remotefilename[] = "/test-command";
12262     int r;
12263     suppress_error = 0;
12264     r = guestfs_upload (g, "test-command", remotefilename);
12265     if (r == -1)
12266       return -1;
12267   }
12268   {
12269     char path[] = "/test-command";
12270     int r;
12271     suppress_error = 0;
12272     r = guestfs_chmod (g, 493, path);
12273     if (r == -1)
12274       return -1;
12275   }
12276   {
12277     char arguments_0[] = "/test-command";
12278     char arguments_1[] = "8";
12279     char *arguments[] = {
12280       arguments_0,
12281       arguments_1,
12282       NULL
12283     };
12284     char *r;
12285     suppress_error = 0;
12286     r = guestfs_command (g, arguments);
12287     if (r == NULL)
12288       return -1;
12289     if (strcmp (r, expected) != 0) {
12290       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12291       return -1;
12292     }
12293     free (r);
12294   }
12295   return 0;
12296 }
12297
12298 static int test_command_8_skip (void)
12299 {
12300   const char *str;
12301
12302   str = getenv ("TEST_ONLY");
12303   if (str)
12304     return strstr (str, "command") == NULL;
12305   str = getenv ("SKIP_TEST_COMMAND_8");
12306   if (str && strcmp (str, "1") == 0) return 1;
12307   str = getenv ("SKIP_TEST_COMMAND");
12308   if (str && strcmp (str, "1") == 0) return 1;
12309   return 0;
12310 }
12311
12312 static int test_command_8 (void)
12313 {
12314   if (test_command_8_skip ()) {
12315     printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
12316     return 0;
12317   }
12318
12319   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12320   {
12321     char device[] = "/dev/sda";
12322     int r;
12323     suppress_error = 0;
12324     r = guestfs_blockdev_setrw (g, device);
12325     if (r == -1)
12326       return -1;
12327   }
12328   {
12329     int r;
12330     suppress_error = 0;
12331     r = guestfs_umount_all (g);
12332     if (r == -1)
12333       return -1;
12334   }
12335   {
12336     int r;
12337     suppress_error = 0;
12338     r = guestfs_lvm_remove_all (g);
12339     if (r == -1)
12340       return -1;
12341   }
12342   {
12343     char device[] = "/dev/sda";
12344     char lines_0[] = ",";
12345     char *lines[] = {
12346       lines_0,
12347       NULL
12348     };
12349     int r;
12350     suppress_error = 0;
12351     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12352     if (r == -1)
12353       return -1;
12354   }
12355   {
12356     char fstype[] = "ext2";
12357     char device[] = "/dev/sda1";
12358     int r;
12359     suppress_error = 0;
12360     r = guestfs_mkfs (g, fstype, device);
12361     if (r == -1)
12362       return -1;
12363   }
12364   {
12365     char device[] = "/dev/sda1";
12366     char mountpoint[] = "/";
12367     int r;
12368     suppress_error = 0;
12369     r = guestfs_mount (g, device, mountpoint);
12370     if (r == -1)
12371       return -1;
12372   }
12373   /* TestOutput for command (8) */
12374   char expected[] = "\n\n";
12375   {
12376     char remotefilename[] = "/test-command";
12377     int r;
12378     suppress_error = 0;
12379     r = guestfs_upload (g, "test-command", remotefilename);
12380     if (r == -1)
12381       return -1;
12382   }
12383   {
12384     char path[] = "/test-command";
12385     int r;
12386     suppress_error = 0;
12387     r = guestfs_chmod (g, 493, path);
12388     if (r == -1)
12389       return -1;
12390   }
12391   {
12392     char arguments_0[] = "/test-command";
12393     char arguments_1[] = "9";
12394     char *arguments[] = {
12395       arguments_0,
12396       arguments_1,
12397       NULL
12398     };
12399     char *r;
12400     suppress_error = 0;
12401     r = guestfs_command (g, arguments);
12402     if (r == NULL)
12403       return -1;
12404     if (strcmp (r, expected) != 0) {
12405       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12406       return -1;
12407     }
12408     free (r);
12409   }
12410   return 0;
12411 }
12412
12413 static int test_command_9_skip (void)
12414 {
12415   const char *str;
12416
12417   str = getenv ("TEST_ONLY");
12418   if (str)
12419     return strstr (str, "command") == NULL;
12420   str = getenv ("SKIP_TEST_COMMAND_9");
12421   if (str && strcmp (str, "1") == 0) return 1;
12422   str = getenv ("SKIP_TEST_COMMAND");
12423   if (str && strcmp (str, "1") == 0) return 1;
12424   return 0;
12425 }
12426
12427 static int test_command_9 (void)
12428 {
12429   if (test_command_9_skip ()) {
12430     printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12431     return 0;
12432   }
12433
12434   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12435   {
12436     char device[] = "/dev/sda";
12437     int r;
12438     suppress_error = 0;
12439     r = guestfs_blockdev_setrw (g, device);
12440     if (r == -1)
12441       return -1;
12442   }
12443   {
12444     int r;
12445     suppress_error = 0;
12446     r = guestfs_umount_all (g);
12447     if (r == -1)
12448       return -1;
12449   }
12450   {
12451     int r;
12452     suppress_error = 0;
12453     r = guestfs_lvm_remove_all (g);
12454     if (r == -1)
12455       return -1;
12456   }
12457   {
12458     char device[] = "/dev/sda";
12459     char lines_0[] = ",";
12460     char *lines[] = {
12461       lines_0,
12462       NULL
12463     };
12464     int r;
12465     suppress_error = 0;
12466     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12467     if (r == -1)
12468       return -1;
12469   }
12470   {
12471     char fstype[] = "ext2";
12472     char device[] = "/dev/sda1";
12473     int r;
12474     suppress_error = 0;
12475     r = guestfs_mkfs (g, fstype, device);
12476     if (r == -1)
12477       return -1;
12478   }
12479   {
12480     char device[] = "/dev/sda1";
12481     char mountpoint[] = "/";
12482     int r;
12483     suppress_error = 0;
12484     r = guestfs_mount (g, device, mountpoint);
12485     if (r == -1)
12486       return -1;
12487   }
12488   /* TestOutput for command (9) */
12489   char expected[] = "Result10-1\nResult10-2\n";
12490   {
12491     char remotefilename[] = "/test-command";
12492     int r;
12493     suppress_error = 0;
12494     r = guestfs_upload (g, "test-command", remotefilename);
12495     if (r == -1)
12496       return -1;
12497   }
12498   {
12499     char path[] = "/test-command";
12500     int r;
12501     suppress_error = 0;
12502     r = guestfs_chmod (g, 493, path);
12503     if (r == -1)
12504       return -1;
12505   }
12506   {
12507     char arguments_0[] = "/test-command";
12508     char arguments_1[] = "10";
12509     char *arguments[] = {
12510       arguments_0,
12511       arguments_1,
12512       NULL
12513     };
12514     char *r;
12515     suppress_error = 0;
12516     r = guestfs_command (g, arguments);
12517     if (r == NULL)
12518       return -1;
12519     if (strcmp (r, expected) != 0) {
12520       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12521       return -1;
12522     }
12523     free (r);
12524   }
12525   return 0;
12526 }
12527
12528 static int test_command_10_skip (void)
12529 {
12530   const char *str;
12531
12532   str = getenv ("TEST_ONLY");
12533   if (str)
12534     return strstr (str, "command") == NULL;
12535   str = getenv ("SKIP_TEST_COMMAND_10");
12536   if (str && strcmp (str, "1") == 0) return 1;
12537   str = getenv ("SKIP_TEST_COMMAND");
12538   if (str && strcmp (str, "1") == 0) return 1;
12539   return 0;
12540 }
12541
12542 static int test_command_10 (void)
12543 {
12544   if (test_command_10_skip ()) {
12545     printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12546     return 0;
12547   }
12548
12549   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12550   {
12551     char device[] = "/dev/sda";
12552     int r;
12553     suppress_error = 0;
12554     r = guestfs_blockdev_setrw (g, device);
12555     if (r == -1)
12556       return -1;
12557   }
12558   {
12559     int r;
12560     suppress_error = 0;
12561     r = guestfs_umount_all (g);
12562     if (r == -1)
12563       return -1;
12564   }
12565   {
12566     int r;
12567     suppress_error = 0;
12568     r = guestfs_lvm_remove_all (g);
12569     if (r == -1)
12570       return -1;
12571   }
12572   {
12573     char device[] = "/dev/sda";
12574     char lines_0[] = ",";
12575     char *lines[] = {
12576       lines_0,
12577       NULL
12578     };
12579     int r;
12580     suppress_error = 0;
12581     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12582     if (r == -1)
12583       return -1;
12584   }
12585   {
12586     char fstype[] = "ext2";
12587     char device[] = "/dev/sda1";
12588     int r;
12589     suppress_error = 0;
12590     r = guestfs_mkfs (g, fstype, device);
12591     if (r == -1)
12592       return -1;
12593   }
12594   {
12595     char device[] = "/dev/sda1";
12596     char mountpoint[] = "/";
12597     int r;
12598     suppress_error = 0;
12599     r = guestfs_mount (g, device, mountpoint);
12600     if (r == -1)
12601       return -1;
12602   }
12603   /* TestOutput for command (10) */
12604   char expected[] = "Result11-1\nResult11-2";
12605   {
12606     char remotefilename[] = "/test-command";
12607     int r;
12608     suppress_error = 0;
12609     r = guestfs_upload (g, "test-command", remotefilename);
12610     if (r == -1)
12611       return -1;
12612   }
12613   {
12614     char path[] = "/test-command";
12615     int r;
12616     suppress_error = 0;
12617     r = guestfs_chmod (g, 493, path);
12618     if (r == -1)
12619       return -1;
12620   }
12621   {
12622     char arguments_0[] = "/test-command";
12623     char arguments_1[] = "11";
12624     char *arguments[] = {
12625       arguments_0,
12626       arguments_1,
12627       NULL
12628     };
12629     char *r;
12630     suppress_error = 0;
12631     r = guestfs_command (g, arguments);
12632     if (r == NULL)
12633       return -1;
12634     if (strcmp (r, expected) != 0) {
12635       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12636       return -1;
12637     }
12638     free (r);
12639   }
12640   return 0;
12641 }
12642
12643 static int test_command_11_skip (void)
12644 {
12645   const char *str;
12646
12647   str = getenv ("TEST_ONLY");
12648   if (str)
12649     return strstr (str, "command") == NULL;
12650   str = getenv ("SKIP_TEST_COMMAND_11");
12651   if (str && strcmp (str, "1") == 0) return 1;
12652   str = getenv ("SKIP_TEST_COMMAND");
12653   if (str && strcmp (str, "1") == 0) return 1;
12654   return 0;
12655 }
12656
12657 static int test_command_11 (void)
12658 {
12659   if (test_command_11_skip ()) {
12660     printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12661     return 0;
12662   }
12663
12664   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12665   {
12666     char device[] = "/dev/sda";
12667     int r;
12668     suppress_error = 0;
12669     r = guestfs_blockdev_setrw (g, device);
12670     if (r == -1)
12671       return -1;
12672   }
12673   {
12674     int r;
12675     suppress_error = 0;
12676     r = guestfs_umount_all (g);
12677     if (r == -1)
12678       return -1;
12679   }
12680   {
12681     int r;
12682     suppress_error = 0;
12683     r = guestfs_lvm_remove_all (g);
12684     if (r == -1)
12685       return -1;
12686   }
12687   {
12688     char device[] = "/dev/sda";
12689     char lines_0[] = ",";
12690     char *lines[] = {
12691       lines_0,
12692       NULL
12693     };
12694     int r;
12695     suppress_error = 0;
12696     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12697     if (r == -1)
12698       return -1;
12699   }
12700   {
12701     char fstype[] = "ext2";
12702     char device[] = "/dev/sda1";
12703     int r;
12704     suppress_error = 0;
12705     r = guestfs_mkfs (g, fstype, device);
12706     if (r == -1)
12707       return -1;
12708   }
12709   {
12710     char device[] = "/dev/sda1";
12711     char mountpoint[] = "/";
12712     int r;
12713     suppress_error = 0;
12714     r = guestfs_mount (g, device, mountpoint);
12715     if (r == -1)
12716       return -1;
12717   }
12718   /* TestLastFail for command (11) */
12719   {
12720     char remotefilename[] = "/test-command";
12721     int r;
12722     suppress_error = 0;
12723     r = guestfs_upload (g, "test-command", remotefilename);
12724     if (r == -1)
12725       return -1;
12726   }
12727   {
12728     char path[] = "/test-command";
12729     int r;
12730     suppress_error = 0;
12731     r = guestfs_chmod (g, 493, path);
12732     if (r == -1)
12733       return -1;
12734   }
12735   {
12736     char arguments_0[] = "/test-command";
12737     char *arguments[] = {
12738       arguments_0,
12739       NULL
12740     };
12741     char *r;
12742     suppress_error = 1;
12743     r = guestfs_command (g, arguments);
12744     if (r != NULL)
12745       return -1;
12746     free (r);
12747   }
12748   return 0;
12749 }
12750
12751 static int test_file_0_skip (void)
12752 {
12753   const char *str;
12754
12755   str = getenv ("TEST_ONLY");
12756   if (str)
12757     return strstr (str, "file") == NULL;
12758   str = getenv ("SKIP_TEST_FILE_0");
12759   if (str && strcmp (str, "1") == 0) return 1;
12760   str = getenv ("SKIP_TEST_FILE");
12761   if (str && strcmp (str, "1") == 0) return 1;
12762   return 0;
12763 }
12764
12765 static int test_file_0 (void)
12766 {
12767   if (test_file_0_skip ()) {
12768     printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12769     return 0;
12770   }
12771
12772   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12773   {
12774     char device[] = "/dev/sda";
12775     int r;
12776     suppress_error = 0;
12777     r = guestfs_blockdev_setrw (g, device);
12778     if (r == -1)
12779       return -1;
12780   }
12781   {
12782     int r;
12783     suppress_error = 0;
12784     r = guestfs_umount_all (g);
12785     if (r == -1)
12786       return -1;
12787   }
12788   {
12789     int r;
12790     suppress_error = 0;
12791     r = guestfs_lvm_remove_all (g);
12792     if (r == -1)
12793       return -1;
12794   }
12795   {
12796     char device[] = "/dev/sda";
12797     char lines_0[] = ",";
12798     char *lines[] = {
12799       lines_0,
12800       NULL
12801     };
12802     int r;
12803     suppress_error = 0;
12804     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12805     if (r == -1)
12806       return -1;
12807   }
12808   {
12809     char fstype[] = "ext2";
12810     char device[] = "/dev/sda1";
12811     int r;
12812     suppress_error = 0;
12813     r = guestfs_mkfs (g, fstype, device);
12814     if (r == -1)
12815       return -1;
12816   }
12817   {
12818     char device[] = "/dev/sda1";
12819     char mountpoint[] = "/";
12820     int r;
12821     suppress_error = 0;
12822     r = guestfs_mount (g, device, mountpoint);
12823     if (r == -1)
12824       return -1;
12825   }
12826   /* TestOutput for file (0) */
12827   char expected[] = "empty";
12828   {
12829     char path[] = "/new";
12830     int r;
12831     suppress_error = 0;
12832     r = guestfs_touch (g, path);
12833     if (r == -1)
12834       return -1;
12835   }
12836   {
12837     char path[] = "/new";
12838     char *r;
12839     suppress_error = 0;
12840     r = guestfs_file (g, path);
12841     if (r == NULL)
12842       return -1;
12843     if (strcmp (r, expected) != 0) {
12844       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12845       return -1;
12846     }
12847     free (r);
12848   }
12849   return 0;
12850 }
12851
12852 static int test_file_1_skip (void)
12853 {
12854   const char *str;
12855
12856   str = getenv ("TEST_ONLY");
12857   if (str)
12858     return strstr (str, "file") == NULL;
12859   str = getenv ("SKIP_TEST_FILE_1");
12860   if (str && strcmp (str, "1") == 0) return 1;
12861   str = getenv ("SKIP_TEST_FILE");
12862   if (str && strcmp (str, "1") == 0) return 1;
12863   return 0;
12864 }
12865
12866 static int test_file_1 (void)
12867 {
12868   if (test_file_1_skip ()) {
12869     printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12870     return 0;
12871   }
12872
12873   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12874   {
12875     char device[] = "/dev/sda";
12876     int r;
12877     suppress_error = 0;
12878     r = guestfs_blockdev_setrw (g, device);
12879     if (r == -1)
12880       return -1;
12881   }
12882   {
12883     int r;
12884     suppress_error = 0;
12885     r = guestfs_umount_all (g);
12886     if (r == -1)
12887       return -1;
12888   }
12889   {
12890     int r;
12891     suppress_error = 0;
12892     r = guestfs_lvm_remove_all (g);
12893     if (r == -1)
12894       return -1;
12895   }
12896   {
12897     char device[] = "/dev/sda";
12898     char lines_0[] = ",";
12899     char *lines[] = {
12900       lines_0,
12901       NULL
12902     };
12903     int r;
12904     suppress_error = 0;
12905     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12906     if (r == -1)
12907       return -1;
12908   }
12909   {
12910     char fstype[] = "ext2";
12911     char device[] = "/dev/sda1";
12912     int r;
12913     suppress_error = 0;
12914     r = guestfs_mkfs (g, fstype, device);
12915     if (r == -1)
12916       return -1;
12917   }
12918   {
12919     char device[] = "/dev/sda1";
12920     char mountpoint[] = "/";
12921     int r;
12922     suppress_error = 0;
12923     r = guestfs_mount (g, device, mountpoint);
12924     if (r == -1)
12925       return -1;
12926   }
12927   /* TestOutput for file (1) */
12928   char expected[] = "ASCII text";
12929   {
12930     char path[] = "/new";
12931     char content[] = "some content\n";
12932     int r;
12933     suppress_error = 0;
12934     r = guestfs_write_file (g, path, content, 0);
12935     if (r == -1)
12936       return -1;
12937   }
12938   {
12939     char path[] = "/new";
12940     char *r;
12941     suppress_error = 0;
12942     r = guestfs_file (g, path);
12943     if (r == NULL)
12944       return -1;
12945     if (strcmp (r, expected) != 0) {
12946       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12947       return -1;
12948     }
12949     free (r);
12950   }
12951   return 0;
12952 }
12953
12954 static int test_file_2_skip (void)
12955 {
12956   const char *str;
12957
12958   str = getenv ("TEST_ONLY");
12959   if (str)
12960     return strstr (str, "file") == NULL;
12961   str = getenv ("SKIP_TEST_FILE_2");
12962   if (str && strcmp (str, "1") == 0) return 1;
12963   str = getenv ("SKIP_TEST_FILE");
12964   if (str && strcmp (str, "1") == 0) return 1;
12965   return 0;
12966 }
12967
12968 static int test_file_2 (void)
12969 {
12970   if (test_file_2_skip ()) {
12971     printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12972     return 0;
12973   }
12974
12975   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12976   {
12977     char device[] = "/dev/sda";
12978     int r;
12979     suppress_error = 0;
12980     r = guestfs_blockdev_setrw (g, device);
12981     if (r == -1)
12982       return -1;
12983   }
12984   {
12985     int r;
12986     suppress_error = 0;
12987     r = guestfs_umount_all (g);
12988     if (r == -1)
12989       return -1;
12990   }
12991   {
12992     int r;
12993     suppress_error = 0;
12994     r = guestfs_lvm_remove_all (g);
12995     if (r == -1)
12996       return -1;
12997   }
12998   {
12999     char device[] = "/dev/sda";
13000     char lines_0[] = ",";
13001     char *lines[] = {
13002       lines_0,
13003       NULL
13004     };
13005     int r;
13006     suppress_error = 0;
13007     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13008     if (r == -1)
13009       return -1;
13010   }
13011   {
13012     char fstype[] = "ext2";
13013     char device[] = "/dev/sda1";
13014     int r;
13015     suppress_error = 0;
13016     r = guestfs_mkfs (g, fstype, device);
13017     if (r == -1)
13018       return -1;
13019   }
13020   {
13021     char device[] = "/dev/sda1";
13022     char mountpoint[] = "/";
13023     int r;
13024     suppress_error = 0;
13025     r = guestfs_mount (g, device, mountpoint);
13026     if (r == -1)
13027       return -1;
13028   }
13029   /* TestLastFail for file (2) */
13030   {
13031     char path[] = "/nofile";
13032     char *r;
13033     suppress_error = 1;
13034     r = guestfs_file (g, path);
13035     if (r != NULL)
13036       return -1;
13037     free (r);
13038   }
13039   return 0;
13040 }
13041
13042 static int test_umount_all_0_skip (void)
13043 {
13044   const char *str;
13045
13046   str = getenv ("TEST_ONLY");
13047   if (str)
13048     return strstr (str, "umount_all") == NULL;
13049   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
13050   if (str && strcmp (str, "1") == 0) return 1;
13051   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13052   if (str && strcmp (str, "1") == 0) return 1;
13053   return 0;
13054 }
13055
13056 static int test_umount_all_0 (void)
13057 {
13058   if (test_umount_all_0_skip ()) {
13059     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
13060     return 0;
13061   }
13062
13063   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
13064   {
13065     char device[] = "/dev/sda";
13066     int r;
13067     suppress_error = 0;
13068     r = guestfs_blockdev_setrw (g, device);
13069     if (r == -1)
13070       return -1;
13071   }
13072   {
13073     int r;
13074     suppress_error = 0;
13075     r = guestfs_umount_all (g);
13076     if (r == -1)
13077       return -1;
13078   }
13079   {
13080     int r;
13081     suppress_error = 0;
13082     r = guestfs_lvm_remove_all (g);
13083     if (r == -1)
13084       return -1;
13085   }
13086   {
13087     char device[] = "/dev/sda";
13088     char lines_0[] = ",";
13089     char *lines[] = {
13090       lines_0,
13091       NULL
13092     };
13093     int r;
13094     suppress_error = 0;
13095     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13096     if (r == -1)
13097       return -1;
13098   }
13099   {
13100     char fstype[] = "ext2";
13101     char device[] = "/dev/sda1";
13102     int r;
13103     suppress_error = 0;
13104     r = guestfs_mkfs (g, fstype, device);
13105     if (r == -1)
13106       return -1;
13107   }
13108   {
13109     char device[] = "/dev/sda1";
13110     char mountpoint[] = "/";
13111     int r;
13112     suppress_error = 0;
13113     r = guestfs_mount (g, device, mountpoint);
13114     if (r == -1)
13115       return -1;
13116   }
13117   /* TestOutputList for umount_all (0) */
13118   {
13119     int r;
13120     suppress_error = 0;
13121     r = guestfs_umount_all (g);
13122     if (r == -1)
13123       return -1;
13124   }
13125   {
13126     char **r;
13127     int i;
13128     suppress_error = 0;
13129     r = guestfs_mounts (g);
13130     if (r == NULL)
13131       return -1;
13132     if (r[0] != NULL) {
13133       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
13134       print_strings (r);
13135       return -1;
13136     }
13137     for (i = 0; r[i] != NULL; ++i)
13138       free (r[i]);
13139     free (r);
13140   }
13141   return 0;
13142 }
13143
13144 static int test_umount_all_1_skip (void)
13145 {
13146   const char *str;
13147
13148   str = getenv ("TEST_ONLY");
13149   if (str)
13150     return strstr (str, "umount_all") == NULL;
13151   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
13152   if (str && strcmp (str, "1") == 0) return 1;
13153   str = getenv ("SKIP_TEST_UMOUNT_ALL");
13154   if (str && strcmp (str, "1") == 0) return 1;
13155   return 0;
13156 }
13157
13158 static int test_umount_all_1 (void)
13159 {
13160   if (test_umount_all_1_skip ()) {
13161     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
13162     return 0;
13163   }
13164
13165   /* InitNone|InitEmpty for test_umount_all_1 */
13166   {
13167     char device[] = "/dev/sda";
13168     int r;
13169     suppress_error = 0;
13170     r = guestfs_blockdev_setrw (g, device);
13171     if (r == -1)
13172       return -1;
13173   }
13174   {
13175     int r;
13176     suppress_error = 0;
13177     r = guestfs_umount_all (g);
13178     if (r == -1)
13179       return -1;
13180   }
13181   {
13182     int r;
13183     suppress_error = 0;
13184     r = guestfs_lvm_remove_all (g);
13185     if (r == -1)
13186       return -1;
13187   }
13188   /* TestOutputList for umount_all (1) */
13189   {
13190     char device[] = "/dev/sda";
13191     char lines_0[] = ",10";
13192     char lines_1[] = ",20";
13193     char lines_2[] = ",";
13194     char *lines[] = {
13195       lines_0,
13196       lines_1,
13197       lines_2,
13198       NULL
13199     };
13200     int r;
13201     suppress_error = 0;
13202     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13203     if (r == -1)
13204       return -1;
13205   }
13206   {
13207     char fstype[] = "ext2";
13208     char device[] = "/dev/sda1";
13209     int r;
13210     suppress_error = 0;
13211     r = guestfs_mkfs (g, fstype, device);
13212     if (r == -1)
13213       return -1;
13214   }
13215   {
13216     char fstype[] = "ext2";
13217     char device[] = "/dev/sda2";
13218     int r;
13219     suppress_error = 0;
13220     r = guestfs_mkfs (g, fstype, device);
13221     if (r == -1)
13222       return -1;
13223   }
13224   {
13225     char fstype[] = "ext2";
13226     char device[] = "/dev/sda3";
13227     int r;
13228     suppress_error = 0;
13229     r = guestfs_mkfs (g, fstype, device);
13230     if (r == -1)
13231       return -1;
13232   }
13233   {
13234     char device[] = "/dev/sda1";
13235     char mountpoint[] = "/";
13236     int r;
13237     suppress_error = 0;
13238     r = guestfs_mount (g, device, mountpoint);
13239     if (r == -1)
13240       return -1;
13241   }
13242   {
13243     char path[] = "/mp1";
13244     int r;
13245     suppress_error = 0;
13246     r = guestfs_mkdir (g, path);
13247     if (r == -1)
13248       return -1;
13249   }
13250   {
13251     char device[] = "/dev/sda2";
13252     char mountpoint[] = "/mp1";
13253     int r;
13254     suppress_error = 0;
13255     r = guestfs_mount (g, device, mountpoint);
13256     if (r == -1)
13257       return -1;
13258   }
13259   {
13260     char path[] = "/mp1/mp2";
13261     int r;
13262     suppress_error = 0;
13263     r = guestfs_mkdir (g, path);
13264     if (r == -1)
13265       return -1;
13266   }
13267   {
13268     char device[] = "/dev/sda3";
13269     char mountpoint[] = "/mp1/mp2";
13270     int r;
13271     suppress_error = 0;
13272     r = guestfs_mount (g, device, mountpoint);
13273     if (r == -1)
13274       return -1;
13275   }
13276   {
13277     char path[] = "/mp1/mp2/mp3";
13278     int r;
13279     suppress_error = 0;
13280     r = guestfs_mkdir (g, path);
13281     if (r == -1)
13282       return -1;
13283   }
13284   {
13285     int r;
13286     suppress_error = 0;
13287     r = guestfs_umount_all (g);
13288     if (r == -1)
13289       return -1;
13290   }
13291   {
13292     char **r;
13293     int i;
13294     suppress_error = 0;
13295     r = guestfs_mounts (g);
13296     if (r == NULL)
13297       return -1;
13298     if (r[0] != NULL) {
13299       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13300       print_strings (r);
13301       return -1;
13302     }
13303     for (i = 0; r[i] != NULL; ++i)
13304       free (r[i]);
13305     free (r);
13306   }
13307   return 0;
13308 }
13309
13310 static int test_mounts_0_skip (void)
13311 {
13312   const char *str;
13313
13314   str = getenv ("TEST_ONLY");
13315   if (str)
13316     return strstr (str, "mounts") == NULL;
13317   str = getenv ("SKIP_TEST_MOUNTS_0");
13318   if (str && strcmp (str, "1") == 0) return 1;
13319   str = getenv ("SKIP_TEST_MOUNTS");
13320   if (str && strcmp (str, "1") == 0) return 1;
13321   return 0;
13322 }
13323
13324 static int test_mounts_0 (void)
13325 {
13326   if (test_mounts_0_skip ()) {
13327     printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
13328     return 0;
13329   }
13330
13331   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13332   {
13333     char device[] = "/dev/sda";
13334     int r;
13335     suppress_error = 0;
13336     r = guestfs_blockdev_setrw (g, device);
13337     if (r == -1)
13338       return -1;
13339   }
13340   {
13341     int r;
13342     suppress_error = 0;
13343     r = guestfs_umount_all (g);
13344     if (r == -1)
13345       return -1;
13346   }
13347   {
13348     int r;
13349     suppress_error = 0;
13350     r = guestfs_lvm_remove_all (g);
13351     if (r == -1)
13352       return -1;
13353   }
13354   {
13355     char device[] = "/dev/sda";
13356     char lines_0[] = ",";
13357     char *lines[] = {
13358       lines_0,
13359       NULL
13360     };
13361     int r;
13362     suppress_error = 0;
13363     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13364     if (r == -1)
13365       return -1;
13366   }
13367   {
13368     char fstype[] = "ext2";
13369     char device[] = "/dev/sda1";
13370     int r;
13371     suppress_error = 0;
13372     r = guestfs_mkfs (g, fstype, device);
13373     if (r == -1)
13374       return -1;
13375   }
13376   {
13377     char device[] = "/dev/sda1";
13378     char mountpoint[] = "/";
13379     int r;
13380     suppress_error = 0;
13381     r = guestfs_mount (g, device, mountpoint);
13382     if (r == -1)
13383       return -1;
13384   }
13385   /* TestOutputListOfDevices for mounts (0) */
13386   {
13387     char **r;
13388     int i;
13389     suppress_error = 0;
13390     r = guestfs_mounts (g);
13391     if (r == NULL)
13392       return -1;
13393     if (!r[0]) {
13394       fprintf (stderr, "test_mounts_0: short list returned from command\n");
13395       print_strings (r);
13396       return -1;
13397     }
13398     {
13399       char expected[] = "/dev/sda1";
13400       r[0][5] = 's';
13401       if (strcmp (r[0], expected) != 0) {
13402         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13403         return -1;
13404       }
13405     }
13406     if (r[1] != NULL) {
13407       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13408       print_strings (r);
13409       return -1;
13410     }
13411     for (i = 0; r[i] != NULL; ++i)
13412       free (r[i]);
13413     free (r);
13414   }
13415   return 0;
13416 }
13417
13418 static int test_umount_0_skip (void)
13419 {
13420   const char *str;
13421
13422   str = getenv ("TEST_ONLY");
13423   if (str)
13424     return strstr (str, "umount") == NULL;
13425   str = getenv ("SKIP_TEST_UMOUNT_0");
13426   if (str && strcmp (str, "1") == 0) return 1;
13427   str = getenv ("SKIP_TEST_UMOUNT");
13428   if (str && strcmp (str, "1") == 0) return 1;
13429   return 0;
13430 }
13431
13432 static int test_umount_0 (void)
13433 {
13434   if (test_umount_0_skip ()) {
13435     printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13436     return 0;
13437   }
13438
13439   /* InitNone|InitEmpty for test_umount_0 */
13440   {
13441     char device[] = "/dev/sda";
13442     int r;
13443     suppress_error = 0;
13444     r = guestfs_blockdev_setrw (g, device);
13445     if (r == -1)
13446       return -1;
13447   }
13448   {
13449     int r;
13450     suppress_error = 0;
13451     r = guestfs_umount_all (g);
13452     if (r == -1)
13453       return -1;
13454   }
13455   {
13456     int r;
13457     suppress_error = 0;
13458     r = guestfs_lvm_remove_all (g);
13459     if (r == -1)
13460       return -1;
13461   }
13462   /* TestOutputListOfDevices for umount (0) */
13463   {
13464     char device[] = "/dev/sda";
13465     char lines_0[] = ",";
13466     char *lines[] = {
13467       lines_0,
13468       NULL
13469     };
13470     int r;
13471     suppress_error = 0;
13472     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13473     if (r == -1)
13474       return -1;
13475   }
13476   {
13477     char fstype[] = "ext2";
13478     char device[] = "/dev/sda1";
13479     int r;
13480     suppress_error = 0;
13481     r = guestfs_mkfs (g, fstype, device);
13482     if (r == -1)
13483       return -1;
13484   }
13485   {
13486     char device[] = "/dev/sda1";
13487     char mountpoint[] = "/";
13488     int r;
13489     suppress_error = 0;
13490     r = guestfs_mount (g, device, mountpoint);
13491     if (r == -1)
13492       return -1;
13493   }
13494   {
13495     char **r;
13496     int i;
13497     suppress_error = 0;
13498     r = guestfs_mounts (g);
13499     if (r == NULL)
13500       return -1;
13501     if (!r[0]) {
13502       fprintf (stderr, "test_umount_0: short list returned from command\n");
13503       print_strings (r);
13504       return -1;
13505     }
13506     {
13507       char expected[] = "/dev/sda1";
13508       r[0][5] = 's';
13509       if (strcmp (r[0], expected) != 0) {
13510         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13511         return -1;
13512       }
13513     }
13514     if (r[1] != NULL) {
13515       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13516       print_strings (r);
13517       return -1;
13518     }
13519     for (i = 0; r[i] != NULL; ++i)
13520       free (r[i]);
13521     free (r);
13522   }
13523   return 0;
13524 }
13525
13526 static int test_umount_1_skip (void)
13527 {
13528   const char *str;
13529
13530   str = getenv ("TEST_ONLY");
13531   if (str)
13532     return strstr (str, "umount") == NULL;
13533   str = getenv ("SKIP_TEST_UMOUNT_1");
13534   if (str && strcmp (str, "1") == 0) return 1;
13535   str = getenv ("SKIP_TEST_UMOUNT");
13536   if (str && strcmp (str, "1") == 0) return 1;
13537   return 0;
13538 }
13539
13540 static int test_umount_1 (void)
13541 {
13542   if (test_umount_1_skip ()) {
13543     printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13544     return 0;
13545   }
13546
13547   /* InitNone|InitEmpty for test_umount_1 */
13548   {
13549     char device[] = "/dev/sda";
13550     int r;
13551     suppress_error = 0;
13552     r = guestfs_blockdev_setrw (g, device);
13553     if (r == -1)
13554       return -1;
13555   }
13556   {
13557     int r;
13558     suppress_error = 0;
13559     r = guestfs_umount_all (g);
13560     if (r == -1)
13561       return -1;
13562   }
13563   {
13564     int r;
13565     suppress_error = 0;
13566     r = guestfs_lvm_remove_all (g);
13567     if (r == -1)
13568       return -1;
13569   }
13570   /* TestOutputList for umount (1) */
13571   {
13572     char device[] = "/dev/sda";
13573     char lines_0[] = ",";
13574     char *lines[] = {
13575       lines_0,
13576       NULL
13577     };
13578     int r;
13579     suppress_error = 0;
13580     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13581     if (r == -1)
13582       return -1;
13583   }
13584   {
13585     char fstype[] = "ext2";
13586     char device[] = "/dev/sda1";
13587     int r;
13588     suppress_error = 0;
13589     r = guestfs_mkfs (g, fstype, device);
13590     if (r == -1)
13591       return -1;
13592   }
13593   {
13594     char device[] = "/dev/sda1";
13595     char mountpoint[] = "/";
13596     int r;
13597     suppress_error = 0;
13598     r = guestfs_mount (g, device, mountpoint);
13599     if (r == -1)
13600       return -1;
13601   }
13602   {
13603     char pathordevice[] = "/";
13604     int r;
13605     suppress_error = 0;
13606     r = guestfs_umount (g, pathordevice);
13607     if (r == -1)
13608       return -1;
13609   }
13610   {
13611     char **r;
13612     int i;
13613     suppress_error = 0;
13614     r = guestfs_mounts (g);
13615     if (r == NULL)
13616       return -1;
13617     if (r[0] != NULL) {
13618       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13619       print_strings (r);
13620       return -1;
13621     }
13622     for (i = 0; r[i] != NULL; ++i)
13623       free (r[i]);
13624     free (r);
13625   }
13626   return 0;
13627 }
13628
13629 static int test_write_file_0_skip (void)
13630 {
13631   const char *str;
13632
13633   str = getenv ("TEST_ONLY");
13634   if (str)
13635     return strstr (str, "write_file") == NULL;
13636   str = getenv ("SKIP_TEST_WRITE_FILE_0");
13637   if (str && strcmp (str, "1") == 0) return 1;
13638   str = getenv ("SKIP_TEST_WRITE_FILE");
13639   if (str && strcmp (str, "1") == 0) return 1;
13640   return 0;
13641 }
13642
13643 static int test_write_file_0 (void)
13644 {
13645   if (test_write_file_0_skip ()) {
13646     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13647     return 0;
13648   }
13649
13650   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13651   {
13652     char device[] = "/dev/sda";
13653     int r;
13654     suppress_error = 0;
13655     r = guestfs_blockdev_setrw (g, device);
13656     if (r == -1)
13657       return -1;
13658   }
13659   {
13660     int r;
13661     suppress_error = 0;
13662     r = guestfs_umount_all (g);
13663     if (r == -1)
13664       return -1;
13665   }
13666   {
13667     int r;
13668     suppress_error = 0;
13669     r = guestfs_lvm_remove_all (g);
13670     if (r == -1)
13671       return -1;
13672   }
13673   {
13674     char device[] = "/dev/sda";
13675     char lines_0[] = ",";
13676     char *lines[] = {
13677       lines_0,
13678       NULL
13679     };
13680     int r;
13681     suppress_error = 0;
13682     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13683     if (r == -1)
13684       return -1;
13685   }
13686   {
13687     char fstype[] = "ext2";
13688     char device[] = "/dev/sda1";
13689     int r;
13690     suppress_error = 0;
13691     r = guestfs_mkfs (g, fstype, device);
13692     if (r == -1)
13693       return -1;
13694   }
13695   {
13696     char device[] = "/dev/sda1";
13697     char mountpoint[] = "/";
13698     int r;
13699     suppress_error = 0;
13700     r = guestfs_mount (g, device, mountpoint);
13701     if (r == -1)
13702       return -1;
13703   }
13704   /* TestOutput for write_file (0) */
13705   char expected[] = "new file contents";
13706   {
13707     char path[] = "/new";
13708     char content[] = "new file contents";
13709     int r;
13710     suppress_error = 0;
13711     r = guestfs_write_file (g, path, content, 0);
13712     if (r == -1)
13713       return -1;
13714   }
13715   {
13716     char path[] = "/new";
13717     char *r;
13718     suppress_error = 0;
13719     r = guestfs_cat (g, path);
13720     if (r == NULL)
13721       return -1;
13722     if (strcmp (r, expected) != 0) {
13723       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13724       return -1;
13725     }
13726     free (r);
13727   }
13728   return 0;
13729 }
13730
13731 static int test_write_file_1_skip (void)
13732 {
13733   const char *str;
13734
13735   str = getenv ("TEST_ONLY");
13736   if (str)
13737     return strstr (str, "write_file") == NULL;
13738   str = getenv ("SKIP_TEST_WRITE_FILE_1");
13739   if (str && strcmp (str, "1") == 0) return 1;
13740   str = getenv ("SKIP_TEST_WRITE_FILE");
13741   if (str && strcmp (str, "1") == 0) return 1;
13742   return 0;
13743 }
13744
13745 static int test_write_file_1 (void)
13746 {
13747   if (test_write_file_1_skip ()) {
13748     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13749     return 0;
13750   }
13751
13752   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13753   {
13754     char device[] = "/dev/sda";
13755     int r;
13756     suppress_error = 0;
13757     r = guestfs_blockdev_setrw (g, device);
13758     if (r == -1)
13759       return -1;
13760   }
13761   {
13762     int r;
13763     suppress_error = 0;
13764     r = guestfs_umount_all (g);
13765     if (r == -1)
13766       return -1;
13767   }
13768   {
13769     int r;
13770     suppress_error = 0;
13771     r = guestfs_lvm_remove_all (g);
13772     if (r == -1)
13773       return -1;
13774   }
13775   {
13776     char device[] = "/dev/sda";
13777     char lines_0[] = ",";
13778     char *lines[] = {
13779       lines_0,
13780       NULL
13781     };
13782     int r;
13783     suppress_error = 0;
13784     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13785     if (r == -1)
13786       return -1;
13787   }
13788   {
13789     char fstype[] = "ext2";
13790     char device[] = "/dev/sda1";
13791     int r;
13792     suppress_error = 0;
13793     r = guestfs_mkfs (g, fstype, device);
13794     if (r == -1)
13795       return -1;
13796   }
13797   {
13798     char device[] = "/dev/sda1";
13799     char mountpoint[] = "/";
13800     int r;
13801     suppress_error = 0;
13802     r = guestfs_mount (g, device, mountpoint);
13803     if (r == -1)
13804       return -1;
13805   }
13806   /* TestOutput for write_file (1) */
13807   char expected[] = "\nnew file contents\n";
13808   {
13809     char path[] = "/new";
13810     char content[] = "\nnew file contents\n";
13811     int r;
13812     suppress_error = 0;
13813     r = guestfs_write_file (g, path, content, 0);
13814     if (r == -1)
13815       return -1;
13816   }
13817   {
13818     char path[] = "/new";
13819     char *r;
13820     suppress_error = 0;
13821     r = guestfs_cat (g, path);
13822     if (r == NULL)
13823       return -1;
13824     if (strcmp (r, expected) != 0) {
13825       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13826       return -1;
13827     }
13828     free (r);
13829   }
13830   return 0;
13831 }
13832
13833 static int test_write_file_2_skip (void)
13834 {
13835   const char *str;
13836
13837   str = getenv ("TEST_ONLY");
13838   if (str)
13839     return strstr (str, "write_file") == NULL;
13840   str = getenv ("SKIP_TEST_WRITE_FILE_2");
13841   if (str && strcmp (str, "1") == 0) return 1;
13842   str = getenv ("SKIP_TEST_WRITE_FILE");
13843   if (str && strcmp (str, "1") == 0) return 1;
13844   return 0;
13845 }
13846
13847 static int test_write_file_2 (void)
13848 {
13849   if (test_write_file_2_skip ()) {
13850     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13851     return 0;
13852   }
13853
13854   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13855   {
13856     char device[] = "/dev/sda";
13857     int r;
13858     suppress_error = 0;
13859     r = guestfs_blockdev_setrw (g, device);
13860     if (r == -1)
13861       return -1;
13862   }
13863   {
13864     int r;
13865     suppress_error = 0;
13866     r = guestfs_umount_all (g);
13867     if (r == -1)
13868       return -1;
13869   }
13870   {
13871     int r;
13872     suppress_error = 0;
13873     r = guestfs_lvm_remove_all (g);
13874     if (r == -1)
13875       return -1;
13876   }
13877   {
13878     char device[] = "/dev/sda";
13879     char lines_0[] = ",";
13880     char *lines[] = {
13881       lines_0,
13882       NULL
13883     };
13884     int r;
13885     suppress_error = 0;
13886     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13887     if (r == -1)
13888       return -1;
13889   }
13890   {
13891     char fstype[] = "ext2";
13892     char device[] = "/dev/sda1";
13893     int r;
13894     suppress_error = 0;
13895     r = guestfs_mkfs (g, fstype, device);
13896     if (r == -1)
13897       return -1;
13898   }
13899   {
13900     char device[] = "/dev/sda1";
13901     char mountpoint[] = "/";
13902     int r;
13903     suppress_error = 0;
13904     r = guestfs_mount (g, device, mountpoint);
13905     if (r == -1)
13906       return -1;
13907   }
13908   /* TestOutput for write_file (2) */
13909   char expected[] = "\n\n";
13910   {
13911     char path[] = "/new";
13912     char content[] = "\n\n";
13913     int r;
13914     suppress_error = 0;
13915     r = guestfs_write_file (g, path, content, 0);
13916     if (r == -1)
13917       return -1;
13918   }
13919   {
13920     char path[] = "/new";
13921     char *r;
13922     suppress_error = 0;
13923     r = guestfs_cat (g, path);
13924     if (r == NULL)
13925       return -1;
13926     if (strcmp (r, expected) != 0) {
13927       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13928       return -1;
13929     }
13930     free (r);
13931   }
13932   return 0;
13933 }
13934
13935 static int test_write_file_3_skip (void)
13936 {
13937   const char *str;
13938
13939   str = getenv ("TEST_ONLY");
13940   if (str)
13941     return strstr (str, "write_file") == NULL;
13942   str = getenv ("SKIP_TEST_WRITE_FILE_3");
13943   if (str && strcmp (str, "1") == 0) return 1;
13944   str = getenv ("SKIP_TEST_WRITE_FILE");
13945   if (str && strcmp (str, "1") == 0) return 1;
13946   return 0;
13947 }
13948
13949 static int test_write_file_3 (void)
13950 {
13951   if (test_write_file_3_skip ()) {
13952     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13953     return 0;
13954   }
13955
13956   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13957   {
13958     char device[] = "/dev/sda";
13959     int r;
13960     suppress_error = 0;
13961     r = guestfs_blockdev_setrw (g, device);
13962     if (r == -1)
13963       return -1;
13964   }
13965   {
13966     int r;
13967     suppress_error = 0;
13968     r = guestfs_umount_all (g);
13969     if (r == -1)
13970       return -1;
13971   }
13972   {
13973     int r;
13974     suppress_error = 0;
13975     r = guestfs_lvm_remove_all (g);
13976     if (r == -1)
13977       return -1;
13978   }
13979   {
13980     char device[] = "/dev/sda";
13981     char lines_0[] = ",";
13982     char *lines[] = {
13983       lines_0,
13984       NULL
13985     };
13986     int r;
13987     suppress_error = 0;
13988     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13989     if (r == -1)
13990       return -1;
13991   }
13992   {
13993     char fstype[] = "ext2";
13994     char device[] = "/dev/sda1";
13995     int r;
13996     suppress_error = 0;
13997     r = guestfs_mkfs (g, fstype, device);
13998     if (r == -1)
13999       return -1;
14000   }
14001   {
14002     char device[] = "/dev/sda1";
14003     char mountpoint[] = "/";
14004     int r;
14005     suppress_error = 0;
14006     r = guestfs_mount (g, device, mountpoint);
14007     if (r == -1)
14008       return -1;
14009   }
14010   /* TestOutput for write_file (3) */
14011   char expected[] = "";
14012   {
14013     char path[] = "/new";
14014     char content[] = "";
14015     int r;
14016     suppress_error = 0;
14017     r = guestfs_write_file (g, path, content, 0);
14018     if (r == -1)
14019       return -1;
14020   }
14021   {
14022     char path[] = "/new";
14023     char *r;
14024     suppress_error = 0;
14025     r = guestfs_cat (g, path);
14026     if (r == NULL)
14027       return -1;
14028     if (strcmp (r, expected) != 0) {
14029       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
14030       return -1;
14031     }
14032     free (r);
14033   }
14034   return 0;
14035 }
14036
14037 static int test_write_file_4_skip (void)
14038 {
14039   const char *str;
14040
14041   str = getenv ("TEST_ONLY");
14042   if (str)
14043     return strstr (str, "write_file") == NULL;
14044   str = getenv ("SKIP_TEST_WRITE_FILE_4");
14045   if (str && strcmp (str, "1") == 0) return 1;
14046   str = getenv ("SKIP_TEST_WRITE_FILE");
14047   if (str && strcmp (str, "1") == 0) return 1;
14048   return 0;
14049 }
14050
14051 static int test_write_file_4 (void)
14052 {
14053   if (test_write_file_4_skip ()) {
14054     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
14055     return 0;
14056   }
14057
14058   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
14059   {
14060     char device[] = "/dev/sda";
14061     int r;
14062     suppress_error = 0;
14063     r = guestfs_blockdev_setrw (g, device);
14064     if (r == -1)
14065       return -1;
14066   }
14067   {
14068     int r;
14069     suppress_error = 0;
14070     r = guestfs_umount_all (g);
14071     if (r == -1)
14072       return -1;
14073   }
14074   {
14075     int r;
14076     suppress_error = 0;
14077     r = guestfs_lvm_remove_all (g);
14078     if (r == -1)
14079       return -1;
14080   }
14081   {
14082     char device[] = "/dev/sda";
14083     char lines_0[] = ",";
14084     char *lines[] = {
14085       lines_0,
14086       NULL
14087     };
14088     int r;
14089     suppress_error = 0;
14090     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14091     if (r == -1)
14092       return -1;
14093   }
14094   {
14095     char fstype[] = "ext2";
14096     char device[] = "/dev/sda1";
14097     int r;
14098     suppress_error = 0;
14099     r = guestfs_mkfs (g, fstype, device);
14100     if (r == -1)
14101       return -1;
14102   }
14103   {
14104     char device[] = "/dev/sda1";
14105     char mountpoint[] = "/";
14106     int r;
14107     suppress_error = 0;
14108     r = guestfs_mount (g, device, mountpoint);
14109     if (r == -1)
14110       return -1;
14111   }
14112   /* TestOutput for write_file (4) */
14113   char expected[] = "\n\n\n";
14114   {
14115     char path[] = "/new";
14116     char content[] = "\n\n\n";
14117     int r;
14118     suppress_error = 0;
14119     r = guestfs_write_file (g, path, content, 0);
14120     if (r == -1)
14121       return -1;
14122   }
14123   {
14124     char path[] = "/new";
14125     char *r;
14126     suppress_error = 0;
14127     r = guestfs_cat (g, path);
14128     if (r == NULL)
14129       return -1;
14130     if (strcmp (r, expected) != 0) {
14131       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
14132       return -1;
14133     }
14134     free (r);
14135   }
14136   return 0;
14137 }
14138
14139 static int test_write_file_5_skip (void)
14140 {
14141   const char *str;
14142
14143   str = getenv ("TEST_ONLY");
14144   if (str)
14145     return strstr (str, "write_file") == NULL;
14146   str = getenv ("SKIP_TEST_WRITE_FILE_5");
14147   if (str && strcmp (str, "1") == 0) return 1;
14148   str = getenv ("SKIP_TEST_WRITE_FILE");
14149   if (str && strcmp (str, "1") == 0) return 1;
14150   return 0;
14151 }
14152
14153 static int test_write_file_5 (void)
14154 {
14155   if (test_write_file_5_skip ()) {
14156     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
14157     return 0;
14158   }
14159
14160   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
14161   {
14162     char device[] = "/dev/sda";
14163     int r;
14164     suppress_error = 0;
14165     r = guestfs_blockdev_setrw (g, device);
14166     if (r == -1)
14167       return -1;
14168   }
14169   {
14170     int r;
14171     suppress_error = 0;
14172     r = guestfs_umount_all (g);
14173     if (r == -1)
14174       return -1;
14175   }
14176   {
14177     int r;
14178     suppress_error = 0;
14179     r = guestfs_lvm_remove_all (g);
14180     if (r == -1)
14181       return -1;
14182   }
14183   {
14184     char device[] = "/dev/sda";
14185     char lines_0[] = ",";
14186     char *lines[] = {
14187       lines_0,
14188       NULL
14189     };
14190     int r;
14191     suppress_error = 0;
14192     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14193     if (r == -1)
14194       return -1;
14195   }
14196   {
14197     char fstype[] = "ext2";
14198     char device[] = "/dev/sda1";
14199     int r;
14200     suppress_error = 0;
14201     r = guestfs_mkfs (g, fstype, device);
14202     if (r == -1)
14203       return -1;
14204   }
14205   {
14206     char device[] = "/dev/sda1";
14207     char mountpoint[] = "/";
14208     int r;
14209     suppress_error = 0;
14210     r = guestfs_mount (g, device, mountpoint);
14211     if (r == -1)
14212       return -1;
14213   }
14214   /* TestOutput for write_file (5) */
14215   char expected[] = "\n";
14216   {
14217     char path[] = "/new";
14218     char content[] = "\n";
14219     int r;
14220     suppress_error = 0;
14221     r = guestfs_write_file (g, path, content, 0);
14222     if (r == -1)
14223       return -1;
14224   }
14225   {
14226     char path[] = "/new";
14227     char *r;
14228     suppress_error = 0;
14229     r = guestfs_cat (g, path);
14230     if (r == NULL)
14231       return -1;
14232     if (strcmp (r, expected) != 0) {
14233       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14234       return -1;
14235     }
14236     free (r);
14237   }
14238   return 0;
14239 }
14240
14241 static int test_mkfs_0_skip (void)
14242 {
14243   const char *str;
14244
14245   str = getenv ("TEST_ONLY");
14246   if (str)
14247     return strstr (str, "mkfs") == NULL;
14248   str = getenv ("SKIP_TEST_MKFS_0");
14249   if (str && strcmp (str, "1") == 0) return 1;
14250   str = getenv ("SKIP_TEST_MKFS");
14251   if (str && strcmp (str, "1") == 0) return 1;
14252   return 0;
14253 }
14254
14255 static int test_mkfs_0 (void)
14256 {
14257   if (test_mkfs_0_skip ()) {
14258     printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
14259     return 0;
14260   }
14261
14262   /* InitNone|InitEmpty for test_mkfs_0 */
14263   {
14264     char device[] = "/dev/sda";
14265     int r;
14266     suppress_error = 0;
14267     r = guestfs_blockdev_setrw (g, device);
14268     if (r == -1)
14269       return -1;
14270   }
14271   {
14272     int r;
14273     suppress_error = 0;
14274     r = guestfs_umount_all (g);
14275     if (r == -1)
14276       return -1;
14277   }
14278   {
14279     int r;
14280     suppress_error = 0;
14281     r = guestfs_lvm_remove_all (g);
14282     if (r == -1)
14283       return -1;
14284   }
14285   /* TestOutput for mkfs (0) */
14286   char expected[] = "new file contents";
14287   {
14288     char device[] = "/dev/sda";
14289     char lines_0[] = ",";
14290     char *lines[] = {
14291       lines_0,
14292       NULL
14293     };
14294     int r;
14295     suppress_error = 0;
14296     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14297     if (r == -1)
14298       return -1;
14299   }
14300   {
14301     char fstype[] = "ext2";
14302     char device[] = "/dev/sda1";
14303     int r;
14304     suppress_error = 0;
14305     r = guestfs_mkfs (g, fstype, device);
14306     if (r == -1)
14307       return -1;
14308   }
14309   {
14310     char device[] = "/dev/sda1";
14311     char mountpoint[] = "/";
14312     int r;
14313     suppress_error = 0;
14314     r = guestfs_mount (g, device, mountpoint);
14315     if (r == -1)
14316       return -1;
14317   }
14318   {
14319     char path[] = "/new";
14320     char content[] = "new file contents";
14321     int r;
14322     suppress_error = 0;
14323     r = guestfs_write_file (g, path, content, 0);
14324     if (r == -1)
14325       return -1;
14326   }
14327   {
14328     char path[] = "/new";
14329     char *r;
14330     suppress_error = 0;
14331     r = guestfs_cat (g, path);
14332     if (r == NULL)
14333       return -1;
14334     if (strcmp (r, expected) != 0) {
14335       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14336       return -1;
14337     }
14338     free (r);
14339   }
14340   return 0;
14341 }
14342
14343 static int test_lvcreate_0_skip (void)
14344 {
14345   const char *str;
14346
14347   str = getenv ("TEST_ONLY");
14348   if (str)
14349     return strstr (str, "lvcreate") == NULL;
14350   str = getenv ("SKIP_TEST_LVCREATE_0");
14351   if (str && strcmp (str, "1") == 0) return 1;
14352   str = getenv ("SKIP_TEST_LVCREATE");
14353   if (str && strcmp (str, "1") == 0) return 1;
14354   return 0;
14355 }
14356
14357 static int test_lvcreate_0 (void)
14358 {
14359   if (test_lvcreate_0_skip ()) {
14360     printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14361     return 0;
14362   }
14363
14364   /* InitNone|InitEmpty for test_lvcreate_0 */
14365   {
14366     char device[] = "/dev/sda";
14367     int r;
14368     suppress_error = 0;
14369     r = guestfs_blockdev_setrw (g, device);
14370     if (r == -1)
14371       return -1;
14372   }
14373   {
14374     int r;
14375     suppress_error = 0;
14376     r = guestfs_umount_all (g);
14377     if (r == -1)
14378       return -1;
14379   }
14380   {
14381     int r;
14382     suppress_error = 0;
14383     r = guestfs_lvm_remove_all (g);
14384     if (r == -1)
14385       return -1;
14386   }
14387   /* TestOutputList for lvcreate (0) */
14388   {
14389     char device[] = "/dev/sda";
14390     char lines_0[] = ",10";
14391     char lines_1[] = ",20";
14392     char lines_2[] = ",";
14393     char *lines[] = {
14394       lines_0,
14395       lines_1,
14396       lines_2,
14397       NULL
14398     };
14399     int r;
14400     suppress_error = 0;
14401     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14402     if (r == -1)
14403       return -1;
14404   }
14405   {
14406     char device[] = "/dev/sda1";
14407     int r;
14408     suppress_error = 0;
14409     r = guestfs_pvcreate (g, device);
14410     if (r == -1)
14411       return -1;
14412   }
14413   {
14414     char device[] = "/dev/sda2";
14415     int r;
14416     suppress_error = 0;
14417     r = guestfs_pvcreate (g, device);
14418     if (r == -1)
14419       return -1;
14420   }
14421   {
14422     char device[] = "/dev/sda3";
14423     int r;
14424     suppress_error = 0;
14425     r = guestfs_pvcreate (g, device);
14426     if (r == -1)
14427       return -1;
14428   }
14429   {
14430     char volgroup[] = "VG1";
14431     char physvols_0[] = "/dev/sda1";
14432     char physvols_1[] = "/dev/sda2";
14433     char *physvols[] = {
14434       physvols_0,
14435       physvols_1,
14436       NULL
14437     };
14438     int r;
14439     suppress_error = 0;
14440     r = guestfs_vgcreate (g, volgroup, physvols);
14441     if (r == -1)
14442       return -1;
14443   }
14444   {
14445     char volgroup[] = "VG2";
14446     char physvols_0[] = "/dev/sda3";
14447     char *physvols[] = {
14448       physvols_0,
14449       NULL
14450     };
14451     int r;
14452     suppress_error = 0;
14453     r = guestfs_vgcreate (g, volgroup, physvols);
14454     if (r == -1)
14455       return -1;
14456   }
14457   {
14458     char logvol[] = "LV1";
14459     char volgroup[] = "VG1";
14460     int r;
14461     suppress_error = 0;
14462     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14463     if (r == -1)
14464       return -1;
14465   }
14466   {
14467     char logvol[] = "LV2";
14468     char volgroup[] = "VG1";
14469     int r;
14470     suppress_error = 0;
14471     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14472     if (r == -1)
14473       return -1;
14474   }
14475   {
14476     char logvol[] = "LV3";
14477     char volgroup[] = "VG2";
14478     int r;
14479     suppress_error = 0;
14480     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14481     if (r == -1)
14482       return -1;
14483   }
14484   {
14485     char logvol[] = "LV4";
14486     char volgroup[] = "VG2";
14487     int r;
14488     suppress_error = 0;
14489     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14490     if (r == -1)
14491       return -1;
14492   }
14493   {
14494     char logvol[] = "LV5";
14495     char volgroup[] = "VG2";
14496     int r;
14497     suppress_error = 0;
14498     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14499     if (r == -1)
14500       return -1;
14501   }
14502   {
14503     char **r;
14504     int i;
14505     suppress_error = 0;
14506     r = guestfs_lvs (g);
14507     if (r == NULL)
14508       return -1;
14509     if (!r[0]) {
14510       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14511       print_strings (r);
14512       return -1;
14513     }
14514     {
14515       char expected[] = "/dev/VG1/LV1";
14516       if (strcmp (r[0], expected) != 0) {
14517         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14518         return -1;
14519       }
14520     }
14521     if (!r[1]) {
14522       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14523       print_strings (r);
14524       return -1;
14525     }
14526     {
14527       char expected[] = "/dev/VG1/LV2";
14528       if (strcmp (r[1], expected) != 0) {
14529         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14530         return -1;
14531       }
14532     }
14533     if (!r[2]) {
14534       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14535       print_strings (r);
14536       return -1;
14537     }
14538     {
14539       char expected[] = "/dev/VG2/LV3";
14540       if (strcmp (r[2], expected) != 0) {
14541         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14542         return -1;
14543       }
14544     }
14545     if (!r[3]) {
14546       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14547       print_strings (r);
14548       return -1;
14549     }
14550     {
14551       char expected[] = "/dev/VG2/LV4";
14552       if (strcmp (r[3], expected) != 0) {
14553         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14554         return -1;
14555       }
14556     }
14557     if (!r[4]) {
14558       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14559       print_strings (r);
14560       return -1;
14561     }
14562     {
14563       char expected[] = "/dev/VG2/LV5";
14564       if (strcmp (r[4], expected) != 0) {
14565         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14566         return -1;
14567       }
14568     }
14569     if (r[5] != NULL) {
14570       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14571       print_strings (r);
14572       return -1;
14573     }
14574     for (i = 0; r[i] != NULL; ++i)
14575       free (r[i]);
14576     free (r);
14577   }
14578   return 0;
14579 }
14580
14581 static int test_vgcreate_0_skip (void)
14582 {
14583   const char *str;
14584
14585   str = getenv ("TEST_ONLY");
14586   if (str)
14587     return strstr (str, "vgcreate") == NULL;
14588   str = getenv ("SKIP_TEST_VGCREATE_0");
14589   if (str && strcmp (str, "1") == 0) return 1;
14590   str = getenv ("SKIP_TEST_VGCREATE");
14591   if (str && strcmp (str, "1") == 0) return 1;
14592   return 0;
14593 }
14594
14595 static int test_vgcreate_0 (void)
14596 {
14597   if (test_vgcreate_0_skip ()) {
14598     printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14599     return 0;
14600   }
14601
14602   /* InitNone|InitEmpty for test_vgcreate_0 */
14603   {
14604     char device[] = "/dev/sda";
14605     int r;
14606     suppress_error = 0;
14607     r = guestfs_blockdev_setrw (g, device);
14608     if (r == -1)
14609       return -1;
14610   }
14611   {
14612     int r;
14613     suppress_error = 0;
14614     r = guestfs_umount_all (g);
14615     if (r == -1)
14616       return -1;
14617   }
14618   {
14619     int r;
14620     suppress_error = 0;
14621     r = guestfs_lvm_remove_all (g);
14622     if (r == -1)
14623       return -1;
14624   }
14625   /* TestOutputList for vgcreate (0) */
14626   {
14627     char device[] = "/dev/sda";
14628     char lines_0[] = ",10";
14629     char lines_1[] = ",20";
14630     char lines_2[] = ",";
14631     char *lines[] = {
14632       lines_0,
14633       lines_1,
14634       lines_2,
14635       NULL
14636     };
14637     int r;
14638     suppress_error = 0;
14639     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14640     if (r == -1)
14641       return -1;
14642   }
14643   {
14644     char device[] = "/dev/sda1";
14645     int r;
14646     suppress_error = 0;
14647     r = guestfs_pvcreate (g, device);
14648     if (r == -1)
14649       return -1;
14650   }
14651   {
14652     char device[] = "/dev/sda2";
14653     int r;
14654     suppress_error = 0;
14655     r = guestfs_pvcreate (g, device);
14656     if (r == -1)
14657       return -1;
14658   }
14659   {
14660     char device[] = "/dev/sda3";
14661     int r;
14662     suppress_error = 0;
14663     r = guestfs_pvcreate (g, device);
14664     if (r == -1)
14665       return -1;
14666   }
14667   {
14668     char volgroup[] = "VG1";
14669     char physvols_0[] = "/dev/sda1";
14670     char physvols_1[] = "/dev/sda2";
14671     char *physvols[] = {
14672       physvols_0,
14673       physvols_1,
14674       NULL
14675     };
14676     int r;
14677     suppress_error = 0;
14678     r = guestfs_vgcreate (g, volgroup, physvols);
14679     if (r == -1)
14680       return -1;
14681   }
14682   {
14683     char volgroup[] = "VG2";
14684     char physvols_0[] = "/dev/sda3";
14685     char *physvols[] = {
14686       physvols_0,
14687       NULL
14688     };
14689     int r;
14690     suppress_error = 0;
14691     r = guestfs_vgcreate (g, volgroup, physvols);
14692     if (r == -1)
14693       return -1;
14694   }
14695   {
14696     char **r;
14697     int i;
14698     suppress_error = 0;
14699     r = guestfs_vgs (g);
14700     if (r == NULL)
14701       return -1;
14702     if (!r[0]) {
14703       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14704       print_strings (r);
14705       return -1;
14706     }
14707     {
14708       char expected[] = "VG1";
14709       if (strcmp (r[0], expected) != 0) {
14710         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14711         return -1;
14712       }
14713     }
14714     if (!r[1]) {
14715       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14716       print_strings (r);
14717       return -1;
14718     }
14719     {
14720       char expected[] = "VG2";
14721       if (strcmp (r[1], expected) != 0) {
14722         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14723         return -1;
14724       }
14725     }
14726     if (r[2] != NULL) {
14727       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14728       print_strings (r);
14729       return -1;
14730     }
14731     for (i = 0; r[i] != NULL; ++i)
14732       free (r[i]);
14733     free (r);
14734   }
14735   return 0;
14736 }
14737
14738 static int test_pvcreate_0_skip (void)
14739 {
14740   const char *str;
14741
14742   str = getenv ("TEST_ONLY");
14743   if (str)
14744     return strstr (str, "pvcreate") == NULL;
14745   str = getenv ("SKIP_TEST_PVCREATE_0");
14746   if (str && strcmp (str, "1") == 0) return 1;
14747   str = getenv ("SKIP_TEST_PVCREATE");
14748   if (str && strcmp (str, "1") == 0) return 1;
14749   return 0;
14750 }
14751
14752 static int test_pvcreate_0 (void)
14753 {
14754   if (test_pvcreate_0_skip ()) {
14755     printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14756     return 0;
14757   }
14758
14759   /* InitNone|InitEmpty for test_pvcreate_0 */
14760   {
14761     char device[] = "/dev/sda";
14762     int r;
14763     suppress_error = 0;
14764     r = guestfs_blockdev_setrw (g, device);
14765     if (r == -1)
14766       return -1;
14767   }
14768   {
14769     int r;
14770     suppress_error = 0;
14771     r = guestfs_umount_all (g);
14772     if (r == -1)
14773       return -1;
14774   }
14775   {
14776     int r;
14777     suppress_error = 0;
14778     r = guestfs_lvm_remove_all (g);
14779     if (r == -1)
14780       return -1;
14781   }
14782   /* TestOutputListOfDevices for pvcreate (0) */
14783   {
14784     char device[] = "/dev/sda";
14785     char lines_0[] = ",10";
14786     char lines_1[] = ",20";
14787     char lines_2[] = ",";
14788     char *lines[] = {
14789       lines_0,
14790       lines_1,
14791       lines_2,
14792       NULL
14793     };
14794     int r;
14795     suppress_error = 0;
14796     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14797     if (r == -1)
14798       return -1;
14799   }
14800   {
14801     char device[] = "/dev/sda1";
14802     int r;
14803     suppress_error = 0;
14804     r = guestfs_pvcreate (g, device);
14805     if (r == -1)
14806       return -1;
14807   }
14808   {
14809     char device[] = "/dev/sda2";
14810     int r;
14811     suppress_error = 0;
14812     r = guestfs_pvcreate (g, device);
14813     if (r == -1)
14814       return -1;
14815   }
14816   {
14817     char device[] = "/dev/sda3";
14818     int r;
14819     suppress_error = 0;
14820     r = guestfs_pvcreate (g, device);
14821     if (r == -1)
14822       return -1;
14823   }
14824   {
14825     char **r;
14826     int i;
14827     suppress_error = 0;
14828     r = guestfs_pvs (g);
14829     if (r == NULL)
14830       return -1;
14831     if (!r[0]) {
14832       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14833       print_strings (r);
14834       return -1;
14835     }
14836     {
14837       char expected[] = "/dev/sda1";
14838       r[0][5] = 's';
14839       if (strcmp (r[0], expected) != 0) {
14840         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14841         return -1;
14842       }
14843     }
14844     if (!r[1]) {
14845       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14846       print_strings (r);
14847       return -1;
14848     }
14849     {
14850       char expected[] = "/dev/sda2";
14851       r[1][5] = 's';
14852       if (strcmp (r[1], expected) != 0) {
14853         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14854         return -1;
14855       }
14856     }
14857     if (!r[2]) {
14858       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14859       print_strings (r);
14860       return -1;
14861     }
14862     {
14863       char expected[] = "/dev/sda3";
14864       r[2][5] = 's';
14865       if (strcmp (r[2], expected) != 0) {
14866         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14867         return -1;
14868       }
14869     }
14870     if (r[3] != NULL) {
14871       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14872       print_strings (r);
14873       return -1;
14874     }
14875     for (i = 0; r[i] != NULL; ++i)
14876       free (r[i]);
14877     free (r);
14878   }
14879   return 0;
14880 }
14881
14882 static int test_is_dir_0_skip (void)
14883 {
14884   const char *str;
14885
14886   str = getenv ("TEST_ONLY");
14887   if (str)
14888     return strstr (str, "is_dir") == NULL;
14889   str = getenv ("SKIP_TEST_IS_DIR_0");
14890   if (str && strcmp (str, "1") == 0) return 1;
14891   str = getenv ("SKIP_TEST_IS_DIR");
14892   if (str && strcmp (str, "1") == 0) return 1;
14893   return 0;
14894 }
14895
14896 static int test_is_dir_0 (void)
14897 {
14898   if (test_is_dir_0_skip ()) {
14899     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14900     return 0;
14901   }
14902
14903   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14904   {
14905     char device[] = "/dev/sda";
14906     int r;
14907     suppress_error = 0;
14908     r = guestfs_blockdev_setrw (g, device);
14909     if (r == -1)
14910       return -1;
14911   }
14912   {
14913     int r;
14914     suppress_error = 0;
14915     r = guestfs_umount_all (g);
14916     if (r == -1)
14917       return -1;
14918   }
14919   {
14920     int r;
14921     suppress_error = 0;
14922     r = guestfs_lvm_remove_all (g);
14923     if (r == -1)
14924       return -1;
14925   }
14926   {
14927     char device[] = "/dev/sda";
14928     char lines_0[] = ",";
14929     char *lines[] = {
14930       lines_0,
14931       NULL
14932     };
14933     int r;
14934     suppress_error = 0;
14935     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14936     if (r == -1)
14937       return -1;
14938   }
14939   {
14940     char fstype[] = "ext2";
14941     char device[] = "/dev/sda1";
14942     int r;
14943     suppress_error = 0;
14944     r = guestfs_mkfs (g, fstype, device);
14945     if (r == -1)
14946       return -1;
14947   }
14948   {
14949     char device[] = "/dev/sda1";
14950     char mountpoint[] = "/";
14951     int r;
14952     suppress_error = 0;
14953     r = guestfs_mount (g, device, mountpoint);
14954     if (r == -1)
14955       return -1;
14956   }
14957   /* TestOutputFalse for is_dir (0) */
14958   {
14959     char path[] = "/new";
14960     int r;
14961     suppress_error = 0;
14962     r = guestfs_touch (g, path);
14963     if (r == -1)
14964       return -1;
14965   }
14966   {
14967     char path[] = "/new";
14968     int r;
14969     suppress_error = 0;
14970     r = guestfs_is_dir (g, path);
14971     if (r == -1)
14972       return -1;
14973     if (r) {
14974       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14975       return -1;
14976     }
14977   }
14978   return 0;
14979 }
14980
14981 static int test_is_dir_1_skip (void)
14982 {
14983   const char *str;
14984
14985   str = getenv ("TEST_ONLY");
14986   if (str)
14987     return strstr (str, "is_dir") == NULL;
14988   str = getenv ("SKIP_TEST_IS_DIR_1");
14989   if (str && strcmp (str, "1") == 0) return 1;
14990   str = getenv ("SKIP_TEST_IS_DIR");
14991   if (str && strcmp (str, "1") == 0) return 1;
14992   return 0;
14993 }
14994
14995 static int test_is_dir_1 (void)
14996 {
14997   if (test_is_dir_1_skip ()) {
14998     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
14999     return 0;
15000   }
15001
15002   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
15003   {
15004     char device[] = "/dev/sda";
15005     int r;
15006     suppress_error = 0;
15007     r = guestfs_blockdev_setrw (g, device);
15008     if (r == -1)
15009       return -1;
15010   }
15011   {
15012     int r;
15013     suppress_error = 0;
15014     r = guestfs_umount_all (g);
15015     if (r == -1)
15016       return -1;
15017   }
15018   {
15019     int r;
15020     suppress_error = 0;
15021     r = guestfs_lvm_remove_all (g);
15022     if (r == -1)
15023       return -1;
15024   }
15025   {
15026     char device[] = "/dev/sda";
15027     char lines_0[] = ",";
15028     char *lines[] = {
15029       lines_0,
15030       NULL
15031     };
15032     int r;
15033     suppress_error = 0;
15034     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15035     if (r == -1)
15036       return -1;
15037   }
15038   {
15039     char fstype[] = "ext2";
15040     char device[] = "/dev/sda1";
15041     int r;
15042     suppress_error = 0;
15043     r = guestfs_mkfs (g, fstype, device);
15044     if (r == -1)
15045       return -1;
15046   }
15047   {
15048     char device[] = "/dev/sda1";
15049     char mountpoint[] = "/";
15050     int r;
15051     suppress_error = 0;
15052     r = guestfs_mount (g, device, mountpoint);
15053     if (r == -1)
15054       return -1;
15055   }
15056   /* TestOutputTrue for is_dir (1) */
15057   {
15058     char path[] = "/new";
15059     int r;
15060     suppress_error = 0;
15061     r = guestfs_mkdir (g, path);
15062     if (r == -1)
15063       return -1;
15064   }
15065   {
15066     char path[] = "/new";
15067     int r;
15068     suppress_error = 0;
15069     r = guestfs_is_dir (g, path);
15070     if (r == -1)
15071       return -1;
15072     if (!r) {
15073       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
15074       return -1;
15075     }
15076   }
15077   return 0;
15078 }
15079
15080 static int test_is_file_0_skip (void)
15081 {
15082   const char *str;
15083
15084   str = getenv ("TEST_ONLY");
15085   if (str)
15086     return strstr (str, "is_file") == NULL;
15087   str = getenv ("SKIP_TEST_IS_FILE_0");
15088   if (str && strcmp (str, "1") == 0) return 1;
15089   str = getenv ("SKIP_TEST_IS_FILE");
15090   if (str && strcmp (str, "1") == 0) return 1;
15091   return 0;
15092 }
15093
15094 static int test_is_file_0 (void)
15095 {
15096   if (test_is_file_0_skip ()) {
15097     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
15098     return 0;
15099   }
15100
15101   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
15102   {
15103     char device[] = "/dev/sda";
15104     int r;
15105     suppress_error = 0;
15106     r = guestfs_blockdev_setrw (g, device);
15107     if (r == -1)
15108       return -1;
15109   }
15110   {
15111     int r;
15112     suppress_error = 0;
15113     r = guestfs_umount_all (g);
15114     if (r == -1)
15115       return -1;
15116   }
15117   {
15118     int r;
15119     suppress_error = 0;
15120     r = guestfs_lvm_remove_all (g);
15121     if (r == -1)
15122       return -1;
15123   }
15124   {
15125     char device[] = "/dev/sda";
15126     char lines_0[] = ",";
15127     char *lines[] = {
15128       lines_0,
15129       NULL
15130     };
15131     int r;
15132     suppress_error = 0;
15133     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15134     if (r == -1)
15135       return -1;
15136   }
15137   {
15138     char fstype[] = "ext2";
15139     char device[] = "/dev/sda1";
15140     int r;
15141     suppress_error = 0;
15142     r = guestfs_mkfs (g, fstype, device);
15143     if (r == -1)
15144       return -1;
15145   }
15146   {
15147     char device[] = "/dev/sda1";
15148     char mountpoint[] = "/";
15149     int r;
15150     suppress_error = 0;
15151     r = guestfs_mount (g, device, mountpoint);
15152     if (r == -1)
15153       return -1;
15154   }
15155   /* TestOutputTrue for is_file (0) */
15156   {
15157     char path[] = "/new";
15158     int r;
15159     suppress_error = 0;
15160     r = guestfs_touch (g, path);
15161     if (r == -1)
15162       return -1;
15163   }
15164   {
15165     char path[] = "/new";
15166     int r;
15167     suppress_error = 0;
15168     r = guestfs_is_file (g, path);
15169     if (r == -1)
15170       return -1;
15171     if (!r) {
15172       fprintf (stderr, "test_is_file_0: expected true, got false\n");
15173       return -1;
15174     }
15175   }
15176   return 0;
15177 }
15178
15179 static int test_is_file_1_skip (void)
15180 {
15181   const char *str;
15182
15183   str = getenv ("TEST_ONLY");
15184   if (str)
15185     return strstr (str, "is_file") == NULL;
15186   str = getenv ("SKIP_TEST_IS_FILE_1");
15187   if (str && strcmp (str, "1") == 0) return 1;
15188   str = getenv ("SKIP_TEST_IS_FILE");
15189   if (str && strcmp (str, "1") == 0) return 1;
15190   return 0;
15191 }
15192
15193 static int test_is_file_1 (void)
15194 {
15195   if (test_is_file_1_skip ()) {
15196     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
15197     return 0;
15198   }
15199
15200   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
15201   {
15202     char device[] = "/dev/sda";
15203     int r;
15204     suppress_error = 0;
15205     r = guestfs_blockdev_setrw (g, device);
15206     if (r == -1)
15207       return -1;
15208   }
15209   {
15210     int r;
15211     suppress_error = 0;
15212     r = guestfs_umount_all (g);
15213     if (r == -1)
15214       return -1;
15215   }
15216   {
15217     int r;
15218     suppress_error = 0;
15219     r = guestfs_lvm_remove_all (g);
15220     if (r == -1)
15221       return -1;
15222   }
15223   {
15224     char device[] = "/dev/sda";
15225     char lines_0[] = ",";
15226     char *lines[] = {
15227       lines_0,
15228       NULL
15229     };
15230     int r;
15231     suppress_error = 0;
15232     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15233     if (r == -1)
15234       return -1;
15235   }
15236   {
15237     char fstype[] = "ext2";
15238     char device[] = "/dev/sda1";
15239     int r;
15240     suppress_error = 0;
15241     r = guestfs_mkfs (g, fstype, device);
15242     if (r == -1)
15243       return -1;
15244   }
15245   {
15246     char device[] = "/dev/sda1";
15247     char mountpoint[] = "/";
15248     int r;
15249     suppress_error = 0;
15250     r = guestfs_mount (g, device, mountpoint);
15251     if (r == -1)
15252       return -1;
15253   }
15254   /* TestOutputFalse for is_file (1) */
15255   {
15256     char path[] = "/new";
15257     int r;
15258     suppress_error = 0;
15259     r = guestfs_mkdir (g, path);
15260     if (r == -1)
15261       return -1;
15262   }
15263   {
15264     char path[] = "/new";
15265     int r;
15266     suppress_error = 0;
15267     r = guestfs_is_file (g, path);
15268     if (r == -1)
15269       return -1;
15270     if (r) {
15271       fprintf (stderr, "test_is_file_1: expected false, got true\n");
15272       return -1;
15273     }
15274   }
15275   return 0;
15276 }
15277
15278 static int test_exists_0_skip (void)
15279 {
15280   const char *str;
15281
15282   str = getenv ("TEST_ONLY");
15283   if (str)
15284     return strstr (str, "exists") == NULL;
15285   str = getenv ("SKIP_TEST_EXISTS_0");
15286   if (str && strcmp (str, "1") == 0) return 1;
15287   str = getenv ("SKIP_TEST_EXISTS");
15288   if (str && strcmp (str, "1") == 0) return 1;
15289   return 0;
15290 }
15291
15292 static int test_exists_0 (void)
15293 {
15294   if (test_exists_0_skip ()) {
15295     printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
15296     return 0;
15297   }
15298
15299   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15300   {
15301     char device[] = "/dev/sda";
15302     int r;
15303     suppress_error = 0;
15304     r = guestfs_blockdev_setrw (g, device);
15305     if (r == -1)
15306       return -1;
15307   }
15308   {
15309     int r;
15310     suppress_error = 0;
15311     r = guestfs_umount_all (g);
15312     if (r == -1)
15313       return -1;
15314   }
15315   {
15316     int r;
15317     suppress_error = 0;
15318     r = guestfs_lvm_remove_all (g);
15319     if (r == -1)
15320       return -1;
15321   }
15322   {
15323     char device[] = "/dev/sda";
15324     char lines_0[] = ",";
15325     char *lines[] = {
15326       lines_0,
15327       NULL
15328     };
15329     int r;
15330     suppress_error = 0;
15331     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15332     if (r == -1)
15333       return -1;
15334   }
15335   {
15336     char fstype[] = "ext2";
15337     char device[] = "/dev/sda1";
15338     int r;
15339     suppress_error = 0;
15340     r = guestfs_mkfs (g, fstype, device);
15341     if (r == -1)
15342       return -1;
15343   }
15344   {
15345     char device[] = "/dev/sda1";
15346     char mountpoint[] = "/";
15347     int r;
15348     suppress_error = 0;
15349     r = guestfs_mount (g, device, mountpoint);
15350     if (r == -1)
15351       return -1;
15352   }
15353   /* TestOutputTrue for exists (0) */
15354   {
15355     char path[] = "/new";
15356     int r;
15357     suppress_error = 0;
15358     r = guestfs_touch (g, path);
15359     if (r == -1)
15360       return -1;
15361   }
15362   {
15363     char path[] = "/new";
15364     int r;
15365     suppress_error = 0;
15366     r = guestfs_exists (g, path);
15367     if (r == -1)
15368       return -1;
15369     if (!r) {
15370       fprintf (stderr, "test_exists_0: expected true, got false\n");
15371       return -1;
15372     }
15373   }
15374   return 0;
15375 }
15376
15377 static int test_exists_1_skip (void)
15378 {
15379   const char *str;
15380
15381   str = getenv ("TEST_ONLY");
15382   if (str)
15383     return strstr (str, "exists") == NULL;
15384   str = getenv ("SKIP_TEST_EXISTS_1");
15385   if (str && strcmp (str, "1") == 0) return 1;
15386   str = getenv ("SKIP_TEST_EXISTS");
15387   if (str && strcmp (str, "1") == 0) return 1;
15388   return 0;
15389 }
15390
15391 static int test_exists_1 (void)
15392 {
15393   if (test_exists_1_skip ()) {
15394     printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15395     return 0;
15396   }
15397
15398   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15399   {
15400     char device[] = "/dev/sda";
15401     int r;
15402     suppress_error = 0;
15403     r = guestfs_blockdev_setrw (g, device);
15404     if (r == -1)
15405       return -1;
15406   }
15407   {
15408     int r;
15409     suppress_error = 0;
15410     r = guestfs_umount_all (g);
15411     if (r == -1)
15412       return -1;
15413   }
15414   {
15415     int r;
15416     suppress_error = 0;
15417     r = guestfs_lvm_remove_all (g);
15418     if (r == -1)
15419       return -1;
15420   }
15421   {
15422     char device[] = "/dev/sda";
15423     char lines_0[] = ",";
15424     char *lines[] = {
15425       lines_0,
15426       NULL
15427     };
15428     int r;
15429     suppress_error = 0;
15430     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15431     if (r == -1)
15432       return -1;
15433   }
15434   {
15435     char fstype[] = "ext2";
15436     char device[] = "/dev/sda1";
15437     int r;
15438     suppress_error = 0;
15439     r = guestfs_mkfs (g, fstype, device);
15440     if (r == -1)
15441       return -1;
15442   }
15443   {
15444     char device[] = "/dev/sda1";
15445     char mountpoint[] = "/";
15446     int r;
15447     suppress_error = 0;
15448     r = guestfs_mount (g, device, mountpoint);
15449     if (r == -1)
15450       return -1;
15451   }
15452   /* TestOutputTrue for exists (1) */
15453   {
15454     char path[] = "/new";
15455     int r;
15456     suppress_error = 0;
15457     r = guestfs_mkdir (g, path);
15458     if (r == -1)
15459       return -1;
15460   }
15461   {
15462     char path[] = "/new";
15463     int r;
15464     suppress_error = 0;
15465     r = guestfs_exists (g, path);
15466     if (r == -1)
15467       return -1;
15468     if (!r) {
15469       fprintf (stderr, "test_exists_1: expected true, got false\n");
15470       return -1;
15471     }
15472   }
15473   return 0;
15474 }
15475
15476 static int test_mkdir_p_0_skip (void)
15477 {
15478   const char *str;
15479
15480   str = getenv ("TEST_ONLY");
15481   if (str)
15482     return strstr (str, "mkdir_p") == NULL;
15483   str = getenv ("SKIP_TEST_MKDIR_P_0");
15484   if (str && strcmp (str, "1") == 0) return 1;
15485   str = getenv ("SKIP_TEST_MKDIR_P");
15486   if (str && strcmp (str, "1") == 0) return 1;
15487   return 0;
15488 }
15489
15490 static int test_mkdir_p_0 (void)
15491 {
15492   if (test_mkdir_p_0_skip ()) {
15493     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15494     return 0;
15495   }
15496
15497   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15498   {
15499     char device[] = "/dev/sda";
15500     int r;
15501     suppress_error = 0;
15502     r = guestfs_blockdev_setrw (g, device);
15503     if (r == -1)
15504       return -1;
15505   }
15506   {
15507     int r;
15508     suppress_error = 0;
15509     r = guestfs_umount_all (g);
15510     if (r == -1)
15511       return -1;
15512   }
15513   {
15514     int r;
15515     suppress_error = 0;
15516     r = guestfs_lvm_remove_all (g);
15517     if (r == -1)
15518       return -1;
15519   }
15520   {
15521     char device[] = "/dev/sda";
15522     char lines_0[] = ",";
15523     char *lines[] = {
15524       lines_0,
15525       NULL
15526     };
15527     int r;
15528     suppress_error = 0;
15529     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15530     if (r == -1)
15531       return -1;
15532   }
15533   {
15534     char fstype[] = "ext2";
15535     char device[] = "/dev/sda1";
15536     int r;
15537     suppress_error = 0;
15538     r = guestfs_mkfs (g, fstype, device);
15539     if (r == -1)
15540       return -1;
15541   }
15542   {
15543     char device[] = "/dev/sda1";
15544     char mountpoint[] = "/";
15545     int r;
15546     suppress_error = 0;
15547     r = guestfs_mount (g, device, mountpoint);
15548     if (r == -1)
15549       return -1;
15550   }
15551   /* TestOutputTrue for mkdir_p (0) */
15552   {
15553     char path[] = "/new/foo/bar";
15554     int r;
15555     suppress_error = 0;
15556     r = guestfs_mkdir_p (g, path);
15557     if (r == -1)
15558       return -1;
15559   }
15560   {
15561     char path[] = "/new/foo/bar";
15562     int r;
15563     suppress_error = 0;
15564     r = guestfs_is_dir (g, path);
15565     if (r == -1)
15566       return -1;
15567     if (!r) {
15568       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15569       return -1;
15570     }
15571   }
15572   return 0;
15573 }
15574
15575 static int test_mkdir_p_1_skip (void)
15576 {
15577   const char *str;
15578
15579   str = getenv ("TEST_ONLY");
15580   if (str)
15581     return strstr (str, "mkdir_p") == NULL;
15582   str = getenv ("SKIP_TEST_MKDIR_P_1");
15583   if (str && strcmp (str, "1") == 0) return 1;
15584   str = getenv ("SKIP_TEST_MKDIR_P");
15585   if (str && strcmp (str, "1") == 0) return 1;
15586   return 0;
15587 }
15588
15589 static int test_mkdir_p_1 (void)
15590 {
15591   if (test_mkdir_p_1_skip ()) {
15592     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15593     return 0;
15594   }
15595
15596   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15597   {
15598     char device[] = "/dev/sda";
15599     int r;
15600     suppress_error = 0;
15601     r = guestfs_blockdev_setrw (g, device);
15602     if (r == -1)
15603       return -1;
15604   }
15605   {
15606     int r;
15607     suppress_error = 0;
15608     r = guestfs_umount_all (g);
15609     if (r == -1)
15610       return -1;
15611   }
15612   {
15613     int r;
15614     suppress_error = 0;
15615     r = guestfs_lvm_remove_all (g);
15616     if (r == -1)
15617       return -1;
15618   }
15619   {
15620     char device[] = "/dev/sda";
15621     char lines_0[] = ",";
15622     char *lines[] = {
15623       lines_0,
15624       NULL
15625     };
15626     int r;
15627     suppress_error = 0;
15628     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15629     if (r == -1)
15630       return -1;
15631   }
15632   {
15633     char fstype[] = "ext2";
15634     char device[] = "/dev/sda1";
15635     int r;
15636     suppress_error = 0;
15637     r = guestfs_mkfs (g, fstype, device);
15638     if (r == -1)
15639       return -1;
15640   }
15641   {
15642     char device[] = "/dev/sda1";
15643     char mountpoint[] = "/";
15644     int r;
15645     suppress_error = 0;
15646     r = guestfs_mount (g, device, mountpoint);
15647     if (r == -1)
15648       return -1;
15649   }
15650   /* TestOutputTrue for mkdir_p (1) */
15651   {
15652     char path[] = "/new/foo/bar";
15653     int r;
15654     suppress_error = 0;
15655     r = guestfs_mkdir_p (g, path);
15656     if (r == -1)
15657       return -1;
15658   }
15659   {
15660     char path[] = "/new/foo";
15661     int r;
15662     suppress_error = 0;
15663     r = guestfs_is_dir (g, path);
15664     if (r == -1)
15665       return -1;
15666     if (!r) {
15667       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15668       return -1;
15669     }
15670   }
15671   return 0;
15672 }
15673
15674 static int test_mkdir_p_2_skip (void)
15675 {
15676   const char *str;
15677
15678   str = getenv ("TEST_ONLY");
15679   if (str)
15680     return strstr (str, "mkdir_p") == NULL;
15681   str = getenv ("SKIP_TEST_MKDIR_P_2");
15682   if (str && strcmp (str, "1") == 0) return 1;
15683   str = getenv ("SKIP_TEST_MKDIR_P");
15684   if (str && strcmp (str, "1") == 0) return 1;
15685   return 0;
15686 }
15687
15688 static int test_mkdir_p_2 (void)
15689 {
15690   if (test_mkdir_p_2_skip ()) {
15691     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15692     return 0;
15693   }
15694
15695   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15696   {
15697     char device[] = "/dev/sda";
15698     int r;
15699     suppress_error = 0;
15700     r = guestfs_blockdev_setrw (g, device);
15701     if (r == -1)
15702       return -1;
15703   }
15704   {
15705     int r;
15706     suppress_error = 0;
15707     r = guestfs_umount_all (g);
15708     if (r == -1)
15709       return -1;
15710   }
15711   {
15712     int r;
15713     suppress_error = 0;
15714     r = guestfs_lvm_remove_all (g);
15715     if (r == -1)
15716       return -1;
15717   }
15718   {
15719     char device[] = "/dev/sda";
15720     char lines_0[] = ",";
15721     char *lines[] = {
15722       lines_0,
15723       NULL
15724     };
15725     int r;
15726     suppress_error = 0;
15727     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15728     if (r == -1)
15729       return -1;
15730   }
15731   {
15732     char fstype[] = "ext2";
15733     char device[] = "/dev/sda1";
15734     int r;
15735     suppress_error = 0;
15736     r = guestfs_mkfs (g, fstype, device);
15737     if (r == -1)
15738       return -1;
15739   }
15740   {
15741     char device[] = "/dev/sda1";
15742     char mountpoint[] = "/";
15743     int r;
15744     suppress_error = 0;
15745     r = guestfs_mount (g, device, mountpoint);
15746     if (r == -1)
15747       return -1;
15748   }
15749   /* TestOutputTrue for mkdir_p (2) */
15750   {
15751     char path[] = "/new/foo/bar";
15752     int r;
15753     suppress_error = 0;
15754     r = guestfs_mkdir_p (g, path);
15755     if (r == -1)
15756       return -1;
15757   }
15758   {
15759     char path[] = "/new";
15760     int r;
15761     suppress_error = 0;
15762     r = guestfs_is_dir (g, path);
15763     if (r == -1)
15764       return -1;
15765     if (!r) {
15766       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15767       return -1;
15768     }
15769   }
15770   return 0;
15771 }
15772
15773 static int test_mkdir_p_3_skip (void)
15774 {
15775   const char *str;
15776
15777   str = getenv ("TEST_ONLY");
15778   if (str)
15779     return strstr (str, "mkdir_p") == NULL;
15780   str = getenv ("SKIP_TEST_MKDIR_P_3");
15781   if (str && strcmp (str, "1") == 0) return 1;
15782   str = getenv ("SKIP_TEST_MKDIR_P");
15783   if (str && strcmp (str, "1") == 0) return 1;
15784   return 0;
15785 }
15786
15787 static int test_mkdir_p_3 (void)
15788 {
15789   if (test_mkdir_p_3_skip ()) {
15790     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15791     return 0;
15792   }
15793
15794   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15795   {
15796     char device[] = "/dev/sda";
15797     int r;
15798     suppress_error = 0;
15799     r = guestfs_blockdev_setrw (g, device);
15800     if (r == -1)
15801       return -1;
15802   }
15803   {
15804     int r;
15805     suppress_error = 0;
15806     r = guestfs_umount_all (g);
15807     if (r == -1)
15808       return -1;
15809   }
15810   {
15811     int r;
15812     suppress_error = 0;
15813     r = guestfs_lvm_remove_all (g);
15814     if (r == -1)
15815       return -1;
15816   }
15817   {
15818     char device[] = "/dev/sda";
15819     char lines_0[] = ",";
15820     char *lines[] = {
15821       lines_0,
15822       NULL
15823     };
15824     int r;
15825     suppress_error = 0;
15826     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15827     if (r == -1)
15828       return -1;
15829   }
15830   {
15831     char fstype[] = "ext2";
15832     char device[] = "/dev/sda1";
15833     int r;
15834     suppress_error = 0;
15835     r = guestfs_mkfs (g, fstype, device);
15836     if (r == -1)
15837       return -1;
15838   }
15839   {
15840     char device[] = "/dev/sda1";
15841     char mountpoint[] = "/";
15842     int r;
15843     suppress_error = 0;
15844     r = guestfs_mount (g, device, mountpoint);
15845     if (r == -1)
15846       return -1;
15847   }
15848   /* TestRun for mkdir_p (3) */
15849   {
15850     char path[] = "/new";
15851     int r;
15852     suppress_error = 0;
15853     r = guestfs_mkdir (g, path);
15854     if (r == -1)
15855       return -1;
15856   }
15857   {
15858     char path[] = "/new";
15859     int r;
15860     suppress_error = 0;
15861     r = guestfs_mkdir_p (g, path);
15862     if (r == -1)
15863       return -1;
15864   }
15865   return 0;
15866 }
15867
15868 static int test_mkdir_p_4_skip (void)
15869 {
15870   const char *str;
15871
15872   str = getenv ("TEST_ONLY");
15873   if (str)
15874     return strstr (str, "mkdir_p") == NULL;
15875   str = getenv ("SKIP_TEST_MKDIR_P_4");
15876   if (str && strcmp (str, "1") == 0) return 1;
15877   str = getenv ("SKIP_TEST_MKDIR_P");
15878   if (str && strcmp (str, "1") == 0) return 1;
15879   return 0;
15880 }
15881
15882 static int test_mkdir_p_4 (void)
15883 {
15884   if (test_mkdir_p_4_skip ()) {
15885     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15886     return 0;
15887   }
15888
15889   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15890   {
15891     char device[] = "/dev/sda";
15892     int r;
15893     suppress_error = 0;
15894     r = guestfs_blockdev_setrw (g, device);
15895     if (r == -1)
15896       return -1;
15897   }
15898   {
15899     int r;
15900     suppress_error = 0;
15901     r = guestfs_umount_all (g);
15902     if (r == -1)
15903       return -1;
15904   }
15905   {
15906     int r;
15907     suppress_error = 0;
15908     r = guestfs_lvm_remove_all (g);
15909     if (r == -1)
15910       return -1;
15911   }
15912   {
15913     char device[] = "/dev/sda";
15914     char lines_0[] = ",";
15915     char *lines[] = {
15916       lines_0,
15917       NULL
15918     };
15919     int r;
15920     suppress_error = 0;
15921     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15922     if (r == -1)
15923       return -1;
15924   }
15925   {
15926     char fstype[] = "ext2";
15927     char device[] = "/dev/sda1";
15928     int r;
15929     suppress_error = 0;
15930     r = guestfs_mkfs (g, fstype, device);
15931     if (r == -1)
15932       return -1;
15933   }
15934   {
15935     char device[] = "/dev/sda1";
15936     char mountpoint[] = "/";
15937     int r;
15938     suppress_error = 0;
15939     r = guestfs_mount (g, device, mountpoint);
15940     if (r == -1)
15941       return -1;
15942   }
15943   /* TestLastFail for mkdir_p (4) */
15944   {
15945     char path[] = "/new";
15946     int r;
15947     suppress_error = 0;
15948     r = guestfs_touch (g, path);
15949     if (r == -1)
15950       return -1;
15951   }
15952   {
15953     char path[] = "/new";
15954     int r;
15955     suppress_error = 1;
15956     r = guestfs_mkdir_p (g, path);
15957     if (r != -1)
15958       return -1;
15959   }
15960   return 0;
15961 }
15962
15963 static int test_mkdir_0_skip (void)
15964 {
15965   const char *str;
15966
15967   str = getenv ("TEST_ONLY");
15968   if (str)
15969     return strstr (str, "mkdir") == NULL;
15970   str = getenv ("SKIP_TEST_MKDIR_0");
15971   if (str && strcmp (str, "1") == 0) return 1;
15972   str = getenv ("SKIP_TEST_MKDIR");
15973   if (str && strcmp (str, "1") == 0) return 1;
15974   return 0;
15975 }
15976
15977 static int test_mkdir_0 (void)
15978 {
15979   if (test_mkdir_0_skip ()) {
15980     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15981     return 0;
15982   }
15983
15984   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15985   {
15986     char device[] = "/dev/sda";
15987     int r;
15988     suppress_error = 0;
15989     r = guestfs_blockdev_setrw (g, device);
15990     if (r == -1)
15991       return -1;
15992   }
15993   {
15994     int r;
15995     suppress_error = 0;
15996     r = guestfs_umount_all (g);
15997     if (r == -1)
15998       return -1;
15999   }
16000   {
16001     int r;
16002     suppress_error = 0;
16003     r = guestfs_lvm_remove_all (g);
16004     if (r == -1)
16005       return -1;
16006   }
16007   {
16008     char device[] = "/dev/sda";
16009     char lines_0[] = ",";
16010     char *lines[] = {
16011       lines_0,
16012       NULL
16013     };
16014     int r;
16015     suppress_error = 0;
16016     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16017     if (r == -1)
16018       return -1;
16019   }
16020   {
16021     char fstype[] = "ext2";
16022     char device[] = "/dev/sda1";
16023     int r;
16024     suppress_error = 0;
16025     r = guestfs_mkfs (g, fstype, device);
16026     if (r == -1)
16027       return -1;
16028   }
16029   {
16030     char device[] = "/dev/sda1";
16031     char mountpoint[] = "/";
16032     int r;
16033     suppress_error = 0;
16034     r = guestfs_mount (g, device, mountpoint);
16035     if (r == -1)
16036       return -1;
16037   }
16038   /* TestOutputTrue for mkdir (0) */
16039   {
16040     char path[] = "/new";
16041     int r;
16042     suppress_error = 0;
16043     r = guestfs_mkdir (g, path);
16044     if (r == -1)
16045       return -1;
16046   }
16047   {
16048     char path[] = "/new";
16049     int r;
16050     suppress_error = 0;
16051     r = guestfs_is_dir (g, path);
16052     if (r == -1)
16053       return -1;
16054     if (!r) {
16055       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
16056       return -1;
16057     }
16058   }
16059   return 0;
16060 }
16061
16062 static int test_mkdir_1_skip (void)
16063 {
16064   const char *str;
16065
16066   str = getenv ("TEST_ONLY");
16067   if (str)
16068     return strstr (str, "mkdir") == NULL;
16069   str = getenv ("SKIP_TEST_MKDIR_1");
16070   if (str && strcmp (str, "1") == 0) return 1;
16071   str = getenv ("SKIP_TEST_MKDIR");
16072   if (str && strcmp (str, "1") == 0) return 1;
16073   return 0;
16074 }
16075
16076 static int test_mkdir_1 (void)
16077 {
16078   if (test_mkdir_1_skip ()) {
16079     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
16080     return 0;
16081   }
16082
16083   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
16084   {
16085     char device[] = "/dev/sda";
16086     int r;
16087     suppress_error = 0;
16088     r = guestfs_blockdev_setrw (g, device);
16089     if (r == -1)
16090       return -1;
16091   }
16092   {
16093     int r;
16094     suppress_error = 0;
16095     r = guestfs_umount_all (g);
16096     if (r == -1)
16097       return -1;
16098   }
16099   {
16100     int r;
16101     suppress_error = 0;
16102     r = guestfs_lvm_remove_all (g);
16103     if (r == -1)
16104       return -1;
16105   }
16106   {
16107     char device[] = "/dev/sda";
16108     char lines_0[] = ",";
16109     char *lines[] = {
16110       lines_0,
16111       NULL
16112     };
16113     int r;
16114     suppress_error = 0;
16115     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16116     if (r == -1)
16117       return -1;
16118   }
16119   {
16120     char fstype[] = "ext2";
16121     char device[] = "/dev/sda1";
16122     int r;
16123     suppress_error = 0;
16124     r = guestfs_mkfs (g, fstype, device);
16125     if (r == -1)
16126       return -1;
16127   }
16128   {
16129     char device[] = "/dev/sda1";
16130     char mountpoint[] = "/";
16131     int r;
16132     suppress_error = 0;
16133     r = guestfs_mount (g, device, mountpoint);
16134     if (r == -1)
16135       return -1;
16136   }
16137   /* TestLastFail for mkdir (1) */
16138   {
16139     char path[] = "/new/foo/bar";
16140     int r;
16141     suppress_error = 1;
16142     r = guestfs_mkdir (g, path);
16143     if (r != -1)
16144       return -1;
16145   }
16146   return 0;
16147 }
16148
16149 static int test_rm_rf_0_skip (void)
16150 {
16151   const char *str;
16152
16153   str = getenv ("TEST_ONLY");
16154   if (str)
16155     return strstr (str, "rm_rf") == NULL;
16156   str = getenv ("SKIP_TEST_RM_RF_0");
16157   if (str && strcmp (str, "1") == 0) return 1;
16158   str = getenv ("SKIP_TEST_RM_RF");
16159   if (str && strcmp (str, "1") == 0) return 1;
16160   return 0;
16161 }
16162
16163 static int test_rm_rf_0 (void)
16164 {
16165   if (test_rm_rf_0_skip ()) {
16166     printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
16167     return 0;
16168   }
16169
16170   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
16171   {
16172     char device[] = "/dev/sda";
16173     int r;
16174     suppress_error = 0;
16175     r = guestfs_blockdev_setrw (g, device);
16176     if (r == -1)
16177       return -1;
16178   }
16179   {
16180     int r;
16181     suppress_error = 0;
16182     r = guestfs_umount_all (g);
16183     if (r == -1)
16184       return -1;
16185   }
16186   {
16187     int r;
16188     suppress_error = 0;
16189     r = guestfs_lvm_remove_all (g);
16190     if (r == -1)
16191       return -1;
16192   }
16193   {
16194     char device[] = "/dev/sda";
16195     char lines_0[] = ",";
16196     char *lines[] = {
16197       lines_0,
16198       NULL
16199     };
16200     int r;
16201     suppress_error = 0;
16202     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16203     if (r == -1)
16204       return -1;
16205   }
16206   {
16207     char fstype[] = "ext2";
16208     char device[] = "/dev/sda1";
16209     int r;
16210     suppress_error = 0;
16211     r = guestfs_mkfs (g, fstype, device);
16212     if (r == -1)
16213       return -1;
16214   }
16215   {
16216     char device[] = "/dev/sda1";
16217     char mountpoint[] = "/";
16218     int r;
16219     suppress_error = 0;
16220     r = guestfs_mount (g, device, mountpoint);
16221     if (r == -1)
16222       return -1;
16223   }
16224   /* TestOutputFalse for rm_rf (0) */
16225   {
16226     char path[] = "/new";
16227     int r;
16228     suppress_error = 0;
16229     r = guestfs_mkdir (g, path);
16230     if (r == -1)
16231       return -1;
16232   }
16233   {
16234     char path[] = "/new/foo";
16235     int r;
16236     suppress_error = 0;
16237     r = guestfs_mkdir (g, path);
16238     if (r == -1)
16239       return -1;
16240   }
16241   {
16242     char path[] = "/new/foo/bar";
16243     int r;
16244     suppress_error = 0;
16245     r = guestfs_touch (g, path);
16246     if (r == -1)
16247       return -1;
16248   }
16249   {
16250     char path[] = "/new";
16251     int r;
16252     suppress_error = 0;
16253     r = guestfs_rm_rf (g, path);
16254     if (r == -1)
16255       return -1;
16256   }
16257   {
16258     char path[] = "/new";
16259     int r;
16260     suppress_error = 0;
16261     r = guestfs_exists (g, path);
16262     if (r == -1)
16263       return -1;
16264     if (r) {
16265       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16266       return -1;
16267     }
16268   }
16269   return 0;
16270 }
16271
16272 static int test_rmdir_0_skip (void)
16273 {
16274   const char *str;
16275
16276   str = getenv ("TEST_ONLY");
16277   if (str)
16278     return strstr (str, "rmdir") == NULL;
16279   str = getenv ("SKIP_TEST_RMDIR_0");
16280   if (str && strcmp (str, "1") == 0) return 1;
16281   str = getenv ("SKIP_TEST_RMDIR");
16282   if (str && strcmp (str, "1") == 0) return 1;
16283   return 0;
16284 }
16285
16286 static int test_rmdir_0 (void)
16287 {
16288   if (test_rmdir_0_skip ()) {
16289     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
16290     return 0;
16291   }
16292
16293   /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16294   {
16295     char device[] = "/dev/sda";
16296     int r;
16297     suppress_error = 0;
16298     r = guestfs_blockdev_setrw (g, device);
16299     if (r == -1)
16300       return -1;
16301   }
16302   {
16303     int r;
16304     suppress_error = 0;
16305     r = guestfs_umount_all (g);
16306     if (r == -1)
16307       return -1;
16308   }
16309   {
16310     int r;
16311     suppress_error = 0;
16312     r = guestfs_lvm_remove_all (g);
16313     if (r == -1)
16314       return -1;
16315   }
16316   {
16317     char device[] = "/dev/sda";
16318     char lines_0[] = ",";
16319     char *lines[] = {
16320       lines_0,
16321       NULL
16322     };
16323     int r;
16324     suppress_error = 0;
16325     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16326     if (r == -1)
16327       return -1;
16328   }
16329   {
16330     char fstype[] = "ext2";
16331     char device[] = "/dev/sda1";
16332     int r;
16333     suppress_error = 0;
16334     r = guestfs_mkfs (g, fstype, device);
16335     if (r == -1)
16336       return -1;
16337   }
16338   {
16339     char device[] = "/dev/sda1";
16340     char mountpoint[] = "/";
16341     int r;
16342     suppress_error = 0;
16343     r = guestfs_mount (g, device, mountpoint);
16344     if (r == -1)
16345       return -1;
16346   }
16347   /* TestRun for rmdir (0) */
16348   {
16349     char path[] = "/new";
16350     int r;
16351     suppress_error = 0;
16352     r = guestfs_mkdir (g, path);
16353     if (r == -1)
16354       return -1;
16355   }
16356   {
16357     char path[] = "/new";
16358     int r;
16359     suppress_error = 0;
16360     r = guestfs_rmdir (g, path);
16361     if (r == -1)
16362       return -1;
16363   }
16364   return 0;
16365 }
16366
16367 static int test_rmdir_1_skip (void)
16368 {
16369   const char *str;
16370
16371   str = getenv ("TEST_ONLY");
16372   if (str)
16373     return strstr (str, "rmdir") == NULL;
16374   str = getenv ("SKIP_TEST_RMDIR_1");
16375   if (str && strcmp (str, "1") == 0) return 1;
16376   str = getenv ("SKIP_TEST_RMDIR");
16377   if (str && strcmp (str, "1") == 0) return 1;
16378   return 0;
16379 }
16380
16381 static int test_rmdir_1 (void)
16382 {
16383   if (test_rmdir_1_skip ()) {
16384     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16385     return 0;
16386   }
16387
16388   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16389   {
16390     char device[] = "/dev/sda";
16391     int r;
16392     suppress_error = 0;
16393     r = guestfs_blockdev_setrw (g, device);
16394     if (r == -1)
16395       return -1;
16396   }
16397   {
16398     int r;
16399     suppress_error = 0;
16400     r = guestfs_umount_all (g);
16401     if (r == -1)
16402       return -1;
16403   }
16404   {
16405     int r;
16406     suppress_error = 0;
16407     r = guestfs_lvm_remove_all (g);
16408     if (r == -1)
16409       return -1;
16410   }
16411   {
16412     char device[] = "/dev/sda";
16413     char lines_0[] = ",";
16414     char *lines[] = {
16415       lines_0,
16416       NULL
16417     };
16418     int r;
16419     suppress_error = 0;
16420     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16421     if (r == -1)
16422       return -1;
16423   }
16424   {
16425     char fstype[] = "ext2";
16426     char device[] = "/dev/sda1";
16427     int r;
16428     suppress_error = 0;
16429     r = guestfs_mkfs (g, fstype, device);
16430     if (r == -1)
16431       return -1;
16432   }
16433   {
16434     char device[] = "/dev/sda1";
16435     char mountpoint[] = "/";
16436     int r;
16437     suppress_error = 0;
16438     r = guestfs_mount (g, device, mountpoint);
16439     if (r == -1)
16440       return -1;
16441   }
16442   /* TestLastFail for rmdir (1) */
16443   {
16444     char path[] = "/new";
16445     int r;
16446     suppress_error = 1;
16447     r = guestfs_rmdir (g, path);
16448     if (r != -1)
16449       return -1;
16450   }
16451   return 0;
16452 }
16453
16454 static int test_rmdir_2_skip (void)
16455 {
16456   const char *str;
16457
16458   str = getenv ("TEST_ONLY");
16459   if (str)
16460     return strstr (str, "rmdir") == NULL;
16461   str = getenv ("SKIP_TEST_RMDIR_2");
16462   if (str && strcmp (str, "1") == 0) return 1;
16463   str = getenv ("SKIP_TEST_RMDIR");
16464   if (str && strcmp (str, "1") == 0) return 1;
16465   return 0;
16466 }
16467
16468 static int test_rmdir_2 (void)
16469 {
16470   if (test_rmdir_2_skip ()) {
16471     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16472     return 0;
16473   }
16474
16475   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16476   {
16477     char device[] = "/dev/sda";
16478     int r;
16479     suppress_error = 0;
16480     r = guestfs_blockdev_setrw (g, device);
16481     if (r == -1)
16482       return -1;
16483   }
16484   {
16485     int r;
16486     suppress_error = 0;
16487     r = guestfs_umount_all (g);
16488     if (r == -1)
16489       return -1;
16490   }
16491   {
16492     int r;
16493     suppress_error = 0;
16494     r = guestfs_lvm_remove_all (g);
16495     if (r == -1)
16496       return -1;
16497   }
16498   {
16499     char device[] = "/dev/sda";
16500     char lines_0[] = ",";
16501     char *lines[] = {
16502       lines_0,
16503       NULL
16504     };
16505     int r;
16506     suppress_error = 0;
16507     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16508     if (r == -1)
16509       return -1;
16510   }
16511   {
16512     char fstype[] = "ext2";
16513     char device[] = "/dev/sda1";
16514     int r;
16515     suppress_error = 0;
16516     r = guestfs_mkfs (g, fstype, device);
16517     if (r == -1)
16518       return -1;
16519   }
16520   {
16521     char device[] = "/dev/sda1";
16522     char mountpoint[] = "/";
16523     int r;
16524     suppress_error = 0;
16525     r = guestfs_mount (g, device, mountpoint);
16526     if (r == -1)
16527       return -1;
16528   }
16529   /* TestLastFail for rmdir (2) */
16530   {
16531     char path[] = "/new";
16532     int r;
16533     suppress_error = 0;
16534     r = guestfs_touch (g, path);
16535     if (r == -1)
16536       return -1;
16537   }
16538   {
16539     char path[] = "/new";
16540     int r;
16541     suppress_error = 1;
16542     r = guestfs_rmdir (g, path);
16543     if (r != -1)
16544       return -1;
16545   }
16546   return 0;
16547 }
16548
16549 static int test_rm_0_skip (void)
16550 {
16551   const char *str;
16552
16553   str = getenv ("TEST_ONLY");
16554   if (str)
16555     return strstr (str, "rm") == NULL;
16556   str = getenv ("SKIP_TEST_RM_0");
16557   if (str && strcmp (str, "1") == 0) return 1;
16558   str = getenv ("SKIP_TEST_RM");
16559   if (str && strcmp (str, "1") == 0) return 1;
16560   return 0;
16561 }
16562
16563 static int test_rm_0 (void)
16564 {
16565   if (test_rm_0_skip ()) {
16566     printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16567     return 0;
16568   }
16569
16570   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16571   {
16572     char device[] = "/dev/sda";
16573     int r;
16574     suppress_error = 0;
16575     r = guestfs_blockdev_setrw (g, device);
16576     if (r == -1)
16577       return -1;
16578   }
16579   {
16580     int r;
16581     suppress_error = 0;
16582     r = guestfs_umount_all (g);
16583     if (r == -1)
16584       return -1;
16585   }
16586   {
16587     int r;
16588     suppress_error = 0;
16589     r = guestfs_lvm_remove_all (g);
16590     if (r == -1)
16591       return -1;
16592   }
16593   {
16594     char device[] = "/dev/sda";
16595     char lines_0[] = ",";
16596     char *lines[] = {
16597       lines_0,
16598       NULL
16599     };
16600     int r;
16601     suppress_error = 0;
16602     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16603     if (r == -1)
16604       return -1;
16605   }
16606   {
16607     char fstype[] = "ext2";
16608     char device[] = "/dev/sda1";
16609     int r;
16610     suppress_error = 0;
16611     r = guestfs_mkfs (g, fstype, device);
16612     if (r == -1)
16613       return -1;
16614   }
16615   {
16616     char device[] = "/dev/sda1";
16617     char mountpoint[] = "/";
16618     int r;
16619     suppress_error = 0;
16620     r = guestfs_mount (g, device, mountpoint);
16621     if (r == -1)
16622       return -1;
16623   }
16624   /* TestRun for rm (0) */
16625   {
16626     char path[] = "/new";
16627     int r;
16628     suppress_error = 0;
16629     r = guestfs_touch (g, path);
16630     if (r == -1)
16631       return -1;
16632   }
16633   {
16634     char path[] = "/new";
16635     int r;
16636     suppress_error = 0;
16637     r = guestfs_rm (g, path);
16638     if (r == -1)
16639       return -1;
16640   }
16641   return 0;
16642 }
16643
16644 static int test_rm_1_skip (void)
16645 {
16646   const char *str;
16647
16648   str = getenv ("TEST_ONLY");
16649   if (str)
16650     return strstr (str, "rm") == NULL;
16651   str = getenv ("SKIP_TEST_RM_1");
16652   if (str && strcmp (str, "1") == 0) return 1;
16653   str = getenv ("SKIP_TEST_RM");
16654   if (str && strcmp (str, "1") == 0) return 1;
16655   return 0;
16656 }
16657
16658 static int test_rm_1 (void)
16659 {
16660   if (test_rm_1_skip ()) {
16661     printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16662     return 0;
16663   }
16664
16665   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16666   {
16667     char device[] = "/dev/sda";
16668     int r;
16669     suppress_error = 0;
16670     r = guestfs_blockdev_setrw (g, device);
16671     if (r == -1)
16672       return -1;
16673   }
16674   {
16675     int r;
16676     suppress_error = 0;
16677     r = guestfs_umount_all (g);
16678     if (r == -1)
16679       return -1;
16680   }
16681   {
16682     int r;
16683     suppress_error = 0;
16684     r = guestfs_lvm_remove_all (g);
16685     if (r == -1)
16686       return -1;
16687   }
16688   {
16689     char device[] = "/dev/sda";
16690     char lines_0[] = ",";
16691     char *lines[] = {
16692       lines_0,
16693       NULL
16694     };
16695     int r;
16696     suppress_error = 0;
16697     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16698     if (r == -1)
16699       return -1;
16700   }
16701   {
16702     char fstype[] = "ext2";
16703     char device[] = "/dev/sda1";
16704     int r;
16705     suppress_error = 0;
16706     r = guestfs_mkfs (g, fstype, device);
16707     if (r == -1)
16708       return -1;
16709   }
16710   {
16711     char device[] = "/dev/sda1";
16712     char mountpoint[] = "/";
16713     int r;
16714     suppress_error = 0;
16715     r = guestfs_mount (g, device, mountpoint);
16716     if (r == -1)
16717       return -1;
16718   }
16719   /* TestLastFail for rm (1) */
16720   {
16721     char path[] = "/new";
16722     int r;
16723     suppress_error = 1;
16724     r = guestfs_rm (g, path);
16725     if (r != -1)
16726       return -1;
16727   }
16728   return 0;
16729 }
16730
16731 static int test_rm_2_skip (void)
16732 {
16733   const char *str;
16734
16735   str = getenv ("TEST_ONLY");
16736   if (str)
16737     return strstr (str, "rm") == NULL;
16738   str = getenv ("SKIP_TEST_RM_2");
16739   if (str && strcmp (str, "1") == 0) return 1;
16740   str = getenv ("SKIP_TEST_RM");
16741   if (str && strcmp (str, "1") == 0) return 1;
16742   return 0;
16743 }
16744
16745 static int test_rm_2 (void)
16746 {
16747   if (test_rm_2_skip ()) {
16748     printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16749     return 0;
16750   }
16751
16752   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16753   {
16754     char device[] = "/dev/sda";
16755     int r;
16756     suppress_error = 0;
16757     r = guestfs_blockdev_setrw (g, device);
16758     if (r == -1)
16759       return -1;
16760   }
16761   {
16762     int r;
16763     suppress_error = 0;
16764     r = guestfs_umount_all (g);
16765     if (r == -1)
16766       return -1;
16767   }
16768   {
16769     int r;
16770     suppress_error = 0;
16771     r = guestfs_lvm_remove_all (g);
16772     if (r == -1)
16773       return -1;
16774   }
16775   {
16776     char device[] = "/dev/sda";
16777     char lines_0[] = ",";
16778     char *lines[] = {
16779       lines_0,
16780       NULL
16781     };
16782     int r;
16783     suppress_error = 0;
16784     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16785     if (r == -1)
16786       return -1;
16787   }
16788   {
16789     char fstype[] = "ext2";
16790     char device[] = "/dev/sda1";
16791     int r;
16792     suppress_error = 0;
16793     r = guestfs_mkfs (g, fstype, device);
16794     if (r == -1)
16795       return -1;
16796   }
16797   {
16798     char device[] = "/dev/sda1";
16799     char mountpoint[] = "/";
16800     int r;
16801     suppress_error = 0;
16802     r = guestfs_mount (g, device, mountpoint);
16803     if (r == -1)
16804       return -1;
16805   }
16806   /* TestLastFail for rm (2) */
16807   {
16808     char path[] = "/new";
16809     int r;
16810     suppress_error = 0;
16811     r = guestfs_mkdir (g, path);
16812     if (r == -1)
16813       return -1;
16814   }
16815   {
16816     char path[] = "/new";
16817     int r;
16818     suppress_error = 1;
16819     r = guestfs_rm (g, path);
16820     if (r != -1)
16821       return -1;
16822   }
16823   return 0;
16824 }
16825
16826 static int test_read_lines_0_skip (void)
16827 {
16828   const char *str;
16829
16830   str = getenv ("TEST_ONLY");
16831   if (str)
16832     return strstr (str, "read_lines") == NULL;
16833   str = getenv ("SKIP_TEST_READ_LINES_0");
16834   if (str && strcmp (str, "1") == 0) return 1;
16835   str = getenv ("SKIP_TEST_READ_LINES");
16836   if (str && strcmp (str, "1") == 0) return 1;
16837   return 0;
16838 }
16839
16840 static int test_read_lines_0 (void)
16841 {
16842   if (test_read_lines_0_skip ()) {
16843     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16844     return 0;
16845   }
16846
16847   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16848   {
16849     char device[] = "/dev/sda";
16850     int r;
16851     suppress_error = 0;
16852     r = guestfs_blockdev_setrw (g, device);
16853     if (r == -1)
16854       return -1;
16855   }
16856   {
16857     int r;
16858     suppress_error = 0;
16859     r = guestfs_umount_all (g);
16860     if (r == -1)
16861       return -1;
16862   }
16863   {
16864     int r;
16865     suppress_error = 0;
16866     r = guestfs_lvm_remove_all (g);
16867     if (r == -1)
16868       return -1;
16869   }
16870   {
16871     char device[] = "/dev/sda";
16872     char lines_0[] = ",";
16873     char *lines[] = {
16874       lines_0,
16875       NULL
16876     };
16877     int r;
16878     suppress_error = 0;
16879     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16880     if (r == -1)
16881       return -1;
16882   }
16883   {
16884     char fstype[] = "ext2";
16885     char device[] = "/dev/sda1";
16886     int r;
16887     suppress_error = 0;
16888     r = guestfs_mkfs (g, fstype, device);
16889     if (r == -1)
16890       return -1;
16891   }
16892   {
16893     char device[] = "/dev/sda1";
16894     char mountpoint[] = "/";
16895     int r;
16896     suppress_error = 0;
16897     r = guestfs_mount (g, device, mountpoint);
16898     if (r == -1)
16899       return -1;
16900   }
16901   /* TestOutputList for read_lines (0) */
16902   {
16903     char path[] = "/new";
16904     char content[] = "line1\r\nline2\nline3";
16905     int r;
16906     suppress_error = 0;
16907     r = guestfs_write_file (g, path, content, 0);
16908     if (r == -1)
16909       return -1;
16910   }
16911   {
16912     char path[] = "/new";
16913     char **r;
16914     int i;
16915     suppress_error = 0;
16916     r = guestfs_read_lines (g, path);
16917     if (r == NULL)
16918       return -1;
16919     if (!r[0]) {
16920       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16921       print_strings (r);
16922       return -1;
16923     }
16924     {
16925       char expected[] = "line1";
16926       if (strcmp (r[0], expected) != 0) {
16927         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16928         return -1;
16929       }
16930     }
16931     if (!r[1]) {
16932       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16933       print_strings (r);
16934       return -1;
16935     }
16936     {
16937       char expected[] = "line2";
16938       if (strcmp (r[1], expected) != 0) {
16939         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16940         return -1;
16941       }
16942     }
16943     if (!r[2]) {
16944       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16945       print_strings (r);
16946       return -1;
16947     }
16948     {
16949       char expected[] = "line3";
16950       if (strcmp (r[2], expected) != 0) {
16951         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16952         return -1;
16953       }
16954     }
16955     if (r[3] != NULL) {
16956       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16957       print_strings (r);
16958       return -1;
16959     }
16960     for (i = 0; r[i] != NULL; ++i)
16961       free (r[i]);
16962     free (r);
16963   }
16964   return 0;
16965 }
16966
16967 static int test_read_lines_1_skip (void)
16968 {
16969   const char *str;
16970
16971   str = getenv ("TEST_ONLY");
16972   if (str)
16973     return strstr (str, "read_lines") == NULL;
16974   str = getenv ("SKIP_TEST_READ_LINES_1");
16975   if (str && strcmp (str, "1") == 0) return 1;
16976   str = getenv ("SKIP_TEST_READ_LINES");
16977   if (str && strcmp (str, "1") == 0) return 1;
16978   return 0;
16979 }
16980
16981 static int test_read_lines_1 (void)
16982 {
16983   if (test_read_lines_1_skip ()) {
16984     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16985     return 0;
16986   }
16987
16988   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16989   {
16990     char device[] = "/dev/sda";
16991     int r;
16992     suppress_error = 0;
16993     r = guestfs_blockdev_setrw (g, device);
16994     if (r == -1)
16995       return -1;
16996   }
16997   {
16998     int r;
16999     suppress_error = 0;
17000     r = guestfs_umount_all (g);
17001     if (r == -1)
17002       return -1;
17003   }
17004   {
17005     int r;
17006     suppress_error = 0;
17007     r = guestfs_lvm_remove_all (g);
17008     if (r == -1)
17009       return -1;
17010   }
17011   {
17012     char device[] = "/dev/sda";
17013     char lines_0[] = ",";
17014     char *lines[] = {
17015       lines_0,
17016       NULL
17017     };
17018     int r;
17019     suppress_error = 0;
17020     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17021     if (r == -1)
17022       return -1;
17023   }
17024   {
17025     char fstype[] = "ext2";
17026     char device[] = "/dev/sda1";
17027     int r;
17028     suppress_error = 0;
17029     r = guestfs_mkfs (g, fstype, device);
17030     if (r == -1)
17031       return -1;
17032   }
17033   {
17034     char device[] = "/dev/sda1";
17035     char mountpoint[] = "/";
17036     int r;
17037     suppress_error = 0;
17038     r = guestfs_mount (g, device, mountpoint);
17039     if (r == -1)
17040       return -1;
17041   }
17042   /* TestOutputList for read_lines (1) */
17043   {
17044     char path[] = "/new";
17045     char content[] = "";
17046     int r;
17047     suppress_error = 0;
17048     r = guestfs_write_file (g, path, content, 0);
17049     if (r == -1)
17050       return -1;
17051   }
17052   {
17053     char path[] = "/new";
17054     char **r;
17055     int i;
17056     suppress_error = 0;
17057     r = guestfs_read_lines (g, path);
17058     if (r == NULL)
17059       return -1;
17060     if (r[0] != NULL) {
17061       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
17062       print_strings (r);
17063       return -1;
17064     }
17065     for (i = 0; r[i] != NULL; ++i)
17066       free (r[i]);
17067     free (r);
17068   }
17069   return 0;
17070 }
17071
17072 static int test_lvs_0_skip (void)
17073 {
17074   const char *str;
17075
17076   str = getenv ("TEST_ONLY");
17077   if (str)
17078     return strstr (str, "lvs") == NULL;
17079   str = getenv ("SKIP_TEST_LVS_0");
17080   if (str && strcmp (str, "1") == 0) return 1;
17081   str = getenv ("SKIP_TEST_LVS");
17082   if (str && strcmp (str, "1") == 0) return 1;
17083   return 0;
17084 }
17085
17086 static int test_lvs_0 (void)
17087 {
17088   if (test_lvs_0_skip ()) {
17089     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
17090     return 0;
17091   }
17092
17093   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
17094   {
17095     char device[] = "/dev/sda";
17096     int r;
17097     suppress_error = 0;
17098     r = guestfs_blockdev_setrw (g, device);
17099     if (r == -1)
17100       return -1;
17101   }
17102   {
17103     int r;
17104     suppress_error = 0;
17105     r = guestfs_umount_all (g);
17106     if (r == -1)
17107       return -1;
17108   }
17109   {
17110     int r;
17111     suppress_error = 0;
17112     r = guestfs_lvm_remove_all (g);
17113     if (r == -1)
17114       return -1;
17115   }
17116   {
17117     char device[] = "/dev/sda";
17118     char lines_0[] = ",";
17119     char *lines[] = {
17120       lines_0,
17121       NULL
17122     };
17123     int r;
17124     suppress_error = 0;
17125     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17126     if (r == -1)
17127       return -1;
17128   }
17129   {
17130     char device[] = "/dev/sda1";
17131     int r;
17132     suppress_error = 0;
17133     r = guestfs_pvcreate (g, device);
17134     if (r == -1)
17135       return -1;
17136   }
17137   {
17138     char volgroup[] = "VG";
17139     char physvols_0[] = "/dev/sda1";
17140     char *physvols[] = {
17141       physvols_0,
17142       NULL
17143     };
17144     int r;
17145     suppress_error = 0;
17146     r = guestfs_vgcreate (g, volgroup, physvols);
17147     if (r == -1)
17148       return -1;
17149   }
17150   {
17151     char logvol[] = "LV";
17152     char volgroup[] = "VG";
17153     int r;
17154     suppress_error = 0;
17155     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17156     if (r == -1)
17157       return -1;
17158   }
17159   {
17160     char fstype[] = "ext2";
17161     char device[] = "/dev/VG/LV";
17162     int r;
17163     suppress_error = 0;
17164     r = guestfs_mkfs (g, fstype, device);
17165     if (r == -1)
17166       return -1;
17167   }
17168   {
17169     char device[] = "/dev/VG/LV";
17170     char mountpoint[] = "/";
17171     int r;
17172     suppress_error = 0;
17173     r = guestfs_mount (g, device, mountpoint);
17174     if (r == -1)
17175       return -1;
17176   }
17177   /* TestOutputList for lvs (0) */
17178   {
17179     char **r;
17180     int i;
17181     suppress_error = 0;
17182     r = guestfs_lvs (g);
17183     if (r == NULL)
17184       return -1;
17185     if (!r[0]) {
17186       fprintf (stderr, "test_lvs_0: short list returned from command\n");
17187       print_strings (r);
17188       return -1;
17189     }
17190     {
17191       char expected[] = "/dev/VG/LV";
17192       if (strcmp (r[0], expected) != 0) {
17193         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17194         return -1;
17195       }
17196     }
17197     if (r[1] != NULL) {
17198       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
17199       print_strings (r);
17200       return -1;
17201     }
17202     for (i = 0; r[i] != NULL; ++i)
17203       free (r[i]);
17204     free (r);
17205   }
17206   return 0;
17207 }
17208
17209 static int test_lvs_1_skip (void)
17210 {
17211   const char *str;
17212
17213   str = getenv ("TEST_ONLY");
17214   if (str)
17215     return strstr (str, "lvs") == NULL;
17216   str = getenv ("SKIP_TEST_LVS_1");
17217   if (str && strcmp (str, "1") == 0) return 1;
17218   str = getenv ("SKIP_TEST_LVS");
17219   if (str && strcmp (str, "1") == 0) return 1;
17220   return 0;
17221 }
17222
17223 static int test_lvs_1 (void)
17224 {
17225   if (test_lvs_1_skip ()) {
17226     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
17227     return 0;
17228   }
17229
17230   /* InitNone|InitEmpty for test_lvs_1 */
17231   {
17232     char device[] = "/dev/sda";
17233     int r;
17234     suppress_error = 0;
17235     r = guestfs_blockdev_setrw (g, device);
17236     if (r == -1)
17237       return -1;
17238   }
17239   {
17240     int r;
17241     suppress_error = 0;
17242     r = guestfs_umount_all (g);
17243     if (r == -1)
17244       return -1;
17245   }
17246   {
17247     int r;
17248     suppress_error = 0;
17249     r = guestfs_lvm_remove_all (g);
17250     if (r == -1)
17251       return -1;
17252   }
17253   /* TestOutputList for lvs (1) */
17254   {
17255     char device[] = "/dev/sda";
17256     char lines_0[] = ",10";
17257     char lines_1[] = ",20";
17258     char lines_2[] = ",";
17259     char *lines[] = {
17260       lines_0,
17261       lines_1,
17262       lines_2,
17263       NULL
17264     };
17265     int r;
17266     suppress_error = 0;
17267     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17268     if (r == -1)
17269       return -1;
17270   }
17271   {
17272     char device[] = "/dev/sda1";
17273     int r;
17274     suppress_error = 0;
17275     r = guestfs_pvcreate (g, device);
17276     if (r == -1)
17277       return -1;
17278   }
17279   {
17280     char device[] = "/dev/sda2";
17281     int r;
17282     suppress_error = 0;
17283     r = guestfs_pvcreate (g, device);
17284     if (r == -1)
17285       return -1;
17286   }
17287   {
17288     char device[] = "/dev/sda3";
17289     int r;
17290     suppress_error = 0;
17291     r = guestfs_pvcreate (g, device);
17292     if (r == -1)
17293       return -1;
17294   }
17295   {
17296     char volgroup[] = "VG1";
17297     char physvols_0[] = "/dev/sda1";
17298     char physvols_1[] = "/dev/sda2";
17299     char *physvols[] = {
17300       physvols_0,
17301       physvols_1,
17302       NULL
17303     };
17304     int r;
17305     suppress_error = 0;
17306     r = guestfs_vgcreate (g, volgroup, physvols);
17307     if (r == -1)
17308       return -1;
17309   }
17310   {
17311     char volgroup[] = "VG2";
17312     char physvols_0[] = "/dev/sda3";
17313     char *physvols[] = {
17314       physvols_0,
17315       NULL
17316     };
17317     int r;
17318     suppress_error = 0;
17319     r = guestfs_vgcreate (g, volgroup, physvols);
17320     if (r == -1)
17321       return -1;
17322   }
17323   {
17324     char logvol[] = "LV1";
17325     char volgroup[] = "VG1";
17326     int r;
17327     suppress_error = 0;
17328     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17329     if (r == -1)
17330       return -1;
17331   }
17332   {
17333     char logvol[] = "LV2";
17334     char volgroup[] = "VG1";
17335     int r;
17336     suppress_error = 0;
17337     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17338     if (r == -1)
17339       return -1;
17340   }
17341   {
17342     char logvol[] = "LV3";
17343     char volgroup[] = "VG2";
17344     int r;
17345     suppress_error = 0;
17346     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17347     if (r == -1)
17348       return -1;
17349   }
17350   {
17351     char **r;
17352     int i;
17353     suppress_error = 0;
17354     r = guestfs_lvs (g);
17355     if (r == NULL)
17356       return -1;
17357     if (!r[0]) {
17358       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17359       print_strings (r);
17360       return -1;
17361     }
17362     {
17363       char expected[] = "/dev/VG1/LV1";
17364       if (strcmp (r[0], expected) != 0) {
17365         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17366         return -1;
17367       }
17368     }
17369     if (!r[1]) {
17370       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17371       print_strings (r);
17372       return -1;
17373     }
17374     {
17375       char expected[] = "/dev/VG1/LV2";
17376       if (strcmp (r[1], expected) != 0) {
17377         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17378         return -1;
17379       }
17380     }
17381     if (!r[2]) {
17382       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17383       print_strings (r);
17384       return -1;
17385     }
17386     {
17387       char expected[] = "/dev/VG2/LV3";
17388       if (strcmp (r[2], expected) != 0) {
17389         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17390         return -1;
17391       }
17392     }
17393     if (r[3] != NULL) {
17394       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17395       print_strings (r);
17396       return -1;
17397     }
17398     for (i = 0; r[i] != NULL; ++i)
17399       free (r[i]);
17400     free (r);
17401   }
17402   return 0;
17403 }
17404
17405 static int test_vgs_0_skip (void)
17406 {
17407   const char *str;
17408
17409   str = getenv ("TEST_ONLY");
17410   if (str)
17411     return strstr (str, "vgs") == NULL;
17412   str = getenv ("SKIP_TEST_VGS_0");
17413   if (str && strcmp (str, "1") == 0) return 1;
17414   str = getenv ("SKIP_TEST_VGS");
17415   if (str && strcmp (str, "1") == 0) return 1;
17416   return 0;
17417 }
17418
17419 static int test_vgs_0 (void)
17420 {
17421   if (test_vgs_0_skip ()) {
17422     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17423     return 0;
17424   }
17425
17426   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17427   {
17428     char device[] = "/dev/sda";
17429     int r;
17430     suppress_error = 0;
17431     r = guestfs_blockdev_setrw (g, device);
17432     if (r == -1)
17433       return -1;
17434   }
17435   {
17436     int r;
17437     suppress_error = 0;
17438     r = guestfs_umount_all (g);
17439     if (r == -1)
17440       return -1;
17441   }
17442   {
17443     int r;
17444     suppress_error = 0;
17445     r = guestfs_lvm_remove_all (g);
17446     if (r == -1)
17447       return -1;
17448   }
17449   {
17450     char device[] = "/dev/sda";
17451     char lines_0[] = ",";
17452     char *lines[] = {
17453       lines_0,
17454       NULL
17455     };
17456     int r;
17457     suppress_error = 0;
17458     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17459     if (r == -1)
17460       return -1;
17461   }
17462   {
17463     char device[] = "/dev/sda1";
17464     int r;
17465     suppress_error = 0;
17466     r = guestfs_pvcreate (g, device);
17467     if (r == -1)
17468       return -1;
17469   }
17470   {
17471     char volgroup[] = "VG";
17472     char physvols_0[] = "/dev/sda1";
17473     char *physvols[] = {
17474       physvols_0,
17475       NULL
17476     };
17477     int r;
17478     suppress_error = 0;
17479     r = guestfs_vgcreate (g, volgroup, physvols);
17480     if (r == -1)
17481       return -1;
17482   }
17483   {
17484     char logvol[] = "LV";
17485     char volgroup[] = "VG";
17486     int r;
17487     suppress_error = 0;
17488     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17489     if (r == -1)
17490       return -1;
17491   }
17492   {
17493     char fstype[] = "ext2";
17494     char device[] = "/dev/VG/LV";
17495     int r;
17496     suppress_error = 0;
17497     r = guestfs_mkfs (g, fstype, device);
17498     if (r == -1)
17499       return -1;
17500   }
17501   {
17502     char device[] = "/dev/VG/LV";
17503     char mountpoint[] = "/";
17504     int r;
17505     suppress_error = 0;
17506     r = guestfs_mount (g, device, mountpoint);
17507     if (r == -1)
17508       return -1;
17509   }
17510   /* TestOutputList for vgs (0) */
17511   {
17512     char **r;
17513     int i;
17514     suppress_error = 0;
17515     r = guestfs_vgs (g);
17516     if (r == NULL)
17517       return -1;
17518     if (!r[0]) {
17519       fprintf (stderr, "test_vgs_0: short list returned from command\n");
17520       print_strings (r);
17521       return -1;
17522     }
17523     {
17524       char expected[] = "VG";
17525       if (strcmp (r[0], expected) != 0) {
17526         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17527         return -1;
17528       }
17529     }
17530     if (r[1] != NULL) {
17531       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17532       print_strings (r);
17533       return -1;
17534     }
17535     for (i = 0; r[i] != NULL; ++i)
17536       free (r[i]);
17537     free (r);
17538   }
17539   return 0;
17540 }
17541
17542 static int test_vgs_1_skip (void)
17543 {
17544   const char *str;
17545
17546   str = getenv ("TEST_ONLY");
17547   if (str)
17548     return strstr (str, "vgs") == NULL;
17549   str = getenv ("SKIP_TEST_VGS_1");
17550   if (str && strcmp (str, "1") == 0) return 1;
17551   str = getenv ("SKIP_TEST_VGS");
17552   if (str && strcmp (str, "1") == 0) return 1;
17553   return 0;
17554 }
17555
17556 static int test_vgs_1 (void)
17557 {
17558   if (test_vgs_1_skip ()) {
17559     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17560     return 0;
17561   }
17562
17563   /* InitNone|InitEmpty for test_vgs_1 */
17564   {
17565     char device[] = "/dev/sda";
17566     int r;
17567     suppress_error = 0;
17568     r = guestfs_blockdev_setrw (g, device);
17569     if (r == -1)
17570       return -1;
17571   }
17572   {
17573     int r;
17574     suppress_error = 0;
17575     r = guestfs_umount_all (g);
17576     if (r == -1)
17577       return -1;
17578   }
17579   {
17580     int r;
17581     suppress_error = 0;
17582     r = guestfs_lvm_remove_all (g);
17583     if (r == -1)
17584       return -1;
17585   }
17586   /* TestOutputList for vgs (1) */
17587   {
17588     char device[] = "/dev/sda";
17589     char lines_0[] = ",10";
17590     char lines_1[] = ",20";
17591     char lines_2[] = ",";
17592     char *lines[] = {
17593       lines_0,
17594       lines_1,
17595       lines_2,
17596       NULL
17597     };
17598     int r;
17599     suppress_error = 0;
17600     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17601     if (r == -1)
17602       return -1;
17603   }
17604   {
17605     char device[] = "/dev/sda1";
17606     int r;
17607     suppress_error = 0;
17608     r = guestfs_pvcreate (g, device);
17609     if (r == -1)
17610       return -1;
17611   }
17612   {
17613     char device[] = "/dev/sda2";
17614     int r;
17615     suppress_error = 0;
17616     r = guestfs_pvcreate (g, device);
17617     if (r == -1)
17618       return -1;
17619   }
17620   {
17621     char device[] = "/dev/sda3";
17622     int r;
17623     suppress_error = 0;
17624     r = guestfs_pvcreate (g, device);
17625     if (r == -1)
17626       return -1;
17627   }
17628   {
17629     char volgroup[] = "VG1";
17630     char physvols_0[] = "/dev/sda1";
17631     char physvols_1[] = "/dev/sda2";
17632     char *physvols[] = {
17633       physvols_0,
17634       physvols_1,
17635       NULL
17636     };
17637     int r;
17638     suppress_error = 0;
17639     r = guestfs_vgcreate (g, volgroup, physvols);
17640     if (r == -1)
17641       return -1;
17642   }
17643   {
17644     char volgroup[] = "VG2";
17645     char physvols_0[] = "/dev/sda3";
17646     char *physvols[] = {
17647       physvols_0,
17648       NULL
17649     };
17650     int r;
17651     suppress_error = 0;
17652     r = guestfs_vgcreate (g, volgroup, physvols);
17653     if (r == -1)
17654       return -1;
17655   }
17656   {
17657     char **r;
17658     int i;
17659     suppress_error = 0;
17660     r = guestfs_vgs (g);
17661     if (r == NULL)
17662       return -1;
17663     if (!r[0]) {
17664       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17665       print_strings (r);
17666       return -1;
17667     }
17668     {
17669       char expected[] = "VG1";
17670       if (strcmp (r[0], expected) != 0) {
17671         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17672         return -1;
17673       }
17674     }
17675     if (!r[1]) {
17676       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17677       print_strings (r);
17678       return -1;
17679     }
17680     {
17681       char expected[] = "VG2";
17682       if (strcmp (r[1], expected) != 0) {
17683         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17684         return -1;
17685       }
17686     }
17687     if (r[2] != NULL) {
17688       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17689       print_strings (r);
17690       return -1;
17691     }
17692     for (i = 0; r[i] != NULL; ++i)
17693       free (r[i]);
17694     free (r);
17695   }
17696   return 0;
17697 }
17698
17699 static int test_pvs_0_skip (void)
17700 {
17701   const char *str;
17702
17703   str = getenv ("TEST_ONLY");
17704   if (str)
17705     return strstr (str, "pvs") == NULL;
17706   str = getenv ("SKIP_TEST_PVS_0");
17707   if (str && strcmp (str, "1") == 0) return 1;
17708   str = getenv ("SKIP_TEST_PVS");
17709   if (str && strcmp (str, "1") == 0) return 1;
17710   return 0;
17711 }
17712
17713 static int test_pvs_0 (void)
17714 {
17715   if (test_pvs_0_skip ()) {
17716     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17717     return 0;
17718   }
17719
17720   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17721   {
17722     char device[] = "/dev/sda";
17723     int r;
17724     suppress_error = 0;
17725     r = guestfs_blockdev_setrw (g, device);
17726     if (r == -1)
17727       return -1;
17728   }
17729   {
17730     int r;
17731     suppress_error = 0;
17732     r = guestfs_umount_all (g);
17733     if (r == -1)
17734       return -1;
17735   }
17736   {
17737     int r;
17738     suppress_error = 0;
17739     r = guestfs_lvm_remove_all (g);
17740     if (r == -1)
17741       return -1;
17742   }
17743   {
17744     char device[] = "/dev/sda";
17745     char lines_0[] = ",";
17746     char *lines[] = {
17747       lines_0,
17748       NULL
17749     };
17750     int r;
17751     suppress_error = 0;
17752     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17753     if (r == -1)
17754       return -1;
17755   }
17756   {
17757     char device[] = "/dev/sda1";
17758     int r;
17759     suppress_error = 0;
17760     r = guestfs_pvcreate (g, device);
17761     if (r == -1)
17762       return -1;
17763   }
17764   {
17765     char volgroup[] = "VG";
17766     char physvols_0[] = "/dev/sda1";
17767     char *physvols[] = {
17768       physvols_0,
17769       NULL
17770     };
17771     int r;
17772     suppress_error = 0;
17773     r = guestfs_vgcreate (g, volgroup, physvols);
17774     if (r == -1)
17775       return -1;
17776   }
17777   {
17778     char logvol[] = "LV";
17779     char volgroup[] = "VG";
17780     int r;
17781     suppress_error = 0;
17782     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17783     if (r == -1)
17784       return -1;
17785   }
17786   {
17787     char fstype[] = "ext2";
17788     char device[] = "/dev/VG/LV";
17789     int r;
17790     suppress_error = 0;
17791     r = guestfs_mkfs (g, fstype, device);
17792     if (r == -1)
17793       return -1;
17794   }
17795   {
17796     char device[] = "/dev/VG/LV";
17797     char mountpoint[] = "/";
17798     int r;
17799     suppress_error = 0;
17800     r = guestfs_mount (g, device, mountpoint);
17801     if (r == -1)
17802       return -1;
17803   }
17804   /* TestOutputListOfDevices for pvs (0) */
17805   {
17806     char **r;
17807     int i;
17808     suppress_error = 0;
17809     r = guestfs_pvs (g);
17810     if (r == NULL)
17811       return -1;
17812     if (!r[0]) {
17813       fprintf (stderr, "test_pvs_0: short list returned from command\n");
17814       print_strings (r);
17815       return -1;
17816     }
17817     {
17818       char expected[] = "/dev/sda1";
17819       r[0][5] = 's';
17820       if (strcmp (r[0], expected) != 0) {
17821         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17822         return -1;
17823       }
17824     }
17825     if (r[1] != NULL) {
17826       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17827       print_strings (r);
17828       return -1;
17829     }
17830     for (i = 0; r[i] != NULL; ++i)
17831       free (r[i]);
17832     free (r);
17833   }
17834   return 0;
17835 }
17836
17837 static int test_pvs_1_skip (void)
17838 {
17839   const char *str;
17840
17841   str = getenv ("TEST_ONLY");
17842   if (str)
17843     return strstr (str, "pvs") == NULL;
17844   str = getenv ("SKIP_TEST_PVS_1");
17845   if (str && strcmp (str, "1") == 0) return 1;
17846   str = getenv ("SKIP_TEST_PVS");
17847   if (str && strcmp (str, "1") == 0) return 1;
17848   return 0;
17849 }
17850
17851 static int test_pvs_1 (void)
17852 {
17853   if (test_pvs_1_skip ()) {
17854     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17855     return 0;
17856   }
17857
17858   /* InitNone|InitEmpty for test_pvs_1 */
17859   {
17860     char device[] = "/dev/sda";
17861     int r;
17862     suppress_error = 0;
17863     r = guestfs_blockdev_setrw (g, device);
17864     if (r == -1)
17865       return -1;
17866   }
17867   {
17868     int r;
17869     suppress_error = 0;
17870     r = guestfs_umount_all (g);
17871     if (r == -1)
17872       return -1;
17873   }
17874   {
17875     int r;
17876     suppress_error = 0;
17877     r = guestfs_lvm_remove_all (g);
17878     if (r == -1)
17879       return -1;
17880   }
17881   /* TestOutputListOfDevices for pvs (1) */
17882   {
17883     char device[] = "/dev/sda";
17884     char lines_0[] = ",10";
17885     char lines_1[] = ",20";
17886     char lines_2[] = ",";
17887     char *lines[] = {
17888       lines_0,
17889       lines_1,
17890       lines_2,
17891       NULL
17892     };
17893     int r;
17894     suppress_error = 0;
17895     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17896     if (r == -1)
17897       return -1;
17898   }
17899   {
17900     char device[] = "/dev/sda1";
17901     int r;
17902     suppress_error = 0;
17903     r = guestfs_pvcreate (g, device);
17904     if (r == -1)
17905       return -1;
17906   }
17907   {
17908     char device[] = "/dev/sda2";
17909     int r;
17910     suppress_error = 0;
17911     r = guestfs_pvcreate (g, device);
17912     if (r == -1)
17913       return -1;
17914   }
17915   {
17916     char device[] = "/dev/sda3";
17917     int r;
17918     suppress_error = 0;
17919     r = guestfs_pvcreate (g, device);
17920     if (r == -1)
17921       return -1;
17922   }
17923   {
17924     char **r;
17925     int i;
17926     suppress_error = 0;
17927     r = guestfs_pvs (g);
17928     if (r == NULL)
17929       return -1;
17930     if (!r[0]) {
17931       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17932       print_strings (r);
17933       return -1;
17934     }
17935     {
17936       char expected[] = "/dev/sda1";
17937       r[0][5] = 's';
17938       if (strcmp (r[0], expected) != 0) {
17939         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17940         return -1;
17941       }
17942     }
17943     if (!r[1]) {
17944       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17945       print_strings (r);
17946       return -1;
17947     }
17948     {
17949       char expected[] = "/dev/sda2";
17950       r[1][5] = 's';
17951       if (strcmp (r[1], expected) != 0) {
17952         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17953         return -1;
17954       }
17955     }
17956     if (!r[2]) {
17957       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17958       print_strings (r);
17959       return -1;
17960     }
17961     {
17962       char expected[] = "/dev/sda3";
17963       r[2][5] = 's';
17964       if (strcmp (r[2], expected) != 0) {
17965         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17966         return -1;
17967       }
17968     }
17969     if (r[3] != NULL) {
17970       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17971       print_strings (r);
17972       return -1;
17973     }
17974     for (i = 0; r[i] != NULL; ++i)
17975       free (r[i]);
17976     free (r);
17977   }
17978   return 0;
17979 }
17980
17981 static int test_list_partitions_0_skip (void)
17982 {
17983   const char *str;
17984
17985   str = getenv ("TEST_ONLY");
17986   if (str)
17987     return strstr (str, "list_partitions") == NULL;
17988   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17989   if (str && strcmp (str, "1") == 0) return 1;
17990   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17991   if (str && strcmp (str, "1") == 0) return 1;
17992   return 0;
17993 }
17994
17995 static int test_list_partitions_0 (void)
17996 {
17997   if (test_list_partitions_0_skip ()) {
17998     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
17999     return 0;
18000   }
18001
18002   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
18003   {
18004     char device[] = "/dev/sda";
18005     int r;
18006     suppress_error = 0;
18007     r = guestfs_blockdev_setrw (g, device);
18008     if (r == -1)
18009       return -1;
18010   }
18011   {
18012     int r;
18013     suppress_error = 0;
18014     r = guestfs_umount_all (g);
18015     if (r == -1)
18016       return -1;
18017   }
18018   {
18019     int r;
18020     suppress_error = 0;
18021     r = guestfs_lvm_remove_all (g);
18022     if (r == -1)
18023       return -1;
18024   }
18025   {
18026     char device[] = "/dev/sda";
18027     char lines_0[] = ",";
18028     char *lines[] = {
18029       lines_0,
18030       NULL
18031     };
18032     int r;
18033     suppress_error = 0;
18034     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18035     if (r == -1)
18036       return -1;
18037   }
18038   {
18039     char fstype[] = "ext2";
18040     char device[] = "/dev/sda1";
18041     int r;
18042     suppress_error = 0;
18043     r = guestfs_mkfs (g, fstype, device);
18044     if (r == -1)
18045       return -1;
18046   }
18047   {
18048     char device[] = "/dev/sda1";
18049     char mountpoint[] = "/";
18050     int r;
18051     suppress_error = 0;
18052     r = guestfs_mount (g, device, mountpoint);
18053     if (r == -1)
18054       return -1;
18055   }
18056   /* TestOutputListOfDevices for list_partitions (0) */
18057   {
18058     char **r;
18059     int i;
18060     suppress_error = 0;
18061     r = guestfs_list_partitions (g);
18062     if (r == NULL)
18063       return -1;
18064     if (!r[0]) {
18065       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
18066       print_strings (r);
18067       return -1;
18068     }
18069     {
18070       char expected[] = "/dev/sda1";
18071       r[0][5] = 's';
18072       if (strcmp (r[0], expected) != 0) {
18073         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18074         return -1;
18075       }
18076     }
18077     if (r[1] != NULL) {
18078       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
18079       print_strings (r);
18080       return -1;
18081     }
18082     for (i = 0; r[i] != NULL; ++i)
18083       free (r[i]);
18084     free (r);
18085   }
18086   return 0;
18087 }
18088
18089 static int test_list_partitions_1_skip (void)
18090 {
18091   const char *str;
18092
18093   str = getenv ("TEST_ONLY");
18094   if (str)
18095     return strstr (str, "list_partitions") == NULL;
18096   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
18097   if (str && strcmp (str, "1") == 0) return 1;
18098   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18099   if (str && strcmp (str, "1") == 0) return 1;
18100   return 0;
18101 }
18102
18103 static int test_list_partitions_1 (void)
18104 {
18105   if (test_list_partitions_1_skip ()) {
18106     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
18107     return 0;
18108   }
18109
18110   /* InitNone|InitEmpty for test_list_partitions_1 */
18111   {
18112     char device[] = "/dev/sda";
18113     int r;
18114     suppress_error = 0;
18115     r = guestfs_blockdev_setrw (g, device);
18116     if (r == -1)
18117       return -1;
18118   }
18119   {
18120     int r;
18121     suppress_error = 0;
18122     r = guestfs_umount_all (g);
18123     if (r == -1)
18124       return -1;
18125   }
18126   {
18127     int r;
18128     suppress_error = 0;
18129     r = guestfs_lvm_remove_all (g);
18130     if (r == -1)
18131       return -1;
18132   }
18133   /* TestOutputListOfDevices for list_partitions (1) */
18134   {
18135     char device[] = "/dev/sda";
18136     char lines_0[] = ",10";
18137     char lines_1[] = ",20";
18138     char lines_2[] = ",";
18139     char *lines[] = {
18140       lines_0,
18141       lines_1,
18142       lines_2,
18143       NULL
18144     };
18145     int r;
18146     suppress_error = 0;
18147     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18148     if (r == -1)
18149       return -1;
18150   }
18151   {
18152     char **r;
18153     int i;
18154     suppress_error = 0;
18155     r = guestfs_list_partitions (g);
18156     if (r == NULL)
18157       return -1;
18158     if (!r[0]) {
18159       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18160       print_strings (r);
18161       return -1;
18162     }
18163     {
18164       char expected[] = "/dev/sda1";
18165       r[0][5] = 's';
18166       if (strcmp (r[0], expected) != 0) {
18167         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18168         return -1;
18169       }
18170     }
18171     if (!r[1]) {
18172       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18173       print_strings (r);
18174       return -1;
18175     }
18176     {
18177       char expected[] = "/dev/sda2";
18178       r[1][5] = 's';
18179       if (strcmp (r[1], expected) != 0) {
18180         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18181         return -1;
18182       }
18183     }
18184     if (!r[2]) {
18185       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18186       print_strings (r);
18187       return -1;
18188     }
18189     {
18190       char expected[] = "/dev/sda3";
18191       r[2][5] = 's';
18192       if (strcmp (r[2], expected) != 0) {
18193         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18194         return -1;
18195       }
18196     }
18197     if (r[3] != NULL) {
18198       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
18199       print_strings (r);
18200       return -1;
18201     }
18202     for (i = 0; r[i] != NULL; ++i)
18203       free (r[i]);
18204     free (r);
18205   }
18206   return 0;
18207 }
18208
18209 static int test_list_devices_0_skip (void)
18210 {
18211   const char *str;
18212
18213   str = getenv ("TEST_ONLY");
18214   if (str)
18215     return strstr (str, "list_devices") == NULL;
18216   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18217   if (str && strcmp (str, "1") == 0) return 1;
18218   str = getenv ("SKIP_TEST_LIST_DEVICES");
18219   if (str && strcmp (str, "1") == 0) return 1;
18220   return 0;
18221 }
18222
18223 static int test_list_devices_0 (void)
18224 {
18225   if (test_list_devices_0_skip ()) {
18226     printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
18227     return 0;
18228   }
18229
18230   /* InitNone|InitEmpty for test_list_devices_0 */
18231   {
18232     char device[] = "/dev/sda";
18233     int r;
18234     suppress_error = 0;
18235     r = guestfs_blockdev_setrw (g, device);
18236     if (r == -1)
18237       return -1;
18238   }
18239   {
18240     int r;
18241     suppress_error = 0;
18242     r = guestfs_umount_all (g);
18243     if (r == -1)
18244       return -1;
18245   }
18246   {
18247     int r;
18248     suppress_error = 0;
18249     r = guestfs_lvm_remove_all (g);
18250     if (r == -1)
18251       return -1;
18252   }
18253   /* TestOutputListOfDevices for list_devices (0) */
18254   {
18255     char **r;
18256     int i;
18257     suppress_error = 0;
18258     r = guestfs_list_devices (g);
18259     if (r == NULL)
18260       return -1;
18261     if (!r[0]) {
18262       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18263       print_strings (r);
18264       return -1;
18265     }
18266     {
18267       char expected[] = "/dev/sda";
18268       r[0][5] = 's';
18269       if (strcmp (r[0], expected) != 0) {
18270         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18271         return -1;
18272       }
18273     }
18274     if (!r[1]) {
18275       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18276       print_strings (r);
18277       return -1;
18278     }
18279     {
18280       char expected[] = "/dev/sdb";
18281       r[1][5] = 's';
18282       if (strcmp (r[1], expected) != 0) {
18283         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18284         return -1;
18285       }
18286     }
18287     if (!r[2]) {
18288       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18289       print_strings (r);
18290       return -1;
18291     }
18292     {
18293       char expected[] = "/dev/sdc";
18294       r[2][5] = 's';
18295       if (strcmp (r[2], expected) != 0) {
18296         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18297         return -1;
18298       }
18299     }
18300     if (!r[3]) {
18301       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18302       print_strings (r);
18303       return -1;
18304     }
18305     {
18306       char expected[] = "/dev/sdd";
18307       r[3][5] = 's';
18308       if (strcmp (r[3], expected) != 0) {
18309         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18310         return -1;
18311       }
18312     }
18313     if (r[4] != NULL) {
18314       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18315       print_strings (r);
18316       return -1;
18317     }
18318     for (i = 0; r[i] != NULL; ++i)
18319       free (r[i]);
18320     free (r);
18321   }
18322   return 0;
18323 }
18324
18325 static int test_ls_0_skip (void)
18326 {
18327   const char *str;
18328
18329   str = getenv ("TEST_ONLY");
18330   if (str)
18331     return strstr (str, "ls") == NULL;
18332   str = getenv ("SKIP_TEST_LS_0");
18333   if (str && strcmp (str, "1") == 0) return 1;
18334   str = getenv ("SKIP_TEST_LS");
18335   if (str && strcmp (str, "1") == 0) return 1;
18336   return 0;
18337 }
18338
18339 static int test_ls_0 (void)
18340 {
18341   if (test_ls_0_skip ()) {
18342     printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
18343     return 0;
18344   }
18345
18346   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18347   {
18348     char device[] = "/dev/sda";
18349     int r;
18350     suppress_error = 0;
18351     r = guestfs_blockdev_setrw (g, device);
18352     if (r == -1)
18353       return -1;
18354   }
18355   {
18356     int r;
18357     suppress_error = 0;
18358     r = guestfs_umount_all (g);
18359     if (r == -1)
18360       return -1;
18361   }
18362   {
18363     int r;
18364     suppress_error = 0;
18365     r = guestfs_lvm_remove_all (g);
18366     if (r == -1)
18367       return -1;
18368   }
18369   {
18370     char device[] = "/dev/sda";
18371     char lines_0[] = ",";
18372     char *lines[] = {
18373       lines_0,
18374       NULL
18375     };
18376     int r;
18377     suppress_error = 0;
18378     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18379     if (r == -1)
18380       return -1;
18381   }
18382   {
18383     char fstype[] = "ext2";
18384     char device[] = "/dev/sda1";
18385     int r;
18386     suppress_error = 0;
18387     r = guestfs_mkfs (g, fstype, device);
18388     if (r == -1)
18389       return -1;
18390   }
18391   {
18392     char device[] = "/dev/sda1";
18393     char mountpoint[] = "/";
18394     int r;
18395     suppress_error = 0;
18396     r = guestfs_mount (g, device, mountpoint);
18397     if (r == -1)
18398       return -1;
18399   }
18400   /* TestOutputList for ls (0) */
18401   {
18402     char path[] = "/new";
18403     int r;
18404     suppress_error = 0;
18405     r = guestfs_touch (g, path);
18406     if (r == -1)
18407       return -1;
18408   }
18409   {
18410     char path[] = "/newer";
18411     int r;
18412     suppress_error = 0;
18413     r = guestfs_touch (g, path);
18414     if (r == -1)
18415       return -1;
18416   }
18417   {
18418     char path[] = "/newest";
18419     int r;
18420     suppress_error = 0;
18421     r = guestfs_touch (g, path);
18422     if (r == -1)
18423       return -1;
18424   }
18425   {
18426     char directory[] = "/";
18427     char **r;
18428     int i;
18429     suppress_error = 0;
18430     r = guestfs_ls (g, directory);
18431     if (r == NULL)
18432       return -1;
18433     if (!r[0]) {
18434       fprintf (stderr, "test_ls_0: short list returned from command\n");
18435       print_strings (r);
18436       return -1;
18437     }
18438     {
18439       char expected[] = "lost+found";
18440       if (strcmp (r[0], expected) != 0) {
18441         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18442         return -1;
18443       }
18444     }
18445     if (!r[1]) {
18446       fprintf (stderr, "test_ls_0: short list returned from command\n");
18447       print_strings (r);
18448       return -1;
18449     }
18450     {
18451       char expected[] = "new";
18452       if (strcmp (r[1], expected) != 0) {
18453         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18454         return -1;
18455       }
18456     }
18457     if (!r[2]) {
18458       fprintf (stderr, "test_ls_0: short list returned from command\n");
18459       print_strings (r);
18460       return -1;
18461     }
18462     {
18463       char expected[] = "newer";
18464       if (strcmp (r[2], expected) != 0) {
18465         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18466         return -1;
18467       }
18468     }
18469     if (!r[3]) {
18470       fprintf (stderr, "test_ls_0: short list returned from command\n");
18471       print_strings (r);
18472       return -1;
18473     }
18474     {
18475       char expected[] = "newest";
18476       if (strcmp (r[3], expected) != 0) {
18477         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18478         return -1;
18479       }
18480     }
18481     if (r[4] != NULL) {
18482       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18483       print_strings (r);
18484       return -1;
18485     }
18486     for (i = 0; r[i] != NULL; ++i)
18487       free (r[i]);
18488     free (r);
18489   }
18490   return 0;
18491 }
18492
18493 static int test_cat_0_skip (void)
18494 {
18495   const char *str;
18496
18497   str = getenv ("TEST_ONLY");
18498   if (str)
18499     return strstr (str, "cat") == NULL;
18500   str = getenv ("SKIP_TEST_CAT_0");
18501   if (str && strcmp (str, "1") == 0) return 1;
18502   str = getenv ("SKIP_TEST_CAT");
18503   if (str && strcmp (str, "1") == 0) return 1;
18504   return 0;
18505 }
18506
18507 static int test_cat_0 (void)
18508 {
18509   if (test_cat_0_skip ()) {
18510     printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18511     return 0;
18512   }
18513
18514   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18515   {
18516     char device[] = "/dev/sda";
18517     int r;
18518     suppress_error = 0;
18519     r = guestfs_blockdev_setrw (g, device);
18520     if (r == -1)
18521       return -1;
18522   }
18523   {
18524     int r;
18525     suppress_error = 0;
18526     r = guestfs_umount_all (g);
18527     if (r == -1)
18528       return -1;
18529   }
18530   {
18531     int r;
18532     suppress_error = 0;
18533     r = guestfs_lvm_remove_all (g);
18534     if (r == -1)
18535       return -1;
18536   }
18537   {
18538     char device[] = "/dev/sda";
18539     char lines_0[] = ",";
18540     char *lines[] = {
18541       lines_0,
18542       NULL
18543     };
18544     int r;
18545     suppress_error = 0;
18546     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18547     if (r == -1)
18548       return -1;
18549   }
18550   {
18551     char fstype[] = "ext2";
18552     char device[] = "/dev/sda1";
18553     int r;
18554     suppress_error = 0;
18555     r = guestfs_mkfs (g, fstype, device);
18556     if (r == -1)
18557       return -1;
18558   }
18559   {
18560     char device[] = "/dev/sda1";
18561     char mountpoint[] = "/";
18562     int r;
18563     suppress_error = 0;
18564     r = guestfs_mount (g, device, mountpoint);
18565     if (r == -1)
18566       return -1;
18567   }
18568   /* TestOutput for cat (0) */
18569   char expected[] = "new file contents";
18570   {
18571     char path[] = "/new";
18572     char content[] = "new file contents";
18573     int r;
18574     suppress_error = 0;
18575     r = guestfs_write_file (g, path, content, 0);
18576     if (r == -1)
18577       return -1;
18578   }
18579   {
18580     char path[] = "/new";
18581     char *r;
18582     suppress_error = 0;
18583     r = guestfs_cat (g, path);
18584     if (r == NULL)
18585       return -1;
18586     if (strcmp (r, expected) != 0) {
18587       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18588       return -1;
18589     }
18590     free (r);
18591   }
18592   return 0;
18593 }
18594
18595 static int test_touch_0_skip (void)
18596 {
18597   const char *str;
18598
18599   str = getenv ("TEST_ONLY");
18600   if (str)
18601     return strstr (str, "touch") == NULL;
18602   str = getenv ("SKIP_TEST_TOUCH_0");
18603   if (str && strcmp (str, "1") == 0) return 1;
18604   str = getenv ("SKIP_TEST_TOUCH");
18605   if (str && strcmp (str, "1") == 0) return 1;
18606   return 0;
18607 }
18608
18609 static int test_touch_0 (void)
18610 {
18611   if (test_touch_0_skip ()) {
18612     printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18613     return 0;
18614   }
18615
18616   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18617   {
18618     char device[] = "/dev/sda";
18619     int r;
18620     suppress_error = 0;
18621     r = guestfs_blockdev_setrw (g, device);
18622     if (r == -1)
18623       return -1;
18624   }
18625   {
18626     int r;
18627     suppress_error = 0;
18628     r = guestfs_umount_all (g);
18629     if (r == -1)
18630       return -1;
18631   }
18632   {
18633     int r;
18634     suppress_error = 0;
18635     r = guestfs_lvm_remove_all (g);
18636     if (r == -1)
18637       return -1;
18638   }
18639   {
18640     char device[] = "/dev/sda";
18641     char lines_0[] = ",";
18642     char *lines[] = {
18643       lines_0,
18644       NULL
18645     };
18646     int r;
18647     suppress_error = 0;
18648     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18649     if (r == -1)
18650       return -1;
18651   }
18652   {
18653     char fstype[] = "ext2";
18654     char device[] = "/dev/sda1";
18655     int r;
18656     suppress_error = 0;
18657     r = guestfs_mkfs (g, fstype, device);
18658     if (r == -1)
18659       return -1;
18660   }
18661   {
18662     char device[] = "/dev/sda1";
18663     char mountpoint[] = "/";
18664     int r;
18665     suppress_error = 0;
18666     r = guestfs_mount (g, device, mountpoint);
18667     if (r == -1)
18668       return -1;
18669   }
18670   /* TestOutputTrue for touch (0) */
18671   {
18672     char path[] = "/new";
18673     int r;
18674     suppress_error = 0;
18675     r = guestfs_touch (g, path);
18676     if (r == -1)
18677       return -1;
18678   }
18679   {
18680     char path[] = "/new";
18681     int r;
18682     suppress_error = 0;
18683     r = guestfs_exists (g, path);
18684     if (r == -1)
18685       return -1;
18686     if (!r) {
18687       fprintf (stderr, "test_touch_0: expected true, got false\n");
18688       return -1;
18689     }
18690   }
18691   return 0;
18692 }
18693
18694 static int test_sync_0_skip (void)
18695 {
18696   const char *str;
18697
18698   str = getenv ("TEST_ONLY");
18699   if (str)
18700     return strstr (str, "sync") == NULL;
18701   str = getenv ("SKIP_TEST_SYNC_0");
18702   if (str && strcmp (str, "1") == 0) return 1;
18703   str = getenv ("SKIP_TEST_SYNC");
18704   if (str && strcmp (str, "1") == 0) return 1;
18705   return 0;
18706 }
18707
18708 static int test_sync_0 (void)
18709 {
18710   if (test_sync_0_skip ()) {
18711     printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18712     return 0;
18713   }
18714
18715   /* InitNone|InitEmpty for test_sync_0 */
18716   {
18717     char device[] = "/dev/sda";
18718     int r;
18719     suppress_error = 0;
18720     r = guestfs_blockdev_setrw (g, device);
18721     if (r == -1)
18722       return -1;
18723   }
18724   {
18725     int r;
18726     suppress_error = 0;
18727     r = guestfs_umount_all (g);
18728     if (r == -1)
18729       return -1;
18730   }
18731   {
18732     int r;
18733     suppress_error = 0;
18734     r = guestfs_lvm_remove_all (g);
18735     if (r == -1)
18736       return -1;
18737   }
18738   /* TestRun for sync (0) */
18739   {
18740     int r;
18741     suppress_error = 0;
18742     r = guestfs_sync (g);
18743     if (r == -1)
18744       return -1;
18745   }
18746   return 0;
18747 }
18748
18749 static int test_mount_0_skip (void)
18750 {
18751   const char *str;
18752
18753   str = getenv ("TEST_ONLY");
18754   if (str)
18755     return strstr (str, "mount") == NULL;
18756   str = getenv ("SKIP_TEST_MOUNT_0");
18757   if (str && strcmp (str, "1") == 0) return 1;
18758   str = getenv ("SKIP_TEST_MOUNT");
18759   if (str && strcmp (str, "1") == 0) return 1;
18760   return 0;
18761 }
18762
18763 static int test_mount_0 (void)
18764 {
18765   if (test_mount_0_skip ()) {
18766     printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18767     return 0;
18768   }
18769
18770   /* InitNone|InitEmpty for test_mount_0 */
18771   {
18772     char device[] = "/dev/sda";
18773     int r;
18774     suppress_error = 0;
18775     r = guestfs_blockdev_setrw (g, device);
18776     if (r == -1)
18777       return -1;
18778   }
18779   {
18780     int r;
18781     suppress_error = 0;
18782     r = guestfs_umount_all (g);
18783     if (r == -1)
18784       return -1;
18785   }
18786   {
18787     int r;
18788     suppress_error = 0;
18789     r = guestfs_lvm_remove_all (g);
18790     if (r == -1)
18791       return -1;
18792   }
18793   /* TestOutput for mount (0) */
18794   char expected[] = "new file contents";
18795   {
18796     char device[] = "/dev/sda";
18797     char lines_0[] = ",";
18798     char *lines[] = {
18799       lines_0,
18800       NULL
18801     };
18802     int r;
18803     suppress_error = 0;
18804     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18805     if (r == -1)
18806       return -1;
18807   }
18808   {
18809     char fstype[] = "ext2";
18810     char device[] = "/dev/sda1";
18811     int r;
18812     suppress_error = 0;
18813     r = guestfs_mkfs (g, fstype, device);
18814     if (r == -1)
18815       return -1;
18816   }
18817   {
18818     char device[] = "/dev/sda1";
18819     char mountpoint[] = "/";
18820     int r;
18821     suppress_error = 0;
18822     r = guestfs_mount (g, device, mountpoint);
18823     if (r == -1)
18824       return -1;
18825   }
18826   {
18827     char path[] = "/new";
18828     char content[] = "new file contents";
18829     int r;
18830     suppress_error = 0;
18831     r = guestfs_write_file (g, path, content, 0);
18832     if (r == -1)
18833       return -1;
18834   }
18835   {
18836     char path[] = "/new";
18837     char *r;
18838     suppress_error = 0;
18839     r = guestfs_cat (g, path);
18840     if (r == NULL)
18841       return -1;
18842     if (strcmp (r, expected) != 0) {
18843       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18844       return -1;
18845     }
18846     free (r);
18847   }
18848   return 0;
18849 }
18850
18851 int main (int argc, char *argv[])
18852 {
18853   char c = 0;
18854   int failed = 0;
18855   const char *filename;
18856   int fd;
18857   int nr_tests, test_num = 0;
18858
18859   no_test_warnings ();
18860
18861   g = guestfs_create ();
18862   if (g == NULL) {
18863     printf ("guestfs_create FAILED\n");
18864     exit (1);
18865   }
18866
18867   guestfs_set_error_handler (g, print_error, NULL);
18868
18869   guestfs_set_path (g, "../appliance");
18870
18871   filename = "test1.img";
18872   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18873   if (fd == -1) {
18874     perror (filename);
18875     exit (1);
18876   }
18877   if (lseek (fd, 524288000, SEEK_SET) == -1) {
18878     perror ("lseek");
18879     close (fd);
18880     unlink (filename);
18881     exit (1);
18882   }
18883   if (write (fd, &c, 1) == -1) {
18884     perror ("write");
18885     close (fd);
18886     unlink (filename);
18887     exit (1);
18888   }
18889   if (close (fd) == -1) {
18890     perror (filename);
18891     unlink (filename);
18892     exit (1);
18893   }
18894   if (guestfs_add_drive (g, filename) == -1) {
18895     printf ("guestfs_add_drive %s FAILED\n", filename);
18896     exit (1);
18897   }
18898
18899   filename = "test2.img";
18900   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18901   if (fd == -1) {
18902     perror (filename);
18903     exit (1);
18904   }
18905   if (lseek (fd, 52428800, SEEK_SET) == -1) {
18906     perror ("lseek");
18907     close (fd);
18908     unlink (filename);
18909     exit (1);
18910   }
18911   if (write (fd, &c, 1) == -1) {
18912     perror ("write");
18913     close (fd);
18914     unlink (filename);
18915     exit (1);
18916   }
18917   if (close (fd) == -1) {
18918     perror (filename);
18919     unlink (filename);
18920     exit (1);
18921   }
18922   if (guestfs_add_drive (g, filename) == -1) {
18923     printf ("guestfs_add_drive %s FAILED\n", filename);
18924     exit (1);
18925   }
18926
18927   filename = "test3.img";
18928   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18929   if (fd == -1) {
18930     perror (filename);
18931     exit (1);
18932   }
18933   if (lseek (fd, 10485760, SEEK_SET) == -1) {
18934     perror ("lseek");
18935     close (fd);
18936     unlink (filename);
18937     exit (1);
18938   }
18939   if (write (fd, &c, 1) == -1) {
18940     perror ("write");
18941     close (fd);
18942     unlink (filename);
18943     exit (1);
18944   }
18945   if (close (fd) == -1) {
18946     perror (filename);
18947     unlink (filename);
18948     exit (1);
18949   }
18950   if (guestfs_add_drive (g, filename) == -1) {
18951     printf ("guestfs_add_drive %s FAILED\n", filename);
18952     exit (1);
18953   }
18954
18955   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18956     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18957     exit (1);
18958   }
18959
18960   if (guestfs_launch (g) == -1) {
18961     printf ("guestfs_launch FAILED\n");
18962     exit (1);
18963   }
18964
18965   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18966   alarm (600);
18967
18968   if (guestfs_wait_ready (g) == -1) {
18969     printf ("guestfs_wait_ready FAILED\n");
18970     exit (1);
18971   }
18972
18973   /* Cancel previous alarm. */
18974   alarm (0);
18975
18976   nr_tests = 169;
18977
18978   test_num++;
18979   printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests);
18980   if (test_mkswap_U_0 () == -1) {
18981     printf ("test_mkswap_U_0 FAILED\n");
18982     failed++;
18983   }
18984   test_num++;
18985   printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests);
18986   if (test_mkswap_L_0 () == -1) {
18987     printf ("test_mkswap_L_0 FAILED\n");
18988     failed++;
18989   }
18990   test_num++;
18991   printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests);
18992   if (test_mkswap_0 () == -1) {
18993     printf ("test_mkswap_0 FAILED\n");
18994     failed++;
18995   }
18996   test_num++;
18997   printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
18998   if (test_initrd_list_0 () == -1) {
18999     printf ("test_initrd_list_0 FAILED\n");
19000     failed++;
19001   }
19002   test_num++;
19003   printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
19004   if (test_du_0 () == -1) {
19005     printf ("test_du_0 FAILED\n");
19006     failed++;
19007   }
19008   test_num++;
19009   printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
19010   if (test_tail_n_0 () == -1) {
19011     printf ("test_tail_n_0 FAILED\n");
19012     failed++;
19013   }
19014   test_num++;
19015   printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
19016   if (test_tail_n_1 () == -1) {
19017     printf ("test_tail_n_1 FAILED\n");
19018     failed++;
19019   }
19020   test_num++;
19021   printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
19022   if (test_tail_n_2 () == -1) {
19023     printf ("test_tail_n_2 FAILED\n");
19024     failed++;
19025   }
19026   test_num++;
19027   printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
19028   if (test_tail_0 () == -1) {
19029     printf ("test_tail_0 FAILED\n");
19030     failed++;
19031   }
19032   test_num++;
19033   printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
19034   if (test_head_n_0 () == -1) {
19035     printf ("test_head_n_0 FAILED\n");
19036     failed++;
19037   }
19038   test_num++;
19039   printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
19040   if (test_head_n_1 () == -1) {
19041     printf ("test_head_n_1 FAILED\n");
19042     failed++;
19043   }
19044   test_num++;
19045   printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
19046   if (test_head_n_2 () == -1) {
19047     printf ("test_head_n_2 FAILED\n");
19048     failed++;
19049   }
19050   test_num++;
19051   printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
19052   if (test_head_0 () == -1) {
19053     printf ("test_head_0 FAILED\n");
19054     failed++;
19055   }
19056   test_num++;
19057   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
19058   if (test_wc_c_0 () == -1) {
19059     printf ("test_wc_c_0 FAILED\n");
19060     failed++;
19061   }
19062   test_num++;
19063   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
19064   if (test_wc_w_0 () == -1) {
19065     printf ("test_wc_w_0 FAILED\n");
19066     failed++;
19067   }
19068   test_num++;
19069   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
19070   if (test_wc_l_0 () == -1) {
19071     printf ("test_wc_l_0 FAILED\n");
19072     failed++;
19073   }
19074   test_num++;
19075   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
19076   if (test_mkdtemp_0 () == -1) {
19077     printf ("test_mkdtemp_0 FAILED\n");
19078     failed++;
19079   }
19080   test_num++;
19081   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
19082   if (test_scrub_file_0 () == -1) {
19083     printf ("test_scrub_file_0 FAILED\n");
19084     failed++;
19085   }
19086   test_num++;
19087   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
19088   if (test_scrub_device_0 () == -1) {
19089     printf ("test_scrub_device_0 FAILED\n");
19090     failed++;
19091   }
19092   test_num++;
19093   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
19094   if (test_glob_expand_0 () == -1) {
19095     printf ("test_glob_expand_0 FAILED\n");
19096     failed++;
19097   }
19098   test_num++;
19099   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
19100   if (test_glob_expand_1 () == -1) {
19101     printf ("test_glob_expand_1 FAILED\n");
19102     failed++;
19103   }
19104   test_num++;
19105   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
19106   if (test_glob_expand_2 () == -1) {
19107     printf ("test_glob_expand_2 FAILED\n");
19108     failed++;
19109   }
19110   test_num++;
19111   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
19112   if (test_ntfs_3g_probe_0 () == -1) {
19113     printf ("test_ntfs_3g_probe_0 FAILED\n");
19114     failed++;
19115   }
19116   test_num++;
19117   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
19118   if (test_ntfs_3g_probe_1 () == -1) {
19119     printf ("test_ntfs_3g_probe_1 FAILED\n");
19120     failed++;
19121   }
19122   test_num++;
19123   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
19124   if (test_sleep_0 () == -1) {
19125     printf ("test_sleep_0 FAILED\n");
19126     failed++;
19127   }
19128   test_num++;
19129   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
19130   if (test_find_0 () == -1) {
19131     printf ("test_find_0 FAILED\n");
19132     failed++;
19133   }
19134   test_num++;
19135   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
19136   if (test_find_1 () == -1) {
19137     printf ("test_find_1 FAILED\n");
19138     failed++;
19139   }
19140   test_num++;
19141   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
19142   if (test_find_2 () == -1) {
19143     printf ("test_find_2 FAILED\n");
19144     failed++;
19145   }
19146   test_num++;
19147   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
19148   if (test_lvresize_0 () == -1) {
19149     printf ("test_lvresize_0 FAILED\n");
19150     failed++;
19151   }
19152   test_num++;
19153   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
19154   if (test_zerofree_0 () == -1) {
19155     printf ("test_zerofree_0 FAILED\n");
19156     failed++;
19157   }
19158   test_num++;
19159   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
19160   if (test_hexdump_0 () == -1) {
19161     printf ("test_hexdump_0 FAILED\n");
19162     failed++;
19163   }
19164   test_num++;
19165   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
19166   if (test_hexdump_1 () == -1) {
19167     printf ("test_hexdump_1 FAILED\n");
19168     failed++;
19169   }
19170   test_num++;
19171   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
19172   if (test_strings_e_0 () == -1) {
19173     printf ("test_strings_e_0 FAILED\n");
19174     failed++;
19175   }
19176   test_num++;
19177   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
19178   if (test_strings_e_1 () == -1) {
19179     printf ("test_strings_e_1 FAILED\n");
19180     failed++;
19181   }
19182   test_num++;
19183   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
19184   if (test_strings_0 () == -1) {
19185     printf ("test_strings_0 FAILED\n");
19186     failed++;
19187   }
19188   test_num++;
19189   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
19190   if (test_strings_1 () == -1) {
19191     printf ("test_strings_1 FAILED\n");
19192     failed++;
19193   }
19194   test_num++;
19195   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
19196   if (test_equal_0 () == -1) {
19197     printf ("test_equal_0 FAILED\n");
19198     failed++;
19199   }
19200   test_num++;
19201   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
19202   if (test_equal_1 () == -1) {
19203     printf ("test_equal_1 FAILED\n");
19204     failed++;
19205   }
19206   test_num++;
19207   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
19208   if (test_equal_2 () == -1) {
19209     printf ("test_equal_2 FAILED\n");
19210     failed++;
19211   }
19212   test_num++;
19213   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
19214   if (test_ping_daemon_0 () == -1) {
19215     printf ("test_ping_daemon_0 FAILED\n");
19216     failed++;
19217   }
19218   test_num++;
19219   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
19220   if (test_dmesg_0 () == -1) {
19221     printf ("test_dmesg_0 FAILED\n");
19222     failed++;
19223   }
19224   test_num++;
19225   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
19226   if (test_drop_caches_0 () == -1) {
19227     printf ("test_drop_caches_0 FAILED\n");
19228     failed++;
19229   }
19230   test_num++;
19231   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19232   if (test_mv_0 () == -1) {
19233     printf ("test_mv_0 FAILED\n");
19234     failed++;
19235   }
19236   test_num++;
19237   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19238   if (test_mv_1 () == -1) {
19239     printf ("test_mv_1 FAILED\n");
19240     failed++;
19241   }
19242   test_num++;
19243   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19244   if (test_cp_a_0 () == -1) {
19245     printf ("test_cp_a_0 FAILED\n");
19246     failed++;
19247   }
19248   test_num++;
19249   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19250   if (test_cp_0 () == -1) {
19251     printf ("test_cp_0 FAILED\n");
19252     failed++;
19253   }
19254   test_num++;
19255   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19256   if (test_cp_1 () == -1) {
19257     printf ("test_cp_1 FAILED\n");
19258     failed++;
19259   }
19260   test_num++;
19261   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19262   if (test_cp_2 () == -1) {
19263     printf ("test_cp_2 FAILED\n");
19264     failed++;
19265   }
19266   test_num++;
19267   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19268   if (test_grub_install_0 () == -1) {
19269     printf ("test_grub_install_0 FAILED\n");
19270     failed++;
19271   }
19272   test_num++;
19273   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19274   if (test_zero_0 () == -1) {
19275     printf ("test_zero_0 FAILED\n");
19276     failed++;
19277   }
19278   test_num++;
19279   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19280   if (test_fsck_0 () == -1) {
19281     printf ("test_fsck_0 FAILED\n");
19282     failed++;
19283   }
19284   test_num++;
19285   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19286   if (test_fsck_1 () == -1) {
19287     printf ("test_fsck_1 FAILED\n");
19288     failed++;
19289   }
19290   test_num++;
19291   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19292   if (test_set_e2uuid_0 () == -1) {
19293     printf ("test_set_e2uuid_0 FAILED\n");
19294     failed++;
19295   }
19296   test_num++;
19297   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19298   if (test_set_e2uuid_1 () == -1) {
19299     printf ("test_set_e2uuid_1 FAILED\n");
19300     failed++;
19301   }
19302   test_num++;
19303   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19304   if (test_set_e2uuid_2 () == -1) {
19305     printf ("test_set_e2uuid_2 FAILED\n");
19306     failed++;
19307   }
19308   test_num++;
19309   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19310   if (test_set_e2uuid_3 () == -1) {
19311     printf ("test_set_e2uuid_3 FAILED\n");
19312     failed++;
19313   }
19314   test_num++;
19315   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19316   if (test_set_e2label_0 () == -1) {
19317     printf ("test_set_e2label_0 FAILED\n");
19318     failed++;
19319   }
19320   test_num++;
19321   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19322   if (test_pvremove_0 () == -1) {
19323     printf ("test_pvremove_0 FAILED\n");
19324     failed++;
19325   }
19326   test_num++;
19327   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19328   if (test_pvremove_1 () == -1) {
19329     printf ("test_pvremove_1 FAILED\n");
19330     failed++;
19331   }
19332   test_num++;
19333   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19334   if (test_pvremove_2 () == -1) {
19335     printf ("test_pvremove_2 FAILED\n");
19336     failed++;
19337   }
19338   test_num++;
19339   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19340   if (test_vgremove_0 () == -1) {
19341     printf ("test_vgremove_0 FAILED\n");
19342     failed++;
19343   }
19344   test_num++;
19345   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19346   if (test_vgremove_1 () == -1) {
19347     printf ("test_vgremove_1 FAILED\n");
19348     failed++;
19349   }
19350   test_num++;
19351   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19352   if (test_lvremove_0 () == -1) {
19353     printf ("test_lvremove_0 FAILED\n");
19354     failed++;
19355   }
19356   test_num++;
19357   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19358   if (test_lvremove_1 () == -1) {
19359     printf ("test_lvremove_1 FAILED\n");
19360     failed++;
19361   }
19362   test_num++;
19363   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19364   if (test_lvremove_2 () == -1) {
19365     printf ("test_lvremove_2 FAILED\n");
19366     failed++;
19367   }
19368   test_num++;
19369   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19370   if (test_mount_ro_0 () == -1) {
19371     printf ("test_mount_ro_0 FAILED\n");
19372     failed++;
19373   }
19374   test_num++;
19375   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19376   if (test_mount_ro_1 () == -1) {
19377     printf ("test_mount_ro_1 FAILED\n");
19378     failed++;
19379   }
19380   test_num++;
19381   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19382   if (test_tgz_in_0 () == -1) {
19383     printf ("test_tgz_in_0 FAILED\n");
19384     failed++;
19385   }
19386   test_num++;
19387   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19388   if (test_tar_in_0 () == -1) {
19389     printf ("test_tar_in_0 FAILED\n");
19390     failed++;
19391   }
19392   test_num++;
19393   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19394   if (test_checksum_0 () == -1) {
19395     printf ("test_checksum_0 FAILED\n");
19396     failed++;
19397   }
19398   test_num++;
19399   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19400   if (test_checksum_1 () == -1) {
19401     printf ("test_checksum_1 FAILED\n");
19402     failed++;
19403   }
19404   test_num++;
19405   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19406   if (test_checksum_2 () == -1) {
19407     printf ("test_checksum_2 FAILED\n");
19408     failed++;
19409   }
19410   test_num++;
19411   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19412   if (test_checksum_3 () == -1) {
19413     printf ("test_checksum_3 FAILED\n");
19414     failed++;
19415   }
19416   test_num++;
19417   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19418   if (test_checksum_4 () == -1) {
19419     printf ("test_checksum_4 FAILED\n");
19420     failed++;
19421   }
19422   test_num++;
19423   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19424   if (test_checksum_5 () == -1) {
19425     printf ("test_checksum_5 FAILED\n");
19426     failed++;
19427   }
19428   test_num++;
19429   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19430   if (test_checksum_6 () == -1) {
19431     printf ("test_checksum_6 FAILED\n");
19432     failed++;
19433   }
19434   test_num++;
19435   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19436   if (test_checksum_7 () == -1) {
19437     printf ("test_checksum_7 FAILED\n");
19438     failed++;
19439   }
19440   test_num++;
19441   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19442   if (test_checksum_8 () == -1) {
19443     printf ("test_checksum_8 FAILED\n");
19444     failed++;
19445   }
19446   test_num++;
19447   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19448   if (test_download_0 () == -1) {
19449     printf ("test_download_0 FAILED\n");
19450     failed++;
19451   }
19452   test_num++;
19453   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19454   if (test_upload_0 () == -1) {
19455     printf ("test_upload_0 FAILED\n");
19456     failed++;
19457   }
19458   test_num++;
19459   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19460   if (test_blockdev_rereadpt_0 () == -1) {
19461     printf ("test_blockdev_rereadpt_0 FAILED\n");
19462     failed++;
19463   }
19464   test_num++;
19465   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19466   if (test_blockdev_flushbufs_0 () == -1) {
19467     printf ("test_blockdev_flushbufs_0 FAILED\n");
19468     failed++;
19469   }
19470   test_num++;
19471   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19472   if (test_blockdev_getsize64_0 () == -1) {
19473     printf ("test_blockdev_getsize64_0 FAILED\n");
19474     failed++;
19475   }
19476   test_num++;
19477   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19478   if (test_blockdev_getsz_0 () == -1) {
19479     printf ("test_blockdev_getsz_0 FAILED\n");
19480     failed++;
19481   }
19482   test_num++;
19483   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19484   if (test_blockdev_getbsz_0 () == -1) {
19485     printf ("test_blockdev_getbsz_0 FAILED\n");
19486     failed++;
19487   }
19488   test_num++;
19489   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19490   if (test_blockdev_getss_0 () == -1) {
19491     printf ("test_blockdev_getss_0 FAILED\n");
19492     failed++;
19493   }
19494   test_num++;
19495   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19496   if (test_blockdev_getro_0 () == -1) {
19497     printf ("test_blockdev_getro_0 FAILED\n");
19498     failed++;
19499   }
19500   test_num++;
19501   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19502   if (test_blockdev_setrw_0 () == -1) {
19503     printf ("test_blockdev_setrw_0 FAILED\n");
19504     failed++;
19505   }
19506   test_num++;
19507   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19508   if (test_blockdev_setro_0 () == -1) {
19509     printf ("test_blockdev_setro_0 FAILED\n");
19510     failed++;
19511   }
19512   test_num++;
19513   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19514   if (test_statvfs_0 () == -1) {
19515     printf ("test_statvfs_0 FAILED\n");
19516     failed++;
19517   }
19518   test_num++;
19519   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19520   if (test_lstat_0 () == -1) {
19521     printf ("test_lstat_0 FAILED\n");
19522     failed++;
19523   }
19524   test_num++;
19525   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19526   if (test_stat_0 () == -1) {
19527     printf ("test_stat_0 FAILED\n");
19528     failed++;
19529   }
19530   test_num++;
19531   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19532   if (test_command_lines_0 () == -1) {
19533     printf ("test_command_lines_0 FAILED\n");
19534     failed++;
19535   }
19536   test_num++;
19537   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19538   if (test_command_lines_1 () == -1) {
19539     printf ("test_command_lines_1 FAILED\n");
19540     failed++;
19541   }
19542   test_num++;
19543   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19544   if (test_command_lines_2 () == -1) {
19545     printf ("test_command_lines_2 FAILED\n");
19546     failed++;
19547   }
19548   test_num++;
19549   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19550   if (test_command_lines_3 () == -1) {
19551     printf ("test_command_lines_3 FAILED\n");
19552     failed++;
19553   }
19554   test_num++;
19555   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19556   if (test_command_lines_4 () == -1) {
19557     printf ("test_command_lines_4 FAILED\n");
19558     failed++;
19559   }
19560   test_num++;
19561   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19562   if (test_command_lines_5 () == -1) {
19563     printf ("test_command_lines_5 FAILED\n");
19564     failed++;
19565   }
19566   test_num++;
19567   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19568   if (test_command_lines_6 () == -1) {
19569     printf ("test_command_lines_6 FAILED\n");
19570     failed++;
19571   }
19572   test_num++;
19573   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19574   if (test_command_lines_7 () == -1) {
19575     printf ("test_command_lines_7 FAILED\n");
19576     failed++;
19577   }
19578   test_num++;
19579   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19580   if (test_command_lines_8 () == -1) {
19581     printf ("test_command_lines_8 FAILED\n");
19582     failed++;
19583   }
19584   test_num++;
19585   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19586   if (test_command_lines_9 () == -1) {
19587     printf ("test_command_lines_9 FAILED\n");
19588     failed++;
19589   }
19590   test_num++;
19591   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19592   if (test_command_lines_10 () == -1) {
19593     printf ("test_command_lines_10 FAILED\n");
19594     failed++;
19595   }
19596   test_num++;
19597   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19598   if (test_command_0 () == -1) {
19599     printf ("test_command_0 FAILED\n");
19600     failed++;
19601   }
19602   test_num++;
19603   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19604   if (test_command_1 () == -1) {
19605     printf ("test_command_1 FAILED\n");
19606     failed++;
19607   }
19608   test_num++;
19609   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19610   if (test_command_2 () == -1) {
19611     printf ("test_command_2 FAILED\n");
19612     failed++;
19613   }
19614   test_num++;
19615   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19616   if (test_command_3 () == -1) {
19617     printf ("test_command_3 FAILED\n");
19618     failed++;
19619   }
19620   test_num++;
19621   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19622   if (test_command_4 () == -1) {
19623     printf ("test_command_4 FAILED\n");
19624     failed++;
19625   }
19626   test_num++;
19627   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19628   if (test_command_5 () == -1) {
19629     printf ("test_command_5 FAILED\n");
19630     failed++;
19631   }
19632   test_num++;
19633   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19634   if (test_command_6 () == -1) {
19635     printf ("test_command_6 FAILED\n");
19636     failed++;
19637   }
19638   test_num++;
19639   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19640   if (test_command_7 () == -1) {
19641     printf ("test_command_7 FAILED\n");
19642     failed++;
19643   }
19644   test_num++;
19645   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19646   if (test_command_8 () == -1) {
19647     printf ("test_command_8 FAILED\n");
19648     failed++;
19649   }
19650   test_num++;
19651   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19652   if (test_command_9 () == -1) {
19653     printf ("test_command_9 FAILED\n");
19654     failed++;
19655   }
19656   test_num++;
19657   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19658   if (test_command_10 () == -1) {
19659     printf ("test_command_10 FAILED\n");
19660     failed++;
19661   }
19662   test_num++;
19663   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19664   if (test_command_11 () == -1) {
19665     printf ("test_command_11 FAILED\n");
19666     failed++;
19667   }
19668   test_num++;
19669   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19670   if (test_file_0 () == -1) {
19671     printf ("test_file_0 FAILED\n");
19672     failed++;
19673   }
19674   test_num++;
19675   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19676   if (test_file_1 () == -1) {
19677     printf ("test_file_1 FAILED\n");
19678     failed++;
19679   }
19680   test_num++;
19681   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19682   if (test_file_2 () == -1) {
19683     printf ("test_file_2 FAILED\n");
19684     failed++;
19685   }
19686   test_num++;
19687   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19688   if (test_umount_all_0 () == -1) {
19689     printf ("test_umount_all_0 FAILED\n");
19690     failed++;
19691   }
19692   test_num++;
19693   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19694   if (test_umount_all_1 () == -1) {
19695     printf ("test_umount_all_1 FAILED\n");
19696     failed++;
19697   }
19698   test_num++;
19699   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19700   if (test_mounts_0 () == -1) {
19701     printf ("test_mounts_0 FAILED\n");
19702     failed++;
19703   }
19704   test_num++;
19705   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19706   if (test_umount_0 () == -1) {
19707     printf ("test_umount_0 FAILED\n");
19708     failed++;
19709   }
19710   test_num++;
19711   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19712   if (test_umount_1 () == -1) {
19713     printf ("test_umount_1 FAILED\n");
19714     failed++;
19715   }
19716   test_num++;
19717   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19718   if (test_write_file_0 () == -1) {
19719     printf ("test_write_file_0 FAILED\n");
19720     failed++;
19721   }
19722   test_num++;
19723   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19724   if (test_write_file_1 () == -1) {
19725     printf ("test_write_file_1 FAILED\n");
19726     failed++;
19727   }
19728   test_num++;
19729   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19730   if (test_write_file_2 () == -1) {
19731     printf ("test_write_file_2 FAILED\n");
19732     failed++;
19733   }
19734   test_num++;
19735   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19736   if (test_write_file_3 () == -1) {
19737     printf ("test_write_file_3 FAILED\n");
19738     failed++;
19739   }
19740   test_num++;
19741   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19742   if (test_write_file_4 () == -1) {
19743     printf ("test_write_file_4 FAILED\n");
19744     failed++;
19745   }
19746   test_num++;
19747   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19748   if (test_write_file_5 () == -1) {
19749     printf ("test_write_file_5 FAILED\n");
19750     failed++;
19751   }
19752   test_num++;
19753   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19754   if (test_mkfs_0 () == -1) {
19755     printf ("test_mkfs_0 FAILED\n");
19756     failed++;
19757   }
19758   test_num++;
19759   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19760   if (test_lvcreate_0 () == -1) {
19761     printf ("test_lvcreate_0 FAILED\n");
19762     failed++;
19763   }
19764   test_num++;
19765   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19766   if (test_vgcreate_0 () == -1) {
19767     printf ("test_vgcreate_0 FAILED\n");
19768     failed++;
19769   }
19770   test_num++;
19771   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19772   if (test_pvcreate_0 () == -1) {
19773     printf ("test_pvcreate_0 FAILED\n");
19774     failed++;
19775   }
19776   test_num++;
19777   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19778   if (test_is_dir_0 () == -1) {
19779     printf ("test_is_dir_0 FAILED\n");
19780     failed++;
19781   }
19782   test_num++;
19783   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19784   if (test_is_dir_1 () == -1) {
19785     printf ("test_is_dir_1 FAILED\n");
19786     failed++;
19787   }
19788   test_num++;
19789   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19790   if (test_is_file_0 () == -1) {
19791     printf ("test_is_file_0 FAILED\n");
19792     failed++;
19793   }
19794   test_num++;
19795   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19796   if (test_is_file_1 () == -1) {
19797     printf ("test_is_file_1 FAILED\n");
19798     failed++;
19799   }
19800   test_num++;
19801   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19802   if (test_exists_0 () == -1) {
19803     printf ("test_exists_0 FAILED\n");
19804     failed++;
19805   }
19806   test_num++;
19807   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19808   if (test_exists_1 () == -1) {
19809     printf ("test_exists_1 FAILED\n");
19810     failed++;
19811   }
19812   test_num++;
19813   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19814   if (test_mkdir_p_0 () == -1) {
19815     printf ("test_mkdir_p_0 FAILED\n");
19816     failed++;
19817   }
19818   test_num++;
19819   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19820   if (test_mkdir_p_1 () == -1) {
19821     printf ("test_mkdir_p_1 FAILED\n");
19822     failed++;
19823   }
19824   test_num++;
19825   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19826   if (test_mkdir_p_2 () == -1) {
19827     printf ("test_mkdir_p_2 FAILED\n");
19828     failed++;
19829   }
19830   test_num++;
19831   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19832   if (test_mkdir_p_3 () == -1) {
19833     printf ("test_mkdir_p_3 FAILED\n");
19834     failed++;
19835   }
19836   test_num++;
19837   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19838   if (test_mkdir_p_4 () == -1) {
19839     printf ("test_mkdir_p_4 FAILED\n");
19840     failed++;
19841   }
19842   test_num++;
19843   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19844   if (test_mkdir_0 () == -1) {
19845     printf ("test_mkdir_0 FAILED\n");
19846     failed++;
19847   }
19848   test_num++;
19849   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19850   if (test_mkdir_1 () == -1) {
19851     printf ("test_mkdir_1 FAILED\n");
19852     failed++;
19853   }
19854   test_num++;
19855   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19856   if (test_rm_rf_0 () == -1) {
19857     printf ("test_rm_rf_0 FAILED\n");
19858     failed++;
19859   }
19860   test_num++;
19861   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19862   if (test_rmdir_0 () == -1) {
19863     printf ("test_rmdir_0 FAILED\n");
19864     failed++;
19865   }
19866   test_num++;
19867   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19868   if (test_rmdir_1 () == -1) {
19869     printf ("test_rmdir_1 FAILED\n");
19870     failed++;
19871   }
19872   test_num++;
19873   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19874   if (test_rmdir_2 () == -1) {
19875     printf ("test_rmdir_2 FAILED\n");
19876     failed++;
19877   }
19878   test_num++;
19879   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19880   if (test_rm_0 () == -1) {
19881     printf ("test_rm_0 FAILED\n");
19882     failed++;
19883   }
19884   test_num++;
19885   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19886   if (test_rm_1 () == -1) {
19887     printf ("test_rm_1 FAILED\n");
19888     failed++;
19889   }
19890   test_num++;
19891   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19892   if (test_rm_2 () == -1) {
19893     printf ("test_rm_2 FAILED\n");
19894     failed++;
19895   }
19896   test_num++;
19897   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19898   if (test_read_lines_0 () == -1) {
19899     printf ("test_read_lines_0 FAILED\n");
19900     failed++;
19901   }
19902   test_num++;
19903   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19904   if (test_read_lines_1 () == -1) {
19905     printf ("test_read_lines_1 FAILED\n");
19906     failed++;
19907   }
19908   test_num++;
19909   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19910   if (test_lvs_0 () == -1) {
19911     printf ("test_lvs_0 FAILED\n");
19912     failed++;
19913   }
19914   test_num++;
19915   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19916   if (test_lvs_1 () == -1) {
19917     printf ("test_lvs_1 FAILED\n");
19918     failed++;
19919   }
19920   test_num++;
19921   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19922   if (test_vgs_0 () == -1) {
19923     printf ("test_vgs_0 FAILED\n");
19924     failed++;
19925   }
19926   test_num++;
19927   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19928   if (test_vgs_1 () == -1) {
19929     printf ("test_vgs_1 FAILED\n");
19930     failed++;
19931   }
19932   test_num++;
19933   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19934   if (test_pvs_0 () == -1) {
19935     printf ("test_pvs_0 FAILED\n");
19936     failed++;
19937   }
19938   test_num++;
19939   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19940   if (test_pvs_1 () == -1) {
19941     printf ("test_pvs_1 FAILED\n");
19942     failed++;
19943   }
19944   test_num++;
19945   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19946   if (test_list_partitions_0 () == -1) {
19947     printf ("test_list_partitions_0 FAILED\n");
19948     failed++;
19949   }
19950   test_num++;
19951   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19952   if (test_list_partitions_1 () == -1) {
19953     printf ("test_list_partitions_1 FAILED\n");
19954     failed++;
19955   }
19956   test_num++;
19957   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19958   if (test_list_devices_0 () == -1) {
19959     printf ("test_list_devices_0 FAILED\n");
19960     failed++;
19961   }
19962   test_num++;
19963   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19964   if (test_ls_0 () == -1) {
19965     printf ("test_ls_0 FAILED\n");
19966     failed++;
19967   }
19968   test_num++;
19969   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19970   if (test_cat_0 () == -1) {
19971     printf ("test_cat_0 FAILED\n");
19972     failed++;
19973   }
19974   test_num++;
19975   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19976   if (test_touch_0 () == -1) {
19977     printf ("test_touch_0 FAILED\n");
19978     failed++;
19979   }
19980   test_num++;
19981   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19982   if (test_sync_0 () == -1) {
19983     printf ("test_sync_0 FAILED\n");
19984     failed++;
19985   }
19986   test_num++;
19987   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19988   if (test_mount_0 () == -1) {
19989     printf ("test_mount_0 FAILED\n");
19990     failed++;
19991   }
19992
19993   guestfs_close (g);
19994   unlink ("test1.img");
19995   unlink ("test2.img");
19996   unlink ("test3.img");
19997
19998   if (failed > 0) {
19999     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
20000     exit (1);
20001   }
20002
20003   exit (0);
20004 }