tests/gunit: src: match naming with upstream Linux

Rename local variable 'cgroup' -> 'cgrp' to match upstream Linux Kernel,
across the files under tests/gunit bringing it closer to the Linux
kernel cgroup code.

Signed-off-by: Kamalesh Babulal <kamalesh.babulal@oracle.com>
Signed-off-by: Tom Hromatka <tom.hromatka@oracle.com>

diff --git a/tests/gunit/003-cg_get_cgroups_from_proc_cgroups.cpp b/tests/gunit/003-cg_get_cgroups_from_proc_cgroups.cpp
index e03139f2048741ac5b63cf1c22a0c05795b61b2b..d2b05f26872f674e7519d4032496be8bf470ca3d 100644 (file)
--- a/tests/gunit/003-cg_get_cgroups_from_proc_cgroups.cpp
+++ b/tests/gunit/003-cg_get_cgroups_from_proc_cgroups.cpp
@@ -32,73 +32,67 @@ TEST_F(GetCgroupsFromProcCgroupsTest, ReadSingleLine)
        char contents[] =
                "5:pids:/user.slice/user-1000.slice/session-1.scope\n";
        char *controller_list[LIST_LEN];
-       char *cgroup_list[LIST_LEN];
+       char *cgrp_list[LIST_LEN];
        pid_t pid = 1234;
        int ret, i;
 
        for (i = 0; i < LIST_LEN; i++) {
                controller_list[i] = NULL;
-               cgroup_list[i] = NULL;
+               cgrp_list[i] = NULL;
        }
 
        CreateCgroupProcFile(contents);
 
-       ret = cg_get_cgroups_from_proc_cgroups(pid, cgroup_list,
-                       controller_list, LIST_LEN);
+       ret = cg_get_cgroups_from_proc_cgroups(pid, cgrp_list, controller_list, LIST_LEN);
        ASSERT_EQ(ret, 0);
        ASSERT_STREQ(controller_list[0], "pids");
-       ASSERT_STREQ(cgroup_list[0],
-                    "user.slice/user-1000.slice/session-1.scope");
+       ASSERT_STREQ(cgrp_list[0], "user.slice/user-1000.slice/session-1.scope");
 }
 
 TEST_F(GetCgroupsFromProcCgroupsTest, ReadSingleLine2)
 {
 #undef LIST_LEN
 #define LIST_LEN 1
-       char contents[] =
-               "5:cpu,cpuacct:/\n";
+       char contents[] = "5:cpu,cpuacct:/\n";
        char *controller_list[LIST_LEN];
-       char *cgroup_list[LIST_LEN];
+       char *cgrp_list[LIST_LEN];
        pid_t pid = 1234;
        int ret, i;
 
        for (i = 0; i < LIST_LEN; i++) {
                controller_list[i] = NULL;
-               cgroup_list[i] = NULL;
+               cgrp_list[i] = NULL;
        }
 
        CreateCgroupProcFile(contents);
 
-       ret = cg_get_cgroups_from_proc_cgroups(pid, cgroup_list,
-                       controller_list, LIST_LEN);
+       ret = cg_get_cgroups_from_proc_cgroups(pid, cgrp_list, controller_list, LIST_LEN);
        ASSERT_EQ(ret, 0);
        ASSERT_STREQ(controller_list[0], "cpu,cpuacct");
-       ASSERT_STREQ(cgroup_list[0], "/");
+       ASSERT_STREQ(cgrp_list[0], "/");
 }
 
 TEST_F(GetCgroupsFromProcCgroupsTest, ReadEmptyController)
 {
 #undef LIST_LEN
 #define LIST_LEN 1
-       char contents[] =
-               "0::/user.slice/user-1000.slice/session-1.scope\n";
+       char contents[] = "0::/user.slice/user-1000.slice/session-1.scope\n";
        char *controller_list[LIST_LEN];
-       char *cgroup_list[LIST_LEN];
+       char *cgrp_list[LIST_LEN];
        pid_t pid = 1234;
        int ret, i;
 
        for (i = 0; i < LIST_LEN; i++) {
                controller_list[i] = NULL;
-               cgroup_list[i] = NULL;
+               cgrp_list[i] = NULL;
        }
 
        CreateCgroupProcFile(contents);
 
-       ret = cg_get_cgroups_from_proc_cgroups(pid, cgroup_list,
-                       controller_list, LIST_LEN);
+       ret = cg_get_cgroups_from_proc_cgroups(pid, cgrp_list, controller_list, LIST_LEN);
        ASSERT_EQ(ret, 0);
        ASSERT_EQ(controller_list[0], nullptr);
-       ASSERT_EQ(cgroup_list[0], nullptr);
+       ASSERT_EQ(cgrp_list[0], nullptr);
 }
 
 TEST_F(GetCgroupsFromProcCgroupsTest, ReadExampleFile)
@@ -118,45 +112,44 @@ TEST_F(GetCgroupsFromProcCgroupsTest, ReadExampleFile)
                "1:name=systemd:/user.slice/user-1000.slice/session-1.scope\n"
                "0::/user.slice/user-1000.slice/session-1.scope\n";
        char *controller_list[MAX_MNT_ELEMENTS];
-       char *cgroup_list[MAX_MNT_ELEMENTS];
+       char *cgrp_list[MAX_MNT_ELEMENTS];
        pid_t pid = 5678;
        int ret, i;
 
        for (i = 0; i < MAX_MNT_ELEMENTS; i++) {
                controller_list[i] = NULL;
-               cgroup_list[i] = NULL;
+               cgrp_list[i] = NULL;
        }
 
        CreateCgroupProcFile(contents);
 
-       ret = cg_get_cgroups_from_proc_cgroups(pid, cgroup_list,
-                       controller_list, MAX_MNT_ELEMENTS);
+       ret = cg_get_cgroups_from_proc_cgroups(pid, cgrp_list, controller_list, MAX_MNT_ELEMENTS);
        ASSERT_EQ(ret, 0);
        ASSERT_STREQ(controller_list[0], "memory");
