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