capitests/tests.c

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