fix variables case and include fiel in 32-Beta2

Signed-off-by: @wu_fan520 <wufan114@huawei.com>

test/fuzztest/accesstokenid/accessftokenidgrptest_fuzzer/accessftokenidgrptest_fuzzer.cpp

@@ -28,8 +28,8 @@ bool AccessfTokenidGrpTestFuzzTest(const uint8_t *data, size_t size)
     if ((data == nullptr) || (size < sizeof(unsigned long long))) {
         return ret;
     } else {
-        uint8_t *data_ftoken = const_cast<uint8_t *>(data);
-        ret = AccessfTokenidGrpTest(data_ftoken);
+        uint8_t *dataFtoken = const_cast<uint8_t *>(data);
+        ret = AccessfTokenidGrpTest(dataFtoken);
     }
     return ret;
 }

test/fuzztest/accesstokenid/accessftokenidgrptestother_fuzzer/accessftokenidgrptestother_fuzzer.cpp

@@ -28,8 +28,8 @@ bool AccessfTokenidGrpTestOtherFuzzTest(const uint8_t *data, size_t size)
     if ((data == nullptr) || (size < sizeof(unsigned long long))) {
         return ret;
     } else {
-        uint8_t *data_ftoken = const_cast<uint8_t *>(data);
-        ret = AccessfTokenidGrpTestOther(data_ftoken);
+        uint8_t *dataFtoken = const_cast<uint8_t *>(data);
+        ret = AccessfTokenidGrpTestOther(dataFtoken);
     }
     return ret;
 }

test/fuzztest/accesstokenid/accessftokenidthreadtest_fuzzer/accessftokenidthreadtest_fuzzer.cpp

@@ -28,8 +28,8 @@ bool AccessfTokenidThreadTestFuzzTest(const uint8_t *data, size_t size)
     if ((data == nullptr) || (size < sizeof(unsigned long long))) {
         return ret;
     } else {
-        uint8_t *data_ftoken = const_cast<uint8_t *>(data);
-        ret = AccessfTokenidThreadTest(data_ftoken);
+        uint8_t *dataFtoken = const_cast<uint8_t *>(data);
+        ret = AccessfTokenidThreadTest(dataFtoken);
     }
     return ret;
 }

test/fuzztest/accesstokenid/accesstokenidgrptest_fuzzer/accesstokenidgrptest_fuzzer.cpp

@@ -28,8 +28,8 @@ bool AccessTokenidGrpTestFuzzTest(const uint8_t *data, size_t size)
     if ((data == nullptr) || (size < sizeof(unsigned long long))) {
         return ret;
     } else {
-        uint8_t *data_token = const_cast<uint8_t *>(data);
-        ret = AccessTokenidGrpTest(data_token);
+        uint8_t *dataToken = const_cast<uint8_t *>(data);
+        ret = AccessTokenidGrpTest(dataToken);
     }
     return ret;
 }

test/fuzztest/accesstokenid/accesstokenidgrptestother_fuzzer/accesstokenidgrptestother_fuzzer.cpp

@@ -28,8 +28,8 @@ bool AccessTokenidGrpTestOtherFuzzTest(const uint8_t *data, size_t size)
     if ((data == nullptr) || (size < sizeof(unsigned long long))) {
         return ret;
     } else {
-        uint8_t *data_token = const_cast<uint8_t *>(data);
-        ret = AccessTokenidGrpTestOther(data_token);
+        uint8_t *dataToken = const_cast<uint8_t *>(data);
+        ret = AccessTokenidGrpTestOther(dataToken);
     }
     return ret;
 }

test/fuzztest/accesstokenid/accesstokenidthreadtest_fuzzer/accesstokenidthreadtest_fuzzer.cpp

