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