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