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