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