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