diff --git a/internal/core/src/segcore/Reduce.cpp b/internal/core/src/segcore/Reduce.cpp
index b5b2aa4e69..7fda82e413 100644
--- a/internal/core/src/segcore/Reduce.cpp
+++ b/internal/core/src/segcore/Reduce.cpp
@@ -17,7 +17,6 @@
 #include "Reduce.h"
 #include "pkVisitor.h"
 #include "SegmentInterface.h"
-#include "ReduceStructure.h"
 #include "Utils.h"
 
 namespace milvus::segcore {
@@ -157,7 +156,12 @@ ReduceHelper::FillEntryData() {
 
 int64_t
 ReduceHelper::ReduceSearchResultForOneNQ(int64_t qi, int64_t topk, int64_t& offset) {
-    std::vector<SearchResultPair> result_pairs;
+    while (!heap_.empty()) {
+        heap_.pop();
+    }
+    pk_set_.clear();
+
+    pairs_.reserve(num_segments_);
     for (int i = 0; i < num_segments_; i++) {
         auto search_result = search_results_[i];
         auto offset_beg = search_result->topk_per_nq_prefix_sum_[qi];
@@ -167,36 +171,39 @@ ReduceHelper::ReduceSearchResultForOneNQ(int64_t qi, int64_t topk, int64_t& offs
         }
         auto primary_key = search_result->primary_keys_[offset_beg];
         auto distance = search_result->distances_[offset_beg];
-        result_pairs.emplace_back(primary_key, distance, search_result, i, offset_beg, offset_end);
+
+        pairs_.emplace_back(primary_key, distance, search_result, i, offset_beg, offset_end);
+        heap_.push(&pairs_.back());
     }
 
     // nq has no results for all segments
-    if (result_pairs.size() == 0) {
+    if (heap_.size() == 0) {
         return 0;
     }
 
     int64_t dup_cnt = 0;
-    std::unordered_set<milvus::PkType> pk_set;
-    int64_t prev_offset = offset;
-    while (offset - prev_offset < topk) {
-        std::sort(result_pairs.begin(), result_pairs.end(), std::greater<>());
-        auto& pilot = result_pairs[0];
-        auto index = pilot.segment_index_;
-        auto pk = pilot.primary_key_;
+    auto start = offset;
+    while (offset - start < topk) {
+        auto pilot = heap_.top();
+        heap_.pop();
+
+        auto index = pilot->segment_index_;
+        auto pk = pilot->primary_key_;
         // no valid search result for this nq, break to next
         if (pk == INVALID_PK) {
             break;
         }
         // remove duplicates
-        if (pk_set.count(pk) == 0) {
-            pilot.search_result_->result_offsets_.push_back(offset++);
-            final_search_records_[index][qi].push_back(pilot.offset_);
-            pk_set.insert(pk);
+        if (pk_set_.count(pk) == 0) {
+            pilot->search_result_->result_offsets_.push_back(offset++);
+            final_search_records_[index][qi].push_back(pilot->offset_);
+            pk_set_.insert(pk);
         } else {
             // skip entity with same primary key
             dup_cnt++;
         }
-        pilot.reset();
+        pilot->advance();
+        heap_.push(pilot);
     }
     return dup_cnt;
 }
@@ -218,9 +225,9 @@ ReduceHelper::ReduceResultData() {
         auto nq_end = slice_nqs_prefix_sum_[slice_index + 1];
 
         // reduce search results
-        int64_t result_offset = 0;
+        int64_t offset = 0;
         for (int64_t qi = nq_begin; qi < nq_end; qi++) {
-            skip_dup_cnt += ReduceSearchResultForOneNQ(qi, slice_topKs_[slice_index], result_offset);
+            skip_dup_cnt += ReduceSearchResultForOneNQ(qi, slice_topKs_[slice_index], offset);
         }
     }
     if (skip_dup_cnt > 0) {
diff --git a/internal/core/src/segcore/Reduce.h b/internal/core/src/segcore/Reduce.h
index 9147731de7..0930489864 100644
--- a/internal/core/src/segcore/Reduce.h
+++ b/internal/core/src/segcore/Reduce.h
@@ -15,11 +15,13 @@
 #include <cstdint>
 #include <memory>
 #include <vector>
+#include <queue>
 
 #include "utils/Status.h"
 #include "common/type_c.h"
 #include "common/QueryResult.h"
 #include "query/PlanImpl.h"
+#include "ReduceStructure.h"
 
 namespace milvus::segcore {
 
@@ -95,6 +97,12 @@ class ReduceHelper {
 
     // output
     std::unique_ptr<SearchResultDataBlobs> search_result_data_blobs_;
+
+    // Used for merge results,
+    // define these here to avoid allocating them for each query
+    std::vector<SearchResultPair> pairs_;
+    std::priority_queue<SearchResultPair*, std::vector<SearchResultPair*>, SearchResultPairComparator> heap_;
+    std::unordered_set<milvus::PkType> pk_set_;
 };
 
 }  // namespace milvus::segcore
diff --git a/internal/core/src/segcore/ReduceStructure.h b/internal/core/src/segcore/ReduceStructure.h
index 8955b0c512..1f25091965 100644
--- a/internal/core/src/segcore/ReduceStructure.h
+++ b/internal/core/src/segcore/ReduceStructure.h
@@ -9,12 +9,13 @@
 // is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 // or implied. See the License for the specific language governing permissions and limitations under the License
 
+#pragma once
+
 #include <limits>
 
 #include "common/Consts.h"
 #include "common/Types.h"
 #include "common/QueryResult.h"
-#include "segcore/Reduce.h"
 
 using milvus::SearchResult;
 
@@ -38,19 +39,11 @@ struct SearchResultPair {
 
     bool
     operator>(const SearchResultPair& other) const {
-        if (this->primary_key_ == INVALID_PK) {
-            return false;
-        } else {
-            if (other.primary_key_ == INVALID_PK) {
-                return true;
-            } else {
-                return (distance_ > other.distance_);
-            }
-        }
+        return distance_ > other.distance_;
     }
 
     void
-    reset() {
+    advance() {
         offset_++;
         if (offset_ < offset_rb_) {
             primary_key_ = search_result_->primary_keys_.at(offset_);
@@ -61,3 +54,10 @@ struct SearchResultPair {
         }
     }
 };
+
+struct SearchResultPairComparator {
+    bool
+    operator()(const SearchResultPair* lhs, const SearchResultPair* rhs) const {
+        return *lhs > *rhs;
+    }
+};
\ No newline at end of file
diff --git a/internal/core/src/segcore/reduce_c.cpp b/internal/core/src/segcore/reduce_c.cpp
index c9cf15327c..d1bc0f6072 100644
--- a/internal/core/src/segcore/reduce_c.cpp
+++ b/internal/core/src/segcore/reduce_c.cpp
@@ -15,7 +15,6 @@
 #include "common/QueryResult.h"
 #include "exceptions/EasyAssert.h"
 #include "query/Plan.h"
-#include "segcore/ReduceStructure.h"
 #include "segcore/reduce_c.h"
 #include "segcore/Utils.h"
 
diff --git a/internal/core/unittest/test_c_api.cpp b/internal/core/unittest/test_c_api.cpp
index 914e17d3dd..3fc73a8e3a 100644
--- a/internal/core/unittest/test_c_api.cpp
+++ b/internal/core/unittest/test_c_api.cpp
@@ -174,7 +174,7 @@ generate_collection_schema(std::string metric_type, int dim, bool is_binary) {
 
     std::string schema_string;
     auto marshal = google::protobuf::TextFormat::PrintToString(collection_schema, &schema_string);
-    assert(marshal == true);
+    assert(marshal);
     return schema_string;
 }
 
@@ -222,7 +222,7 @@ TEST(CApiTest, CollectionTest) {
 TEST(CApiTest, GetCollectionNameTest) {
     auto collection = NewCollection(get_default_schema_config());
     auto name = GetCollectionName(collection);
-    assert(strcmp(name, "default-collection") == 0);
+    ASSERT_EQ(strcmp(name, "default-collection"), 0);
     DeleteCollection(collection);
     free((void*)(name));
 }
@@ -257,19 +257,19 @@ TEST(CApiTest, CPlan) {
 
     void* plan = nullptr;
     auto status = CreateSearchPlan(collection, dsl_string, &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     int64_t field_id = -1;
     status = GetFieldID(plan, &field_id);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     auto col = static_cast<Collection*>(collection);
     for (auto& [target_field_id, field_meta] : col->get_schema()->get_fields()) {
         if (field_meta.is_vector()) {
-            assert(field_id == target_field_id.get());
+            ASSERT_EQ(field_id, target_field_id.get());
         }
     }
-    assert(field_id != -1);
+    ASSERT_NE(field_id, -1);
 
     DeleteSearchPlan(plan);
     DeleteCollection(collection);
@@ -289,7 +289,7 @@ TEST(CApiTest, InsertTest) {
     auto insert_data = serialize(dataset.raw_);
     auto res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                       insert_data.size());
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
 
     DeleteCollection(c_collection);
     DeleteSegment(segment);
@@ -308,7 +308,7 @@ TEST(CApiTest, DeleteTest) {
     auto offset = PreDelete(segment, 3);
 
     auto del_res = Delete(segment, offset, 3, delete_data.data(), delete_data.size(), delete_timestamps);
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     DeleteCollection(collection);
     DeleteSegment(segment);
@@ -328,7 +328,7 @@ TEST(CApiTest, MultiDeleteGrowingSegment) {
     PreInsert(segment, N, &offset);
     auto res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                       insert_data.size());
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
 
     // delete data pks = {1}
     std::vector<int64_t> delete_pks = {1};
@@ -338,7 +338,7 @@ TEST(CApiTest, MultiDeleteGrowingSegment) {
     std::vector<uint64_t> delete_timestamps(1, dataset.timestamps_[N - 1]);
     offset = PreDelete(segment, 1);
     auto del_res = Delete(segment, offset, 1, delete_data.data(), delete_data.size(), delete_timestamps.data());
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     // retrieve pks = {1}
     std::vector<int64_t> retrive_pks = {1};
@@ -377,7 +377,7 @@ TEST(CApiTest, MultiDeleteGrowingSegment) {
     delete_data = serialize(ids.get());
     offset = PreDelete(segment, 1);
     del_res = Delete(segment, offset, 1, delete_data.data(), delete_data.size(), delete_timestamps.data());
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     // retrieve pks in {2}
     res = Retrieve(segment, plan.get(), dataset.timestamps_[N - 1], &retrieve_result);
@@ -409,9 +409,9 @@ TEST(CApiTest, MultiDeleteSealedSegment) {
         auto load_info = CLoadFieldDataInfo{field_id.get(), data.data(), data.size(), N};
 
         auto res = LoadFieldData(segment, load_info);
-        assert(res.error_code == Success);
+        ASSERT_EQ(res.error_code, Success);
         auto count = GetRowCount(segment);
-        assert(count == N);
+        ASSERT_EQ(count, N);
     }
 
     // load timestamps
@@ -420,9 +420,9 @@ TEST(CApiTest, MultiDeleteSealedSegment) {
     auto ts_data = serialize(ts_array.get());
     auto load_info = CLoadFieldDataInfo{TimestampFieldID.get(), ts_data.data(), ts_data.size(), N};
     auto res = LoadFieldData(segment, load_info);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     auto count = GetRowCount(segment);
-    assert(count == N);
+    ASSERT_EQ(count, N);
 
     // load rowID
     FieldMeta row_id_field_meta(FieldName("RowID"), RowFieldID, DataType::INT64);
@@ -430,9 +430,9 @@ TEST(CApiTest, MultiDeleteSealedSegment) {
     auto row_id_data = serialize(row_id_array.get());
     load_info = CLoadFieldDataInfo{RowFieldID.get(), row_id_data.data(), row_id_data.size(), N};
     res = LoadFieldData(segment, load_info);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     count = GetRowCount(segment);
-    assert(count == N);
+    ASSERT_EQ(count, N);
 
     // delete data pks = {1}
     std::vector<int64_t> delete_pks = {1};
@@ -442,7 +442,7 @@ TEST(CApiTest, MultiDeleteSealedSegment) {
     std::vector<uint64_t> delete_timestamps(1, dataset.timestamps_[N - 1]);
     auto offset = PreDelete(segment, 1);
     auto del_res = Delete(segment, offset, 1, delete_data.data(), delete_data.size(), delete_timestamps.data());
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     // retrieve pks = {1}
     std::vector<int64_t> retrive_pks = {1};
@@ -481,7 +481,7 @@ TEST(CApiTest, MultiDeleteSealedSegment) {
     delete_data = serialize(ids.get());
     offset = PreDelete(segment, 1);
     del_res = Delete(segment, offset, 1, delete_data.data(), delete_data.size(), delete_timestamps.data());
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     // retrieve pks in {2}
     res = Retrieve(segment, plan.get(), dataset.timestamps_[N - 1], &retrieve_result);
@@ -512,13 +512,13 @@ TEST(CApiTest, DeleteRepeatedPksFromGrowingSegment) {
     PreInsert(segment, N, &offset);
     auto res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                       insert_data.size());
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
 
     // second insert, pks= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
     PreInsert(segment, N, &offset);
     res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                  insert_data.size());
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
 
     // create retrieve plan pks in {1, 2, 3}
     std::vector<int64_t> retrive_row_ids = {1, 2, 3};
@@ -548,7 +548,7 @@ TEST(CApiTest, DeleteRepeatedPksFromGrowingSegment) {
 
     offset = PreDelete(segment, 3);
     auto del_res = Delete(segment, offset, 3, delete_data.data(), delete_data.size(), delete_timestamps.data());
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     // retrieve pks in {1, 2, 3}
     res = Retrieve(segment, plan.get(), dataset.timestamps_[N - 1], &retrieve_result);
@@ -581,9 +581,9 @@ TEST(CApiTest, DeleteRepeatedPksFromSealedSegment) {
         auto load_info = CLoadFieldDataInfo{field_id.get(), data.data(), data.size(), N};
 
         auto res = LoadFieldData(segment, load_info);
-        assert(res.error_code == Success);
+        ASSERT_EQ(res.error_code, Success);
         auto count = GetRowCount(segment);
-        assert(count == N);
+        ASSERT_EQ(count, N);
     }
 
     FieldMeta ts_field_meta(FieldName("Timestamp"), TimestampFieldID, DataType::INT64);
@@ -591,18 +591,18 @@ TEST(CApiTest, DeleteRepeatedPksFromSealedSegment) {
     auto ts_data = serialize(ts_array.get());
     auto load_info = CLoadFieldDataInfo{TimestampFieldID.get(), ts_data.data(), ts_data.size(), N};
     auto res = LoadFieldData(segment, load_info);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     auto count = GetRowCount(segment);
-    assert(count == N);
+    ASSERT_EQ(count, N);
 
     FieldMeta row_id_field_meta(FieldName("RowID"), RowFieldID, DataType::INT64);
     auto row_id_array = CreateScalarDataArrayFrom(dataset.row_ids_.data(), N, row_id_field_meta);
     auto row_id_data = serialize(row_id_array.get());
     load_info = CLoadFieldDataInfo{RowFieldID.get(), row_id_data.data(), row_id_data.size(), N};
     res = LoadFieldData(segment, load_info);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     count = GetRowCount(segment);
-    assert(count == N);
+    ASSERT_EQ(count, N);
 
     // create retrieve plan pks in {1, 2, 3}
     std::vector<int64_t> retrive_row_ids = {1, 2, 3};
@@ -633,7 +633,7 @@ TEST(CApiTest, DeleteRepeatedPksFromSealedSegment) {
     auto offset = PreDelete(segment, 3);
 
     auto del_res = Delete(segment, offset, 3, delete_data.data(), delete_data.size(), delete_timestamps.data());
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     // retrieve pks in {1, 2, 3}
     res = Retrieve(segment, plan.get(), dataset.timestamps_[N - 1], &retrieve_result);
@@ -666,7 +666,7 @@ TEST(CApiTest, InsertSamePkAfterDeleteOnGrowingSegment) {
     PreInsert(segment, N, &offset);
     auto res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                       insert_data.size());
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
 
     // delete data pks = {1, 2, 3}, timestamps = {9, 9, 9}
     std::vector<int64_t> delete_row_ids = {1, 2, 3};
@@ -678,7 +678,7 @@ TEST(CApiTest, InsertSamePkAfterDeleteOnGrowingSegment) {
     offset = PreDelete(segment, 3);
 
     auto del_res = Delete(segment, offset, 3, delete_data.data(), delete_data.size(), delete_timestamps.data());
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     // create retrieve plan pks in {1, 2, 3}, timestamp = 9
     std::vector<int64_t> retrive_row_ids = {1, 2, 3};
@@ -706,7 +706,7 @@ TEST(CApiTest, InsertSamePkAfterDeleteOnGrowingSegment) {
     PreInsert(segment, N, &offset);
     res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                  insert_data.size());
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
 
     // retrieve pks in {1, 2, 3}, timestamp = 19
     res = Retrieve(segment, plan.get(), dataset.timestamps_[N - 1], &retrieve_result);
@@ -740,9 +740,9 @@ TEST(CApiTest, InsertSamePkAfterDeleteOnSealedSegment) {
         auto load_info = CLoadFieldDataInfo{field_id.get(), data.data(), data.size(), N};
 
         auto res = LoadFieldData(segment, load_info);
-        assert(res.error_code == Success);
+        ASSERT_EQ(res.error_code, Success);
         auto count = GetRowCount(segment);
-        assert(count == N);
+        ASSERT_EQ(count, N);
     }
 
     FieldMeta ts_field_meta(FieldName("Timestamp"), TimestampFieldID, DataType::INT64);
@@ -750,18 +750,18 @@ TEST(CApiTest, InsertSamePkAfterDeleteOnSealedSegment) {
     auto ts_data = serialize(ts_array.get());
     auto load_info = CLoadFieldDataInfo{TimestampFieldID.get(), ts_data.data(), ts_data.size(), N};
     auto res = LoadFieldData(segment, load_info);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     auto count = GetRowCount(segment);
-    assert(count == N);
+    ASSERT_EQ(count, N);
 
     FieldMeta row_id_field_meta(FieldName("RowID"), RowFieldID, DataType::INT64);
     auto row_id_array = CreateScalarDataArrayFrom(dataset.row_ids_.data(), N, row_id_field_meta);
     auto row_id_data = serialize(row_id_array.get());
     load_info = CLoadFieldDataInfo{RowFieldID.get(), row_id_data.data(), row_id_data.size(), N};
     res = LoadFieldData(segment, load_info);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     count = GetRowCount(segment);
-    assert(count == N);
+    ASSERT_EQ(count, N);
 
     // delete data pks = {1, 2, 3}, timestamps = {4, 4, 4}
     std::vector<int64_t> delete_row_ids = {1, 2, 3};
@@ -773,7 +773,7 @@ TEST(CApiTest, InsertSamePkAfterDeleteOnSealedSegment) {
     auto offset = PreDelete(segment, 3);
 
     auto del_res = Delete(segment, offset, 3, delete_data.data(), delete_data.size(), delete_timestamps.data());
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     // create retrieve plan pks in {1, 2, 3}, timestamp = 9
     std::vector<int64_t> retrive_row_ids = {1, 2, 3};
@@ -960,7 +960,7 @@ TEST(CApiTest, GetMemoryUsageInBytesTest) {
 
     auto old_memory_usage_size = GetMemoryUsageInBytes(segment);
     // std::cout << "old_memory_usage_size = " << old_memory_usage_size << std::endl;
-    assert(old_memory_usage_size == 0);
+    ASSERT_EQ(old_memory_usage_size, 0);
 
     auto schema = ((milvus::segcore::Collection*)collection)->get_schema();
     int N = 10000;
@@ -972,12 +972,12 @@ TEST(CApiTest, GetMemoryUsageInBytesTest) {
     auto insert_data = serialize(dataset.raw_);
     auto res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                       insert_data.size());
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
 
     auto memory_usage_size = GetMemoryUsageInBytes(segment);
     // std::cout << "new_memory_usage_size = " << memory_usage_size << std::endl;
     // TODO:: assert
-    // assert(memory_usage_size == 2785280);
+    // ASSERT_EQ(memory_usage_size, 2785280);
 
     DeleteCollection(collection);
     DeleteSegment(segment);
@@ -996,11 +996,11 @@ TEST(CApiTest, GetDeletedCountTest) {
     auto offset = PreDelete(segment, 3);
 
     auto del_res = Delete(segment, offset, 3, delete_data.data(), delete_data.size(), delete_timestamps);
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     // TODO: assert(deleted_count == len(delete_row_ids))
     auto deleted_count = GetDeletedCount(segment);
-    assert(deleted_count == delete_row_ids.size());
+    ASSERT_EQ(deleted_count, delete_row_ids.size());
 
     DeleteCollection(collection);
     DeleteSegment(segment);
@@ -1020,10 +1020,10 @@ TEST(CApiTest, GetRowCountTest) {
     auto insert_data = serialize(dataset.raw_);
     auto res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                       insert_data.size());
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
 
     auto row_count = GetRowCount(segment);
-    assert(row_count == N);
+    ASSERT_EQ(row_count, N);
 
     DeleteCollection(collection);
     DeleteSegment(segment);
@@ -1043,7 +1043,7 @@ TEST(CApiTest, GetRealCount) {
     auto insert_data = serialize(dataset.raw_);
     auto res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                       insert_data.size());
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
 
     auto pks = dataset.get_col<int64_t>(schema->get_primary_field_id().value());
     std::vector<int64_t> delete_row_ids(pks.begin(), pks.begin() + 3);
@@ -1056,10 +1056,10 @@ TEST(CApiTest, GetRealCount) {
     auto del_offset = PreDelete(segment, 3);
 
     auto del_res = Delete(segment, del_offset, 3, delete_data.data(), delete_data.size(), delete_timestamps);
-    assert(del_res.error_code == Success);
+    ASSERT_EQ(del_res.error_code, Success);
 
     auto real_count = GetRealCount(segment);
-    assert(real_count == N - delete_row_ids.size());
+    ASSERT_EQ(real_count, N - delete_row_ids.size());
 
     DeleteCollection(collection);
     DeleteSegment(segment);
@@ -1111,7 +1111,7 @@ TEST(CApiTest, ReudceNullResult) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* dsl_string = R"(
     {
@@ -1137,11 +1137,11 @@ TEST(CApiTest, ReudceNullResult) {
 
     void* plan = nullptr;
     auto status = CreateSearchPlan(collection, dsl_string, &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -1154,12 +1154,12 @@ TEST(CApiTest, ReudceNullResult) {
         std::vector<CSearchResult> results;
         CSearchResult res;
         status = Search(segment, plan, placeholderGroup, dataset.timestamps_[0], &res);
-        assert(status.error_code == Success);
+        ASSERT_EQ(status.error_code, Success);
         results.push_back(res);
         CSearchResultDataBlobs cSearchResultData;
         status = ReduceSearchResultsAndFillData(&cSearchResultData, plan, results.data(), results.size(),
                                                 slice_nqs.data(), slice_topKs.data(), slice_nqs.size());
-        assert(status.error_code == Success);
+        ASSERT_EQ(status.error_code, Success);
 
         auto search_result = (SearchResult*)results[0];
         auto size = search_result->result_offsets_.size();
@@ -1189,7 +1189,7 @@ TEST(CApiTest, ReduceRemoveDuplicates) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* dsl_string = R"(
     {
@@ -1215,11 +1215,11 @@ TEST(CApiTest, ReduceRemoveDuplicates) {
 
     void* plan = nullptr;
     auto status = CreateSearchPlan(collection, dsl_string, &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -1232,16 +1232,16 @@ TEST(CApiTest, ReduceRemoveDuplicates) {
         std::vector<CSearchResult> results;
         CSearchResult res1, res2;
         status = Search(segment, plan, placeholderGroup, dataset.timestamps_[0], &res1);
-        assert(status.error_code == Success);
+        ASSERT_EQ(status.error_code, Success);
         status = Search(segment, plan, placeholderGroup, dataset.timestamps_[0], &res2);
-        assert(status.error_code == Success);
+        ASSERT_EQ(status.error_code, Success);
         results.push_back(res1);
         results.push_back(res2);
 
         CSearchResultDataBlobs cSearchResultData;
         status = ReduceSearchResultsAndFillData(&cSearchResultData, plan, results.data(), results.size(),
                                                 slice_nqs.data(), slice_topKs.data(), slice_nqs.size());
-        assert(status.error_code == Success);
+        ASSERT_EQ(status.error_code, Success);
         // TODO:: insert no duplicate pks and check reduce results
         CheckSearchResultDuplicate(results);
 
@@ -1258,18 +1258,18 @@ TEST(CApiTest, ReduceRemoveDuplicates) {
         std::vector<CSearchResult> results;
         CSearchResult res1, res2, res3;
         status = Search(segment, plan, placeholderGroup, dataset.timestamps_[0], &res1);
-        assert(status.error_code == Success);
+        ASSERT_EQ(status.error_code, Success);
         status = Search(segment, plan, placeholderGroup, dataset.timestamps_[0], &res2);
-        assert(status.error_code == Success);
+        ASSERT_EQ(status.error_code, Success);
         status = Search(segment, plan, placeholderGroup, dataset.timestamps_[0], &res3);
-        assert(status.error_code == Success);
+        ASSERT_EQ(status.error_code, Success);
         results.push_back(res1);
         results.push_back(res2);
         results.push_back(res3);
         CSearchResultDataBlobs cSearchResultData;
         status = ReduceSearchResultsAndFillData(&cSearchResultData, plan, results.data(), results.size(),
                                                 slice_nqs.data(), slice_topKs.data(), slice_nqs.size());
-        assert(status.error_code == Success);
+        ASSERT_EQ(status.error_code, Success);
         // TODO:: insert no duplicate pks and check reduce results
         CheckSearchResultDuplicate(results);
 
@@ -1287,6 +1287,8 @@ TEST(CApiTest, ReduceRemoveDuplicates) {
 
 void
 testReduceSearchWithExpr(int N, int topK, int num_queries) {
+    std::cerr << "testReduceSearchWithExpr(" << N << ", " << topK << ", " << num_queries << ")" << std::endl;
+
     auto collection = NewCollection(get_default_schema_config());
     auto segment = NewSegment(collection, Growing, -1);
 
@@ -1299,7 +1301,7 @@ testReduceSearchWithExpr(int N, int topK, int num_queries) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     auto fmt = boost::format(R"(vector_anns: <
                                             field_id: 100
@@ -1318,11 +1320,11 @@ testReduceSearchWithExpr(int N, int topK, int num_queries) {
     void* plan = nullptr;
     auto binary_plan = translate_text_plan_to_binary_plan(serialized_expr_plan.data());
     auto status = CreateSearchPlanByExpr(collection, binary_plan.data(), binary_plan.size(), &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -1333,9 +1335,9 @@ testReduceSearchWithExpr(int N, int topK, int num_queries) {
     CSearchResult res1;
     CSearchResult res2;
     auto res = Search(segment, plan, placeholderGroup, dataset.timestamps_[N - 1], &res1);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     res = Search(segment, plan, placeholderGroup, dataset.timestamps_[N - 1], &res2);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     results.push_back(res1);
     results.push_back(res2);
 
@@ -1352,7 +1354,7 @@ testReduceSearchWithExpr(int N, int topK, int num_queries) {
     CSearchResultDataBlobs cSearchResultData;
     status = ReduceSearchResultsAndFillData(&cSearchResultData, plan, results.data(), results.size(), slice_nqs.data(),
                                             slice_topKs.data(), slice_nqs.size());
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     auto search_result_data_blobs = reinterpret_cast<milvus::segcore::SearchResultDataBlobs*>(cSearchResultData);
 
@@ -1361,16 +1363,16 @@ testReduceSearchWithExpr(int N, int topK, int num_queries) {
         milvus::proto::schema::SearchResultData search_result_data;
         auto suc = search_result_data.ParseFromArray(search_result_data_blobs->blobs[i].data(),
                                                      search_result_data_blobs->blobs[i].size());
-        assert(suc);
-        assert(search_result_data.num_queries() == slice_nqs[i]);
-        assert(search_result_data.top_k() == slice_topKs[i]);
-        assert(search_result_data.scores().size() == search_result_data.topks().at(0) * slice_nqs[i]);
-        assert(search_result_data.ids().int_id().data_size() == search_result_data.topks().at(0) * slice_nqs[i]);
+        ASSERT_TRUE(suc);
+        ASSERT_EQ(search_result_data.num_queries(), slice_nqs[i]);
+        ASSERT_EQ(search_result_data.top_k(), slice_topKs[i]);
+        ASSERT_EQ(search_result_data.ids().int_id().data_size(), search_result_data.topks().at(0) * slice_nqs[i]);
+        ASSERT_EQ(search_result_data.scores().size(), search_result_data.topks().at(0) * slice_nqs[i]);
 
         // check real topks
-        assert(search_result_data.topks().size() == slice_nqs[i]);
+        ASSERT_EQ(search_result_data.topks().size(), slice_nqs[i]);
         for (auto real_topk : search_result_data.topks()) {
-            assert(real_topk <= slice_topKs[i]);
+            ASSERT_LE(real_topk, slice_topKs[i]);
         }
     }
 
@@ -1418,23 +1420,23 @@ TEST(CApiTest, LoadIndexInfo) {
 
     void* c_load_index_info = nullptr;
     auto status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_param_key1 = "index_type";
     std::string index_param_value1 = "IVF_PQ";
     status = AppendIndexParam(c_load_index_info, index_param_key1.data(), index_param_value1.data());
     std::string index_param_key2 = "index_mode";
     std::string index_param_value2 = "cpu";
     status = AppendIndexParam(c_load_index_info, index_param_key2.data(), index_param_value2.data());
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_param_key3 = knowhere::meta::METRIC_TYPE;
     std::string index_param_value3 = knowhere::metric::L2;
     status = AppendIndexParam(c_load_index_info, index_param_key3.data(), index_param_value3.data());
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string field_name = "field0";
     status = AppendFieldInfo(c_load_index_info, 0, 0, 0, 0, CDataType::FloatVector);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     status = AppendIndex(c_load_index_info, c_binary_set);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     DeleteLoadIndexInfo(c_load_index_info);
 }
 
@@ -1506,7 +1508,7 @@ TEST(CApiTest, Indexing_Without_Predicate) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* dsl_string = R"(
      {
@@ -1533,11 +1535,11 @@ TEST(CApiTest, Indexing_Without_Predicate) {
     // search on segment's small index
     void* plan = nullptr;
     auto status = CreateSearchPlan(collection, dsl_string, &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -1545,7 +1547,7 @@ TEST(CApiTest, Indexing_Without_Predicate) {
 
     CSearchResult c_search_result_on_smallIndex;
     auto res_before_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_smallIndex);
-    assert(res_before_load_index.error_code == Success);
+    ASSERT_EQ(res_before_load_index.error_code, Success);
 
     // load index to segment
     auto indexing = generate_index(vec_col.data(), DataType::VECTOR_FLOAT, knowhere::metric::L2,
@@ -1572,7 +1574,7 @@ TEST(CApiTest, Indexing_Without_Predicate) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "IVF_PQ";
     std::string index_mode_key = "index_mode";
@@ -1594,7 +1596,7 @@ TEST(CApiTest, Indexing_Without_Predicate) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_raw_index_json = SearchResultToJson(*search_result_on_raw_index);
     auto search_result_on_bigIndex_json = SearchResultToJson((*(SearchResult*)c_search_result_on_bigIndex));
@@ -1632,7 +1634,7 @@ TEST(CApiTest, Indexing_Expr_Without_Predicate) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* serialized_expr_plan = R"(vector_anns: <
                                              field_id: 100
@@ -1654,11 +1656,11 @@ TEST(CApiTest, Indexing_Expr_Without_Predicate) {
     void* plan = nullptr;
     auto binary_plan = translate_text_plan_to_binary_plan(serialized_expr_plan);
     auto status = CreateSearchPlanByExpr(collection, binary_plan.data(), binary_plan.size(), &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -1666,7 +1668,7 @@ TEST(CApiTest, Indexing_Expr_Without_Predicate) {
 
     CSearchResult c_search_result_on_smallIndex;
     auto res_before_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_smallIndex);
-    assert(res_before_load_index.error_code == Success);
+    ASSERT_EQ(res_before_load_index.error_code, Success);
 
     // load index to segment
     auto indexing = generate_index(vec_col.data(), DataType::VECTOR_FLOAT, knowhere::metric::L2,
@@ -1693,7 +1695,7 @@ TEST(CApiTest, Indexing_Expr_Without_Predicate) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "IVF_PQ";
     std::string index_mode_key = "index_mode";
@@ -1715,7 +1717,7 @@ TEST(CApiTest, Indexing_Expr_Without_Predicate) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_raw_index_json = SearchResultToJson(*search_result_on_raw_index);
     auto search_result_on_bigIndex_json = SearchResultToJson((*(SearchResult*)c_search_result_on_bigIndex));
@@ -1753,7 +1755,7 @@ TEST(CApiTest, Indexing_With_float_Predicate_Range) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* dsl_string = R"({
          "bool": {
@@ -1792,11 +1794,11 @@ TEST(CApiTest, Indexing_With_float_Predicate_Range) {
     // search on segment's small index
     void* plan = nullptr;
     auto status = CreateSearchPlan(collection, dsl_string, &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -1804,7 +1806,7 @@ TEST(CApiTest, Indexing_With_float_Predicate_Range) {
 
     CSearchResult c_search_result_on_smallIndex;
     auto res_before_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_smallIndex);
-    assert(res_before_load_index.error_code == Success);
+    ASSERT_EQ(res_before_load_index.error_code, Success);
 
     // load index to segment
     auto indexing = generate_index(vec_col.data(), DataType::VECTOR_FLOAT, knowhere::metric::L2,
@@ -1831,7 +1833,7 @@ TEST(CApiTest, Indexing_With_float_Predicate_Range) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "IVF_PQ";
     std::string index_mode_key = "index_mode";
@@ -1853,7 +1855,7 @@ TEST(CApiTest, Indexing_With_float_Predicate_Range) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -1892,7 +1894,7 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Range) {
         auto insert_data = serialize(dataset.raw_);
         auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(),
                               insert_data.data(), insert_data.size());
-        assert(ins_res.error_code == Success);
+        ASSERT_EQ(ins_res.error_code, Success);
     }
 
     const char* serialized_expr_plan = R"(vector_anns: <
@@ -1944,11 +1946,11 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Range) {
     void* plan = nullptr;
     auto binary_plan = translate_text_plan_to_binary_plan(serialized_expr_plan);
     auto status = CreateSearchPlanByExpr(collection, binary_plan.data(), binary_plan.size(), &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -1956,7 +1958,7 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Range) {
 
     CSearchResult c_search_result_on_smallIndex;
     auto res_before_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_smallIndex);
-    assert(res_before_load_index.error_code == Success);
+    ASSERT_EQ(res_before_load_index.error_code, Success);
 
     // load index to segment
     auto indexing = generate_index(vec_col.data(), DataType::VECTOR_FLOAT, knowhere::metric::L2,
@@ -1983,7 +1985,7 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Range) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "IVF_PQ";
     std::string index_mode_key = "index_mode";
@@ -2005,7 +2007,7 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Range) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -2043,7 +2045,7 @@ TEST(CApiTest, Indexing_With_float_Predicate_Term) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* dsl_string = R"({
          "bool": {
@@ -2080,11 +2082,11 @@ TEST(CApiTest, Indexing_With_float_Predicate_Term) {
     // search on segment's small index
     void* plan = nullptr;
     auto status = CreateSearchPlan(collection, dsl_string, &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -2092,7 +2094,7 @@ TEST(CApiTest, Indexing_With_float_Predicate_Term) {
 
     CSearchResult c_search_result_on_smallIndex;
     auto res_before_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_smallIndex);
-    assert(res_before_load_index.error_code == Success);
+    ASSERT_EQ(res_before_load_index.error_code, Success);
 
     // load index to segment
     auto indexing = generate_index(vec_col.data(), DataType::VECTOR_FLOAT, knowhere::metric::L2,
@@ -2119,7 +2121,7 @@ TEST(CApiTest, Indexing_With_float_Predicate_Term) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "IVF_PQ";
     std::string index_mode_key = "index_mode";
@@ -2141,7 +2143,7 @@ TEST(CApiTest, Indexing_With_float_Predicate_Term) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -2179,7 +2181,7 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Term) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* serialized_expr_plan = R"(
  vector_anns: <
@@ -2225,11 +2227,11 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Term) {
     void* plan = nullptr;
     auto binary_plan = translate_text_plan_to_binary_plan(serialized_expr_plan);
     auto status = CreateSearchPlanByExpr(collection, binary_plan.data(), binary_plan.size(), &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -2237,7 +2239,7 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Term) {
 
     CSearchResult c_search_result_on_smallIndex;
     auto res_before_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_smallIndex);
-    assert(res_before_load_index.error_code == Success);
+    ASSERT_EQ(res_before_load_index.error_code, Success);
 
     // load index to segment
     auto indexing = generate_index(vec_col.data(), DataType::VECTOR_FLOAT, knowhere::metric::L2,
@@ -2264,7 +2266,7 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Term) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "IVF_PQ";
     std::string index_mode_key = "index_mode";
@@ -2286,7 +2288,7 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Term) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -2324,7 +2326,7 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Range) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* dsl_string = R"({
          "bool": {
@@ -2362,11 +2364,11 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Range) {
     // search on segment's small index
     void* plan = nullptr;
     auto status = CreateSearchPlan(collection, dsl_string, &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -2374,7 +2376,7 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Range) {
 
     CSearchResult c_search_result_on_smallIndex;
     auto res_before_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_smallIndex);
-    assert(res_before_load_index.error_code == Success);
+    ASSERT_EQ(res_before_load_index.error_code, Success);
 
     // load index to segment
 
@@ -2402,7 +2404,7 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Range) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "BIN_IVF_FLAT";
     std::string index_mode_key = "index_mode";
@@ -2424,7 +2426,7 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Range) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -2462,7 +2464,7 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Range) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* serialized_expr_plan = R"(vector_anns: <
                                             field_id: 100
@@ -2513,11 +2515,11 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Range) {
     void* plan = nullptr;
     auto binary_plan = translate_text_plan_to_binary_plan(serialized_expr_plan);
     auto status = CreateSearchPlanByExpr(collection, binary_plan.data(), binary_plan.size(), &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -2552,7 +2554,7 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Range) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "BIN_IVF_FLAT";
     std::string index_mode_key = "index_mode";
@@ -2574,7 +2576,7 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Range) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -2612,7 +2614,7 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Term) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* dsl_string = R"({
         "bool": {
@@ -2650,11 +2652,11 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Term) {
     // search on segment's small index
     void* plan = nullptr;
     auto status = CreateSearchPlan(collection, dsl_string, &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -2662,7 +2664,7 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Term) {
 
     CSearchResult c_search_result_on_smallIndex;
     auto res_before_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_smallIndex);
-    assert(res_before_load_index.error_code == Success);
+    ASSERT_EQ(res_before_load_index.error_code, Success);
 
     // load index to segment
     auto indexing = generate_index(vec_col.data(), DataType::VECTOR_BINARY, knowhere::metric::JACCARD,
@@ -2689,7 +2691,7 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Term) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "BIN_IVF_FLAT";
     std::string index_mode_key = "index_mode";
@@ -2711,7 +2713,7 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Term) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     std::vector<CSearchResult> results;
     results.push_back(c_search_result_on_bigIndex);
@@ -2722,10 +2724,10 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Term) {
     CSearchResultDataBlobs cSearchResultData;
     status = ReduceSearchResultsAndFillData(&cSearchResultData, plan, results.data(), results.size(), slice_nqs.data(),
                                             slice_topKs.data(), slice_nqs.size());
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     //    status = ReduceSearchResultsAndFillData(plan, results.data(), results.size());
-    //    assert(status.error_code == Success);
+    //    ASSERT_EQ(status.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -2765,7 +2767,7 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Term) {
     auto insert_data = serialize(dataset.raw_);
     auto ins_res = Insert(segment, offset, N, dataset.row_ids_.data(), dataset.timestamps_.data(), insert_data.data(),
                           insert_data.size());
-    assert(ins_res.error_code == Success);
+    ASSERT_EQ(ins_res.error_code, Success);
 
     const char* serialized_expr_plan = R"(vector_anns: <
                                             field_id: 100
@@ -2811,11 +2813,11 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Term) {
     void* plan = nullptr;
     auto binary_plan = translate_text_plan_to_binary_plan(serialized_expr_plan);
     auto status = CreateSearchPlanByExpr(collection, binary_plan.data(), binary_plan.size(), &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -2823,7 +2825,7 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Term) {
 
     CSearchResult c_search_result_on_smallIndex;
     auto res_before_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_smallIndex);
-    assert(res_before_load_index.error_code == Success);
+    ASSERT_EQ(res_before_load_index.error_code, Success);
 
     // load index to segment
     auto indexing = generate_index(vec_col.data(), DataType::VECTOR_BINARY, knowhere::metric::JACCARD,
@@ -2850,7 +2852,7 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Term) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "BIN_IVF_FLAT";
     std::string index_mode_key = "index_mode";
@@ -2872,7 +2874,7 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Term) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     std::vector<CSearchResult> results;
     results.push_back(c_search_result_on_bigIndex);
@@ -2883,10 +2885,10 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Term) {
     CSearchResultDataBlobs cSearchResultData;
     status = ReduceSearchResultsAndFillData(&cSearchResultData, plan, results.data(), results.size(), slice_nqs.data(),
                                             slice_topKs.data(), slice_nqs.size());
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     //    status = ReduceSearchResultsAndFillData(plan, results.data(), results.size());
-    //    assert(status.error_code == Success);
+    //    ASSERT_EQ(status.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -2924,9 +2926,9 @@ TEST(CApiTest, SealedSegmentTest) {
     auto load_info = CLoadFieldDataInfo{101, age_data.data(), age_data.size(), N};
 
     auto res = LoadFieldData(segment, load_info);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     auto count = GetRowCount(segment);
-    assert(count == N);
+    ASSERT_EQ(count, N);
 
     DeleteCollection(collection);
     DeleteSegment(segment);
@@ -2994,11 +2996,11 @@ TEST(CApiTest, SealedSegment_search_float_Predicate_Range) {
     // search on segment's small index
     void* plan = nullptr;
     auto status = CreateSearchPlan(collection, dsl_string, &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -3010,7 +3012,7 @@ TEST(CApiTest, SealedSegment_search_float_Predicate_Range) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "IVF_PQ";
     std::string index_mode_key = "index_mode";
@@ -3041,7 +3043,7 @@ TEST(CApiTest, SealedSegment_search_float_Predicate_Range) {
         N,
     };
     status = LoadFieldData(segment, c_counter_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     auto c_id_field_data = CLoadFieldDataInfo{
         0,
@@ -3050,7 +3052,7 @@ TEST(CApiTest, SealedSegment_search_float_Predicate_Range) {
         N,
     };
     status = LoadFieldData(segment, c_id_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     auto c_ts_field_data = CLoadFieldDataInfo{
         1,
@@ -3059,7 +3061,7 @@ TEST(CApiTest, SealedSegment_search_float_Predicate_Range) {
         N,
     };
     status = LoadFieldData(segment, c_ts_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     // load index for vec field, load raw data for scalar filed
     auto sealed_segment = SealedCreator(schema, dataset);
@@ -3069,7 +3071,7 @@ TEST(CApiTest, SealedSegment_search_float_Predicate_Range) {
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index =
         Search(sealed_segment.get(), plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -3138,7 +3140,7 @@ TEST(CApiTest, SealedSegment_search_without_predicates) {
         N,
     };
     auto status = LoadFieldData(segment, c_vec_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     auto c_counter_field_data = CLoadFieldDataInfo{
         101,
@@ -3147,7 +3149,7 @@ TEST(CApiTest, SealedSegment_search_without_predicates) {
         N,
     };
     status = LoadFieldData(segment, c_counter_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     auto c_id_field_data = CLoadFieldDataInfo{
         0,
@@ -3156,7 +3158,7 @@ TEST(CApiTest, SealedSegment_search_without_predicates) {
         N,
     };
     status = LoadFieldData(segment, c_id_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     auto c_ts_field_data = CLoadFieldDataInfo{
         1,
@@ -3165,7 +3167,7 @@ TEST(CApiTest, SealedSegment_search_without_predicates) {
         N,
     };
     status = LoadFieldData(segment, c_ts_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     int num_queries = 10;
     auto blob = generate_query_data(num_queries);
@@ -3272,11 +3274,11 @@ TEST(CApiTest, SealedSegment_search_float_With_Expr_Predicate_Range) {
     void* plan = nullptr;
     auto binary_plan = translate_text_plan_to_binary_plan(serialized_expr_plan);
     auto status = CreateSearchPlanByExpr(collection, binary_plan.data(), binary_plan.size(), &plan);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     void* placeholderGroup = nullptr;
     status = ParsePlaceholderGroup(plan, blob.data(), blob.length(), &placeholderGroup);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     std::vector<CPlaceholderGroup> placeholderGroups;
     placeholderGroups.push_back(placeholderGroup);
@@ -3289,7 +3291,7 @@ TEST(CApiTest, SealedSegment_search_float_With_Expr_Predicate_Range) {
     auto binary_set = indexing->Serialize(milvus::Config{});
     void* c_load_index_info = nullptr;
     status = NewLoadIndexInfo(&c_load_index_info, c_storage_config);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
     std::string index_type_key = "index_type";
     std::string index_type_value = "IVF_PQ";
     std::string index_mode_key = "index_mode";
@@ -3305,7 +3307,7 @@ TEST(CApiTest, SealedSegment_search_float_With_Expr_Predicate_Range) {
 
     // load vec index
     status = UpdateSealedSegmentIndex(segment, c_load_index_info);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     // load raw data
     auto c_counter_field_data = CLoadFieldDataInfo{
@@ -3315,7 +3317,7 @@ TEST(CApiTest, SealedSegment_search_float_With_Expr_Predicate_Range) {
         N,
     };
     status = LoadFieldData(segment, c_counter_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     auto c_id_field_data = CLoadFieldDataInfo{
         0,
@@ -3324,7 +3326,7 @@ TEST(CApiTest, SealedSegment_search_float_With_Expr_Predicate_Range) {
         N,
     };
     status = LoadFieldData(segment, c_id_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     auto c_ts_field_data = CLoadFieldDataInfo{
         1,
@@ -3333,7 +3335,7 @@ TEST(CApiTest, SealedSegment_search_float_With_Expr_Predicate_Range) {
         N,
     };
     status = LoadFieldData(segment, c_ts_field_data);
-    assert(status.error_code == Success);
+    ASSERT_EQ(status.error_code, Success);
 
     // gen query dataset
     auto query_dataset = knowhere::GenDataset(num_queries, DIM, query_ptr);
@@ -3351,7 +3353,7 @@ TEST(CApiTest, SealedSegment_search_float_With_Expr_Predicate_Range) {
 
     CSearchResult c_search_result_on_bigIndex;
     auto res_after_load_index = Search(segment, plan, placeholderGroup, time, &c_search_result_on_bigIndex);
-    assert(res_after_load_index.error_code == Success);
+    ASSERT_EQ(res_after_load_index.error_code, Success);
 
     auto search_result_on_bigIndex = (SearchResult*)c_search_result_on_bigIndex;
     for (int i = 0; i < num_queries; ++i) {
@@ -3389,9 +3391,9 @@ TEST(CApiTest, RetriveScalarFieldFromSealedSegmentWithIndex) {
     auto ts_data = serialize(ts_array.get());
     auto load_info = CLoadFieldDataInfo{TimestampFieldID.get(), ts_data.data(), ts_data.size(), N};
     auto res = LoadFieldData(segment, load_info);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     auto count = GetRowCount(segment);
-    assert(count == N);
+    ASSERT_EQ(count, N);
 
     // load rowid field
     FieldMeta row_id_field_meta(FieldName("RowID"), RowFieldID, DataType::INT64);
@@ -3399,9 +3401,9 @@ TEST(CApiTest, RetriveScalarFieldFromSealedSegmentWithIndex) {
     auto row_id_data = serialize(row_id_array.get());
     load_info = CLoadFieldDataInfo{RowFieldID.get(), row_id_data.data(), row_id_data.size(), N};
     res = LoadFieldData(segment, load_info);
-    assert(res.error_code == Success);
+    ASSERT_EQ(res.error_code, Success);
     count = GetRowCount(segment);
-    assert(count == N);
+    ASSERT_EQ(count, N);
 
     // load index for int8 field
     auto age8_col = raw_data.get_col<int8_t>(i8_fid);
diff --git a/internal/core/unittest/test_reduce_c.cpp b/internal/core/unittest/test_reduce_c.cpp
index 843504fd43..f6aa47a522 100644
--- a/internal/core/unittest/test_reduce_c.cpp
+++ b/internal/core/unittest/test_reduce_c.cpp
@@ -15,19 +15,11 @@
 #include "segcore/ReduceStructure.h"
 
 TEST(SearchResultPair, Greater) {
-    auto pair1 = SearchResultPair(0, 1.0, nullptr, 0, 0, 10);
+    auto pair1 = SearchResultPair(0, 1.0, nullptr, 0, 0, 1);
     auto pair2 = SearchResultPair(1, 2.0, nullptr, 1, 0, 10);
     ASSERT_EQ(pair1 > pair2, false);
 
-    pair1.primary_key_ = INVALID_PK;
-    pair2.primary_key_ = 1;
-    ASSERT_EQ(pair1 > pair2, false);
-
-    pair1.primary_key_ = 0;
-    pair2.primary_key_ = INVALID_PK;
+    pair1.advance();
     ASSERT_EQ(pair1 > pair2, true);
-
-    pair1.primary_key_ = INVALID_PK;
-    pair2.primary_key_ = INVALID_PK;
-    ASSERT_EQ(pair1 > pair2, false);
+    ASSERT_EQ(pair1.primary_key_, INVALID_PK);
 }