← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to tests/test-qmp-input-visitor.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-qmp-input-visitor.c
61
61
    return v;
62
62
}
63
63
 
 
64
/* similar to visitor_input_test_init(), but does not expect a string
 
65
 * literal/format json_string argument and so can be used for
 
66
 * programatically generated strings (and we can't pass in programatically
 
67
 * generated strings via %s format parameters since qobject_from_jsonv()
 
68
 * will wrap those in double-quotes and treat the entire object as a
 
69
 * string)
 
70
 */
 
71
static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
 
72
                                            const char *json_string)
 
73
{
 
74
    Visitor *v;
 
75
 
 
76
    data->obj = qobject_from_json(json_string);
 
77
 
 
78
    g_assert(data->obj != NULL);
 
79
 
 
80
    data->qiv = qmp_input_visitor_new(data->obj);
 
81
    g_assert(data->qiv != NULL);
 
82
 
 
83
    v = qmp_input_get_visitor(data->qiv);
 
84
    g_assert(v != NULL);
 
85
 
 
86
    return v;
 
87
}
 
88
 
64
89
static void test_visitor_in_int(TestInputVisitorData *data,
65
90
                                const void *unused)
66
91
{
75
100
    g_assert_cmpint(res, ==, value);
76
101
}
77
102
 
 
103
static void test_visitor_in_int_overflow(TestInputVisitorData *data,
 
104
                                         const void *unused)
 
105
{
 
106
    int64_t res = 0;
 
107
    Error *errp = NULL;
 
108
    Visitor *v;
 
109
 
 
110
    /* this will overflow a Qint/int64, so should be deserialized into
 
111
     * a QFloat/double field instead, leading to an error if we pass it
 
112
     * to visit_type_int. confirm this.
 
113
     */
 
114
    v = visitor_input_test_init(data, "%f", DBL_MAX);
 
115
 
 
116
    visit_type_int(v, &res, NULL, &errp);
 
117
    g_assert(error_is_set(&errp));
 
118
    error_free(errp);
 
119
}
 
120
 
78
121
static void test_visitor_in_bool(TestInputVisitorData *data,
79
122
                                 const void *unused)
80
123
{
259
302
    qapi_free_UserDefUnion(tmp);
260
303
}
261
304
 
 
305
static void test_native_list_integer_helper(TestInputVisitorData *data,
 
306
                                            const void *unused,
 
307
                                            UserDefNativeListUnionKind kind)
 
308
{
 
309
    UserDefNativeListUnion *cvalue = NULL;
 
310
    Error *err = NULL;
 
311
    Visitor *v;
 
312
    GString *gstr_list = g_string_new("");
 
313
    GString *gstr_union = g_string_new("");
 
314
    int i;
 
315
 
 
316
    for (i = 0; i < 32; i++) {
 
317
        g_string_append_printf(gstr_list, "%d", i);
 
318
        if (i != 31) {
 
319
            g_string_append(gstr_list, ", ");
 
320
        }
 
321
    }
 
322
    g_string_append_printf(gstr_union,  "{ 'type': '%s', 'data': [ %s ] }",
 
323
                           UserDefNativeListUnionKind_lookup[kind],
 
324
                           gstr_list->str);
 
325
    v = visitor_input_test_init_raw(data,  gstr_union->str);
 
326
 
 
327
    visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err);
 
328
    g_assert(err == NULL);
 
329
    g_assert(cvalue != NULL);
 
330
    g_assert_cmpint(cvalue->kind, ==, kind);
 
