Add unit tests for deserialization

Change-Id: I896e59f2ce6c140995e4aad1b8010a96f413d8ac
Signed-off-by: Konrad Kuchciak <k.kuchciak@samsung.com>

diff --git a/src/event_types/action_executed_event.c b/src/event_types/action_executed_event.c
index 34c9554a4c7a30c0e95b6f3e268065e2faf2434f..dd0b5edd7beaceb1178893a62de6c3fc389339d0 100644 (file)
--- a/src/event_types/action_executed_event.c
+++ b/src/event_types/action_executed_event.c
@@ -130,6 +130,7 @@ static int deserialize_ae_event(struct faultd_event_type *type,
 finish:
        return ret;
 }
+TEST_ENTRY_POINT(deserialize_ae_event);
 
 static void ae_event_release(struct faultd_event *ev)
 {

diff --git a/src/event_types/decision_made_event.c b/src/event_types/decision_made_event.c
index 63d7c94f9fbd46d34c60f0bc6c8609963b4c9c2a..4c7905ed020e25528b5f7bdc5d5c6c6628c1ef62 100644 (file)
--- a/src/event_types/decision_made_event.c
+++ b/src/event_types/decision_made_event.c
@@ -124,6 +124,7 @@ static int deserialize_dm_event(struct faultd_event_type *type,
 finish:
        return ret;
 }
+TEST_ENTRY_POINT(deserialize_dm_event);
 
 static void dm_event_release(struct faultd_event *ev)
 {

diff --git a/src/event_types/faultd_started_event.c b/src/event_types/faultd_started_event.c
index 12f6a0b7052d6136ac8855953e9c99885c70cdc5..d95f6852b021f1ea6b26d6a967d1eda1f5933d49 100644 (file)
--- a/src/event_types/faultd_started_event.c
+++ b/src/event_types/faultd_started_event.c
@@ -46,6 +46,7 @@ static int deserialize_fs_event(struct faultd_event_type *type,
 finish:
        return ret;
 }
+TEST_ENTRY_POINT(deserialize_fs_event);
 
 static void fs_event_release(struct faultd_event *ev)
 {

diff --git a/src/event_types/resource_violation_event.c b/src/event_types/resource_violation_event.c
index a1f5b037579bc2a535f4d2edfae70c092d8e14fe..f3960760b00c1e4bee389033734bc2bd0addd29a 100644 (file)
--- a/src/event_types/resource_violation_event.c
+++ b/src/event_types/resource_violation_event.c
@@ -105,6 +105,7 @@ static int deserialize_rv_event(struct faultd_event_type *type,
 finish:
        return ret;
 }
+TEST_ENTRY_POINT(deserialize_rv_event);
 
 static void rv_event_release(struct faultd_event *ev)
 {

diff --git a/src/event_types/service_failed_event.c b/src/event_types/service_failed_event.c
index c0dacfbb4581e16143bfede9fbc54d1ac44faa90..a994ccc536dc1444d38556f7e3225fd01e024b29 100644 (file)
--- a/src/event_types/service_failed_event.c
+++ b/src/event_types/service_failed_event.c
@@ -92,6 +92,7 @@ static int deserialize_sf_event(struct faultd_event_type *type,
 finish:
        return ret;
 }
+TEST_ENTRY_POINT(deserialize_sf_event);
 
 static void sf_event_release(struct faultd_event *ev)
 {

diff --git a/src/event_types/system_booted_event.c b/src/event_types/system_booted_event.c
index ee9aa70e90d1cc576d01e558ea4b1a0ed30bdec5..a217908966092c4fdaea3cd0b9cb5a716638f156 100644 (file)
--- a/src/event_types/system_booted_event.c
+++ b/src/event_types/system_booted_event.c
@@ -88,6 +88,7 @@ static int deserialize_sb_event(struct faultd_event_type *type,
 finish:
        return ret;
 }
+TEST_ENTRY_POINT(deserialize_sb_event);
 
 static void sb_event_release(struct faultd_event *ev)
 {

diff --git a/tests/unit/action_executed_event_tests.c b/tests/unit/action_executed_event_tests.c
index 9caa4f69696f814310f7c03d646f4c08f2ff0cf5..5c3ab7baff6ed69e645d447a90872a6cf87246fd 100644 (file)
--- a/tests/unit/action_executed_event_tests.c
+++ b/tests/unit/action_executed_event_tests.c
@@ -1,9 +1,11 @@
 #include "action_executed_event.h"
 #include "helpers.h"
+#include "database.h"
 
 #define TESTED_MOD action_executed_event
 
 DECLARE_TEST_ENTRY_POINT(TESTED_MOD, ae_event_serialize, void);
+DECLARE_TEST_ENTRY_POINT(TESTED_MOD, deserialize_ae_event, int);
 
 static struct faultd_event *alloc_event()
 {
@@ -59,6 +61,15 @@ static int setup(void **state)
                                                                         NULL);
 }
 
+static int setup_deserialization(void **state)
+{
+       return setup_event_serialization(state, alloc_event, generate_test_attrs,
+                                                                        (serialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, ae_event_serialize),
+                                                                        (deserialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, deserialize_ae_event));
+}
+
 static int teardown(void **state)
 {
        struct serialize_test_data *td = *state;
@@ -77,5 +88,7 @@ static int teardown(void **state)
 
 FAULTD_TEST_GROUP(
        FAULTD_TEST_CASE_NST("ae_ev_serialize_test", test_event_serialization,
-                                                setup, teardown)
+                                                setup, teardown),
+       FAULTD_TEST_CASE_NST("ae_ev_deserialize_test", test_event_deserialization,
+                                                setup_deserialization, teardown)
 )

diff --git a/tests/unit/decision_made_event_tests.c b/tests/unit/decision_made_event_tests.c
index 8b2ebf0c668aa640059b5b1a29580970b29a7c13..9d459f885f72936d506ebf441920ff79b7a75d7d 100644 (file)
--- a/tests/unit/decision_made_event_tests.c
+++ b/tests/unit/decision_made_event_tests.c
@@ -4,6 +4,7 @@
 #define TESTED_MOD decision_made_event
 
 DECLARE_TEST_ENTRY_POINT(TESTED_MOD, dm_event_serialize, void);
+DECLARE_TEST_ENTRY_POINT(TESTED_MOD, deserialize_dm_event, int);
 
 static struct faultd_event *alloc_event()
 {
@@ -52,7 +53,17 @@ static int setup(void **state)
 {
        return setup_event_serialization(state, alloc_event, generate_test_attrs,
                                                                         (serialize_func_t)CALL_TEST_ENTRY_POINT(
-                                                                                TESTED_MOD, dm_event_serialize));
+                                                                                TESTED_MOD, dm_event_serialize),
+                                                                        NULL);
+}
+
+static int setup_deserialization(void **state)
+{
+       return setup_event_serialization(state, alloc_event, generate_test_attrs,
+                                                                        (serialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, dm_event_serialize),
+                                                                        (deserialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, deserialize_dm_event));
 }
 
 static int teardown(void **state)
@@ -73,5 +84,7 @@ static int teardown(void **state)
 
 FAULTD_TEST_GROUP(
        FAULTD_TEST_CASE_NST("dm_ev_serialize_test", test_event_serialization,
-                                                setup, teardown)
+                                                setup, teardown),
+       FAULTD_TEST_CASE_NST("dm_ev_deserialize_test", test_event_deserialization,
+                                                setup_deserialization, teardown)
 )

diff --git a/tests/unit/faultd_started_event_tests.c b/tests/unit/faultd_started_event_tests.c
index 0822e97070c4dad5282d5ed016647c6c5b35ebae..cc6cbc9278ef26f73d91d8f8c8e98ce17e7579f6 100644 (file)
--- a/tests/unit/faultd_started_event_tests.c
+++ b/tests/unit/faultd_started_event_tests.c
@@ -4,6 +4,7 @@
 #define TESTED_MOD faultd_started_event
 
 DECLARE_TEST_ENTRY_POINT(TESTED_MOD, fs_event_serialize, void);
+DECLARE_TEST_ENTRY_POINT(TESTED_MOD, deserialize_fs_event, int);
 
 static struct faultd_event *alloc_event()
 {
@@ -38,6 +39,15 @@ static int setup(void **state)
                                                                         NULL);
 }
 
+static int setup_deserialization(void **state)
+{
+       return setup_event_serialization(state, alloc_event, generate_test_attrs,
+                                                                        (serialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, fs_event_serialize),
+                                                                        (deserialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, deserialize_fs_event));
+}
+
 static int teardown(void **state)
 {
        struct serialize_test_data *td = *state;
@@ -52,5 +62,7 @@ static int teardown(void **state)
 
 FAULTD_TEST_GROUP(
        FAULTD_TEST_CASE_NST("fs_ev_serialize_test", test_event_serialization,
-                                                setup, teardown)
+                                                setup, teardown),
+       FAULTD_TEST_CASE_NST("fs_ev_deserialize_test", test_event_deserialization,
+                                                setup_deserialization, teardown)
 )

diff --git a/tests/unit/helpers.c b/tests/unit/helpers.c
index aecd9c7a42bfef563087bed0c691fe98f1f52b15..160a49457343f06e41c6b4a04d11c4f545898816 100644 (file)
--- a/tests/unit/helpers.c
+++ b/tests/unit/helpers.c
@@ -61,6 +61,23 @@ void test_serialization(struct serialized_element *data, int size, struct faultd
        assert_int_equal(faultd_object_count_children(parent), size);
 }
 
+void assert_test_attrs_equal(struct serialized_element *actual,
+                                                        struct serialized_element *desired, int size)
+{
+       for (int i = 0; i < size; i++) {
+               assert_int_equal(actual[i].type, desired[i].type);
+
+               switch (actual[i].type) {
+               case TYPE_OBJECT:
+                       assert_test_attrs_equal(actual[i].child, desired[i].child, actual[i].children_num);
+                       break;
+               default:
+                       assert_data_equal(actual[i].type, actual[i].desired, desired[i].desired);
+                       break;
+               }
+       }
+}
+
 void assert_faultd_object_equal(struct faultd_object *actual,
                                                                struct faultd_object *desired)
 {
@@ -283,6 +300,30 @@ void test_event_serialization(void **state)
        test_serialization(td->test_data, td->size, td->fd_obj);
 }
 
+void test_event_deserialization(void **state)
+{
+       struct serialize_test_data *td = *state;
+       struct serialize_test_data td_out;
+       int ret;
+
+       td->serialize_func(td->ev, td->fd_obj);
+
+       ret = td->deserialize_func(td->ev->type, td->fd_obj, &td_out.ev);
+       assert_int_equal(ret, 0);
+
+       td->generate_attrs_func(&td_out);
+
+       /*
+        * generate_test_attrs function stores only pointers to
+        * serialized/deserialized variables in test_data structure array,
+        * so it's enough to compare td->test_data and td_out.test_data
+        */
+
+       assert_test_attrs_equal(td->test_data, td_out.test_data, td->size);
+
+       serialized_elems_free(td_out.test_data, td_out.size);
+}
+
 struct serialized_element *serialized_elems_dup(
        struct serialized_element *elems, size_t size)
 {
@@ -314,7 +355,8 @@ void serialized_elems_free(struct serialized_element *elems, size_t size)
 int setup_event_serialization(void **state,
                                                          struct faultd_event *(*alloc_event)(),
                                                          generate_attrs_func_t generate_attrs,
-                                                         serialize_func_t serialize_func)
+                                                         serialize_func_t serialize_func,
+                                                         deserialize_func_t deserialize_func)
 {
        struct serialize_test_data *td;
        int ret;
@@ -333,6 +375,7 @@ int setup_event_serialization(void **state,
        /* store generate_attrs function pointer for further use */
        td->generate_attrs_func = generate_attrs;
        td->serialize_func = serialize_func;
+       td->deserialize_func = deserialize_func;
 
        *state = td;
        return 0;

diff --git a/tests/unit/helpers.h b/tests/unit/helpers.h
index 947b2ca7922bad1a25ffbe5643f315769a144d6c..a6672ce7c2b8982d1d064ef00872b1e2ada8d993 100644 (file)
--- a/tests/unit/helpers.h
+++ b/tests/unit/helpers.h
@@ -58,6 +58,8 @@ void test_serialization(struct serialized_element *data, int size,
                                                struct faultd_object *parent);
 int faultd_object_count_children(struct faultd_object *obj);
 
+void assert_test_attrs_equal(struct serialized_element *actual,
+                                                        struct serialized_element *desired, int size);
 void assert_faultd_object_equal(struct faultd_object *actual,
                                                                struct faultd_object *desired);
 void assert_data_equal(int type, void *actual, void *desired);
@@ -80,6 +82,8 @@ struct timespec generate_timespec();
 struct serialize_test_data;
 
 typedef void (*serialize_func_t)(struct faultd_event *, struct faultd_object *);
+typedef int (*deserialize_func_t)(struct faultd_event_type *,
+                                                                 struct faultd_object *, struct faultd_event **);
 typedef void (*generate_attrs_func_t)(struct serialize_test_data *);
 
 struct serialize_test_data {
@@ -88,10 +92,12 @@ struct serialize_test_data {
        struct serialized_element *test_data;
        size_t size;
        serialize_func_t serialize_func;
+       deserialize_func_t deserialize_func;
        generate_attrs_func_t generate_attrs_func;
 };
 
 void test_event_serialization(void **state);
+void test_event_deserialization(void **state);
 
 struct serialized_element *serialized_elems_dup(
        struct serialized_element *elems, size_t size);
@@ -101,7 +107,8 @@ void serialized_elems_free(struct serialized_element *elems, size_t size);
 int setup_event_serialization(void **state,
                                                          struct faultd_event *(*alloc_event)(),
                                                          generate_attrs_func_t generate_attrs,
-                                                         serialize_func_t serialize_func);
+                                                         serialize_func_t serialize_func,
+                                                         deserialize_func_t deserialize_func);
 
 static inline void allocate_boot_event()
 {

diff --git a/tests/unit/resource_violation_event_tests.c b/tests/unit/resource_violation_event_tests.c
index 3f802d24481ecf61679d0dc463aa1ab7befe90f1..92cfdfe5558dad1244f75d2b0f5f4c6a8f5dbf54 100644 (file)
--- a/tests/unit/resource_violation_event_tests.c
+++ b/tests/unit/resource_violation_event_tests.c
@@ -4,6 +4,7 @@
 #define TESTED_MOD resource_violation_event
 
 DECLARE_TEST_ENTRY_POINT(TESTED_MOD, rv_event_serialize, void);
+DECLARE_TEST_ENTRY_POINT(TESTED_MOD, deserialize_rv_event, int);
 
 static struct faultd_event *alloc_event()
 {
@@ -46,7 +47,17 @@ static int setup(void **state)
 {
        return setup_event_serialization(state, alloc_event, generate_test_attrs,
                                                                         (serialize_func_t)CALL_TEST_ENTRY_POINT(
-                                                                                TESTED_MOD, rv_event_serialize));
+                                                                                TESTED_MOD, rv_event_serialize),
+                                                                        NULL);
+}
+
+static int setup_deserialization(void **state)
+{
+       return setup_event_serialization(state, alloc_event, generate_test_attrs,
+                                                                        (serialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, rv_event_serialize),
+                                                                        (deserialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, deserialize_rv_event));
 }
 
 static int teardown(void **state)
@@ -64,5 +75,7 @@ static int teardown(void **state)
 
 FAULTD_TEST_GROUP(
        FAULTD_TEST_CASE_NST("rv_ev_serialize_test", test_event_serialization,
-                                                setup, teardown)
+                                                setup, teardown),
+       FAULTD_TEST_CASE_NST("rv_ev_deserialize_test", test_event_deserialization,
+                                                setup_deserialization, teardown)
 )

diff --git a/tests/unit/service_failed_event_tests.c b/tests/unit/service_failed_event_tests.c
index 0707eb4be159bcfe3b8c883341af29f1ab71c3bd..7a779504233c899257887cbd8a3344c2969eecbe 100644 (file)
--- a/tests/unit/service_failed_event_tests.c
+++ b/tests/unit/service_failed_event_tests.c
@@ -4,6 +4,7 @@
 #define TESTED_MOD service_failed_event
 
 DECLARE_TEST_ENTRY_POINT(TESTED_MOD, sf_event_serialize, void);
+DECLARE_TEST_ENTRY_POINT(TESTED_MOD, deserialize_sf_event, int);
 
 static struct faultd_event *alloc_event()
 {
@@ -42,7 +43,17 @@ static int setup(void **state)
 {
        return setup_event_serialization(state, alloc_event, generate_test_attrs,
                                                                         (serialize_func_t)CALL_TEST_ENTRY_POINT(
-                                                                                TESTED_MOD, sf_event_serialize));
+                                                                                TESTED_MOD, sf_event_serialize),
+                                                                        NULL);
+}
+
+static int setup_deserialization(void **state)
+{
+       return setup_event_serialization(state, alloc_event, generate_test_attrs,
+                                                                        (serialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, sf_event_serialize),
+                                                                        (deserialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, deserialize_sf_event));
 }
 
 static int teardown(void **state)
@@ -60,5 +71,7 @@ static int teardown(void **state)
 
 FAULTD_TEST_GROUP(
        FAULTD_TEST_CASE_NST("sf_ev_serialize_test", test_event_serialization,
-                                                setup, teardown)
+                                                setup, teardown),
+       FAULTD_TEST_CASE_NST("sf_ev_deserialize_test", test_event_deserialization,
+                                                setup_deserialization, teardown)
 )

diff --git a/tests/unit/system_booted_event_tests.c b/tests/unit/system_booted_event_tests.c
index 94d7bef67de43512683e703c5e0e9e705f197987..8dba9cb25f83ec07da164a83caf4aac89479d1c4 100644 (file)
--- a/tests/unit/system_booted_event_tests.c
+++ b/tests/unit/system_booted_event_tests.c
@@ -4,6 +4,7 @@
 #define TESTED_MOD system_booted_event
 
 DECLARE_TEST_ENTRY_POINT(TESTED_MOD, sb_event_serialize, void);
+DECLARE_TEST_ENTRY_POINT(TESTED_MOD, deserialize_sb_event, int);
 
 static struct faultd_event *alloc_event()
 {
@@ -37,7 +38,17 @@ static int setup(void **state)
 {
        return setup_event_serialization(state, alloc_event, generate_test_attrs,
                                                                         (serialize_func_t)CALL_TEST_ENTRY_POINT(
-                                                                                TESTED_MOD, sb_event_serialize));
+                                                                                TESTED_MOD, sb_event_serialize),
+                                                                        NULL);
+}
+
+static int setup_deserialization(void **state)
+{
+       return setup_event_serialization(state, alloc_event, generate_test_attrs,
+                                                                        (serialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, sb_event_serialize),
+                                                                        (deserialize_func_t)CALL_TEST_ENTRY_POINT(
+                                                                                TESTED_MOD, deserialize_sb_event));
 }
 
 static int teardown(void **state)
