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