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