renames

12 files changed, 98 insertions, 98 deletions

diff --git a/include/fieldstat/fieldstat.h b/include/fieldstat/fieldstat.h
index b0969cf..b30be53 100644
--- a/include/fieldstat/fieldstat.h
+++ b/include/fieldstat/fieldstat.h
@@ -60,13 +60,13 @@ struct fieldstat *fieldstat_fork(const struct fieldstat *instance);
 int fieldstat_calibrate(const struct fieldstat *master, struct fieldstat *replica);
 /*
     * @brief add an cube to this instance. Cube represents an template with a user-defined set of cells and metrics.
-    * @param shared_tags: tags that are shared by all cells in this cube. This is the key of the cube. Can be NULL. Must be unique. Shared_tags are ordered, which means that {"TAG_KEY": "123", "TAG_KEY2": "456"} and {"TAG_KEY2": "456", "TAG_KEY": "123"} are map to different cube.
+    * @param cube_identifier: tags that are shared by all cells in this cube. This is the key of the cube. Can be NULL. Must be unique. Shared_tags are ordered, which means that {"TAG_KEY": "123", "TAG_KEY2": "456"} and {"TAG_KEY2": "456", "TAG_KEY": "123"} are map to different cube.
     * @param n_tag: number of shared tags.
     * @param mode: sampling mode. Refer to enum sampling_mode.
     * @param max_n_cell: max number of samplings(cells) in each cube. When mode is TOPK, max_n_cell > 0, while in COMPREHENSIVE mode, max_n_cell can be 0, meaning that there is no limit.
-    * @return cube id, if success; otherwise, return FS_ERR_NULL_HANDLER, or FS_ERR_INVALID_PARAM when (max_n_cell == 0 && mode == TOPK). return FS_ERR_INVALID_KEY when the shared_tags is not unique.
+    * @return cube id, if success; otherwise, return FS_ERR_NULL_HANDLER, or FS_ERR_INVALID_PARAM when (max_n_cell == 0 && mode == TOPK). return FS_ERR_INVALID_KEY when the cube_identifier is not unique.
 */
-int fieldstat_create_cube(struct fieldstat *instance, const struct fieldstat_tag *shared_tags, size_t n_tag, enum sampling_mode mode, size_t max_n_cell);
+int fieldstat_create_cube(struct fieldstat *instance, const struct fieldstat_tag *cube_identifier, size_t n_tag, enum sampling_mode mode, size_t max_n_cell);
 
 /*
     @brief Change the topk cube primary metric id. When fieldstat_counter_add or fieldstat_counter_set are called on the primary metric, the topk record of such cell will be updated.
@@ -193,18 +193,18 @@ enum metric_type fieldstat_get_metric_type(const struct fieldstat *instance, int
 /*
     get the tags added to cube when calling fieldstat_counter_incrby, fieldstat_counter_set, fieldstat_hll_add, fieldstat_hist_record.
 */
-void fieldstat_get_cells_used_by_cube(const struct fieldstat *instance, int cube_id, struct fieldstat_tag_list **tag_list, size_t *n_cell);
+void fieldstat_cube_get_cells(const struct fieldstat *instance, int cube_id, struct fieldstat_tag_list **tag_list, size_t *n_cell);
 
 /*
-    get the shared tag of fieldstat_create_cube. User free them by calling fieldstat_tag_list_arr_free(struct fieldstat_tag_list *, 1)
+    get the tag of fieldstat_create_cube. User free them by calling fieldstat_tag_list_arr_free(struct fieldstat_tag_list *, 1)
     return NULL when ID is invalid.
 */
-struct fieldstat_tag_list *fieldstat_get_shared_tags(const struct fieldstat *instance, int cube_id);
+struct fieldstat_tag_list *fieldstat_cube_get_tags(const struct fieldstat *instance, int cube_id);
 
 /*
     return a cube id corresponding to the shared tags. FS_ERR_INVALID_KEY is returned if the shared tags are not found.
 */
-int fieldstat_find_cube(const struct fieldstat *instance, const struct fieldstat_tag *shared_tags, size_t n_shared_tags);
+int fieldstat_find_cube(const struct fieldstat *instance, const struct fieldstat_tag *cube_identifier, size_t n_shared_tags);
 
 /* 
     get the cell numbers in a cube. Return FS_ERR_INVALID_CUBE_ID if cube_id is invalid.
@@ -219,15 +219,15 @@ int fieldstat_get_used_sampling(const struct fieldstat *instance, int cube_id);
     * @param value_out: the value of the metric. If the cell is not found, *value_out is set to 0.
     * @return FS_OK if success. FS_ERR_NULL_HANDLER, FS_ERR_INVALID_CUBE_ID, FS_ERR_INVALID_METRIC_ID if fail.
 */
-int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tags, long long *value);
+int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, const struct fieldstat_tag_list *tags, int metric_id, long long *value);
 
 /*
     @brief Get an approximate count of the number of distinct elements in the cell. Other information refer to fieldstat_counter_get.
     @return >= 0 if success. FS_ERR_INVALID_PARAM if precision is invalid.
 */