-       ASSERT_STREQ(cgroup_list[0], "user/johndoe/0");
+       ASSERT_STREQ(cgrp_list[0], "user/johndoe/0");
        ASSERT_STREQ(controller_list[1], "perf_event");
-       ASSERT_STREQ(cgroup_list[1], "/");
+       ASSERT_STREQ(cgrp_list[1], "/");
        ASSERT_STREQ(controller_list[2], "rdma");
-       ASSERT_STREQ(cgroup_list[2], "/");
+       ASSERT_STREQ(cgrp_list[2], "/");
        ASSERT_STREQ(controller_list[3], "blkio");
-       ASSERT_STREQ(cgroup_list[3], "user.slice");
+       ASSERT_STREQ(cgrp_list[3], "user.slice");
        ASSERT_STREQ(controller_list[4], "cpu,cpuacct");
-       ASSERT_STREQ(cgroup_list[4], "myCgroup");
+       ASSERT_STREQ(cgrp_list[4], "myCgroup");
        ASSERT_STREQ(controller_list[5], "freezer");
-       ASSERT_STREQ(cgroup_list[5], "user/johndoe/0");
+       ASSERT_STREQ(cgrp_list[5], "user/johndoe/0");
        ASSERT_STREQ(controller_list[6], "net_cls,net_prio");
-       ASSERT_STREQ(cgroup_list[6], "/");
+       ASSERT_STREQ(cgrp_list[6], "/");
        ASSERT_STREQ(controller_list[7], "pids");
-       ASSERT_STREQ(cgroup_list[7], "user.slice/user-1000.slice/session-1.scope");
+       ASSERT_STREQ(cgrp_list[7], "user.slice/user-1000.slice/session-1.scope");
        ASSERT_STREQ(controller_list[8], "devices");
-       ASSERT_STREQ(cgroup_list[8], "user.slice");
+       ASSERT_STREQ(cgrp_list[8], "user.slice");
        ASSERT_STREQ(controller_list[9], "cpuset");
-       ASSERT_STREQ(cgroup_list[9], "/");
+       ASSERT_STREQ(cgrp_list[9], "/");
        ASSERT_STREQ(controller_list[10], "hugetlb");
-       ASSERT_STREQ(cgroup_list[10], "/");
+       ASSERT_STREQ(cgrp_list[10], "/");
        ASSERT_STREQ(controller_list[11], "name=systemd");
-       ASSERT_STREQ(cgroup_list[11], "user.slice/user-1000.slice/session-1.scope");
+       ASSERT_STREQ(cgrp_list[11], "user.slice/user-1000.slice/session-1.scope");
 
        ASSERT_EQ(controller_list[12], nullptr);
-       ASSERT_EQ(cgroup_list[12], nullptr);
+       ASSERT_EQ(cgrp_list[12], nullptr);
 }

