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