@@ -54,5 +65,7 @@ static int teardown(void **state)
 
 FAULTD_TEST_GROUP(
        FAULTD_TEST_CASE_NST("sb_ev_serialize_test", test_event_serialization,
-                                                setup, teardown)
+                                                setup, teardown),
+       FAULTD_TEST_CASE_NST("sb_ev_deserialize_test", test_event_deserialization,
+                                                setup_deserialization, teardown)
 )

diff --git a/tests/unit/test_dbadapter.c b/tests/unit/test_dbadapter.c
index f2f909f63f40255f27bdeaadf11f305a51fc47bd..5b546100e8c472d8aac3ff2b5280568ecffd848d 100644 (file)
--- a/tests/unit/test_dbadapter.c
+++ b/tests/unit/test_dbadapter.c
@@ -67,6 +67,18 @@ static bool testdb_is_oid_valid(faultd_oid_t *oid)
        return true;
 }
 
+static int testdb_get_event(faultd_oid_t *oid, struct faultd_event **ev)
+{
+       *ev = calloc(1, sizeof(struct faultd_event));
+       if (*ev == NULL)
+               return 1;
+
+       (*ev)->uref.refcnt = 1;
+       (*ev)->oid = *oid;
+
+       return 0;
+}
+
 static struct testdb_adapter testdb_adapter = {
        .database_adapter = {
                .module = {
@@ -82,6 +94,7 @@ static struct testdb_adapter testdb_adapter = {
                .load = testdb_load,
                .new_oid = testdb_new_oid,
                .is_oid_valid = testdb_is_oid_valid,
+               .get_event = testdb_get_event,
        }
 };