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