@@ -28,8 +28,8 @@ bool AccessTokenidThreadTestFuzzTest(const uint8_t *data, size_t size)
     if ((data == nullptr) || (size < sizeof(unsigned long long))) {
         return ret;
     } else {
-        uint8_t *data_token = const_cast<uint8_t *>(data);
-        ret = AccessTokenidThreadTest(data_token);
+        uint8_t *dataToken = const_cast<uint8_t *>(data);
+        ret = AccessTokenidThreadTest(dataToken);
     }
     return ret;
 }

test/fuzztest/accesstokenid/include/accesstokenidcommon.h

@@ -26,25 +26,25 @@ namespace AccessToken {
 #define ACCESS_TOKEN_ID_IOCTL_BASE    'A'
 
 #ifdef CMDERROR
-constexpr unsigned int get_token_id = 0;
-constexpr unsigned int set_token_id = 0;
-constexpr unsigned int get_ftoken_id = 0;
-constexpr unsigned int set_ftoken_id = 0;
+#define GET_TOKEN_ID    0
+#define SET_TOKEN_ID    0
+#define GET_GTOKEN_ID   0
+#define SET_GTOKEN_ID   0
 #else
-constexpr unsigned int get_token_id = 1;
-constexpr unsigned int set_token_id = 2;
-constexpr unsigned int get_ftoken_id = 3;
-constexpr unsigned int set_ftoken_id = 4;
+#define GET_TOKEN_ID    1
+#define SET_TOKEN_ID    2
+#define GET_GTOKEN_ID   3
+#define SET_GTOKEN_ID   4
 #endif
 
 #define ACCESS_TOKENID_GET_TOKENID \
-        _IOR(ACCESS_TOKEN_ID_IOCTL_BASE, get_token_id, unsigned long long)
+        _IOR(ACCESS_TOKEN_ID_IOCTL_BASE, GET_TOKEN_ID, unsigned long long)
 #define ACCESS_TOKENID_SET_TOKENID \
-        _IOW(ACCESS_TOKEN_ID_IOCTL_BASE, set_token_id, unsigned long long)
+        _IOW(ACCESS_TOKEN_ID_IOCTL_BASE, SET_TOKEN_ID, unsigned long long)
 #define ACCESS_TOKENID_GET_FTOKENID \
-        _IOR(ACCESS_TOKEN_ID_IOCTL_BASE, get_ftoken_id, unsigned long long)
+        _IOR(ACCESS_TOKEN_ID_IOCTL_BASE, GET_GTOKEN_ID, unsigned long long)
 #define ACCESS_TOKENID_SET_FTOKENID \
-        _IOW(ACCESS_TOKEN_ID_IOCTL_BASE, set_ftoken_id, unsigned long long)
+        _IOW(ACCESS_TOKEN_ID_IOCTL_BASE, SET_GTOKEN_ID, unsigned long long)
 
 #define LIST_NUM_1    1
 #define LIST_NUM_2    2
@@ -69,20 +69,20 @@ int SetfTokenid(unsigned long long *ftoken);
 void SetUidAndGrp();
 void SetUidAndGrpOther();
 void GetCurToken(unsigned long long *token);
-void SetRandTokenAndCheck(unsigned long long *data_token);
-void TokenTest(unsigned long long *data_token);
-void ThreadTest(unsigned long long *data_token);
-int AccessTokenidThreadTest(uint8_t *data_token);
-int AccessTokenidGrpTest(uint8_t *data_token);
-int AccessTokenidGrpTestOther(uint8_t *data_token);
+void SetRandTokenAndCheck(unsigned long long *dataToken);
+void TokenTest(unsigned long long *dataToken);
+void ThreadTest(unsigned long long *dataToken);
+int AccessTokenidThreadTest(uint8_t *dataToken);
+int AccessTokenidGrpTest(uint8_t *dataToken);
+int AccessTokenidGrpTestOther(uint8_t *dataToken);
 
 void GetCurfToken(unsigned long long *ftoken);
-void SetRandfTokenAndCheck(unsigned long long *data_ftoken);
-void fTokenTest(unsigned long long *data_ftoken);
-void ThreadTest(unsigned long long *data_ftoken);
-int AccessfTokenidThreadTest(uint8_t *data_ftoken);
-int AccessfTokenidGrpTest(uint8_t *data_ftoken);
-int AccessfTokenidGrpTestOther(uint8_t *data_ftoken);
+void SetRandfTokenAndCheck(unsigned long long *dataFtoken);
+void FTokenTest(unsigned long long *dataFtoken);
+void ThreadTest(unsigned long long *dataFtoken);
+int AccessfTokenidThreadTest(uint8_t *dataFtoken);
+int AccessfTokenidGrpTest(uint8_t *dataFtoken);
+int AccessfTokenidGrpTestOther(uint8_t *dataFtoken);
 bool SetfTokenidCmdFuzzTest(const uint8_t *data, size_t size);
 bool GetfTokenidCmdFuzzTest(const uint8_t *data, size_t size);
 bool SetTokenidCmdFuzzTest(const uint8_t *data, size_t size);

test/fuzztest/accesstokenid/src/accesstokenidcommon.cpp

@@ -34,7 +34,7 @@ int GetTokenid(unsigned long long *token)
         return -1;
     }
     int ret = ioctl(fd, ACCESS_TOKENID_GET_TOKENID, token);
