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