Generated code for 'mkdtemp' command.
[libguestfs.git] / capitests / tests.c
1 /* libguestfs generated file
2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
4  *
5  * Copyright (C) 2009 Red Hat Inc.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <sys/types.h>
27 #include <fcntl.h>
28
29 #include "guestfs.h"
30
31 static guestfs_h *g;
32 static int suppress_error = 0;
33
34 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_strings_e_0_skip (void)
1801 {
1802   const char *str;
1803
1804   str = getenv ("SKIP_TEST_STRINGS_E_0");
1805   if (str && strcmp (str, "1") == 0) return 1;
1806   str = getenv ("SKIP_TEST_STRINGS_E");
1807   if (str && strcmp (str, "1") == 0) return 1;
1808   return 0;
1809 }
1810
1811 static int test_strings_e_0 (void)
1812 {
1813   if (test_strings_e_0_skip ()) {
1814     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1815     return 0;
1816   }
1817
1818   /* InitBasicFS for test_strings_e_0: 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   /* TestOutputList for strings_e (0) */
1873   {
1874     char path[] = "/new";
1875     char content[] = "hello\nworld\n";
1876     int r;
1877     suppress_error = 0;
1878     r = guestfs_write_file (g, path, content, 0);
1879     if (r == -1)
1880       return -1;
1881   }
1882   {
1883     char encoding[] = "b";
1884     char path[] = "/new";
1885     char **r;
1886     int i;
1887     suppress_error = 0;
1888     r = guestfs_strings_e (g, encoding, path);
1889     if (r == NULL)
1890       return -1;
1891     if (r[0] != NULL) {
1892       fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1893       print_strings (r);
1894       return -1;
1895     }
1896     for (i = 0; r[i] != NULL; ++i)
1897       free (r[i]);
1898     free (r);
1899   }
1900   return 0;
1901 }
1902
1903 static int test_strings_e_1_skip (void)
1904 {
1905   const char *str;
1906
1907   str = getenv ("SKIP_TEST_STRINGS_E_1");
1908   if (str && strcmp (str, "1") == 0) return 1;
1909   str = getenv ("SKIP_TEST_STRINGS_E");
1910   if (str && strcmp (str, "1") == 0) return 1;
1911   return 0;
1912 }
1913
1914 static int test_strings_e_1 (void)
1915 {
1916   if (test_strings_e_1_skip ()) {
1917     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1918     return 0;
1919   }
1920
1921   printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1922   return 0;
1923 }
1924
1925 static int test_strings_0_skip (void)
1926 {
1927   const char *str;
1928
1929   str = getenv ("SKIP_TEST_STRINGS_0");
1930   if (str && strcmp (str, "1") == 0) return 1;
1931   str = getenv ("SKIP_TEST_STRINGS");
1932   if (str && strcmp (str, "1") == 0) return 1;
1933   return 0;
1934 }
1935
1936 static int test_strings_0 (void)
1937 {
1938   if (test_strings_0_skip ()) {
1939     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1940     return 0;
1941   }
1942
1943   /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1944   {
1945     char device[] = "/dev/sda";
1946     int r;
1947     suppress_error = 0;
1948     r = guestfs_blockdev_setrw (g, device);
1949     if (r == -1)
1950       return -1;
1951   }
1952   {
1953     int r;
1954     suppress_error = 0;
1955     r = guestfs_umount_all (g);
1956     if (r == -1)
1957       return -1;
1958   }
1959   {
1960     int r;
1961     suppress_error = 0;
1962     r = guestfs_lvm_remove_all (g);
1963     if (r == -1)
1964       return -1;
1965   }
1966   {
1967     char device[] = "/dev/sda";
1968     char lines_0[] = ",";
1969     char *lines[] = {
1970       lines_0,
1971       NULL
1972     };
1973     int r;
1974     suppress_error = 0;
1975     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1976     if (r == -1)
1977       return -1;
1978   }
1979   {
1980     char fstype[] = "ext2";
1981     char device[] = "/dev/sda1";
1982     int r;
1983     suppress_error = 0;
1984     r = guestfs_mkfs (g, fstype, device);
1985     if (r == -1)
1986       return -1;
1987   }
1988   {
1989     char device[] = "/dev/sda1";
1990     char mountpoint[] = "/";
1991     int r;
1992     suppress_error = 0;
1993     r = guestfs_mount (g, device, mountpoint);
1994     if (r == -1)
1995       return -1;
1996   }
1997   /* TestOutputList for strings (0) */
1998   {
1999     char path[] = "/new";
2000     char content[] = "hello\nworld\n";
2001     int r;
2002     suppress_error = 0;
2003     r = guestfs_write_file (g, path, content, 0);
2004     if (r == -1)
2005       return -1;
2006   }
2007   {
2008     char path[] = "/new";
2009     char **r;
2010     int i;
2011     suppress_error = 0;
2012     r = guestfs_strings (g, path);
2013     if (r == NULL)
2014       return -1;
2015     if (!r[0]) {
2016       fprintf (stderr, "test_strings_0: short list returned from command\n");
2017       print_strings (r);
2018       return -1;
2019     }
2020     {
2021       char expected[] = "hello";
2022       if (strcmp (r[0], expected) != 0) {
2023         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2024         return -1;
2025       }
2026     }
2027     if (!r[1]) {
2028       fprintf (stderr, "test_strings_0: short list returned from command\n");
2029       print_strings (r);
2030       return -1;
2031     }
2032     {
2033       char expected[] = "world";
2034       if (strcmp (r[1], expected) != 0) {
2035         fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2036         return -1;
2037       }
2038     }
2039     if (r[2] != NULL) {
2040       fprintf (stderr, "test_strings_0: extra elements returned from command\n");
2041       print_strings (r);
2042       return -1;
2043     }
2044     for (i = 0; r[i] != NULL; ++i)
2045       free (r[i]);
2046     free (r);
2047   }
2048   return 0;
2049 }
2050
2051 static int test_strings_1_skip (void)
2052 {
2053   const char *str;
2054
2055   str = getenv ("SKIP_TEST_STRINGS_1");
2056   if (str && strcmp (str, "1") == 0) return 1;
2057   str = getenv ("SKIP_TEST_STRINGS");
2058   if (str && strcmp (str, "1") == 0) return 1;
2059   return 0;
2060 }
2061
2062 static int test_strings_1 (void)
2063 {
2064   if (test_strings_1_skip ()) {
2065     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
2066     return 0;
2067   }
2068
2069   /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
2070   {
2071     char device[] = "/dev/sda";
2072     int r;
2073     suppress_error = 0;
2074     r = guestfs_blockdev_setrw (g, device);
2075     if (r == -1)
2076       return -1;
2077   }
2078   {
2079     int r;
2080     suppress_error = 0;
2081     r = guestfs_umount_all (g);
2082     if (r == -1)
2083       return -1;
2084   }
2085   {
2086     int r;
2087     suppress_error = 0;
2088     r = guestfs_lvm_remove_all (g);
2089     if (r == -1)
2090       return -1;
2091   }
2092   {
2093     char device[] = "/dev/sda";
2094     char lines_0[] = ",";
2095     char *lines[] = {
2096       lines_0,
2097       NULL
2098     };
2099     int r;
2100     suppress_error = 0;
2101     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2102     if (r == -1)
2103       return -1;
2104   }
2105   {
2106     char fstype[] = "ext2";
2107     char device[] = "/dev/sda1";
2108     int r;
2109     suppress_error = 0;
2110     r = guestfs_mkfs (g, fstype, device);
2111     if (r == -1)
2112       return -1;
2113   }
2114   {
2115     char device[] = "/dev/sda1";
2116     char mountpoint[] = "/";
2117     int r;
2118     suppress_error = 0;
2119     r = guestfs_mount (g, device, mountpoint);
2120     if (r == -1)
2121       return -1;
2122   }
2123   /* TestOutputList for strings (1) */
2124   {
2125     char path[] = "/new";
2126     int r;
2127     suppress_error = 0;
2128     r = guestfs_touch (g, path);
2129     if (r == -1)
2130       return -1;
2131   }
2132   {
2133     char path[] = "/new";
2134     char **r;
2135     int i;
2136     suppress_error = 0;
2137     r = guestfs_strings (g, path);
2138     if (r == NULL)
2139       return -1;
2140     if (r[0] != NULL) {
2141       fprintf (stderr, "test_strings_1: extra elements returned from command\n");
2142       print_strings (r);
2143       return -1;
2144     }
2145     for (i = 0; r[i] != NULL; ++i)
2146       free (r[i]);
2147     free (r);
2148   }
2149   return 0;
2150 }
2151
2152 static int test_equal_0_skip (void)
2153 {
2154   const char *str;
2155
2156   str = getenv ("SKIP_TEST_EQUAL_0");
2157   if (str && strcmp (str, "1") == 0) return 1;
2158   str = getenv ("SKIP_TEST_EQUAL");
2159   if (str && strcmp (str, "1") == 0) return 1;
2160   return 0;
2161 }
2162
2163 static int test_equal_0 (void)
2164 {
2165   if (test_equal_0_skip ()) {
2166     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
2167     return 0;
2168   }
2169
2170   /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
2171   {
2172     char device[] = "/dev/sda";
2173     int r;
2174     suppress_error = 0;
2175     r = guestfs_blockdev_setrw (g, device);
2176     if (r == -1)
2177       return -1;
2178   }
2179   {
2180     int r;
2181     suppress_error = 0;
2182     r = guestfs_umount_all (g);
2183     if (r == -1)
2184       return -1;
2185   }
2186   {
2187     int r;
2188     suppress_error = 0;
2189     r = guestfs_lvm_remove_all (g);
2190     if (r == -1)
2191       return -1;
2192   }
2193   {
2194     char device[] = "/dev/sda";
2195     char lines_0[] = ",";
2196     char *lines[] = {
2197       lines_0,
2198       NULL
2199     };
2200     int r;
2201     suppress_error = 0;
2202     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2203     if (r == -1)
2204       return -1;
2205   }
2206   {
2207     char fstype[] = "ext2";
2208     char device[] = "/dev/sda1";
2209     int r;
2210     suppress_error = 0;
2211     r = guestfs_mkfs (g, fstype, device);
2212     if (r == -1)
2213       return -1;
2214   }
2215   {
2216     char device[] = "/dev/sda1";
2217     char mountpoint[] = "/";
2218     int r;
2219     suppress_error = 0;
2220     r = guestfs_mount (g, device, mountpoint);
2221     if (r == -1)
2222       return -1;
2223   }
2224   /* TestOutputTrue for equal (0) */
2225   {
2226     char path[] = "/file1";
2227     char content[] = "contents of a file";
2228     int r;
2229     suppress_error = 0;
2230     r = guestfs_write_file (g, path, content, 0);
2231     if (r == -1)
2232       return -1;
2233   }
2234   {
2235     char src[] = "/file1";
2236     char dest[] = "/file2";
2237     int r;
2238     suppress_error = 0;
2239     r = guestfs_cp (g, src, dest);
2240     if (r == -1)
2241       return -1;
2242   }
2243   {
2244     char file1[] = "/file1";
2245     char file2[] = "/file2";
2246     int r;
2247     suppress_error = 0;
2248     r = guestfs_equal (g, file1, file2);
2249     if (r == -1)
2250       return -1;
2251     if (!r) {
2252       fprintf (stderr, "test_equal_0: expected true, got false\n");
2253       return -1;
2254     }
2255   }
2256   return 0;
2257 }
2258
2259 static int test_equal_1_skip (void)
2260 {
2261   const char *str;
2262
2263   str = getenv ("SKIP_TEST_EQUAL_1");
2264   if (str && strcmp (str, "1") == 0) return 1;
2265   str = getenv ("SKIP_TEST_EQUAL");
2266   if (str && strcmp (str, "1") == 0) return 1;
2267   return 0;
2268 }
2269
2270 static int test_equal_1 (void)
2271 {
2272   if (test_equal_1_skip ()) {
2273     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
2274     return 0;
2275   }
2276
2277   /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2278   {
2279     char device[] = "/dev/sda";
2280     int r;
2281     suppress_error = 0;
2282     r = guestfs_blockdev_setrw (g, device);
2283     if (r == -1)
2284       return -1;
2285   }
2286   {
2287     int r;
2288     suppress_error = 0;
2289     r = guestfs_umount_all (g);
2290     if (r == -1)
2291       return -1;
2292   }
2293   {
2294     int r;
2295     suppress_error = 0;
2296     r = guestfs_lvm_remove_all (g);
2297     if (r == -1)
2298       return -1;
2299   }
2300   {
2301     char device[] = "/dev/sda";
2302     char lines_0[] = ",";
2303     char *lines[] = {
2304       lines_0,
2305       NULL
2306     };
2307     int r;
2308     suppress_error = 0;
2309     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2310     if (r == -1)
2311       return -1;
2312   }
2313   {
2314     char fstype[] = "ext2";
2315     char device[] = "/dev/sda1";
2316     int r;
2317     suppress_error = 0;
2318     r = guestfs_mkfs (g, fstype, device);
2319     if (r == -1)
2320       return -1;
2321   }
2322   {
2323     char device[] = "/dev/sda1";
2324     char mountpoint[] = "/";
2325     int r;
2326     suppress_error = 0;
2327     r = guestfs_mount (g, device, mountpoint);
2328     if (r == -1)
2329       return -1;
2330   }
2331   /* TestOutputFalse for equal (1) */
2332   {
2333     char path[] = "/file1";
2334     char content[] = "contents of a file";
2335     int r;
2336     suppress_error = 0;
2337     r = guestfs_write_file (g, path, content, 0);
2338     if (r == -1)
2339       return -1;
2340   }
2341   {
2342     char path[] = "/file2";
2343     char content[] = "contents of another file";
2344     int r;
2345     suppress_error = 0;
2346     r = guestfs_write_file (g, path, content, 0);
2347     if (r == -1)
2348       return -1;
2349   }
2350   {
2351     char file1[] = "/file1";
2352     char file2[] = "/file2";
2353     int r;
2354     suppress_error = 0;
2355     r = guestfs_equal (g, file1, file2);
2356     if (r == -1)
2357       return -1;
2358     if (r) {
2359       fprintf (stderr, "test_equal_1: expected false, got true\n");
2360       return -1;
2361     }
2362   }
2363   return 0;
2364 }
2365
2366 static int test_equal_2_skip (void)
2367 {
2368   const char *str;
2369
2370   str = getenv ("SKIP_TEST_EQUAL_2");
2371   if (str && strcmp (str, "1") == 0) return 1;
2372   str = getenv ("SKIP_TEST_EQUAL");
2373   if (str && strcmp (str, "1") == 0) return 1;
2374   return 0;
2375 }
2376
2377 static int test_equal_2 (void)
2378 {
2379   if (test_equal_2_skip ()) {
2380     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
2381     return 0;
2382   }
2383
2384   /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
2385   {
2386     char device[] = "/dev/sda";
2387     int r;
2388     suppress_error = 0;
2389     r = guestfs_blockdev_setrw (g, device);
2390     if (r == -1)
2391       return -1;
2392   }
2393   {
2394     int r;
2395     suppress_error = 0;
2396     r = guestfs_umount_all (g);
2397     if (r == -1)
2398       return -1;
2399   }
2400   {
2401     int r;
2402     suppress_error = 0;
2403     r = guestfs_lvm_remove_all (g);
2404     if (r == -1)
2405       return -1;
2406   }
2407   {
2408     char device[] = "/dev/sda";
2409     char lines_0[] = ",";
2410     char *lines[] = {
2411       lines_0,
2412       NULL
2413     };
2414     int r;
2415     suppress_error = 0;
2416     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2417     if (r == -1)
2418       return -1;
2419   }
2420   {
2421     char fstype[] = "ext2";
2422     char device[] = "/dev/sda1";
2423     int r;
2424     suppress_error = 0;
2425     r = guestfs_mkfs (g, fstype, device);
2426     if (r == -1)
2427       return -1;
2428   }
2429   {
2430     char device[] = "/dev/sda1";
2431     char mountpoint[] = "/";
2432     int r;
2433     suppress_error = 0;
2434     r = guestfs_mount (g, device, mountpoint);
2435     if (r == -1)
2436       return -1;
2437   }
2438   /* TestLastFail for equal (2) */
2439   {
2440     char file1[] = "/file1";
2441     char file2[] = "/file2";
2442     int r;
2443     suppress_error = 1;
2444     r = guestfs_equal (g, file1, file2);
2445     if (r != -1)
2446       return -1;
2447   }
2448   return 0;
2449 }
2450
2451 static int test_ping_daemon_0_skip (void)
2452 {
2453   const char *str;
2454
2455   str = getenv ("SKIP_TEST_PING_DAEMON_0");
2456   if (str && strcmp (str, "1") == 0) return 1;
2457   str = getenv ("SKIP_TEST_PING_DAEMON");
2458   if (str && strcmp (str, "1") == 0) return 1;
2459   return 0;
2460 }
2461
2462 static int test_ping_daemon_0 (void)
2463 {
2464   if (test_ping_daemon_0_skip ()) {
2465     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
2466     return 0;
2467   }
2468
2469   /* InitNone|InitEmpty for test_ping_daemon_0 */
2470   {
2471     char device[] = "/dev/sda";
2472     int r;
2473     suppress_error = 0;
2474     r = guestfs_blockdev_setrw (g, device);
2475     if (r == -1)
2476       return -1;
2477   }
2478   {
2479     int r;
2480     suppress_error = 0;
2481     r = guestfs_umount_all (g);
2482     if (r == -1)
2483       return -1;
2484   }
2485   {
2486     int r;
2487     suppress_error = 0;
2488     r = guestfs_lvm_remove_all (g);
2489     if (r == -1)
2490       return -1;
2491   }
2492   /* TestRun for ping_daemon (0) */
2493   {
2494     int r;
2495     suppress_error = 0;
2496     r = guestfs_ping_daemon (g);
2497     if (r == -1)
2498       return -1;
2499   }
2500   return 0;
2501 }
2502
2503 static int test_dmesg_0_skip (void)
2504 {
2505   const char *str;
2506
2507   str = getenv ("SKIP_TEST_DMESG_0");
2508   if (str && strcmp (str, "1") == 0) return 1;
2509   str = getenv ("SKIP_TEST_DMESG");
2510   if (str && strcmp (str, "1") == 0) return 1;
2511   return 0;
2512 }
2513
2514 static int test_dmesg_0 (void)
2515 {
2516   if (test_dmesg_0_skip ()) {
2517     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
2518     return 0;
2519   }
2520
2521   /* InitNone|InitEmpty for test_dmesg_0 */
2522   {
2523     char device[] = "/dev/sda";
2524     int r;
2525     suppress_error = 0;
2526     r = guestfs_blockdev_setrw (g, device);
2527     if (r == -1)
2528       return -1;
2529   }
2530   {
2531     int r;
2532     suppress_error = 0;
2533     r = guestfs_umount_all (g);
2534     if (r == -1)
2535       return -1;
2536   }
2537   {
2538     int r;
2539     suppress_error = 0;
2540     r = guestfs_lvm_remove_all (g);
2541     if (r == -1)
2542       return -1;
2543   }
2544   /* TestRun for dmesg (0) */
2545   {
2546     char *r;
2547     suppress_error = 0;
2548     r = guestfs_dmesg (g);
2549     if (r == NULL)
2550       return -1;
2551     free (r);
2552   }
2553   return 0;
2554 }
2555
2556 static int test_drop_caches_0_skip (void)
2557 {
2558   const char *str;
2559
2560   str = getenv ("SKIP_TEST_DROP_CACHES_0");
2561   if (str && strcmp (str, "1") == 0) return 1;
2562   str = getenv ("SKIP_TEST_DROP_CACHES");
2563   if (str && strcmp (str, "1") == 0) return 1;
2564   return 0;
2565 }
2566
2567 static int test_drop_caches_0 (void)
2568 {
2569   if (test_drop_caches_0_skip ()) {
2570     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
2571     return 0;
2572   }
2573
2574   /* InitNone|InitEmpty for test_drop_caches_0 */
2575   {
2576     char device[] = "/dev/sda";
2577     int r;
2578     suppress_error = 0;
2579     r = guestfs_blockdev_setrw (g, device);
2580     if (r == -1)
2581       return -1;
2582   }
2583   {
2584     int r;
2585     suppress_error = 0;
2586     r = guestfs_umount_all (g);
2587     if (r == -1)
2588       return -1;
2589   }
2590   {
2591     int r;
2592     suppress_error = 0;
2593     r = guestfs_lvm_remove_all (g);
2594     if (r == -1)
2595       return -1;
2596   }
2597   /* TestRun for drop_caches (0) */
2598   {
2599     int r;
2600     suppress_error = 0;
2601     r = guestfs_drop_caches (g, 3);
2602     if (r == -1)
2603       return -1;
2604   }
2605   return 0;
2606 }
2607
2608 static int test_mv_0_skip (void)
2609 {
2610   const char *str;
2611
2612   str = getenv ("SKIP_TEST_MV_0");
2613   if (str && strcmp (str, "1") == 0) return 1;
2614   str = getenv ("SKIP_TEST_MV");
2615   if (str && strcmp (str, "1") == 0) return 1;
2616   return 0;
2617 }
2618
2619 static int test_mv_0 (void)
2620 {
2621   if (test_mv_0_skip ()) {
2622     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2623     return 0;
2624   }
2625
2626   /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2627   {
2628     char device[] = "/dev/sda";
2629     int r;
2630     suppress_error = 0;
2631     r = guestfs_blockdev_setrw (g, device);
2632     if (r == -1)
2633       return -1;
2634   }
2635   {
2636     int r;
2637     suppress_error = 0;
2638     r = guestfs_umount_all (g);
2639     if (r == -1)
2640       return -1;
2641   }
2642   {
2643     int r;
2644     suppress_error = 0;
2645     r = guestfs_lvm_remove_all (g);
2646     if (r == -1)
2647       return -1;
2648   }
2649   {
2650     char device[] = "/dev/sda";
2651     char lines_0[] = ",";
2652     char *lines[] = {
2653       lines_0,
2654       NULL
2655     };
2656     int r;
2657     suppress_error = 0;
2658     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2659     if (r == -1)
2660       return -1;
2661   }
2662   {
2663     char fstype[] = "ext2";
2664     char device[] = "/dev/sda1";
2665     int r;
2666     suppress_error = 0;
2667     r = guestfs_mkfs (g, fstype, device);
2668     if (r == -1)
2669       return -1;
2670   }
2671   {
2672     char device[] = "/dev/sda1";
2673     char mountpoint[] = "/";
2674     int r;
2675     suppress_error = 0;
2676     r = guestfs_mount (g, device, mountpoint);
2677     if (r == -1)
2678       return -1;
2679   }
2680   /* TestOutput for mv (0) */
2681   char expected[] = "file content";
2682   {
2683     char path[] = "/old";
2684     char content[] = "file content";
2685     int r;
2686     suppress_error = 0;
2687     r = guestfs_write_file (g, path, content, 0);
2688     if (r == -1)
2689       return -1;
2690   }
2691   {
2692     char src[] = "/old";
2693     char dest[] = "/new";
2694     int r;
2695     suppress_error = 0;
2696     r = guestfs_mv (g, src, dest);
2697     if (r == -1)
2698       return -1;
2699   }
2700   {
2701     char path[] = "/new";
2702     char *r;
2703     suppress_error = 0;
2704     r = guestfs_cat (g, path);
2705     if (r == NULL)
2706       return -1;
2707     if (strcmp (r, expected) != 0) {
2708       fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2709       return -1;
2710     }
2711     free (r);
2712   }
2713   return 0;
2714 }
2715
2716 static int test_mv_1_skip (void)
2717 {
2718   const char *str;
2719
2720   str = getenv ("SKIP_TEST_MV_1");
2721   if (str && strcmp (str, "1") == 0) return 1;
2722   str = getenv ("SKIP_TEST_MV");
2723   if (str && strcmp (str, "1") == 0) return 1;
2724   return 0;
2725 }
2726
2727 static int test_mv_1 (void)
2728 {
2729   if (test_mv_1_skip ()) {
2730     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2731     return 0;
2732   }
2733
2734   /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2735   {
2736     char device[] = "/dev/sda";
2737     int r;
2738     suppress_error = 0;
2739     r = guestfs_blockdev_setrw (g, device);
2740     if (r == -1)
2741       return -1;
2742   }
2743   {
2744     int r;
2745     suppress_error = 0;
2746     r = guestfs_umount_all (g);
2747     if (r == -1)
2748       return -1;
2749   }
2750   {
2751     int r;
2752     suppress_error = 0;
2753     r = guestfs_lvm_remove_all (g);
2754     if (r == -1)
2755       return -1;
2756   }
2757   {
2758     char device[] = "/dev/sda";
2759     char lines_0[] = ",";
2760     char *lines[] = {
2761       lines_0,
2762       NULL
2763     };
2764     int r;
2765     suppress_error = 0;
2766     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2767     if (r == -1)
2768       return -1;
2769   }
2770   {
2771     char fstype[] = "ext2";
2772     char device[] = "/dev/sda1";
2773     int r;
2774     suppress_error = 0;
2775     r = guestfs_mkfs (g, fstype, device);
2776     if (r == -1)
2777       return -1;
2778   }
2779   {
2780     char device[] = "/dev/sda1";
2781     char mountpoint[] = "/";
2782     int r;
2783     suppress_error = 0;
2784     r = guestfs_mount (g, device, mountpoint);
2785     if (r == -1)
2786       return -1;
2787   }
2788   /* TestOutputFalse for mv (1) */
2789   {
2790     char path[] = "/old";
2791     char content[] = "file content";
2792     int r;
2793     suppress_error = 0;
2794     r = guestfs_write_file (g, path, content, 0);
2795     if (r == -1)
2796       return -1;
2797   }
2798   {
2799     char src[] = "/old";
2800     char dest[] = "/new";
2801     int r;
2802     suppress_error = 0;
2803     r = guestfs_mv (g, src, dest);
2804     if (r == -1)
2805       return -1;
2806   }
2807   {
2808     char path[] = "/old";
2809     int r;
2810     suppress_error = 0;
2811     r = guestfs_is_file (g, path);
2812     if (r == -1)
2813       return -1;
2814     if (r) {
2815       fprintf (stderr, "test_mv_1: expected false, got true\n");
2816       return -1;
2817     }
2818   }
2819   return 0;
2820 }
2821
2822 static int test_cp_a_0_skip (void)
2823 {
2824   const char *str;
2825
2826   str = getenv ("SKIP_TEST_CP_A_0");
2827   if (str && strcmp (str, "1") == 0) return 1;
2828   str = getenv ("SKIP_TEST_CP_A");
2829   if (str && strcmp (str, "1") == 0) return 1;
2830   return 0;
2831 }
2832
2833 static int test_cp_a_0 (void)
2834 {
2835   if (test_cp_a_0_skip ()) {
2836     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2837     return 0;
2838   }
2839
2840   /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2841   {
2842     char device[] = "/dev/sda";
2843     int r;
2844     suppress_error = 0;
2845     r = guestfs_blockdev_setrw (g, device);
2846     if (r == -1)
2847       return -1;
2848   }
2849   {
2850     int r;
2851     suppress_error = 0;
2852     r = guestfs_umount_all (g);
2853     if (r == -1)
2854       return -1;
2855   }
2856   {
2857     int r;
2858     suppress_error = 0;
2859     r = guestfs_lvm_remove_all (g);
2860     if (r == -1)
2861       return -1;
2862   }
2863   {
2864     char device[] = "/dev/sda";
2865     char lines_0[] = ",";
2866     char *lines[] = {
2867       lines_0,
2868       NULL
2869     };
2870     int r;
2871     suppress_error = 0;
2872     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2873     if (r == -1)
2874       return -1;
2875   }
2876   {
2877     char fstype[] = "ext2";
2878     char device[] = "/dev/sda1";
2879     int r;
2880     suppress_error = 0;
2881     r = guestfs_mkfs (g, fstype, device);
2882     if (r == -1)
2883       return -1;
2884   }
2885   {
2886     char device[] = "/dev/sda1";
2887     char mountpoint[] = "/";
2888     int r;
2889     suppress_error = 0;
2890     r = guestfs_mount (g, device, mountpoint);
2891     if (r == -1)
2892       return -1;
2893   }
2894   /* TestOutput for cp_a (0) */
2895   char expected[] = "file content";
2896   {
2897     char path[] = "/olddir";
2898     int r;
2899     suppress_error = 0;
2900     r = guestfs_mkdir (g, path);
2901     if (r == -1)
2902       return -1;
2903   }
2904   {
2905     char path[] = "/newdir";
2906     int r;
2907     suppress_error = 0;
2908     r = guestfs_mkdir (g, path);
2909     if (r == -1)
2910       return -1;
2911   }
2912   {
2913     char path[] = "/olddir/file";
2914     char content[] = "file content";
2915     int r;
2916     suppress_error = 0;
2917     r = guestfs_write_file (g, path, content, 0);
2918     if (r == -1)
2919       return -1;
2920   }
2921   {
2922     char src[] = "/olddir";
2923     char dest[] = "/newdir";
2924     int r;
2925     suppress_error = 0;
2926     r = guestfs_cp_a (g, src, dest);
2927     if (r == -1)
2928       return -1;
2929   }
2930   {
2931     char path[] = "/newdir/olddir/file";
2932     char *r;
2933     suppress_error = 0;
2934     r = guestfs_cat (g, path);
2935     if (r == NULL)
2936       return -1;
2937     if (strcmp (r, expected) != 0) {
2938       fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2939       return -1;
2940     }
2941     free (r);
2942   }
2943   return 0;
2944 }
2945
2946 static int test_cp_0_skip (void)
2947 {
2948   const char *str;
2949
2950   str = getenv ("SKIP_TEST_CP_0");
2951   if (str && strcmp (str, "1") == 0) return 1;
2952   str = getenv ("SKIP_TEST_CP");
2953   if (str && strcmp (str, "1") == 0) return 1;
2954   return 0;
2955 }
2956
2957 static int test_cp_0 (void)
2958 {
2959   if (test_cp_0_skip ()) {
2960     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2961     return 0;
2962   }
2963
2964   /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2965   {
2966     char device[] = "/dev/sda";
2967     int r;
2968     suppress_error = 0;
2969     r = guestfs_blockdev_setrw (g, device);
2970     if (r == -1)
2971       return -1;
2972   }
2973   {
2974     int r;
2975     suppress_error = 0;
2976     r = guestfs_umount_all (g);
2977     if (r == -1)
2978       return -1;
2979   }
2980   {
2981     int r;
2982     suppress_error = 0;
2983     r = guestfs_lvm_remove_all (g);
2984     if (r == -1)
2985       return -1;
2986   }
2987   {
2988     char device[] = "/dev/sda";
2989     char lines_0[] = ",";
2990     char *lines[] = {
2991       lines_0,
2992       NULL
2993     };
2994     int r;
2995     suppress_error = 0;
2996     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2997     if (r == -1)
2998       return -1;
2999   }
3000   {
3001     char fstype[] = "ext2";
3002     char device[] = "/dev/sda1";
3003     int r;
3004     suppress_error = 0;
3005     r = guestfs_mkfs (g, fstype, device);
3006     if (r == -1)
3007       return -1;
3008   }
3009   {
3010     char device[] = "/dev/sda1";
3011     char mountpoint[] = "/";
3012     int r;
3013     suppress_error = 0;
3014     r = guestfs_mount (g, device, mountpoint);
3015     if (r == -1)
3016       return -1;
3017   }
3018   /* TestOutput for cp (0) */
3019   char expected[] = "file content";
3020   {
3021     char path[] = "/old";
3022     char content[] = "file content";
3023     int r;
3024     suppress_error = 0;
3025     r = guestfs_write_file (g, path, content, 0);
3026     if (r == -1)
3027       return -1;
3028   }
3029   {
3030     char src[] = "/old";
3031     char dest[] = "/new";
3032     int r;
3033     suppress_error = 0;
3034     r = guestfs_cp (g, src, dest);
3035     if (r == -1)
3036       return -1;
3037   }
3038   {
3039     char path[] = "/new";
3040     char *r;
3041     suppress_error = 0;
3042     r = guestfs_cat (g, path);
3043     if (r == NULL)
3044       return -1;
3045     if (strcmp (r, expected) != 0) {
3046       fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
3047       return -1;
3048     }
3049     free (r);
3050   }
3051   return 0;
3052 }
3053
3054 static int test_cp_1_skip (void)
3055 {
3056   const char *str;
3057
3058   str = getenv ("SKIP_TEST_CP_1");
3059   if (str && strcmp (str, "1") == 0) return 1;
3060   str = getenv ("SKIP_TEST_CP");
3061   if (str && strcmp (str, "1") == 0) return 1;
3062   return 0;
3063 }
3064
3065 static int test_cp_1 (void)
3066 {
3067   if (test_cp_1_skip ()) {
3068     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
3069     return 0;
3070   }
3071
3072   /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
3073   {
3074     char device[] = "/dev/sda";
3075     int r;
3076     suppress_error = 0;
3077     r = guestfs_blockdev_setrw (g, device);
3078     if (r == -1)
3079       return -1;
3080   }
3081   {
3082     int r;
3083     suppress_error = 0;
3084     r = guestfs_umount_all (g);
3085     if (r == -1)
3086       return -1;
3087   }
3088   {
3089     int r;
3090     suppress_error = 0;
3091     r = guestfs_lvm_remove_all (g);
3092     if (r == -1)
3093       return -1;
3094   }
3095   {
3096     char device[] = "/dev/sda";
3097     char lines_0[] = ",";
3098     char *lines[] = {
3099       lines_0,
3100       NULL
3101     };
3102     int r;
3103     suppress_error = 0;
3104     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3105     if (r == -1)
3106       return -1;
3107   }
3108   {
3109     char fstype[] = "ext2";
3110     char device[] = "/dev/sda1";
3111     int r;
3112     suppress_error = 0;
3113     r = guestfs_mkfs (g, fstype, device);
3114     if (r == -1)
3115       return -1;
3116   }
3117   {
3118     char device[] = "/dev/sda1";
3119     char mountpoint[] = "/";
3120     int r;
3121     suppress_error = 0;
3122     r = guestfs_mount (g, device, mountpoint);
3123     if (r == -1)
3124       return -1;
3125   }
3126   /* TestOutputTrue for cp (1) */
3127   {
3128     char path[] = "/old";
3129     char content[] = "file content";
3130     int r;
3131     suppress_error = 0;
3132     r = guestfs_write_file (g, path, content, 0);
3133     if (r == -1)
3134       return -1;
3135   }
3136   {
3137     char src[] = "/old";
3138     char dest[] = "/new";
3139     int r;
3140     suppress_error = 0;
3141     r = guestfs_cp (g, src, dest);
3142     if (r == -1)
3143       return -1;
3144   }
3145   {
3146     char path[] = "/old";
3147     int r;
3148     suppress_error = 0;
3149     r = guestfs_is_file (g, path);
3150     if (r == -1)
3151       return -1;
3152     if (!r) {
3153       fprintf (stderr, "test_cp_1: expected true, got false\n");
3154       return -1;
3155     }
3156   }
3157   return 0;
3158 }
3159
3160 static int test_cp_2_skip (void)
3161 {
3162   const char *str;
3163
3164   str = getenv ("SKIP_TEST_CP_2");
3165   if (str && strcmp (str, "1") == 0) return 1;
3166   str = getenv ("SKIP_TEST_CP");
3167   if (str && strcmp (str, "1") == 0) return 1;
3168   return 0;
3169 }
3170
3171 static int test_cp_2 (void)
3172 {
3173   if (test_cp_2_skip ()) {
3174     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
3175     return 0;
3176   }
3177
3178   /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
3179   {
3180     char device[] = "/dev/sda";
3181     int r;
3182     suppress_error = 0;
3183     r = guestfs_blockdev_setrw (g, device);
3184     if (r == -1)
3185       return -1;
3186   }
3187   {
3188     int r;
3189     suppress_error = 0;
3190     r = guestfs_umount_all (g);
3191     if (r == -1)
3192       return -1;
3193   }
3194   {
3195     int r;
3196     suppress_error = 0;
3197     r = guestfs_lvm_remove_all (g);
3198     if (r == -1)
3199       return -1;
3200   }
3201   {
3202     char device[] = "/dev/sda";
3203     char lines_0[] = ",";
3204     char *lines[] = {
3205       lines_0,
3206       NULL
3207     };
3208     int r;
3209     suppress_error = 0;
3210     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3211     if (r == -1)
3212       return -1;
3213   }
3214   {
3215     char fstype[] = "ext2";
3216     char device[] = "/dev/sda1";
3217     int r;
3218     suppress_error = 0;
3219     r = guestfs_mkfs (g, fstype, device);
3220     if (r == -1)
3221       return -1;
3222   }
3223   {
3224     char device[] = "/dev/sda1";
3225     char mountpoint[] = "/";
3226     int r;
3227     suppress_error = 0;
3228     r = guestfs_mount (g, device, mountpoint);
3229     if (r == -1)
3230       return -1;
3231   }
3232   /* TestOutput for cp (2) */
3233   char expected[] = "file content";
3234   {
3235     char path[] = "/old";
3236     char content[] = "file content";
3237     int r;
3238     suppress_error = 0;
3239     r = guestfs_write_file (g, path, content, 0);
3240     if (r == -1)
3241       return -1;
3242   }
3243   {
3244     char path[] = "/dir";
3245     int r;
3246     suppress_error = 0;
3247     r = guestfs_mkdir (g, path);
3248     if (r == -1)
3249       return -1;
3250   }
3251   {
3252     char src[] = "/old";
3253     char dest[] = "/dir/new";
3254     int r;
3255     suppress_error = 0;
3256     r = guestfs_cp (g, src, dest);
3257     if (r == -1)
3258       return -1;
3259   }
3260   {
3261     char path[] = "/dir/new";
3262     char *r;
3263     suppress_error = 0;
3264     r = guestfs_cat (g, path);
3265     if (r == NULL)
3266       return -1;
3267     if (strcmp (r, expected) != 0) {
3268       fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3269       return -1;
3270     }
3271     free (r);
3272   }
3273   return 0;
3274 }
3275
3276 static int test_grub_install_0_skip (void)
3277 {
3278   const char *str;
3279
3280   str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3281   if (str && strcmp (str, "1") == 0) return 1;
3282   str = getenv ("SKIP_TEST_GRUB_INSTALL");
3283   if (str && strcmp (str, "1") == 0) return 1;
3284   return 0;
3285 }
3286
3287 static int test_grub_install_0 (void)
3288 {
3289   if (test_grub_install_0_skip ()) {
3290     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
3291     return 0;
3292   }
3293
3294   /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3295   {
3296     char device[] = "/dev/sda";
3297     int r;
3298     suppress_error = 0;
3299     r = guestfs_blockdev_setrw (g, device);
3300     if (r == -1)
3301       return -1;
3302   }
3303   {
3304     int r;
3305     suppress_error = 0;
3306     r = guestfs_umount_all (g);
3307     if (r == -1)
3308       return -1;
3309   }
3310   {
3311     int r;
3312     suppress_error = 0;
3313     r = guestfs_lvm_remove_all (g);
3314     if (r == -1)
3315       return -1;
3316   }
3317   {
3318     char device[] = "/dev/sda";
3319     char lines_0[] = ",";
3320     char *lines[] = {
3321       lines_0,
3322       NULL
3323     };
3324     int r;
3325     suppress_error = 0;
3326     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3327     if (r == -1)
3328       return -1;
3329   }
3330   {
3331     char fstype[] = "ext2";
3332     char device[] = "/dev/sda1";
3333     int r;
3334     suppress_error = 0;
3335     r = guestfs_mkfs (g, fstype, device);
3336     if (r == -1)
3337       return -1;
3338   }
3339   {
3340     char device[] = "/dev/sda1";
3341     char mountpoint[] = "/";
3342     int r;
3343     suppress_error = 0;
3344     r = guestfs_mount (g, device, mountpoint);
3345     if (r == -1)
3346       return -1;
3347   }
3348   /* TestOutputTrue for grub_install (0) */
3349   {
3350     char root[] = "/";
3351     char device[] = "/dev/sda1";
3352     int r;
3353     suppress_error = 0;
3354     r = guestfs_grub_install (g, root, device);
3355     if (r == -1)
3356       return -1;
3357   }
3358   {
3359     char path[] = "/boot";
3360     int r;
3361     suppress_error = 0;
3362     r = guestfs_is_dir (g, path);
3363     if (r == -1)
3364       return -1;
3365     if (!r) {
3366       fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3367       return -1;
3368     }
3369   }
3370   return 0;
3371 }
3372
3373 static int test_zero_0_skip (void)
3374 {
3375   const char *str;
3376
3377   str = getenv ("SKIP_TEST_ZERO_0");
3378   if (str && strcmp (str, "1") == 0) return 1;
3379   str = getenv ("SKIP_TEST_ZERO");
3380   if (str && strcmp (str, "1") == 0) return 1;
3381   return 0;
3382 }
3383
3384 static int test_zero_0 (void)
3385 {
3386   if (test_zero_0_skip ()) {
3387     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
3388     return 0;
3389   }
3390
3391   /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3392   {
3393     char device[] = "/dev/sda";
3394     int r;
3395     suppress_error = 0;
3396     r = guestfs_blockdev_setrw (g, device);
3397     if (r == -1)
3398       return -1;
3399   }
3400   {
3401     int r;
3402     suppress_error = 0;
3403     r = guestfs_umount_all (g);
3404     if (r == -1)
3405       return -1;
3406   }
3407   {
3408     int r;
3409     suppress_error = 0;
3410     r = guestfs_lvm_remove_all (g);
3411     if (r == -1)
3412       return -1;
3413   }
3414   {
3415     char device[] = "/dev/sda";
3416     char lines_0[] = ",";
3417     char *lines[] = {
3418       lines_0,
3419       NULL
3420     };
3421     int r;
3422     suppress_error = 0;
3423     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3424     if (r == -1)
3425       return -1;
3426   }
3427   {
3428     char fstype[] = "ext2";
3429     char device[] = "/dev/sda1";
3430     int r;
3431     suppress_error = 0;
3432     r = guestfs_mkfs (g, fstype, device);
3433     if (r == -1)
3434       return -1;
3435   }
3436   {
3437     char device[] = "/dev/sda1";
3438     char mountpoint[] = "/";
3439     int r;
3440     suppress_error = 0;
3441     r = guestfs_mount (g, device, mountpoint);
3442     if (r == -1)
3443       return -1;
3444   }
3445   /* TestOutput for zero (0) */
3446   char expected[] = "data";
3447   {
3448     char pathordevice[] = "/dev/sda1";
3449     int r;
3450     suppress_error = 0;
3451     r = guestfs_umount (g, pathordevice);
3452     if (r == -1)
3453       return -1;
3454   }
3455   {
3456     char device[] = "/dev/sda1";
3457     int r;
3458     suppress_error = 0;
3459     r = guestfs_zero (g, device);
3460     if (r == -1)
3461       return -1;
3462   }
3463   {
3464     char path[] = "/dev/sda1";
3465     char *r;
3466     suppress_error = 0;
3467     r = guestfs_file (g, path);
3468     if (r == NULL)
3469       return -1;
3470     if (strcmp (r, expected) != 0) {
3471       fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3472       return -1;
3473     }
3474     free (r);
3475   }
3476   return 0;
3477 }
3478
3479 static int test_fsck_0_skip (void)
3480 {
3481   const char *str;
3482
3483   str = getenv ("SKIP_TEST_FSCK_0");
3484   if (str && strcmp (str, "1") == 0) return 1;
3485   str = getenv ("SKIP_TEST_FSCK");
3486   if (str && strcmp (str, "1") == 0) return 1;
3487   return 0;
3488 }
3489
3490 static int test_fsck_0 (void)
3491 {
3492   if (test_fsck_0_skip ()) {
3493     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
3494     return 0;
3495   }
3496
3497   /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
3498   {
3499     char device[] = "/dev/sda";
3500     int r;
3501     suppress_error = 0;
3502     r = guestfs_blockdev_setrw (g, device);
3503     if (r == -1)
3504       return -1;
3505   }
3506   {
3507     int r;
3508     suppress_error = 0;
3509     r = guestfs_umount_all (g);
3510     if (r == -1)
3511       return -1;
3512   }
3513   {
3514     int r;
3515     suppress_error = 0;
3516     r = guestfs_lvm_remove_all (g);
3517     if (r == -1)
3518       return -1;
3519   }
3520   {
3521     char device[] = "/dev/sda";
3522     char lines_0[] = ",";
3523     char *lines[] = {
3524       lines_0,
3525       NULL
3526     };
3527     int r;
3528     suppress_error = 0;
3529     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3530     if (r == -1)
3531       return -1;
3532   }
3533   {
3534     char fstype[] = "ext2";
3535     char device[] = "/dev/sda1";
3536     int r;
3537     suppress_error = 0;
3538     r = guestfs_mkfs (g, fstype, device);
3539     if (r == -1)
3540       return -1;
3541   }
3542   {
3543     char device[] = "/dev/sda1";
3544     char mountpoint[] = "/";
3545     int r;
3546     suppress_error = 0;
3547     r = guestfs_mount (g, device, mountpoint);
3548     if (r == -1)
3549       return -1;
3550   }
3551   /* TestOutputInt for fsck (0) */
3552   {
3553     char pathordevice[] = "/dev/sda1";
3554     int r;
3555     suppress_error = 0;
3556     r = guestfs_umount (g, pathordevice);
3557     if (r == -1)
3558       return -1;
3559   }
3560   {
3561     char fstype[] = "ext2";
3562     char device[] = "/dev/sda1";
3563     int r;
3564     suppress_error = 0;
3565     r = guestfs_fsck (g, fstype, device);
3566     if (r == -1)
3567       return -1;
3568     if (r != 0) {
3569       fprintf (stderr, "test_fsck_0: expected 0 but got %d\n",               (int) r);
3570       return -1;
3571     }
3572   }
3573   return 0;
3574 }
3575
3576 static int test_fsck_1_skip (void)
3577 {
3578   const char *str;
3579
3580   str = getenv ("SKIP_TEST_FSCK_1");
3581   if (str && strcmp (str, "1") == 0) return 1;
3582   str = getenv ("SKIP_TEST_FSCK");
3583   if (str && strcmp (str, "1") == 0) return 1;
3584   return 0;
3585 }
3586
3587 static int test_fsck_1 (void)
3588 {
3589   if (test_fsck_1_skip ()) {
3590     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3591     return 0;
3592   }
3593
3594   /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3595   {
3596     char device[] = "/dev/sda";
3597     int r;
3598     suppress_error = 0;
3599     r = guestfs_blockdev_setrw (g, device);
3600     if (r == -1)
3601       return -1;
3602   }
3603   {
3604     int r;
3605     suppress_error = 0;
3606     r = guestfs_umount_all (g);
3607     if (r == -1)
3608       return -1;
3609   }
3610   {
3611     int r;
3612     suppress_error = 0;
3613     r = guestfs_lvm_remove_all (g);
3614     if (r == -1)
3615       return -1;
3616   }
3617   {
3618     char device[] = "/dev/sda";
3619     char lines_0[] = ",";
3620     char *lines[] = {
3621       lines_0,
3622       NULL
3623     };
3624     int r;
3625     suppress_error = 0;
3626     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3627     if (r == -1)
3628       return -1;
3629   }
3630   {
3631     char fstype[] = "ext2";
3632     char device[] = "/dev/sda1";
3633     int r;
3634     suppress_error = 0;
3635     r = guestfs_mkfs (g, fstype, device);
3636     if (r == -1)
3637       return -1;
3638   }
3639   {
3640     char device[] = "/dev/sda1";
3641     char mountpoint[] = "/";
3642     int r;
3643     suppress_error = 0;
3644     r = guestfs_mount (g, device, mountpoint);
3645     if (r == -1)
3646       return -1;
3647   }
3648   /* TestOutputInt for fsck (1) */
3649   {
3650     char pathordevice[] = "/dev/sda1";
3651     int r;
3652     suppress_error = 0;
3653     r = guestfs_umount (g, pathordevice);
3654     if (r == -1)
3655       return -1;
3656   }
3657   {
3658     char device[] = "/dev/sda1";
3659     int r;
3660     suppress_error = 0;
3661     r = guestfs_zero (g, device);
3662     if (r == -1)
3663       return -1;
3664   }
3665   {
3666     char fstype[] = "ext2";
3667     char device[] = "/dev/sda1";
3668     int r;
3669     suppress_error = 0;
3670     r = guestfs_fsck (g, fstype, device);
3671     if (r == -1)
3672       return -1;
3673     if (r != 8) {
3674       fprintf (stderr, "test_fsck_1: expected 8 but got %d\n",               (int) r);
3675       return -1;
3676     }
3677   }
3678   return 0;
3679 }
3680
3681 static int test_set_e2uuid_0_skip (void)
3682 {
3683   const char *str;
3684
3685   str = getenv ("SKIP_TEST_SET_E2UUID_0");
3686   if (str && strcmp (str, "1") == 0) return 1;
3687   str = getenv ("SKIP_TEST_SET_E2UUID");
3688   if (str && strcmp (str, "1") == 0) return 1;
3689   return 0;
3690 }
3691
3692 static int test_set_e2uuid_0 (void)
3693 {
3694   if (test_set_e2uuid_0_skip ()) {
3695     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3696     return 0;
3697   }
3698
3699   /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3700   {
3701     char device[] = "/dev/sda";
3702     int r;
3703     suppress_error = 0;
3704     r = guestfs_blockdev_setrw (g, device);
3705     if (r == -1)
3706       return -1;
3707   }
3708   {
3709     int r;
3710     suppress_error = 0;
3711     r = guestfs_umount_all (g);
3712     if (r == -1)
3713       return -1;
3714   }
3715   {
3716     int r;
3717     suppress_error = 0;
3718     r = guestfs_lvm_remove_all (g);
3719     if (r == -1)
3720       return -1;
3721   }
3722   {
3723     char device[] = "/dev/sda";
3724     char lines_0[] = ",";
3725     char *lines[] = {
3726       lines_0,
3727       NULL
3728     };
3729     int r;
3730     suppress_error = 0;
3731     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3732     if (r == -1)
3733       return -1;
3734   }
3735   {
3736     char fstype[] = "ext2";
3737     char device[] = "/dev/sda1";
3738     int r;
3739     suppress_error = 0;
3740     r = guestfs_mkfs (g, fstype, device);
3741     if (r == -1)
3742       return -1;
3743   }
3744   {
3745     char device[] = "/dev/sda1";
3746     char mountpoint[] = "/";
3747     int r;
3748     suppress_error = 0;
3749     r = guestfs_mount (g, device, mountpoint);
3750     if (r == -1)
3751       return -1;
3752   }
3753   /* TestOutput for set_e2uuid (0) */
3754   char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3755   {
3756     char device[] = "/dev/sda1";
3757     char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3758     int r;
3759     suppress_error = 0;
3760     r = guestfs_set_e2uuid (g, device, uuid);
3761     if (r == -1)
3762       return -1;
3763   }
3764   {
3765     char device[] = "/dev/sda1";
3766     char *r;
3767     suppress_error = 0;
3768     r = guestfs_get_e2uuid (g, device);
3769     if (r == NULL)
3770       return -1;
3771     if (strcmp (r, expected) != 0) {
3772       fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3773       return -1;
3774     }
3775     free (r);
3776   }
3777   return 0;
3778 }
3779
3780 static int test_set_e2uuid_1_skip (void)
3781 {
3782   const char *str;
3783
3784   str = getenv ("SKIP_TEST_SET_E2UUID_1");
3785   if (str && strcmp (str, "1") == 0) return 1;
3786   str = getenv ("SKIP_TEST_SET_E2UUID");
3787   if (str && strcmp (str, "1") == 0) return 1;
3788   return 0;
3789 }
3790
3791 static int test_set_e2uuid_1 (void)
3792 {
3793   if (test_set_e2uuid_1_skip ()) {
3794     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3795     return 0;
3796   }
3797
3798   /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3799   {
3800     char device[] = "/dev/sda";
3801     int r;
3802     suppress_error = 0;
3803     r = guestfs_blockdev_setrw (g, device);
3804     if (r == -1)
3805       return -1;
3806   }
3807   {
3808     int r;
3809     suppress_error = 0;
3810     r = guestfs_umount_all (g);
3811     if (r == -1)
3812       return -1;
3813   }
3814   {
3815     int r;
3816     suppress_error = 0;
3817     r = guestfs_lvm_remove_all (g);
3818     if (r == -1)
3819       return -1;
3820   }
3821   {
3822     char device[] = "/dev/sda";
3823     char lines_0[] = ",";
3824     char *lines[] = {
3825       lines_0,
3826       NULL
3827     };
3828     int r;
3829     suppress_error = 0;
3830     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3831     if (r == -1)
3832       return -1;
3833   }
3834   {
3835     char fstype[] = "ext2";
3836     char device[] = "/dev/sda1";
3837     int r;
3838     suppress_error = 0;
3839     r = guestfs_mkfs (g, fstype, device);
3840     if (r == -1)
3841       return -1;
3842   }
3843   {
3844     char device[] = "/dev/sda1";
3845     char mountpoint[] = "/";
3846     int r;
3847     suppress_error = 0;
3848     r = guestfs_mount (g, device, mountpoint);
3849     if (r == -1)
3850       return -1;
3851   }
3852   /* TestOutput for set_e2uuid (1) */
3853   char expected[] = "";
3854   {
3855     char device[] = "/dev/sda1";
3856     char uuid[] = "clear";
3857     int r;
3858     suppress_error = 0;
3859     r = guestfs_set_e2uuid (g, device, uuid);
3860     if (r == -1)
3861       return -1;
3862   }
3863   {
3864     char device[] = "/dev/sda1";
3865     char *r;
3866     suppress_error = 0;
3867     r = guestfs_get_e2uuid (g, device);
3868     if (r == NULL)
3869       return -1;
3870     if (strcmp (r, expected) != 0) {
3871       fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3872       return -1;
3873     }
3874     free (r);
3875   }
3876   return 0;
3877 }
3878
3879 static int test_set_e2uuid_2_skip (void)
3880 {
3881   const char *str;
3882
3883   str = getenv ("SKIP_TEST_SET_E2UUID_2");
3884   if (str && strcmp (str, "1") == 0) return 1;
3885   str = getenv ("SKIP_TEST_SET_E2UUID");
3886   if (str && strcmp (str, "1") == 0) return 1;
3887   return 0;
3888 }
3889
3890 static int test_set_e2uuid_2 (void)
3891 {
3892   if (test_set_e2uuid_2_skip ()) {
3893     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3894     return 0;
3895   }
3896
3897   /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3898   {
3899     char device[] = "/dev/sda";
3900     int r;
3901     suppress_error = 0;
3902     r = guestfs_blockdev_setrw (g, device);
3903     if (r == -1)
3904       return -1;
3905   }
3906   {
3907     int r;
3908     suppress_error = 0;
3909     r = guestfs_umount_all (g);
3910     if (r == -1)
3911       return -1;
3912   }
3913   {
3914     int r;
3915     suppress_error = 0;
3916     r = guestfs_lvm_remove_all (g);
3917     if (r == -1)
3918       return -1;
3919   }
3920   {
3921     char device[] = "/dev/sda";
3922     char lines_0[] = ",";
3923     char *lines[] = {
3924       lines_0,
3925       NULL
3926     };
3927     int r;
3928     suppress_error = 0;
3929     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3930     if (r == -1)
3931       return -1;
3932   }
3933   {
3934     char fstype[] = "ext2";
3935     char device[] = "/dev/sda1";
3936     int r;
3937     suppress_error = 0;
3938     r = guestfs_mkfs (g, fstype, device);
3939     if (r == -1)
3940       return -1;
3941   }
3942   {
3943     char device[] = "/dev/sda1";
3944     char mountpoint[] = "/";
3945     int r;
3946     suppress_error = 0;
3947     r = guestfs_mount (g, device, mountpoint);
3948     if (r == -1)
3949       return -1;
3950   }
3951   /* TestRun for set_e2uuid (2) */
3952   {
3953     char device[] = "/dev/sda1";
3954     char uuid[] = "random";
3955     int r;
3956     suppress_error = 0;
3957     r = guestfs_set_e2uuid (g, device, uuid);
3958     if (r == -1)
3959       return -1;
3960   }
3961   return 0;
3962 }
3963
3964 static int test_set_e2uuid_3_skip (void)
3965 {
3966   const char *str;
3967
3968   str = getenv ("SKIP_TEST_SET_E2UUID_3");
3969   if (str && strcmp (str, "1") == 0) return 1;
3970   str = getenv ("SKIP_TEST_SET_E2UUID");
3971   if (str && strcmp (str, "1") == 0) return 1;
3972   return 0;
3973 }
3974
3975 static int test_set_e2uuid_3 (void)
3976 {
3977   if (test_set_e2uuid_3_skip ()) {
3978     printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3979     return 0;
3980   }
3981
3982   /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3983   {
3984     char device[] = "/dev/sda";
3985     int r;
3986     suppress_error = 0;
3987     r = guestfs_blockdev_setrw (g, device);
3988     if (r == -1)
3989       return -1;
3990   }
3991   {
3992     int r;
3993     suppress_error = 0;
3994     r = guestfs_umount_all (g);
3995     if (r == -1)
3996       return -1;
3997   }
3998   {
3999     int r;
4000     suppress_error = 0;
4001     r = guestfs_lvm_remove_all (g);
4002     if (r == -1)
4003       return -1;
4004   }
4005   {
4006     char device[] = "/dev/sda";
4007     char lines_0[] = ",";
4008     char *lines[] = {
4009       lines_0,
4010       NULL
4011     };
4012     int r;
4013     suppress_error = 0;
4014     r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4015     if (r == -1)
4016       return -1;
4017   }
4018   {
4019     char fstype[] = "ext2";
4020     char device[] = "/dev/sda1";
4021     int r;
4022     suppress_error = 0;
4023     r = guestfs_mkfs (g, fstype, device);
4024     if (r == -1)
4025       return -1;
4026   }
4027   {
4028     char device[] = "/dev/sda1";
4029     char mountpoint[] = "/";
4030     int r;
4031     suppress_error = 0;
4032     r = guestfs_mount (g, device, mountpoint);
4033     if (r == -1)
4034       return -1;
4035   }
4036   /* TestRun for set_e2uuid (3) */
4037   {
4038     char device[] = "/dev/sda1";
4039     char uuid[] = "time";
4040     int r;
4041     suppress_error = 0;
4042     r = guestfs_set_e2uuid (g, device, uuid);
4043     if (r == -1)
4044       return -1;
4045   }
4046   return 0;
4047 }
4048
4049 static int test_set_e2label_0_skip (void)
4050 {