tests/test-string-input-visitor.c

   1 /*
   2  * String Input Visitor unit-tests.
   3  *
   4  * Copyright (C) 2012 Red Hat Inc.
   5  *
   6  * Authors:
   7  *  Paolo Bonzini <pbonzini@redhat.com> (based on test-qobject-input-visitor)
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14
  15 #include "qemu-common.h"
  16 #include "qapi/error.h"
  17 #include "qapi/string-input-visitor.h"
  18 #include "test-qapi-visit.h"
  19
  20 typedef struct TestInputVisitorData {
  21     Visitor *v;
  22 } TestInputVisitorData;
  23
  24 static void visitor_input_teardown(TestInputVisitorData *data,
  25                                    const void *unused)
  26 {
  27     if (data->v) {
  28         visit_free(data->v);
  29         data->v = NULL;
  30     }
  31 }
  32
  33 /* This is provided instead of a test setup function so that the JSON
  34    string used by the tests are kept in the test functions (and not
  35    int main()) */
  36 static
  37 Visitor *visitor_input_test_init(TestInputVisitorData *data,
  38                                  const char *string)
  39 {
  40     visitor_input_teardown(data, NULL);
  41
  42     data->v = string_input_visitor_new(string);
  43     g_assert(data->v);
  44     return data->v;
  45 }
  46
  47 static void test_visitor_in_int(TestInputVisitorData *data,
  48                                 const void *unused)
  49 {
  50     int64_t res = 0, value = -42;
  51     Error *err = NULL;
  52     Visitor *v;
  53
  54     v = visitor_input_test_init(data, "-42");
  55
  56     visit_type_int(v, NULL, &res, &err);
  57     g_assert(!err);
  58     g_assert_cmpint(res, ==, value);
  59
  60     v = visitor_input_test_init(data, "not an int");
  61
  62     visit_type_int(v, NULL, &res, &err);
  63     error_free_or_abort(&err);
  64
  65     v = visitor_input_test_init(data, "");
  66
  67     visit_type_int(v, NULL, &res, &err);
  68     error_free_or_abort(&err);
  69 }
  70
  71 static void check_ilist(Visitor *v, int64_t *expected, size_t n)
  72 {
  73     int64List *res = NULL;
  74     int64List *tail;
  75     int i;
  76
  77     visit_type_int64List(v, NULL, &res, &error_abort);
  78     tail = res;
  79     for (i = 0; i < n; i++) {
  80         g_assert(tail);
  81         g_assert_cmpint(tail->value, ==, expected[i]);
  82         tail = tail->next;
  83     }
  84     g_assert(!tail);
  85
  86     qapi_free_int64List(res);
  87 }
  88
  89 static void check_ulist(Visitor *v, uint64_t *expected, size_t n)
  90 {
  91     uint64List *res = NULL;
  92     uint64List *tail;
  93     int i;
  94
  95     visit_type_uint64List(v, NULL, &res, &error_abort);
  96     tail = res;
  97     for (i = 0; i < n; i++) {
  98         g_assert(tail);
  99         g_assert_cmpuint(tail->value, ==, expected[i]);
 100         tail = tail->next;
 101     }
 102     g_assert(!tail);
 103
 104     qapi_free_uint64List(res);
 105 }
 106
 107 static void test_visitor_in_intList(TestInputVisitorData *data,
 108                                     const void *unused)
 109 {
 110     int64_t expect1[] = { 1, 2, 0, 2, 3, 4, 20, 5, 6, 7,
 111                           8, 9, 1, 2, 3, 4, 5, 6, 7, 8 };
 112     int64_t expect2[] = { 32767, -32768, -32767 };
 113     int64_t expect3[] = { INT64_MIN, INT64_MAX };
 114     int64_t expect4[] = { 1 };
 115     uint64_t expect5[] = { UINT64_MAX };
 116     Error *err = NULL;
 117     int64List *res = NULL;
 118     int64List *tail;
 119     Visitor *v;
 120     int64_t val;
 121
 122     /* Valid lists */
 123
 124     v = visitor_input_test_init(data, "1,2,0,2-4,20,5-9,1-8");
 125     check_ilist(v, expect1, ARRAY_SIZE(expect1));
 126
 127     v = visitor_input_test_init(data, "32767,-32768--32767");
 128     check_ilist(v, expect2, ARRAY_SIZE(expect2));
 129
 130     v = visitor_input_test_init(data,
 131                                 "-9223372036854775808,9223372036854775807");
 132     check_ilist(v, expect3, ARRAY_SIZE(expect3));
 133
 134     v = visitor_input_test_init(data, "1-1");
 135     check_ilist(v, expect4, ARRAY_SIZE(expect4));
 136
 137     v = visitor_input_test_init(data, "18446744073709551615");
 138     check_ulist(v, expect5, ARRAY_SIZE(expect5));
 139
 140     /* Value too large */
 141
 142     v = visitor_input_test_init(data, "9223372036854775808");
 143     visit_type_int64List(v, NULL, &res, &err);
 144     error_free_or_abort(&err);
 145     g_assert(!res);
 146
 147     /* Value too small */
 148
 149     v = visitor_input_test_init(data, "-9223372036854775809");
 150     visit_type_int64List(v, NULL, &res, &err);
 151     error_free_or_abort(&err);
 152     g_assert(!res);
 153
 154     /* Range not ascending */
 155
 156     v = visitor_input_test_init(data, "3-1");
 157     visit_type_int64List(v, NULL, &res, &err);
 158     error_free_or_abort(&err);
 159     g_assert(!res);
 160
 161     v = visitor_input_test_init(data, "9223372036854775807-0");
 162     visit_type_int64List(v, NULL, &res, &err);
 163     error_free_or_abort(&err);
 164     g_assert(!res);
 165
 166     /* Range too big (65536 is the limit against DOS attacks) */
 167
 168     v = visitor_input_test_init(data, "0-65536");
 169     visit_type_int64List(v, NULL, &res, &err);
 170     error_free_or_abort(&err);
 171     g_assert(!res);
 172
 173     /* Empty list */
 174
 175     v = visitor_input_test_init(data, "");
 176     visit_type_int64List(v, NULL, &res, &error_abort);
 177     g_assert(!res);
 178
 179     /* Not a list */
 180
 181     v = visitor_input_test_init(data, "not an int list");
 182
 183     visit_type_int64List(v, NULL, &res, &err);
 184     error_free_or_abort(&err);
 185     g_assert(!res);
 186
 187     /* Unvisited list tail */
 188
 189     v = visitor_input_test_init(data, "0,2-3");
 190
 191     /* Would be simpler if the visitor genuinely supported virtual walks */
 192     visit_start_list(v, NULL, (GenericList **)&res, sizeof(*res),
 193                      &error_abort);
 194     tail = res;
 195     visit_type_int64(v, NULL, &tail->value, &error_abort);
 196     g_assert_cmpint(tail->value, ==, 0);
 197     tail = (int64List *)visit_next_list(v, (GenericList *)tail, sizeof(*res));
 198     g_assert(tail);
 199     visit_type_int64(v, NULL, &tail->value, &error_abort);
 200     g_assert_cmpint(tail->value, ==, 2);
 201     tail = (int64List *)visit_next_list(v, (GenericList *)tail, sizeof(*res));
 202     g_assert(tail);
 203
 204     visit_check_list(v, &err);
 205     error_free_or_abort(&err);
 206     visit_end_list(v, (void **)&res);
 207
 208     qapi_free_int64List(res);
 209
 210     /* Visit beyond end of list */
 211     v = visitor_input_test_init(data, "0");
 212
 213     visit_start_list(v, NULL, (GenericList **)&res, sizeof(*res),
 214                      &error_abort);
 215     tail = res;
 216     visit_type_int64(v, NULL, &tail->value, &err);
 217     g_assert_cmpint(tail->value, ==, 0);
 218     visit_type_int64(v, NULL, &val, &err);
 219     error_free_or_abort(&err);
 220     visit_check_list(v, &error_abort);
 221     visit_end_list(v, (void **)&res);
 222
 223     qapi_free_int64List(res);
 224 }
 225
 226 static void test_visitor_in_bool(TestInputVisitorData *data,
 227                                  const void *unused)
 228 {
 229     Error *err = NULL;
 230     bool res = false;
 231     Visitor *v;
 232
 233     v = visitor_input_test_init(data, "true");
 234
 235     visit_type_bool(v, NULL, &res, &err);
 236     g_assert(!err);
 237     g_assert_cmpint(res, ==, true);
 238
 239     v = visitor_input_test_init(data, "yes");
 240
 241     visit_type_bool(v, NULL, &res, &err);
 242     g_assert(!err);
 243     g_assert_cmpint(res, ==, true);
 244
 245     v = visitor_input_test_init(data, "on");
 246
 247     visit_type_bool(v, NULL, &res, &err);
 248     g_assert(!err);
 249     g_assert_cmpint(res, ==, true);
 250
 251     v = visitor_input_test_init(data, "false");
 252
 253     visit_type_bool(v, NULL, &res, &err);
 254     g_assert(!err);
 255     g_assert_cmpint(res, ==, false);
 256
 257     v = visitor_input_test_init(data, "no");
 258
 259     visit_type_bool(v, NULL, &res, &err);
 260     g_assert(!err);
 261     g_assert_cmpint(res, ==, false);
 262
 263     v = visitor_input_test_init(data, "off");
 264
 265     visit_type_bool(v, NULL, &res, &err);
 266     g_assert(!err);
 267     g_assert_cmpint(res, ==, false);
 268 }
 269
 270 static void test_visitor_in_number(TestInputVisitorData *data,
 271                                    const void *unused)
 272 {
 273     double res = 0, value = 3.14;
 274     Error *err = NULL;
 275     Visitor *v;
 276
 277     v = visitor_input_test_init(data, "3.14");
 278
 279     visit_type_number(v, NULL, &res, &err);
 280     g_assert(!err);
 281     g_assert_cmpfloat(res, ==, value);
 282
 283     /* NaN and infinity has to be rejected */
 284
 285     v = visitor_input_test_init(data, "NaN");
 286
 287     visit_type_number(v, NULL, &res, &err);
 288     error_free_or_abort(&err);
 289
 290     v = visitor_input_test_init(data, "inf");
 291
 292     visit_type_number(v, NULL, &res, &err);
 293     error_free_or_abort(&err);
 294
 295 }
 296
 297 static void test_visitor_in_string(TestInputVisitorData *data,
 298                                    const void *unused)
 299 {
 300     char *res = NULL, *value = (char *) "Q E M U";
 301     Error *err = NULL;
 302     Visitor *v;
 303
 304     v = visitor_input_test_init(data, value);
 305
 306     visit_type_str(v, NULL, &res, &err);
 307     g_assert(!err);
 308     g_assert_cmpstr(res, ==, value);
 309
 310     g_free(res);
 311 }
 312
 313 static void test_visitor_in_enum(TestInputVisitorData *data,
 314                                  const void *unused)
 315 {
 316     Error *err = NULL;
 317     Visitor *v;
 318     EnumOne i;
 319
 320     for (i = 0; i < ENUM_ONE__MAX; i++) {
 321         EnumOne res = -1;
 322
 323         v = visitor_input_test_init(data, EnumOne_str(i));
 324
 325         visit_type_EnumOne(v, NULL, &res, &err);
 326         g_assert(!err);
 327         g_assert_cmpint(i, ==, res);
 328     }
 329 }
 330
 331 /* Try to crash the visitors */
 332 static void test_visitor_in_fuzz(TestInputVisitorData *data,
 333                                  const void *unused)
 334 {
 335     int64_t ires;
 336     intList *ilres;
 337     bool bres;
 338     double nres;
 339     char *sres;
 340     EnumOne eres;
 341     Visitor *v;
 342     unsigned int i;
 343     char buf[10000];
 344
 345     for (i = 0; i < 100; i++) {
 346         unsigned int j;
 347
 348         j = g_test_rand_int_range(0, sizeof(buf) - 1);
 349
 350         buf[j] = '\0';
 351
 352         if (j != 0) {
 353             for (j--; j != 0; j--) {
 354                 buf[j - 1] = (char)g_test_rand_int_range(0, 256);
 355             }
 356         }
 357
 358         v = visitor_input_test_init(data, buf);
 359         visit_type_int(v, NULL, &ires, NULL);
 360
 361         v = visitor_input_test_init(data, buf);
 362         visit_type_intList(v, NULL, &ilres, NULL);
 363         qapi_free_intList(ilres);
 364
 365         v = visitor_input_test_init(data, buf);
 366         visit_type_bool(v, NULL, &bres, NULL);
 367
 368         v = visitor_input_test_init(data, buf);
 369         visit_type_number(v, NULL, &nres, NULL);
 370
 371         v = visitor_input_test_init(data, buf);
 372         sres = NULL;
 373         visit_type_str(v, NULL, &sres, NULL);
 374         g_free(sres);
 375
 376         v = visitor_input_test_init(data, buf);
 377         visit_type_EnumOne(v, NULL, &eres, NULL);
 378     }
 379 }
 380
 381 static void input_visitor_test_add(const char *testpath,
 382                                    TestInputVisitorData *data,
 383                                    void (*test_func)(TestInputVisitorData *data, const void *user_data))
 384 {
 385     g_test_add(testpath, TestInputVisitorData, data, NULL, test_func,
 386                visitor_input_teardown);
 387 }
 388
 389 int main(int argc, char **argv)
 390 {
 391     TestInputVisitorData in_visitor_data;
 392
 393     g_test_init(&argc, &argv, NULL);
 394
 395     input_visitor_test_add("/string-visitor/input/int",
 396                            &in_visitor_data, test_visitor_in_int);
 397     input_visitor_test_add("/string-visitor/input/intList",
 398                            &in_visitor_data, test_visitor_in_intList);
 399     input_visitor_test_add("/string-visitor/input/bool",
 400                            &in_visitor_data, test_visitor_in_bool);
 401     input_visitor_test_add("/string-visitor/input/number",
 402                            &in_visitor_data, test_visitor_in_number);
 403     input_visitor_test_add("/string-visitor/input/string",
 404                             &in_visitor_data, test_visitor_in_string);
 405     input_visitor_test_add("/string-visitor/input/enum",
 406                             &in_visitor_data, test_visitor_in_enum);
 407     input_visitor_test_add("/string-visitor/input/fuzz",
 408                             &in_visitor_data, test_visitor_in_fuzz);
 409
 410     g_test_run();
 411
 412     return 0;
 413 }