capitests/tests.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28
  29 #include "guestfs.h"
  30
  31 static guestfs_h *g;
  32 static int suppress_error = 0;
  33
  34 static void print_error (guestfs_h *g, void *data, const char *msg)
  35 {
  36   if (!suppress_error)
  37     fprintf (stderr, "%s\n", msg);
  38 }
  39
  40 static void print_strings (char * const * const argv)
  41 {
  42   int argc;
  43
  44   for (argc = 0; argv[argc] != NULL; ++argc)
  45     printf ("\t%s\n", argv[argc]);
  46 }
  47
  48 /*
  49 static void print_table (char * const * const argv)
  50 {
  51   int i;
  52
  53   for (i = 0; argv[i] != NULL; i += 2)
  54     printf ("%s: %s\n", argv[i], argv[i+1]);
  55 }
  56 */
  57
  58 static void no_test_warnings (void)
  59 {
  60   fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
  61   fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
  62   fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
  63   fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
  64   fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
  65   fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
  66   fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
  67   fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
  68   fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
  69   fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
  70   fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
  71   fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
  72   fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
  73   fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
  74   fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
  75   fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
  76   fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
  77   fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
  78   fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
  79   fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
  80   fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
  81   fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
  82   fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
  83   fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
  84   fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
  85   fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
  86   fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
  87   fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
  88   fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
  89   fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
  90   fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
  91   fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
  92   fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
  93   fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
  94   fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
  95   fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
  96   fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
  97   fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
  98   fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
  99   fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
 100   fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
 101   fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
 102   fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
 103   fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
 104   fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
 105   fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
 106   fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
 107   fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
 108   fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
 109   fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
 110   fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
 111   fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
 112   fprintf (stderr, "warning: \"guestfs_set_memsize\" has no tests\n");
 113   fprintf (stderr, "warning: \"guestfs_get_memsize\" has no tests\n");
 114   fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
 115   fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
 116   fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
 117   fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
 118   fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
 119   fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
 120   fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
 121   fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
 122   fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
 123   fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
 124   fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
 125   fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
 126   fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
 127   fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
 128   fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
 129   fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
 130   fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
 131   fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
 132   fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
 133   fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
 134   fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
 135   fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
 136   fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
 137   fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
 138   fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
 139   fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
 140   fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
 141   fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
 142   fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
 143   fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
 144   fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
 145   fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
 146   fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
 147   fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
 148   fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
 149   fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
 150   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
 151   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
 152   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
 153   fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
 154   fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
 155   fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
 156   fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
 157   fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
 158   fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
 159   fprintf (stderr, "warning: \"guestfs_umask\" has no tests\n");
 160 }
 161
 162 static int test_mknod_c_0_skip (void)
 163 {
 164   const char *str;
 165
 166   str = getenv ("TEST_ONLY");
 167   if (str)
 168     return strstr (str, "mknod_c") == NULL;
 169   str = getenv ("SKIP_TEST_MKNOD_C_0");
 170   if (str && strcmp (str, "1") == 0) return 1;
 171   str = getenv ("SKIP_TEST_MKNOD_C");
 172   if (str && strcmp (str, "1") == 0) return 1;
 173   return 0;
 174 }
 175
 176 static int test_mknod_c_0 (void)
 177 {
 178   if (test_mknod_c_0_skip ()) {
 179     printf ("%s skipped (reason: environment variable set)\n", "test_mknod_c_0");
 180     return 0;
 181   }
 182
 183   /* InitBasicFS for test_mknod_c_0: create ext2 on /dev/sda1 */
 184   {
 185     char device[] = "/dev/sda";
 186     int r;
 187     suppress_error = 0;
 188     r = guestfs_blockdev_setrw (g, device);
 189     if (r == -1)
 190       return -1;
 191   }
 192   {
 193     int r;
 194     suppress_error = 0;
 195     r = guestfs_umount_all (g);
 196     if (r == -1)
 197       return -1;
 198   }
 199   {
 200     int r;
 201     suppress_error = 0;
 202     r = guestfs_lvm_remove_all (g);
 203     if (r == -1)
 204       return -1;
 205   }
 206   {
 207     char device[] = "/dev/sda";
 208     char lines_0[] = ",";
 209     char *lines[] = {
 210       lines_0,
 211       NULL
 212     };
 213     int r;
 214     suppress_error = 0;
 215     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 216     if (r == -1)
 217       return -1;
 218   }
 219   {
 220     char fstype[] = "ext2";
 221     char device[] = "/dev/sda1";
 222     int r;
 223     suppress_error = 0;
 224     r = guestfs_mkfs (g, fstype, device);
 225     if (r == -1)
 226       return -1;
 227   }
 228   {
 229     char device[] = "/dev/sda1";
 230     char mountpoint[] = "/";
 231     int r;
 232     suppress_error = 0;
 233     r = guestfs_mount (g, device, mountpoint);
 234     if (r == -1)
 235       return -1;
 236   }
 237   /* TestOutputStruct for mknod_c (0) */
 238   {
 239     char path[] = "/node";
 240     int r;
 241     suppress_error = 0;
 242     r = guestfs_mknod_c (g, 511, 99, 66, path);
 243     if (r == -1)
 244       return -1;
 245   }
 246   {
 247     char path[] = "/node";
 248     struct guestfs_stat *r;
 249     suppress_error = 0;
 250     r = guestfs_stat (g, path);
 251     if (r == NULL)
 252       return -1;
 253     if (r->mode != 8685) {
 254       fprintf (stderr, "test_mknod_c_0: mode was %d, expected 8685\n",
 255                (int) r->mode);
 256       return -1;
 257     }
 258     free (r);
 259   }
 260   return 0;
 261 }
 262
 263 static int test_mknod_b_0_skip (void)
 264 {
 265   const char *str;
 266
 267   str = getenv ("TEST_ONLY");
 268   if (str)
 269     return strstr (str, "mknod_b") == NULL;
 270   str = getenv ("SKIP_TEST_MKNOD_B_0");
 271   if (str && strcmp (str, "1") == 0) return 1;
 272   str = getenv ("SKIP_TEST_MKNOD_B");
 273   if (str && strcmp (str, "1") == 0) return 1;
 274   return 0;
 275 }
 276
 277 static int test_mknod_b_0 (void)
 278 {
 279   if (test_mknod_b_0_skip ()) {
 280     printf ("%s skipped (reason: environment variable set)\n", "test_mknod_b_0");
 281     return 0;
 282   }
 283
 284   /* InitBasicFS for test_mknod_b_0: create ext2 on /dev/sda1 */
 285   {
 286     char device[] = "/dev/sda";
 287     int r;
 288     suppress_error = 0;
 289     r = guestfs_blockdev_setrw (g, device);
 290     if (r == -1)
 291       return -1;
 292   }
 293   {
 294     int r;
 295     suppress_error = 0;
 296     r = guestfs_umount_all (g);
 297     if (r == -1)
 298       return -1;
 299   }
 300   {
 301     int r;
 302     suppress_error = 0;
 303     r = guestfs_lvm_remove_all (g);
 304     if (r == -1)
 305       return -1;
 306   }
 307   {
 308     char device[] = "/dev/sda";
 309     char lines_0[] = ",";
 310     char *lines[] = {
 311       lines_0,
 312       NULL
 313     };
 314     int r;
 315     suppress_error = 0;
 316     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 317     if (r == -1)
 318       return -1;
 319   }
 320   {
 321     char fstype[] = "ext2";
 322     char device[] = "/dev/sda1";
 323     int r;
 324     suppress_error = 0;
 325     r = guestfs_mkfs (g, fstype, device);
 326     if (r == -1)
 327       return -1;
 328   }
 329   {
 330     char device[] = "/dev/sda1";
 331     char mountpoint[] = "/";
 332     int r;
 333     suppress_error = 0;
 334     r = guestfs_mount (g, device, mountpoint);
 335     if (r == -1)
 336       return -1;
 337   }
 338   /* TestOutputStruct for mknod_b (0) */
 339   {
 340     char path[] = "/node";
 341     int r;
 342     suppress_error = 0;
 343     r = guestfs_mknod_b (g, 511, 99, 66, path);
 344     if (r == -1)
 345       return -1;
 346   }
 347   {
 348     char path[] = "/node";
 349     struct guestfs_stat *r;
 350     suppress_error = 0;
 351     r = guestfs_stat (g, path);
 352     if (r == NULL)
 353       return -1;
 354     if (r->mode != 25069) {
 355       fprintf (stderr, "test_mknod_b_0: mode was %d, expected 25069\n",
 356                (int) r->mode);
 357       return -1;
 358     }
 359     free (r);
 360   }
 361   return 0;
 362 }
 363
 364 static int test_mkfifo_0_skip (void)
 365 {
 366   const char *str;
 367
 368   str = getenv ("TEST_ONLY");
 369   if (str)
 370     return strstr (str, "mkfifo") == NULL;
 371   str = getenv ("SKIP_TEST_MKFIFO_0");
 372   if (str && strcmp (str, "1") == 0) return 1;
 373   str = getenv ("SKIP_TEST_MKFIFO");
 374   if (str && strcmp (str, "1") == 0) return 1;
 375   return 0;
 376 }
 377
 378 static int test_mkfifo_0 (void)
 379 {
 380   if (test_mkfifo_0_skip ()) {
 381     printf ("%s skipped (reason: environment variable set)\n", "test_mkfifo_0");
 382     return 0;
 383   }
 384
 385   /* InitBasicFS for test_mkfifo_0: create ext2 on /dev/sda1 */
 386   {
 387     char device[] = "/dev/sda";
 388     int r;
 389     suppress_error = 0;
 390     r = guestfs_blockdev_setrw (g, device);
 391     if (r == -1)
 392       return -1;
 393   }
 394   {
 395     int r;
 396     suppress_error = 0;
 397     r = guestfs_umount_all (g);
 398     if (r == -1)
 399       return -1;
 400   }
 401   {
 402     int r;
 403     suppress_error = 0;
 404     r = guestfs_lvm_remove_all (g);
 405     if (r == -1)
 406       return -1;
 407   }
 408   {
 409     char device[] = "/dev/sda";
 410     char lines_0[] = ",";
 411     char *lines[] = {
 412       lines_0,
 413       NULL
 414     };
 415     int r;
 416     suppress_error = 0;
 417     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 418     if (r == -1)
 419       return -1;
 420   }
 421   {
 422     char fstype[] = "ext2";
 423     char device[] = "/dev/sda1";
 424     int r;
 425     suppress_error = 0;
 426     r = guestfs_mkfs (g, fstype, device);
 427     if (r == -1)
 428       return -1;
 429   }
 430   {
 431     char device[] = "/dev/sda1";
 432     char mountpoint[] = "/";
 433     int r;
 434     suppress_error = 0;
 435     r = guestfs_mount (g, device, mountpoint);
 436     if (r == -1)
 437       return -1;
 438   }
 439   /* TestOutputStruct for mkfifo (0) */
 440   {
 441     char path[] = "/node";
 442     int r;
 443     suppress_error = 0;
 444     r = guestfs_mkfifo (g, 511, path);
 445     if (r == -1)
 446       return -1;
 447   }
 448   {
 449     char path[] = "/node";
 450     struct guestfs_stat *r;
 451     suppress_error = 0;
 452     r = guestfs_stat (g, path);
 453     if (r == NULL)
 454       return -1;
 455     if (r->mode != 4589) {
 456       fprintf (stderr, "test_mkfifo_0: mode was %d, expected 4589\n",
 457                (int) r->mode);
 458       return -1;
 459     }
 460     free (r);
 461   }
 462   return 0;
 463 }
 464
 465 static int test_mknod_0_skip (void)
 466 {
 467   const char *str;
 468
 469   str = getenv ("TEST_ONLY");
 470   if (str)
 471     return strstr (str, "mknod") == NULL;
 472   str = getenv ("SKIP_TEST_MKNOD_0");
 473   if (str && strcmp (str, "1") == 0) return 1;
 474   str = getenv ("SKIP_TEST_MKNOD");
 475   if (str && strcmp (str, "1") == 0) return 1;
 476   return 0;
 477 }
 478
 479 static int test_mknod_0 (void)
 480 {
 481   if (test_mknod_0_skip ()) {
 482     printf ("%s skipped (reason: environment variable set)\n", "test_mknod_0");
 483     return 0;
 484   }
 485
 486   /* InitBasicFS for test_mknod_0: create ext2 on /dev/sda1 */
 487   {
 488     char device[] = "/dev/sda";
 489     int r;
 490     suppress_error = 0;
 491     r = guestfs_blockdev_setrw (g, device);
 492     if (r == -1)
 493       return -1;
 494   }
 495   {
 496     int r;
 497     suppress_error = 0;
 498     r = guestfs_umount_all (g);
 499     if (r == -1)
 500       return -1;
 501   }
 502   {
 503     int r;
 504     suppress_error = 0;
 505     r = guestfs_lvm_remove_all (g);
 506     if (r == -1)
 507       return -1;
 508   }
 509   {
 510     char device[] = "/dev/sda";
 511     char lines_0[] = ",";
 512     char *lines[] = {
 513       lines_0,
 514       NULL
 515     };
 516     int r;
 517     suppress_error = 0;
 518     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 519     if (r == -1)
 520       return -1;
 521   }
 522   {
 523     char fstype[] = "ext2";
 524     char device[] = "/dev/sda1";
 525     int r;
 526     suppress_error = 0;
 527     r = guestfs_mkfs (g, fstype, device);
 528     if (r == -1)
 529       return -1;
 530   }
 531   {
 532     char device[] = "/dev/sda1";
 533     char mountpoint[] = "/";
 534     int r;
 535     suppress_error = 0;
 536     r = guestfs_mount (g, device, mountpoint);
 537     if (r == -1)
 538       return -1;
 539   }
 540   /* TestOutputStruct for mknod (0) */
 541   {
 542     char path[] = "/node";
 543     int r;
 544     suppress_error = 0;
 545     r = guestfs_mknod (g, 4607, 0, 0, path);
 546     if (r == -1)
 547       return -1;
 548   }
 549   {
 550     char path[] = "/node";
 551     struct guestfs_stat *r;
 552     suppress_error = 0;
 553     r = guestfs_stat (g, path);
 554     if (r == NULL)
 555       return -1;
 556     if (r->mode != 4589) {
 557       fprintf (stderr, "test_mknod_0: mode was %d, expected 4589\n",
 558                (int) r->mode);
 559       return -1;
 560     }
 561     free (r);
 562   }
 563   return 0;
 564 }
 565
 566 static int test_mknod_1_skip (void)
 567 {
 568   const char *str;
 569
 570   str = getenv ("TEST_ONLY");
 571   if (str)
 572     return strstr (str, "mknod") == NULL;
 573   str = getenv ("SKIP_TEST_MKNOD_1");
 574   if (str && strcmp (str, "1") == 0) return 1;
 575   str = getenv ("SKIP_TEST_MKNOD");
 576   if (str && strcmp (str, "1") == 0) return 1;
 577   return 0;
 578 }
 579
 580 static int test_mknod_1 (void)
 581 {
 582   if (test_mknod_1_skip ()) {
 583     printf ("%s skipped (reason: environment variable set)\n", "test_mknod_1");
 584     return 0;
 585   }
 586
 587   /* InitBasicFS for test_mknod_1: create ext2 on /dev/sda1 */
 588   {
 589     char device[] = "/dev/sda";
 590     int r;
 591     suppress_error = 0;
 592     r = guestfs_blockdev_setrw (g, device);
 593     if (r == -1)
 594       return -1;
 595   }
 596   {
 597     int r;
 598     suppress_error = 0;
 599     r = guestfs_umount_all (g);
 600     if (r == -1)
 601       return -1;
 602   }
 603   {
 604     int r;
 605     suppress_error = 0;
 606     r = guestfs_lvm_remove_all (g);
 607     if (r == -1)
 608       return -1;
 609   }
 610   {
 611     char device[] = "/dev/sda";
 612     char lines_0[] = ",";
 613     char *lines[] = {
 614       lines_0,
 615       NULL
 616     };
 617     int r;
 618     suppress_error = 0;
 619     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 620     if (r == -1)
 621       return -1;
 622   }
 623   {
 624     char fstype[] = "ext2";
 625     char device[] = "/dev/sda1";
 626     int r;
 627     suppress_error = 0;
 628     r = guestfs_mkfs (g, fstype, device);
 629     if (r == -1)
 630       return -1;
 631   }
 632   {
 633     char device[] = "/dev/sda1";
 634     char mountpoint[] = "/";
 635     int r;
 636     suppress_error = 0;
 637     r = guestfs_mount (g, device, mountpoint);
 638     if (r == -1)
 639       return -1;
 640   }
 641   /* TestOutputStruct for mknod (1) */
 642   {
 643     char path[] = "/node";
 644     int r;
 645     suppress_error = 0;
 646     r = guestfs_mknod (g, 25087, 66, 99, path);
 647     if (r == -1)
 648       return -1;
 649   }
 650   {
 651     char path[] = "/node";
 652     struct guestfs_stat *r;
 653     suppress_error = 0;
 654     r = guestfs_stat (g, path);
 655     if (r == NULL)
 656       return -1;
 657     if (r->mode != 25069) {
 658       fprintf (stderr, "test_mknod_1: mode was %d, expected 25069\n",
 659                (int) r->mode);
 660       return -1;
 661     }
 662     free (r);
 663   }
 664   return 0;
 665 }
 666
 667 static int test_mkswap_U_0_skip (void)
 668 {
 669   const char *str;
 670
 671   str = getenv ("TEST_ONLY");
 672   if (str)
 673     return strstr (str, "mkswap_U") == NULL;
 674   str = getenv ("SKIP_TEST_MKSWAP_U_0");
 675   if (str && strcmp (str, "1") == 0) return 1;
 676   str = getenv ("SKIP_TEST_MKSWAP_U");
 677   if (str && strcmp (str, "1") == 0) return 1;
 678   return 0;
 679 }
 680
 681 static int test_mkswap_U_0 (void)
 682 {
 683   if (test_mkswap_U_0_skip ()) {
 684     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
 685     return 0;
 686   }
 687
 688   /* InitNone|InitEmpty for test_mkswap_U_0 */
 689   {
 690     char device[] = "/dev/sda";
 691     int r;
 692     suppress_error = 0;
 693     r = guestfs_blockdev_setrw (g, device);
 694     if (r == -1)
 695       return -1;
 696   }
 697   {
 698     int r;
 699     suppress_error = 0;
 700     r = guestfs_umount_all (g);
 701     if (r == -1)
 702       return -1;
 703   }
 704   {
 705     int r;
 706     suppress_error = 0;
 707     r = guestfs_lvm_remove_all (g);
 708     if (r == -1)
 709       return -1;
 710   }
 711   /* TestRun for mkswap_U (0) */
 712   {
 713     char device[] = "/dev/sda";
 714     char lines_0[] = ",";
 715     char *lines[] = {
 716       lines_0,
 717       NULL
 718     };
 719     int r;
 720     suppress_error = 0;
 721     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 722     if (r == -1)
 723       return -1;
 724   }
 725   {
 726     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
 727     char device[] = "/dev/sda1";
 728     int r;
 729     suppress_error = 0;
 730     r = guestfs_mkswap_U (g, uuid, device);
 731     if (r == -1)
 732       return -1;
 733   }
 734   return 0;
 735 }
 736
 737 static int test_mkswap_L_0_skip (void)
 738 {
 739   const char *str;
 740
 741   str = getenv ("TEST_ONLY");
 742   if (str)
 743     return strstr (str, "mkswap_L") == NULL;
 744   str = getenv ("SKIP_TEST_MKSWAP_L_0");
 745   if (str && strcmp (str, "1") == 0) return 1;
 746   str = getenv ("SKIP_TEST_MKSWAP_L");
 747   if (str && strcmp (str, "1") == 0) return 1;
 748   return 0;
 749 }
 750
 751 static int test_mkswap_L_0 (void)
 752 {
 753   if (test_mkswap_L_0_skip ()) {
 754     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
 755     return 0;
 756   }
 757
 758   /* InitNone|InitEmpty for test_mkswap_L_0 */
 759   {
 760     char device[] = "/dev/sda";
 761     int r;
 762     suppress_error = 0;
 763     r = guestfs_blockdev_setrw (g, device);
 764     if (r == -1)
 765       return -1;
 766   }
 767   {
 768     int r;
 769     suppress_error = 0;
 770     r = guestfs_umount_all (g);
 771     if (r == -1)
 772       return -1;
 773   }
 774   {
 775     int r;
 776     suppress_error = 0;
 777     r = guestfs_lvm_remove_all (g);
 778     if (r == -1)
 779       return -1;
 780   }
 781   /* TestRun for mkswap_L (0) */
 782   {
 783     char device[] = "/dev/sda";
 784     char lines_0[] = ",";
 785     char *lines[] = {
 786       lines_0,
 787       NULL
 788     };
 789     int r;
 790     suppress_error = 0;
 791     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 792     if (r == -1)
 793       return -1;
 794   }
 795   {
 796     char label[] = "hello";
 797     char device[] = "/dev/sda1";
 798     int r;
 799     suppress_error = 0;
 800     r = guestfs_mkswap_L (g, label, device);
 801     if (r == -1)
 802       return -1;
 803   }
 804   return 0;
 805 }
 806
 807 static int test_mkswap_0_skip (void)
 808 {
 809   const char *str;
 810
 811   str = getenv ("TEST_ONLY");
 812   if (str)
 813     return strstr (str, "mkswap") == NULL;
 814   str = getenv ("SKIP_TEST_MKSWAP_0");
 815   if (str && strcmp (str, "1") == 0) return 1;
 816   str = getenv ("SKIP_TEST_MKSWAP");
 817   if (str && strcmp (str, "1") == 0) return 1;
 818   return 0;
 819 }
 820
 821 static int test_mkswap_0 (void)
 822 {
 823   if (test_mkswap_0_skip ()) {
 824     printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_0");
 825     return 0;
 826   }
 827
 828   /* InitNone|InitEmpty for test_mkswap_0 */
 829   {
 830     char device[] = "/dev/sda";
 831     int r;
 832     suppress_error = 0;
 833     r = guestfs_blockdev_setrw (g, device);
 834     if (r == -1)
 835       return -1;
 836   }
 837   {
 838     int r;
 839     suppress_error = 0;
 840     r = guestfs_umount_all (g);
 841     if (r == -1)
 842       return -1;
 843   }
 844   {
 845     int r;
 846     suppress_error = 0;
 847     r = guestfs_lvm_remove_all (g);
 848     if (r == -1)
 849       return -1;
 850   }
 851   /* TestRun for mkswap (0) */
 852   {
 853     char device[] = "/dev/sda";
 854     char lines_0[] = ",";
 855     char *lines[] = {
 856       lines_0,
 857       NULL
 858     };
 859     int r;
 860     suppress_error = 0;
 861     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 862     if (r == -1)
 863       return -1;
 864   }
 865   {
 866     char device[] = "/dev/sda1";
 867     int r;
 868     suppress_error = 0;
 869     r = guestfs_mkswap (g, device);
 870     if (r == -1)
 871       return -1;
 872   }
 873   return 0;
 874 }
 875
 876 static int test_initrd_list_0_skip (void)
 877 {
 878   const char *str;
 879
 880   str = getenv ("TEST_ONLY");
 881   if (str)
 882     return strstr (str, "initrd_list") == NULL;
 883   str = getenv ("SKIP_TEST_INITRD_LIST_0");
 884   if (str && strcmp (str, "1") == 0) return 1;
 885   str = getenv ("SKIP_TEST_INITRD_LIST");
 886   if (str && strcmp (str, "1") == 0) return 1;
 887   return 0;
 888 }
 889
 890 static int test_initrd_list_0 (void)
 891 {
 892   if (test_initrd_list_0_skip ()) {
 893     printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
 894     return 0;
 895   }
 896
 897   /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
 898   {
 899     char device[] = "/dev/sda";
 900     int r;
 901     suppress_error = 0;
 902     r = guestfs_blockdev_setrw (g, device);
 903     if (r == -1)
 904       return -1;
 905   }
 906   {
 907     int r;
 908     suppress_error = 0;
 909     r = guestfs_umount_all (g);
 910     if (r == -1)
 911       return -1;
 912   }
 913   {
 914     int r;
 915     suppress_error = 0;
 916     r = guestfs_lvm_remove_all (g);
 917     if (r == -1)
 918       return -1;
 919   }
 920   {
 921     char device[] = "/dev/sda";
 922     char lines_0[] = ",";
 923     char *lines[] = {
 924       lines_0,
 925       NULL
 926     };
 927     int r;
 928     suppress_error = 0;
 929     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
 930     if (r == -1)
 931       return -1;
 932   }
 933   {
 934     char fstype[] = "ext2";
 935     char device[] = "/dev/sda1";
 936     int r;
 937     suppress_error = 0;
 938     r = guestfs_mkfs (g, fstype, device);
 939     if (r == -1)
 940       return -1;
 941   }
 942   {
 943     char device[] = "/dev/sda1";
 944     char mountpoint[] = "/";
 945     int r;
 946     suppress_error = 0;
 947     r = guestfs_mount (g, device, mountpoint);
 948     if (r == -1)
 949       return -1;
 950   }
 951   /* TestOutputList for initrd_list (0) */
 952   {
 953     char options[] = "ro";
 954     char vfstype[] = "squashfs";
 955     char device[] = "/dev/sdd";
 956     char mountpoint[] = "/";
 957     int r;
 958     suppress_error = 0;
 959     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
 960     if (r == -1)
 961       return -1;
 962   }
 963   {
 964     char path[] = "/initrd";
 965     char **r;
 966     int i;
 967     suppress_error = 0;
 968     r = guestfs_initrd_list (g, path);
 969     if (r == NULL)
 970       return -1;
 971     if (!r[0]) {
 972       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 973       print_strings (r);
 974       return -1;
 975     }
 976     {
 977       char expected[] = "empty";
 978       if (strcmp (r[0], expected) != 0) {
 979         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
 980         return -1;
 981       }
 982     }
 983     if (!r[1]) {
 984       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 985       print_strings (r);
 986       return -1;
 987     }
 988     {
 989       char expected[] = "known-1";
 990       if (strcmp (r[1], expected) != 0) {
 991         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
 992         return -1;
 993       }
 994     }
 995     if (!r[2]) {
 996       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
 997       print_strings (r);
 998       return -1;
 999     }
1000     {
1001       char expected[] = "known-2";
1002       if (strcmp (r[2], expected) != 0) {
1003         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1004         return -1;
1005       }
1006     }
1007     if (!r[3]) {
1008       fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
1009       print_strings (r);
1010       return -1;
1011     }
1012     {
1013       char expected[] = "known-3";
1014       if (strcmp (r[3], expected) != 0) {
1015         fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1016         return -1;
1017       }
1018     }
1019     if (r[4] != NULL) {
1020       fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
1021       print_strings (r);
1022       return -1;
1023     }
1024     for (i = 0; r[i] != NULL; ++i)
1025       free (r[i]);
1026     free (r);
1027   }
1028   return 0;
1029 }
1030
1031 static int test_du_0_skip (void)
1032 {
1033   const char *str;
1034
1035   str = getenv ("TEST_ONLY");
1036   if (str)
1037     return strstr (str, "du") == NULL;
1038   str = getenv ("SKIP_TEST_DU_0");
1039   if (str && strcmp (str, "1") == 0) return 1;
1040   str = getenv ("SKIP_TEST_DU");
1041   if (str && strcmp (str, "1") == 0) return 1;
1042   return 0;
1043 }
1044
1045 static int test_du_0 (void)
1046 {
1047   if (test_du_0_skip ()) {
1048     printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
1049     return 0;
1050   }
1051
1052   /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
1053   {
1054     char device[] = "/dev/sda";
1055     int r;
1056     suppress_error = 0;
1057     r = guestfs_blockdev_setrw (g, device);
1058     if (r == -1)
1059       return -1;
1060   }
1061   {
1062     int r;
1063     suppress_error = 0;
1064     r = guestfs_umount_all (g);
1065     if (r == -1)
1066       return -1;
1067   }
1068   {
1069     int r;
1070     suppress_error = 0;
1071     r = guestfs_lvm_remove_all (g);
1072     if (r == -1)
1073       return -1;
1074   }
1075   {
1076     char device[] = "/dev/sda";
1077     char lines_0[] = ",";
1078     char *lines[] = {
1079       lines_0,
1080       NULL
1081     };
1082     int r;
1083     suppress_error = 0;
1084     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1085     if (r == -1)
1086       return -1;
1087   }
1088   {
1089     char fstype[] = "ext2";
1090     char device[] = "/dev/sda1";
1091     int r;
1092     suppress_error = 0;
1093     r = guestfs_mkfs (g, fstype, device);
1094     if (r == -1)
1095       return -1;
1096   }
1097   {
1098     char device[] = "/dev/sda1";
1099     char mountpoint[] = "/";
1100     int r;
1101     suppress_error = 0;
1102     r = guestfs_mount (g, device, mountpoint);
1103     if (r == -1)
1104       return -1;
1105   }
1106   /* TestOutputInt for du (0) */
1107   {
1108     char path[] = "/p";
1109     int r;
1110     suppress_error = 0;
1111     r = guestfs_mkdir (g, path);
1112     if (r == -1)
1113       return -1;
1114   }
1115   {
1116     char path[] = "/p";
1117     int64_t r;
1118     suppress_error = 0;
1119     r = guestfs_du (g, path);
1120     if (r == -1)
1121       return -1;
1122     if (r != 1) {
1123       fprintf (stderr, "test_du_0: expected 1 but got %d\n",               (int) r);
1124       return -1;
1125     }
1126   }
1127   return 0;
1128 }
1129
1130 static int test_tail_n_0_skip (void)
1131 {
1132   const char *str;
1133
1134   str = getenv ("TEST_ONLY");
1135   if (str)
1136     return strstr (str, "tail_n") == NULL;
1137   str = getenv ("SKIP_TEST_TAIL_N_0");
1138   if (str && strcmp (str, "1") == 0) return 1;
1139   str = getenv ("SKIP_TEST_TAIL_N");
1140   if (str && strcmp (str, "1") == 0) return 1;
1141   return 0;
1142 }
1143
1144 static int test_tail_n_0 (void)
1145 {
1146   if (test_tail_n_0_skip ()) {
1147     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
1148     return 0;
1149   }
1150
1151   /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
1152   {
1153     char device[] = "/dev/sda";
1154     int r;
1155     suppress_error = 0;
1156     r = guestfs_blockdev_setrw (g, device);
1157     if (r == -1)
1158       return -1;
1159   }
1160   {
1161     int r;
1162     suppress_error = 0;
1163     r = guestfs_umount_all (g);
1164     if (r == -1)
1165       return -1;
1166   }
1167   {
1168     int r;
1169     suppress_error = 0;
1170     r = guestfs_lvm_remove_all (g);
1171     if (r == -1)
1172       return -1;
1173   }
1174   {
1175     char device[] = "/dev/sda";
1176     char lines_0[] = ",";
1177     char *lines[] = {
1178       lines_0,
1179       NULL
1180     };
1181     int r;
1182     suppress_error = 0;
1183     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1184     if (r == -1)
1185       return -1;
1186   }
1187   {
1188     char fstype[] = "ext2";
1189     char device[] = "/dev/sda1";
1190     int r;
1191     suppress_error = 0;
1192     r = guestfs_mkfs (g, fstype, device);
1193     if (r == -1)
1194       return -1;
1195   }
1196   {
1197     char device[] = "/dev/sda1";
1198     char mountpoint[] = "/";
1199     int r;
1200     suppress_error = 0;
1201     r = guestfs_mount (g, device, mountpoint);
1202     if (r == -1)
1203       return -1;
1204   }
1205   /* TestOutputList for tail_n (0) */
1206   {
1207     char options[] = "ro";
1208     char vfstype[] = "squashfs";
1209     char device[] = "/dev/sdd";
1210     char mountpoint[] = "/";
1211     int r;
1212     suppress_error = 0;
1213     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1214     if (r == -1)
1215       return -1;
1216   }
1217   {
1218     char path[] = "/10klines";
1219     char **r;
1220     int i;
1221     suppress_error = 0;
1222     r = guestfs_tail_n (g, 3, path);
1223     if (r == NULL)
1224       return -1;
1225     if (!r[0]) {
1226       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1227       print_strings (r);
1228       return -1;
1229     }
1230     {
1231       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1232       if (strcmp (r[0], expected) != 0) {
1233         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1234         return -1;
1235       }
1236     }
1237     if (!r[1]) {
1238       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1239       print_strings (r);
1240       return -1;
1241     }
1242     {
1243       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1244       if (strcmp (r[1], expected) != 0) {
1245         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1246         return -1;
1247       }
1248     }
1249     if (!r[2]) {
1250       fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1251       print_strings (r);
1252       return -1;
1253     }
1254     {
1255       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1256       if (strcmp (r[2], expected) != 0) {
1257         fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1258         return -1;
1259       }
1260     }
1261     if (r[3] != NULL) {
1262       fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
1263       print_strings (r);
1264       return -1;
1265     }
1266     for (i = 0; r[i] != NULL; ++i)
1267       free (r[i]);
1268     free (r);
1269   }
1270   return 0;
1271 }
1272
1273 static int test_tail_n_1_skip (void)
1274 {
1275   const char *str;
1276
1277   str = getenv ("TEST_ONLY");
1278   if (str)
1279     return strstr (str, "tail_n") == NULL;
1280   str = getenv ("SKIP_TEST_TAIL_N_1");
1281   if (str && strcmp (str, "1") == 0) return 1;
1282   str = getenv ("SKIP_TEST_TAIL_N");
1283   if (str && strcmp (str, "1") == 0) return 1;
1284   return 0;
1285 }
1286
1287 static int test_tail_n_1 (void)
1288 {
1289   if (test_tail_n_1_skip ()) {
1290     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
1291     return 0;
1292   }
1293
1294   /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
1295   {
1296     char device[] = "/dev/sda";
1297     int r;
1298     suppress_error = 0;
1299     r = guestfs_blockdev_setrw (g, device);
1300     if (r == -1)
1301       return -1;
1302   }
1303   {
1304     int r;
1305     suppress_error = 0;
1306     r = guestfs_umount_all (g);
1307     if (r == -1)
1308       return -1;
1309   }
1310   {
1311     int r;
1312     suppress_error = 0;
1313     r = guestfs_lvm_remove_all (g);
1314     if (r == -1)
1315       return -1;
1316   }
1317   {
1318     char device[] = "/dev/sda";
1319     char lines_0[] = ",";
1320     char *lines[] = {
1321       lines_0,
1322       NULL
1323     };
1324     int r;
1325     suppress_error = 0;
1326     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1327     if (r == -1)
1328       return -1;
1329   }
1330   {
1331     char fstype[] = "ext2";
1332     char device[] = "/dev/sda1";
1333     int r;
1334     suppress_error = 0;
1335     r = guestfs_mkfs (g, fstype, device);
1336     if (r == -1)
1337       return -1;
1338   }
1339   {
1340     char device[] = "/dev/sda1";
1341     char mountpoint[] = "/";
1342     int r;
1343     suppress_error = 0;
1344     r = guestfs_mount (g, device, mountpoint);
1345     if (r == -1)
1346       return -1;
1347   }
1348   /* TestOutputList for tail_n (1) */
1349   {
1350     char options[] = "ro";
1351     char vfstype[] = "squashfs";
1352     char device[] = "/dev/sdd";
1353     char mountpoint[] = "/";
1354     int r;
1355     suppress_error = 0;
1356     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1357     if (r == -1)
1358       return -1;
1359   }
1360   {
1361     char path[] = "/10klines";
1362     char **r;
1363     int i;
1364     suppress_error = 0;
1365     r = guestfs_tail_n (g, -9998, path);
1366     if (r == NULL)
1367       return -1;
1368     if (!r[0]) {
1369       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1370       print_strings (r);
1371       return -1;
1372     }
1373     {
1374       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1375       if (strcmp (r[0], expected) != 0) {
1376         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1377         return -1;
1378       }
1379     }
1380     if (!r[1]) {
1381       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1382       print_strings (r);
1383       return -1;
1384     }
1385     {
1386       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1387       if (strcmp (r[1], expected) != 0) {
1388         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1389         return -1;
1390       }
1391     }
1392     if (!r[2]) {
1393       fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1394       print_strings (r);
1395       return -1;
1396     }
1397     {
1398       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1399       if (strcmp (r[2], expected) != 0) {
1400         fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1401         return -1;
1402       }
1403     }
1404     if (r[3] != NULL) {
1405       fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
1406       print_strings (r);
1407       return -1;
1408     }
1409     for (i = 0; r[i] != NULL; ++i)
1410       free (r[i]);
1411     free (r);
1412   }
1413   return 0;
1414 }
1415
1416 static int test_tail_n_2_skip (void)
1417 {
1418   const char *str;
1419
1420   str = getenv ("TEST_ONLY");
1421   if (str)
1422     return strstr (str, "tail_n") == NULL;
1423   str = getenv ("SKIP_TEST_TAIL_N_2");
1424   if (str && strcmp (str, "1") == 0) return 1;
1425   str = getenv ("SKIP_TEST_TAIL_N");
1426   if (str && strcmp (str, "1") == 0) return 1;
1427   return 0;
1428 }
1429
1430 static int test_tail_n_2 (void)
1431 {
1432   if (test_tail_n_2_skip ()) {
1433     printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
1434     return 0;
1435   }
1436
1437   /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
1438   {
1439     char device[] = "/dev/sda";
1440     int r;
1441     suppress_error = 0;
1442     r = guestfs_blockdev_setrw (g, device);
1443     if (r == -1)
1444       return -1;
1445   }
1446   {
1447     int r;
1448     suppress_error = 0;
1449     r = guestfs_umount_all (g);
1450     if (r == -1)
1451       return -1;
1452   }
1453   {
1454     int r;
1455     suppress_error = 0;
1456     r = guestfs_lvm_remove_all (g);
1457     if (r == -1)
1458       return -1;
1459   }
1460   {
1461     char device[] = "/dev/sda";
1462     char lines_0[] = ",";
1463     char *lines[] = {
1464       lines_0,
1465       NULL
1466     };
1467     int r;
1468     suppress_error = 0;
1469     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1470     if (r == -1)
1471       return -1;
1472   }
1473   {
1474     char fstype[] = "ext2";
1475     char device[] = "/dev/sda1";
1476     int r;
1477     suppress_error = 0;
1478     r = guestfs_mkfs (g, fstype, device);
1479     if (r == -1)
1480       return -1;
1481   }
1482   {
1483     char device[] = "/dev/sda1";
1484     char mountpoint[] = "/";
1485     int r;
1486     suppress_error = 0;
1487     r = guestfs_mount (g, device, mountpoint);
1488     if (r == -1)
1489       return -1;
1490   }
1491   /* TestOutputList for tail_n (2) */
1492   {
1493     char options[] = "ro";
1494     char vfstype[] = "squashfs";
1495     char device[] = "/dev/sdd";
1496     char mountpoint[] = "/";
1497     int r;
1498     suppress_error = 0;
1499     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1500     if (r == -1)
1501       return -1;
1502   }
1503   {
1504     char path[] = "/10klines";
1505     char **r;
1506     int i;
1507     suppress_error = 0;
1508     r = guestfs_tail_n (g, 0, path);
1509     if (r == NULL)
1510       return -1;
1511     if (r[0] != NULL) {
1512       fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1513       print_strings (r);
1514       return -1;
1515     }
1516     for (i = 0; r[i] != NULL; ++i)
1517       free (r[i]);
1518     free (r);
1519   }
1520   return 0;
1521 }
1522
1523 static int test_tail_0_skip (void)
1524 {
1525   const char *str;
1526
1527   str = getenv ("TEST_ONLY");
1528   if (str)
1529     return strstr (str, "tail") == NULL;
1530   str = getenv ("SKIP_TEST_TAIL_0");
1531   if (str && strcmp (str, "1") == 0) return 1;
1532   str = getenv ("SKIP_TEST_TAIL");
1533   if (str && strcmp (str, "1") == 0) return 1;
1534   return 0;
1535 }
1536
1537 static int test_tail_0 (void)
1538 {
1539   if (test_tail_0_skip ()) {
1540     printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
1541     return 0;
1542   }
1543
1544   /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1545   {
1546     char device[] = "/dev/sda";
1547     int r;
1548     suppress_error = 0;
1549     r = guestfs_blockdev_setrw (g, device);
1550     if (r == -1)
1551       return -1;
1552   }
1553   {
1554     int r;
1555     suppress_error = 0;
1556     r = guestfs_umount_all (g);
1557     if (r == -1)
1558       return -1;
1559   }
1560   {
1561     int r;
1562     suppress_error = 0;
1563     r = guestfs_lvm_remove_all (g);
1564     if (r == -1)
1565       return -1;
1566   }
1567   {
1568     char device[] = "/dev/sda";
1569     char lines_0[] = ",";
1570     char *lines[] = {
1571       lines_0,
1572       NULL
1573     };
1574     int r;
1575     suppress_error = 0;
1576     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1577     if (r == -1)
1578       return -1;
1579   }
1580   {
1581     char fstype[] = "ext2";
1582     char device[] = "/dev/sda1";
1583     int r;
1584     suppress_error = 0;
1585     r = guestfs_mkfs (g, fstype, device);
1586     if (r == -1)
1587       return -1;
1588   }
1589   {
1590     char device[] = "/dev/sda1";
1591     char mountpoint[] = "/";
1592     int r;
1593     suppress_error = 0;
1594     r = guestfs_mount (g, device, mountpoint);
1595     if (r == -1)
1596       return -1;
1597   }
1598   /* TestOutputList for tail (0) */
1599   {
1600     char options[] = "ro";
1601     char vfstype[] = "squashfs";
1602     char device[] = "/dev/sdd";
1603     char mountpoint[] = "/";
1604     int r;
1605     suppress_error = 0;
1606     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1607     if (r == -1)
1608       return -1;
1609   }
1610   {
1611     char path[] = "/10klines";
1612     char **r;
1613     int i;
1614     suppress_error = 0;
1615     r = guestfs_tail (g, path);
1616     if (r == NULL)
1617       return -1;
1618     if (!r[0]) {
1619       fprintf (stderr, "test_tail_0: short list returned from command\n");
1620       print_strings (r);
1621       return -1;
1622     }
1623     {
1624       char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1625       if (strcmp (r[0], expected) != 0) {
1626         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1627         return -1;
1628       }
1629     }
1630     if (!r[1]) {
1631       fprintf (stderr, "test_tail_0: short list returned from command\n");
1632       print_strings (r);
1633       return -1;
1634     }
1635     {
1636       char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1637       if (strcmp (r[1], expected) != 0) {
1638         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1639         return -1;
1640       }
1641     }
1642     if (!r[2]) {
1643       fprintf (stderr, "test_tail_0: short list returned from command\n");
1644       print_strings (r);
1645       return -1;
1646     }
1647     {
1648       char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1649       if (strcmp (r[2], expected) != 0) {
1650         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1651         return -1;
1652       }
1653     }
1654     if (!r[3]) {
1655       fprintf (stderr, "test_tail_0: short list returned from command\n");
1656       print_strings (r);
1657       return -1;
1658     }
1659     {
1660       char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1661       if (strcmp (r[3], expected) != 0) {
1662         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1663         return -1;
1664       }
1665     }
1666     if (!r[4]) {
1667       fprintf (stderr, "test_tail_0: short list returned from command\n");
1668       print_strings (r);
1669       return -1;
1670     }
1671     {
1672       char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1673       if (strcmp (r[4], expected) != 0) {
1674         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1675         return -1;
1676       }
1677     }
1678     if (!r[5]) {
1679       fprintf (stderr, "test_tail_0: short list returned from command\n");
1680       print_strings (r);
1681       return -1;
1682     }
1683     {
1684       char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1685       if (strcmp (r[5], expected) != 0) {
1686         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1687         return -1;
1688       }
1689     }
1690     if (!r[6]) {
1691       fprintf (stderr, "test_tail_0: short list returned from command\n");
1692       print_strings (r);
1693       return -1;
1694     }
1695     {
1696       char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1697       if (strcmp (r[6], expected) != 0) {
1698         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1699         return -1;
1700       }
1701     }
1702     if (!r[7]) {
1703       fprintf (stderr, "test_tail_0: short list returned from command\n");
1704       print_strings (r);
1705       return -1;
1706     }
1707     {
1708       char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1709       if (strcmp (r[7], expected) != 0) {
1710         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1711         return -1;
1712       }
1713     }
1714     if (!r[8]) {
1715       fprintf (stderr, "test_tail_0: short list returned from command\n");
1716       print_strings (r);
1717       return -1;
1718     }
1719     {
1720       char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1721       if (strcmp (r[8], expected) != 0) {
1722         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1723         return -1;
1724       }
1725     }
1726     if (!r[9]) {
1727       fprintf (stderr, "test_tail_0: short list returned from command\n");
1728       print_strings (r);
1729       return -1;
1730     }
1731     {
1732       char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1733       if (strcmp (r[9], expected) != 0) {
1734         fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1735         return -1;
1736       }
1737     }
1738     if (r[10] != NULL) {
1739       fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1740       print_strings (r);
1741       return -1;
1742     }
1743     for (i = 0; r[i] != NULL; ++i)
1744       free (r[i]);
1745     free (r);
1746   }
1747   return 0;
1748 }
1749
1750 static int test_head_n_0_skip (void)
1751 {
1752   const char *str;
1753
1754   str = getenv ("TEST_ONLY");
1755   if (str)
1756     return strstr (str, "head_n") == NULL;
1757   str = getenv ("SKIP_TEST_HEAD_N_0");
1758   if (str && strcmp (str, "1") == 0) return 1;
1759   str = getenv ("SKIP_TEST_HEAD_N");
1760   if (str && strcmp (str, "1") == 0) return 1;
1761   return 0;
1762 }
1763
1764 static int test_head_n_0 (void)
1765 {
1766   if (test_head_n_0_skip ()) {
1767     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1768     return 0;
1769   }
1770
1771   /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1772   {
1773     char device[] = "/dev/sda";
1774     int r;
1775     suppress_error = 0;
1776     r = guestfs_blockdev_setrw (g, device);
1777     if (r == -1)
1778       return -1;
1779   }
1780   {
1781     int r;
1782     suppress_error = 0;
1783     r = guestfs_umount_all (g);
1784     if (r == -1)
1785       return -1;
1786   }
1787   {
1788     int r;
1789     suppress_error = 0;
1790     r = guestfs_lvm_remove_all (g);
1791     if (r == -1)
1792       return -1;
1793   }
1794   {
1795     char device[] = "/dev/sda";
1796     char lines_0[] = ",";
1797     char *lines[] = {
1798       lines_0,
1799       NULL
1800     };
1801     int r;
1802     suppress_error = 0;
1803     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1804     if (r == -1)
1805       return -1;
1806   }
1807   {
1808     char fstype[] = "ext2";
1809     char device[] = "/dev/sda1";
1810     int r;
1811     suppress_error = 0;
1812     r = guestfs_mkfs (g, fstype, device);
1813     if (r == -1)
1814       return -1;
1815   }
1816   {
1817     char device[] = "/dev/sda1";
1818     char mountpoint[] = "/";
1819     int r;
1820     suppress_error = 0;
1821     r = guestfs_mount (g, device, mountpoint);
1822     if (r == -1)
1823       return -1;
1824   }
1825   /* TestOutputList for head_n (0) */
1826   {
1827     char options[] = "ro";
1828     char vfstype[] = "squashfs";
1829     char device[] = "/dev/sdd";
1830     char mountpoint[] = "/";
1831     int r;
1832     suppress_error = 0;
1833     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1834     if (r == -1)
1835       return -1;
1836   }
1837   {
1838     char path[] = "/10klines";
1839     char **r;
1840     int i;
1841     suppress_error = 0;
1842     r = guestfs_head_n (g, 3, path);
1843     if (r == NULL)
1844       return -1;
1845     if (!r[0]) {
1846       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1847       print_strings (r);
1848       return -1;
1849     }
1850     {
1851       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1852       if (strcmp (r[0], expected) != 0) {
1853         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1854         return -1;
1855       }
1856     }
1857     if (!r[1]) {
1858       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1859       print_strings (r);
1860       return -1;
1861     }
1862     {
1863       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1864       if (strcmp (r[1], expected) != 0) {
1865         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1866         return -1;
1867       }
1868     }
1869     if (!r[2]) {
1870       fprintf (stderr, "test_head_n_0: short list returned from command\n");
1871       print_strings (r);
1872       return -1;
1873     }
1874     {
1875       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1876       if (strcmp (r[2], expected) != 0) {
1877         fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1878         return -1;
1879       }
1880     }
1881     if (r[3] != NULL) {
1882       fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1883       print_strings (r);
1884       return -1;
1885     }
1886     for (i = 0; r[i] != NULL; ++i)
1887       free (r[i]);
1888     free (r);
1889   }
1890   return 0;
1891 }
1892
1893 static int test_head_n_1_skip (void)
1894 {
1895   const char *str;
1896
1897   str = getenv ("TEST_ONLY");
1898   if (str)
1899     return strstr (str, "head_n") == NULL;
1900   str = getenv ("SKIP_TEST_HEAD_N_1");
1901   if (str && strcmp (str, "1") == 0) return 1;
1902   str = getenv ("SKIP_TEST_HEAD_N");
1903   if (str && strcmp (str, "1") == 0) return 1;
1904   return 0;
1905 }
1906
1907 static int test_head_n_1 (void)
1908 {
1909   if (test_head_n_1_skip ()) {
1910     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1911     return 0;
1912   }
1913
1914   /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1915   {
1916     char device[] = "/dev/sda";
1917     int r;
1918     suppress_error = 0;
1919     r = guestfs_blockdev_setrw (g, device);
1920     if (r == -1)
1921       return -1;
1922   }
1923   {
1924     int r;
1925     suppress_error = 0;
1926     r = guestfs_umount_all (g);
1927     if (r == -1)
1928       return -1;
1929   }
1930   {
1931     int r;
1932     suppress_error = 0;
1933     r = guestfs_lvm_remove_all (g);
1934     if (r == -1)
1935       return -1;
1936   }
1937   {
1938     char device[] = "/dev/sda";
1939     char lines_0[] = ",";
1940     char *lines[] = {
1941       lines_0,
1942       NULL
1943     };
1944     int r;
1945     suppress_error = 0;
1946     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1947     if (r == -1)
1948       return -1;
1949   }
1950   {
1951     char fstype[] = "ext2";
1952     char device[] = "/dev/sda1";
1953     int r;
1954     suppress_error = 0;
1955     r = guestfs_mkfs (g, fstype, device);
1956     if (r == -1)
1957       return -1;
1958   }
1959   {
1960     char device[] = "/dev/sda1";
1961     char mountpoint[] = "/";
1962     int r;
1963     suppress_error = 0;
1964     r = guestfs_mount (g, device, mountpoint);
1965     if (r == -1)
1966       return -1;
1967   }
1968   /* TestOutputList for head_n (1) */
1969   {
1970     char options[] = "ro";
1971     char vfstype[] = "squashfs";
1972     char device[] = "/dev/sdd";
1973     char mountpoint[] = "/";
1974     int r;
1975     suppress_error = 0;
1976     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1977     if (r == -1)
1978       return -1;
1979   }
1980   {
1981     char path[] = "/10klines";
1982     char **r;
1983     int i;
1984     suppress_error = 0;
1985     r = guestfs_head_n (g, -9997, path);
1986     if (r == NULL)
1987       return -1;
1988     if (!r[0]) {
1989       fprintf (stderr, "test_head_n_1: short list returned from command\n");
1990       print_strings (r);
1991       return -1;
1992     }
1993     {
1994       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1995       if (strcmp (r[0], expected) != 0) {
1996         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1997         return -1;
1998       }
1999     }
2000     if (!r[1]) {
2001       fprintf (stderr, "test_head_n_1: short list returned from command\n");
2002       print_strings (r);
2003       return -1;
2004     }
2005     {
2006       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2007       if (strcmp (r[1], expected) != 0) {
2008         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2009         return -1;
2010       }
2011     }
2012     if (!r[2]) {
2013       fprintf (stderr, "test_head_n_1: short list returned from command\n");
2014       print_strings (r);
2015       return -1;
2016     }
2017     {
2018       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2019       if (strcmp (r[2], expected) != 0) {
2020         fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2021         return -1;
2022       }
2023     }
2024     if (r[3] != NULL) {
2025       fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
2026       print_strings (r);
2027       return -1;
2028     }
2029     for (i = 0; r[i] != NULL; ++i)
2030       free (r[i]);
2031     free (r);
2032   }
2033   return 0;
2034 }
2035
2036 static int test_head_n_2_skip (void)
2037 {
2038   const char *str;
2039
2040   str = getenv ("TEST_ONLY");
2041   if (str)
2042     return strstr (str, "head_n") == NULL;
2043   str = getenv ("SKIP_TEST_HEAD_N_2");
2044   if (str && strcmp (str, "1") == 0) return 1;
2045   str = getenv ("SKIP_TEST_HEAD_N");
2046   if (str && strcmp (str, "1") == 0) return 1;
2047   return 0;
2048 }
2049
2050 static int test_head_n_2 (void)
2051 {
2052   if (test_head_n_2_skip ()) {
2053     printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
2054     return 0;
2055   }
2056
2057   /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
2058   {
2059     char device[] = "/dev/sda";
2060     int r;
2061     suppress_error = 0;
2062     r = guestfs_blockdev_setrw (g, device);
2063     if (r == -1)
2064       return -1;
2065   }
2066   {
2067     int r;
2068     suppress_error = 0;
2069     r = guestfs_umount_all (g);
2070     if (r == -1)
2071       return -1;
2072   }
2073   {
2074     int r;
2075     suppress_error = 0;
2076     r = guestfs_lvm_remove_all (g);
2077     if (r == -1)
2078       return -1;
2079   }
2080   {
2081     char device[] = "/dev/sda";
2082     char lines_0[] = ",";
2083     char *lines[] = {
2084       lines_0,
2085       NULL
2086     };
2087     int r;
2088     suppress_error = 0;
2089     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2090     if (r == -1)
2091       return -1;
2092   }
2093   {
2094     char fstype[] = "ext2";
2095     char device[] = "/dev/sda1";
2096     int r;
2097     suppress_error = 0;
2098     r = guestfs_mkfs (g, fstype, device);
2099     if (r == -1)
2100       return -1;
2101   }
2102   {
2103     char device[] = "/dev/sda1";
2104     char mountpoint[] = "/";
2105     int r;
2106     suppress_error = 0;
2107     r = guestfs_mount (g, device, mountpoint);
2108     if (r == -1)
2109       return -1;
2110   }
2111   /* TestOutputList for head_n (2) */
2112   {
2113     char options[] = "ro";
2114     char vfstype[] = "squashfs";
2115     char device[] = "/dev/sdd";
2116     char mountpoint[] = "/";
2117     int r;
2118     suppress_error = 0;
2119     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2120     if (r == -1)
2121       return -1;
2122   }
2123   {
2124     char path[] = "/10klines";
2125     char **r;
2126     int i;
2127     suppress_error = 0;
2128     r = guestfs_head_n (g, 0, path);
2129     if (r == NULL)
2130       return -1;
2131     if (r[0] != NULL) {
2132       fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
2133       print_strings (r);
2134       return -1;
2135     }
2136     for (i = 0; r[i] != NULL; ++i)
2137       free (r[i]);
2138     free (r);
2139   }
2140   return 0;
2141 }
2142
2143 static int test_head_0_skip (void)
2144 {
2145   const char *str;
2146
2147   str = getenv ("TEST_ONLY");
2148   if (str)
2149     return strstr (str, "head") == NULL;
2150   str = getenv ("SKIP_TEST_HEAD_0");
2151   if (str && strcmp (str, "1") == 0) return 1;
2152   str = getenv ("SKIP_TEST_HEAD");
2153   if (str && strcmp (str, "1") == 0) return 1;
2154   return 0;
2155 }
2156
2157 static int test_head_0 (void)
2158 {
2159   if (test_head_0_skip ()) {
2160     printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
2161     return 0;
2162   }
2163
2164   /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
2165   {
2166     char device[] = "/dev/sda";
2167     int r;
2168     suppress_error = 0;
2169     r = guestfs_blockdev_setrw (g, device);
2170     if (r == -1)
2171       return -1;
2172   }
2173   {
2174     int r;
2175     suppress_error = 0;
2176     r = guestfs_umount_all (g);
2177     if (r == -1)
2178       return -1;
2179   }
2180   {
2181     int r;
2182     suppress_error = 0;
2183     r = guestfs_lvm_remove_all (g);
2184     if (r == -1)
2185       return -1;
2186   }
2187   {
2188     char device[] = "/dev/sda";
2189     char lines_0[] = ",";
2190     char *lines[] = {
2191       lines_0,
2192       NULL
2193     };
2194     int r;
2195     suppress_error = 0;
2196     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2197     if (r == -1)
2198       return -1;
2199   }
2200   {
2201     char fstype[] = "ext2";
2202     char device[] = "/dev/sda1";
2203     int r;
2204     suppress_error = 0;
2205     r = guestfs_mkfs (g, fstype, device);
2206     if (r == -1)
2207       return -1;
2208   }
2209   {
2210     char device[] = "/dev/sda1";
2211     char mountpoint[] = "/";
2212     int r;
2213     suppress_error = 0;
2214     r = guestfs_mount (g, device, mountpoint);
2215     if (r == -1)
2216       return -1;
2217   }
2218   /* TestOutputList for head (0) */
2219   {
2220     char options[] = "ro";
2221     char vfstype[] = "squashfs";
2222     char device[] = "/dev/sdd";
2223     char mountpoint[] = "/";
2224     int r;
2225     suppress_error = 0;
2226     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2227     if (r == -1)
2228       return -1;
2229   }
2230   {
2231     char path[] = "/10klines";
2232     char **r;
2233     int i;
2234     suppress_error = 0;
2235     r = guestfs_head (g, path);
2236     if (r == NULL)
2237       return -1;
2238     if (!r[0]) {
2239       fprintf (stderr, "test_head_0: short list returned from command\n");
2240       print_strings (r);
2241       return -1;
2242     }
2243     {
2244       char expected[] = "0abcdefghijklmnopqrstuvwxyz";
2245       if (strcmp (r[0], expected) != 0) {
2246         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2247         return -1;
2248       }
2249     }
2250     if (!r[1]) {
2251       fprintf (stderr, "test_head_0: short list returned from command\n");
2252       print_strings (r);
2253       return -1;
2254     }
2255     {
2256       char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2257       if (strcmp (r[1], expected) != 0) {
2258         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2259         return -1;
2260       }
2261     }
2262     if (!r[2]) {
2263       fprintf (stderr, "test_head_0: short list returned from command\n");
2264       print_strings (r);
2265       return -1;
2266     }
2267     {
2268       char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2269       if (strcmp (r[2], expected) != 0) {
2270         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2271         return -1;
2272       }
2273     }
2274     if (!r[3]) {
2275       fprintf (stderr, "test_head_0: short list returned from command\n");
2276       print_strings (r);
2277       return -1;
2278     }
2279     {
2280       char expected[] = "3abcdefghijklmnopqrstuvwxyz";
2281       if (strcmp (r[3], expected) != 0) {
2282         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2283         return -1;
2284       }
2285     }
2286     if (!r[4]) {
2287       fprintf (stderr, "test_head_0: short list returned from command\n");
2288       print_strings (r);
2289       return -1;
2290     }
2291     {
2292       char expected[] = "4abcdefghijklmnopqrstuvwxyz";
2293       if (strcmp (r[4], expected) != 0) {
2294         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
2295         return -1;
2296       }
2297     }
2298     if (!r[5]) {
2299       fprintf (stderr, "test_head_0: short list returned from command\n");
2300       print_strings (r);
2301       return -1;
2302     }
2303     {
2304       char expected[] = "5abcdefghijklmnopqrstuvwxyz";
2305       if (strcmp (r[5], expected) != 0) {
2306         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
2307         return -1;
2308       }
2309     }
2310     if (!r[6]) {
2311       fprintf (stderr, "test_head_0: short list returned from command\n");
2312       print_strings (r);
2313       return -1;
2314     }
2315     {
2316       char expected[] = "6abcdefghijklmnopqrstuvwxyz";
2317       if (strcmp (r[6], expected) != 0) {
2318         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
2319         return -1;
2320       }
2321     }
2322     if (!r[7]) {
2323       fprintf (stderr, "test_head_0: short list returned from command\n");
2324       print_strings (r);
2325       return -1;
2326     }
2327     {
2328       char expected[] = "7abcdefghijklmnopqrstuvwxyz";
2329       if (strcmp (r[7], expected) != 0) {
2330         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
2331         return -1;
2332       }
2333     }
2334     if (!r[8]) {
2335       fprintf (stderr, "test_head_0: short list returned from command\n");
2336       print_strings (r);
2337       return -1;
2338     }
2339     {
2340       char expected[] = "8abcdefghijklmnopqrstuvwxyz";
2341       if (strcmp (r[8], expected) != 0) {
2342         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
2343         return -1;
2344       }
2345     }
2346     if (!r[9]) {
2347       fprintf (stderr, "test_head_0: short list returned from command\n");
2348       print_strings (r);
2349       return -1;
2350     }
2351     {
2352       char expected[] = "9abcdefghijklmnopqrstuvwxyz";
2353       if (strcmp (r[9], expected) != 0) {
2354         fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
2355         return -1;
2356       }
2357     }
2358     if (r[10] != NULL) {
2359       fprintf (stderr, "test_head_0: extra elements returned from command\n");
2360       print_strings (r);
2361       return -1;
2362     }
2363     for (i = 0; r[i] != NULL; ++i)
2364       free (r[i]);
2365     free (r);
2366   }
2367   return 0;
2368 }
2369
2370 static int test_wc_c_0_skip (void)
2371 {
2372   const char *str;
2373
2374   str = getenv ("TEST_ONLY");
2375   if (str)
2376     return strstr (str, "wc_c") == NULL;
2377   str = getenv ("SKIP_TEST_WC_C_0");
2378   if (str && strcmp (str, "1") == 0) return 1;
2379   str = getenv ("SKIP_TEST_WC_C");
2380   if (str && strcmp (str, "1") == 0) return 1;
2381   return 0;
2382 }
2383
2384 static int test_wc_c_0 (void)
2385 {
2386   if (test_wc_c_0_skip ()) {
2387     printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
2388     return 0;
2389   }
2390
2391   /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
2392   {
2393     char device[] = "/dev/sda";
2394     int r;
2395     suppress_error = 0;
2396     r = guestfs_blockdev_setrw (g, device);
2397     if (r == -1)
2398       return -1;
2399   }
2400   {
2401     int r;
2402     suppress_error = 0;
2403     r = guestfs_umount_all (g);
2404     if (r == -1)
2405       return -1;
2406   }
2407   {
2408     int r;
2409     suppress_error = 0;
2410     r = guestfs_lvm_remove_all (g);
2411     if (r == -1)
2412       return -1;
2413   }
2414   {
2415     char device[] = "/dev/sda";
2416     char lines_0[] = ",";
2417     char *lines[] = {
2418       lines_0,
2419       NULL
2420     };
2421     int r;
2422     suppress_error = 0;
2423     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2424     if (r == -1)
2425       return -1;
2426   }
2427   {
2428     char fstype[] = "ext2";
2429     char device[] = "/dev/sda1";
2430     int r;
2431     suppress_error = 0;
2432     r = guestfs_mkfs (g, fstype, device);
2433     if (r == -1)
2434       return -1;
2435   }
2436   {
2437     char device[] = "/dev/sda1";
2438     char mountpoint[] = "/";
2439     int r;
2440     suppress_error = 0;
2441     r = guestfs_mount (g, device, mountpoint);
2442     if (r == -1)
2443       return -1;
2444   }
2445   /* TestOutputInt for wc_c (0) */
2446   {
2447     char options[] = "ro";
2448     char vfstype[] = "squashfs";
2449     char device[] = "/dev/sdd";
2450     char mountpoint[] = "/";
2451     int r;
2452     suppress_error = 0;
2453     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2454     if (r == -1)
2455       return -1;
2456   }
2457   {
2458     char path[] = "/100kallspaces";
2459     int r;
2460     suppress_error = 0;
2461     r = guestfs_wc_c (g, path);
2462     if (r == -1)
2463       return -1;
2464     if (r != 102400) {
2465       fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n",               (int) r);
2466       return -1;
2467     }
2468   }
2469   return 0;
2470 }
2471
2472 static int test_wc_w_0_skip (void)
2473 {
2474   const char *str;
2475
2476   str = getenv ("TEST_ONLY");
2477   if (str)
2478     return strstr (str, "wc_w") == NULL;
2479   str = getenv ("SKIP_TEST_WC_W_0");
2480   if (str && strcmp (str, "1") == 0) return 1;
2481   str = getenv ("SKIP_TEST_WC_W");
2482   if (str && strcmp (str, "1") == 0) return 1;
2483   return 0;
2484 }
2485
2486 static int test_wc_w_0 (void)
2487 {
2488   if (test_wc_w_0_skip ()) {
2489     printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
2490     return 0;
2491   }
2492
2493   /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
2494   {
2495     char device[] = "/dev/sda";
2496     int r;
2497     suppress_error = 0;
2498     r = guestfs_blockdev_setrw (g, device);
2499     if (r == -1)
2500       return -1;
2501   }
2502   {
2503     int r;
2504     suppress_error = 0;
2505     r = guestfs_umount_all (g);
2506     if (r == -1)
2507       return -1;
2508   }
2509   {
2510     int r;
2511     suppress_error = 0;
2512     r = guestfs_lvm_remove_all (g);
2513     if (r == -1)
2514       return -1;
2515   }
2516   {
2517     char device[] = "/dev/sda";
2518     char lines_0[] = ",";
2519     char *lines[] = {
2520       lines_0,
2521       NULL
2522     };
2523     int r;
2524     suppress_error = 0;
2525     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2526     if (r == -1)
2527       return -1;
2528   }
2529   {
2530     char fstype[] = "ext2";
2531     char device[] = "/dev/sda1";
2532     int r;
2533     suppress_error = 0;
2534     r = guestfs_mkfs (g, fstype, device);
2535     if (r == -1)
2536       return -1;
2537   }
2538   {
2539     char device[] = "/dev/sda1";
2540     char mountpoint[] = "/";
2541     int r;
2542     suppress_error = 0;
2543     r = guestfs_mount (g, device, mountpoint);
2544     if (r == -1)
2545       return -1;
2546   }
2547   /* TestOutputInt for wc_w (0) */
2548   {
2549     char options[] = "ro";
2550     char vfstype[] = "squashfs";
2551     char device[] = "/dev/sdd";
2552     char mountpoint[] = "/";
2553     int r;
2554     suppress_error = 0;
2555     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2556     if (r == -1)
2557       return -1;
2558   }
2559   {
2560     char path[] = "/10klines";
2561     int r;
2562     suppress_error = 0;
2563     r = guestfs_wc_w (g, path);
2564     if (r == -1)
2565       return -1;
2566     if (r != 10000) {
2567       fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n",               (int) r);
2568       return -1;
2569     }
2570   }
2571   return 0;
2572 }
2573
2574 static int test_wc_l_0_skip (void)
2575 {
2576   const char *str;
2577
2578   str = getenv ("TEST_ONLY");
2579   if (str)
2580     return strstr (str, "wc_l") == NULL;
2581   str = getenv ("SKIP_TEST_WC_L_0");
2582   if (str && strcmp (str, "1") == 0) return 1;
2583   str = getenv ("SKIP_TEST_WC_L");
2584   if (str && strcmp (str, "1") == 0) return 1;
2585   return 0;
2586 }
2587
2588 static int test_wc_l_0 (void)
2589 {
2590   if (test_wc_l_0_skip ()) {
2591     printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
2592     return 0;
2593   }
2594
2595   /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2596   {
2597     char device[] = "/dev/sda";
2598     int r;
2599     suppress_error = 0;
2600     r = guestfs_blockdev_setrw (g, device);
2601     if (r == -1)
2602       return -1;
2603   }
2604   {
2605     int r;
2606     suppress_error = 0;
2607     r = guestfs_umount_all (g);
2608     if (r == -1)
2609       return -1;
2610   }
2611   {
2612     int r;
2613     suppress_error = 0;
2614     r = guestfs_lvm_remove_all (g);
2615     if (r == -1)
2616       return -1;
2617   }
2618   {
2619     char device[] = "/dev/sda";
2620     char lines_0[] = ",";
2621     char *lines[] = {
2622       lines_0,
2623       NULL
2624     };
2625     int r;
2626     suppress_error = 0;
2627     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2628     if (r == -1)
2629       return -1;
2630   }
2631   {
2632     char fstype[] = "ext2";
2633     char device[] = "/dev/sda1";
2634     int r;
2635     suppress_error = 0;
2636     r = guestfs_mkfs (g, fstype, device);
2637     if (r == -1)
2638       return -1;
2639   }
2640   {
2641     char device[] = "/dev/sda1";
2642     char mountpoint[] = "/";
2643     int r;
2644     suppress_error = 0;
2645     r = guestfs_mount (g, device, mountpoint);
2646     if (r == -1)
2647       return -1;
2648   }
2649   /* TestOutputInt for wc_l (0) */
2650   {
2651     char options[] = "ro";
2652     char vfstype[] = "squashfs";
2653     char device[] = "/dev/sdd";
2654     char mountpoint[] = "/";
2655     int r;
2656     suppress_error = 0;
2657     r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2658     if (r == -1)
2659       return -1;
2660   }
2661   {
2662     char path[] = "/10klines";
2663     int r;
2664     suppress_error = 0;
2665     r = guestfs_wc_l (g, path);
2666     if (r == -1)
2667       return -1;
2668     if (r != 10000) {
2669       fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n",               (int) r);
2670       return -1;
2671     }
2672   }
2673   return 0;
2674 }
2675
2676 static int test_mkdtemp_0_skip (void)
2677 {
2678   const char *str;
2679
2680   str = getenv ("TEST_ONLY");
2681   if (str)
2682     return strstr (str, "mkdtemp") == NULL;
2683   str = getenv ("SKIP_TEST_MKDTEMP_0");
2684   if (str && strcmp (str, "1") == 0) return 1;
2685   str = getenv ("SKIP_TEST_MKDTEMP");
2686   if (str && strcmp (str, "1") == 0) return 1;
2687   return 0;
2688 }
2689
2690 static int test_mkdtemp_0 (void)
2691 {
2692   if (test_mkdtemp_0_skip ()) {
2693     printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2694     return 0;
2695   }
2696
2697   /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2698   {
2699     char device[] = "/dev/sda";
2700     int r;
2701     suppress_error = 0;
2702     r = guestfs_blockdev_setrw (g, device);
2703     if (r == -1)
2704       return -1;
2705   }
2706   {
2707     int r;
2708     suppress_error = 0;
2709     r = guestfs_umount_all (g);
2710     if (r == -1)
2711       return -1;
2712   }
2713   {
2714     int r;
2715     suppress_error = 0;
2716     r = guestfs_lvm_remove_all (g);
2717     if (r == -1)
2718       return -1;
2719   }
2720   {
2721     char device[] = "/dev/sda";
2722     char lines_0[] = ",";
2723     char *lines[] = {
2724       lines_0,
2725       NULL
2726     };
2727     int r;
2728     suppress_error = 0;
2729     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2730     if (r == -1)
2731       return -1;
2732   }
2733   {
2734     char fstype[] = "ext2";
2735     char device[] = "/dev/sda1";
2736     int r;
2737     suppress_error = 0;
2738     r = guestfs_mkfs (g, fstype, device);
2739     if (r == -1)
2740       return -1;
2741   }
2742   {
2743     char device[] = "/dev/sda1";
2744     char mountpoint[] = "/";
2745     int r;
2746     suppress_error = 0;
2747     r = guestfs_mount (g, device, mountpoint);
2748     if (r == -1)
2749       return -1;
2750   }
2751   /* TestRun for mkdtemp (0) */
2752   {
2753     char path[] = "/tmp";
2754     int r;
2755     suppress_error = 0;
2756     r = guestfs_mkdir (g, path);
2757     if (r == -1)
2758       return -1;
2759   }
2760   {
2761     char template[] = "/tmp/tmpXXXXXX";
2762     char *r;
2763     suppress_error = 0;
2764     r = guestfs_mkdtemp (g, template);
2765     if (r == NULL)
2766       return -1;
2767     free (r);
2768   }
2769   return 0;
2770 }
2771
2772 static int test_scrub_file_0_skip (void)
2773 {
2774   const char *str;
2775
2776   str = getenv ("TEST_ONLY");
2777   if (str)
2778     return strstr (str, "scrub_file") == NULL;
2779   str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2780   if (str && strcmp (str, "1") == 0) return 1;
2781   str = getenv ("SKIP_TEST_SCRUB_FILE");
2782   if (str && strcmp (str, "1") == 0) return 1;
2783   return 0;
2784 }
2785
2786 static int test_scrub_file_0 (void)
2787 {
2788   if (test_scrub_file_0_skip ()) {
2789     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2790     return 0;
2791   }
2792
2793   /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2794   {
2795     char device[] = "/dev/sda";
2796     int r;
2797     suppress_error = 0;
2798     r = guestfs_blockdev_setrw (g, device);
2799     if (r == -1)
2800       return -1;
2801   }
2802   {
2803     int r;
2804     suppress_error = 0;
2805     r = guestfs_umount_all (g);
2806     if (r == -1)
2807       return -1;
2808   }
2809   {
2810     int r;
2811     suppress_error = 0;
2812     r = guestfs_lvm_remove_all (g);
2813     if (r == -1)
2814       return -1;
2815   }
2816   {
2817     char device[] = "/dev/sda";
2818     char lines_0[] = ",";
2819     char *lines[] = {
2820       lines_0,
2821       NULL
2822     };
2823     int r;
2824     suppress_error = 0;
2825     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2826     if (r == -1)
2827       return -1;
2828   }
2829   {
2830     char fstype[] = "ext2";
2831     char device[] = "/dev/sda1";
2832     int r;
2833     suppress_error = 0;
2834     r = guestfs_mkfs (g, fstype, device);
2835     if (r == -1)
2836       return -1;
2837   }
2838   {
2839     char device[] = "/dev/sda1";
2840     char mountpoint[] = "/";
2841     int r;
2842     suppress_error = 0;
2843     r = guestfs_mount (g, device, mountpoint);
2844     if (r == -1)
2845       return -1;
2846   }
2847   /* TestRun for scrub_file (0) */
2848   {
2849     char path[] = "/file";
2850     char content[] = "content";
2851     int r;
2852     suppress_error = 0;
2853     r = guestfs_write_file (g, path, content, 0);
2854     if (r == -1)
2855       return -1;
2856   }
2857   {
2858     char file[] = "/file";
2859     int r;
2860     suppress_error = 0;
2861     r = guestfs_scrub_file (g, file);
2862     if (r == -1)
2863       return -1;
2864   }
2865   return 0;
2866 }
2867
2868 static int test_scrub_device_0_skip (void)
2869 {
2870   const char *str;
2871
2872   str = getenv ("TEST_ONLY");
2873   if (str)
2874     return strstr (str, "scrub_device") == NULL;
2875   str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2876   if (str && strcmp (str, "1") == 0) return 1;
2877   str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2878   if (str && strcmp (str, "1") == 0) return 1;
2879   return 0;
2880 }
2881
2882 static int test_scrub_device_0 (void)
2883 {
2884   if (test_scrub_device_0_skip ()) {
2885     printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2886     return 0;
2887   }
2888
2889   /* InitNone|InitEmpty for test_scrub_device_0 */
2890   {
2891     char device[] = "/dev/sda";
2892     int r;
2893     suppress_error = 0;
2894     r = guestfs_blockdev_setrw (g, device);
2895     if (r == -1)
2896       return -1;
2897   }
2898   {
2899     int r;
2900     suppress_error = 0;
2901     r = guestfs_umount_all (g);
2902     if (r == -1)
2903       return -1;
2904   }
2905   {
2906     int r;
2907     suppress_error = 0;
2908     r = guestfs_lvm_remove_all (g);
2909     if (r == -1)
2910       return -1;
2911   }
2912   /* TestRun for scrub_device (0) */
2913   {
2914     char device[] = "/dev/sdc";
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_scrub_device (g, device);
2918     if (r == -1)
2919       return -1;
2920   }
2921   return 0;
2922 }
2923
2924 static int test_glob_expand_0_skip (void)
2925 {
2926   const char *str;
2927
2928   str = getenv ("TEST_ONLY");
2929   if (str)
2930     return strstr (str, "glob_expand") == NULL;
2931   str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2932   if (str && strcmp (str, "1") == 0) return 1;
2933   str = getenv ("SKIP_TEST_GLOB_EXPAND");
2934   if (str && strcmp (str, "1") == 0) return 1;
2935   return 0;
2936 }
2937
2938 static int test_glob_expand_0 (void)
2939 {
2940   if (test_glob_expand_0_skip ()) {
2941     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2942     return 0;
2943   }
2944
2945   /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2946   {
2947     char device[] = "/dev/sda";
2948     int r;
2949     suppress_error = 0;
2950     r = guestfs_blockdev_setrw (g, device);
2951     if (r == -1)
2952       return -1;
2953   }
2954   {
2955     int r;
2956     suppress_error = 0;
2957     r = guestfs_umount_all (g);
2958     if (r == -1)
2959       return -1;
2960   }
2961   {
2962     int r;
2963     suppress_error = 0;
2964     r = guestfs_lvm_remove_all (g);
2965     if (r == -1)
2966       return -1;
2967   }
2968   {
2969     char device[] = "/dev/sda";
2970     char lines_0[] = ",";
2971     char *lines[] = {
2972       lines_0,
2973       NULL
2974     };
2975     int r;
2976     suppress_error = 0;
2977     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2978     if (r == -1)
2979       return -1;
2980   }
2981   {
2982     char fstype[] = "ext2";
2983     char device[] = "/dev/sda1";
2984     int r;
2985     suppress_error = 0;
2986     r = guestfs_mkfs (g, fstype, device);
2987     if (r == -1)
2988       return -1;
2989   }
2990   {
2991     char device[] = "/dev/sda1";
2992     char mountpoint[] = "/";
2993     int r;
2994     suppress_error = 0;
2995     r = guestfs_mount (g, device, mountpoint);
2996     if (r == -1)
2997       return -1;
2998   }
2999   /* TestOutputList for glob_expand (0) */
3000   {
3001     char path[] = "/a/b/c";
3002     int r;
3003     suppress_error = 0;
3004     r = guestfs_mkdir_p (g, path);
3005     if (r == -1)
3006       return -1;
3007   }
3008   {
3009     char path[] = "/a/b/c/d";
3010     int r;
3011     suppress_error = 0;
3012     r = guestfs_touch (g, path);
3013     if (r == -1)
3014       return -1;
3015   }
3016   {
3017     char path[] = "/a/b/c/e";
3018     int r;
3019     suppress_error = 0;
3020     r = guestfs_touch (g, path);
3021     if (r == -1)
3022       return -1;
3023   }
3024   {
3025     char pattern[] = "/a/b/c/*";
3026     char **r;
3027     int i;
3028     suppress_error = 0;
3029     r = guestfs_glob_expand (g, pattern);
3030     if (r == NULL)
3031       return -1;
3032     if (!r[0]) {
3033       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3034       print_strings (r);
3035       return -1;
3036     }
3037     {
3038       char expected[] = "/a/b/c/d";
3039       if (strcmp (r[0], expected) != 0) {
3040         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3041         return -1;
3042       }
3043     }
3044     if (!r[1]) {
3045       fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3046       print_strings (r);
3047       return -1;
3048     }
3049     {
3050       char expected[] = "/a/b/c/e";
3051       if (strcmp (r[1], expected) != 0) {
3052         fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3053         return -1;
3054       }
3055     }
3056     if (r[2] != NULL) {
3057       fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
3058       print_strings (r);
3059       return -1;
3060     }
3061     for (i = 0; r[i] != NULL; ++i)
3062       free (r[i]);
3063     free (r);
3064   }
3065   return 0;
3066 }
3067
3068 static int test_glob_expand_1_skip (void)
3069 {
3070   const char *str;
3071
3072   str = getenv ("TEST_ONLY");
3073   if (str)
3074     return strstr (str, "glob_expand") == NULL;
3075   str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
3076   if (str && strcmp (str, "1") == 0) return 1;
3077   str = getenv ("SKIP_TEST_GLOB_EXPAND");
3078   if (str && strcmp (str, "1") == 0) return 1;
3079   return 0;
3080 }
3081
3082 static int test_glob_expand_1 (void)
3083 {
3084   if (test_glob_expand_1_skip ()) {
3085     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
3086     return 0;
3087   }
3088
3089   /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
3090   {
3091     char device[] = "/dev/sda";
3092     int r;
3093     suppress_error = 0;
3094     r = guestfs_blockdev_setrw (g, device);
3095     if (r == -1)
3096       return -1;
3097   }
3098   {
3099     int r;
3100     suppress_error = 0;
3101     r = guestfs_umount_all (g);
3102     if (r == -1)
3103       return -1;
3104   }
3105   {
3106     int r;
3107     suppress_error = 0;
3108     r = guestfs_lvm_remove_all (g);
3109     if (r == -1)
3110       return -1;
3111   }
3112   {
3113     char device[] = "/dev/sda";
3114     char lines_0[] = ",";
3115     char *lines[] = {
3116       lines_0,
3117       NULL
3118     };
3119     int r;
3120     suppress_error = 0;
3121     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3122     if (r == -1)
3123       return -1;
3124   }
3125   {
3126     char fstype[] = "ext2";
3127     char device[] = "/dev/sda1";
3128     int r;
3129     suppress_error = 0;
3130     r = guestfs_mkfs (g, fstype, device);
3131     if (r == -1)
3132       return -1;
3133   }
3134   {
3135     char device[] = "/dev/sda1";
3136     char mountpoint[] = "/";
3137     int r;
3138     suppress_error = 0;
3139     r = guestfs_mount (g, device, mountpoint);
3140     if (r == -1)
3141       return -1;
3142   }
3143   /* TestOutputList for glob_expand (1) */
3144   {
3145     char path[] = "/a/b/c";
3146     int r;
3147     suppress_error = 0;
3148     r = guestfs_mkdir_p (g, path);
3149     if (r == -1)
3150       return -1;
3151   }
3152   {
3153     char path[] = "/a/b/c/d";
3154     int r;
3155     suppress_error = 0;
3156     r = guestfs_touch (g, path);
3157     if (r == -1)
3158       return -1;
3159   }
3160   {
3161     char path[] = "/a/b/c/e";
3162     int r;
3163     suppress_error = 0;
3164     r = guestfs_touch (g, path);
3165     if (r == -1)
3166       return -1;
3167   }
3168   {
3169     char pattern[] = "/a/*/c/*";
3170     char **r;
3171     int i;
3172     suppress_error = 0;
3173     r = guestfs_glob_expand (g, pattern);
3174     if (r == NULL)
3175       return -1;
3176     if (!r[0]) {
3177       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3178       print_strings (r);
3179       return -1;
3180     }
3181     {
3182       char expected[] = "/a/b/c/d";
3183       if (strcmp (r[0], expected) != 0) {
3184         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3185         return -1;
3186       }
3187     }
3188     if (!r[1]) {
3189       fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3190       print_strings (r);
3191       return -1;
3192     }
3193     {
3194       char expected[] = "/a/b/c/e";
3195       if (strcmp (r[1], expected) != 0) {
3196         fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3197         return -1;
3198       }
3199     }
3200     if (r[2] != NULL) {
3201       fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
3202       print_strings (r);
3203       return -1;
3204     }
3205     for (i = 0; r[i] != NULL; ++i)
3206       free (r[i]);
3207     free (r);
3208   }
3209   return 0;
3210 }
3211
3212 static int test_glob_expand_2_skip (void)
3213 {
3214   const char *str;
3215
3216   str = getenv ("TEST_ONLY");
3217   if (str)
3218     return strstr (str, "glob_expand") == NULL;
3219   str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
3220   if (str && strcmp (str, "1") == 0) return 1;
3221   str = getenv ("SKIP_TEST_GLOB_EXPAND");
3222   if (str && strcmp (str, "1") == 0) return 1;
3223   return 0;
3224 }
3225
3226 static int test_glob_expand_2 (void)
3227 {
3228   if (test_glob_expand_2_skip ()) {
3229     printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
3230     return 0;
3231   }
3232
3233   /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
3234   {
3235     char device[] = "/dev/sda";
3236     int r;
3237     suppress_error = 0;
3238     r = guestfs_blockdev_setrw (g, device);
3239     if (r == -1)
3240       return -1;
3241   }
3242   {
3243     int r;
3244     suppress_error = 0;
3245     r = guestfs_umount_all (g);
3246     if (r == -1)
3247       return -1;
3248   }
3249   {
3250     int r;
3251     suppress_error = 0;
3252     r = guestfs_lvm_remove_all (g);
3253     if (r == -1)
3254       return -1;
3255   }
3256   {
3257     char device[] = "/dev/sda";
3258     char lines_0[] = ",";
3259     char *lines[] = {
3260       lines_0,
3261       NULL
3262     };
3263     int r;
3264     suppress_error = 0;
3265     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3266     if (r == -1)
3267       return -1;
3268   }
3269   {
3270     char fstype[] = "ext2";
3271     char device[] = "/dev/sda1";
3272     int r;
3273     suppress_error = 0;
3274     r = guestfs_mkfs (g, fstype, device);
3275     if (r == -1)
3276       return -1;
3277   }
3278   {
3279     char device[] = "/dev/sda1";
3280     char mountpoint[] = "/";
3281     int r;
3282     suppress_error = 0;
3283     r = guestfs_mount (g, device, mountpoint);
3284     if (r == -1)
3285       return -1;
3286   }
3287   /* TestOutputList for glob_expand (2) */
3288   {
3289     char path[] = "/a/b/c";
3290     int r;
3291     suppress_error = 0;
3292     r = guestfs_mkdir_p (g, path);
3293     if (r == -1)
3294       return -1;
3295   }
3296   {
3297     char path[] = "/a/b/c/d";
3298     int r;
3299     suppress_error = 0;
3300     r = guestfs_touch (g, path);
3301     if (r == -1)
3302       return -1;
3303   }
3304   {
3305     char path[] = "/a/b/c/e";
3306     int r;
3307     suppress_error = 0;
3308     r = guestfs_touch (g, path);
3309     if (r == -1)
3310       return -1;
3311   }
3312   {
3313     char pattern[] = "/a/*/x/*";
3314     char **r;
3315     int i;
3316     suppress_error = 0;
3317     r = guestfs_glob_expand (g, pattern);
3318     if (r == NULL)
3319       return -1;
3320     if (r[0] != NULL) {
3321       fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
3322       print_strings (r);
3323       return -1;
3324     }
3325     for (i = 0; r[i] != NULL; ++i)
3326       free (r[i]);
3327     free (r);
3328   }
3329   return 0;
3330 }
3331
3332 static int test_ntfs_3g_probe_0_skip (void)
3333 {
3334   const char *str;
3335
3336   str = getenv ("TEST_ONLY");
3337   if (str)
3338     return strstr (str, "ntfs_3g_probe") == NULL;
3339   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
3340   if (str && strcmp (str, "1") == 0) return 1;
3341   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3342   if (str && strcmp (str, "1") == 0) return 1;
3343   return 0;
3344 }
3345
3346 static int test_ntfs_3g_probe_0 (void)
3347 {
3348   if (test_ntfs_3g_probe_0_skip ()) {
3349     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
3350     return 0;
3351   }
3352
3353   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
3354   {
3355     char device[] = "/dev/sda";
3356     int r;
3357     suppress_error = 0;
3358     r = guestfs_blockdev_setrw (g, device);
3359     if (r == -1)
3360       return -1;
3361   }
3362   {
3363     int r;
3364     suppress_error = 0;
3365     r = guestfs_umount_all (g);
3366     if (r == -1)
3367       return -1;
3368   }
3369   {
3370     int r;
3371     suppress_error = 0;
3372     r = guestfs_lvm_remove_all (g);
3373     if (r == -1)
3374       return -1;
3375   }
3376   /* TestOutputInt for ntfs_3g_probe (0) */
3377   {
3378     char device[] = "/dev/sda";
3379     char lines_0[] = ",";
3380     char *lines[] = {
3381       lines_0,
3382       NULL
3383     };
3384     int r;
3385     suppress_error = 0;
3386     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3387     if (r == -1)
3388       return -1;
3389   }
3390   {
3391     char fstype[] = "ntfs";
3392     char device[] = "/dev/sda1";
3393     int r;
3394     suppress_error = 0;
3395     r = guestfs_mkfs (g, fstype, device);
3396     if (r == -1)
3397       return -1;
3398   }
3399   {
3400     char device[] = "/dev/sda1";
3401     int r;
3402     suppress_error = 0;
3403     r = guestfs_ntfs_3g_probe (g, 1, device);
3404     if (r == -1)
3405       return -1;
3406     if (r != 0) {
3407       fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
3408       return -1;
3409     }
3410   }
3411   return 0;
3412 }
3413
3414 static int test_ntfs_3g_probe_1_skip (void)
3415 {
3416   const char *str;
3417
3418   str = getenv ("TEST_ONLY");
3419   if (str)
3420     return strstr (str, "ntfs_3g_probe") == NULL;
3421   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
3422   if (str && strcmp (str, "1") == 0) return 1;
3423   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3424   if (str && strcmp (str, "1") == 0) return 1;
3425   return 0;
3426 }
3427
3428 static int test_ntfs_3g_probe_1 (void)
3429 {
3430   if (test_ntfs_3g_probe_1_skip ()) {
3431     printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
3432     return 0;
3433   }
3434
3435   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
3436   {
3437     char device[] = "/dev/sda";
3438     int r;
3439     suppress_error = 0;
3440     r = guestfs_blockdev_setrw (g, device);
3441     if (r == -1)
3442       return -1;
3443   }
3444   {
3445     int r;
3446     suppress_error = 0;
3447     r = guestfs_umount_all (g);
3448     if (r == -1)
3449       return -1;
3450   }
3451   {
3452     int r;
3453     suppress_error = 0;
3454     r = guestfs_lvm_remove_all (g);
3455     if (r == -1)
3456       return -1;
3457   }
3458   /* TestOutputInt for ntfs_3g_probe (1) */
3459   {
3460     char device[] = "/dev/sda";
3461     char lines_0[] = ",";
3462     char *lines[] = {
3463       lines_0,
3464       NULL
3465     };
3466     int r;
3467     suppress_error = 0;
3468     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3469     if (r == -1)
3470       return -1;
3471   }
3472   {
3473     char fstype[] = "ext2";
3474     char device[] = "/dev/sda1";
3475     int r;
3476     suppress_error = 0;
3477     r = guestfs_mkfs (g, fstype, device);
3478     if (r == -1)
3479       return -1;
3480   }
3481   {
3482     char device[] = "/dev/sda1";
3483     int r;
3484     suppress_error = 0;
3485     r = guestfs_ntfs_3g_probe (g, 1, device);
3486     if (r == -1)
3487       return -1;
3488     if (r != 12) {
3489       fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
3490       return -1;
3491     }
3492   }
3493   return 0;
3494 }
3495
3496 static int test_sleep_0_skip (void)
3497 {
3498   const char *str;
3499
3500   str = getenv ("TEST_ONLY");
3501   if (str)
3502     return strstr (str, "sleep") == NULL;
3503   str = getenv ("SKIP_TEST_SLEEP_0");
3504   if (str && strcmp (str, "1") == 0) return 1;
3505   str = getenv ("SKIP_TEST_SLEEP");
3506   if (str && strcmp (str, "1") == 0) return 1;
3507   return 0;
3508 }
3509
3510 static int test_sleep_0 (void)
3511 {
3512   if (test_sleep_0_skip ()) {
3513     printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
3514     return 0;
3515   }
3516
3517   /* InitNone|InitEmpty for test_sleep_0 */
3518   {
3519     char device[] = "/dev/sda";
3520     int r;
3521     suppress_error = 0;
3522     r = guestfs_blockdev_setrw (g, device);
3523     if (r == -1)
3524       return -1;
3525   }
3526   {
3527     int r;
3528     suppress_error = 0;
3529     r = guestfs_umount_all (g);
3530     if (r == -1)
3531       return -1;
3532   }
3533   {
3534     int r;
3535     suppress_error = 0;
3536     r = guestfs_lvm_remove_all (g);
3537     if (r == -1)
3538       return -1;
3539   }
3540   /* TestRun for sleep (0) */
3541   {
3542     int r;
3543     suppress_error = 0;
3544     r = guestfs_sleep (g, 1);
3545     if (r == -1)
3546       return -1;
3547   }
3548   return 0;
3549 }
3550
3551 static int test_find_0_skip (void)
3552 {
3553   const char *str;
3554
3555   str = getenv ("TEST_ONLY");
3556   if (str)
3557     return strstr (str, "find") == NULL;
3558   str = getenv ("SKIP_TEST_FIND_0");
3559   if (str && strcmp (str, "1") == 0) return 1;
3560   str = getenv ("SKIP_TEST_FIND");
3561   if (str && strcmp (str, "1") == 0) return 1;
3562   return 0;
3563 }
3564
3565 static int test_find_0 (void)
3566 {
3567   if (test_find_0_skip ()) {
3568     printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
3569     return 0;
3570   }
3571
3572   /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3573   {
3574     char device[] = "/dev/sda";
3575     int r;
3576     suppress_error = 0;
3577     r = guestfs_blockdev_setrw (g, device);
3578     if (r == -1)
3579       return -1;
3580   }
3581   {
3582     int r;
3583     suppress_error = 0;
3584     r = guestfs_umount_all (g);
3585     if (r == -1)
3586       return -1;
3587   }
3588   {
3589     int r;
3590     suppress_error = 0;
3591     r = guestfs_lvm_remove_all (g);
3592     if (r == -1)
3593       return -1;
3594   }
3595   {
3596     char device[] = "/dev/sda";
3597     char lines_0[] = ",";
3598     char *lines[] = {
3599       lines_0,
3600       NULL
3601     };
3602     int r;
3603     suppress_error = 0;
3604     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3605     if (r == -1)
3606       return -1;
3607   }
3608   {
3609     char fstype[] = "ext2";
3610     char device[] = "/dev/sda1";
3611     int r;
3612     suppress_error = 0;
3613     r = guestfs_mkfs (g, fstype, device);
3614     if (r == -1)
3615       return -1;
3616   }
3617   {
3618     char device[] = "/dev/sda1";
3619     char mountpoint[] = "/";
3620     int r;
3621     suppress_error = 0;
3622     r = guestfs_mount (g, device, mountpoint);
3623     if (r == -1)
3624       return -1;
3625   }
3626   /* TestOutputList for find (0) */
3627   {
3628     char directory[] = "/";
3629     char **r;
3630     int i;
3631     suppress_error = 0;
3632     r = guestfs_find (g, directory);
3633     if (r == NULL)
3634       return -1;
3635     if (!r[0]) {
3636       fprintf (stderr, "test_find_0: short list returned from command\n");
3637       print_strings (r);
3638       return -1;
3639     }
3640     {
3641       char expected[] = "lost+found";
3642       if (strcmp (r[0], expected) != 0) {
3643         fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3644         return -1;
3645       }
3646     }
3647     if (r[1] != NULL) {
3648       fprintf (stderr, "test_find_0: extra elements returned from command\n");
3649       print_strings (r);
3650       return -1;
3651     }
3652     for (i = 0; r[i] != NULL; ++i)
3653       free (r[i]);
3654     free (r);
3655   }
3656   return 0;
3657 }
3658
3659 static int test_find_1_skip (void)
3660 {
3661   const char *str;
3662
3663   str = getenv ("TEST_ONLY");
3664   if (str)
3665     return strstr (str, "find") == NULL;
3666   str = getenv ("SKIP_TEST_FIND_1");
3667   if (str && strcmp (str, "1") == 0) return 1;
3668   str = getenv ("SKIP_TEST_FIND");
3669   if (str && strcmp (str, "1") == 0) return 1;
3670   return 0;
3671 }
3672
3673 static int test_find_1 (void)
3674 {
3675   if (test_find_1_skip ()) {
3676     printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
3677     return 0;
3678   }
3679
3680   /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3681   {
3682     char device[] = "/dev/sda";
3683     int r;
3684     suppress_error = 0;
3685     r = guestfs_blockdev_setrw (g, device);
3686     if (r == -1)
3687       return -1;
3688   }
3689   {
3690     int r;
3691     suppress_error = 0;
3692     r = guestfs_umount_all (g);
3693     if (r == -1)
3694       return -1;
3695   }
3696   {
3697     int r;
3698     suppress_error = 0;
3699     r = guestfs_lvm_remove_all (g);
3700     if (r == -1)
3701       return -1;
3702   }
3703   {
3704     char device[] = "/dev/sda";
3705     char lines_0[] = ",";
3706     char *lines[] = {
3707       lines_0,
3708       NULL
3709     };
3710     int r;
3711     suppress_error = 0;
3712     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3713     if (r == -1)
3714       return -1;
3715   }
3716   {
3717     char fstype[] = "ext2";
3718     char device[] = "/dev/sda1";
3719     int r;
3720     suppress_error = 0;
3721     r = guestfs_mkfs (g, fstype, device);
3722     if (r == -1)
3723       return -1;
3724   }
3725   {
3726     char device[] = "/dev/sda1";
3727     char mountpoint[] = "/";
3728     int r;
3729     suppress_error = 0;
3730     r = guestfs_mount (g, device, mountpoint);
3731     if (r == -1)
3732       return -1;
3733   }
3734   /* TestOutputList for find (1) */
3735   {
3736     char path[] = "/a";
3737     int r;
3738     suppress_error = 0;
3739     r = guestfs_touch (g, path);
3740     if (r == -1)
3741       return -1;
3742   }
3743   {
3744     char path[] = "/b";
3745     int r;
3746     suppress_error = 0;
3747     r = guestfs_mkdir (g, path);
3748     if (r == -1)
3749       return -1;
3750   }
3751   {
3752     char path[] = "/b/c";
3753     int r;
3754     suppress_error = 0;
3755     r = guestfs_touch (g, path);
3756     if (r == -1)
3757       return -1;
3758   }
3759   {
3760     char directory[] = "/";
3761     char **r;
3762     int i;
3763     suppress_error = 0;
3764     r = guestfs_find (g, directory);
3765     if (r == NULL)
3766       return -1;
3767     if (!r[0]) {
3768       fprintf (stderr, "test_find_1: short list returned from command\n");
3769       print_strings (r);
3770       return -1;
3771     }
3772     {
3773       char expected[] = "a";
3774       if (strcmp (r[0], expected) != 0) {
3775         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3776         return -1;
3777       }
3778     }
3779     if (!r[1]) {
3780       fprintf (stderr, "test_find_1: short list returned from command\n");
3781       print_strings (r);
3782       return -1;
3783     }
3784     {
3785       char expected[] = "b";
3786       if (strcmp (r[1], expected) != 0) {
3787         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3788         return -1;
3789       }
3790     }
3791     if (!r[2]) {
3792       fprintf (stderr, "test_find_1: short list returned from command\n");
3793       print_strings (r);
3794       return -1;
3795     }
3796     {
3797       char expected[] = "b/c";
3798       if (strcmp (r[2], expected) != 0) {
3799         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3800         return -1;
3801       }
3802     }
3803     if (!r[3]) {
3804       fprintf (stderr, "test_find_1: short list returned from command\n");
3805       print_strings (r);
3806       return -1;
3807     }
3808     {
3809       char expected[] = "lost+found";
3810       if (strcmp (r[3], expected) != 0) {
3811         fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3812         return -1;
3813       }
3814     }
3815     if (r[4] != NULL) {
3816       fprintf (stderr, "test_find_1: extra elements returned from command\n");
3817       print_strings (r);
3818       return -1;
3819     }
3820     for (i = 0; r[i] != NULL; ++i)
3821       free (r[i]);
3822     free (r);
3823   }
3824   return 0;
3825 }
3826
3827 static int test_find_2_skip (void)
3828 {
3829   const char *str;
3830
3831   str = getenv ("TEST_ONLY");
3832   if (str)
3833     return strstr (str, "find") == NULL;
3834   str = getenv ("SKIP_TEST_FIND_2");
3835   if (str && strcmp (str, "1") == 0) return 1;
3836   str = getenv ("SKIP_TEST_FIND");
3837   if (str && strcmp (str, "1") == 0) return 1;
3838   return 0;
3839 }
3840
3841 static int test_find_2 (void)
3842 {
3843   if (test_find_2_skip ()) {
3844     printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3845     return 0;
3846   }
3847
3848   /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3849   {
3850     char device[] = "/dev/sda";
3851     int r;
3852     suppress_error = 0;
3853     r = guestfs_blockdev_setrw (g, device);
3854     if (r == -1)
3855       return -1;
3856   }
3857   {
3858     int r;
3859     suppress_error = 0;
3860     r = guestfs_umount_all (g);
3861     if (r == -1)
3862       return -1;
3863   }
3864   {
3865     int r;
3866     suppress_error = 0;
3867     r = guestfs_lvm_remove_all (g);
3868     if (r == -1)
3869       return -1;
3870   }
3871   {
3872     char device[] = "/dev/sda";
3873     char lines_0[] = ",";
3874     char *lines[] = {
3875       lines_0,
3876       NULL
3877     };
3878     int r;
3879     suppress_error = 0;
3880     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3881     if (r == -1)
3882       return -1;
3883   }
3884   {
3885     char fstype[] = "ext2";
3886     char device[] = "/dev/sda1";
3887     int r;
3888     suppress_error = 0;
3889     r = guestfs_mkfs (g, fstype, device);
3890     if (r == -1)
3891       return -1;
3892   }
3893   {
3894     char device[] = "/dev/sda1";
3895     char mountpoint[] = "/";
3896     int r;
3897     suppress_error = 0;
3898     r = guestfs_mount (g, device, mountpoint);
3899     if (r == -1)
3900       return -1;
3901   }
3902   /* TestOutputList for find (2) */
3903   {
3904     char path[] = "/a/b/c";
3905     int r;
3906     suppress_error = 0;
3907     r = guestfs_mkdir_p (g, path);
3908     if (r == -1)
3909       return -1;
3910   }
3911   {
3912     char path[] = "/a/b/c/d";
3913     int r;
3914     suppress_error = 0;
3915     r = guestfs_touch (g, path);
3916     if (r == -1)
3917       return -1;
3918   }
3919   {
3920     char directory[] = "/a/b/";
3921     char **r;
3922     int i;
3923     suppress_error = 0;
3924     r = guestfs_find (g, directory);
3925     if (r == NULL)
3926       return -1;
3927     if (!r[0]) {
3928       fprintf (stderr, "test_find_2: short list returned from command\n");
3929       print_strings (r);
3930       return -1;
3931     }
3932     {
3933       char expected[] = "c";
3934       if (strcmp (r[0], expected) != 0) {
3935         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3936         return -1;
3937       }
3938     }
3939     if (!r[1]) {
3940       fprintf (stderr, "test_find_2: short list returned from command\n");
3941       print_strings (r);
3942       return -1;
3943     }
3944     {
3945       char expected[] = "c/d";
3946       if (strcmp (r[1], expected) != 0) {
3947         fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3948         return -1;
3949       }
3950     }
3951     if (r[2] != NULL) {
3952       fprintf (stderr, "test_find_2: extra elements returned from command\n");
3953       print_strings (r);
3954       return -1;
3955     }
3956     for (i = 0; r[i] != NULL; ++i)
3957       free (r[i]);
3958     free (r);
3959   }
3960   return 0;
3961 }
3962
3963 static int test_lvresize_0_skip (void)
3964 {
3965   const char *str;
3966
3967   str = getenv ("TEST_ONLY");
3968   if (str)
3969     return strstr (str, "lvresize") == NULL;
3970   str = getenv ("SKIP_TEST_LVRESIZE_0");
3971   if (str && strcmp (str, "1") == 0) return 1;
3972   str = getenv ("SKIP_TEST_LVRESIZE");
3973   if (str && strcmp (str, "1") == 0) return 1;
3974   return 0;
3975 }
3976
3977 static int test_lvresize_0 (void)
3978 {
3979   if (test_lvresize_0_skip ()) {
3980     printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3981     return 0;
3982   }
3983
3984   /* InitNone|InitEmpty for test_lvresize_0 */
3985   {
3986     char device[] = "/dev/sda";
3987     int r;
3988     suppress_error = 0;
3989     r = guestfs_blockdev_setrw (g, device);
3990     if (r == -1)
3991       return -1;
3992   }
3993   {
3994     int r;
3995    &