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