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