331
 
 
332
    switch (kind) {
 
333
    case USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER: {
 
334
        intList *elem = NULL;
 
335
        for (i = 0, elem = cvalue->integer; elem; elem = elem->next, i++) {
 
336
            g_assert_cmpint(elem->value, ==, i);
 
337
        }
 
338
        break;
 
339
    }
 
340
    case USER_DEF_NATIVE_LIST_UNION_KIND_S8: {
 
341
        int8List *elem = NULL;
 
342
        for (i = 0, elem = cvalue->s8; elem; elem = elem->next, i++) {
 
343
            g_assert_cmpint(elem->value, ==, i);
 
344
        }
 
345
        break;
 
346
    }
 
347
    case USER_DEF_NATIVE_LIST_UNION_KIND_S16: {
 
348
        int16List *elem = NULL;
 
349
        for (i = 0, elem = cvalue->s16; elem; elem = elem->next, i++) {
 
350
            g_assert_cmpint(elem->value, ==, i);
 
351
        }
 
352
        break;
 
353
    }
 
354
    case USER_DEF_NATIVE_LIST_UNION_KIND_S32: {
 
355
        int32List *elem = NULL;
 
356
        for (i = 0, elem = cvalue->s32; elem; elem = elem->next, i++) {
 
357
            g_assert_cmpint(elem->value, ==, i);
 
358
        }
 
359
        break;
 
360
    }
 
361
    case USER_DEF_NATIVE_LIST_UNION_KIND_S64: {
 
362
        int64List *elem = NULL;
 
363
        for (i = 0, elem = cvalue->s64; elem; elem = elem->next, i++) {
 
364
            g_assert_cmpint(elem->value, ==, i);
 
365
        }
 
366
        break;
 
367
    }
 
368
    case USER_DEF_NATIVE_LIST_UNION_KIND_U8: {
 
369
        uint8List *elem = NULL;
 
370
        for (i = 0, elem = cvalue->u8; elem; elem = elem->next, i++) {
 
371
            g_assert_cmpint(elem->value, ==, i);
 
372
        }
 
373
        break;
 
374
    }
 
375
    case USER_DEF_NATIVE_LIST_UNION_KIND_U16: {
 
376
        uint16List *elem = NULL;
 
377
        for (i = 0, elem = cvalue->u16; elem; elem = elem->next, i++) {
 
378
            g_assert_cmpint(elem->value, ==, i);
 
379
        }
 
380
        break;
 
381
    }
 
382
    case USER_DEF_NATIVE_LIST_UNION_KIND_U32: {
 
383
        uint32List *elem = NULL;
 
384
        for (i = 0, elem = cvalue->u32; elem; elem = elem->next, i++) {
 
385
            g_assert_cmpint(elem->value, ==, i);
 
386
        }
 
387
        break;
 
388
    }
 
389
    case USER_DEF_NATIVE_LIST_UNION_KIND_U64: {
 
390
        uint64List *elem = NULL;
 
391
        for (i = 0, elem = cvalue->u64; elem; elem = elem->next, i++) {
 
392
            g_assert_cmpint(elem->value, ==, i);
 
393
        }
 
394
        break;
 
395
    }
 
396
    default:
 
397
        g_assert_not_reached();
 
398
    }
 
399
 
 
400
    g_string_free(gstr_union, true);
 
401
    g_string_free(gstr_list, true);
 
402
    qapi_free_UserDefNativeListUnion(cvalue);
 
403
}
 
404
 
 
405
static void test_visitor_in_native_list_int(TestInputVisitorData *data,
 
406
                                            const void *unused)
 
407
{
 
408
    test_native_list_integer_helper(data, unused,
 
409
                                    USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER);
 
410
}
 
411
 
 
412
static void test_visitor_in_native_list_int8(TestInputVisitorData *data,
 
413
                                             const void *unused)
 
414
{
 
415
    test_native_list_integer_helper(data, unused,
 
416
                                    USER_DEF_NATIVE_LIST_UNION_KIND_S8);
 
417
}
 
418
 
 
419
static void test_visitor_in_native_list_int16(TestInputVisitorData *data,
 
420
                                              const void *unused)
 
421
{
 
422
    test_native_list_integer_helper(data, unused,
 
423
                                    USER_DEF_NATIVE_LIST_UNION_KIND_S16);
 
424
}
 
425
 
 
426
static void test_visitor_in_native_list_int32(TestInputVisitorData *data,
 
427
                                              const void *unused)
 
428
{
 
429
    test_native_list_integer_helper(data, unused,
 
430
                                    USER_DEF_NATIVE_LIST_UNION_KIND_S32);
 
431
}
 
432
 
 
433
static void test_visitor_in_native_list_int64(TestInputVisitorData *data,
 
434
                                              const void *unused)
 
435
{
 
436
    test_native_list_integer_helper(data, unused,
 
437
                                    USER_DEF_NATIVE_LIST_UNION_KIND_S64);
 
438
}
 
439
 
 
440
static void test_visitor_in_native_list_uint8(TestInputVisitorData *data,
 
441
                                             const void *unused)
 
442
{
 
443
    test_native_list_integer_helper(data, unused,
 
444
                                    USER_DEF_NATIVE_LIST_UNION_KIND_U8);
 
445
}
 
446
 
 
447
static void test_visitor_in_native_list_uint16(TestInputVisitorData *data,
 
448
                                               const void *unused)
 
449
{
 
450
    test_native_list_integer_helper(data, unused,
 
451
                                    USER_DEF_NATIVE_LIST_UNION_KIND_U16);
 
452
}
 
