From: Konrad Kuchciak Date: Fri, 23 Oct 2020 16:19:53 +0000 (+0200) Subject: Improve unit tests coverage rate X-Git-Tag: submit/tizen/20210322.183501~4 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c5cef05715380773f569559f2a3ee21c71a25d40;p=platform%2Fcore%2Fapi%2Fdiagnostics.git Improve unit tests coverage rate Current coverage: 99.3% (line) 100% (functions) Change-Id: I746fe85fc148acea9f6c68136badd57cf2bc29f0 Signed-off-by: Konrad Kuchciak --- diff --git a/src/library/dbus.c b/src/library/dbus.c index d0fdc64..e92f870 100644 --- a/src/library/dbus.c +++ b/src/library/dbus.c @@ -36,7 +36,6 @@ static GDBusConnection *dbus_connect() return conn; } -MOCKABLE_FOR_TESTS int dbus_subscribe(void (*signal_handler)(GDBusConnection *, const gchar *, const gchar *, @@ -84,7 +83,6 @@ void dbus_unsubscribe(void) subscription_id = 0; } -MOCKABLE_FOR_TESTS int dbus_get_file_from_report(const char *report_path, const int entry, int *fd) { GDBusConnection *conn = dbus_connect(); diff --git a/src/library/dbus.h b/src/library/dbus.h index da0b0cb..5b01f38 100644 --- a/src/library/dbus.h +++ b/src/library/dbus.h @@ -29,12 +29,6 @@ #include #include -#ifdef UNIT_TEST -#define MOCKABLE_FOR_TESTS __attribute__((weak)) -#else -#define MOCKABLE_FOR_TESTS -#endif - struct dbus_signal_s { gchar *sender_name; gchar *object_path; diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt index 41dcca7..b45083e 100644 --- a/src/test/CMakeLists.txt +++ b/src/test/CMakeLists.txt @@ -15,12 +15,13 @@ function(add_mocked_test name wraps) ADD_DEPENDENCIES(ctest test_${name}) endfunction(add_mocked_test) -add_mocked_test(diagnostics_set_notification_cb "-Wl,--wrap=system_info_get_platform_bool,--wrap=dbus_subscribe") -add_mocked_test(diagnostics_unset_notification_cb "-Wl,--wrap=system_info_get_platform_bool") +add_mocked_test(diagnostics_common "-Wl,--wrap=calloc,--wrap=system_info_get_platform_bool,--wrap=dumpsys_dump,--wrap=poll,--wrap=read,--wrap=g_bus_get_sync,--wrap=g_dbus_connection_send_message_with_reply_sync") +add_mocked_test(diagnostics_set_notification_cb "-Wl,--wrap=system_info_get_platform_bool,--wrap=g_bus_get_sync,--wrap=g_dbus_connection_signal_subscribe") +add_mocked_test(diagnostics_unset_notification_cb "-Wl,--wrap=system_info_get_platform_bool,--wrap=g_bus_get_sync,--wrap=g_dbus_connection_signal_subscribe,--wrap=g_dbus_connection_signal_unsubscribe") add_mocked_test(diagnostics_request_client_data "-Wl,--wrap=system_info_get_platform_bool,--wrap=dumpsys_dump") add_mocked_test(diagnostics_get_client_id "-Wl,--wrap=system_info_get_platform_bool") add_mocked_test(diagnostics_get_report_path "") -add_mocked_test(diagnostics_get_data "-Wl,--wrap=system_info_get_platform_bool,--wrap=dbus_get_file_from_report") +add_mocked_test(diagnostics_get_data "-Wl,--wrap=system_info_get_platform_bool,--wrap=g_bus_get_sync,--wrap=g_dbus_connection_send_message_with_reply_sync") add_mocked_test(diagnostics_data_read "-Wl,--wrap=system_info_get_platform_bool,--wrap=poll,--wrap=read") add_mocked_test(diagnostics_create "") add_mocked_test(diagnostics_data_create "") diff --git a/src/test/test_diagnostics.h b/src/test/test_diagnostics.h index e97da73..956a3ec 100644 --- a/src/test/test_diagnostics.h +++ b/src/test/test_diagnostics.h @@ -73,13 +73,51 @@ int __wrap_dbus_subscribe(void (*signal_handler)(GDBusConnection *, const gchar return (int)mock(); } -int __wrap_dbus_get_file_from_report(const char *report_path, const int entry, int *fd) +GDBusConnection *__wrap_g_bus_get_sync(GBusType bus_type, GCancellable *cancellable, GError **error) { - (void) report_path; - (void) entry; - *fd = 1; + GDBusConnection *conn = mock_ptr_type(GDBusConnection *); + if (!conn && error) + *error = g_error_new_literal(1, 1, ""); - return (int)mock(); + return conn; +} + +guint __wrap_g_dbus_connection_signal_subscribe(GDBusConnection *connection, + const gchar *sender, + const gchar *interface_name, + const gchar *member, + const gchar *object_path, + const gchar *arg0, + GDBusSignalFlags flags, + GDBusSignalCallback callback, + gpointer user_data, + GDestroyNotify user_data_free_func) +{ + return (guint)mock(); +} + +void __wrap_g_dbus_connection_signal_unsubscribe(GDBusConnection *connection, guint subscription_id) +{ + (void) connection; + return; +} + +GDBusMessage *__wrap_g_dbus_connection_send_message_with_reply_sync(GDBusConnection *connection, + GDBusMessage *message, + GDBusSendMessageFlags flags, + gint timeout_msec, + volatile guint32 *out_serial, + GCancellable *cancellable, + GError **error) +{ + GDBusMessage *reply = mock_ptr_type(GDBusMessage *); + if (!reply && error) { + *error = g_error_new_literal(1, 1, ""); + reply = g_dbus_message_new(); + g_dbus_message_set_message_type(reply, G_DBUS_MESSAGE_TYPE_ERROR); + } + + return reply; } int __wrap_poll(struct pollfd *__fds, nfds_t __nfds, int __timeout) @@ -87,10 +125,14 @@ int __wrap_poll(struct pollfd *__fds, nfds_t __nfds, int __timeout) (void) __fds; (void) __nfds; (void) __timeout; + int mode = (int)mock(); - __fds->revents = POLLIN; + if (mode <= 0) + return mode; - return (int)mock(); + __fds->revents = mode; + + return 1; } ssize_t __wrap_read(int fd, void *buf, size_t nbytes) diff --git a/src/test/test_diagnostics_common.c b/src/test/test_diagnostics_common.c new file mode 100644 index 0000000..7729c66 --- /dev/null +++ b/src/test/test_diagnostics_common.c @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "diagnostics.h" +#include +#include + +#include + +#include "test_diagnostics.h" +#include "test_diagnostics_add_function_defs.h" + +struct _diagnostics_cb_info_s { + diagnostics_notification_cb cb; + void *user_data; +}; + +struct _diagnostics_ctx_s *ctx = NULL; + +void signal_callback(void *_ctx, void *user_data) +{ + ctx = _ctx; + + assert_ptr_equal(user_data, NULL); +} + +void *__real_calloc(size_t nmemb, size_t size); +void *__wrap_calloc(size_t nmemb, size_t size) +{ + int fake = (int) mock(); + if (fake) + return NULL; + + return __real_calloc(nmemb, size); +} + +static void test_diagnostics_common_n1(void **state) +{ + (void) state; + GVariant *parameters = build_signal_parameters_crash(); + + cb_info.cb = signal_callback; + cb_info.user_data = NULL; + + will_return(__wrap_calloc, 1); + + signal_handler(NULL, DBUS_SENDER_CRASH, DBUS_OBJECT_PATH, DBUS_INTERFACE_NAME, DBUS_MEMBER_CRASH, parameters, NULL); + assert_null(ctx); + + g_variant_unref(parameters); +} + +static void test_diagnostics_common_n2(void **state) +{ + (void) state; + struct dbus_signal_s *signal; + struct _diagnostics_ctx_s *ctx; + + will_return(__wrap_calloc, 0); + will_return(__wrap_calloc, 1); + + signal = dbus_signal_create(DBUS_SENDER_CRASH, DBUS_OBJECT_PATH, DBUS_INTERFACE_NAME, DBUS_MEMBER_CRASH, build_signal_parameters_crash()); + assert_non_null(signal); + + ctx = diagnostics_create(signal); + assert_null(ctx); + + dbus_signal_cleanup(signal); +} + +static void test_diagnostics_common_n3(void **state) +{ + (void) state; + int fd = 0; + + will_return(__wrap_calloc, 1); + assert_null(diagnostics_data_create(fd)); +} + +static void test_diagnostics_common_n4(void **state) +{ + (void) state; + const char *client_id = ""; + int params_size = 3; + const char *params[] = {"a", "b", "c"}; + struct _diagnostics_data_s *data = NULL; + int ret; + + will_return(__wrap_dumpsys_dump, DIAGNOSTICS_ERROR_NONE); + will_return(__wrap_calloc, 1); + + ret = diagnostics_request_client_data(client_id, params, params_size, (void**)&data); + + assert_int_equal(ret, DIAGNOSTICS_ERROR_OUT_OF_MEMORY); + assert_null(data); +} + +static void test_diagnostics_common_n5(void **state) +{ + (void) state; + struct _diagnostics_ctx_s *ctx = NULL; + struct _diagnostics_data_s *data = NULL; + const char *params[] = {"cs_full"}; + static int dummy = 1; + GDBusConnection *conn = (GDBusConnection *)&dummy; + GDBusMessage *reply; + GUnixFDList *fd_list; + int fd = 1; + int ret; + + will_return_count(__wrap_calloc, 0, 2); + + ctx = build_ctx_crash(); + reply = g_dbus_message_new(); + fd_list = g_unix_fd_list_new_from_array(&fd, 1); + g_dbus_message_set_message_type(reply, G_DBUS_MESSAGE_TYPE_METHOD_RETURN); + g_dbus_message_set_unix_fd_list(reply, fd_list); + + will_return(__wrap_g_bus_get_sync, conn); + will_return(__wrap_g_dbus_connection_send_message_with_reply_sync, reply); + will_return(__wrap_calloc, 1); + + ret = diagnostics_get_data(ctx, params, 1, (void**)&data); + + assert_int_equal(ret, DIAGNOSTICS_ERROR_OUT_OF_MEMORY); + assert_null(data); + + destroy_ctx(ctx); +} + +int main(void) +{ + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_diagnostics_common_n1), + cmocka_unit_test(test_diagnostics_common_n2), + cmocka_unit_test(test_diagnostics_common_n3), + cmocka_unit_test(test_diagnostics_common_n4), + cmocka_unit_test(test_diagnostics_common_n5), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} \ No newline at end of file diff --git a/src/test/test_diagnostics_create.c b/src/test/test_diagnostics_create.c index ca534d4..58b0491 100644 --- a/src/test/test_diagnostics_create.c +++ b/src/test/test_diagnostics_create.c @@ -39,42 +39,35 @@ static void test_diagnostics_create_n1(void **state) static void test_diagnostics_create_n2(void **state) { (void) state; - struct _diagnostics_ctx_s *ctx = build_ctx_crash(); - free(ctx->signal->signal_name); - ctx->signal->signal_name = g_strdup("non dbus member crash"); - struct _diagnostics_ctx_s *result = diagnostics_create(ctx->signal); + struct dbus_signal_s *signal; + struct _diagnostics_ctx_s *ctx; - assert_null(result); + signal = dbus_signal_create(DBUS_SENDER_CRASH, DBUS_OBJECT_PATH, DBUS_INTERFACE_NAME, "", build_signal_parameters_crash()); + assert_non_null(signal); - destroy_ctx(ctx); -} - -static void test_diagnostics_create_n3(void **state) -{ - (void) state; - struct _diagnostics_ctx_s *ctx = build_ctx_crash(); - free(ctx->signal->signal_name); - ctx->signal->signal_name = NULL; - struct _diagnostics_ctx_s *result = diagnostics_create(ctx->signal); - - assert_null(result); + ctx = diagnostics_create(signal); + assert_null(ctx); - destroy_ctx(ctx); + dbus_signal_cleanup(signal); } static void test_diagnostics_create_p1(void **state) { (void) state; - struct _diagnostics_ctx_s *ctx = build_ctx_crash(); - struct _diagnostics_ctx_s *result = diagnostics_create(ctx->signal); + struct dbus_signal_s *signal; + struct _diagnostics_ctx_s *ctx; + + signal = dbus_signal_create(DBUS_SENDER_CRASH, DBUS_OBJECT_PATH, DBUS_INTERFACE_NAME, DBUS_MEMBER_CRASH, build_signal_parameters_crash()); + assert_non_null(signal); - assert_non_null(result); - assert_string_equal(result->client_id, DBUS_SENDER_CRASH); - assert_ptr_equal(result->signal, ctx->signal); - assert_int_equal(result->signal_type, SIG_TYPE_CRASH); + ctx = diagnostics_create(signal); + assert_non_null(ctx); + assert_string_equal(ctx->client_id, DBUS_SENDER_CRASH); + assert_ptr_equal(ctx->signal, ctx->signal); + assert_int_equal(ctx->signal_type, SIG_TYPE_CRASH); - destroy_ctx(ctx); - free(result); + dbus_signal_cleanup(signal); + free(ctx); } int main(void) @@ -82,7 +75,6 @@ int main(void) const struct CMUnitTest tests[] = { cmocka_unit_test(test_diagnostics_create_n1), cmocka_unit_test(test_diagnostics_create_n2), - cmocka_unit_test(test_diagnostics_create_n3), cmocka_unit_test(test_diagnostics_create_p1), }; return cmocka_run_group_tests(tests, NULL, NULL); diff --git a/src/test/test_diagnostics_data_read.c b/src/test/test_diagnostics_data_read.c index bf54d8f..4bb547d 100644 --- a/src/test/test_diagnostics_data_read.c +++ b/src/test/test_diagnostics_data_read.c @@ -94,6 +94,39 @@ static void test_diagnostics_data_read_n6(void **state) assert_int_equal(diagnostics_data_read(&data, buf, count, timeout, &bytes_read), DIAGNOSTICS_ERROR_IO_ERROR); } +static void test_diagnostics_data_read_n7(void **state) +{ + (void) state; + struct _diagnostics_data_s data; + data.fd = 0; + char buf[256]; + size_t count = sizeof(buf); + int timeout = 100; + size_t bytes_read = 0; + + will_return(__wrap_poll, POLLIN); + will_return(__wrap_read, -1); + + assert_int_equal(diagnostics_data_read(&data, buf, count, timeout, &bytes_read), DIAGNOSTICS_ERROR_IO_ERROR); + assert_int_equal(bytes_read, 0); +} + +static void test_diagnostics_data_read_n8(void **state) +{ + (void) state; + struct _diagnostics_data_s data; + data.fd = 0; + char buf[256]; + size_t count = sizeof(buf); + int timeout = 100; + size_t bytes_read = 0; + + will_return(__wrap_poll, POLLERR); + + assert_int_equal(diagnostics_data_read(&data, buf, count, timeout, &bytes_read), DIAGNOSTICS_ERROR_IO_ERROR); + assert_int_equal(bytes_read, 0); +} + static void test_diagnostics_data_read_p1(void **state) { (void) state; @@ -104,13 +137,29 @@ static void test_diagnostics_data_read_p1(void **state) int timeout = 100; size_t bytes_read = 0; - will_return(__wrap_poll, 1); + will_return(__wrap_poll, POLLIN); will_return(__wrap_read, 2); assert_int_equal(diagnostics_data_read(&data, buf, count, timeout, &bytes_read), DIAGNOSTICS_ERROR_NONE); assert_int_equal(bytes_read, 2); } +static void test_diagnostics_data_read_p2(void **state) +{ + (void) state; + struct _diagnostics_data_s data; + data.fd = 0; + char buf[256]; + size_t count = sizeof(buf); + int timeout = 100; + size_t bytes_read = 0; + + will_return(__wrap_poll, POLLHUP); + + assert_int_equal(diagnostics_data_read(&data, buf, count, timeout, &bytes_read), DIAGNOSTICS_ERROR_NONE); + assert_int_equal(bytes_read, 0); +} + int main(void) { const struct CMUnitTest tests[] = { @@ -119,7 +168,10 @@ int main(void) cmocka_unit_test(test_diagnostics_data_read_n4), cmocka_unit_test(test_diagnostics_data_read_n5), cmocka_unit_test(test_diagnostics_data_read_n6), + cmocka_unit_test(test_diagnostics_data_read_n7), + cmocka_unit_test(test_diagnostics_data_read_n8), cmocka_unit_test(test_diagnostics_data_read_p1), + cmocka_unit_test(test_diagnostics_data_read_p2), }; return cmocka_run_group_tests(tests, NULL, NULL); } diff --git a/src/test/test_diagnostics_get_data.c b/src/test/test_diagnostics_get_data.c index 240ec25..9a88098 100644 --- a/src/test/test_diagnostics_get_data.c +++ b/src/test/test_diagnostics_get_data.c @@ -27,9 +27,15 @@ #include "dbus.h" #include +#include +#include +#include #include "test_diagnostics.h" +static int dummy = 1; +GDBusConnection *conn = (GDBusConnection *)&dummy; + static void test_diagnostics_get_data_n1(void **state) { (void) state; @@ -69,9 +75,80 @@ static void test_diagnostics_get_data_n4(void **state) struct _diagnostics_data_s *data = NULL; const char *params[] = {"cs_foo"}; - int result = diagnostics_get_data(ctx, params, 1, (void**)&data); + assert_int_equal(diagnostics_get_data(ctx, params, 1, (void**)&data), DIAGNOSTICS_ERROR_NOT_SUPPORTED); + assert_null(data); + + destroy_ctx(ctx); +} + +static void test_diagnostics_get_data_n5(void **state) +{ + (void) state; + struct _diagnostics_ctx_s *ctx = build_ctx_crash(); + struct _diagnostics_data_s *data = NULL; + const char *params[] = {"cs_full"}; + GDBusConnection *conn = NULL; + + will_return(__wrap_g_bus_get_sync, conn); + + assert_int_equal(diagnostics_get_data(ctx, params, 1, (void**)&data), DIAGNOSTICS_ERROR_IO_ERROR); + assert_null(data); + + destroy_ctx(ctx); +} + +static void test_diagnostics_get_data_n6(void **state) +{ + (void) state; + struct _diagnostics_ctx_s *ctx = build_ctx_crash(); + struct _diagnostics_data_s *data = NULL; + const char *params[] = {"cs_full"}; + GDBusMessage *reply = NULL; + + will_return(__wrap_g_bus_get_sync, conn); + will_return(__wrap_g_dbus_connection_send_message_with_reply_sync, reply); + + assert_int_equal(diagnostics_get_data(ctx, params, 1, (void**)&data), DIAGNOSTICS_ERROR_IO_ERROR); + assert_null(data); + + destroy_ctx(ctx); +} + +static void test_diagnostics_get_data_n7(void **state) +{ + (void) state; + struct _diagnostics_ctx_s *ctx = build_ctx_crash(); + struct _diagnostics_data_s *data = NULL; + const char *params[] = {"cs_full"}; + GDBusMessage *reply = g_dbus_message_new(); + + g_dbus_message_set_message_type(reply, G_DBUS_MESSAGE_TYPE_METHOD_RETURN); + + will_return(__wrap_g_bus_get_sync, conn); + will_return(__wrap_g_dbus_connection_send_message_with_reply_sync, reply); + + assert_int_equal(diagnostics_get_data(ctx, params, 1, (void**)&data), DIAGNOSTICS_ERROR_IO_ERROR); + assert_null(data); + + destroy_ctx(ctx); +} + +static void test_diagnostics_get_data_n8(void **state) +{ + (void) state; + struct _diagnostics_ctx_s *ctx = build_ctx_crash(); + struct _diagnostics_data_s *data = NULL; + const char *params[] = {"cs_full"}; + GDBusMessage *reply = g_dbus_message_new(); + GUnixFDList *fd_list = g_unix_fd_list_new(); + + g_dbus_message_set_message_type(reply, G_DBUS_MESSAGE_TYPE_METHOD_RETURN); + g_dbus_message_set_unix_fd_list(reply, fd_list); + + will_return(__wrap_g_bus_get_sync, conn); + will_return(__wrap_g_dbus_connection_send_message_with_reply_sync, reply); - assert_int_equal(result, DIAGNOSTICS_ERROR_NOT_SUPPORTED); + assert_int_equal(diagnostics_get_data(ctx, params, 1, (void**)&data), DIAGNOSTICS_ERROR_IO_ERROR); assert_null(data); destroy_ctx(ctx); @@ -83,14 +160,18 @@ static void test_diagnostics_get_data_p1(void **state) struct _diagnostics_ctx_s *ctx = build_ctx_crash(); struct _diagnostics_data_s *data = NULL; const char *params[] = {"cs_full"}; + int fd = 1; + GDBusMessage *reply = g_dbus_message_new(); + GUnixFDList *fd_list = g_unix_fd_list_new_from_array(&fd, 1); - will_return(__wrap_dbus_get_file_from_report, 0); + g_dbus_message_set_message_type(reply, G_DBUS_MESSAGE_TYPE_METHOD_RETURN); + g_dbus_message_set_unix_fd_list(reply, fd_list); - int result = diagnostics_get_data(ctx, params, 1, (void**)&data); + will_return(__wrap_g_bus_get_sync, conn); + will_return(__wrap_g_dbus_connection_send_message_with_reply_sync, reply); - assert_int_equal(result, DIAGNOSTICS_ERROR_NONE); + assert_int_equal(diagnostics_get_data(ctx, params, 1, (void**)&data), DIAGNOSTICS_ERROR_NONE); assert_non_null(data); - assert_int_equal(data->fd, 1); destroy_ctx(ctx); } @@ -102,6 +183,10 @@ int main(void) cmocka_unit_test(test_diagnostics_get_data_n2), cmocka_unit_test(test_diagnostics_get_data_n3), cmocka_unit_test(test_diagnostics_get_data_n4), + cmocka_unit_test(test_diagnostics_get_data_n5), + cmocka_unit_test(test_diagnostics_get_data_n6), + cmocka_unit_test(test_diagnostics_get_data_n7), + cmocka_unit_test(test_diagnostics_get_data_n8), cmocka_unit_test(test_diagnostics_get_data_p1), }; return cmocka_run_group_tests(tests, NULL, NULL); diff --git a/src/test/test_diagnostics_set_notification_cb.c b/src/test/test_diagnostics_set_notification_cb.c index ea90a1d..aaf8e8e 100644 --- a/src/test/test_diagnostics_set_notification_cb.c +++ b/src/test/test_diagnostics_set_notification_cb.c @@ -31,6 +31,9 @@ struct _diagnostics_cb_info_s { void *user_data; }; +static int dummy = 1; +GDBusConnection *conn = (GDBusConnection *)&dummy; + void callback(void *ctx, void *user_data) { (void)ctx; @@ -44,10 +47,21 @@ static void test_diagnostics_set_notification_cb_n1(void **state) } static void test_diagnostics_set_notification_cb_n2(void **state) +{ + (void) state; + GDBusConnection *conn = NULL; + + will_return(__wrap_g_bus_get_sync, conn); + + assert_int_equal(diagnostics_set_notification_cb(callback, NULL), DIAGNOSTICS_ERROR_IO_ERROR); +} + +static void test_diagnostics_set_notification_cb_n3(void **state) { (void) state; - will_return(__wrap_dbus_subscribe, -1); + will_return(__wrap_g_bus_get_sync, conn); + will_return(__wrap_g_dbus_connection_signal_subscribe, 0); assert_int_equal(diagnostics_set_notification_cb(callback, NULL), DIAGNOSTICS_ERROR_IO_ERROR); } @@ -56,7 +70,8 @@ static void test_diagnostics_set_notification_cb_p1(void **state) { (void) state; - will_return(__wrap_dbus_subscribe, DIAGNOSTICS_ERROR_NONE); + will_return(__wrap_g_bus_get_sync, conn); + will_return(__wrap_g_dbus_connection_signal_subscribe, 1); assert_int_equal(diagnostics_set_notification_cb(callback, NULL), DIAGNOSTICS_ERROR_NONE); assert_ptr_equal(cb_info.cb, callback); @@ -69,7 +84,8 @@ static void test_diagnostics_set_notification_cb_p2(void **state) { (void) state; - will_return(__wrap_dbus_subscribe, DIAGNOSTICS_ERROR_NONE); + will_return(__wrap_g_bus_get_sync, conn); + will_return(__wrap_g_dbus_connection_signal_subscribe, 1); assert_int_equal(diagnostics_set_notification_cb(callback, NULL), DIAGNOSTICS_ERROR_NONE); assert_int_equal(diagnostics_set_notification_cb(callback, NULL), DIAGNOSTICS_ERROR_RESOURCE_BUSY); @@ -80,6 +96,7 @@ int main(void) const struct CMUnitTest tests[] = { cmocka_unit_test(test_diagnostics_set_notification_cb_n1), cmocka_unit_test(test_diagnostics_set_notification_cb_n2), + cmocka_unit_test(test_diagnostics_set_notification_cb_n3), cmocka_unit_test(test_diagnostics_set_notification_cb_p1), cmocka_unit_test(test_diagnostics_set_notification_cb_p2), }; diff --git a/src/test/test_diagnostics_unset_notification_cb.c b/src/test/test_diagnostics_unset_notification_cb.c index 4104eac..698fb15 100644 --- a/src/test/test_diagnostics_unset_notification_cb.c +++ b/src/test/test_diagnostics_unset_notification_cb.c @@ -25,10 +25,25 @@ #include "test_diagnostics.h" +static int dummy = 1; +GDBusConnection *conn = (GDBusConnection *)&dummy; + +void callback(void *ctx, void *user_data) +{ + (void)ctx; + (void)user_data; +} + static void test_diagnostics_unset_notification_cb_p1(void **state) { (void) state; + will_return(__wrap_g_bus_get_sync, conn); + will_return(__wrap_g_dbus_connection_signal_subscribe, 1); + + assert_int_equal(diagnostics_set_notification_cb(callback, NULL), DIAGNOSTICS_ERROR_NONE); + + will_return(__wrap_g_bus_get_sync, conn); assert_int_equal(diagnostics_unset_notification_cb(), DIAGNOSTICS_ERROR_NONE); }