capitests/tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 static void print_error (guestfs_h *g, void *data, const char *msg)
  35 {
  36   if (!suppress_error)
  37     fprintf (stderr, "%s\n", msg);
  38 }
  39
  40 static void print_strings (char * const * const argv)
  41 {
  42   int argc;
  43
  44   for (argc = 0; argv[argc] != NULL; ++argc)
  45     printf ("\t%s\n", argv[argc]);
  46 }
  47
  48 /*
  49 static void print_table (char * const * const argv)
  50 {
  51   int i;
  52
  53   for (i = 0; argv[i] != NULL; i += 2)
  54     printf ("%s: %s\n", argv[i], argv[i+1]);
  55 }
  56 */
  57
  58 static void no_test_warnings (void)
  59 {
  60   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  61   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  62   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  63   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  64   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  65   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
 156 }
 157
 158 static int test_initrd_list_0_skip (void)
 159 {
 160   const char *str;
 161
 162   str = getenv ("TEST_ONLY");
 163   if (str)
 164     return strstr (str, "initrd_list") == NULL;
 165   str = getenv ("SKIP_TEST_INITRD_LIST_0");
 166   if (str && strcmp (str, "1") == 0) return 1;
 167   str = getenv ("SKIP_TEST_INITRD_LIST");
 168   if (str && strcmp (str, "1") == 0) return 1;
 169   return 0;
 170 }
 171
 172 static int test_initrd_list_0 (void)
 173 {
 174   if (test_initrd_list_0_skip ()) {
 175     printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
 176     return 0;
 177   }
 178
 179   /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
 180   {
 181     char device[] = "/dev/sda";
 182     int r;
 183     suppress_error = 0;
 184     r = guestfs_blockdev_setrw (g, device);
 185     if (r == -1)
 186       return -1;
 187   }
 188   {
 189     int r;
 190     suppress_error = 0;
 191     r = guestfs_umount_all (g);
 192     if (r == -1)
 193       return -1;
 194   }
 195   {
 196     int r;
 197     suppress_error = 0;
 198     r = guestfs_lvm_remove_all (g);
 199     if (r == -1)
 200       return -1;
 201   }
 202   {
 203     char device[] = "/dev/sda";
 204     char lines_0[] = ",";
 205     char *lines[] = {
 206       lines_0,
 207       NULL
 208     };
 209     int r;
 210     suppress_error = 0;
 211     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 212     if (r == -1)
 213       return -1;
 214   }
 215   {
 216     char fstype[] = "ext2";
 217     char device[] = "/dev/sda1";
 218     int r;
 219     suppress_error = 0;
 220     r = guestfs_mkfs (g, fstype, device);
 221     if (r == -1)
 222       return -1;
 223   }
 224   {
 225     char device[] = "/dev/sda1";
 226     char mountpoint[] = "/";
 227     int r;
 228     suppress_error = 0;
 229     r = guestfs_mount (g, device, mountpoint);
 230     if (r == -1)
 231       return -1;
 232   }
 233   /* TestOutputList for initrd_list (0) */
 234   {
 235     char options[] = "ro";
 236     char vfstype[] = "squashfs";
 237     char device[] = "/dev/sdd";
 238     char mountpoint[] = "/";
 239     int r;
 240     suppress_error = 0;
 241     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 242     if (r == -1)
 243       return -1;
 244   }
 245   {
 246     char path[] = "/initrd";
 247     char **r;
 248     int i;
 249     suppress_error = 0;
 250     r = guestfs_initrd_list (g, path);
 251     if (r == NULL)
 252       return -1;
 253     if (!r[0]) {
 254       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 255       print_strings (r);
 256       return -1;
 257     }
 258     {
 259       char expected[] = "empty";
 260       if (strcmp (r[0], expected) != 0) {
 261         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 262         return -1;
 263       }
 264     }
 265     if (!r[1]) {
 266       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 267       print_strings (r);
 268       return -1;
 269     }
 270     {
 271       char expected[] = "known-1";
 272       if (strcmp (r[1], expected) != 0) {
 273         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 274         return -1;
 275       }
 276     }
 277     if (!r[2]) {
 278       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 279       print_strings (r);
 280       return -1;
 281     }
 282     {
 283       char expected[] = "known-2";
 284       if (strcmp (r[2], expected) != 0) {
 285         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 286         return -1;
 287       }
 288     }
 289     if (!r[3]) {
 290       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 291       print_strings (r);
 292       return -1;
 293     }
 294     {
 295       char expected[] = "known-3";
 296       if (strcmp (r[3], expected) != 0) {
 297         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 298         return -1;
 299       }
 300     }
 301     if (r[4] != NULL) {
 302       fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
 303       print_strings (r);
 304       return -1;
 305     }
 306     for (i = 0; r[i] != NULL; ++i)
 307       free (r[i]);
 308     free (r);
 309   }
 310   return 0;
 311 }
 312
 313 static int test_du_0_skip (void)
 314 {
 315   const char *str;
 316
 317   str = getenv ("TEST_ONLY");
 318   if (str)
 319     return strstr (str, "du") == NULL;
 320   str = getenv ("SKIP_TEST_DU_0");
 321   if (str && strcmp (str, "1") == 0) return 1;
 322   str = getenv ("SKIP_TEST_DU");
 323   if (str && strcmp (str, "1") == 0) return 1;
 324   return 0;
 325 }
 326
 327 static int test_du_0 (void)
 328 {
 329   if (test_du_0_skip ()) {
 330     printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
 331     return 0;
 332   }
 333
 334   /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
 335   {
 336     char device[] = "/dev/sda";
 337     int r;
 338     suppress_error = 0;
 339     r = guestfs_blockdev_setrw (g, device);
 340     if (r == -1)
 341       return -1;
 342   }
 343   {
 344     int r;
 345     suppress_error = 0;
 346     r = guestfs_umount_all (g);
 347     if (r == -1)
 348       return -1;
 349   }
 350   {
 351     int r;
 352     suppress_error = 0;
 353     r = guestfs_lvm_remove_all (g);
 354     if (r == -1)
 355       return -1;
 356   }
 357   {
 358     char device[] = "/dev/sda";
 359     char lines_0[] = ",";
 360     char *lines[] = {
 361       lines_0,
 362       NULL
 363     };
 364     int r;
 365     suppress_error = 0;
 366     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 367     if (r == -1)
 368       return -1;
 369   }
 370   {
 371     char fstype[] = "ext2";
 372     char device[] = "/dev/sda1";
 373     int r;
 374     suppress_error = 0;
 375     r = guestfs_mkfs (g, fstype, device);
 376     if (r == -1)
 377       return -1;
 378   }
 379   {
 380     char device[] = "/dev/sda1";
 381     char mountpoint[] = "/";
 382     int r;
 383     suppress_error = 0;
 384     r = guestfs_mount (g, device, mountpoint);
 385     if (r == -1)
 386       return -1;
 387   }
 388   /* TestOutputInt for du (0) */
 389   {
 390     char path[] = "/p";
 391     int r;
 392     suppress_error = 0;
 393     r = guestfs_mkdir (g, path);
 394     if (r == -1)
 395       return -1;
 396   }
 397   {
 398     char path[] = "/p";
 399     int64_t r;
 400     suppress_error = 0;
 401     r = guestfs_du (g, path);
 402     if (r == -1)
 403       return -1;
 404     if (r != 1) {
 405       fprintf (stderr, "test_du_0: expected 1 but got %d\n",               (int) r);
 406       return -1;
 407     }
 408   }
 409   return 0;
 410 }
 411
 412 static int test_tail_n_0_skip (void)
 413 {
 414   const char *str;
 415
 416   str = getenv ("TEST_ONLY");
 417   if (str)
 418     return strstr (str, "tail_n") == NULL;
 419   str = getenv ("SKIP_TEST_TAIL_N_0");
 420   if (str && strcmp (str, "1") == 0) return 1;
 421   str = getenv ("SKIP_TEST_TAIL_N");
 422   if (str && strcmp (str, "1") == 0) return 1;
 423   return 0;
 424 }
 425
 426 static int test_tail_n_0 (void)
 427 {
 428   if (test_tail_n_0_skip ()) {
 429     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
 430     return 0;
 431   }
 432
 433   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
 434   {
 435     char device[] = "/dev/sda";
 436     int r;
 437     suppress_error = 0;
 438     r = guestfs_blockdev_setrw (g, device);
 439     if (r == -1)
 440       return -1;
 441   }
 442   {
 443     int r;
 444     suppress_error = 0;
 445     r = guestfs_umount_all (g);
 446     if (r == -1)
 447       return -1;
 448   }
 449   {
 450     int r;
 451     suppress_error = 0;
 452     r = guestfs_lvm_remove_all (g);
 453     if (r == -1)
 454       return -1;
 455   }
 456   {
 457     char device[] = "/dev/sda";
 458     char lines_0[] = ",";
 459     char *lines[] = {
 460       lines_0,
 461       NULL
 462     };
 463     int r;
 464     suppress_error = 0;
 465     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 466     if (r == -1)
 467       return -1;
 468   }
 469   {
 470     char fstype[] = "ext2";
 471     char device[] = "/dev/sda1";
 472     int r;
 473     suppress_error = 0;
 474     r = guestfs_mkfs (g, fstype, device);
 475     if (r == -1)
 476       return -1;
 477   }
 478   {
 479     char device[] = "/dev/sda1";
 480     char mountpoint[] = "/";
 481     int r;
 482     suppress_error = 0;
 483     r = guestfs_mount (g, device, mountpoint);
 484     if (r == -1)
 485       return -1;
 486   }
 487   /* TestOutputList for tail_n (0) */
 488   {
 489     char options[] = "ro";
 490     char vfstype[] = "squashfs";
 491     char device[] = "/dev/sdd";
 492     char mountpoint[] = "/";
 493     int r;
 494     suppress_error = 0;
 495     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 496     if (r == -1)
 497       return -1;
 498   }
 499   {
 500     char path[] = "/10klines";
 501     char **r;
 502     int i;
 503     suppress_error = 0;
 504     r = guestfs_tail_n (g, 3, path);
 505     if (r == NULL)
 506       return -1;
 507     if (!r[0]) {
 508       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 509       print_strings (r);
 510       return -1;
 511     }
 512     {
 513       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 514       if (strcmp (r[0], expected) != 0) {
 515         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 516         return -1;
 517       }
 518     }
 519     if (!r[1]) {
 520       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 521       print_strings (r);
 522       return -1;
 523     }
 524     {
 525       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 526       if (strcmp (r[1], expected) != 0) {
 527         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 528         return -1;
 529       }
 530     }
 531     if (!r[2]) {
 532       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
 533       print_strings (r);
 534       return -1;
 535     }
 536     {
 537       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 538       if (strcmp (r[2], expected) != 0) {
 539         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 540         return -1;
 541       }
 542     }
 543     if (r[3] != NULL) {
 544       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
 545       print_strings (r);
 546       return -1;
 547     }
 548     for (i = 0; r[i] != NULL; ++i)
 549       free (r[i]);
 550     free (r);
 551   }
 552   return 0;
 553 }
 554
 555 static int test_tail_n_1_skip (void)
 556 {
 557   const char *str;
 558
 559   str = getenv ("TEST_ONLY");
 560   if (str)
 561     return strstr (str, "tail_n") == NULL;
 562   str = getenv ("SKIP_TEST_TAIL_N_1");
 563   if (str && strcmp (str, "1") == 0) return 1;
 564   str = getenv ("SKIP_TEST_TAIL_N");
 565   if (str && strcmp (str, "1") == 0) return 1;
 566   return 0;
 567 }
 568
 569 static int test_tail_n_1 (void)
 570 {
 571   if (test_tail_n_1_skip ()) {
 572     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
 573     return 0;
 574   }
 575
 576   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
 577   {
 578     char device[] = "/dev/sda";
 579     int r;
 580     suppress_error = 0;
 581     r = guestfs_blockdev_setrw (g, device);
 582     if (r == -1)
 583       return -1;
 584   }
 585   {
 586     int r;
 587     suppress_error = 0;
 588     r = guestfs_umount_all (g);
 589     if (r == -1)
 590       return -1;
 591   }
 592   {
 593     int r;
 594     suppress_error = 0;
 595     r = guestfs_lvm_remove_all (g);
 596     if (r == -1)
 597       return -1;
 598   }
 599   {
 600     char device[] = "/dev/sda";
 601     char lines_0[] = ",";
 602     char *lines[] = {
 603       lines_0,
 604       NULL
 605     };
 606     int r;
 607     suppress_error = 0;
 608     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 609     if (r == -1)
 610       return -1;
 611   }
 612   {
 613     char fstype[] = "ext2";
 614     char device[] = "/dev/sda1";
 615     int r;
 616     suppress_error = 0;
 617     r = guestfs_mkfs (g, fstype, device);
 618     if (r == -1)
 619       return -1;
 620   }
 621   {
 622     char device[] = "/dev/sda1";
 623     char mountpoint[] = "/";
 624     int r;
 625     suppress_error = 0;
 626     r = guestfs_mount (g, device, mountpoint);
 627     if (r == -1)
 628       return -1;
 629   }
 630   /* TestOutputList for tail_n (1) */
 631   {
 632     char options[] = "ro";
 633     char vfstype[] = "squashfs";
 634     char device[] = "/dev/sdd";
 635     char mountpoint[] = "/";
 636     int r;
 637     suppress_error = 0;
 638     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 639     if (r == -1)
 640       return -1;
 641   }
 642   {
 643     char path[] = "/10klines";
 644     char **r;
 645     int i;
 646     suppress_error = 0;
 647     r = guestfs_tail_n (g, -9998, path);
 648     if (r == NULL)
 649       return -1;
 650     if (!r[0]) {
 651       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 652       print_strings (r);
 653       return -1;
 654     }
 655     {
 656       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 657       if (strcmp (r[0], expected) != 0) {
 658         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 659         return -1;
 660       }
 661     }
 662     if (!r[1]) {
 663       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 664       print_strings (r);
 665       return -1;
 666     }
 667     {
 668       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
 669       if (strcmp (r[1], expected) != 0) {
 670         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 671         return -1;
 672       }
 673     }
 674     if (!r[2]) {
 675       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
 676       print_strings (r);
 677       return -1;
 678     }
 679     {
 680       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
 681       if (strcmp (r[2], expected) != 0) {
 682         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 683         return -1;
 684       }
 685     }
 686     if (r[3] != NULL) {
 687       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
 688       print_strings (r);
 689       return -1;
 690     }
 691     for (i = 0; r[i] != NULL; ++i)
 692       free (r[i]);
 693     free (r);
 694   }
 695   return 0;
 696 }
 697
 698 static int test_tail_n_2_skip (void)
 699 {
 700   const char *str;
 701
 702   str = getenv ("TEST_ONLY");
 703   if (str)
 704     return strstr (str, "tail_n") == NULL;
 705   str = getenv ("SKIP_TEST_TAIL_N_2");
 706   if (str && strcmp (str, "1") == 0) return 1;
 707   str = getenv ("SKIP_TEST_TAIL_N");
 708   if (str && strcmp (str, "1") == 0) return 1;
 709   return 0;
 710 }
 711
 712 static int test_tail_n_2 (void)
 713 {
 714   if (test_tail_n_2_skip ()) {
 715     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
 716     return 0;
 717   }
 718
 719   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
 720   {
 721     char device[] = "/dev/sda";
 722     int r;
 723     suppress_error = 0;
 724     r = guestfs_blockdev_setrw (g, device);
 725     if (r == -1)
 726       return -1;
 727   }
 728   {
 729     int r;
 730     suppress_error = 0;
 731     r = guestfs_umount_all (g);
 732     if (r == -1)
 733       return -1;
 734   }
 735   {
 736     int r;
 737     suppress_error = 0;
 738     r = guestfs_lvm_remove_all (g);
 739     if (r == -1)
 740       return -1;
 741   }
 742   {
 743     char device[] = "/dev/sda";
 744     char lines_0[] = ",";
 745     char *lines[] = {
 746       lines_0,
 747       NULL
 748     };
 749     int r;
 750     suppress_error = 0;
 751     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 752     if (r == -1)
 753       return -1;
 754   }
 755   {
 756     char fstype[] = "ext2";
 757     char device[] = "/dev/sda1";
 758     int r;
 759     suppress_error = 0;
 760     r = guestfs_mkfs (g, fstype, device);
 761     if (r == -1)
 762       return -1;
 763   }
 764   {
 765     char device[] = "/dev/sda1";
 766     char mountpoint[] = "/";
 767     int r;
 768     suppress_error = 0;
 769     r = guestfs_mount (g, device, mountpoint);
 770     if (r == -1)
 771       return -1;
 772   }
 773   /* TestOutputList for tail_n (2) */
 774   {
 775     char options[] = "ro";
 776     char vfstype[] = "squashfs";
 777     char device[] = "/dev/sdd";
 778     char mountpoint[] = "/";
 779     int r;
 780     suppress_error = 0;
 781     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 782     if (r == -1)
 783       return -1;
 784   }
 785   {
 786     char path[] = "/10klines";
 787     char **r;
 788     int i;
 789     suppress_error = 0;
 790     r = guestfs_tail_n (g, 0, path);
 791     if (r == NULL)
 792       return -1;
 793     if (r[0] != NULL) {
 794       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
 795       print_strings (r);
 796       return -1;
 797     }
 798     for (i = 0; r[i] != NULL; ++i)
 799       free (r[i]);
 800     free (r);
 801   }
 802   return 0;
 803 }
 804
 805 static int test_tail_0_skip (void)
 806 {
 807   const char *str;
 808
 809   str = getenv ("TEST_ONLY");
 810   if (str)
 811     return strstr (str, "tail") == NULL;
 812   str = getenv ("SKIP_TEST_TAIL_0");
 813   if (str && strcmp (str, "1") == 0) return 1;
 814   str = getenv ("SKIP_TEST_TAIL");
 815   if (str && strcmp (str, "1") == 0) return 1;
 816   return 0;
 817 }
 818
 819 static int test_tail_0 (void)
 820 {
 821   if (test_tail_0_skip ()) {
 822     printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
 823     return 0;
 824   }
 825
 826   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
 827   {
 828     char device[] = "/dev/sda";
 829     int r;
 830     suppress_error = 0;
 831     r = guestfs_blockdev_setrw (g, device);
 832     if (r == -1)
 833       return -1;
 834   }
 835   {
 836     int r;
 837     suppress_error = 0;
 838     r = guestfs_umount_all (g);
 839     if (r == -1)
 840       return -1;
 841   }
 842   {
 843     int r;
 844     suppress_error = 0;
 845     r = guestfs_lvm_remove_all (g);
 846     if (r == -1)
 847       return -1;
 848   }
 849   {
 850     char device[] = "/dev/sda";
 851     char lines_0[] = ",";
 852     char *lines[] = {
 853       lines_0,
 854       NULL
 855     };
 856     int r;
 857     suppress_error = 0;
 858     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 859     if (r == -1)
 860       return -1;
 861   }
 862   {
 863     char fstype[] = "ext2";
 864     char device[] = "/dev/sda1";
 865     int r;
 866     suppress_error = 0;
 867     r = guestfs_mkfs (g, fstype, device);
 868     if (r == -1)
 869       return -1;
 870   }
 871   {
 872     char device[] = "/dev/sda1";
 873     char mountpoint[] = "/";
 874     int r;
 875     suppress_error = 0;
 876     r = guestfs_mount (g, device, mountpoint);
 877     if (r == -1)
 878       return -1;
 879   }
 880   /* TestOutputList for tail (0) */
 881   {
 882     char options[] = "ro";
 883     char vfstype[] = "squashfs";
 884     char device[] = "/dev/sdd";
 885     char mountpoint[] = "/";
 886     int r;
 887     suppress_error = 0;
 888     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 889     if (r == -1)
 890       return -1;
 891   }
 892   {
 893     char path[] = "/10klines";
 894     char **r;
 895     int i;
 896     suppress_error = 0;
 897     r = guestfs_tail (g, path);
 898     if (r == NULL)
 899       return -1;
 900     if (!r[0]) {
 901       fprintf (stderr, "test_tail_0: short list returned from command\n");
 902       print_strings (r);
 903       return -1;
 904     }
 905     {
 906       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
 907       if (strcmp (r[0], expected) != 0) {
 908         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 909         return -1;
 910       }
 911     }
 912     if (!r[1]) {
 913       fprintf (stderr, "test_tail_0: short list returned from command\n");
 914       print_strings (r);
 915       return -1;
 916     }
 917     {
 918       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
 919       if (strcmp (r[1], expected) != 0) {
 920         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 921         return -1;
 922       }
 923     }
 924     if (!r[2]) {
 925       fprintf (stderr, "test_tail_0: short list returned from command\n");
 926       print_strings (r);
 927       return -1;
 928     }
 929     {
 930       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
 931       if (strcmp (r[2], expected) != 0) {
 932         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
 933         return -1;
 934       }
 935     }
 936     if (!r[3]) {
 937       fprintf (stderr, "test_tail_0: short list returned from command\n");
 938       print_strings (r);
 939       return -1;
 940     }
 941     {
 942       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
 943       if (strcmp (r[3], expected) != 0) {
 944         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
 945         return -1;
 946       }
 947     }
 948     if (!r[4]) {
 949       fprintf (stderr, "test_tail_0: short list returned from command\n");
 950       print_strings (r);
 951       return -1;
 952     }
 953     {
 954       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
 955       if (strcmp (r[4], expected) != 0) {
 956         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
 957         return -1;
 958       }
 959     }
 960     if (!r[5]) {
 961       fprintf (stderr, "test_tail_0: short list returned from command\n");
 962       print_strings (r);
 963       return -1;
 964     }
 965     {
 966       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
 967       if (strcmp (r[5], expected) != 0) {
 968         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
 969         return -1;
 970       }
 971     }
 972     if (!r[6]) {
 973       fprintf (stderr, "test_tail_0: short list returned from command\n");
 974       print_strings (r);
 975       return -1;
 976     }
 977     {
 978       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
 979       if (strcmp (r[6], expected) != 0) {
 980         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
 981         return -1;
 982       }
 983     }
 984     if (!r[7]) {
 985       fprintf (stderr, "test_tail_0: short list returned from command\n");
 986       print_strings (r);
 987       return -1;
 988     }
 989     {
 990       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
 991       if (strcmp (r[7], expected) != 0) {
 992         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
 993         return -1;
 994       }
 995     }
 996     if (!r[8]) {
 997       fprintf (stderr, "test_tail_0: short list returned from command\n");
 998       print_strings (r);
 999       return -1;
1000     }
1001     {
1002       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1003       if (strcmp (r[8], expected) != 0) {
1004         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1005         return -1;
1006       }
1007     }
1008     if (!r[9]) {
1009       fprintf (stderr, "test_tail_0: short list returned from command\n");
1010       print_strings (r);
1011       return -1;
1012     }
1013     {
1014       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1015       if (strcmp (r[9], expected) != 0) {
1016         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1017         return -1;
1018       }
1019     }
1020     if (r[10] != NULL) {
1021       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1022       print_strings (r);
1023       return -1;
1024     }
1025     for (i = 0; r[i] != NULL; ++i)
1026       free (r[i]);
1027     free (r);
1028   }
1029   return 0;
1030 }
1031
1032 static int test_head_n_0_skip (void)
1033 {
1034   const char *str;
1035
1036   str = getenv ("TEST_ONLY");
1037   if (str)
1038     return strstr (str, "head_n") == NULL;
1039   str = getenv ("SKIP_TEST_HEAD_N_0");
1040   if (str && strcmp (str, "1") == 0) return 1;
1041   str = getenv ("SKIP_TEST_HEAD_N");
1042   if (str && strcmp (str, "1") == 0) return 1;
1043   return 0;
1044 }
1045
1046 static int test_head_n_0 (void)
1047 {
1048   if (test_head_n_0_skip ()) {
1049     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1050     return 0;
1051   }
1052
1053   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1054   {
1055     char device[] = "/dev/sda";
1056     int r;
1057     suppress_error = 0;
1058     r = guestfs_blockdev_setrw (g, device);
1059     if (r == -1)
1060       return -1;
1061   }
1062   {
1063     int r;
1064     suppress_error = 0;
1065     r = guestfs_umount_all (g);
1066     if (r == -1)
1067       return -1;
1068   }
1069   {
1070     int r;
1071     suppress_error = 0;
1072     r = guestfs_lvm_remove_all (g);
1073     if (r == -1)
1074       return -1;
1075   }
1076   {
1077     char device[] = "/dev/sda";
1078     char lines_0[] = ",";
1079     char *lines[] = {
1080       lines_0,
1081       NULL
1082     };
1083     int r;
1084     suppress_error = 0;
1085     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1086     if (r == -1)
1087       return -1;
1088   }
1089   {
1090     char fstype[] = "ext2";
1091     char device[] = "/dev/sda1";
1092     int r;
1093     suppress_error = 0;
1094     r = guestfs_mkfs (g, fstype, device);
1095     if (r == -1)
1096       return -1;
1097   }
1098   {
1099     char device[] = "/dev/sda1";
1100     char mountpoint[] = "/";
1101     int r;
1102     suppress_error = 0;
1103     r = guestfs_mount (g, device, mountpoint);
1104     if (r == -1)
1105       return -1;
1106   }
1107   /* TestOutputList for head_n (0) */
1108   {
1109     char options[] = "ro";
1110     char vfstype[] = "squashfs";
1111     char device[] = "/dev/sdd";
1112     char mountpoint[] = "/";
1113     int r;
1114     suppress_error = 0;
1115     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1116     if (r == -1)
1117       return -1;
1118   }
1119   {
1120     char path[] = "/10klines";
1121     char **r;
1122     int i;
1123     suppress_error = 0;
1124     r = guestfs_head_n (g, 3, path);
1125     if (r == NULL)
1126       return -1;
1127     if (!r[0]) {
1128       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1129       print_strings (r);
1130       return -1;
1131     }
1132     {
1133       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1134       if (strcmp (r[0], expected) != 0) {
1135         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1136         return -1;
1137       }
1138     }
1139     if (!r[1]) {
1140       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1141       print_strings (r);
1142       return -1;
1143     }
1144     {
1145       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1146       if (strcmp (r[1], expected) != 0) {
1147         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1148         return -1;
1149       }
1150     }
1151     if (!r[2]) {
1152       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1153       print_strings (r);
1154       return -1;
1155     }
1156     {
1157       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1158       if (strcmp (r[2], expected) != 0) {
1159         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1160         return -1;
1161       }
1162     }
1163     if (r[3] != NULL) {
1164       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1165       print_strings (r);
1166       return -1;
1167     }
1168     for (i = 0; r[i] != NULL; ++i)
1169       free (r[i]);
1170     free (r);
1171   }
1172   return 0;
1173 }
1174
1175 static int test_head_n_1_skip (void)
1176 {
1177   const char *str;
1178
1179   str = getenv ("TEST_ONLY");
1180   if (str)
1181     return strstr (str, "head_n") == NULL;
1182   str = getenv ("SKIP_TEST_HEAD_N_1");
1183   if (str && strcmp (str, "1") == 0) return 1;
1184   str = getenv ("SKIP_TEST_HEAD_N");
1185   if (str && strcmp (str, "1") == 0) return 1;
1186   return 0;
1187 }
1188
1189 static int test_head_n_1 (void)
1190 {
1191   if (test_head_n_1_skip ()) {
1192     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1193     return 0;
1194   }
1195
1196   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1197   {
1198     char device[] = "/dev/sda";
1199     int r;
1200     suppress_error = 0;
1201     r = guestfs_blockdev_setrw (g, device);
1202     if (r == -1)
1203       return -1;
1204   }
1205   {
1206     int r;
1207     suppress_error = 0;
1208     r = guestfs_umount_all (g);
1209     if (r == -1)
1210       return -1;
1211   }
1212   {
1213     int r;
1214     suppress_error = 0;
1215     r = guestfs_lvm_remove_all (g);
1216     if (r == -1)
1217       return -1;
1218   }
1219   {
1220     char device[] = "/dev/sda";
1221     char lines_0[] = ",";
1222     char *lines[] = {
1223       lines_0,
1224       NULL
1225     };
1226     int r;
1227     suppress_error = 0;
1228     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1229     if (r == -1)
1230       return -1;
1231   }
1232   {
1233     char fstype[] = "ext2";
1234     char device[] = "/dev/sda1";
1235     int r;
1236     suppress_error = 0;
1237     r = guestfs_mkfs (g, fstype, device);
1238     if (r == -1)
1239       return -1;
1240   }
1241   {
1242     char device[] = "/dev/sda1";
1243     char mountpoint[] = "/";
1244     int r;
1245     suppress_error = 0;
1246     r = guestfs_mount (g, device, mountpoint);
1247     if (r == -1)
1248       return -1;
1249   }
1250   /* TestOutputList for head_n (1) */
1251   {
1252     char options[] = "ro";
1253     char vfstype[] = "squashfs";
1254     char device[] = "/dev/sdd";
1255     char mountpoint[] = "/";
1256     int r;
1257     suppress_error = 0;
1258     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1259     if (r == -1)
1260       return -1;
1261   }
1262   {
1263     char path[] = "/10klines";
1264     char **r;
1265     int i;
1266     suppress_error = 0;
1267     r = guestfs_head_n (g, -9997, path);
1268     if (r == NULL)
1269       return -1;
1270     if (!r[0]) {
1271       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1272       print_strings (r);
1273       return -1;
1274     }
1275     {
1276       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1277       if (strcmp (r[0], expected) != 0) {
1278         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1279         return -1;
1280       }
1281     }
1282     if (!r[1]) {
1283       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1284       print_strings (r);
1285       return -1;
1286     }
1287     {
1288       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1289       if (strcmp (r[1], expected) != 0) {
1290         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1291         return -1;
1292       }
1293     }
1294     if (!r[2]) {
1295       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1296       print_strings (r);
1297       return -1;
1298     }
1299     {
1300       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1301       if (strcmp (r[2], expected) != 0) {
1302         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1303         return -1;
1304       }
1305     }
1306     if (r[3] != NULL) {
1307       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1308       print_strings (r);
1309       return -1;
1310     }
1311     for (i = 0; r[i] != NULL; ++i)
1312       free (r[i]);
1313     free (r);
1314   }
1315   return 0;
1316 }
1317
1318 static int test_head_n_2_skip (void)
1319 {
1320   const char *str;
1321
1322   str = getenv ("TEST_ONLY");
1323   if (str)
1324     return strstr (str, "head_n") == NULL;
1325   str = getenv ("SKIP_TEST_HEAD_N_2");
1326   if (str && strcmp (str, "1") == 0) return 1;
1327   str = getenv ("SKIP_TEST_HEAD_N");
1328   if (str && strcmp (str, "1") == 0) return 1;
1329   return 0;
1330 }
1331
1332 static int test_head_n_2 (void)
1333 {
1334   if (test_head_n_2_skip ()) {
1335     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1336     return 0;
1337   }
1338
1339   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1340   {
1341     char device[] = "/dev/sda";
1342     int r;
1343     suppress_error = 0;
1344     r = guestfs_blockdev_setrw (g, device);
1345     if (r == -1)
1346       return -1;
1347   }
1348   {
1349     int r;
1350     suppress_error = 0;
1351     r = guestfs_umount_all (g);
1352     if (r == -1)
1353       return -1;
1354   }
1355   {
1356     int r;
1357     suppress_error = 0;
1358     r = guestfs_lvm_remove_all (g);
1359     if (r == -1)
1360       return -1;
1361   }
1362   {
1363     char device[] = "/dev/sda";
1364     char lines_0[] = ",";
1365     char *lines[] = {
1366       lines_0,
1367       NULL
1368     };
1369     int r;
1370     suppress_error = 0;
1371     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1372     if (r == -1)
1373       return -1;
1374   }
1375   {
1376     char fstype[] = "ext2";
1377     char device[] = "/dev/sda1";
1378     int r;
1379     suppress_error = 0;
1380     r = guestfs_mkfs (g, fstype, device);
1381     if (r == -1)
1382       return -1;
1383   }
1384   {
1385     char device[] = "/dev/sda1";
1386     char mountpoint[] = "/";
1387     int r;
1388     suppress_error = 0;
1389     r = guestfs_mount (g, device, mountpoint);
1390     if (r == -1)
1391       return -1;
1392   }
1393   /* TestOutputList for head_n (2) */
1394   {
1395     char options[] = "ro";
1396     char vfstype[] = "squashfs";
1397     char device[] = "/dev/sdd";
1398     char mountpoint[] = "/";
1399     int r;
1400     suppress_error = 0;
1401     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1402     if (r == -1)
1403       return -1;
1404   }
1405   {
1406     char path[] = "/10klines";
1407     char **r;
1408     int i;
1409     suppress_error = 0;
1410     r = guestfs_head_n (g, 0, path);
1411     if (r == NULL)
1412       return -1;
1413     if (r[0] != NULL) {
1414       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1415       print_strings (r);
1416       return -1;
1417     }
1418     for (i = 0; r[i] != NULL; ++i)
1419       free (r[i]);
1420     free (r);
1421   }
1422   return 0;
1423 }
1424
1425 static int test_head_0_skip (void)
1426 {
1427   const char *str;
1428
1429   str = getenv ("TEST_ONLY");
1430   if (str)
1431     return strstr (str, "head") == NULL;
1432   str = getenv ("SKIP_TEST_HEAD_0");
1433   if (str && strcmp (str, "1") == 0) return 1;
1434   str = getenv ("SKIP_TEST_HEAD");
1435   if (str && strcmp (str, "1") == 0) return 1;
1436   return 0;
1437 }
1438
1439 static int test_head_0 (void)
1440 {
1441   if (test_head_0_skip ()) {
1442     printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1443     return 0;
1444   }
1445
1446   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1447   {
1448     char device[] = "/dev/sda";
1449     int r;
1450     suppress_error = 0;
1451     r = guestfs_blockdev_setrw (g, device);
1452     if (r == -1)
1453       return -1;
1454   }
1455   {
1456     int r;
1457     suppress_error = 0;
1458     r = guestfs_umount_all (g);
1459     if (r == -1)
1460       return -1;
1461   }
1462   {
1463     int r;
1464     suppress_error = 0;
1465     r = guestfs_lvm_remove_all (g);
1466     if (r == -1)
1467       return -1;
1468   }
1469   {
1470     char device[] = "/dev/sda";
1471     char lines_0[] = ",";
1472     char *lines[] = {
1473       lines_0,
1474       NULL
1475     };
1476     int r;
1477     suppress_error = 0;
1478     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1479     if (r == -1)
1480       return -1;
1481   }
1482   {
1483     char fstype[] = "ext2";
1484     char device[] = "/dev/sda1";
1485     int r;
1486     suppress_error = 0;
1487     r = guestfs_mkfs (g, fstype, device);
1488     if (r == -1)
1489       return -1;
1490   }
1491   {
1492     char device[] = "/dev/sda1";
1493     char mountpoint[] = "/";
1494     int r;
1495     suppress_error = 0;
1496     r = guestfs_mount (g, device, mountpoint);
1497     if (r == -1)
1498       return -1;
1499   }
1500   /* TestOutputList for head (0) */
1501   {
1502     char options[] = "ro";
1503     char vfstype[] = "squashfs";
1504     char device[] = "/dev/sdd";
1505     char mountpoint[] = "/";
1506     int r;
1507     suppress_error = 0;
1508     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1509     if (r == -1)
1510       return -1;
1511   }
1512   {
1513     char path[] = "/10klines";
1514     char **r;
1515     int i;
1516     suppress_error = 0;
1517     r = guestfs_head (g, path);
1518     if (r == NULL)
1519       return -1;
1520     if (!r[0]) {
1521       fprintf (stderr, "test_head_0: short list returned from command\n");
1522       print_strings (r);
1523       return -1;
1524     }
1525     {
1526       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1527       if (strcmp (r[0], expected) != 0) {
1528         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1529         return -1;
1530       }
1531     }
1532     if (!r[1]) {
1533       fprintf (stderr, "test_head_0: short list returned from command\n");
1534       print_strings (r);
1535       return -1;
1536     }
1537     {
1538       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1539       if (strcmp (r[1], expected) != 0) {
1540         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1541         return -1;
1542       }
1543     }
1544     if (!r[2]) {
1545       fprintf (stderr, "test_head_0: short list returned from command\n");
1546       print_strings (r);
1547       return -1;
1548     }
1549     {
1550       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1551       if (strcmp (r[2], expected) != 0) {
1552         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1553         return -1;
1554       }
1555     }
1556     if (!r[3]) {
1557       fprintf (stderr, "test_head_0: short list returned from command\n");
1558       print_strings (r);
1559       return -1;
1560     }
1561     {
1562       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1563       if (strcmp (r[3], expected) != 0) {
1564         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1565         return -1;
1566       }
1567     }
1568     if (!r[4]) {
1569       fprintf (stderr, "test_head_0: short list returned from command\n");
1570       print_strings (r);
1571       return -1;
1572     }
1573     {
1574       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1575       if (strcmp (r[4], expected) != 0) {
1576         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1577         return -1;
1578       }
1579     }
1580     if (!r[5]) {
1581       fprintf (stderr, "test_head_0: short list returned from command\n");
1582       print_strings (r);
1583       return -1;
1584     }
1585     {
1586       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1587       if (strcmp (r[5], expected) != 0) {
1588         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1589         return -1;
1590       }
1591     }
1592     if (!r[6]) {
1593       fprintf (stderr, "test_head_0: short list returned from command\n");
1594       print_strings (r);
1595       return -1;
1596     }
1597     {
1598       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1599       if (strcmp (r[6], expected) != 0) {
1600         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1601         return -1;
1602       }
1603     }
1604     if (!r[7]) {
1605       fprintf (stderr, "test_head_0: short list returned from command\n");
1606       print_strings (r);
1607       return -1;
1608     }
1609     {
1610       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1611       if (strcmp (r[7], expected) != 0) {
1612         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1613         return -1;
1614       }
1615     }
1616     if (!r[8]) {
1617       fprintf (stderr, "test_head_0: short list returned from command\n");
1618       print_strings (r);
1619       return -1;
1620     }
1621     {
1622       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1623       if (strcmp (r[8], expected) != 0) {
1624         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1625         return -1;
1626       }
1627     }
1628     if (!r[9]) {
1629       fprintf (stderr, "test_head_0: short list returned from command\n");
1630       print_strings (r);
1631       return -1;
1632     }
1633     {
1634       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1635       if (strcmp (r[9], expected) != 0) {
1636         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1637         return -1;
1638       }
1639     }
1640     if (r[10] != NULL) {
1641       fprintf (stderr, "test_head_0: extra elements returned from command\n");
1642       print_strings (r);
1643       return -1;
1644     }
1645     for (i = 0; r[i] != NULL; ++i)
1646       free (r[i]);
1647     free (r);
1648   }
1649   return 0;
1650 }
1651
1652 static int test_wc_c_0_skip (void)
1653 {
1654   const char *str;
1655
1656   str = getenv ("TEST_ONLY");
1657   if (str)
1658     return strstr (str, "wc_c") == NULL;
1659   str = getenv ("SKIP_TEST_WC_C_0");
1660   if (str && strcmp (str, "1") == 0) return 1;
1661   str = getenv ("SKIP_TEST_WC_C");
1662   if (str && strcmp (str, "1") == 0) return 1;
1663   return 0;
1664 }
1665
1666 static int test_wc_c_0 (void)
1667 {
1668   if (test_wc_c_0_skip ()) {
1669     printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1670     return 0;
1671   }
1672
1673   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1674   {
1675     char device[] = "/dev/sda";
1676     int r;
1677     suppress_error = 0;
1678     r = guestfs_blockdev_setrw (g, device);
1679     if (r == -1)
1680       return -1;
1681   }
1682   {
1683     int r;
1684     suppress_error = 0;
1685     r = guestfs_umount_all (g);
1686     if (r == -1)
1687       return -1;
1688   }
1689   {
1690     int r;
1691     suppress_error = 0;
1692     r = guestfs_lvm_remove_all (g);
1693     if (r == -1)
1694       return -1;
1695   }
1696   {
1697     char device[] = "/dev/sda";
1698     char lines_0[] = ",";
1699     char *lines[] = {
1700       lines_0,
1701       NULL
1702     };
1703     int r;
1704     suppress_error = 0;
1705     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1706     if (r == -1)
1707       return -1;
1708   }
1709   {
1710     char fstype[] = "ext2";
1711     char device[] = "/dev/sda1";
1712     int r;
1713     suppress_error = 0;
1714     r = guestfs_mkfs (g, fstype, device);
1715     if (r == -1)
1716       return -1;
1717   }
1718   {
1719     char device[] = "/dev/sda1";
1720     char mountpoint[] = "/";
1721     int r;
1722     suppress_error = 0;
1723     r = guestfs_mount (g, device, mountpoint);
1724     if (r == -1)
1725       return -1;
1726   }
1727   /* TestOutputInt for wc_c (0) */
1728   {
1729     char options[] = "ro";
1730     char vfstype[] = "squashfs";
1731     char device[] = "/dev/sdd";
1732     char mountpoint[] = "/";
1733     int r;
1734     suppress_error = 0;
1735     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1736     if (r == -1)
1737       return -1;
1738   }
1739   {
1740     char path[] = "/100kallspaces";
1741     int r;
1742     suppress_error = 0;
1743     r = guestfs_wc_c (g, path);
1744     if (r == -1)
1745       return -1;
1746     if (r != 102400) {
1747       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
1748       return -1;
1749     }
1750   }
1751   return 0;
1752 }
1753
1754 static int test_wc_w_0_skip (void)
1755 {
1756   const char *str;
1757
1758   str = getenv ("TEST_ONLY");
1759   if (str)
1760     return strstr (str, "wc_w") == NULL;
1761   str = getenv ("SKIP_TEST_WC_W_0");
1762   if (str && strcmp (str, "1") == 0) return 1;
1763   str = getenv ("SKIP_TEST_WC_W");
1764   if (str && strcmp (str, "1") == 0) return 1;
1765   return 0;
1766 }
1767
1768 static int test_wc_w_0 (void)
1769 {
1770   if (test_wc_w_0_skip ()) {
1771     printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1772     return 0;
1773   }
1774
1775   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1776   {
1777     char device[] = "/dev/sda";
1778     int r;
1779     suppress_error = 0;
1780     r = guestfs_blockdev_setrw (g, device);
1781     if (r == -1)
1782       return -1;
1783   }
1784   {
1785     int r;
1786     suppress_error = 0;
1787     r = guestfs_umount_all (g);
1788     if (r == -1)
1789       return -1;
1790   }
1791   {
1792     int r;
1793     suppress_error = 0;
1794     r = guestfs_lvm_remove_all (g);
1795     if (r == -1)
1796       return -1;
1797   }
1798   {
1799     char device[] = "/dev/sda";
1800     char lines_0[] = ",";
1801     char *lines[] = {
1802       lines_0,
1803       NULL
1804     };
1805     int r;
1806     suppress_error = 0;
1807     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1808     if (r == -1)
1809       return -1;
1810   }
1811   {
1812     char fstype[] = "ext2";
1813     char device[] = "/dev/sda1";
1814     int r;
1815     suppress_error = 0;
1816     r = guestfs_mkfs (g, fstype, device);
1817     if (r == -1)
1818       return -1;
1819   }
1820   {
1821     char device[] = "/dev/sda1";
1822     char mountpoint[] = "/";
1823     int r;
1824     suppress_error = 0;
1825     r = guestfs_mount (g, device, mountpoint);
1826     if (r == -1)
1827       return -1;
1828   }
1829   /* TestOutputInt for wc_w (0) */
1830   {
1831     char options[] = "ro";
1832     char vfstype[] = "squashfs";
1833     char device[] = "/dev/sdd";
1834     char mountpoint[] = "/";
1835     int r;
1836     suppress_error = 0;
1837     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1838     if (r == -1)
1839       return -1;
1840   }
1841   {
1842     char path[] = "/10klines";
1843     int r;
1844     suppress_error = 0;
1845     r = guestfs_wc_w (g, path);
1846     if (r == -1)
1847       return -1;
1848     if (r != 10000) {
1849       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
1850       return -1;
1851     }
1852   }
1853   return 0;
1854 }
1855
1856 static int test_wc_l_0_skip (void)
1857 {
1858   const char *str;
1859
1860   str = getenv ("TEST_ONLY");
1861   if (str)
1862     return strstr (str, "wc_l") == NULL;
1863   str = getenv ("SKIP_TEST_WC_L_0");
1864   if (str && strcmp (str, "1") == 0) return 1;
1865   str = getenv ("SKIP_TEST_WC_L");
1866   if (str && strcmp (str, "1") == 0) return 1;
1867   return 0;
1868 }
1869
1870 static int test_wc_l_0 (void)
1871 {
1872   if (test_wc_l_0_skip ()) {
1873     printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
1874     return 0;
1875   }
1876
1877   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
1878   {
1879     char device[] = "/dev/sda";
1880     int r;
1881     suppress_error = 0;
1882     r = guestfs_blockdev_setrw (g, device);
1883     if (r == -1)
1884       return -1;
1885   }
1886   {
1887     int r;
1888     suppress_error = 0;
1889     r = guestfs_umount_all (g);
1890     if (r == -1)
1891       return -1;
1892   }
1893   {
1894     int r;
1895     suppress_error = 0;
1896     r = guestfs_lvm_remove_all (g);
1897     if (r == -1)
1898       return -1;
1899   }
1900   {
1901     char device[] = "/dev/sda";
1902     char lines_0[] = ",";
1903     char *lines[] = {
1904       lines_0,
1905       NULL
1906     };
1907     int r;
1908     suppress_error = 0;
1909     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1910     if (r == -1)
1911       return -1;
1912   }
1913   {
1914     char fstype[] = "ext2";
1915     char device[] = "/dev/sda1";
1916     int r;
1917     suppress_error = 0;
1918     r = guestfs_mkfs (g, fstype, device);
1919     if (r == -1)
1920       return -1;
1921   }
1922   {
1923     char device[] = "/dev/sda1";
1924     char mountpoint[] = "/";
1925     int r;
1926     suppress_error = 0;
1927     r = guestfs_mount (g, device, mountpoint);
1928     if (r == -1)
1929       return -1;
1930   }
1931   /* TestOutputInt for wc_l (0) */
1932   {
1933     char options[] = "ro";
1934     char vfstype[] = "squashfs";
1935     char device[] = "/dev/sdd";
1936     char mountpoint[] = "/";
1937     int r;
1938     suppress_error = 0;
1939     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1940     if (r == -1)
1941       return -1;
1942   }
1943   {
1944     char path[] = "/10klines";
1945     int r;
1946     suppress_error = 0;
1947     r = guestfs_wc_l (g, path);
1948     if (r == -1)
1949       return -1;
1950     if (r != 10000) {
1951       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
1952       return -1;
1953     }
1954   }
1955   return 0;
1956 }
1957
1958 static int test_mkdtemp_0_skip (void)
1959 {
1960   const char *str;
1961
1962   str = getenv ("TEST_ONLY");
1963   if (str)
1964     return strstr (str, "mkdtemp") == NULL;
1965   str = getenv ("SKIP_TEST_MKDTEMP_0");
1966   if (str && strcmp (str, "1") == 0) return 1;
1967   str = getenv ("SKIP_TEST_MKDTEMP");
1968   if (str && strcmp (str, "1") == 0) return 1;
1969   return 0;
1970 }
1971
1972 static int test_mkdtemp_0 (void)
1973 {
1974   if (test_mkdtemp_0_skip ()) {
1975     printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
1976     return 0;
1977   }
1978
1979   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
1980   {
1981     char device[] = "/dev/sda";
1982     int r;
1983     suppress_error = 0;
1984     r = guestfs_blockdev_setrw (g, device);
1985     if (r == -1)
1986       return -1;
1987   }
1988   {
1989     int r;
1990     suppress_error = 0;
1991     r = guestfs_umount_all (g);
1992     if (r == -1)
1993       return -1;
1994   }
1995   {
1996     int r;
1997     suppress_error = 0;
1998     r = guestfs_lvm_remove_all (g);
1999     if (r == -1)
2000       return -1;
2001   }
2002   {
2003     char device[] = "/dev/sda";
2004     char lines_0[] = ",";
2005     char *lines[] = {
2006       lines_0,
2007       NULL
2008     };
2009     int r;
2010     suppress_error = 0;
2011     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2012     if (r == -1)
2013       return -1;
2014   }
2015   {
2016     char fstype[] = "ext2";
2017     char device[] = "/dev/sda1";
2018     int r;
2019     suppress_error = 0;
2020     r = guestfs_mkfs (g, fstype, device);
2021     if (r == -1)
2022       return -1;
2023   }
2024   {
2025     char device[] = "/dev/sda1";
2026     char mountpoint[] = "/";
2027     int r;
2028     suppress_error = 0;
2029     r = guestfs_mount (g, device, mountpoint);
2030     if (r == -1)
2031       return -1;
2032   }
2033   /* TestRun for mkdtemp (0) */
2034   {
2035     char path[] = "/tmp";
2036     int r;
2037     suppress_error = 0;
2038     r = guestfs_mkdir (g, path);
2039     if (r == -1)
2040       return -1;
2041   }
2042   {
2043     char template[] = "/tmp/tmpXXXXXX";
2044     char *r;
2045     suppress_error = 0;
2046     r = guestfs_mkdtemp (g, template);
2047     if (r == NULL)
2048       return -1;
2049     free (r);
2050   }
2051   return 0;
2052 }
2053
2054 static int test_scrub_file_0_skip (void)
2055 {
2056   const char *str;
2057
2058   str = getenv ("TEST_ONLY");
2059   if (str)
2060     return strstr (str, "scrub_file") == NULL;
2061   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2062   if (str && strcmp (str, "1") == 0) return 1;
2063   str = getenv ("SKIP_TEST_SCRUB_FILE");
2064   if (str && strcmp (str, "1") == 0) return 1;
2065   return 0;
2066 }
2067
2068 static int test_scrub_file_0 (void)
2069 {
2070   if (test_scrub_file_0_skip ()) {
2071     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2072     return 0;
2073   }
2074
2075   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2076   {
2077     char device[] = "/dev/sda";
2078     int r;
2079     suppress_error = 0;
2080     r = guestfs_blockdev_setrw (g, device);
2081     if (r == -1)
2082       return -1;
2083   }
2084   {
2085     int r;
2086     suppress_error = 0;
2087     r = guestfs_umount_all (g);
2088     if (r == -1)
2089       return -1;
2090   }
2091   {
2092     int r;
2093     suppress_error = 0;
2094     r = guestfs_lvm_remove_all (g);
2095     if (r == -1)
2096       return -1;
2097   }
2098   {
2099     char device[] = "/dev/sda";
2100     char lines_0[] = ",";
2101     char *lines[] = {
2102       lines_0,
2103       NULL
2104     };
2105     int r;
2106     suppress_error = 0;
2107     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2108     if (r == -1)
2109       return -1;
2110   }
2111   {
2112     char fstype[] = "ext2";
2113     char device[] = "/dev/sda1";
2114     int r;
2115     suppress_error = 0;
2116     r = guestfs_mkfs (g, fstype, device);
2117     if (r == -1)
2118       return -1;
2119   }
2120   {
2121     char device[] = "/dev/sda1";
2122     char mountpoint[] = "/";
2123     int r;
2124     suppress_error = 0;
2125     r = guestfs_mount (g, device, mountpoint);
2126     if (r == -1)
2127       return -1;
2128   }
2129   /* TestRun for scrub_file (0) */
2130   {
2131     char path[] = "/file";
2132     char content[] = "content";
2133     int r;
2134     suppress_error = 0;
2135     r = guestfs_write_file (g, path, content, 0);
2136     if (r == -1)
2137       return -1;
2138   }
2139   {
2140     char file[] = "/file";
2141     int r;
2142     suppress_error = 0;
2143     r = guestfs_scrub_file (g, file);
2144     if (r == -1)
2145       return -1;
2146   }
2147   return 0;
2148 }
2149
2150 static int test_scrub_device_0_skip (void)
2151 {
2152   const char *str;
2153
2154   str = getenv ("TEST_ONLY");
2155   if (str)
2156     return strstr (str, "scrub_device") == NULL;
2157   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2158   if (str && strcmp (str, "1") == 0) return 1;
2159   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2160   if (str && strcmp (str, "1") == 0) return 1;
2161   return 0;
2162 }
2163
2164 static int test_scrub_device_0 (void)
2165 {
2166   if (test_scrub_device_0_skip ()) {
2167     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2168     return 0;
2169   }
2170
2171   /* InitNone|InitEmpty for test_scrub_device_0 */
2172   {
2173     char device[] = "/dev/sda";
2174     int r;
2175     suppress_error = 0;
2176     r = guestfs_blockdev_setrw (g, device);
2177     if (r == -1)
2178       return -1;
2179   }
2180   {
2181     int r;
2182     suppress_error = 0;
2183     r = guestfs_umount_all (g);
2184     if (r == -1)
2185       return -1;
2186   }
2187   {
2188     int r;
2189     suppress_error = 0;
2190     r = guestfs_lvm_remove_all (g);
2191     if (r == -1)
2192       return -1;
2193   }
2194   /* TestRun for scrub_device (0) */
2195   {
2196     char device[] = "/dev/sdc";
2197     int r;
2198     suppress_error = 0;
2199     r = guestfs_scrub_device (g, device);
2200     if (r == -1)
2201       return -1;
2202   }
2203   return 0;
2204 }
2205
2206 static int test_glob_expand_0_skip (void)
2207 {
2208   const char *str;
2209
2210   str = getenv ("TEST_ONLY");
2211   if (str)
2212     return strstr (str, "glob_expand") == NULL;
2213   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2214   if (str && strcmp (str, "1") == 0) return 1;
2215   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2216   if (str && strcmp (str, "1") == 0) return 1;
2217   return 0;
2218 }
2219
2220 static int test_glob_expand_0 (void)
2221 {
2222   if (test_glob_expand_0_skip ()) {
2223     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2224     return 0;
2225   }
2226
2227   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2228   {
2229     char device[] = "/dev/sda";
2230     int r;
2231     suppress_error = 0;
2232     r = guestfs_blockdev_setrw (g, device);
2233     if (r == -1)
2234       return -1;
2235   }
2236   {
2237     int r;
2238     suppress_error = 0;
2239     r = guestfs_umount_all (g);
2240     if (r == -1)
2241       return -1;
2242   }
2243   {
2244     int r;
2245     suppress_error = 0;
2246     r = guestfs_lvm_remove_all (g);
2247     if (r == -1)
2248       return -1;
2249   }
2250   {
2251     char device[] = "/dev/sda";
2252     char lines_0[] = ",";
2253     char *lines[] = {
2254       lines_0,
2255       NULL
2256     };
2257     int r;
2258     suppress_error = 0;
2259     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2260     if (r == -1)
2261       return -1;
2262   }
2263   {
2264     char fstype[] = "ext2";
2265     char device[] = "/dev/sda1";
2266     int r;
2267     suppress_error = 0;
2268     r = guestfs_mkfs (g, fstype, device);
2269     if (r == -1)
2270       return -1;
2271   }
2272   {
2273     char device[] = "/dev/sda1";
2274     char mountpoint[] = "/";
2275     int r;
2276     suppress_error = 0;
2277     r = guestfs_mount (g, device, mountpoint);
2278     if (r == -1)
2279       return -1;
2280   }
2281   /* TestOutputList for glob_expand (0) */
2282   {
2283     char path[] = "/a/b/c";
2284     int r;
2285     suppress_error = 0;
2286     r = guestfs_mkdir_p (g, path);
2287     if (r == -1)
2288       return -1;
2289   }
2290   {
2291     char path[] = "/a/b/c/d";
2292     int r;
2293     suppress_error = 0;
2294     r = guestfs_touch (g, path);
2295     if (r == -1)
2296       return -1;
2297   }
2298   {
2299     char path[] = "/a/b/c/e";
2300     int r;
2301     suppress_error = 0;
2302     r = guestfs_touch (g, path);
2303     if (r == -1)
2304       return -1;
2305   }
2306   {
2307     char pattern[] = "/a/b/c/*";
2308     char **r;
2309     int i;
2310     suppress_error = 0;
2311     r = guestfs_glob_expand (g, pattern);
2312     if (r == NULL)
2313       return -1;
2314     if (!r[0]) {
2315       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2316       print_strings (r);
2317       return -1;
2318     }
2319     {
2320       char expected[] = "/a/b/c/d";
2321       if (strcmp (r[0], expected) != 0) {
2322         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2323         return -1;
2324       }
2325     }
2326     if (!r[1]) {
2327       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2328       print_strings (r);
2329       return -1;
2330     }
2331     {
2332       char expected[] = "/a/b/c/e";
2333       if (strcmp (r[1], expected) != 0) {
2334         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2335         return -1;
2336       }
2337     }
2338     if (r[2] != NULL) {
2339       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2340       print_strings (r);
2341       return -1;
2342     }
2343     for (i = 0; r[i] != NULL; ++i)
2344       free (r[i]);
2345     free (r);
2346   }
2347   return 0;
2348 }
2349
2350 static int test_glob_expand_1_skip (void)
2351 {
2352   const char *str;
2353
2354   str = getenv ("TEST_ONLY");
2355   if (str)
2356     return strstr (str, "glob_expand") == NULL;
2357   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2358   if (str && strcmp (str, "1") == 0) return 1;
2359   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2360   if (str && strcmp (str, "1") == 0) return 1;
2361   return 0;
2362 }
2363
2364 static int test_glob_expand_1 (void)
2365 {
2366   if (test_glob_expand_1_skip ()) {
2367     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2368     return 0;
2369   }
2370
2371   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2372   {
2373     char device[] = "/dev/sda";
2374     int r;
2375     suppress_error = 0;
2376     r = guestfs_blockdev_setrw (g, device);
2377     if (r == -1)
2378       return -1;
2379   }
2380   {
2381     int r;
2382     suppress_error = 0;
2383     r = guestfs_umount_all (g);
2384     if (r == -1)
2385       return -1;
2386   }
2387   {
2388     int r;
2389     suppress_error = 0;
2390     r = guestfs_lvm_remove_all (g);
2391     if (r == -1)
2392       return -1;
2393   }
2394   {
2395     char device[] = "/dev/sda";
2396     char lines_0[] = ",";
2397     char *lines[] = {
2398       lines_0,
2399       NULL
2400     };
2401     int r;
2402     suppress_error = 0;
2403     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2404     if (r == -1)
2405       return -1;
2406   }
2407   {
2408     char fstype[] = "ext2";
2409     char device[] = "/dev/sda1";
2410     int r;
2411     suppress_error = 0;
2412     r = guestfs_mkfs (g, fstype, device);
2413     if (r == -1)
2414       return -1;
2415   }
2416   {
2417     char device[] = "/dev/sda1";
2418     char mountpoint[] = "/";
2419     int r;
2420     suppress_error = 0;
2421     r = guestfs_mount (g, device, mountpoint);
2422     if (r == -1)
2423       return -1;
2424   }
2425   /* TestOutputList for glob_expand (1) */
2426   {
2427     char path[] = "/a/b/c";
2428     int r;
2429     suppress_error = 0;
2430     r = guestfs_mkdir_p (g, path);
2431     if (r == -1)
2432       return -1;
2433   }
2434   {
2435     char path[] = "/a/b/c/d";
2436     int r;
2437     suppress_error = 0;
2438     r = guestfs_touch (g, path);
2439     if (r == -1)
2440       return -1;
2441   }
2442   {
2443     char path[] = "/a/b/c/e";
2444     int r;
2445     suppress_error = 0;
2446     r = guestfs_touch (g, path);
2447     if (r == -1)
2448       return -1;
2449   }
2450   {
2451     char pattern[] = "/a/*/c/*";
2452     char **r;
2453     int i;
2454     suppress_error = 0;
2455     r = guestfs_glob_expand (g, pattern);
2456     if (r == NULL)
2457       return -1;
2458     if (!r[0]) {
2459       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2460       print_strings (r);
2461       return -1;
2462     }
2463     {
2464       char expected[] = "/a/b/c/d";
2465       if (strcmp (r[0], expected) != 0) {
2466         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2467         return -1;
2468       }
2469     }
2470     if (!r[1]) {
2471       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2472       print_strings (r);
2473       return -1;
2474     }
2475     {
2476       char expected[] = "/a/b/c/e";
2477       if (strcmp (r[1], expected) != 0) {
2478         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2479         return -1;
2480       }
2481     }
2482     if (r[2] != NULL) {
2483       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2484       print_strings (r);
2485       return -1;
2486     }
2487     for (i = 0; r[i] != NULL; ++i)
2488       free (r[i]);
2489     free (r);
2490   }
2491   return 0;
2492 }
2493
2494 static int test_glob_expand_2_skip (void)
2495 {
2496   const char *str;
2497
2498   str = getenv ("TEST_ONLY");
2499   if (str)
2500     return strstr (str, "glob_expand") == NULL;
2501   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2502   if (str && strcmp (str, "1") == 0) return 1;
2503   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2504   if (str && strcmp (str, "1") == 0) return 1;
2505   return 0;
2506 }
2507
2508 static int test_glob_expand_2 (void)
2509 {
2510   if (test_glob_expand_2_skip ()) {
2511     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2512     return 0;
2513   }
2514
2515   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2516   {
2517     char device[] = "/dev/sda";
2518     int r;
2519     suppress_error = 0;
2520     r = guestfs_blockdev_setrw (g, device);
2521     if (r == -1)
2522       return -1;
2523   }
2524   {
2525     int r;
2526     suppress_error = 0;
2527     r = guestfs_umount_all (g);
2528     if (r == -1)
2529       return -1;
2530   }
2531   {
2532     int r;
2533     suppress_error = 0;
2534     r = guestfs_lvm_remove_all (g);
2535     if (r == -1)
2536       return -1;
2537   }
2538   {
2539     char device[] = "/dev/sda";
2540     char lines_0[] = ",";
2541     char *lines[] = {
2542       lines_0,
2543       NULL
2544     };
2545     int r;
2546     suppress_error = 0;
2547     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2548     if (r == -1)
2549       return -1;
2550   }
2551   {
2552     char fstype[] = "ext2";
2553     char device[] = "/dev/sda1";
2554     int r;
2555     suppress_error = 0;
2556     r = guestfs_mkfs (g, fstype, device);
2557     if (r == -1)
2558       return -1;
2559   }
2560   {
2561     char device[] = "/dev/sda1";
2562     char mountpoint[] = "/";
2563     int r;
2564     suppress_error = 0;
2565     r = guestfs_mount (g, device, mountpoint);
2566     if (r == -1)
2567       return -1;
2568   }
2569   /* TestOutputList for glob_expand (2) */
2570   {
2571     char path[] = "/a/b/c";
2572     int r;
2573     suppress_error = 0;
2574     r = guestfs_mkdir_p (g, path);
2575     if (r == -1)
2576       return -1;
2577   }
2578   {
2579     char path[] = "/a/b/c/d";
2580     int r;
2581     suppress_error = 0;
2582     r = guestfs_touch (g, path);
2583     if (r == -1)
2584       return -1;
2585   }
2586   {
2587     char path[] = "/a/b/c/e";
2588     int r;
2589     suppress_error = 0;
2590     r = guestfs_touch (g, path);
2591     if (r == -1)
2592       return -1;
2593   }
2594   {
2595     char pattern[] = "/a/*/x/*";
2596     char **r;
2597     int i;
2598     suppress_error = 0;
2599     r = guestfs_glob_expand (g, pattern);
2600     if (r == NULL)
2601       return -1;
2602     if (r[0] != NULL) {
2603       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2604       print_strings (r);
2605       return -1;
2606     }
2607     for (i = 0; r[i] != NULL; ++i)
2608       free (r[i]);
2609     free (r);
2610   }
2611   return 0;
2612 }
2613
2614 static int test_ntfs_3g_probe_0_skip (void)
2615 {
2616   const char *str;
2617
2618   str = getenv ("TEST_ONLY");
2619   if (str)
2620     return strstr (str, "ntfs_3g_probe") == NULL;
2621   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2622   if (str && strcmp (str, "1") == 0) return 1;
2623   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2624   if (str && strcmp (str, "1") == 0) return 1;
2625   return 0;
2626 }
2627
2628 static int test_ntfs_3g_probe_0 (void)
2629 {
2630   if (test_ntfs_3g_probe_0_skip ()) {
2631     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2632     return 0;
2633   }
2634
2635   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2636   {
2637     char device[] = "/dev/sda";
2638     int r;
2639     suppress_error = 0;
2640     r = guestfs_blockdev_setrw (g, device);
2641     if (r == -1)
2642       return -1;
2643   }
2644   {
2645     int r;
2646     suppress_error = 0;
2647     r = guestfs_umount_all (g);
2648     if (r == -1)
2649       return -1;
2650   }
2651   {
2652     int r;
2653     suppress_error = 0;
2654     r = guestfs_lvm_remove_all (g);
2655     if (r == -1)
2656       return -1;
2657   }
2658   /* TestOutputInt for ntfs_3g_probe (0) */
2659   {
2660     char device[] = "/dev/sda";
2661     char lines_0[] = ",";
2662     char *lines[] = {
2663       lines_0,
2664       NULL
2665     };
2666     int r;
2667     suppress_error = 0;
2668     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2669     if (r == -1)
2670       return -1;
2671   }
2672   {
2673     char fstype[] = "ntfs";
2674     char device[] = "/dev/sda1";
2675     int r;
2676     suppress_error = 0;
2677     r = guestfs_mkfs (g, fstype, device);
2678     if (r == -1)
2679       return -1;
2680   }
2681   {
2682     char device[] = "/dev/sda1";
2683     int r;
2684     suppress_error = 0;
2685     r = guestfs_ntfs_3g_probe (g, 1, device);
2686     if (r == -1)
2687       return -1;
2688     if (r != 0) {
2689       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
2690       return -1;
2691     }
2692   }
2693   return 0;
2694 }
2695
2696 static int test_ntfs_3g_probe_1_skip (void)
2697 {
2698   const char *str;
2699
2700   str = getenv ("TEST_ONLY");
2701   if (str)
2702     return strstr (str, "ntfs_3g_probe") == NULL;
2703   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2704   if (str && strcmp (str, "1") == 0) return 1;
2705   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2706   if (str && strcmp (str, "1") == 0) return 1;
2707   return 0;
2708 }
2709
2710 static int test_ntfs_3g_probe_1 (void)
2711 {
2712   if (test_ntfs_3g_probe_1_skip ()) {
2713     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2714     return 0;
2715   }
2716
2717   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2718   {
2719     char device[] = "/dev/sda";
2720     int r;
2721     suppress_error = 0;
2722     r = guestfs_blockdev_setrw (g, device);
2723     if (r == -1)
2724       return -1;
2725   }
2726   {
2727     int r;
2728     suppress_error = 0;
2729     r = guestfs_umount_all (g);
2730     if (r == -1)
2731       return -1;
2732   }
2733   {
2734     int r;
2735     suppress_error = 0;
2736     r = guestfs_lvm_remove_all (g);
2737     if (r == -1)
2738       return -1;
2739   }
2740   /* TestOutputInt for ntfs_3g_probe (1) */
2741   {
2742     char device[] = "/dev/sda";
2743     char lines_0[] = ",";
2744     char *lines[] = {
2745       lines_0,
2746       NULL
2747     };
2748     int r;
2749     suppress_error = 0;
2750     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2751     if (r == -1)
2752       return -1;
2753   }
2754   {
2755     char fstype[] = "ext2";
2756     char device[] = "/dev/sda1";
2757     int r;
2758     suppress_error = 0;
2759     r = guestfs_mkfs (g, fstype, device);
2760     if (r == -1)
2761       return -1;
2762   }
2763   {
2764     char device[] = "/dev/sda1";
2765     int r;
2766     suppress_error = 0;
2767     r = guestfs_ntfs_3g_probe (g, 1, device);
2768     if (r == -1)
2769       return -1;
2770     if (r != 12) {
2771       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
2772       return -1;
2773     }
2774   }
2775   return 0;
2776 }
2777
2778 static int test_sleep_0_skip (void)
2779 {
2780   const char *str;
2781
2782   str = getenv ("TEST_ONLY");
2783   if (str)
2784     return strstr (str, "sleep") == NULL;
2785   str = getenv ("SKIP_TEST_SLEEP_0");
2786   if (str && strcmp (str, "1") == 0) return 1;
2787   str = getenv ("SKIP_TEST_SLEEP");
2788   if (str && strcmp (str, "1") == 0) return 1;
2789   return 0;
2790 }
2791
2792 static int test_sleep_0 (void)
2793 {
2794   if (test_sleep_0_skip ()) {
2795     printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
2796     return 0;
2797   }
2798
2799   /* InitNone|InitEmpty for test_sleep_0 */
2800   {
2801     char device[] = "/dev/sda";
2802     int r;
2803     suppress_error = 0;
2804     r = guestfs_blockdev_setrw (g, device);
2805     if (r == -1)
2806       return -1;
2807   }
2808   {
2809     int r;
2810     suppress_error = 0;
2811     r = guestfs_umount_all (g);
2812     if (r == -1)
2813       return -1;
2814   }
2815   {
2816     int r;
2817     suppress_error = 0;
2818     r = guestfs_lvm_remove_all (g);
2819     if (r == -1)
2820       return -1;
2821   }
2822   /* TestRun for sleep (0) */
2823   {
2824     int r;
2825     suppress_error = 0;
2826     r = guestfs_sleep (g, 1);
2827     if (r == -1)
2828       return -1;
2829   }
2830   return 0;
2831 }
2832
2833 static int test_find_0_skip (void)
2834 {
2835   const char *str;
2836
2837   str = getenv ("TEST_ONLY");
2838   if (str)
2839     return strstr (str, "find") == NULL;
2840   str = getenv ("SKIP_TEST_FIND_0");
2841   if (str && strcmp (str, "1") == 0) return 1;
2842   str = getenv ("SKIP_TEST_FIND");
2843   if (str && strcmp (str, "1") == 0) return 1;
2844   return 0;
2845 }
2846
2847 static int test_find_0 (void)
2848 {
2849   if (test_find_0_skip ()) {
2850     printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
2851     return 0;
2852   }
2853
2854   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
2855   {
2856     char device[] = "/dev/sda";
2857     int r;
2858     suppress_error = 0;
2859     r = guestfs_blockdev_setrw (g, device);
2860     if (r == -1)
2861       return -1;
2862   }
2863   {
2864     int r;
2865     suppress_error = 0;
2866     r = guestfs_umount_all (g);
2867     if (r == -1)
2868       return -1;
2869   }
2870   {
2871     int r;
2872     suppress_error = 0;
2873     r = guestfs_lvm_remove_all (g);
2874     if (r == -1)
2875       return -1;
2876   }
2877   {
2878     char device[] = "/dev/sda";
2879     char lines_0[] = ",";
2880     char *lines[] = {
2881       lines_0,
2882       NULL
2883     };
2884     int r;
2885     suppress_error = 0;
2886     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2887     if (r == -1)
2888       return -1;
2889   }
2890   {
2891     char fstype[] = "ext2";
2892     char device[] = "/dev/sda1";
2893     int r;
2894     suppress_error = 0;
2895     r = guestfs_mkfs (g, fstype, device);
2896     if (r == -1)
2897       return -1;
2898   }
2899   {
2900     char device[] = "/dev/sda1";
2901     char mountpoint[] = "/";
2902     int r;
2903     suppress_error = 0;
2904     r = guestfs_mount (g, device, mountpoint);
2905     if (r == -1)
2906       return -1;
2907   }
2908   /* TestOutputList for find (0) */
2909   {
2910     char directory[] = "/";
2911     char **r;
2912     int i;
2913     suppress_error = 0;
2914     r = guestfs_find (g, directory);
2915     if (r == NULL)
2916       return -1;
2917     if (!r[0]) {
2918       fprintf (stderr, "test_find_0: short list returned from command\n");
2919       print_strings (r);
2920       return -1;
2921     }
2922     {
2923       char expected[] = "lost+found";
2924       if (strcmp (r[0], expected) != 0) {
2925         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2926         return -1;
2927       }
2928     }
2929     if (r[1] != NULL) {
2930       fprintf (stderr, "test_find_0: extra elements returned from command\n");
2931       print_strings (r);
2932       return -1;
2933     }
2934     for (i = 0; r[i] != NULL; ++i)
2935       free (r[i]);
2936     free (r);
2937   }
2938   return 0;
2939 }
2940
2941 static int test_find_1_skip (void)
2942 {
2943   const char *str;
2944
2945   str = getenv ("TEST_ONLY");
2946   if (str)
2947     return strstr (str, "find") == NULL;
2948   str = getenv ("SKIP_TEST_FIND_1");
2949   if (str && strcmp (str, "1") == 0) return 1;
2950   str = getenv ("SKIP_TEST_FIND");
2951   if (str && strcmp (str, "1") == 0) return 1;
2952   return 0;
2953 }
2954
2955 static int test_find_1 (void)
2956 {
2957   if (test_find_1_skip ()) {
2958     printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
2959     return 0;
2960   }
2961
2962   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
2963   {
2964     char device[] = "/dev/sda";
2965     int r;
2966     suppress_error = 0;
2967     r = guestfs_blockdev_setrw (g, device);
2968     if (r == -1)
2969       return -1;
2970   }
2971   {
2972     int r;
2973     suppress_error = 0;
2974     r = guestfs_umount_all (g);
2975     if (r == -1)
2976       return -1;
2977   }
2978   {
2979     int r;
2980     suppress_error = 0;
2981     r = guestfs_lvm_remove_all (g);
2982     if (r == -1)
2983       return -1;
2984   }
2985   {
2986     char device[] = "/dev/sda";
2987     char lines_0[] = ",";
2988     char *lines[] = {
2989       lines_0,
2990       NULL
2991     };
2992     int r;
2993     suppress_error = 0;
2994     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2995     if (r == -1)
2996       return -1;
2997   }
2998   {
2999     char fstype[] = "ext2";
3000     char device[] = "/dev/sda1";
3001     int r;
3002     suppress_error = 0;
3003     r = guestfs_mkfs (g, fstype, device);
3004     if (r == -1)
3005       return -1;
3006   }
3007   {
3008     char device[] = "/dev/sda1";
3009     char mountpoint[] = "/";
3010     int r;
3011     suppress_error = 0;
3012     r = guestfs_mount (g, device, mountpoint);
3013     if (r == -1)
3014       return -1;
3015   }
3016   /* TestOutputList for find (1) */
3017   {
3018     char path[] = "/a";
3019     int r;
3020     suppress_error = 0;
3021     r = guestfs_touch (g, path);
3022     if (r == -1)
3023       return -1;
3024   }
3025   {
3026     char path[] = "/b";
3027     int r;
3028     suppress_error = 0;
3029     r = guestfs_mkdir (g, path);
3030     if (r == -1)
3031       return -1;
3032   }
3033   {
3034     char path[] = "/b/c";
3035     int r;
3036     suppress_error = 0;
3037     r = guestfs_touch (g, path);
3038     if (r == -1)
3039       return -1;
3040   }
3041   {
3042     char directory[] = "/";
3043     char **r;
3044     int i;
3045     suppress_error = 0;
3046     r = guestfs_find (g, directory);
3047     if (r == NULL)
3048       return -1;
3049     if (!r[0]) {
3050       fprintf (stderr, "test_find_1: short list returned from command\n");
3051       print_strings (r);
3052       return -1;
3053     }
3054     {
3055       char expected[] = "a";
3056       if (strcmp (r[0], expected) != 0) {
3057         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3058         return -1;
3059       }
3060     }
3061     if (!r[1]) {
3062       fprintf (stderr, "test_find_1: short list returned from command\n");
3063       print_strings (r);
3064       return -1;
3065     }
3066     {
3067       char expected[] = "b";
3068       if (strcmp (r[1], expected) != 0) {
3069         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3070         return -1;
3071       }
3072     }
3073     if (!r[2]) {
3074       fprintf (stderr, "test_find_1: short list returned from command\n");
3075       print_strings (r);
3076       return -1;
3077     }
3078     {
3079       char expected[] = "b/c";
3080       if (strcmp (r[2], expected) != 0) {
3081         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3082         return -1;
3083       }
3084     }
3085     if (!r[3]) {
3086       fprintf (stderr, "test_find_1: short list returned from command\n");
3087       print_strings (r);
3088       return -1;
3089     }
3090     {
3091       char expected[] = "lost+found";
3092       if (strcmp (r[3], expected) != 0) {
3093         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3094         return -1;
3095       }
3096     }
3097     if (r[4] != NULL) {
3098       fprintf (stderr, "test_find_1: extra elements returned from command\n");
3099       print_strings (r);
3100       return -1;
3101     }
3102     for (i = 0; r[i] != NULL; ++i)
3103       free (r[i]);
3104     free (r);
3105   }
3106   return 0;
3107 }
3108
3109 static int test_find_2_skip (void)
3110 {
3111   const char *str;
3112
3113   str = getenv ("TEST_ONLY");
3114   if (str)
3115     return strstr (str, "find") == NULL;
3116   str = getenv ("SKIP_TEST_FIND_2");
3117   if (str && strcmp (str, "1") == 0) return 1;
3118   str = getenv ("SKIP_TEST_FIND");
3119   if (str && strcmp (str, "1") == 0) return 1;
3120   return 0;
3121 }
3122
3123 static int test_find_2 (void)
3124 {
3125   if (test_find_2_skip ()) {
3126     printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3127     return 0;
3128   }
3129
3130   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3131   {
3132     char device[] = "/dev/sda";
3133     int r;
3134     suppress_error = 0;
3135     r = guestfs_blockdev_setrw (g, device);
3136     if (r == -1)
3137       return -1;
3138   }
3139   {
3140     int r;
3141     suppress_error = 0;
3142     r = guestfs_umount_all (g);
3143     if (r == -1)
3144       return -1;
3145   }
3146   {
3147     int r;
3148     suppress_error = 0;
3149     r = guestfs_lvm_remove_all (g);
3150     if (r == -1)
3151       return -1;
3152   }
3153   {
3154     char device[] = "/dev/sda";
3155     char lines_0[] = ",";
3156     char *lines[] = {
3157       lines_0,
3158       NULL
3159     };
3160     int r;
3161     suppress_error = 0;
3162     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3163     if (r == -1)
3164       return -1;
3165   }
3166   {
3167     char fstype[] = "ext2";
3168     char device[] = "/dev/sda1";
3169     int r;
3170     suppress_error = 0;
3171     r = guestfs_mkfs (g, fstype, device);
3172     if (r == -1)
3173       return -1;
3174   }
3175   {
3176     char device[] = "/dev/sda1";
3177     char mountpoint[] = "/";
3178     int r;
3179     suppress_error = 0;
3180     r = guestfs_mount (g, device, mountpoint);
3181     if (r == -1)
3182       return -1;
3183   }
3184   /* TestOutputList for find (2) */
3185   {
3186     char path[] = "/a/b/c";
3187     int r;
3188     suppress_error = 0;
3189     r = guestfs_mkdir_p (g, path);
3190     if (r == -1)
3191       return -1;
3192   }
3193   {
3194     char path[] = "/a/b/c/d";
3195     int r;
3196     suppress_error = 0;
3197     r = guestfs_touch (g, path);
3198     if (r == -1)
3199       return -1;
3200   }
3201   {
3202     char directory[] = "/a/b/";
3203     char **r;
3204     int i;
3205     suppress_error = 0;
3206     r = guestfs_find (g, directory);
3207     if (r == NULL)
3208       return -1;
3209     if (!r[0]) {
3210       fprintf (stderr, "test_find_2: short list returned from command\n");
3211       print_strings (r);
3212       return -1;
3213     }
3214     {
3215       char expected[] = "c";
3216       if (strcmp (r[0], expected) != 0) {
3217         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3218         return -1;
3219       }
3220     }
3221     if (!r[1]) {
3222       fprintf (stderr, "test_find_2: short list returned from command\n");
3223       print_strings (r);
3224       return -1;
3225     }
3226     {
3227       char expected[] = "c/d";
3228       if (strcmp (r[1], expected) != 0) {
3229         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3230         return -1;
3231       }
3232     }
3233     if (r[2] != NULL) {
3234       fprintf (stderr, "test_find_2: extra elements returned from command\n");
3235       print_strings (r);
3236       return -1;
3237     }
3238     for (i = 0; r[i] != NULL; ++i)
3239       free (r[i]);
3240     free (r);
3241   }
3242   return 0;
3243 }
3244
3245 static int test_lvresize_0_skip (void)
3246 {
3247   const char *str;
3248
3249   str = getenv ("TEST_ONLY");
3250   if (str)
3251     return strstr (str, "lvresize") == NULL;
3252   str = getenv ("SKIP_TEST_LVRESIZE_0");
3253   if (str && strcmp (str, "1") == 0) return 1;
3254   str = getenv ("SKIP_TEST_LVRESIZE");
3255   if (str && strcmp (str, "1") == 0) return 1;
3256   return 0;
3257 }
3258
3259 static int test_lvresize_0 (void)
3260 {
3261   if (test_lvresize_0_skip ()) {
3262     printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3263     return 0;
3264   }
3265
3266   /* InitNone|InitEmpty for test_lvresize_0 */
3267   {
3268     char device[] = "/dev/sda";
3269     int r;
3270     suppress_error = 0;
3271     r = guestfs_blockdev_setrw (g, device);
3272     if (r == -1)
3273       return -1;
3274   }
3275   {
3276     int r;
3277     suppress_error = 0;
3278     r = guestfs_umount_all (g);
3279     if (r == -1)
3280       return -1;
3281   }
3282   {
3283     int r;
3284     suppress_error = 0;
3285     r = guestfs_lvm_remove_all (g);
3286     if (r == -1)
3287       return -1;
3288   }
3289   /* TestOutput for lvresize (0) */
3290   char expected[] = "test content";
3291   {
3292     char device[] = "/dev/sda";
3293     char lines_0[] = ",";
3294     char *lines[] = {
3295       lines_0,
3296       NULL
3297     };
3298     int r;
3299     suppress_error = 0;
3300     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3301     if (r == -1)
3302       return -1;
3303   }
3304   {
3305     char device[] = "/dev/sda1";
3306     int r;
3307     suppress_error = 0;
3308     r = guestfs_pvcreate (g, device);
3309     if (r == -1)
3310       return -1;
3311   }
3312   {
3313     char volgroup[] = "VG";
3314     char physvols_0[] = "/dev/sda1";
3315     char *physvols[] = {
3316       physvols_0,
3317       NULL
3318     };
3319     int r;
3320     suppress_error = 0;
3321     r = guestfs_vgcreate (g, volgroup, physvols);
3322     if (r == -1)
3323       return -1;
3324   }
3325   {
3326     char logvol[] = "LV";
3327     char volgroup[] = "VG";
3328     int r;
3329     suppress_error = 0;
3330     r = guestfs_lvcreate (g, logvol, volgroup, 10);
3331     if (r == -1)
3332       return -1;
3333   }
3334   {
3335     char fstype[] = "ext2";
3336     char device[] = "/dev/VG/LV";
3337     int r;
3338     suppress_error = 0;
3339     r = guestfs_mkfs (g, fstype, device);
3340     if (r == -1)
3341       return -1;
3342   }
3343   {
3344     char device[] = "/dev/VG/LV";
3345     char mountpoint[] = "/";
3346     int r;
3347     suppress_error = 0;
3348     r = guestfs_mount (g, device, mountpoint);
3349     if (r == -1)
3350       return -1;
3351   }
3352   {
3353     char path[] = "/new";
3354     char content[] = "test content";
3355     int r;
3356     suppress_error = 0;
3357     r = guestfs_write_file (g, path, content, 0);
3358     if (r == -1)
3359       return -1;
3360   }
3361   {
3362     char pathordevice[] = "/";
3363     int r;
3364     suppress_error = 0;
3365     r = guestfs_umount (g, pathordevice);
3366     if (r == -1)
3367       return -1;
3368   }
3369   {
3370     char device[] = "/dev/VG/LV";
3371     int r;
3372     suppress_error = 0;
3373     r = guestfs_lvresize (g, device, 20);
3374     if (r == -1)
3375       return -1;
3376   }
3377   {
3378     char device[] = "/dev/VG/LV";
3379     int r;
3380     suppress_error = 0;
3381     r = guestfs_e2fsck_f (g, device);
3382     if (r == -1)
3383       return -1;
3384   }
3385   {
3386     char device[] = "/dev/VG/LV";
3387     int r;
3388     suppress_error = 0;
3389     r = guestfs_resize2fs (g, device);
3390     if (r == -1)
3391       return -1;
3392   }
3393   {
3394     char device[] = "/dev/VG/LV";
3395     char mountpoint[] = "/";
3396     int r;
3397     suppress_error = 0;
3398     r = guestfs_mount (g, device, mountpoint);
3399     if (r == -1)
3400       return -1;
3401   }
3402   {
3403     char path[] = "/new";
3404     char *r;
3405     suppress_error = 0;
3406     r = guestfs_cat (g, path);
3407     if (r == NULL)
3408       return -1;
3409     if (strcmp (r, expected) != 0) {
3410       fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3411       return -1;
3412     }
3413     free (r);
3414   }
3415   return 0;
3416 }
3417
3418 static int test_zerofree_0_skip (void)
3419 {
3420   const char *str;
3421
3422   str = getenv ("TEST_ONLY");
3423   if (str)
3424     return strstr (str, "zerofree") == NULL;
3425   str = getenv ("SKIP_TEST_ZEROFREE_0");
3426   if (str && strcmp (str, "1") == 0) return 1;
3427   str = getenv ("SKIP_TEST_ZEROFREE");
3428   if (str && strcmp (str, "1") == 0) return 1;
3429   return 0;
3430 }
3431
3432 static int test_zerofree_0 (void)
3433 {
3434   if (test_zerofree_0_skip ()) {
3435     printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3436     return 0;
3437   }
3438
3439   /* InitNone|InitEmpty for test_zerofree_0 */
3440   {
3441     char device[] = "/dev/sda";
3442     int r;
3443     suppress_error = 0;
3444     r = guestfs_blockdev_setrw (g, device);
3445     if (r == -1)
3446       return -1;
3447   }
3448   {
3449     int r;
3450     suppress_error = 0;
3451     r = guestfs_umount_all (g);
3452     if (r == -1)
3453       return -1;
3454   }
3455   {
3456     int r;
3457     suppress_error = 0;
3458     r = guestfs_lvm_remove_all (g);
3459     if (r == -1)
3460       return -1;
3461   }
3462   /* TestOutput for zerofree (0) */
3463   char expected[] = "test file";
3464   {
3465     char device[] = "/dev/sda";
3466     char lines_0[] = ",";
3467     char *lines[] = {
3468       lines_0,
3469       NULL
3470     };
3471     int r;
3472     suppress_error = 0;
3473     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3474     if (r == -1)
3475       return -1;
3476   }
3477   {
3478     char fstype[] = "ext3";
3479     char device[] = "/dev/sda1";
3480     int r;
3481     suppress_error = 0;
3482     r = guestfs_mkfs (g, fstype, device);
3483     if (r == -1)
3484       return -1;
3485   }
3486   {
3487     char device[] = "/dev/sda1";
3488     char mountpoint[] = "/";
3489     int r;
3490     suppress_error = 0;
3491     r = guestfs_mount (g, device, mountpoint);
3492     if (r == -1)
3493       return -1;
3494   }
3495   {
3496     char path[] = "/new";
3497     char content[] = "test file";
3498     int r;
3499     suppress_error = 0;
3500     r = guestfs_write_file (g, path, content, 0);
3501     if (r == -1)
3502       return -1;
3503   }
3504   {
3505     char pathordevice[] = "/dev/sda1";
3506     int r;
3507     suppress_error = 0;
3508     r = guestfs_umount (g, pathordevice);
3509     if (r == -1)
3510       return -1;
3511   }
3512   {
3513     char device[] = "/dev/sda1";
3514     int r;
3515     suppress_error = 0;
3516     r = guestfs_zerofree (g, device);
3517     if (r == -1)
3518       return -1;
3519   }
3520   {
3521     char device[] = "/dev/sda1";
3522     char mountpoint[] = "/";
3523     int r;
3524     suppress_error = 0;
3525     r = guestfs_mount (g, device, mountpoint);
3526     if (r == -1)
3527       return -1;
3528   }
3529   {
3530     char path[] = "/new";
3531     char *r;
3532     suppress_error = 0;
3533     r = guestfs_cat (g, path);
3534     if (r == NULL)
3535       return -1;
3536     if (strcmp (r, expected) != 0) {
3537       fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3538       return -1;
3539     }
3540     free (r);
3541   }
3542   return 0;
3543 }
3544
3545 static int test_hexdump_0_skip (void)
3546 {
3547   const char *str;
3548
3549   str = getenv ("TEST_ONLY");
3550   if (str)
3551     return strstr (str, "hexdump") == NULL;
3552   str = getenv ("SKIP_TEST_HEXDUMP_0");
3553   if (str && strcmp (str, "1") == 0) return 1;
3554   str = getenv ("SKIP_TEST_HEXDUMP");
3555   if (str && strcmp (str, "1") == 0) return 1;
3556   return 0;
3557 }
3558
3559 static int test_hexdump_0 (void)
3560 {
3561   if (test_hexdump_0_skip ()) {
3562     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3563     return 0;
3564   }
3565
3566   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3567   {
3568     char device[] = "/dev/sda";
3569     int r;
3570     suppress_error = 0;
3571     r = guestfs_blockdev_setrw (g, device);
3572     if (r == -1)
3573       return -1;
3574   }
3575   {
3576     int r;
3577     suppress_error = 0;
3578     r = guestfs_umount_all (g);
3579     if (r == -1)
3580       return -1;
3581   }
3582   {
3583     int r;
3584     suppress_error = 0;
3585     r = guestfs_lvm_remove_all (g);
3586     if (r == -1)
3587       return -1;
3588   }
3589   {
3590     char device[] = "/dev/sda";
3591     char lines_0[] = ",";
3592     char *lines[] = {
3593       lines_0,
3594       NULL
3595     };
3596     int r;
3597     suppress_error = 0;
3598     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3599     if (r == -1)
3600       return -1;
3601   }
3602   {
3603     char fstype[] = "ext2";
3604     char device[] = "/dev/sda1";
3605     int r;
3606     suppress_error = 0;
3607     r = guestfs_mkfs (g, fstype, device);
3608     if (r == -1)
3609       return -1;
3610   }
3611   {
3612     char device[] = "/dev/sda1";
3613     char mountpoint[] = "/";
3614     int r;
3615     suppress_error = 0;
3616     r = guestfs_mount (g, device, mountpoint);
3617     if (r == -1)
3618       return -1;
3619   }
3620   /* TestOutput for hexdump (0) */
3621   char expected[] = "00000000  68 65 6c 6c 6f 0a 77 6f  72 6c 64 0a              |hello.world.|\n0000000c\n";
3622   {
3623     char path[] = "/new";
3624     char content[] = "hello\nworld\n";
3625     int r;
3626     suppress_error = 0;
3627     r = guestfs_write_file (g, path, content, 12);
3628     if (r == -1)
3629       return -1;
3630   }
3631   {
3632     char path[] = "/new";
3633     char *r;
3634     suppress_error = 0;
3635     r = guestfs_hexdump (g, path);
3636     if (r == NULL)
3637       return -1;
3638     if (strcmp (r, expected) != 0) {
3639       fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3640       return -1;
3641     }
3642     free (r);
3643   }
3644   return 0;
3645 }
3646
3647 static int test_hexdump_1_skip (void)
3648 {
3649   const char *str;
3650
3651   str = getenv ("TEST_ONLY");
3652   if (str)
3653     return strstr (str, "hexdump") == NULL;
3654   str = getenv ("SKIP_TEST_HEXDUMP_1");
3655   if (str && strcmp (str, "1") == 0) return 1;
3656   str = getenv ("SKIP_TEST_HEXDUMP");
3657   if (str && strcmp (str, "1") == 0) return 1;
3658   return 0;
3659 }
3660
3661 static int test_hexdump_1 (void)
3662 {
3663   if (test_hexdump_1_skip ()) {
3664     printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3665     return 0;
3666   }
3667
3668   /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3669   {
3670     char device[] = "/dev/sda";
3671     int r;
3672     suppress_error = 0;
3673     r = guestfs_blockdev_setrw (g, device);
3674     if (r == -1)
3675       return -1;
3676   }
3677   {
3678     int r;
3679     suppress_error = 0;
3680     r = guestfs_umount_all (g);
3681     if (r == -1)
3682       return -1;
3683   }
3684   {
3685     int r;
3686     suppress_error = 0;
3687     r = guestfs_lvm_remove_all (g);
3688     if (r == -1)
3689       return -1;
3690   }
3691   {
3692     char device[] = "/dev/sda";
3693     char lines_0[] = ",";
3694     char *lines[] = {
3695       lines_0,
3696       NULL
3697     };
3698     int r;
3699     suppress_error = 0;
3700     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3701     if (r == -1)
3702       return -1;
3703   }
3704   {
3705     char fstype[] = "ext2";
3706     char device[] = "/dev/sda1";
3707     int r;
3708     suppress_error = 0;
3709     r = guestfs_mkfs (g, fstype, device);
3710     if (r == -1)
3711       return -1;
3712   }
3713   {
3714     char device[] = "/dev/sda1";
3715     char mountpoint[] = "/";
3716     int r;
3717     suppress_error = 0;
3718     r = guestfs_mount (g, device, mountpoint);
3719     if (r == -1)
3720       return -1;
3721   }
3722   /* TestRun for hexdump (1) */
3723   {
3724     char options[] = "ro";
3725     char vfstype[] = "squashfs";
3726     char device[] = "/dev/sdd";
3727     char mountpoint[] = "/";
3728     int r;
3729     suppress_error = 0;
3730     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3731     if (r == -1)
3732       return -1;
3733   }
3734   {
3735     char path[] = "/100krandom";
3736     char *r;
3737     suppress_error = 0;
3738     r = guestfs_hexdump (g, path);
3739     if (r == NULL)
3740       return -1;
3741     free (r);
3742   }
3743   return 0;
3744 }
3745
3746 static int test_strings_e_0_skip (void)
3747 {
3748   const char *str;
3749
3750   str = getenv ("TEST_ONLY");
3751   if (str)
3752     return strstr (str, "strings_e") == NULL;
3753   str = getenv ("SKIP_TEST_STRINGS_E_0");
3754   if (str && strcmp (str, "1") == 0) return 1;
3755   str = getenv ("SKIP_TEST_STRINGS_E");
3756   if (str && strcmp (str, "1") == 0) return 1;
3757   return 0;
3758 }
3759
3760 static int test_strings_e_0 (void)
3761 {
3762   if (test_strings_e_0_skip ()) {
3763     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3764     return 0;
3765   }
3766
3767   /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3768   {
3769     char device[] = "/dev/sda";
3770     int r;
3771     suppress_error = 0;
3772     r = guestfs_blockdev_setrw (g, device);
3773     if (r == -1)
3774       return -1;
3775   }
3776   {
3777     int r;
3778     suppress_error = 0;
3779     r = guestfs_umount_all (g);
3780     if (r == -1)
3781       return -1;
3782   }
3783   {
3784     int r;
3785     suppress_error = 0;
3786     r = guestfs_lvm_remove_all (g);
3787     if (r == -1)
3788       return -1;
3789   }
3790   {
3791     char device[] = "/dev/sda";
3792     char lines_0[] = ",";
3793     char *lines[] = {
3794       lines_0,
3795       NULL
3796     };
3797     int r;
3798     suppress_error = 0;
3799     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3800     if (r == -1)
3801       return -1;
3802   }
3803   {
3804     char fstype[] = "ext2";
3805     char device[] = "/dev/sda1";
3806     int r;
3807     suppress_error = 0;
3808     r = guestfs_mkfs (g, fstype, device);
3809     if (r == -1)
3810       return -1;
3811   }
3812   {
3813     char device[] = "/dev/sda1";
3814     char mountpoint[] = "/";
3815     int r;
3816     suppress_error = 0;
3817     r = guestfs_mount (g, device, mountpoint);
3818     if (r == -1)
3819       return -1;
3820   }
3821   /* TestOutputList for strings_e (0) */
3822   {
3823     char path[] = "/new";
3824     char content[] = "hello\nworld\n";
3825     int r;
3826     suppress_error = 0;
3827     r = guestfs_write_file (g, path, content, 0);
3828     if (r == -1)
3829       return -1;
3830   }
3831   {
3832     char encoding[] = "b";
3833     char path[] = "/new";
3834     char **r;
3835     int i;
3836     suppress_error = 0;
3837     r = guestfs_strings_e (g, encoding, path);
3838     if (r == NULL)
3839       return -1;
3840     if (r[0] != NULL) {
3841       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
3842       print_strings (r);
3843       return -1;
3844     }
3845     for (i = 0; r[i] != NULL; ++i)
3846       free (r[i]);
3847     free (r);
3848   }
3849   return 0;
3850 }
3851
3852 static int test_strings_e_1_skip (void)
3853 {
3854   const char *str;
3855
3856   str = getenv ("TEST_ONLY");
3857   if (str)
3858     return strstr (str, "strings_e") == NULL;
3859   str = getenv ("SKIP_TEST_STRINGS_E_1");
3860   if (str && strcmp (str, "1") == 0) return 1;
3861   str = getenv ("SKIP_TEST_STRINGS_E");
3862   if (str && strcmp (str, "1") == 0) return 1;
3863   return 0;
3864 }
3865
3866 static int test_strings_e_1 (void)
3867 {
3868   if (test_strings_e_1_skip ()) {
3869     printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
3870     return 0;
3871   }
3872
3873   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
3874   return 0;
3875 }
3876
3877 static int test_strings_0_skip (void)
3878 {
3879   const char *str;
3880
3881   str = getenv ("TEST_ONLY");
3882   if (str)
3883     return strstr (str, "strings") == NULL;
3884   str = getenv ("SKIP_TEST_STRINGS_0");
3885   if (str && strcmp (str, "1") == 0) return 1;
3886   str = getenv ("SKIP_TEST_STRINGS");
3887   if (str && strcmp (str, "1") == 0) return 1;
3888   return 0;
3889 }
3890
3891 static int test_strings_0 (void)
3892 {
3893   if (test_strings_0_skip ()) {
3894     printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
3895     return 0;
3896   }
3897
3898   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
3899   {
3900     char device[] = "/dev/sda";
3901     int r;
3902     suppress_error = 0;
3903     r = guestfs_blockdev_setrw (g, device);
3904     if (r == -1)
3905       return -1;
3906   }
3907   {
3908     int r;
3909     suppress_error = 0;
3910     r = guestfs_umount_all (g);
3911     if (r == -1)
3912       return -1;
3913   }
3914   {
3915     int r;
3916     suppress_error = 0;
3917     r = guestfs_lvm_remove_all (g);
3918     if (r == -1)
3919       return -1;
3920   }
3921   {
3922     char device[] = "/dev/sda";
3923     char lines_0[] = ",";
3924     char *lines[] = {
3925       lines_0,
3926       NULL
3927     };
3928     int r;
3929     suppress_error = 0;
3930     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3931     if (r == -1)
3932       return -1;
3933   }
3934   {
3935     char fstype[] = "ext2";
3936     char device[] = "/dev/sda1";
3937     int r;
3938     suppress_error = 0;
3939     r = guestfs_mkfs (g, fstype, device);
3940     if (r == -1)
3941       return -1;
3942   }
3943   {
3944     char device[] = "/dev/sda1";
3945     char mountpoint[] = "/";
3946     int r;
3947     suppress_error = 0;
3948     r = guestfs_mount (g, device, mountpoint);
3949     if (r == -1)
3950       return -1;
3951   }
3952   /* TestOutputList for strings (0) */
3953   {
3954     char path[] = "/new";
3955     char content[] = "hello\nworld\n";
3956     int r;
3957     suppress_error = 0;
3958     r = guestfs_write_file (g, path, content, 0);
3959     if (r == -1)
3960       return -1;
3961   }
3962   {
3963     char path[] = "/new";
3964     char **r;
3965     int i;
3966     suppress_error = 0;
3967     r = guestfs_strings (g, path);
3968     if (r == NULL)
3969       return -1;
3970     if (!r[0]) {
3971       fprintf (stderr, "test_strings_0: short list returned from command\n");
3972       print_strings (r);
3973       return -1;
3974     }
3975     {
3976       char expected[] = "hello";
3977       if (strcmp (r[0], expected) != 0) {
3978         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3979         return -1;
3980       }
3981     }
3982     if (!r[1]) {
3983       fprintf (stderr, "test_strings_0: short list returned from command\n");
3984       print_strings (r);
3985       return -1;
3986     }
3987     {
3988       char expected[] = "world";
3989       if (strcmp (r[1], expected) != 0) {
3990         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3991         return -1;
3992       }
3993     }
3994     if (r[2] != NULL) {
3995       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
3996       print_strings (r);
3997       return -1;
3998     }
3999     for (i = 0; r[i] != NULL; ++i)
4000       free (r[i]);
4001     free (r);
4002   }
4003   return 0;
4004 }
4005
4006 static int test_strings_1_skip (void)
4007 {
4008   const char *str;
4009
4010   str = getenv ("TEST_ONLY");
4011   if (str)
4012     return strstr (str, "strings") == NULL;
4013   str = getenv ("SKIP_TEST_STRINGS_1");
4014   if (str && strcmp (str, "1") == 0) return 1;
4015   str = getenv ("SKIP_TEST_STRINGS");
4016   if (str && strcmp (str, "1") == 0) return 1;
4017   return 0;
4018 }
4019
4020 static int test_strings_1 (void)
4021 {
4022   if (test_strings_1_skip ()) {
4023     printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
4024     return 0;
4025   }
4026
4027   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4028   {
4029     char device[] = "/dev/sda";
4030     int r;
4031     suppress_error = 0;
4032     r = guestfs_blockdev_setrw (g, device);
4033     if (r == -1)
4034       return -1;
4035   }
4036   {
4037     int r;
4038     suppress_error = 0;
4039     r = guestfs_umount_all (g);
4040     if (r == -1)
4041       return -1;
4042   }
4043   {
4044     int r;
4045     suppress_error = 0;
4046     r = guestfs_lvm_remove_all (g);
4047     if (r == -1)
4048       return -1;
4049   }
4050   {
4051     char device[] = "/dev/sda";
4052     char lines_0[] = ",";
4053     char *lines[] = {
4054       lines_0,
4055       NULL
4056     };
4057     int r;
4058     suppress_error = 0;
4059     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4060     if (r == -1)
4061       return -1;
4062   }
4063   {
4064     char fstype[] = "ext2";
4065     char device[] = "/dev/sda1";
4066     int r;
4067     suppress_error = 0;
4068     r = guestfs_mkfs (g, fstype, device);
4069     if (r == -1)
4070       return -1;
4071   }
4072   {
4073     char device[] = "/dev/sda1";
4074     char mountpoint[] = "/";
4075     int r;
4076     suppress_error = 0;
4077     r = guestfs_mount (g, device, mountpoint);
4078     if (r == -1)
4079       return -1;
4080   }
4081   /* TestOutputList for strings (1) */
4082   {
4083     char path[] = "/new";
4084     int r;
4085     suppress_error = 0;
4086     r = guestfs_touch (g, path);
4087     if (r == -1)
4088       return -1;
4089   }
4090   {
4091     char path[] = "/new";
4092     char **r;
4093     int i;
4094     suppress_error = 0;
4095     r = guestfs_strings (g, path);
4096     if (r == NULL)
4097       return -1;
4098     if (r[0] != NULL) {
4099       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4100       print_strings (r);
4101       return -1;
4102     }
4103     for (i = 0; r[i] != NULL; ++i)
4104       free (r[i]);
4105     free (r);
4106   }
4107   return 0;
4108 }
4109
4110 static int test_equal_0_skip (void)
4111 {
4112   const char *str;
4113
4114   str = getenv ("TEST_ONLY");
4115   if (str)
4116     return strstr (str, "equal") == NULL;
4117   str = getenv ("SKIP_TEST_EQUAL_0");
4118   if (str && strcmp (str, "1") == 0) return 1;
4119   str = getenv ("SKIP_TEST_EQUAL");
4120   if (str && strcmp (str, "1") == 0) return 1;
4121   return 0;
4122 }
4123
4124 static int test_equal_0 (void)
4125 {
4126   if (test_equal_0_skip ()) {
4127     printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
4128     return 0;
4129   }
4130
4131   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4132   {
4133     char device[] = "/dev/sda";
4134     int r;
4135     suppress_error = 0;
4136     r = guestfs_blockdev_setrw (g, device);
4137     if (r == -1)
4138       return -1;
4139   }
4140   {
4141     int r;
4142     suppress_error = 0;
4143     r = guestfs_umount_all (g);
4144     if (r == -1)
4145       return -1;
4146   }
4147   {
4148     int r;
4149     suppress_error = 0;
4150     r = guestfs_lvm_remove_all (g);
4151     if (r == -1)
4152       return -1;
4153   }
4154   {
4155     char device[] = "/dev/sda";
4156     char lines_0[] = ",";
4157     char *lines[] = {
4158       lines_0,
4159       NULL
4160     };
4161     int r;
4162     suppress_error = 0;
4163     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4164     if (r == -1)
4165       return -1;
4166   }
4167   {
4168     char fstype[] = "ext2";
4169     char device[] = "/dev/sda1";
4170     int r;
4171     suppress_error = 0;
4172     r = guestfs_mkfs (g, fstype, device);
4173     if (r == -1)
4174       return -1;
4175   }
4176   {
4177     char device[] = "/dev/sda1";
4178     char mountpoint[] = "/";
4179     int r;
4180     suppress_error = 0;
4181     r = guestfs_mount (g, device, mountpoint);
4182     if (r == -1)
4183       return -1;
4184   }
4185   /* TestOutputTrue for equal (0) */
4186   {
4187     char path[] = "/file1";
4188     char content[] = "contents of a file";
4189     int r;
4190     suppress_error = 0;
4191     r = guestfs_write_file (g, path, content, 0);
4192     if (r == -1)
4193       return -1;
4194   }
4195   {
4196     char src[] = "/file1";
4197     char dest[] = "/file2";
4198     int r;
4199     suppress_error = 0;
4200     r = guestfs_cp (g, src, dest);
4201     if (r == -1)
4202       return -1;
4203   }
4204   {
4205     char file1[] = "/file1";
4206     char file2[] = "/file2";
4207     int r;
4208     suppress_error = 0;
4209     r = guestfs_equal (g, file1, file2);
4210     if (r == -1)
4211       return -1;
4212     if (!r) {
4213       fprintf (stderr, "test_equal_0: expected true, got false\n");
4214       return -1;
4215     }
4216   }
4217   return 0;
4218 }
4219
4220 static int test_equal_1_skip (void)
4221 {
4222   const char *str;
4223
4224   str = getenv ("TEST_ONLY");
4225   if (str)
4226     return strstr (str, "equal") == NULL;
4227   str = getenv ("SKIP_TEST_EQUAL_1");
4228   if (str && strcmp (str, "1") == 0) return 1;
4229   str = getenv ("SKIP_TEST_EQUAL");
4230   if (str && strcmp (str, "1") == 0) return 1;
4231   return 0;
4232 }
4233
4234 static int test_equal_1 (void)
4235 {
4236   if (test_equal_1_skip ()) {
4237     printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4238     return 0;
4239   }
4240
4241   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4242   {
4243     char device[] = "/dev/sda";
4244     int r;
4245     suppress_error = 0;
4246     r = guestfs_blockdev_setrw (g, device);
4247     if (r == -1)
4248       return -1;
4249   }
4250   {
4251     int r;
4252     suppress_error = 0;
4253     r = guestfs_umount_all (g);
4254     if (r == -1)
4255       return -1;
4256   }
4257   {
4258     int r;
4259     suppress_error = 0;
4260     r = guestfs_lvm_remove_all (g);
4261     if (r == -1)
4262       return -1;
4263   }
4264   {
4265     char device[] = "/dev/sda";
4266     char lines_0[] = ",";
4267     char *lines[] = {
4268       lines_0,
4269       NULL
4270     };
4271     int r;
4272     suppress_error = 0;
4273     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4274     if (r == -1)
4275       return -1;
4276   }
4277   {
4278     char fstype[] = "ext2";
4279     char device[] = "/dev/sda1";
4280     int r;
4281     suppress_error = 0;
4282     r = guestfs_mkfs (g, fstype, device);
4283     if (r == -1)
4284       return -1;
4285   }
4286   {
4287     char device[] = "/dev/sda1";
4288     char mountpoint[] = "/";
4289     int r;
4290     suppress_error = 0;
4291     r = guestfs_mount (g, device, mountpoint);
4292     if (r == -1)
4293       return -1;
4294   }
4295   /* TestOutputFalse for equal (1) */
4296   {
4297     char path[] = "/file1";
4298     char content[] = "contents of a file";
4299     int r;
4300     suppress_error = 0;
4301     r = guestfs_write_file (g, path, content, 0);
4302     if (r == -1)
4303       return -1;
4304   }
4305   {
4306     char path[] = "/file2";
4307     char content[] = "contents of another file";
4308     int r;
4309     suppress_error = 0;
4310     r = guestfs_write_file (g, path, content, 0);
4311     if (r == -1)
4312       return -1;
4313   }
4314   {
4315     char file1[] = "/file1";
4316     char file2[] = "/file2";
4317     int r;
4318     suppress_error = 0;
4319     r = guestfs_equal (g, file1, file2);
4320     if (r == -1)
4321       return -1;
4322     if (r) {
4323       fprintf (stderr, "test_equal_1: expected false, got true\n");
4324       return -1;
4325     }
4326   }
4327   return 0;
4328 }
4329
4330 static int test_equal_2_skip (void)
4331 {
4332   const char *str;
4333
4334   str = getenv ("TEST_ONLY");
4335   if (str)
4336     return strstr (str, "equal") == NULL;
4337   str = getenv ("SKIP_TEST_EQUAL_2");
4338   if (str && strcmp (str, "1") == 0) return 1;
4339   str = getenv ("SKIP_TEST_EQUAL");
4340   if (str && strcmp (str, "1") == 0) return 1;
4341   return 0;
4342 }
4343
4344 static int test_equal_2 (void)
4345 {
4346   if (test_equal_2_skip ()) {
4347     printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4348     return 0;
4349   }
4350
4351   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4352   {
4353     char device[] = "/dev/sda";
4354     int r;
4355     suppress_error = 0;
4356     r = guestfs_blockdev_setrw (g, device);
4357     if (r == -1)
4358       return -1;
4359   }
4360   {
4361     int r;
4362     suppress_error = 0;
4363     r = guestfs_umount_all (g);
4364     if (r == -1)
4365       return -1;
4366   }
4367   {
4368     int r;
4369     suppress_error = 0;
4370     r = guestfs_lvm_remove_all (g);
4371     if (r == -1)
4372       return -1;
4373   }
4374   {
4375     char device[] = "/dev/sda";
4376     char lines_0[] = ",";
4377     char *lines[] = {
4378       lines_0,
4379       NULL
4380     };
4381     int r;
4382     suppress_error = 0;
4383     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4384     if (r == -1)
4385       return -1;
4386   }
4387   {
4388     char fstype[] = "ext2";
4389     char device[] = "/dev/sda1";
4390     int r;
4391     suppress_error = 0;
4392     r = guestfs_mkfs (g, fstype, device);
4393     if (r == -1)
4394       return -1;
4395   }
4396   {
4397     char device[] = "/dev/sda1";
4398     char mountpoint[] = "/";
4399     int r;
4400     suppress_error = 0;
4401     r = guestfs_mount (g, device, mountpoint);
4402     if (r == -1)
4403       return -1;
4404   }
4405   /* TestLastFail for equal (2) */
4406   {
4407     char file1[] = "/file1";
4408     char file2[] = "/file2";
4409     int r;
4410     suppress_error = 1;
4411     r = guestfs_equal (g, file1, file2);
4412     if (r != -1)
4413       return -1;
4414   }
4415   return 0;
4416 }
4417
4418 static int test_ping_daemon_0_skip (void)
4419 {
4420   const char *str;
4421
4422   str = getenv ("TEST_ONLY");
4423   if (str)
4424     return strstr (str, "ping_daemon") == NULL;
4425   str = getenv ("SKIP_TEST_PING_DAEMON_0");
4426   if (str && strcmp (str, "1") == 0) return 1;
4427   str = getenv ("SKIP_TEST_PING_DAEMON");
4428   if (str && strcmp (str, "1") == 0) return 1;
4429   return 0;
4430 }
4431
4432 static int test_ping_daemon_0 (void)
4433 {
4434   if (test_ping_daemon_0_skip ()) {
4435     printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4436     return 0;
4437   }
4438
4439   /* InitNone|InitEmpty for test_ping_daemon_0 */
4440   {
4441     char device[] = "/dev/sda";
4442     int r;
4443     suppress_error = 0;
4444     r = guestfs_blockdev_setrw (g, device);
4445     if (r == -1)
4446       return -1;
4447   }
4448   {
4449     int r;
4450     suppress_error = 0;
4451     r = guestfs_umount_all (g);
4452     if (r == -1)
4453       return -1;
4454   }
4455   {
4456     int r;
4457     suppress_error = 0;
4458     r = guestfs_lvm_remove_all (g);
4459     if (r == -1)
4460       return -1;
4461   }
4462   /* TestRun for ping_daemon (0) */
4463   {
4464     int r;
4465     suppress_error = 0;
4466     r = guestfs_ping_daemon (g);
4467     if (r == -1)
4468       return -1;
4469   }
4470   return 0;
4471 }
4472
4473 static int test_dmesg_0_skip (void)
4474 {
4475   const char *str;
4476
4477   str = getenv ("TEST_ONLY");
4478   if (str)
4479     return strstr (str, "dmesg") == NULL;
4480   str = getenv ("SKIP_TEST_DMESG_0");
4481   if (str && strcmp (str, "1") == 0) return 1;
4482   str = getenv ("SKIP_TEST_DMESG");
4483   if (str && strcmp (str, "1") == 0) return 1;
4484   return 0;
4485 }
4486
4487 static int test_dmesg_0 (void)
4488 {
4489   if (test_dmesg_0_skip ()) {
4490     printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4491     return 0;
4492   }
4493
4494   /* InitNone|InitEmpty for test_dmesg_0 */
4495   {
4496     char device[] = "/dev/sda";
4497     int r;
4498     suppress_error = 0;
4499     r = guestfs_blockdev_setrw (g, device);
4500     if (r == -1)
4501       return -1;
4502   }
4503   {
4504     int r;
4505     suppress_error = 0;
4506     r = guestfs_umount_all (g);
4507     if (r == -1)
4508       return -1;
4509   }
4510   {
4511     int r;
4512     suppress_error = 0;
4513     r = guestfs_lvm_remove_all (g);
4514     if (r == -1)
4515       return -1;
4516   }
4517   /* TestRun for dmesg (0) */
4518   {
4519     char *r;
4520     suppress_error = 0;
4521     r = guestfs_dmesg (g);
4522     if (r == NULL)
4523       return -1;
4524     free (r);
4525   }
4526   return 0;
4527 }
4528
4529 static int test_drop_caches_0_skip (void)
4530 {
4531   const char *str;
4532
4533   str = getenv ("TEST_ONLY");
4534   if (str)
4535     return strstr (str, "drop_caches") == NULL;
4536   str = getenv ("SKIP_TEST_DROP_CACHES_0");
4537   if (str && strcmp (str, "1") == 0) return 1;
4538   str = getenv ("SKIP_TEST_DROP_CACHES");
4539   if (str && strcmp (str, "1") == 0) return 1;
4540   return 0;
4541 }
4542
4543 static int test_drop_caches_0 (void)
4544 {
4545   if (test_drop_caches_0_skip ()) {
4546     printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4547     return 0;
4548   }
4549
4550   /* InitNone|InitEmpty for test_drop_caches_0 */
4551   {
4552     char device[] = "/dev/sda";
4553     int r;
4554     suppress_error = 0;
4555     r = guestfs_blockdev_setrw (g, device);
4556     if (r == -1)
4557       return -1;
4558   }
4559   {
4560     int r;
4561     suppress_error = 0;
4562     r = guestfs_umount_all (g);
4563     if (r == -1)
4564       return -1;
4565   }
4566   {
4567     int r;
4568     suppress_error = 0;
4569     r = guestfs_lvm_remove_all (g);
4570     if (r == -1)
4571       return -1;
4572   }
4573   /* TestRun for drop_caches (0) */
4574   {
4575     int r;
4576     suppress_error = 0;
4577     r = guestfs_drop_caches (g, 3);
4578     if (r == -1)
4579       return -1;
4580   }
4581   return 0;
4582 }
4583
4584 static int test_mv_0_skip (void)
4585 {
4586   const char *str;
4587
4588   str = getenv ("TEST_ONLY");
4589   if (str)
4590     return strstr (str, "mv") == NULL;
4591   str = getenv ("SKIP_TEST_MV_0");
4592   if (str && strcmp (str, "1") == 0) return 1;
4593   str = getenv ("SKIP_TEST_MV");
4594   if (str && strcmp (str, "1") == 0) return 1;
4595   return 0;
4596 }
4597
4598 static int test_mv_0 (void)
4599 {
4600   if (test_mv_0_skip ()) {
4601     printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4602     return 0;
4603   }
4604
4605   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4606   {
4607     char device[] = "/dev/sda";
4608     int r;
4609     suppress_error = 0;
4610     r = guestfs_blockdev_setrw (g, device);
4611     if (r == -1)
4612       return -1;
4613   }
4614   {
4615     int r;
4616     suppress_error = 0;
4617     r = guestfs_umount_all (g);
4618     if (r == -1)
4619       return -1;
4620   }
4621   {
4622     int r;
4623     suppress_error = 0;
4624     r = guestfs_lvm_remove_all (g);
4625     if (r == -1)
4626       return -1;
4627   }
4628   {
4629     char device[] = "/dev/sda";
4630     char lines_0[] = ",";
4631     char *lines[] = {
4632       lines_0,
4633       NULL
4634     };
4635     int r;
4636     suppress_error = 0;
4637     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4638     if (r == -1)
4639       return -1;
4640   }
4641   {
4642     char fstype[] = "ext2";
4643     char device[] = "/dev/sda1";
4644     int r;
4645     suppress_error = 0;
4646     r = guestfs_mkfs (g, fstype, device);
4647     if (r == -1)
4648       return -1;
4649   }
4650   {
4651     char device[] = "/dev/sda1";
4652     char mountpoint[] = "/";
4653     int r;
4654     suppress_error = 0;
4655     r = guestfs_mount (g, device, mountpoint);
4656     if (r == -1)
4657       return -1;
4658   }
4659   /* TestOutput for mv (0) */
4660   char expected[] = "file content";
4661   {
4662     char path[] = "/old";
4663     char content[] = "file content";
4664     int r;
4665     suppress_error = 0;
4666     r = guestfs_write_file (g, path, content, 0);
4667     if (r == -1)
4668       return -1;
4669   }
4670   {
4671     char src[] = "/old";
4672     char dest[] = "/new";
4673     int r;
4674     suppress_error = 0;
4675     r = guestfs_mv (g, src, dest);
4676     if (r == -1)
4677       return -1;
4678   }
4679   {
4680     char path[] = "/new";
4681     char *r;
4682     suppress_error = 0;
4683     r = guestfs_cat (g, path);
4684     if (r == NULL)
4685       return -1;
4686     if (strcmp (r, expected) != 0) {
4687       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4688       return -1;
4689     }
4690     free (r);
4691   }
4692   return 0;
4693 }
4694
4695 static int test_mv_1_skip (void)
4696 {
4697   const char *str;
4698
4699   str = getenv ("TEST_ONLY");
4700   if (str)
4701     return strstr (str, "mv") == NULL;
4702   str = getenv ("SKIP_TEST_MV_1");
4703   if (str && strcmp (str, "1") == 0) return 1;
4704   str = getenv ("SKIP_TEST_MV");
4705   if (str && strcmp (str, "1") == 0) return 1;
4706   return 0;
4707 }
4708
4709 static int test_mv_1 (void)
4710 {
4711   if (test_mv_1_skip ()) {
4712     printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4713     return 0;
4714   }
4715
4716   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4717   {
4718     char device[] = "/dev/sda";
4719     int r;
4720     suppress_error = 0;
4721     r = guestfs_blockdev_setrw (g, device);
4722     if (r == -1)
4723       return -1;
4724   }
4725   {
4726     int r;
4727     suppress_error = 0;
4728     r = guestfs_umount_all (g);
4729     if (r == -1)
4730       return -1;
4731   }
4732   {
4733     int r;
4734     suppress_error = 0;
4735     r = guestfs_lvm_remove_all (g);
4736     if (r == -1)
4737       return -1;
4738   }
4739   {
4740     char device[] = "/dev/sda";
4741     char lines_0[] = ",";
4742     char *lines[] = {
4743       lines_0,
4744       NULL
4745     };
4746     int r;
4747     suppress_error = 0;
4748     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4749     if (r == -1)
4750       return -1;
4751   }
4752   {
4753     char fstype[] = "ext2";
4754     char device[] = "/dev/sda1";
4755     int r;
4756     suppress_error = 0;
4757     r = guestfs_mkfs (g, fstype, device);
4758     if (r == -1)
4759       return -1;
4760   }
4761   {
4762     char device[] = "/dev/sda1";
4763     char mountpoint[] = "/";
4764     int r;
4765     suppress_error = 0;
4766     r = guestfs_mount (g, device, mountpoint);
4767     if (r == -1)
4768       return -1;
4769   }
4770   /* TestOutputFalse for mv (1) */
4771   {
4772     char path[] = "/old";
4773     char content[] = "file content";
4774     int r;
4775     suppress_error = 0;
4776     r = guestfs_write_file (g, path, content, 0);
4777     if (r == -1)
4778       return -1;
4779   }
4780   {
4781     char src[] = "/old";
4782     char dest[] = "/new";
4783     int r;
4784     suppress_error = 0;
4785     r = guestfs_mv (g, src, dest);
4786     if (r == -1)
4787       return -1;
4788   }
4789   {
4790     char path[] = "/old";
4791     int r;
4792     suppress_error = 0;
4793     r = guestfs_is_file (g, path);
4794     if (r == -1)
4795       return -1;
4796     if (r) {
4797       fprintf (stderr, "test_mv_1: expected false, got true\n");
4798       return -1;
4799     }
4800   }
4801   return 0;
4802 }
4803
4804 static int test_cp_a_0_skip (void)
4805 {
4806   const char *str;
4807
4808   str = getenv ("TEST_ONLY");
4809   if (str)
4810     return strstr (str, "cp_a") == NULL;
4811   str = getenv ("SKIP_TEST_CP_A_0");
4812   if (str && strcmp (str, "1") == 0) return 1;
4813   str = getenv ("SKIP_TEST_CP_A");
4814   if (str && strcmp (str, "1") == 0) return 1;
4815   return 0;
4816 }
4817
4818 static int test_cp_a_0 (void)
4819 {
4820   if (test_cp_a_0_skip ()) {
4821     printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
4822     return 0;
4823   }
4824
4825   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
4826   {
4827     char device[] = "/dev/sda";
4828     int r;
4829     suppress_error = 0;
4830     r = guestfs_blockdev_setrw (g, device);
4831     if (r == -1)
4832       return -1;
4833   }
4834   {
4835     int r;
4836     suppress_error = 0;
4837     r = guestfs_umount_all (g);
4838     if (r == -1)
4839       return -1;
4840   }
4841   {
4842     int r;
4843     suppress_error = 0;
4844     r = guestfs_lvm_remove_all (g);
4845     if (r == -1)
4846       return -1;
4847   }
4848   {
4849     char device[] = "/dev/sda";
4850     char lines_0[] = ",";
4851     char *lines[] = {
4852       lines_0,
4853       NULL
4854     };
4855     int r;
4856     suppress_error = 0;
4857     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4858     if (r == -1)
4859       return -1;
4860   }
4861   {
4862     char fstype[] = "ext2";
4863     char device[] = "/dev/sda1";
4864     int r;
4865     suppress_error = 0;
4866     r = guestfs_mkfs (g, fstype, device);
4867     if (r == -1)
4868       return -1;
4869   }
4870   {
4871     char device[] = "/dev/sda1";
4872     char mountpoint[] = "/";
4873     int r;
4874     suppress_error = 0;
4875     r = guestfs_mount (g, device, mountpoint);
4876     if (r == -1)
4877       return -1;
4878   }
4879   /* TestOutput for cp_a (0) */
4880   char expected[] = "file content";
4881   {
4882     char path[] = "/olddir";
4883     int r;
4884     suppress_error = 0;
4885     r = guestfs_mkdir (g, path);
4886     if (r == -1)
4887       return -1;
4888   }
4889   {
4890     char path[] = "/newdir";
4891     int r;
4892     suppress_error = 0;
4893     r = guestfs_mkdir (g, path);
4894     if (r == -1)
4895       return -1;
4896   }
4897   {
4898     char path[] = "/olddir/file";
4899     char content[] = "file content";
4900     int r;
4901     suppress_error = 0;
4902     r = guestfs_write_file (g, path, content, 0);
4903     if (r == -1)
4904       return -1;
4905   }
4906   {
4907     char src[] = "/olddir";
4908     char dest[] = "/newdir";
4909     int r;
4910     suppress_error = 0;
4911     r = guestfs_cp_a (g, src, dest);
4912     if (r == -1)
4913       return -1;
4914   }
4915   {
4916     char path[] = "/newdir/olddir/file";
4917     char *r;
4918     suppress_error = 0;
4919     r = guestfs_cat (g, path);
4920     if (r == NULL)
4921       return -1;
4922     if (strcmp (r, expected) != 0) {
4923       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
4924       return -1;
4925     }
4926     free (r);
4927   }
4928   return 0;
4929 }
4930
4931 static int test_cp_0_skip (void)
4932 {
4933   const char *str;
4934
4935   str = getenv ("TEST_ONLY");
4936   if (str)
4937     return strstr (str, "cp") == NULL;
4938   str = getenv ("SKIP_TEST_CP_0");
4939   if (str && strcmp (str, "1") == 0) return 1;
4940   str = getenv ("SKIP_TEST_CP");
4941   if (str && strcmp (str, "1") == 0) return 1;
4942   return 0;
4943 }
4944
4945 static int test_cp_0 (void)
4946 {
4947   if (test_cp_0_skip ()) {
4948     printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
4949     return 0;
4950   }
4951
4952   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
4953   {
4954     char device[] = "/dev/sda";
4955     int r;
4956     suppress_error = 0;
4957     r = guestfs_blockdev_setrw (g, device);
4958     if (r == -1)
4959       return -1;
4960   }
4961   {
4962     int r;
4963     suppress_error = 0;
4964     r = guestfs_umount_all (g);
4965     if (r == -1)
4966       return -1;
4967   }
4968   {
4969     int r;
4970     suppress_error = 0;
4971     r = guestfs_lvm_remove_all (g);
4972     if (r == -1)
4973       return -1;
4974   }
4975   {
4976     char device[] = "/dev/sda";
4977     char lines_0[] = ",";
4978     char *lines[] = {
4979       lines_0,
4980       NULL
4981     };
4982     int r;
4983     suppress_error = 0;
4984     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4985     if (r == -1)
4986       return -1;
4987   }
4988   {
4989     char fstype[] = "ext2";
4990     char device[] = "/dev/sda1";
4991     int r;
4992     suppress_error = 0;
4993     r = guestfs_mkfs (g, fstype, device);
4994     if (r == -1)
4995       return -1;
4996   }
4997   {
4998     char device[] = "/dev/sda1";
4999     char mountpoint[] = "/";
5000     int r;
5001     suppress_error = 0;
5002     r = guestfs_mount (g, device, mountpoint);
5003     if (r == -1)
5004       return -1;
5005   }
5006   /* TestOutput for cp (0) */
5007   char expected[] = "file content";
5008   {
5009     char path[] = "/old";
5010     char content[] = "file content";
5011     int r;
5012     suppress_error = 0;
5013     r = guestfs_write_file (g, path, content, 0);
5014     if (r == -1)
5015       return -1;
5016   }
5017   {
5018     char src[] = "/old";
5019     char dest[] = "/new";
5020     int r;
5021     suppress_error = 0;
5022     r = guestfs_cp (g, src, dest);
5023     if (r == -1)
5024       return -1;
5025   }
5026   {
5027     char path[] = "/new";
5028     char *r;
5029     suppress_error = 0;
5030     r = guestfs_cat (g, path);
5031     if (r == NULL)
5032       return -1;
5033     if (strcmp (r, expected) != 0) {
5034       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5035       return -1;
5036     }
5037     free (r);
5038   }
5039   return 0;
5040 }
5041
5042 static int test_cp_1_skip (void)
5043 {
5044   const char *str;
5045
5046   str = getenv ("TEST_ONLY");
5047   if (str)
5048     return strstr (str, "cp") == NULL;
5049   str = getenv ("SKIP_TEST_CP_1");
5050   if (str && strcmp (str, "1") == 0) return 1;
5051   str = getenv ("SKIP_TEST_CP");
5052   if (str && strcmp (str, "1") == 0) return 1;
5053   return 0;
5054 }
5055
5056 static int test_cp_1 (void)
5057 {
5058   if (test_cp_1_skip ()) {
5059     printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
5060     return 0;
5061   }
5062
5063   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5064   {
5065     char device[] = "/dev/sda";
5066     int r;
5067     suppress_error = 0;
5068     r = guestfs_blockdev_setrw (g, device);
5069     if (r == -1)
5070       return -1;
5071   }
5072   {
5073     int r;
5074     suppress_error = 0;
5075     r = guestfs_umount_all (g);
5076     if (r == -1)
5077       return -1;
5078   }
5079   {
5080     int r;
5081     suppress_error = 0;
5082     r = guestfs_lvm_remove_all (g);
5083     if (r == -1)
5084       return -1;
5085   }
5086   {
5087     char device[] = "/dev/sda";
5088     char lines_0[] = ",";
5089     char *lines[] = {
5090       lines_0,
5091       NULL
5092     };
5093     int r;
5094     suppress_error = 0;
5095     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5096     if (r == -1)
5097       return -1;
5098   }
5099   {
5100     char fstype[] = "ext2";
5101     char device[] = "/dev/sda1";
5102     int r;
5103     suppress_error = 0;
5104     r = guestfs_mkfs (g, fstype, device);
5105     if (r == -1)
5106       return -1;
5107   }
5108   {
5109     char device[] = "/dev/sda1";
5110     char mountpoint[] = "/";
5111     int r;
5112     suppress_error = 0;
5113     r = guestfs_mount (g, device, mountpoint);
5114     if (r == -1)
5115       return -1;
5116   }
5117   /* TestOutputTrue for cp (1) */
5118   {
5119     char path[] = "/old";
5120     char content[] = "file content";
5121     int r;
5122     suppress_error = 0;
5123     r = guestfs_write_file (g, path, content, 0);
5124     if (r == -1)
5125       return -1;
5126   }
5127   {
5128     char src[] = "/old";
5129     char dest[] = "/new";
5130     int r;
5131     suppress_error = 0;
5132     r = guestfs_cp (g, src, dest);
5133     if (r == -1)
5134       return -1;
5135   }
5136   {
5137     char path[] = "/old";
5138     int r;
5139     suppress_error = 0;
5140     r = guestfs_is_file (g, path);
5141     if (r == -1)
5142       return -1;
5143     if (!r) {
5144       fprintf (stderr, "test_cp_1: expected true, got false\n");
5145       return -1;
5146     }
5147   }
5148   return 0;
5149 }
5150
5151 static int test_cp_2_skip (void)
5152 {
5153   const char *str;
5154
5155   str = getenv ("TEST_ONLY");
5156   if (str)
5157     return strstr (str, "cp") == NULL;
5158   str = getenv ("SKIP_TEST_CP_2");
5159   if (str && strcmp (str, "1") == 0) return 1;
5160   str = getenv ("SKIP_TEST_CP");
5161   if (str && strcmp (str, "1") == 0) return 1;
5162   return 0;
5163 }
5164
5165 static int test_cp_2 (void)
5166 {
5167   if (test_cp_2_skip ()) {
5168     printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5169     return 0;
5170   }
5171
5172   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5173   {
5174     char device[] = "/dev/sda";
5175     int r;
5176     suppress_error = 0;
5177     r = guestfs_blockdev_setrw (g, device);
5178     if (r == -1)
5179       return -1;
5180   }
5181   {
5182     int r;
5183     suppress_error = 0;
5184     r = guestfs_umount_all (g);
5185     if (r == -1)
5186       return -1;
5187   }
5188   {
5189     int r;
5190     suppress_error = 0;
5191     r = guestfs_lvm_remove_all (g);
5192     if (r == -1)
5193       return -1;
5194   }
5195   {
5196     char device[] = "/dev/sda";
5197     char lines_0[] = ",";
5198     char *lines[] = {
5199       lines_0,
5200       NULL
5201     };
5202     int r;
5203     suppress_error = 0;
5204     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5205     if (r == -1)
5206       return -1;
5207   }
5208   {
5209     char fstype[] = "ext2";
5210     char device[] = "/dev/sda1";
5211     int r;
5212     suppress_error = 0;
5213     r = guestfs_mkfs (g, fstype, device);
5214     if (r == -1)
5215       return -1;
5216   }
5217   {
5218     char device[] = "/dev/sda1";
5219     char mountpoint[] = "/";
5220     int r;
5221     suppress_error = 0;
5222     r = guestfs_mount (g, device, mountpoint);
5223     if (r == -1)
5224       return -1;
5225   }
5226   /* TestOutput for cp (2) */
5227   char expected[] = "file content";
5228   {
5229     char path[] = "/old";
5230     char content[] = "file content";
5231     int r;
5232     suppress_error = 0;
5233     r = guestfs_write_file (g, path, content, 0);
5234     if (r == -1)
5235       return -1;
5236   }
5237   {
5238     char path[] = "/dir";
5239     int r;
5240     suppress_error = 0;
5241     r = guestfs_mkdir (g, path);
5242     if (r == -1)
5243       return -1;
5244   }
5245   {
5246     char src[] = "/old";
5247     char dest[] = "/dir/new";
5248     int r;
5249     suppress_error = 0;
5250     r = guestfs_cp (g, src, dest);
5251     if (r == -1)
5252       return -1;
5253   }
5254   {
5255     char path[] = "/dir/new";
5256     char *r;
5257     suppress_error = 0;
5258     r = guestfs_cat (g, path);
5259     if (r == NULL)
5260       return -1;
5261     if (strcmp (r, expected) != 0) {
5262       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5263       return -1;
5264     }
5265     free (r);
5266   }
5267   return 0;
5268 }
5269
5270 static int test_grub_install_0_skip (void)
5271 {
5272   const char *str;
5273
5274   str = getenv ("TEST_ONLY");
5275   if (str)
5276     return strstr (str, "grub_install") == NULL;
5277   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5278   if (str && strcmp (str, "1") == 0) return 1;
5279   str = getenv ("SKIP_TEST_GRUB_INSTALL");
5280   if (str && strcmp (str, "1") == 0) return 1;
5281   return 0;
5282 }
5283
5284 static int test_grub_install_0 (void)
5285 {
5286   if (test_grub_install_0_skip ()) {
5287     printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5288     return 0;
5289   }
5290
5291   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5292   {
5293     char device[] = "/dev/sda";
5294     int r;
5295     suppress_error = 0;
5296     r = guestfs_blockdev_setrw (g, device);
5297     if (r == -1)
5298       return -1;
5299   }
5300   {
5301     int r;
5302     suppress_error = 0;
5303     r = guestfs_umount_all (g);
5304     if (r == -1)
5305       return -1;
5306   }
5307   {
5308     int r;
5309     suppress_error = 0;
5310     r = guestfs_lvm_remove_all (g);
5311     if (r == -1)
5312       return -1;
5313   }
5314   {
5315     char device[] = "/dev/sda";
5316     char lines_0[] = ",";
5317     char *lines[] = {
5318       lines_0,
5319       NULL
5320     };
5321     int r;
5322     suppress_error = 0;
5323     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5324     if (r == -1)
5325       return -1;
5326   }
5327   {
5328     char fstype[] = "ext2";
5329     char device[] = "/dev/sda1";
5330     int r;
5331     suppress_error = 0;
5332     r = guestfs_mkfs (g, fstype, device);
5333     if (r == -1)
5334       return -1;
5335   }
5336   {
5337     char device[] = "/dev/sda1";
5338     char mountpoint[] = "/";
5339     int r;
5340     suppress_error = 0;
5341     r = guestfs_mount (g, device, mountpoint);
5342     if (r == -1)
5343       return -1;
5344   }
5345   /* TestOutputTrue for grub_install (0) */
5346   {
5347     char root[] = "/";
5348     char device[] = "/dev/sda1";
5349     int r;
5350     suppress_error = 0;
5351     r = guestfs_grub_install (g, root, device);
5352     if (r == -1)
5353       return -1;
5354   }
5355   {
5356     char path[] = "/boot";
5357     int r;
5358     suppress_error = 0;
5359     r = guestfs_is_dir (g, path);
5360     if (r == -1)
5361       return -1;
5362     if (!r) {
5363       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5364       return -1;
5365     }
5366   }
5367   return 0;
5368 }
5369
5370 static int test_zero_0_skip (void)
5371 {
5372   const char *str;
5373
5374   str = getenv ("TEST_ONLY");
5375   if (str)
5376     return strstr (str, "zero") == NULL;
5377   str = getenv ("SKIP_TEST_ZERO_0");
5378   if (str && strcmp (str, "1") == 0) return 1;
5379   str = getenv ("SKIP_TEST_ZERO");
5380   if (str && strcmp (str, "1") == 0) return 1;
5381   return 0;
5382 }
5383
5384 static int test_zero_0 (void)
5385 {
5386   if (test_zero_0_skip ()) {
5387     printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5388     return 0;
5389   }
5390
5391   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5392   {
5393     char device[] = "/dev/sda";
5394     int r;
5395     suppress_error = 0;
5396     r = guestfs_blockdev_setrw (g, device);
5397     if (r == -1)
5398       return -1;
5399   }
5400   {
5401     int r;
5402     suppress_error = 0;
5403     r = guestfs_umount_all (g);
5404     if (r == -1)
5405       return -1;
5406   }
5407   {
5408     int r;
5409     suppress_error = 0;
5410     r = guestfs_lvm_remove_all (g);
5411     if (r == -1)
5412       return -1;
5413   }
5414   {
5415     char device[] = "/dev/sda";
5416     char lines_0[] = ",";
5417     char *lines[] = {
5418       lines_0,
5419       NULL
5420     };
5421     int r;
5422     suppress_error = 0;
5423     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5424     if (r == -1)
5425       return -1;
5426   }
5427   {
5428     char fstype[] = "ext2";
5429     char device[] = "/dev/sda1";
5430     int r;
5431     suppress_error = 0;
5432     r = guestfs_mkfs (g, fstype, device);
5433     if (r == -1)
5434       return -1;
5435   }
5436   {
5437     char device[] = "/dev/sda1";
5438     char mountpoint[] = "/";
5439     int r;
5440     suppress_error = 0;
5441     r = guestfs_mount (g, device, mountpoint);
5442     if (r == -1)
5443       return -1;
5444   }
5445   /* TestOutput for zero (0) */
5446   char expected[] = "data";
5447   {
5448     char pathordevice[] = "/dev/sda1";
5449     int r;
5450     suppress_error = 0;
5451     r = guestfs_umount (g, pathordevice);
5452     if (r == -1)
5453       return -1;
5454   }
5455   {
5456     char device[] = "/dev/sda1";
5457     int r;
5458     suppress_error = 0;
5459     r = guestfs_zero (g, device);
5460     if (r == -1)
5461       return -1;
5462   }
5463   {
5464     char path[] = "/dev/sda1";
5465     char *r;
5466     suppress_error = 0;
5467     r = guestfs_file (g, path);
5468     if (r == NULL)
5469       return -1;
5470     if (strcmp (r, expected) != 0) {
5471       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5472       return -1;
5473     }
5474     free (r);
5475   }
5476   return 0;
5477 }
5478
5479 static int test_fsck_0_skip (void)
5480 {
5481   const char *str;
5482
5483   str = getenv ("TEST_ONLY");
5484   if (str)
5485     return strstr (str, "fsck") == NULL;
5486   str = getenv ("SKIP_TEST_FSCK_0");
5487   if (str && strcmp (str, "1") == 0) return 1;
5488   str = getenv ("SKIP_TEST_FSCK");
5489   if (str && strcmp (str, "1") == 0) return 1;
5490   return 0;
5491 }
5492
5493 static int test_fsck_0 (void)
5494 {
5495   if (test_fsck_0_skip ()) {
5496     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5497     return 0;
5498   }
5499
5500   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5501   {
5502     char device[] = "/dev/sda";
5503     int r;
5504     suppress_error = 0;
5505     r = guestfs_blockdev_setrw (g, device);
5506     if (r == -1)
5507       return -1;
5508   }
5509   {
5510     int r;
5511     suppress_error = 0;
5512     r = guestfs_umount_all (g);
5513     if (r == -1)
5514       return -1;
5515   }
5516   {
5517     int r;
5518     suppress_error = 0;
5519     r = guestfs_lvm_remove_all (g);
5520     if (r == -1)
5521       return -1;
5522   }
5523   {
5524     char device[] = "/dev/sda";
5525     char lines_0[] = ",";
5526     char *lines[] = {
5527       lines_0,
5528       NULL
5529     };
5530     int r;
5531     suppress_error = 0;
5532     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5533     if (r == -1)
5534       return -1;
5535   }
5536   {
5537     char fstype[] = "ext2";
5538     char device[] = "/dev/sda1";
5539     int r;
5540     suppress_error = 0;
5541     r = guestfs_mkfs (g, fstype, device);
5542     if (r == -1)
5543       return -1;
5544   }
5545   {
5546     char device[] = "/dev/sda1";
5547     char mountpoint[] = "/";
5548     int r;
5549     suppress_error = 0;
5550     r = guestfs_mount (g, device, mountpoint);
5551     if (r == -1)
5552       return -1;
5553   }
5554   /* TestOutputInt for fsck (0) */
5555   {
5556     char pathordevice[] = "/dev/sda1";
5557     int r;
5558     suppress_error = 0;
5559     r = guestfs_umount (g, pathordevice);
5560     if (r == -1)
5561       return -1;
5562   }
5563   {
5564     char fstype[] = "ext2";
5565     char device[] = "/dev/sda1";
5566     int r;
5567     suppress_error = 0;
5568     r = guestfs_fsck (g, fstype, device);
5569     if (r == -1)
5570       return -1;
5571     if (r != 0) {
5572       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
5573       return -1;
5574     }
5575   }
5576   return 0;
5577 }
5578
5579 static int test_fsck_1_skip (void)
5580 {
5581   const char *str;
5582
5583   str = getenv ("TEST_ONLY");
5584   if (str)
5585     return strstr (str, "fsck") == NULL;
5586   str = getenv ("SKIP_TEST_FSCK_1");
5587   if (str && strcmp (str, "1") == 0) return 1;
5588   str = getenv ("SKIP_TEST_FSCK");
5589   if (str && strcmp (str, "1") == 0) return 1;
5590   return 0;
5591 }
5592
5593 static int test_fsck_1 (void)
5594 {
5595   if (test_fsck_1_skip ()) {
5596     printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5597     return 0;
5598   }
5599
5600   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5601   {
5602     char device[] = "/dev/sda";
5603     int r;
5604     suppress_error = 0;
5605     r = guestfs_blockdev_setrw (g, device);
5606     if (r == -1)
5607       return -1;
5608   }
5609   {
5610     int r;
5611     suppress_error = 0;
5612     r = guestfs_umount_all (g);
5613     if (r == -1)
5614       return -1;
5615   }
5616   {
5617     int r;
5618     suppress_error = 0;
5619     r = guestfs_lvm_remove_all (g);
5620     if (r == -1)
5621       return -1;
5622   }
5623   {
5624     char device[] = "/dev/sda";
5625     char lines_0[] = ",";
5626     char *lines[] = {
5627       lines_0,
5628       NULL
5629     };
5630     int r;
5631     suppress_error = 0;
5632     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5633     if (r == -1)
5634       return -1;
5635   }
5636   {
5637     char fstype[] = "ext2";
5638     char device[] = "/dev/sda1";
5639     int r;
5640     suppress_error = 0;
5641     r = guestfs_mkfs (g, fstype, device);
5642     if (r == -1)
5643       return -1;
5644   }
5645   {
5646     char device[] = "/dev/sda1";
5647     char mountpoint[] = "/";
5648     int r;
5649     suppress_error = 0;
5650     r = guestfs_mount (g, device, mountpoint);
5651     if (r == -1)
5652       return -1;
5653   }
5654   /* TestOutputInt for fsck (1) */
5655   {
5656     char pathordevice[] = "/dev/sda1";
5657     int r;
5658     suppress_error = 0;
5659     r = guestfs_umount (g, pathordevice);
5660     if (r == -1)
5661       return -1;
5662   }
5663   {
5664     char device[] = "/dev/sda1";
5665     int r;
5666     suppress_error = 0;
5667     r = guestfs_zero (g, device);
5668     if (r == -1)
5669       return -1;
5670   }
5671   {
5672     char fstype[] = "ext2";
5673     char device[] = "/dev/sda1";
5674     int r;
5675     suppress_error = 0;
5676     r = guestfs_fsck (g, fstype, device);
5677     if (r == -1)
5678       return -1;
5679     if (r != 8) {
5680       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
5681       return -1;
5682     }
5683   }
5684   return 0;
5685 }
5686
5687 static int test_set_e2uuid_0_skip (void)
5688 {
5689   const char *str;
5690
5691   str = getenv ("TEST_ONLY");
5692   if (str)
5693     return strstr (str, "set_e2uuid") == NULL;
5694   str = getenv ("SKIP_TEST_SET_E2UUID_0");
5695   if (str && strcmp (str, "1") == 0) return 1;
5696   str = getenv ("SKIP_TEST_SET_E2UUID");
5697   if (str && strcmp (str, "1") == 0) return 1;
5698   return 0;
5699 }
5700
5701 static int test_set_e2uuid_0 (void)
5702 {
5703   if (test_set_e2uuid_0_skip ()) {
5704     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5705     return 0;
5706   }
5707
5708   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5709   {
5710     char device[] = "/dev/sda";
5711     int r;
5712     suppress_error = 0;
5713     r = guestfs_blockdev_setrw (g, device);
5714     if (r == -1)
5715       return -1;
5716   }
5717   {
5718     int r;
5719     suppress_error = 0;
5720     r = guestfs_umount_all (g);
5721     if (r == -1)
5722       return -1;
5723   }
5724   {
5725     int r;
5726     suppress_error = 0;
5727     r = guestfs_lvm_remove_all (g);
5728     if (r == -1)
5729       return -1;
5730   }
5731   {
5732     char device[] = "/dev/sda";
5733     char lines_0[] = ",";
5734     char *lines[] = {
5735       lines_0,
5736       NULL
5737     };
5738     int r;
5739     suppress_error = 0;
5740     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5741     if (r == -1)
5742       return -1;
5743   }
5744   {
5745     char fstype[] = "ext2";
5746     char device[] = "/dev/sda1";
5747     int r;
5748     suppress_error = 0;
5749     r = guestfs_mkfs (g, fstype, device);
5750     if (r == -1)
5751       return -1;
5752   }
5753   {
5754     char device[] = "/dev/sda1";
5755     char mountpoint[] = "/";
5756     int r;
5757     suppress_error = 0;
5758     r = guestfs_mount (g, device, mountpoint);
5759     if (r == -1)
5760       return -1;
5761   }
5762   /* TestOutput for set_e2uuid (0) */
5763   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5764   {
5765     char device[] = "/dev/sda1";
5766     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5767     int r;
5768     suppress_error = 0;
5769     r = guestfs_set_e2uuid (g, device, uuid);
5770     if (r == -1)
5771       return -1;
5772   }
5773   {
5774     char device[] = "/dev/sda1";
5775     char *r;
5776     suppress_error = 0;
5777     r = guestfs_get_e2uuid (g, device);
5778     if (r == NULL)
5779       return -1;
5780     if (strcmp (r, expected) != 0) {
5781       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5782       return -1;
5783     }
5784     free (r);
5785   }
5786   return 0;
5787 }
5788
5789 static int test_set_e2uuid_1_skip (void)
5790 {
5791   const char *str;
5792
5793   str = getenv ("TEST_ONLY");
5794   if (str)
5795     return strstr (str, "set_e2uuid") == NULL;
5796   str = getenv ("SKIP_TEST_SET_E2UUID_1");
5797   if (str && strcmp (str, "1") == 0) return 1;
5798   str = getenv ("SKIP_TEST_SET_E2UUID");
5799   if (str && strcmp (str, "1") == 0) return 1;
5800   return 0;
5801 }
5802
5803 static int test_set_e2uuid_1 (void)
5804 {
5805   if (test_set_e2uuid_1_skip ()) {
5806     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
5807     return 0;
5808   }
5809
5810   /* InitBasicFS for test_set_e2uuid_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   /* TestOutput for set_e2uuid (1) */
5865   char expected[] = "";
5866   {
5867     char device[] = "/dev/sda1";
5868     char uuid[] = "clear";
5869     int r;
5870     suppress_error = 0;
5871     r = guestfs_set_e2uuid (g, device, uuid);
5872     if (r == -1)
5873       return -1;
5874   }
5875   {
5876     char device[] = "/dev/sda1";
5877     char *r;
5878     suppress_error = 0;
5879     r = guestfs_get_e2uuid (g, device);
5880     if (r == NULL)
5881       return -1;
5882     if (strcmp (r, expected) != 0) {
5883       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
5884       return -1;
5885     }
5886     free (r);
5887   }
5888   return 0;
5889 }
5890
5891 static int test_set_e2uuid_2_skip (void)
5892 {
5893   const char *str;
5894
5895   str = getenv ("TEST_ONLY");
5896   if (str)
5897     return strstr (str, "set_e2uuid") == NULL;
5898   str = getenv ("SKIP_TEST_SET_E2UUID_2");
5899   if (str && strcmp (str, "1") == 0) return 1;
5900   str = getenv ("SKIP_TEST_SET_E2UUID");
5901   if (str && strcmp (str, "1") == 0) return 1;
5902   return 0;
5903 }
5904
5905 static int test_set_e2uuid_2 (void)
5906 {
5907   if (test_set_e2uuid_2_skip ()) {
5908     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
5909     return 0;
5910   }
5911
5912   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
5913   {
5914     char device[] = "/dev/sda";
5915     int r;
5916     suppress_error = 0;
5917     r = guestfs_blockdev_setrw (g, device);
5918     if (r == -1)
5919       return -1;
5920   }
5921   {
5922     int r;
5923     suppress_error = 0;
5924     r = guestfs_umount_all (g);
5925     if (r == -1)
5926       return -1;
5927   }
5928   {
5929     int r;
5930     suppress_error = 0;
5931     r = guestfs_lvm_remove_all (g);
5932     if (r == -1)
5933       return -1;
5934   }
5935   {
5936     char device[] = "/dev/sda";
5937     char lines_0[] = ",";
5938     char *lines[] = {
5939       lines_0,
5940       NULL
5941     };
5942     int r;
5943     suppress_error = 0;
5944     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5945     if (r == -1)
5946       return -1;
5947   }
5948   {
5949     char fstype[] = "ext2";
5950     char device[] = "/dev/sda1";
5951     int r;
5952     suppress_error = 0;
5953     r = guestfs_mkfs (g, fstype, device);
5954     if (r == -1)
5955       return -1;
5956   }
5957   {
5958     char device[] = "/dev/sda1";
5959     char mountpoint[] = "/";
5960     int r;
5961     suppress_error = 0;
5962     r = guestfs_mount (g, device, mountpoint);
5963     if (r == -1)
5964       return -1;
5965   }
5966   /* TestRun for set_e2uuid (2) */
5967   {
5968     char device[] = "/dev/sda1";
5969     char uuid[] = "random";
5970     int r;
5971     suppress_error = 0;
5972     r = guestfs_set_e2uuid (g, device, uuid);
5973     if (r == -1)
5974       return -1;
5975   }
5976   return 0;
5977 }
5978
5979 static int test_set_e2uuid_3_skip (void)
5980 {
5981   const char *str;
5982
5983   str = getenv ("TEST_ONLY");
5984   if (str)
5985     return strstr (str, "set_e2uuid") == NULL;
5986   str = getenv ("SKIP_TEST_SET_E2UUID_3");
5987   if (str && strcmp (str, "1") == 0) return 1;
5988   str = getenv ("SKIP_TEST_SET_E2UUID");
5989   if (str && strcmp (str, "1") == 0) return 1;
5990   return 0;
5991 }
5992
5993 static int test_set_e2uuid_3 (void)
5994 {
5995   if (test_set_e2uuid_3_skip ()) {
5996     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
5997     return 0;
5998   }
5999
6000   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6001   {
6002     char device[] = "/dev/sda";
6003     int r;
6004     suppress_error = 0;
6005     r = guestfs_blockdev_setrw (g, device);
6006     if (r == -1)
6007       return -1;
6008   }
6009   {
6010     int r;
6011     suppress_error = 0;
6012     r = guestfs_umount_all (g);
6013     if (r == -1)
6014       return -1;
6015   }
6016   {
6017     int r;
6018     suppress_error = 0;
6019     r = guestfs_lvm_remove_all (g);
6020     if (r == -1)
6021       return -1;
6022   }
6023   {
6024     char device[] = "/dev/sda";
6025     char lines_0[] = ",";
6026     char *lines[] = {
6027       lines_0,
6028       NULL
6029     };
6030     int r;
6031     suppress_error = 0;
6032     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6033     if (r == -1)
6034       return -1;
6035   }
6036   {
6037     char fstype[] = "ext2";
6038     char device[] = "/dev/sda1";
6039     int r;
6040     suppress_error = 0;
6041     r = guestfs_mkfs (g, fstype, device);
6042     if (r == -1)
6043       return -1;
6044   }
6045   {
6046     char device[] = "/dev/sda1";
6047     char mountpoint[] = "/";
6048     int r;
6049     suppress_error = 0;
6050     r = guestfs_mount (g, device, mountpoint);
6051     if (r == -1)
6052       return -1;
6053   }
6054   /* TestRun for set_e2uuid (3) */
6055   {
6056     char device[] = "/dev/sda1";
6057     char uuid[] = "time";
6058     int r;
6059     suppress_error = 0;
6060     r = guestfs_set_e2uuid (g, device, uuid);
6061     if (r == -1)
6062       return -1;
6063   }
6064   return 0;
6065 }
6066
6067 static int test_set_e2label_0_skip (void)
6068 {
6069   const char *str;
6070
6071   str = getenv ("TEST_ONLY");
6072   if (str)
6073     return strstr (str, "set_e2label") == NULL;
6074   str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6075   if (str && strcmp (str, "1") == 0) return 1;
6076   str = getenv ("SKIP_TEST_SET_E2LABEL");
6077   if (str && strcmp (str, "1") == 0) return 1;
6078   return 0;
6079 }
6080
6081 static int test_set_e2label_0 (void)
6082 {
6083   if (test_set_e2label_0_skip ()) {
6084     printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6085     return 0;
6086   }
6087
6088   /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6089   {
6090     char device[] = "/dev/sda";
6091     int r;
6092     suppress_error = 0;
6093     r = guestfs_blockdev_setrw (g, device);
6094     if (r == -1)
6095       return -1;
6096   }
6097   {
6098     int r;
6099     suppress_error = 0;
6100     r = guestfs_umount_all (g);
6101     if (r == -1)
6102       return -1;
6103   }
6104   {
6105     int r;
6106     suppress_error = 0;
6107     r = guestfs_lvm_remove_all (g);
6108     if (r == -1)
6109       return -1;
6110   }
6111   {
6112     char device[] = "/dev/sda";
6113     char lines_0[] = ",";
6114     char *lines[] = {
6115       lines_0,
6116       NULL
6117     };
6118     int r;
6119     suppress_error = 0;
6120     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6121     if (r == -1)
6122       return -1;
6123   }
6124   {
6125     char fstype[] = "ext2";
6126     char device[] = "/dev/sda1";
6127     int r;
6128     suppress_error = 0;
6129     r = guestfs_mkfs (g, fstype, device);
6130     if (r == -1)
6131       return -1;
6132   }
6133   {
6134     char device[] = "/dev/sda1";
6135     char mountpoint[] = "/";
6136     int r;
6137     suppress_error = 0;
6138     r = guestfs_mount (g, device, mountpoint);
6139     if (r == -1)
6140       return -1;
6141   }
6142   /* TestOutput for set_e2label (0) */
6143   char expected[] = "testlabel";
6144   {
6145     char device[] = "/dev/sda1";
6146     char label[] = "testlabel";
6147     int r;
6148     suppress_error = 0;
6149     r = guestfs_set_e2label (g, device, label);
6150     if (r == -1)
6151       return -1;
6152   }
6153   {
6154     char device[] = "/dev/sda1";
6155     char *r;
6156     suppress_error = 0;
6157     r = guestfs_get_e2label (g, device);
6158     if (r == NULL)
6159       return -1;
6160     if (strcmp (r, expected) != 0) {
6161       fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6162       return -1;
6163     }
6164     free (r);
6165   }
6166   return 0;
6167 }
6168
6169 static int test_pvremove_0_skip (void)
6170 {
6171   const char *str;
6172
6173   str = getenv ("TEST_ONLY");
6174   if (str)
6175     return strstr (str, "pvremove") == NULL;
6176   str = getenv ("SKIP_TEST_PVREMOVE_0");
6177   if (str && strcmp (str, "1") == 0) return 1;
6178   str = getenv ("SKIP_TEST_PVREMOVE");
6179   if (str && strcmp (str, "1") == 0) return 1;
6180   return 0;
6181 }
6182
6183 static int test_pvremove_0 (void)
6184 {
6185   if (test_pvremove_0_skip ()) {
6186     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6187     return 0;
6188   }
6189
6190   /* InitNone|InitEmpty for test_pvremove_0 */
6191   {
6192     char device[] = "/dev/sda";
6193     int r;
6194     suppress_error = 0;
6195     r = guestfs_blockdev_setrw (g, device);
6196     if (r == -1)
6197       return -1;
6198   }
6199   {
6200     int r;
6201     suppress_error = 0;
6202     r = guestfs_umount_all (g);
6203     if (r == -1)
6204       return -1;
6205   }
6206   {
6207     int r;
6208     suppress_error = 0;
6209     r = guestfs_lvm_remove_all (g);
6210     if (r == -1)
6211       return -1;
6212   }
6213   /* TestOutputListOfDevices for pvremove (0) */
6214   {
6215     char device[] = "/dev/sda";
6216     char lines_0[] = ",";
6217     char *lines[] = {
6218       lines_0,
6219       NULL
6220     };
6221     int r;
6222     suppress_error = 0;
6223     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6224     if (r == -1)
6225       return -1;
6226   }
6227   {
6228     char device[] = "/dev/sda1";
6229     int r;
6230     suppress_error = 0;
6231     r = guestfs_pvcreate (g, device);
6232     if (r == -1)
6233       return -1;
6234   }
6235   {
6236     char volgroup[] = "VG";
6237     char physvols_0[] = "/dev/sda1";
6238     char *physvols[] = {
6239       physvols_0,
6240       NULL
6241     };
6242     int r;
6243     suppress_error = 0;
6244     r = guestfs_vgcreate (g, volgroup, physvols);
6245     if (r == -1)
6246       return -1;
6247   }
6248   {
6249     char logvol[] = "LV1";
6250     char volgroup[] = "VG";
6251     int r;
6252     suppress_error = 0;
6253     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6254     if (r == -1)
6255       return -1;
6256   }
6257   {
6258     char logvol[] = "LV2";
6259     char volgroup[] = "VG";
6260     int r;
6261     suppress_error = 0;
6262     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6263     if (r == -1)
6264       return -1;
6265   }
6266   {
6267     char vgname[] = "VG";
6268     int r;
6269     suppress_error = 0;
6270     r = guestfs_vgremove (g, vgname);
6271     if (r == -1)
6272       return -1;
6273   }
6274   {
6275     char device[] = "/dev/sda1";
6276     int r;
6277     suppress_error = 0;
6278     r = guestfs_pvremove (g, device);
6279     if (r == -1)
6280       return -1;
6281   }
6282   {
6283     char **r;
6284     int i;
6285     suppress_error = 0;
6286     r = guestfs_lvs (g);
6287     if (r == NULL)
6288       return -1;
6289     if (r[0] != NULL) {
6290       fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6291       print_strings (r);
6292       return -1;
6293     }
6294     for (i = 0; r[i] != NULL; ++i)
6295       free (r[i]);
6296     free (r);
6297   }
6298   return 0;
6299 }
6300
6301 static int test_pvremove_1_skip (void)
6302 {
6303   const char *str;
6304
6305   str = getenv ("TEST_ONLY");
6306   if (str)
6307     return strstr (str, "pvremove") == NULL;
6308   str = getenv ("SKIP_TEST_PVREMOVE_1");
6309   if (str && strcmp (str, "1") == 0) return 1;
6310   str = getenv ("SKIP_TEST_PVREMOVE");
6311   if (str && strcmp (str, "1") == 0) return 1;
6312   return 0;
6313 }
6314
6315 static int test_pvremove_1 (void)
6316 {
6317   if (test_pvremove_1_skip ()) {
6318     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6319     return 0;
6320   }
6321
6322   /* InitNone|InitEmpty for test_pvremove_1 */
6323   {
6324     char device[] = "/dev/sda";
6325     int r;
6326     suppress_error = 0;
6327     r = guestfs_blockdev_setrw (g, device);
6328     if (r == -1)
6329       return -1;
6330   }
6331   {
6332     int r;
6333     suppress_error = 0;
6334     r = guestfs_umount_all (g);
6335     if (r == -1)
6336       return -1;
6337   }
6338   {
6339     int r;
6340     suppress_error = 0;
6341     r = guestfs_lvm_remove_all (g);
6342     if (r == -1)
6343       return -1;
6344   }
6345   /* TestOutputListOfDevices for pvremove (1) */
6346   {
6347     char device[] = "/dev/sda";
6348     char lines_0[] = ",";
6349     char *lines[] = {
6350       lines_0,
6351       NULL
6352     };
6353     int r;
6354     suppress_error = 0;
6355     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6356     if (r == -1)
6357       return -1;
6358   }
6359   {
6360     char device[] = "/dev/sda1";
6361     int r;
6362     suppress_error = 0;
6363     r = guestfs_pvcreate (g, device);
6364     if (r == -1)
6365       return -1;
6366   }
6367   {
6368     char volgroup[] = "VG";
6369     char physvols_0[] = "/dev/sda1";
6370     char *physvols[] = {
6371       physvols_0,
6372       NULL
6373     };
6374     int r;
6375     suppress_error = 0;
6376     r = guestfs_vgcreate (g, volgroup, physvols);
6377     if (r == -1)
6378       return -1;
6379   }
6380   {
6381     char logvol[] = "LV1";
6382     char volgroup[] = "VG";
6383     int r;
6384     suppress_error = 0;
6385     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6386     if (r == -1)
6387       return -1;
6388   }
6389   {
6390     char logvol[] = "LV2";
6391     char volgroup[] = "VG";
6392     int r;
6393     suppress_error = 0;
6394     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6395     if (r == -1)
6396       return -1;
6397   }
6398   {
6399     char vgname[] = "VG";
6400     int r;
6401     suppress_error = 0;
6402     r = guestfs_vgremove (g, vgname);
6403     if (r == -1)
6404       return -1;
6405   }
6406   {
6407     char device[] = "/dev/sda1";
6408     int r;
6409     suppress_error = 0;
6410     r = guestfs_pvremove (g, device);
6411     if (r == -1)
6412       return -1;
6413   }
6414   {
6415     char **r;
6416     int i;
6417     suppress_error = 0;
6418     r = guestfs_vgs (g);
6419     if (r == NULL)
6420       return -1;
6421     if (r[0] != NULL) {
6422       fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6423       print_strings (r);
6424       return -1;
6425     }
6426     for (i = 0; r[i] != NULL; ++i)
6427       free (r[i]);
6428     free (r);
6429   }
6430   return 0;
6431 }
6432
6433 static int test_pvremove_2_skip (void)
6434 {
6435   const char *str;
6436
6437   str = getenv ("TEST_ONLY");
6438   if (str)
6439     return strstr (str, "pvremove") == NULL;
6440   str = getenv ("SKIP_TEST_PVREMOVE_2");
6441   if (str && strcmp (str, "1") == 0) return 1;
6442   str = getenv ("SKIP_TEST_PVREMOVE");
6443   if (str && strcmp (str, "1") == 0) return 1;
6444   return 0;
6445 }
6446
6447 static int test_pvremove_2 (void)
6448 {
6449   if (test_pvremove_2_skip ()) {
6450     printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6451     return 0;
6452   }
6453
6454   /* InitNone|InitEmpty for test_pvremove_2 */
6455   {
6456     char device[] = "/dev/sda";
6457     int r;
6458     suppress_error = 0;
6459     r = guestfs_blockdev_setrw (g, device);
6460     if (r == -1)
6461       return -1;
6462   }
6463   {
6464     int r;
6465     suppress_error = 0;
6466     r = guestfs_umount_all (g);
6467     if (r == -1)
6468       return -1;
6469   }
6470   {
6471     int r;
6472     suppress_error = 0;
6473     r = guestfs_lvm_remove_all (g);
6474     if (r == -1)
6475       return -1;
6476   }
6477   /* TestOutputListOfDevices for pvremove (2) */
6478   {
6479     char device[] = "/dev/sda";
6480     char lines_0[] = ",";
6481     char *lines[] = {
6482       lines_0,
6483       NULL
6484     };
6485     int r;
6486     suppress_error = 0;
6487     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6488     if (r == -1)
6489       return -1;
6490   }
6491   {
6492     char device[] = "/dev/sda1";
6493     int r;
6494     suppress_error = 0;
6495     r = guestfs_pvcreate (g, device);
6496     if (r == -1)
6497       return -1;
6498   }
6499   {
6500     char volgroup[] = "VG";
6501     char physvols_0[] = "/dev/sda1";
6502     char *physvols[] = {
6503       physvols_0,
6504       NULL
6505     };
6506     int r;
6507     suppress_error = 0;
6508     r = guestfs_vgcreate (g, volgroup, physvols);
6509     if (r == -1)
6510       return -1;
6511   }
6512   {
6513     char logvol[] = "LV1";
6514     char volgroup[] = "VG";
6515     int r;
6516     suppress_error = 0;
6517     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6518     if (r == -1)
6519       return -1;
6520   }
6521   {
6522     char logvol[] = "LV2";
6523     char volgroup[] = "VG";
6524     int r;
6525     suppress_error = 0;
6526     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6527     if (r == -1)
6528       return -1;
6529   }
6530   {
6531     char vgname[] = "VG";
6532     int r;
6533     suppress_error = 0;
6534     r = guestfs_vgremove (g, vgname);
6535     if (r == -1)
6536       return -1;
6537   }
6538   {
6539     char device[] = "/dev/sda1";
6540     int r;
6541     suppress_error = 0;
6542     r = guestfs_pvremove (g, device);
6543     if (r == -1)
6544       return -1;
6545   }
6546   {
6547     char **r;
6548     int i;
6549     suppress_error = 0;
6550     r = guestfs_pvs (g);
6551     if (r == NULL)
6552       return -1;
6553     if (r[0] != NULL) {
6554       fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6555       print_strings (r);
6556       return -1;
6557     }
6558     for (i = 0; r[i] != NULL; ++i)
6559       free (r[i]);
6560     free (r);
6561   }
6562   return 0;
6563 }
6564
6565 static int test_vgremove_0_skip (void)
6566 {
6567   const char *str;
6568
6569   str = getenv ("TEST_ONLY");
6570   if (str)
6571     return strstr (str, "vgremove") == NULL;
6572   str = getenv ("SKIP_TEST_VGREMOVE_0");
6573   if (str && strcmp (str, "1") == 0) return 1;
6574   str = getenv ("SKIP_TEST_VGREMOVE");
6575   if (str && strcmp (str, "1") == 0) return 1;
6576   return 0;
6577 }
6578
6579 static int test_vgremove_0 (void)
6580 {
6581   if (test_vgremove_0_skip ()) {
6582     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6583     return 0;
6584   }
6585
6586   /* InitNone|InitEmpty for test_vgremove_0 */
6587   {
6588     char device[] = "/dev/sda";
6589     int r;
6590     suppress_error = 0;
6591     r = guestfs_blockdev_setrw (g, device);
6592     if (r == -1)
6593       return -1;
6594   }
6595   {
6596     int r;
6597     suppress_error = 0;
6598     r = guestfs_umount_all (g);
6599     if (r == -1)
6600       return -1;
6601   }
6602   {
6603     int r;
6604     suppress_error = 0;
6605     r = guestfs_lvm_remove_all (g);
6606     if (r == -1)
6607       return -1;
6608   }
6609   /* TestOutputList for vgremove (0) */
6610   {
6611     char device[] = "/dev/sda";
6612     char lines_0[] = ",";
6613     char *lines[] = {
6614       lines_0,
6615       NULL
6616     };
6617     int r;
6618     suppress_error = 0;
6619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6620     if (r == -1)
6621       return -1;
6622   }
6623   {
6624     char device[] = "/dev/sda1";
6625     int r;
6626     suppress_error = 0;
6627     r = guestfs_pvcreate (g, device);
6628     if (r == -1)
6629       return -1;
6630   }
6631   {
6632     char volgroup[] = "VG";
6633     char physvols_0[] = "/dev/sda1";
6634     char *physvols[] = {
6635       physvols_0,
6636       NULL
6637     };
6638     int r;
6639     suppress_error = 0;
6640     r = guestfs_vgcreate (g, volgroup, physvols);
6641     if (r == -1)
6642       return -1;
6643   }
6644   {
6645     char logvol[] = "LV1";
6646     char volgroup[] = "VG";
6647     int r;
6648     suppress_error = 0;
6649     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6650     if (r == -1)
6651       return -1;
6652   }
6653   {
6654     char logvol[] = "LV2";
6655     char volgroup[] = "VG";
6656     int r;
6657     suppress_error = 0;
6658     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6659     if (r == -1)
6660       return -1;
6661   }
6662   {
6663     char vgname[] = "VG";
6664     int r;
6665     suppress_error = 0;
6666     r = guestfs_vgremove (g, vgname);
6667     if (r == -1)
6668       return -1;
6669   }
6670   {
6671     char **r;
6672     int i;
6673     suppress_error = 0;
6674     r = guestfs_lvs (g);
6675     if (r == NULL)
6676       return -1;
6677     if (r[0] != NULL) {
6678       fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6679       print_strings (r);
6680       return -1;
6681     }
6682     for (i = 0; r[i] != NULL; ++i)
6683       free (r[i]);
6684     free (r);
6685   }
6686   return 0;
6687 }
6688
6689 static int test_vgremove_1_skip (void)
6690 {
6691   const char *str;
6692
6693   str = getenv ("TEST_ONLY");
6694   if (str)
6695     return strstr (str, "vgremove") == NULL;
6696   str = getenv ("SKIP_TEST_VGREMOVE_1");
6697   if (str && strcmp (str, "1") == 0) return 1;
6698   str = getenv ("SKIP_TEST_VGREMOVE");
6699   if (str && strcmp (str, "1") == 0) return 1;
6700   return 0;
6701 }
6702
6703 static int test_vgremove_1 (void)
6704 {
6705   if (test_vgremove_1_skip ()) {
6706     printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6707     return 0;
6708   }
6709
6710   /* InitNone|InitEmpty for test_vgremove_1 */
6711   {
6712     char device[] = "/dev/sda";
6713     int r;
6714     suppress_error = 0;
6715     r = guestfs_blockdev_setrw (g, device);
6716     if (r == -1)
6717       return -1;
6718   }
6719   {
6720     int r;
6721     suppress_error = 0;
6722     r = guestfs_umount_all (g);
6723     if (r == -1)
6724       return -1;
6725   }
6726   {
6727     int r;
6728     suppress_error = 0;
6729     r = guestfs_lvm_remove_all (g);
6730     if (r == -1)
6731       return -1;
6732   }
6733   /* TestOutputList for vgremove (1) */
6734   {
6735     char device[] = "/dev/sda";
6736     char lines_0[] = ",";
6737     char *lines[] = {
6738       lines_0,
6739       NULL
6740     };
6741     int r;
6742     suppress_error = 0;
6743     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6744     if (r == -1)
6745       return -1;
6746   }
6747   {
6748     char device[] = "/dev/sda1";
6749     int r;
6750     suppress_error = 0;
6751     r = guestfs_pvcreate (g, device);
6752     if (r == -1)
6753       return -1;
6754   }
6755   {
6756     char volgroup[] = "VG";
6757     char physvols_0[] = "/dev/sda1";
6758     char *physvols[] = {
6759       physvols_0,
6760       NULL
6761     };
6762     int r;
6763     suppress_error = 0;
6764     r = guestfs_vgcreate (g, volgroup, physvols);
6765     if (r == -1)
6766       return -1;
6767   }
6768   {
6769     char logvol[] = "LV1";
6770     char volgroup[] = "VG";
6771     int r;
6772     suppress_error = 0;
6773     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6774     if (r == -1)
6775       return -1;
6776   }
6777   {
6778     char logvol[] = "LV2";
6779     char volgroup[] = "VG";
6780     int r;
6781     suppress_error = 0;
6782     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6783     if (r == -1)
6784       return -1;
6785   }
6786   {
6787     char vgname[] = "VG";
6788     int r;
6789     suppress_error = 0;
6790     r = guestfs_vgremove (g, vgname);
6791     if (r == -1)
6792       return -1;
6793   }
6794   {
6795     char **r;
6796     int i;
6797     suppress_error = 0;
6798     r = guestfs_vgs (g);
6799     if (r == NULL)
6800       return -1;
6801     if (r[0] != NULL) {
6802       fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
6803       print_strings (r);
6804       return -1;
6805     }
6806     for (i = 0; r[i] != NULL; ++i)
6807       free (r[i]);
6808     free (r);
6809   }
6810   return 0;
6811 }
6812
6813 static int test_lvremove_0_skip (void)
6814 {
6815   const char *str;
6816
6817   str = getenv ("TEST_ONLY");
6818   if (str)
6819     return strstr (str, "lvremove") == NULL;
6820   str = getenv ("SKIP_TEST_LVREMOVE_0");
6821   if (str && strcmp (str, "1") == 0) return 1;
6822   str = getenv ("SKIP_TEST_LVREMOVE");
6823   if (str && strcmp (str, "1") == 0) return 1;
6824   return 0;
6825 }
6826
6827 static int test_lvremove_0 (void)
6828 {
6829   if (test_lvremove_0_skip ()) {
6830     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
6831     return 0;
6832   }
6833
6834   /* InitNone|InitEmpty for test_lvremove_0 */
6835   {
6836     char device[] = "/dev/sda";
6837     int r;
6838     suppress_error = 0;
6839     r = guestfs_blockdev_setrw (g, device);
6840     if (r == -1)
6841       return -1;
6842   }
6843   {
6844     int r;
6845     suppress_error = 0;
6846     r = guestfs_umount_all (g);
6847     if (r == -1)
6848       return -1;
6849   }
6850   {
6851     int r;
6852     suppress_error = 0;
6853     r = guestfs_lvm_remove_all (g);
6854     if (r == -1)
6855       return -1;
6856   }
6857   /* TestOutputList for lvremove (0) */
6858   {
6859     char device[] = "/dev/sda";
6860     char lines_0[] = ",";
6861     char *lines[] = {
6862       lines_0,
6863       NULL
6864     };
6865     int r;
6866     suppress_error = 0;
6867     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6868     if (r == -1)
6869       return -1;
6870   }
6871   {
6872     char device[] = "/dev/sda1";
6873     int r;
6874     suppress_error = 0;
6875     r = guestfs_pvcreate (g, device);
6876     if (r == -1)
6877       return -1;
6878   }
6879   {
6880     char volgroup[] = "VG";
6881     char physvols_0[] = "/dev/sda1";
6882     char *physvols[] = {
6883       physvols_0,
6884       NULL
6885     };
6886     int r;
6887     suppress_error = 0;
6888     r = guestfs_vgcreate (g, volgroup, physvols);
6889     if (r == -1)
6890       return -1;
6891   }
6892   {
6893     char logvol[] = "LV1";
6894     char volgroup[] = "VG";
6895     int r;
6896     suppress_error = 0;
6897     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6898     if (r == -1)
6899       return -1;
6900   }
6901   {
6902     char logvol[] = "LV2";
6903     char volgroup[] = "VG";
6904     int r;
6905     suppress_error = 0;
6906     r = guestfs_lvcreate (g, logvol, volgroup, 50);
6907     if (r == -1)
6908       return -1;
6909   }
6910   {
6911     char device[] = "/dev/VG/LV1";
6912     int r;
6913     suppress_error = 0;
6914     r = guestfs_lvremove (g, device);
6915     if (r == -1)
6916       return -1;
6917   }
6918   {
6919     char **r;
6920     int i;
6921     suppress_error = 0;
6922     r = guestfs_lvs (g);
6923     if (r == NULL)
6924       return -1;
6925     if (!r[0]) {
6926       fprintf (stderr, "test_lvremove_0: short list returned from command\n");
6927       print_strings (r);
6928       return -1;
6929     }
6930     {
6931       char expected[] = "/dev/VG/LV2";
6932       if (strcmp (r[0], expected) != 0) {
6933         fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6934         return -1;
6935       }
6936     }
6937     if (r[1] != NULL) {
6938       fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
6939       print_strings (r);
6940       return -1;
6941     }
6942     for (i = 0; r[i] != NULL; ++i)
6943       free (r[i]);
6944     free (r);
6945   }
6946   return 0;
6947 }
6948
6949 static int test_lvremove_1_skip (void)
6950 {
6951   const char *str;
6952
6953   str = getenv ("TEST_ONLY");
6954   if (str)
6955     return strstr (str, "lvremove") == NULL;
6956   str = getenv ("SKIP_TEST_LVREMOVE_1");
6957   if (str && strcmp (str, "1") == 0) return 1;
6958   str = getenv ("SKIP_TEST_LVREMOVE");
6959   if (str && strcmp (str, "1") == 0) return 1;
6960   return 0;
6961 }
6962
6963 static int test_lvremove_1 (void)
6964 {
6965   if (test_lvremove_1_skip ()) {
6966     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
6967     return 0;
6968   }
6969
6970   /* InitNone|InitEmpty for test_lvremove_1 */
6971   {
6972     char device[] = "/dev/sda";
6973     int r;
6974     suppress_error = 0;
6975     r = guestfs_blockdev_setrw (g, device);
6976     if (r == -1)
6977       return -1;
6978   }
6979   {
6980     int r;
6981     suppress_error = 0;
6982     r = guestfs_umount_all (g);
6983     if (r == -1)
6984       return -1;
6985   }
6986   {
6987     int r;
6988     suppress_error = 0;
6989     r = guestfs_lvm_remove_all (g);
6990     if (r == -1)
6991       return -1;
6992   }
6993   /* TestOutputList for lvremove (1) */
6994   {
6995     char device[] = "/dev/sda";
6996     char lines_0[] = ",";
6997     char *lines[] = {
6998       lines_0,
6999       NULL
7000     };
7001     int r;
7002     suppress_error = 0;
7003     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7004     if (r == -1)
7005       return -1;
7006   }
7007   {
7008     char device[] = "/dev/sda1";
7009     int r;
7010     suppress_error = 0;
7011     r = guestfs_pvcreate (g, device);
7012     if (r == -1)
7013       return -1;
7014   }
7015   {
7016     char volgroup[] = "VG";
7017     char physvols_0[] = "/dev/sda1";
7018     char *physvols[] = {
7019       physvols_0,
7020       NULL
7021     };
7022     int r;
7023     suppress_error = 0;
7024     r = guestfs_vgcreate (g, volgroup, physvols);
7025     if (r == -1)
7026       return -1;
7027   }
7028   {
7029     char logvol[] = "LV1";
7030     char volgroup[] = "VG";
7031     int r;
7032     suppress_error = 0;
7033     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7034     if (r == -1)
7035       return -1;
7036   }
7037   {
7038     char logvol[] = "LV2";
7039     char volgroup[] = "VG";
7040     int r;
7041     suppress_error = 0;
7042     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7043     if (r == -1)
7044       return -1;
7045   }
7046   {
7047     char device[] = "/dev/VG";
7048     int r;
7049     suppress_error = 0;
7050     r = guestfs_lvremove (g, device);
7051     if (r == -1)
7052       return -1;
7053   }
7054   {
7055     char **r;
7056     int i;
7057     suppress_error = 0;
7058     r = guestfs_lvs (g);
7059     if (r == NULL)
7060       return -1;
7061     if (r[0] != NULL) {
7062       fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7063       print_strings (r);
7064       return -1;
7065     }
7066     for (i = 0; r[i] != NULL; ++i)
7067       free (r[i]);
7068     free (r);
7069   }
7070   return 0;
7071 }
7072
7073 static int test_lvremove_2_skip (void)
7074 {
7075   const char *str;
7076
7077   str = getenv ("TEST_ONLY");
7078   if (str)
7079     return strstr (str, "lvremove") == NULL;
7080   str = getenv ("SKIP_TEST_LVREMOVE_2");
7081   if (str && strcmp (str, "1") == 0) return 1;
7082   str = getenv ("SKIP_TEST_LVREMOVE");
7083   if (str && strcmp (str, "1") == 0) return 1;
7084   return 0;
7085 }
7086
7087 static int test_lvremove_2 (void)
7088 {
7089   if (test_lvremove_2_skip ()) {
7090     printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
7091     return 0;
7092   }
7093
7094   /* InitNone|InitEmpty for test_lvremove_2 */
7095   {
7096     char device[] = "/dev/sda";
7097     int r;
7098     suppress_error = 0;
7099     r = guestfs_blockdev_setrw (g, device);
7100     if (r == -1)
7101       return -1;
7102   }
7103   {
7104     int r;
7105     suppress_error = 0;
7106     r = guestfs_umount_all (g);
7107     if (r == -1)
7108       return -1;
7109   }
7110   {
7111     int r;
7112     suppress_error = 0;
7113     r = guestfs_lvm_remove_all (g);
7114     if (r == -1)
7115       return -1;
7116   }
7117   /* TestOutputList for lvremove (2) */
7118   {
7119     char device[] = "/dev/sda";
7120     char lines_0[] = ",";
7121     char *lines[] = {
7122       lines_0,
7123       NULL
7124     };
7125     int r;
7126     suppress_error = 0;
7127     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7128     if (r == -1)
7129       return -1;
7130   }
7131   {
7132     char device[] = "/dev/sda1";
7133     int r;
7134     suppress_error = 0;
7135     r = guestfs_pvcreate (g, device);
7136     if (r == -1)
7137       return -1;
7138   }
7139   {
7140     char volgroup[] = "VG";
7141     char physvols_0[] = "/dev/sda1";
7142     char *physvols[] = {
7143       physvols_0,
7144       NULL
7145     };
7146     int r;
7147     suppress_error = 0;
7148     r = guestfs_vgcreate (g, volgroup, physvols);
7149     if (r == -1)
7150       return -1;
7151   }
7152   {
7153     char logvol[] = "LV1";
7154     char volgroup[] = "VG";
7155     int r;
7156     suppress_error = 0;
7157     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7158     if (r == -1)
7159       return -1;
7160   }
7161   {
7162     char logvol[] = "LV2";
7163     char volgroup[] = "VG";
7164     int r;
7165     suppress_error = 0;
7166     r = guestfs_lvcreate (g, logvol, volgroup, 50);
7167     if (r == -1)
7168       return -1;
7169   }
7170   {
7171     char device[] = "/dev/VG";
7172     int r;
7173     suppress_error = 0;
7174     r = guestfs_lvremove (g, device);
7175     if (r == -1)
7176       return -1;
7177   }
7178   {
7179     char **r;
7180     int i;
7181     suppress_error = 0;
7182     r = guestfs_vgs (g);
7183     if (r == NULL)
7184       return -1;
7185     if (!r[0]) {
7186       fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7187       print_strings (r);
7188       return -1;
7189     }
7190     {
7191       char expected[] = "VG";
7192       if (strcmp (r[0], expected) != 0) {
7193         fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7194         return -1;
7195       }
7196     }
7197     if (r[1] != NULL) {
7198       fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7199       print_strings (r);
7200       return -1;
7201     }
7202     for (i = 0; r[i] != NULL; ++i)
7203       free (r[i]);
7204     free (r);
7205   }
7206   return 0;
7207 }
7208
7209 static int test_mount_ro_0_skip (void)
7210 {
7211   const char *str;
7212
7213   str = getenv ("TEST_ONLY");
7214   if (str)
7215     return strstr (str, "mount_ro") == NULL;
7216   str = getenv ("SKIP_TEST_MOUNT_RO_0");
7217   if (str && strcmp (str, "1") == 0) return 1;
7218   str = getenv ("SKIP_TEST_MOUNT_RO");
7219   if (str && strcmp (str, "1") == 0) return 1;
7220   return 0;
7221 }
7222
7223 static int test_mount_ro_0 (void)
7224 {
7225   if (test_mount_ro_0_skip ()) {
7226     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7227     return 0;
7228   }
7229
7230   /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7231   {
7232     char device[] = "/dev/sda";
7233     int r;
7234     suppress_error = 0;
7235     r = guestfs_blockdev_setrw (g, device);
7236     if (r == -1)
7237       return -1;
7238   }
7239   {
7240     int r;
7241     suppress_error = 0;
7242     r = guestfs_umount_all (g);
7243     if (r == -1)
7244       return -1;
7245   }
7246   {
7247     int r;
7248     suppress_error = 0;
7249     r = guestfs_lvm_remove_all (g);
7250     if (r == -1)
7251       return -1;
7252   }
7253   {
7254     char device[] = "/dev/sda";
7255     char lines_0[] = ",";
7256     char *lines[] = {
7257       lines_0,
7258       NULL
7259     };
7260     int r;
7261     suppress_error = 0;
7262     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7263     if (r == -1)
7264       return -1;
7265   }
7266   {
7267     char fstype[] = "ext2";
7268     char device[] = "/dev/sda1";
7269     int r;
7270     suppress_error = 0;
7271     r = guestfs_mkfs (g, fstype, device);
7272     if (r == -1)
7273       return -1;
7274   }
7275   {
7276     char device[] = "/dev/sda1";
7277     char mountpoint[] = "/";
7278     int r;
7279     suppress_error = 0;
7280     r = guestfs_mount (g, device, mountpoint);
7281     if (r == -1)
7282       return -1;
7283   }
7284   /* TestLastFail for mount_ro (0) */
7285   {
7286     char pathordevice[] = "/";
7287     int r;
7288     suppress_error = 0;
7289     r = guestfs_umount (g, pathordevice);
7290     if (r == -1)
7291       return -1;
7292   }
7293   {
7294     char device[] = "/dev/sda1";
7295     char mountpoint[] = "/";
7296     int r;
7297     suppress_error = 0;
7298     r = guestfs_mount_ro (g, device, mountpoint);
7299     if (r == -1)
7300       return -1;
7301   }
7302   {
7303     char path[] = "/new";
7304     int r;
7305     suppress_error = 1;
7306     r = guestfs_touch (g, path);
7307     if (r != -1)
7308       return -1;
7309   }
7310   return 0;
7311 }
7312
7313 static int test_mount_ro_1_skip (void)
7314 {
7315   const char *str;
7316
7317   str = getenv ("TEST_ONLY");
7318   if (str)
7319     return strstr (str, "mount_ro") == NULL;
7320   str = getenv ("SKIP_TEST_MOUNT_RO_1");
7321   if (str && strcmp (str, "1") == 0) return 1;
7322   str = getenv ("SKIP_TEST_MOUNT_RO");
7323   if (str && strcmp (str, "1") == 0) return 1;
7324   return 0;
7325 }
7326
7327 static int test_mount_ro_1 (void)
7328 {
7329   if (test_mount_ro_1_skip ()) {
7330     printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7331     return 0;
7332   }
7333
7334   /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7335   {
7336     char device[] = "/dev/sda";
7337     int r;
7338     suppress_error = 0;
7339     r = guestfs_blockdev_setrw (g, device);
7340     if (r == -1)
7341       return -1;
7342   }
7343   {
7344     int r;
7345     suppress_error = 0;
7346     r = guestfs_umount_all (g);
7347     if (r == -1)
7348       return -1;
7349   }
7350   {
7351     int r;
7352     suppress_error = 0;
7353     r = guestfs_lvm_remove_all (g);
7354     if (r == -1)
7355       return -1;
7356   }
7357   {
7358     char device[] = "/dev/sda";
7359     char lines_0[] = ",";
7360     char *lines[] = {
7361       lines_0,
7362       NULL
7363     };
7364     int r;
7365     suppress_error = 0;
7366     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7367     if (r == -1)
7368       return -1;
7369   }
7370   {
7371     char fstype[] = "ext2";
7372     char device[] = "/dev/sda1";
7373     int r;
7374     suppress_error = 0;
7375     r = guestfs_mkfs (g, fstype, device);
7376     if (r == -1)
7377       return -1;
7378   }
7379   {
7380     char device[] = "/dev/sda1";
7381     char mountpoint[] = "/";
7382     int r;
7383     suppress_error = 0;
7384     r = guestfs_mount (g, device, mountpoint);
7385     if (r == -1)
7386       return -1;
7387   }
7388   /* TestOutput for mount_ro (1) */
7389   char expected[] = "data";
7390   {
7391     char path[] = "/new";
7392     char content[] = "data";
7393     int r;
7394     suppress_error = 0;
7395     r = guestfs_write_file (g, path, content, 0);
7396     if (r == -1)
7397       return -1;
7398   }
7399   {
7400     char pathordevice[] = "/";
7401     int r;
7402     suppress_error = 0;
7403     r = guestfs_umount (g, pathordevice);
7404     if (r == -1)
7405       return -1;
7406   }
7407   {
7408     char device[] = "/dev/sda1";
7409     char mountpoint[] = "/";
7410     int r;
7411     suppress_error = 0;
7412     r = guestfs_mount_ro (g, device, mountpoint);
7413     if (r == -1)
7414       return -1;
7415   }
7416   {
7417     char path[] = "/new";
7418     char *r;
7419     suppress_error = 0;
7420     r = guestfs_cat (g, path);
7421     if (r == NULL)
7422       return -1;
7423     if (strcmp (r, expected) != 0) {
7424       fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7425       return -1;
7426     }
7427     free (r);
7428   }
7429   return 0;
7430 }
7431
7432 static int test_tgz_in_0_skip (void)
7433 {
7434   const char *str;
7435
7436   str = getenv ("TEST_ONLY");
7437   if (str)
7438     return strstr (str, "tgz_in") == NULL;
7439   str = getenv ("SKIP_TEST_TGZ_IN_0");
7440   if (str && strcmp (str, "1") == 0) return 1;
7441   str = getenv ("SKIP_TEST_TGZ_IN");
7442   if (str && strcmp (str, "1") == 0) return 1;
7443   return 0;
7444 }
7445
7446 static int test_tgz_in_0 (void)
7447 {
7448   if (test_tgz_in_0_skip ()) {
7449     printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7450     return 0;
7451   }
7452
7453   /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7454   {
7455     char device[] = "/dev/sda";
7456     int r;
7457     suppress_error = 0;
7458     r = guestfs_blockdev_setrw (g, device);
7459     if (r == -1)
7460       return -1;
7461   }
7462   {
7463     int r;
7464     suppress_error = 0;
7465     r = guestfs_umount_all (g);
7466     if (r == -1)
7467       return -1;
7468   }
7469   {
7470     int r;
7471     suppress_error = 0;
7472     r = guestfs_lvm_remove_all (g);
7473     if (r == -1)
7474       return -1;
7475   }
7476   {
7477     char device[] = "/dev/sda";
7478     char lines_0[] = ",";
7479     char *lines[] = {
7480       lines_0,
7481       NULL
7482     };
7483     int r;
7484     suppress_error = 0;
7485     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7486     if (r == -1)
7487       return -1;
7488   }
7489   {
7490     char fstype[] = "ext2";
7491     char device[] = "/dev/sda1";
7492     int r;
7493     suppress_error = 0;
7494     r = guestfs_mkfs (g, fstype, device);
7495     if (r == -1)
7496       return -1;
7497   }
7498   {
7499     char device[] = "/dev/sda1";
7500     char mountpoint[] = "/";
7501     int r;
7502     suppress_error = 0;
7503     r = guestfs_mount (g, device, mountpoint);
7504     if (r == -1)
7505       return -1;
7506   }
7507   /* TestOutput for tgz_in (0) */
7508   char expected[] = "hello\n";
7509   {
7510     char directory[] = "/";
7511     int r;
7512     suppress_error = 0;
7513     r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7514     if (r == -1)
7515       return -1;
7516   }
7517   {
7518     char path[] = "/hello";
7519     char *r;
7520     suppress_error = 0;
7521     r = guestfs_cat (g, path);
7522     if (r == NULL)
7523       return -1;
7524     if (strcmp (r, expected) != 0) {
7525       fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7526       return -1;
7527     }
7528     free (r);
7529   }
7530   return 0;
7531 }
7532
7533 static int test_tar_in_0_skip (void)
7534 {
7535   const char *str;
7536
7537   str = getenv ("TEST_ONLY");
7538   if (str)
7539     return strstr (str, "tar_in") == NULL;
7540   str = getenv ("SKIP_TEST_TAR_IN_0");
7541   if (str && strcmp (str, "1") == 0) return 1;
7542   str = getenv ("SKIP_TEST_TAR_IN");
7543   if (str && strcmp (str, "1") == 0) return 1;
7544   return 0;
7545 }
7546
7547 static int test_tar_in_0 (void)
7548 {
7549   if (test_tar_in_0_skip ()) {
7550     printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7551     return 0;
7552   }
7553
7554   /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7555   {
7556     char device[] = "/dev/sda";
7557     int r;
7558     suppress_error = 0;
7559     r = guestfs_blockdev_setrw (g, device);
7560     if (r == -1)
7561       return -1;
7562   }
7563   {
7564     int r;
7565     suppress_error = 0;
7566     r = guestfs_umount_all (g);
7567     if (r == -1)
7568       return -1;
7569   }
7570   {
7571     int r;
7572     suppress_error = 0;
7573     r = guestfs_lvm_remove_all (g);
7574     if (r == -1)
7575       return -1;
7576   }
7577   {
7578     char device[] = "/dev/sda";
7579     char lines_0[] = ",";
7580     char *lines[] = {
7581       lines_0,
7582       NULL
7583     };
7584     int r;
7585     suppress_error = 0;
7586     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7587     if (r == -1)
7588       return -1;
7589   }
7590   {
7591     char fstype[] = "ext2";
7592     char device[] = "/dev/sda1";
7593     int r;
7594     suppress_error = 0;
7595     r = guestfs_mkfs (g, fstype, device);
7596     if (r == -1)
7597       return -1;
7598   }
7599   {
7600     char device[] = "/dev/sda1";
7601     char mountpoint[] = "/";
7602     int r;
7603     suppress_error = 0;
7604     r = guestfs_mount (g, device, mountpoint);
7605     if (r == -1)
7606       return -1;
7607   }
7608   /* TestOutput for tar_in (0) */
7609   char expected[] = "hello\n";
7610   {
7611     char directory[] = "/";
7612     int r;
7613     suppress_error = 0;
7614     r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7615     if (r == -1)
7616       return -1;
7617   }
7618   {
7619     char path[] = "/hello";
7620     char *r;
7621     suppress_error = 0;
7622     r = guestfs_cat (g, path);
7623     if (r == NULL)
7624       return -1;
7625     if (strcmp (r, expected) != 0) {
7626       fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7627       return -1;
7628     }
7629     free (r);
7630   }
7631   return 0;
7632 }
7633
7634 static int test_checksum_0_skip (void)
7635 {
7636   const char *str;
7637
7638   str = getenv ("TEST_ONLY");
7639   if (str)
7640     return strstr (str, "checksum") == NULL;
7641   str = getenv ("SKIP_TEST_CHECKSUM_0");
7642   if (str && strcmp (str, "1") == 0) return 1;
7643   str = getenv ("SKIP_TEST_CHECKSUM");
7644   if (str && strcmp (str, "1") == 0) return 1;
7645   return 0;
7646 }
7647
7648 static int test_checksum_0 (void)
7649 {
7650   if (test_checksum_0_skip ()) {
7651     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7652     return 0;
7653   }
7654
7655   /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7656   {
7657     char device[] = "/dev/sda";
7658     int r;
7659     suppress_error = 0;
7660     r = guestfs_blockdev_setrw (g, device);
7661     if (r == -1)
7662       return -1;
7663   }
7664   {
7665     int r;
7666     suppress_error = 0;
7667     r = guestfs_umount_all (g);
7668     if (r == -1)
7669       return -1;
7670   }
7671   {
7672     int r;
7673     suppress_error = 0;
7674     r = guestfs_lvm_remove_all (g);
7675     if (r == -1)
7676       return -1;
7677   }
7678   {
7679     char device[] = "/dev/sda";
7680     char lines_0[] = ",";
7681     char *lines[] = {
7682       lines_0,
7683       NULL
7684     };
7685     int r;
7686     suppress_error = 0;
7687     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7688     if (r == -1)
7689       return -1;
7690   }
7691   {
7692     char fstype[] = "ext2";
7693     char device[] = "/dev/sda1";
7694     int r;
7695     suppress_error = 0;
7696     r = guestfs_mkfs (g, fstype, device);
7697     if (r == -1)
7698       return -1;
7699   }
7700   {
7701     char device[] = "/dev/sda1";
7702     char mountpoint[] = "/";
7703     int r;
7704     suppress_error = 0;
7705     r = guestfs_mount (g, device, mountpoint);
7706     if (r == -1)
7707       return -1;
7708   }
7709   /* TestOutput for checksum (0) */
7710   char expected[] = "935282863";
7711   {
7712     char path[] = "/new";
7713     char content[] = "test\n";
7714     int r;
7715     suppress_error = 0;
7716     r = guestfs_write_file (g, path, content, 0);
7717     if (r == -1)
7718       return -1;
7719   }
7720   {
7721     char csumtype[] = "crc";
7722     char path[] = "/new";
7723     char *r;
7724     suppress_error = 0;
7725     r = guestfs_checksum (g, csumtype, path);
7726     if (r == NULL)
7727       return -1;
7728     if (strcmp (r, expected) != 0) {
7729       fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7730       return -1;
7731     }
7732     free (r);
7733   }
7734   return 0;
7735 }
7736
7737 static int test_checksum_1_skip (void)
7738 {
7739   const char *str;
7740
7741   str = getenv ("TEST_ONLY");
7742   if (str)
7743     return strstr (str, "checksum") == NULL;
7744   str = getenv ("SKIP_TEST_CHECKSUM_1");
7745   if (str && strcmp (str, "1") == 0) return 1;
7746   str = getenv ("SKIP_TEST_CHECKSUM");
7747   if (str && strcmp (str, "1") == 0) return 1;
7748   return 0;
7749 }
7750
7751 static int test_checksum_1 (void)
7752 {
7753   if (test_checksum_1_skip ()) {
7754     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7755     return 0;
7756   }
7757
7758   /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7759   {
7760     char device[] = "/dev/sda";
7761     int r;
7762     suppress_error = 0;
7763     r = guestfs_blockdev_setrw (g, device);
7764     if (r == -1)
7765       return -1;
7766   }
7767   {
7768     int r;
7769     suppress_error = 0;
7770     r = guestfs_umount_all (g);
7771     if (r == -1)
7772       return -1;
7773   }
7774   {
7775     int r;
7776     suppress_error = 0;
7777     r = guestfs_lvm_remove_all (g);
7778     if (r == -1)
7779       return -1;
7780   }
7781   {
7782     char device[] = "/dev/sda";
7783     char lines_0[] = ",";
7784     char *lines[] = {
7785       lines_0,
7786       NULL
7787     };
7788     int r;
7789     suppress_error = 0;
7790     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7791     if (r == -1)
7792       return -1;
7793   }
7794   {
7795     char fstype[] = "ext2";
7796     char device[] = "/dev/sda1";
7797     int r;
7798     suppress_error = 0;
7799     r = guestfs_mkfs (g, fstype, device);
7800     if (r == -1)
7801       return -1;
7802   }
7803   {
7804     char device[] = "/dev/sda1";
7805     char mountpoint[] = "/";
7806     int r;
7807     suppress_error = 0;
7808     r = guestfs_mount (g, device, mountpoint);
7809     if (r == -1)
7810       return -1;
7811   }
7812   /* TestLastFail for checksum (1) */
7813   {
7814     char csumtype[] = "crc";
7815     char path[] = "/new";
7816     char *r;
7817     suppress_error = 1;
7818     r = guestfs_checksum (g, csumtype, path);
7819     if (r != NULL)
7820       return -1;
7821     free (r);
7822   }
7823   return 0;
7824 }
7825
7826 static int test_checksum_2_skip (void)
7827 {
7828   const char *str;
7829
7830   str = getenv ("TEST_ONLY");
7831   if (str)
7832     return strstr (str, "checksum") == NULL;
7833   str = getenv ("SKIP_TEST_CHECKSUM_2");
7834   if (str && strcmp (str, "1") == 0) return 1;
7835   str = getenv ("SKIP_TEST_CHECKSUM");
7836   if (str && strcmp (str, "1") == 0) return 1;
7837   return 0;
7838 }
7839
7840 static int test_checksum_2 (void)
7841 {
7842   if (test_checksum_2_skip ()) {
7843     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
7844     return 0;
7845   }
7846
7847   /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
7848   {
7849     char device[] = "/dev/sda";
7850     int r;
7851     suppress_error = 0;
7852     r = guestfs_blockdev_setrw (g, device);
7853     if (r == -1)
7854       return -1;
7855   }
7856   {
7857     int r;
7858     suppress_error = 0;
7859     r = guestfs_umount_all (g);
7860     if (r == -1)
7861       return -1;
7862   }
7863   {
7864     int r;
7865     suppress_error = 0;
7866     r = guestfs_lvm_remove_all (g);
7867     if (r == -1)
7868       return -1;
7869   }
7870   {
7871     char device[] = "/dev/sda";
7872     char lines_0[] = ",";
7873     char *lines[] = {
7874       lines_0,
7875       NULL
7876     };
7877     int r;
7878     suppress_error = 0;
7879     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7880     if (r == -1)
7881       return -1;
7882   }
7883   {
7884     char fstype[] = "ext2";
7885     char device[] = "/dev/sda1";
7886     int r;
7887     suppress_error = 0;
7888     r = guestfs_mkfs (g, fstype, device);
7889     if (r == -1)
7890       return -1;
7891   }
7892   {
7893     char device[] = "/dev/sda1";
7894     char mountpoint[] = "/";
7895     int r;
7896     suppress_error = 0;
7897     r = guestfs_mount (g, device, mountpoint);
7898     if (r == -1)
7899       return -1;
7900   }
7901   /* TestOutput for checksum (2) */
7902   char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
7903   {
7904     char path[] = "/new";
7905     char content[] = "test\n";
7906     int r;
7907     suppress_error = 0;
7908     r = guestfs_write_file (g, path, content, 0);
7909     if (r == -1)
7910       return -1;
7911   }
7912   {
7913     char csumtype[] = "md5";
7914     char path[] = "/new";
7915     char *r;
7916     suppress_error = 0;
7917     r = guestfs_checksum (g, csumtype, path);
7918     if (r == NULL)
7919       return -1;
7920     if (strcmp (r, expected) != 0) {
7921       fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
7922       return -1;
7923     }
7924     free (r);
7925   }
7926   return 0;
7927 }
7928
7929 static int test_checksum_3_skip (void)
7930 {
7931   const char *str;
7932
7933   str = getenv ("TEST_ONLY");
7934   if (str)
7935     return strstr (str, "checksum") == NULL;
7936   str = getenv ("SKIP_TEST_CHECKSUM_3");
7937   if (str && strcmp (str, "1") == 0) return 1;
7938   str = getenv ("SKIP_TEST_CHECKSUM");
7939   if (str && strcmp (str, "1") == 0) return 1;
7940   return 0;
7941 }
7942
7943 static int test_checksum_3 (void)
7944 {
7945   if (test_checksum_3_skip ()) {
7946     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
7947     return 0;
7948   }
7949
7950   /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
7951   {
7952     char device[] = "/dev/sda";
7953     int r;
7954     suppress_error = 0;
7955     r = guestfs_blockdev_setrw (g, device);
7956     if (r == -1)
7957       return -1;
7958   }
7959   {
7960     int r;
7961     suppress_error = 0;
7962     r = guestfs_umount_all (g);
7963     if (r == -1)
7964       return -1;
7965   }
7966   {
7967     int r;
7968     suppress_error = 0;
7969     r = guestfs_lvm_remove_all (g);
7970     if (r == -1)
7971       return -1;
7972   }
7973   {
7974     char device[] = "/dev/sda";
7975     char lines_0[] = ",";
7976     char *lines[] = {
7977       lines_0,
7978       NULL
7979     };
7980     int r;
7981     suppress_error = 0;
7982     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7983     if (r == -1)
7984       return -1;
7985   }
7986   {
7987     char fstype[] = "ext2";
7988     char device[] = "/dev/sda1";
7989     int r;
7990     suppress_error = 0;
7991     r = guestfs_mkfs (g, fstype, device);
7992     if (r == -1)
7993       return -1;
7994   }
7995   {
7996     char device[] = "/dev/sda1";
7997     char mountpoint[] = "/";
7998     int r;
7999     suppress_error = 0;
8000     r = guestfs_mount (g, device, mountpoint);
8001     if (r == -1)
8002       return -1;
8003   }
8004   /* TestOutput for checksum (3) */
8005   char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8006   {
8007     char path[] = "/new";
8008     char content[] = "test\n";
8009     int r;
8010     suppress_error = 0;
8011     r = guestfs_write_file (g, path, content, 0);
8012     if (r == -1)
8013       return -1;
8014   }
8015   {
8016     char csumtype[] = "sha1";
8017     char path[] = "/new";
8018     char *r;
8019     suppress_error = 0;
8020     r = guestfs_checksum (g, csumtype, path);
8021     if (r == NULL)
8022       return -1;
8023     if (strcmp (r, expected) != 0) {
8024       fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8025       return -1;
8026     }
8027     free (r);
8028   }
8029   return 0;
8030 }
8031
8032 static int test_checksum_4_skip (void)
8033 {
8034   const char *str;
8035
8036   str = getenv ("TEST_ONLY");
8037   if (str)
8038     return strstr (str, "checksum") == NULL;
8039   str = getenv ("SKIP_TEST_CHECKSUM_4");
8040   if (str && strcmp (str, "1") == 0) return 1;
8041   str = getenv ("SKIP_TEST_CHECKSUM");
8042   if (str && strcmp (str, "1") == 0) return 1;
8043   return 0;
8044 }
8045
8046 static int test_checksum_4 (void)
8047 {
8048   if (test_checksum_4_skip ()) {
8049     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
8050     return 0;
8051   }
8052
8053   /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8054   {
8055     char device[] = "/dev/sda";
8056     int r;
8057     suppress_error = 0;
8058     r = guestfs_blockdev_setrw (g, device);
8059     if (r == -1)
8060       return -1;
8061   }
8062   {
8063     int r;
8064     suppress_error = 0;
8065     r = guestfs_umount_all (g);
8066     if (r == -1)
8067       return -1;
8068   }
8069   {
8070     int r;
8071     suppress_error = 0;
8072     r = guestfs_lvm_remove_all (g);
8073     if (r == -1)
8074       return -1;
8075   }
8076   {
8077     char device[] = "/dev/sda";
8078     char lines_0[] = ",";
8079     char *lines[] = {
8080       lines_0,
8081       NULL
8082     };
8083     int r;
8084     suppress_error = 0;
8085     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8086     if (r == -1)
8087       return -1;
8088   }
8089   {
8090     char fstype[] = "ext2";
8091     char device[] = "/dev/sda1";
8092     int r;
8093     suppress_error = 0;
8094     r = guestfs_mkfs (g, fstype, device);
8095     if (r == -1)
8096       return -1;
8097   }
8098   {
8099     char device[] = "/dev/sda1";
8100     char mountpoint[] = "/";
8101     int r;
8102     suppress_error = 0;
8103     r = guestfs_mount (g, device, mountpoint);
8104     if (r == -1)
8105       return -1;
8106   }
8107   /* TestOutput for checksum (4) */
8108   char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8109   {
8110     char path[] = "/new";
8111     char content[] = "test\n";
8112     int r;
8113     suppress_error = 0;
8114     r = guestfs_write_file (g, path, content, 0);
8115     if (r == -1)
8116       return -1;
8117   }
8118   {
8119     char csumtype[] = "sha224";
8120     char path[] = "/new";
8121     char *r;
8122     suppress_error = 0;
8123     r = guestfs_checksum (g, csumtype, path);
8124     if (r == NULL)
8125       return -1;
8126     if (strcmp (r, expected) != 0) {
8127       fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8128       return -1;
8129     }
8130     free (r);
8131   }
8132   return 0;
8133 }
8134
8135 static int test_checksum_5_skip (void)
8136 {
8137   const char *str;
8138
8139   str = getenv ("TEST_ONLY");
8140   if (str)
8141     return strstr (str, "checksum") == NULL;
8142   str = getenv ("SKIP_TEST_CHECKSUM_5");
8143   if (str && strcmp (str, "1") == 0) return 1;
8144   str = getenv ("SKIP_TEST_CHECKSUM");
8145   if (str && strcmp (str, "1") == 0) return 1;
8146   return 0;
8147 }
8148
8149 static int test_checksum_5 (void)
8150 {
8151   if (test_checksum_5_skip ()) {
8152     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8153     return 0;
8154   }
8155
8156   /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8157   {
8158     char device[] = "/dev/sda";
8159     int r;
8160     suppress_error = 0;
8161     r = guestfs_blockdev_setrw (g, device);
8162     if (r == -1)
8163       return -1;
8164   }
8165   {
8166     int r;
8167     suppress_error = 0;
8168     r = guestfs_umount_all (g);
8169     if (r == -1)
8170       return -1;
8171   }
8172   {
8173     int r;
8174     suppress_error = 0;
8175     r = guestfs_lvm_remove_all (g);
8176     if (r == -1)
8177       return -1;
8178   }
8179   {
8180     char device[] = "/dev/sda";
8181     char lines_0[] = ",";
8182     char *lines[] = {
8183       lines_0,
8184       NULL
8185     };
8186     int r;
8187     suppress_error = 0;
8188     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8189     if (r == -1)
8190       return -1;
8191   }
8192   {
8193     char fstype[] = "ext2";
8194     char device[] = "/dev/sda1";
8195     int r;
8196     suppress_error = 0;
8197     r = guestfs_mkfs (g, fstype, device);
8198     if (r == -1)
8199       return -1;
8200   }
8201   {
8202     char device[] = "/dev/sda1";
8203     char mountpoint[] = "/";
8204     int r;
8205     suppress_error = 0;
8206     r = guestfs_mount (g, device, mountpoint);
8207     if (r == -1)
8208       return -1;
8209   }
8210   /* TestOutput for checksum (5) */
8211   char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8212   {
8213     char path[] = "/new";
8214     char content[] = "test\n";
8215     int r;
8216     suppress_error = 0;
8217     r = guestfs_write_file (g, path, content, 0);
8218     if (r == -1)
8219       return -1;
8220   }
8221   {
8222     char csumtype[] = "sha256";
8223     char path[] = "/new";
8224     char *r;
8225     suppress_error = 0;
8226     r = guestfs_checksum (g, csumtype, path);
8227     if (r == NULL)
8228       return -1;
8229     if (strcmp (r, expected) != 0) {
8230       fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8231       return -1;
8232     }
8233     free (r);
8234   }
8235   return 0;
8236 }
8237
8238 static int test_checksum_6_skip (void)
8239 {
8240   const char *str;
8241
8242   str = getenv ("TEST_ONLY");
8243   if (str)
8244     return strstr (str, "checksum") == NULL;
8245   str = getenv ("SKIP_TEST_CHECKSUM_6");
8246   if (str && strcmp (str, "1") == 0) return 1;
8247   str = getenv ("SKIP_TEST_CHECKSUM");
8248   if (str && strcmp (str, "1") == 0) return 1;
8249   return 0;
8250 }
8251
8252 static int test_checksum_6 (void)
8253 {
8254   if (test_checksum_6_skip ()) {
8255     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8256     return 0;
8257   }
8258
8259   /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8260   {
8261     char device[] = "/dev/sda";
8262     int r;
8263     suppress_error = 0;
8264     r = guestfs_blockdev_setrw (g, device);
8265     if (r == -1)
8266       return -1;
8267   }
8268   {
8269     int r;
8270     suppress_error = 0;
8271     r = guestfs_umount_all (g);
8272     if (r == -1)
8273       return -1;
8274   }
8275   {
8276     int r;
8277     suppress_error = 0;
8278     r = guestfs_lvm_remove_all (g);
8279     if (r == -1)
8280       return -1;
8281   }
8282   {
8283     char device[] = "/dev/sda";
8284     char lines_0[] = ",";
8285     char *lines[] = {
8286       lines_0,
8287       NULL
8288     };
8289     int r;
8290     suppress_error = 0;
8291     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8292     if (r == -1)
8293       return -1;
8294   }
8295   {
8296     char fstype[] = "ext2";
8297     char device[] = "/dev/sda1";
8298     int r;
8299     suppress_error = 0;
8300     r = guestfs_mkfs (g, fstype, device);
8301     if (r == -1)
8302       return -1;
8303   }
8304   {
8305     char device[] = "/dev/sda1";
8306     char mountpoint[] = "/";
8307     int r;
8308     suppress_error = 0;
8309     r = guestfs_mount (g, device, mountpoint);
8310     if (r == -1)
8311       return -1;
8312   }
8313   /* TestOutput for checksum (6) */
8314   char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8315   {
8316     char path[] = "/new";
8317     char content[] = "test\n";
8318     int r;
8319     suppress_error = 0;
8320     r = guestfs_write_file (g, path, content, 0);
8321     if (r == -1)
8322       return -1;
8323   }
8324   {
8325     char csumtype[] = "sha384";
8326     char path[] = "/new";
8327     char *r;
8328     suppress_error = 0;
8329     r = guestfs_checksum (g, csumtype, path);
8330     if (r == NULL)
8331       return -1;
8332     if (strcmp (r, expected) != 0) {
8333       fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8334       return -1;
8335     }
8336     free (r);
8337   }
8338   return 0;
8339 }
8340
8341 static int test_checksum_7_skip (void)
8342 {
8343   const char *str;
8344
8345   str = getenv ("TEST_ONLY");
8346   if (str)
8347     return strstr (str, "checksum") == NULL;
8348   str = getenv ("SKIP_TEST_CHECKSUM_7");
8349   if (str && strcmp (str, "1") == 0) return 1;
8350   str = getenv ("SKIP_TEST_CHECKSUM");
8351   if (str && strcmp (str, "1") == 0) return 1;
8352   return 0;
8353 }
8354
8355 static int test_checksum_7 (void)
8356 {
8357   if (test_checksum_7_skip ()) {
8358     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8359     return 0;
8360   }
8361
8362   /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8363   {
8364     char device[] = "/dev/sda";
8365     int r;
8366     suppress_error = 0;
8367     r = guestfs_blockdev_setrw (g, device);
8368     if (r == -1)
8369       return -1;
8370   }
8371   {
8372     int r;
8373     suppress_error = 0;
8374     r = guestfs_umount_all (g);
8375     if (r == -1)
8376       return -1;
8377   }
8378   {
8379     int r;
8380     suppress_error = 0;
8381     r = guestfs_lvm_remove_all (g);
8382     if (r == -1)
8383       return -1;
8384   }
8385   {
8386     char device[] = "/dev/sda";
8387     char lines_0[] = ",";
8388     char *lines[] = {
8389       lines_0,
8390       NULL
8391     };
8392     int r;
8393     suppress_error = 0;
8394     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8395     if (r == -1)
8396       return -1;
8397   }
8398   {
8399     char fstype[] = "ext2";
8400     char device[] = "/dev/sda1";
8401     int r;
8402     suppress_error = 0;
8403     r = guestfs_mkfs (g, fstype, device);
8404     if (r == -1)
8405       return -1;
8406   }
8407   {
8408     char device[] = "/dev/sda1";
8409     char mountpoint[] = "/";
8410     int r;
8411     suppress_error = 0;
8412     r = guestfs_mount (g, device, mountpoint);
8413     if (r == -1)
8414       return -1;
8415   }
8416   /* TestOutput for checksum (7) */
8417   char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8418   {
8419     char path[] = "/new";
8420     char content[] = "test\n";
8421     int r;
8422     suppress_error = 0;
8423     r = guestfs_write_file (g, path, content, 0);
8424     if (r == -1)
8425       return -1;
8426   }
8427   {
8428     char csumtype[] = "sha512";
8429     char path[] = "/new";
8430     char *r;
8431     suppress_error = 0;
8432     r = guestfs_checksum (g, csumtype, path);
8433     if (r == NULL)
8434       return -1;
8435     if (strcmp (r, expected) != 0) {
8436       fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8437       return -1;
8438     }
8439     free (r);
8440   }
8441   return 0;
8442 }
8443
8444 static int test_checksum_8_skip (void)
8445 {
8446   const char *str;
8447
8448   str = getenv ("TEST_ONLY");
8449   if (str)
8450     return strstr (str, "checksum") == NULL;
8451   str = getenv ("SKIP_TEST_CHECKSUM_8");
8452   if (str && strcmp (str, "1") == 0) return 1;
8453   str = getenv ("SKIP_TEST_CHECKSUM");
8454   if (str && strcmp (str, "1") == 0) return 1;
8455   return 0;
8456 }
8457
8458 static int test_checksum_8 (void)
8459 {
8460   if (test_checksum_8_skip ()) {
8461     printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8462     return 0;
8463   }
8464
8465   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8466   {
8467     char device[] = "/dev/sda";
8468     int r;
8469     suppress_error = 0;
8470     r = guestfs_blockdev_setrw (g, device);
8471     if (r == -1)
8472       return -1;
8473   }
8474   {
8475     int r;
8476     suppress_error = 0;
8477     r = guestfs_umount_all (g);
8478     if (r == -1)
8479       return -1;
8480   }
8481   {
8482     int r;
8483     suppress_error = 0;
8484     r = guestfs_lvm_remove_all (g);
8485     if (r == -1)
8486       return -1;
8487   }
8488   {
8489     char device[] = "/dev/sda";
8490     char lines_0[] = ",";
8491     char *lines[] = {
8492       lines_0,
8493       NULL
8494     };
8495     int r;
8496     suppress_error = 0;
8497     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8498     if (r == -1)
8499       return -1;
8500   }
8501   {
8502     char fstype[] = "ext2";
8503     char device[] = "/dev/sda1";
8504     int r;
8505     suppress_error = 0;
8506     r = guestfs_mkfs (g, fstype, device);
8507     if (r == -1)
8508       return -1;
8509   }
8510   {
8511     char device[] = "/dev/sda1";
8512     char mountpoint[] = "/";
8513     int r;
8514     suppress_error = 0;
8515     r = guestfs_mount (g, device, mountpoint);
8516     if (r == -1)
8517       return -1;
8518   }
8519   /* TestOutput for checksum (8) */
8520   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8521   {
8522     char options[] = "ro";
8523     char vfstype[] = "squashfs";
8524     char device[] = "/dev/sdd";
8525     char mountpoint[] = "/";
8526     int r;
8527     suppress_error = 0;
8528     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8529     if (r == -1)
8530       return -1;
8531   }
8532   {
8533     char csumtype[] = "md5";
8534     char path[] = "/known-3";
8535     char *r;
8536     suppress_error = 0;
8537     r = guestfs_checksum (g, csumtype, path);
8538     if (r == NULL)
8539       return -1;
8540     if (strcmp (r, expected) != 0) {
8541       fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8542       return -1;
8543     }
8544     free (r);
8545   }
8546   return 0;
8547 }
8548
8549 static int test_download_0_skip (void)
8550 {
8551   const char *str;
8552
8553   str = getenv ("TEST_ONLY");
8554   if (str)
8555     return strstr (str, "download") == NULL;
8556   str = getenv ("SKIP_TEST_DOWNLOAD_0");
8557   if (str && strcmp (str, "1") == 0) return 1;
8558   str = getenv ("SKIP_TEST_DOWNLOAD");
8559   if (str && strcmp (str, "1") == 0) return 1;
8560   return 0;
8561 }
8562
8563 static int test_download_0 (void)
8564 {
8565   if (test_download_0_skip ()) {
8566     printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8567     return 0;
8568   }
8569
8570   /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8571   {
8572     char device[] = "/dev/sda";
8573     int r;
8574     suppress_error = 0;
8575     r = guestfs_blockdev_setrw (g, device);
8576     if (r == -1)
8577       return -1;
8578   }
8579   {
8580     int r;
8581     suppress_error = 0;
8582     r = guestfs_umount_all (g);
8583     if (r == -1)
8584       return -1;
8585   }
8586   {
8587     int r;
8588     suppress_error = 0;
8589     r = guestfs_lvm_remove_all (g);
8590     if (r == -1)
8591       return -1;
8592   }
8593   {
8594     char device[] = "/dev/sda";
8595     char lines_0[] = ",";
8596     char *lines[] = {
8597       lines_0,
8598       NULL
8599     };
8600     int r;
8601     suppress_error = 0;
8602     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8603     if (r == -1)
8604       return -1;
8605   }
8606   {
8607     char fstype[] = "ext2";
8608     char device[] = "/dev/sda1";
8609     int r;
8610     suppress_error = 0;
8611     r = guestfs_mkfs (g, fstype, device);
8612     if (r == -1)
8613       return -1;
8614   }
8615   {
8616     char device[] = "/dev/sda1";
8617     char mountpoint[] = "/";
8618     int r;
8619     suppress_error = 0;
8620     r = guestfs_mount (g, device, mountpoint);
8621     if (r == -1)
8622       return -1;
8623   }
8624   /* TestOutput for download (0) */
8625   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8626   {
8627     char remotefilename[] = "/COPYING.LIB";
8628     int r;
8629     suppress_error = 0;
8630     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8631     if (r == -1)
8632       return -1;
8633   }
8634   {
8635     char remotefilename[] = "/COPYING.LIB";
8636     int r;
8637     suppress_error = 0;
8638     r = guestfs_download (g, remotefilename, "testdownload.tmp");
8639     if (r == -1)
8640       return -1;
8641   }
8642   {
8643     char remotefilename[] = "/upload";
8644     int r;
8645     suppress_error = 0;
8646     r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8647     if (r == -1)
8648       return -1;
8649   }
8650   {
8651     char csumtype[] = "md5";
8652     char path[] = "/upload";
8653     char *r;
8654     suppress_error = 0;
8655     r = guestfs_checksum (g, csumtype, path);
8656     if (r == NULL)
8657       return -1;
8658     if (strcmp (r, expected) != 0) {
8659       fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8660       return -1;
8661     }
8662     free (r);
8663   }
8664   return 0;
8665 }
8666
8667 static int test_upload_0_skip (void)
8668 {
8669   const char *str;
8670
8671   str = getenv ("TEST_ONLY");
8672   if (str)
8673     return strstr (str, "upload") == NULL;
8674   str = getenv ("SKIP_TEST_UPLOAD_0");
8675   if (str && strcmp (str, "1") == 0) return 1;
8676   str = getenv ("SKIP_TEST_UPLOAD");
8677   if (str && strcmp (str, "1") == 0) return 1;
8678   return 0;
8679 }
8680
8681 static int test_upload_0 (void)
8682 {
8683   if (test_upload_0_skip ()) {
8684     printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8685     return 0;
8686   }
8687
8688   /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8689   {
8690     char device[] = "/dev/sda";
8691     int r;
8692     suppress_error = 0;
8693     r = guestfs_blockdev_setrw (g, device);
8694     if (r == -1)
8695       return -1;
8696   }
8697   {
8698     int r;
8699     suppress_error = 0;
8700     r = guestfs_umount_all (g);
8701     if (r == -1)
8702       return -1;
8703   }
8704   {
8705     int r;
8706     suppress_error = 0;
8707     r = guestfs_lvm_remove_all (g);
8708     if (r == -1)
8709       return -1;
8710   }
8711   {
8712     char device[] = "/dev/sda";
8713     char lines_0[] = ",";
8714     char *lines[] = {
8715       lines_0,
8716       NULL
8717     };
8718     int r;
8719     suppress_error = 0;
8720     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8721     if (r == -1)
8722       return -1;
8723   }
8724   {
8725     char fstype[] = "ext2";
8726     char device[] = "/dev/sda1";
8727     int r;
8728     suppress_error = 0;
8729     r = guestfs_mkfs (g, fstype, device);
8730     if (r == -1)
8731       return -1;
8732   }
8733   {
8734     char device[] = "/dev/sda1";
8735     char mountpoint[] = "/";
8736     int r;
8737     suppress_error = 0;
8738     r = guestfs_mount (g, device, mountpoint);
8739     if (r == -1)
8740       return -1;
8741   }
8742   /* TestOutput for upload (0) */
8743   char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8744   {
8745     char remotefilename[] = "/COPYING.LIB";
8746     int r;
8747     suppress_error = 0;
8748     r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8749     if (r == -1)
8750       return -1;
8751   }
8752   {
8753     char csumtype[] = "md5";
8754     char path[] = "/COPYING.LIB";
8755     char *r;
8756     suppress_error = 0;
8757     r = guestfs_checksum (g, csumtype, path);
8758     if (r == NULL)
8759       return -1;
8760     if (strcmp (r, expected) != 0) {
8761       fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8762       return -1;
8763     }
8764     free (r);
8765   }
8766   return 0;
8767 }
8768
8769 static int test_blockdev_rereadpt_0_skip (void)
8770 {
8771   const char *str;
8772
8773   str = getenv ("TEST_ONLY");
8774   if (str)
8775     return strstr (str, "blockdev_rereadpt") == NULL;
8776   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8777   if (str && strcmp (str, "1") == 0) return 1;
8778   str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8779   if (str && strcmp (str, "1") == 0) return 1;
8780   return 0;
8781 }
8782
8783 static int test_blockdev_rereadpt_0 (void)
8784 {
8785   if (test_blockdev_rereadpt_0_skip ()) {
8786     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8787     return 0;
8788   }
8789
8790   /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
8791   {
8792     char device[] = "/dev/sda";
8793     int r;
8794     suppress_error = 0;
8795     r = guestfs_blockdev_setrw (g, device);
8796     if (r == -1)
8797       return -1;
8798   }
8799   {
8800     int r;
8801     suppress_error = 0;
8802     r = guestfs_umount_all (g);
8803     if (r == -1)
8804       return -1;
8805   }
8806   {
8807     int r;
8808     suppress_error = 0;
8809     r = guestfs_lvm_remove_all (g);
8810     if (r == -1)
8811       return -1;
8812   }
8813   /* TestRun for blockdev_rereadpt (0) */
8814   {
8815     char device[] = "/dev/sda";
8816     int r;
8817     suppress_error = 0;
8818     r = guestfs_blockdev_rereadpt (g, device);
8819     if (r == -1)
8820       return -1;
8821   }
8822   return 0;
8823 }
8824
8825 static int test_blockdev_flushbufs_0_skip (void)
8826 {
8827   const char *str;
8828
8829   str = getenv ("TEST_ONLY");
8830   if (str)
8831     return strstr (str, "blockdev_flushbufs") == NULL;
8832   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
8833   if (str && strcmp (str, "1") == 0) return 1;
8834   str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
8835   if (str && strcmp (str, "1") == 0) return 1;
8836   return 0;
8837 }
8838
8839 static int test_blockdev_flushbufs_0 (void)
8840 {
8841   if (test_blockdev_flushbufs_0_skip ()) {
8842     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
8843     return 0;
8844   }
8845
8846   /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
8847   {
8848     char device[] = "/dev/sda";
8849     int r;
8850     suppress_error = 0;
8851     r = guestfs_blockdev_setrw (g, device);
8852     if (r == -1)
8853       return -1;
8854   }
8855   {
8856     int r;
8857     suppress_error = 0;
8858     r = guestfs_umount_all (g);
8859     if (r == -1)
8860       return -1;
8861   }
8862   {
8863     int r;
8864     suppress_error = 0;
8865     r = guestfs_lvm_remove_all (g);
8866     if (r == -1)
8867       return -1;
8868   }
8869   /* TestRun for blockdev_flushbufs (0) */
8870   {
8871     char device[] = "/dev/sda";
8872     int r;
8873     suppress_error = 0;
8874     r = guestfs_blockdev_flushbufs (g, device);
8875     if (r == -1)
8876       return -1;
8877   }
8878   return 0;
8879 }
8880
8881 static int test_blockdev_getsize64_0_skip (void)
8882 {
8883   const char *str;
8884
8885   str = getenv ("TEST_ONLY");
8886   if (str)
8887     return strstr (str, "blockdev_getsize64") == NULL;
8888   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
8889   if (str && strcmp (str, "1") == 0) return 1;
8890   str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
8891   if (str && strcmp (str, "1") == 0) return 1;
8892   return 0;
8893 }
8894
8895 static int test_blockdev_getsize64_0 (void)
8896 {
8897   if (test_blockdev_getsize64_0_skip ()) {
8898     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
8899     return 0;
8900   }
8901
8902   /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
8903   {
8904     char device[] = "/dev/sda";
8905     int r;
8906     suppress_error = 0;
8907     r = guestfs_blockdev_setrw (g, device);
8908     if (r == -1)
8909       return -1;
8910   }
8911   {
8912     int r;
8913     suppress_error = 0;
8914     r = guestfs_umount_all (g);
8915     if (r == -1)
8916       return -1;
8917   }
8918   {
8919     int r;
8920     suppress_error = 0;
8921     r = guestfs_lvm_remove_all (g);
8922     if (r == -1)
8923       return -1;
8924   }
8925   /* TestOutputInt for blockdev_getsize64 (0) */
8926   {
8927     char device[] = "/dev/sda";
8928     int64_t r;
8929     suppress_error = 0;
8930     r = guestfs_blockdev_getsize64 (g, device);
8931     if (r == -1)
8932       return -1;
8933     if (r != 524288000) {
8934       fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n",               (int) r);
8935       return -1;
8936     }
8937   }
8938   return 0;
8939 }
8940
8941 static int test_blockdev_getsz_0_skip (void)
8942 {
8943   const char *str;
8944
8945   str = getenv ("TEST_ONLY");
8946   if (str)
8947     return strstr (str, "blockdev_getsz") == NULL;
8948   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
8949   if (str && strcmp (str, "1") == 0) return 1;
8950   str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
8951   if (str && strcmp (str, "1") == 0) return 1;
8952   return 0;
8953 }
8954
8955 static int test_blockdev_getsz_0 (void)
8956 {
8957   if (test_blockdev_getsz_0_skip ()) {
8958     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
8959     return 0;
8960   }
8961
8962   /* InitNone|InitEmpty for test_blockdev_getsz_0 */
8963   {
8964     char device[] = "/dev/sda";
8965     int r;
8966     suppress_error = 0;
8967     r = guestfs_blockdev_setrw (g, device);
8968     if (r == -1)
8969       return -1;
8970   }
8971   {
8972     int r;
8973     suppress_error = 0;
8974     r = guestfs_umount_all (g);
8975     if (r == -1)
8976       return -1;
8977   }
8978   {
8979     int r;
8980     suppress_error = 0;
8981     r = guestfs_lvm_remove_all (g);
8982     if (r == -1)
8983       return -1;
8984   }
8985   /* TestOutputInt for blockdev_getsz (0) */
8986   {
8987     char device[] = "/dev/sda";
8988     int64_t r;
8989     suppress_error = 0;
8990     r = guestfs_blockdev_getsz (g, device);
8991     if (r == -1)
8992       return -1;
8993     if (r != 1024000) {
8994       fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n",               (int) r);
8995       return -1;
8996     }
8997   }
8998   return 0;
8999 }
9000
9001 static int test_blockdev_getbsz_0_skip (void)
9002 {
9003   const char *str;
9004
9005   str = getenv ("TEST_ONLY");
9006   if (str)
9007     return strstr (str, "blockdev_getbsz") == NULL;
9008   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9009   if (str && strcmp (str, "1") == 0) return 1;
9010   str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9011   if (str && strcmp (str, "1") == 0) return 1;
9012   return 0;
9013 }
9014
9015 static int test_blockdev_getbsz_0 (void)
9016 {
9017   if (test_blockdev_getbsz_0_skip ()) {
9018     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9019     return 0;
9020   }
9021
9022   /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9023   {
9024     char device[] = "/dev/sda";
9025     int r;
9026     suppress_error = 0;
9027     r = guestfs_blockdev_setrw (g, device);
9028     if (r == -1)
9029       return -1;
9030   }
9031   {
9032     int r;
9033     suppress_error = 0;
9034     r = guestfs_umount_all (g);
9035     if (r == -1)
9036       return -1;
9037   }
9038   {
9039     int r;
9040     suppress_error = 0;
9041     r = guestfs_lvm_remove_all (g);
9042     if (r == -1)
9043       return -1;
9044   }
9045   /* TestOutputInt for blockdev_getbsz (0) */
9046   {
9047     char device[] = "/dev/sda";
9048     int r;
9049     suppress_error = 0;
9050     r = guestfs_blockdev_getbsz (g, device);
9051     if (r == -1)
9052       return -1;
9053     if (r != 4096) {
9054       fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n",               (int) r);
9055       return -1;
9056     }
9057   }
9058   return 0;
9059 }
9060
9061 static int test_blockdev_getss_0_skip (void)
9062 {
9063   const char *str;
9064
9065   str = getenv ("TEST_ONLY");
9066   if (str)
9067     return strstr (str, "blockdev_getss") == NULL;
9068   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9069   if (str && strcmp (str, "1") == 0) return 1;
9070   str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9071   if (str && strcmp (str, "1") == 0) return 1;
9072   return 0;
9073 }
9074
9075 static int test_blockdev_getss_0 (void)
9076 {
9077   if (test_blockdev_getss_0_skip ()) {
9078     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9079     return 0;
9080   }
9081
9082   /* InitNone|InitEmpty for test_blockdev_getss_0 */
9083   {
9084     char device[] = "/dev/sda";
9085     int r;
9086     suppress_error = 0;
9087     r = guestfs_blockdev_setrw (g, device);
9088     if (r == -1)
9089       return -1;
9090   }
9091   {
9092     int r;
9093     suppress_error = 0;
9094     r = guestfs_umount_all (g);
9095     if (r == -1)
9096       return -1;
9097   }
9098   {
9099     int r;
9100     suppress_error = 0;
9101     r = guestfs_lvm_remove_all (g);
9102     if (r == -1)
9103       return -1;
9104   }
9105   /* TestOutputInt for blockdev_getss (0) */
9106   {
9107     char device[] = "/dev/sda";
9108     int r;
9109     suppress_error = 0;
9110     r = guestfs_blockdev_getss (g, device);
9111     if (r == -1)
9112       return -1;
9113     if (r != 512) {
9114       fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n",               (int) r);
9115       return -1;
9116     }
9117   }
9118   return 0;
9119 }
9120
9121 static int test_blockdev_getro_0_skip (void)
9122 {
9123   const char *str;
9124
9125   str = getenv ("TEST_ONLY");
9126   if (str)
9127     return strstr (str, "blockdev_getro") == NULL;
9128   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9129   if (str && strcmp (str, "1") == 0) return 1;
9130   str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9131   if (str && strcmp (str, "1") == 0) return 1;
9132   return 0;
9133 }
9134
9135 static int test_blockdev_getro_0 (void)
9136 {
9137   if (test_blockdev_getro_0_skip ()) {
9138     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9139     return 0;
9140   }
9141
9142   /* InitNone|InitEmpty for test_blockdev_getro_0 */
9143   {
9144     char device[] = "/dev/sda";
9145     int r;
9146     suppress_error = 0;
9147     r = guestfs_blockdev_setrw (g, device);
9148     if (r == -1)
9149       return -1;
9150   }
9151   {
9152     int r;
9153     suppress_error = 0;
9154     r = guestfs_umount_all (g);
9155     if (r == -1)
9156       return -1;
9157   }
9158   {
9159     int r;
9160     suppress_error = 0;
9161     r = guestfs_lvm_remove_all (g);
9162     if (r == -1)
9163       return -1;
9164   }
9165   /* TestOutputTrue for blockdev_getro (0) */
9166   {
9167     char device[] = "/dev/sda";
9168     int r;
9169     suppress_error = 0;
9170     r = guestfs_blockdev_setro (g, device);
9171     if (r == -1)
9172       return -1;
9173   }
9174   {
9175     char device[] = "/dev/sda";
9176     int r;
9177     suppress_error = 0;
9178     r = guestfs_blockdev_getro (g, device);
9179     if (r == -1)
9180       return -1;
9181     if (!r) {
9182       fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9183       return -1;
9184     }
9185   }
9186   return 0;
9187 }
9188
9189 static int test_blockdev_setrw_0_skip (void)
9190 {
9191   const char *str;
9192
9193   str = getenv ("TEST_ONLY");
9194   if (str)
9195     return strstr (str, "blockdev_setrw") == NULL;
9196   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9197   if (str && strcmp (str, "1") == 0) return 1;
9198   str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9199   if (str && strcmp (str, "1") == 0) return 1;
9200   return 0;
9201 }
9202
9203 static int test_blockdev_setrw_0 (void)
9204 {
9205   if (test_blockdev_setrw_0_skip ()) {
9206     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9207     return 0;
9208   }
9209
9210   /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9211   {
9212     char device[] = "/dev/sda";
9213     int r;
9214     suppress_error = 0;
9215     r = guestfs_blockdev_setrw (g, device);
9216     if (r == -1)
9217       return -1;
9218   }
9219   {
9220     int r;
9221     suppress_error = 0;
9222     r = guestfs_umount_all (g);
9223     if (r == -1)
9224       return -1;
9225   }
9226   {
9227     int r;
9228     suppress_error = 0;
9229     r = guestfs_lvm_remove_all (g);
9230     if (r == -1)
9231       return -1;
9232   }
9233   /* TestOutputFalse for blockdev_setrw (0) */
9234   {
9235     char device[] = "/dev/sda";
9236     int r;
9237     suppress_error = 0;
9238     r = guestfs_blockdev_setrw (g, device);
9239     if (r == -1)
9240       return -1;
9241   }
9242   {
9243     char device[] = "/dev/sda";
9244     int r;
9245     suppress_error = 0;
9246     r = guestfs_blockdev_getro (g, device);
9247     if (r == -1)
9248       return -1;
9249     if (r) {
9250       fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9251       return -1;
9252     }
9253   }
9254   return 0;
9255 }
9256
9257 static int test_blockdev_setro_0_skip (void)
9258 {
9259   const char *str;
9260
9261   str = getenv ("TEST_ONLY");
9262   if (str)
9263     return strstr (str, "blockdev_setro") == NULL;
9264   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9265   if (str && strcmp (str, "1") == 0) return 1;
9266   str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9267   if (str && strcmp (str, "1") == 0) return 1;
9268   return 0;
9269 }
9270
9271 static int test_blockdev_setro_0 (void)
9272 {
9273   if (test_blockdev_setro_0_skip ()) {
9274     printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9275     return 0;
9276   }
9277
9278   /* InitNone|InitEmpty for test_blockdev_setro_0 */
9279   {
9280     char device[] = "/dev/sda";
9281     int r;
9282     suppress_error = 0;
9283     r = guestfs_blockdev_setrw (g, device);
9284     if (r == -1)
9285       return -1;
9286   }
9287   {
9288     int r;
9289     suppress_error = 0;
9290     r = guestfs_umount_all (g);
9291     if (r == -1)
9292       return -1;
9293   }
9294   {
9295     int r;
9296     suppress_error = 0;
9297     r = guestfs_lvm_remove_all (g);
9298     if (r == -1)
9299       return -1;
9300   }
9301   /* TestOutputTrue for blockdev_setro (0) */
9302   {
9303     char device[] = "/dev/sda";
9304     int r;
9305     suppress_error = 0;
9306     r = guestfs_blockdev_setro (g, device);
9307     if (r == -1)
9308       return -1;
9309   }
9310   {
9311     char device[] = "/dev/sda";
9312     int r;
9313     suppress_error = 0;
9314     r = guestfs_blockdev_getro (g, device);
9315     if (r == -1)
9316       return -1;
9317     if (!r) {
9318       fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9319       return -1;
9320     }
9321   }
9322   return 0;
9323 }
9324
9325 static int test_statvfs_0_skip (void)
9326 {
9327   const char *str;
9328
9329   str = getenv ("TEST_ONLY");
9330   if (str)
9331     return strstr (str, "statvfs") == NULL;
9332   str = getenv ("SKIP_TEST_STATVFS_0");
9333   if (str && strcmp (str, "1") == 0) return 1;
9334   str = getenv ("SKIP_TEST_STATVFS");
9335   if (str && strcmp (str, "1") == 0) return 1;
9336   return 0;
9337 }
9338
9339 static int test_statvfs_0 (void)
9340 {
9341   if (test_statvfs_0_skip ()) {
9342     printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9343     return 0;
9344   }
9345
9346   /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9347   {
9348     char device[] = "/dev/sda";
9349     int r;
9350     suppress_error = 0;
9351     r = guestfs_blockdev_setrw (g, device);
9352     if (r == -1)
9353       return -1;
9354   }
9355   {
9356     int r;
9357     suppress_error = 0;
9358     r = guestfs_umount_all (g);
9359     if (r == -1)
9360       return -1;
9361   }
9362   {
9363     int r;
9364     suppress_error = 0;
9365     r = guestfs_lvm_remove_all (g);
9366     if (r == -1)
9367       return -1;
9368   }
9369   {
9370     char device[] = "/dev/sda";
9371     char lines_0[] = ",";
9372     char *lines[] = {
9373       lines_0,
9374       NULL
9375     };
9376     int r;
9377     suppress_error = 0;
9378     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9379     if (r == -1)
9380       return -1;
9381   }
9382   {
9383     char fstype[] = "ext2";
9384     char device[] = "/dev/sda1";
9385     int r;
9386     suppress_error = 0;
9387     r = guestfs_mkfs (g, fstype, device);
9388     if (r == -1)
9389       return -1;
9390   }
9391   {
9392     char device[] = "/dev/sda1";
9393     char mountpoint[] = "/";
9394     int r;
9395     suppress_error = 0;
9396     r = guestfs_mount (g, device, mountpoint);
9397     if (r == -1)
9398       return -1;
9399   }
9400   /* TestOutputStruct for statvfs (0) */
9401   {
9402     char path[] = "/";
9403     struct guestfs_statvfs *r;
9404     suppress_error = 0;
9405     r = guestfs_statvfs (g, path);
9406     if (r == NULL)
9407       return -1;
9408     if (r->bfree != 487702) {
9409       fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9410                (int) r->bfree);
9411       return -1;
9412     }
9413     if (r->blocks != 490020) {
9414       fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9415                (int) r->blocks);
9416       return -1;
9417     }
9418     if (r->bsize != 1024) {
9419       fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9420                (int) r->bsize);
9421       return -1;
9422     }
9423     free (r);
9424   }
9425   return 0;
9426 }
9427
9428 static int test_lstat_0_skip (void)
9429 {
9430   const char *str;
9431
9432   str = getenv ("TEST_ONLY");
9433   if (str)
9434     return strstr (str, "lstat") == NULL;
9435   str = getenv ("SKIP_TEST_LSTAT_0");
9436   if (str && strcmp (str, "1") == 0) return 1;
9437   str = getenv ("SKIP_TEST_LSTAT");
9438   if (str && strcmp (str, "1") == 0) return 1;
9439   return 0;
9440 }
9441
9442 static int test_lstat_0 (void)
9443 {
9444   if (test_lstat_0_skip ()) {
9445     printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9446     return 0;
9447   }
9448
9449   /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9450   {
9451     char device[] = "/dev/sda";
9452     int r;
9453     suppress_error = 0;
9454     r = guestfs_blockdev_setrw (g, device);
9455     if (r == -1)
9456       return -1;
9457   }
9458   {
9459     int r;
9460     suppress_error = 0;
9461     r = guestfs_umount_all (g);
9462     if (r == -1)
9463       return -1;
9464   }
9465   {
9466     int r;
9467     suppress_error = 0;
9468     r = guestfs_lvm_remove_all (g);
9469     if (r == -1)
9470       return -1;
9471   }
9472   {
9473     char device[] = "/dev/sda";
9474     char lines_0[] = ",";
9475     char *lines[] = {
9476       lines_0,
9477       NULL
9478     };
9479     int r;
9480     suppress_error = 0;
9481     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9482     if (r == -1)
9483       return -1;
9484   }
9485   {
9486     char fstype[] = "ext2";
9487     char device[] = "/dev/sda1";
9488     int r;
9489     suppress_error = 0;
9490     r = guestfs_mkfs (g, fstype, device);
9491     if (r == -1)
9492       return -1;
9493   }
9494   {
9495     char device[] = "/dev/sda1";
9496     char mountpoint[] = "/";
9497     int r;
9498     suppress_error = 0;
9499     r = guestfs_mount (g, device, mountpoint);
9500     if (r == -1)
9501       return -1;
9502   }
9503   /* TestOutputStruct for lstat (0) */
9504   {
9505     char path[] = "/new";
9506     int r;
9507     suppress_error = 0;
9508     r = guestfs_touch (g, path);
9509     if (r == -1)
9510       return -1;
9511   }
9512   {
9513     char path[] = "/new";
9514     struct guestfs_stat *r;
9515     suppress_error = 0;
9516     r = guestfs_lstat (g, path);
9517     if (r == NULL)
9518       return -1;
9519     if (r->size != 0) {
9520       fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9521                (int) r->size);
9522       return -1;
9523     }
9524     free (r);
9525   }
9526   return 0;
9527 }
9528
9529 static int test_stat_0_skip (void)
9530 {
9531   const char *str;
9532
9533   str = getenv ("TEST_ONLY");
9534   if (str)
9535     return strstr (str, "stat") == NULL;
9536   str = getenv ("SKIP_TEST_STAT_0");
9537   if (str && strcmp (str, "1") == 0) return 1;
9538   str = getenv ("SKIP_TEST_STAT");
9539   if (str && strcmp (str, "1") == 0) return 1;
9540   return 0;
9541 }
9542
9543 static int test_stat_0 (void)
9544 {
9545   if (test_stat_0_skip ()) {
9546     printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9547     return 0;
9548   }
9549
9550   /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9551   {
9552     char device[] = "/dev/sda";
9553     int r;
9554     suppress_error = 0;
9555     r = guestfs_blockdev_setrw (g, device);
9556     if (r == -1)
9557       return -1;
9558   }
9559   {
9560     int r;
9561     suppress_error = 0;
9562     r = guestfs_umount_all (g);
9563     if (r == -1)
9564       return -1;
9565   }
9566   {
9567     int r;
9568     suppress_error = 0;
9569     r = guestfs_lvm_remove_all (g);
9570     if (r == -1)
9571       return -1;
9572   }
9573   {
9574     char device[] = "/dev/sda";
9575     char lines_0[] = ",";
9576     char *lines[] = {
9577       lines_0,
9578       NULL
9579     };
9580     int r;
9581     suppress_error = 0;
9582     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9583     if (r == -1)
9584       return -1;
9585   }
9586   {
9587     char fstype[] = "ext2";
9588     char device[] = "/dev/sda1";
9589     int r;
9590     suppress_error = 0;
9591     r = guestfs_mkfs (g, fstype, device);
9592     if (r == -1)
9593       return -1;
9594   }
9595   {
9596     char device[] = "/dev/sda1";
9597     char mountpoint[] = "/";
9598     int r;
9599     suppress_error = 0;
9600     r = guestfs_mount (g, device, mountpoint);
9601     if (r == -1)
9602       return -1;
9603   }
9604   /* TestOutputStruct for stat (0) */
9605   {
9606     char path[] = "/new";
9607     int r;
9608     suppress_error = 0;
9609     r = guestfs_touch (g, path);
9610     if (r == -1)
9611       return -1;
9612   }
9613   {
9614     char path[] = "/new";
9615     struct guestfs_stat *r;
9616     suppress_error = 0;
9617     r = guestfs_stat (g, path);
9618     if (r == NULL)
9619       return -1;
9620     if (r->size != 0) {
9621       fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9622                (int) r->size);
9623       return -1;
9624     }
9625     free (r);
9626   }
9627   return 0;
9628 }
9629
9630 static int test_command_lines_0_skip (void)
9631 {
9632   const char *str;
9633
9634   str = getenv ("TEST_ONLY");
9635   if (str)
9636     return strstr (str, "command_lines") == NULL;
9637   str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9638   if (str && strcmp (str, "1") == 0) return 1;
9639   str = getenv ("SKIP_TEST_COMMAND_LINES");
9640   if (str && strcmp (str, "1") == 0) return 1;
9641   return 0;
9642 }
9643
9644 static int test_command_lines_0 (void)
9645 {
9646   if (test_command_lines_0_skip ()) {
9647     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9648     return 0;
9649   }
9650
9651   /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9652   {
9653     char device[] = "/dev/sda";
9654     int r;
9655     suppress_error = 0;
9656     r = guestfs_blockdev_setrw (g, device);
9657     if (r == -1)
9658       return -1;
9659   }
9660   {
9661     int r;
9662     suppress_error = 0;
9663     r = guestfs_umount_all (g);
9664     if (r == -1)
9665       return -1;
9666   }
9667   {
9668     int r;
9669     suppress_error = 0;
9670     r = guestfs_lvm_remove_all (g);
9671     if (r == -1)
9672       return -1;
9673   }
9674   {
9675     char device[] = "/dev/sda";
9676     char lines_0[] = ",";
9677     char *lines[] = {
9678       lines_0,
9679       NULL
9680     };
9681     int r;
9682     suppress_error = 0;
9683     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9684     if (r == -1)
9685       return -1;
9686   }
9687   {
9688     char fstype[] = "ext2";
9689     char device[] = "/dev/sda1";
9690     int r;
9691     suppress_error = 0;
9692     r = guestfs_mkfs (g, fstype, device);
9693     if (r == -1)
9694       return -1;
9695   }
9696   {
9697     char device[] = "/dev/sda1";
9698     char mountpoint[] = "/";
9699     int r;
9700     suppress_error = 0;
9701     r = guestfs_mount (g, device, mountpoint);
9702     if (r == -1)
9703       return -1;
9704   }
9705   /* TestOutputList for command_lines (0) */
9706   {
9707     char remotefilename[] = "/test-command";
9708     int r;
9709     suppress_error = 0;
9710     r = guestfs_upload (g, "test-command", remotefilename);
9711     if (r == -1)
9712       return -1;
9713   }
9714   {
9715     char path[] = "/test-command";
9716     int r;
9717     suppress_error = 0;
9718     r = guestfs_chmod (g, 493, path);
9719     if (r == -1)
9720       return -1;
9721   }
9722   {
9723     char arguments_0[] = "/test-command";
9724     char arguments_1[] = "1";
9725     char *arguments[] = {
9726       arguments_0,
9727       arguments_1,
9728       NULL
9729     };
9730     char **r;
9731     int i;
9732     suppress_error = 0;
9733     r = guestfs_command_lines (g, arguments);
9734     if (r == NULL)
9735       return -1;
9736     if (!r[0]) {
9737       fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9738       print_strings (r);
9739       return -1;
9740     }
9741     {
9742       char expected[] = "Result1";
9743       if (strcmp (r[0], expected) != 0) {
9744         fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9745         return -1;
9746       }
9747     }
9748     if (r[1] != NULL) {
9749       fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9750       print_strings (r);
9751       return -1;
9752     }
9753     for (i = 0; r[i] != NULL; ++i)
9754       free (r[i]);
9755     free (r);
9756   }
9757   return 0;
9758 }
9759
9760 static int test_command_lines_1_skip (void)
9761 {
9762   const char *str;
9763
9764   str = getenv ("TEST_ONLY");
9765   if (str)
9766     return strstr (str, "command_lines") == NULL;
9767   str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9768   if (str && strcmp (str, "1") == 0) return 1;
9769   str = getenv ("SKIP_TEST_COMMAND_LINES");
9770   if (str && strcmp (str, "1") == 0) return 1;
9771   return 0;
9772 }
9773
9774 static int test_command_lines_1 (void)
9775 {
9776   if (test_command_lines_1_skip ()) {
9777     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9778     return 0;
9779   }
9780
9781   /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9782   {
9783     char device[] = "/dev/sda";
9784     int r;
9785     suppress_error = 0;
9786     r = guestfs_blockdev_setrw (g, device);
9787     if (r == -1)
9788       return -1;
9789   }
9790   {
9791     int r;
9792     suppress_error = 0;
9793     r = guestfs_umount_all (g);
9794     if (r == -1)
9795       return -1;
9796   }
9797   {
9798     int r;
9799     suppress_error = 0;
9800     r = guestfs_lvm_remove_all (g);
9801     if (r == -1)
9802       return -1;
9803   }
9804   {
9805     char device[] = "/dev/sda";
9806     char lines_0[] = ",";
9807     char *lines[] = {
9808       lines_0,
9809       NULL
9810     };
9811     int r;
9812     suppress_error = 0;
9813     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9814     if (r == -1)
9815       return -1;
9816   }
9817   {
9818     char fstype[] = "ext2";
9819     char device[] = "/dev/sda1";
9820     int r;
9821     suppress_error = 0;
9822     r = guestfs_mkfs (g, fstype, device);
9823     if (r == -1)
9824       return -1;
9825   }
9826   {
9827     char device[] = "/dev/sda1";
9828     char mountpoint[] = "/";
9829     int r;
9830     suppress_error = 0;
9831     r = guestfs_mount (g, device, mountpoint);
9832     if (r == -1)
9833       return -1;
9834   }
9835   /* TestOutputList for command_lines (1) */
9836   {
9837     char remotefilename[] = "/test-command";
9838     int r;
9839     suppress_error = 0;
9840     r = guestfs_upload (g, "test-command", remotefilename);
9841     if (r == -1)
9842       return -1;
9843   }
9844   {
9845     char path[] = "/test-command";
9846     int r;
9847     suppress_error = 0;
9848     r = guestfs_chmod (g, 493, path);
9849     if (r == -1)
9850       return -1;
9851   }
9852   {
9853     char arguments_0[] = "/test-command";
9854     char arguments_1[] = "2";
9855     char *arguments[] = {
9856       arguments_0,
9857       arguments_1,
9858       NULL
9859     };
9860     char **r;
9861     int i;
9862     suppress_error = 0;
9863     r = guestfs_command_lines (g, arguments);
9864     if (r == NULL)
9865       return -1;
9866     if (!r[0]) {
9867       fprintf (stderr, "test_command_lines_1: short list returned from command\n");
9868       print_strings (r);
9869       return -1;
9870     }
9871     {
9872       char expected[] = "Result2";
9873       if (strcmp (r[0], expected) != 0) {
9874         fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9875         return -1;
9876       }
9877     }
9878     if (r[1] != NULL) {
9879       fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
9880       print_strings (r);
9881       return -1;
9882     }
9883     for (i = 0; r[i] != NULL; ++i)
9884       free (r[i]);
9885     free (r);
9886   }
9887   return 0;
9888 }
9889
9890 static int test_command_lines_2_skip (void)
9891 {
9892   const char *str;
9893
9894   str = getenv ("TEST_ONLY");
9895   if (str)
9896     return strstr (str, "command_lines") == NULL;
9897   str = getenv ("SKIP_TEST_COMMAND_LINES_2");
9898   if (str && strcmp (str, "1") == 0) return 1;
9899   str = getenv ("SKIP_TEST_COMMAND_LINES");
9900   if (str && strcmp (str, "1") == 0) return 1;
9901   return 0;
9902 }
9903
9904 static int test_command_lines_2 (void)
9905 {
9906   if (test_command_lines_2_skip ()) {
9907     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
9908     return 0;
9909   }
9910
9911   /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
9912   {
9913     char device[] = "/dev/sda";
9914     int r;
9915     suppress_error = 0;
9916     r = guestfs_blockdev_setrw (g, device);
9917     if (r == -1)
9918       return -1;
9919   }
9920   {
9921     int r;
9922     suppress_error = 0;
9923     r = guestfs_umount_all (g);
9924     if (r == -1)
9925       return -1;
9926   }
9927   {
9928     int r;
9929     suppress_error = 0;
9930     r = guestfs_lvm_remove_all (g);
9931     if (r == -1)
9932       return -1;
9933   }
9934   {
9935     char device[] = "/dev/sda";
9936     char lines_0[] = ",";
9937     char *lines[] = {
9938       lines_0,
9939       NULL
9940     };
9941     int r;
9942     suppress_error = 0;
9943     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9944     if (r == -1)
9945       return -1;
9946   }
9947   {
9948     char fstype[] = "ext2";
9949     char device[] = "/dev/sda1";
9950     int r;
9951     suppress_error = 0;
9952     r = guestfs_mkfs (g, fstype, device);
9953     if (r == -1)
9954       return -1;
9955   }
9956   {
9957     char device[] = "/dev/sda1";
9958     char mountpoint[] = "/";
9959     int r;
9960     suppress_error = 0;
9961     r = guestfs_mount (g, device, mountpoint);
9962     if (r == -1)
9963       return -1;
9964   }
9965   /* TestOutputList for command_lines (2) */
9966   {
9967     char remotefilename[] = "/test-command";
9968     int r;
9969     suppress_error = 0;
9970     r = guestfs_upload (g, "test-command", remotefilename);
9971     if (r == -1)
9972       return -1;
9973   }
9974   {
9975     char path[] = "/test-command";
9976     int r;
9977     suppress_error = 0;
9978     r = guestfs_chmod (g, 493, path);
9979     if (r == -1)
9980       return -1;
9981   }
9982   {
9983     char arguments_0[] = "/test-command";
9984     char arguments_1[] = "3";
9985     char *arguments[] = {
9986       arguments_0,
9987       arguments_1,
9988       NULL
9989     };
9990     char **r;
9991     int i;
9992     suppress_error = 0;
9993     r = guestfs_command_lines (g, arguments);
9994     if (r == NULL)
9995       return -1;
9996     if (!r[0]) {
9997       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9998       print_strings (r);
9999       return -1;
10000     }
10001     {
10002       char expected[] = "";
10003       if (strcmp (r[0], expected) != 0) {
10004         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10005         return -1;
10006       }
10007     }
10008     if (!r[1]) {
10009       fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10010       print_strings (r);
10011       return -1;
10012     }
10013     {
10014       char expected[] = "Result3";
10015       if (strcmp (r[1], expected) != 0) {
10016         fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10017         return -1;
10018       }
10019     }
10020     if (r[2] != NULL) {
10021       fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10022       print_strings (r);
10023       return -1;
10024     }
10025     for (i = 0; r[i] != NULL; ++i)
10026       free (r[i]);
10027     free (r);
10028   }
10029   return 0;
10030 }
10031
10032 static int test_command_lines_3_skip (void)
10033 {
10034   const char *str;
10035
10036   str = getenv ("TEST_ONLY");
10037   if (str)
10038     return strstr (str, "command_lines") == NULL;
10039   str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10040   if (str && strcmp (str, "1") == 0) return 1;
10041   str = getenv ("SKIP_TEST_COMMAND_LINES");
10042   if (str && strcmp (str, "1") == 0) return 1;
10043   return 0;
10044 }
10045
10046 static int test_command_lines_3 (void)
10047 {
10048   if (test_command_lines_3_skip ()) {
10049     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
10050     return 0;
10051   }
10052
10053   /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10054   {
10055     char device[] = "/dev/sda";
10056     int r;
10057     suppress_error = 0;
10058     r = guestfs_blockdev_setrw (g, device);
10059     if (r == -1)
10060       return -1;
10061   }
10062   {
10063     int r;
10064     suppress_error = 0;
10065     r = guestfs_umount_all (g);
10066     if (r == -1)
10067       return -1;
10068   }
10069   {
10070     int r;
10071     suppress_error = 0;
10072     r = guestfs_lvm_remove_all (g);
10073     if (r == -1)
10074       return -1;
10075   }
10076   {
10077     char device[] = "/dev/sda";
10078     char lines_0[] = ",";
10079     char *lines[] = {
10080       lines_0,
10081       NULL
10082     };
10083     int r;
10084     suppress_error = 0;
10085     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10086     if (r == -1)
10087       return -1;
10088   }
10089   {
10090     char fstype[] = "ext2";
10091     char device[] = "/dev/sda1";
10092     int r;
10093     suppress_error = 0;
10094     r = guestfs_mkfs (g, fstype, device);
10095     if (r == -1)
10096       return -1;
10097   }
10098   {
10099     char device[] = "/dev/sda1";
10100     char mountpoint[] = "/";
10101     int r;
10102     suppress_error = 0;
10103     r = guestfs_mount (g, device, mountpoint);
10104     if (r == -1)
10105       return -1;
10106   }
10107   /* TestOutputList for command_lines (3) */
10108   {
10109     char remotefilename[] = "/test-command";
10110     int r;
10111     suppress_error = 0;
10112     r = guestfs_upload (g, "test-command", remotefilename);
10113     if (r == -1)
10114       return -1;
10115   }
10116   {
10117     char path[] = "/test-command";
10118     int r;
10119     suppress_error = 0;
10120     r = guestfs_chmod (g, 493, path);
10121     if (r == -1)
10122       return -1;
10123   }
10124   {
10125     char arguments_0[] = "/test-command";
10126     char arguments_1[] = "4";
10127     char *arguments[] = {
10128       arguments_0,
10129       arguments_1,
10130       NULL
10131     };
10132     char **r;
10133     int i;
10134     suppress_error = 0;
10135     r = guestfs_command_lines (g, arguments);
10136     if (r == NULL)
10137       return -1;
10138     if (!r[0]) {
10139       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10140       print_strings (r);
10141       return -1;
10142     }
10143     {
10144       char expected[] = "";
10145       if (strcmp (r[0], expected) != 0) {
10146         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10147         return -1;
10148       }
10149     }
10150     if (!r[1]) {
10151       fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10152       print_strings (r);
10153       return -1;
10154     }
10155     {
10156       char expected[] = "Result4";
10157       if (strcmp (r[1], expected) != 0) {
10158         fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10159         return -1;
10160       }
10161     }
10162     if (r[2] != NULL) {
10163       fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10164       print_strings (r);
10165       return -1;
10166     }
10167     for (i = 0; r[i] != NULL; ++i)
10168       free (r[i]);
10169     free (r);
10170   }
10171   return 0;
10172 }
10173
10174 static int test_command_lines_4_skip (void)
10175 {
10176   const char *str;
10177
10178   str = getenv ("TEST_ONLY");
10179   if (str)
10180     return strstr (str, "command_lines") == NULL;
10181   str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10182   if (str && strcmp (str, "1") == 0) return 1;
10183   str = getenv ("SKIP_TEST_COMMAND_LINES");
10184   if (str && strcmp (str, "1") == 0) return 1;
10185   return 0;
10186 }
10187
10188 static int test_command_lines_4 (void)
10189 {
10190   if (test_command_lines_4_skip ()) {
10191     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10192     return 0;
10193   }
10194
10195   /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10196   {
10197     char device[] = "/dev/sda";
10198     int r;
10199     suppress_error = 0;
10200     r = guestfs_blockdev_setrw (g, device);
10201     if (r == -1)
10202       return -1;
10203   }
10204   {
10205     int r;
10206     suppress_error = 0;
10207     r = guestfs_umount_all (g);
10208     if (r == -1)
10209       return -1;
10210   }
10211   {
10212     int r;
10213     suppress_error = 0;
10214     r = guestfs_lvm_remove_all (g);
10215     if (r == -1)
10216       return -1;
10217   }
10218   {
10219     char device[] = "/dev/sda";
10220     char lines_0[] = ",";
10221     char *lines[] = {
10222       lines_0,
10223       NULL
10224     };
10225     int r;
10226     suppress_error = 0;
10227     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10228     if (r == -1)
10229       return -1;
10230   }
10231   {
10232     char fstype[] = "ext2";
10233     char device[] = "/dev/sda1";
10234     int r;
10235     suppress_error = 0;
10236     r = guestfs_mkfs (g, fstype, device);
10237     if (r == -1)
10238       return -1;
10239   }
10240   {
10241     char device[] = "/dev/sda1";
10242     char mountpoint[] = "/";
10243     int r;
10244     suppress_error = 0;
10245     r = guestfs_mount (g, device, mountpoint);
10246     if (r == -1)
10247       return -1;
10248   }
10249   /* TestOutputList for command_lines (4) */
10250   {
10251     char remotefilename[] = "/test-command";
10252     int r;
10253     suppress_error = 0;
10254     r = guestfs_upload (g, "test-command", remotefilename);
10255     if (r == -1)
10256       return -1;
10257   }
10258   {
10259     char path[] = "/test-command";
10260     int r;
10261     suppress_error = 0;
10262     r = guestfs_chmod (g, 493, path);
10263     if (r == -1)
10264       return -1;
10265   }
10266   {
10267     char arguments_0[] = "/test-command";
10268     char arguments_1[] = "5";
10269     char *arguments[] = {
10270       arguments_0,
10271       arguments_1,
10272       NULL
10273     };
10274     char **r;
10275     int i;
10276     suppress_error = 0;
10277     r = guestfs_command_lines (g, arguments);
10278     if (r == NULL)
10279       return -1;
10280     if (!r[0]) {
10281       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10282       print_strings (r);
10283       return -1;
10284     }
10285     {
10286       char expected[] = "";
10287       if (strcmp (r[0], expected) != 0) {
10288         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10289         return -1;
10290       }
10291     }
10292     if (!r[1]) {
10293       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10294       print_strings (r);
10295       return -1;
10296     }
10297     {
10298       char expected[] = "Result5";
10299       if (strcmp (r[1], expected) != 0) {
10300         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10301         return -1;
10302       }
10303     }
10304     if (!r[2]) {
10305       fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10306       print_strings (r);
10307       return -1;
10308     }
10309     {
10310       char expected[] = "";
10311       if (strcmp (r[2], expected) != 0) {
10312         fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10313         return -1;
10314       }
10315     }
10316     if (r[3] != NULL) {
10317       fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10318       print_strings (r);
10319       return -1;
10320     }
10321     for (i = 0; r[i] != NULL; ++i)
10322       free (r[i]);
10323     free (r);
10324   }
10325   return 0;
10326 }
10327
10328 static int test_command_lines_5_skip (void)
10329 {
10330   const char *str;
10331
10332   str = getenv ("TEST_ONLY");
10333   if (str)
10334     return strstr (str, "command_lines") == NULL;
10335   str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10336   if (str && strcmp (str, "1") == 0) return 1;
10337   str = getenv ("SKIP_TEST_COMMAND_LINES");
10338   if (str && strcmp (str, "1") == 0) return 1;
10339   return 0;
10340 }
10341
10342 static int test_command_lines_5 (void)
10343 {
10344   if (test_command_lines_5_skip ()) {
10345     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10346     return 0;
10347   }
10348
10349   /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10350   {
10351     char device[] = "/dev/sda";
10352     int r;
10353     suppress_error = 0;
10354     r = guestfs_blockdev_setrw (g, device);
10355     if (r == -1)
10356       return -1;
10357   }
10358   {
10359     int r;
10360     suppress_error = 0;
10361     r = guestfs_umount_all (g);
10362     if (r == -1)
10363       return -1;
10364   }
10365   {
10366     int r;
10367     suppress_error = 0;
10368     r = guestfs_lvm_remove_all (g);
10369     if (r == -1)
10370       return -1;
10371   }
10372   {
10373     char device[] = "/dev/sda";
10374     char lines_0[] = ",";
10375     char *lines[] = {
10376       lines_0,
10377       NULL
10378     };
10379     int r;
10380     suppress_error = 0;
10381     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10382     if (r == -1)
10383       return -1;
10384   }
10385   {
10386     char fstype[] = "ext2";
10387     char device[] = "/dev/sda1";
10388     int r;
10389     suppress_error = 0;
10390     r = guestfs_mkfs (g, fstype, device);
10391     if (r == -1)
10392       return -1;
10393   }
10394   {
10395     char device[] = "/dev/sda1";
10396     char mountpoint[] = "/";
10397     int r;
10398     suppress_error = 0;
10399     r = guestfs_mount (g, device, mountpoint);
10400     if (r == -1)
10401       return -1;
10402   }
10403   /* TestOutputList for command_lines (5) */
10404   {
10405     char remotefilename[] = "/test-command";
10406     int r;
10407     suppress_error = 0;
10408     r = guestfs_upload (g, "test-command", remotefilename);
10409     if (r == -1)
10410       return -1;
10411   }
10412   {
10413     char path[] = "/test-command";
10414     int r;
10415     suppress_error = 0;
10416     r = guestfs_chmod (g, 493, path);
10417     if (r == -1)
10418       return -1;
10419   }
10420   {
10421     char arguments_0[] = "/test-command";
10422     char arguments_1[] = "6";
10423     char *arguments[] = {
10424       arguments_0,
10425       arguments_1,
10426       NULL
10427     };
10428     char **r;
10429     int i;
10430     suppress_error = 0;
10431     r = guestfs_command_lines (g, arguments);
10432     if (r == NULL)
10433       return -1;
10434     if (!r[0]) {
10435       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10436       print_strings (r);
10437       return -1;
10438     }
10439     {
10440       char expected[] = "";
10441       if (strcmp (r[0], expected) != 0) {
10442         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10443         return -1;
10444       }
10445     }
10446     if (!r[1]) {
10447       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10448       print_strings (r);
10449       return -1;
10450     }
10451     {
10452       char expected[] = "";
10453       if (strcmp (r[1], expected) != 0) {
10454         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10455         return -1;
10456       }
10457     }
10458     if (!r[2]) {
10459       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10460       print_strings (r);
10461       return -1;
10462     }
10463     {
10464       char expected[] = "Result6";
10465       if (strcmp (r[2], expected) != 0) {
10466         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10467         return -1;
10468       }
10469     }
10470     if (!r[3]) {
10471       fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10472       print_strings (r);
10473       return -1;
10474     }
10475     {
10476       char expected[] = "";
10477       if (strcmp (r[3], expected) != 0) {
10478         fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10479         return -1;
10480       }
10481     }
10482     if (r[4] != NULL) {
10483       fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10484       print_strings (r);
10485       return -1;
10486     }
10487     for (i = 0; r[i] != NULL; ++i)
10488       free (r[i]);
10489     free (r);
10490   }
10491   return 0;
10492 }
10493
10494 static int test_command_lines_6_skip (void)
10495 {
10496   const char *str;
10497
10498   str = getenv ("TEST_ONLY");
10499   if (str)
10500     return strstr (str, "command_lines") == NULL;
10501   str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10502   if (str && strcmp (str, "1") == 0) return 1;
10503   str = getenv ("SKIP_TEST_COMMAND_LINES");
10504   if (str && strcmp (str, "1") == 0) return 1;
10505   return 0;
10506 }
10507
10508 static int test_command_lines_6 (void)
10509 {
10510   if (test_command_lines_6_skip ()) {
10511     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10512     return 0;
10513   }
10514
10515   /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10516   {
10517     char device[] = "/dev/sda";
10518     int r;
10519     suppress_error = 0;
10520     r = guestfs_blockdev_setrw (g, device);
10521     if (r == -1)
10522       return -1;
10523   }
10524   {
10525     int r;
10526     suppress_error = 0;
10527     r = guestfs_umount_all (g);
10528     if (r == -1)
10529       return -1;
10530   }
10531   {
10532     int r;
10533     suppress_error = 0;
10534     r = guestfs_lvm_remove_all (g);
10535     if (r == -1)
10536       return -1;
10537   }
10538   {
10539     char device[] = "/dev/sda";
10540     char lines_0[] = ",";
10541     char *lines[] = {
10542       lines_0,
10543       NULL
10544     };
10545     int r;
10546     suppress_error = 0;
10547     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10548     if (r == -1)
10549       return -1;
10550   }
10551   {
10552     char fstype[] = "ext2";
10553     char device[] = "/dev/sda1";
10554     int r;
10555     suppress_error = 0;
10556     r = guestfs_mkfs (g, fstype, device);
10557     if (r == -1)
10558       return -1;
10559   }
10560   {
10561     char device[] = "/dev/sda1";
10562     char mountpoint[] = "/";
10563     int r;
10564     suppress_error = 0;
10565     r = guestfs_mount (g, device, mountpoint);
10566     if (r == -1)
10567       return -1;
10568   }
10569   /* TestOutputList for command_lines (6) */
10570   {
10571     char remotefilename[] = "/test-command";
10572     int r;
10573     suppress_error = 0;
10574     r = guestfs_upload (g, "test-command", remotefilename);
10575     if (r == -1)
10576       return -1;
10577   }
10578   {
10579     char path[] = "/test-command";
10580     int r;
10581     suppress_error = 0;
10582     r = guestfs_chmod (g, 493, path);
10583     if (r == -1)
10584       return -1;
10585   }
10586   {
10587     char arguments_0[] = "/test-command";
10588     char arguments_1[] = "7";
10589     char *arguments[] = {
10590       arguments_0,
10591       arguments_1,
10592       NULL
10593     };
10594     char **r;
10595     int i;
10596     suppress_error = 0;
10597     r = guestfs_command_lines (g, arguments);
10598     if (r == NULL)
10599       return -1;
10600     if (r[0] != NULL) {
10601       fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10602       print_strings (r);
10603       return -1;
10604     }
10605     for (i = 0; r[i] != NULL; ++i)
10606       free (r[i]);
10607     free (r);
10608   }
10609   return 0;
10610 }
10611
10612 static int test_command_lines_7_skip (void)
10613 {
10614   const char *str;
10615
10616   str = getenv ("TEST_ONLY");
10617   if (str)
10618     return strstr (str, "command_lines") == NULL;
10619   str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10620   if (str && strcmp (str, "1") == 0) return 1;
10621   str = getenv ("SKIP_TEST_COMMAND_LINES");
10622   if (str && strcmp (str, "1") == 0) return 1;
10623   return 0;
10624 }
10625
10626 static int test_command_lines_7 (void)
10627 {
10628   if (test_command_lines_7_skip ()) {
10629     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10630     return 0;
10631   }
10632
10633   /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10634   {
10635     char device[] = "/dev/sda";
10636     int r;
10637     suppress_error = 0;
10638     r = guestfs_blockdev_setrw (g, device);
10639     if (r == -1)
10640       return -1;
10641   }
10642   {
10643     int r;
10644     suppress_error = 0;
10645     r = guestfs_umount_all (g);
10646     if (r == -1)
10647       return -1;
10648   }
10649   {
10650     int r;
10651     suppress_error = 0;
10652     r = guestfs_lvm_remove_all (g);
10653     if (r == -1)
10654       return -1;
10655   }
10656   {
10657     char device[] = "/dev/sda";
10658     char lines_0[] = ",";
10659     char *lines[] = {
10660       lines_0,
10661       NULL
10662     };
10663     int r;
10664     suppress_error = 0;
10665     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10666     if (r == -1)
10667       return -1;
10668   }
10669   {
10670     char fstype[] = "ext2";
10671     char device[] = "/dev/sda1";
10672     int r;
10673     suppress_error = 0;
10674     r = guestfs_mkfs (g, fstype, device);
10675     if (r == -1)
10676       return -1;
10677   }
10678   {
10679     char device[] = "/dev/sda1";
10680     char mountpoint[] = "/";
10681     int r;
10682     suppress_error = 0;
10683     r = guestfs_mount (g, device, mountpoint);
10684     if (r == -1)
10685       return -1;
10686   }
10687   /* TestOutputList for command_lines (7) */
10688   {
10689     char remotefilename[] = "/test-command";
10690     int r;
10691     suppress_error = 0;
10692     r = guestfs_upload (g, "test-command", remotefilename);
10693     if (r == -1)
10694       return -1;
10695   }
10696   {
10697     char path[] = "/test-command";
10698     int r;
10699     suppress_error = 0;
10700     r = guestfs_chmod (g, 493, path);
10701     if (r == -1)
10702       return -1;
10703   }
10704   {
10705     char arguments_0[] = "/test-command";
10706     char arguments_1[] = "8";
10707     char *arguments[] = {
10708       arguments_0,
10709       arguments_1,
10710       NULL
10711     };
10712     char **r;
10713     int i;
10714     suppress_error = 0;
10715     r = guestfs_command_lines (g, arguments);
10716     if (r == NULL)
10717       return -1;
10718     if (!r[0]) {
10719       fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10720       print_strings (r);
10721       return -1;
10722     }
10723     {
10724       char expected[] = "";
10725       if (strcmp (r[0], expected) != 0) {
10726         fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10727         return -1;
10728       }
10729     }
10730     if (r[1] != NULL) {
10731       fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10732       print_strings (r);
10733       return -1;
10734     }
10735     for (i = 0; r[i] != NULL; ++i)
10736       free (r[i]);
10737     free (r);
10738   }
10739   return 0;
10740 }
10741
10742 static int test_command_lines_8_skip (void)
10743 {
10744   const char *str;
10745
10746   str = getenv ("TEST_ONLY");
10747   if (str)
10748     return strstr (str, "command_lines") == NULL;
10749   str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10750   if (str && strcmp (str, "1") == 0) return 1;
10751   str = getenv ("SKIP_TEST_COMMAND_LINES");
10752   if (str && strcmp (str, "1") == 0) return 1;
10753   return 0;
10754 }
10755
10756 static int test_command_lines_8 (void)
10757 {
10758   if (test_command_lines_8_skip ()) {
10759     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10760     return 0;
10761   }
10762
10763   /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10764   {
10765     char device[] = "/dev/sda";
10766     int r;
10767     suppress_error = 0;
10768     r = guestfs_blockdev_setrw (g, device);
10769     if (r == -1)
10770       return -1;
10771   }
10772   {
10773     int r;
10774     suppress_error = 0;
10775     r = guestfs_umount_all (g);
10776     if (r == -1)
10777       return -1;
10778   }
10779   {
10780     int r;
10781     suppress_error = 0;
10782     r = guestfs_lvm_remove_all (g);
10783     if (r == -1)
10784       return -1;
10785   }
10786   {
10787     char device[] = "/dev/sda";
10788     char lines_0[] = ",";
10789     char *lines[] = {
10790       lines_0,
10791       NULL
10792     };
10793     int r;
10794     suppress_error = 0;
10795     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10796     if (r == -1)
10797       return -1;
10798   }
10799   {
10800     char fstype[] = "ext2";
10801     char device[] = "/dev/sda1";
10802     int r;
10803     suppress_error = 0;
10804     r = guestfs_mkfs (g, fstype, device);
10805     if (r == -1)
10806       return -1;
10807   }
10808   {
10809     char device[] = "/dev/sda1";
10810     char mountpoint[] = "/";
10811     int r;
10812     suppress_error = 0;
10813     r = guestfs_mount (g, device, mountpoint);
10814     if (r == -1)
10815       return -1;
10816   }
10817   /* TestOutputList for command_lines (8) */
10818   {
10819     char remotefilename[] = "/test-command";
10820     int r;
10821     suppress_error = 0;
10822     r = guestfs_upload (g, "test-command", remotefilename);
10823     if (r == -1)
10824       return -1;
10825   }
10826   {
10827     char path[] = "/test-command";
10828     int r;
10829     suppress_error = 0;
10830     r = guestfs_chmod (g, 493, path);
10831     if (r == -1)
10832       return -1;
10833   }
10834   {
10835     char arguments_0[] = "/test-command";
10836     char arguments_1[] = "9";
10837     char *arguments[] = {
10838       arguments_0,
10839       arguments_1,
10840       NULL
10841     };
10842     char **r;
10843     int i;
10844     suppress_error = 0;
10845     r = guestfs_command_lines (g, arguments);
10846     if (r == NULL)
10847       return -1;
10848     if (!r[0]) {
10849       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10850       print_strings (r);
10851       return -1;
10852     }
10853     {
10854       char expected[] = "";
10855       if (strcmp (r[0], expected) != 0) {
10856         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10857         return -1;
10858       }
10859     }
10860     if (!r[1]) {
10861       fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10862       print_strings (r);
10863       return -1;
10864     }
10865     {
10866       char expected[] = "";
10867       if (strcmp (r[1], expected) != 0) {
10868         fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10869         return -1;
10870       }
10871     }
10872     if (r[2] != NULL) {
10873       fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
10874       print_strings (r);
10875       return -1;
10876     }
10877     for (i = 0; r[i] != NULL; ++i)
10878       free (r[i]);
10879     free (r);
10880   }
10881   return 0;
10882 }
10883
10884 static int test_command_lines_9_skip (void)
10885 {
10886   const char *str;
10887
10888   str = getenv ("TEST_ONLY");
10889   if (str)
10890     return strstr (str, "command_lines") == NULL;
10891   str = getenv ("SKIP_TEST_COMMAND_LINES_9");
10892   if (str && strcmp (str, "1") == 0) return 1;
10893   str = getenv ("SKIP_TEST_COMMAND_LINES");
10894   if (str && strcmp (str, "1") == 0) return 1;
10895   return 0;
10896 }
10897
10898 static int test_command_lines_9 (void)
10899 {
10900   if (test_command_lines_9_skip ()) {
10901     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
10902     return 0;
10903   }
10904
10905   /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
10906   {
10907     char device[] = "/dev/sda";
10908     int r;
10909     suppress_error = 0;
10910     r = guestfs_blockdev_setrw (g, device);
10911     if (r == -1)
10912       return -1;
10913   }
10914   {
10915     int r;
10916     suppress_error = 0;
10917     r = guestfs_umount_all (g);
10918     if (r == -1)
10919       return -1;
10920   }
10921   {
10922     int r;
10923     suppress_error = 0;
10924     r = guestfs_lvm_remove_all (g);
10925     if (r == -1)
10926       return -1;
10927   }
10928   {
10929     char device[] = "/dev/sda";
10930     char lines_0[] = ",";
10931     char *lines[] = {
10932       lines_0,
10933       NULL
10934     };
10935     int r;
10936     suppress_error = 0;
10937     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10938     if (r == -1)
10939       return -1;
10940   }
10941   {
10942     char fstype[] = "ext2";
10943     char device[] = "/dev/sda1";
10944     int r;
10945     suppress_error = 0;
10946     r = guestfs_mkfs (g, fstype, device);
10947     if (r == -1)
10948       return -1;
10949   }
10950   {
10951     char device[] = "/dev/sda1";
10952     char mountpoint[] = "/";
10953     int r;
10954     suppress_error = 0;
10955     r = guestfs_mount (g, device, mountpoint);
10956     if (r == -1)
10957       return -1;
10958   }
10959   /* TestOutputList for command_lines (9) */
10960   {
10961     char remotefilename[] = "/test-command";
10962     int r;
10963     suppress_error = 0;
10964     r = guestfs_upload (g, "test-command", remotefilename);
10965     if (r == -1)
10966       return -1;
10967   }
10968   {
10969     char path[] = "/test-command";
10970     int r;
10971     suppress_error = 0;
10972     r = guestfs_chmod (g, 493, path);
10973     if (r == -1)
10974       return -1;
10975   }
10976   {
10977     char arguments_0[] = "/test-command";
10978     char arguments_1[] = "10";
10979     char *arguments[] = {
10980       arguments_0,
10981       arguments_1,
10982       NULL
10983     };
10984     char **r;
10985     int i;
10986     suppress_error = 0;
10987     r = guestfs_command_lines (g, arguments);
10988     if (r == NULL)
10989       return -1;
10990     if (!r[0]) {
10991       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10992       print_strings (r);
10993       return -1;
10994     }
10995     {
10996       char expected[] = "Result10-1";
10997       if (strcmp (r[0], expected) != 0) {
10998         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10999         return -1;
11000       }
11001     }
11002     if (!r[1]) {
11003       fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11004       print_strings (r);
11005       return -1;
11006     }
11007     {
11008       char expected[] = "Result10-2";
11009       if (strcmp (r[1], expected) != 0) {
11010         fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11011         return -1;
11012       }
11013     }
11014     if (r[2] != NULL) {
11015       fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11016       print_strings (r);
11017       return -1;
11018     }
11019     for (i = 0; r[i] != NULL; ++i)
11020       free (r[i]);
11021     free (r);
11022   }
11023   return 0;
11024 }
11025
11026 static int test_command_lines_10_skip (void)
11027 {
11028   const char *str;
11029
11030   str = getenv ("TEST_ONLY");
11031   if (str)
11032     return strstr (str, "command_lines") == NULL;
11033   str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11034   if (str && strcmp (str, "1") == 0) return 1;
11035   str = getenv ("SKIP_TEST_COMMAND_LINES");
11036   if (str && strcmp (str, "1") == 0) return 1;
11037   return 0;
11038 }
11039
11040 static int test_command_lines_10 (void)
11041 {
11042   if (test_command_lines_10_skip ()) {
11043     printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
11044     return 0;
11045   }
11046
11047   /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11048   {
11049     char device[] = "/dev/sda";
11050     int r;
11051     suppress_error = 0;
11052     r = guestfs_blockdev_setrw (g, device);
11053     if (r == -1)
11054       return -1;
11055   }
11056   {
11057     int r;
11058     suppress_error = 0;
11059     r = guestfs_umount_all (g);
11060     if (r == -1)
11061       return -1;
11062   }
11063   {
11064     int r;
11065     suppress_error = 0;
11066     r = guestfs_lvm_remove_all (g);
11067     if (r == -1)
11068       return -1;
11069   }
11070   {
11071     char device[] = "/dev/sda";
11072     char lines_0[] = ",";
11073     char *lines[] = {
11074       lines_0,
11075       NULL
11076     };
11077     int r;
11078     suppress_error = 0;
11079     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11080     if (r == -1)
11081       return -1;
11082   }
11083   {
11084     char fstype[] = "ext2";
11085     char device[] = "/dev/sda1";
11086     int r;
11087     suppress_error = 0;
11088     r = guestfs_mkfs (g, fstype, device);
11089     if (r == -1)
11090       return -1;
11091   }
11092   {
11093     char device[] = "/dev/sda1";
11094     char mountpoint[] = "/";
11095     int r;
11096     suppress_error = 0;
11097     r = guestfs_mount (g, device, mountpoint);
11098     if (r == -1)
11099       return -1;
11100   }
11101   /* TestOutputList for command_lines (10) */
11102   {
11103     char remotefilename[] = "/test-command";
11104     int r;
11105     suppress_error = 0;
11106     r = guestfs_upload (g, "test-command", remotefilename);
11107     if (r == -1)
11108       return -1;
11109   }
11110   {
11111     char path[] = "/test-command";
11112     int r;
11113     suppress_error = 0;
11114     r = guestfs_chmod (g, 493, path);
11115     if (r == -1)
11116       return -1;
11117   }
11118   {
11119     char arguments_0[] = "/test-command";
11120     char arguments_1[] = "11";
11121     char *arguments[] = {
11122       arguments_0,
11123       arguments_1,
11124       NULL
11125     };
11126     char **r;
11127     int i;
11128     suppress_error = 0;
11129     r = guestfs_command_lines (g, arguments);
11130     if (r == NULL)
11131       return -1;
11132     if (!r[0]) {
11133       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11134       print_strings (r);
11135       return -1;
11136     }
11137     {
11138       char expected[] = "Result11-1";
11139       if (strcmp (r[0], expected) != 0) {
11140         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11141         return -1;
11142       }
11143     }
11144     if (!r[1]) {
11145       fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11146       print_strings (r);
11147       return -1;
11148     }
11149     {
11150       char expected[] = "Result11-2";
11151       if (strcmp (r[1], expected) != 0) {
11152         fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11153         return -1;
11154       }
11155     }
11156     if (r[2] != NULL) {
11157       fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11158       print_strings (r);
11159       return -1;
11160     }
11161     for (i = 0; r[i] != NULL; ++i)
11162       free (r[i]);
11163     free (r);
11164   }
11165   return 0;
11166 }
11167
11168 static int test_command_0_skip (void)
11169 {
11170   const char *str;
11171
11172   str = getenv ("TEST_ONLY");
11173   if (str)
11174     return strstr (str, "command") == NULL;
11175   str = getenv ("SKIP_TEST_COMMAND_0");
11176   if (str && strcmp (str, "1") == 0) return 1;
11177   str = getenv ("SKIP_TEST_COMMAND");
11178   if (str && strcmp (str, "1") == 0) return 1;
11179   return 0;
11180 }
11181
11182 static int test_command_0 (void)
11183 {
11184   if (test_command_0_skip ()) {
11185     printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11186     return 0;
11187   }
11188
11189   /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11190   {
11191     char device[] = "/dev/sda";
11192     int r;
11193     suppress_error = 0;
11194     r = guestfs_blockdev_setrw (g, device);
11195     if (r == -1)
11196       return -1;
11197   }
11198   {
11199     int r;
11200     suppress_error = 0;
11201     r = guestfs_umount_all (g);
11202     if (r == -1)
11203       return -1;
11204   }
11205   {
11206     int r;
11207     suppress_error = 0;
11208     r = guestfs_lvm_remove_all (g);
11209     if (r == -1)
11210       return -1;
11211   }
11212   {
11213     char device[] = "/dev/sda";
11214     char lines_0[] = ",";
11215     char *lines[] = {
11216       lines_0,
11217       NULL
11218     };
11219     int r;
11220     suppress_error = 0;
11221     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11222     if (r == -1)
11223       return -1;
11224   }
11225   {
11226     char fstype[] = "ext2";
11227     char device[] = "/dev/sda1";
11228     int r;
11229     suppress_error = 0;
11230     r = guestfs_mkfs (g, fstype, device);
11231     if (r == -1)
11232       return -1;
11233   }
11234   {
11235     char device[] = "/dev/sda1";
11236     char mountpoint[] = "/";
11237     int r;
11238     suppress_error = 0;
11239     r = guestfs_mount (g, device, mountpoint);
11240     if (r == -1)
11241       return -1;
11242   }
11243   /* TestOutput for command (0) */
11244   char expected[] = "Result1";
11245   {
11246     char remotefilename[] = "/test-command";
11247     int r;
11248     suppress_error = 0;
11249     r = guestfs_upload (g, "test-command", remotefilename);
11250     if (r == -1)
11251       return -1;
11252   }
11253   {
11254     char path[] = "/test-command";
11255     int r;
11256     suppress_error = 0;
11257     r = guestfs_chmod (g, 493, path);
11258     if (r == -1)
11259       return -1;
11260   }
11261   {
11262     char arguments_0[] = "/test-command";
11263     char arguments_1[] = "1";
11264     char *arguments[] = {
11265       arguments_0,
11266       arguments_1,
11267       NULL
11268     };
11269     char *r;
11270     suppress_error = 0;
11271     r = guestfs_command (g, arguments);
11272     if (r == NULL)
11273       return -1;
11274     if (strcmp (r, expected) != 0) {
11275       fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11276       return -1;
11277     }
11278     free (r);
11279   }
11280   return 0;
11281 }
11282
11283 static int test_command_1_skip (void)
11284 {
11285   const char *str;
11286
11287   str = getenv ("TEST_ONLY");
11288   if (str)
11289     return strstr (str, "command") == NULL;
11290   str = getenv ("SKIP_TEST_COMMAND_1");
11291   if (str && strcmp (str, "1") == 0) return 1;
11292   str = getenv ("SKIP_TEST_COMMAND");
11293   if (str && strcmp (str, "1") == 0) return 1;
11294   return 0;
11295 }
11296
11297 static int test_command_1 (void)
11298 {
11299   if (test_command_1_skip ()) {
11300     printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11301     return 0;
11302   }
11303
11304   /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11305   {
11306     char device[] = "/dev/sda";
11307     int r;
11308     suppress_error = 0;
11309     r = guestfs_blockdev_setrw (g, device);
11310     if (r == -1)
11311       return -1;
11312   }
11313   {
11314     int r;
11315     suppress_error = 0;
11316     r = guestfs_umount_all (g);
11317     if (r == -1)
11318       return -1;
11319   }
11320   {
11321     int r;
11322     suppress_error = 0;
11323     r = guestfs_lvm_remove_all (g);
11324     if (r == -1)
11325       return -1;
11326   }
11327   {
11328     char device[] = "/dev/sda";
11329     char lines_0[] = ",";
11330     char *lines[] = {
11331       lines_0,
11332       NULL
11333     };
11334     int r;
11335     suppress_error = 0;
11336     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11337     if (r == -1)
11338       return -1;
11339   }
11340   {
11341     char fstype[] = "ext2";
11342     char device[] = "/dev/sda1";
11343     int r;
11344     suppress_error = 0;
11345     r = guestfs_mkfs (g, fstype, device);
11346     if (r == -1)
11347       return -1;
11348   }
11349   {
11350     char device[] = "/dev/sda1";
11351     char mountpoint[] = "/";
11352     int r;
11353     suppress_error = 0;
11354     r = guestfs_mount (g, device, mountpoint);
11355     if (r == -1)
11356       return -1;
11357   }
11358   /* TestOutput for command (1) */
11359   char expected[] = "Result2\n";
11360   {
11361     char remotefilename[] = "/test-command";
11362     int r;
11363     suppress_error = 0;
11364     r = guestfs_upload (g, "test-command", remotefilename);
11365     if (r == -1)
11366       return -1;
11367   }
11368   {
11369     char path[] = "/test-command";
11370     int r;
11371     suppress_error = 0;
11372     r = guestfs_chmod (g, 493, path);
11373     if (r == -1)
11374       return -1;
11375   }
11376   {
11377     char arguments_0[] = "/test-command";
11378     char arguments_1[] = "2";
11379     char *arguments[] = {
11380       arguments_0,
11381       arguments_1,
11382       NULL
11383     };
11384     char *r;
11385     suppress_error = 0;
11386     r = guestfs_command (g, arguments);
11387     if (r == NULL)
11388       return -1;
11389     if (strcmp (r, expected) != 0) {
11390       fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11391       return -1;
11392     }
11393     free (r);
11394   }
11395   return 0;
11396 }
11397
11398 static int test_command_2_skip (void)
11399 {
11400   const char *str;
11401
11402   str = getenv ("TEST_ONLY");
11403   if (str)
11404     return strstr (str, "command") == NULL;
11405   str = getenv ("SKIP_TEST_COMMAND_2");
11406   if (str && strcmp (str, "1") == 0) return 1;
11407   str = getenv ("SKIP_TEST_COMMAND");
11408   if (str && strcmp (str, "1") == 0) return 1;
11409   return 0;
11410 }
11411
11412 static int test_command_2 (void)
11413 {
11414   if (test_command_2_skip ()) {
11415     printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11416     return 0;
11417   }
11418
11419   /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11420   {
11421     char device[] = "/dev/sda";
11422     int r;
11423     suppress_error = 0;
11424     r = guestfs_blockdev_setrw (g, device);
11425     if (r == -1)
11426       return -1;
11427   }
11428   {
11429     int r;
11430     suppress_error = 0;
11431     r = guestfs_umount_all (g);
11432     if (r == -1)
11433       return -1;
11434   }
11435   {
11436     int r;
11437     suppress_error = 0;
11438     r = guestfs_lvm_remove_all (g);
11439     if (r == -1)
11440       return -1;
11441   }
11442   {
11443     char device[] = "/dev/sda";
11444     char lines_0[] = ",";
11445     char *lines[] = {
11446       lines_0,
11447       NULL
11448     };
11449     int r;
11450     suppress_error = 0;
11451     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11452     if (r == -1)
11453       return -1;
11454   }
11455   {
11456     char fstype[] = "ext2";
11457     char device[] = "/dev/sda1";
11458     int r;
11459     suppress_error = 0;
11460     r = guestfs_mkfs (g, fstype, device);
11461     if (r == -1)
11462       return -1;
11463   }
11464   {
11465     char device[] = "/dev/sda1";
11466     char mountpoint[] = "/";
11467     int r;
11468     suppress_error = 0;
11469     r = guestfs_mount (g, device, mountpoint);
11470     if (r == -1)
11471       return -1;
11472   }
11473   /* TestOutput for command (2) */
11474   char expected[] = "\nResult3";
11475   {
11476     char remotefilename[] = "/test-command";
11477     int r;
11478     suppress_error = 0;
11479     r = guestfs_upload (g, "test-command", remotefilename);
11480     if (r == -1)
11481       return -1;
11482   }
11483   {
11484     char path[] = "/test-command";
11485     int r;
11486     suppress_error = 0;
11487     r = guestfs_chmod (g, 493, path);
11488     if (r == -1)
11489       return -1;
11490   }
11491   {
11492     char arguments_0[] = "/test-command";
11493     char arguments_1[] = "3";
11494     char *arguments[] = {
11495       arguments_0,
11496       arguments_1,
11497       NULL
11498     };
11499     char *r;
11500     suppress_error = 0;
11501     r = guestfs_command (g, arguments);
11502     if (r == NULL)
11503       return -1;
11504     if (strcmp (r, expected) != 0) {
11505       fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11506       return -1;
11507     }
11508     free (r);
11509   }
11510   return 0;
11511 }
11512
11513 static int test_command_3_skip (void)
11514 {
11515   const char *str;
11516
11517   str = getenv ("TEST_ONLY");
11518   if (str)
11519     return strstr (str, "command") == NULL;
11520   str = getenv ("SKIP_TEST_COMMAND_3");
11521   if (str && strcmp (str, "1") == 0) return 1;
11522   str = getenv ("SKIP_TEST_COMMAND");
11523   if (str && strcmp (str, "1") == 0) return 1;
11524   return 0;
11525 }
11526
11527 static int test_command_3 (void)
11528 {
11529   if (test_command_3_skip ()) {
11530     printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11531     return 0;
11532   }
11533
11534   /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11535   {
11536     char device[] = "/dev/sda";
11537     int r;
11538     suppress_error = 0;
11539     r = guestfs_blockdev_setrw (g, device);
11540     if (r == -1)
11541       return -1;
11542   }
11543   {
11544     int r;
11545     suppress_error = 0;
11546     r = guestfs_umount_all (g);
11547     if (r == -1)
11548       return -1;
11549   }
11550   {
11551     int r;
11552     suppress_error = 0;
11553     r = guestfs_lvm_remove_all (g);
11554     if (r == -1)
11555       return -1;
11556   }
11557   {
11558     char device[] = "/dev/sda";
11559     char lines_0[] = ",";
11560     char *lines[] = {
11561       lines_0,
11562       NULL
11563     };
11564     int r;
11565     suppress_error = 0;
11566     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11567     if (r == -1)
11568       return -1;
11569   }
11570   {
11571     char fstype[] = "ext2";
11572     char device[] = "/dev/sda1";
11573     int r;
11574     suppress_error = 0;
11575     r = guestfs_mkfs (g, fstype, device);
11576     if (r == -1)
11577       return -1;
11578   }
11579   {
11580     char device[] = "/dev/sda1";
11581     char mountpoint[] = "/";
11582     int r;
11583     suppress_error = 0;
11584     r = guestfs_mount (g, device, mountpoint);
11585     if (r == -1)
11586       return -1;
11587   }
11588   /* TestOutput for command (3) */
11589   char expected[] = "\nResult4\n";
11590   {
11591     char remotefilename[] = "/test-command";
11592     int r;
11593     suppress_error = 0;
11594     r = guestfs_upload (g, "test-command", remotefilename);
11595     if (r == -1)
11596       return -1;
11597   }
11598   {
11599     char path[] = "/test-command";
11600     int r;
11601     suppress_error = 0;
11602     r = guestfs_chmod (g, 493, path);
11603     if (r == -1)
11604       return -1;
11605   }
11606   {
11607     char arguments_0[] = "/test-command";
11608     char arguments_1[] = "4";
11609     char *arguments[] = {
11610       arguments_0,
11611       arguments_1,
11612       NULL
11613     };
11614     char *r;
11615     suppress_error = 0;
11616     r = guestfs_command (g, arguments);
11617     if (r == NULL)
11618       return -1;
11619     if (strcmp (r, expected) != 0) {
11620       fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11621       return -1;
11622     }
11623     free (r);
11624   }
11625   return 0;
11626 }
11627
11628 static int test_command_4_skip (void)
11629 {
11630   const char *str;
11631
11632   str = getenv ("TEST_ONLY");
11633   if (str)
11634     return strstr (str, "command") == NULL;
11635   str = getenv ("SKIP_TEST_COMMAND_4");
11636   if (str && strcmp (str, "1") == 0) return 1;
11637   str = getenv ("SKIP_TEST_COMMAND");
11638   if (str && strcmp (str, "1") == 0) return 1;
11639   return 0;
11640 }
11641
11642 static int test_command_4 (void)
11643 {
11644   if (test_command_4_skip ()) {
11645     printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11646     return 0;
11647   }
11648
11649   /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11650   {
11651     char device[] = "/dev/sda";
11652     int r;
11653     suppress_error = 0;
11654     r = guestfs_blockdev_setrw (g, device);
11655     if (r == -1)
11656       return -1;
11657   }
11658   {
11659     int r;
11660     suppress_error = 0;
11661     r = guestfs_umount_all (g);
11662     if (r == -1)
11663       return -1;
11664   }
11665   {
11666     int r;
11667     suppress_error = 0;
11668     r = guestfs_lvm_remove_all (g);
11669     if (r == -1)
11670       return -1;
11671   }
11672   {
11673     char device[] = "/dev/sda";
11674     char lines_0[] = ",";
11675     char *lines[] = {
11676       lines_0,
11677       NULL
11678     };
11679     int r;
11680     suppress_error = 0;
11681     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11682     if (r == -1)
11683       return -1;
11684   }
11685   {
11686     char fstype[] = "ext2";
11687     char device[] = "/dev/sda1";
11688     int r;
11689     suppress_error = 0;
11690     r = guestfs_mkfs (g, fstype, device);
11691     if (r == -1)
11692       return -1;
11693   }
11694   {
11695     char device[] = "/dev/sda1";
11696     char mountpoint[] = "/";
11697     int r;
11698     suppress_error = 0;
11699     r = guestfs_mount (g, device, mountpoint);
11700     if (r == -1)
11701       return -1;
11702   }
11703   /* TestOutput for command (4) */
11704   char expected[] = "\nResult5\n\n";
11705   {
11706     char remotefilename[] = "/test-command";
11707     int r;
11708     suppress_error = 0;
11709     r = guestfs_upload (g, "test-command", remotefilename);
11710     if (r == -1)
11711       return -1;
11712   }
11713   {
11714     char path[] = "/test-command";
11715     int r;
11716     suppress_error = 0;
11717     r = guestfs_chmod (g, 493, path);
11718     if (r == -1)
11719       return -1;
11720   }
11721   {
11722     char arguments_0[] = "/test-command";
11723     char arguments_1[] = "5";
11724     char *arguments[] = {
11725       arguments_0,
11726       arguments_1,
11727       NULL
11728     };
11729     char *r;
11730     suppress_error = 0;
11731     r = guestfs_command (g, arguments);
11732     if (r == NULL)
11733       return -1;
11734     if (strcmp (r, expected) != 0) {
11735       fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11736       return -1;
11737     }
11738     free (r);
11739   }
11740   return 0;
11741 }
11742
11743 static int test_command_5_skip (void)
11744 {
11745   const char *str;
11746
11747   str = getenv ("TEST_ONLY");
11748   if (str)
11749     return strstr (str, "command") == NULL;
11750   str = getenv ("SKIP_TEST_COMMAND_5");
11751   if (str && strcmp (str, "1") == 0) return 1;
11752   str = getenv ("SKIP_TEST_COMMAND");
11753   if (str && strcmp (str, "1") == 0) return 1;
11754   return 0;
11755 }
11756
11757 static int test_command_5 (void)
11758 {
11759   if (test_command_5_skip ()) {
11760     printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11761     return 0;
11762   }
11763
11764   /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11765   {
11766     char device[] = "/dev/sda";
11767     int r;
11768     suppress_error = 0;
11769     r = guestfs_blockdev_setrw (g, device);
11770     if (r == -1)
11771       return -1;
11772   }
11773   {
11774     int r;
11775     suppress_error = 0;
11776     r = guestfs_umount_all (g);
11777     if (r == -1)
11778       return -1;
11779   }
11780   {
11781     int r;
11782     suppress_error = 0;
11783     r = guestfs_lvm_remove_all (g);
11784     if (r == -1)
11785       return -1;
11786   }
11787   {
11788     char device[] = "/dev/sda";
11789     char lines_0[] = ",";
11790     char *lines[] = {
11791       lines_0,
11792       NULL
11793     };
11794     int r;
11795     suppress_error = 0;
11796     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11797     if (r == -1)
11798       return -1;
11799   }
11800   {
11801     char fstype[] = "ext2";
11802     char device[] = "/dev/sda1";
11803     int r;
11804     suppress_error = 0;
11805     r = guestfs_mkfs (g, fstype, device);
11806     if (r == -1)
11807       return -1;
11808   }
11809   {
11810     char device[] = "/dev/sda1";
11811     char mountpoint[] = "/";
11812     int r;
11813     suppress_error = 0;
11814     r = guestfs_mount (g, device, mountpoint);
11815     if (r == -1)
11816       return -1;
11817   }
11818   /* TestOutput for command (5) */
11819   char expected[] = "\n\nResult6\n\n";
11820   {
11821     char remotefilename[] = "/test-command";
11822     int r;
11823     suppress_error = 0;
11824     r = guestfs_upload (g, "test-command", remotefilename);
11825     if (r == -1)
11826       return -1;
11827   }
11828   {
11829     char path[] = "/test-command";
11830     int r;
11831     suppress_error = 0;
11832     r = guestfs_chmod (g, 493, path);
11833     if (r == -1)
11834       return -1;
11835   }
11836   {
11837     char arguments_0[] = "/test-command";
11838     char arguments_1[] = "6";
11839     char *arguments[] = {
11840       arguments_0,
11841       arguments_1,
11842       NULL
11843     };
11844     char *r;
11845     suppress_error = 0;
11846     r = guestfs_command (g, arguments);
11847     if (r == NULL)
11848       return -1;
11849     if (strcmp (r, expected) != 0) {
11850       fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
11851       return -1;
11852     }
11853     free (r);
11854   }
11855   return 0;
11856 }
11857
11858 static int test_command_6_skip (void)
11859 {
11860   const char *str;
11861
11862   str = getenv ("TEST_ONLY");
11863   if (str)
11864     return strstr (str, "command") == NULL;
11865   str = getenv ("SKIP_TEST_COMMAND_6");
11866   if (str && strcmp (str, "1") == 0) return 1;
11867   str = getenv ("SKIP_TEST_COMMAND");
11868   if (str && strcmp (str, "1") == 0) return 1;
11869   return 0;
11870 }
11871
11872 static int test_command_6 (void)
11873 {
11874   if (test_command_6_skip ()) {
11875     printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
11876     return 0;
11877   }
11878
11879   /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
11880   {
11881     char device[] = "/dev/sda";
11882     int r;
11883     suppress_error = 0;
11884     r = guestfs_blockdev_setrw (g, device);
11885     if (r == -1)
11886       return -1;
11887   }
11888   {
11889     int r;
11890     suppress_error = 0;
11891     r = guestfs_umount_all (g);
11892     if (r == -1)
11893       return -1;
11894   }
11895   {
11896     int r;
11897     suppress_error = 0;
11898     r = guestfs_lvm_remove_all (g);
11899     if (r == -1)
11900       return -1;
11901   }
11902   {
11903     char device[] = "/dev/sda";
11904     char lines_0[] = ",";
11905     char *lines[] = {
11906       lines_0,
11907       NULL
11908     };
11909     int r;
11910     suppress_error = 0;
11911     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11912     if (r == -1)
11913       return -1;
11914   }
11915   {
11916     char fstype[] = "ext2";
11917     char device[] = "/dev/sda1";
11918     int r;
11919     suppress_error = 0;
11920     r = guestfs_mkfs (g, fstype, device);
11921     if (r == -1)
11922       return -1;
11923   }
11924   {
11925     char device[] = "/dev/sda1";
11926     char mountpoint[] = "/";
11927     int r;
11928     suppress_error = 0;
11929     r = guestfs_mount (g, device, mountpoint);
11930     if (r == -1)
11931       return -1;
11932   }
11933   /* TestOutput for command (6) */
11934   char expected[] = "";
11935   {
11936     char remotefilename[] = "/test-command";
11937     int r;
11938     suppress_error = 0;
11939     r = guestfs_upload (g, "test-command", remotefilename);
11940     if (r == -1)
11941       return -1;
11942   }
11943   {
11944     char path[] = "/test-command";
11945     int r;
11946     suppress_error = 0;
11947     r = guestfs_chmod (g, 493, path);
11948     if (r == -1)
11949       return -1;
11950   }
11951   {
11952     char arguments_0[] = "/test-command";
11953     char arguments_1[] = "7";
11954     char *arguments[] = {
11955       arguments_0,
11956       arguments_1,
11957       NULL
11958     };
11959     char *r;
11960     suppress_error = 0;
11961     r = guestfs_command (g, arguments);
11962     if (r == NULL)
11963       return -1;
11964     if (strcmp (r, expected) != 0) {
11965       fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
11966       return -1;
11967     }
11968     free (r);
11969   }
11970   return 0;
11971 }
11972
11973 static int test_command_7_skip (void)
11974 {
11975   const char *str;
11976
11977   str = getenv ("TEST_ONLY");
11978   if (str)
11979     return strstr (str, "command") == NULL;
11980   str = getenv ("SKIP_TEST_COMMAND_7");
11981   if (str && strcmp (str, "1") == 0) return 1;
11982   str = getenv ("SKIP_TEST_COMMAND");
11983   if (str && strcmp (str, "1") == 0) return 1;
11984   return 0;
11985 }
11986
11987 static int test_command_7 (void)
11988 {
11989   if (test_command_7_skip ()) {
11990     printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
11991     return 0;
11992   }
11993
11994   /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
11995   {
11996     char device[] = "/dev/sda";
11997     int r;
11998     suppress_error = 0;
11999     r = guestfs_blockdev_setrw (g, device);
12000     if (r == -1)
12001       return -1;
12002   }
12003   {
12004     int r;
12005     suppress_error = 0;
12006     r = guestfs_umount_all (g);
12007     if (r == -1)
12008       return -1;
12009   }
12010   {
12011     int r;
12012     suppress_error = 0;
12013     r = guestfs_lvm_remove_all (g);
12014     if (r == -1)
12015       return -1;
12016   }
12017   {
12018     char device[] = "/dev/sda";
12019     char lines_0[] = ",";
12020     char *lines[] = {
12021       lines_0,
12022       NULL
12023     };
12024     int r;
12025     suppress_error = 0;
12026     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12027     if (r == -1)
12028       return -1;
12029   }
12030   {
12031     char fstype[] = "ext2";
12032     char device[] = "/dev/sda1";
12033     int r;
12034     suppress_error = 0;
12035     r = guestfs_mkfs (g, fstype, device);
12036     if (r == -1)
12037       return -1;
12038   }
12039   {
12040     char device[] = "/dev/sda1";
12041     char mountpoint[] = "/";
12042     int r;
12043     suppress_error = 0;
12044     r = guestfs_mount (g, device, mountpoint);
12045     if (r == -1)
12046       return -1;
12047   }
12048   /* TestOutput for command (7) */
12049   char expected[] = "\n";
12050   {
12051     char remotefilename[] = "/test-command";
12052     int r;
12053     suppress_error = 0;
12054     r = guestfs_upload (g, "test-command", remotefilename);
12055     if (r == -1)
12056       return -1;
12057   }
12058   {
12059     char path[] = "/test-command";
12060     int r;
12061     suppress_error = 0;
12062     r = guestfs_chmod (g, 493, path);
12063     if (r == -1)
12064       return -1;
12065   }
12066   {
12067     char arguments_0[] = "/test-command";
12068     char arguments_1[] = "8";
12069     char *arguments[] = {
12070       arguments_0,
12071       arguments_1,
12072       NULL
12073     };
12074     char *r;
12075     suppress_error = 0;
12076     r = guestfs_command (g, arguments);
12077     if (r == NULL)
12078       return -1;
12079     if (strcmp (r, expected) != 0) {
12080       fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12081       return -1;
12082     }
12083     free (r);
12084   }
12085   return 0;
12086 }
12087
12088 static int test_command_8_skip (void)
12089 {
12090   const char *str;
12091
12092   str = getenv ("TEST_ONLY");
12093   if (str)
12094     return strstr (str, "command") == NULL;
12095   str = getenv ("SKIP_TEST_COMMAND_8");
12096   if (str && strcmp (str, "1") == 0) return 1;
12097   str = getenv ("SKIP_TEST_COMMAND");
12098   if (str && strcmp (str, "1") == 0) return 1;
12099   return 0;
12100 }
12101
12102 static int test_command_8 (void)
12103 {
12104   if (test_command_8_skip ()) {
12105     printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
12106     return 0;
12107   }
12108
12109   /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12110   {
12111     char device[] = "/dev/sda";
12112     int r;
12113     suppress_error = 0;
12114     r = guestfs_blockdev_setrw (g, device);
12115     if (r == -1)
12116       return -1;
12117   }
12118   {
12119     int r;
12120     suppress_error = 0;
12121     r = guestfs_umount_all (g);
12122     if (r == -1)
12123       return -1;
12124   }
12125   {
12126     int r;
12127     suppress_error = 0;
12128     r = guestfs_lvm_remove_all (g);
12129     if (r == -1)
12130       return -1;
12131   }
12132   {
12133     char device[] = "/dev/sda";
12134     char lines_0[] = ",";
12135     char *lines[] = {
12136       lines_0,
12137       NULL
12138     };
12139     int r;
12140     suppress_error = 0;
12141     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12142     if (r == -1)
12143       return -1;
12144   }
12145   {
12146     char fstype[] = "ext2";
12147     char device[] = "/dev/sda1";
12148     int r;
12149     suppress_error = 0;
12150     r = guestfs_mkfs (g, fstype, device);
12151     if (r == -1)
12152       return -1;
12153   }
12154   {
12155     char device[] = "/dev/sda1";
12156     char mountpoint[] = "/";
12157     int r;
12158     suppress_error = 0;
12159     r = guestfs_mount (g, device, mountpoint);
12160     if (r == -1)
12161       return -1;
12162   }
12163   /* TestOutput for command (8) */
12164   char expected[] = "\n\n";
12165   {
12166     char remotefilename[] = "/test-command";
12167     int r;
12168     suppress_error = 0;
12169     r = guestfs_upload (g, "test-command", remotefilename);
12170     if (r == -1)
12171       return -1;
12172   }
12173   {
12174     char path[] = "/test-command";
12175     int r;
12176     suppress_error = 0;
12177     r = guestfs_chmod (g, 493, path);
12178     if (r == -1)
12179       return -1;
12180   }
12181   {
12182     char arguments_0[] = "/test-command";
12183     char arguments_1[] = "9";
12184     char *arguments[] = {
12185       arguments_0,
12186       arguments_1,
12187       NULL
12188     };
12189     char *r;
12190     suppress_error = 0;
12191     r = guestfs_command (g, arguments);
12192     if (r == NULL)
12193       return -1;
12194     if (strcmp (r, expected) != 0) {
12195       fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12196       return -1;
12197     }
12198     free (r);
12199   }
12200   return 0;
12201 }
12202
12203 static int test_command_9_skip (void)
12204 {
12205   const char *str;
12206
12207   str = getenv ("TEST_ONLY");
12208   if (str)
12209     return strstr (str, "command") == NULL;
12210   str = getenv ("SKIP_TEST_COMMAND_9");
12211   if (str && strcmp (str, "1") == 0) return 1;
12212   str = getenv ("SKIP_TEST_COMMAND");
12213   if (str && strcmp (str, "1") == 0) return 1;
12214   return 0;
12215 }
12216
12217 static int test_command_9 (void)
12218 {
12219   if (test_command_9_skip ()) {
12220     printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12221     return 0;
12222   }
12223
12224   /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12225   {
12226     char device[] = "/dev/sda";
12227     int r;
12228     suppress_error = 0;
12229     r = guestfs_blockdev_setrw (g, device);
12230     if (r == -1)
12231       return -1;
12232   }
12233   {
12234     int r;
12235     suppress_error = 0;
12236     r = guestfs_umount_all (g);
12237     if (r == -1)
12238       return -1;
12239   }
12240   {
12241     int r;
12242     suppress_error = 0;
12243     r = guestfs_lvm_remove_all (g);
12244     if (r == -1)
12245       return -1;
12246   }
12247   {
12248     char device[] = "/dev/sda";
12249     char lines_0[] = ",";
12250     char *lines[] = {
12251       lines_0,
12252       NULL
12253     };
12254     int r;
12255     suppress_error = 0;
12256     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12257     if (r == -1)
12258       return -1;
12259   }
12260   {
12261     char fstype[] = "ext2";
12262     char device[] = "/dev/sda1";
12263     int r;
12264     suppress_error = 0;
12265     r = guestfs_mkfs (g, fstype, device);
12266     if (r == -1)
12267       return -1;
12268   }
12269   {
12270     char device[] = "/dev/sda1";
12271     char mountpoint[] = "/";
12272     int r;
12273     suppress_error = 0;
12274     r = guestfs_mount (g, device, mountpoint);
12275     if (r == -1)
12276       return -1;
12277   }
12278   /* TestOutput for command (9) */
12279   char expected[] = "Result10-1\nResult10-2\n";
12280   {
12281     char remotefilename[] = "/test-command";
12282     int r;
12283     suppress_error = 0;
12284     r = guestfs_upload (g, "test-command", remotefilename);
12285     if (r == -1)
12286       return -1;
12287   }
12288   {
12289     char path[] = "/test-command";
12290     int r;
12291     suppress_error = 0;
12292     r = guestfs_chmod (g, 493, path);
12293     if (r == -1)
12294       return -1;
12295   }
12296   {
12297     char arguments_0[] = "/test-command";
12298     char arguments_1[] = "10";
12299     char *arguments[] = {
12300       arguments_0,
12301       arguments_1,
12302       NULL
12303     };
12304     char *r;
12305     suppress_error = 0;
12306     r = guestfs_command (g, arguments);
12307     if (r == NULL)
12308       return -1;
12309     if (strcmp (r, expected) != 0) {
12310       fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12311       return -1;
12312     }
12313     free (r);
12314   }
12315   return 0;
12316 }
12317
12318 static int test_command_10_skip (void)
12319 {
12320   const char *str;
12321
12322   str = getenv ("TEST_ONLY");
12323   if (str)
12324     return strstr (str, "command") == NULL;
12325   str = getenv ("SKIP_TEST_COMMAND_10");
12326   if (str && strcmp (str, "1") == 0) return 1;
12327   str = getenv ("SKIP_TEST_COMMAND");
12328   if (str && strcmp (str, "1") == 0) return 1;
12329   return 0;
12330 }
12331
12332 static int test_command_10 (void)
12333 {
12334   if (test_command_10_skip ()) {
12335     printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12336     return 0;
12337   }
12338
12339   /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12340   {
12341     char device[] = "/dev/sda";
12342     int r;
12343     suppress_error = 0;
12344     r = guestfs_blockdev_setrw (g, device);
12345     if (r == -1)
12346       return -1;
12347   }
12348   {
12349     int r;
12350     suppress_error = 0;
12351     r = guestfs_umount_all (g);
12352     if (r == -1)
12353       return -1;
12354   }
12355   {
12356     int r;
12357     suppress_error = 0;
12358     r = guestfs_lvm_remove_all (g);
12359     if (r == -1)
12360       return -1;
12361   }
12362   {
12363     char device[] = "/dev/sda";
12364     char lines_0[] = ",";
12365     char *lines[] = {
12366       lines_0,
12367       NULL
12368     };
12369     int r;
12370     suppress_error = 0;
12371     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12372     if (r == -1)
12373       return -1;
12374   }
12375   {
12376     char fstype[] = "ext2";
12377     char device[] = "/dev/sda1";
12378     int r;
12379     suppress_error = 0;
12380     r = guestfs_mkfs (g, fstype, device);
12381     if (r == -1)
12382       return -1;
12383   }
12384   {
12385     char device[] = "/dev/sda1";
12386     char mountpoint[] = "/";
12387     int r;
12388     suppress_error = 0;
12389     r = guestfs_mount (g, device, mountpoint);
12390     if (r == -1)
12391       return -1;
12392   }
12393   /* TestOutput for command (10) */
12394   char expected[] = "Result11-1\nResult11-2";
12395   {
12396     char remotefilename[] = "/test-command";
12397     int r;
12398     suppress_error = 0;
12399     r = guestfs_upload (g, "test-command", remotefilename);
12400     if (r == -1)
12401       return -1;
12402   }
12403   {
12404     char path[] = "/test-command";
12405     int r;
12406     suppress_error = 0;
12407     r = guestfs_chmod (g, 493, path);
12408     if (r == -1)
12409       return -1;
12410   }
12411   {
12412     char arguments_0[] = "/test-command";
12413     char arguments_1[] = "11";
12414     char *arguments[] = {
12415       arguments_0,
12416       arguments_1,
12417       NULL
12418     };
12419     char *r;
12420     suppress_error = 0;
12421     r = guestfs_command (g, arguments);
12422     if (r == NULL)
12423       return -1;
12424     if (strcmp (r, expected) != 0) {
12425       fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12426       return -1;
12427     }
12428     free (r);
12429   }
12430   return 0;
12431 }
12432
12433 static int test_command_11_skip (void)
12434 {
12435   const char *str;
12436
12437   str = getenv ("TEST_ONLY");
12438   if (str)
12439     return strstr (str, "command") == NULL;
12440   str = getenv ("SKIP_TEST_COMMAND_11");
12441   if (str && strcmp (str, "1") == 0) return 1;
12442   str = getenv ("SKIP_TEST_COMMAND");
12443   if (str && strcmp (str, "1") == 0) return 1;
12444   return 0;
12445 }
12446
12447 static int test_command_11 (void)
12448 {
12449   if (test_command_11_skip ()) {
12450     printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12451     return 0;
12452   }
12453
12454   /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12455   {
12456     char device[] = "/dev/sda";
12457     int r;
12458     suppress_error = 0;
12459     r = guestfs_blockdev_setrw (g, device);
12460     if (r == -1)
12461       return -1;
12462   }
12463   {
12464     int r;
12465     suppress_error = 0;
12466     r = guestfs_umount_all (g);
12467     if (r == -1)
12468       return -1;
12469   }
12470   {
12471     int r;
12472     suppress_error = 0;
12473     r = guestfs_lvm_remove_all (g);
12474     if (r == -1)
12475       return -1;
12476   }
12477   {
12478     char device[] = "/dev/sda";
12479     char lines_0[] = ",";
12480     char *lines[] = {
12481       lines_0,
12482       NULL
12483     };
12484     int r;
12485     suppress_error = 0;
12486     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12487     if (r == -1)
12488       return -1;
12489   }
12490   {
12491     char fstype[] = "ext2";
12492     char device[] = "/dev/sda1";
12493     int r;
12494     suppress_error = 0;
12495     r = guestfs_mkfs (g, fstype, device);
12496     if (r == -1)
12497       return -1;
12498   }
12499   {
12500     char device[] = "/dev/sda1";
12501     char mountpoint[] = "/";
12502     int r;
12503     suppress_error = 0;
12504     r = guestfs_mount (g, device, mountpoint);
12505     if (r == -1)
12506       return -1;
12507   }
12508   /* TestLastFail for command (11) */
12509   {
12510     char remotefilename[] = "/test-command";
12511     int r;
12512     suppress_error = 0;
12513     r = guestfs_upload (g, "test-command", remotefilename);
12514     if (r == -1)
12515       return -1;
12516   }
12517   {
12518     char path[] = "/test-command";
12519     int r;
12520     suppress_error = 0;
12521     r = guestfs_chmod (g, 493, path);
12522     if (r == -1)
12523       return -1;
12524   }
12525   {
12526     char arguments_0[] = "/test-command";
12527     char *arguments[] = {
12528       arguments_0,
12529       NULL
12530     };
12531     char *r;
12532     suppress_error = 1;
12533     r = guestfs_command (g, arguments);
12534     if (r != NULL)
12535       return -1;
12536     free (r);
12537   }
12538   return 0;
12539 }
12540
12541 static int test_file_0_skip (void)
12542 {
12543   const char *str;
12544
12545   str = getenv ("TEST_ONLY");
12546   if (str)
12547     return strstr (str, "file") == NULL;
12548   str = getenv ("SKIP_TEST_FILE_0");
12549   if (str && strcmp (str, "1") == 0) return 1;
12550   str = getenv ("SKIP_TEST_FILE");
12551   if (str && strcmp (str, "1") == 0) return 1;
12552   return 0;
12553 }
12554
12555 static int test_file_0 (void)
12556 {
12557   if (test_file_0_skip ()) {
12558     printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12559     return 0;
12560   }
12561
12562   /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12563   {
12564     char device[] = "/dev/sda";
12565     int r;
12566     suppress_error = 0;
12567     r = guestfs_blockdev_setrw (g, device);
12568     if (r == -1)
12569       return -1;
12570   }
12571   {
12572     int r;
12573     suppress_error = 0;
12574     r = guestfs_umount_all (g);
12575     if (r == -1)
12576       return -1;
12577   }
12578   {
12579     int r;
12580     suppress_error = 0;
12581     r = guestfs_lvm_remove_all (g);
12582     if (r == -1)
12583       return -1;
12584   }
12585   {
12586     char device[] = "/dev/sda";
12587     char lines_0[] = ",";
12588     char *lines[] = {
12589       lines_0,
12590       NULL
12591     };
12592     int r;
12593     suppress_error = 0;
12594     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12595     if (r == -1)
12596       return -1;
12597   }
12598   {
12599     char fstype[] = "ext2";
12600     char device[] = "/dev/sda1";
12601     int r;
12602     suppress_error = 0;
12603     r = guestfs_mkfs (g, fstype, device);
12604     if (r == -1)
12605       return -1;
12606   }
12607   {
12608     char device[] = "/dev/sda1";
12609     char mountpoint[] = "/";
12610     int r;
12611     suppress_error = 0;
12612     r = guestfs_mount (g, device, mountpoint);
12613     if (r == -1)
12614       return -1;
12615   }
12616   /* TestOutput for file (0) */
12617   char expected[] = "empty";
12618   {
12619     char path[] = "/new";
12620     int r;
12621     suppress_error = 0;
12622     r = guestfs_touch (g, path);
12623     if (r == -1)
12624       return -1;
12625   }
12626   {
12627     char path[] = "/new";
12628     char *r;
12629     suppress_error = 0;
12630     r = guestfs_file (g, path);
12631     if (r == NULL)
12632       return -1;
12633     if (strcmp (r, expected) != 0) {
12634       fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12635       return -1;
12636     }
12637     free (r);
12638   }
12639   return 0;
12640 }
12641
12642 static int test_file_1_skip (void)
12643 {
12644   const char *str;
12645
12646   str = getenv ("TEST_ONLY");
12647   if (str)
12648     return strstr (str, "file") == NULL;
12649   str = getenv ("SKIP_TEST_FILE_1");
12650   if (str && strcmp (str, "1") == 0) return 1;
12651   str = getenv ("SKIP_TEST_FILE");
12652   if (str && strcmp (str, "1") == 0) return 1;
12653   return 0;
12654 }
12655
12656 static int test_file_1 (void)
12657 {
12658   if (test_file_1_skip ()) {
12659     printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12660     return 0;
12661   }
12662
12663   /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12664   {
12665     char device[] = "/dev/sda";
12666     int r;
12667     suppress_error = 0;
12668     r = guestfs_blockdev_setrw (g, device);
12669     if (r == -1)
12670       return -1;
12671   }
12672   {
12673     int r;
12674     suppress_error = 0;
12675     r = guestfs_umount_all (g);
12676     if (r == -1)
12677       return -1;
12678   }
12679   {
12680     int r;
12681     suppress_error = 0;
12682     r = guestfs_lvm_remove_all (g);
12683     if (r == -1)
12684       return -1;
12685   }
12686   {
12687     char device[] = "/dev/sda";
12688     char lines_0[] = ",";
12689     char *lines[] = {
12690       lines_0,
12691       NULL
12692     };
12693     int r;
12694     suppress_error = 0;
12695     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12696     if (r == -1)
12697       return -1;
12698   }
12699   {
12700     char fstype[] = "ext2";
12701     char device[] = "/dev/sda1";
12702     int r;
12703     suppress_error = 0;
12704     r = guestfs_mkfs (g, fstype, device);
12705     if (r == -1)
12706       return -1;
12707   }
12708   {
12709     char device[] = "/dev/sda1";
12710     char mountpoint[] = "/";
12711     int r;
12712     suppress_error = 0;
12713     r = guestfs_mount (g, device, mountpoint);
12714     if (r == -1)
12715       return -1;
12716   }
12717   /* TestOutput for file (1) */
12718   char expected[] = "ASCII text";
12719   {
12720     char path[] = "/new";
12721     char content[] = "some content\n";
12722     int r;
12723     suppress_error = 0;
12724     r = guestfs_write_file (g, path, content, 0);
12725     if (r == -1)
12726       return -1;
12727   }
12728   {
12729     char path[] = "/new";
12730     char *r;
12731     suppress_error = 0;
12732     r = guestfs_file (g, path);
12733     if (r == NULL)
12734       return -1;
12735     if (strcmp (r, expected) != 0) {
12736       fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12737       return -1;
12738     }
12739     free (r);
12740   }
12741   return 0;
12742 }
12743
12744 static int test_file_2_skip (void)
12745 {
12746   const char *str;
12747
12748   str = getenv ("TEST_ONLY");
12749   if (str)
12750     return strstr (str, "file") == NULL;
12751   str = getenv ("SKIP_TEST_FILE_2");
12752   if (str && strcmp (str, "1") == 0) return 1;
12753   str = getenv ("SKIP_TEST_FILE");
12754   if (str && strcmp (str, "1") == 0) return 1;
12755   return 0;
12756 }
12757
12758 static int test_file_2 (void)
12759 {
12760   if (test_file_2_skip ()) {
12761     printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12762     return 0;
12763   }
12764
12765   /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12766   {
12767     char device[] = "/dev/sda";
12768     int r;
12769     suppress_error = 0;
12770     r = guestfs_blockdev_setrw (g, device);
12771     if (r == -1)
12772       return -1;
12773   }
12774   {
12775     int r;
12776     suppress_error = 0;
12777     r = guestfs_umount_all (g);
12778     if (r == -1)
12779       return -1;
12780   }
12781   {
12782     int r;
12783     suppress_error = 0;
12784     r = guestfs_lvm_remove_all (g);
12785     if (r == -1)
12786       return -1;
12787   }
12788   {
12789     char device[] = "/dev/sda";
12790     char lines_0[] = ",";
12791     char *lines[] = {
12792       lines_0,
12793       NULL
12794     };
12795     int r;
12796     suppress_error = 0;
12797     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12798     if (r == -1)
12799       return -1;
12800   }
12801   {
12802     char fstype[] = "ext2";
12803     char device[] = "/dev/sda1";
12804     int r;
12805     suppress_error = 0;
12806     r = guestfs_mkfs (g, fstype, device);
12807     if (r == -1)
12808       return -1;
12809   }
12810   {
12811     char device[] = "/dev/sda1";
12812     char mountpoint[] = "/";
12813     int r;
12814     suppress_error = 0;
12815     r = guestfs_mount (g, device, mountpoint);
12816     if (r == -1)
12817       return -1;
12818   }
12819   /* TestLastFail for file (2) */
12820   {
12821     char path[] = "/nofile";
12822     char *r;
12823     suppress_error = 1;
12824     r = guestfs_file (g, path);
12825     if (r != NULL)
12826       return -1;
12827     free (r);
12828   }
12829   return 0;
12830 }
12831
12832 static int test_umount_all_0_skip (void)
12833 {
12834   const char *str;
12835
12836   str = getenv ("TEST_ONLY");
12837   if (str)
12838     return strstr (str, "umount_all") == NULL;
12839   str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
12840   if (str && strcmp (str, "1") == 0) return 1;
12841   str = getenv ("SKIP_TEST_UMOUNT_ALL");
12842   if (str && strcmp (str, "1") == 0) return 1;
12843   return 0;
12844 }
12845
12846 static int test_umount_all_0 (void)
12847 {
12848   if (test_umount_all_0_skip ()) {
12849     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
12850     return 0;
12851   }
12852
12853   /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
12854   {
12855     char device[] = "/dev/sda";
12856     int r;
12857     suppress_error = 0;
12858     r = guestfs_blockdev_setrw (g, device);
12859     if (r == -1)
12860       return -1;
12861   }
12862   {
12863     int r;
12864     suppress_error = 0;
12865     r = guestfs_umount_all (g);
12866     if (r == -1)
12867       return -1;
12868   }
12869   {
12870     int r;
12871     suppress_error = 0;
12872     r = guestfs_lvm_remove_all (g);
12873     if (r == -1)
12874       return -1;
12875   }
12876   {
12877     char device[] = "/dev/sda";
12878     char lines_0[] = ",";
12879     char *lines[] = {
12880       lines_0,
12881       NULL
12882     };
12883     int r;
12884     suppress_error = 0;
12885     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12886     if (r == -1)
12887       return -1;
12888   }
12889   {
12890     char fstype[] = "ext2";
12891     char device[] = "/dev/sda1";
12892     int r;
12893     suppress_error = 0;
12894     r = guestfs_mkfs (g, fstype, device);
12895     if (r == -1)
12896       return -1;
12897   }
12898   {
12899     char device[] = "/dev/sda1";
12900     char mountpoint[] = "/";
12901     int r;
12902     suppress_error = 0;
12903     r = guestfs_mount (g, device, mountpoint);
12904     if (r == -1)
12905       return -1;
12906   }
12907   /* TestOutputList for umount_all (0) */
12908   {
12909     int r;
12910     suppress_error = 0;
12911     r = guestfs_umount_all (g);
12912     if (r == -1)
12913       return -1;
12914   }
12915   {
12916     char **r;
12917     int i;
12918     suppress_error = 0;
12919     r = guestfs_mounts (g);
12920     if (r == NULL)
12921       return -1;
12922     if (r[0] != NULL) {
12923       fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
12924       print_strings (r);
12925       return -1;
12926     }
12927     for (i = 0; r[i] != NULL; ++i)
12928       free (r[i]);
12929     free (r);
12930   }
12931   return 0;
12932 }
12933
12934 static int test_umount_all_1_skip (void)
12935 {
12936   const char *str;
12937
12938   str = getenv ("TEST_ONLY");
12939   if (str)
12940     return strstr (str, "umount_all") == NULL;
12941   str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
12942   if (str && strcmp (str, "1") == 0) return 1;
12943   str = getenv ("SKIP_TEST_UMOUNT_ALL");
12944   if (str && strcmp (str, "1") == 0) return 1;
12945   return 0;
12946 }
12947
12948 static int test_umount_all_1 (void)
12949 {
12950   if (test_umount_all_1_skip ()) {
12951     printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
12952     return 0;
12953   }
12954
12955   /* InitNone|InitEmpty for test_umount_all_1 */
12956   {
12957     char device[] = "/dev/sda";
12958     int r;
12959     suppress_error = 0;
12960     r = guestfs_blockdev_setrw (g, device);
12961     if (r == -1)
12962       return -1;
12963   }
12964   {
12965     int r;
12966     suppress_error = 0;
12967     r = guestfs_umount_all (g);
12968     if (r == -1)
12969       return -1;
12970   }
12971   {
12972     int r;
12973     suppress_error = 0;
12974     r = guestfs_lvm_remove_all (g);
12975     if (r == -1)
12976       return -1;
12977   }
12978   /* TestOutputList for umount_all (1) */
12979   {
12980     char device[] = "/dev/sda";
12981     char lines_0[] = ",10";
12982     char lines_1[] = ",20";
12983     char lines_2[] = ",";
12984     char *lines[] = {
12985       lines_0,
12986       lines_1,
12987       lines_2,
12988       NULL
12989     };
12990     int r;
12991     suppress_error = 0;
12992     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12993     if (r == -1)
12994       return -1;
12995   }
12996   {
12997     char fstype[] = "ext2";
12998     char device[] = "/dev/sda1";
12999     int r;
13000     suppress_error = 0;
13001     r = guestfs_mkfs (g, fstype, device);
13002     if (r == -1)
13003       return -1;
13004   }
13005   {
13006     char fstype[] = "ext2";
13007     char device[] = "/dev/sda2";
13008     int r;
13009     suppress_error = 0;
13010     r = guestfs_mkfs (g, fstype, device);
13011     if (r == -1)
13012       return -1;
13013   }
13014   {
13015     char fstype[] = "ext2";
13016     char device[] = "/dev/sda3";
13017     int r;
13018     suppress_error = 0;
13019     r = guestfs_mkfs (g, fstype, device);
13020     if (r == -1)
13021       return -1;
13022   }
13023   {
13024     char device[] = "/dev/sda1";
13025     char mountpoint[] = "/";
13026     int r;
13027     suppress_error = 0;
13028     r = guestfs_mount (g, device, mountpoint);
13029     if (r == -1)
13030       return -1;
13031   }
13032   {
13033     char path[] = "/mp1";
13034     int r;
13035     suppress_error = 0;
13036     r = guestfs_mkdir (g, path);
13037     if (r == -1)
13038       return -1;
13039   }
13040   {
13041     char device[] = "/dev/sda2";
13042     char mountpoint[] = "/mp1";
13043     int r;
13044     suppress_error = 0;
13045     r = guestfs_mount (g, device, mountpoint);
13046     if (r == -1)
13047       return -1;
13048   }
13049   {
13050     char path[] = "/mp1/mp2";
13051     int r;
13052     suppress_error = 0;
13053     r = guestfs_mkdir (g, path);
13054     if (r == -1)
13055       return -1;
13056   }
13057   {
13058     char device[] = "/dev/sda3";
13059     char mountpoint[] = "/mp1/mp2";
13060     int r;
13061     suppress_error = 0;
13062     r = guestfs_mount (g, device, mountpoint);
13063     if (r == -1)
13064       return -1;
13065   }
13066   {
13067     char path[] = "/mp1/mp2/mp3";
13068     int r;
13069     suppress_error = 0;
13070     r = guestfs_mkdir (g, path);
13071     if (r == -1)
13072       return -1;
13073   }
13074   {
13075     int r;
13076     suppress_error = 0;
13077     r = guestfs_umount_all (g);
13078     if (r == -1)
13079       return -1;
13080   }
13081   {
13082     char **r;
13083     int i;
13084     suppress_error = 0;
13085     r = guestfs_mounts (g);
13086     if (r == NULL)
13087       return -1;
13088     if (r[0] != NULL) {
13089       fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13090       print_strings (r);
13091       return -1;
13092     }
13093     for (i = 0; r[i] != NULL; ++i)
13094       free (r[i]);
13095     free (r);
13096   }
13097   return 0;
13098 }
13099
13100 static int test_mounts_0_skip (void)
13101 {
13102   const char *str;
13103
13104   str = getenv ("TEST_ONLY");
13105   if (str)
13106     return strstr (str, "mounts") == NULL;
13107   str = getenv ("SKIP_TEST_MOUNTS_0");
13108   if (str && strcmp (str, "1") == 0) return 1;
13109   str = getenv ("SKIP_TEST_MOUNTS");
13110   if (str && strcmp (str, "1") == 0) return 1;
13111   return 0;
13112 }
13113
13114 static int test_mounts_0 (void)
13115 {
13116   if (test_mounts_0_skip ()) {
13117     printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
13118     return 0;
13119   }
13120
13121   /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13122   {
13123     char device[] = "/dev/sda";
13124     int r;
13125     suppress_error = 0;
13126     r = guestfs_blockdev_setrw (g, device);
13127     if (r == -1)
13128       return -1;
13129   }
13130   {
13131     int r;
13132     suppress_error = 0;
13133     r = guestfs_umount_all (g);
13134     if (r == -1)
13135       return -1;
13136   }
13137   {
13138     int r;
13139     suppress_error = 0;
13140     r = guestfs_lvm_remove_all (g);
13141     if (r == -1)
13142       return -1;
13143   }
13144   {
13145     char device[] = "/dev/sda";
13146     char lines_0[] = ",";
13147     char *lines[] = {
13148       lines_0,
13149       NULL
13150     };
13151     int r;
13152     suppress_error = 0;
13153     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13154     if (r == -1)
13155       return -1;
13156   }
13157   {
13158     char fstype[] = "ext2";
13159     char device[] = "/dev/sda1";
13160     int r;
13161     suppress_error = 0;
13162     r = guestfs_mkfs (g, fstype, device);
13163     if (r == -1)
13164       return -1;
13165   }
13166   {
13167     char device[] = "/dev/sda1";
13168     char mountpoint[] = "/";
13169     int r;
13170     suppress_error = 0;
13171     r = guestfs_mount (g, device, mountpoint);
13172     if (r == -1)
13173       return -1;
13174   }
13175   /* TestOutputListOfDevices for mounts (0) */
13176   {
13177     char **r;
13178     int i;
13179     suppress_error = 0;
13180     r = guestfs_mounts (g);
13181     if (r == NULL)
13182       return -1;
13183     if (!r[0]) {
13184       fprintf (stderr, "test_mounts_0: short list returned from command\n");
13185       print_strings (r);
13186       return -1;
13187     }
13188     {
13189       char expected[] = "/dev/sda1";
13190       r[0][5] = 's';
13191       if (strcmp (r[0], expected) != 0) {
13192         fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13193         return -1;
13194       }
13195     }
13196     if (r[1] != NULL) {
13197       fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13198       print_strings (r);
13199       return -1;
13200     }
13201     for (i = 0; r[i] != NULL; ++i)
13202       free (r[i]);
13203     free (r);
13204   }
13205   return 0;
13206 }
13207
13208 static int test_umount_0_skip (void)
13209 {
13210   const char *str;
13211
13212   str = getenv ("TEST_ONLY");
13213   if (str)
13214     return strstr (str, "umount") == NULL;
13215   str = getenv ("SKIP_TEST_UMOUNT_0");
13216   if (str && strcmp (str, "1") == 0) return 1;
13217   str = getenv ("SKIP_TEST_UMOUNT");
13218   if (str && strcmp (str, "1") == 0) return 1;
13219   return 0;
13220 }
13221
13222 static int test_umount_0 (void)
13223 {
13224   if (test_umount_0_skip ()) {
13225     printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13226     return 0;
13227   }
13228
13229   /* InitNone|InitEmpty for test_umount_0 */
13230   {
13231     char device[] = "/dev/sda";
13232     int r;
13233     suppress_error = 0;
13234     r = guestfs_blockdev_setrw (g, device);
13235     if (r == -1)
13236       return -1;
13237   }
13238   {
13239     int r;
13240     suppress_error = 0;
13241     r = guestfs_umount_all (g);
13242     if (r == -1)
13243       return -1;
13244   }
13245   {
13246     int r;
13247     suppress_error = 0;
13248     r = guestfs_lvm_remove_all (g);
13249     if (r == -1)
13250       return -1;
13251   }
13252   /* TestOutputListOfDevices for umount (0) */
13253   {
13254     char device[] = "/dev/sda";
13255     char lines_0[] = ",";
13256     char *lines[] = {
13257       lines_0,
13258       NULL
13259     };
13260     int r;
13261     suppress_error = 0;
13262     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13263     if (r == -1)
13264       return -1;
13265   }
13266   {
13267     char fstype[] = "ext2";
13268     char device[] = "/dev/sda1";
13269     int r;
13270     suppress_error = 0;
13271     r = guestfs_mkfs (g, fstype, device);
13272     if (r == -1)
13273       return -1;
13274   }
13275   {
13276     char device[] = "/dev/sda1";
13277     char mountpoint[] = "/";
13278     int r;
13279     suppress_error = 0;
13280     r = guestfs_mount (g, device, mountpoint);
13281     if (r == -1)
13282       return -1;
13283   }
13284   {
13285     char **r;
13286     int i;
13287     suppress_error = 0;
13288     r = guestfs_mounts (g);
13289     if (r == NULL)
13290       return -1;
13291     if (!r[0]) {
13292       fprintf (stderr, "test_umount_0: short list returned from command\n");
13293       print_strings (r);
13294       return -1;
13295     }
13296     {
13297       char expected[] = "/dev/sda1";
13298       r[0][5] = 's';
13299       if (strcmp (r[0], expected) != 0) {
13300         fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13301         return -1;
13302       }
13303     }
13304     if (r[1] != NULL) {
13305       fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13306       print_strings (r);
13307       return -1;
13308     }
13309     for (i = 0; r[i] != NULL; ++i)
13310       free (r[i]);
13311     free (r);
13312   }
13313   return 0;
13314 }
13315
13316 static int test_umount_1_skip (void)
13317 {
13318   const char *str;
13319
13320   str = getenv ("TEST_ONLY");
13321   if (str)
13322     return strstr (str, "umount") == NULL;
13323   str = getenv ("SKIP_TEST_UMOUNT_1");
13324   if (str && strcmp (str, "1") == 0) return 1;
13325   str = getenv ("SKIP_TEST_UMOUNT");
13326   if (str && strcmp (str, "1") == 0) return 1;
13327   return 0;
13328 }
13329
13330 static int test_umount_1 (void)
13331 {
13332   if (test_umount_1_skip ()) {
13333     printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13334     return 0;
13335   }
13336
13337   /* InitNone|InitEmpty for test_umount_1 */
13338   {
13339     char device[] = "/dev/sda";
13340     int r;
13341     suppress_error = 0;
13342     r = guestfs_blockdev_setrw (g, device);
13343     if (r == -1)
13344       return -1;
13345   }
13346   {
13347     int r;
13348     suppress_error = 0;
13349     r = guestfs_umount_all (g);
13350     if (r == -1)
13351       return -1;
13352   }
13353   {
13354     int r;
13355     suppress_error = 0;
13356     r = guestfs_lvm_remove_all (g);
13357     if (r == -1)
13358       return -1;
13359   }
13360   /* TestOutputList for umount (1) */
13361   {
13362     char device[] = "/dev/sda";
13363     char lines_0[] = ",";
13364     char *lines[] = {
13365       lines_0,
13366       NULL
13367     };
13368     int r;
13369     suppress_error = 0;
13370     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13371     if (r == -1)
13372       return -1;
13373   }
13374   {
13375     char fstype[] = "ext2";
13376     char device[] = "/dev/sda1";
13377     int r;
13378     suppress_error = 0;
13379     r = guestfs_mkfs (g, fstype, device);
13380     if (r == -1)
13381       return -1;
13382   }
13383   {
13384     char device[] = "/dev/sda1";
13385     char mountpoint[] = "/";
13386     int r;
13387     suppress_error = 0;
13388     r = guestfs_mount (g, device, mountpoint);
13389     if (r == -1)
13390       return -1;
13391   }
13392   {
13393     char pathordevice[] = "/";
13394     int r;
13395     suppress_error = 0;
13396     r = guestfs_umount (g, pathordevice);
13397     if (r == -1)
13398       return -1;
13399   }
13400   {
13401     char **r;
13402     int i;
13403     suppress_error = 0;
13404     r = guestfs_mounts (g);
13405     if (r == NULL)
13406       return -1;
13407     if (r[0] != NULL) {
13408       fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13409       print_strings (r);
13410       return -1;
13411     }
13412     for (i = 0; r[i] != NULL; ++i)
13413       free (r[i]);
13414     free (r);
13415   }
13416   return 0;
13417 }
13418
13419 static int test_write_file_0_skip (void)
13420 {
13421   const char *str;
13422
13423   str = getenv ("TEST_ONLY");
13424   if (str)
13425     return strstr (str, "write_file") == NULL;
13426   str = getenv ("SKIP_TEST_WRITE_FILE_0");
13427   if (str && strcmp (str, "1") == 0) return 1;
13428   str = getenv ("SKIP_TEST_WRITE_FILE");
13429   if (str && strcmp (str, "1") == 0) return 1;
13430   return 0;
13431 }
13432
13433 static int test_write_file_0 (void)
13434 {
13435   if (test_write_file_0_skip ()) {
13436     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13437     return 0;
13438   }
13439
13440   /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13441   {
13442     char device[] = "/dev/sda";
13443     int r;
13444     suppress_error = 0;
13445     r = guestfs_blockdev_setrw (g, device);
13446     if (r == -1)
13447       return -1;
13448   }
13449   {
13450     int r;
13451     suppress_error = 0;
13452     r = guestfs_umount_all (g);
13453     if (r == -1)
13454       return -1;
13455   }
13456   {
13457     int r;
13458     suppress_error = 0;
13459     r = guestfs_lvm_remove_all (g);
13460     if (r == -1)
13461       return -1;
13462   }
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   /* TestOutput for write_file (0) */
13495   char expected[] = "new file contents";
13496   {
13497     char path[] = "/new";
13498     char content[] = "new file contents";
13499     int r;
13500     suppress_error = 0;
13501     r = guestfs_write_file (g, path, content, 0);
13502     if (r == -1)
13503       return -1;
13504   }
13505   {
13506     char path[] = "/new";
13507     char *r;
13508     suppress_error = 0;
13509     r = guestfs_cat (g, path);
13510     if (r == NULL)
13511       return -1;
13512     if (strcmp (r, expected) != 0) {
13513       fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13514       return -1;
13515     }
13516     free (r);
13517   }
13518   return 0;
13519 }
13520
13521 static int test_write_file_1_skip (void)
13522 {
13523   const char *str;
13524
13525   str = getenv ("TEST_ONLY");
13526   if (str)
13527     return strstr (str, "write_file") == NULL;
13528   str = getenv ("SKIP_TEST_WRITE_FILE_1");
13529   if (str && strcmp (str, "1") == 0) return 1;
13530   str = getenv ("SKIP_TEST_WRITE_FILE");
13531   if (str && strcmp (str, "1") == 0) return 1;
13532   return 0;
13533 }
13534
13535 static int test_write_file_1 (void)
13536 {
13537   if (test_write_file_1_skip ()) {
13538     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13539     return 0;
13540   }
13541
13542   /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13543   {
13544     char device[] = "/dev/sda";
13545     int r;
13546     suppress_error = 0;
13547     r = guestfs_blockdev_setrw (g, device);
13548     if (r == -1)
13549       return -1;
13550   }
13551   {
13552     int r;
13553     suppress_error = 0;
13554     r = guestfs_umount_all (g);
13555     if (r == -1)
13556       return -1;
13557   }
13558   {
13559     int r;
13560     suppress_error = 0;
13561     r = guestfs_lvm_remove_all (g);
13562     if (r == -1)
13563       return -1;
13564   }
13565   {
13566     char device[] = "/dev/sda";
13567     char lines_0[] = ",";
13568     char *lines[] = {
13569       lines_0,
13570       NULL
13571     };
13572     int r;
13573     suppress_error = 0;
13574     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13575     if (r == -1)
13576       return -1;
13577   }
13578   {
13579     char fstype[] = "ext2";
13580     char device[] = "/dev/sda1";
13581     int r;
13582     suppress_error = 0;
13583     r = guestfs_mkfs (g, fstype, device);
13584     if (r == -1)
13585       return -1;
13586   }
13587   {
13588     char device[] = "/dev/sda1";
13589     char mountpoint[] = "/";
13590     int r;
13591     suppress_error = 0;
13592     r = guestfs_mount (g, device, mountpoint);
13593     if (r == -1)
13594       return -1;
13595   }
13596   /* TestOutput for write_file (1) */
13597   char expected[] = "\nnew file contents\n";
13598   {
13599     char path[] = "/new";
13600     char content[] = "\nnew file contents\n";
13601     int r;
13602     suppress_error = 0;
13603     r = guestfs_write_file (g, path, content, 0);
13604     if (r == -1)
13605       return -1;
13606   }
13607   {
13608     char path[] = "/new";
13609     char *r;
13610     suppress_error = 0;
13611     r = guestfs_cat (g, path);
13612     if (r == NULL)
13613       return -1;
13614     if (strcmp (r, expected) != 0) {
13615       fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13616       return -1;
13617     }
13618     free (r);
13619   }
13620   return 0;
13621 }
13622
13623 static int test_write_file_2_skip (void)
13624 {
13625   const char *str;
13626
13627   str = getenv ("TEST_ONLY");
13628   if (str)
13629     return strstr (str, "write_file") == NULL;
13630   str = getenv ("SKIP_TEST_WRITE_FILE_2");
13631   if (str && strcmp (str, "1") == 0) return 1;
13632   str = getenv ("SKIP_TEST_WRITE_FILE");
13633   if (str && strcmp (str, "1") == 0) return 1;
13634   return 0;
13635 }
13636
13637 static int test_write_file_2 (void)
13638 {
13639   if (test_write_file_2_skip ()) {
13640     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13641     return 0;
13642   }
13643
13644   /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13645   {
13646     char device[] = "/dev/sda";
13647     int r;
13648     suppress_error = 0;
13649     r = guestfs_blockdev_setrw (g, device);
13650     if (r == -1)
13651       return -1;
13652   }
13653   {
13654     int r;
13655     suppress_error = 0;
13656     r = guestfs_umount_all (g);
13657     if (r == -1)
13658       return -1;
13659   }
13660   {
13661     int r;
13662     suppress_error = 0;
13663     r = guestfs_lvm_remove_all (g);
13664     if (r == -1)
13665       return -1;
13666   }
13667   {
13668     char device[] = "/dev/sda";
13669     char lines_0[] = ",";
13670     char *lines[] = {
13671       lines_0,
13672       NULL
13673     };
13674     int r;
13675     suppress_error = 0;
13676     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13677     if (r == -1)
13678       return -1;
13679   }
13680   {
13681     char fstype[] = "ext2";
13682     char device[] = "/dev/sda1";
13683     int r;
13684     suppress_error = 0;
13685     r = guestfs_mkfs (g, fstype, device);
13686     if (r == -1)
13687       return -1;
13688   }
13689   {
13690     char device[] = "/dev/sda1";
13691     char mountpoint[] = "/";
13692     int r;
13693     suppress_error = 0;
13694     r = guestfs_mount (g, device, mountpoint);
13695     if (r == -1)
13696       return -1;
13697   }
13698   /* TestOutput for write_file (2) */
13699   char expected[] = "\n\n";
13700   {
13701     char path[] = "/new";
13702     char content[] = "\n\n";
13703     int r;
13704     suppress_error = 0;
13705     r = guestfs_write_file (g, path, content, 0);
13706     if (r == -1)
13707       return -1;
13708   }
13709   {
13710     char path[] = "/new";
13711     char *r;
13712     suppress_error = 0;
13713     r = guestfs_cat (g, path);
13714     if (r == NULL)
13715       return -1;
13716     if (strcmp (r, expected) != 0) {
13717       fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13718       return -1;
13719     }
13720     free (r);
13721   }
13722   return 0;
13723 }
13724
13725 static int test_write_file_3_skip (void)
13726 {
13727   const char *str;
13728
13729   str = getenv ("TEST_ONLY");
13730   if (str)
13731     return strstr (str, "write_file") == NULL;
13732   str = getenv ("SKIP_TEST_WRITE_FILE_3");
13733   if (str && strcmp (str, "1") == 0) return 1;
13734   str = getenv ("SKIP_TEST_WRITE_FILE");
13735   if (str && strcmp (str, "1") == 0) return 1;
13736   return 0;
13737 }
13738
13739 static int test_write_file_3 (void)
13740 {
13741   if (test_write_file_3_skip ()) {
13742     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13743     return 0;
13744   }
13745
13746   /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13747   {
13748     char device[] = "/dev/sda";
13749     int r;
13750     suppress_error = 0;
13751     r = guestfs_blockdev_setrw (g, device);
13752     if (r == -1)
13753       return -1;
13754   }
13755   {
13756     int r;
13757     suppress_error = 0;
13758     r = guestfs_umount_all (g);
13759     if (r == -1)
13760       return -1;
13761   }
13762   {
13763     int r;
13764     suppress_error = 0;
13765     r = guestfs_lvm_remove_all (g);
13766     if (r == -1)
13767       return -1;
13768   }
13769   {
13770     char device[] = "/dev/sda";
13771     char lines_0[] = ",";
13772     char *lines[] = {
13773       lines_0,
13774       NULL
13775     };
13776     int r;
13777     suppress_error = 0;
13778     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13779     if (r == -1)
13780       return -1;
13781   }
13782   {
13783     char fstype[] = "ext2";
13784     char device[] = "/dev/sda1";
13785     int r;
13786     suppress_error = 0;
13787     r = guestfs_mkfs (g, fstype, device);
13788     if (r == -1)
13789       return -1;
13790   }
13791   {
13792     char device[] = "/dev/sda1";
13793     char mountpoint[] = "/";
13794     int r;
13795     suppress_error = 0;
13796     r = guestfs_mount (g, device, mountpoint);
13797     if (r == -1)
13798       return -1;
13799   }
13800   /* TestOutput for write_file (3) */
13801   char expected[] = "";
13802   {
13803     char path[] = "/new";
13804     char content[] = "";
13805     int r;
13806     suppress_error = 0;
13807     r = guestfs_write_file (g, path, content, 0);
13808     if (r == -1)
13809       return -1;
13810   }
13811   {
13812     char path[] = "/new";
13813     char *r;
13814     suppress_error = 0;
13815     r = guestfs_cat (g, path);
13816     if (r == NULL)
13817       return -1;
13818     if (strcmp (r, expected) != 0) {
13819       fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
13820       return -1;
13821     }
13822     free (r);
13823   }
13824   return 0;
13825 }
13826
13827 static int test_write_file_4_skip (void)
13828 {
13829   const char *str;
13830
13831   str = getenv ("TEST_ONLY");
13832   if (str)
13833     return strstr (str, "write_file") == NULL;
13834   str = getenv ("SKIP_TEST_WRITE_FILE_4");
13835   if (str && strcmp (str, "1") == 0) return 1;
13836   str = getenv ("SKIP_TEST_WRITE_FILE");
13837   if (str && strcmp (str, "1") == 0) return 1;
13838   return 0;
13839 }
13840
13841 static int test_write_file_4 (void)
13842 {
13843   if (test_write_file_4_skip ()) {
13844     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
13845     return 0;
13846   }
13847
13848   /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
13849   {
13850     char device[] = "/dev/sda";
13851     int r;
13852     suppress_error = 0;
13853     r = guestfs_blockdev_setrw (g, device);
13854     if (r == -1)
13855       return -1;
13856   }
13857   {
13858     int r;
13859     suppress_error = 0;
13860     r = guestfs_umount_all (g);
13861     if (r == -1)
13862       return -1;
13863   }
13864   {
13865     int r;
13866     suppress_error = 0;
13867     r = guestfs_lvm_remove_all (g);
13868     if (r == -1)
13869       return -1;
13870   }
13871   {
13872     char device[] = "/dev/sda";
13873     char lines_0[] = ",";
13874     char *lines[] = {
13875       lines_0,
13876       NULL
13877     };
13878     int r;
13879     suppress_error = 0;
13880     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13881     if (r == -1)
13882       return -1;
13883   }
13884   {
13885     char fstype[] = "ext2";
13886     char device[] = "/dev/sda1";
13887     int r;
13888     suppress_error = 0;
13889     r = guestfs_mkfs (g, fstype, device);
13890     if (r == -1)
13891       return -1;
13892   }
13893   {
13894     char device[] = "/dev/sda1";
13895     char mountpoint[] = "/";
13896     int r;
13897     suppress_error = 0;
13898     r = guestfs_mount (g, device, mountpoint);
13899     if (r == -1)
13900       return -1;
13901   }
13902   /* TestOutput for write_file (4) */
13903   char expected[] = "\n\n\n";
13904   {
13905     char path[] = "/new";
13906     char content[] = "\n\n\n";
13907     int r;
13908     suppress_error = 0;
13909     r = guestfs_write_file (g, path, content, 0);
13910     if (r == -1)
13911       return -1;
13912   }
13913   {
13914     char path[] = "/new";
13915     char *r;
13916     suppress_error = 0;
13917     r = guestfs_cat (g, path);
13918     if (r == NULL)
13919       return -1;
13920     if (strcmp (r, expected) != 0) {
13921       fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
13922       return -1;
13923     }
13924     free (r);
13925   }
13926   return 0;
13927 }
13928
13929 static int test_write_file_5_skip (void)
13930 {
13931   const char *str;
13932
13933   str = getenv ("TEST_ONLY");
13934   if (str)
13935     return strstr (str, "write_file") == NULL;
13936   str = getenv ("SKIP_TEST_WRITE_FILE_5");
13937   if (str && strcmp (str, "1") == 0) return 1;
13938   str = getenv ("SKIP_TEST_WRITE_FILE");
13939   if (str && strcmp (str, "1") == 0) return 1;
13940   return 0;
13941 }
13942
13943 static int test_write_file_5 (void)
13944 {
13945   if (test_write_file_5_skip ()) {
13946     printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
13947     return 0;
13948   }
13949
13950   /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
13951   {
13952     char device[] = "/dev/sda";
13953     int r;
13954     suppress_error = 0;
13955     r = guestfs_blockdev_setrw (g, device);
13956     if (r == -1)
13957       return -1;
13958   }
13959   {
13960     int r;
13961     suppress_error = 0;
13962     r = guestfs_umount_all (g);
13963     if (r == -1)
13964       return -1;
13965   }
13966   {
13967     int r;
13968     suppress_error = 0;
13969     r = guestfs_lvm_remove_all (g);
13970     if (r == -1)
13971       return -1;
13972   }
13973   {
13974     char device[] = "/dev/sda";
13975     char lines_0[] = ",";
13976     char *lines[] = {
13977       lines_0,
13978       NULL
13979     };
13980     int r;
13981     suppress_error = 0;
13982     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13983     if (r == -1)
13984       return -1;
13985   }
13986   {
13987     char fstype[] = "ext2";
13988     char device[] = "/dev/sda1";
13989     int r;
13990     suppress_error = 0;
13991     r = guestfs_mkfs (g, fstype, device);
13992     if (r == -1)
13993       return -1;
13994   }
13995   {
13996     char device[] = "/dev/sda1";
13997     char mountpoint[] = "/";
13998     int r;
13999     suppress_error = 0;
14000     r = guestfs_mount (g, device, mountpoint);
14001     if (r == -1)
14002       return -1;
14003   }
14004   /* TestOutput for write_file (5) */
14005   char expected[] = "\n";
14006   {
14007     char path[] = "/new";
14008     char content[] = "\n";
14009     int r;
14010     suppress_error = 0;
14011     r = guestfs_write_file (g, path, content, 0);
14012     if (r == -1)
14013       return -1;
14014   }
14015   {
14016     char path[] = "/new";
14017     char *r;
14018     suppress_error = 0;
14019     r = guestfs_cat (g, path);
14020     if (r == NULL)
14021       return -1;
14022     if (strcmp (r, expected) != 0) {
14023       fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14024       return -1;
14025     }
14026     free (r);
14027   }
14028   return 0;
14029 }
14030
14031 static int test_mkfs_0_skip (void)
14032 {
14033   const char *str;
14034
14035   str = getenv ("TEST_ONLY");
14036   if (str)
14037     return strstr (str, "mkfs") == NULL;
14038   str = getenv ("SKIP_TEST_MKFS_0");
14039   if (str && strcmp (str, "1") == 0) return 1;
14040   str = getenv ("SKIP_TEST_MKFS");
14041   if (str && strcmp (str, "1") == 0) return 1;
14042   return 0;
14043 }
14044
14045 static int test_mkfs_0 (void)
14046 {
14047   if (test_mkfs_0_skip ()) {
14048     printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
14049     return 0;
14050   }
14051
14052   /* InitNone|InitEmpty for test_mkfs_0 */
14053   {
14054     char device[] = "/dev/sda";
14055     int r;
14056     suppress_error = 0;
14057     r = guestfs_blockdev_setrw (g, device);
14058     if (r == -1)
14059       return -1;
14060   }
14061   {
14062     int r;
14063     suppress_error = 0;
14064     r = guestfs_umount_all (g);
14065     if (r == -1)
14066       return -1;
14067   }
14068   {
14069     int r;
14070     suppress_error = 0;
14071     r = guestfs_lvm_remove_all (g);
14072     if (r == -1)
14073       return -1;
14074   }
14075   /* TestOutput for mkfs (0) */
14076   char expected[] = "new file contents";
14077   {
14078     char device[] = "/dev/sda";
14079     char lines_0[] = ",";
14080     char *lines[] = {
14081       lines_0,
14082       NULL
14083     };
14084     int r;
14085     suppress_error = 0;
14086     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14087     if (r == -1)
14088       return -1;
14089   }
14090   {
14091     char fstype[] = "ext2";
14092     char device[] = "/dev/sda1";
14093     int r;
14094     suppress_error = 0;
14095     r = guestfs_mkfs (g, fstype, device);
14096     if (r == -1)
14097       return -1;
14098   }
14099   {
14100     char device[] = "/dev/sda1";
14101     char mountpoint[] = "/";
14102     int r;
14103     suppress_error = 0;
14104     r = guestfs_mount (g, device, mountpoint);
14105     if (r == -1)
14106       return -1;
14107   }
14108   {
14109     char path[] = "/new";
14110     char content[] = "new file contents";
14111     int r;
14112     suppress_error = 0;
14113     r = guestfs_write_file (g, path, content, 0);
14114     if (r == -1)
14115       return -1;
14116   }
14117   {
14118     char path[] = "/new";
14119     char *r;
14120     suppress_error = 0;
14121     r = guestfs_cat (g, path);
14122     if (r == NULL)
14123       return -1;
14124     if (strcmp (r, expected) != 0) {
14125       fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14126       return -1;
14127     }
14128     free (r);
14129   }
14130   return 0;
14131 }
14132
14133 static int test_lvcreate_0_skip (void)
14134 {
14135   const char *str;
14136
14137   str = getenv ("TEST_ONLY");
14138   if (str)
14139     return strstr (str, "lvcreate") == NULL;
14140   str = getenv ("SKIP_TEST_LVCREATE_0");
14141   if (str && strcmp (str, "1") == 0) return 1;
14142   str = getenv ("SKIP_TEST_LVCREATE");
14143   if (str && strcmp (str, "1") == 0) return 1;
14144   return 0;
14145 }
14146
14147 static int test_lvcreate_0 (void)
14148 {
14149   if (test_lvcreate_0_skip ()) {
14150     printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14151     return 0;
14152   }
14153
14154   /* InitNone|InitEmpty for test_lvcreate_0 */
14155   {
14156     char device[] = "/dev/sda";
14157     int r;
14158     suppress_error = 0;
14159     r = guestfs_blockdev_setrw (g, device);
14160     if (r == -1)
14161       return -1;
14162   }
14163   {
14164     int r;
14165     suppress_error = 0;
14166     r = guestfs_umount_all (g);
14167     if (r == -1)
14168       return -1;
14169   }
14170   {
14171     int r;
14172     suppress_error = 0;
14173     r = guestfs_lvm_remove_all (g);
14174     if (r == -1)
14175       return -1;
14176   }
14177   /* TestOutputList for lvcreate (0) */
14178   {
14179     char device[] = "/dev/sda";
14180     char lines_0[] = ",10";
14181     char lines_1[] = ",20";
14182     char lines_2[] = ",";
14183     char *lines[] = {
14184       lines_0,
14185       lines_1,
14186       lines_2,
14187       NULL
14188     };
14189     int r;
14190     suppress_error = 0;
14191     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14192     if (r == -1)
14193       return -1;
14194   }
14195   {
14196     char device[] = "/dev/sda1";
14197     int r;
14198     suppress_error = 0;
14199     r = guestfs_pvcreate (g, device);
14200     if (r == -1)
14201       return -1;
14202   }
14203   {
14204     char device[] = "/dev/sda2";
14205     int r;
14206     suppress_error = 0;
14207     r = guestfs_pvcreate (g, device);
14208     if (r == -1)
14209       return -1;
14210   }
14211   {
14212     char device[] = "/dev/sda3";
14213     int r;
14214     suppress_error = 0;
14215     r = guestfs_pvcreate (g, device);
14216     if (r == -1)
14217       return -1;
14218   }
14219   {
14220     char volgroup[] = "VG1";
14221     char physvols_0[] = "/dev/sda1";
14222     char physvols_1[] = "/dev/sda2";
14223     char *physvols[] = {
14224       physvols_0,
14225       physvols_1,
14226       NULL
14227     };
14228     int r;
14229     suppress_error = 0;
14230     r = guestfs_vgcreate (g, volgroup, physvols);
14231     if (r == -1)
14232       return -1;
14233   }
14234   {
14235     char volgroup[] = "VG2";
14236     char physvols_0[] = "/dev/sda3";
14237     char *physvols[] = {
14238       physvols_0,
14239       NULL
14240     };
14241     int r;
14242     suppress_error = 0;
14243     r = guestfs_vgcreate (g, volgroup, physvols);
14244     if (r == -1)
14245       return -1;
14246   }
14247   {
14248     char logvol[] = "LV1";
14249     char volgroup[] = "VG1";
14250     int r;
14251     suppress_error = 0;
14252     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14253     if (r == -1)
14254       return -1;
14255   }
14256   {
14257     char logvol[] = "LV2";
14258     char volgroup[] = "VG1";
14259     int r;
14260     suppress_error = 0;
14261     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14262     if (r == -1)
14263       return -1;
14264   }
14265   {
14266     char logvol[] = "LV3";
14267     char volgroup[] = "VG2";
14268     int r;
14269     suppress_error = 0;
14270     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14271     if (r == -1)
14272       return -1;
14273   }
14274   {
14275     char logvol[] = "LV4";
14276     char volgroup[] = "VG2";
14277     int r;
14278     suppress_error = 0;
14279     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14280     if (r == -1)
14281       return -1;
14282   }
14283   {
14284     char logvol[] = "LV5";
14285     char volgroup[] = "VG2";
14286     int r;
14287     suppress_error = 0;
14288     r = guestfs_lvcreate (g, logvol, volgroup, 50);
14289     if (r == -1)
14290       return -1;
14291   }
14292   {
14293     char **r;
14294     int i;
14295     suppress_error = 0;
14296     r = guestfs_lvs (g);
14297     if (r == NULL)
14298       return -1;
14299     if (!r[0]) {
14300       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14301       print_strings (r);
14302       return -1;
14303     }
14304     {
14305       char expected[] = "/dev/VG1/LV1";
14306       if (strcmp (r[0], expected) != 0) {
14307         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14308         return -1;
14309       }
14310     }
14311     if (!r[1]) {
14312       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14313       print_strings (r);
14314       return -1;
14315     }
14316     {
14317       char expected[] = "/dev/VG1/LV2";
14318       if (strcmp (r[1], expected) != 0) {
14319         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14320         return -1;
14321       }
14322     }
14323     if (!r[2]) {
14324       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14325       print_strings (r);
14326       return -1;
14327     }
14328     {
14329       char expected[] = "/dev/VG2/LV3";
14330       if (strcmp (r[2], expected) != 0) {
14331         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14332         return -1;
14333       }
14334     }
14335     if (!r[3]) {
14336       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14337       print_strings (r);
14338       return -1;
14339     }
14340     {
14341       char expected[] = "/dev/VG2/LV4";
14342       if (strcmp (r[3], expected) != 0) {
14343         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14344         return -1;
14345       }
14346     }
14347     if (!r[4]) {
14348       fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14349       print_strings (r);
14350       return -1;
14351     }
14352     {
14353       char expected[] = "/dev/VG2/LV5";
14354       if (strcmp (r[4], expected) != 0) {
14355         fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14356         return -1;
14357       }
14358     }
14359     if (r[5] != NULL) {
14360       fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14361       print_strings (r);
14362       return -1;
14363     }
14364     for (i = 0; r[i] != NULL; ++i)
14365       free (r[i]);
14366     free (r);
14367   }
14368   return 0;
14369 }
14370
14371 static int test_vgcreate_0_skip (void)
14372 {
14373   const char *str;
14374
14375   str = getenv ("TEST_ONLY");
14376   if (str)
14377     return strstr (str, "vgcreate") == NULL;
14378   str = getenv ("SKIP_TEST_VGCREATE_0");
14379   if (str && strcmp (str, "1") == 0) return 1;
14380   str = getenv ("SKIP_TEST_VGCREATE");
14381   if (str && strcmp (str, "1") == 0) return 1;
14382   return 0;
14383 }
14384
14385 static int test_vgcreate_0 (void)
14386 {
14387   if (test_vgcreate_0_skip ()) {
14388     printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14389     return 0;
14390   }
14391
14392   /* InitNone|InitEmpty for test_vgcreate_0 */
14393   {
14394     char device[] = "/dev/sda";
14395     int r;
14396     suppress_error = 0;
14397     r = guestfs_blockdev_setrw (g, device);
14398     if (r == -1)
14399       return -1;
14400   }
14401   {
14402     int r;
14403     suppress_error = 0;
14404     r = guestfs_umount_all (g);
14405     if (r == -1)
14406       return -1;
14407   }
14408   {
14409     int r;
14410     suppress_error = 0;
14411     r = guestfs_lvm_remove_all (g);
14412     if (r == -1)
14413       return -1;
14414   }
14415   /* TestOutputList for vgcreate (0) */
14416   {
14417     char device[] = "/dev/sda";
14418     char lines_0[] = ",10";
14419     char lines_1[] = ",20";
14420     char lines_2[] = ",";
14421     char *lines[] = {
14422       lines_0,
14423       lines_1,
14424       lines_2,
14425       NULL
14426     };
14427     int r;
14428     suppress_error = 0;
14429     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14430     if (r == -1)
14431       return -1;
14432   }
14433   {
14434     char device[] = "/dev/sda1";
14435     int r;
14436     suppress_error = 0;
14437     r = guestfs_pvcreate (g, device);
14438     if (r == -1)
14439       return -1;
14440   }
14441   {
14442     char device[] = "/dev/sda2";
14443     int r;
14444     suppress_error = 0;
14445     r = guestfs_pvcreate (g, device);
14446     if (r == -1)
14447       return -1;
14448   }
14449   {
14450     char device[] = "/dev/sda3";
14451     int r;
14452     suppress_error = 0;
14453     r = guestfs_pvcreate (g, device);
14454     if (r == -1)
14455       return -1;
14456   }
14457   {
14458     char volgroup[] = "VG1";
14459     char physvols_0[] = "/dev/sda1";
14460     char physvols_1[] = "/dev/sda2";
14461     char *physvols[] = {
14462       physvols_0,
14463       physvols_1,
14464       NULL
14465     };
14466     int r;
14467     suppress_error = 0;
14468     r = guestfs_vgcreate (g, volgroup, physvols);
14469     if (r == -1)
14470       return -1;
14471   }
14472   {
14473     char volgroup[] = "VG2";
14474     char physvols_0[] = "/dev/sda3";
14475     char *physvols[] = {
14476       physvols_0,
14477       NULL
14478     };
14479     int r;
14480     suppress_error = 0;
14481     r = guestfs_vgcreate (g, volgroup, physvols);
14482     if (r == -1)
14483       return -1;
14484   }
14485   {
14486     char **r;
14487     int i;
14488     suppress_error = 0;
14489     r = guestfs_vgs (g);
14490     if (r == NULL)
14491       return -1;
14492     if (!r[0]) {
14493       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14494       print_strings (r);
14495       return -1;
14496     }
14497     {
14498       char expected[] = "VG1";
14499       if (strcmp (r[0], expected) != 0) {
14500         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14501         return -1;
14502       }
14503     }
14504     if (!r[1]) {
14505       fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14506       print_strings (r);
14507       return -1;
14508     }
14509     {
14510       char expected[] = "VG2";
14511       if (strcmp (r[1], expected) != 0) {
14512         fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14513         return -1;
14514       }
14515     }
14516     if (r[2] != NULL) {
14517       fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14518       print_strings (r);
14519       return -1;
14520     }
14521     for (i = 0; r[i] != NULL; ++i)
14522       free (r[i]);
14523     free (r);
14524   }
14525   return 0;
14526 }
14527
14528 static int test_pvcreate_0_skip (void)
14529 {
14530   const char *str;
14531
14532   str = getenv ("TEST_ONLY");
14533   if (str)
14534     return strstr (str, "pvcreate") == NULL;
14535   str = getenv ("SKIP_TEST_PVCREATE_0");
14536   if (str && strcmp (str, "1") == 0) return 1;
14537   str = getenv ("SKIP_TEST_PVCREATE");
14538   if (str && strcmp (str, "1") == 0) return 1;
14539   return 0;
14540 }
14541
14542 static int test_pvcreate_0 (void)
14543 {
14544   if (test_pvcreate_0_skip ()) {
14545     printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14546     return 0;
14547   }
14548
14549   /* InitNone|InitEmpty for test_pvcreate_0 */
14550   {
14551     char device[] = "/dev/sda";
14552     int r;
14553     suppress_error = 0;
14554     r = guestfs_blockdev_setrw (g, device);
14555     if (r == -1)
14556       return -1;
14557   }
14558   {
14559     int r;
14560     suppress_error = 0;
14561     r = guestfs_umount_all (g);
14562     if (r == -1)
14563       return -1;
14564   }
14565   {
14566     int r;
14567     suppress_error = 0;
14568     r = guestfs_lvm_remove_all (g);
14569     if (r == -1)
14570       return -1;
14571   }
14572   /* TestOutputListOfDevices for pvcreate (0) */
14573   {
14574     char device[] = "/dev/sda";
14575     char lines_0[] = ",10";
14576     char lines_1[] = ",20";
14577     char lines_2[] = ",";
14578     char *lines[] = {
14579       lines_0,
14580       lines_1,
14581       lines_2,
14582       NULL
14583     };
14584     int r;
14585     suppress_error = 0;
14586     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14587     if (r == -1)
14588       return -1;
14589   }
14590   {
14591     char device[] = "/dev/sda1";
14592     int r;
14593     suppress_error = 0;
14594     r = guestfs_pvcreate (g, device);
14595     if (r == -1)
14596       return -1;
14597   }
14598   {
14599     char device[] = "/dev/sda2";
14600     int r;
14601     suppress_error = 0;
14602     r = guestfs_pvcreate (g, device);
14603     if (r == -1)
14604       return -1;
14605   }
14606   {
14607     char device[] = "/dev/sda3";
14608     int r;
14609     suppress_error = 0;
14610     r = guestfs_pvcreate (g, device);
14611     if (r == -1)
14612       return -1;
14613   }
14614   {
14615     char **r;
14616     int i;
14617     suppress_error = 0;
14618     r = guestfs_pvs (g);
14619     if (r == NULL)
14620       return -1;
14621     if (!r[0]) {
14622       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14623       print_strings (r);
14624       return -1;
14625     }
14626     {
14627       char expected[] = "/dev/sda1";
14628       r[0][5] = 's';
14629       if (strcmp (r[0], expected) != 0) {
14630         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14631         return -1;
14632       }
14633     }
14634     if (!r[1]) {
14635       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14636       print_strings (r);
14637       return -1;
14638     }
14639     {
14640       char expected[] = "/dev/sda2";
14641       r[1][5] = 's';
14642       if (strcmp (r[1], expected) != 0) {
14643         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14644         return -1;
14645       }
14646     }
14647     if (!r[2]) {
14648       fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14649       print_strings (r);
14650       return -1;
14651     }
14652     {
14653       char expected[] = "/dev/sda3";
14654       r[2][5] = 's';
14655       if (strcmp (r[2], expected) != 0) {
14656         fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14657         return -1;
14658       }
14659     }
14660     if (r[3] != NULL) {
14661       fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14662       print_strings (r);
14663       return -1;
14664     }
14665     for (i = 0; r[i] != NULL; ++i)
14666       free (r[i]);
14667     free (r);
14668   }
14669   return 0;
14670 }
14671
14672 static int test_is_dir_0_skip (void)
14673 {
14674   const char *str;
14675
14676   str = getenv ("TEST_ONLY");
14677   if (str)
14678     return strstr (str, "is_dir") == NULL;
14679   str = getenv ("SKIP_TEST_IS_DIR_0");
14680   if (str && strcmp (str, "1") == 0) return 1;
14681   str = getenv ("SKIP_TEST_IS_DIR");
14682   if (str && strcmp (str, "1") == 0) return 1;
14683   return 0;
14684 }
14685
14686 static int test_is_dir_0 (void)
14687 {
14688   if (test_is_dir_0_skip ()) {
14689     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14690     return 0;
14691   }
14692
14693   /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14694   {
14695     char device[] = "/dev/sda";
14696     int r;
14697     suppress_error = 0;
14698     r = guestfs_blockdev_setrw (g, device);
14699     if (r == -1)
14700       return -1;
14701   }
14702   {
14703     int r;
14704     suppress_error = 0;
14705     r = guestfs_umount_all (g);
14706     if (r == -1)
14707       return -1;
14708   }
14709   {
14710     int r;
14711     suppress_error = 0;
14712     r = guestfs_lvm_remove_all (g);
14713     if (r == -1)
14714       return -1;
14715   }
14716   {
14717     char device[] = "/dev/sda";
14718     char lines_0[] = ",";
14719     char *lines[] = {
14720       lines_0,
14721       NULL
14722     };
14723     int r;
14724     suppress_error = 0;
14725     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14726     if (r == -1)
14727       return -1;
14728   }
14729   {
14730     char fstype[] = "ext2";
14731     char device[] = "/dev/sda1";
14732     int r;
14733     suppress_error = 0;
14734     r = guestfs_mkfs (g, fstype, device);
14735     if (r == -1)
14736       return -1;
14737   }
14738   {
14739     char device[] = "/dev/sda1";
14740     char mountpoint[] = "/";
14741     int r;
14742     suppress_error = 0;
14743     r = guestfs_mount (g, device, mountpoint);
14744     if (r == -1)
14745       return -1;
14746   }
14747   /* TestOutputFalse for is_dir (0) */
14748   {
14749     char path[] = "/new";
14750     int r;
14751     suppress_error = 0;
14752     r = guestfs_touch (g, path);
14753     if (r == -1)
14754       return -1;
14755   }
14756   {
14757     char path[] = "/new";
14758     int r;
14759     suppress_error = 0;
14760     r = guestfs_is_dir (g, path);
14761     if (r == -1)
14762       return -1;
14763     if (r) {
14764       fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14765       return -1;
14766     }
14767   }
14768   return 0;
14769 }
14770
14771 static int test_is_dir_1_skip (void)
14772 {
14773   const char *str;
14774
14775   str = getenv ("TEST_ONLY");
14776   if (str)
14777     return strstr (str, "is_dir") == NULL;
14778   str = getenv ("SKIP_TEST_IS_DIR_1");
14779   if (str && strcmp (str, "1") == 0) return 1;
14780   str = getenv ("SKIP_TEST_IS_DIR");
14781   if (str && strcmp (str, "1") == 0) return 1;
14782   return 0;
14783 }
14784
14785 static int test_is_dir_1 (void)
14786 {
14787   if (test_is_dir_1_skip ()) {
14788     printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
14789     return 0;
14790   }
14791
14792   /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
14793   {
14794     char device[] = "/dev/sda";
14795     int r;
14796     suppress_error = 0;
14797     r = guestfs_blockdev_setrw (g, device);
14798     if (r == -1)
14799       return -1;
14800   }
14801   {
14802     int r;
14803     suppress_error = 0;
14804     r = guestfs_umount_all (g);
14805     if (r == -1)
14806       return -1;
14807   }
14808   {
14809     int r;
14810     suppress_error = 0;
14811     r = guestfs_lvm_remove_all (g);
14812     if (r == -1)
14813       return -1;
14814   }
14815   {
14816     char device[] = "/dev/sda";
14817     char lines_0[] = ",";
14818     char *lines[] = {
14819       lines_0,
14820       NULL
14821     };
14822     int r;
14823     suppress_error = 0;
14824     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14825     if (r == -1)
14826       return -1;
14827   }
14828   {
14829     char fstype[] = "ext2";
14830     char device[] = "/dev/sda1";
14831     int r;
14832     suppress_error = 0;
14833     r = guestfs_mkfs (g, fstype, device);
14834     if (r == -1)
14835       return -1;
14836   }
14837   {
14838     char device[] = "/dev/sda1";
14839     char mountpoint[] = "/";
14840     int r;
14841     suppress_error = 0;
14842     r = guestfs_mount (g, device, mountpoint);
14843     if (r == -1)
14844       return -1;
14845   }
14846   /* TestOutputTrue for is_dir (1) */
14847   {
14848     char path[] = "/new";
14849     int r;
14850     suppress_error = 0;
14851     r = guestfs_mkdir (g, path);
14852     if (r == -1)
14853       return -1;
14854   }
14855   {
14856     char path[] = "/new";
14857     int r;
14858     suppress_error = 0;
14859     r = guestfs_is_dir (g, path);
14860     if (r == -1)
14861       return -1;
14862     if (!r) {
14863       fprintf (stderr, "test_is_dir_1: expected true, got false\n");
14864       return -1;
14865     }
14866   }
14867   return 0;
14868 }
14869
14870 static int test_is_file_0_skip (void)
14871 {
14872   const char *str;
14873
14874   str = getenv ("TEST_ONLY");
14875   if (str)
14876     return strstr (str, "is_file") == NULL;
14877   str = getenv ("SKIP_TEST_IS_FILE_0");
14878   if (str && strcmp (str, "1") == 0) return 1;
14879   str = getenv ("SKIP_TEST_IS_FILE");
14880   if (str && strcmp (str, "1") == 0) return 1;
14881   return 0;
14882 }
14883
14884 static int test_is_file_0 (void)
14885 {
14886   if (test_is_file_0_skip ()) {
14887     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
14888     return 0;
14889   }
14890
14891   /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
14892   {
14893     char device[] = "/dev/sda";
14894     int r;
14895     suppress_error = 0;
14896     r = guestfs_blockdev_setrw (g, device);
14897     if (r == -1)
14898       return -1;
14899   }
14900   {
14901     int r;
14902     suppress_error = 0;
14903     r = guestfs_umount_all (g);
14904     if (r == -1)
14905       return -1;
14906   }
14907   {
14908     int r;
14909     suppress_error = 0;
14910     r = guestfs_lvm_remove_all (g);
14911     if (r == -1)
14912       return -1;
14913   }
14914   {
14915     char device[] = "/dev/sda";
14916     char lines_0[] = ",";
14917     char *lines[] = {
14918       lines_0,
14919       NULL
14920     };
14921     int r;
14922     suppress_error = 0;
14923     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14924     if (r == -1)
14925       return -1;
14926   }
14927   {
14928     char fstype[] = "ext2";
14929     char device[] = "/dev/sda1";
14930     int r;
14931     suppress_error = 0;
14932     r = guestfs_mkfs (g, fstype, device);
14933     if (r == -1)
14934       return -1;
14935   }
14936   {
14937     char device[] = "/dev/sda1";
14938     char mountpoint[] = "/";
14939     int r;
14940     suppress_error = 0;
14941     r = guestfs_mount (g, device, mountpoint);
14942     if (r == -1)
14943       return -1;
14944   }
14945   /* TestOutputTrue for is_file (0) */
14946   {
14947     char path[] = "/new";
14948     int r;
14949     suppress_error = 0;
14950     r = guestfs_touch (g, path);
14951     if (r == -1)
14952       return -1;
14953   }
14954   {
14955     char path[] = "/new";
14956     int r;
14957     suppress_error = 0;
14958     r = guestfs_is_file (g, path);
14959     if (r == -1)
14960       return -1;
14961     if (!r) {
14962       fprintf (stderr, "test_is_file_0: expected true, got false\n");
14963       return -1;
14964     }
14965   }
14966   return 0;
14967 }
14968
14969 static int test_is_file_1_skip (void)
14970 {
14971   const char *str;
14972
14973   str = getenv ("TEST_ONLY");
14974   if (str)
14975     return strstr (str, "is_file") == NULL;
14976   str = getenv ("SKIP_TEST_IS_FILE_1");
14977   if (str && strcmp (str, "1") == 0) return 1;
14978   str = getenv ("SKIP_TEST_IS_FILE");
14979   if (str && strcmp (str, "1") == 0) return 1;
14980   return 0;
14981 }
14982
14983 static int test_is_file_1 (void)
14984 {
14985   if (test_is_file_1_skip ()) {
14986     printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
14987     return 0;
14988   }
14989
14990   /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
14991   {
14992     char device[] = "/dev/sda";
14993     int r;
14994     suppress_error = 0;
14995     r = guestfs_blockdev_setrw (g, device);
14996     if (r == -1)
14997       return -1;
14998   }
14999   {
15000     int r;
15001     suppress_error = 0;
15002     r = guestfs_umount_all (g);
15003     if (r == -1)
15004       return -1;
15005   }
15006   {
15007     int r;
15008     suppress_error = 0;
15009     r = guestfs_lvm_remove_all (g);
15010     if (r == -1)
15011       return -1;
15012   }
15013   {
15014     char device[] = "/dev/sda";
15015     char lines_0[] = ",";
15016     char *lines[] = {
15017       lines_0,
15018       NULL
15019     };
15020     int r;
15021     suppress_error = 0;
15022     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15023     if (r == -1)
15024       return -1;
15025   }
15026   {
15027     char fstype[] = "ext2";
15028     char device[] = "/dev/sda1";
15029     int r;
15030     suppress_error = 0;
15031     r = guestfs_mkfs (g, fstype, device);
15032     if (r == -1)
15033       return -1;
15034   }
15035   {
15036     char device[] = "/dev/sda1";
15037     char mountpoint[] = "/";
15038     int r;
15039     suppress_error = 0;
15040     r = guestfs_mount (g, device, mountpoint);
15041     if (r == -1)
15042       return -1;
15043   }
15044   /* TestOutputFalse for is_file (1) */
15045   {
15046     char path[] = "/new";
15047     int r;
15048     suppress_error = 0;
15049     r = guestfs_mkdir (g, path);
15050     if (r == -1)
15051       return -1;
15052   }
15053   {
15054     char path[] = "/new";
15055     int r;
15056     suppress_error = 0;
15057     r = guestfs_is_file (g, path);
15058     if (r == -1)
15059       return -1;
15060     if (r) {
15061       fprintf (stderr, "test_is_file_1: expected false, got true\n");
15062       return -1;
15063     }
15064   }
15065   return 0;
15066 }
15067
15068 static int test_exists_0_skip (void)
15069 {
15070   const char *str;
15071
15072   str = getenv ("TEST_ONLY");
15073   if (str)
15074     return strstr (str, "exists") == NULL;
15075   str = getenv ("SKIP_TEST_EXISTS_0");
15076   if (str && strcmp (str, "1") == 0) return 1;
15077   str = getenv ("SKIP_TEST_EXISTS");
15078   if (str && strcmp (str, "1") == 0) return 1;
15079   return 0;
15080 }
15081
15082 static int test_exists_0 (void)
15083 {
15084   if (test_exists_0_skip ()) {
15085     printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
15086     return 0;
15087   }
15088
15089   /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15090   {
15091     char device[] = "/dev/sda";
15092     int r;
15093     suppress_error = 0;
15094     r = guestfs_blockdev_setrw (g, device);
15095     if (r == -1)
15096       return -1;
15097   }
15098   {
15099     int r;
15100     suppress_error = 0;
15101     r = guestfs_umount_all (g);
15102     if (r == -1)
15103       return -1;
15104   }
15105   {
15106     int r;
15107     suppress_error = 0;
15108     r = guestfs_lvm_remove_all (g);
15109     if (r == -1)
15110       return -1;
15111   }
15112   {
15113     char device[] = "/dev/sda";
15114     char lines_0[] = ",";
15115     char *lines[] = {
15116       lines_0,
15117       NULL
15118     };
15119     int r;
15120     suppress_error = 0;
15121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15122     if (r == -1)
15123       return -1;
15124   }
15125   {
15126     char fstype[] = "ext2";
15127     char device[] = "/dev/sda1";
15128     int r;
15129     suppress_error = 0;
15130     r = guestfs_mkfs (g, fstype, device);
15131     if (r == -1)
15132       return -1;
15133   }
15134   {
15135     char device[] = "/dev/sda1";
15136     char mountpoint[] = "/";
15137     int r;
15138     suppress_error = 0;
15139     r = guestfs_mount (g, device, mountpoint);
15140     if (r == -1)
15141       return -1;
15142   }
15143   /* TestOutputTrue for exists (0) */
15144   {
15145     char path[] = "/new";
15146     int r;
15147     suppress_error = 0;
15148     r = guestfs_touch (g, path);
15149     if (r == -1)
15150       return -1;
15151   }
15152   {
15153     char path[] = "/new";
15154     int r;
15155     suppress_error = 0;
15156     r = guestfs_exists (g, path);
15157     if (r == -1)
15158       return -1;
15159     if (!r) {
15160       fprintf (stderr, "test_exists_0: expected true, got false\n");
15161       return -1;
15162     }
15163   }
15164   return 0;
15165 }
15166
15167 static int test_exists_1_skip (void)
15168 {
15169   const char *str;
15170
15171   str = getenv ("TEST_ONLY");
15172   if (str)
15173     return strstr (str, "exists") == NULL;
15174   str = getenv ("SKIP_TEST_EXISTS_1");
15175   if (str && strcmp (str, "1") == 0) return 1;
15176   str = getenv ("SKIP_TEST_EXISTS");
15177   if (str && strcmp (str, "1") == 0) return 1;
15178   return 0;
15179 }
15180
15181 static int test_exists_1 (void)
15182 {
15183   if (test_exists_1_skip ()) {
15184     printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15185     return 0;
15186   }
15187
15188   /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15189   {
15190     char device[] = "/dev/sda";
15191     int r;
15192     suppress_error = 0;
15193     r = guestfs_blockdev_setrw (g, device);
15194     if (r == -1)
15195       return -1;
15196   }
15197   {
15198     int r;
15199     suppress_error = 0;
15200     r = guestfs_umount_all (g);
15201     if (r == -1)
15202       return -1;
15203   }
15204   {
15205     int r;
15206     suppress_error = 0;
15207     r = guestfs_lvm_remove_all (g);
15208     if (r == -1)
15209       return -1;
15210   }
15211   {
15212     char device[] = "/dev/sda";
15213     char lines_0[] = ",";
15214     char *lines[] = {
15215       lines_0,
15216       NULL
15217     };
15218     int r;
15219     suppress_error = 0;
15220     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15221     if (r == -1)
15222       return -1;
15223   }
15224   {
15225     char fstype[] = "ext2";
15226     char device[] = "/dev/sda1";
15227     int r;
15228     suppress_error = 0;
15229     r = guestfs_mkfs (g, fstype, device);
15230     if (r == -1)
15231       return -1;
15232   }
15233   {
15234     char device[] = "/dev/sda1";
15235     char mountpoint[] = "/";
15236     int r;
15237     suppress_error = 0;
15238     r = guestfs_mount (g, device, mountpoint);
15239     if (r == -1)
15240       return -1;
15241   }
15242   /* TestOutputTrue for exists (1) */
15243   {
15244     char path[] = "/new";
15245     int r;
15246     suppress_error = 0;
15247     r = guestfs_mkdir (g, path);
15248     if (r == -1)
15249       return -1;
15250   }
15251   {
15252     char path[] = "/new";
15253     int r;
15254     suppress_error = 0;
15255     r = guestfs_exists (g, path);
15256     if (r == -1)
15257       return -1;
15258     if (!r) {
15259       fprintf (stderr, "test_exists_1: expected true, got false\n");
15260       return -1;
15261     }
15262   }
15263   return 0;
15264 }
15265
15266 static int test_mkdir_p_0_skip (void)
15267 {
15268   const char *str;
15269
15270   str = getenv ("TEST_ONLY");
15271   if (str)
15272     return strstr (str, "mkdir_p") == NULL;
15273   str = getenv ("SKIP_TEST_MKDIR_P_0");
15274   if (str && strcmp (str, "1") == 0) return 1;
15275   str = getenv ("SKIP_TEST_MKDIR_P");
15276   if (str && strcmp (str, "1") == 0) return 1;
15277   return 0;
15278 }
15279
15280 static int test_mkdir_p_0 (void)
15281 {
15282   if (test_mkdir_p_0_skip ()) {
15283     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15284     return 0;
15285   }
15286
15287   /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15288   {
15289     char device[] = "/dev/sda";
15290     int r;
15291     suppress_error = 0;
15292     r = guestfs_blockdev_setrw (g, device);
15293     if (r == -1)
15294       return -1;
15295   }
15296   {
15297     int r;
15298     suppress_error = 0;
15299     r = guestfs_umount_all (g);
15300     if (r == -1)
15301       return -1;
15302   }
15303   {
15304     int r;
15305     suppress_error = 0;
15306     r = guestfs_lvm_remove_all (g);
15307     if (r == -1)
15308       return -1;
15309   }
15310   {
15311     char device[] = "/dev/sda";
15312     char lines_0[] = ",";
15313     char *lines[] = {
15314       lines_0,
15315       NULL
15316     };
15317     int r;
15318     suppress_error = 0;
15319     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15320     if (r == -1)
15321       return -1;
15322   }
15323   {
15324     char fstype[] = "ext2";
15325     char device[] = "/dev/sda1";
15326     int r;
15327     suppress_error = 0;
15328     r = guestfs_mkfs (g, fstype, device);
15329     if (r == -1)
15330       return -1;
15331   }
15332   {
15333     char device[] = "/dev/sda1";
15334     char mountpoint[] = "/";
15335     int r;
15336     suppress_error = 0;
15337     r = guestfs_mount (g, device, mountpoint);
15338     if (r == -1)
15339       return -1;
15340   }
15341   /* TestOutputTrue for mkdir_p (0) */
15342   {
15343     char path[] = "/new/foo/bar";
15344     int r;
15345     suppress_error = 0;
15346     r = guestfs_mkdir_p (g, path);
15347     if (r == -1)
15348       return -1;
15349   }
15350   {
15351     char path[] = "/new/foo/bar";
15352     int r;
15353     suppress_error = 0;
15354     r = guestfs_is_dir (g, path);
15355     if (r == -1)
15356       return -1;
15357     if (!r) {
15358       fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15359       return -1;
15360     }
15361   }
15362   return 0;
15363 }
15364
15365 static int test_mkdir_p_1_skip (void)
15366 {
15367   const char *str;
15368
15369   str = getenv ("TEST_ONLY");
15370   if (str)
15371     return strstr (str, "mkdir_p") == NULL;
15372   str = getenv ("SKIP_TEST_MKDIR_P_1");
15373   if (str && strcmp (str, "1") == 0) return 1;
15374   str = getenv ("SKIP_TEST_MKDIR_P");
15375   if (str && strcmp (str, "1") == 0) return 1;
15376   return 0;
15377 }
15378
15379 static int test_mkdir_p_1 (void)
15380 {
15381   if (test_mkdir_p_1_skip ()) {
15382     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15383     return 0;
15384   }
15385
15386   /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15387   {
15388     char device[] = "/dev/sda";
15389     int r;
15390     suppress_error = 0;
15391     r = guestfs_blockdev_setrw (g, device);
15392     if (r == -1)
15393       return -1;
15394   }
15395   {
15396     int r;
15397     suppress_error = 0;
15398     r = guestfs_umount_all (g);
15399     if (r == -1)
15400       return -1;
15401   }
15402   {
15403     int r;
15404     suppress_error = 0;
15405     r = guestfs_lvm_remove_all (g);
15406     if (r == -1)
15407       return -1;
15408   }
15409   {
15410     char device[] = "/dev/sda";
15411     char lines_0[] = ",";
15412     char *lines[] = {
15413       lines_0,
15414       NULL
15415     };
15416     int r;
15417     suppress_error = 0;
15418     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15419     if (r == -1)
15420       return -1;
15421   }
15422   {
15423     char fstype[] = "ext2";
15424     char device[] = "/dev/sda1";
15425     int r;
15426     suppress_error = 0;
15427     r = guestfs_mkfs (g, fstype, device);
15428     if (r == -1)
15429       return -1;
15430   }
15431   {
15432     char device[] = "/dev/sda1";
15433     char mountpoint[] = "/";
15434     int r;
15435     suppress_error = 0;
15436     r = guestfs_mount (g, device, mountpoint);
15437     if (r == -1)
15438       return -1;
15439   }
15440   /* TestOutputTrue for mkdir_p (1) */
15441   {
15442     char path[] = "/new/foo/bar";
15443     int r;
15444     suppress_error = 0;
15445     r = guestfs_mkdir_p (g, path);
15446     if (r == -1)
15447       return -1;
15448   }
15449   {
15450     char path[] = "/new/foo";
15451     int r;
15452     suppress_error = 0;
15453     r = guestfs_is_dir (g, path);
15454     if (r == -1)
15455       return -1;
15456     if (!r) {
15457       fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15458       return -1;
15459     }
15460   }
15461   return 0;
15462 }
15463
15464 static int test_mkdir_p_2_skip (void)
15465 {
15466   const char *str;
15467
15468   str = getenv ("TEST_ONLY");
15469   if (str)
15470     return strstr (str, "mkdir_p") == NULL;
15471   str = getenv ("SKIP_TEST_MKDIR_P_2");
15472   if (str && strcmp (str, "1") == 0) return 1;
15473   str = getenv ("SKIP_TEST_MKDIR_P");
15474   if (str && strcmp (str, "1") == 0) return 1;
15475   return 0;
15476 }
15477
15478 static int test_mkdir_p_2 (void)
15479 {
15480   if (test_mkdir_p_2_skip ()) {
15481     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15482     return 0;
15483   }
15484
15485   /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15486   {
15487     char device[] = "/dev/sda";
15488     int r;
15489     suppress_error = 0;
15490     r = guestfs_blockdev_setrw (g, device);
15491     if (r == -1)
15492       return -1;
15493   }
15494   {
15495     int r;
15496     suppress_error = 0;
15497     r = guestfs_umount_all (g);
15498     if (r == -1)
15499       return -1;
15500   }
15501   {
15502     int r;
15503     suppress_error = 0;
15504     r = guestfs_lvm_remove_all (g);
15505     if (r == -1)
15506       return -1;
15507   }
15508   {
15509     char device[] = "/dev/sda";
15510     char lines_0[] = ",";
15511     char *lines[] = {
15512       lines_0,
15513       NULL
15514     };
15515     int r;
15516     suppress_error = 0;
15517     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15518     if (r == -1)
15519       return -1;
15520   }
15521   {
15522     char fstype[] = "ext2";
15523     char device[] = "/dev/sda1";
15524     int r;
15525     suppress_error = 0;
15526     r = guestfs_mkfs (g, fstype, device);
15527     if (r == -1)
15528       return -1;
15529   }
15530   {
15531     char device[] = "/dev/sda1";
15532     char mountpoint[] = "/";
15533     int r;
15534     suppress_error = 0;
15535     r = guestfs_mount (g, device, mountpoint);
15536     if (r == -1)
15537       return -1;
15538   }
15539   /* TestOutputTrue for mkdir_p (2) */
15540   {
15541     char path[] = "/new/foo/bar";
15542     int r;
15543     suppress_error = 0;
15544     r = guestfs_mkdir_p (g, path);
15545     if (r == -1)
15546       return -1;
15547   }
15548   {
15549     char path[] = "/new";
15550     int r;
15551     suppress_error = 0;
15552     r = guestfs_is_dir (g, path);
15553     if (r == -1)
15554       return -1;
15555     if (!r) {
15556       fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15557       return -1;
15558     }
15559   }
15560   return 0;
15561 }
15562
15563 static int test_mkdir_p_3_skip (void)
15564 {
15565   const char *str;
15566
15567   str = getenv ("TEST_ONLY");
15568   if (str)
15569     return strstr (str, "mkdir_p") == NULL;
15570   str = getenv ("SKIP_TEST_MKDIR_P_3");
15571   if (str && strcmp (str, "1") == 0) return 1;
15572   str = getenv ("SKIP_TEST_MKDIR_P");
15573   if (str && strcmp (str, "1") == 0) return 1;
15574   return 0;
15575 }
15576
15577 static int test_mkdir_p_3 (void)
15578 {
15579   if (test_mkdir_p_3_skip ()) {
15580     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15581     return 0;
15582   }
15583
15584   /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15585   {
15586     char device[] = "/dev/sda";
15587     int r;
15588     suppress_error = 0;
15589     r = guestfs_blockdev_setrw (g, device);
15590     if (r == -1)
15591       return -1;
15592   }
15593   {
15594     int r;
15595     suppress_error = 0;
15596     r = guestfs_umount_all (g);
15597     if (r == -1)
15598       return -1;
15599   }
15600   {
15601     int r;
15602     suppress_error = 0;
15603     r = guestfs_lvm_remove_all (g);
15604     if (r == -1)
15605       return -1;
15606   }
15607   {
15608     char device[] = "/dev/sda";
15609     char lines_0[] = ",";
15610     char *lines[] = {
15611       lines_0,
15612       NULL
15613     };
15614     int r;
15615     suppress_error = 0;
15616     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15617     if (r == -1)
15618       return -1;
15619   }
15620   {
15621     char fstype[] = "ext2";
15622     char device[] = "/dev/sda1";
15623     int r;
15624     suppress_error = 0;
15625     r = guestfs_mkfs (g, fstype, device);
15626     if (r == -1)
15627       return -1;
15628   }
15629   {
15630     char device[] = "/dev/sda1";
15631     char mountpoint[] = "/";
15632     int r;
15633     suppress_error = 0;
15634     r = guestfs_mount (g, device, mountpoint);
15635     if (r == -1)
15636       return -1;
15637   }
15638   /* TestRun for mkdir_p (3) */
15639   {
15640     char path[] = "/new";
15641     int r;
15642     suppress_error = 0;
15643     r = guestfs_mkdir (g, path);
15644     if (r == -1)
15645       return -1;
15646   }
15647   {
15648     char path[] = "/new";
15649     int r;
15650     suppress_error = 0;
15651     r = guestfs_mkdir_p (g, path);
15652     if (r == -1)
15653       return -1;
15654   }
15655   return 0;
15656 }
15657
15658 static int test_mkdir_p_4_skip (void)
15659 {
15660   const char *str;
15661
15662   str = getenv ("TEST_ONLY");
15663   if (str)
15664     return strstr (str, "mkdir_p") == NULL;
15665   str = getenv ("SKIP_TEST_MKDIR_P_4");
15666   if (str && strcmp (str, "1") == 0) return 1;
15667   str = getenv ("SKIP_TEST_MKDIR_P");
15668   if (str && strcmp (str, "1") == 0) return 1;
15669   return 0;
15670 }
15671
15672 static int test_mkdir_p_4 (void)
15673 {
15674   if (test_mkdir_p_4_skip ()) {
15675     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15676     return 0;
15677   }
15678
15679   /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15680   {
15681     char device[] = "/dev/sda";
15682     int r;
15683     suppress_error = 0;
15684     r = guestfs_blockdev_setrw (g, device);
15685     if (r == -1)
15686       return -1;
15687   }
15688   {
15689     int r;
15690     suppress_error = 0;
15691     r = guestfs_umount_all (g);
15692     if (r == -1)
15693       return -1;
15694   }
15695   {
15696     int r;
15697     suppress_error = 0;
15698     r = guestfs_lvm_remove_all (g);
15699     if (r == -1)
15700       return -1;
15701   }
15702   {
15703     char device[] = "/dev/sda";
15704     char lines_0[] = ",";
15705     char *lines[] = {
15706       lines_0,
15707       NULL
15708     };
15709     int r;
15710     suppress_error = 0;
15711     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15712     if (r == -1)
15713       return -1;
15714   }
15715   {
15716     char fstype[] = "ext2";
15717     char device[] = "/dev/sda1";
15718     int r;
15719     suppress_error = 0;
15720     r = guestfs_mkfs (g, fstype, device);
15721     if (r == -1)
15722       return -1;
15723   }
15724   {
15725     char device[] = "/dev/sda1";
15726     char mountpoint[] = "/";
15727     int r;
15728     suppress_error = 0;
15729     r = guestfs_mount (g, device, mountpoint);
15730     if (r == -1)
15731       return -1;
15732   }
15733   /* TestLastFail for mkdir_p (4) */
15734   {
15735     char path[] = "/new";
15736     int r;
15737     suppress_error = 0;
15738     r = guestfs_touch (g, path);
15739     if (r == -1)
15740       return -1;
15741   }
15742   {
15743     char path[] = "/new";
15744     int r;
15745     suppress_error = 1;
15746     r = guestfs_mkdir_p (g, path);
15747     if (r != -1)
15748       return -1;
15749   }
15750   return 0;
15751 }
15752
15753 static int test_mkdir_0_skip (void)
15754 {
15755   const char *str;
15756
15757   str = getenv ("TEST_ONLY");
15758   if (str)
15759     return strstr (str, "mkdir") == NULL;
15760   str = getenv ("SKIP_TEST_MKDIR_0");
15761   if (str && strcmp (str, "1") == 0) return 1;
15762   str = getenv ("SKIP_TEST_MKDIR");
15763   if (str && strcmp (str, "1") == 0) return 1;
15764   return 0;
15765 }
15766
15767 static int test_mkdir_0 (void)
15768 {
15769   if (test_mkdir_0_skip ()) {
15770     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15771     return 0;
15772   }
15773
15774   /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15775   {
15776     char device[] = "/dev/sda";
15777     int r;
15778     suppress_error = 0;
15779     r = guestfs_blockdev_setrw (g, device);
15780     if (r == -1)
15781       return -1;
15782   }
15783   {
15784     int r;
15785     suppress_error = 0;
15786     r = guestfs_umount_all (g);
15787     if (r == -1)
15788       return -1;
15789   }
15790   {
15791     int r;
15792     suppress_error = 0;
15793     r = guestfs_lvm_remove_all (g);
15794     if (r == -1)
15795       return -1;
15796   }
15797   {
15798     char device[] = "/dev/sda";
15799     char lines_0[] = ",";
15800     char *lines[] = {
15801       lines_0,
15802       NULL
15803     };
15804     int r;
15805     suppress_error = 0;
15806     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15807     if (r == -1)
15808       return -1;
15809   }
15810   {
15811     char fstype[] = "ext2";
15812     char device[] = "/dev/sda1";
15813     int r;
15814     suppress_error = 0;
15815     r = guestfs_mkfs (g, fstype, device);
15816     if (r == -1)
15817       return -1;
15818   }
15819   {
15820     char device[] = "/dev/sda1";
15821     char mountpoint[] = "/";
15822     int r;
15823     suppress_error = 0;
15824     r = guestfs_mount (g, device, mountpoint);
15825     if (r == -1)
15826       return -1;
15827   }
15828   /* TestOutputTrue for mkdir (0) */
15829   {
15830     char path[] = "/new";
15831     int r;
15832     suppress_error = 0;
15833     r = guestfs_mkdir (g, path);
15834     if (r == -1)
15835       return -1;
15836   }
15837   {
15838     char path[] = "/new";
15839     int r;
15840     suppress_error = 0;
15841     r = guestfs_is_dir (g, path);
15842     if (r == -1)
15843       return -1;
15844     if (!r) {
15845       fprintf (stderr, "test_mkdir_0: expected true, got false\n");
15846       return -1;
15847     }
15848   }
15849   return 0;
15850 }
15851
15852 static int test_mkdir_1_skip (void)
15853 {
15854   const char *str;
15855
15856   str = getenv ("TEST_ONLY");
15857   if (str)
15858     return strstr (str, "mkdir") == NULL;
15859   str = getenv ("SKIP_TEST_MKDIR_1");
15860   if (str && strcmp (str, "1") == 0) return 1;
15861   str = getenv ("SKIP_TEST_MKDIR");
15862   if (str && strcmp (str, "1") == 0) return 1;
15863   return 0;
15864 }
15865
15866 static int test_mkdir_1 (void)
15867 {
15868   if (test_mkdir_1_skip ()) {
15869     printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
15870     return 0;
15871   }
15872
15873   /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
15874   {
15875     char device[] = "/dev/sda";
15876     int r;
15877     suppress_error = 0;
15878     r = guestfs_blockdev_setrw (g, device);
15879     if (r == -1)
15880       return -1;
15881   }
15882   {
15883     int r;
15884     suppress_error = 0;
15885     r = guestfs_umount_all (g);
15886     if (r == -1)
15887       return -1;
15888   }
15889   {
15890     int r;
15891     suppress_error = 0;
15892     r = guestfs_lvm_remove_all (g);
15893     if (r == -1)
15894       return -1;
15895   }
15896   {
15897     char device[] = "/dev/sda";
15898     char lines_0[] = ",";
15899     char *lines[] = {
15900       lines_0,
15901       NULL
15902     };
15903     int r;
15904     suppress_error = 0;
15905     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15906     if (r == -1)
15907       return -1;
15908   }
15909   {
15910     char fstype[] = "ext2";
15911     char device[] = "/dev/sda1";
15912     int r;
15913     suppress_error = 0;
15914     r = guestfs_mkfs (g, fstype, device);
15915     if (r == -1)
15916       return -1;
15917   }
15918   {
15919     char device[] = "/dev/sda1";
15920     char mountpoint[] = "/";
15921     int r;
15922     suppress_error = 0;
15923     r = guestfs_mount (g, device, mountpoint);
15924     if (r == -1)
15925       return -1;
15926   }
15927   /* TestLastFail for mkdir (1) */
15928   {
15929     char path[] = "/new/foo/bar";
15930     int r;
15931     suppress_error = 1;
15932     r = guestfs_mkdir (g, path);
15933     if (r != -1)
15934       return -1;
15935   }
15936   return 0;
15937 }
15938
15939 static int test_rm_rf_0_skip (void)
15940 {
15941   const char *str;
15942
15943   str = getenv ("TEST_ONLY");
15944   if (str)
15945     return strstr (str, "rm_rf") == NULL;
15946   str = getenv ("SKIP_TEST_RM_RF_0");
15947   if (str && strcmp (str, "1") == 0) return 1;
15948   str = getenv ("SKIP_TEST_RM_RF");
15949   if (str && strcmp (str, "1") == 0) return 1;
15950   return 0;
15951 }
15952
15953 static int test_rm_rf_0 (void)
15954 {
15955   if (test_rm_rf_0_skip ()) {
15956     printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
15957     return 0;
15958   }
15959
15960   /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
15961   {
15962     char device[] = "/dev/sda";
15963     int r;
15964     suppress_error = 0;
15965     r = guestfs_blockdev_setrw (g, device);
15966     if (r == -1)
15967       return -1;
15968   }
15969   {
15970     int r;
15971     suppress_error = 0;
15972     r = guestfs_umount_all (g);
15973     if (r == -1)
15974       return -1;
15975   }
15976   {
15977     int r;
15978     suppress_error = 0;
15979     r = guestfs_lvm_remove_all (g);
15980     if (r == -1)
15981       return -1;
15982   }
15983   {
15984     char device[] = "/dev/sda";
15985     char lines_0[] = ",";
15986     char *lines[] = {
15987       lines_0,
15988       NULL
15989     };
15990     int r;
15991     suppress_error = 0;
15992     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15993     if (r == -1)
15994       return -1;
15995   }
15996   {
15997     char fstype[] = "ext2";
15998     char device[] = "/dev/sda1";
15999     int r;
16000     suppress_error = 0;
16001     r = guestfs_mkfs (g, fstype, device);
16002     if (r == -1)
16003       return -1;
16004   }
16005   {
16006     char device[] = "/dev/sda1";
16007     char mountpoint[] = "/";
16008     int r;
16009     suppress_error = 0;
16010     r = guestfs_mount (g, device, mountpoint);
16011     if (r == -1)
16012       return -1;
16013   }
16014   /* TestOutputFalse for rm_rf (0) */
16015   {
16016     char path[] = "/new";
16017     int r;
16018     suppress_error = 0;
16019     r = guestfs_mkdir (g, path);
16020     if (r == -1)
16021       return -1;
16022   }
16023   {
16024     char path[] = "/new/foo";
16025     int r;
16026     suppress_error = 0;
16027     r = guestfs_mkdir (g, path);
16028     if (r == -1)
16029       return -1;
16030   }
16031   {
16032     char path[] = "/new/foo/bar";
16033     int r;
16034     suppress_error = 0;
16035     r = guestfs_touch (g, path);
16036     if (r == -1)
16037       return -1;
16038   }
16039   {
16040     char path[] = "/new";
16041     int r;
16042     suppress_error = 0;
16043     r = guestfs_rm_rf (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_exists (g, path);
16052     if (r == -1)
16053       return -1;
16054     if (r) {
16055       fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16056       return -1;
16057     }
16058   }
16059   return 0;
16060 }
16061
16062 static int test_rmdir_0_skip (void)
16063 {
16064   const char *str;
16065
16066   str = getenv ("TEST_ONLY");
16067   if (str)
16068     return strstr (str, "rmdir") == NULL;
16069   str = getenv ("SKIP_TEST_RMDIR_0");
16070   if (str && strcmp (str, "1") == 0) return 1;
16071   str = getenv ("SKIP_TEST_RMDIR");
16072   if (str && strcmp (str, "1") == 0) return 1;
16073   return 0;
16074 }
16075
16076 static int test_rmdir_0 (void)
16077 {
16078   if (test_rmdir_0_skip ()) {
16079     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
16080     return 0;
16081   }
16082
16083   /* InitBasicFS for test_rmdir_0: 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   /* TestRun for rmdir (0) */
16138   {
16139     char path[] = "/new";
16140     int r;
16141     suppress_error = 0;
16142     r = guestfs_mkdir (g, path);
16143     if (r == -1)
16144       return -1;
16145   }
16146   {
16147     char path[] = "/new";
16148     int r;
16149     suppress_error = 0;
16150     r = guestfs_rmdir (g, path);
16151     if (r == -1)
16152       return -1;
16153   }
16154   return 0;
16155 }
16156
16157 static int test_rmdir_1_skip (void)
16158 {
16159   const char *str;
16160
16161   str = getenv ("TEST_ONLY");
16162   if (str)
16163     return strstr (str, "rmdir") == NULL;
16164   str = getenv ("SKIP_TEST_RMDIR_1");
16165   if (str && strcmp (str, "1") == 0) return 1;
16166   str = getenv ("SKIP_TEST_RMDIR");
16167   if (str && strcmp (str, "1") == 0) return 1;
16168   return 0;
16169 }
16170
16171 static int test_rmdir_1 (void)
16172 {
16173   if (test_rmdir_1_skip ()) {
16174     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16175     return 0;
16176   }
16177
16178   /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16179   {
16180     char device[] = "/dev/sda";
16181     int r;
16182     suppress_error = 0;
16183     r = guestfs_blockdev_setrw (g, device);
16184     if (r == -1)
16185       return -1;
16186   }
16187   {
16188     int r;
16189     suppress_error = 0;
16190     r = guestfs_umount_all (g);
16191     if (r == -1)
16192       return -1;
16193   }
16194   {
16195     int r;
16196     suppress_error = 0;
16197     r = guestfs_lvm_remove_all (g);
16198     if (r == -1)
16199       return -1;
16200   }
16201   {
16202     char device[] = "/dev/sda";
16203     char lines_0[] = ",";
16204     char *lines[] = {
16205       lines_0,
16206       NULL
16207     };
16208     int r;
16209     suppress_error = 0;
16210     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16211     if (r == -1)
16212       return -1;
16213   }
16214   {
16215     char fstype[] = "ext2";
16216     char device[] = "/dev/sda1";
16217     int r;
16218     suppress_error = 0;
16219     r = guestfs_mkfs (g, fstype, device);
16220     if (r == -1)
16221       return -1;
16222   }
16223   {
16224     char device[] = "/dev/sda1";
16225     char mountpoint[] = "/";
16226     int r;
16227     suppress_error = 0;
16228     r = guestfs_mount (g, device, mountpoint);
16229     if (r == -1)
16230       return -1;
16231   }
16232   /* TestLastFail for rmdir (1) */
16233   {
16234     char path[] = "/new";
16235     int r;
16236     suppress_error = 1;
16237     r = guestfs_rmdir (g, path);
16238     if (r != -1)
16239       return -1;
16240   }
16241   return 0;
16242 }
16243
16244 static int test_rmdir_2_skip (void)
16245 {
16246   const char *str;
16247
16248   str = getenv ("TEST_ONLY");
16249   if (str)
16250     return strstr (str, "rmdir") == NULL;
16251   str = getenv ("SKIP_TEST_RMDIR_2");
16252   if (str && strcmp (str, "1") == 0) return 1;
16253   str = getenv ("SKIP_TEST_RMDIR");
16254   if (str && strcmp (str, "1") == 0) return 1;
16255   return 0;
16256 }
16257
16258 static int test_rmdir_2 (void)
16259 {
16260   if (test_rmdir_2_skip ()) {
16261     printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16262     return 0;
16263   }
16264
16265   /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16266   {
16267     char device[] = "/dev/sda";
16268     int r;
16269     suppress_error = 0;
16270     r = guestfs_blockdev_setrw (g, device);
16271     if (r == -1)
16272       return -1;
16273   }
16274   {
16275     int r;
16276     suppress_error = 0;
16277     r = guestfs_umount_all (g);
16278     if (r == -1)
16279       return -1;
16280   }
16281   {
16282     int r;
16283     suppress_error = 0;
16284     r = guestfs_lvm_remove_all (g);
16285     if (r == -1)
16286       return -1;
16287   }
16288   {
16289     char device[] = "/dev/sda";
16290     char lines_0[] = ",";
16291     char *lines[] = {
16292       lines_0,
16293       NULL
16294     };
16295     int r;
16296     suppress_error = 0;
16297     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16298     if (r == -1)
16299       return -1;
16300   }
16301   {
16302     char fstype[] = "ext2";
16303     char device[] = "/dev/sda1";
16304     int r;
16305     suppress_error = 0;
16306     r = guestfs_mkfs (g, fstype, device);
16307     if (r == -1)
16308       return -1;
16309   }
16310   {
16311     char device[] = "/dev/sda1";
16312     char mountpoint[] = "/";
16313     int r;
16314     suppress_error = 0;
16315     r = guestfs_mount (g, device, mountpoint);
16316     if (r == -1)
16317       return -1;
16318   }
16319   /* TestLastFail for rmdir (2) */
16320   {
16321     char path[] = "/new";
16322     int r;
16323     suppress_error = 0;
16324     r = guestfs_touch (g, path);
16325     if (r == -1)
16326       return -1;
16327   }
16328   {
16329     char path[] = "/new";
16330     int r;
16331     suppress_error = 1;
16332     r = guestfs_rmdir (g, path);
16333     if (r != -1)
16334       return -1;
16335   }
16336   return 0;
16337 }
16338
16339 static int test_rm_0_skip (void)
16340 {
16341   const char *str;
16342
16343   str = getenv ("TEST_ONLY");
16344   if (str)
16345     return strstr (str, "rm") == NULL;
16346   str = getenv ("SKIP_TEST_RM_0");
16347   if (str && strcmp (str, "1") == 0) return 1;
16348   str = getenv ("SKIP_TEST_RM");
16349   if (str && strcmp (str, "1") == 0) return 1;
16350   return 0;
16351 }
16352
16353 static int test_rm_0 (void)
16354 {
16355   if (test_rm_0_skip ()) {
16356     printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16357     return 0;
16358   }
16359
16360   /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16361   {
16362     char device[] = "/dev/sda";
16363     int r;
16364     suppress_error = 0;
16365     r = guestfs_blockdev_setrw (g, device);
16366     if (r == -1)
16367       return -1;
16368   }
16369   {
16370     int r;
16371     suppress_error = 0;
16372     r = guestfs_umount_all (g);
16373     if (r == -1)
16374       return -1;
16375   }
16376   {
16377     int r;
16378     suppress_error = 0;
16379     r = guestfs_lvm_remove_all (g);
16380     if (r == -1)
16381       return -1;
16382   }
16383   {
16384     char device[] = "/dev/sda";
16385     char lines_0[] = ",";
16386     char *lines[] = {
16387       lines_0,
16388       NULL
16389     };
16390     int r;
16391     suppress_error = 0;
16392     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16393     if (r == -1)
16394       return -1;
16395   }
16396   {
16397     char fstype[] = "ext2";
16398     char device[] = "/dev/sda1";
16399     int r;
16400     suppress_error = 0;
16401     r = guestfs_mkfs (g, fstype, device);
16402     if (r == -1)
16403       return -1;
16404   }
16405   {
16406     char device[] = "/dev/sda1";
16407     char mountpoint[] = "/";
16408     int r;
16409     suppress_error = 0;
16410     r = guestfs_mount (g, device, mountpoint);
16411     if (r == -1)
16412       return -1;
16413   }
16414   /* TestRun for rm (0) */
16415   {
16416     char path[] = "/new";
16417     int r;
16418     suppress_error = 0;
16419     r = guestfs_touch (g, path);
16420     if (r == -1)
16421       return -1;
16422   }
16423   {
16424     char path[] = "/new";
16425     int r;
16426     suppress_error = 0;
16427     r = guestfs_rm (g, path);
16428     if (r == -1)
16429       return -1;
16430   }
16431   return 0;
16432 }
16433
16434 static int test_rm_1_skip (void)
16435 {
16436   const char *str;
16437
16438   str = getenv ("TEST_ONLY");
16439   if (str)
16440     return strstr (str, "rm") == NULL;
16441   str = getenv ("SKIP_TEST_RM_1");
16442   if (str && strcmp (str, "1") == 0) return 1;
16443   str = getenv ("SKIP_TEST_RM");
16444   if (str && strcmp (str, "1") == 0) return 1;
16445   return 0;
16446 }
16447
16448 static int test_rm_1 (void)
16449 {
16450   if (test_rm_1_skip ()) {
16451     printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16452     return 0;
16453   }
16454
16455   /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16456   {
16457     char device[] = "/dev/sda";
16458     int r;
16459     suppress_error = 0;
16460     r = guestfs_blockdev_setrw (g, device);
16461     if (r == -1)
16462       return -1;
16463   }
16464   {
16465     int r;
16466     suppress_error = 0;
16467     r = guestfs_umount_all (g);
16468     if (r == -1)
16469       return -1;
16470   }
16471   {
16472     int r;
16473     suppress_error = 0;
16474     r = guestfs_lvm_remove_all (g);
16475     if (r == -1)
16476       return -1;
16477   }
16478   {
16479     char device[] = "/dev/sda";
16480     char lines_0[] = ",";
16481     char *lines[] = {
16482       lines_0,
16483       NULL
16484     };
16485     int r;
16486     suppress_error = 0;
16487     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16488     if (r == -1)
16489       return -1;
16490   }
16491   {
16492     char fstype[] = "ext2";
16493     char device[] = "/dev/sda1";
16494     int r;
16495     suppress_error = 0;
16496     r = guestfs_mkfs (g, fstype, device);
16497     if (r == -1)
16498       return -1;
16499   }
16500   {
16501     char device[] = "/dev/sda1";
16502     char mountpoint[] = "/";
16503     int r;
16504     suppress_error = 0;
16505     r = guestfs_mount (g, device, mountpoint);
16506     if (r == -1)
16507       return -1;
16508   }
16509   /* TestLastFail for rm (1) */
16510   {
16511     char path[] = "/new";
16512     int r;
16513     suppress_error = 1;
16514     r = guestfs_rm (g, path);
16515     if (r != -1)
16516       return -1;
16517   }
16518   return 0;
16519 }
16520
16521 static int test_rm_2_skip (void)
16522 {
16523   const char *str;
16524
16525   str = getenv ("TEST_ONLY");
16526   if (str)
16527     return strstr (str, "rm") == NULL;
16528   str = getenv ("SKIP_TEST_RM_2");
16529   if (str && strcmp (str, "1") == 0) return 1;
16530   str = getenv ("SKIP_TEST_RM");
16531   if (str && strcmp (str, "1") == 0) return 1;
16532   return 0;
16533 }
16534
16535 static int test_rm_2 (void)
16536 {
16537   if (test_rm_2_skip ()) {
16538     printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16539     return 0;
16540   }
16541
16542   /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16543   {
16544     char device[] = "/dev/sda";
16545     int r;
16546     suppress_error = 0;
16547     r = guestfs_blockdev_setrw (g, device);
16548     if (r == -1)
16549       return -1;
16550   }
16551   {
16552     int r;
16553     suppress_error = 0;
16554     r = guestfs_umount_all (g);
16555     if (r == -1)
16556       return -1;
16557   }
16558   {
16559     int r;
16560     suppress_error = 0;
16561     r = guestfs_lvm_remove_all (g);
16562     if (r == -1)
16563       return -1;
16564   }
16565   {
16566     char device[] = "/dev/sda";
16567     char lines_0[] = ",";
16568     char *lines[] = {
16569       lines_0,
16570       NULL
16571     };
16572     int r;
16573     suppress_error = 0;
16574     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16575     if (r == -1)
16576       return -1;
16577   }
16578   {
16579     char fstype[] = "ext2";
16580     char device[] = "/dev/sda1";
16581     int r;
16582     suppress_error = 0;
16583     r = guestfs_mkfs (g, fstype, device);
16584     if (r == -1)
16585       return -1;
16586   }
16587   {
16588     char device[] = "/dev/sda1";
16589     char mountpoint[] = "/";
16590     int r;
16591     suppress_error = 0;
16592     r = guestfs_mount (g, device, mountpoint);
16593     if (r == -1)
16594       return -1;
16595   }
16596   /* TestLastFail for rm (2) */
16597   {
16598     char path[] = "/new";
16599     int r;
16600     suppress_error = 0;
16601     r = guestfs_mkdir (g, path);
16602     if (r == -1)
16603       return -1;
16604   }
16605   {
16606     char path[] = "/new";
16607     int r;
16608     suppress_error = 1;
16609     r = guestfs_rm (g, path);
16610     if (r != -1)
16611       return -1;
16612   }
16613   return 0;
16614 }
16615
16616 static int test_read_lines_0_skip (void)
16617 {
16618   const char *str;
16619
16620   str = getenv ("TEST_ONLY");
16621   if (str)
16622     return strstr (str, "read_lines") == NULL;
16623   str = getenv ("SKIP_TEST_READ_LINES_0");
16624   if (str && strcmp (str, "1") == 0) return 1;
16625   str = getenv ("SKIP_TEST_READ_LINES");
16626   if (str && strcmp (str, "1") == 0) return 1;
16627   return 0;
16628 }
16629
16630 static int test_read_lines_0 (void)
16631 {
16632   if (test_read_lines_0_skip ()) {
16633     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16634     return 0;
16635   }
16636
16637   /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16638   {
16639     char device[] = "/dev/sda";
16640     int r;
16641     suppress_error = 0;
16642     r = guestfs_blockdev_setrw (g, device);
16643     if (r == -1)
16644       return -1;
16645   }
16646   {
16647     int r;
16648     suppress_error = 0;
16649     r = guestfs_umount_all (g);
16650     if (r == -1)
16651       return -1;
16652   }
16653   {
16654     int r;
16655     suppress_error = 0;
16656     r = guestfs_lvm_remove_all (g);
16657     if (r == -1)
16658       return -1;
16659   }
16660   {
16661     char device[] = "/dev/sda";
16662     char lines_0[] = ",";
16663     char *lines[] = {
16664       lines_0,
16665       NULL
16666     };
16667     int r;
16668     suppress_error = 0;
16669     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16670     if (r == -1)
16671       return -1;
16672   }
16673   {
16674     char fstype[] = "ext2";
16675     char device[] = "/dev/sda1";
16676     int r;
16677     suppress_error = 0;
16678     r = guestfs_mkfs (g, fstype, device);
16679     if (r == -1)
16680       return -1;
16681   }
16682   {
16683     char device[] = "/dev/sda1";
16684     char mountpoint[] = "/";
16685     int r;
16686     suppress_error = 0;
16687     r = guestfs_mount (g, device, mountpoint);
16688     if (r == -1)
16689       return -1;
16690   }
16691   /* TestOutputList for read_lines (0) */
16692   {
16693     char path[] = "/new";
16694     char content[] = "line1\r\nline2\nline3";
16695     int r;
16696     suppress_error = 0;
16697     r = guestfs_write_file (g, path, content, 0);
16698     if (r == -1)
16699       return -1;
16700   }
16701   {
16702     char path[] = "/new";
16703     char **r;
16704     int i;
16705     suppress_error = 0;
16706     r = guestfs_read_lines (g, path);
16707     if (r == NULL)
16708       return -1;
16709     if (!r[0]) {
16710       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16711       print_strings (r);
16712       return -1;
16713     }
16714     {
16715       char expected[] = "line1";
16716       if (strcmp (r[0], expected) != 0) {
16717         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16718         return -1;
16719       }
16720     }
16721     if (!r[1]) {
16722       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16723       print_strings (r);
16724       return -1;
16725     }
16726     {
16727       char expected[] = "line2";
16728       if (strcmp (r[1], expected) != 0) {
16729         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16730         return -1;
16731       }
16732     }
16733     if (!r[2]) {
16734       fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16735       print_strings (r);
16736       return -1;
16737     }
16738     {
16739       char expected[] = "line3";
16740       if (strcmp (r[2], expected) != 0) {
16741         fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16742         return -1;
16743       }
16744     }
16745     if (r[3] != NULL) {
16746       fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16747       print_strings (r);
16748       return -1;
16749     }
16750     for (i = 0; r[i] != NULL; ++i)
16751       free (r[i]);
16752     free (r);
16753   }
16754   return 0;
16755 }
16756
16757 static int test_read_lines_1_skip (void)
16758 {
16759   const char *str;
16760
16761   str = getenv ("TEST_ONLY");
16762   if (str)
16763     return strstr (str, "read_lines") == NULL;
16764   str = getenv ("SKIP_TEST_READ_LINES_1");
16765   if (str && strcmp (str, "1") == 0) return 1;
16766   str = getenv ("SKIP_TEST_READ_LINES");
16767   if (str && strcmp (str, "1") == 0) return 1;
16768   return 0;
16769 }
16770
16771 static int test_read_lines_1 (void)
16772 {
16773   if (test_read_lines_1_skip ()) {
16774     printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16775     return 0;
16776   }
16777
16778   /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16779   {
16780     char device[] = "/dev/sda";
16781     int r;
16782     suppress_error = 0;
16783     r = guestfs_blockdev_setrw (g, device);
16784     if (r == -1)
16785       return -1;
16786   }
16787   {
16788     int r;
16789     suppress_error = 0;
16790     r = guestfs_umount_all (g);
16791     if (r == -1)
16792       return -1;
16793   }
16794   {
16795     int r;
16796     suppress_error = 0;
16797     r = guestfs_lvm_remove_all (g);
16798     if (r == -1)
16799       return -1;
16800   }
16801   {
16802     char device[] = "/dev/sda";
16803     char lines_0[] = ",";
16804     char *lines[] = {
16805       lines_0,
16806       NULL
16807     };
16808     int r;
16809     suppress_error = 0;
16810     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16811     if (r == -1)
16812       return -1;
16813   }
16814   {
16815     char fstype[] = "ext2";
16816     char device[] = "/dev/sda1";
16817     int r;
16818     suppress_error = 0;
16819     r = guestfs_mkfs (g, fstype, device);
16820     if (r == -1)
16821       return -1;
16822   }
16823   {
16824     char device[] = "/dev/sda1";
16825     char mountpoint[] = "/";
16826     int r;
16827     suppress_error = 0;
16828     r = guestfs_mount (g, device, mountpoint);
16829     if (r == -1)
16830       return -1;
16831   }
16832   /* TestOutputList for read_lines (1) */
16833   {
16834     char path[] = "/new";
16835     char content[] = "";
16836     int r;
16837     suppress_error = 0;
16838     r = guestfs_write_file (g, path, content, 0);
16839     if (r == -1)
16840       return -1;
16841   }
16842   {
16843     char path[] = "/new";
16844     char **r;
16845     int i;
16846     suppress_error = 0;
16847     r = guestfs_read_lines (g, path);
16848     if (r == NULL)
16849       return -1;
16850     if (r[0] != NULL) {
16851       fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
16852       print_strings (r);
16853       return -1;
16854     }
16855     for (i = 0; r[i] != NULL; ++i)
16856       free (r[i]);
16857     free (r);
16858   }
16859   return 0;
16860 }
16861
16862 static int test_lvs_0_skip (void)
16863 {
16864   const char *str;
16865
16866   str = getenv ("TEST_ONLY");
16867   if (str)
16868     return strstr (str, "lvs") == NULL;
16869   str = getenv ("SKIP_TEST_LVS_0");
16870   if (str && strcmp (str, "1") == 0) return 1;
16871   str = getenv ("SKIP_TEST_LVS");
16872   if (str && strcmp (str, "1") == 0) return 1;
16873   return 0;
16874 }
16875
16876 static int test_lvs_0 (void)
16877 {
16878   if (test_lvs_0_skip ()) {
16879     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
16880     return 0;
16881   }
16882
16883   /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
16884   {
16885     char device[] = "/dev/sda";
16886     int r;
16887     suppress_error = 0;
16888     r = guestfs_blockdev_setrw (g, device);
16889     if (r == -1)
16890       return -1;
16891   }
16892   {
16893     int r;
16894     suppress_error = 0;
16895     r = guestfs_umount_all (g);
16896     if (r == -1)
16897       return -1;
16898   }
16899   {
16900     int r;
16901     suppress_error = 0;
16902     r = guestfs_lvm_remove_all (g);
16903     if (r == -1)
16904       return -1;
16905   }
16906   {
16907     char device[] = "/dev/sda";
16908     char lines_0[] = ",";
16909     char *lines[] = {
16910       lines_0,
16911       NULL
16912     };
16913     int r;
16914     suppress_error = 0;
16915     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16916     if (r == -1)
16917       return -1;
16918   }
16919   {
16920     char device[] = "/dev/sda1";
16921     int r;
16922     suppress_error = 0;
16923     r = guestfs_pvcreate (g, device);
16924     if (r == -1)
16925       return -1;
16926   }
16927   {
16928     char volgroup[] = "VG";
16929     char physvols_0[] = "/dev/sda1";
16930     char *physvols[] = {
16931       physvols_0,
16932       NULL
16933     };
16934     int r;
16935     suppress_error = 0;
16936     r = guestfs_vgcreate (g, volgroup, physvols);
16937     if (r == -1)
16938       return -1;
16939   }
16940   {
16941     char logvol[] = "LV";
16942     char volgroup[] = "VG";
16943     int r;
16944     suppress_error = 0;
16945     r = guestfs_lvcreate (g, logvol, volgroup, 8);
16946     if (r == -1)
16947       return -1;
16948   }
16949   {
16950     char fstype[] = "ext2";
16951     char device[] = "/dev/VG/LV";
16952     int r;
16953     suppress_error = 0;
16954     r = guestfs_mkfs (g, fstype, device);
16955     if (r == -1)
16956       return -1;
16957   }
16958   {
16959     char device[] = "/dev/VG/LV";
16960     char mountpoint[] = "/";
16961     int r;
16962     suppress_error = 0;
16963     r = guestfs_mount (g, device, mountpoint);
16964     if (r == -1)
16965       return -1;
16966   }
16967   /* TestOutputList for lvs (0) */
16968   {
16969     char **r;
16970     int i;
16971     suppress_error = 0;
16972     r = guestfs_lvs (g);
16973     if (r == NULL)
16974       return -1;
16975     if (!r[0]) {
16976       fprintf (stderr, "test_lvs_0: short list returned from command\n");
16977       print_strings (r);
16978       return -1;
16979     }
16980     {
16981       char expected[] = "/dev/VG/LV";
16982       if (strcmp (r[0], expected) != 0) {
16983         fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16984         return -1;
16985       }
16986     }
16987     if (r[1] != NULL) {
16988       fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
16989       print_strings (r);
16990       return -1;
16991     }
16992     for (i = 0; r[i] != NULL; ++i)
16993       free (r[i]);
16994     free (r);
16995   }
16996   return 0;
16997 }
16998
16999 static int test_lvs_1_skip (void)
17000 {
17001   const char *str;
17002
17003   str = getenv ("TEST_ONLY");
17004   if (str)
17005     return strstr (str, "lvs") == NULL;
17006   str = getenv ("SKIP_TEST_LVS_1");
17007   if (str && strcmp (str, "1") == 0) return 1;
17008   str = getenv ("SKIP_TEST_LVS");
17009   if (str && strcmp (str, "1") == 0) return 1;
17010   return 0;
17011 }
17012
17013 static int test_lvs_1 (void)
17014 {
17015   if (test_lvs_1_skip ()) {
17016     printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
17017     return 0;
17018   }
17019
17020   /* InitNone|InitEmpty for test_lvs_1 */
17021   {
17022     char device[] = "/dev/sda";
17023     int r;
17024     suppress_error = 0;
17025     r = guestfs_blockdev_setrw (g, device);
17026     if (r == -1)
17027       return -1;
17028   }
17029   {
17030     int r;
17031     suppress_error = 0;
17032     r = guestfs_umount_all (g);
17033     if (r == -1)
17034       return -1;
17035   }
17036   {
17037     int r;
17038     suppress_error = 0;
17039     r = guestfs_lvm_remove_all (g);
17040     if (r == -1)
17041       return -1;
17042   }
17043   /* TestOutputList for lvs (1) */
17044   {
17045     char device[] = "/dev/sda";
17046     char lines_0[] = ",10";
17047     char lines_1[] = ",20";
17048     char lines_2[] = ",";
17049     char *lines[] = {
17050       lines_0,
17051       lines_1,
17052       lines_2,
17053       NULL
17054     };
17055     int r;
17056     suppress_error = 0;
17057     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17058     if (r == -1)
17059       return -1;
17060   }
17061   {
17062     char device[] = "/dev/sda1";
17063     int r;
17064     suppress_error = 0;
17065     r = guestfs_pvcreate (g, device);
17066     if (r == -1)
17067       return -1;
17068   }
17069   {
17070     char device[] = "/dev/sda2";
17071     int r;
17072     suppress_error = 0;
17073     r = guestfs_pvcreate (g, device);
17074     if (r == -1)
17075       return -1;
17076   }
17077   {
17078     char device[] = "/dev/sda3";
17079     int r;
17080     suppress_error = 0;
17081     r = guestfs_pvcreate (g, device);
17082     if (r == -1)
17083       return -1;
17084   }
17085   {
17086     char volgroup[] = "VG1";
17087     char physvols_0[] = "/dev/sda1";
17088     char physvols_1[] = "/dev/sda2";
17089     char *physvols[] = {
17090       physvols_0,
17091       physvols_1,
17092       NULL
17093     };
17094     int r;
17095     suppress_error = 0;
17096     r = guestfs_vgcreate (g, volgroup, physvols);
17097     if (r == -1)
17098       return -1;
17099   }
17100   {
17101     char volgroup[] = "VG2";
17102     char physvols_0[] = "/dev/sda3";
17103     char *physvols[] = {
17104       physvols_0,
17105       NULL
17106     };
17107     int r;
17108     suppress_error = 0;
17109     r = guestfs_vgcreate (g, volgroup, physvols);
17110     if (r == -1)
17111       return -1;
17112   }
17113   {
17114     char logvol[] = "LV1";
17115     char volgroup[] = "VG1";
17116     int r;
17117     suppress_error = 0;
17118     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17119     if (r == -1)
17120       return -1;
17121   }
17122   {
17123     char logvol[] = "LV2";
17124     char volgroup[] = "VG1";
17125     int r;
17126     suppress_error = 0;
17127     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17128     if (r == -1)
17129       return -1;
17130   }
17131   {
17132     char logvol[] = "LV3";
17133     char volgroup[] = "VG2";
17134     int r;
17135     suppress_error = 0;
17136     r = guestfs_lvcreate (g, logvol, volgroup, 50);
17137     if (r == -1)
17138       return -1;
17139   }
17140   {
17141     char **r;
17142     int i;
17143     suppress_error = 0;
17144     r = guestfs_lvs (g);
17145     if (r == NULL)
17146       return -1;
17147     if (!r[0]) {
17148       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17149       print_strings (r);
17150       return -1;
17151     }
17152     {
17153       char expected[] = "/dev/VG1/LV1";
17154       if (strcmp (r[0], expected) != 0) {
17155         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17156         return -1;
17157       }
17158     }
17159     if (!r[1]) {
17160       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17161       print_strings (r);
17162       return -1;
17163     }
17164     {
17165       char expected[] = "/dev/VG1/LV2";
17166       if (strcmp (r[1], expected) != 0) {
17167         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17168         return -1;
17169       }
17170     }
17171     if (!r[2]) {
17172       fprintf (stderr, "test_lvs_1: short list returned from command\n");
17173       print_strings (r);
17174       return -1;
17175     }
17176     {
17177       char expected[] = "/dev/VG2/LV3";
17178       if (strcmp (r[2], expected) != 0) {
17179         fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17180         return -1;
17181       }
17182     }
17183     if (r[3] != NULL) {
17184       fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17185       print_strings (r);
17186       return -1;
17187     }
17188     for (i = 0; r[i] != NULL; ++i)
17189       free (r[i]);
17190     free (r);
17191   }
17192   return 0;
17193 }
17194
17195 static int test_vgs_0_skip (void)
17196 {
17197   const char *str;
17198
17199   str = getenv ("TEST_ONLY");
17200   if (str)
17201     return strstr (str, "vgs") == NULL;
17202   str = getenv ("SKIP_TEST_VGS_0");
17203   if (str && strcmp (str, "1") == 0) return 1;
17204   str = getenv ("SKIP_TEST_VGS");
17205   if (str && strcmp (str, "1") == 0) return 1;
17206   return 0;
17207 }
17208
17209 static int test_vgs_0 (void)
17210 {
17211   if (test_vgs_0_skip ()) {
17212     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17213     return 0;
17214   }
17215
17216   /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17217   {
17218     char device[] = "/dev/sda";
17219     int r;
17220     suppress_error = 0;
17221     r = guestfs_blockdev_setrw (g, device);
17222     if (r == -1)
17223       return -1;
17224   }
17225   {
17226     int r;
17227     suppress_error = 0;
17228     r = guestfs_umount_all (g);
17229     if (r == -1)
17230       return -1;
17231   }
17232   {
17233     int r;
17234     suppress_error = 0;
17235     r = guestfs_lvm_remove_all (g);
17236     if (r == -1)
17237       return -1;
17238   }
17239   {
17240     char device[] = "/dev/sda";
17241     char lines_0[] = ",";
17242     char *lines[] = {
17243       lines_0,
17244       NULL
17245     };
17246     int r;
17247     suppress_error = 0;
17248     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17249     if (r == -1)
17250       return -1;
17251   }
17252   {
17253     char device[] = "/dev/sda1";
17254     int r;
17255     suppress_error = 0;
17256     r = guestfs_pvcreate (g, device);
17257     if (r == -1)
17258       return -1;
17259   }
17260   {
17261     char volgroup[] = "VG";
17262     char physvols_0[] = "/dev/sda1";
17263     char *physvols[] = {
17264       physvols_0,
17265       NULL
17266     };
17267     int r;
17268     suppress_error = 0;
17269     r = guestfs_vgcreate (g, volgroup, physvols);
17270     if (r == -1)
17271       return -1;
17272   }
17273   {
17274     char logvol[] = "LV";
17275     char volgroup[] = "VG";
17276     int r;
17277     suppress_error = 0;
17278     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17279     if (r == -1)
17280       return -1;
17281   }
17282   {
17283     char fstype[] = "ext2";
17284     char device[] = "/dev/VG/LV";
17285     int r;
17286     suppress_error = 0;
17287     r = guestfs_mkfs (g, fstype, device);
17288     if (r == -1)
17289       return -1;
17290   }
17291   {
17292     char device[] = "/dev/VG/LV";
17293     char mountpoint[] = "/";
17294     int r;
17295     suppress_error = 0;
17296     r = guestfs_mount (g, device, mountpoint);
17297     if (r == -1)
17298       return -1;
17299   }
17300   /* TestOutputList for vgs (0) */
17301   {
17302     char **r;
17303     int i;
17304     suppress_error = 0;
17305     r = guestfs_vgs (g);
17306     if (r == NULL)
17307       return -1;
17308     if (!r[0]) {
17309       fprintf (stderr, "test_vgs_0: short list returned from command\n");
17310       print_strings (r);
17311       return -1;
17312     }
17313     {
17314       char expected[] = "VG";
17315       if (strcmp (r[0], expected) != 0) {
17316         fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17317         return -1;
17318       }
17319     }
17320     if (r[1] != NULL) {
17321       fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17322       print_strings (r);
17323       return -1;
17324     }
17325     for (i = 0; r[i] != NULL; ++i)
17326       free (r[i]);
17327     free (r);
17328   }
17329   return 0;
17330 }
17331
17332 static int test_vgs_1_skip (void)
17333 {
17334   const char *str;
17335
17336   str = getenv ("TEST_ONLY");
17337   if (str)
17338     return strstr (str, "vgs") == NULL;
17339   str = getenv ("SKIP_TEST_VGS_1");
17340   if (str && strcmp (str, "1") == 0) return 1;
17341   str = getenv ("SKIP_TEST_VGS");
17342   if (str && strcmp (str, "1") == 0) return 1;
17343   return 0;
17344 }
17345
17346 static int test_vgs_1 (void)
17347 {
17348   if (test_vgs_1_skip ()) {
17349     printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17350     return 0;
17351   }
17352
17353   /* InitNone|InitEmpty for test_vgs_1 */
17354   {
17355     char device[] = "/dev/sda";
17356     int r;
17357     suppress_error = 0;
17358     r = guestfs_blockdev_setrw (g, device);
17359     if (r == -1)
17360       return -1;
17361   }
17362   {
17363     int r;
17364     suppress_error = 0;
17365     r = guestfs_umount_all (g);
17366     if (r == -1)
17367       return -1;
17368   }
17369   {
17370     int r;
17371     suppress_error = 0;
17372     r = guestfs_lvm_remove_all (g);
17373     if (r == -1)
17374       return -1;
17375   }
17376   /* TestOutputList for vgs (1) */
17377   {
17378     char device[] = "/dev/sda";
17379     char lines_0[] = ",10";
17380     char lines_1[] = ",20";
17381     char lines_2[] = ",";
17382     char *lines[] = {
17383       lines_0,
17384       lines_1,
17385       lines_2,
17386       NULL
17387     };
17388     int r;
17389     suppress_error = 0;
17390     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17391     if (r == -1)
17392       return -1;
17393   }
17394   {
17395     char device[] = "/dev/sda1";
17396     int r;
17397     suppress_error = 0;
17398     r = guestfs_pvcreate (g, device);
17399     if (r == -1)
17400       return -1;
17401   }
17402   {
17403     char device[] = "/dev/sda2";
17404     int r;
17405     suppress_error = 0;
17406     r = guestfs_pvcreate (g, device);
17407     if (r == -1)
17408       return -1;
17409   }
17410   {
17411     char device[] = "/dev/sda3";
17412     int r;
17413     suppress_error = 0;
17414     r = guestfs_pvcreate (g, device);
17415     if (r == -1)
17416       return -1;
17417   }
17418   {
17419     char volgroup[] = "VG1";
17420     char physvols_0[] = "/dev/sda1";
17421     char physvols_1[] = "/dev/sda2";
17422     char *physvols[] = {
17423       physvols_0,
17424       physvols_1,
17425       NULL
17426     };
17427     int r;
17428     suppress_error = 0;
17429     r = guestfs_vgcreate (g, volgroup, physvols);
17430     if (r == -1)
17431       return -1;
17432   }
17433   {
17434     char volgroup[] = "VG2";
17435     char physvols_0[] = "/dev/sda3";
17436     char *physvols[] = {
17437       physvols_0,
17438       NULL
17439     };
17440     int r;
17441     suppress_error = 0;
17442     r = guestfs_vgcreate (g, volgroup, physvols);
17443     if (r == -1)
17444       return -1;
17445   }
17446   {
17447     char **r;
17448     int i;
17449     suppress_error = 0;
17450     r = guestfs_vgs (g);
17451     if (r == NULL)
17452       return -1;
17453     if (!r[0]) {
17454       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17455       print_strings (r);
17456       return -1;
17457     }
17458     {
17459       char expected[] = "VG1";
17460       if (strcmp (r[0], expected) != 0) {
17461         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17462         return -1;
17463       }
17464     }
17465     if (!r[1]) {
17466       fprintf (stderr, "test_vgs_1: short list returned from command\n");
17467       print_strings (r);
17468       return -1;
17469     }
17470     {
17471       char expected[] = "VG2";
17472       if (strcmp (r[1], expected) != 0) {
17473         fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17474         return -1;
17475       }
17476     }
17477     if (r[2] != NULL) {
17478       fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17479       print_strings (r);
17480       return -1;
17481     }
17482     for (i = 0; r[i] != NULL; ++i)
17483       free (r[i]);
17484     free (r);
17485   }
17486   return 0;
17487 }
17488
17489 static int test_pvs_0_skip (void)
17490 {
17491   const char *str;
17492
17493   str = getenv ("TEST_ONLY");
17494   if (str)
17495     return strstr (str, "pvs") == NULL;
17496   str = getenv ("SKIP_TEST_PVS_0");
17497   if (str && strcmp (str, "1") == 0) return 1;
17498   str = getenv ("SKIP_TEST_PVS");
17499   if (str && strcmp (str, "1") == 0) return 1;
17500   return 0;
17501 }
17502
17503 static int test_pvs_0 (void)
17504 {
17505   if (test_pvs_0_skip ()) {
17506     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17507     return 0;
17508   }
17509
17510   /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17511   {
17512     char device[] = "/dev/sda";
17513     int r;
17514     suppress_error = 0;
17515     r = guestfs_blockdev_setrw (g, device);
17516     if (r == -1)
17517       return -1;
17518   }
17519   {
17520     int r;
17521     suppress_error = 0;
17522     r = guestfs_umount_all (g);
17523     if (r == -1)
17524       return -1;
17525   }
17526   {
17527     int r;
17528     suppress_error = 0;
17529     r = guestfs_lvm_remove_all (g);
17530     if (r == -1)
17531       return -1;
17532   }
17533   {
17534     char device[] = "/dev/sda";
17535     char lines_0[] = ",";
17536     char *lines[] = {
17537       lines_0,
17538       NULL
17539     };
17540     int r;
17541     suppress_error = 0;
17542     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17543     if (r == -1)
17544       return -1;
17545   }
17546   {
17547     char device[] = "/dev/sda1";
17548     int r;
17549     suppress_error = 0;
17550     r = guestfs_pvcreate (g, device);
17551     if (r == -1)
17552       return -1;
17553   }
17554   {
17555     char volgroup[] = "VG";
17556     char physvols_0[] = "/dev/sda1";
17557     char *physvols[] = {
17558       physvols_0,
17559       NULL
17560     };
17561     int r;
17562     suppress_error = 0;
17563     r = guestfs_vgcreate (g, volgroup, physvols);
17564     if (r == -1)
17565       return -1;
17566   }
17567   {
17568     char logvol[] = "LV";
17569     char volgroup[] = "VG";
17570     int r;
17571     suppress_error = 0;
17572     r = guestfs_lvcreate (g, logvol, volgroup, 8);
17573     if (r == -1)
17574       return -1;
17575   }
17576   {
17577     char fstype[] = "ext2";
17578     char device[] = "/dev/VG/LV";
17579     int r;
17580     suppress_error = 0;
17581     r = guestfs_mkfs (g, fstype, device);
17582     if (r == -1)
17583       return -1;
17584   }
17585   {
17586     char device[] = "/dev/VG/LV";
17587     char mountpoint[] = "/";
17588     int r;
17589     suppress_error = 0;
17590     r = guestfs_mount (g, device, mountpoint);
17591     if (r == -1)
17592       return -1;
17593   }
17594   /* TestOutputListOfDevices for pvs (0) */
17595   {
17596     char **r;
17597     int i;
17598     suppress_error = 0;
17599     r = guestfs_pvs (g);
17600     if (r == NULL)
17601       return -1;
17602     if (!r[0]) {
17603       fprintf (stderr, "test_pvs_0: short list returned from command\n");
17604       print_strings (r);
17605       return -1;
17606     }
17607     {
17608       char expected[] = "/dev/sda1";
17609       r[0][5] = 's';
17610       if (strcmp (r[0], expected) != 0) {
17611         fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17612         return -1;
17613       }
17614     }
17615     if (r[1] != NULL) {
17616       fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17617       print_strings (r);
17618       return -1;
17619     }
17620     for (i = 0; r[i] != NULL; ++i)
17621       free (r[i]);
17622     free (r);
17623   }
17624   return 0;
17625 }
17626
17627 static int test_pvs_1_skip (void)
17628 {
17629   const char *str;
17630
17631   str = getenv ("TEST_ONLY");
17632   if (str)
17633     return strstr (str, "pvs") == NULL;
17634   str = getenv ("SKIP_TEST_PVS_1");
17635   if (str && strcmp (str, "1") == 0) return 1;
17636   str = getenv ("SKIP_TEST_PVS");
17637   if (str && strcmp (str, "1") == 0) return 1;
17638   return 0;
17639 }
17640
17641 static int test_pvs_1 (void)
17642 {
17643   if (test_pvs_1_skip ()) {
17644     printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17645     return 0;
17646   }
17647
17648   /* InitNone|InitEmpty for test_pvs_1 */
17649   {
17650     char device[] = "/dev/sda";
17651     int r;
17652     suppress_error = 0;
17653     r = guestfs_blockdev_setrw (g, device);
17654     if (r == -1)
17655       return -1;
17656   }
17657   {
17658     int r;
17659     suppress_error = 0;
17660     r = guestfs_umount_all (g);
17661     if (r == -1)
17662       return -1;
17663   }
17664   {
17665     int r;
17666     suppress_error = 0;
17667     r = guestfs_lvm_remove_all (g);
17668     if (r == -1)
17669       return -1;
17670   }
17671   /* TestOutputListOfDevices for pvs (1) */
17672   {
17673     char device[] = "/dev/sda";
17674     char lines_0[] = ",10";
17675     char lines_1[] = ",20";
17676     char lines_2[] = ",";
17677     char *lines[] = {
17678       lines_0,
17679       lines_1,
17680       lines_2,
17681       NULL
17682     };
17683     int r;
17684     suppress_error = 0;
17685     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17686     if (r == -1)
17687       return -1;
17688   }
17689   {
17690     char device[] = "/dev/sda1";
17691     int r;
17692     suppress_error = 0;
17693     r = guestfs_pvcreate (g, device);
17694     if (r == -1)
17695       return -1;
17696   }
17697   {
17698     char device[] = "/dev/sda2";
17699     int r;
17700     suppress_error = 0;
17701     r = guestfs_pvcreate (g, device);
17702     if (r == -1)
17703       return -1;
17704   }
17705   {
17706     char device[] = "/dev/sda3";
17707     int r;
17708     suppress_error = 0;
17709     r = guestfs_pvcreate (g, device);
17710     if (r == -1)
17711       return -1;
17712   }
17713   {
17714     char **r;
17715     int i;
17716     suppress_error = 0;
17717     r = guestfs_pvs (g);
17718     if (r == NULL)
17719       return -1;
17720     if (!r[0]) {
17721       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17722       print_strings (r);
17723       return -1;
17724     }
17725     {
17726       char expected[] = "/dev/sda1";
17727       r[0][5] = 's';
17728       if (strcmp (r[0], expected) != 0) {
17729         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17730         return -1;
17731       }
17732     }
17733     if (!r[1]) {
17734       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17735       print_strings (r);
17736       return -1;
17737     }
17738     {
17739       char expected[] = "/dev/sda2";
17740       r[1][5] = 's';
17741       if (strcmp (r[1], expected) != 0) {
17742         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17743         return -1;
17744       }
17745     }
17746     if (!r[2]) {
17747       fprintf (stderr, "test_pvs_1: short list returned from command\n");
17748       print_strings (r);
17749       return -1;
17750     }
17751     {
17752       char expected[] = "/dev/sda3";
17753       r[2][5] = 's';
17754       if (strcmp (r[2], expected) != 0) {
17755         fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17756         return -1;
17757       }
17758     }
17759     if (r[3] != NULL) {
17760       fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17761       print_strings (r);
17762       return -1;
17763     }
17764     for (i = 0; r[i] != NULL; ++i)
17765       free (r[i]);
17766     free (r);
17767   }
17768   return 0;
17769 }
17770
17771 static int test_list_partitions_0_skip (void)
17772 {
17773   const char *str;
17774
17775   str = getenv ("TEST_ONLY");
17776   if (str)
17777     return strstr (str, "list_partitions") == NULL;
17778   str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17779   if (str && strcmp (str, "1") == 0) return 1;
17780   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17781   if (str && strcmp (str, "1") == 0) return 1;
17782   return 0;
17783 }
17784
17785 static int test_list_partitions_0 (void)
17786 {
17787   if (test_list_partitions_0_skip ()) {
17788     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
17789     return 0;
17790   }
17791
17792   /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
17793   {
17794     char device[] = "/dev/sda";
17795     int r;
17796     suppress_error = 0;
17797     r = guestfs_blockdev_setrw (g, device);
17798     if (r == -1)
17799       return -1;
17800   }
17801   {
17802     int r;
17803     suppress_error = 0;
17804     r = guestfs_umount_all (g);
17805     if (r == -1)
17806       return -1;
17807   }
17808   {
17809     int r;
17810     suppress_error = 0;
17811     r = guestfs_lvm_remove_all (g);
17812     if (r == -1)
17813       return -1;
17814   }
17815   {
17816     char device[] = "/dev/sda";
17817     char lines_0[] = ",";
17818     char *lines[] = {
17819       lines_0,
17820       NULL
17821     };
17822     int r;
17823     suppress_error = 0;
17824     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17825     if (r == -1)
17826       return -1;
17827   }
17828   {
17829     char fstype[] = "ext2";
17830     char device[] = "/dev/sda1";
17831     int r;
17832     suppress_error = 0;
17833     r = guestfs_mkfs (g, fstype, device);
17834     if (r == -1)
17835       return -1;
17836   }
17837   {
17838     char device[] = "/dev/sda1";
17839     char mountpoint[] = "/";
17840     int r;
17841     suppress_error = 0;
17842     r = guestfs_mount (g, device, mountpoint);
17843     if (r == -1)
17844       return -1;
17845   }
17846   /* TestOutputListOfDevices for list_partitions (0) */
17847   {
17848     char **r;
17849     int i;
17850     suppress_error = 0;
17851     r = guestfs_list_partitions (g);
17852     if (r == NULL)
17853       return -1;
17854     if (!r[0]) {
17855       fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
17856       print_strings (r);
17857       return -1;
17858     }
17859     {
17860       char expected[] = "/dev/sda1";
17861       r[0][5] = 's';
17862       if (strcmp (r[0], expected) != 0) {
17863         fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17864         return -1;
17865       }
17866     }
17867     if (r[1] != NULL) {
17868       fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
17869       print_strings (r);
17870       return -1;
17871     }
17872     for (i = 0; r[i] != NULL; ++i)
17873       free (r[i]);
17874     free (r);
17875   }
17876   return 0;
17877 }
17878
17879 static int test_list_partitions_1_skip (void)
17880 {
17881   const char *str;
17882
17883   str = getenv ("TEST_ONLY");
17884   if (str)
17885     return strstr (str, "list_partitions") == NULL;
17886   str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
17887   if (str && strcmp (str, "1") == 0) return 1;
17888   str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17889   if (str && strcmp (str, "1") == 0) return 1;
17890   return 0;
17891 }
17892
17893 static int test_list_partitions_1 (void)
17894 {
17895   if (test_list_partitions_1_skip ()) {
17896     printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
17897     return 0;
17898   }
17899
17900   /* InitNone|InitEmpty for test_list_partitions_1 */
17901   {
17902     char device[] = "/dev/sda";
17903     int r;
17904     suppress_error = 0;
17905     r = guestfs_blockdev_setrw (g, device);
17906     if (r == -1)
17907       return -1;
17908   }
17909   {
17910     int r;
17911     suppress_error = 0;
17912     r = guestfs_umount_all (g);
17913     if (r == -1)
17914       return -1;
17915   }
17916   {
17917     int r;
17918     suppress_error = 0;
17919     r = guestfs_lvm_remove_all (g);
17920     if (r == -1)
17921       return -1;
17922   }
17923   /* TestOutputListOfDevices for list_partitions (1) */
17924   {
17925     char device[] = "/dev/sda";
17926     char lines_0[] = ",10";
17927     char lines_1[] = ",20";
17928     char lines_2[] = ",";
17929     char *lines[] = {
17930       lines_0,
17931       lines_1,
17932       lines_2,
17933       NULL
17934     };
17935     int r;
17936     suppress_error = 0;
17937     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17938     if (r == -1)
17939       return -1;
17940   }
17941   {
17942     char **r;
17943     int i;
17944     suppress_error = 0;
17945     r = guestfs_list_partitions (g);
17946     if (r == NULL)
17947       return -1;
17948     if (!r[0]) {
17949       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17950       print_strings (r);
17951       return -1;
17952     }
17953     {
17954       char expected[] = "/dev/sda1";
17955       r[0][5] = 's';
17956       if (strcmp (r[0], expected) != 0) {
17957         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17958         return -1;
17959       }
17960     }
17961     if (!r[1]) {
17962       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17963       print_strings (r);
17964       return -1;
17965     }
17966     {
17967       char expected[] = "/dev/sda2";
17968       r[1][5] = 's';
17969       if (strcmp (r[1], expected) != 0) {
17970         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17971         return -1;
17972       }
17973     }
17974     if (!r[2]) {
17975       fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17976       print_strings (r);
17977       return -1;
17978     }
17979     {
17980       char expected[] = "/dev/sda3";
17981       r[2][5] = 's';
17982       if (strcmp (r[2], expected) != 0) {
17983         fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17984         return -1;
17985       }
17986     }
17987     if (r[3] != NULL) {
17988       fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
17989       print_strings (r);
17990       return -1;
17991     }
17992     for (i = 0; r[i] != NULL; ++i)
17993       free (r[i]);
17994     free (r);
17995   }
17996   return 0;
17997 }
17998
17999 static int test_list_devices_0_skip (void)
18000 {
18001   const char *str;
18002
18003   str = getenv ("TEST_ONLY");
18004   if (str)
18005     return strstr (str, "list_devices") == NULL;
18006   str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18007   if (str && strcmp (str, "1") == 0) return 1;
18008   str = getenv ("SKIP_TEST_LIST_DEVICES");
18009   if (str && strcmp (str, "1") == 0) return 1;
18010   return 0;
18011 }
18012
18013 static int test_list_devices_0 (void)
18014 {
18015   if (test_list_devices_0_skip ()) {
18016     printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
18017     return 0;
18018   }
18019
18020   /* InitNone|InitEmpty for test_list_devices_0 */
18021   {
18022     char device[] = "/dev/sda";
18023     int r;
18024     suppress_error = 0;
18025     r = guestfs_blockdev_setrw (g, device);
18026     if (r == -1)
18027       return -1;
18028   }
18029   {
18030     int r;
18031     suppress_error = 0;
18032     r = guestfs_umount_all (g);
18033     if (r == -1)
18034       return -1;
18035   }
18036   {
18037     int r;
18038     suppress_error = 0;
18039     r = guestfs_lvm_remove_all (g);
18040     if (r == -1)
18041       return -1;
18042   }
18043   /* TestOutputListOfDevices for list_devices (0) */
18044   {
18045     char **r;
18046     int i;
18047     suppress_error = 0;
18048     r = guestfs_list_devices (g);
18049     if (r == NULL)
18050       return -1;
18051     if (!r[0]) {
18052       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18053       print_strings (r);
18054       return -1;
18055     }
18056     {
18057       char expected[] = "/dev/sda";
18058       r[0][5] = 's';
18059       if (strcmp (r[0], expected) != 0) {
18060         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18061         return -1;
18062       }
18063     }
18064     if (!r[1]) {
18065       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18066       print_strings (r);
18067       return -1;
18068     }
18069     {
18070       char expected[] = "/dev/sdb";
18071       r[1][5] = 's';
18072       if (strcmp (r[1], expected) != 0) {
18073         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18074         return -1;
18075       }
18076     }
18077     if (!r[2]) {
18078       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18079       print_strings (r);
18080       return -1;
18081     }
18082     {
18083       char expected[] = "/dev/sdc";
18084       r[2][5] = 's';
18085       if (strcmp (r[2], expected) != 0) {
18086         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18087         return -1;
18088       }
18089     }
18090     if (!r[3]) {
18091       fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18092       print_strings (r);
18093       return -1;
18094     }
18095     {
18096       char expected[] = "/dev/sdd";
18097       r[3][5] = 's';
18098       if (strcmp (r[3], expected) != 0) {
18099         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18100         return -1;
18101       }
18102     }
18103     if (r[4] != NULL) {
18104       fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18105       print_strings (r);
18106       return -1;
18107     }
18108     for (i = 0; r[i] != NULL; ++i)
18109       free (r[i]);
18110     free (r);
18111   }
18112   return 0;
18113 }
18114
18115 static int test_ls_0_skip (void)
18116 {
18117   const char *str;
18118
18119   str = getenv ("TEST_ONLY");
18120   if (str)
18121     return strstr (str, "ls") == NULL;
18122   str = getenv ("SKIP_TEST_LS_0");
18123   if (str && strcmp (str, "1") == 0) return 1;
18124   str = getenv ("SKIP_TEST_LS");
18125   if (str && strcmp (str, "1") == 0) return 1;
18126   return 0;
18127 }
18128
18129 static int test_ls_0 (void)
18130 {
18131   if (test_ls_0_skip ()) {
18132     printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
18133     return 0;
18134   }
18135
18136   /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18137   {
18138     char device[] = "/dev/sda";
18139     int r;
18140     suppress_error = 0;
18141     r = guestfs_blockdev_setrw (g, device);
18142     if (r == -1)
18143       return -1;
18144   }
18145   {
18146     int r;
18147     suppress_error = 0;
18148     r = guestfs_umount_all (g);
18149     if (r == -1)
18150       return -1;
18151   }
18152   {
18153     int r;
18154     suppress_error = 0;
18155     r = guestfs_lvm_remove_all (g);
18156     if (r == -1)
18157       return -1;
18158   }
18159   {
18160     char device[] = "/dev/sda";
18161     char lines_0[] = ",";
18162     char *lines[] = {
18163       lines_0,
18164       NULL
18165     };
18166     int r;
18167     suppress_error = 0;
18168     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18169     if (r == -1)
18170       return -1;
18171   }
18172   {
18173     char fstype[] = "ext2";
18174     char device[] = "/dev/sda1";
18175     int r;
18176     suppress_error = 0;
18177     r = guestfs_mkfs (g, fstype, device);
18178     if (r == -1)
18179       return -1;
18180   }
18181   {
18182     char device[] = "/dev/sda1";
18183     char mountpoint[] = "/";
18184     int r;
18185     suppress_error = 0;
18186     r = guestfs_mount (g, device, mountpoint);
18187     if (r == -1)
18188       return -1;
18189   }
18190   /* TestOutputList for ls (0) */
18191   {
18192     char path[] = "/new";
18193     int r;
18194     suppress_error = 0;
18195     r = guestfs_touch (g, path);
18196     if (r == -1)
18197       return -1;
18198   }
18199   {
18200     char path[] = "/newer";
18201     int r;
18202     suppress_error = 0;
18203     r = guestfs_touch (g, path);
18204     if (r == -1)
18205       return -1;
18206   }
18207   {
18208     char path[] = "/newest";
18209     int r;
18210     suppress_error = 0;
18211     r = guestfs_touch (g, path);
18212     if (r == -1)
18213       return -1;
18214   }
18215   {
18216     char directory[] = "/";
18217     char **r;
18218     int i;
18219     suppress_error = 0;
18220     r = guestfs_ls (g, directory);
18221     if (r == NULL)
18222       return -1;
18223     if (!r[0]) {
18224       fprintf (stderr, "test_ls_0: short list returned from command\n");
18225       print_strings (r);
18226       return -1;
18227     }
18228     {
18229       char expected[] = "lost+found";
18230       if (strcmp (r[0], expected) != 0) {
18231         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18232         return -1;
18233       }
18234     }
18235     if (!r[1]) {
18236       fprintf (stderr, "test_ls_0: short list returned from command\n");
18237       print_strings (r);
18238       return -1;
18239     }
18240     {
18241       char expected[] = "new";
18242       if (strcmp (r[1], expected) != 0) {
18243         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18244         return -1;
18245       }
18246     }
18247     if (!r[2]) {
18248       fprintf (stderr, "test_ls_0: short list returned from command\n");
18249       print_strings (r);
18250       return -1;
18251     }
18252     {
18253       char expected[] = "newer";
18254       if (strcmp (r[2], expected) != 0) {
18255         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18256         return -1;
18257       }
18258     }
18259     if (!r[3]) {
18260       fprintf (stderr, "test_ls_0: short list returned from command\n");
18261       print_strings (r);
18262       return -1;
18263     }
18264     {
18265       char expected[] = "newest";
18266       if (strcmp (r[3], expected) != 0) {
18267         fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18268         return -1;
18269       }
18270     }
18271     if (r[4] != NULL) {
18272       fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18273       print_strings (r);
18274       return -1;
18275     }
18276     for (i = 0; r[i] != NULL; ++i)
18277       free (r[i]);
18278     free (r);
18279   }
18280   return 0;
18281 }
18282
18283 static int test_cat_0_skip (void)
18284 {
18285   const char *str;
18286
18287   str = getenv ("TEST_ONLY");
18288   if (str)
18289     return strstr (str, "cat") == NULL;
18290   str = getenv ("SKIP_TEST_CAT_0");
18291   if (str && strcmp (str, "1") == 0) return 1;
18292   str = getenv ("SKIP_TEST_CAT");
18293   if (str && strcmp (str, "1") == 0) return 1;
18294   return 0;
18295 }
18296
18297 static int test_cat_0 (void)
18298 {
18299   if (test_cat_0_skip ()) {
18300     printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18301     return 0;
18302   }
18303
18304   /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18305   {
18306     char device[] = "/dev/sda";
18307     int r;
18308     suppress_error = 0;
18309     r = guestfs_blockdev_setrw (g, device);
18310     if (r == -1)
18311       return -1;
18312   }
18313   {
18314     int r;
18315     suppress_error = 0;
18316     r = guestfs_umount_all (g);
18317     if (r == -1)
18318       return -1;
18319   }
18320   {
18321     int r;
18322     suppress_error = 0;
18323     r = guestfs_lvm_remove_all (g);
18324     if (r == -1)
18325       return -1;
18326   }
18327   {
18328     char device[] = "/dev/sda";
18329     char lines_0[] = ",";
18330     char *lines[] = {
18331       lines_0,
18332       NULL
18333     };
18334     int r;
18335     suppress_error = 0;
18336     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18337     if (r == -1)
18338       return -1;
18339   }
18340   {
18341     char fstype[] = "ext2";
18342     char device[] = "/dev/sda1";
18343     int r;
18344     suppress_error = 0;
18345     r = guestfs_mkfs (g, fstype, device);
18346     if (r == -1)
18347       return -1;
18348   }
18349   {
18350     char device[] = "/dev/sda1";
18351     char mountpoint[] = "/";
18352     int r;
18353     suppress_error = 0;
18354     r = guestfs_mount (g, device, mountpoint);
18355     if (r == -1)
18356       return -1;
18357   }
18358   /* TestOutput for cat (0) */
18359   char expected[] = "new file contents";
18360   {
18361     char path[] = "/new";
18362     char content[] = "new file contents";
18363     int r;
18364     suppress_error = 0;
18365     r = guestfs_write_file (g, path, content, 0);
18366     if (r == -1)
18367       return -1;
18368   }
18369   {
18370     char path[] = "/new";
18371     char *r;
18372     suppress_error = 0;
18373     r = guestfs_cat (g, path);
18374     if (r == NULL)
18375       return -1;
18376     if (strcmp (r, expected) != 0) {
18377       fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18378       return -1;
18379     }
18380     free (r);
18381   }
18382   return 0;
18383 }
18384
18385 static int test_touch_0_skip (void)
18386 {
18387   const char *str;
18388
18389   str = getenv ("TEST_ONLY");
18390   if (str)
18391     return strstr (str, "touch") == NULL;
18392   str = getenv ("SKIP_TEST_TOUCH_0");
18393   if (str && strcmp (str, "1") == 0) return 1;
18394   str = getenv ("SKIP_TEST_TOUCH");
18395   if (str && strcmp (str, "1") == 0) return 1;
18396   return 0;
18397 }
18398
18399 static int test_touch_0 (void)
18400 {
18401   if (test_touch_0_skip ()) {
18402     printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18403     return 0;
18404   }
18405
18406   /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18407   {
18408     char device[] = "/dev/sda";
18409     int r;
18410     suppress_error = 0;
18411     r = guestfs_blockdev_setrw (g, device);
18412     if (r == -1)
18413       return -1;
18414   }
18415   {
18416     int r;
18417     suppress_error = 0;
18418     r = guestfs_umount_all (g);
18419     if (r == -1)
18420       return -1;
18421   }
18422   {
18423     int r;
18424     suppress_error = 0;
18425     r = guestfs_lvm_remove_all (g);
18426     if (r == -1)
18427       return -1;
18428   }
18429   {
18430     char device[] = "/dev/sda";
18431     char lines_0[] = ",";
18432     char *lines[] = {
18433       lines_0,
18434       NULL
18435     };
18436     int r;
18437     suppress_error = 0;
18438     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18439     if (r == -1)
18440       return -1;
18441   }
18442   {
18443     char fstype[] = "ext2";
18444     char device[] = "/dev/sda1";
18445     int r;
18446     suppress_error = 0;
18447     r = guestfs_mkfs (g, fstype, device);
18448     if (r == -1)
18449       return -1;
18450   }
18451   {
18452     char device[] = "/dev/sda1";
18453     char mountpoint[] = "/";
18454     int r;
18455     suppress_error = 0;
18456     r = guestfs_mount (g, device, mountpoint);
18457     if (r == -1)
18458       return -1;
18459   }
18460   /* TestOutputTrue for touch (0) */
18461   {
18462     char path[] = "/new";
18463     int r;
18464     suppress_error = 0;
18465     r = guestfs_touch (g, path);
18466     if (r == -1)
18467       return -1;
18468   }
18469   {
18470     char path[] = "/new";
18471     int r;
18472     suppress_error = 0;
18473     r = guestfs_exists (g, path);
18474     if (r == -1)
18475       return -1;
18476     if (!r) {
18477       fprintf (stderr, "test_touch_0: expected true, got false\n");
18478       return -1;
18479     }
18480   }
18481   return 0;
18482 }
18483
18484 static int test_sync_0_skip (void)
18485 {
18486   const char *str;
18487
18488   str = getenv ("TEST_ONLY");
18489   if (str)
18490     return strstr (str, "sync") == NULL;
18491   str = getenv ("SKIP_TEST_SYNC_0");
18492   if (str && strcmp (str, "1") == 0) return 1;
18493   str = getenv ("SKIP_TEST_SYNC");
18494   if (str && strcmp (str, "1") == 0) return 1;
18495   return 0;
18496 }
18497
18498 static int test_sync_0 (void)
18499 {
18500   if (test_sync_0_skip ()) {
18501     printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18502     return 0;
18503   }
18504
18505   /* InitNone|InitEmpty for test_sync_0 */
18506   {
18507     char device[] = "/dev/sda";
18508     int r;
18509     suppress_error = 0;
18510     r = guestfs_blockdev_setrw (g, device);
18511     if (r == -1)
18512       return -1;
18513   }
18514   {
18515     int r;
18516     suppress_error = 0;
18517     r = guestfs_umount_all (g);
18518     if (r == -1)
18519       return -1;
18520   }
18521   {
18522     int r;
18523     suppress_error = 0;
18524     r = guestfs_lvm_remove_all (g);
18525     if (r == -1)
18526       return -1;
18527   }
18528   /* TestRun for sync (0) */
18529   {
18530     int r;
18531     suppress_error = 0;
18532     r = guestfs_sync (g);
18533     if (r == -1)
18534       return -1;
18535   }
18536   return 0;
18537 }
18538
18539 static int test_mount_0_skip (void)
18540 {
18541   const char *str;
18542
18543   str = getenv ("TEST_ONLY");
18544   if (str)
18545     return strstr (str, "mount") == NULL;
18546   str = getenv ("SKIP_TEST_MOUNT_0");
18547   if (str && strcmp (str, "1") == 0) return 1;
18548   str = getenv ("SKIP_TEST_MOUNT");
18549   if (str && strcmp (str, "1") == 0) return 1;
18550   return 0;
18551 }
18552
18553 static int test_mount_0 (void)
18554 {
18555   if (test_mount_0_skip ()) {
18556     printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18557     return 0;
18558   }
18559
18560   /* InitNone|InitEmpty for test_mount_0 */
18561   {
18562     char device[] = "/dev/sda";
18563     int r;
18564     suppress_error = 0;
18565     r = guestfs_blockdev_setrw (g, device);
18566     if (r == -1)
18567       return -1;
18568   }
18569   {
18570     int r;
18571     suppress_error = 0;
18572     r = guestfs_umount_all (g);
18573     if (r == -1)
18574       return -1;
18575   }
18576   {
18577     int r;
18578     suppress_error = 0;
18579     r = guestfs_lvm_remove_all (g);
18580     if (r == -1)
18581       return -1;
18582   }
18583   /* TestOutput for mount (0) */
18584   char expected[] = "new file contents";
18585   {
18586     char device[] = "/dev/sda";
18587     char lines_0[] = ",";
18588     char *lines[] = {
18589       lines_0,
18590       NULL
18591     };
18592     int r;
18593     suppress_error = 0;
18594     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18595     if (r == -1)
18596       return -1;
18597   }
18598   {
18599     char fstype[] = "ext2";
18600     char device[] = "/dev/sda1";
18601     int r;
18602     suppress_error = 0;
18603     r = guestfs_mkfs (g, fstype, device);
18604     if (r == -1)
18605       return -1;
18606   }
18607   {
18608     char device[] = "/dev/sda1";
18609     char mountpoint[] = "/";
18610     int r;
18611     suppress_error = 0;
18612     r = guestfs_mount (g, device, mountpoint);
18613     if (r == -1)
18614       return -1;
18615   }
18616   {
18617     char path[] = "/new";
18618     char content[] = "new file contents";
18619     int r;
18620     suppress_error = 0;
18621     r = guestfs_write_file (g, path, content, 0);
18622     if (r == -1)
18623       return -1;
18624   }
18625   {
18626     char path[] = "/new";
18627     char *r;
18628     suppress_error = 0;
18629     r = guestfs_cat (g, path);
18630     if (r == NULL)
18631       return -1;
18632     if (strcmp (r, expected) != 0) {
18633       fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18634       return -1;
18635     }
18636     free (r);
18637   }
18638   return 0;
18639 }
18640
18641 int main (int argc, char *argv[])
18642 {
18643   char c = 0;
18644   int failed = 0;
18645   const char *filename;
18646   int fd;
18647   int nr_tests, test_num = 0;
18648
18649   no_test_warnings ();
18650
18651   g = guestfs_create ();
18652   if (g == NULL) {
18653     printf ("guestfs_create FAILED\n");
18654     exit (1);
18655   }
18656
18657   guestfs_set_error_handler (g, print_error, NULL);
18658
18659   guestfs_set_path (g, "../appliance");
18660
18661   filename = "test1.img";
18662   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18663   if (fd == -1) {
18664     perror (filename);
18665     exit (1);
18666   }
18667   if (lseek (fd, 524288000, SEEK_SET) == -1) {
18668     perror ("lseek");
18669     close (fd);
18670     unlink (filename);
18671     exit (1);
18672   }
18673   if (write (fd, &c, 1) == -1) {
18674     perror ("write");
18675     close (fd);
18676     unlink (filename);
18677     exit (1);
18678   }
18679   if (close (fd) == -1) {
18680     perror (filename);
18681     unlink (filename);
18682     exit (1);
18683   }
18684   if (guestfs_add_drive (g, filename) == -1) {
18685     printf ("guestfs_add_drive %s FAILED\n", filename);
18686     exit (1);
18687   }
18688
18689   filename = "test2.img";
18690   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18691   if (fd == -1) {
18692     perror (filename);
18693     exit (1);
18694   }
18695   if (lseek (fd, 52428800, SEEK_SET) == -1) {
18696     perror ("lseek");
18697     close (fd);
18698     unlink (filename);
18699     exit (1);
18700   }
18701   if (write (fd, &c, 1) == -1) {
18702     perror ("write");
18703     close (fd);
18704     unlink (filename);
18705     exit (1);
18706   }
18707   if (close (fd) == -1) {
18708     perror (filename);
18709     unlink (filename);
18710     exit (1);
18711   }
18712   if (guestfs_add_drive (g, filename) == -1) {
18713     printf ("guestfs_add_drive %s FAILED\n", filename);
18714     exit (1);
18715   }
18716
18717   filename = "test3.img";
18718   fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18719   if (fd == -1) {
18720     perror (filename);
18721     exit (1);
18722   }
18723   if (lseek (fd, 10485760, SEEK_SET) == -1) {
18724     perror ("lseek");
18725     close (fd);
18726     unlink (filename);
18727     exit (1);
18728   }
18729   if (write (fd, &c, 1) == -1) {
18730     perror ("write");
18731     close (fd);
18732     unlink (filename);
18733     exit (1);
18734   }
18735   if (close (fd) == -1) {
18736     perror (filename);
18737     unlink (filename);
18738     exit (1);
18739   }
18740   if (guestfs_add_drive (g, filename) == -1) {
18741     printf ("guestfs_add_drive %s FAILED\n", filename);
18742     exit (1);
18743   }
18744
18745   if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18746     printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18747     exit (1);
18748   }
18749
18750   if (guestfs_launch (g) == -1) {
18751     printf ("guestfs_launch FAILED\n");
18752     exit (1);
18753   }
18754
18755   /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18756   alarm (600);
18757
18758   if (guestfs_wait_ready (g) == -1) {
18759     printf ("guestfs_wait_ready FAILED\n");
18760     exit (1);
18761   }
18762
18763   /* Cancel previous alarm. */
18764   alarm (0);
18765
18766   nr_tests = 166;
18767
18768   test_num++;
18769   printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
18770   if (test_initrd_list_0 () == -1) {
18771     printf ("test_initrd_list_0 FAILED\n");
18772     failed++;
18773   }
18774   test_num++;
18775   printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
18776   if (test_du_0 () == -1) {
18777     printf ("test_du_0 FAILED\n");
18778     failed++;
18779   }
18780   test_num++;
18781   printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
18782   if (test_tail_n_0 () == -1) {
18783     printf ("test_tail_n_0 FAILED\n");
18784     failed++;
18785   }
18786   test_num++;
18787   printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
18788   if (test_tail_n_1 () == -1) {
18789     printf ("test_tail_n_1 FAILED\n");
18790     failed++;
18791   }
18792   test_num++;
18793   printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
18794   if (test_tail_n_2 () == -1) {
18795     printf ("test_tail_n_2 FAILED\n");
18796     failed++;
18797   }
18798   test_num++;
18799   printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
18800   if (test_tail_0 () == -1) {
18801     printf ("test_tail_0 FAILED\n");
18802     failed++;
18803   }
18804   test_num++;
18805   printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
18806   if (test_head_n_0 () == -1) {
18807     printf ("test_head_n_0 FAILED\n");
18808     failed++;
18809   }
18810   test_num++;
18811   printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
18812   if (test_head_n_1 () == -1) {
18813     printf ("test_head_n_1 FAILED\n");
18814     failed++;
18815   }
18816   test_num++;
18817   printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
18818   if (test_head_n_2 () == -1) {
18819     printf ("test_head_n_2 FAILED\n");
18820     failed++;
18821   }
18822   test_num++;
18823   printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
18824   if (test_head_0 () == -1) {
18825     printf ("test_head_0 FAILED\n");
18826     failed++;
18827   }
18828   test_num++;
18829   printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
18830   if (test_wc_c_0 () == -1) {
18831     printf ("test_wc_c_0 FAILED\n");
18832     failed++;
18833   }
18834   test_num++;
18835   printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
18836   if (test_wc_w_0 () == -1) {
18837     printf ("test_wc_w_0 FAILED\n");
18838     failed++;
18839   }
18840   test_num++;
18841   printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
18842   if (test_wc_l_0 () == -1) {
18843     printf ("test_wc_l_0 FAILED\n");
18844     failed++;
18845   }
18846   test_num++;
18847   printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
18848   if (test_mkdtemp_0 () == -1) {
18849     printf ("test_mkdtemp_0 FAILED\n");
18850     failed++;
18851   }
18852   test_num++;
18853   printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
18854   if (test_scrub_file_0 () == -1) {
18855     printf ("test_scrub_file_0 FAILED\n");
18856     failed++;
18857   }
18858   test_num++;
18859   printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
18860   if (test_scrub_device_0 () == -1) {
18861     printf ("test_scrub_device_0 FAILED\n");
18862     failed++;
18863   }
18864   test_num++;
18865   printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
18866   if (test_glob_expand_0 () == -1) {
18867     printf ("test_glob_expand_0 FAILED\n");
18868     failed++;
18869   }
18870   test_num++;
18871   printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
18872   if (test_glob_expand_1 () == -1) {
18873     printf ("test_glob_expand_1 FAILED\n");
18874     failed++;
18875   }
18876   test_num++;
18877   printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
18878   if (test_glob_expand_2 () == -1) {
18879     printf ("test_glob_expand_2 FAILED\n");
18880     failed++;
18881   }
18882   test_num++;
18883   printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
18884   if (test_ntfs_3g_probe_0 () == -1) {
18885     printf ("test_ntfs_3g_probe_0 FAILED\n");
18886     failed++;
18887   }
18888   test_num++;
18889   printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
18890   if (test_ntfs_3g_probe_1 () == -1) {
18891     printf ("test_ntfs_3g_probe_1 FAILED\n");
18892     failed++;
18893   }
18894   test_num++;
18895   printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
18896   if (test_sleep_0 () == -1) {
18897     printf ("test_sleep_0 FAILED\n");
18898     failed++;
18899   }
18900   test_num++;
18901   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
18902   if (test_find_0 () == -1) {
18903     printf ("test_find_0 FAILED\n");
18904     failed++;
18905   }
18906   test_num++;
18907   printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
18908   if (test_find_1 () == -1) {
18909     printf ("test_find_1 FAILED\n");
18910     failed++;
18911   }
18912   test_num++;
18913   printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
18914   if (test_find_2 () == -1) {
18915     printf ("test_find_2 FAILED\n");
18916     failed++;
18917   }
18918   test_num++;
18919   printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
18920   if (test_lvresize_0 () == -1) {
18921     printf ("test_lvresize_0 FAILED\n");
18922     failed++;
18923   }
18924   test_num++;
18925   printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
18926   if (test_zerofree_0 () == -1) {
18927     printf ("test_zerofree_0 FAILED\n");
18928     failed++;
18929   }
18930   test_num++;
18931   printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
18932   if (test_hexdump_0 () == -1) {
18933     printf ("test_hexdump_0 FAILED\n");
18934     failed++;
18935   }
18936   test_num++;
18937   printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
18938   if (test_hexdump_1 () == -1) {
18939     printf ("test_hexdump_1 FAILED\n");
18940     failed++;
18941   }
18942   test_num++;
18943   printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
18944   if (test_strings_e_0 () == -1) {
18945     printf ("test_strings_e_0 FAILED\n");
18946     failed++;
18947   }
18948   test_num++;
18949   printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
18950   if (test_strings_e_1 () == -1) {
18951     printf ("test_strings_e_1 FAILED\n");
18952     failed++;
18953   }
18954   test_num++;
18955   printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
18956   if (test_strings_0 () == -1) {
18957     printf ("test_strings_0 FAILED\n");
18958     failed++;
18959   }
18960   test_num++;
18961   printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
18962   if (test_strings_1 () == -1) {
18963     printf ("test_strings_1 FAILED\n");
18964     failed++;
18965   }
18966   test_num++;
18967   printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
18968   if (test_equal_0 () == -1) {
18969     printf ("test_equal_0 FAILED\n");
18970     failed++;
18971   }
18972   test_num++;
18973   printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
18974   if (test_equal_1 () == -1) {
18975     printf ("test_equal_1 FAILED\n");
18976     failed++;
18977   }
18978   test_num++;
18979   printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
18980   if (test_equal_2 () == -1) {
18981     printf ("test_equal_2 FAILED\n");
18982     failed++;
18983   }
18984   test_num++;
18985   printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
18986   if (test_ping_daemon_0 () == -1) {
18987     printf ("test_ping_daemon_0 FAILED\n");
18988     failed++;
18989   }
18990   test_num++;
18991   printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
18992   if (test_dmesg_0 () == -1) {
18993     printf ("test_dmesg_0 FAILED\n");
18994     failed++;
18995   }
18996   test_num++;
18997   printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
18998   if (test_drop_caches_0 () == -1) {
18999     printf ("test_drop_caches_0 FAILED\n");
19000     failed++;
19001   }
19002   test_num++;
19003   printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19004   if (test_mv_0 () == -1) {
19005     printf ("test_mv_0 FAILED\n");
19006     failed++;
19007   }
19008   test_num++;
19009   printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19010   if (test_mv_1 () == -1) {
19011     printf ("test_mv_1 FAILED\n");
19012     failed++;
19013   }
19014   test_num++;
19015   printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19016   if (test_cp_a_0 () == -1) {
19017     printf ("test_cp_a_0 FAILED\n");
19018     failed++;
19019   }
19020   test_num++;
19021   printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19022   if (test_cp_0 () == -1) {
19023     printf ("test_cp_0 FAILED\n");
19024     failed++;
19025   }
19026   test_num++;
19027   printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19028   if (test_cp_1 () == -1) {
19029     printf ("test_cp_1 FAILED\n");
19030     failed++;
19031   }
19032   test_num++;
19033   printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19034   if (test_cp_2 () == -1) {
19035     printf ("test_cp_2 FAILED\n");
19036     failed++;
19037   }
19038   test_num++;
19039   printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19040   if (test_grub_install_0 () == -1) {
19041     printf ("test_grub_install_0 FAILED\n");
19042     failed++;
19043   }
19044   test_num++;
19045   printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19046   if (test_zero_0 () == -1) {
19047     printf ("test_zero_0 FAILED\n");
19048     failed++;
19049   }
19050   test_num++;
19051   printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19052   if (test_fsck_0 () == -1) {
19053     printf ("test_fsck_0 FAILED\n");
19054     failed++;
19055   }
19056   test_num++;
19057   printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19058   if (test_fsck_1 () == -1) {
19059     printf ("test_fsck_1 FAILED\n");
19060     failed++;
19061   }
19062   test_num++;
19063   printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19064   if (test_set_e2uuid_0 () == -1) {
19065     printf ("test_set_e2uuid_0 FAILED\n");
19066     failed++;
19067   }
19068   test_num++;
19069   printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19070   if (test_set_e2uuid_1 () == -1) {
19071     printf ("test_set_e2uuid_1 FAILED\n");
19072     failed++;
19073   }
19074   test_num++;
19075   printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19076   if (test_set_e2uuid_2 () == -1) {
19077     printf ("test_set_e2uuid_2 FAILED\n");
19078     failed++;
19079   }
19080   test_num++;
19081   printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19082   if (test_set_e2uuid_3 () == -1) {
19083     printf ("test_set_e2uuid_3 FAILED\n");
19084     failed++;
19085   }
19086   test_num++;
19087   printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19088   if (test_set_e2label_0 () == -1) {
19089     printf ("test_set_e2label_0 FAILED\n");
19090     failed++;
19091   }
19092   test_num++;
19093   printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19094   if (test_pvremove_0 () == -1) {
19095     printf ("test_pvremove_0 FAILED\n");
19096     failed++;
19097   }
19098   test_num++;
19099   printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19100   if (test_pvremove_1 () == -1) {
19101     printf ("test_pvremove_1 FAILED\n");
19102     failed++;
19103   }
19104   test_num++;
19105   printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19106   if (test_pvremove_2 () == -1) {
19107     printf ("test_pvremove_2 FAILED\n");
19108     failed++;
19109   }
19110   test_num++;
19111   printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19112   if (test_vgremove_0 () == -1) {
19113     printf ("test_vgremove_0 FAILED\n");
19114     failed++;
19115   }
19116   test_num++;
19117   printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19118   if (test_vgremove_1 () == -1) {
19119     printf ("test_vgremove_1 FAILED\n");
19120     failed++;
19121   }
19122   test_num++;
19123   printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19124   if (test_lvremove_0 () == -1) {
19125     printf ("test_lvremove_0 FAILED\n");
19126     failed++;
19127   }
19128   test_num++;
19129   printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19130   if (test_lvremove_1 () == -1) {
19131     printf ("test_lvremove_1 FAILED\n");
19132     failed++;
19133   }
19134   test_num++;
19135   printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19136   if (test_lvremove_2 () == -1) {
19137     printf ("test_lvremove_2 FAILED\n");
19138     failed++;
19139   }
19140   test_num++;
19141   printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19142   if (test_mount_ro_0 () == -1) {
19143     printf ("test_mount_ro_0 FAILED\n");
19144     failed++;
19145   }
19146   test_num++;
19147   printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19148   if (test_mount_ro_1 () == -1) {
19149     printf ("test_mount_ro_1 FAILED\n");
19150     failed++;
19151   }
19152   test_num++;
19153   printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19154   if (test_tgz_in_0 () == -1) {
19155     printf ("test_tgz_in_0 FAILED\n");
19156     failed++;
19157   }
19158   test_num++;
19159   printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19160   if (test_tar_in_0 () == -1) {
19161     printf ("test_tar_in_0 FAILED\n");
19162     failed++;
19163   }
19164   test_num++;
19165   printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19166   if (test_checksum_0 () == -1) {
19167     printf ("test_checksum_0 FAILED\n");
19168     failed++;
19169   }
19170   test_num++;
19171   printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19172   if (test_checksum_1 () == -1) {
19173     printf ("test_checksum_1 FAILED\n");
19174     failed++;
19175   }
19176   test_num++;
19177   printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19178   if (test_checksum_2 () == -1) {
19179     printf ("test_checksum_2 FAILED\n");
19180     failed++;
19181   }
19182   test_num++;
19183   printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19184   if (test_checksum_3 () == -1) {
19185     printf ("test_checksum_3 FAILED\n");
19186     failed++;
19187   }
19188   test_num++;
19189   printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19190   if (test_checksum_4 () == -1) {
19191     printf ("test_checksum_4 FAILED\n");
19192     failed++;
19193   }
19194   test_num++;
19195   printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19196   if (test_checksum_5 () == -1) {
19197     printf ("test_checksum_5 FAILED\n");
19198     failed++;
19199   }
19200   test_num++;
19201   printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19202   if (test_checksum_6 () == -1) {
19203     printf ("test_checksum_6 FAILED\n");
19204     failed++;
19205   }
19206   test_num++;
19207   printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19208   if (test_checksum_7 () == -1) {
19209     printf ("test_checksum_7 FAILED\n");
19210     failed++;
19211   }
19212   test_num++;
19213   printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19214   if (test_checksum_8 () == -1) {
19215     printf ("test_checksum_8 FAILED\n");
19216     failed++;
19217   }
19218   test_num++;
19219   printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19220   if (test_download_0 () == -1) {
19221     printf ("test_download_0 FAILED\n");
19222     failed++;
19223   }
19224   test_num++;
19225   printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19226   if (test_upload_0 () == -1) {
19227     printf ("test_upload_0 FAILED\n");
19228     failed++;
19229   }
19230   test_num++;
19231   printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19232   if (test_blockdev_rereadpt_0 () == -1) {
19233     printf ("test_blockdev_rereadpt_0 FAILED\n");
19234     failed++;
19235   }
19236   test_num++;
19237   printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19238   if (test_blockdev_flushbufs_0 () == -1) {
19239     printf ("test_blockdev_flushbufs_0 FAILED\n");
19240     failed++;
19241   }
19242   test_num++;
19243   printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19244   if (test_blockdev_getsize64_0 () == -1) {
19245     printf ("test_blockdev_getsize64_0 FAILED\n");
19246     failed++;
19247   }
19248   test_num++;
19249   printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19250   if (test_blockdev_getsz_0 () == -1) {
19251     printf ("test_blockdev_getsz_0 FAILED\n");
19252     failed++;
19253   }
19254   test_num++;
19255   printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19256   if (test_blockdev_getbsz_0 () == -1) {
19257     printf ("test_blockdev_getbsz_0 FAILED\n");
19258     failed++;
19259   }
19260   test_num++;
19261   printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19262   if (test_blockdev_getss_0 () == -1) {
19263     printf ("test_blockdev_getss_0 FAILED\n");
19264     failed++;
19265   }
19266   test_num++;
19267   printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19268   if (test_blockdev_getro_0 () == -1) {
19269     printf ("test_blockdev_getro_0 FAILED\n");
19270     failed++;
19271   }
19272   test_num++;
19273   printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19274   if (test_blockdev_setrw_0 () == -1) {
19275     printf ("test_blockdev_setrw_0 FAILED\n");
19276     failed++;
19277   }
19278   test_num++;
19279   printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19280   if (test_blockdev_setro_0 () == -1) {
19281     printf ("test_blockdev_setro_0 FAILED\n");
19282     failed++;
19283   }
19284   test_num++;
19285   printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19286   if (test_statvfs_0 () == -1) {
19287     printf ("test_statvfs_0 FAILED\n");
19288     failed++;
19289   }
19290   test_num++;
19291   printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19292   if (test_lstat_0 () == -1) {
19293     printf ("test_lstat_0 FAILED\n");
19294     failed++;
19295   }
19296   test_num++;
19297   printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19298   if (test_stat_0 () == -1) {
19299     printf ("test_stat_0 FAILED\n");
19300     failed++;
19301   }
19302   test_num++;
19303   printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19304   if (test_command_lines_0 () == -1) {
19305     printf ("test_command_lines_0 FAILED\n");
19306     failed++;
19307   }
19308   test_num++;
19309   printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19310   if (test_command_lines_1 () == -1) {
19311     printf ("test_command_lines_1 FAILED\n");
19312     failed++;
19313   }
19314   test_num++;
19315   printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19316   if (test_command_lines_2 () == -1) {
19317     printf ("test_command_lines_2 FAILED\n");
19318     failed++;
19319   }
19320   test_num++;
19321   printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19322   if (test_command_lines_3 () == -1) {
19323     printf ("test_command_lines_3 FAILED\n");
19324     failed++;
19325   }
19326   test_num++;
19327   printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19328   if (test_command_lines_4 () == -1) {
19329     printf ("test_command_lines_4 FAILED\n");
19330     failed++;
19331   }
19332   test_num++;
19333   printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19334   if (test_command_lines_5 () == -1) {
19335     printf ("test_command_lines_5 FAILED\n");
19336     failed++;
19337   }
19338   test_num++;
19339   printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19340   if (test_command_lines_6 () == -1) {
19341     printf ("test_command_lines_6 FAILED\n");
19342     failed++;
19343   }
19344   test_num++;
19345   printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19346   if (test_command_lines_7 () == -1) {
19347     printf ("test_command_lines_7 FAILED\n");
19348     failed++;
19349   }
19350   test_num++;
19351   printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19352   if (test_command_lines_8 () == -1) {
19353     printf ("test_command_lines_8 FAILED\n");
19354     failed++;
19355   }
19356   test_num++;
19357   printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19358   if (test_command_lines_9 () == -1) {
19359     printf ("test_command_lines_9 FAILED\n");
19360     failed++;
19361   }
19362   test_num++;
19363   printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19364   if (test_command_lines_10 () == -1) {
19365     printf ("test_command_lines_10 FAILED\n");
19366     failed++;
19367   }
19368   test_num++;
19369   printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19370   if (test_command_0 () == -1) {
19371     printf ("test_command_0 FAILED\n");
19372     failed++;
19373   }
19374   test_num++;
19375   printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19376   if (test_command_1 () == -1) {
19377     printf ("test_command_1 FAILED\n");
19378     failed++;
19379   }
19380   test_num++;
19381   printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19382   if (test_command_2 () == -1) {
19383     printf ("test_command_2 FAILED\n");
19384     failed++;
19385   }
19386   test_num++;
19387   printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19388   if (test_command_3 () == -1) {
19389     printf ("test_command_3 FAILED\n");
19390     failed++;
19391   }
19392   test_num++;
19393   printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19394   if (test_command_4 () == -1) {
19395     printf ("test_command_4 FAILED\n");
19396     failed++;
19397   }
19398   test_num++;
19399   printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19400   if (test_command_5 () == -1) {
19401     printf ("test_command_5 FAILED\n");
19402     failed++;
19403   }
19404   test_num++;
19405   printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19406   if (test_command_6 () == -1) {
19407     printf ("test_command_6 FAILED\n");
19408     failed++;
19409   }
19410   test_num++;
19411   printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19412   if (test_command_7 () == -1) {
19413     printf ("test_command_7 FAILED\n");
19414     failed++;
19415   }
19416   test_num++;
19417   printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19418   if (test_command_8 () == -1) {
19419     printf ("test_command_8 FAILED\n");
19420     failed++;
19421   }
19422   test_num++;
19423   printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19424   if (test_command_9 () == -1) {
19425     printf ("test_command_9 FAILED\n");
19426     failed++;
19427   }
19428   test_num++;
19429   printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19430   if (test_command_10 () == -1) {
19431     printf ("test_command_10 FAILED\n");
19432     failed++;
19433   }
19434   test_num++;
19435   printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19436   if (test_command_11 () == -1) {
19437     printf ("test_command_11 FAILED\n");
19438     failed++;
19439   }
19440   test_num++;
19441   printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19442   if (test_file_0 () == -1) {
19443     printf ("test_file_0 FAILED\n");
19444     failed++;
19445   }
19446   test_num++;
19447   printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19448   if (test_file_1 () == -1) {
19449     printf ("test_file_1 FAILED\n");
19450     failed++;
19451   }
19452   test_num++;
19453   printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19454   if (test_file_2 () == -1) {
19455     printf ("test_file_2 FAILED\n");
19456     failed++;
19457   }
19458   test_num++;
19459   printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19460   if (test_umount_all_0 () == -1) {
19461     printf ("test_umount_all_0 FAILED\n");
19462     failed++;
19463   }
19464   test_num++;
19465   printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19466   if (test_umount_all_1 () == -1) {
19467     printf ("test_umount_all_1 FAILED\n");
19468     failed++;
19469   }
19470   test_num++;
19471   printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19472   if (test_mounts_0 () == -1) {
19473     printf ("test_mounts_0 FAILED\n");
19474     failed++;
19475   }
19476   test_num++;
19477   printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19478   if (test_umount_0 () == -1) {
19479     printf ("test_umount_0 FAILED\n");
19480     failed++;
19481   }
19482   test_num++;
19483   printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19484   if (test_umount_1 () == -1) {
19485     printf ("test_umount_1 FAILED\n");
19486     failed++;
19487   }
19488   test_num++;
19489   printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19490   if (test_write_file_0 () == -1) {
19491     printf ("test_write_file_0 FAILED\n");
19492     failed++;
19493   }
19494   test_num++;
19495   printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19496   if (test_write_file_1 () == -1) {
19497     printf ("test_write_file_1 FAILED\n");
19498     failed++;
19499   }
19500   test_num++;
19501   printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19502   if (test_write_file_2 () == -1) {
19503     printf ("test_write_file_2 FAILED\n");
19504     failed++;
19505   }
19506   test_num++;
19507   printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19508   if (test_write_file_3 () == -1) {
19509     printf ("test_write_file_3 FAILED\n");
19510     failed++;
19511   }
19512   test_num++;
19513   printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19514   if (test_write_file_4 () == -1) {
19515     printf ("test_write_file_4 FAILED\n");
19516     failed++;
19517   }
19518   test_num++;
19519   printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19520   if (test_write_file_5 () == -1) {
19521     printf ("test_write_file_5 FAILED\n");
19522     failed++;
19523   }
19524   test_num++;
19525   printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19526   if (test_mkfs_0 () == -1) {
19527     printf ("test_mkfs_0 FAILED\n");
19528     failed++;
19529   }
19530   test_num++;
19531   printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19532   if (test_lvcreate_0 () == -1) {
19533     printf ("test_lvcreate_0 FAILED\n");
19534     failed++;
19535   }
19536   test_num++;
19537   printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19538   if (test_vgcreate_0 () == -1) {
19539     printf ("test_vgcreate_0 FAILED\n");
19540     failed++;
19541   }
19542   test_num++;
19543   printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19544   if (test_pvcreate_0 () == -1) {
19545     printf ("test_pvcreate_0 FAILED\n");
19546     failed++;
19547   }
19548   test_num++;
19549   printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19550   if (test_is_dir_0 () == -1) {
19551     printf ("test_is_dir_0 FAILED\n");
19552     failed++;
19553   }
19554   test_num++;
19555   printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19556   if (test_is_dir_1 () == -1) {
19557     printf ("test_is_dir_1 FAILED\n");
19558     failed++;
19559   }
19560   test_num++;
19561   printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19562   if (test_is_file_0 () == -1) {
19563     printf ("test_is_file_0 FAILED\n");
19564     failed++;
19565   }
19566   test_num++;
19567   printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19568   if (test_is_file_1 () == -1) {
19569     printf ("test_is_file_1 FAILED\n");
19570     failed++;
19571   }
19572   test_num++;
19573   printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19574   if (test_exists_0 () == -1) {
19575     printf ("test_exists_0 FAILED\n");
19576     failed++;
19577   }
19578   test_num++;
19579   printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19580   if (test_exists_1 () == -1) {
19581     printf ("test_exists_1 FAILED\n");
19582     failed++;
19583   }
19584   test_num++;
19585   printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19586   if (test_mkdir_p_0 () == -1) {
19587     printf ("test_mkdir_p_0 FAILED\n");
19588     failed++;
19589   }
19590   test_num++;
19591   printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19592   if (test_mkdir_p_1 () == -1) {
19593     printf ("test_mkdir_p_1 FAILED\n");
19594     failed++;
19595   }
19596   test_num++;
19597   printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19598   if (test_mkdir_p_2 () == -1) {
19599     printf ("test_mkdir_p_2 FAILED\n");
19600     failed++;
19601   }
19602   test_num++;
19603   printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19604   if (test_mkdir_p_3 () == -1) {
19605     printf ("test_mkdir_p_3 FAILED\n");
19606     failed++;
19607   }
19608   test_num++;
19609   printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19610   if (test_mkdir_p_4 () == -1) {
19611     printf ("test_mkdir_p_4 FAILED\n");
19612     failed++;
19613   }
19614   test_num++;
19615   printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19616   if (test_mkdir_0 () == -1) {
19617     printf ("test_mkdir_0 FAILED\n");
19618     failed++;
19619   }
19620   test_num++;
19621   printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19622   if (test_mkdir_1 () == -1) {
19623     printf ("test_mkdir_1 FAILED\n");
19624     failed++;
19625   }
19626   test_num++;
19627   printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19628   if (test_rm_rf_0 () == -1) {
19629     printf ("test_rm_rf_0 FAILED\n");
19630     failed++;
19631   }
19632   test_num++;
19633   printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19634   if (test_rmdir_0 () == -1) {
19635     printf ("test_rmdir_0 FAILED\n");
19636     failed++;
19637   }
19638   test_num++;
19639   printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19640   if (test_rmdir_1 () == -1) {
19641     printf ("test_rmdir_1 FAILED\n");
19642     failed++;
19643   }
19644   test_num++;
19645   printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19646   if (test_rmdir_2 () == -1) {
19647     printf ("test_rmdir_2 FAILED\n");
19648     failed++;
19649   }
19650   test_num++;
19651   printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19652   if (test_rm_0 () == -1) {
19653     printf ("test_rm_0 FAILED\n");
19654     failed++;
19655   }
19656   test_num++;
19657   printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19658   if (test_rm_1 () == -1) {
19659     printf ("test_rm_1 FAILED\n");
19660     failed++;
19661   }
19662   test_num++;
19663   printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19664   if (test_rm_2 () == -1) {
19665     printf ("test_rm_2 FAILED\n");
19666     failed++;
19667   }
19668   test_num++;
19669   printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19670   if (test_read_lines_0 () == -1) {
19671     printf ("test_read_lines_0 FAILED\n");
19672     failed++;
19673   }
19674   test_num++;
19675   printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19676   if (test_read_lines_1 () == -1) {
19677     printf ("test_read_lines_1 FAILED\n");
19678     failed++;
19679   }
19680   test_num++;
19681   printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19682   if (test_lvs_0 () == -1) {
19683     printf ("test_lvs_0 FAILED\n");
19684     failed++;
19685   }
19686   test_num++;
19687   printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19688   if (test_lvs_1 () == -1) {
19689     printf ("test_lvs_1 FAILED\n");
19690     failed++;
19691   }
19692   test_num++;
19693   printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19694   if (test_vgs_0 () == -1) {
19695     printf ("test_vgs_0 FAILED\n");
19696     failed++;
19697   }
19698   test_num++;
19699   printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19700   if (test_vgs_1 () == -1) {
19701     printf ("test_vgs_1 FAILED\n");
19702     failed++;
19703   }
19704   test_num++;
19705   printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19706   if (test_pvs_0 () == -1) {
19707     printf ("test_pvs_0 FAILED\n");
19708     failed++;
19709   }
19710   test_num++;
19711   printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19712   if (test_pvs_1 () == -1) {
19713     printf ("test_pvs_1 FAILED\n");
19714     failed++;
19715   }
19716   test_num++;
19717   printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19718   if (test_list_partitions_0 () == -1) {
19719     printf ("test_list_partitions_0 FAILED\n");
19720     failed++;
19721   }
19722   test_num++;
19723   printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19724   if (test_list_partitions_1 () == -1) {
19725     printf ("test_list_partitions_1 FAILED\n");
19726     failed++;
19727   }
19728   test_num++;
19729   printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19730   if (test_list_devices_0 () == -1) {
19731     printf ("test_list_devices_0 FAILED\n");
19732     failed++;
19733   }
19734   test_num++;
19735   printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19736   if (test_ls_0 () == -1) {
19737     printf ("test_ls_0 FAILED\n");
19738     failed++;
19739   }
19740   test_num++;
19741   printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19742   if (test_cat_0 () == -1) {
19743     printf ("test_cat_0 FAILED\n");
19744     failed++;
19745   }
19746   test_num++;
19747   printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19748   if (test_touch_0 () == -1) {
19749     printf ("test_touch_0 FAILED\n");
19750     failed++;
19751   }
19752   test_num++;
19753   printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19754   if (test_sync_0 () == -1) {
19755     printf ("test_sync_0 FAILED\n");
19756     failed++;
19757   }
19758   test_num++;
19759   printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19760   if (test_mount_0 () == -1) {
19761     printf ("test_mount_0 FAILED\n");
19762     failed++;
19763   }
19764
19765   guestfs_close (g);
19766   unlink ("test1.img");
19767   unlink ("test2.img");
19768   unlink ("test3.img");
19769
19770   if (failed > 0) {
19771     printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);
19772     exit (1);
19773   }
19774
19775   exit (0);
19776 }