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