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   return 0;
  63 }
  64
  65 /* Test normal return. */
  66 int guestfs_test0rint (guestfs_h *g,
  67                 const char *val)
  68 {
  69   int r;
  70   sscanf (val, "%d", &r);
  71   return r;
  72 }
  73
  74 /* Test error return. */
  75 int guestfs_test0rinterr (guestfs_h *g)
  76 {
  77   error (g, "error");
  78   return -1;
  79 }
  80
  81 /* Test normal return. */
  82 int64_t guestfs_test0rint64 (guestfs_h *g,
  83                 const char *val)
  84 {
  85   int64_t r;
  86   sscanf (val, "%" SCNi64, &r);
  87   return r;
  88 }
  89
  90 /* Test error return. */
  91 int64_t guestfs_test0rint64err (guestfs_h *g)
  92 {
  93   error (g, "error");
  94   return -1;
  95 }
  96
  97 /* Test normal return. */
  98 int guestfs_test0rbool (guestfs_h *g,
  99                 const char *val)
 100 {
 101   return strcmp (val, "true") == 0;
 102 }
 103
 104 /* Test error return. */
 105 int guestfs_test0rboolerr (guestfs_h *g)
 106 {
 107   error (g, "error");
 108   return -1;
 109 }
 110
 111 /* Test normal return. */
 112 const char *guestfs_test0rconststring (guestfs_h *g,
 113                 const char *val)
 114 {
 115   return "static string";
 116 }
 117
 118 /* Test error return. */
 119 const char *guestfs_test0rconststringerr (guestfs_h *g)
 120 {
 121   error (g, "error");
 122   return NULL;
 123 }
 124
 125 /* Test normal return. */
 126 char *guestfs_test0rstring (guestfs_h *g,
 127                 const char *val)
 128 {
 129   return strdup (val);
 130 }
 131
 132 /* Test error return. */
 133 char *guestfs_test0rstringerr (guestfs_h *g)
 134 {
 135   error (g, "error");
 136   return NULL;
 137 }
 138
 139 /* Test normal return. */
 140 char **guestfs_test0rstringlist (guestfs_h *g,
 141                 const char *val)
 142 {
 143   char **strs;
 144   int n, i;
 145   sscanf (val, "%d", &n);
 146   strs = malloc ((n+1) * sizeof (char *));
 147   for (i = 0; i < n; ++i) {
 148     strs[i] = malloc (16);
 149     snprintf (strs[i], 16, "%d", i);
 150   }
 151   strs[n] = NULL;
 152   return strs;
 153 }
 154
 155 /* Test error return. */
 156 char **guestfs_test0rstringlisterr (guestfs_h *g)
 157 {
 158   error (g, "error");
 159   return NULL;
 160 }
 161
 162 /* Test normal return. */
 163 struct guestfs_int_bool *guestfs_test0rintbool (guestfs_h *g,
 164                 const char *val)
 165 {
 166   struct guestfs_int_bool *r;
 167   r = malloc (sizeof (struct guestfs_int_bool));
 168   sscanf (val, "%" SCNi32, &r->i);
 169   r->b = 0;
 170   return r;
 171 }
 172
 173 /* Test error return. */
 174 struct guestfs_int_bool *guestfs_test0rintboolerr (guestfs_h *g)
 175 {
 176   error (g, "error");
 177   return NULL;
 178 }
 179
 180 /* Test normal return. */
 181 struct guestfs_lvm_pv_list *guestfs_test0rpvlist (guestfs_h *g,
 182                 const char *val)
 183 {
 184   struct guestfs_lvm_pv_list *r;
 185   int i;
 186   r = malloc (sizeof (struct guestfs_lvm_pv_list));
 187   sscanf (val, "%d", &r->len);
 188   r->val = calloc (r->len, sizeof (struct guestfs_lvm_pv));
 189   for (i = 0; i < r->len; ++i) {
 190     r->val[i].pv_name = malloc (16);
 191     snprintf (r->val[i].pv_name, 16, "%d", i);
 192   }
 193   return r;
 194 }
 195
 196 /* Test error return. */
 197 struct guestfs_lvm_pv_list *guestfs_test0rpvlisterr (guestfs_h *g)
 198 {
 199   error (g, "error");
 200   return NULL;
 201 }
 202
 203 /* Test normal return. */
 204 struct guestfs_lvm_vg_list *guestfs_test0rvglist (guestfs_h *g,
 205                 const char *val)
 206 {
 207   struct guestfs_lvm_vg_list *r;
 208   int i;
 209   r = malloc (sizeof (struct guestfs_lvm_vg_list));
 210   sscanf (val, "%d", &r->len);
 211   r->val = calloc (r->len, sizeof (struct guestfs_lvm_vg));
 212   for (i = 0; i < r->len; ++i) {
 213     r->val[i].vg_name = malloc (16);
 214     snprintf (r->val[i].vg_name, 16, "%d", i);
 215   }
 216   return r;
 217 }
 218
 219 /* Test error return. */
 220 struct guestfs_lvm_vg_list *guestfs_test0rvglisterr (guestfs_h *g)
 221 {
 222   error (g, "error");
 223   return NULL;
 224 }
 225
 226 /* Test normal return. */
 227 struct guestfs_lvm_lv_list *guestfs_test0rlvlist (guestfs_h *g,
 228                 const char *val)
 229 {
 230   struct guestfs_lvm_lv_list *r;
 231   int i;
 232   r = malloc (sizeof (struct guestfs_lvm_lv_list));
 233   sscanf (val, "%d", &r->len);
 234   r->val = calloc (r->len, sizeof (struct guestfs_lvm_lv));
 235   for (i = 0; i < r->len; ++i) {
 236     r->val[i].lv_name = malloc (16);
 237     snprintf (r->val[i].lv_name, 16, "%d", i);
 238   }
 239   return r;
 240 }
 241
 242 /* Test error return. */
 243 struct guestfs_lvm_lv_list *guestfs_test0rlvlisterr (guestfs_h *g)
 244 {
 245   error (g, "error");
 246   return NULL;
 247 }
 248
 249 /* Test normal return. */
 250 struct guestfs_stat *guestfs_test0rstat (guestfs_h *g,
 251                 const char *val)
 252 {
 253   struct guestfs_stat *r;
 254   r = calloc (1, sizeof (*r));
 255   sscanf (val, "%" SCNi64, &r->dev);
 256   return r;
 257 }
 258
 259 /* Test error return. */
 260 struct guestfs_stat *guestfs_test0rstaterr (guestfs_h *g)
 261 {
 262   error (g, "error");
 263   return NULL;
 264 }
 265
 266 /* Test normal return. */
 267 struct guestfs_statvfs *guestfs_test0rstatvfs (guestfs_h *g,
 268                 const char *val)
 269 {
 270   struct guestfs_statvfs *r;
 271   r = calloc (1, sizeof (*r));
 272   sscanf (val, "%" SCNi64, &r->bsize);
 273   return r;
 274 }
 275
 276 /* Test error return. */
 277 struct guestfs_statvfs *guestfs_test0rstatvfserr (guestfs_h *g)
 278 {
 279   error (g, "error");
 280   return NULL;
 281 }
 282
 283 /* Test normal return. */
 284 char **guestfs_test0rhashtable (guestfs_h *g,
 285                 const char *val)
 286 {
 287   char **strs;
 288   int n, i;
 289   sscanf (val, "%d", &n);
 290   strs = malloc ((n*2+1) * sizeof (char *));
 291   for (i = 0; i < n; ++i) {
 292     strs[i*2] = malloc (16);
 293     strs[i*2+1] = malloc (16);
 294     snprintf (strs[i*2], 16, "%d", i);
 295     snprintf (strs[i*2+1], 16, "%d", i);
 296   }
 297   strs[n*2] = NULL;
 298   return strs;
 299 }
 300
 301 /* Test error return. */
 302 char **guestfs_test0rhashtableerr (guestfs_h *g)
 303 {
 304   error (g, "error");
 305   return NULL;
 306 }
 307