453
 
 
454
static void test_visitor_in_native_list_uint32(TestInputVisitorData *data,
 
455
                                               const void *unused)
 
456
{
 
457
    test_native_list_integer_helper(data, unused,
 
458
                                    USER_DEF_NATIVE_LIST_UNION_KIND_U32);
 
459
}
 
460
 
 
461
static void test_visitor_in_native_list_uint64(TestInputVisitorData *data,
 
462
                                               const void *unused)
 
463
{
 
464
    test_native_list_integer_helper(data, unused,
 
465
                                    USER_DEF_NATIVE_LIST_UNION_KIND_U64);
 
466
}
 
467
 
 
468
static void test_visitor_in_native_list_bool(TestInputVisitorData *data,
 
469
                                            const void *unused)
 
470
{
 
471
    UserDefNativeListUnion *cvalue = NULL;
 
472
    boolList *elem = NULL;
 
473
    Error *err = NULL;
 
474
    Visitor *v;
 
475
    GString *gstr_list = g_string_new("");
 
476
    GString *gstr_union = g_string_new("");
 
477
    int i;
 
478
 
 
479
    for (i = 0; i < 32; i++) {
 
480
        g_string_append_printf(gstr_list, "%s",
 
481
                               (i % 3 == 0) ? "true" : "false");
 
482
        if (i != 31) {
 
483
            g_string_append(gstr_list, ", ");
 
484
        }
 
485
    }
 
486
    g_string_append_printf(gstr_union,  "{ 'type': 'boolean', 'data': [ %s ] }",
 
487
                           gstr_list->str);
 
488
    v = visitor_input_test_init_raw(data,  gstr_union->str);
 
489
 
 
490
    visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err);
 
491
    g_assert(err == NULL);
 
492
    g_assert(cvalue != NULL);
 
493
    g_assert_cmpint(cvalue->kind, ==, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN);
 
494
 
 
495
    for (i = 0, elem = cvalue->boolean; elem; elem = elem->next, i++) {
 
496
        g_assert_cmpint(elem->value, ==, (i % 3 == 0) ? 1 : 0);
 
497
    }
 
498
 
 
499
    g_string_free(gstr_union, true);
 
500
    g_string_free(gstr_list, true);
 
501
    qapi_free_UserDefNativeListUnion(cvalue);
 
502
}
 
503
 
 
504
static void test_visitor_in_native_list_string(TestInputVisitorData *data,
 
505
                                               const void *unused)
 
506
{
 
507
    UserDefNativeListUnion *cvalue = NULL;
 
508
    strList *elem = NULL;
 
509
    Error *err = NULL;
 
510
    Visitor *v;
 
511
    GString *gstr_list = g_string_new("");
 
512
    GString *gstr_union = g_string_new("");
 
513
    int i;
 
514
 
 
515
    for (i = 0; i < 32; i++) {
 
516
        g_string_append_printf(gstr_list, "'%d'", i);
 
517
        if (i != 31) {
 
518
            g_string_append(gstr_list, ", ");
 
519
        }
 
520
    }
 
521
    g_string_append_printf(gstr_union,  "{ 'type': 'string', 'data': [ %s ] }",
 
522
                           gstr_list->str);
 
523
    v = visitor_input_test_init_raw(data,  gstr_union->str);
 
524
 
 
525
    visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err);
 
526
    g_assert(err == NULL);
 
527
    g_assert(cvalue != NULL);
 
528
    g_assert_cmpint(cvalue->kind, ==, USER_DEF_NATIVE_LIST_UNION_KIND_STRING);
 
529
 
 
530
    for (i = 0, elem = cvalue->string; elem; elem = elem->next, i++) {
 
531
        gchar str[8];
 
532
        sprintf(str, "%d", i);
 
533
        g_assert_cmpstr(elem->value, ==, str);
 
534
    }
 
535
 
 
536
    g_string_free(gstr_union, true);
 
537
    g_string_free(gstr_list, true);
 
538
    qapi_free_UserDefNativeListUnion(cvalue);
 
539
}
 
540
 
 
541
#define DOUBLE_STR_MAX 16
 
542
 
 
543
static void test_visitor_in_native_list_number(TestInputVisitorData *data,
 
544
                                               const void *unused)
 
