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