[PATCH]add expr_matcher hit pattern statisticsv4.1.26

7 files changed, 900 insertions, 600 deletions

diff --git a/test/benchmark/benchmark_hs_gtest.cpp b/test/benchmark/benchmark_hs_gtest.cpp
index caa6d28..55801c7 100644
--- a/test/benchmark/benchmark_hs_gtest.cpp
+++ b/test/benchmark/benchmark_hs_gtest.cpp
@@ -25,14 +25,14 @@
 
 #define ARRAY_SIZE 10
 #define PERF_THREAD_NUM 5
-#define MAX_SCAN_COUNT 1000000
+#define MAX_SCAN_TIMES 1000000
 
 const char *table_info_path = "./benchmark_table_info.conf";
 struct log_handle *g_logger = NULL;
 
 struct thread_param {
 	int thread_id;
-	int test_count;
+	int test_times;
     int rule_count;
 	struct maat *maat_inst;
 	const char *table_name;
@@ -182,7 +182,7 @@ void *perf_regex_scan_thread(void *arg)
     int table_id = maat_get_table_id(maat_inst, table_name);
     
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data),
                                    results, ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -195,7 +195,7 @@ void *perf_regex_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d regex_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -246,7 +246,7 @@ void *perf_literal_scan_thread(void *arg)
     int table_id = maat_get_table_id(maat_inst, table_name);
     
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data),
                                    results, ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -259,7 +259,7 @@ void *perf_literal_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d literal_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -311,7 +311,7 @@ void *perf_stream_scan_thread(void *arg)
     struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state);
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         ret = maat_stream_scan(sp, scan_data, strlen(scan_data), results, ARRAY_SIZE,
                                 &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -326,7 +326,7 @@ void *perf_stream_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = ((hit_times == param->test_count) ? 1 : 0);
+    *is_all_hit = ((hit_times == param->test_times) ? 1 : 0);
 
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d stream_scan time_elapse:%lldms hit_times:%d", 
@@ -354,7 +354,7 @@ void *perf_ip_scan_thread(void *arg)
     int proto = 6;
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto,
                                  results, ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -367,7 +367,7 @@ void *perf_ip_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d ip_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -420,7 +420,7 @@ void *perf_integer_scan_thread(void *arg)
     long long scan_data = 1000000;
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_integer(maat_inst, table_id, scan_data, results,
                                     ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -433,7 +433,7 @@ void *perf_integer_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d integer_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -482,7 +482,7 @@ void *perf_flag_scan_thread(void *arg)
     long long scan_data = 1000000;
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_flag(maat_inst, table_id, scan_data, results,
                                  ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -495,7 +495,7 @@ void *perf_flag_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d flag_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -587,7 +587,7 @@ TEST_F(Regex100BenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 100;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -595,24 +595,24 @@ TEST_F(Regex100BenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex100Scan match rate on %d-threads speed %lld lookups/s/thread",
@@ -679,7 +679,7 @@ TEST_F(Regex200BenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 200;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -687,24 +687,24 @@ TEST_F(Regex200BenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex200Scan match rate on %d-threads speed %lld lookups/s/thread",
@@ -771,7 +771,7 @@ TEST_F(Regex300BenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 300;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -779,24 +779,24 @@ TEST_F(Regex300BenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex300Scan match rate on %d-threads speed %lld lookups/s/thread",
@@ -863,7 +863,7 @@ TEST_F(Regex500BenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 500;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -871,24 +871,24 @@ TEST_F(Regex500BenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex500Scan match rate on %d-threads speed %lld lookups/s/thread",
@@ -955,7 +955,7 @@ TEST_F(Regex1KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -963,24 +963,24 @@ TEST_F(Regex1KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex1KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1047,7 +1047,7 @@ TEST_F(Regex2KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 2000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1055,24 +1055,24 @@ TEST_F(Regex2KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex2KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1139,7 +1139,7 @@ TEST_F(Regex3KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 3000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1147,24 +1147,24 @@ TEST_F(Regex3KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex3KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1231,7 +1231,7 @@ TEST_F(Regex5KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1239,24 +1239,24 @@ TEST_F(Regex5KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex5KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1323,7 +1323,7 @@ TEST_F(Regex10KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1331,24 +1331,24 @@ TEST_F(Regex10KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex10KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1415,7 +1415,7 @@ TEST_F(Regex15KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 15000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1423,24 +1423,24 @@ TEST_F(Regex15KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex15KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1508,7 +1508,7 @@ TEST_F(Expr1KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1516,24 +1516,24 @@ TEST_F(Expr1KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr1KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1601,7 +1601,7 @@ TEST_F(Expr5KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1609,24 +1609,24 @@ TEST_F(Expr5KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr5KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1694,7 +1694,7 @@ TEST_F(Expr10KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1702,24 +1702,24 @@ TEST_F(Expr10KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr10KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1787,7 +1787,7 @@ TEST_F(Expr50KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 50000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1795,24 +1795,24 @@ TEST_F(Expr50KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr50KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1880,7 +1880,7 @@ TEST_F(Expr100KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 100000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1888,24 +1888,24 @@ TEST_F(Expr100KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr100KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1973,7 +1973,7 @@ TEST_F(Expr500KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 500000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1981,24 +1981,24 @@ TEST_F(Expr500KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr500KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2066,7 +2066,7 @@ TEST_F(Expr1MBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 1000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2074,24 +2074,24 @@ TEST_F(Expr1MBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr1MLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2159,7 +2159,7 @@ TEST_F(Expr2MBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 2000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2167,24 +2167,24 @@ TEST_F(Expr2MBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr2MLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2252,7 +2252,7 @@ TEST_F(Stream1KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2263,18 +2263,18 @@ TEST_F(Stream1KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream1KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2342,7 +2342,7 @@ TEST_F(Stream5KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2353,18 +2353,18 @@ TEST_F(Stream5KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream5KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2432,7 +2432,7 @@ TEST_F(Stream10KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2443,18 +2443,18 @@ TEST_F(Stream10KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream10KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2522,7 +2522,7 @@ TEST_F(Stream50KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 50000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2533,18 +2533,18 @@ TEST_F(Stream50KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream50KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2612,7 +2612,7 @@ TEST_F(Stream100KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 100000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2623,18 +2623,18 @@ TEST_F(Stream100KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream100KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2702,7 +2702,7 @@ TEST_F(Stream500KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 500000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2713,18 +2713,18 @@ TEST_F(Stream500KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream500KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2792,7 +2792,7 @@ TEST_F(Stream1MBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 1000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2803,18 +2803,18 @@ TEST_F(Stream1MBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream1MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2882,7 +2882,7 @@ TEST_F(Stream2MBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 2000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2893,18 +2893,18 @@ TEST_F(Stream2MBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream2MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2970,7 +2970,7 @@ TEST_F(IP1KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2978,24 +2978,24 @@ TEST_F(IP1KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP1KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3061,7 +3061,7 @@ TEST_F(IP5KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3069,24 +3069,24 @@ TEST_F(IP5KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP5KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3152,7 +3152,7 @@ TEST_F(IP10KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3160,24 +3160,24 @@ TEST_F(IP10KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP10KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3243,7 +3243,7 @@ TEST_F(IP50KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 50000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3251,24 +3251,24 @@ TEST_F(IP50KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP50KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3334,7 +3334,7 @@ TEST_F(IP100KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 100000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3342,24 +3342,24 @@ TEST_F(IP100KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP100KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3425,7 +3425,7 @@ TEST_F(IP500KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 500000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3433,24 +3433,24 @@ TEST_F(IP500KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP500KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3516,7 +3516,7 @@ TEST_F(IP1MBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 1000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3524,24 +3524,24 @@ TEST_F(IP1MBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP1MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3607,7 +3607,7 @@ TEST_F(IP5MBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 5000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3615,24 +3615,24 @@ TEST_F(IP5MBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP5MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3698,7 +3698,7 @@ TEST_F(IP10MBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 10000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3706,24 +3706,24 @@ TEST_F(IP10MBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP10MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3789,7 +3789,7 @@ TEST_F(Integer1KBenchmarkGTest, IntegerScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3797,24 +3797,24 @@ TEST_F(Integer1KBenchmarkGTest, IntegerScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Integer1KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3880,7 +3880,7 @@ TEST_F(Integer5KBenchmarkGTest, IntegerScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3888,24 +3888,24 @@ TEST_F(Integer5KBenchmarkGTest, IntegerScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Integer5KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3971,7 +3971,7 @@ TEST_F(Integer10KBenchmarkGTest, IntegerScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3979,24 +3979,24 @@ TEST_F(Integer10KBenchmarkGTest, IntegerScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Integer10KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -4062,7 +4062,7 @@ TEST_F(Flag1KBenchmarkGTest, FlagScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -4070,24 +4070,24 @@ TEST_F(Flag1KBenchmarkGTest, FlagScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Flag1KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -4153,7 +4153,7 @@ TEST_F(Flag5KBenchmarkGTest, FlagScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -4161,24 +4161,24 @@ TEST_F(Flag5KBenchmarkGTest, FlagScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Flag5KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -4244,7 +4244,7 @@ TEST_F(Flag10KBenchmarkGTest, FlagScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_SCAN_TIMES;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -4252,24 +4252,24 @@ TEST_F(Flag10KBenchmarkGTest, FlagScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Flag10KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -4286,4 +4286,4 @@ int main(int argc, char ** argv)
 
     log_handle_destroy(g_logger);
 	return ret;
-}
\ No newline at end of file
+}
diff --git a/test/benchmark/benchmark_rs_gtest.cpp b/test/benchmark/benchmark_rs_gtest.cpp
index ae97759..7cbd111 100644
--- a/test/benchmark/benchmark_rs_gtest.cpp
+++ b/test/benchmark/benchmark_rs_gtest.cpp
@@ -25,14 +25,14 @@
 
 #define ARRAY_SIZE 10
 #define PERF_THREAD_NUM 5
-#define MAX_SCAN_COUNT 1000000
+#define MAX_scan_times 1000000
 
 const char *table_info_path = "./benchmark_table_info.conf";
 struct log_handle *g_logger = NULL;
 
 struct thread_param {
 	int thread_id;
-	int test_count;
+	int test_times;
     int rule_count;
 	struct maat *maat_inst;
 	const char *table_name;
@@ -183,7 +183,7 @@ void *perf_literal_scan_thread(void *arg)
     int table_id = maat_get_table_id(maat_inst, table_name);
     
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data),
                                    results, ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -196,7 +196,7 @@ void *perf_literal_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d literal_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -248,7 +248,7 @@ void *perf_stream_scan_thread(void *arg)
     struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state);
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         ret = maat_stream_scan(sp, scan_data, strlen(scan_data), results, ARRAY_SIZE,
                                 &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -263,7 +263,7 @@ void *perf_stream_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = ((hit_times == param->test_count) ? 1 : 0);
+    *is_all_hit = ((hit_times == param->test_times) ? 1 : 0);
 
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d stream_scan time_elapse:%lldms hit_times:%d", 
@@ -291,7 +291,7 @@ void *perf_ip_scan_thread(void *arg)
     int proto = 6;
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto,
                                  results, ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -304,7 +304,7 @@ void *perf_ip_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d ip_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -357,7 +357,7 @@ void *perf_integer_scan_thread(void *arg)
     long long scan_data = 1000000;
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_integer(maat_inst, table_id, scan_data, results,
                                     ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -370,7 +370,7 @@ void *perf_integer_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d integer_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -419,7 +419,7 @@ void *perf_flag_scan_thread(void *arg)
     long long scan_data = 1000000;
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_flag(maat_inst, table_id, scan_data, results,
                                  ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -432,7 +432,7 @@ void *perf_flag_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d flag_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -480,7 +480,7 @@ void *perf_regex_scan_thread(void *arg)
     int table_id = maat_get_table_id(maat_inst, table_name);
     
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data),
                                    results, ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -493,7 +493,7 @@ void *perf_regex_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_BENCHMARK_GTEST, 
              "thread_id:%d rule_count:%d regex_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->rule_count, param->time_elapse_ms, hit_times);
@@ -587,7 +587,7 @@ TEST_F(Regex100BenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 100;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -595,24 +595,24 @@ TEST_F(Regex100BenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex100Scan match rate on %d-threads speed %lld lookups/s/thread",
@@ -679,7 +679,7 @@ TEST_F(Regex200BenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 200;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -687,24 +687,24 @@ TEST_F(Regex200BenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex200Scan match rate on %d-threads speed %lld lookups/s/thread",
@@ -771,7 +771,7 @@ TEST_F(Regex300BenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 300;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -779,24 +779,24 @@ TEST_F(Regex300BenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Regex300Scan match rate on %d-threads speed %lld lookups/s/thread",
@@ -864,7 +864,7 @@ TEST_F(Expr1KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -872,24 +872,24 @@ TEST_F(Expr1KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr1KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -957,7 +957,7 @@ TEST_F(Expr5KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -965,24 +965,24 @@ TEST_F(Expr5KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr5KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1050,7 +1050,7 @@ TEST_F(Expr10KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1058,24 +1058,24 @@ TEST_F(Expr10KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr10KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1143,7 +1143,7 @@ TEST_F(Expr50KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 50000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1151,24 +1151,24 @@ TEST_F(Expr50KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr50KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1236,7 +1236,7 @@ TEST_F(Expr100KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 100000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1244,24 +1244,24 @@ TEST_F(Expr100KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr100KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1329,7 +1329,7 @@ TEST_F(Expr500KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 500000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1337,24 +1337,24 @@ TEST_F(Expr500KBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr500KLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1422,7 +1422,7 @@ TEST_F(Expr1MBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 1000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1430,24 +1430,24 @@ TEST_F(Expr1MBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr1MLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1515,7 +1515,7 @@ TEST_F(Expr2MBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 2000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1523,24 +1523,24 @@ TEST_F(Expr2MBenchmarkGTest, LiteralScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Expr2MLiteralScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1608,7 +1608,7 @@ TEST_F(Stream1KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1619,18 +1619,18 @@ TEST_F(Stream1KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream1KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1698,7 +1698,7 @@ TEST_F(Stream5KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1709,18 +1709,18 @@ TEST_F(Stream5KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream5KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1788,7 +1788,7 @@ TEST_F(Stream10KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1799,18 +1799,18 @@ TEST_F(Stream10KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream10KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1878,7 +1878,7 @@ TEST_F(Stream50KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 50000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1889,18 +1889,18 @@ TEST_F(Stream50KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream50KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1968,7 +1968,7 @@ TEST_F(Stream100KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 100000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -1979,18 +1979,18 @@ TEST_F(Stream100KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream100KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2058,7 +2058,7 @@ TEST_F(Stream500KBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 500000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2069,18 +2069,18 @@ TEST_F(Stream500KBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream500KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2148,7 +2148,7 @@ TEST_F(Stream1MBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 1000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2159,18 +2159,18 @@ TEST_F(Stream1MBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream1MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2238,7 +2238,7 @@ TEST_F(Stream2MBenchmarkGTest, LiteralScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 2000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2249,18 +2249,18 @@ TEST_F(Stream2MBenchmarkGTest, LiteralScan) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
    
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Stream2MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2328,7 +2328,7 @@ TEST_F(IP1KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2336,24 +2336,24 @@ TEST_F(IP1KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP1KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2421,7 +2421,7 @@ TEST_F(IP5KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2429,24 +2429,24 @@ TEST_F(IP5KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP5KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2514,7 +2514,7 @@ TEST_F(IP10KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2522,24 +2522,24 @@ TEST_F(IP10KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP10KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2607,7 +2607,7 @@ TEST_F(IP50KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 50000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2615,24 +2615,24 @@ TEST_F(IP50KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP50KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2700,7 +2700,7 @@ TEST_F(IP100KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 100000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2708,24 +2708,24 @@ TEST_F(IP100KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP100KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2793,7 +2793,7 @@ TEST_F(IP500KBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 500000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2801,24 +2801,24 @@ TEST_F(IP500KBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP500KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2886,7 +2886,7 @@ TEST_F(IP1MBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 1000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2894,24 +2894,24 @@ TEST_F(IP1MBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP1MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -2979,7 +2979,7 @@ TEST_F(IP5MBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 5000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -2987,24 +2987,24 @@ TEST_F(IP5MBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP5MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3071,7 +3071,7 @@ TEST_F(IP10MBenchmarkGTest, IPScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 10000000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3079,24 +3079,24 @@ TEST_F(IP10MBenchmarkGTest, IPScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "IP10MScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3164,7 +3164,7 @@ TEST_F(Integer1KBenchmarkGTest, IntegerScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3172,24 +3172,24 @@ TEST_F(Integer1KBenchmarkGTest, IntegerScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Integer1KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3257,7 +3257,7 @@ TEST_F(Integer5KBenchmarkGTest, IntegerScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3265,24 +3265,24 @@ TEST_F(Integer5KBenchmarkGTest, IntegerScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Integer5KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3350,7 +3350,7 @@ TEST_F(Integer10KBenchmarkGTest, IntegerScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3358,24 +3358,24 @@ TEST_F(Integer10KBenchmarkGTest, IntegerScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Integer10KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3443,7 +3443,7 @@ TEST_F(Flag1KBenchmarkGTest, FlagScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 1000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3451,24 +3451,24 @@ TEST_F(Flag1KBenchmarkGTest, FlagScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Flag1KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3536,7 +3536,7 @@ TEST_F(Flag5KBenchmarkGTest, FlagScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 5000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3544,24 +3544,24 @@ TEST_F(Flag5KBenchmarkGTest, FlagScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Flag5KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3629,7 +3629,7 @@ TEST_F(Flag10KBenchmarkGTest, FlagScan) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = MAX_SCAN_COUNT;
+        thread_params[i].test_times = MAX_scan_times;
         thread_params[i].rule_count = 10000;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
@@ -3637,24 +3637,24 @@ TEST_F(Flag10KBenchmarkGTest, FlagScan) {
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST,
              "Flag10KScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -3671,4 +3671,4 @@ int main(int argc, char ** argv)
 
     log_handle_destroy(g_logger);
 	return ret;
-}
\ No newline at end of file
+}
diff --git a/test/expr_matcher_gtest.cpp b/test/expr_matcher_gtest.cpp
index 1f58fc8..a2364a5 100644
--- a/test/expr_matcher_gtest.cpp
+++ b/test/expr_matcher_gtest.cpp
@@ -296,33 +296,42 @@ TEST(hs_expr_matcher_match, literal_sub_has_normal_offset)
     char scan_data1[64] = "hello aaa";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data2[64] = "Ahello aaa";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 101);
     
     char scan_data3[64] = "Aahello aaa";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 101);
 
     char scan_data4[64] = "Aaahello aaa";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -343,33 +352,42 @@ TEST(rs_expr_matcher_match, literal_sub_has_normal_offset)
     char scan_data1[64] = "hello aaa";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data2[64] = "Ahello aaa";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 101);
     
     char scan_data3[64] = "Aahello aaa";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                            64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 101);
 
     char scan_data4[64] = "Aaahello aaa";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -383,41 +401,51 @@ TEST(hs_expr_matcher_match, literal_sub_has_left_unlimit_offset)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello bbb";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 102);
 
     char scan_data2[64] = "Ahello bbb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 102);
 
     char scan_data3[64] = "Aahello bbb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 102);
 
     char scan_data4[64] = "Aaahello bbb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                            64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -431,41 +459,51 @@ TEST(rs_expr_matcher_match, literal_sub_has_left_unlimit_offset)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello bbb";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 102);
 
     char scan_data2[64] = "Ahello bbb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                            64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 102);
 
     char scan_data3[64] = "Aahello bbb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 102);
 
     char scan_data4[64] = "Aaahello bbb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -479,47 +517,59 @@ TEST(hs_expr_matcher_match, literal_sub_has_right_unlimit_offset)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello ccc";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data2[64] = "1234hello ccc";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data3[64] = "12345hello ccc";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 103);
 
     char scan_data4[64] = "12345hello cccAaBb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 103);
 
     char scan_data5[64] = "123456hello cccAaBb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data5, strlen(scan_data5), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data5, strlen(scan_data5), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 103);
 
     expr_matcher_free(matcher);
@@ -534,47 +584,59 @@ TEST(rs_expr_matcher_match, literal_sub_has_right_unlimit_offset)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                     1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello ccc";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data2[64] = "1234hello ccc";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data3[64] = "12345hello ccc";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 103);
 
     char scan_data4[64] = "12345hello cccAaBb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 103);
 
     char scan_data5[64] = "123456hello cccAaBb";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data5, strlen(scan_data5), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data5, strlen(scan_data5), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 103);
 
     expr_matcher_free(matcher);
@@ -589,40 +651,51 @@ TEST(hs_expr_matcher_match, literal_sub_with_no_offset)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello ddd";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 104);
 
     char scan_data2[64] = "123hello ddd";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 104);
 
     char scan_data3[64] = "123hello ddd456";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 104);
 
     char scan_data4[64] = "helloddd";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -636,40 +709,51 @@ TEST(rs_expr_matcher_match, literal_sub_with_no_offset)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello ddd";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 104);
 
     char scan_data2[64] = "123hello ddd";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 104);
 
     char scan_data3[64] = "123hello ddd456";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 104);
 
     char scan_data4[64] = "helloddd";
     memset(result, 0, sizeof(result));
     n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -683,24 +767,29 @@ TEST(hs_expr_matcher_match, literal_exactly)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello eee";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                            64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 105);
 
     char scan_data2[64] = "Ahello eee";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
 
@@ -708,9 +797,11 @@ TEST(hs_expr_matcher_match, literal_exactly)
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -724,34 +815,42 @@ TEST(rs_expr_matcher_match, literal_exactly)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello eee";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 105);
 
     char scan_data2[64] = "Ahello eee";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data3[64] = "hello eeeB";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -765,42 +864,52 @@ TEST(hs_expr_matcher_match, literal_prefix)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello fff";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 106);
 
     char scan_data2[64] = "Ahello fff";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data3[64] = "Ahello fffBCD";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data4[64] = "hello fffBCD";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 106);
 
     expr_matcher_free(matcher);
@@ -815,42 +924,52 @@ TEST(rs_expr_matcher_match, literal_prefix)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello fff";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 106);
 
     char scan_data2[64] = "Ahello fff";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data3[64] = "Ahello fffBCD";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data4[64] = "hello fffBCD";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 106);
 
     expr_matcher_free(matcher);
@@ -865,43 +984,53 @@ TEST(hs_expr_matcher_match, literal_suffix)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello ggg";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 107);
 
     char scan_data2[64] = "ABChello ggg";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                            64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 107);
 
     char scan_data3[64] = "ABChello gggDEF";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data4[64] = "hello gggDEF";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                            64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -915,43 +1044,53 @@ TEST(rs_expr_matcher_match, literal_suffix)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "hello ggg";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                            64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 107);
 
     char scan_data2[64] = "ABChello ggg";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 107);
 
     char scan_data3[64] = "ABChello gggDEF";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result,
+                            64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     char scan_data4[64] = "hello gggDEF";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0);
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -965,25 +1104,32 @@ TEST(hs_expr_matcher_match, literal_sub_with_hex)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "Content-Type: /html";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1);
     EXPECT_EQ(result[0].rule_id, 108);
 
     char scan_data2[64] = " html";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0); 
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -997,25 +1143,32 @@ TEST(rs_expr_matcher_match, literal_sub_with_hex)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char scan_data1[64] = "Content-Type: /html";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1); 
     EXPECT_EQ(result[0].rule_id, 108);
 
     char scan_data2[64] = " html";
     memset(result, 0, sizeof(result));
     n_result = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 0); 
 
     expr_matcher_free(matcher);
     matcher = NULL;
@@ -1029,16 +1182,21 @@ TEST(hs_expr_matcher_match, literal_with_chinese)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char data0[64] = "#中国 你好";
     struct expr_scan_result result0[64] = {0};
     size_t n_result0 = 0;
-    ret = expr_matcher_match(matcher, 0, data0, strlen(data0), result0, 64, &n_result0);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, data0, strlen(data0), result0, 64,
+                             &n_result0, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result0, 1);
+    EXPECT_EQ(n_hit_pattern, 1); 
     EXPECT_EQ(result0[0].rule_id, 110);
 
     expr_matcher_free(matcher);
@@ -1053,16 +1211,21 @@ TEST(rs_expr_matcher_match, literal_with_chinese)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char data0[64] = "#中国 你好";
     struct expr_scan_result result0[64] = {0};
     size_t n_result0 = 0;
-    ret = expr_matcher_match(matcher, 0, data0, strlen(data0), result0, 64, &n_result0);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, data0, strlen(data0), result0, 64,
+                             &n_result0, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result0, 1);
+    EXPECT_EQ(n_hit_pattern, 1); 
     EXPECT_EQ(result0[0].rule_id, 110);
 
     expr_matcher_free(matcher);
@@ -1077,16 +1240,21 @@ TEST(hs_expr_matcher_match, same_pattern_different_offset)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char data[64] = "onetoday,anothertoday";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
-    ret = expr_matcher_match(matcher, 0, data, strlen(data), result, 64, &n_result);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, data, strlen(data), result, 64,
+                             &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 3); 
     EXPECT_EQ(result[0].rule_id, 112);
 
     expr_matcher_free(matcher);
@@ -1101,16 +1269,21 @@ TEST(rs_expr_matcher_match, same_pattern_different_offset)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
     char data[64] = "onetoday,anothertoday";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
-    ret = expr_matcher_match(matcher, 0, data, strlen(data), result, 64, &n_result);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, data, strlen(data), result, 64,
+                             &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 3); 
     EXPECT_EQ(result[0].rule_id, 112);
 
     expr_matcher_free(matcher);
@@ -1125,7 +1298,8 @@ TEST(hs_expr_matcher_match, long_scan_data)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
@@ -1134,9 +1308,13 @@ sequence of edges which joins a sequence of distinct vertices, but with the adde
 that the edges be all directed in the same direction.";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data, strlen(scan_data), result, 64, &n_result);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, scan_data, strlen(scan_data), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 3);
     EXPECT_EQ(result[0].rule_id, 113);
 
     expr_matcher_free(matcher);
@@ -1151,7 +1329,8 @@ TEST(rs_expr_matcher_match, long_scan_data)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
@@ -1160,9 +1339,13 @@ sequence of edges which joins a sequence of distinct vertices, but with the adde
 that the edges be all directed in the same direction.";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
-    ret = expr_matcher_match(matcher, 0, scan_data, strlen(scan_data), result, 64, &n_result);
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, scan_data, strlen(scan_data), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 3); 
     EXPECT_EQ(result[0].rule_id, 113);
 
     expr_matcher_free(matcher);
@@ -1194,7 +1377,8 @@ TEST(hs_expr_matcher_stream, basic)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
@@ -1203,18 +1387,23 @@ TEST(hs_expr_matcher_stream, basic)
 
     struct expr_scan_result result[64] = {0};
     size_t n_hit_result = 0;
+    size_t n_hit_pattern = 0;
     int thread_id = 0;
 
     struct expr_matcher_stream *stream = expr_matcher_stream_open(matcher, thread_id);
     EXPECT_TRUE(stream != NULL);
 
-    ret = expr_matcher_stream_match(stream, scan_data1, strlen(scan_data1), result, 64, &n_hit_result);
+    ret = expr_matcher_stream_match(stream, scan_data1, strlen(scan_data1), result,
+                                    64, &n_hit_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_hit_result, 0);
+    EXPECT_EQ(n_hit_pattern, 2); 
 
-    ret = expr_matcher_stream_match(stream, scan_data2, strlen(scan_data2), result, 64, &n_hit_result);
+    ret = expr_matcher_stream_match(stream, scan_data2, strlen(scan_data2), result,
+                                    64, &n_hit_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_hit_result, 1);
+    EXPECT_EQ(n_hit_pattern, 3); 
     EXPECT_EQ(result[0].rule_id, 113);
 
     expr_matcher_stream_close(stream);
@@ -1230,7 +1419,8 @@ TEST(rs_expr_matcher_stream, basic)
     int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
     EXPECT_EQ(ret, 0);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
@@ -1239,18 +1429,23 @@ TEST(rs_expr_matcher_stream, basic)
 
     struct expr_scan_result result[64] = {0};
     size_t n_hit_result = 0;
+    size_t n_hit_pattern = 0;
     int thread_id = 0;
 
     struct expr_matcher_stream *stream = expr_matcher_stream_open(matcher, thread_id);
     EXPECT_TRUE(stream != NULL);
 
-    ret = expr_matcher_stream_match(stream, scan_data1, strlen(scan_data1), result, 64, &n_hit_result);
+    ret = expr_matcher_stream_match(stream, scan_data1, strlen(scan_data1), result,
+                                    64, &n_hit_result, &n_hit_pattern);
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(n_hit_result, 0);
+    EXPECT_EQ(n_hit_pattern, 2); 
 
-    ret = expr_matcher_stream_match(stream, scan_data2, strlen(scan_data2), result, 64, &n_hit_result);
+    ret = expr_matcher_stream_match(stream, scan_data2, strlen(scan_data2), result,
+                                    64, &n_hit_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_hit_result, 1);
+    EXPECT_EQ(n_hit_pattern, 3); 
     EXPECT_EQ(result[0].rule_id, 113);
 
     expr_matcher_stream_close(stream);
@@ -1277,9 +1472,12 @@ TEST(hs_expr_matcher, regex_basic)
     //const char *scan_data2 = "8rain";
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1); 
     EXPECT_EQ(result[0].rule_id, 114);
 
     expr_matcher_free(matcher);
@@ -1297,7 +1495,8 @@ TEST(rs_expr_matcher, regex_basic)
     ret = expr_matcher_verify_regex_expression("[0-9]rain", g_logger);
     EXPECT_EQ(ret, 1);
 
-    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger);
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS,
+                                                    1, g_logger);
     EXPECT_TRUE(matcher != NULL);
     expr_array_free(rules, n_rule);
 
@@ -1306,14 +1505,53 @@ TEST(rs_expr_matcher, regex_basic)
     
     struct expr_scan_result result[64] = {0};
     size_t n_result = 0;
+    size_t n_hit_pattern = 0;
 
-    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result);
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
     EXPECT_EQ(ret, 1);
     EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 1); 
     EXPECT_EQ(result[0].rule_id, 114);
 
     expr_matcher_free(matcher);
-    matcher = NULL;                  
+    matcher = NULL;
+}
+
+TEST(hs_expr_matcher, hit_pattern_num)
+{
+    struct expr_rule rules[64] = {0};
+    size_t n_rule = 0;
+    
+    int ret = parse_config_file("./literal_expr.conf", rules, &n_rule);
+    EXPECT_EQ(ret, 0);
+
+    struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS,
+                                                    1, g_logger);
+    EXPECT_TRUE(matcher != NULL);
+    expr_array_free(rules, n_rule);
+
+    const char *scan_data1 = "string has one two";
+    const char *scan_data2 = "string has one two three";
+    struct expr_scan_result result[64] = {0};
+    size_t n_result = 0;
+    size_t n_hit_pattern = 0;
+
+    ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result,
+                             64, &n_result, &n_hit_pattern);
+    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(n_result, 0);
+    EXPECT_EQ(n_hit_pattern, 2); 
+
+    ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result,
+                             64, &n_result, &n_hit_pattern);
+    EXPECT_EQ(ret, 1);
+    EXPECT_EQ(n_result, 1);
+    EXPECT_EQ(n_hit_pattern, 3);
+    EXPECT_EQ(result[0].rule_id, 115);
+
+    expr_matcher_free(matcher);
+    matcher = NULL;
 }
 
 int main(int argc, char **argv)
diff --git a/test/ipport_plugin/ipport_plugin_gtest.cpp b/test/ipport_plugin/ipport_plugin_gtest.cpp
index 54c449b..1b5f73c 100644
--- a/test/ipport_plugin/ipport_plugin_gtest.cpp
+++ b/test/ipport_plugin/ipport_plugin_gtest.cpp
@@ -11,7 +11,7 @@
 
 #define MODULE_IPPORT_PLUGIN_GTEST module_name_str("maat.ipport_plugin_gtest")
 #define ARRAY_SIZE 10
-#define PERF_SCAN_COUNT 1000 * 1000
+#define PERF_scan_times 1000 * 1000
 
 const char *table_info_path = "./ipport_plugin_table_info.conf";
 const char *log_file = "./ipport_plugin_gtest.log";
@@ -252,15 +252,18 @@ void *ipport_plugin_scan_thread(void *arg)
     return is_all_hit;
 }
 
-static void test_add_ipport_plugin_command(struct maat *maat_inst, const char *table_name,
+static int test_add_ipport_plugin_command(struct maat *maat_inst, const char *table_name,
                                            long long item_id, const char *ip_str, int port1, int port2)
 {
     int table_id = maat_get_table_id(maat_inst, table_name);
-    assert(table_id >= 0);
-    
-    enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id);
-    assert(table_type == TABLE_TYPE_IPPORT_PLUGIN);
+    if (table_id < 0) {
+        return -1;
+    }
 
+    enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id);
+    if (table_type != TABLE_TYPE_IPPORT_PLUGIN) {
+        return -1;
+    }
 
     char table_line[1024] = {0};
     sprintf(table_line, "%lld\t4\t%s\t%d\t%d\t1", item_id, ip_str, port1, port2);
@@ -272,17 +275,22 @@ static void test_add_ipport_plugin_command(struct maat *maat_inst, const char *t
     line_rule.expire_after = 0;
 
     maat_cmd_set_line(maat_inst, &line_rule);
+
+    return 0;
 }
 
-static void test_del_ipport_plugin_command(struct maat *maat_inst, const char *table_name,
+static int test_del_ipport_plugin_command(struct maat *maat_inst, const char *table_name,
                                            long long item_id, const char *ip_str, int port1, int port2)
 {
     int table_id = maat_get_table_id(maat_inst, table_name);
-    assert(table_id >= 0);
-    
-    enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id);
-    assert(table_type == TABLE_TYPE_IPPORT_PLUGIN);
+    if (table_id < 0) {
+        return -1;
+    }
 
+    enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id);
+    if (table_type != TABLE_TYPE_IPPORT_PLUGIN) {
+        return -1;
+    }
 
     char table_line[1024] = {0};
     sprintf(table_line, "%lld\t4\t%s\t%d\t%d\t0", item_id, ip_str, port1, port2);
@@ -294,6 +302,8 @@ static void test_del_ipport_plugin_command(struct maat *maat_inst, const char *t
     line_rule.expire_after = 0;
 
     maat_cmd_set_line(maat_inst, &line_rule);
+
+    return 0;
 }
 
 void *ipport_plugin_update_thread(void *arg)
@@ -303,16 +313,29 @@ void *ipport_plugin_update_thread(void *arg)
     const char *table_name = param->table_name;
     const int CMD_EXPR_NUM = 256;
     long long item_id = 9000000;
+    int ret = 0;
 
     for (int i = 0; i < CMD_EXPR_NUM; i++) {
-        test_add_ipport_plugin_command(maat_inst, table_name, item_id, g_ip_str, i+201, i+201);
+        ret = test_add_ipport_plugin_command(maat_inst, table_name, item_id, g_ip_str, i+201, i+201);
+        if (ret < 0) {
+            log_fatal(param->logger, MODULE_IPPORT_PLUGIN_GTEST,
+                     "[%s:%d]add ipport rule(item_id:%lld) for table:%s failed.",
+                     __FUNCTION__, __LINE__, item_id, table_name);
+            continue;
+        }
         item_id++;
         usleep(100 * 1000);
     }
 
     item_id = 9000000; 
     for (int i = 0; i < CMD_EXPR_NUM; i++) {
-        test_del_ipport_plugin_command(maat_inst, table_name, item_id, g_ip_str, i+201, i+201);
+        ret = test_del_ipport_plugin_command(maat_inst, table_name, item_id, g_ip_str, i+201, i+201);
+        if (ret < 0) {
+            log_fatal(param->logger, MODULE_IPPORT_PLUGIN_GTEST,
+                     "[%s:%d]del ipport rule(item_id:%lld) for table:%s failed.",
+                     __FUNCTION__, __LINE__, item_id, table_name);
+            continue;
+        }
         usleep(100 * 1000);
         item_id++;
     }
@@ -364,7 +387,7 @@ TEST_F(IPPortPluginTable, WITHOUT_SAME_IP) {
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
         thread_params[i].port = 10;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_count = PERF_scan_times;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
     }
@@ -385,7 +408,7 @@ TEST_F(IPPortPluginTable, WITHOUT_SAME_IP) {
     }
 
     maat_free(maat_inst);
-    scan_per_second = PERF_SCAN_COUNT * 1000 / time_elapse_ms;
+    scan_per_second = PERF_scan_times * 1000 / time_elapse_ms;
     log_info(maat_inst->logger, MODULE_IPPORT_PLUGIN_GTEST,
              "IpportPluginScan without same ip match rate speed %lld lookups/s/thread",
              scan_per_second);
@@ -432,7 +455,7 @@ TEST_F(IPPortPluginTable, WITH_256SAME_IP) {
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
         thread_params[i].port = 10;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_count = PERF_scan_times;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
     }
@@ -453,7 +476,7 @@ TEST_F(IPPortPluginTable, WITH_256SAME_IP) {
     }
     maat_free(maat_inst);
 
-    scan_per_second = PERF_SCAN_COUNT * 1000 / time_elapse_ms;
+    scan_per_second = PERF_scan_times * 1000 / time_elapse_ms;
     log_info(maat_inst->logger, MODULE_IPPORT_PLUGIN_GTEST,
              "IpportPluginScan with 256 same ip match rate speed %lld lookups/s/thread",
              scan_per_second);
@@ -466,4 +489,4 @@ int main(int argc, char ** argv)
 	ret = RUN_ALL_TESTS();
 
 	return ret;
-}
\ No newline at end of file
+}
diff --git a/test/literal_expr.conf b/test/literal_expr.conf
index 7bb2db6..2b5e6cd 100644
--- a/test/literal_expr.conf
+++ b/test/literal_expr.conf
@@ -124,7 +124,7 @@
                     "match_method": "sub",
                     "case_sensitive": "yes",
                     "is_hexbin": "no",
-                    "pattern": "pat"
+                    "pattern": "directed graph"
                 }
             ]
         },
@@ -178,7 +178,7 @@
         },
         {
             "expr_id": 113,
-            "pattern_num": 1,
+            "pattern_num": 2,
             "patterns": [
                 {
                     "pattern_type": "literal",
@@ -186,6 +186,13 @@
                     "case_sensitive": "yes",
                     "is_hexbin": "no",
                     "pattern": "a finite or infinite"
+                },
+                {
+                    "pattern_type": "literal",
+                    "match_method": "sub",
+                    "case_sensitive": "yes",
+                    "is_hexbin": "no",
+                    "pattern": "directed path"
                 }
             ]
         },
@@ -201,6 +208,33 @@
                     "pattern": "query=(.*)"
                 }
             ]
+        },
+        {
+            "expr_id": 115,
+            "pattern_num": 3,
+            "patterns": [
+                {
+                    "pattern_type": "literal",
+                    "match_method": "sub",
+                    "case_sensitive": "yes",
+                    "is_hexbin": "no",
+                    "pattern": "one"
+                },
+                {
+                    "pattern_type": "literal",
+                    "match_method": "sub",
+                    "case_sensitive": "yes",
+                    "is_hexbin": "no",
+                    "pattern": "two"
+                },
+                {
+                    "pattern_type": "literal",
+                    "match_method": "sub",
+                    "case_sensitive": "yes",
+                    "is_hexbin": "no",
+                    "pattern": "three"
+                }
+            ]
         }
     ]
 }
diff --git a/test/maat_framework_gtest.cpp b/test/maat_framework_gtest.cpp
index e57d7fc..76a8631 100644
--- a/test/maat_framework_gtest.cpp
+++ b/test/maat_framework_gtest.cpp
@@ -9005,8 +9005,8 @@ TEST_F(MaatCmdTest, HitGroup) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    size_t scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 1);
+    size_t scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 1);
 
     struct maat_hit_group hit_groups[128];
     memset(hit_groups, 0, sizeof(hit_groups));
@@ -9052,8 +9052,8 @@ TEST_F(MaatCmdTest, HitGroup) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 2);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 2);
 
     memset(hit_groups, 0, sizeof(hit_groups));
     n_hit_group = maat_state_get_direct_hit_group_cnt(state);
@@ -9088,8 +9088,8 @@ TEST_F(MaatCmdTest, HitGroup) {
     ret = maat_stream_scan(stream, keywords1, strlen(keywords1), results, ARRAY_SIZE,
                           &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT);
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 3);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 3);
 
     int ip_table_id = maat_get_table_id(maat_inst, ip_table_name);
     ASSERT_GT(ip_table_id, 0);
@@ -9105,8 +9105,8 @@ TEST_F(MaatCmdTest, HitGroup) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 4);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 4);
 
     memset(hit_groups, 0, sizeof(hit_groups));
     n_hit_group = maat_state_get_direct_hit_group_cnt(state);
@@ -9125,23 +9125,28 @@ TEST_F(MaatCmdTest, HitGroup) {
                             ARRAY_SIZE, &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 5);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 5);
 
     memset(hit_groups, 0, sizeof(hit_groups));
     n_hit_group = maat_state_get_direct_hit_group_cnt(state);
     maat_state_get_direct_hit_groups(state, hit_groups, n_hit_group);
-    EXPECT_EQ(n_hit_group, 1);
+    EXPECT_EQ(n_hit_group, 2);
 
     EXPECT_EQ(hit_groups[0].item_id, item5_id);
     EXPECT_EQ(hit_groups[0].group_id, group1_id);
     EXPECT_EQ(hit_groups[0].vtable_id, keywords_table_id); //physical table(keywords_table) vtable_id is 0
 
+    EXPECT_EQ(hit_groups[1].item_id, item4_id);
+    EXPECT_EQ(hit_groups[1].group_id, group4_id);
+    EXPECT_EQ(hit_groups[1].vtable_id, keywords_table_id); //physical table(keywords_table) vtable_id is 0
+
     n_last_hit_group = maat_state_get_last_hit_group_id_cnt(state);
     maat_state_get_last_hit_group_ids(state, last_hit_group_ids, 128);
-    EXPECT_EQ(n_last_hit_group, 2);
+    EXPECT_EQ(n_last_hit_group, 3);
     EXPECT_EQ(last_hit_group_ids[0], group1_id);
-    EXPECT_EQ(last_hit_group_ids[1], group11_id);
+    EXPECT_EQ(last_hit_group_ids[1], group4_id);
+    EXPECT_EQ(last_hit_group_ids[2], group11_id);
 
     maat_stream_free(stream);
     maat_state_free(state);
@@ -9263,8 +9268,8 @@ TEST_F(MaatCmdTest, HitPathBasic) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    size_t scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 1);
+    size_t scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 1);
 
     struct maat_hit_path hit_path[128];
     memset(hit_path, 0, sizeof(hit_path));
@@ -9306,8 +9311,8 @@ TEST_F(MaatCmdTest, HitPathBasic) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 2);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 2);
 
     n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path));
     EXPECT_EQ(n_read, 4);
@@ -9364,8 +9369,8 @@ that the edges be all directed in the same direction.";
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 3);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 3);
 
     n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path));
     EXPECT_EQ(n_read, 5);
@@ -9394,8 +9399,8 @@ that the edges be all directed in the same direction.";
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 4);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 4);
  
     n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path));
     EXPECT_EQ(n_read, 6);
@@ -9418,8 +9423,8 @@ that the edges be all directed in the same direction.";
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 5);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 5);
 
     n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path));
     EXPECT_EQ(n_read, 7);
@@ -9927,8 +9932,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    size_t scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 1);
+    size_t scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 1);
 
     struct maat_hit_path hit_path[128];
     memset(hit_path, 0, sizeof(hit_path));
@@ -9972,8 +9977,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 2);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 2);
 
     n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path));
     EXPECT_EQ(n_read, 4);
@@ -10031,8 +10036,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 3);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 3);
 
     n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path));
     EXPECT_EQ(n_read, 5);
@@ -10062,8 +10067,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 4);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 4);
  
     n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path));
     EXPECT_EQ(n_read, 6);
@@ -10087,8 +10092,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) {
                               &n_hit_result, state);
     EXPECT_EQ(ret, MAAT_SCAN_OK);
 
-    scan_count = maat_state_get_scan_count(state);
-    EXPECT_EQ(scan_count, 5);
+    scan_times = maat_state_get_scan_count(state);
+    EXPECT_EQ(scan_times, 5);
 
     n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path));
     EXPECT_EQ(n_read, 7);
diff --git a/test/maat_framework_perf_gtest.cpp b/test/maat_framework_perf_gtest.cpp
index 89393a5..3084759 100644
--- a/test/maat_framework_perf_gtest.cpp
+++ b/test/maat_framework_perf_gtest.cpp
@@ -15,14 +15,14 @@
 #define ARRAY_SIZE              10
 #define	WAIT_FOR_EFFECTIVE_S	2
 #define PERF_THREAD_NUM         5
-#define PERF_SCAN_COUNT        1000 * 1000
+#define PERF_SCAN_TIMES        1000 * 1000
 
 const char *table_info_path = "./table_info.conf";
 const char *json_filename = "maat_json.json";
 
 struct thread_param {
 	int thread_id;
-	int test_count;
+	int test_times;
 	struct maat *maat_inst;
 	const char *table_name;
 	long long time_elapse_ms;
@@ -449,7 +449,7 @@ void *perf_string_scan_thread(void *arg)
 
     struct timespec start, end;
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data),
                                    results, ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -462,7 +462,7 @@ void *perf_string_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "thread_id:%d string_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->time_elapse_ms, hit_times);
@@ -505,31 +505,31 @@ TEST_F(MaatPerfStringScan, LiteralMultiThread) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_times = PERF_SCAN_TIMES;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_string_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_string_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
              "StringScan match rate on %d-threads speed %lld lookups/s/thread",
              PERF_THREAD_NUM, scan_per_second);
@@ -599,7 +599,7 @@ void *perf_regex_scan_thread(void *arg)
     maat_register_thread(maat_inst);
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data),
                                    results, ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -612,7 +612,7 @@ void *perf_regex_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "thread_id:%d regex_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->time_elapse_ms, hit_times);
@@ -655,31 +655,31 @@ TEST_F(MaatPerfRegexScan, RegexMultiThread) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_times = PERF_SCAN_TIMES;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
     
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
              "RegexScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -701,7 +701,7 @@ void *perf_integer_scan_thread(void *arg)
     maat_register_thread(maat_inst);
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_integer(maat_inst, table_id, 3000, results,
                                     ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -714,7 +714,7 @@ void *perf_integer_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + 
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "thread_id:%d integer_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->time_elapse_ms, hit_times);
@@ -804,7 +804,7 @@ void *perf_stream_scan_thread(void *arg)
     maat_register_thread(maat_inst);
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         ret = maat_stream_scan(sp, scan_data, strlen(scan_data), results, ARRAY_SIZE,
                                 &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -819,7 +819,7 @@ void *perf_stream_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = ((hit_times == param->test_count) ? 1 : 0);
+    *is_all_hit = ((hit_times == param->test_times) ? 1 : 0);
 
     log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "thread_id:%d stream_scan time_elapse:%lldms hit_times:%d", 
@@ -843,7 +843,7 @@ TEST_F(MaatPerfStreamScan, MultiThread) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_times = PERF_SCAN_TIMES;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
@@ -853,17 +853,17 @@ TEST_F(MaatPerfStreamScan, MultiThread) {
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
         //maybe expr_runtime rebuild in stream_scan, so should not expect is_all_hit always 1
 		EXPECT_EQ(*is_all_hit, 1);
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
              "StreamScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -939,7 +939,7 @@ void *perf_ip_scan_thread(void *arg)
     maat_register_thread(maat_inst);
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6,
                                  results, ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -952,7 +952,7 @@ void *perf_ip_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "thread_id:%d ip_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->time_elapse_ms, hit_times);
@@ -1006,31 +1006,31 @@ TEST_F(MaatPerfIPScan, MultiThread)
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_times = PERF_SCAN_TIMES;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
              "IPScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1101,31 +1101,31 @@ TEST_F(MaatPerfIntegerScan, MultiThread) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_times = PERF_SCAN_TIMES;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
              "IntegerScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1195,7 +1195,7 @@ void *perf_flag_scan_thread(void *arg)
     int table_id = maat_get_table_id(maat_inst, table_name);
 
     clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < param->test_count; i++) {
+    for (int i = 0; i < param->test_times; i++) {
         int ret = maat_scan_flag(maat_inst, table_id, scan_data, results,
                                  ARRAY_SIZE, &n_hit_result, state);
         if (ret == MAAT_SCAN_HIT) {
@@ -1208,7 +1208,7 @@ void *perf_flag_scan_thread(void *arg)
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    *is_all_hit = (hit_times == param->test_times ? 1 : 0);
     log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "thread_id:%d flag_scan time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->time_elapse_ms, hit_times);
@@ -1249,31 +1249,31 @@ TEST_F(MaatPerfFlagScan, MultiThread) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_times = PERF_SCAN_TIMES;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
              "FlagScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1382,7 +1382,7 @@ void* perf_fqdn_plugin_scan_thread(void *arg)
 	struct timespec start, end;
 	
 	clock_gettime(CLOCK_MONOTONIC, &start);
-	for (i = 0; i < param->test_count; i++) {
+	for (i = 0; i < param->test_times; i++) {
 	
 		ret = maat_fqdn_plugin_table_get_ex_data(maat_inst, table_id, 
                                                  "r3---sn-i3belne6.example2.com",
@@ -1396,7 +1396,7 @@ void* perf_fqdn_plugin_scan_thread(void *arg)
 	param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + 
                             (end.tv_nsec - start.tv_nsec) / 1000000;
 	int* is_all_hit = (int*)malloc(sizeof(int));
-	*is_all_hit = (hit_times == param->test_count) ? 1 : 0;
+	*is_all_hit = (hit_times == param->test_times) ? 1 : 0;
     log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "thread_id:%d fqdn_plugin_get_ex_data time_elapse:%lldms hit_times:%d", 
              param->thread_id, param->time_elapse_ms, hit_times);
@@ -1477,31 +1477,31 @@ TEST_F(MaatPerfFQDNPluginScan, MultiThread) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_times = PERF_SCAN_TIMES;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_fqdn_plugin_scan_thread, thread_params + i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_fqdn_plugin_update_thread, thread_params + i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
              "FQDNPluginScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1613,7 +1613,7 @@ void* perf_bool_plugin_scan_thread(void *arg)
 	unsigned long long items_4[]={7, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7};
 
 	clock_gettime(CLOCK_MONOTONIC, &start);
-	for (i = 0; i < param->test_count; i++) {
+	for (i = 0; i < param->test_times; i++) {
 	
 		ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items_4,
                                                  sizeof(items_4)/sizeof(unsigned long long),
@@ -1627,7 +1627,7 @@ void* perf_bool_plugin_scan_thread(void *arg)
 	param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
                             (end.tv_nsec - start.tv_nsec) / 1000000;
 	int* is_all_hit = (int*)malloc(sizeof(int));
-	*is_all_hit = (hit_times == param->test_count) ? 1 : 0;
+	*is_all_hit = (hit_times == param->test_times) ? 1 : 0;
 
     log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "thread_id:%d bool_plugin_get_ex_data time_elapse:%lldms hit_times:%d", 
@@ -1685,31 +1685,31 @@ TEST_F(MaatPerfBoolPluginScan, MultiThread) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_times = PERF_SCAN_TIMES;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_bool_plugin_scan_thread, thread_params + i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_bool_plugin_update_thread, thread_params + i);
         }
     }
 
     long long time_elapse_ms = 0;
-    long long scan_count = 0;
+    long long scan_times = 0;
     long long scan_per_second = 0;
     for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
-		scan_count += thread_params[i].test_count;
+		scan_times += thread_params[i].test_times;
 
 		EXPECT_EQ(*is_all_hit, 1);
 		*is_all_hit = 0;
 		free(is_all_hit);
     }
-    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    scan_per_second = scan_times * 1000 / time_elapse_ms;
 
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
              "BoolPluginScan match rate on %d-threads speed %lld lookups/s/thread",
@@ -1990,7 +1990,7 @@ static void *perf_ipport_plugin_scan_thread(void *arg)
 	inet_pton(AF_INET, "192.168.100.1", &ipv4.ipv4);	
     uint16_t port = htons(215);
 
-	for (i = 0; i < param->test_count; i++) {
+	for (i = 0; i < param->test_times; i++) {
 		ret = maat_ipport_plugin_table_get_ex_data(maat_inst, table_id, &ipv4,
                                                    port, (void**)results, 4);
 		if (ret > 0) {
@@ -1999,7 +1999,7 @@ static void *perf_ipport_plugin_scan_thread(void *arg)
 	}
 
 	int *is_all_hit = (int *)malloc(sizeof(int));
-	*is_all_hit = (hit_times == param->test_count) ? 1 : 0;
+	*is_all_hit = (hit_times == param->test_times) ? 1 : 0;
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "ipport_plugin_get_ex_data hit_times:%d", hit_times);
 
@@ -2056,14 +2056,14 @@ TEST_F(MaatPerfIPPortPluginScan, MultiThread) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].test_times = PERF_SCAN_TIMES;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_ipport_plugin_scan_thread, thread_params+i);
         } else {
-            thread_params[i].test_count = 0;
+            thread_params[i].test_times = 0;
             pthread_create(&threads[i], NULL, perf_ipport_plugin_update_thread, thread_params+i);
         }
 	}
@@ -2084,4 +2084,4 @@ int main(int argc, char ** argv)
     ret=RUN_ALL_TESTS();
 
 	return ret;
-}
\ No newline at end of file
+}