test: cmocka-memory-cgroup: Add unit test for memory_cgroup getter

Add unit test for memory cgroup getter funtions to check correctness of the function.

Getter functions for memcg_info list:
memory_cgroup_get_memcg_info_name()
memory_cgroup_get_memcg_info_swappiness()
memory_cgroup_get_memcg_info_evfd()
memory_cgroup_get_memcg_info_limit_bytes()
memory_cgroup_get_memcg_info_limit_ratio()
memory_cgroup_get_memcg_info_threshold_mb()
memory_cgroup_get_memcg_info_threshold_leave_mb()

Change-Id: Iaf1831656e0f422e4e168dfd4326d3c0d39bbd31
Signed-off-by: Unsung Lee <unsung.lee@samsung.com>

diff --git a/tests/cmocka-memory-cgroup.c b/tests/cmocka-memory-cgroup.c
index dec7cae35793cbc95de42ecca5c4af2c09a0e2fe..2271a636d464db49c3b984e6ba2affa40cf637a5 100644 (file)
--- a/tests/cmocka-memory-cgroup.c
+++ b/tests/cmocka-memory-cgroup.c
@@ -68,11 +68,185 @@ static void test_memory_cgroup_is_valid_cgroup_type(void **state)
                                RESOURCED_ERROR_INVALID_PARAMETER);
 }
 
