Prepare for 1.0.46.
[libguestfs.git] / src / guestfs-bindtests.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 library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library 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 GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <inttypes.h>
25 #include <string.h>
26
27 #include "guestfs.h"
28 #include "guestfs_protocol.h"
29
30 #define error guestfs_error
31
32 static void
33 print_strings (char * const* const argv)
34 {
35   int argc;
36
37   printf ("[");
38   for (argc = 0; argv[argc] != NULL; ++argc) {
39     if (argc > 0) printf (", ");
40     printf ("\"%s\"", argv[argc]);
41   }
42   printf ("]\n");
43 }
44
45 /* The test0 function prints its parameters to stdout. */
46 int guestfs_test0 (guestfs_h *g,
47                 const char *str,
48                 const char *optstr,
49                 char * const* const strlist,
50                 int b,
51                 int integer,
52                 const char *filein,
53                 const char *fileout)
54 {
55   printf ("%s\n", str);
56   printf ("%s\n", optstr ? optstr : "null");
57   print_strings (strlist);
58   printf ("%s\n", b ? "true" : "false");
59   printf ("%d\n", integer);
60   printf ("%s\n", filein);
61   printf ("%s\n", fileout);
62   /* Java changes stdout line buffering so we need this: */
63   fflush (stdout);
64   return 0;
65 }
66
67 /* Test normal return. */
68 int guestfs_test0rint (guestfs_h *g,
69                 const char *val)
70 {
71   int r;
72   sscanf (val, "%d", &r);
73   return r;
74 }
75
76 /* Test error return. */
77 int guestfs_test0rinterr (guestfs_h *g)
78 {
79   error (g, "error");
80   return -1;
81 }
82
83 /* Test normal return. */
84 int64_t guestfs_test0rint64 (guestfs_h *g,
85                 const char *val)
86 {
87   int64_t r;
88   sscanf (val, "%" SCNi64, &r);
89   return r;
90 }
91
92 /* Test error return. */
93 int64_t guestfs_test0rint64err (guestfs_h *g)
94 {
95   error (g, "error");
96   return -1;
97 }
98
99 /* Test normal return. */
100 int guestfs_test0rbool (guestfs_h *g,
101                 const char *val)
102 {
103   return strcmp (val, "true") == 0;
104 }
105
106 /* Test error return. */
107 int guestfs_test0rboolerr (guestfs_h *g)
108 {
109   error (g, "error");
110   return -1;
111 }
112
113 /* Test normal return. */
114 const char *guestfs_test0rconststring (guestfs_h *g,
115                 const char *val)
116 {
117   return "static string";
118 }
119
120 /* Test error return. */
121 const char *guestfs_test0rconststringerr (guestfs_h *g)
122 {
123   error (g, "error");
124   return NULL;
125 }
126
127 /* Test normal return. */
128 char *guestfs_test0rstring (guestfs_h *g,
129                 const char *val)
130 {
131   return strdup (val);
132 }
133
134 /* Test error return. */
135 char *guestfs_test0rstringerr (guestfs_h *g)
136 {
137   error (g, "error");
138   return NULL;
139 }
140
141 /* Test normal return. */
142 char **guestfs_test0rstringlist (guestfs_h *g,
143                 const char *val)
144 {
145   char **strs;
146   int n, i;
147   sscanf (val, "%d", &n);
148   strs = malloc ((n+1) * sizeof (char *));
149   for (i = 0; i < n; ++i) {
150     strs[i] = malloc (16);
151     snprintf (strs[i], 16, "%d", i);
152   }
153   strs[n] = NULL;
154   return strs;
155 }
156
157 /* Test error return. */
158 char **guestfs_test0rstringlisterr (guestfs_h *g)
159 {
160   error (g, "error");
161   return NULL;
162 }
163
164 /* Test normal return. */
165 struct guestfs_int_bool *guestfs_test0rintbool (guestfs_h *g,
166                 const char *val)
167 {
168   struct guestfs_int_bool *r;
169   r = malloc (sizeof (struct guestfs_int_bool));
170   sscanf (val, "%" SCNi32, &r->i);
171   r->b = 0;
172   return r;
173 }
174
175 /* Test error return. */
176 struct guestfs_int_bool *guestfs_test0rintboolerr (guestfs_h *g)
177 {
178   error (g, "error");
179   return NULL;
180 }
181
182 /* Test normal return. */
183 struct guestfs_lvm_pv_list *guestfs_test0rpvlist (guestfs_h *g,
184                 const char *val)
185 {
186   struct guestfs_lvm_pv_list *r;
187   int i;
188   r = malloc (sizeof (struct guestfs_lvm_pv_list));
189   sscanf (val, "%d", &r->len);
190   r->val = calloc (r->len, sizeof (struct guestfs_lvm_pv));
191   for (i = 0; i < r->len; ++i) {
192     r->val[i].pv_name = malloc (16);
193     snprintf (r->val[i].pv_name, 16, "%d", i);
194   }
195   return r;
196 }
197
198 /* Test error return. */
199 struct guestfs_lvm_pv_list *guestfs_test0rpvlisterr (guestfs_h *g)
200 {
201   error (g, "error");
202   return NULL;
203 }
204
205 /* Test normal return. */
206 struct guestfs_lvm_vg_list *guestfs_test0rvglist (guestfs_h *g,
207                 const char *val)
208 {
209   struct guestfs_lvm_vg_list *r;
210   int i;
211   r = malloc (sizeof (struct guestfs_lvm_vg_list));
212   sscanf (val, "%d", &r->len);
213   r->val = calloc (r->len, sizeof (struct guestfs_lvm_vg));
214   for (i = 0; i < r->len; ++i) {
215     r->val[i].vg_name = malloc (16);
216     snprintf (r->val[i].vg_name, 16, "%d", i);
217   }
218   return r;
219 }
220
221 /* Test error return. */
222 struct guestfs_lvm_vg_list *guestfs_test0rvglisterr (guestfs_h *g)
223 {
224   error (g, "error");
225   return NULL;
226 }
227
228 /* Test normal return. */
229 struct guestfs_lvm_lv_list *guestfs_test0rlvlist (guestfs_h *g,
230                 const char *val)
231 {
232   struct guestfs_lvm_lv_list *r;
233   int i;
234   r = malloc (sizeof (struct guestfs_lvm_lv_list));
235   sscanf (val, "%d", &r->len);
236   r->val = calloc (r->len, sizeof (struct guestfs_lvm_lv));
237   for (i = 0; i < r->len; ++i) {
238     r->val[i].lv_name = malloc (16);
239     snprintf (r->val[i].lv_name, 16, "%d", i);
240   }
241   return r;
242 }
243
244 /* Test error return. */
245 struct guestfs_lvm_lv_list *guestfs_test0rlvlisterr (guestfs_h *g)
246 {
247   error (g, "error");
248   return NULL;
249 }
250
251 /* Test normal return. */
252 struct guestfs_stat *guestfs_test0rstat (guestfs_h *g,
253                 const char *val)
254 {
255   struct guestfs_stat *r;
256   r = calloc (1, sizeof (*r));
257   sscanf (val, "%" SCNi64, &r->dev);
258   return r;
259 }
260
261 /* Test error return. */
262 struct guestfs_stat *guestfs_test0rstaterr (guestfs_h *g)
263 {
264   error (g, "error");
265   return NULL;
266 }
267
268 /* Test normal return. */
269 struct guestfs_statvfs *guestfs_test0rstatvfs (guestfs_h *g,
270                 const char *val)
271 {
272   struct guestfs_statvfs *r;
273   r = calloc (1, sizeof (*r));
274   sscanf (val, "%" SCNi64, &r->bsize);
275   return r;
276 }
277
278 /* Test error return. */
279 struct guestfs_statvfs *guestfs_test0rstatvfserr (guestfs_h *g)
280 {
281   error (g, "error");
282   return NULL;
283 }
284
285 /* Test normal return. */
286 char **guestfs_test0rhashtable (guestfs_h *g,
287                 const char *val)
288 {
289   char **strs;
290   int n, i;
291   sscanf (val, "%d", &n);
292   strs = malloc ((n*2+1) * sizeof (char *));
293   for (i = 0; i < n; ++i) {
294     strs[i*2] = malloc (16);
295     strs[i*2+1] = malloc (16);
296     snprintf (strs[i*2], 16, "%d", i);
297     snprintf (strs[i*2+1], 16, "%d", i);
298   }
299   strs[n*2] = NULL;
300   return strs;
301 }
302
303 /* Test error return. */
304 char **guestfs_test0rhashtableerr (guestfs_h *g)
305 {
306   error (g, "error");
307   return NULL;
308 }
309