-    if (ret) {
+    if (ret != 0) {
         close(fd);
         return -1;
     }
@@ -49,7 +49,7 @@ int SetTokenid(unsigned long long *token)
         return -1;
     }
     int ret = ioctl(fd, ACCESS_TOKENID_SET_TOKENID, token);
-    if (ret) {
+    if (ret != 0) {
         close(fd);
         return -1;
     }
@@ -95,12 +95,12 @@ void SetUidAndGrpOther()
     return;
 }
 
-void SetRandTokenAndCheck(unsigned long long *data_token)
+void SetRandTokenAndCheck(unsigned long long *dataToken)
 {
     pid_t pid = getpid();
     pid_t tid = syscall(__NR_gettid);
     unsigned long long token = INVAL_TOKEN;
-    unsigned long long tokenSet = *data_token;
+    unsigned long long tokenSet = *dataToken;
 
     SetTokenid(&tokenSet);
     GetTokenid(&token);
@@ -126,62 +126,61 @@ void SetRandTokenAndCheck(unsigned long long *data_token)
     return;
 }
 
-void *TokenTest(void *data_token)
+void *TokenTest(void *dataToken)
 {
-    SetRandTokenAndCheck(static_cast<unsigned long long *>(data_token));
-
+    SetRandTokenAndCheck(static_cast<unsigned long long *>(dataToken));
     return nullptr;
 }
 
-void ThreadTest(void *data_token)
+void ThreadTest(void *dataToken)
 {
-    pthread_t id_1;
-    pthread_t id_2;
-    pthread_t id_3;
+    pthread_t tid1;
+    pthread_t tid2;
+    pthread_t tid3;
     int ret = 0;
 
-    ret = pthread_create(&id_1, nullptr, TokenTest, data_token);
+    ret = pthread_create(&tid1, nullptr, TokenTest, dataToken);
     if (ret != 0) {
         return;
     }
   
-    ret = pthread_create(&id_2, nullptr, TokenTest, data_token);
+    ret = pthread_create(&tid2, nullptr, TokenTest, dataToken);
     if (ret != 0) {
         return;
     }
 
-    ret = pthread_create(&id_3, nullptr, TokenTest, data_token);
+    ret = pthread_create(&tid3, nullptr, TokenTest, dataToken);
     if (ret != 0) {
         return;
     }
 
-    pthread_join(id_1, nullptr);
-    pthread_join(id_2, nullptr);
-    pthread_join(id_3, nullptr);
+    pthread_join(tid1, nullptr);
+    pthread_join(tid2, nullptr);
+    pthread_join(tid3, nullptr);
 
     return;
 }
 