-int fieldstat_hll_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tags, double *value);
-long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tags, double percentile);
-long long fieldstat_hist_count_le_value(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tags, long long value);
+int fieldstat_hll_get(const struct fieldstat *instance, int cube_id, const struct fieldstat_tag_list *tags, int metric_id, double *value);
+long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, int cube_id, const struct fieldstat_tag_list *tags, int metric_id, double percentile);
+long long fieldstat_hist_count_le_value(const struct fieldstat *instance, int cube_id, const struct fieldstat_tag_list *tags, int metric_id, long long value);
 
 // get the base 64 encoded string of the serialized blob of a cell
 void fieldstat_get_serialized_blob(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tags, char **blob, size_t *blob_size);
diff --git a/src/cube.c b/src/cube.c
index aa50440..b1123a0 100644
--- a/src/cube.c
+++ b/src/cube.c
@@ -53,8 +53,10 @@ struct cube {
     UT_hash_handle hh;
 };
 
-static void tag_array_copy(struct fieldstat_tag *tags_dst, const struct fieldstat_tag *tags_src, size_t n_tag) // TODO: 改成clone吧, 
+static struct fieldstat_tag *tag_array_duplicate(const struct fieldstat_tag *tags_src, size_t n_tag)
 {
+    struct fieldstat_tag *tags_dst = malloc(sizeof(struct fieldstat_tag) * n_tag);
+
     for (size_t i = 0; i < n_tag; i++) {
         tags_dst[i].key = strdup(tags_src[i].key);
         tags_dst[i].type = tags_src[i].type;
@@ -73,6 +75,8 @@ static void tag_array_copy(struct fieldstat_tag *tags_dst, const struct fieldsta
             break;
         }
     }
+
+    return tags_dst;
 }
 
 static void fieldstat_free_tag_array(struct fieldstat_tag *tags, size_t n_tags)
