diff mbox

[RFC,3/3] tests: add test cases for qapi event support

Message ID 1384307094-5836-5-git-send-email-xiawenc@linux.vnet.ibm.com
State New
Headers show

Commit Message

Wayne Xia Nov. 13, 2013, 1:44 a.m. UTC 
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
---
 tests/Makefile                          |   14 ++-
 tests/qapi-schema/qapi-schema-test.json |   12 ++
 tests/qapi-schema/qapi-schema-test.out  |   10 +-
 tests/test-qmp-event.c                  |  250 +++++++++++++++++++++++++++++++
 4 files changed, 281 insertions(+), 5 deletions(-)
 create mode 100644 tests/test-qmp-event.c

Comments

Eric Blake Dec. 13, 2013, 1:36 p.m. UTC | #1 
On 11/12/2013 06:44 PM, Wenchao Xia wrote:
> Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
> ---

> +++ b/tests/qapi-schema/qapi-schema-test.json
> @@ -93,3 +93,15 @@
>      '*u16' : [ 'uint16' ],
>      '*i64x':   'int'     ,
>      '*u64x':   'uint64'  } }
> +
> +# testing event
> +{ 'type': 'EventStructOne',
> +  'data': { 'struct1': 'UserDefOne', 'string': 'str', '*enum2': 'EnumOne' } }
> +
> +{ 'event': 'EVENT_A' }
> +{ 'event': 'EVENT_B',
> +  'data': { } }

Do we really have events with no associated information (the mere name
of the event carrying the full data?)

> +{ 'event': 'EVENT_C',
> +  'data': { '*a': 'int', '*b': 'UserDefOne', 'c': 'str' } }
> +{ 'event': 'EVENT_D',
> +  'data': { 'a' : 'EventStructOne', 'b' : 'str', '*c': 'str', '*enum3': 'EnumOne' } }

Looks like reasonable support for encoding existing events.

> + OrderedDict([('event', 'EVENT_A')]),
> + OrderedDict([('event', 'EVENT_B'), ('data', OrderedDict())]),

Shouldn't the omission of 'data' be the same as 'data':{}?

