tests/test-qmp-event.c

   1 /*
   2  * qapi event unit-tests.
   3  *
   4  * Copyright (c) 2014 Wenchao Xia
   5  *
   6  * Authors:
   7  *  Wenchao Xia   <wenchaoqemu@gmail.com>
   8  *
   9  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
  10  * See the COPYING.LIB file in the top-level directory.
  11  *
  12  */
  13
  14 #include "qemu/osdep.h"
  15
  16 #include "qemu-common.h"
  17 #include "qapi/error.h"
  18 #include "qapi/qmp/qbool.h"
  19 #include "qapi/qmp/qdict.h"
  20 #include "qapi/qmp/qjson.h"
  21 #include "qapi/qmp/qnum.h"
  22 #include "qapi/qmp/qstring.h"
  23 #include "qapi/qmp-event.h"
  24 #include "test-qapi-events.h"
  25 #include "test-qapi-emit-events.h"
  26
  27 typedef struct TestEventData {
  28     QDict *expect;
  29     bool emitted;
  30 } TestEventData;
  31
  32 TestEventData *test_event_data;
  33 static GMutex test_event_lock;
  34
  35 void test_qapi_event_emit(test_QAPIEvent event, QDict *d)
  36 {
  37     QDict *t;
  38     int64_t s, ms;
  39
  40     /* Verify that we have timestamp, then remove it to compare other fields */
  41     t = qdict_get_qdict(d, "timestamp");
  42     g_assert(t);
  43     s = qdict_get_try_int(t, "seconds", -2);
  44     ms = qdict_get_try_int(t, "microseconds", -2);
  45     if (s == -1) {
  46         g_assert(ms == -1);
  47     } else {
  48         g_assert(s >= 0);
  49         g_assert(ms >= 0 && ms <= 999999);
  50     }
  51     g_assert(qdict_size(t) == 2);
  52
  53     qdict_del(d, "timestamp");
  54
  55     g_assert(qobject_is_equal(QOBJECT(d), QOBJECT(test_event_data->expect)));
  56     test_event_data->emitted = true;
  57 }
  58
  59 static void event_prepare(TestEventData *data,
  60                           const void *unused)
  61 {
  62     /* Global variable test_event_data was used to pass the expectation, so
  63        test cases can't be executed at same time. */
  64     g_mutex_lock(&test_event_lock);
  65     test_event_data = data;
  66 }
  67
  68 static void event_teardown(TestEventData *data,
  69                            const void *unused)
  70 {
  71     test_event_data = NULL;
  72     g_mutex_unlock(&test_event_lock);
  73 }
  74
  75 static void event_test_add(const char *testpath,
  76                            void (*test_func)(TestEventData *data,
  77                                              const void *user_data))
  78 {
  79     g_test_add(testpath, TestEventData, NULL, event_prepare, test_func,
  80                event_teardown);
  81 }
  82
  83
  84 /* Test cases */
  85
  86 static void test_event_a(TestEventData *data,
  87                          const void *unused)
  88 {
  89     data->expect = qdict_from_jsonf_nofail("{ 'event': 'EVENT_A' }");
  90     qapi_event_send_event_a();
  91     g_assert(data->emitted);
  92     qobject_unref(data->expect);
  93 }
  94
  95 static void test_event_b(TestEventData *data,
  96                          const void *unused)
  97 {
  98     data->expect = qdict_from_jsonf_nofail("{ 'event': 'EVENT_B' }");
  99     qapi_event_send_event_b();
 100     g_assert(data->emitted);
 101     qobject_unref(data->expect);
 102 }
 103
 104 static void test_event_c(TestEventData *data,
 105                          const void *unused)
 106 {
 107     UserDefOne b = { .integer = 2, .string = (char *)"test1" };
 108
 109     data->expect = qdict_from_jsonf_nofail(
 110         "{ 'event': 'EVENT_C', 'data': {"
 111         " 'a': 1, 'b': { 'integer': 2, 'string': 'test1' }, 'c': 'test2' } }");
 112     qapi_event_send_event_c(true, 1, true, &b, "test2");
 113     g_assert(data->emitted);
 114     qobject_unref(data->expect);
 115 }
 116
 117 /* Complex type */
 118 static void test_event_d(TestEventData *data,
 119                          const void *unused)
 120 {
 121     UserDefOne struct1 = {
 122         .integer = 2, .string = (char *)"test1",
 123         .has_enum1 = true, .enum1 = ENUM_ONE_VALUE1,
 124     };
 125     EventStructOne a = {
 126         .struct1 = &struct1,
 127         .string = (char *)"test2",
 128         .has_enum2 = true,
 129         .enum2 = ENUM_ONE_VALUE2,
 130     };
 131
 132     data->expect = qdict_from_jsonf_nofail(
 133         "{ 'event': 'EVENT_D', 'data': {"
 134         " 'a': {"
 135         "  'struct1': { 'integer': 2, 'string': 'test1', 'enum1': 'value1' },"
 136         "  'string': 'test2', 'enum2': 'value2' },"
 137         " 'b': 'test3', 'enum3': 'value3' } }");
 138     qapi_event_send_event_d(&a, "test3", false, NULL, true, ENUM_ONE_VALUE3);
 139     g_assert(data->emitted);
 140     qobject_unref(data->expect);
 141 }
 142
 143 int main(int argc, char **argv)
 144 {
 145     g_test_init(&argc, &argv, NULL);
 146
 147     event_test_add("/event/event_a", test_event_a);
 148     event_test_add("/event/event_b", test_event_b);
 149     event_test_add("/event/event_c", test_event_c);
 150     event_test_add("/event/event_d", test_event_d);
 151     g_test_run();
 152
 153     return 0;
 154 }