-int AccessTokenidThreadTest(uint8_t *data_token)
+int AccessTokenidThreadTest(uint8_t *dataToken)
 {
-    TokenTest(static_cast<void *>(data_token));
-    ThreadTest(static_cast<void *>(data_token));
+    TokenTest(static_cast<void *>(dataToken));
+    ThreadTest(static_cast<void *>(dataToken));
     return 0;
 }
 
-int AccessTokenidGrpTest(uint8_t *data_token)
+int AccessTokenidGrpTest(uint8_t *dataToken)
 {
     SetUidAndGrp();
-    TokenTest(static_cast<void *>(data_token));
-    ThreadTest(static_cast<void *>(data_token));
+    TokenTest(static_cast<void *>(dataToken));
+    ThreadTest(static_cast<void *>(dataToken));
     return 0;
 }
 
-int AccessTokenidGrpTestOther(uint8_t *data_token)
+int AccessTokenidGrpTestOther(uint8_t *dataToken)
 {
     SetUidAndGrpOther();
-    TokenTest(static_cast<void *>(data_token));
-    ThreadTest(static_cast<void *>(data_token));
+    TokenTest(static_cast<void *>(dataToken));
+    ThreadTest(static_cast<void *>(dataToken));
     return 0;
 }
 
@@ -193,7 +192,7 @@ int GetfTokenid(unsigned long long *ftoken)
     }
 
     int ret = ioctl(fd, ACCESS_TOKENID_GET_FTOKENID, ftoken);
-    if (ret) {
+    if (ret != 0) {
         close(fd);
         return -1;
     }
@@ -210,7 +209,7 @@ int SetfTokenid(unsigned long long *ftoken)
     }
 
     int ret = ioctl(fd, ACCESS_TOKENID_SET_FTOKENID, ftoken);
-    if (ret) {
+    if (ret != 0) {
         close(fd);
         return -1;
     }
@@ -219,12 +218,12 @@ int SetfTokenid(unsigned long long *ftoken)
     return 0;
 }
 
-void SetRandfTokenAndCheck(unsigned long long *data_ftoken)
+void SetRandfTokenAndCheck(unsigned long long *dataFtoken)
 {
     pid_t pid = getpid();
     pid_t tid = syscall(__NR_gettid);
     unsigned long long ftoken = INVAL_TOKEN;
-    unsigned long long ftokenSet = *data_ftoken;
+    unsigned long long ftokenSet = *dataFtoken;
 
     SetfTokenid(&ftokenSet);
     GetfTokenid(&ftoken);
@@ -250,32 +249,32 @@ void SetRandfTokenAndCheck(unsigned long long *data_ftoken)
     return;
 }
 
-void *fTokenTest(void *data_ftoken)
+void *FTokenTest(void *dataFtoken)
 {
-    SetRandfTokenAndCheck(static_cast<unsigned long long *>(data_ftoken));
+    SetRandfTokenAndCheck(static_cast<unsigned long long *>(dataFtoken));
     return nullptr;
 }
 
-int AccessfTokenidThreadTest(uint8_t *data_ftoken)
+int AccessfTokenidThreadTest(uint8_t *dataFtoken)
 {
-    fTokenTest(static_cast<void *>(data_ftoken));
-    ThreadTest(static_cast<void *>(data_ftoken));
+    FTokenTest(static_cast<void *>(dataFtoken));
+    ThreadTest(static_cast<void *>(dataFtoken));
     return 0;
 }
 
-int AccessfTokenidGrpTest(uint8_t *data_ftoken)
+int AccessfTokenidGrpTest(uint8_t *dataFtoken)
 {
     SetUidAndGrp();
-    fTokenTest(static_cast<void *>(data_ftoken));
-    ThreadTest(static_cast<void *>(data_ftoken));
+    FTokenTest(static_cast<void *>(dataFtoken));
+    ThreadTest(static_cast<void *>(dataFtoken));
     return 0;
 }
 
