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