@@ -143,7 +147,7 @@ static void tag2key(const struct fieldstat_tag tags[], size_t n_tags, char **out
     size_t remain_key_size = alloced_every_time;
     size_t total_key_size = alloced_every_time;
     char *dynamic_mem = (char *)malloc(total_key_size);
-    void *val_position;
+    void *val_position = NULL;
 
     size_t key_len = 0;
     size_t val_len = 0;
@@ -156,11 +160,11 @@ static void tag2key(const struct fieldstat_tag tags[], size_t n_tags, char **out
 		{
 			case TAG_INTEGER:
                 val_len = sizeof(long long);
-                val_position = &tag->value_longlong;
+                val_position = (void *)&tag->value_longlong;
 				break;
 			case TAG_DOUBLE:
                 val_len = sizeof(double);
-                val_position = &tag->value_double;
+                val_position = (void *)&tag->value_double;
 
 				break;
 			case TAG_CSTRING:
@@ -378,8 +382,7 @@ struct cell *cell_new(const struct exdata_new_args *args) {
     pthis->metrics_len = 0;
 
     pthis->tags.n_tag = args->n_tags;
-    pthis->tags.tag = malloc(sizeof(struct fieldstat_tag) * args->n_tags);
-    tag_array_copy(pthis->tags.tag, args->tags, args->n_tags);
+    pthis->tags.tag = tag_array_duplicate(args->tags, args->n_tags);
     return pthis;
 }
 
@@ -412,8 +415,7 @@ struct cell *cell_copy(const struct cell *src) {
     }
     
     pthis->tags.n_tag = src->tags.n_tag;
-    pthis->tags.tag = malloc(sizeof(struct fieldstat_tag) * src->tags.n_tag);
-    tag_array_copy(pthis->tags.tag, src->tags.tag, src->tags.n_tag);
+    pthis->tags.tag = tag_array_duplicate(src->tags.tag, src->tags.n_tag);
 
     return pthis;
 }
@@ -472,8 +474,7 @@ struct cube *cube_info_new(const struct fieldstat_tag *shared_tags, size_t n_tag
     if (n_tag == 0) {
         cube->cube_identifier = NULL;
     } else {
-        cube->cube_identifier = malloc(sizeof(struct fieldstat_tag) * n_tag);
-        tag_array_copy(cube->cube_identifier, shared_tags, n_tag);
+        cube->cube_identifier = tag_array_duplicate(shared_tags, n_tag);
     }
 
     cube->n_shared_tags = n_tag;
@@ -732,8 +733,7 @@ void cube_get_cells(const struct cube *cube, struct fieldstat_tag_list **tag_lis
             tag_list_tmp->tag = NULL;
             continue;
         }
-        tag_list_tmp->tag = (struct fieldstat_tag *)malloc(sizeof(struct fieldstat_tag) * tag_list_tmp->n_tag);
-        tag_array_copy(tag_list_tmp->tag, cell_data->tags.tag, tag_list_tmp->n_tag);
+        tag_list_tmp->tag = tag_array_duplicate(cell_data->tags.tag, tag_list_tmp->n_tag);
     }
 
     free(cell_datas);
@@ -893,9 +893,9 @@ struct fieldstat_tag_list *cube_get_identifier(const struct cube *cube) {
         return tag_list;
     }
 
-    tag_list->tag = (struct fieldstat_tag *)malloc(sizeof(struct fieldstat_tag) * cube->n_shared_tags);
+    tag_list->tag = tag_array_duplicate(cube->cube_identifier, cube->n_shared_tags);
     tag_list->n_tag = cube->n_shared_tags;
-    tag_array_copy(tag_list->tag, cube->cube_identifier, cube->n_shared_tags);
+    
 
     return tag_list;
 }
\ No newline at end of file
diff --git a/src/exporter/cjson_exporter.c b/src/exporter/cjson_exporter.c
index 23e3503..643fb0f 100644
--- a/src/exporter/cjson_exporter.c
+++ b/src/exporter/cjson_exporter.c
@@ -476,12 +476,12 @@ int cell_iter_next_cube(struct cell_iter *iter) {
     while (iter->curr_cube_idx < iter->n_cube - 1) {
         int cube_id_next = iter->cube_ids[++iter->curr_cube_idx];
 
-        fieldstat_get_cells_used_by_cube(instance, cube_id_next, &iter->tag_list, &iter->n_cell);
+        fieldstat_cube_get_cells(instance, cube_id_next, &iter->tag_list, &iter->n_cell);
         if (iter->n_cell == 0) {
             continue;
         }
 
-        iter->shared_tag = fieldstat_get_shared_tags(iter->instance, iter->cube_ids[iter->curr_cube_idx]);
+        iter->shared_tag = fieldstat_cube_get_tags(iter->instance, iter->cube_ids[iter->curr_cube_idx]);
         iter->curr_cell_idx = 0;
         return 1;
     }
@@ -528,7 +528,7 @@ struct export_kv_pair *cell_query_with_iter(const struct cell_iter *iter, int me
     struct export_kv_pair *ret = NULL;
     if (type == METRIC_TYPE_COUNTER) {
         long long value;
-        int tmp_ret = fieldstat_counter_get(iter->instance, iter->cube_ids[iter->curr_cube_idx], metric_id, &iter->tag_list[iter->curr_cell_idx], &value);
+        int tmp_ret = fieldstat_counter_get(iter->instance, iter->cube_ids[iter->curr_cube_idx], &iter->tag_list[iter->curr_cell_idx], metric_id, &value);
         if (tmp_ret < 0) {
             return NULL;
         }
diff --git a/src/fieldstat.c b/src/fieldstat.c
index df5f482..e5a5945 100644
--- a/src/fieldstat.c
+++ b/src/fieldstat.c
@@ -162,14 +162,14 @@ void fieldstat_free_tag_array(struct fieldstat_tag *tags, size_t n_tags)
     free(tags);
 }
 
-int fieldstat_create_cube(struct fieldstat *instance, const struct fieldstat_tag *shared_tags, size_t n_tag, enum sampling_mode mode, size_t max_n_cell)
+int fieldstat_create_cube(struct fieldstat *instance, const struct fieldstat_tag *cube_identifier, size_t n_tag, enum sampling_mode mode, size_t max_n_cell)
 {
     if (instance == NULL) {
         return  FS_ERR_NULL_HANDLER;
     }
 
-    if (n_tag == 0 || shared_tags == NULL) {
-        shared_tags = NULL;
+    if (n_tag == 0 || cube_identifier == NULL) {
+        cube_identifier = NULL;
         n_tag = 0;
     }
     if (mode == SAMPLING_MODE_TOPK && max_n_cell == 0) {
@@ -179,7 +179,7 @@ int fieldstat_create_cube(struct fieldstat *instance, const struct fieldstat_tag
         max_n_cell = INT32_MAX;
     }
     
-    struct cube *cube = cube_new(shared_tags, n_tag, mode, max_n_cell);
+    struct cube *cube = cube_new(cube_identifier, n_tag, mode, max_n_cell);
     int ret = cube_manager_add(instance->cube_manager, cube);
     if (ret < 0) {
         cube_free(cube);
@@ -429,7 +429,7 @@ void fieldstat_get_metrics(const struct fieldstat *instance, int **metric_id_out
     }
 }
 
-struct fieldstat_tag_list *fieldstat_get_shared_tags(const struct fieldstat *instance, int cube_id)
+struct fieldstat_tag_list *fieldstat_cube_get_tags(const struct fieldstat *instance, int cube_id)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -439,7 +439,7 @@ struct fieldstat_tag_list *fieldstat_get_shared_tags(const struct fieldstat *ins
     return cube_get_identifier(cube);
 }
 
-int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tags, long long *value)
+int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, const struct fieldstat_tag_list *tags, int metric_id, long long *value)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -449,7 +449,7 @@ int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int met
     return cube_counter_get(cube, metric_id, tags, value);
 }
 
-int fieldstat_hll_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tags, double *value)
+int fieldstat_hll_get(const struct fieldstat *instance, int cube_id, const struct fieldstat_tag_list *tags, int metric_id, double *value)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -461,7 +461,7 @@ int fieldstat_hll_get(const struct fieldstat *instance, int cube_id, int metric_
     return ret;
 }
 
-long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tags, double percentile)
+long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, int cube_id, const struct fieldstat_tag_list *tags, int metric_id, double percentile)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -476,7 +476,7 @@ long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, i
     return value;
 }
 
-long long fieldstat_hist_count_le_value(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tags, long long value)
+long long fieldstat_hist_count_le_value(const struct fieldstat *instance, int cube_id, const struct fieldstat_tag_list *tags, int metric_id, long long value)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -533,7 +533,7 @@ enum metric_type fieldstat_get_metric_type(const struct fieldstat *instance, int
     return metric->type;
 }
 
