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