admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-01-07 19:31:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

refine unittest code

Browse Source 
Former-commit-id: 71662b7d99de6fcbbe80b98b82cc704ae3cc9398
This commit is contained in:
starlord 2019-09-11 11:37:19 +08:00
commit 1982736a86
16 changed files with 113 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cpp/src/utils/LogUtil.cpp
View File

@ -27,7 +27,7 @@ static int fatal_idx = 0;
}
// TODO(yzb) : change the easylogging library to get the log level from parameter rather than filename
void rolloutHandler(const char *filename, std::size_t size) {
void RolloutHandler(const char *filename, std::size_t size) {
char *dirc = strdup(filename);
char *basec = strdup(filename);
char *dir = dirname(dirc);
@ -112,7 +112,7 @@ int32_t InitLog(const std::string &log_config_file) {
el::Loggers::reconfigureAllLoggers(conf);
el::Loggers::addFlag(el::LoggingFlag::StrictLogFileSizeCheck);
el::Helpers::installPreRollOutCallback(rolloutHandler);
el::Helpers::installPreRollOutCallback(RolloutHandler);
return 0;
}

1
cpp/src/utils/LogUtil.h
View File

@ -16,6 +16,7 @@ inline std::string GetFileName(std::string filename) {
int pos = filename.find_last_of('/');
return filename.substr(pos + 1);
}
void RolloutHandler(const char *filename, std::size_t size);
#define SHOW_LOCATION
#ifdef SHOW_LOCATION

12
cpp/unittest/knowhere/knowhere_test.cpp
View File

@ -142,7 +142,7 @@ INSTANTIATE_TEST_CASE_P(WrapperParam, KnowhereWrapperTest,
)
);
TEST_P(KnowhereWrapperTest, base_test) {
TEST_P(KnowhereWrapperTest, BASE_TEST) {
EXPECT_EQ(index_->GetType(), index_type);
auto elems = nq * k;
@ -154,7 +154,7 @@ TEST_P(KnowhereWrapperTest, base_test) {
AssertResult(res_ids, res_dis);
}
TEST_P(KnowhereWrapperTest, to_gpu_test) {
TEST_P(KnowhereWrapperTest, TO_GPU_TEST) {
EXPECT_EQ(index_->GetType(), index_type);
auto elems = nq * k;
@ -174,7 +174,7 @@ TEST_P(KnowhereWrapperTest, to_gpu_test) {
}
{
std::string file_location = "/tmp/test_gpu_file";
std::string file_location = "/tmp/knowhere_gpu_file";
write_index(index_, file_location);
auto new_index = read_index(file_location);
@ -186,11 +186,11 @@ TEST_P(KnowhereWrapperTest, to_gpu_test) {
}
}
TEST_P(KnowhereWrapperTest, to_cpu_test) {
TEST_P(KnowhereWrapperTest, TO_CPU_TEST) {
// dev
}
TEST_P(KnowhereWrapperTest, serialize) {
TEST_P(KnowhereWrapperTest, SERIALIZE_TEST) {
EXPECT_EQ(index_->GetType(), index_type);
auto elems = nq * k;
@ -215,7 +215,7 @@ TEST_P(KnowhereWrapperTest, serialize) {
}
{
std::string file_location = "/tmp/whatever";
std::string file_location = "/tmp/knowhere";
write_index(index_, file_location);
auto new_index = read_index(file_location);
EXPECT_EQ(new_index->GetType(), ConvertToCpuIndexType(index_type));

4
cpp/unittest/metrics/metrics_test.cpp
View File

@ -24,7 +24,7 @@
using namespace zilliz::milvus;
TEST_F(MetricTest, Metric_Tes) {
TEST_F(MetricTest, METRIC_TEST) {
server::ConfigNode &configNode = server::ServerConfig::GetInstance().GetConfig(server::CONFIG_METRIC);
configNode.SetValue(server::CONFIG_METRIC_COLLECTOR, "zabbix");
server::Metrics::GetInstance();
@ -122,7 +122,7 @@ TEST_F(MetricTest, Metric_Tes) {
delete [] qxb;
};
TEST_F(MetricTest, Collector_Metrics_Test){
TEST_F(MetricTest, COLLECTOR_METRICS_TEST){
engine::Status status = engine::Status::OK();
server::CollectInsertMetrics insert_metrics0(0, status);
status = engine::Status(DB_ERROR, "error");

2
cpp/unittest/scheduler/algorithm_test.cpp
View File

@ -53,7 +53,7 @@ class AlgorithmTest : public testing::Test {
ResourceMgrPtr res_mgr_;
};
TEST_F(AlgorithmTest, ShortestPath_test) {
TEST_F(AlgorithmTest, SHORTESTPATH_TEST) {
std::vector<std::string> sp;
uint64_t cost;
cost = ShortestPath(disk_.lock(), gpu_0_.lock(), res_mgr_, sp);

8
cpp/unittest/scheduler/event_test.cpp
View File

@ -15,7 +15,7 @@ namespace zilliz {
namespace milvus {
namespace engine {
TEST(EventTest, start_up_event) {
TEST(EventTest, START_UP_EVENT) {
ResourceWPtr res(ResourcePtr(nullptr));
auto event = std::make_shared<StartUpEvent>(res);
ASSERT_FALSE(event->Dump().empty());
@ -23,7 +23,7 @@ TEST(EventTest, start_up_event) {
std::cout << *EventPtr(event);
}
TEST(EventTest, load_completed_event) {
TEST(EventTest, LOAD_COMPLETED_EVENT) {
ResourceWPtr res(ResourcePtr(nullptr));
auto event = std::make_shared<LoadCompletedEvent>(res, nullptr);
ASSERT_FALSE(event->Dump().empty());
@ -31,7 +31,7 @@ TEST(EventTest, load_completed_event) {
std::cout << *EventPtr(event);
}
TEST(EventTest, finish_task_event) {
TEST(EventTest, FINISH_TASK_EVENT) {
ResourceWPtr res(ResourcePtr(nullptr));
auto event = std::make_shared<FinishTaskEvent>(res, nullptr);
ASSERT_FALSE(event->Dump().empty());
@ -40,7 +40,7 @@ TEST(EventTest, finish_task_event) {
}
TEST(EventTest, tasktable_updated_event) {
TEST(EventTest, TASKTABLE_UPDATED_EVENT) {
ResourceWPtr res(ResourcePtr(nullptr));
auto event = std::make_shared<TaskTableUpdatedEvent>(res);
ASSERT_FALSE(event->Dump().empty());

8
cpp/unittest/scheduler/node_test.cpp
View File

@ -28,7 +28,7 @@ protected:
NodePtr isolated_node2_;
};
TEST_F(NodeTest, add_neighbour) {
TEST_F(NodeTest, ADD_NEIGHBOUR) {
ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 0);
ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
auto pcie = Connection("PCIe", 11.0);
@ -37,7 +37,7 @@ TEST_F(NodeTest, add_neighbour) {
ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
}
TEST_F(NodeTest, repeat_add_neighbour) {
TEST_F(NodeTest, REPEAT_ADD_NEIGHBOUR) {
ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 0);
ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
auto pcie = Connection("PCIe", 11.0);
@ -47,7 +47,7 @@ TEST_F(NodeTest, repeat_add_neighbour) {
ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
}
TEST_F(NodeTest, get_neighbours) {
TEST_F(NodeTest, GET_NEIGHBOURS) {
{
bool n2 = false, n3 = false;
auto node1_neighbours = node1_->GetNeighbours();
@ -72,7 +72,7 @@ TEST_F(NodeTest, get_neighbours) {
}
}
TEST_F(NodeTest, dump) {
TEST_F(NodeTest, DUMP) {
std::cout << node1_->Dump();
ASSERT_FALSE(node1_->Dump().empty());

2
cpp/unittest/scheduler/normal_test.cpp
View File

@ -11,7 +11,7 @@
using namespace zilliz::milvus::engine;
TEST(normal_test, inst_test) {
TEST(NormalTest, INST_TEST) {
// ResourceMgr only compose resources, provide unified event
auto res_mgr = ResMgrInst::GetInstance();

2
cpp/unittest/scheduler/resource_factory_test.cpp
View File

@ -4,7 +4,7 @@
using namespace zilliz::milvus::engine;
TEST(resource_factory_test, create) {
TEST(ResourceFactoryTest, CREATE) {
auto disk = ResourceFactory::Create("ssd", "DISK", 0);
auto cpu = ResourceFactory::Create("cpu", "CPU", 0);
auto gpu = ResourceFactory::Create("gpu", "GPU", 0);

32
cpp/unittest/scheduler/resource_mgr_test.cpp
View File

@ -44,19 +44,19 @@ protected:
ResourcePtr gpu_res;
};
TEST_F(ResourceMgrBaseTest, add) {
TEST_F(ResourceMgrBaseTest, ADD) {
auto resource = std::make_shared<TestResource>("test", 0, true, true);
auto ret = empty_mgr_->Add(ResourcePtr(resource));
ASSERT_EQ(ret.lock(), resource);
}
TEST_F(ResourceMgrBaseTest, add_disk) {
TEST_F(ResourceMgrBaseTest, ADD_DISK) {
auto resource = std::make_shared<DiskResource>("disk", 0, true, true);
auto ret = empty_mgr_->Add(ResourcePtr(resource));
ASSERT_EQ(ret.lock(), resource);
}
TEST_F(ResourceMgrBaseTest, connect) {
TEST_F(ResourceMgrBaseTest, CONNECT) {
auto resource1 = std::make_shared<TestResource>("resource1", 0, true, true);
auto resource2 = std::make_shared<TestResource>("resource2", 2, true, true);
empty_mgr_->Add(resource1);
@ -66,7 +66,7 @@ TEST_F(ResourceMgrBaseTest, connect) {
}
TEST_F(ResourceMgrBaseTest, invalid_connect) {
TEST_F(ResourceMgrBaseTest, INVALID_CONNECT) {
auto resource1 = std::make_shared<TestResource>("resource1", 0, true, true);
auto resource2 = std::make_shared<TestResource>("resource2", 2, true, true);
empty_mgr_->Add(resource1);
@ -76,19 +76,19 @@ TEST_F(ResourceMgrBaseTest, invalid_connect) {
}
TEST_F(ResourceMgrBaseTest, clear) {
TEST_F(ResourceMgrBaseTest, CLEAR) {
ASSERT_EQ(mgr1_->GetNumOfResource(), 3);
mgr1_->Clear();
ASSERT_EQ(mgr1_->GetNumOfResource(), 0);
}
TEST_F(ResourceMgrBaseTest, get_disk_resources) {
TEST_F(ResourceMgrBaseTest, GET_DISK_RESOURCES) {
auto disks = mgr1_->GetDiskResources();
ASSERT_EQ(disks.size(), 1);
ASSERT_EQ(disks[0].lock(), disk_res);
}
TEST_F(ResourceMgrBaseTest, get_all_resources) {
TEST_F(ResourceMgrBaseTest, GET_ALL_RESOURCES) {
bool disk = false, cpu = false, gpu = false;
auto resources = mgr1_->GetAllResources();
ASSERT_EQ(resources.size(), 3);
@ -103,13 +103,13 @@ TEST_F(ResourceMgrBaseTest, get_all_resources) {
ASSERT_TRUE(gpu);
}
TEST_F(ResourceMgrBaseTest, get_compute_resources) {
TEST_F(ResourceMgrBaseTest, GET_COMPUTE_RESOURCES) {
auto compute_resources = mgr1_->GetComputeResources();
ASSERT_EQ(compute_resources.size(), 1);
ASSERT_EQ(compute_resources[0], gpu_res);
}
TEST_F(ResourceMgrBaseTest, get_resource_by_type_and_deviceid) {
TEST_F(ResourceMgrBaseTest, GET_RESOURCE_BY_TYPE_AND_DEVICEID) {
auto cpu = mgr1_->GetResource(ResourceType::CPU, 1);
ASSERT_EQ(cpu, cpu_res);
@ -117,7 +117,7 @@ TEST_F(ResourceMgrBaseTest, get_resource_by_type_and_deviceid) {
ASSERT_EQ(invalid, nullptr);
}
TEST_F(ResourceMgrBaseTest, get_resource_by_name) {
TEST_F(ResourceMgrBaseTest, GET_RESOURCE_BY_NAME) {
auto disk = mgr1_->GetResource("disk");
ASSERT_EQ(disk, disk_res);
@ -125,26 +125,26 @@ TEST_F(ResourceMgrBaseTest, get_resource_by_name) {
ASSERT_EQ(invalid, nullptr);
}
TEST_F(ResourceMgrBaseTest, get_num_of_resource) {
TEST_F(ResourceMgrBaseTest, GET_NUM_OF_RESOURCE) {
ASSERT_EQ(empty_mgr_->GetNumOfResource(), 0);
ASSERT_EQ(mgr1_->GetNumOfResource(), 3);
}
TEST_F(ResourceMgrBaseTest, get_num_of_compute_resource) {
TEST_F(ResourceMgrBaseTest, GET_NUM_OF_COMPUTE_RESOURCE) {
ASSERT_EQ(empty_mgr_->GetNumOfComputeResource(), 0);
ASSERT_EQ(mgr1_->GetNumOfComputeResource(), 1);
}
TEST_F(ResourceMgrBaseTest, get_num_of_gpu_resource) {
TEST_F(ResourceMgrBaseTest, GET_NUM_OF_GPU_RESOURCE) {
ASSERT_EQ(empty_mgr_->GetNumGpuResource(), 0);
ASSERT_EQ(mgr1_->GetNumGpuResource(), 1);
}
TEST_F(ResourceMgrBaseTest, dump) {
TEST_F(ResourceMgrBaseTest, DUMP) {
ASSERT_FALSE(mgr1_->Dump().empty());
}
TEST_F(ResourceMgrBaseTest, dump_tasktables) {
TEST_F(ResourceMgrBaseTest, DUMP_TASKTABLES) {
ASSERT_FALSE(mgr1_->DumpTaskTables().empty());
}
@ -169,7 +169,7 @@ class ResourceMgrAdvanceTest : public testing::Test {
ResourcePtr disk_res;
};
TEST_F(ResourceMgrAdvanceTest, register_subscriber) {
TEST_F(ResourceMgrAdvanceTest, REGISTER_SUBSCRIBER) {
bool flag = false;
auto callback = [&](EventPtr event) {
flag = true;

20
cpp/unittest/scheduler/resource_test.cpp
View File

@ -46,42 +46,42 @@ protected:
ResourcePtr both_disable_ = nullptr;
};
TEST_F(ResourceBaseTest, name) {
TEST_F(ResourceBaseTest, NAME) {
ASSERT_EQ(only_loader_->name(), name1);
ASSERT_EQ(only_executor_->name(), name2);
ASSERT_EQ(both_enable_->name(), name3);
ASSERT_EQ(both_disable_->name(), name4);
}
TEST_F(ResourceBaseTest, type) {
TEST_F(ResourceBaseTest, TYPE) {
ASSERT_EQ(only_loader_->type(), ResourceType::DISK);
ASSERT_EQ(only_executor_->type(), ResourceType::CPU);
ASSERT_EQ(both_enable_->type(), ResourceType::GPU);
ASSERT_EQ(both_disable_->type(), ResourceType::TEST);
}
TEST_F(ResourceBaseTest, device_id) {
TEST_F(ResourceBaseTest, DEVICE_ID) {
ASSERT_EQ(only_loader_->device_id(), id1);
ASSERT_EQ(only_executor_->device_id(), id2);
ASSERT_EQ(both_enable_->device_id(), id3);
ASSERT_EQ(both_disable_->device_id(), id4);
}
TEST_F(ResourceBaseTest, has_loader) {
TEST_F(ResourceBaseTest, HAS_LOADER) {
ASSERT_TRUE(only_loader_->HasLoader());
ASSERT_FALSE(only_executor_->HasLoader());
ASSERT_TRUE(both_enable_->HasLoader());
ASSERT_FALSE(both_disable_->HasLoader());
}
TEST_F(ResourceBaseTest, has_executor) {
TEST_F(ResourceBaseTest, HAS_EXECUTOR) {
ASSERT_FALSE(only_loader_->HasExecutor());
ASSERT_TRUE(only_executor_->HasExecutor());
ASSERT_TRUE(both_enable_->HasExecutor());
ASSERT_FALSE(both_disable_->HasExecutor());
}
TEST_F(ResourceBaseTest, dump) {
TEST_F(ResourceBaseTest, DUMP) {
ASSERT_FALSE(only_loader_->Dump().empty());
ASSERT_FALSE(only_executor_->Dump().empty());
ASSERT_FALSE(both_enable_->Dump().empty());
@ -165,7 +165,7 @@ protected:
std::condition_variable cv_;
};
TEST_F(ResourceAdvanceTest, disk_resource_test) {
TEST_F(ResourceAdvanceTest, DISK_RESOURCE_TEST) {
const uint64_t NUM = 100;
std::vector<std::shared_ptr<TestTask>> tasks;
TableFileSchemaPtr dummy = nullptr;
@ -190,7 +190,7 @@ TEST_F(ResourceAdvanceTest, disk_resource_test) {
}
}
TEST_F(ResourceAdvanceTest, cpu_resource_test) {
TEST_F(ResourceAdvanceTest, CPU_RESOURCE_TEST) {
const uint64_t NUM = 100;
std::vector<std::shared_ptr<TestTask>> tasks;
TableFileSchemaPtr dummy = nullptr;
@ -215,7 +215,7 @@ TEST_F(ResourceAdvanceTest, cpu_resource_test) {
}
}
TEST_F(ResourceAdvanceTest, gpu_resource_test) {
TEST_F(ResourceAdvanceTest, GPU_RESOURCE_TEST) {
const uint64_t NUM = 100;
std::vector<std::shared_ptr<TestTask>> tasks;
TableFileSchemaPtr dummy = nullptr;
@ -240,7 +240,7 @@ TEST_F(ResourceAdvanceTest, gpu_resource_test) {
}
}
TEST_F(ResourceAdvanceTest, test_resource_test) {
TEST_F(ResourceAdvanceTest, TEST_RESOURCE_TEST) {
const uint64_t NUM = 100;
std::vector<std::shared_ptr<TestTask>> tasks;
TableFileSchemaPtr dummy = nullptr;

2
cpp/unittest/scheduler/schedinst_test.cpp
View File

@ -68,7 +68,7 @@ protected:
const std::string CONFIG_FILE = "/tmp/milvus_sched_test/config.yaml";
};
TEST_F(SchedInstTest, simple_gpu) {
TEST_F(SchedInstTest, SIMPLE_GPU) {
StartSchedulerService();
}

6
cpp/unittest/scheduler/scheduler_test.cpp
View File

@ -138,7 +138,7 @@ insert_dummy_index_into_gpu_cache(uint64_t device_id) {
cache::GpuCacheMgr::GetInstance(device_id)->InsertItem("location", obj);
}
TEST_F(SchedulerTest, OnLoadCompleted) {
TEST_F(SchedulerTest, ON_LOAD_COMPLETED) {
const uint64_t NUM = 10;
std::vector<std::shared_ptr<TestTask>> tasks;
TableFileSchemaPtr dummy = std::make_shared<meta::TableFileSchema>();
@ -158,7 +158,7 @@ TEST_F(SchedulerTest, OnLoadCompleted) {
}
TEST_F(SchedulerTest, PushTaskToNeighbourRandomlyTest) {
TEST_F(SchedulerTest, PUSH_TASK_TO_NEIGHBOUR_RANDOMLY_TEST) {
const uint64_t NUM = 10;
std::vector<std::shared_ptr<TestTask>> tasks;
TableFileSchemaPtr dummy1 = std::make_shared<meta::TableFileSchema>();
@ -229,7 +229,7 @@ protected:
};
TEST_F(SchedulerTest2, SpecifiedResourceTest) {
TEST_F(SchedulerTest2, SPECIFIED_RESOURCE_TEST) {
const uint64_t NUM = 10;
std::vector<std::shared_ptr<TestTask>> tasks;
TableFileSchemaPtr dummy = std::make_shared<meta::TableFileSchema>();

2
cpp/unittest/scheduler/task_test.cpp
View File

@ -13,7 +13,7 @@ namespace milvus {
namespace engine {
TEST(TaskTest, invalid_index) {
TEST(TaskTest, INVALID_INDEX) {
auto search_task = std::make_shared<XSearchTask>(nullptr);
search_task->Load(LoadType::TEST, 10);
}

60
cpp/unittest/scheduler/tasktable_test.cpp
View File

@ -32,18 +32,18 @@ protected:
std::vector<TaskTableItemPtr> items_;
};
TEST_F(TaskTableItemTest, construct) {
TEST_F(TaskTableItemTest, CONSTRUCT) {
ASSERT_EQ(default_.id, 0);
ASSERT_EQ(default_.task, nullptr);
ASSERT_EQ(default_.state, TaskTableItemState::INVALID);
}
TEST_F(TaskTableItemTest, destruct) {
TEST_F(TaskTableItemTest, DESTRUCT) {
auto p_item = new TaskTableItem();
delete p_item;
}
TEST_F(TaskTableItemTest, is_finish) {
TEST_F(TaskTableItemTest, IS_FINISH) {
for (auto &item : items_) {
if (item->state == TaskTableItemState::EXECUTED
|| item->state == TaskTableItemState::MOVED) {
@ -54,13 +54,13 @@ TEST_F(TaskTableItemTest, is_finish) {
}
}
TEST_F(TaskTableItemTest, dump) {
TEST_F(TaskTableItemTest, DUMP) {
for (auto &item : items_) {
ASSERT_FALSE(item->Dump().empty());
}
}
TEST_F(TaskTableItemTest, load) {
TEST_F(TaskTableItemTest, LOAD) {
for (auto &item : items_) {
auto before_state = item->state;
auto ret = item->Load();
@ -74,7 +74,7 @@ TEST_F(TaskTableItemTest, load) {
}
}
TEST_F(TaskTableItemTest, loaded) {
TEST_F(TaskTableItemTest, LOADED) {
for (auto &item : items_) {
auto before_state = item->state;
auto ret = item->Loaded();
@ -88,7 +88,7 @@ TEST_F(TaskTableItemTest, loaded) {
}
}
TEST_F(TaskTableItemTest, execute) {
TEST_F(TaskTableItemTest, EXECUTE) {
for (auto &item : items_) {
auto before_state = item->state;
auto ret = item->Execute();
@ -103,7 +103,7 @@ TEST_F(TaskTableItemTest, execute) {
}
TEST_F(TaskTableItemTest, executed) {
TEST_F(TaskTableItemTest, EXECUTED) {
for (auto &item : items_) {
auto before_state = item->state;
auto ret = item->Executed();
@ -117,7 +117,7 @@ TEST_F(TaskTableItemTest, executed) {
}
}
TEST_F(TaskTableItemTest, move) {
TEST_F(TaskTableItemTest, MOVE) {
for (auto &item : items_) {
auto before_state = item->state;
auto ret = item->Move();
@ -131,7 +131,7 @@ TEST_F(TaskTableItemTest, move) {
}
}
TEST_F(TaskTableItemTest, moved) {
TEST_F(TaskTableItemTest, MOVED) {
for (auto &item : items_) {
auto before_state = item->state;
auto ret = item->Moved();
@ -163,7 +163,7 @@ protected:
TaskTable empty_table_;
};
TEST_F(TaskTableBaseTest, subscriber) {
TEST_F(TaskTableBaseTest, SUBSCRIBER) {
bool flag = false;
auto callback = [&]() {
flag = true;
@ -174,46 +174,46 @@ TEST_F(TaskTableBaseTest, subscriber) {
}
TEST_F(TaskTableBaseTest, put_task) {
TEST_F(TaskTableBaseTest, PUT_TASK) {
empty_table_.Put(task1_);
ASSERT_EQ(empty_table_.Get(0)->task, task1_);
}
TEST_F(TaskTableBaseTest, put_invalid_test) {
TEST_F(TaskTableBaseTest, PUT_INVALID_TEST) {
empty_table_.Put(invalid_task_);
ASSERT_EQ(empty_table_.Get(0)->task, invalid_task_);
}
TEST_F(TaskTableBaseTest, put_batch) {
TEST_F(TaskTableBaseTest, PUT_BATCH) {
std::vector<TaskPtr> tasks{task1_, task2_};
empty_table_.Put(tasks);
ASSERT_EQ(empty_table_.Get(0)->task, task1_);
ASSERT_EQ(empty_table_.Get(1)->task, task2_);
}
TEST_F(TaskTableBaseTest, put_empty_batch) {
TEST_F(TaskTableBaseTest, PUT_EMPTY_BATCH) {
std::vector<TaskPtr> tasks{};
empty_table_.Put(tasks);
}
TEST_F(TaskTableBaseTest, empty) {
TEST_F(TaskTableBaseTest, EMPTY) {
ASSERT_TRUE(empty_table_.Empty());
empty_table_.Put(task1_);
ASSERT_FALSE(empty_table_.Empty());
}
TEST_F(TaskTableBaseTest, size) {
TEST_F(TaskTableBaseTest, SIZE) {
ASSERT_EQ(empty_table_.Size(), 0);
empty_table_.Put(task1_);
ASSERT_EQ(empty_table_.Size(), 1);
}
TEST_F(TaskTableBaseTest, operator_) {
TEST_F(TaskTableBaseTest, OPERATOR) {
empty_table_.Put(task1_);
ASSERT_EQ(empty_table_.Get(0), empty_table_[0]);
}
TEST_F(TaskTableBaseTest, pick_to_load) {
TEST_F(TaskTableBaseTest, PICK_TO_LOAD) {
const size_t NUM_TASKS = 10;
for (size_t i = 0; i < NUM_TASKS; ++i) {
empty_table_.Put(task1_);
@ -226,7 +226,7 @@ TEST_F(TaskTableBaseTest, pick_to_load) {
ASSERT_EQ(indexes[0], 2);
}
TEST_F(TaskTableBaseTest, pick_to_load_limit) {
TEST_F(TaskTableBaseTest, PICK_TO_LOAD_LIMIT) {
const size_t NUM_TASKS = 10;
for (size_t i = 0; i < NUM_TASKS; ++i) {
empty_table_.Put(task1_);
@ -241,7 +241,7 @@ TEST_F(TaskTableBaseTest, pick_to_load_limit) {
ASSERT_EQ(indexes[2], 4);
}
TEST_F(TaskTableBaseTest, pick_to_load_cache) {
TEST_F(TaskTableBaseTest, PICK_TO_LOAD_CACHE) {
const size_t NUM_TASKS = 10;
for (size_t i = 0; i < NUM_TASKS; ++i) {
empty_table_.Put(task1_);
@ -262,7 +262,7 @@ TEST_F(TaskTableBaseTest, pick_to_load_cache) {
ASSERT_EQ(indexes[0], 2);
}
TEST_F(TaskTableBaseTest, pick_to_execute) {
TEST_F(TaskTableBaseTest, PICK_TO_EXECUTE) {
const size_t NUM_TASKS = 10;
for (size_t i = 0; i < NUM_TASKS; ++i) {
empty_table_.Put(task1_);
@ -276,7 +276,7 @@ TEST_F(TaskTableBaseTest, pick_to_execute) {
ASSERT_EQ(indexes[0], 2);
}
TEST_F(TaskTableBaseTest, pick_to_execute_limit) {
TEST_F(TaskTableBaseTest, PICK_TO_EXECUTE_LIMIT) {
const size_t NUM_TASKS = 10;
for (size_t i = 0; i < NUM_TASKS; ++i) {
empty_table_.Put(task1_);
@ -292,7 +292,7 @@ TEST_F(TaskTableBaseTest, pick_to_execute_limit) {
ASSERT_EQ(indexes[1], 3);
}
TEST_F(TaskTableBaseTest, pick_to_execute_cache) {
TEST_F(TaskTableBaseTest, PICK_TO_EXECUTE_CACHE) {
const size_t NUM_TASKS = 10;
for (size_t i = 0; i < NUM_TASKS; ++i) {
empty_table_.Put(task1_);
@ -340,7 +340,7 @@ protected:
TaskTable table1_;
};
TEST_F(TaskTableAdvanceTest, load) {
TEST_F(TaskTableAdvanceTest, LOAD) {
std::vector<TaskTableItemState> before_state;
for (auto &task : table1_) {
before_state.push_back(task->state);
@ -359,7 +359,7 @@ TEST_F(TaskTableAdvanceTest, load) {
}
}
TEST_F(TaskTableAdvanceTest, loaded) {
TEST_F(TaskTableAdvanceTest, LOADED) {
std::vector<TaskTableItemState> before_state;
for (auto &task : table1_) {
before_state.push_back(task->state);
@ -378,7 +378,7 @@ TEST_F(TaskTableAdvanceTest, loaded) {
}
}
TEST_F(TaskTableAdvanceTest, execute) {
TEST_F(TaskTableAdvanceTest, EXECUTE) {
std::vector<TaskTableItemState> before_state;
for (auto &task : table1_) {
before_state.push_back(task->state);
@ -397,7 +397,7 @@ TEST_F(TaskTableAdvanceTest, execute) {
}
}
TEST_F(TaskTableAdvanceTest, executed) {
TEST_F(TaskTableAdvanceTest, EXECUTED) {
std::vector<TaskTableItemState> before_state;
for (auto &task : table1_) {
before_state.push_back(task->state);
@ -416,7 +416,7 @@ TEST_F(TaskTableAdvanceTest, executed) {
}
}
TEST_F(TaskTableAdvanceTest, move) {
TEST_F(TaskTableAdvanceTest, MOVE) {
std::vector<TaskTableItemState> before_state;
for (auto &task : table1_) {
before_state.push_back(task->state);
@ -435,7 +435,7 @@ TEST_F(TaskTableAdvanceTest, move) {
}
}
TEST_F(TaskTableAdvanceTest, moved) {
TEST_F(TaskTableAdvanceTest, MOVED) {
std::vector<TaskTableItemState> before_state;
for (auto &task : table1_) {
before_state.push_back(task->state);

30
cpp/unittest/server/util_test.cpp
View File

@ -6,6 +6,9 @@
#include <gtest/gtest.h>
#include <thread>
#include <easylogging++.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <boost/filesystem.hpp>
#include "utils/CommonUtil.h"
#include "utils/Error.h"
@ -282,3 +285,30 @@ TEST(ValidationUtilTest, VALIDATE_DBURI_TEST) {
ASSERT_EQ(server::ValidationUtil::ValidateDbURI("mysql://root:123456@127.0.0.1:3303/milvus"), SERVER_SUCCESS);
ASSERT_NE(server::ValidationUtil::ValidateDbURI("mysql://root:123456@127.0.0.1:port/milvus"), SERVER_SUCCESS);
}
TEST(UtilTest, ROLLOUTHANDLER_TEST){
std::string dir1 = "/tmp/milvus_test";
std::string dir2 = "/tmp/milvus_test/log_test";
std::string filename[6] = {"log_global.log", "log_debug.log", "log_warning.log", "log_trace.log", "log_error.log", "log_fatal.log"};
mkdir(dir1.c_str(), S_IRWXU);
mkdir(dir2.c_str(), S_IRWXU);
for (int i = 0; i < 6; ++i) {
std::string tmp = dir2 + "/" + filename[i];
std::ofstream file;
file.open(tmp.c_str());
file << "zilliz" << std::endl;
server::RolloutHandler(tmp.c_str(), 0);
tmp.append(".1");
std::ifstream file2;
file2.open(tmp);
std::string tmp2;
file2 >> tmp2;
ASSERT_EQ(tmp2, "zilliz");
}
boost::filesystem::remove_all(dir2);
}