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