From: Youngjae Cho Date: Thu, 7 Sep 2023 12:37:59 +0000 (+0900) Subject: tests: Add test for resource-manager X-Git-Tag: accepted/tizen/8.0/unified/20231123.173029~8 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F54%2F301654%2F1;p=platform%2Fcore%2Fsystem%2Flibsyscommon.git tests: Add test for resource-manager Change-Id: Id16676523c3c503ce76593d408b1701cc3f6cc20 Signed-off-by: Youngjae Cho --- diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 132c796..c20c070 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -6,11 +6,14 @@ FILE(GLOB TEST_DRIVER_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/*.c") FILE(GLOB LIBCOMMON_SRCS "${CMAKE_SOURCE_DIR}/tests/libcommon/*.c" "${CMAKE_SOURCE_DIR}/src/libcommon/*.c") +FILE(GLOB RESOURCE_MANAGER_SRCS + "${CMAKE_SOURCE_DIR}/tests/resource-manager/*.c" + "${CMAKE_SOURCE_DIR}/src/resource-manager/*.c") SET(SRCS ${TEST_DRIVER_SRCS} ${LIBCOMMON_SRCS} - ) + ${RESOURCE_MANAGER_SRCS}) SET(WRAP_FLAGS "${WRAP_FLAGS} -Wl,--wrap=open") SET(WRAP_FLAGS "${WRAP_FLAGS} -Wl,--wrap=open64") @@ -18,6 +21,7 @@ SET(WRAP_FLAGS "${WRAP_FLAGS} -Wl,--wrap=open64") INCLUDE(FindPkgConfig) PKG_CHECK_MODULES(REQUIRED_PKGS REQUIRED glib-2.0 + json-c capi-system-info cmocka) diff --git a/tests/resource-manager/resource-driver-test.c b/tests/resource-manager/resource-driver-test.c new file mode 100644 index 0000000..5ebca3f --- /dev/null +++ b/tests/resource-manager/resource-driver-test.c @@ -0,0 +1,278 @@ +#include +#include + +#include +#include + +#include "syscommon-plugin-libsyscommon-test-interface.h" +#include "../test-main.h" + +typedef union { + int32_t i32; + int64_t i64; + uint32_t u32; + uint64_t u64; + double d; + void* p; + bool b; +} resource_attr_data_t; + +static int test_driver_create(int resource_id) +{ + return mock_type(int); +} + +static void test_driver_delete(int resource_id) +{ + function_called(); +} + +static int test_driver_init(void) +{ + return mock_type(int); +} + +static void test_driver_exit(void) +{ + function_called(); +} + +static bool test_is_support(int resource_id, const struct syscommon_resman_resource_attribute *attr) +{ + return mock_type(bool); +} + +static int test_get(int resource_id, + const struct syscommon_resman_resource_attribute *attr, + void *data) +{ + int ret = 0; + resource_attr_data_t attr_data = { 0, }; + + switch (attr->id) { + case TEST_ATTR_INT: + case TEST_ATTR_INT_IS_SUPPORT_FUNC: + case TEST_ATTR_INT_NO_IS_SUPPORT_FUNC: + case TEST_ATTR_INT_NO_GETTER: + case TEST_ATTR_INT_NO_SETTER: + attr_data.i32 = mock_type(int); + break; + case TEST_ATTR_INT64: + attr_data.i64 = mock_type(int64_t); + break; + case TEST_ATTR_UINT: + attr_data.u32 = mock_type(uint32_t); + break; + case TEST_ATTR_UINT64: + attr_data.u64 = mock_type(uint64_t); + break; + case TEST_ATTR_DOUBLE: + attr_data.d = mock_type(double); + break; + } + + ret = mock_type(int); + + if (ret < 0) + return ret; + + switch (attr->type) { + case SYSCOMMON_RESMAN_DATA_TYPE_INT: + *(int32_t *) data = attr_data.i32; + break; + case SYSCOMMON_RESMAN_DATA_TYPE_INT64: + *(int64_t *) data = attr_data.i64; + break; + case SYSCOMMON_RESMAN_DATA_TYPE_UINT: + *(uint32_t *) data = attr_data.u32; + break; + case SYSCOMMON_RESMAN_DATA_TYPE_UINT64: + *(uint64_t *) data = attr_data.u64; + break; + case SYSCOMMON_RESMAN_DATA_TYPE_DOUBLE: + *(double *) data = attr_data.d; + break; + case SYSCOMMON_RESMAN_DATA_TYPE_PTR: + *(void **) data = attr_data.p; + break; + case SYSCOMMON_RESMAN_DATA_TYPE_BOOLEAN: + *(bool *) data = attr_data.b; + break; + default: + return -EINVAL; + } + + return ret; +} + +static int test_set(int resource_id, + const struct syscommon_resman_resource_attribute *attr, + const void *data, int count) +{ + check_expected_ptr(data); + + return mock_type(int); +} + +static const struct syscommon_resman_resource_attribute test_attrs[] = { + { + .name = "TEST_ATTR_INT", + .id = TEST_ATTR_INT, + .type = SYSCOMMON_RESMAN_DATA_TYPE_INT, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + }, { + .name = "TEST_ATTR_INT64", + .id = TEST_ATTR_INT64, + .type = SYSCOMMON_RESMAN_DATA_TYPE_INT64, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + }, { + .name = "TEST_ATTR_UINT", + .id = TEST_ATTR_UINT, + .type = SYSCOMMON_RESMAN_DATA_TYPE_UINT, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + }, { + .name = "TEST_ATTR_UINT64", + .id = TEST_ATTR_UINT64, + .type = SYSCOMMON_RESMAN_DATA_TYPE_UINT64, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + }, { + .name = "TEST_ATTR_DOUBLE", + .id = TEST_ATTR_DOUBLE, + .type = SYSCOMMON_RESMAN_DATA_TYPE_DOUBLE, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + }, { + .name = "TEST_ATTR_2_UINT64", + .id = TEST_ATTR_2_UINT64, + .type = SYSCOMMON_RESMAN_DATA_TYPE_2_UINT64, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + }, { + .name = "TEST_ATTR_3_UINT64", + .id = TEST_ATTR_3_UINT64, + .type = SYSCOMMON_RESMAN_DATA_TYPE_3_UINT64, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + }, { + .name = "TEST_ATTR_4_UINT64", + .id = TEST_ATTR_4_UINT64, + .type = SYSCOMMON_RESMAN_DATA_TYPE_4_UINT64, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + }, { + /* Attribute for testing .is_support operation */ + .name = "TEST_ATTR_INT_IS_SUPPORT_FUNC", + .id = TEST_ATTR_INT_IS_SUPPORT_FUNC, + .type = SYSCOMMON_RESMAN_DATA_TYPE_INT, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + .is_supported = test_is_support, + }, + }, { + /** + * Attribute for testing the .get undertakes what .is_support should have done + * when the .is_support operation is not given + */ + .name = "TEST_ATTR_INT_NO_IS_SUPPORT_FUNC", + .id = TEST_ATTR_INT_NO_IS_SUPPORT_FUNC, + .type = SYSCOMMON_RESMAN_DATA_TYPE_INT, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .set = test_set, + }, + }, { + /** + * Attribute for testing not existing .get operation + */ + .name = "TEST_ATTR_INT_NO_GETTER", + .id = TEST_ATTR_INT_NO_GETTER, + .type = SYSCOMMON_RESMAN_DATA_TYPE_INT, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .set = test_set, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + }, { + /** + * Attribute for testing not existing .set operation + */ + .name = "TEST_ATTR_INT_NO_SETTER", + .id = TEST_ATTR_INT_NO_SETTER, + .type = SYSCOMMON_RESMAN_DATA_TYPE_INT, + .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC, + .ops = { + .get = test_get, + .is_supported = syscommon_resman_resource_attr_supported_always, + }, + } +}; + +static const struct syscommon_resman_resource_driver test_driver = { + .name = "test-driver", + .type = TEST_RESOURCE_TYPE_NORMAL_SINGLETON, + .flag = SYSCOMMON_RESMAN_RESOURCE_DRIVER_FLAG_COUNT_ONLY_ONE, + .attrs = test_attrs, + .num_attrs = sizeof(test_attrs)/sizeof(test_attrs[0]), + .ops = { + .create = test_driver_create, + .delete = test_driver_delete, + .init = test_driver_init, + .exit = test_driver_exit, + }, +}; + +int resource_driver_test_setup(void **state) +{ + /** + * Instead of using macro SYSCOMMON_RESMAN_RESOURCE_DRIVER_REGISTER(), + * use function. + * + * There two macros, SYSCOMMON_RESMAN_RESOURCE_DRIVER_REGISTER() and TESTSUITE(), + * are both using __attribute__((constructor)). And its order cannot be explicitly + * specified. However, the SYSCOMMON_RESMAN_RESOURCE_DRIVER_REGISTER() must be followed + * by the TESTSUITE(). Therefore, explicitly registers the driver via setup function + * prior to the execution of the testsuite. + */ + syscommon_resman_add_resource_driver(&test_driver); + + return 0; +} diff --git a/tests/resource-manager/resource-driver-test.h b/tests/resource-manager/resource-driver-test.h new file mode 100644 index 0000000..6b5f8ee --- /dev/null +++ b/tests/resource-manager/resource-driver-test.h @@ -0,0 +1,6 @@ +#ifndef __RESOURCE_DRIVER_TEST_H__ +#define __RESOURCE_DRIVER_TEST_H__ + +int resource_driver_test_setup(void **state); + +#endif /* __RESOURCE_DRIVER_TEST_H__ */ diff --git a/tests/resource-manager/syscommon-plugin-libsyscommon-test-interface.h b/tests/resource-manager/syscommon-plugin-libsyscommon-test-interface.h new file mode 100644 index 0000000..72b2cd1 --- /dev/null +++ b/tests/resource-manager/syscommon-plugin-libsyscommon-test-interface.h @@ -0,0 +1,25 @@ +#ifndef __TEST_RESOURCE_DRIVER_H__ +#define __TEST_RESOURCE_DRIVER_H__ + +enum libsyscommon_test_resource_type { + TEST_RESOURCE_TYPE_NORMAL, + TEST_RESOURCE_TYPE_NORMAL_SINGLETON, + TEST_RESOURCE_TYPE_INVALID_ATTRIBUTE, + TEST_RESOURCE_TYPE_NOT_EXIST, +}; + +#define TEST_ATTR_INT (1ULL << 0) +#define TEST_ATTR_INT64 (1ULL << 1) +#define TEST_ATTR_UINT (1ULL << 2) +#define TEST_ATTR_UINT64 (1ULL << 3) +#define TEST_ATTR_DOUBLE (1ULL << 4) +#define TEST_ATTR_2_UINT64 (1ULL << 5) +#define TEST_ATTR_3_UINT64 (1ULL << 6) +#define TEST_ATTR_4_UINT64 (1ULL << 7) +#define TEST_ATTR_INT_IS_SUPPORT_FUNC (1ULL << 8) +#define TEST_ATTR_INT_NO_IS_SUPPORT_FUNC (1ULL << 9) +#define TEST_ATTR_INT_NO_GETTER (1ULL << 10) +#define TEST_ATTR_INT_NO_SETTER (1ULL << 11) +#define TEST_ATTR_MAX (1ULL << 12) + +#endif /* __TEST_RESOURCE_DRIVER_H__ */ diff --git a/tests/resource-manager/test.c b/tests/resource-manager/test.c new file mode 100644 index 0000000..ccf35e4 --- /dev/null +++ b/tests/resource-manager/test.c @@ -0,0 +1,424 @@ +#include + +#include "resource-driver-test.h" +#include "syscommon-plugin-libsyscommon-test-interface.h" +#include "../test-main.h" + +static int setup_normal_resource(void) +{ + int resource_id; + int ret; + + /** + * To successfully create a resource instance of type TEST_RESOURCE_TYPE_NORMAL, + * it is necessary to configure 3 mocks below. + * 1. driver->ops.create() must success, returning 0. + * 2. The attribute->ops.is_support() of the attribute TEST_ATTR_INT_IS_SUPPORT_FUNC + * must success, returning true. + * 3. The attribute->ops.get() of the attribuet TEST_ATTR_INT_NO_IS_SUPPORT_FUNC + * must success, returnin 0. It needs reserving 2 value, the first one is an + * arbitrary value to be consumed by the ops.get(), and the latter one is an + * effective return value to be returned by the ops.get(). + */ + will_return(test_driver_create, 0); /* precondition 1 */ + will_return(test_is_support, true); /* precondition 2 */ + will_return(test_get, 123456); /* precondition 3 */ + will_return(test_get, 0); /* precondition 3 */ + + ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NORMAL_SINGLETON); + assert_int_equal(ret, 0); + + return resource_id; +} + +static void cleanup_normal_resource(int resource_id) +{ + expect_function_call(test_driver_delete); + syscommon_resman_delete_resource(resource_id); +} + +static void test_create_resource_pass(void **state) +{ + int resource_id; + int ret; + + /* Assume that the driver->ops.create() success and return 0 */ + will_return(test_driver_create, 0); + /* Set attribute TEST_ATTR_INT_IS_SUPPORT_FUNC's is_support() function to return true */ + will_return(test_is_support, true); + /* Set attribute TEST_ATTR_INT_NO_IS_SUPPORT_FUNC's get() function to return 0 */ + will_return(test_get, 121212); /* arbitrary value to be consumed */ + will_return(test_get, 0); + + ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NORMAL_SINGLETON); + + /* Check return value */ + assert_int_equal(ret, 0); + + /* Check attribute interest and memory allocation for attr_value->data */ + for (unsigned long long i = TEST_ATTR_INT; i < TEST_ATTR_MAX; i <<= 1) { + /* It must have been interested in all attribute */ + bool interest = syscommon_resman_is_resource_attr_interested(resource_id, i); + assert_true(interest); + + struct syscommon_resman_resource_attribute_value *attr_value + = syscommon_resman_get_resource_attr_value(resource_id, i); + assert_non_null(attr_value); + + switch (i) { + case TEST_ATTR_INT: + case TEST_ATTR_INT_IS_SUPPORT_FUNC: + case TEST_ATTR_INT_NO_IS_SUPPORT_FUNC: + case TEST_ATTR_INT_NO_GETTER: + case TEST_ATTR_INT_NO_SETTER: + case TEST_ATTR_INT64: + case TEST_ATTR_UINT: + case TEST_ATTR_UINT64: + case TEST_ATTR_DOUBLE: + /** + * Check created resource has attr_value that has + * successfully been allocated memory for data + */ + assert_non_null(attr_value->data); + break; + case TEST_ATTR_2_UINT64: + case TEST_ATTR_3_UINT64: + case TEST_ATTR_4_UINT64: + /** + * FIXME: Currently, memory allocation for the above type + * has not been implemented yet. Therefore it must be NULL. + */ + assert_null(attr_value->data); + break; + default: + assert_true(0); /* fail */ + } + } + + /* Check driver->ops.delete() is called on deleting resource */ + expect_function_call(test_driver_delete); + syscommon_resman_delete_resource(resource_id); +} + +static void test_create_resource_fail_driver_ops_create(void **state) +{ + int resource_id; + int ret; + + /* Assume that the driver->ops.create() fail and return -123 */ + will_return(test_driver_create, -123); + /* Additionally, test_driver_delete() should be called on fail */ + expect_function_call(test_driver_delete); + + ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NORMAL_SINGLETON); + + assert_int_equal(ret, -123); +} + +static void test_create_resource_fail_invalid_parameter_1(void **state) +{ + int ret; + + ret = syscommon_resman_create_resource(NULL, TEST_RESOURCE_TYPE_NORMAL_SINGLETON); + + assert_int_equal(ret, -EINVAL); +} + +static void test_create_resource_fail_invalid_parameter_2(void **state) +{ + int ret; + int resource_id; + + ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NOT_EXIST); + + assert_int_equal(ret, -EINVAL); +} + +static void test_create_resource_fail_is_support_1(void **state) +{ + int ret; + int resource_id; + + /* Assume that the driver->ops.create() success and return 0 */ + will_return(test_driver_create, 0); + /* Set attribute TEST_ATTR_INT_IS_SUPPORT_FUNC's is_support() function to return false */ + will_return(test_is_support, false); + /* Additionally, test_driver_delete() should be called on fail */ + expect_function_call(test_driver_delete); + + ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NORMAL_SINGLETON); + + assert_int_equal(ret, -ENOTSUP); +} + +static void test_create_resource_fail_is_support_2(void **state) +{ + int ret; + int resource_id; + + /* Assume that the driver->ops.create() success and return 0 */ + will_return(test_driver_create, 0); + /* Set attribute TEST_ATTR_INT_IS_SUPPORT_FUNC's is_support() function to return true */ + will_return(test_is_support, true); + /* The attr->ops.get() return negative, fail */ + will_return(test_get, 123123); + will_return(test_get, -1); + /* Additionally, test_driver_delete() should be called on fail */ + expect_function_call(test_driver_delete); + + ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NORMAL_SINGLETON); + + assert_int_equal(ret, -ENOTSUP); +} + +static void test_get_resource_attr_int_pass(void **state) +{ + int resource_id; + int value; + struct syscommon_resman_resource_attribute_value *attr_value; + int ret; + + resource_id = setup_normal_resource(); + + will_return(test_get, 131313); + will_return(test_get, 0); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT, &value); + assert_int_equal(ret, 0); + assert_int_equal(value, 131313); + + attr_value = syscommon_resman_get_resource_attr_value(resource_id, TEST_ATTR_INT); + assert_non_null(attr_value); + assert_int_equal(*(int *) attr_value->data, 131313); + + cleanup_normal_resource(resource_id); +} + +static void test_get_resource_attr_int_fail_getter(void **state) +{ + int resource_id; + int value; + struct syscommon_resman_resource_attribute_value *attr_value; + int ret; + + resource_id = setup_normal_resource(); + + /* First try, success */ + will_return(test_get, 9494); + will_return(test_get, 0 /* success */); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT, &value); + assert_int_equal(ret, 0); + assert_int_equal(value, 9494); + + attr_value = syscommon_resman_get_resource_attr_value(resource_id, TEST_ATTR_INT); + assert_non_null(attr_value); + assert_int_equal(*(int *) attr_value->data, 9494); + + /* Second try, fail */ + will_return(test_get, 777777); + will_return(test_get, -EPIPE /* An error occured */); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT, &value); + assert_int_equal(ret, -EPIPE); + + /* The attr_value MUST NOT be changed */ + attr_value = syscommon_resman_get_resource_attr_value(resource_id, TEST_ATTR_INT); + assert_non_null(attr_value); + assert_int_equal(*(int *) attr_value->data, 9494); + + cleanup_normal_resource(resource_id); +} + +static void test_get_resource_attr_int_fail_no_getter(void **state) +{ + int resource_id; + int value; + int ret; + + resource_id = setup_normal_resource(); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT_NO_GETTER, &value); + assert_int_equal(ret, -EINVAL); + + cleanup_normal_resource(resource_id); +} + +static void test_get_resource_attr_int_fail_unmatched_type(void **state) +{ + int resource_id; + int value; + int ret; + + resource_id = setup_normal_resource(); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT64, &value); + assert_int_equal(ret, -EINVAL); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_UINT, &value); + assert_int_equal(ret, -EINVAL); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_UINT64, &value); + assert_int_equal(ret, -EINVAL); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_DOUBLE, &value); + assert_int_equal(ret, -EINVAL); + + cleanup_normal_resource(resource_id); +} + +/* DEFECT: The NULL checking for the third parameter is not being checked */ +__attribute__((unused)) +static void test_get_resource_attr_int_fail_invalid_parameter_1(void **state) +{ + int resource_id; + int ret; + + resource_id = setup_normal_resource(); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT, NULL /* invalid */); + assert_int_equal(ret, -EINVAL); + + cleanup_normal_resource(resource_id); +} + +static void test_get_resource_attr_int_fail_invalid_parameter_2(void **state) +{ + int resource_id; + int value; + int ret; + + resource_id = setup_normal_resource(); + + ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_MAX /* invalid */, &value); + assert_int_equal(ret, -EINVAL); + + cleanup_normal_resource(resource_id); +} + +static void test_get_resource_attr_int_fail_invalid_parameter_3(void **state) +{ + int resource_id; + int value; + int ret; + + resource_id = setup_normal_resource(); + + ret = syscommon_resman_get_resource_attr_int(-1 /* invalid */, TEST_ATTR_INT, &value); + assert_int_equal(ret, -EINVAL); + + cleanup_normal_resource(resource_id); +} + +static void test_set_resource_attr_int_pass(void **state) +{ + int resource_id; + int ret; + const int value = 565656; + + resource_id = setup_normal_resource(); + + expect_memory(test_set, data, &value, sizeof(int)); + will_return(test_set, 0); + + ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_INT, value); + assert_int_equal(ret, 0); + + cleanup_normal_resource(resource_id); +} + +static void test_set_resource_attr_int_fail_setter(void **state) +{ + int resource_id; + int ret; + const int value = 444888; + + resource_id = setup_normal_resource(); + + expect_memory(test_set, data, &value, sizeof(int)); + will_return(test_set, -EPIPE /* An error occured */); + + ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_INT, value); + assert_int_equal(ret, -EPIPE); + + cleanup_normal_resource(resource_id); +} + +static void test_set_resource_attr_int_fail_no_setter(void **state) +{ + int resource_id; + int ret; + const int value = 444888; + + resource_id = setup_normal_resource(); + + ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_INT_NO_SETTER, value); + assert_int_equal(ret, -EINVAL); + + cleanup_normal_resource(resource_id); +} + +static void test_set_resource_attr_int_fail_unmatched_type(void **state) +{ + int resource_id; + int ret; + const int value = 9911; + + resource_id = setup_normal_resource(); + + ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_INT64, value); + assert_int_equal(ret, -EINVAL); + + ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_UINT, value); + assert_int_equal(ret, -EINVAL); + + ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_UINT64, value); + assert_int_equal(ret, -EINVAL); + + ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_DOUBLE, value); + assert_int_equal(ret, -EINVAL); + + cleanup_normal_resource(resource_id); +} + +static void test_set_resource_attr_int_fail_invalid_parameter_1(void **state) +{ + int resource_id; + int ret; + const int value = 543210; + + resource_id = setup_normal_resource(); + + ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_MAX, value); + assert_int_equal(ret, -EINVAL); + + cleanup_normal_resource(resource_id); +} + +static const struct CMUnitTest resource_manager_testsuite[] = { + cmocka_unit_test(test_create_resource_pass), + cmocka_unit_test(test_create_resource_fail_driver_ops_create), + cmocka_unit_test(test_create_resource_fail_invalid_parameter_1), + cmocka_unit_test(test_create_resource_fail_invalid_parameter_2), + cmocka_unit_test(test_create_resource_fail_is_support_1), + cmocka_unit_test(test_create_resource_fail_is_support_2), + + cmocka_unit_test(test_get_resource_attr_int_pass), + cmocka_unit_test(test_get_resource_attr_int_fail_getter), + cmocka_unit_test(test_get_resource_attr_int_fail_no_getter), + cmocka_unit_test(test_get_resource_attr_int_fail_unmatched_type), + /** + * DEFECT: It is not being checked that the third parameter is NULL. + * Enable this TC after adding check code, and it will get pass. + */ + //cmocka_unit_test(test_get_resource_attr_int_fail_invalid_parameter_1), + cmocka_unit_test(test_get_resource_attr_int_fail_invalid_parameter_2), + cmocka_unit_test(test_get_resource_attr_int_fail_invalid_parameter_3), + + cmocka_unit_test(test_set_resource_attr_int_pass), + cmocka_unit_test(test_set_resource_attr_int_fail_setter), + cmocka_unit_test(test_set_resource_attr_int_fail_no_setter), + cmocka_unit_test(test_set_resource_attr_int_fail_unmatched_type), + cmocka_unit_test(test_set_resource_attr_int_fail_invalid_parameter_1), +}; +TESTSUITE_FIXTURE(resource_manager_testsuite, resource_driver_test_setup, NULL); diff --git a/tests/test-main.h b/tests/test-main.h index 0430e4d..891a096 100644 --- a/tests/test-main.h +++ b/tests/test-main.h @@ -14,5 +14,10 @@ static void __attribute__((constructor)) run(void) \ testsuite_report_failcount(cmocka_run_group_tests(cmocka_unittest, NULL, NULL)); \ } -#endif //__TEST_MAIN_H__ +#define TESTSUITE_FIXTURE(cmocka_unittest, setup, teardown) \ +static void __attribute__((constructor)) run(void) \ +{ \ + testsuite_report_failcount(cmocka_run_group_tests(cmocka_unittest, setup, teardown)); \ +} +#endif //__TEST_MAIN_H__