diff --git a/base/test/benchmarktest/datatime_benchmark_test/datatime_benchmark_test.cpp b/base/test/benchmarktest/datatime_benchmark_test/datatime_benchmark_test.cpp
index 2f98a1238f4a3f87b62234d1173ad5717b484767..0e418c41584927ca877608019403e83048f2fa81 100644
--- a/base/test/benchmarktest/datatime_benchmark_test/datatime_benchmark_test.cpp
+++ b/base/test/benchmarktest/datatime_benchmark_test/datatime_benchmark_test.cpp
@@ -26,22 +26,23 @@ namespace {
 
 class BenchmarkDateTimeTest : public benchmark::Fixture {
 public:
-    BenchmarkDateTimeTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkDateTimeTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkDateTimeTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkDateTimeTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 1000;
diff --git a/base/test/benchmarktest/directory_benchmark_test/directory_benchmark_test.cpp b/base/test/benchmarktest/directory_benchmark_test/directory_benchmark_test.cpp
index 7a40c95a58d09cac69cd8080a8628a3f8a2a58ac..efac76ff76dc809e86a9405bca9a6eda47d9f14c 100644
--- a/base/test/benchmarktest/directory_benchmark_test/directory_benchmark_test.cpp
+++ b/base/test/benchmarktest/directory_benchmark_test/directory_benchmark_test.cpp
@@ -29,22 +29,23 @@ namespace {
 
 class BenchmarkDirectoryTest : public benchmark::Fixture {
 public:
-    BenchmarkDirectoryTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkDirectoryTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkDirectoryTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkDirectoryTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 1000;
diff --git a/base/test/benchmarktest/event_benchmark_test/event_benchmark_test.cpp b/base/test/benchmarktest/event_benchmark_test/event_benchmark_test.cpp
index 53b68c4e52b07f96a2c7eae8b0cc77f018761237..1a422984b66b13c8c00af860520b0e6824a849b8 100644
--- a/base/test/benchmarktest/event_benchmark_test/event_benchmark_test.cpp
+++ b/base/test/benchmarktest/event_benchmark_test/event_benchmark_test.cpp
@@ -1048,7 +1048,7 @@ int64_t CurMs()
 std::atomic<int> g_data1(0);
 void TimeOutCallback1()
 {
-    g_data1 += 1;
+    g_data1 = g_data1 + 1;
 }
 
 std::atomic<int> g_data2(0);
@@ -1141,7 +1141,7 @@ public:
 private:
     void TimeOutProc()
     {
-        data_ -= 1;
+        data_ = data_ - 1;
     };
     int data_;
     Timer timer_;
diff --git a/base/test/benchmarktest/file_benchmark_test/file_benchmark_test.cpp b/base/test/benchmarktest/file_benchmark_test/file_benchmark_test.cpp
index b14837dc0fc05a0e9678b8fac12b3421759e34c6..8edbd2ca135e798065998782d852f6d67ff41950 100644
--- a/base/test/benchmarktest/file_benchmark_test/file_benchmark_test.cpp
+++ b/base/test/benchmarktest/file_benchmark_test/file_benchmark_test.cpp
@@ -37,22 +37,23 @@ static constexpr int EXCEEDS_MAXIMUM_LENGTH = 32 * 1024 * 1024 + 1;
 
 class BenchmarkFileTest : public benchmark::Fixture {
 public:
-    BenchmarkFileTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkFileTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkFileTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkFileTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 1000;
diff --git a/base/test/benchmarktest/observer_benchmark_test/observer_benchmark_test.cpp b/base/test/benchmarktest/observer_benchmark_test/observer_benchmark_test.cpp
index 1877e9597e498d6b07e5e49ddfc1aad086ac7b7b..9a8ecda5430602a1c6ccce3d6512667e80baa94a 100644
--- a/base/test/benchmarktest/observer_benchmark_test/observer_benchmark_test.cpp
+++ b/base/test/benchmarktest/observer_benchmark_test/observer_benchmark_test.cpp
@@ -27,22 +27,23 @@ namespace {
 
 class BenchmarkObserverTest : public benchmark::Fixture {
 public:
-    BenchmarkObserverTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkObserverTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkObserverTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkObserverTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 1000;
diff --git a/base/test/benchmarktest/parcel_benchmark_test/parcel_benchmark_test.cpp b/base/test/benchmarktest/parcel_benchmark_test/parcel_benchmark_test.cpp
index 4974c60a2dbc17e7836eea04956faeb2908aff6b..4e1eeee284391ffb9c258ab457d718e267d087cc 100644
--- a/base/test/benchmarktest/parcel_benchmark_test/parcel_benchmark_test.cpp
+++ b/base/test/benchmarktest/parcel_benchmark_test/parcel_benchmark_test.cpp
@@ -45,22 +45,23 @@ static constexpr int32_t WRITE_AND_CMP_INT32_VALUE = 5;
 
 class BenchmarkParcelTest : public benchmark::Fixture {
 public:
-    BenchmarkParcelTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkParcelTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkParcelTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkParcelTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 1000;
diff --git a/base/test/benchmarktest/refbase_benchmark_test/refbase_benchmark_test.cpp b/base/test/benchmarktest/refbase_benchmark_test/refbase_benchmark_test.cpp
index f151d195c1b917c9e6f293a5e7bf195ac7089c45..bb3f0551cd6146cec65f9517c549916949e16749 100644
--- a/base/test/benchmarktest/refbase_benchmark_test/refbase_benchmark_test.cpp
+++ b/base/test/benchmarktest/refbase_benchmark_test/refbase_benchmark_test.cpp
@@ -1297,7 +1297,7 @@ BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase001)(benchmark::State& state)
         // test wptr<T>::wptr(const sptr<T>&)
         sptr<WptrTest> testOrigSptrObject(new WptrTest());
         AssertEqual(testOrigSptrObject->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE,
-            "testOrigSptrObject->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state);
+            "testOrigSptrObject->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE as expected.", state);
 
         wptr<WptrTest> testTargetWptrObject3(testOrigSptrObject);
         CompOrigSptrAndTarWptr002(testOrigSptrObject, testTargetWptrObject3, EXPECTED_REF_COUNT_TWO, state);
@@ -1305,7 +1305,7 @@ BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase001)(benchmark::State& state)
         // test wptr<T>::operator=(const sptr<T>&)
         wptr<WptrTest> testTargetWptrObject4(new WptrTest());
         AssertEqual(testTargetWptrObject4->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE,
-            "testTargetWptrObject4->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state);
+            "testTargetWptrObject4->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE as expected.", state);
 
         testTargetWptrObject4 = testOrigSptrObject;
         CompOrigSptrAndTarWptr002(testOrigSptrObject, testTargetWptrObject4, EXPECTED_REF_COUNT_THREE, state);
diff --git a/base/test/benchmarktest/rwlock_benchmark_test/rwlock_benchmark_test.cpp b/base/test/benchmarktest/rwlock_benchmark_test/rwlock_benchmark_test.cpp
index 866468dce3f83dd92a79711c278d006e35e3f02f..7711276d7ef33b5801ac1846676015b0dcbb3d78 100644
--- a/base/test/benchmarktest/rwlock_benchmark_test/rwlock_benchmark_test.cpp
+++ b/base/test/benchmarktest/rwlock_benchmark_test/rwlock_benchmark_test.cpp
@@ -26,22 +26,23 @@ namespace {
 
 class BenchmarkRWLockTest : public benchmark::Fixture {
 public:
-    BenchmarkRWLockTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkRWLockTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkRWLockTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkRWLockTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 1000;
diff --git a/base/test/benchmarktest/safe_block_queue_benchmark_test/safe_block_queue_benchmark_test.cpp b/base/test/benchmarktest/safe_block_queue_benchmark_test/safe_block_queue_benchmark_test.cpp
index 6d0a55af6406a43caece5774caa661d2c3ca7ede..0570adc004f774366cb963c0fae59887140712cf 100644
--- a/base/test/benchmarktest/safe_block_queue_benchmark_test/safe_block_queue_benchmark_test.cpp
+++ b/base/test/benchmarktest/safe_block_queue_benchmark_test/safe_block_queue_benchmark_test.cpp
@@ -30,22 +30,23 @@ namespace {
 
 class BenchmarkSafeBlockQueue : public benchmark::Fixture {
 public:
-    BenchmarkSafeBlockQueue()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkSafeBlockQueue() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkSafeBlockQueue()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkSafeBlockQueue() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 100;
@@ -66,18 +67,17 @@ public:
     static SafeBlockQueue<int> shareQueue;
     bool putStatus;
     bool getStatus;
+    void Get()
+    {
+        shareQueue.Pop();
+        getStatus = true;
+    }
 
     void Put(int i)
     {
         shareQueue.Push(i);
         putStatus = true;
     }
-
-    void Get()
-    {
-        shareQueue.Pop();
-        getStatus = true;
-    }
 };
 
 SafeBlockQueue<int> DemoThreadData::shareQueue(QUEUE_SLOTS);
@@ -87,30 +87,30 @@ void PutHandleThreadData(DemoThreadData& q, int i)
     q.Put(i);
 }
 
-void GetThreadDatePushedStatus(std::array<DemoThreadData, THREAD_NUM>& demoDatas, unsigned int& pushedIn,
-    unsigned int& unpushedIn)
+void GetThreadDateGetedStatus(std::array<DemoThreadData, THREAD_NUM>& demoDatas, unsigned int& getedOut,
+    unsigned int& ungetedOut)
 {
-    pushedIn = 0;
-    unpushedIn = 0;
+    ungetedOut = 0;
+    getedOut = 0;
     for (auto& t : demoDatas) {
-        if (t.putStatus) {
-            pushedIn++;
+        if (t.getStatus) {
+            getedOut++;
         } else {
-            unpushedIn++;
+            ungetedOut++;
         }
     }
 }
 
-void GetThreadDateGetedStatus(std::array<DemoThreadData, THREAD_NUM>& demoDatas, unsigned int& getedOut,
-    unsigned int& ungetedOut)
+void GetThreadDatePushedStatus(std::array<DemoThreadData, THREAD_NUM>& demoDatas, unsigned int& pushedIn,
+    unsigned int& unpushedIn)
 {
-    getedOut = 0;
-    ungetedOut = 0;
+    unpushedIn = 0;
+    pushedIn = 0;
     for (auto& t : demoDatas) {
-        if (t.getStatus) {
-            getedOut++;
+        if (t.putStatus) {
+            pushedIn++;
         } else {
-            ungetedOut++;
+            unpushedIn++;
         }
     }
 }
@@ -137,6 +137,22 @@ auto GetTimeOfSleepTwentyMillisecond()
     return timeT;
 }
 
+static void QueuePushFullEquivalent(const int Equivalent, benchmark::State& state)
+{
+    for (unsigned int i = 0; i < QUEUE_SLOTS; i++) {
+        DemoThreadData::shareQueue.Push(Equivalent);
+    }
+    AssertTrue((DemoThreadData::shareQueue.IsFull()), "shareQueue.IsFull() did not equal true.", state);
+}
+
+static void QueuePushInnotfullNotEquivalent(const unsigned int remain)
+{
+    for (unsigned int i = 0; i < QUEUE_SLOTS - remain; i++) {
+        int t = i;
+        DemoThreadData::shareQueue.Push(t);
+    }
+}
+
 /*
  * @tc.name: testPut001
  * @tc.desc: Single-threaded call put and get to determine that the normal scenario
@@ -290,7 +306,7 @@ BENCHMARK_F(BenchmarkSafeBlockQueue, testMutilthreadConcurrentPutAndBlockInfullq
         GetThreadDatePushedStatus(demoDatas, pushedIn, unpushedIn);
         AssertEqual(pushedIn, static_cast<unsigned int>(0),
             "pushedIn did not equal static_cast<unsigned int>(0) as expected.", state);
-        AssertEqual(unpushedIn, THREAD_NUM, "unpushedIn did not equal THREAD_NUM as expected.", state);
+        AssertEqual(unpushedIn, THREAD_NUM, "unpushedIn did not equal THREAD_NUM.", state);
         AssertTrue((DemoThreadData::shareQueue.IsFull()),
             "DemoThreadData::shareQueue.IsFull() did not equal true as expected.", state);
         for (unsigned int i = 0; i < THREAD_NUM; i++) {
@@ -379,11 +395,7 @@ BENCHMARK_F(BenchmarkSafeBlockQueue, testMutilthreadConcurrentGetAndBlockInfullq
         AssertTrue((DemoThreadData::shareQueue.IsEmpty()),
             "DemoThreadData::shareQueue.IsEmpty() did not equal true as expected.", state);
         int t = 1;
-        for (unsigned int i = 0; i < QUEUE_SLOTS; i++) {
-            DemoThreadData::shareQueue.Push(t);
-        }
-        AssertTrue((DemoThreadData::shareQueue.IsFull()),
-            "DemoThreadData::shareQueue.IsFull() did not equal true as expected.", state);
+        QueuePushFullEquivalent(t, state);
         for (unsigned int i = 0; i < THREAD_NUM; i++) {
             threads[i] = std::thread(GetHandleThreadDataTime,
                                      std::ref(demoDatas[i]), i, timeT);
@@ -430,12 +442,8 @@ BENCHMARK_F(BenchmarkSafeBlockQueue, testMutilthreadConcurrentGetAndBlockInnotfu
         demoDatas.fill(DemoThreadData());
         auto timeT = GetTimeOfSleepTwentyMillisecond();
         const unsigned int REMAIN_SLOTS = 5;
-        AssertTrue((DemoThreadData::shareQueue.IsEmpty()),
-            "DemoThreadData::shareQueue.IsEmpty() did not equal true as expected.", state);
-        for (unsigned int i = 0; i < QUEUE_SLOTS - REMAIN_SLOTS; i++) {
-            int t = i;
-            DemoThreadData::shareQueue.Push(t);
-        }
+        AssertTrue((DemoThreadData::shareQueue.IsEmpty()), "shareQueue.IsEmpty() did not equal true.", state);
+        QueuePushInnotfullNotEquivalent(REMAIN_SLOTS);
         for (unsigned int i = 0; i < THREAD_NUM; i++) {
             threads[i] = std::thread(GetHandleThreadDataTime,
                 std::ref(demoDatas[i]), i, timeT);
@@ -481,12 +489,8 @@ BENCHMARK_F(BenchmarkSafeBlockQueue, testMutilthreadConcurrentPutAndBlockInnotfu
         demoDatas.fill(DemoThreadData());
         auto timeT = GetTimeOfSleepTwentyMillisecond();
         const unsigned int REMAIN_SLOTS = 5;
-        AssertTrue((DemoThreadData::shareQueue.IsEmpty()),
-            "DemoThreadData::shareQueue.IsEmpty() did not equal true as expected.", state);
-        for (unsigned int i = 0; i < QUEUE_SLOTS - REMAIN_SLOTS; i++) {
-            int t = i;
-            DemoThreadData::shareQueue.Push(t);
-        }
+        AssertTrue((DemoThreadData::shareQueue.IsEmpty()), "shareQueue.IsEmpty() did not equal true.", state);
+        QueuePushInnotfullNotEquivalent(REMAIN_SLOTS);
         for (unsigned int i = 0; i < THREAD_NUM; i++) {
             threads[i] = std::thread(PutHandleThreadDataTime,
                 std::ref(demoDatas[i]), i, timeT);
@@ -582,11 +586,7 @@ BENCHMARK_F(BenchmarkSafeBlockQueue, testMutilthreadConcurrentGetAndPopInfullque
         AssertTrue((DemoThreadData::shareQueue.IsEmpty()),
             "DemoThreadData::shareQueue.IsEmpty() did not equal true as expected.", state);
         int t = 1;
-        for (unsigned int i = 0; i < QUEUE_SLOTS; i++) {
-            DemoThreadData::shareQueue.Push(t);
-        }
-        AssertTrue((DemoThreadData::shareQueue.IsFull()),
-            "DemoThreadData::shareQueue.IsFull() did not equal true as expected.", state);
+        QueuePushFullEquivalent(t, state);
         for (unsigned int i = 0; i < THREAD_NUM; i++) {
             threadsin[i] = std::thread(PutHandleThreadDataTime,
                 std::ref(demoDatas[i]), i, timeT);
diff --git a/base/test/benchmarktest/safe_block_queue_tracking_benchmark_test/safe_block_queue_tracking_benchmark_test.cpp b/base/test/benchmarktest/safe_block_queue_tracking_benchmark_test/safe_block_queue_tracking_benchmark_test.cpp
index a89f26d8213eb4de20332c12648cb2ea19677f4f..218f5adbd3a049509b7958e3292e421e343c34c9 100644
--- a/base/test/benchmarktest/safe_block_queue_tracking_benchmark_test/safe_block_queue_tracking_benchmark_test.cpp
+++ b/base/test/benchmarktest/safe_block_queue_tracking_benchmark_test/safe_block_queue_tracking_benchmark_test.cpp
@@ -103,30 +103,30 @@ void PutHandleThreadData(DemoThreadData& q, int i)
     q.Put(i);
 }
 
-void GetThreadDatePushedStatus(std::array<DemoThreadData, THREAD_NUM>& demoDatas, unsigned int& pushedIn,
-    unsigned int& unpushedIn)
+void GetThreadDateGetedStatus(std::array<DemoThreadData, THREAD_NUM>& demoDatas, unsigned int& getedOut,
+    unsigned int& ungetedOut)
 {
-    pushedIn = 0;
-    unpushedIn = 0;
+    getedOut = 0;
+    ungetedOut = 0;
     for (auto& t : demoDatas) {
-        if (t.putStatus) {
-            pushedIn++;
+        if (t.getStatus) {
+            getedOut += 1;
         } else {
-            unpushedIn++;
+            ungetedOut += 1;
         }
     }
 }
 
-void GetThreadDateGetedStatus(std::array<DemoThreadData, THREAD_NUM>& demoDatas, unsigned int& getedOut,
-    unsigned int& ungetedOut)
+void GetThreadDatePushedStatus(std::array<DemoThreadData, THREAD_NUM>& demoDatas, unsigned int& pushedIn,
+    unsigned int& unpushedIn)
 {
-    getedOut = 0;
-    ungetedOut = 0;
+    pushedIn = 0;
+    unpushedIn = 0;
     for (auto& t : demoDatas) {
-        if (t.getStatus) {
-            getedOut++;
+        if (t.putStatus) {
+            pushedIn += 1;
         } else {
-            ungetedOut++;
+            unpushedIn += 1;
         }
     }
 }
diff --git a/base/test/benchmarktest/safe_map_benchmark_test/safe_map_benchmark_test.cpp b/base/test/benchmarktest/safe_map_benchmark_test/safe_map_benchmark_test.cpp
index e035c1fd8a2b34df5d4c7997b26f7ca048ad5cc8..88ee0f9b683783415330b1dbf7ea84878295eab2 100644
--- a/base/test/benchmarktest/safe_map_benchmark_test/safe_map_benchmark_test.cpp
+++ b/base/test/benchmarktest/safe_map_benchmark_test/safe_map_benchmark_test.cpp
@@ -517,8 +517,8 @@ BENCHMARK_F(BenchmarkSafeMap, testUtilsConcurrentWriteAndFind001)(benchmark::Sta
     std::thread threads[THREAD_NUM];
     std::vector<std::future<int>> vcfi;
     while (state.KeepRunning()) {
-        auto lamfuncInsert = [](SafeMap<string, int>& data, const string& key,
-            const int& value, std::chrono::time_point<std::chrono::high_resolution_clock> absTime) {
+        auto lamfuncInsert = [](SafeMap<string, int>& data, const string& key, const int& value,
+            std::chrono::time_point<std::chrono::high_resolution_clock> absTime) {
             std::this_thread::sleep_until(absTime);
             data.EnsureInsert(key, value);
         };
@@ -535,8 +535,7 @@ BENCHMARK_F(BenchmarkSafeMap, testUtilsConcurrentWriteAndFind001)(benchmark::Sta
         timeT += std::chrono::milliseconds(SLEEP_FOR_FIFTY_MILLISECOND);
         string key("A");
         for (int i = 0; i < THREAD_NUM; ++i) {
-            threads[i] = std::thread(lamfuncInsert, std::ref(demoData),
-                key + std::to_string(i), i, timeT);
+            threads[i] = std::thread(lamfuncInsert, std::ref(demoData), key + std::to_string(i), i, timeT);
             vcfi.push_back(std::async(std::launch::async, lamfuncCheckLoop,
                 std::ref(demoData), key + std::to_string(i), timeT));
         }
diff --git a/base/test/benchmarktest/singleton_benchmark_test/singleton_benchmark_test.cpp b/base/test/benchmarktest/singleton_benchmark_test/singleton_benchmark_test.cpp
index e82aec9b0b92a7ebbcdede12a0764598b8c671df..564b8f0baa616c5e24c78a61def4af256b978493 100644
--- a/base/test/benchmarktest/singleton_benchmark_test/singleton_benchmark_test.cpp
+++ b/base/test/benchmarktest/singleton_benchmark_test/singleton_benchmark_test.cpp
@@ -30,22 +30,23 @@ static constexpr long DELAYEDSINGLETON_SP2_USE_COUNT = 3;
 
 class BenchmarkSingletonTest : public benchmark::Fixture {
 public:
-    BenchmarkSingletonTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkSingletonTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkSingletonTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkSingletonTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 1000;
diff --git a/base/test/benchmarktest/sorted_vector_benchmark_test/sorted_vector_benchmark_test.cpp b/base/test/benchmarktest/sorted_vector_benchmark_test/sorted_vector_benchmark_test.cpp
index 9acb6d119734f860fc67d7521471030e93b9020b..c8b981fe712e148dfb8473a9ab7c472bfc97d468 100644
--- a/base/test/benchmarktest/sorted_vector_benchmark_test/sorted_vector_benchmark_test.cpp
+++ b/base/test/benchmarktest/sorted_vector_benchmark_test/sorted_vector_benchmark_test.cpp
@@ -35,22 +35,23 @@ const size_t EXPECTED_SIZE_AFTER_DUPLICATES = 30;
 
 class BenchmarkSortedVector : public benchmark::Fixture {
 public:
-    BenchmarkSortedVector()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkSortedVector() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkSortedVector()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkSortedVector() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 1000;
diff --git a/base/test/benchmarktest/string_benchmark_test/string_benchmark_test.cpp b/base/test/benchmarktest/string_benchmark_test/string_benchmark_test.cpp
index 7038951a9ffee29e372731ab9c8058068d7944f0..91df5181299ef51653547babfe41e95545e15a83 100644
--- a/base/test/benchmarktest/string_benchmark_test/string_benchmark_test.cpp
+++ b/base/test/benchmarktest/string_benchmark_test/string_benchmark_test.cpp
@@ -39,22 +39,23 @@ static constexpr int GETSUBSTR04_STRING_SIZE = 0;
 
 class BenchmarkStringTest : public benchmark::Fixture {
 public:
-    BenchmarkStringTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkStringTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkStringTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkStringTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 1000;
diff --git a/base/test/benchmarktest/thread_benchmark_test/thread_benchmark_test.cpp b/base/test/benchmarktest/thread_benchmark_test/thread_benchmark_test.cpp
index 68a9a3f73f9a76eca574e42b801754354aee07ee..4a55425be56fdec470ac6a360b28d99630acb410 100644
--- a/base/test/benchmarktest/thread_benchmark_test/thread_benchmark_test.cpp
+++ b/base/test/benchmarktest/thread_benchmark_test/thread_benchmark_test.cpp
@@ -29,22 +29,23 @@ namespace {
 
 class BenchmarkThreadTest : public benchmark::Fixture {
 public:
-    BenchmarkThreadTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkThreadTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkThreadTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkThreadTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 100;
diff --git a/base/test/benchmarktest/thread_pool_benchmark_test/thread_pool_benchmark_test.cpp b/base/test/benchmarktest/thread_pool_benchmark_test/thread_pool_benchmark_test.cpp
index 49ae526210b5315fac2fb1aa65d8b2e81a52042d..fcbba8770d3b8050b6fa6e8190a5128fad4e18c3 100644
--- a/base/test/benchmarktest/thread_pool_benchmark_test/thread_pool_benchmark_test.cpp
+++ b/base/test/benchmarktest/thread_pool_benchmark_test/thread_pool_benchmark_test.cpp
@@ -34,22 +34,23 @@ static bool g_flagTestFuncGetName = true;
 
 class BenchmarkThreadPoolTest : public benchmark::Fixture {
 public:
-    BenchmarkThreadPoolTest()
+    void SetUp(const ::benchmark::State& state) override
     {
-        Iterations(iterations);
-        Repetitions(repetitions);
-        ReportAggregatesOnly();
     }
 
-    ~BenchmarkThreadPoolTest() override = default;
-    void SetUp(const ::benchmark::State& state) override
+    void TearDown(const ::benchmark::State& state) override
     {
     }
 
-    void TearDown(const ::benchmark::State& state) override
+    BenchmarkThreadPoolTest()
     {
+        Iterations(iterations);
+        Repetitions(repetitions);
+        ReportAggregatesOnly();
     }
 
+    ~BenchmarkThreadPoolTest() override = default;
+
 protected:
     const int32_t repetitions = 3;
     const int32_t iterations = 100;