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