From 57af8c95f5639e3ff61d4b1e9864fee8150cd2ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20B=C5=99ezina?= <pbrezina@redhat.com>
Date: Thu, 16 Aug 2018 13:20:55 +0200
Subject: [PATCH 35/47] sbus: add unit tests for public sbus_message module
Reviewed-by: Jakub Hrozek <jhrozek@redhat.com>
(cherry picked from commit c895fa2449900f4abd1dce6bb62a45c52bbb12cf)
---
Makefile.am | 14 +
src/tests/cmocka/sbus/test_sbus_message.c | 610 ++++++++++++++++++++++++++++++
2 files changed, 624 insertions(+)
create mode 100644 src/tests/cmocka/sbus/test_sbus_message.c
diff --git a/Makefile.am b/Makefile.am
index 1602ec6236799015fa7fd9f1707cb2bcdb20e07b..c05c9312d74d2adab9dfe6d40987a791785da256 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -270,6 +270,7 @@ if HAVE_CMOCKA
test_copy_keytab \
test_child_common \
responder_cache_req-tests \
+ test_sbus_message \
test_sbus_opath \
test_fo_srv \
pam-srv-tests \
@@ -2593,6 +2594,19 @@ test_ssh_client_LDADD = \
$(SSSD_LIBS) \
$(NULL)
+test_sbus_message_SOURCES = \
+ src/tests/cmocka/sbus/test_sbus_message.c \
+ $(NULL)
+test_sbus_message_CFLAGS = \
+ $(AM_CFLAGS)
+test_sbus_message_LDADD = \
+ $(CMOCKA_LIBS) \
+ $(POPT_LIBS) \
+ libsss_debug.la \
+ libsss_test_common.la \
+ libsss_sbus.la \
+ $(NULL)
+
test_sbus_opath_SOURCES = \
src/tests/cmocka/sbus/test_sbus_opath.c \
$(NULL)
diff --git a/src/tests/cmocka/sbus/test_sbus_message.c b/src/tests/cmocka/sbus/test_sbus_message.c
new file mode 100644
index 0000000000000000000000000000000000000000..c01e16823237775f95b772534adb5639e264c057
--- /dev/null
+++ b/src/tests/cmocka/sbus/test_sbus_message.c
@@ -0,0 +1,610 @@
+/*
+ Authors:
+ Jakub Hrozek <jhrozek@redhat.com>
+ Pavel Březina <pbrezina@redhat.com>
+
+ Copyright (C) 2014 Red Hat
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "config.h"
+
+#include <talloc.h>
+#include <errno.h>
+#include <popt.h>
+
+#include "util/util.h"
+#include "sbus/sbus_message.h"
+#include "tests/cmocka/common_mock.h"
+#include "tests/common.h"
+
+#define BASE_PATH "/some/path"
+
+struct test_ctx {
+ bool msg_removed;
+};
+
+static void helper_msg_removed(void *state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(state, struct test_ctx);
+
+ test_ctx->msg_removed = true;
+}
+
+static void helper_msg_watch(struct test_ctx *test_ctx, DBusMessage *msg)
+{
+ DBusFreeFunction free_fn;
+ dbus_int32_t data_slot = -1;
+ dbus_bool_t bret;
+
+ assert_non_null(msg);
+
+ bret = dbus_message_allocate_data_slot(&data_slot);
+ assert_true(bret);
+
+ free_fn = helper_msg_removed;
+ bret = dbus_message_set_data(msg, data_slot, test_ctx, free_fn);
+ assert_true(bret);
+}
+
+static int test_setup(void **state)
+{
+ struct test_ctx *test_ctx;
+
+ assert_true(leak_check_setup());
+
+ test_ctx = talloc_zero(global_talloc_context, struct test_ctx);
+ assert_non_null(test_ctx);
+ *state = test_ctx;
+
+ check_leaks_push(test_ctx);
+
+ return 0;
+}
+
+int test_teardown(void **state)
+{
+ struct test_ctx *test_ctx;
+
+ test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+
+ assert_true(check_leaks_pop(test_ctx));
+ talloc_zfree(test_ctx);
+ assert_true(leak_check_teardown());
+
+ return 0;
+}
+
+void test_sbus_message_bound__null(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ DBusMessage *msg;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+
+ ret = sbus_message_bound(NULL, msg);
+ assert_int_equal(ret, EINVAL);
+
+ ret = sbus_message_bound(test_ctx, NULL);
+ assert_int_equal(ret, EINVAL);
+
+ dbus_message_unref(msg);
+}
+
+void test_sbus_message_bound__unref(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ DBusMessage *msg;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ ret = sbus_message_bound(test_ctx, msg);
+ assert_int_equal(ret, EOK);
+
+ /* no memory leak should be detected in teardown */
+ dbus_message_unref(msg);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_message_bound__free(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ TALLOC_CTX *tmp_ctx;
+ DBusMessage *msg;
+ errno_t ret;
+
+ tmp_ctx = talloc_new(test_ctx);
+ assert_non_null(tmp_ctx);
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ ret = sbus_message_bound(tmp_ctx, msg);
+ assert_int_equal(ret, EOK);
+
+ talloc_free(tmp_ctx);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_message_bound_steal__null(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ DBusMessage *msg;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ ret = sbus_message_bound_steal(NULL, msg);
+ assert_int_equal(ret, EINVAL);
+
+ ret = sbus_message_bound_steal(test_ctx, NULL);
+ assert_int_equal(ret, EINVAL);
+
+ dbus_message_unref(msg);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_message_bound_steal__invalid(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ DBusMessage *msg;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ ret = sbus_message_bound_steal(test_ctx, msg);
+ assert_int_equal(ret, ERR_INTERNAL);
+
+ dbus_message_unref(msg);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_message_bound_steal__free(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ TALLOC_CTX *tmp_ctx;
+ TALLOC_CTX *tmp_ctx_steal;
+ DBusMessage *msg;
+ errno_t ret;
+
+ tmp_ctx = talloc_new(test_ctx);
+ assert_non_null(tmp_ctx);
+
+ tmp_ctx_steal = talloc_new(test_ctx);
+ assert_non_null(tmp_ctx_steal);
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ ret = sbus_message_bound(tmp_ctx, msg);
+ assert_int_equal(ret, EOK);
+
+ /* this will increase ref counter of message and add new talloc bound */
+ ret = sbus_message_bound_steal(tmp_ctx_steal, msg);
+ assert_int_equal(ret, EOK);
+
+ talloc_free(tmp_ctx);
+ assert_false(test_ctx->msg_removed);
+ talloc_free(tmp_ctx_steal);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_method_create_empty__unref(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ DBusMessage *msg;
+
+ msg = sbus_method_create_empty(NULL, "bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ assert_int_equal(dbus_message_get_type(msg), DBUS_MESSAGE_TYPE_METHOD_CALL);
+ assert_string_equal(dbus_message_get_destination(msg), "bus.test");
+ assert_string_equal(dbus_message_get_path(msg), "/");
+ assert_string_equal(dbus_message_get_interface(msg), "iface.test");
+ assert_string_equal(dbus_message_get_member(msg), "method");
+
+ dbus_message_unref(msg);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_method_create_empty__free(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ TALLOC_CTX *tmp_ctx;
+ DBusMessage *msg;
+
+ tmp_ctx = talloc_new(test_ctx);
+ assert_non_null(tmp_ctx);
+
+ msg = sbus_method_create_empty(tmp_ctx, "bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ assert_int_equal(dbus_message_get_type(msg), DBUS_MESSAGE_TYPE_METHOD_CALL);
+ assert_string_equal(dbus_message_get_destination(msg), "bus.test");
+ assert_string_equal(dbus_message_get_path(msg), "/");
+ assert_string_equal(dbus_message_get_interface(msg), "iface.test");
+ assert_string_equal(dbus_message_get_member(msg), "method");
+
+ talloc_free(tmp_ctx);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_method_create__unref(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ DBusMessage *msg;
+ dbus_bool_t dbret;
+ uint32_t in_value = 32;
+ uint32_t out_value;
+
+ msg = sbus_method_create(NULL, "bus.test", "/", "iface.test", "method",
+ DBUS_TYPE_UINT32, &in_value);
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ assert_int_equal(dbus_message_get_type(msg), DBUS_MESSAGE_TYPE_METHOD_CALL);
+ assert_string_equal(dbus_message_get_destination(msg), "bus.test");
+ assert_string_equal(dbus_message_get_path(msg), "/");
+ assert_string_equal(dbus_message_get_interface(msg), "iface.test");
+ assert_string_equal(dbus_message_get_member(msg), "method");
+
+ dbret = dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_UINT32, &out_value,
+ DBUS_TYPE_INVALID);
+ assert_true(dbret);
+ assert_int_equal(out_value, 32);
+
+ dbus_message_unref(msg);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_method_create__free(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ TALLOC_CTX *tmp_ctx;
+ DBusMessage *msg;
+
+ tmp_ctx = talloc_new(test_ctx);
+ assert_non_null(tmp_ctx);
+
+ msg = sbus_method_create_empty(tmp_ctx, "bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ assert_int_equal(dbus_message_get_type(msg), DBUS_MESSAGE_TYPE_METHOD_CALL);
+ assert_string_equal(dbus_message_get_destination(msg), "bus.test");
+ assert_string_equal(dbus_message_get_path(msg), "/");
+ assert_string_equal(dbus_message_get_interface(msg), "iface.test");
+ assert_string_equal(dbus_message_get_member(msg), "method");
+
+ talloc_free(tmp_ctx);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_signal_create_empty__unref(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ DBusMessage *msg;
+
+ msg = sbus_signal_create_empty(NULL, "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ assert_int_equal(dbus_message_get_type(msg), DBUS_MESSAGE_TYPE_SIGNAL);
+ assert_null(dbus_message_get_destination(msg));
+ assert_string_equal(dbus_message_get_path(msg), "/");
+ assert_string_equal(dbus_message_get_interface(msg), "iface.test");
+ assert_string_equal(dbus_message_get_member(msg), "method");
+
+ dbus_message_unref(msg);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_signal_create_empty__free(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ TALLOC_CTX *tmp_ctx;
+ DBusMessage *msg;
+
+ tmp_ctx = talloc_new(test_ctx);
+ assert_non_null(tmp_ctx);
+
+ msg = sbus_signal_create_empty(tmp_ctx, "/", "iface.test", "method");
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ assert_int_equal(dbus_message_get_type(msg), DBUS_MESSAGE_TYPE_SIGNAL);
+ assert_null(dbus_message_get_destination(msg));
+ assert_string_equal(dbus_message_get_path(msg), "/");
+ assert_string_equal(dbus_message_get_interface(msg), "iface.test");
+ assert_string_equal(dbus_message_get_member(msg), "method");
+
+ talloc_free(tmp_ctx);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_signal_create__unref(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ DBusMessage *msg;
+ dbus_bool_t dbret;
+ uint32_t in_value = 32;
+ uint32_t out_value;
+
+ msg = sbus_signal_create(NULL, "/", "iface.test", "method",
+ DBUS_TYPE_UINT32, &in_value);
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ assert_int_equal(dbus_message_get_type(msg), DBUS_MESSAGE_TYPE_SIGNAL);
+ assert_null(dbus_message_get_destination(msg));
+ assert_string_equal(dbus_message_get_path(msg), "/");
+ assert_string_equal(dbus_message_get_interface(msg), "iface.test");
+ assert_string_equal(dbus_message_get_member(msg), "method");
+
+ dbret = dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_UINT32, &out_value,
+ DBUS_TYPE_INVALID);
+ assert_true(dbret);
+ assert_int_equal(out_value, 32);
+
+ dbus_message_unref(msg);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_signal_create__free(void **state)
+{
+ struct test_ctx *test_ctx = talloc_get_type_abort(*state, struct test_ctx);
+ TALLOC_CTX *tmp_ctx;
+ DBusMessage *msg;
+ dbus_bool_t dbret;
+ uint32_t in_value = 32;
+ uint32_t out_value;
+
+ tmp_ctx = talloc_new(test_ctx);
+ assert_non_null(tmp_ctx);
+
+ msg = sbus_signal_create(tmp_ctx, "/", "iface.test", "method",
+ DBUS_TYPE_UINT32, &in_value);
+ assert_non_null(msg);
+ helper_msg_watch(test_ctx, msg);
+
+ assert_int_equal(dbus_message_get_type(msg), DBUS_MESSAGE_TYPE_SIGNAL);
+ assert_null(dbus_message_get_destination(msg));
+ assert_string_equal(dbus_message_get_path(msg), "/");
+ assert_string_equal(dbus_message_get_interface(msg), "iface.test");
+ assert_string_equal(dbus_message_get_member(msg), "method");
+
+ dbret = dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_UINT32, &out_value,
+ DBUS_TYPE_INVALID);
+ assert_true(dbret);
+ assert_int_equal(out_value, 32);
+
+ talloc_free(tmp_ctx);
+ assert_true(test_ctx->msg_removed);
+}
+
+void test_sbus_reply_parse__ok(void **state)
+{
+ DBusMessage *msg;
+ DBusMessage *reply;
+ dbus_bool_t dbret;
+ uint32_t in_value1 = 32;
+ uint32_t in_value2 = 64;
+ uint32_t out_value1;
+ uint32_t out_value2;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ dbus_message_set_serial(msg, 1);
+
+ reply = dbus_message_new_method_return(msg);
+ assert_non_null(reply);
+
+ dbret = dbus_message_append_args(reply, DBUS_TYPE_UINT32, &in_value1,
+ DBUS_TYPE_UINT32, &in_value2,
+ DBUS_TYPE_INVALID);
+ assert_true(dbret);
+
+ ret = sbus_reply_parse(reply, DBUS_TYPE_UINT32, &out_value1,
+ DBUS_TYPE_UINT32, &out_value2);
+ assert_int_equal(ret, EOK);
+ assert_int_equal(out_value1, in_value1);
+ assert_int_equal(out_value2, in_value2);
+
+ dbus_message_unref(msg);
+ dbus_message_unref(reply);
+}
+
+void test_sbus_reply_parse__error(void **state)
+{
+ DBusMessage *msg;
+ DBusMessage *reply;
+ uint32_t out_value1;
+ uint32_t out_value2;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ dbus_message_set_serial(msg, 1);
+
+ reply = dbus_message_new_error(msg, SBUS_ERROR_KILLED, "Test error!");
+ assert_non_null(reply);
+
+ ret = sbus_reply_parse(reply, DBUS_TYPE_UINT32, &out_value1,
+ DBUS_TYPE_UINT32, &out_value2);
+ assert_int_equal(ret, ERR_SBUS_KILL_CONNECTION);
+
+ dbus_message_unref(msg);
+ dbus_message_unref(reply);
+}
+
+void test_sbus_reply_parse__wrong_type(void **state)
+{
+ DBusMessage *msg;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ dbus_message_set_serial(msg, 1);
+
+ ret = sbus_reply_parse(msg);
+ assert_int_not_equal(ret, EOK);
+
+ dbus_message_unref(msg);
+}
+
+void test_sbus_reply_check__ok(void **state)
+{
+ DBusMessage *msg;
+ DBusMessage *reply;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ dbus_message_set_serial(msg, 1);
+
+ reply = dbus_message_new_method_return(msg);
+ assert_non_null(reply);
+
+ ret = sbus_reply_check(reply);
+ assert_int_equal(ret, EOK);
+
+ dbus_message_unref(msg);
+ dbus_message_unref(reply);
+}
+
+void test_sbus_reply_check__error(void **state)
+{
+ DBusMessage *msg;
+ DBusMessage *reply;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ dbus_message_set_serial(msg, 1);
+
+ reply = dbus_message_new_error(msg, SBUS_ERROR_KILLED, "Test error!");
+ assert_non_null(reply);
+
+ ret = sbus_reply_check(reply);
+ assert_int_equal(ret, ERR_SBUS_KILL_CONNECTION);
+
+ dbus_message_unref(msg);
+ dbus_message_unref(reply);
+}
+
+void test_sbus_reply_check__wrong_type(void **state)
+{
+ DBusMessage *msg;
+ errno_t ret;
+
+ msg = dbus_message_new_method_call("bus.test", "/", "iface.test", "method");
+ assert_non_null(msg);
+ dbus_message_set_serial(msg, 1);
+
+ ret = sbus_reply_check(msg);
+ assert_int_not_equal(ret, EOK);
+
+ dbus_message_unref(msg);
+}
+
+int main(int argc, const char *argv[])
+{
+ poptContext pc;
+ int opt;
+ struct poptOption long_options[] = {
+ POPT_AUTOHELP
+ SSSD_DEBUG_OPTS
+ POPT_TABLEEND
+ };
+
+ const struct CMUnitTest tests[] = {
+ cmocka_unit_test_setup_teardown(test_sbus_message_bound__null,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_message_bound__unref,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_message_bound__free,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_message_bound_steal__null,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_message_bound_steal__invalid,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_message_bound_steal__free,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_method_create_empty__unref,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_method_create_empty__free,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_method_create__unref,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_method_create__free,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_signal_create_empty__unref,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_signal_create_empty__free,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_signal_create__unref,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_signal_create__free,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_reply_parse__ok,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_reply_parse__error,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_reply_parse__wrong_type,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_reply_check__ok,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_reply_check__error,
+ test_setup, test_teardown),
+ cmocka_unit_test_setup_teardown(test_sbus_reply_check__wrong_type,
+ test_setup, test_teardown),
+ };
+
+ /* Set debug level to invalid value so we can decide if -d 0 was used. */
+ debug_level = SSSDBG_INVALID;
+
+ pc = poptGetContext(argv[0], argc, argv, long_options, 0);
+ while((opt = poptGetNextOpt(pc)) != -1) {
+ switch(opt) {
+ default:
+ fprintf(stderr, "\nInvalid option %s: %s\n\n",
+ poptBadOption(pc, 0), poptStrerror(opt));
+ poptPrintUsage(pc, stderr, 0);
+ return 1;
+ }
+ }
+ poptFreeContext(pc);
+
+ DEBUG_CLI_INIT(debug_level);
+
+ return cmocka_run_group_tests(tests, NULL, NULL);
+}
--
2.14.4