--- /dev/null
+#include <stdio.h>
+#include <stdint.h>
+
+#include <libsyscommon/resource-manager.h>
+#include <libsyscommon/resource-type.h>
+
+#include "common-interface.h"
+#include "display-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 display_resource_driver_create(int resource_id)
+{
+ return mock_type(int);
+}
+
+static void display_resource_driver_delete(int resource_id)
+{
+ function_called();
+}
+
+static int display_resource_driver_init(void)
+{
+ return mock_type(int);
+}
+
+static void display_resource_driver_exit(void)
+{
+ function_called();
+}
+
+static bool test_display_is_support(int resource_id, const struct syscommon_resman_resource_attribute *attr)
+{
+ return mock_type(bool);
+}
+
+static int test_display_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 DISPLAY_ATTR_INT:
+ case DISPLAY_ATTR_INT_IS_SUPPORT_FUNC:
+ case DISPLAY_ATTR_INT_NO_IS_SUPPORT_FUNC:
+ case DISPLAY_ATTR_INT_NO_GETTER:
+ case DISPLAY_ATTR_INT_NO_SETTER:
+ attr_data.i32 = mock_type(int);
+ break;
+ case DISPLAY_ATTR_INT64:
+ attr_data.i64 = mock_type(int64_t);
+ break;
+ case DISPLAY_ATTR_UINT:
+ attr_data.u32 = mock_type(uint32_t);
+ break;
+ case DISPLAY_ATTR_UINT64:
+ attr_data.u64 = mock_type(uint64_t);
+ break;
+ case DISPLAY_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_display_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 display_attrs[] = {
+ {
+ .name = "DISPLAY_ATTR_INT",
+ .id = DISPLAY_ATTR_INT,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_INT,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }, {
+ .name = "DISPLAY_ATTR_INT64",
+ .id = DISPLAY_ATTR_INT64,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_INT64,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }, {
+ .name = "DISPLAY_ATTR_UINT",
+ .id = DISPLAY_ATTR_UINT,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_UINT,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }, {
+ .name = "DISPLAY_ATTR_UINT64",
+ .id = DISPLAY_ATTR_UINT64,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_UINT64,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }, {
+ .name = "DISPLAY_ATTR_DOUBLE",
+ .id = DISPLAY_ATTR_DOUBLE,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_DOUBLE,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }, {
+ .name = "DISPLAY_ATTR_2_UINT64",
+ .id = DISPLAY_ATTR_2_UINT64,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_2_UINT64,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }, {
+ .name = "DISPLAY_ATTR_3_UINT64",
+ .id = DISPLAY_ATTR_3_UINT64,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_3_UINT64,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }, {
+ .name = "DISPLAY_ATTR_4_UINT64",
+ .id = DISPLAY_ATTR_4_UINT64,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_4_UINT64,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }, {
+ /* Attribute for testing .is_support operation */
+ .name = "DISPLAY_ATTR_INT_IS_SUPPORT_FUNC",
+ .id = DISPLAY_ATTR_INT_IS_SUPPORT_FUNC,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_INT,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ .is_supported = test_display_is_support,
+ },
+ }, {
+ /**
+ * Attribute for testing the .get undertakes what .is_support should have done
+ * when the .is_support operation is not given
+ */
+ .name = "DISPLAY_ATTR_INT_NO_IS_SUPPORT_FUNC",
+ .id = DISPLAY_ATTR_INT_NO_IS_SUPPORT_FUNC,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_INT,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .set = test_display_set,
+ },
+ }, {
+ /**
+ * Attribute for testing not existing .get operation
+ */
+ .name = "DISPLAY_ATTR_INT_NO_GETTER",
+ .id = DISPLAY_ATTR_INT_NO_GETTER,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_INT,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .set = test_display_set,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }, {
+ /**
+ * Attribute for testing not existing .set operation
+ */
+ .name = "DISPLAY_ATTR_INT_NO_SETTER",
+ .id = DISPLAY_ATTR_INT_NO_SETTER,
+ .type = SYSCOMMON_RESMAN_DATA_TYPE_INT,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_ATTR_FLAG_PUBLIC,
+ .ops = {
+ .get = test_display_get,
+ .is_supported = syscommon_resman_resource_attr_supported_always,
+ },
+ }
+};
+
+static const struct syscommon_resman_resource_driver display_resource_driver = {
+ .name = "test-display",
+ .type = TEST_RESOURCE_TYPE_DISPLAY,
+ .flag = SYSCOMMON_RESMAN_RESOURCE_DRIVER_FLAG_COUNT_ONLY_ONE,
+ .attrs = display_attrs,
+ .num_attrs = sizeof(display_attrs)/sizeof(display_attrs[0]),
+ .ops = {
+ .create = display_resource_driver_create,
+ .delete = display_resource_driver_delete,
+ .init = display_resource_driver_init,
+ .exit = display_resource_driver_exit,
+ },
+};
+
+int create_display_resource(void)
+{
+ int resource_id;
+ int ret;
+
+ /**
+ * To successfully create a resource instance of type TEST_RESOURCE_TYPE_DISPLAY,
+ * 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 DISPLAY_ATTR_INT_IS_SUPPORT_FUNC
+ * must success, returning true.
+ * 3. The attribute->ops.get() of the attribuet DISPLAY_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(display_resource_driver_create, 0); /* precondition 1 */
+ will_return(test_display_is_support, true); /* precondition 2 */
+ will_return(test_display_get, 123456); /* precondition 3 */
+ will_return(test_display_get, 0); /* precondition 3 */
+
+ ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_DISPLAY);
+ assert_int_equal(ret, 0);
+
+ return resource_id;
+}
+
+void delete_display_resource(int resource_id)
+{
+ expect_function_call(display_resource_driver_delete);
+ syscommon_resman_delete_resource(resource_id);
+}
+
+void setup_display_resource_driver(void)
+{
+ /**
+ * 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(&display_resource_driver);
+}
+++ /dev/null
-#include <stdio.h>
-#include <stdint.h>
-
-#include <libsyscommon/resource-manager.h>
-#include <libsyscommon/resource-type.h>
-
-#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;
-}
#include <libsyscommon/resource-manager.h>
-#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);
+#include "common-interface.h"
+#include "display-interface.h"
- return resource_id;
-}
-
-static void cleanup_normal_resource(int resource_id)
-{
- expect_function_call(test_driver_delete);
- syscommon_resman_delete_resource(resource_id);
-}
+#include "resource-display.h"
+#include "../test-main.h"
static void test_create_resource_pass(void **state)
{
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);
+ will_return(display_resource_driver_create, 0);
+ /* Set attribute DISPLAY_ATTR_INT_IS_SUPPORT_FUNC's is_support() function to return true */
+ will_return(test_display_is_support, true);
+ /* Set attribute DISPLAY_ATTR_INT_NO_IS_SUPPORT_FUNC's get() function to return 0 */
+ will_return(test_display_get, 121212); /* arbitrary value to be consumed */
+ will_return(test_display_get, 0);
- ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NORMAL_SINGLETON);
+ ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_DISPLAY);
/* 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) {
+ for (unsigned long long i = DISPLAY_ATTR_INT; i < DISPLAY_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);
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:
+ case DISPLAY_ATTR_INT:
+ case DISPLAY_ATTR_INT_IS_SUPPORT_FUNC:
+ case DISPLAY_ATTR_INT_NO_IS_SUPPORT_FUNC:
+ case DISPLAY_ATTR_INT_NO_GETTER:
+ case DISPLAY_ATTR_INT_NO_SETTER:
+ case DISPLAY_ATTR_INT64:
+ case DISPLAY_ATTR_UINT:
+ case DISPLAY_ATTR_UINT64:
+ case DISPLAY_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:
+ case DISPLAY_ATTR_2_UINT64:
+ case DISPLAY_ATTR_3_UINT64:
+ case DISPLAY_ATTR_4_UINT64:
/**
* FIXME: Currently, memory allocation for the above type
* has not been implemented yet. Therefore it must be NULL.
}
/* Check driver->ops.delete() is called on deleting resource */
- expect_function_call(test_driver_delete);
+ expect_function_call(display_resource_driver_delete);
syscommon_resman_delete_resource(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);
+ will_return(display_resource_driver_create, -123);
+ /* Additionally, display_resource_driver_delete() should be called on fail */
+ expect_function_call(display_resource_driver_delete);
- ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NORMAL_SINGLETON);
+ ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_DISPLAY);
assert_int_equal(ret, -123);
}
{
int ret;
- ret = syscommon_resman_create_resource(NULL, TEST_RESOURCE_TYPE_NORMAL_SINGLETON);
+ ret = syscommon_resman_create_resource(NULL, TEST_RESOURCE_TYPE_DISPLAY);
assert_int_equal(ret, -EINVAL);
}
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);
+ will_return(display_resource_driver_create, 0);
+ /* Set attribute DISPLAY_ATTR_INT_IS_SUPPORT_FUNC's is_support() function to return false */
+ will_return(test_display_is_support, false);
+ /* Additionally, display_resource_driver_delete() should be called on fail */
+ expect_function_call(display_resource_driver_delete);
- ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NORMAL_SINGLETON);
+ ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_DISPLAY);
assert_int_equal(ret, -ENOTSUP);
}
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);
+ will_return(display_resource_driver_create, 0);
+ /* Set attribute DISPLAY_ATTR_INT_IS_SUPPORT_FUNC's is_support() function to return true */
+ will_return(test_display_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);
+ will_return(test_display_get, 123123);
+ will_return(test_display_get, -1);
+ /* Additionally, display_resource_driver_delete() should be called on fail */
+ expect_function_call(display_resource_driver_delete);
- ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_NORMAL_SINGLETON);
+ ret = syscommon_resman_create_resource(&resource_id, TEST_RESOURCE_TYPE_DISPLAY);
assert_int_equal(ret, -ENOTSUP);
}
struct syscommon_resman_resource_attribute_value *attr_value;
int ret;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- will_return(test_get, 131313);
- will_return(test_get, 0);
+ will_return(test_display_get, 131313);
+ will_return(test_display_get, 0);
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT, &value);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_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);
+ attr_value = syscommon_resman_get_resource_attr_value(resource_id, DISPLAY_ATTR_INT);
assert_non_null(attr_value);
assert_int_equal(*(int *) attr_value->data, 131313);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_get_resource_attr_int_fail_getter(void **state)
struct syscommon_resman_resource_attribute_value *attr_value;
int ret;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
/* First try, success */
- will_return(test_get, 9494);
- will_return(test_get, 0 /* success */);
+ will_return(test_display_get, 9494);
+ will_return(test_display_get, 0 /* success */);
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT, &value);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_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);
+ attr_value = syscommon_resman_get_resource_attr_value(resource_id, DISPLAY_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 */);
+ will_return(test_display_get, 777777);
+ will_return(test_display_get, -EPIPE /* An error occured */);
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT, &value);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_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);
+ attr_value = syscommon_resman_get_resource_attr_value(resource_id, DISPLAY_ATTR_INT);
assert_non_null(attr_value);
assert_int_equal(*(int *) attr_value->data, 9494);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_get_resource_attr_int_fail_no_getter(void **state)
int value;
int ret;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT_NO_GETTER, &value);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_ATTR_INT_NO_GETTER, &value);
assert_int_equal(ret, -EINVAL);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_get_resource_attr_int_fail_unmatched_type(void **state)
int value;
int ret;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT64, &value);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_ATTR_INT64, &value);
assert_int_equal(ret, -EINVAL);
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_UINT, &value);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_ATTR_UINT, &value);
assert_int_equal(ret, -EINVAL);
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_UINT64, &value);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_ATTR_UINT64, &value);
assert_int_equal(ret, -EINVAL);
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_DOUBLE, &value);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_ATTR_DOUBLE, &value);
assert_int_equal(ret, -EINVAL);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
/* DEFECT: The NULL checking for the third parameter is not being checked */
int resource_id;
int ret;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_INT, NULL /* invalid */);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_ATTR_INT, NULL /* invalid */);
assert_int_equal(ret, -EINVAL);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_get_resource_attr_int_fail_invalid_parameter_2(void **state)
int value;
int ret;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- ret = syscommon_resman_get_resource_attr_int(resource_id, TEST_ATTR_MAX /* invalid */, &value);
+ ret = syscommon_resman_get_resource_attr_int(resource_id, DISPLAY_ATTR_MAX /* invalid */, &value);
assert_int_equal(ret, -EINVAL);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_get_resource_attr_int_fail_invalid_parameter_3(void **state)
int value;
int ret;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- ret = syscommon_resman_get_resource_attr_int(-1 /* invalid */, TEST_ATTR_INT, &value);
+ ret = syscommon_resman_get_resource_attr_int(-1 /* invalid */, DISPLAY_ATTR_INT, &value);
assert_int_equal(ret, -EINVAL);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_set_resource_attr_int_pass(void **state)
int ret;
const int value = 565656;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- expect_memory(test_set, data, &value, sizeof(int));
- will_return(test_set, 0);
+ expect_memory(test_display_set, data, &value, sizeof(int));
+ will_return(test_display_set, 0);
- ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_INT, value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id, DISPLAY_ATTR_INT, value);
assert_int_equal(ret, 0);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_set_resource_attr_int_fail_setter(void **state)
int ret;
const int value = 444888;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- expect_memory(test_set, data, &value, sizeof(int));
- will_return(test_set, -EPIPE /* An error occured */);
+ expect_memory(test_display_set, data, &value, sizeof(int));
+ will_return(test_display_set, -EPIPE /* An error occured */);
- ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_INT, value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id, DISPLAY_ATTR_INT, value);
assert_int_equal(ret, -EPIPE);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_set_resource_attr_int_fail_no_setter(void **state)
int ret;
const int value = 444888;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_INT_NO_SETTER, value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id, DISPLAY_ATTR_INT_NO_SETTER, value);
assert_int_equal(ret, -EINVAL);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_set_resource_attr_int_fail_unmatched_type(void **state)
int ret;
const int value = 9911;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_INT64, value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id, DISPLAY_ATTR_INT64, value);
assert_int_equal(ret, -EINVAL);
- ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_UINT, value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id, DISPLAY_ATTR_UINT, value);
assert_int_equal(ret, -EINVAL);
- ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_UINT64, value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id, DISPLAY_ATTR_UINT64, value);
assert_int_equal(ret, -EINVAL);
- ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_DOUBLE, value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id, DISPLAY_ATTR_DOUBLE, value);
assert_int_equal(ret, -EINVAL);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_set_resource_attr_int_fail_invalid_parameter_1(void **state)
int ret;
const int value = 543210;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
- ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_MAX, value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id, DISPLAY_ATTR_MAX, value);
assert_int_equal(ret, -EINVAL);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
static void test_event_callback1(int resource_type, int resource_id, int attr_id, const void *data, int count)
double double_value = 12.1212;
int ret;
- resource_id1 = setup_normal_resource();
- resource_id2 = setup_normal_resource();
+ resource_id1 = create_display_resource();
+ resource_id2 = create_display_resource();
ret = syscommon_resman_subscribe_resource_event(test_event_callback1, &callback_id1);
assert_int_equal(ret, 0);
/* configure mock setter, success */
- expect_memory(test_set, data, &int_value, sizeof(int));
- will_return(test_set, 0);
+ expect_memory(test_display_set, data, &int_value, sizeof(int));
+ will_return(test_display_set, 0);
/* configure mock callback1 */
- expect_value(test_event_callback1, resource_type, TEST_RESOURCE_TYPE_NORMAL_SINGLETON);
+ expect_value(test_event_callback1, resource_type, TEST_RESOURCE_TYPE_DISPLAY);
expect_value(test_event_callback1, resource_id, resource_id1);
- expect_value(test_event_callback1, attr_id, TEST_ATTR_INT);
+ expect_value(test_event_callback1, attr_id, DISPLAY_ATTR_INT);
expect_memory(test_event_callback1, data, &int_value, sizeof(int));
expect_value(test_event_callback1, count, 1);
- ret = syscommon_resman_set_resource_attr_int(resource_id1, TEST_ATTR_INT, int_value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id1, DISPLAY_ATTR_INT, int_value);
assert_int_equal(ret, 0);
/* register additional callback2 */
assert_int_equal(ret, 0);
/* second try, configure mock setter, success */
- expect_memory(test_set, data, &double_value, sizeof(double));
- will_return(test_set, 0);
+ expect_memory(test_display_set, data, &double_value, sizeof(double));
+ will_return(test_display_set, 0);
/* configure mock callback1 */
- expect_value(test_event_callback1, resource_type, TEST_RESOURCE_TYPE_NORMAL_SINGLETON);
+ expect_value(test_event_callback1, resource_type, TEST_RESOURCE_TYPE_DISPLAY);
expect_value(test_event_callback1, resource_id, resource_id2);
- expect_value(test_event_callback1, attr_id, TEST_ATTR_DOUBLE);
+ expect_value(test_event_callback1, attr_id, DISPLAY_ATTR_DOUBLE);
expect_memory(test_event_callback1, data, &double_value, sizeof(double));
expect_value(test_event_callback1, count, 1);
/* configure mock callback2 */
- expect_value(test_event_callback2, resource_type, TEST_RESOURCE_TYPE_NORMAL_SINGLETON);
+ expect_value(test_event_callback2, resource_type, TEST_RESOURCE_TYPE_DISPLAY);
expect_value(test_event_callback2, resource_id, resource_id2);
- expect_value(test_event_callback2, attr_id, TEST_ATTR_DOUBLE);
+ expect_value(test_event_callback2, attr_id, DISPLAY_ATTR_DOUBLE);
expect_memory(test_event_callback2, data, &double_value, sizeof(double));
expect_value(test_event_callback2, count, 1);
/* set another resource(2), and another attribute(double) */
- ret = syscommon_resman_set_resource_attr_double(resource_id2, TEST_ATTR_DOUBLE, double_value);
+ ret = syscommon_resman_set_resource_attr_double(resource_id2, DISPLAY_ATTR_DOUBLE, double_value);
assert_int_equal(ret, 0);
/* unregister the callback1 */
/* third try, configure mock setter, success */
int_value = 10101;
- expect_memory(test_set, data, &int_value, sizeof(int));
- will_return(test_set, 0);
+ expect_memory(test_display_set, data, &int_value, sizeof(int));
+ will_return(test_display_set, 0);
/* configure only mock callback2 */
- expect_value(test_event_callback2, resource_type, TEST_RESOURCE_TYPE_NORMAL_SINGLETON);
+ expect_value(test_event_callback2, resource_type, TEST_RESOURCE_TYPE_DISPLAY);
expect_value(test_event_callback2, resource_id, resource_id2);
- expect_value(test_event_callback2, attr_id, TEST_ATTR_INT);
+ expect_value(test_event_callback2, attr_id, DISPLAY_ATTR_INT);
expect_memory(test_event_callback2, data, &int_value, sizeof(int));
expect_value(test_event_callback2, count, 1);
- ret = syscommon_resman_set_resource_attr_int(resource_id2, TEST_ATTR_INT, int_value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id2, DISPLAY_ATTR_INT, int_value);
assert_int_equal(ret, 0);
/* unregister the callback2 */
/* the last try, configure mock setter, success */
double_value = 5959.95;
- expect_memory(test_set, data, &double_value, sizeof(double));
- will_return(test_set, 0);
+ expect_memory(test_display_set, data, &double_value, sizeof(double));
+ will_return(test_display_set, 0);
/* neither configure callback1 nor callback2 */
- ret = syscommon_resman_set_resource_attr_double(resource_id1, TEST_ATTR_DOUBLE, double_value);
+ ret = syscommon_resman_set_resource_attr_double(resource_id1, DISPLAY_ATTR_DOUBLE, double_value);
assert_int_equal(ret, 0);
- cleanup_normal_resource(resource_id1);
- cleanup_normal_resource(resource_id2);
+ delete_display_resource(resource_id1);
+ delete_display_resource(resource_id2);
}
static void test_subscribe_event_fail_invalid_parameter_1(void **state)
int ret;
int value = 890890;
- resource_id = setup_normal_resource();
+ resource_id = create_display_resource();
ret = syscommon_resman_subscribe_resource_event(test_event_callback1, &callback_id);
assert_int_equal(ret, 0);
/* configure mock setter, fail */
- expect_memory(test_set, data, &value, sizeof(int));
- will_return(test_set, -ENOENT /* An error occured */);
+ expect_memory(test_display_set, data, &value, sizeof(int));
+ will_return(test_display_set, -ENOENT /* An error occured */);
/* do not configure mock callback. it must not be invoked if setter has failed */
- ret = syscommon_resman_set_resource_attr_int(resource_id, TEST_ATTR_INT, value);
+ ret = syscommon_resman_set_resource_attr_int(resource_id, DISPLAY_ATTR_INT, value);
assert_int_equal(ret, -ENOENT);
syscommon_resman_unsubscribe_resource_event(callback_id);
- cleanup_normal_resource(resource_id);
+ delete_display_resource(resource_id);
}
-extern int setup_resource_test_driver(void **state);
+static int setup_resource_drivers(void **state)
+{
+ setup_display_resource_driver();
+
+ return 0;
+}
static const struct CMUnitTest resource_manager_testsuite[] = {
cmocka_unit_test(test_create_resource_pass),
cmocka_unit_test(test_subscribe_event_fail_invalid_parameter_2),
cmocka_unit_test(test_subscribe_event_fail_setter),
};
-TESTSUITE_FIXTURE(resource_manager_testsuite, resource_driver_test_setup, NULL);
+TESTSUITE_FIXTURE(resource_manager_testsuite, setup_resource_drivers, NULL);
projects / platform / core / system / libsyscommon.git / commitdiff