-void fieldstat_get_cells_used_by_cube(const struct fieldstat *instance, int cube_id, struct fieldstat_tag_list **tag_list, size_t *n_cell)
+void fieldstat_cube_get_cells(const struct fieldstat *instance, int cube_id, struct fieldstat_tag_list **tag_list, size_t *n_cell)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
diff --git a/src/tags/heavy_keeper.c b/src/tags/heavy_keeper.c
index a017a72..faca93c 100644
--- a/src/tags/heavy_keeper.c
+++ b/src/tags/heavy_keeper.c
@@ -644,8 +644,8 @@ int heavy_keeper_add(struct heavy_keeper *heavy_keeper, const char *key, size_t
             sorted_set_insert(summary, key, key_len, maxv, arg);
             return 1;
         }
-        unsigned nMin = sorted_set_get_min_count(summary);
-        if (maxv > nMin || nMin == INVALID_COUNT) {
+        unsigned min_value = sorted_set_get_min_count(summary);
+        if (maxv > min_value || min_value == INVALID_COUNT) {
             sorted_set_insert(summary, key, key_len, maxv, arg);
             return 1;
         }
diff --git a/test/test_empty_tags.cpp b/test/test_empty_tags.cpp
index 4f500bd..7e17489 100644
--- a/test/test_empty_tags.cpp
+++ b/test/test_empty_tags.cpp
@@ -10,12 +10,12 @@ void assert_cell_null(const struct fieldstat *instance, int cube_id, long long e
 {
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance, cube_id, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance, cube_id, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
     EXPECT_EQ(tag_list[0].n_tag, 0);
     EXPECT_TRUE(tag_list[0].tag == NULL);
     long long value;
-    fieldstat_counter_get(instance, cube_id, 0, &tag_list[0], &value);
+    fieldstat_counter_get(instance, cube_id, &tag_list[0], 0, &value);
     EXPECT_EQ(value, expected_count);
     fieldstat_tag_list_arr_free(tag_list, n_cell);
 }
@@ -57,7 +57,7 @@ TEST(test_empty_tag, merge)
     int n_cube = 0;
     fieldstat_get_cubes(instance_dst, &ret_cube_id_arr, &n_cube);
     int ret_cell_id = ret_cube_id_arr[0];
-    struct fieldstat_tag_list *shared_tag = fieldstat_get_shared_tags(instance_dst, ret_cell_id);
+    struct fieldstat_tag_list *shared_tag = fieldstat_cube_get_tags(instance_dst, ret_cell_id);
     EXPECT_EQ(shared_tag->n_tag, 0);
     EXPECT_TRUE(shared_tag->tag == NULL);
     fieldstat_tag_list_arr_free(shared_tag, 1);
@@ -81,7 +81,7 @@ TEST(test_empty_tag, merge_topk)
     int n_cube = 0;
     fieldstat_get_cubes(instance_dst, &ret_cube_id_arr, &n_cube);
     int ret_cell_id = ret_cube_id_arr[0];
-    struct fieldstat_tag_list *shared_tag = fieldstat_get_shared_tags(instance_dst, ret_cell_id);
+    struct fieldstat_tag_list *shared_tag = fieldstat_cube_get_tags(instance_dst, ret_cell_id);
     EXPECT_EQ(shared_tag->n_tag, 0);
     EXPECT_TRUE(shared_tag->tag == NULL);
     fieldstat_tag_list_arr_free(shared_tag, 1);
diff --git a/test/test_fuzz_test.cpp b/test/test_fuzz_test.cpp
index 96e5405..bcf0d20 100644
--- a/test/test_fuzz_test.cpp
+++ b/test/test_fuzz_test.cpp
@@ -43,7 +43,7 @@ void fill_with_elephant_flows(Fieldstat_tag_list_wrapper *tags[], int tag_list_n
 long long fuzz_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tag_list)
 {
     long long value = 0;
-    int ret = fieldstat_counter_get(instance, cube_id, metric_id, tag_list, &value);
+    int ret = fieldstat_counter_get(instance, cube_id, tag_list, metric_id, &value);
     EXPECT_EQ(ret, 0);
     return value;
 }
@@ -51,7 +51,7 @@ long long fuzz_fieldstat_counter_get(const struct fieldstat *instance, int cube_
 double fuzz_fieldstat_hll_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tag_list)
 {
     double value = 0;
-    int ret = fieldstat_hll_get(instance, cube_id, metric_id, tag_list, &value);
+    int ret = fieldstat_hll_get(instance, cube_id, tag_list, metric_id, &value);
     EXPECT_EQ(ret, 0);
     return value;
 }
@@ -170,15 +170,15 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
     struct fieldstat *instance_in_focus = dest;
     fieldstat_get_cubes(instance_in_focus, &cube_ids, &cube_num);
     for (int i = 0; i < cube_num; i++) {
-        struct fieldstat_tag_list *shared_tag_out = fieldstat_get_shared_tags(instance_in_focus, cube_ids[i]);
+        struct fieldstat_tag_list *shared_tag_out = fieldstat_cube_get_tags(instance_in_focus, cube_ids[i]);
 
         size_t cell_num0;
         struct fieldstat_tag_list *tags0;
-        fieldstat_get_cells_used_by_cube(instance_in_focus, cube_ids[i], &tags0, &cell_num0);
+        fieldstat_cube_get_cells(instance_in_focus, cube_ids[i], &tags0, &cell_num0);
 
         for (size_t j = 0; j < cell_num0; j++) {
-            EXPECT_EQ(fieldstat_counter_get(instance_in_focus, cube_ids[i], METRIC_ID_COUNTER, &tags0[j], &dummy_ll), FS_OK);
-            EXPECT_EQ(fieldstat_hll_get(instance_in_focus, cube_ids[i], METRIC_ID_HLL, &tags0[j], &dummy_d), FS_OK);
+            EXPECT_EQ(fieldstat_counter_get(instance_in_focus, cube_ids[i], &tags0[j], METRIC_ID_COUNTER, &dummy_ll), FS_OK);
+            EXPECT_EQ(fieldstat_hll_get(instance_in_focus, cube_ids[i], &tags0[j], METRIC_ID_HLL, &dummy_d), FS_OK);
         }
 
         for (size_t j = 0; j < cell_num0; j++) {
@@ -296,11 +296,11 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
     struct fieldstat *instance_in_focus = dest;
     fieldstat_get_cubes(instance_in_focus, &cube_ids, &cube_num);
     for (int i = 0; i < cube_num; i++) {
-        struct fieldstat_tag_list *shared_tag_out = fieldstat_get_shared_tags(instance_in_focus, cube_ids[i]);
+        struct fieldstat_tag_list *shared_tag_out = fieldstat_cube_get_tags(instance_in_focus, cube_ids[i]);
 
         size_t cell_num;
         struct fieldstat_tag_list *tags;
-        fieldstat_get_cells_used_by_cube(instance_in_focus, cube_ids[i], &tags, &cell_num);
+        fieldstat_cube_get_cells(instance_in_focus, cube_ids[i], &tags, &cell_num);
 
         std::vector<struct Fieldstat_tag_list_wrapper *> test_result;
         for (size_t j = 0; j < cell_num; j++) {
@@ -350,13 +350,13 @@ TEST(Fuzz_test, add_and_reset_with_randomly_generated_flows_and_randomly_chosen_
         if (ret == FS_ERR_TOO_MANY_CELLS) {
             struct fieldstat_tag_list *tag_list = NULL;
             size_t n_cell = 0;
-            fieldstat_get_cells_used_by_cube(instance, cube_id, &tag_list, &n_cell);
+            fieldstat_cube_get_cells(instance, cube_id, &tag_list, &n_cell);
             ASSERT_EQ(n_cell, 1);
 
             long long value;
             tag_list_tmp.tag = (struct fieldstat_tag *)tag_list_wrapper[i]->get_tag();
             tag_list_tmp.n_tag = tag_list_wrapper[i]->get_tag_count();
-            int counter_exist = fieldstat_counter_get(instance, cube_id, using_id, &tag_list_tmp, &value);
+            int counter_exist = fieldstat_counter_get(instance, cube_id, &tag_list_tmp, using_id,  &value);
             ASSERT_EQ(counter_exist, FS_ERR_INVALID_TAG); // the tag is not added to the cube
             fieldstat_tag_list_arr_free(tag_list, n_cell);
         }
@@ -403,7 +403,7 @@ TEST(Fuzz_test, simple_one_for_perf)
     struct fieldstat *instance = master;
 
     clock_t start = clock();
-    printf("press any key to start\n");
+    printf("press any key to start v46\n");
     getchar();
 
     for (int i = 0; i < TEST_ROUND; i++) {
@@ -432,7 +432,7 @@ int main(int argc, char *argv[])
 {
 	testing::InitGoogleTest(&argc, argv);
     // testing::GTEST_FLAG(filter) = "Fuzz_test.many_instance_random_flow_unregister_calibrate_reset_fork_merge_topk";
-    testing::GTEST_FLAG(filter) = "-Fuzz_test.simple_one_for_perf";
+    testing::GTEST_FLAG(filter) = "Fuzz_test.simple_one_for_perf";
 
 	return RUN_ALL_TESTS();
 }
\ No newline at end of file
diff --git a/test/test_merge.cpp b/test/test_merge.cpp
index 42f87e0..cf37bc7 100644
--- a/test/test_merge.cpp
+++ b/test/test_merge.cpp
@@ -34,7 +34,7 @@ double test_cal_accuracy_given_expected_key(vector<struct Fieldstat_tag_list_wra
 long long merge_test_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tag_list = &TEST_TAG_LIST_STRING)
 {
     long long ret = 0;
-    fieldstat_counter_get(instance, cube_id, metric_id, tag_list, &ret);
+    fieldstat_counter_get(instance, cube_id, tag_list, metric_id, &ret);
     return ret;
 }
 
@@ -158,7 +158,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_comprehensive)
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance, cube_id, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance, cube_id, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
     EXPECT_EQ(tag_list->n_tag, 1);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_STRING.key);
@@ -205,7 +205,7 @@ TEST(unit_test_merge, new_too_many_cells_on_one_metric_given_source_cube_reset_a
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance_dest, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 2);
     EXPECT_EQ(merge_test_fieldstat_counter_get(instance_dest, 0, 0, &tag_list[0]), 1);
     EXPECT_EQ(merge_test_fieldstat_counter_get(instance_dest, 0, 0, &tag_list[1]), 2);
@@ -293,7 +293,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_topk)
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance, cube_id, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance, cube_id, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
     EXPECT_EQ(tag_list->n_tag, 1);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_STRING.key);
@@ -324,7 +324,7 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_topk)
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance_dest, ret_cube_id, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance_dest, ret_cube_id, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
     long long measure = merge_test_fieldstat_counter_get(instance_dest, cube_id, metric_id, &tag_list[0]);
     EXPECT_EQ(measure, 10);
@@ -352,7 +352,7 @@ TEST(unit_test_merge, new_too_many_cells_on_one_metric_given_source_cube_reset_a
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance_dest, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 2);
     EXPECT_EQ(merge_test_fieldstat_counter_get(instance_dest, 0, 0, &tag_list[0]), 3);
     EXPECT_EQ(merge_test_fieldstat_counter_get(instance_dest, 0, 0, &tag_list[1]), 2);
@@ -384,7 +384,7 @@ TEST(unit_test_merge, merge_accuracy_test_with_K_large_enough_topk)
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance_dest, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
 
     vector<Fieldstat_tag_list_wrapper *> flows_in_merged;
     for (size_t i = 0; i < n_cell; i++) {
@@ -422,7 +422,7 @@ TEST(unit_test_merge, merge_accuracy_test_gen_dest_full_all_inserted_given_src_f
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance_dest, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     vector<Fieldstat_tag_list_wrapper *> flows_in_merged;
     for (size_t i = 0; i < n_cell; i++) {
         flows_in_merged.push_back(new Fieldstat_tag_list_wrapper(&tag_list[i]));
@@ -455,7 +455,7 @@ TEST(unit_test_merge, merge_accuracy_test_gen_dest_full_some_inserted_and_some_m
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance_dest, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     vector<Fieldstat_tag_list_wrapper *> flows_in_merged;
     for (size_t i = 0; i < n_cell; i++) {
         flows_in_merged.push_back(new Fieldstat_tag_list_wrapper(&tag_list[i]));
@@ -490,7 +490,7 @@ TEST(unit_test_merge, primary_metric_has_no_value)
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance_dest, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
     EXPECT_STREQ(tag_list[0].tag[0].key, TEST_TAG_STRING.key);
 
diff --git a/test/test_metric_counter.cpp b/test/test_metric_counter.cpp
index f0ed7bc..d5d2d5c 100644
--- a/test/test_metric_counter.cpp
+++ b/test/test_metric_counter.cpp
@@ -22,7 +22,7 @@ struct fieldstat *test_init_standard_instance()
 long long my_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tag_list = &TEST_TAG_LIST_INT)
 {
     long long ret = 0;
-    fieldstat_counter_get(instance, cube_id, metric_id, tag_list, &ret);
+    fieldstat_counter_get(instance, cube_id, tag_list, metric_id,  &ret);
     return ret;
 }
 
@@ -40,7 +40,7 @@ void test_assert_standard_instance(const struct fieldstat *instance)
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
     EXPECT_EQ(tag_list->n_tag, 1);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_INT.key);
@@ -138,7 +138,7 @@ TEST(metric_test_counter, topk_add_and_test_accuracy)
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 10);
     long long error = 0;
     for (size_t i = 0; i < n_cell; i++) {
diff --git a/test/test_metric_histogram.cpp b/test/test_metric_histogram.cpp
index ebb067c..4faf9fc 100644
--- a/test/test_metric_histogram.cpp
+++ b/test/test_metric_histogram.cpp
@@ -33,7 +33,7 @@ void test_assert_standard_instance(const struct fieldstat *instance)
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
     EXPECT_EQ(tag_list->n_tag, 1);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_STRING.key);
@@ -57,8 +57,8 @@ TEST(metric_test_histogram, simple_register_and_query)
     fieldstat_hist_record(instance, 0, 0, &TEST_TAG_STRING, 1, 123);
 
     test_assert_standard_instance(instance);
-    EXPECT_EQ(fieldstat_hist_value_at_percentile(instance, 0, 0, &TEST_TAG_LIST_STRING, 50.0), 1234);
-    EXPECT_EQ(fieldstat_hist_count_le_value(instance, 0, 0, &TEST_TAG_LIST_STRING, 1000), 1);
+    EXPECT_EQ(fieldstat_hist_value_at_percentile(instance, 0, &TEST_TAG_LIST_STRING, 0, 50.0), 1234);
+    EXPECT_EQ(fieldstat_hist_count_le_value(instance, 0, &TEST_TAG_LIST_STRING, 0, 1000), 1);
 
     fieldstat_free(instance);
 }
@@ -76,8 +76,8 @@ TEST(metric_test_histogram, merge)
     // query
     test_assert_standard_instance(instance_total);
 
-    EXPECT_EQ(fieldstat_hist_value_at_percentile(instance_total, 0, 0, &TEST_TAG_LIST_STRING, 50.0), 1234);
-    EXPECT_EQ(fieldstat_hist_count_le_value(instance, 0, 0, &TEST_TAG_LIST_STRING, 1000), 1);
+    EXPECT_EQ(fieldstat_hist_value_at_percentile(instance_total, 0, &TEST_TAG_LIST_STRING, 0, 50.0), 1234);
+    EXPECT_EQ(fieldstat_hist_count_le_value(instance, 0, &TEST_TAG_LIST_STRING, 0, 1000), 1);
 
     fieldstat_free(instance);
     fieldstat_free(instance_total);
@@ -97,8 +97,8 @@ TEST(metric_test_histogram, merge_twice_with_reset)
     fieldstat_merge(instance_total, instance);
 
     test_assert_standard_instance(instance_total);
-    EXPECT_EQ(fieldstat_hist_value_at_percentile(instance_total, 0, 0, &TEST_TAG_LIST_STRING, 50.0), 1234);
-    EXPECT_EQ(fieldstat_hist_count_le_value(instance_total, 0, 0, &TEST_TAG_LIST_STRING, 1000), 1);
+    EXPECT_EQ(fieldstat_hist_value_at_percentile(instance_total, 0, &TEST_TAG_LIST_STRING, 0, 50.0), 1234);
+    EXPECT_EQ(fieldstat_hist_count_le_value(instance_total, 0, &TEST_TAG_LIST_STRING, 0, 1000), 1);
 
     fieldstat_free(instance);
     fieldstat_free(instance_total);
@@ -178,7 +178,7 @@ TEST(metric_test_histogram, can_add_0value) // histogram only allow min_val > 0,
     EXPECT_EQ(ret, 0);
     ret = fieldstat_hist_record(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 500);
 
-    EXPECT_EQ(fieldstat_hist_value_at_percentile(instance, cube_id, metric_id, &TEST_TAG_LIST_INT, 60.0), 0);
+    EXPECT_EQ(fieldstat_hist_value_at_percentile(instance, cube_id, &TEST_TAG_LIST_INT, metric_id,  60.0), 0);
 
     fieldstat_free(instance);
 }
diff --git a/test/test_metric_hll.cpp b/test/test_metric_hll.cpp
index e58fdfb..96b4e6c 100644
--- a/test/test_metric_hll.cpp
+++ b/test/test_metric_hll.cpp
@@ -28,7 +28,7 @@ void test_assert_standard_instance(const struct fieldstat *instance)
 
     struct fieldstat_tag_list *tag_list = NULL;
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(instance, 0, &tag_list, &n_cell);
+    fieldstat_cube_get_cells(instance, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
     EXPECT_EQ(tag_list->n_tag, 1);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_INT.key);
@@ -46,7 +46,7 @@ void test_assert_standard_instance(const struct fieldstat *instance)
 double my_fieldstat_hll_get(const struct fieldstat *instance, int cube_id, int metric_id)
 {
     double ret = 0;
-    fieldstat_hll_get(instance, cube_id, metric_id, &TEST_TAG_LIST_INT, &ret);
+    fieldstat_hll_get(instance, cube_id, &TEST_TAG_LIST_INT, metric_id,  &ret);
     return ret;
 }
 
diff --git a/test/test_register_and_reset.cpp b/test/test_register_and_reset.cpp
index ff95ea6..25bdfb0 100644
--- a/test/test_register_and_reset.cpp
+++ b/test/test_register_and_reset.cpp
@@ -56,7 +56,7 @@ TEST(test_register, reset_and_try_to_query_cell)
     fieldstat_reset(instance);
     EXPECT_EQ(test_get_max_metric_id(instance), 0);
     long long value;
-    EXPECT_EQ(fieldstat_counter_get(instance, cube_id, metric_id, &TEST_TAG_LIST_INT, &value), FS_ERR_INVALID_TAG);
+    EXPECT_EQ(fieldstat_counter_get(instance, cube_id, &TEST_TAG_LIST_INT, metric_id, &value), FS_ERR_INVALID_TAG);
 
     fieldstat_free(instance);
 }
@@ -96,7 +96,7 @@ TEST(test_register, register_many_cubes)
 
     for (int i = 0; i < registered_cube; i++) {
         long long result;
-        fieldstat_counter_get(instance, i, 0, &TEST_TAG_LIST_INT, &result);
+        fieldstat_counter_get(instance, i, &TEST_TAG_LIST_INT, 0,  &result);
         EXPECT_EQ(result, i);
     }
 
@@ -117,7 +117,7 @@ TEST(test_register, add_many_tagged_cells)
 
     long long result;
     struct fieldstat_tag_list tag_list = {test_tag_long, 100};
-    fieldstat_counter_get(instance, cube_id, metric_id, &tag_list, &result);
+    fieldstat_counter_get(instance, cube_id, &tag_list, metric_id,  &result);
     EXPECT_EQ(result, 10086);
 
     fieldstat_free(instance);
@@ -138,7 +138,7 @@ TEST(test_register, add_long_tagged_cells)
 
     long long result;
     struct fieldstat_tag_list tag_list = {&test_tag_long, 1};
-    fieldstat_counter_get(instance, cube_id, metric_id, &tag_list, &result);
+    fieldstat_counter_get(instance, cube_id, &tag_list, metric_id, &result);
     EXPECT_EQ(result, 10086);
 
     fieldstat_free(instance);
@@ -196,14 +196,14 @@ TEST(test_register, fork_registered_info_with_cube_and_metric)
     EXPECT_EQ(cube_num, 2);
     struct fieldstat_tag_list *tag_list = NULL;
     
-    tag_list = fieldstat_get_shared_tags(dup, cube_ids[0]);
+    tag_list = fieldstat_cube_get_tags(dup, cube_ids[0]);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
     fieldstat_tag_list_arr_free(tag_list, 1);
     size_t n_cell = 0;
-    fieldstat_get_cells_used_by_cube(dup, cube_ids[0], &tag_list, &n_cell);
+    fieldstat_cube_get_cells(dup, cube_ids[0], &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 0);
 
-    tag_list = fieldstat_get_shared_tags(dup, cube_ids[1]);
+    tag_list = fieldstat_cube_get_tags(dup, cube_ids[1]);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_DOUBLE.key);
     free(cube_ids);
     fieldstat_tag_list_arr_free(tag_list, 1);
@@ -240,10 +240,10 @@ TEST(test_register, unregister_cube_on_wrong_instance)
     fieldstat_merge(instance_dst, instance);
 
     long long val_deleted_once;
-    fieldstat_counter_get(instance_dst, cube_id, metric_id, &TEST_TAG_LIST_INT, &val_deleted_once);
+    fieldstat_counter_get(instance_dst, cube_id, &TEST_TAG_LIST_INT,metric_id,  &val_deleted_once);
     EXPECT_EQ(val_deleted_once, 1);
     long long val_merged_twice;
-    fieldstat_counter_get(instance_dst, cube_id2, metric_id2, &TEST_TAG_LIST_INT, &val_merged_twice);
+    fieldstat_counter_get(instance_dst, cube_id2, &TEST_TAG_LIST_INT, metric_id2,  &val_merged_twice);
     EXPECT_EQ(val_merged_twice, 2);
 
     fieldstat_free(instance);
@@ -266,7 +266,7 @@ TEST(test_register, register_many_cells_on_unlimited_sized_cube)
         test_tag.value_longlong = i;
         struct fieldstat_tag_list tag_list = {&test_tag, 1};
         long long value;
-        fieldstat_counter_get(instance, cube_id, metric_id, &tag_list, &value);
+        fieldstat_counter_get(instance, cube_id, &tag_list, metric_id, &value);
         EXPECT_EQ(value, 1);
     }
 
