tests.c

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