> +++ b/tests/test-qmp-event.c
> @@ -0,0 +1,250 @@
> +/*
> + * QMP Input Visitor unit-tests.
> + *
> + * Copyright (C) 2011 Red Hat Inc.

Unusual choice of copyright year and ownership.
Wayne Xia Dec. 16, 2013, 2:55 a.m. UTC | #2 
于 2013/12/13 21:36, Eric Blake 写道:
> On 11/12/2013 06:44 PM, Wenchao Xia wrote:
>> Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
>> ---
>
>> +++ b/tests/qapi-schema/qapi-schema-test.json
>> @@ -93,3 +93,15 @@
>>       '*u16' : [ 'uint16' ],
>>       '*i64x':   'int'     ,
>>       '*u64x':   'uint64'  } }
>> +
>> +# testing event
>> +{ 'type': 'EventStructOne',
>> +  'data': { 'struct1': 'UserDefOne', 'string': 'str', '*enum2': 'EnumOne' } }
>> +
>> +{ 'event': 'EVENT_A' }
>> +{ 'event': 'EVENT_B',
>> +  'data': { } }
>
> Do we really have events with no associated information (the mere name
> of the event carrying the full data?)
>

   I guess EVENT_SHUDDOWN is one example, that have no associated info,
except time stamp.


>> +{ 'event': 'EVENT_C',
>> +  'data': { '*a': 'int', '*b': 'UserDefOne', 'c': 'str' } }
>> +{ 'event': 'EVENT_D',
>> +  'data': { 'a' : 'EventStructOne', 'b' : 'str', '*c': 'str', '*enum3': 'EnumOne' } }
>
> Looks like reasonable support for encoding existing events.
>
>> + OrderedDict([('event', 'EVENT_A')]),
>> + OrderedDict([('event', 'EVENT_B'), ('data', OrderedDict())]),
>
> Shouldn't the omission of 'data' be the same as 'data':{}?
>

   I didn't touch the "{ }" parsing part, maybe an existing parsing
style, will check it.

>> +++ b/tests/test-qmp-event.c
>> @@ -0,0 +1,250 @@
>> +/*
>> + * QMP Input Visitor unit-tests.
>> + *
>> + * Copyright (C) 2011 Red Hat Inc.
>
> Unusual choice of copyright year and ownership.
>
  yep, will fix.
Wayne Xia Dec. 16, 2013, 3:12 a.m. UTC | #3 
于 2013/12/16 10:55, Wenchao Xia 写道:
> 于 2013/12/13 21:36, Eric Blake 写道:
>> On 11/12/2013 06:44 PM, Wenchao Xia wrote:
>>> Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
>>> ---
>>
>>> +++ b/tests/qapi-schema/qapi-schema-test.json
>>> @@ -93,3 +93,15 @@
>>>       '*u16' : [ 'uint16' ],
>>>       '*i64x':   'int'     ,
>>>       '*u64x':   'uint64'  } }
>>> +
>>> +# testing event
>>> +{ 'type': 'EventStructOne',
>>> +  'data': { 'struct1': 'UserDefOne', 'string': 'str', '*enum2':
>>> 'EnumOne' } }
>>> +
>>> +{ 'event': 'EVENT_A' }
>>> +{ 'event': 'EVENT_B',
>>> +  'data': { } }
>>
>> Do we really have events with no associated information (the mere name
>> of the event carrying the full data?)
>>
>
>    I guess EVENT_SHUDDOWN is one example, that have no associated info,
> except time stamp.
>

   I think you questioned why EVENT_B is needed? I added it before to
allow that, both define can work.

>
>>> +{ 'event': 'EVENT_C',
>>> +  'data': { '*a': 'int', '*b': 'UserDefOne', 'c': 'str' } }
>>> +{ 'event': 'EVENT_D',
>>> +  'data': { 'a' : 'EventStructOne', 'b' : 'str', '*c': 'str',
>>> '*enum3': 'EnumOne' } }
>>
>> Looks like reasonable support for encoding existing events.
>>
>>> + OrderedDict([('event', 'EVENT_A')]),
>>> + OrderedDict([('event', 'EVENT_B'), ('data', OrderedDict())]),
>>
>> Shouldn't the omission of 'data' be the same as 'data':{}?
>>
>
>    I didn't touch the "{ }" parsing part, maybe an existing parsing
> style, will check it.
>
>>> +++ b/tests/test-qmp-event.c
>>> @@ -0,0 +1,250 @@
>>> +/*
>>> + * QMP Input Visitor unit-tests.
>>> + *
>>> + * Copyright (C) 2011 Red Hat Inc.
>>
>> Unusual choice of copyright year and ownership.
>>
>   yep, will fix.
>
>
Wayne Xia Jan. 2, 2014, 2:30 a.m. UTC | #4 
>>>
>>>> + OrderedDict([('event', 'EVENT_A')]),
>>>> + OrderedDict([('event', 'EVENT_B'), ('data', OrderedDict())]),
>>>
>>> Shouldn't the omission of 'data' be the same as 'data':{}?
>>>
>>
>>    I didn't touch the "{ }" parsing part, maybe an existing parsing
>> style, will check it.
>>

   Checked the code, it is generated by tests/qapi-schema/test-qapi.py:

try:
     exprs = parse_schema(sys.stdin)
except SystemExit:
     raise
except:
     print >>sys.stderr, "Crashed:", sys.exc_info()[0]
     exit(1)

pprint(exprs)

   I think it worked as expectation for exprs.

>>>> +++ b/tests/test-qmp-event.c
>>>> @@ -0,0 +1,250 @@
>>>> +/*
>>>> + * QMP Input Visitor unit-tests.
>>>> + *
>>>> + * Copyright (C) 2011 Red Hat Inc.
>>>
>>> Unusual choice of copyright year and ownership.
>>>
>>   yep, will fix.
>>
>>
>
>
diff mbox

Patch

diff --git a/tests/Makefile b/tests/Makefile
index f414f2c..3c22f0a 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -23,6 +23,8 @@  check-unit-y += tests/test-string-input-visitor$(EXESUF)
 gcov-files-test-string-input-visitor-y = qapi/string-input-visitor.c
 check-unit-y += tests/test-string-output-visitor$(EXESUF)
 gcov-files-test-string-output-visitor-y = qapi/string-output-visitor.c
+check-unit-y += tests/test-qmp-event$(EXESUF)
+gcov-files-test-qmp-event-y += qapi/qmp-event.c
 check-unit-y += tests/test-opts-visitor$(EXESUF)
 gcov-files-test-opts-visitor-y = qapi/opts-visitor.c
 check-unit-y += tests/test-coroutine$(EXESUF)
@@ -120,7 +122,8 @@  check-qapi-schema-y := $(addprefix tests/qapi-schema/, \
         trailing-comma-list.json trailing-comma-object.json \
         unclosed-list.json unclosed-object.json unclosed-string.json)
 
-GENERATED_HEADERS += tests/test-qapi-types.h tests/test-qapi-visit.h tests/test-qmp-commands.h
+GENERATED_HEADERS += tests/test-qapi-types.h tests/test-qapi-visit.h \
+                     tests/test-qapi-event.h tests/test-qmp-commands.h
 
 test-obj-y = tests/check-qint.o tests/check-qstring.o tests/check-qdict.o \
 	tests/check-qlist.o tests/check-qfloat.o tests/check-qjson.o \
@@ -129,9 +132,10 @@  test-obj-y = tests/check-qint.o tests/check-qstring.o tests/check-qdict.o \
 	tests/test-qmp-input-visitor.o tests/test-qmp-input-strict.o \
 	tests/test-qmp-commands.o tests/test-visitor-serialization.o \
 	tests/test-x86-cpuid.o tests/test-mul64.o tests/test-int128.o \
-	tests/test-opts-visitor.o
+	tests/test-opts-visitor.o tests/test-qmp-event.o
 
-test-qapi-obj-y = tests/test-qapi-visit.o tests/test-qapi-types.o
+test-qapi-obj-y = tests/test-qapi-visit.o tests/test-qapi-types.o \
+                  tests/test-qapi-event.o
 
 $(test-obj-y): QEMU_INCLUDES += -Itests
 QEMU_CFLAGS += -I$(SRC_PATH)/tests
@@ -167,12 +171,16 @@  $(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-typ
 tests/test-qapi-visit.c tests/test-qapi-visit.h :\
 $(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-visit.py
 	$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-visit.py $(gen-out-type) -o tests -p "test-" < $<, "  GEN   $@")
+tests/test-qapi-event.c tests/test-qapi-event.h :\
+$(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-event.py
+	$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-event.py $(gen-out-type) -o tests -p "test-" < $<, "  GEN   $@")
 tests/test-qmp-commands.h tests/test-qmp-marshal.c :\
 $(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-commands.py
 	$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-commands.py $(gen-out-type) -o tests -p "test-" < $<, "  GEN   $@")
 
 tests/test-string-output-visitor$(EXESUF): tests/test-string-output-visitor.o $(test-qapi-obj-y) libqemuutil.a libqemustub.a
 tests/test-string-input-visitor$(EXESUF): tests/test-string-input-visitor.o $(test-qapi-obj-y) libqemuutil.a libqemustub.a
+tests/test-qmp-event$(EXESUF): tests/test-qmp-event.o $(test-qapi-obj-y) libqemuutil.a libqemustub.a
 tests/test-qmp-output-visitor$(EXESUF): tests/test-qmp-output-visitor.o $(test-qapi-obj-y) libqemuutil.a libqemustub.a
 tests/test-qmp-input-visitor$(EXESUF): tests/test-qmp-input-visitor.o $(test-qapi-obj-y) libqemuutil.a libqemustub.a
 tests/test-qmp-input-strict$(EXESUF): tests/test-qmp-input-strict.o $(test-qapi-obj-y) libqemuutil.a libqemustub.a
diff --git a/tests/qapi-schema/qapi-schema-test.json b/tests/qapi-schema/qapi-schema-test.json
index 1e23d21..3fd7902 100644
--- a/tests/qapi-schema/qapi-schema-test.json
+++ b/tests/qapi-schema/qapi-schema-test.json
@@ -93,3 +93,15 @@ 
     '*u16' : [ 'uint16' ],
     '*i64x':   'int'     ,
     '*u64x':   'uint64'  } }
+
+# testing event
+{ 'type': 'EventStructOne',
+  'data': { 'struct1': 'UserDefOne', 'string': 'str', '*enum2': 'EnumOne' } }
+
+{ 'event': 'EVENT_A' }
+{ 'event': 'EVENT_B',
+  'data': { } }
+{ 'event': 'EVENT_C',
+  'data': { '*a': 'int', '*b': 'UserDefOne', 'c': 'str' } }
+{ 'event': 'EVENT_D',
+  'data': { 'a' : 'EventStructOne', 'b' : 'str', '*c': 'str', '*enum3': 'EnumOne' } }
diff --git a/tests/qapi-schema/qapi-schema-test.out b/tests/qapi-schema/qapi-schema-test.out
index ce174a2..22430ba 100644
--- a/tests/qapi-schema/qapi-schema-test.out
+++ b/tests/qapi-schema/qapi-schema-test.out
@@ -16,7 +16,12 @@ 
  OrderedDict([('command', 'user_def_cmd'), ('data', OrderedDict())]),
  OrderedDict([('command', 'user_def_cmd1'), ('data', OrderedDict([('ud1a', 'UserDefOne')]))]),
  OrderedDict([('command', 'user_def_cmd2'), ('data', OrderedDict([('ud1a', 'UserDefOne'), ('ud1b', 'UserDefOne')])), ('returns', 'UserDefTwo')]),
- OrderedDict([('type', 'UserDefOptions'), ('data', OrderedDict([('*i64', ['int']), ('*u64', ['uint64']), ('*u16', ['uint16']), ('*i64x', 'int'), ('*u64x', 'uint64')]))])]
+ OrderedDict([('type', 'UserDefOptions'), ('data', OrderedDict([('*i64', ['int']), ('*u64', ['uint64']), ('*u16', ['uint16']), ('*i64x', 'int'), ('*u64x', 'uint64')]))]),
+ OrderedDict([('type', 'EventStructOne'), ('data', OrderedDict([('struct1', 'UserDefOne'), ('string', 'str'), ('*enum2', 'EnumOne')]))]),
+ OrderedDict([('event', 'EVENT_A')]),
+ OrderedDict([('event', 'EVENT_B'), ('data', OrderedDict())]),
+ OrderedDict([('event', 'EVENT_C'), ('data', OrderedDict([('*a', 'int'), ('*b', 'UserDefOne'), ('c', 'str')]))]),
+ OrderedDict([('event', 'EVENT_D'), ('data', OrderedDict([('a', 'EventStructOne'), ('b', 'str'), ('*c', 'str'), ('*enum3', 'EnumOne')]))])]
 [{'enum_name': 'EnumOne', 'enum_values': ['value1', 'value2', 'value3']},
  {'enum_name': 'UserDefUnionKind', 'enum_values': None},
  {'enum_name': 'UserDefBaseUnionKind', 'enum_values': None},
@@ -31,4 +36,5 @@ 
  OrderedDict([('type', 'UserDefBase0'), ('data', OrderedDict([('base-string0', 'str'), ('base-enum0', 'EnumOne')]))]),
  OrderedDict([('type', 'UserDefA'), ('data', OrderedDict([('boolean', 'bool')]))]),
  OrderedDict([('type', 'UserDefB'), ('data', OrderedDict([('integer', 'int')]))]),
- OrderedDict([('type', 'UserDefOptions'), ('data', OrderedDict([('*i64', ['int']), ('*u64', ['uint64']), ('*u16', ['uint16']), ('*i64x', 'int'), ('*u64x', 'uint64')]))])]
+ OrderedDict([('type', 'UserDefOptions'), ('data', OrderedDict([('*i64', ['int']), ('*u64', ['uint64']), ('*u16', ['uint16']), ('*i64x', 'int'), ('*u64x', 'uint64')]))]),
+ OrderedDict([('type', 'EventStructOne'), ('data', OrderedDict([('struct1', 'UserDefOne'), ('string', 'str'), ('*enum2', 'EnumOne')]))])]
diff --git a/tests/test-qmp-event.c b/tests/test-qmp-event.c
new file mode 100644
index 0000000..3b2c43e
--- /dev/null
+++ b/tests/test-qmp-event.c
@@ -0,0 +1,250 @@ 
+/*
+ * QMP Input Visitor unit-tests.
+ *
+ * Copyright (C) 2011 Red Hat Inc.
+ *
+ * Authors:
+ *  Luiz Capitulino <lcapitulino@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include <glib.h>
+#include <stdarg.h>
+
+#include "qemu-common.h"
+#include "test-qapi-types.h"
+#include "test-qapi-visit.h"
+#include "test-qapi-event.h"
+#include "qapi/qmp/types.h"
+#include "qapi/qmp/qobject.h"
+
+typedef struct TestEventData {
+    QDict *expect;
+} TestEventData;
+
+typedef struct QDictCmpData {
+    QDict *expect;
+    bool result;
+} QDictCmpData;
+
+TestEventData *test_event_data;
+static GStaticMutex test_event_lock = G_STATIC_MUTEX_INIT;
+
+/* Only compares bool, int, string */
+static
+void qdict_cmp_do_simple(const char *key, QObject *obj1, void *opaque)
+
+{
+    QObject *obj2;
+    QDictCmpData d_new, *d = opaque;
+
+    if (!d->result) {
+        return;
+    }
+
+    obj2 = qdict_get(d->expect, key);
+    if (!obj2) {
+        d->result = false;
+        return;
+    }
+
+    if (qobject_type(obj1) != qobject_type(obj2)) {
+        d->result = false;
+        return;
+    }
+
+    switch (qobject_type(obj1)) {
+    case QTYPE_QBOOL:
+        d->result = (qbool_get_int(qobject_to_qbool(obj1)) ==
+                     qbool_get_int(qobject_to_qbool(obj2)));
+        return;
+    case QTYPE_QINT:
+        d->result = (qint_get_int(qobject_to_qint(obj1)) ==
+                     qint_get_int(qobject_to_qint(obj2)));
+        return;
+    case QTYPE_QSTRING:
+        if (!g_strcmp0(qstring_get_str(qobject_to_qstring(obj1)),
+                       qstring_get_str(qobject_to_qstring(obj2)))) {
+            d->result = true;
+        } else {
+            d->result = false;
+        }
+        return;
+    case QTYPE_QDICT:
+        d_new.expect = qobject_to_qdict(obj2);
+        d_new.result = true;
+        qdict_iter(qobject_to_qdict(obj1), qdict_cmp_do_simple, &d_new);
+        d->result = d_new.result;
+        return;
+    default:
+        abort();
+    }
+}
+
+static bool qdict_cmp_simple(QDict *a, QDict *b)
+{
+    QDictCmpData d;
+
+    d.expect = b;
+    d.result = true;
+    qdict_iter(a, qdict_cmp_do_simple, &d);
+    return d.result;
+}
+
+static void event_prepare(TestEventData *data,
+                          const void *unused)
+{
+    /* Global variable test_event_data was used to pass the expectation, so
+       test cases can't be executed at same time. */
+    g_static_mutex_lock(&test_event_lock);
+
+    data->expect = qdict_new();
+    test_event_data = data;
+}
+
+static void event_teardown(TestEventData *data,
+                           const void *unused)
+{
+    QDECREF(data->expect);
+    test_event_data = NULL;
+
+    g_static_mutex_unlock(&test_event_lock);
+}
+
+static void test_event_a(TestEventData *data,
+                         const void *unused)
+{
+    QDict *d;
+    d = data->expect;
+    qdict_put(d, "event", qstring_from_str("EVENT_A"));
+    qapi_event_gen_EVENT_A(NULL);
+}
+
+static void test_event_b(TestEventData *data,
+                         const void *unused)
+{
+    QDict *d;
+    d = data->expect;
+    qdict_put(d, "event", qstring_from_str("EVENT_B"));
+    qapi_event_gen_EVENT_B(NULL);
+}
+
+static void test_event_c(TestEventData *data,
+                         const void *unused)
+{
+    QDict *d, *d_data, *d_b;
+
+    UserDefOne b;
+    b.integer = 2;
+    b.string = g_strdup("test1");
+    b.has_enum1 = false;
+
+    d_b = qdict_new();
+    qdict_put(d_b, "integer", qint_from_int(2));
+    qdict_put(d_b, "string", qstring_from_str("test1"));
+
+    d_data = qdict_new();
+    qdict_put(d_data, "a", qint_from_int(1));
+    qdict_put(d_data, "b", d_b);
+    qdict_put(d_data, "c", qstring_from_str("test2"));
+
+    d = data->expect;
+    qdict_put(d, "event", qstring_from_str("EVENT_C"));
+    qdict_put(d, "data", d_data);
+
+    qapi_event_gen_EVENT_C(true, 1, true, &b, "test2", NULL);
+
+    g_free(b.string);
+}
+
+/* Complex type */
+static void test_event_d(TestEventData *data,
+                         const void *unused)
+{
+    UserDefOne struct1;
+    EventStructOne a;
+    QDict *d, *d_data, *d_a, *d_struct1;
+
+    struct1.integer = 2;
+    struct1.string = g_strdup("test1");
+    struct1.has_enum1 = true;
+    struct1.enum1 = ENUM_ONE_VALUE1;
+
+    a.struct1 = &struct1;
+    a.string = g_strdup("test2");
+    a.has_enum2 = true;
+    a.enum2 = ENUM_ONE_VALUE2;
+
+    d_struct1 = qdict_new();
+    qdict_put(d_struct1, "integer", qint_from_int(2));
+    qdict_put(d_struct1, "string", qstring_from_str("test1"));
+    qdict_put(d_struct1, "enum1", qstring_from_str("value1"));
+
+    d_a = qdict_new();
+    qdict_put(d_a, "struct1", d_struct1);
+    qdict_put(d_a, "string", qstring_from_str("test2"));
+    qdict_put(d_a, "enum2", qstring_from_str("value2"));
+
+    d_data = qdict_new();
+    qdict_put(d_data, "a", d_a);
+    qdict_put(d_data, "b", qstring_from_str("test3"));
+    qdict_put(d_data, "enum3", qstring_from_str("value3"));
+
+    d = data->expect;
+    qdict_put(d, "event", qstring_from_str("EVENT_D"));
+    qdict_put(d, "data", d_data);
+
+    qapi_event_gen_EVENT_D(&a, "test3", false, NULL, true, ENUM_ONE_VALUE3,
+                           NULL);
+
+    g_free(struct1.string);
+    g_free(a.string);
+}
+
+static void event_test_emit(QDict *d, Error **errp)
+{
+    QObject *obj;
+    QDict *t;
+
+    /* Verify that we have timestamp, then remove it to compare other field */
+    obj = qdict_get(d, "timestamp");
+    g_assert(obj);
+    t = qobject_to_qdict(obj);
+    g_assert(t);
+    obj = qdict_get(t, "seconds");
+    g_assert(obj && qobject_type(obj) == QTYPE_QINT);
+    obj = qdict_get(t, "microseconds");
+    g_assert(obj && qobject_type(obj) == QTYPE_QINT);
+
+    qdict_del(d, "timestamp");
+
+    g_assert(qdict_cmp_simple(d, test_event_data->expect));
+
+}
+
+static void event_test_add(const char *testpath,
+                           void (*test_func)(TestEventData *data,
+                                             const void *user_data))
+{
+    g_test_add(testpath, TestEventData, NULL, event_prepare, test_func,
+               event_teardown);
+}
+
+
+
+int main(int argc, char **argv)
+{
+    qapi_event_set_func_emit(event_test_emit);
+
+    g_test_init(&argc, &argv, NULL);
+
+    event_test_add("/event/event_a", test_event_a);
+    event_test_add("/event/event_b", test_event_b);
+    event_test_add("/event/event_c", test_event_c);
+    event_test_add("/event/event_d", test_event_d);
+    g_test_run();
+
+    return 0;
+}