-int AccessfTokenidGrpTestOther(uint8_t *data_ftoken)
+int AccessfTokenidGrpTestOther(uint8_t *dataFtoken)
 {
     SetUidAndGrpOther();
-    fTokenTest(static_cast<void *>(data_ftoken));
-    ThreadTest(static_cast<void *>(data_ftoken));
+    FTokenTest(static_cast<void *>(dataFtoken));
+    ThreadTest(static_cast<void *>(dataFtoken));
     return 0;
 }
 

test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/anonrefaultsnapshotmininterval_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool AnonRefaultSnapshotMinIntervalFuzzer(const uint8_t *data, size_t size)
 {
-    const char *anon_refault_snapshot_min_interval = "/dev/memcg/memory.anon_refault_snapshot_min_interval";
-    bool ret = MemoryFuzzTest(data, size, anon_refault_snapshot_min_interval);
+    const char *anonRefaultSnapshotMinInterval = "/dev/memcg/memory.anon_refault_snapshot_min_interval";
+    bool ret = MemoryFuzzTest(data, size, anonRefaultSnapshotMinInterval);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/appscore_fuzzer/appscore_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool AppScoreFuzzer(const uint8_t *data, size_t size)
 {
-    const char *app_score = "/dev/memcg/memory.app_score";
-    bool ret = MemoryFuzzTest(data, size, app_score);
+    const char *appScore = "/dev/memcg/memory.app_score";
+    bool ret = MemoryFuzzTest(data, size, appScore);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/areaanonrefaultthreshold_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool AreaAnonRefaultThresholdFuzzer(const uint8_t *data, size_t size)
 {
-    const char *area_anon_refault_threshold = "/dev/memcg/memory.area_anon_refault_threshold";
-    bool ret = MemoryFuzzTest(data, size, area_anon_refault_threshold);
+    const char *areaAnonRefaultThreshold = "/dev/memcg/memory.area_anon_refault_threshold";
+    bool ret = MemoryFuzzTest(data, size, areaAnonRefaultThreshold);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/availbuffers_fuzzer/availbuffers_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool AvailBuffersFuzzer(const uint8_t *data, size_t size)
 {
-    const char *avail_buffers = "/dev/memcg/memory.avail_buffers";
-    bool ret = MemoryFuzzTest(data, size, avail_buffers);
+    const char *availBuffers = "/dev/memcg/memory.avail_buffers";
+    bool ret = MemoryFuzzTest(data, size, availBuffers);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/bufferratioparams_fuzzer/bufferratioparams_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool BufferRatioParamsFuzzer(const uint8_t *data, size_t size)
 {
-    const char *buffer_ratio_params = "/dev/memcg/memory.buffer_ratio_params";
-    bool ret = MemoryFuzzTest(data, size, buffer_ratio_params);
+    const char *bufferRatioParams = "/dev/memcg/memory.buffer_ratio_params";
+    bool ret = MemoryFuzzTest(data, size, bufferRatioParams);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/compressratio_fuzzer/compressratio_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool CompressRatioFuzzer(const uint8_t *data, size_t size)
 {
-    const char *compress_ratio = "/dev/memcg/memory.compress_ratio";
-    bool ret = MemoryFuzzTest(data, size, compress_ratio);
+    const char *compressRatio = "/dev/memcg/memory.compress_ratio";
+    bool ret = MemoryFuzzTest(data, size, compressRatio);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/emptyroundcheckthreshold_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool EmptyRoundCheckThresholdFuzzer(const uint8_t *data, size_t size)
 {
-    const char *empty_round_check_threshold = "/dev/memcg/memory.empty_round_check_threshold";
-    bool ret = MemoryFuzzTest(data, size, empty_round_check_threshold);
+    const char *emptyRoundCheckThreshold = "/dev/memcg/memory.empty_round_check_threshold";
+    bool ret = MemoryFuzzTest(data, size, emptyRoundCheckThreshold);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/emptyroundskipinterval_fuzzer/emptyroundskipinterval_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool EmptyRoundSkipIntervalFuzzer(const uint8_t *data, size_t size)
 {
-    const char *empty_round_skip_interval = "/dev/memcg/memory.empty_round_skip_interval";
-    bool ret = MemoryFuzzTest(data, size, empty_round_skip_interval);
+    const char *emptyRoundSkipInterval = "/dev/memcg/memory.empty_round_skip_interval";
+    bool ret = MemoryFuzzTest(data, size, emptyRoundSkipInterval);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/forceshrinkanon_fuzzer/forceshrinkanon_fuzzer.cpp

@@ -14,24 +14,22 @@
  */
 
 #include <cstdio>
-#include <cstddef>
 #include <cstdint>
 #include <unistd.h>
 #include <fcntl.h>
-#include "memorycommon.h"
 
 namespace OHOS {
 bool ForceShrinkAnonFuzzer(const uint8_t *data, size_t size)
 {
-    const char *force_shrink_anon = "/dev/memcg/memory.force_shrink_anon";
-    int fd = open(force_shrink_anon, O_RDWR);
+    const char *forceShrinkAnon = "/dev/memcg/memory.force_shrink_anon";
+    int fd = open(forceShrinkAnon, O_RDWR);
     if (fd < 0) {
         return false;
     }
 
     int ret = write(fd, data, size);
     if (ret < 0) {
-        printf("%s write fail\n", force_shrink_anon);
+        printf("%s write fail\n", forceShrinkAnon);
         close(fd);
         return false;
     }

test/fuzztest/memory/maxskipinterval_fuzzer/maxskipinterval_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool MaxSkipIntervalFuzzer(const uint8_t *data, size_t size)
 {
-    const char *max_skip_interval = "/dev/memcg/memory.max_skip_interval";
-    bool ret = MemoryFuzzTest(data, size, max_skip_interval);
+    const char *maxSkipInterval = "/dev/memcg/memory.max_skip_interval";
+    bool ret = MemoryFuzzTest(data, size, maxSkipInterval);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/ubufs2zramratio_fuzzer/ubufs2zramratio_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool UbUfs2zramRatioFuzzer(const uint8_t *data, size_t size)
 {
-    const char *ub_ufs2zram_ratio = "/dev/memcg/memory.ub_ufs2zram_ratio";
-    bool ret = MemoryFuzzTest(data, size, ub_ufs2zram_ratio);
+    const char *ubUfs2zramRatio = "/dev/memcg/memory.ub_ufs2zram_ratio";
+    bool ret = MemoryFuzzTest(data, size, ubUfs2zramRatio);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/zramcriticalthreshold_fuzzer/zramcriticalthreshold_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool ZramCriticalThresholdFuzzer(const uint8_t *data, size_t size)
 {
-    const char *zram_critical_threshold = "/dev/memcg/memory.zram_critical_threshold";
-    bool ret = MemoryFuzzTest(data, size, zram_critical_threshold);
+    const char *zramCriticalThreshold = "/dev/memcg/memory.zram_critical_threshold";
+    bool ret = MemoryFuzzTest(data, size, zramCriticalThreshold);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/zramwmratio_fuzzer/zramwmratio_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool ZramWmRatioFuzzer(const uint8_t *data, size_t size)
 {
-    const char *zram_wr_ratio = "/dev/memcg/memory.zram_wm_ratio";
-    bool ret = MemoryFuzzTest(data, size, zram_wr_ratio);
+    const char *zramWrRatio = "/dev/memcg/memory.zram_wm_ratio";
+    bool ret = MemoryFuzzTest(data, size, zramWrRatio);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/zswapdmaxreclaimsize_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool ZswapdMaxReclaimSizeFuzzer(const uint8_t *data, size_t size)
 {
-    const char *zswapd_max_reclaim_size = "/dev/memcg/memory.zswapd_max_reclaim_size";
-    bool ret = MemoryFuzzTest(data, size, zswapd_max_reclaim_size);
+    const char *zswapdMaxReclaimSize = "/dev/memcg/memory.zswapd_max_reclaim_size";
+    bool ret = MemoryFuzzTest(data, size, zswapdMaxReclaimSize);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/zswapdmemcgsparam_fuzzer/zswapdmemcgsparam_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool ZswapdMemcgsParamFuzzer(const uint8_t *data, size_t size)
 {
-    const char *zswapd_memcgs_param = "/dev/memcg/memory.zswapd_memcgs_param";
-    bool ret = MemoryFuzzTest(data, size, zswapd_memcgs_param);
+    const char *zswapdMemcgsParam = "/dev/memcg/memory.zswapd_memcgs_param";
+    bool ret = MemoryFuzzTest(data, size, zswapdMemcgsParam);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/zswapdpressureshow_fuzzer/zswapdpressureshow_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool ZswapdPressureShowFuzzer(const uint8_t *data, size_t size)
 {
-    const char *zswapd_pressure_show = "/dev/memcg/memory.zswapd_pressure_show";
-    bool ret = MemoryFuzzTest(data, size, zswapd_pressure_show);
+    const char *zswapdPressureShow = "/dev/memcg/memory.zswapd_pressure_show";
+    bool ret = MemoryFuzzTest(data, size, zswapdPressureShow);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/zswapdsinglememcgparam_fuzzer.cpp

@@ -20,8 +20,8 @@
 namespace OHOS {
 bool ZswapdSingleMemcgParamFuzzer(const uint8_t *data, size_t size)
 {
-    const char *zswapd_single_memcg_param = "/dev/memcg/memory.zswapd_single_memcg_param";
-    bool ret = MemoryFuzzTest(data, size, zswapd_single_memcg_param);
+    const char *zswapdSingleMemcgParam = "/dev/memcg/memory.zswapd_single_memcg_param";
+    bool ret = MemoryFuzzTest(data, size, zswapdSingleMemcgParam);
     return ret;
 }
 } // namespace OHOS

test/fuzztest/sched/beginframefreq_fuzzer/beginframefreq_fuzzer.cpp

@@ -25,14 +25,14 @@ namespace OHOS {
 bool BeginFrameFreqFuzzTest(const uint8_t *data, size_t size)
 {
     bool ret = false;
-    constexpr int margin_upper_limit_time = 32000;
-    constexpr int margin_lower_limit_time = -32000;
+    constexpr int marginUpperLimitTime = 32000;
+    constexpr int marginLowerLimitTime = -32000;
     if (data == nullptr) {
         return ret;
     } else {
         uint8_t *countData = const_cast<uint8_t *>(data);
         int margin = *(reinterpret_cast<int *>(countData));
-        if (margin < margin_lower_limit_time || margin > margin_upper_limit_time) {
+        if (margin < marginLowerLimitTime || margin > marginUpperLimitTime) {
             return ret;
         }
         int grpId = 2;

test/fuzztest/sched/setmargin_fuzzer/setmargin_fuzzer.cpp

@@ -25,14 +25,14 @@ namespace OHOS {
 bool SetMarginFuzzTest(const uint8_t *data, size_t size)
 {
     bool ret = false;
-    constexpr int margin_upper_limit_time = 32000;
-    constexpr int margin_lower_limit_time = -32000;
+    constexpr int marginUpperLimitTime = 32000;
+    constexpr int marginLowerLimitTime = -32000;
     if (data == nullptr) {
         return ret;
     } else {
         uint8_t *countData = const_cast<uint8_t *>(data);
         int margin = *(reinterpret_cast<int *>(countData));
-        if (margin < margin_lower_limit_time || margin > margin_upper_limit_time) {
+        if (margin < marginLowerLimitTime || margin > marginUpperLimitTime) {
             return ret;
         }
         int grpId = 2;