545
{
 
546
    UserDefNativeListUnion *cvalue = NULL;
 
547
    numberList *elem = NULL;
 
548
    Error *err = NULL;
 
549
    Visitor *v;
 
550
    GString *gstr_list = g_string_new("");
 
551
    GString *gstr_union = g_string_new("");
 
552
    int i;
 
553
 
 
554
    for (i = 0; i < 32; i++) {
 
555
        g_string_append_printf(gstr_list, "%f", (double)i / 3);
 
556
        if (i != 31) {
 
557
            g_string_append(gstr_list, ", ");
 
558
        }
 
559
    }
 
560
    g_string_append_printf(gstr_union,  "{ 'type': 'number', 'data': [ %s ] }",
 
561
                           gstr_list->str);
 
562
    v = visitor_input_test_init_raw(data,  gstr_union->str);
 
563
 
 
564
    visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err);
 
565
    g_assert(err == NULL);
 
566
    g_assert(cvalue != NULL);
 
567
    g_assert_cmpint(cvalue->kind, ==, USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER);
 
568
 
 
569
    for (i = 0, elem = cvalue->number; elem; elem = elem->next, i++) {
 
570
        GString *double_expected = g_string_new("");
 
571
        GString *double_actual = g_string_new("");
 
572
 
 
573
        g_string_printf(double_expected, "%.6f", (double)i / 3);
 
574
        g_string_printf(double_actual, "%.6f", elem->value);
 
575
        g_assert_cmpstr(double_expected->str, ==, double_actual->str);
 
576
 
 
577
        g_string_free(double_expected, true);
 
578
        g_string_free(double_actual, true);
 
579
    }
 
580
 
 
581
    g_string_free(gstr_union, true);
 
582
    g_string_free(gstr_list, true);
 
583
    qapi_free_UserDefNativeListUnion(cvalue);
 
584
}
 
585
 
262
586
static void input_visitor_test_add(const char *testpath,
263
587
                                   TestInputVisitorData *data,
264
588
                                   void (*test_func)(TestInputVisitorData *data, const void *user_data))
292
616
 
293
617
    input_visitor_test_add("/visitor/input/int",
294
618
                           &in_visitor_data, test_visitor_in_int);
 
619
    input_visitor_test_add("/visitor/input/int_overflow",
 
620
                           &in_visitor_data, test_visitor_in_int_overflow);
295
621
    input_visitor_test_add("/visitor/input/bool",
296
622
                           &in_visitor_data, test_visitor_in_bool);
297
623
    input_visitor_test_add("/visitor/input/number",
310
636
                            &in_visitor_data, test_visitor_in_union);
311
637
    input_visitor_test_add("/visitor/input/errors",
312
638
                            &in_visitor_data, test_visitor_in_errors);
 
639
    input_visitor_test_add("/visitor/input/native_list/int",
 
640
                            &in_visitor_data,
 
641
                            test_visitor_in_native_list_int);
 
642
    input_visitor_test_add("/visitor/input/native_list/int8",
 
643
                            &in_visitor_data,
 
644
                            test_visitor_in_native_list_int8);
 
645
    input_visitor_test_add("/visitor/input/native_list/int16",
 
646
                            &in_visitor_data,
 
647
                            test_visitor_in_native_list_int16);
 
648
    input_visitor_test_add("/visitor/input/native_list/int32",
 
649
                            &in_visitor_data,
 
650
                            test_visitor_in_native_list_int32);
 
651
    input_visitor_test_add("/visitor/input/native_list/int64",
 
652
                            &in_visitor_data,
 
653
                            test_visitor_in_native_list_int64);
 
654
    input_visitor_test_add("/visitor/input/native_list/uint8",
 
655
                            &in_visitor_data,
 
656
                            test_visitor_in_native_list_uint8);
 
657
    input_visitor_test_add("/visitor/input/native_list/uint16",
 
658
                            &in_visitor_data,
 
659
                            test_visitor_in_native_list_uint16);
 
660
    input_visitor_test_add("/visitor/input/native_list/uint32",
 
661
                            &in_visitor_data,
 
662
                            test_visitor_in_native_list_uint32);
 
663
    input_visitor_test_add("/visitor/input/native_list/uint64",
 
664
                            &in_visitor_data, test_visitor_in_native_list_uint64);
 
665
    input_visitor_test_add("/visitor/input/native_list/bool",
 
666
                            &in_visitor_data, test_visitor_in_native_list_bool);
 
667
    input_visitor_test_add("/visitor/input/native_list/str",
 
668
                            &in_visitor_data, test_visitor_in_native_list_string);
 
669
    input_visitor_test_add("/visitor/input/native_list/number",
 
670
                            &in_visitor_data, test_visitor_in_native_list_number);
313
671
 
314
672
    g_test_run();
315
673