diff --git a/tests/gunit/006-cgroup_get_cgroup.cpp b/tests/gunit/006-cgroup_get_cgroup.cpp
index 30155f487bddec4db0befa4297c486b2c7dafd06..e1ff67ca0a732f3af7c406e905e5d3cc643bdef2 100644 (file)
--- a/tests/gunit/006-cgroup_get_cgroup.cpp
+++ b/tests/gunit/006-cgroup_get_cgroup.cpp
@@ -113,8 +113,7 @@ class CgroupGetCgroupTest : public ::testing::Test {
                memset(&cg_namespace_table, 0, sizeof(cg_namespace_table));
 
                for (i = 0; i < CONTROLLERS_CNT; i++) {
-                       snprintf(cg_mount_table[i].name, CONTROL_NAMELEN_MAX,
-                                "%s", CONTROLLERS[i]);
+                       snprintf(cg_mount_table[i].name, CONTROL_NAMELEN_MAX, "%s", CONTROLLERS[i]);
                        snprintf(cg_mount_table[i].mount.path, FILENAME_MAX,
                                 "%s/%s", PARENT_DIR, CONTROLLERS[i]);
                        cg_mount_table[i].version = CGROUP_V1;
@@ -162,29 +161,29 @@ class CgroupGetCgroupTest : public ::testing::Test {
        }
 };
 
-static void vectorize_cg(const struct cgroup * const cg,
-                        vector<string>& cg_vec)
+static void vectorize_cgrp(const struct cgroup * const cgrp,
+                        vector<string>& cgrp_vec)
 {
        int i, j;
 
-       for (i = 0; i < cg->index; i++) {
-               for (j = 0; j < cg->controller[i]->index; j++) {
-                       string cgname(cg->name);
-                       string cgcname(cg->controller[i]->name);
-                       string name(cg->controller[i]->values[j]->name);
-                       string value(cg->controller[i]->values[j]->value);
+       for (i = 0; i < cgrp->index; i++) {
+               for (j = 0; j < cgrp->controller[i]->index; j++) {
+                       string cgrp_name(cgrp->name);
+                       string cgrp_cname(cgrp->controller[i]->name);
+                       string name(cgrp->controller[i]->values[j]->name);
+                       string value(cgrp->controller[i]->values[j]->value);
 
-                       cg_vec.push_back(cgcname + "+" + cgname + "+" +
+                       cgrp_vec.push_back(cgrp_cname + "+" + cgrp_name + "+" +
                                         name + "+" + value);
                }
        }
 
-       sort(cg_vec.begin(), cg_vec.end());
+       sort(cgrp_vec.begin(), cgrp_vec.end());
 }
 
 static void vectorize_testdata(vector<string>& test_vec)
 {
-       string cgname(CG_NAME);
+       string cgrp_name(CG_NAME);
        int i, j;
 
        for (i = 0; i < CTRL_CNT; i++) {
@@ -199,12 +198,11 @@ static void vectorize_testdata(vector<string>& test_vec)
                                 */
                                continue;
 
-                       string cgcname(CONTROLLERS[i]);
+                       string cgrp_cname(CONTROLLERS[i]);
                        string name(NAMES[i][j]);
                        string value(VALUES[i][j]);
 
-                       test_vec.push_back(cgcname + "+" + cgname + "+" +
-                                          name + "+" + value);
+                       test_vec.push_back(cgrp_cname + "+" + cgrp_name + "+" + name + "+" + value);
                }
        }
 
@@ -213,23 +211,23 @@ static void vectorize_testdata(vector<string>& test_vec)
 
 TEST_F(CgroupGetCgroupTest, CgroupGetCgroup1)
 {
-       vector<string> cg_vec, test_vec;
-       struct cgroup *cg = NULL;
+       vector<string> cgrp_vec, test_vec;
+       struct cgroup *cgrp = NULL;
        int ret;
 
-       cg = cgroup_new_cgroup(CG_NAME);
-       ASSERT_NE(cg, nullptr);
+       cgrp = cgroup_new_cgroup(CG_NAME);
+       ASSERT_NE(cgrp, nullptr);
 
-       ret = cgroup_get_cgroup(cg);
+       ret = cgroup_get_cgroup(cgrp);
        ASSERT_EQ(ret, 0);
 
-       vectorize_cg(cg, cg_vec);
+       vectorize_cgrp(cgrp, cgrp_vec);
        vectorize_testdata(test_vec);
 
-       ASSERT_EQ(cg_vec, test_vec);
+       ASSERT_EQ(cgrp_vec, test_vec);
 
-       if (cg)
-               free(cg);
+       if (cgrp)
+               free(cgrp);
 }
 
 /*
@@ -238,7 +236,7 @@ TEST_F(CgroupGetCgroupTest, CgroupGetCgroup1)
 TEST_F(CgroupGetCgroupTest, CgroupGetCgroup_NoTasksFile)
 {
        char tmp_path[FILENAME_MAX];
-       struct cgroup *cg = NULL;
+       struct cgroup *cgrp = NULL;
        int ret;
 
        snprintf(tmp_path, FILENAME_MAX - 1, "%s/%s/%s/tasks",
@@ -246,12 +244,12 @@ TEST_F(CgroupGetCgroupTest, CgroupGetCgroup_NoTasksFile)
        ret = rmrf(tmp_path);
        ASSERT_EQ(ret, 0);
 
-       cg = cgroup_new_cgroup(CG_NAME);
-       ASSERT_NE(cg, nullptr);
+       cgrp = cgroup_new_cgroup(CG_NAME);
+       ASSERT_NE(cgrp, nullptr);
 
-       ret = cgroup_get_cgroup(cg);
+       ret = cgroup_get_cgroup(cgrp);
        ASSERT_EQ(ret, ECGOTHER);
 
-       if (cg)
-               free(cg);
+       if (cgrp)
+               free(cgrp);
 }

diff --git a/tests/gunit/012-cgroup_create_cgroup.cpp b/tests/gunit/012-cgroup_create_cgroup.cpp
index c06bb3a4cd677e26be8eb7195a34a3b76f927551..5e723376a5c3b1717eaac144cb80be8c1adb6b3a 100644 (file)
--- a/tests/gunit/012-cgroup_create_cgroup.cpp
+++ b/tests/gunit/012-cgroup_create_cgroup.cpp
@@ -57,15 +57,13 @@ class CgroupCreateCgroupTest : public ::testing::Test {
                memset(&cg_namespace_table, 0, sizeof(cg_namespace_table));
 
                for (i = 0; i < CONTROLLERS_CNT; i++) {
-                       snprintf(cg_mount_table[i].name, CONTROL_NAMELEN_MAX,
-                                "%s", CONTROLLERS[i]);
+                       snprintf(cg_mount_table[i].name, CONTROL_NAMELEN_MAX, "%s", CONTROLLERS[i]);
                        cg_mount_table[i].version = VERSIONS[i];
 
                        switch (VERSIONS[i]) {
                        case CGROUP_V1:
                                snprintf(cg_mount_table[i].mount.path,
-                                        FILENAME_MAX, "%s/%s", PARENT_DIR,
-                                        CONTROLLERS[i]);
+                                        FILENAME_MAX, "%s/%s", PARENT_DIR, CONTROLLERS[i]);
 
                                ret = mkdir(cg_mount_table[i].mount.path, MODE);
                                ASSERT_EQ(ret, 0);
@@ -75,8 +73,7 @@ class CgroupCreateCgroupTest : public ::testing::Test {
                                         FILENAME_MAX, "%s", PARENT_DIR);
 
                                memset(tmp_path, 0, sizeof(tmp_path));
-                               snprintf(tmp_path, FILENAME_MAX - 1,
-                                        "%s/cgroup.subtree_control",
+                               snprintf(tmp_path, FILENAME_MAX - 1, "%s/cgroup.subtree_control",
                                         PARENT_DIR);
 
                                f = fopen(tmp_path, "w");
@@ -123,8 +120,7 @@ class CgroupCreateCgroupTest : public ::testing::Test {
        }
 };
 
-static void verify_cgroup_created(const char * const cg_name,
-                                 const char * const ctrl)
+static void verify_cgroup_created(const char * const cgrp_name, const char * const ctrl)
 {
        char tmp_path[FILENAME_MAX];
        DIR *dir;
@@ -132,11 +128,9 @@ static void verify_cgroup_created(const char * const cg_name,
        memset(tmp_path, 0, sizeof(tmp_path));
 
        if (ctrl)
-               snprintf(tmp_path, FILENAME_MAX - 1, "%s/%s/%s",
-                        PARENT_DIR, ctrl, cg_name);
+               snprintf(tmp_path, FILENAME_MAX - 1, "%s/%s/%s", PARENT_DIR, ctrl, cgrp_name);
        else
-               snprintf(tmp_path, FILENAME_MAX - 1, "%s/%s",
-                        PARENT_DIR, cg_name);
+               snprintf(tmp_path, FILENAME_MAX - 1, "%s/%s", PARENT_DIR, cgrp_name);
 
        dir = opendir(tmp_path);
        ASSERT_NE(dir, nullptr);
@@ -149,8 +143,7 @@ static void verify_subtree_contents(const char * const expected)
        FILE *f;
 
        memset(tmp_path, 0, sizeof(tmp_path));
-       snprintf(tmp_path, FILENAME_MAX - 1, "%s/cgroup.subtree_control",
-                PARENT_DIR);
+       snprintf(tmp_path, FILENAME_MAX - 1, "%s/cgroup.subtree_control", PARENT_DIR);
        f = fopen(tmp_path, "r");
        ASSERT_NE(f, nullptr);
 
@@ -161,67 +154,67 @@ static void verify_subtree_contents(const char * const expected)
 
 TEST_F(CgroupCreateCgroupTest, CgroupCreateCgroupV1)
 {
-       struct cgroup_controller *ctrl;
-       struct cgroup *cg = NULL;
+       const char * const cgrp_name = "MyV1Cgroup";
        const char * const ctrl_name = "cpu";
-       const char * const cg_name = "MyV1Cgroup";
+       struct cgroup_controller *ctrl;
+       struct cgroup *cgrp = NULL;
        int ret;
 
-       cg = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cg, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       ctrl = cgroup_add_controller(cg, ctrl_name);
+       ctrl = cgroup_add_controller(cgrp, ctrl_name);
        ASSERT_NE(ctrl, nullptr);
 
-       ret = cgroup_create_cgroup(cg, 1);
+       ret = cgroup_create_cgroup(cgrp, 1);
        ASSERT_EQ(ret, 0);
 
-       verify_cgroup_created(cg_name, ctrl_name);
+       verify_cgroup_created(cgrp_name, ctrl_name);
 }
 
 TEST_F(CgroupCreateCgroupTest, CgroupCreateCgroupV2)
 {
-       struct cgroup_controller *ctrl;
-       struct cgroup *cg = NULL;
+       const char * const cgrp_name = "MyV2Cgroup";
        const char * const ctrl_name = "freezer";
-       const char * const cg_name = "MyV2Cgroup";
+       struct cgroup_controller *ctrl;
+       struct cgroup *cgrp = NULL;
        int ret;
 
-       cg = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cg, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       ctrl = cgroup_add_controller(cg, ctrl_name);
+       ctrl = cgroup_add_controller(cgrp, ctrl_name);
        ASSERT_NE(ctrl, nullptr);
 
-       ret = cgroup_create_cgroup(cg, 0);
+       ret = cgroup_create_cgroup(cgrp, 0);
        ASSERT_EQ(ret, 0);
 
-       verify_cgroup_created(cg_name, NULL);
+       verify_cgroup_created(cgrp_name, NULL);
        verify_subtree_contents("+freezer");
 }
 
 TEST_F(CgroupCreateCgroupTest, CgroupCreateCgroupV1AndV2)
 {
-       struct cgroup_controller *ctrl;
-       struct cgroup *cg = NULL;
+       const char * const cgrp_name = "MyV1AndV2Cgroup";
        const char * const ctrl1_name = "memory";
        const char * const ctrl2_name = "cpuset";
-       const char * const cg_name = "MyV1AndV2Cgroup";
+       struct cgroup_controller *ctrl;
+       struct cgroup *cgrp = NULL;
        int ret;
 
-       cg = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cg, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       ctrl = cgroup_add_controller(cg, ctrl1_name);
+       ctrl = cgroup_add_controller(cgrp, ctrl1_name);
        ASSERT_NE(ctrl, nullptr);
        ctrl = NULL;
-       ctrl = cgroup_add_controller(cg, ctrl2_name);
+       ctrl = cgroup_add_controller(cgrp, ctrl2_name);
        ASSERT_NE(ctrl, nullptr);
 
-       ret = cgroup_create_cgroup(cg, 1);
+       ret = cgroup_create_cgroup(cgrp, 1);
        ASSERT_EQ(ret, 0);
 
-       verify_cgroup_created(cg_name, NULL);
-       verify_cgroup_created(cg_name, ctrl2_name);
+       verify_cgroup_created(cgrp_name, NULL);
+       verify_cgroup_created(cgrp_name, ctrl2_name);
        verify_subtree_contents("+memory");
 }

diff --git a/tests/gunit/013-cgroup_build_tasks_procs_path.cpp b/tests/gunit/013-cgroup_build_tasks_procs_path.cpp
index 59d82c9b631df1551c82a26f128aedb9da832364..87b00e5e41b150bb0262bc94742f788993c5a219 100644 (file)
--- a/tests/gunit/013-cgroup_build_tasks_procs_path.cpp
+++ b/tests/gunit/013-cgroup_build_tasks_procs_path.cpp
@@ -39,13 +39,11 @@ class BuildTasksProcPathTest : public ::testing::Test {
                int i, ret;
 
                memset(&cg_mount_table, 0, sizeof(cg_mount_table));
-               memset(cg_namespace_table, 0,
-                       CG_CONTROLLER_MAX * sizeof(cg_namespace_table[0]));
+               memset(cg_namespace_table, 0, CG_CONTROLLER_MAX * sizeof(cg_namespace_table[0]));
 
                // Populate the mount table
                for (i = 0; i < ENTRY_CNT; i++) {
-                       snprintf(cg_mount_table[i].name, CONTROL_NAMELEN_MAX,
-                                "controller%d", i);
+                       snprintf(cg_mount_table[i].name, CONTROL_NAMELEN_MAX, "controller%d", i);
                        cg_mount_table[i].index = i;
 
                        ret = snprintf(cg_mount_table[i].mount.path, FILENAME_MAX,
@@ -57,8 +55,7 @@ class BuildTasksProcPathTest : public ::testing::Test {
                        if (i == 0)
                                cg_mount_table[i].version = CGROUP_UNK;
                        else
-                               cg_mount_table[i].version =
-                                       (cg_version_t)((i % 2) + 1);
+                               cg_mount_table[i].version = (cg_version_t)((i % 2) + 1);
                }
 
                // Give a couple of the entries a namespace as well
@@ -70,12 +67,11 @@ class BuildTasksProcPathTest : public ::testing::Test {
 TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_ControllerNotFound)
 {
        char ctrlname[] = "InvalidCtrlr";
+       char cgrp_name[] = "foo";
        char path[FILENAME_MAX];
-       char cgname[] = "foo";
        int ret;
 
-       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgname,
-                                           ctrlname);
+       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgrp_name, ctrlname);
        ASSERT_EQ(ret, ECGOTHER);
        ASSERT_STREQ(path, "\0");
 }
@@ -83,12 +79,11 @@ TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_ControllerNotFound)
 TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_UnknownCgVersion)
 {
        char ctrlname[] = "controller0";
+       char cgrp_name[] = "bar";
        char path[FILENAME_MAX];
-       char cgname[] = "bar";
        int ret;
 
-       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgname,
-                                           ctrlname);
+       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgrp_name, ctrlname);
        ASSERT_EQ(ret, ECGOTHER);
        ASSERT_STREQ(path, "\0");
 }
@@ -96,11 +91,11 @@ TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_UnknownCgVersion)
 TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_CgV1)
 {
        char ctrlname[] = "controller2";
+       char cgrp_name[] = "Container7";
        char path[FILENAME_MAX];
-       char cgname[] = "Container7";
        int ret;
 
-       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgname,
+       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgrp_name,
                                            ctrlname);
        ASSERT_EQ(ret, 0);
        ASSERT_STREQ(path, "/sys/fs/cgroup/controller2/Container7/tasks");
@@ -109,11 +104,11 @@ TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_CgV1)
 TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_CgV2)
 {
        char ctrlname[] = "controller3";
+       char cgrp_name[] = "tomcat";
        char path[FILENAME_MAX];
-       char cgname[] = "tomcat";
        int ret;
 
-       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgname,
+       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgrp_name,
                                            ctrlname);
        ASSERT_EQ(ret, 0);
        ASSERT_STREQ(path, "/sys/fs/cgroup/controller3/tomcat/cgroup.procs");
@@ -122,11 +117,11 @@ TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_CgV2)
 TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_CgV1WithNs)
 {
        char ctrlname[] = "controller4";
+       char cgrp_name[] = "database12";
        char path[FILENAME_MAX];
-       char cgname[] = "database12";
        int ret;
 
-       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgname,
+       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgrp_name,
                                            ctrlname);
        ASSERT_EQ(ret, 0);
        ASSERT_STREQ(path, "/sys/fs/cgroup/controller4/ns4/database12/tasks");
@@ -135,11 +130,11 @@ TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_CgV1WithNs)
 TEST_F(BuildTasksProcPathTest, BuildTasksProcPathTest_CgV2WithNs)
 {
        char ctrlname[] = "controller1";
+       char cgrp_name[] = "server";
        char path[FILENAME_MAX];
-       char cgname[] = "server";
        int ret;
 
-       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgname,
+       ret = cgroup_build_tasks_procs_path(path, sizeof(path), cgrp_name,
                                            ctrlname);
        ASSERT_EQ(ret, 0);
        ASSERT_STREQ(path, "/sys/fs/cgroup/controller1/ns1/server/cgroup.procs");

diff --git a/tests/gunit/015-cgroupv2_controller_enabled.cpp b/tests/gunit/015-cgroupv2_controller_enabled.cpp
index 16619c24657a056b8869d72c3eb3898b9aed05d9..85e18b13c6942bf9fc2ba82a8dc0eab207de7534 100644 (file)
--- a/tests/gunit/015-cgroupv2_controller_enabled.cpp
+++ b/tests/gunit/015-cgroupv2_controller_enabled.cpp
@@ -55,8 +55,7 @@ class CgroupV2ControllerEnabled : public ::testing::Test {
                int ret;
 
                /* create the directory */
-               snprintf(tmp_path, FILENAME_MAX - 1, "%s/%s",
-                        PARENT_DIR, dirname);
+               snprintf(tmp_path, FILENAME_MAX - 1, "%s/%s", PARENT_DIR, dirname);
                ret = mkdir(tmp_path, MODE);
                ASSERT_EQ(ret, 0);
        }
@@ -69,8 +68,7 @@ class CgroupV2ControllerEnabled : public ::testing::Test {
 
                ASSERT_EQ(VERSIONS_CNT, CONTROLLERS_CNT);
 
-               snprintf(tmp_path, FILENAME_MAX - 1,
-                        "%s/cgroup.subtree_control", PARENT_DIR);
+               snprintf(tmp_path, FILENAME_MAX - 1, "%s/cgroup.subtree_control", PARENT_DIR);
 
                f = fopen(tmp_path, "w");
                ASSERT_NE(f, nullptr);
@@ -85,10 +83,8 @@ class CgroupV2ControllerEnabled : public ::testing::Test {
                memset(&cg_namespace_table, 0, sizeof(cg_namespace_table));
 
                for (i = 0; i < CONTROLLERS_CNT; i++) {
-                       snprintf(cg_mount_table[i].name, CONTROL_NAMELEN_MAX,
-                                "%s", CONTROLLERS[i]);
-                       snprintf(cg_mount_table[i].mount.path, FILENAME_MAX,
-                                "%s", PARENT_DIR);
+                       snprintf(cg_mount_table[i].name, CONTROL_NAMELEN_MAX, "%s", CONTROLLERS[i]);
+                       snprintf(cg_mount_table[i].mount.path, FILENAME_MAX, "%s", PARENT_DIR);
                        cg_mount_table[i].version = VERSIONS[i];
                }
        }
@@ -132,30 +128,30 @@ class CgroupV2ControllerEnabled : public ::testing::Test {
 TEST_F(CgroupV2ControllerEnabled, CgroupV1Controller)
 {
        char ctrlr_name[] = "cpuset";
-       char cg_name[] = "foo";
+       char cgrp_name[] = "foo";
        int ret;
 
-       ret = cgroupv2_controller_enabled(cg_name, ctrlr_name);
+       ret = cgroupv2_controller_enabled(cgrp_name, ctrlr_name);
        ASSERT_EQ(ret, 0);
 }
 
 TEST_F(CgroupV2ControllerEnabled, RootCgroup)
 {
        char ctrlr_name[] = "cpu";
-       char cg_name[] = "/";
+       char cgrp_name[] = "/";
        int ret;
 
-       ret = cgroupv2_controller_enabled(cg_name, ctrlr_name);
+       ret = cgroupv2_controller_enabled(cgrp_name, ctrlr_name);
        ASSERT_EQ(ret, 0);
 }
 
 TEST_F(CgroupV2ControllerEnabled, ControllerEnabled)
 {
        char ctrlr_name[] = "pids";
-       char cg_name[] = "test3-ctrlrenabled";
+       char cgrp_name[] = "test3-ctrlrenabled";
        int ret;
 
-       ret = cgroupv2_controller_enabled(cg_name, ctrlr_name);
+       ret = cgroupv2_controller_enabled(cgrp_name, ctrlr_name);
        ASSERT_EQ(ret, 0);
 }
 

diff --git a/tests/gunit/017-API_fuzz_test.cpp b/tests/gunit/017-API_fuzz_test.cpp
index 49a80ba5a34c692989ac15869ec07cd75e7172ca..ecab25198e5bef2ca18ce0d72657f9b180cba7fc 100644 (file)
--- a/tests/gunit/017-API_fuzz_test.cpp
+++ b/tests/gunit/017-API_fuzz_test.cpp
@@ -31,7 +31,7 @@ class APIArgsTest: public :: testing:: Test {
 TEST_F(APIArgsTest, API_cgroup_set_permissions)
 {
        mode_t dir_mode, ctrl_mode, task_mode;
-       struct cgroup * cgroup = NULL;
+       struct cgroup * cgrp = NULL;
 
        dir_mode = (S_IRWXU | S_IXGRP | S_IXOTH);
        ctrl_mode = (S_IRUSR | S_IWUSR | S_IRGRP);
@@ -39,7 +39,7 @@ TEST_F(APIArgsTest, API_cgroup_set_permissions)
 
        testing::internal::CaptureStdout();
 
-       cgroup_set_permissions(cgroup, dir_mode, ctrl_mode, task_mode);
+       cgroup_set_permissions(cgrp, dir_mode, ctrl_mode, task_mode);
 
        std::string result = testing::internal::GetCapturedStdout();
        ASSERT_EQ(result, "Error: Cgroup, operation not allowed\n");
@@ -55,11 +55,11 @@ TEST_F(APIArgsTest, API_cgroup_set_permissions)
  */
 TEST_F(APIArgsTest, API_cgroup_new_cgroup)
 {
-       struct cgroup *cgroup = NULL;
+       struct cgroup *cgrp = NULL;
        char *name = NULL;
 
-       cgroup = cgroup_new_cgroup(name);
-       ASSERT_EQ(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(name);
+       ASSERT_EQ(cgrp, nullptr);
 }
 
 /**
@@ -73,11 +73,11 @@ TEST_F(APIArgsTest, API_cgroup_new_cgroup)
  */
 TEST_F(APIArgsTest, API_cgroup_set_value_string)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        struct cgroup_controller * cgc = NULL;
-       const char * const cg_ctrl = "cpu";
+       const char * const cgrp_ctrl = "cpu";
        char * name = NULL, *value = NULL;
-       struct cgroup *cgroup = NULL;
+       struct cgroup *cgrp = NULL;
        int ret;
 
        // case 1
@@ -85,11 +85,11 @@ TEST_F(APIArgsTest, API_cgroup_set_value_string)
        ret = cgroup_set_value_string(cgc, name, value);
        ASSERT_EQ(ret, 50011);
 
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
-       ASSERT_NE(cgroup, nullptr);
+       cgc = cgroup_add_controller(cgrp, cgrp_ctrl);
+       ASSERT_NE(cgrp, nullptr);
 
        // case 2
        // cgc = valid, name = NULL, value = NULL
@@ -129,11 +129,11 @@ TEST_F(APIArgsTest, API_cgroup_set_value_string)
  */
 TEST_F(APIArgsTest, API_cgroup_get_value_string)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        struct cgroup_controller * cgc = NULL;
-       const char * const cg_ctrl = "cpu";
+       const char * const cgrp_ctrl = "cpu";
        char *name = NULL, *value = NULL;
-       struct cgroup *cgroup = NULL;
+       struct cgroup *cgrp = NULL;
        int ret;
 
        // case 1
@@ -141,11 +141,11 @@ TEST_F(APIArgsTest, API_cgroup_get_value_string)
        ret = cgroup_get_value_string(cgc, name, NULL);
        ASSERT_EQ(ret, 50011);
 
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
-       ASSERT_NE(cgroup, nullptr);
+       cgc = cgroup_add_controller(cgrp, cgrp_ctrl);
+       ASSERT_NE(cgrp, nullptr);
 
        // case 2
        // cgc = valid, name = NULL, value = NULL
@@ -182,31 +182,31 @@ TEST_F(APIArgsTest, API_cgroup_get_value_string)
  */
 TEST_F(APIArgsTest, API_cgroup_add_controller)
 {
-       const char * const cg_name = "FuzzerCgroup";
-       const char * const cg_ctrl = "cpu";
-       const char * const new_cg_ctrl = NULL;
+       const char * const cgrp_name = "FuzzerCgroup";
+       const char * const cgrp_ctrl = "cpu";
+       const char * const new_cgrp_ctrl = NULL;
        struct cgroup_controller *cgc = NULL;
        struct cgroup *cgroup = NULL;
 
        // case 1
        // cgrp = NULL, name = NULL
-       cgc = cgroup_add_controller(cgroup, new_cg_ctrl);
+       cgc = cgroup_add_controller(cgroup, new_cgrp_ctrl);
        ASSERT_EQ(cgroup, nullptr);
 
        // case 2
        // cgrp = NULL, name = valid
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
+       cgc = cgroup_add_controller(cgroup, cgrp_ctrl);
        ASSERT_EQ(cgroup, nullptr);
 
-       cgroup = cgroup_new_cgroup(cg_name);
+       cgroup = cgroup_new_cgroup(cgrp_name);
        ASSERT_NE(cgroup, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
+       cgc = cgroup_add_controller(cgroup, cgrp_ctrl);
        ASSERT_NE(cgroup, nullptr);
 
        // case 3
        // cgrp = valid, name = NULL
-       cgc = cgroup_add_controller(cgroup, new_cg_ctrl);
+       cgc = cgroup_add_controller(cgroup, new_cgrp_ctrl);
        ASSERT_EQ(cgc, nullptr);
 }
 
@@ -221,10 +221,10 @@ TEST_F(APIArgsTest, API_cgroup_add_controller)
  */
 TEST_F(APIArgsTest, API_cgroup_add_value_string)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        struct cgroup_controller *cgc = NULL;
-       const char * const cg_ctrl = "cpu";
-       struct cgroup *cgroup = NULL;
+       const char * const cgrp_ctrl = "cpu";
+       struct cgroup *cgrp = NULL;
        char * ctrl_value = NULL;
        char * ctrl_name = NULL;
        int ret;
@@ -236,11 +236,11 @@ TEST_F(APIArgsTest, API_cgroup_add_value_string)
 
        // case 2
        // cgc = valid, name = NULL, value = NULL
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
-       ASSERT_NE(cgroup, nullptr);
+       cgc = cgroup_add_controller(cgrp, cgrp_ctrl);
+       ASSERT_NE(cgrp, nullptr);
 
        ret = cgroup_add_value_string(cgc, ctrl_name, ctrl_value);
        ASSERT_EQ(ret, 50011);
@@ -269,49 +269,49 @@ TEST_F(APIArgsTest, API_cgroup_add_value_string)
 
 TEST_F(APIArgsTest, API_cgroup_get_uid_gid)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        uid_t tasks_uid, control_uid;
        gid_t tasks_gid, control_gid;
 
-       struct cgroup *cgroup = NULL;
+       struct cgroup *cgrp = NULL;
        int ret;
        // case 1
        // cgroup = NULL, tasks_uid = NULL, tasks_gid = NULL, control_uid = NULL,
        // control_uid = NULL
-       ret = cgroup_get_uid_gid(cgroup, NULL, NULL, NULL, NULL);
+       ret = cgroup_get_uid_gid(cgrp, NULL, NULL, NULL, NULL);
        ASSERT_EQ(ret, 50011);
 
        // case 2
        // cgroup = valid, tasks_uid = NULL, tasks_gid = NULL, control_uid = NULL,
        // control_uid = NULL
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       ret = cgroup_get_uid_gid(cgroup, NULL, NULL, NULL, NULL);
+       ret = cgroup_get_uid_gid(cgrp, NULL, NULL, NULL, NULL);
        ASSERT_EQ(ret, 50011);
 
        // case 3
        // cgroup = valid, tasks_uid = valid, tasks_gid = NULL, control_uid = NULL,
        // control_uid = NULL
-       ret = cgroup_get_uid_gid(cgroup, &tasks_uid, NULL, NULL, NULL);
+       ret = cgroup_get_uid_gid(cgrp, &tasks_uid, NULL, NULL, NULL);
        ASSERT_EQ(ret, 50011);
 
        // case 4
        // cgroup = valid, tasks_uid = valid, tasks_gid = valid, control_uid = NULL,
        // control_uid = NULL
-       ret = cgroup_get_uid_gid(cgroup, &tasks_uid, &tasks_gid, NULL, NULL);
+       ret = cgroup_get_uid_gid(cgrp, &tasks_uid, &tasks_gid, NULL, NULL);
        ASSERT_EQ(ret, 50011);
 
        // case 5
        // cgroup = valid, tasks_uid = valid, tasks_gid = valid, control_uid = valid,
        // control_uid = NULL
-       ret = cgroup_get_uid_gid(cgroup, &tasks_uid, &tasks_gid, &control_uid, NULL);
+       ret = cgroup_get_uid_gid(cgrp, &tasks_uid, &tasks_gid, &control_uid, NULL);
        ASSERT_EQ(ret, 50011);
 
        // case 6
        // cgroup = valid, tasks_uid = valid, tasks_gid = valid, control_uid = valid,
        // control_uid = valid
-       ret = cgroup_get_uid_gid(cgroup, &tasks_uid, &tasks_gid, &control_uid, &control_gid);
+       ret = cgroup_get_uid_gid(cgrp, &tasks_uid, &tasks_gid, &control_uid, &control_gid);
        ASSERT_EQ(ret, 0);
 }
 
@@ -326,10 +326,10 @@ TEST_F(APIArgsTest, API_cgroup_get_uid_gid)
  */
 TEST_F(APIArgsTest, API_cgroup_set_value_int64)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        struct cgroup_controller * cgc = NULL;
-       const char * const cg_ctrl = "cpu";
-       struct cgroup *cgroup = NULL;
+       const char * const cgrp_ctrl = "cpu";
+       struct cgroup *cgrp = NULL;
        int64_t value = 1024;
        char * name = NULL;
        int ret;
@@ -341,11 +341,11 @@ TEST_F(APIArgsTest, API_cgroup_set_value_int64)
 
        // case 2
        // cgc = valid, name = NULL, value = valid
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
-       ASSERT_NE(cgroup, nullptr);
+       cgc = cgroup_add_controller(cgrp, cgrp_ctrl);
+       ASSERT_NE(cgrp, nullptr);
 
        // set cpu.shares, so that cgc->index > 0
        ret = cgroup_set_value_int64(cgc, "cpu.shares", 1024);
@@ -381,10 +381,10 @@ TEST_F(APIArgsTest, API_cgroup_set_value_int64)
  */
 TEST_F(APIArgsTest, API_cgroup_get_value_int64)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        struct cgroup_controller * cgc = NULL;
-       const char * const cg_ctrl = "cpu";
-       struct cgroup *cgroup = NULL;
+       const char * const cgrp_ctrl = "cpu";
+       struct cgroup *cgrp = NULL;
        char * name = NULL;
        int64_t value;
        int ret;
@@ -396,11 +396,11 @@ TEST_F(APIArgsTest, API_cgroup_get_value_int64)
 
        // case 2
        // cgc = valid, name = NULL, value = NULL
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
-       ASSERT_NE(cgroup, nullptr);
+       cgc = cgroup_add_controller(cgrp, cgrp_ctrl);
+       ASSERT_NE(cgrp, nullptr);
 
        // set cpu.shares, so that cgc->index > 0
        ret = cgroup_set_value_int64(cgc, "cpu.shares", 1024);
@@ -437,10 +437,10 @@ TEST_F(APIArgsTest, API_cgroup_get_value_int64)
  */
 TEST_F(APIArgsTest, API_cgroup_set_value_uint64)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        struct cgroup_controller * cgc = NULL;
-       const char * const cg_ctrl = "cpu";
-       struct cgroup *cgroup = NULL;
+       const char * const cgrp_ctrl = "cpu";
+       struct cgroup *cgrp = NULL;
        u_int64_t value = 1024;
        char * name = NULL;
        int ret;
@@ -452,11 +452,11 @@ TEST_F(APIArgsTest, API_cgroup_set_value_uint64)
 
        // case 2
        // cgc = valid, name = NULL, value = valid
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
-       ASSERT_NE(cgroup, nullptr);
+       cgc = cgroup_add_controller(cgrp, cgrp_ctrl);
+       ASSERT_NE(cgrp, nullptr);
 
        // set cpu.shares, so that cgc->index > 0
        ret = cgroup_set_value_uint64(cgc, "cpu.shares", 1024);
@@ -492,10 +492,10 @@ TEST_F(APIArgsTest, API_cgroup_set_value_uint64)
  */
 TEST_F(APIArgsTest, API_cgroup_get_value_uint64)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        struct cgroup_controller * cgc = NULL;
-       const char * const cg_ctrl = "cpu";
-       struct cgroup *cgroup = NULL;
+       const char * const cgrp_ctrl = "cpu";
+       struct cgroup *cgrp = NULL;
        char * name = NULL;
        u_int64_t value;
        int ret;
@@ -507,11 +507,11 @@ TEST_F(APIArgsTest, API_cgroup_get_value_uint64)
 
        // case 2
        // cgc = valid, name = NULL, value = NULL
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
-       ASSERT_NE(cgroup, nullptr);
+       cgc = cgroup_add_controller(cgrp, cgrp_ctrl);
+       ASSERT_NE(cgrp, nullptr);
 
        // set cpu.shares, so that cgc->index > 0
        ret = cgroup_set_value_uint64(cgc, "cpu.shares", 1024);
@@ -548,10 +548,10 @@ TEST_F(APIArgsTest, API_cgroup_get_value_uint64)
  */
 TEST_F(APIArgsTest, API_cgroup_set_value_bool)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        struct cgroup_controller * cgc = NULL;
-       const char * const cg_ctrl = "cpuset";
-       struct cgroup *cgroup = NULL;
+       const char * const cgrp_ctrl = "cpuset";
+       struct cgroup *cgrp = NULL;
        char * name = NULL;
        bool value = 1;
        int ret;
@@ -563,11 +563,11 @@ TEST_F(APIArgsTest, API_cgroup_set_value_bool)
 
        // case 2
        // cgc = valid, name = NULL, value = valid
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
-       ASSERT_NE(cgroup, nullptr);
+       cgc = cgroup_add_controller(cgrp, cgrp_ctrl);
+       ASSERT_NE(cgrp, nullptr);
 
        // set cpuset.cpu_exclusive, so that cgc->index > 0
        ret = cgroup_set_value_bool(cgc, "cpuset.cpu_exclusive", 0);
@@ -603,10 +603,10 @@ TEST_F(APIArgsTest, API_cgroup_set_value_bool)
  */
 TEST_F(APIArgsTest, API_cgroup_get_value_bool)
 {
-       const char * const cg_name = "FuzzerCgroup";
+       const char * const cgrp_name = "FuzzerCgroup";
        struct cgroup_controller * cgc = NULL;
-       const char * const cg_ctrl = "cpuset";
-       struct cgroup *cgroup = NULL;
+       const char * const cgrp_ctrl = "cpuset";
+       struct cgroup *cgrp = NULL;
        char * name = NULL;
        bool value;
        int ret;
@@ -618,11 +618,11 @@ TEST_F(APIArgsTest, API_cgroup_get_value_bool)
 
        // case 2
        // cgc = valid, name = NULL, value = NULL
-       cgroup = cgroup_new_cgroup(cg_name);
-       ASSERT_NE(cgroup, nullptr);
+       cgrp = cgroup_new_cgroup(cgrp_name);
+       ASSERT_NE(cgrp, nullptr);
 
-       cgc = cgroup_add_controller(cgroup, cg_ctrl);
-       ASSERT_NE(cgroup, nullptr);
+       cgc = cgroup_add_controller(cgrp, cgrp_ctrl);
+       ASSERT_NE(cgrp, nullptr);
 
        // set cpuset.cpu_exclusive, so that cgc->index > 0
        ret = cgroup_set_value_bool(cgc, "cpuset.cpu_exclusive", 0);