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