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