+static void test_memory_cgroup_get_memcg_info_name(void **state)
+{
+       int result = 0;
+       char actual_name[PATH_MAX] = {};
+
+       /* Error case: Input argument is NULL */
+       result = memory_cgroup_get_memcg_info_name(MEMCG_ROOT, NULL, sizeof actual_name);
+       assert_int_equal(RESOURCED_ERROR_INVALID_PARAMETER, result);
+
+       /* Error case: Input arugment 'size' is too small */
+       result = memory_cgroup_get_memcg_info_name(MEMCG_ROOT, actual_name, 0);
+       assert_int_equal(RESOURCED_ERROR_INVALID_PARAMETER, result);
+
+       /* Error case: Invalid memory cgroup */
+       result = memory_cgroup_get_memcg_info_name(MEMCG_TOP, actual_name, sizeof actual_name);
+       assert_int_equal(RESOURCED_ERROR_FAIL, result);
+
+       /* Success case */
+       result = memory_cgroup_get_memcg_info_name(MEMCG_ROOT, actual_name, sizeof actual_name);
+       assert_int_equal(RESOURCED_ERROR_NONE, result);
+       assert_string_equal(MEMCG_PATH, actual_name);
+}
+
+static void test_memory_cgroup_get_memcg_info_swappiness(void **state)
+{
+       int result = 0;
+       int swappiness = 0;
+
+       /* Error case: Input argument is NULL */
+       result = memory_cgroup_get_memcg_info_swappiness(MEMCG_ROOT, NULL);
+       assert_int_equal(RESOURCED_ERROR_INVALID_PARAMETER, result);
+
+       /* Error case: Invalid memory cgroup */
+       result = memory_cgroup_get_memcg_info_swappiness(MEMCG_TOP, &swappiness);
+       assert_int_equal(RESOURCED_ERROR_FAIL, result);
+
+       /* Success case */
+       result = memory_cgroup_get_memcg_info_swappiness(MEMCG_ROOT, &swappiness);
+       assert_int_equal(RESOURCED_ERROR_NONE, result);
+       assert_int_equal(0, swappiness);
+}
+
+static void test_memory_cgroup_get_memcg_info_evfd(void **state)
+{
+       int result = 0;
+       int evfd = 0;
+
+       /* Error case: Input argument is NULL */
+       result = memory_cgroup_get_memcg_info_evfd(MEMCG_ROOT, NULL);
+       assert_int_equal(RESOURCED_ERROR_INVALID_PARAMETER, result);
+
+       /* Error case: Invalid memory cgroup */
+       result = memory_cgroup_get_memcg_info_evfd(MEMCG_TOP, &evfd);
+       assert_int_equal(RESOURCED_ERROR_FAIL, result);
+
+       /* Success case */
+       result = memory_cgroup_get_memcg_info_evfd(MEMCG_ROOT, &evfd);
+       assert_int_equal(RESOURCED_ERROR_NONE, result);
+       assert_int_equal(0, evfd);
+}
+
+static void test_memory_cgroup_get_memcg_info_limit_bytes(void **state)
+{
+       int result = 0;
+       uint64_t limit_bytes = 0;
+
+       /* Error case: Input argument is NULL */
+       result = memory_cgroup_get_memcg_info_limit_bytes(MEMCG_ROOT, NULL);
+       assert_int_equal(RESOURCED_ERROR_INVALID_PARAMETER, result);
+
+       /* Error case: Invalid memory cgroup */
+       result = memory_cgroup_get_memcg_info_limit_bytes(MEMCG_TOP, &limit_bytes);
+       assert_int_equal(RESOURCED_ERROR_FAIL, result);
+
+       /* Success case */
+       result = memory_cgroup_get_memcg_info_limit_bytes(MEMCG_ROOT, &limit_bytes);
+       assert_int_equal(RESOURCED_ERROR_NONE, result);
+       assert_true(limit_bytes == 0);
+}
+
+static void test_memory_cgroup_get_memcg_info_limit_ratio(void **state)
+{
+       int result = 0;
+       float limit_ratio = 0.0;
+
+       /* Error case: Input argument is NULL */
+       result = memory_cgroup_get_memcg_info_limit_ratio(MEMCG_ROOT, NULL);
+       assert_int_equal(RESOURCED_ERROR_INVALID_PARAMETER, result);
+
+       /* Error case: Invalid memory cgroup */
+       result = memory_cgroup_get_memcg_info_limit_ratio(MEMCG_TOP, &limit_ratio);
+       assert_int_equal(RESOURCED_ERROR_FAIL, result);
+
+       /* Success case */
+       result = memory_cgroup_get_memcg_info_limit_ratio(MEMCG_ROOT, &limit_ratio);
+       assert_int_equal(RESOURCED_ERROR_NONE, result);
+       assert_true(limit_ratio == 0.0);
+}
+
+static void test_memory_cgroup_get_memcg_info_threshold_mb(void **state)
+{
+       int result = 0;
+       unsigned int threshold_mb = 0;
+
+       /* Error case: Input argument is NULL */
+       result = memory_cgroup_get_memcg_info_threshold_mb(MEMCG_ROOT, MEM_LEVEL_OOM,
+                       NULL);
+       assert_int_equal(RESOURCED_ERROR_INVALID_PARAMETER, result);
+
+       /* Error case: Input arugment 'mem_level' is wrong */
+       result = memory_cgroup_get_memcg_info_threshold_mb(MEMCG_ROOT, MEM_LEVEL_MAX,
+                       &threshold_mb);
+       assert_int_equal(RESOURCED_ERROR_INVALID_PARAMETER, result);
+
+       /* Error case: Invalid memory cgroup */
+       result = memory_cgroup_get_memcg_info_threshold_mb(MEMCG_TOP, MEM_LEVEL_OOM,
+                       &threshold_mb);
+       assert_int_equal(RESOURCED_ERROR_FAIL, result);
+
+       /* Success case */
+       result = memory_cgroup_get_memcg_info_threshold_mb(MEMCG_ROOT, MEM_LEVEL_OOM,
+                       &threshold_mb);
+       assert_int_equal(RESOURCED_ERROR_NONE, result);
+       assert_true(threshold_mb == 0);
+}
+
+static void test_memory_cgroup_get_memcg_info_threshold_leave_mb(void **state)
+{
+       int result = 0;
+       unsigned int threshold_leave_mb = 0;
+
+       /* Error case: Input argument is NULL */
+       result = memory_cgroup_get_memcg_info_threshold_leave_mb(MEMCG_ROOT,
+                       NULL);
+       assert_int_equal(RESOURCED_ERROR_INVALID_PARAMETER, result);
+
+       /* Error case: Invalid memory cgroup */
+       result = memory_cgroup_get_memcg_info_threshold_leave_mb(MEMCG_TOP,
+                       &threshold_leave_mb);
+       assert_int_equal(RESOURCED_ERROR_FAIL, result);
+
+       /* Success case */
+       result = memory_cgroup_get_memcg_info_threshold_leave_mb(MEMCG_ROOT,
+                       &threshold_leave_mb);
+       assert_int_equal(RESOURCED_ERROR_NONE, result);
+       assert_true(threshold_leave_mb == 0);
+
+}
+
 int main(int argc, char* argv[])
 {
        const struct CMUnitTest memory_cgroup_tests[] = {
                cmocka_unit_test(test_memory_cgroup_is_valid_cgroup_type),
+               cmocka_unit_test(test_memory_cgroup_get_memcg_info_name),
+               cmocka_unit_test(test_memory_cgroup_get_memcg_info_swappiness),
+               cmocka_unit_test(test_memory_cgroup_get_memcg_info_evfd),
+               cmocka_unit_test(test_memory_cgroup_get_memcg_info_limit_bytes),
+               cmocka_unit_test(test_memory_cgroup_get_memcg_info_limit_ratio),
+               cmocka_unit_test(test_memory_cgroup_get_memcg_info_threshold_mb),
+               cmocka_unit_test(test_memory_cgroup_get_memcg_info_threshold_leave_mb),
        };
 
+       /**
+        * Init memcg info of the cgroup tree
+        *
+        * Init memcg_info.name:
+        *
+        * MEMCG_ROOT Case: MEMCG_PATH
+        * MEMCG_BACKGROUND_MRU Case: MEMCG_BACKGROUND_MRU_PATH
+        * MEMCG_BACKGROUND_LRU Case: MEMCG_BACKGROUND_LRU_PATH
+        *
+        * Init memcg_info.swappiness: 0
+        * Init memcg_info.evfd: 0
+        * Init memcg_info.limit_bytes: 0
+        * Init memcg_info.limit_ratio: 0.0
+        * Init memcg_info.threshold_mb: 0
+        * Init memcg_info.threshold_leave_mb: 0
+        **/
+       memcg_params_init();
+
        return cmocka_run_group_tests(memory_cgroup_tests, NULL, NULL);
 }