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