!208 Code specification fixing

Merge pull request !208 from caozhijun/OpenHarmony-4.0-Release

test/fuzztest/accesstokenid/src/accesstokenidcommon.cpp

@@ -21,11 +21,11 @@
 namespace OHOS {
 namespace Kernel {
 namespace AccessToken {
-const char *DEVACCESSTOKENID = "/dev/access_token_id";
+const char *g_devaccesstokenid = "/dev/access_token_id";
 
 int GetTokenid(unsigned long long *token)
 {
-    int fd = open(DEVACCESSTOKENID, O_RDWR);
+    int fd = open(g_devaccesstokenid, O_RDWR);
     if (fd < 0) {
         return -1;
     }
@@ -40,7 +40,7 @@ int GetTokenid(unsigned long long *token)
 
 int SetTokenid(unsigned long long *token)
 {
-    int fd = open(DEVACCESSTOKENID, O_RDWR);
+    int fd = open(g_devaccesstokenid, O_RDWR);
     if (fd < 0) {
         return -1;
     }
@@ -182,7 +182,7 @@ int AccessTokenidGrpTestOther(uint8_t *dataToken)
 
 int GetfTokenid(unsigned long long *ftoken)
 {
-    int fd = open(DEVACCESSTOKENID, O_RDWR);
+    int fd = open(g_devaccesstokenid, O_RDWR);
     if (fd < 0) {
         return -1;
     }
@@ -199,7 +199,7 @@ int GetfTokenid(unsigned long long *ftoken)
 
 int SetfTokenid(unsigned long long *ftoken)
 {
-    int fd = open(DEVACCESSTOKENID, O_RDWR);
+    int fd = open(g_devaccesstokenid, O_RDWR);
     if (fd < 0) {
         return -1;
     }

test/fuzztest/hc_node/hcenable_fuzzer/hcenable_fuzzer.cpp

@@ -13,12 +13,12 @@
 #include <cstdint>
 #include "hccommon.h"
 
-const char *HC_ENABLE = "/sys/fs/f2fs/loop1/hc_enable";
+const char *g_hcEnable = "/sys/fs/f2fs/loop1/hc_enable";
 
 namespace OHOS {
 bool HcEnableFuzzer(const uint8_t *data, size_t size)
 {
-    bool ret = HcFuzzTest(data, HC_ENABLE, size);
+    bool ret = HcFuzzTest(data, g_hcEnable, size);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer/hchotdatalowerlimit_fuzzer.cpp

@@ -13,12 +13,12 @@
 #include <cstdint>
 #include "hccommon.h"
 
-const char *HC_HOT_DATA_LOWER_LIMIT = "/sys/fs/f2fs/loop1/hc_hot_data_lower_limit";
+const char *g_hcHotDataLowerLimit = "/sys/fs/f2fs/loop1/hc_hot_data_lower_limit";
 
 namespace OHOS {
 bool HcHotDataLowerLimitFuzzer(const uint8_t *data, size_t size)
 {
-    bool ret = HcFuzzTest(data, HC_HOT_DATA_LOWER_LIMIT, size);
+    bool ret = HcFuzzTest(data, g_hcHotDataLowerLimit, size);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/hc_node/hchotdatawaterline_fuzzer/hchotdatawaterline_fuzzer.cpp

@@ -13,12 +13,12 @@
 #include <cstdint>
 #include "hccommon.h"
 
-const char *HC_HOT_DATA_WATERLINE = "/sys/fs/f2fs/loop1/hc_hot_data_waterline";
+const char *g_hcHotDataWaterline = "/sys/fs/f2fs/loop1/hc_hot_data_waterline";
 
 namespace OHOS {
 bool HcHotDataWaterlineFuzzer(const uint8_t *data, size_t size)
 {
-    bool ret = HcFuzzTest(data, HC_HOT_DATA_WATERLINE, size);
+    bool ret = HcFuzzTest(data, g_hcHotDataWaterline, size);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer/hchotnodelowerlimit_fuzzer.cpp

@@ -13,12 +13,12 @@
 #include <cstdint>
 #include "hccommon.h"
 
-const char *HC_HOT_NODE_LOWER_LIMIT = "/sys/fs/f2fs/loop1/hc_hot_node_lower_limit";
+const char *g_hcHotNodeLowerLimit = "/sys/fs/f2fs/loop1/hc_hot_node_lower_limit";
 
 namespace OHOS {
 bool HcHotNodeLowerLimitFuzzTest(const uint8_t *data, size_t size)
 {
-    bool ret = HcFuzzTest(data, HC_HOT_NODE_LOWER_LIMIT, size);
+    bool ret = HcFuzzTest(data, g_hcHotNodeLowerLimit, size);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/hc_node/hchotnodewaterline_fuzzer/hchotnodewaterline_fuzzer.cpp

@@ -13,12 +13,12 @@
 #include <cstdint>
 #include "hccommon.h"
 
-const char *HC_HOT_NODE_WATERLINE = "/sys/fs/f2fs/loop1/hc_hot_node_waterline";
+const char *g_hcHotNodeWaterline = "/sys/fs/f2fs/loop1/hc_hot_node_waterline";
 
 namespace OHOS {
 bool HcHotNodeWaterlineFuzzTest(const uint8_t *data, size_t size)
 {
-    bool ret = HcFuzzTest(data, HC_HOT_NODE_WATERLINE, size);
+    bool ret = HcFuzzTest(data, g_hcHotNodeWaterline, size);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer/hcwarmdatalowerlimit_fuzzer.cpp

@@ -13,12 +13,12 @@
 #include <cstdint>
 #include "hccommon.h"
 
-const char *HC_WARM_DATA_LOWER_LIMIT = "/sys/fs/f2fs/loop1/hc_warm_data_lower_limit";
+const char *g_hcWarmDataLowerLimit = "/sys/fs/f2fs/loop1/hc_warm_data_lower_limit";
 
 namespace OHOS {
 bool HcWarmDataLowerLimitFuzzTest(const uint8_t *data, size_t size)
 {
-    bool ret = HcFuzzTest(data, HC_WARM_DATA_LOWER_LIMIT, size);
+    bool ret = HcFuzzTest(data, g_hcWarmDataLowerLimit, size);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer/hcwarmdatawaterline_fuzzer.cpp

@@ -13,12 +13,12 @@
 #include <cstdint>
 #include "hccommon.h"
 
-const char *HC_WARM_DATA_WATERLINE = "/sys/fs/f2fs/loop1/hc_warm_data_waterline";
+const char *g_hcWarmDataWaterline = "/sys/fs/f2fs/loop1/hc_warm_data_waterline";
 
 namespace OHOS {
 bool HcWarmDataWaterLineFuzzTest(const uint8_t *data, size_t size)
 {
-    bool ret = HcFuzzTest(data, HC_WARM_DATA_WATERLINE, size);
+    bool ret = HcFuzzTest(data, g_hcWarmDataWaterline, size);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer/hcwarmnodelowerlimit_fuzzer.cpp

@@ -13,12 +13,12 @@
 #include <cstdint>
 #include "hccommon.h"
 
-const char *HC_WARM_NODE_LOWER_LIMIT = "/sys/fs/f2fs/loop1/hc_warm_node_lower_limit";
+const char *g_hcWarmNodeLowerLimit = "/sys/fs/f2fs/loop1/hc_warm_node_lower_limit";
 
 namespace OHOS {
 bool HcWarmNodeLowerLimit(const uint8_t *data, size_t size)
 {
-    bool ret = HcFuzzTest(data, HC_WARM_NODE_LOWER_LIMIT, size);
+    bool ret = HcFuzzTest(data, g_hcWarmNodeLowerLimit, size);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer/hcwarmnodewaterline_fuzzer.cpp

@@ -13,12 +13,12 @@
 #include <cstdint>
 #include "hccommon.h"
 
-const char *HC_WARM_NODE_WATERLINE = "/sys/fs/f2fs/loop1/hc_warm_node_waterline";
+const char *g_hcWarmNodeWaterline = "/sys/fs/f2fs/loop1/hc_warm_node_waterline";
 
 namespace OHOS {
 bool HcWarmNodeLowerWaterLine(const uint8_t *data, size_t size)
 {
-    bool ret = HcFuzzTest(data, HC_WARM_NODE_WATERLINE, size);
+    bool ret = HcFuzzTest(data, g_hcWarmNodeWaterline, size);
     return ret;
 }
 } // namespace OHOS

test/tracepointtest/emmc.h

@@ -9,12 +9,15 @@
  * limitations under the License.
  */
 
+#ifnef TEST_TRACEPOINT_EMMC_H
+#define TEST_TRACEPOINT_EMMC_H
+
 #undef TRACE_SYSTEM
 #define TRACE_SYSTEM emmc
 
 #define TRACE_INCLUDE_PATH trace/hooks
-#if !defined(_TRACE_HOOKS_EMMC_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_HOOKS_EMMC_H
+#if !defined(TRACE_HOOKS_EMMC_H) || defined(TRACE_HEADER_MULTI_READ)
+#define TRACE_HOOKS_EMMC_H
 
 #include <trace/hooks/vendor_hooks.h>
 #include <linux/tracepoint.h>
@@ -33,3 +36,5 @@ DECLARE_HOOK(vendor_fake_boot_partition,
 
 /* This part must be outside protection */
 #include <trace/define_trace.h>
+
+#endif //TEST_TRACEPOINT_EMMC_H

test/tracepointtest/tracepoint_test/tracepoint_test.c

@@ -33,4 +33,4 @@ static void tracepoint_test_exit_module(void)
 /* module entry points */
 module_init(tracepoint_test_init_module);
 module_exit(tracepoint_test_exit_module);
-MODULE_LICENSE ("GPL v2");
+MODULE_LICENSE("GPL v2");

test/tracepointtest/vendoramlemmcpartition_test/vendoramlemmcpartition_test.c

@@ -32,4 +32,4 @@ static void aml_emmc_partition_test_exit_module(void)
 /* module entry points */
 module_init(aml_emmc_partition_test_init_module);
 module_exit(aml_emmc_partition_test_exit_module);
-MODULE_LICENSE ("GPL v2");
+MODULE_LICENSE("GPL v2");

test/tracepointtest/vendordommap_test/vendordommap_test.c

@@ -32,4 +32,4 @@ static void mmap_test_exit_module(void)
 /* module entry points */
 module_init(mmap_test_init_module);
 module_exit(mmap_test_exit_module);
-MODULE_LICENSE ("GPL v2");
+MODULE_LICENSE("GPL v2");

test/tracepointtest/vendordomprotectpkey_test/vendordomprotectpkey_test.c

@@ -32,4 +32,4 @@ static void mprotect_pkey_test_exit_module(void)
 /* module entry points */
 module_init(mprotect_pkey_test_init_module);
 module_exit(mprotect_pkey_test_exit_module);
-MODULE_LICENSE ("GPL v2");
+MODULE_LICENSE("GPL v2");

test/tracepointtest/vendorfakebootpartition_test/vendorfakebootpartition_test.c

@@ -32,4 +32,4 @@ static void fake_boot_partition_test_exit_module(void)
 /* module entry points */
 module_init(fake_boot_partition_test_init_module);
 module_exit(fake_boot_partition_test_exit_module);
-MODULE_LICENSE ("GPL v2");
+MODULE_LICENSE("GPL v2");

test/unittest/accesstokenid/accesstokenid_test.cpp

@@ -55,9 +55,9 @@ constexpr unsigned int ACCESS_TOKEN_GRPID = 3020;
 constexpr unsigned int ACCESS_TOKEN_OTHER_UID = 1234;
 constexpr unsigned int ACCESS_TOKEN_OTHER_GRPID = 1234;
 
-const char dev_accesstokenid[] = "/dev/access_token_id";
+const char DEV_ACCESSTOKENID[] = "/dev/access_token_id";
 
-struct tokeninfo {
+struct Tokeninfo {
     pid_t               pid;
     pid_t               tid;
     unsigned long long  tokenid;
@@ -85,9 +85,9 @@ static unsigned long long GenRand64(void)
 
 static int GetTokenid(unsigned long long *token)
 {
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return -1;
     }
 
@@ -104,9 +104,9 @@ static int GetTokenid(unsigned long long *token)
 
 static int SetTokenid(unsigned long long *token)
 {
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return -1;
     }
 
@@ -123,9 +123,9 @@ static int SetTokenid(unsigned long long *token)
 
 static int GetfTokenid(unsigned long long *ftoken)
 {
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return -1;
     }
 
@@ -142,9 +142,9 @@ static int GetfTokenid(unsigned long long *ftoken)
 
 static int SetfTokenid(unsigned long long *ftoken)
 {
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return -1;
     }
 
@@ -169,7 +169,7 @@ static void GetCurToken(unsigned long long *token, unsigned long long *ftoken)
 
 static void *CheckChildThreadInheritance(void *args)
 {
-    struct tokeninfo *tinfo = static_cast<struct tokeninfo *> (args);
+    struct Tokeninfo *tinfo = static_cast<struct Tokeninfo *>(args);
 
     tinfo->pid = getpid();
     tinfo->tid = gettid();
@@ -182,7 +182,7 @@ static void *CheckChildThreadInheritance(void *args)
 
 static void *CheckChildThreadSetIndepent(void *args)
 {
-    struct tokeninfo *tinfo = static_cast<struct tokeninfo *> (args);
+    struct Tokeninfo *tinfo = static_cast<struct Tokeninfo *>(args);
     unsigned long long tokenSet = GenRand64();
     unsigned long long ftokenSet = GenRand64();
     unsigned long long tokenidGet = INVAL_TOKEN;
@@ -288,7 +288,7 @@ HWTEST_F(AccesstokenidTest, CheckChildThreadInheritance, Function | MediumTest |
     unsigned long long tokenSet = GenRand64();
     unsigned long long ftokenSet = GenRand64();
 
-    struct tokeninfo tinfo;
+    struct Tokeninfo tinfo;
     tinfo.pid = getpid();
     tinfo.tid = gettid();
     tinfo.tokenid = INVAL_TOKEN;
@@ -330,7 +330,7 @@ HWTEST_F(AccesstokenidTest, CheckChildThreadSetIndepent, Function | MediumTest |
     unsigned long long tokenSet = GenRand64();
     unsigned long long ftokenSet = GenRand64();
 
-    struct tokeninfo tinfo;
+    struct Tokeninfo tinfo;
     tinfo.pid = getpid();
     tinfo.tid = gettid();
     tinfo.tokenid = INVAL_TOKEN;
@@ -365,9 +365,9 @@ HWTEST_F(AccesstokenidTest, CheckChildThreadSetIndepent, Function | MediumTest |
  */
 HWTEST_F(AccesstokenidTest, AbnormalGetTokenid, Function | MediumTest | Level1)
 {
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -385,9 +385,9 @@ HWTEST_F(AccesstokenidTest, AbnormalGetTokenid, Function | MediumTest | Level1)
  */
 HWTEST_F(AccesstokenidTest, AbnormalSetTokenid, Function | MediumTest | Level1)
 {
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -405,9 +405,9 @@ HWTEST_F(AccesstokenidTest, AbnormalSetTokenid, Function | MediumTest | Level1)
  */
 HWTEST_F(AccesstokenidTest, AbnormalGetfTokenid, Function | MediumTest | Level1)
 {
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -425,9 +425,9 @@ HWTEST_F(AccesstokenidTest, AbnormalGetfTokenid, Function | MediumTest | Level1)
  */
 HWTEST_F(AccesstokenidTest, AbnormalSetfTokenid, Function | MediumTest | Level1)
 {
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -447,9 +447,9 @@ HWTEST_F(AccesstokenidTest, AbnormalIoctlCmd, Function | MediumTest | Level1)
 {
     unsigned long long token;
 
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -477,9 +477,9 @@ HWTEST_F(AccesstokenidTest, OtherUidSetTokenid, Function | MediumTest | Level1)
         printf("setuid error %d \r\n", ret);
     }
 
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -505,9 +505,9 @@ HWTEST_F(AccesstokenidTest, OtherUidGetTokenid, Function | MediumTest | Level1)
         printf("setuid error %d \r\n", ret);
     }
 
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -535,9 +535,9 @@ HWTEST_F(AccesstokenidTest, WithoutGrpSetfTokenid, Function | MediumTest | Level
         printf("setgroups error %d \r\n", ret);
     }
 
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -565,9 +565,9 @@ HWTEST_F(AccesstokenidTest, WithoutGrpGetfTokenid, Function | MediumTest | Level
         printf("setgroups error %d \r\n", ret);
     }
 
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -595,9 +595,9 @@ HWTEST_F(AccesstokenidTest, WithGrpSetfTokenid, Function | MediumTest | Level1)
         printf("setgroups error %d \r\n", ret);
     }
 
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 
@@ -625,9 +625,9 @@ HWTEST_F(AccesstokenidTest, WithGrpGetfTokenid, Function | MediumTest | Level1)
         printf("setgroups error %d \r\n", ret);
     }
 
-    int fd = open(dev_accesstokenid, O_RDWR);
+    int fd = open(DEV_ACCESSTOKENID, O_RDWR);
     if (fd < 0) {
-        printf("open %s failed\r\n", dev_accesstokenid);
+        printf("open %s failed\r\n", DEV_ACCESSTOKENID);
         return;
     }
 

test/unittest/rtg/rtg_test.cpp

@@ -40,46 +40,46 @@ const int MAX_TID_NUM = 5;
 const int MULTI_FRAME_NUM = 5;
 
 #define CMD_ID_SET_ENABLE \
-    _IOWR(RTG_SCHED_IPC_MAGIC, SET_ENABLE, struct rtg_enable_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, SET_ENABLE, struct RtgEnableData)
 #define CMD_ID_SET_RTG \
-    _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG, struct rtg_str_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG, struct RtgStrData)
 #define CMD_ID_BEGIN_FRAME_FREQ \
-    _IOWR(RTG_SCHED_IPC_MAGIC, BEGIN_FRAME_FREQ, struct proc_state_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, BEGIN_FRAME_FREQ, struct ProcStateData)
 #define CMD_ID_END_FRAME_FREQ \
-    _IOWR(RTG_SCHED_IPC_MAGIC, END_FRAME_FREQ, struct proc_state_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, END_FRAME_FREQ, struct ProcStateData)
 #define CMD_ID_END_SCENE \
-    _IOWR(RTG_SCHED_IPC_MAGIC, END_SCENE, struct proc_state_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, END_SCENE, struct ProcStateData)
 #define CMD_ID_SET_MIN_UTIL \
-    _IOWR(RTG_SCHED_IPC_MAGIC, SET_MIN_UTIL, struct proc_state_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, SET_MIN_UTIL, struct ProcStateData)
 #define CMD_ID_SET_MARGIN \
-    _IOWR(RTG_SCHED_IPC_MAGIC, SET_MARGIN, struct proc_state_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, SET_MARGIN, struct ProcStateData)
 #define CMD_ID_LIST_RTG_THREAD \
-    _IOWR(RTG_SCHED_IPC_MAGIC, LIST_RTG_THREAD, struct rtg_grp_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, LIST_RTG_THREAD, struct RtgGrpData)
 #define CMD_ID_LIST_RTG \
-    _IOWR(RTG_SCHED_IPC_MAGIC, LIST_RTG, struct rtg_info)
+    _IOWR(RTG_SCHED_IPC_MAGIC, LIST_RTG, struct RtgInfo)
 #define CMD_ID_SET_RTG_ATTR \
-    _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG_ATTR, struct rtg_str_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG_ATTR, struct RtgStrData)
 #define CMD_ID_SET_CONFIG \
-    _IOWR(RTG_SCHED_IPC_MAGIC, SET_CONFIG, struct rtg_str_data)
+    _IOWR(RTG_SCHED_IPC_MAGIC, SET_CONFIG, struct RtgStrData)
 
-struct rtg_enable_data {
+struct RtgEnableData {
     int enable;
     int len;
     char *data;
 };
 
-struct rtg_str_data {
+struct RtgStrData {
     int type;
     int len;
     char *data;
 };
 
-struct proc_state_data {
-    int grp_id;
-    int state_param;
+struct ProcStateData {
+    int grpId;
+    int stateParam;
 };
 
-enum grp_ctrl_cmd {
+enum GrpCtrlCmd {
     CMD_CREATE_RTG_GRP,
     CMD_ADD_RTG_THREAD,
     CMD_REMOVE_RTG_THREAD,
@@ -87,21 +87,21 @@ enum grp_ctrl_cmd {
     CMD_DESTROY_RTG_GRP
 };
 
-struct rtg_grp_data {
-    int rtg_cmd;
-    int grp_id;
-    int prio_type;
-    int rt_cnt;
-    int tid_num;
+struct RtgGrpData {
+    int rtgCmd;
+    int grpId;
+    int prioType;
+    int rtCnt;
+    int tidNum;
     int tids[MAX_TID_NUM];
 };
 
-struct rtg_info {
-    int rtg_num;
+struct RtgInfo {
+    int rtgNum;
     int rtgs[MULTI_FRAME_NUM];
 };
 
-enum rtg_sched_cmdid {
+enum RtgSchedCmdid {
     SET_ENABLE = 1,
     SET_RTG,
     SET_CONFIG,
@@ -118,7 +118,7 @@ enum rtg_sched_cmdid {
     RTG_CTRL_MAX_NR,
 };
 
-enum rtg_type : int {
+enum RtgType : int {
     VIP = 0,
     TOP_TASK_KEY,
     NORMAL_TASK,
@@ -129,17 +129,15 @@ static int BasicOpenRtgNode()
 {
     char fileName[] = "/proc/self/sched_rtg_ctrl";
     int fd = open(fileName, O_RDWR);
-
     if (fd < 0) {
         cout << "open node err." << endl;
     }
-
     return fd;
 }
 
 static int EnableRtg(bool flag)
 {
-    struct rtg_enable_data enableData;
+    struct RtgEnableData enableData;
     char configStr[] = "load_freq_switch:1;sched_cycle:1";
 
     enableData.enable = flag;
@@ -160,38 +158,38 @@ static int EnableRtg(bool flag)
 
 static int CreateNewRtgGrp(int prioType, int rtNum)
 {
-    struct rtg_grp_data grp_data;
+    struct RtgGrpData grpData;
     int ret;
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return RTG_ERR;
     }
-    (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data));
+    (void)memset_s(&grpData, sizeof(struct RtgGrpData), 0, sizeof(struct RtgGrpData));
     if ((prioType > 0) && (prioType < RTG_TYPE_MAX)) {
-        grp_data.prio_type = prioType;
+        grpData.prioType = prioType;
     }
     if (rtNum > 0) {
-        grp_data.rt_cnt = rtNum;
+        grpData.rtCnt = rtNum;
     }
-    grp_data.rtg_cmd = CMD_CREATE_RTG_GRP;
-    ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data);
+    grpData.rtgCmd = CMD_CREATE_RTG_GRP;
+    ret = ioctl(fd, CMD_ID_SET_RTG, &grpData);
 
     close(fd);
     return ret;
 }
 
-static int DestroyRtgGrp(int GrpId)
+static int DestroyRtgGrp(int grpId)
 {
-    struct rtg_grp_data grp_data;
+    struct RtgGrpData grpData;
     int ret;
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return fd;
     }
-    (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data));
-    grp_data.rtg_cmd = CMD_DESTROY_RTG_GRP;
-    grp_data.grp_id = GrpId;
-    ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data);
+    (void)memset_s(&grpData, sizeof(struct RtgGrpData), 0, sizeof(struct RtgGrpData));
+    grpData.rtgCmd = CMD_DESTROY_RTG_GRP;
+    grpData.grpId = grpId;
+    ret = ioctl(fd, CMD_ID_SET_RTG, &grpData);
 
     close(fd);
     return ret;
@@ -199,36 +197,36 @@ static int DestroyRtgGrp(int GrpId)
 
 static int AddThreadToRtg(int tid, int grpId, int prioType)
 {
-    struct rtg_grp_data grp_data;
+    struct RtgGrpData grpData;
     int ret;
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return fd;
     }
-    (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data));
-    grp_data.tid_num = 1;
-    grp_data.tids[0] = tid;
-    grp_data.grp_id = grpId;
-    grp_data.rtg_cmd = CMD_ADD_RTG_THREAD;
-    grp_data.prio_type = prioType;
-    ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data);
+    (void)memset_s(&grpData, sizeof(struct RtgGrpData), 0, sizeof(struct RtgGrpData));
+    grpData.tidNum = 1;
+    grpData.tids[0] = tid;
+    grpData.grpId = grpId;
+    grpData.rtgCmd = CMD_ADD_RTG_THREAD;
+    grpData.prioType = prioType;
+    ret = ioctl(fd, CMD_ID_SET_RTG, &grpData);
 
     close(fd);
     return ret;
 }
 
-static int ClearRtgGrp(int GrpId)
+static int ClearRtgGrp(int grpId)
 {
-    struct rtg_grp_data grp_data;
+    struct RtgGrpData grpData;
     int ret;
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return fd;
     }
-    (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data));
-    grp_data.rtg_cmd = CMD_CLEAR_RTG_GRP;
-    grp_data.grp_id = GrpId;
-    ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data);
+    (void)memset_s(&grpData, sizeof(struct RtgGrpData), 0, sizeof(struct RtgGrpData));
+    grpData.rtgCmd = CMD_CLEAR_RTG_GRP;
+    grpData.grpId = grpId;
+    ret = ioctl(fd, CMD_ID_SET_RTG, &grpData);
     if (ret < 0) {
         return ret;
     }
@@ -240,14 +238,14 @@ static int ClearRtgGrp(int GrpId)
 static int BeginFrameFreq(int grpId, int stateParam)
 {
     int ret = 0;
-    struct proc_state_data state_data;
-    state_data.grp_id = grpId;
-    state_data.state_param = stateParam;
+    struct ProcStateData stateData;
+    stateData.grpId = grpId;
+    stateData.stateParam = stateParam;
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return fd;
     }
-    ret = ioctl(fd, CMD_ID_BEGIN_FRAME_FREQ, &state_data);
+    ret = ioctl(fd, CMD_ID_BEGIN_FRAME_FREQ, &stateData);
 
     close(fd);
     return ret;
@@ -256,14 +254,14 @@ static int BeginFrameFreq(int grpId, int stateParam)
 static int EndFrameFreq(int grpId)
 {
     int ret = 0;
-    struct proc_state_data state_data;
-    state_data.grp_id = grpId;
-    state_data.state_param = 0;
+    struct ProcStateData stateData;
+    stateData.grpId = grpId;
+    stateData.stateParam = 0;
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
-            return fd;
-        }
-    ret = ioctl(fd, CMD_ID_END_FRAME_FREQ, &state_data);
+        return fd;
+    }
+    ret = ioctl(fd, CMD_ID_END_FRAME_FREQ, &stateData);
 
     close(fd);
     return ret;
@@ -272,15 +270,14 @@ static int EndFrameFreq(int grpId)
 static int EndScene(int grpId)
 {
     int ret = 0;
-    struct proc_state_data state_data;
-    state_data.grp_id = grpId;
+    struct ProcStateData stateData;
+    stateData.grpId = grpId;
 
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
-       return fd;
+        return fd;
     }
-    ret = ioctl(fd, CMD_ID_END_SCENE, &state_data);
-
+    ret = ioctl(fd, CMD_ID_END_SCENE, &stateData);
     close(fd);
     return ret;
 }
@@ -288,15 +285,15 @@ static int EndScene(int grpId)
 static int SetStateParam(unsigned int cmd, int grpId, int stateParam)
 {
     int ret = 0;
-    struct proc_state_data state_data;
-    state_data.grp_id = grpId;
-    state_data.state_param = stateParam;
+    struct ProcStateData stateData;
+    stateData.grpId = grpId;
+    stateData.stateParam = stateParam;
 
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return fd;
     }
-    ret = ioctl(fd, cmd, &state_data);
+    ret = ioctl(fd, cmd, &stateData);
 
     close(fd);
     return ret;
@@ -306,23 +303,23 @@ static int SetStateParam(unsigned int cmd, int grpId, int stateParam)
 static int ListRtgThread(int grpId, vector<int> *rs)
 {
     int ret = 0;
-    struct rtg_grp_data grp_data;
+    struct RtgGrpData grpData;
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return fd;
     }
     if (!rs) {
-       return RTG_ERR;
+        return RTG_ERR;
     }
-    (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data));
-    grp_data.grp_id = grpId;
-    ret = ioctl(fd, CMD_ID_LIST_RTG_THREAD, &grp_data);
+    (void)memset_s(&grpData, sizeof(struct RtgGrpData), 0, sizeof(struct RtgGrpData));
+    grpData.grpId = grpId;
+    ret = ioctl(fd, CMD_ID_LIST_RTG_THREAD, &grpData);
     if (ret < 0) {
         return ret;
     } else {
         rs->clear();
-        for (int i = 0; i < grp_data.tid_num; i++) {
-            rs->push_back(grp_data.tids[i]);
+        for (int i = 0; i < grpData.tidNum; i++) {
+            rs->push_back(grpData.tids[i]);
         }
     }
 
@@ -333,7 +330,7 @@ static int ListRtgThread(int grpId, vector<int> *rs)
 static int ListRtgGroup(vector<int> *rs)
 {
     int ret = 0;
-    struct rtg_info rtg_info;
+    struct RtgInfo rtgInfo;
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return fd;
@@ -341,14 +338,14 @@ static int ListRtgGroup(vector<int> *rs)
     if (!rs) {
         return RTG_ERR;
     }
-    (void)memset_s(&rtg_info, sizeof(struct rtg_info), 0, sizeof(struct rtg_info));
-    ret = ioctl(fd, CMD_ID_LIST_RTG, &rtg_info);
+    (void)memset_s(&rtgInfo, sizeof(struct RtgInfo), 0, sizeof(struct RtgInfo));
+    ret = ioctl(fd, CMD_ID_LIST_RTG, &rtgInfo);
     if (ret < 0) {
         return ret;
     } else {
         rs->clear();
-        for (int i = 0; i < rtg_info.rtg_num; i++) {
-            rs->push_back(rtg_info.rtgs[i]);
+        for (int i = 0; i < rtgInfo.rtgNum; i++) {
+            rs->push_back(rtgInfo.rtgs[i]);
         }
     }
 
@@ -359,17 +356,17 @@ static int ListRtgGroup(vector<int> *rs)
 static int SetFrameRateAndPrioType(int rtgId, int rate, int rtgType)
 {
     int ret = 0;
-    char str_data[MAX_LENGTH] = {};
-    (void)sprintf_s(str_data, sizeof(str_data), "rtgId:%d;rate:%d;type:%d", rtgId, rate, rtgType);
-    struct rtg_str_data strData;
-    strData.len = strlen(str_data);
-    strData.data = str_data;
+    char strData[MAX_LENGTH] = {};
+    (void)sprintf_s(strData, sizeof(strData), "rtgId:%d;rate:%d;type:%d", rtgId, rate, rtgType);
+    struct RtgStrData rtgStrData;
+    rtgStrData.len = strlen(strData);
+    rtgStrData.data = strData;
 
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return fd;
     }
-    ret = ioctl(fd, CMD_ID_SET_RTG_ATTR, &strData);
+    ret = ioctl(fd, CMD_ID_SET_RTG_ATTR, &rtgStrData);
 
     close(fd);
     return ret;
@@ -378,17 +375,17 @@ static int SetFrameRateAndPrioType(int rtgId, int rate, int rtgType)
 static int SetMaxVipRtgs(int rtframe)
 {
     int ret = 0;
-    char str_data[MAX_STR_LEN] = {};
-    (void)sprintf_s(str_data, sizeof(str_data), "rtframe:%d", rtframe);
-    struct rtg_str_data strData;
-    strData.len = strlen(str_data);
-    strData.data = str_data;
+    char strData[MAX_STR_LEN] = {};
+    (void)sprintf_s(strData, sizeof(strData), "rtframe:%d", rtframe);
+    struct RtgStrData rtgStrData;
+    rtgStrData.len = strlen(strData);
+    rtgStrData.data = strData;
 
     int fd = BasicOpenRtgNode();
     if (fd < 0) {
         return fd;
     }
-    ret = ioctl(fd, CMD_ID_SET_CONFIG, &strData);
+    ret = ioctl(fd, CMD_ID_SET_CONFIG, &rtgStrData);
 
     close(fd);
     return ret;
@@ -396,41 +393,42 @@ static int SetMaxVipRtgs(int rtframe)
 
 static int AddThreadsToRtg(vector<int> tids, int grpId, int prioType)
 {
-    struct rtg_grp_data grp_data;
+    struct RtgGrpData grpData;
     int ret;
     int fd = BasicOpenRtgNode();
-
     if (fd < 0) {
         return fd;
     }
-    (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data));
+    (void)memset_s(&grpData, sizeof(struct RtgGrpData), 0, sizeof(struct RtgGrpData));
     int num = static_cast<int>(tids.size());
     if (num > MAX_TID_NUM) {
         return -1;
     }
-    grp_data.tid_num = num;
-    grp_data.grp_id = grpId;
-    grp_data.rtg_cmd = CMD_ADD_RTG_THREAD;
-    grp_data.prio_type = prioType;
+    grpData.tidNum = num;
+    grpData.grpId = grpId;
+    grpData.rtgCmd = CMD_ADD_RTG_THREAD;
+    grpData.prioType = prioType;
     for (int i = 0; i < num; i++) {
         if (tids[i] < 0) {
             return -1;
         }
-        grp_data.tids[i] = tids[i];
+        grpData.tids[i] = tids[i];
     }
-    ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data);
+    ret = ioctl(fd, CMD_ID_SET_RTG, &grpData);
 
     close(fd);
     return ret;
 }
 
-void RtgTest::SetUp() {
+void RtgTest::SetUp()
+{
     // must enable rtg before use the interface
     int ret = EnableRtg(true);
     ASSERT_EQ(RTG_SUCC, ret);
 }
 
-void RtgTest::TearDown() {
+void RtgTest::TearDown()
+{
     // disable rtg after use the interface
     int ret = EnableRtg(false);
     ASSERT_EQ(RTG_SUCC, ret);
@@ -524,7 +522,7 @@ HWTEST_F(RtgTest, addRtgGrpFail, Function | MediumTest | Level1)
     ASSERT_NE(ret, 0);
 
     // error grpid
-    ret=AddThreadToRtg(pid, -1, VIP);
+    ret = AddThreadToRtg(pid, -1, VIP);
     ASSERT_NE(ret, RTG_SUCC);
     ret = DestroyRtgGrp(grpId);
     ASSERT_EQ(ret, 0);
@@ -867,7 +865,7 @@ HWTEST_F(RtgTest, RtgAddMutipleThreadsSucc, Function | MediumTest | Level1)
         ASSERT_TRUE(pid[i] >= 0) << "> parent: fork errno = " << errno;
         if (pid[i] == 0) {
             usleep(50000);
-             _Exit(0);
+            _Exit(0);
         }
         threads.push_back(pid[i]);
     }