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