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