@@ -313,7 +313,7 @@ TEST(calibrate, target_one_more_metric)
 
     EXPECT_EQ(test_get_max_metric_id(target), 0);
     EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
-    struct fieldstat_tag_list *tag_list = fieldstat_get_shared_tags(target, cube_id);
+    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
 
     fieldstat_free(master);
@@ -334,7 +334,7 @@ TEST(calibrate, master_one_more_metric)
     EXPECT_EQ(test_get_max_metric_id(target), 1);
     EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
     EXPECT_STREQ(fieldstat_get_metric_name(target, 1), "counter2");
-    struct fieldstat_tag_list *tag_list = fieldstat_get_shared_tags(target, cube_id);
+    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
 
     fieldstat_free(master);
@@ -357,7 +357,7 @@ TEST(calibrate, different_metric)
     EXPECT_EQ(test_get_max_metric_id(target), 1);
     EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
     EXPECT_STREQ(fieldstat_get_metric_name(target, 1), "hi i am master new");
-    struct fieldstat_tag_list *tag_list = fieldstat_get_shared_tags(target, cube_id);
+    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
 
     fieldstat_free(master);
@@ -386,7 +386,7 @@ TEST(calibrate, target_more_cube)
 
     EXPECT_EQ(test_get_max_metric_id(target), 0);
     EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
