refine unittest code

Former-commit-id: 4d9a2330acc0cb7cb7fe663fcb4c2035203bc78b

cpp/unittest/db/db_tests.cpp

@@ -147,7 +147,7 @@ TEST_F(DBTest, DB_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     engine::IDNumbers vector_ids;
@@ -181,7 +181,7 @@ TEST_F(DBTest, DB_TEST) {
             ss << "Search " << j << " With Size " << count/engine::meta::M << " M";
             STOP_TIMER(ss.str());
 
-            ASSERT_STATS(stat);
+            ASSERT_TRUE(stat.ok());
             for (auto k=0; k<qb; ++k) {
                 ASSERT_EQ(results[k][0].first, target_ids[k]);
                 ss.str("");
@@ -212,7 +212,7 @@ TEST_F(DBTest, DB_TEST) {
 
     uint64_t count;
     stat = db_->GetTableRowCount(TABLE_NAME, count);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_TRUE(count > 0);
 };
 
@@ -223,7 +223,7 @@ TEST_F(DBTest, SEARCH_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     // prepare raw data
@@ -258,7 +258,7 @@ TEST_F(DBTest, SEARCH_TEST) {
     for (int j = 0; j < nb / batch_size; ++j) {
         stat = db_->InsertVectors(TABLE_NAME, batch_size, xb.data()+batch_size*j*TABLE_DIM, ids);
         if (j == 200){ sleep(1);}
-        ASSERT_STATS(stat);
+        ASSERT_TRUE(stat.ok());
     }
 
     engine::TableIndex index;
@@ -268,7 +268,7 @@ TEST_F(DBTest, SEARCH_TEST) {
     {
         engine::QueryResults results;
         stat = db_->Query(TABLE_NAME, k, nq, 10, xq.data(), results);
-        ASSERT_STATS(stat);
+        ASSERT_TRUE(stat.ok());
     }
 
     {//search by specify index file
@@ -276,7 +276,7 @@ TEST_F(DBTest, SEARCH_TEST) {
         std::vector<std::string> file_ids = {"1", "2", "3", "4", "5", "6"};
         engine::QueryResults results;
         stat = db_->Query(TABLE_NAME, file_ids, k, nq, 10, xq.data(), dates, results);
-        ASSERT_STATS(stat);
+        ASSERT_TRUE(stat.ok());
     }
 
     // TODO(linxj): add groundTruth assert
@@ -289,7 +289,7 @@ TEST_F(DBTest, PRELOADTABLE_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     int64_t nb = VECTOR_COUNT;
@@ -309,7 +309,7 @@ TEST_F(DBTest, PRELOADTABLE_TEST) {
 
     int64_t prev_cache_usage = cache::CpuCacheMgr::GetInstance()->CacheUsage();
     stat = db_->PreloadTable(TABLE_NAME);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     int64_t cur_cache_usage = cache::CpuCacheMgr::GetInstance()->CacheUsage();
     ASSERT_TRUE(prev_cache_usage < cur_cache_usage);
 
@@ -322,7 +322,7 @@ TEST_F(DBTest2, ARHIVE_DISK_CHECK) {
 
     std::vector<engine::meta::TableSchema> table_schema_array;
     stat = db_->AllTables(table_schema_array);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     bool bfound = false;
     for(auto& schema : table_schema_array) {
         if(schema.table_id_ == TABLE_NAME) {
@@ -335,7 +335,7 @@ TEST_F(DBTest2, ARHIVE_DISK_CHECK) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     uint64_t size;
@@ -366,7 +366,7 @@ TEST_F(DBTest2, DELETE_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
 
     bool has_table = false;
     db_->HasTable(TABLE_NAME, has_table);
@@ -405,7 +405,7 @@ TEST_F(DBTest2, DELETE_BY_RANGE_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
 
     bool has_table = false;
     db_->HasTable(TABLE_NAME, has_table);
@@ -433,7 +433,7 @@ TEST_F(DBTest2, DELETE_BY_RANGE_TEST) {
     ConvertTimeRangeToDBDates(start_value, end_value, dates);
 
     stat = db_->DeleteTable(TABLE_NAME, dates);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
 
     uint64_t row_count = 0;
     db_->GetTableRowCount(TABLE_NAME, row_count);

cpp/unittest/db/mem_test.cpp

@@ -3,12 +3,12 @@
 #include "db/insert/VectorSource.h"
 #include "db/insert/MemTableFile.h"
 #include "db/insert/MemTable.h"
-#include "utils.h"
 #include "db/Factories.h"
 #include "db/Constants.h"
 #include "db/engine/EngineFactory.h"
-#include "metrics/Metrics.h"
 #include "db/meta/MetaConsts.h"
+#include "metrics/Metrics.h"
+#include "utils.h"
 
 #include <boost/filesystem.hpp>
 #include <thread>
@@ -223,7 +223,7 @@ TEST_F(MemManagerTest2, SERIAL_INSERT_SEARCH_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     std::map<int64_t, std::vector<float>> search_vectors;
@@ -269,7 +269,7 @@ TEST_F(MemManagerTest2, INSERT_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     auto start_time = METRICS_NOW_TIME;
@@ -295,7 +295,7 @@ TEST_F(MemManagerTest2, CONCURRENT_INSERT_SEARCH_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     engine::IDNumbers vector_ids;
@@ -329,7 +329,7 @@ TEST_F(MemManagerTest2, CONCURRENT_INSERT_SEARCH_TEST) {
             ss << "Search " << j << " With Size " << count / engine::meta::M << " M";
             STOP_TIMER(ss.str());
 
-            ASSERT_STATS(stat);
+            ASSERT_TRUE(stat.ok());
             for (auto k = 0; k < qb; ++k) {
                 ASSERT_EQ(results[k][0].first, target_ids[k]);
                 ss.str("");
@@ -366,7 +366,7 @@ TEST_F(MemManagerTest2, VECTOR_IDS_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     engine::IDNumbers vector_ids;
@@ -383,7 +383,7 @@ TEST_F(MemManagerTest2, VECTOR_IDS_TEST) {
 
     stat = db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
     ASSERT_EQ(vector_ids[0], 0);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
 
     nb = 25000;
     xb.clear();
@@ -395,7 +395,7 @@ TEST_F(MemManagerTest2, VECTOR_IDS_TEST) {
     }
     stat = db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
     ASSERT_EQ(vector_ids[0], nb);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
 
     nb = 262144; //512M
     xb.clear();
@@ -407,14 +407,14 @@ TEST_F(MemManagerTest2, VECTOR_IDS_TEST) {
     }
     stat = db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
     ASSERT_EQ(vector_ids[0], nb/2);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
 
     nb = 65536; //128M
     xb.clear();
     BuildVectors(nb, xb);
     vector_ids.clear();
     stat = db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
 
     nb = 100;
     xb.clear();

cpp/unittest/db/mysql_db_test.cpp

@@ -53,7 +53,7 @@ TEST_F(MySqlDBTest, DB_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     engine::IDNumbers vector_ids;
@@ -90,7 +90,7 @@ TEST_F(MySqlDBTest, DB_TEST) {
             ss << "Search " << j << " With Size " << count/engine::meta::M << " M";
             STOP_TIMER(ss.str());
 
-            ASSERT_STATS(stat);
+            ASSERT_TRUE(stat.ok());
             for (auto k=0; k<qb; ++k) {
 //                std::cout << results[k][0].first << " " << target_ids[k] << std::endl;
 //                ASSERT_EQ(results[k][0].first, target_ids[k]);
@@ -138,7 +138,7 @@ TEST_F(MySqlDBTest, SEARCH_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     // prepare raw data
@@ -173,14 +173,14 @@ TEST_F(MySqlDBTest, SEARCH_TEST) {
     for (int j = 0; j < nb / batch_size; ++j) {
         stat = db_->InsertVectors(TABLE_NAME, batch_size, xb.data()+batch_size*j*TABLE_DIM, ids);
         if (j == 200){ sleep(1);}
-        ASSERT_STATS(stat);
+        ASSERT_TRUE(stat.ok());
     }
 
     sleep(2); // wait until build index finish
 
     engine::QueryResults results;
     stat = db_->Query(TABLE_NAME, k, nq, 10, xq.data(), results);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
 };
 
 TEST_F(MySqlDBTest, ARHIVE_DISK_CHECK) {
@@ -189,7 +189,7 @@ TEST_F(MySqlDBTest, ARHIVE_DISK_CHECK) {
 
     std::vector<engine::meta::TableSchema> table_schema_array;
     stat = db_->AllTables(table_schema_array);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     bool bfound = false;
     for(auto& schema : table_schema_array) {
         if(schema.table_id_ == TABLE_NAME) {
@@ -202,7 +202,7 @@ TEST_F(MySqlDBTest, ARHIVE_DISK_CHECK) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
     ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
 
     engine::IDNumbers vector_ids;
@@ -236,7 +236,7 @@ TEST_F(MySqlDBTest, DELETE_TEST) {
     engine::meta::TableSchema table_info_get;
     table_info_get.table_id_ = TABLE_NAME;
     stat = db_->DescribeTable(table_info_get);
-    ASSERT_STATS(stat);
+    ASSERT_TRUE(stat.ok());
 
     bool has_table = false;
     db_->HasTable(TABLE_NAME, has_table);

cpp/unittest/db/utils.cpp

@@ -35,13 +35,6 @@ public:
 
 };
 
-void ASSERT_STATS(engine::Status& stat) {
-    ASSERT_TRUE(stat.ok());
-    if(!stat.ok()) {
-        std::cout << stat.ToString() << std::endl;
-    }
-}
-
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void BaseTest::InitLog() {
     el::Configurations defaultConf;

cpp/unittest/db/utils.h

@@ -32,8 +32,6 @@
 #define STOP_TIMER(name)
 #endif
 
-void ASSERT_STATS(zilliz::milvus::engine::Status &stat);
-
 class BaseTest : public ::testing::Test {
 protected:
     void InitLog();

cpp/unittest/knowhere/knowhere_test.cpp

@@ -34,7 +34,6 @@ class KnowhereWrapperTest
         std::string generator_type;
         std::tie(index_type, generator_type, dim, nb, nq, k, train_cfg, search_cfg) = GetParam();
 
-        //auto generator = GetGenerateFactory(generator_type);
         auto generator = std::make_shared<DataGenBase>();
         generator->GenData(dim, nb, nq, xb, xq, ids, k, gt_ids, gt_dis);
 

cpp/unittest/knowhere/utils.cpp

@@ -9,14 +9,6 @@
 #include "utils.h"
 
 
-DataGenPtr GetGenerateFactory(const std::string &gen_type) {
-    std::shared_ptr<DataGenBase> generator;
-    if (gen_type == "default") {
-        generator = std::make_shared<DataGenBase>();
-    }
-    return generator;
-}
-
 void DataGenBase::GenData(const int &dim, const int &nb, const int &nq,
                           float *xb, float *xq, long *ids,
                           const int &k, long *gt_ids, float *gt_dis) {

cpp/unittest/knowhere/utils.h

@@ -17,8 +17,6 @@ class DataGenBase;
 
 using DataGenPtr = std::shared_ptr<DataGenBase>;
 
-extern DataGenPtr GetGenerateFactory(const std::string &gen_type);
-
 
 class DataGenBase {
  public:

cpp/unittest/metrics/metrics_test.cpp

@@ -90,8 +90,6 @@ TEST_F(MetricTest, Metric_Tes) {
 //            stat = db_->Query(group_name, k, qb, qxb, results);
             ss << "Search " << j << " With Size " << (float)(count*group_dim*sizeof(float))/(1024*1024) << " M";
 
-
-//            ASSERT_STATS(stat);
             for (auto k=0; k<qb; ++k) {
 //                ASSERT_EQ(results[k][0].first, target_ids[k]);
                 ss.str("");

cpp/unittest/metrics/utils.cpp

@@ -34,14 +34,6 @@ public:
 
 };
 
-void ASSERT_STATS(engine::Status& stat) {
-    ASSERT_TRUE(stat.ok());
-    if(!stat.ok()) {
-        std::cout << stat.ToString() << std::endl;
-    }
-}
-
-
 void MetricTest::InitLog() {
     el::Configurations defaultConf;
     defaultConf.setToDefault();

cpp/unittest/server/cache_test.cpp

@@ -36,7 +36,7 @@ public:
                                const engine::Config &cfg,
                                const long &nt = 0,
                                const float *xt = nullptr) {
-
+        return 0;
     }
 
     engine::VecIndexPtr Clone() override {
@@ -55,7 +55,7 @@ public:
                           const float *xb,
                           const long *ids,
                           const engine::Config &cfg = engine::Config()) {
-
+        return 0;
     }
 
     virtual ErrorCode Search(const long &nq,
@@ -63,15 +63,16 @@ public:
                              float *dist,
                              long *ids,
                              const engine::Config &cfg = engine::Config()) {
-
+        return 0;
     }
 
-    engine::VecIndexPtr CopyToGpu(const int64_t &device_id, const engine::Config &cfg) override {
-
+    engine::VecIndexPtr CopyToGpu(const int64_t &device_id,
+                                  const engine::Config &cfg) override {
+        return nullptr;
     }
 
     engine::VecIndexPtr CopyToCpu(const engine::Config &cfg) override {
-
+        return nullptr;
     }
 
     virtual int64_t Dimension() {
@@ -88,7 +89,7 @@ public:
     }
 
     virtual ErrorCode Load(const zilliz::knowhere::BinarySet &index_binary) {
-
+        return 0;
     }
 
 public:
@@ -98,6 +99,24 @@ public:
 
 }
 
+TEST(CacheTest, DUMMY_TEST) {
+    engine::Config cfg;
+    MockVecIndex mock_index;
+    mock_index.Dimension();
+    mock_index.Count();
+    mock_index.Add(1, nullptr, nullptr);
+    mock_index.BuildAll(1, nullptr, nullptr, cfg);
+    mock_index.Search(1, nullptr, nullptr, nullptr, cfg);
+    mock_index.Clone();
+    mock_index.CopyToCpu(cfg);
+    mock_index.CopyToGpu(1, cfg);
+    mock_index.GetDeviceId();
+    mock_index.GetType();
+    zilliz::knowhere::BinarySet index_binary;
+    mock_index.Load(index_binary);
+    mock_index.Serialize();
+}
+
 TEST(CacheTest, CPU_CACHE_TEST) {
     cache::CacheMgr *cpu_mgr = cache::CpuCacheMgr::GetInstance();