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