-    struct fieldstat_tag_list *tag_list = fieldstat_get_shared_tags(target, cube_id);
+    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
 
     EXPECT_EQ(fieldstat_find_cube(target, &TEST_SHARED_TAG, 1), 0);
@@ -414,9 +414,9 @@ TEST(calibrate, master_more_cube)
     EXPECT_EQ(cube_ids[1], cube_id2);
     free(cube_ids);
 
-    struct fieldstat_tag_list *tag_list = fieldstat_get_shared_tags(target, cube_id);
+    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
-    struct fieldstat_tag_list *tag_list2 = fieldstat_get_shared_tags(target, cube_id2);
+    struct fieldstat_tag_list *tag_list2 = fieldstat_cube_get_tags(target, cube_id2);
     EXPECT_STREQ(tag_list2->tag[0].key, TEST_TAG_STRING.key);
 
     EXPECT_EQ(fieldstat_find_cube(target, &TEST_TAG_STRING, 1), 1);
@@ -439,7 +439,7 @@ TEST(calibrate, master_change_cube)
 
     fieldstat_calibrate(master, target);
 
-    struct fieldstat_tag_list *tag_list = fieldstat_get_shared_tags(target, cube_id);
+    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_STRING.key);
 
     EXPECT_EQ(fieldstat_find_cube(target, &TEST_TAG_STRING, 1), 0);
@@ -521,7 +521,7 @@ TEST(calibrate, issue_calibrate_wrong)
     EXPECT_EQ(fieldstat_find_cube(target, tag_A, 1), FS_ERR_INVALID_KEY);
     EXPECT_EQ(fieldstat_find_cube(target, tag_B, 1), cubes_id_ret[0]);
 
-    struct fieldstat_tag_list *tag_list = fieldstat_get_shared_tags(target, cubes_id_ret[0]);
+    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cubes_id_ret[0]);
     EXPECT_STREQ(tag_list->tag[0].key, tag_B->key);
     fieldstat_tag_list_arr_free(tag_list, 1);
 
@@ -553,7 +553,7 @@ TEST(calibrate, delete_first_cube)
     EXPECT_EQ(fieldstat_find_cube(target, tag_A, 1), FS_ERR_INVALID_KEY);
     EXPECT_EQ(fieldstat_find_cube(target, tag_B, 1), 1);
 
-    struct fieldstat_tag_list *tag_list = fieldstat_get_shared_tags(target, 1);
+    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, 1);
     EXPECT_STREQ(tag_list->tag[0].key, tag_B->key);
     fieldstat_tag_list_arr_free(tag_list, 1);