From a416633936f04ef8021b02b7ec1de63541f34a4a Mon Sep 17 00:00:00 2001 From: Avinash Varma Date: Tue, 2 Sep 2025 12:12:49 +0530 Subject: [PATCH 1/4] Convert from boost test to gtest --- .vscode/settings.json | 93 ++++++++++ Test/CMakeLists.txt | 41 +++-- Test/cuda/cuda_tests.cpp | 30 ++-- Test/cuda/pq_perf.cpp | 44 +++-- Test/inc/Test.h | 2 +- Test/src/AlgoTest.cpp | 59 +++---- Test/src/Base64HelperTest.cpp | 19 +- Test/src/CommonHelperTest.cpp | 75 ++++---- Test/src/ConcurrentTest.cpp | 12 +- Test/src/DistanceTest.cpp | 16 +- Test/src/FilterTest.cpp | 19 +- Test/src/IniReaderTest.cpp | 32 ++-- Test/src/IterativeScanTest.cpp | 23 ++- Test/src/KVTest.cpp | 21 +-- Test/src/MultiIndexExperiment.cpp | 17 +- Test/src/MultiIndexScanTest.cpp | 17 +- Test/src/PerfTest.cpp | 28 ++- Test/src/ReconstructIndexSimilarityTest.cpp | 39 ++--- Test/src/SIMDTest.cpp | 11 +- Test/src/SPFreshTest.cpp | 183 ++++++++++---------- Test/src/SSDServingTest.cpp | 34 ++-- Test/src/StringConvertTest.cpp | 49 ++---- Test/src/main.cpp | 40 +---- 23 files changed, 459 insertions(+), 445 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 000000000..ac24f1f82 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,93 @@ +{ + "files.associations": { + "cctype": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "csetjmp": "cpp", + "csignal": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "cwctype": "cpp", + "any": "cpp", + "array": "cpp", + "atomic": "cpp", + "strstream": "cpp", + "barrier": "cpp", + "bit": "cpp", + "bitset": "cpp", + "cfenv": "cpp", + "charconv": "cpp", + "chrono": "cpp", + "cinttypes": "cpp", + "codecvt": "cpp", + "compare": "cpp", + "complex": "cpp", + "concepts": "cpp", + "condition_variable": "cpp", + "coroutine": "cpp", + "cstdint": "cpp", + "cuchar": "cpp", + "deque": "cpp", + "forward_list": "cpp", + "list": "cpp", + "map": "cpp", + "set": "cpp", + "string": "cpp", + "unordered_map": "cpp", + "unordered_set": "cpp", + "vector": "cpp", + "exception": "cpp", + "algorithm": "cpp", + "functional": "cpp", + "iterator": "cpp", + "memory": "cpp", + "memory_resource": "cpp", + "numeric": "cpp", + "optional": "cpp", + "random": "cpp", + "ratio": "cpp", + "regex": "cpp", + "source_location": "cpp", + "string_view": "cpp", + "system_error": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "utility": "cpp", + "fstream": "cpp", + "future": "cpp", + "initializer_list": "cpp", + "iomanip": "cpp", + "iosfwd": "cpp", + "iostream": "cpp", + "istream": "cpp", + "latch": "cpp", + "limits": "cpp", + "mutex": "cpp", + "new": "cpp", + "numbers": "cpp", + "ostream": "cpp", + "ranges": "cpp", + "scoped_allocator": "cpp", + "semaphore": "cpp", + "shared_mutex": "cpp", + "span": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "stop_token": "cpp", + "streambuf": "cpp", + "syncstream": "cpp", + "thread": "cpp", + "typeindex": "cpp", + "typeinfo": "cpp", + "valarray": "cpp", + "variant": "cpp", + "expected": "cpp", + "spanstream": "cpp", + "stacktrace": "cpp" + } +} \ No newline at end of file diff --git a/Test/CMakeLists.txt b/Test/CMakeLists.txt index 52f4168a9..0700188f8 100644 --- a/Test/CMakeLists.txt +++ b/Test/CMakeLists.txt @@ -2,29 +2,38 @@ # Licensed under the MIT License. if (NOT LIBRARYONLY) - if(NOT WIN32) - ADD_DEFINITIONS(-DBOOST_TEST_DYN_LINK) - message (STATUS "BOOST_TEST_DYN_LINK") - endif() + find_package(Boost 1.66 COMPONENTS system thread serialization wserialization regex filesystem) + if (Boost_FOUND) + include_directories (${Boost_INCLUDE_DIR}) + link_directories (${Boost_LIBRARY_DIR}) + message (STATUS "Found Boost.") + message (STATUS "Include Path: ${Boost_INCLUDE_DIRS}") + message (STATUS "Library Path: ${Boost_LIBRARY_DIRS}") + message (STATUS "Library: ${Boost_LIBRARIES}") + else() + message (FATAL_ERROR "Could not find Boost 1.67!") + endif() - find_package(Boost 1.66 COMPONENTS system thread serialization wserialization regex filesystem unit_test_framework) - if (Boost_FOUND) - include_directories (${Boost_INCLUDE_DIR}) - link_directories (${Boost_LIBRARY_DIR}) - message (STATUS "Found Boost.") - message (STATUS "Include Path: ${Boost_INCLUDE_DIRS}") - message (STATUS "Library Path: ${Boost_LIBRARY_DIRS}") - message (STATUS "Library: ${Boost_LIBRARIES}") - else() - message (FATAL_ERROR "Could not find Boost 1.67!") - endif() + # GoogleTest + include(FetchContent) + find_package(GTest QUIET) + if (NOT GTest_FOUND) + message(STATUS "GTest not found; fetching googletest via FetchContent...") + FetchContent_Declare( + googletest + URL https://github.com/google/googletest/archive/refs/tags/v1.14.0.zip + ) + # For Windows: prevent overriding the parent project's compiler/linker settings + set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) + FetchContent_MakeAvailable(googletest) + endif() include_directories(${PROJECT_SOURCE_DIR}/AnnService ${PROJECT_SOURCE_DIR}/Test ${PROJECT_SOURCE_DIR}/ThirdParty/spdk/build/include) file(GLOB TEST_HDR_FILES ${PROJECT_SOURCE_DIR}/Test/inc/Test.h) file(GLOB TEST_SRC_FILES ${PROJECT_SOURCE_DIR}/Test/src/*.cpp) add_executable(SPTAGTest ${TEST_SRC_FILES} ${TEST_HDR_FILES}) - target_link_libraries(SPTAGTest SPTAGLibStatic ssdservingLib ${Boost_LIBRARIES}) + target_link_libraries(SPTAGTest PRIVATE SPTAGLibStatic ssdservingLib ${Boost_LIBRARIES} GTest::gtest GTest::gtest_main) install(TARGETS SPTAGTest RUNTIME DESTINATION bin diff --git a/Test/cuda/cuda_tests.cpp b/Test/cuda/cuda_tests.cpp index 50b186462..06e43784b 100644 --- a/Test/cuda/cuda_tests.cpp +++ b/Test/cuda/cuda_tests.cpp @@ -1,43 +1,41 @@ //#include "test_kernels.cu" -#define BOOST_TEST_MODULE GPU - #include #include #include -#include +#include "inc/Test.h" #include int GPUBuildKNNTest(); -BOOST_AUTO_TEST_CASE(RandomTests) { - BOOST_CHECK(1 == 1); +TEST(GPUTest, RandomTests) { + EXPECT_EQ(1, 1); int errors = GPUBuildKNNTest(); -printf("outside\n"); - BOOST_CHECK(errors == 0); + printf("outside\n"); + EXPECT_EQ(errors, 0); } /* int GPUTestDistance_All(); -BOOST_AUTO_TEST_CASE(DistanceTests) { +// TEST(GPUTest, DistanceTests) { int errs = GPUTestDistance_All(); - BOOST_CHECK(errs == 0); -} + EXPECT_EQ(errs, 0); +// } int GPUBuildTPTTest(); -BOOST_AUTO_TEST_CASE(TPTreeTests) { +// TEST(GPUTest, TPTreeTests) { int errs = GPUBuildTPTTest(); - BOOST_CHECK(errs == 0); -} + EXPECT_EQ(errs, 0); +// } int GPUBuildSSDTest_All(); -BOOST_AUTO_TEST_CASE(BuildSSDTests) { +// TEST(GPUTest, BuildSSDTests) { int errs = GPUBuildSSDTest_All(); - BOOST_CHECK(errs == 0); -} + EXPECT_EQ(errs, 0); +// } */ diff --git a/Test/cuda/pq_perf.cpp b/Test/cuda/pq_perf.cpp index b6cc1e289..0e15be46c 100644 --- a/Test/cuda/pq_perf.cpp +++ b/Test/cuda/pq_perf.cpp @@ -3,10 +3,8 @@ //#include "../inc/Test.h" -#define BOOST_TEST_MODULE GPU - #include -#include +#include "inc/Test.h" #include #include @@ -79,8 +77,8 @@ template std::shared_ptr PerfBuild(IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr& vec, std::shared_ptr& meta, std::shared_ptr& queryset, int k, std::shared_ptr& truth, std::string out, std::shared_ptr quantizer) { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - vecIndex->SetQuantizer(quantizer); - BOOST_CHECK(nullptr != vecIndex); + vecIndex->SetQuantizer(quantizer); + ASSERT_NE(nullptr, vecIndex); if (algo == IndexAlgoType::KDT) vecIndex->SetParameter("KDTNumber", "2"); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -89,8 +87,8 @@ std::shared_ptr PerfBuild(IndexAlgoType algo, std::string distCalcM vecIndex->SetParameter("MaxCheck", "4096"); vecIndex->SetParameter("MaxCheckForRefineGraph", "8192"); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta, true)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->BuildIndex(vec, meta, true)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); //Search(vecIndex, queryset, k, truth); return vecIndex; } @@ -177,11 +175,11 @@ void GenerateReconstructData(std::shared_ptr& real_vecset, std::share if (fileexists(CODEBOOK_FILE.c_str()) && fileexists("quantest_quan_vector.bin") && fileexists("quantest_rec_vector.bin")) { auto ptr = SPTAG::f_createIO(); - if (ptr == nullptr || !ptr->Initialize(CODEBOOK_FILE.c_str(), std::ios::binary | std::ios::in)) { - BOOST_ASSERT("Canot Open CODEBOOK_FILE to read!" == "Error"); - } - quantizer->LoadIQuantizer(ptr); - BOOST_ASSERT(quantizer); + if (ptr == nullptr || !ptr->Initialize(CODEBOOK_FILE.c_str(), std::ios::binary | std::ios::in)) { + GTEST_FAIL() << "Cannot open CODEBOOK_FILE to read!"; + } + quantizer->LoadIQuantizer(ptr); + ASSERT_TRUE(quantizer != nullptr); std::shared_ptr options(new Helper::ReaderOptions(GetEnumValueType(), m, VectorFileType::DEFAULT)); auto vectorReader = Helper::VectorSetReader::CreateInstance(options); @@ -255,17 +253,17 @@ void GenerateReconstructData(std::shared_ptr& real_vecset, std::share printf("After built, pq type:%d\n", (int)quantizer->GetQuantizerType()); auto ptr = SPTAG::f_createIO(); - if (ptr == nullptr || !ptr->Initialize(CODEBOOK_FILE.c_str(), std::ios::binary | std::ios::out)) { - BOOST_ASSERT("Canot Open CODEBOOK_FILE to write!" == "Error"); - } + if (ptr == nullptr || !ptr->Initialize(CODEBOOK_FILE.c_str(), std::ios::binary | std::ios::out)) { + GTEST_FAIL() << "Cannot open CODEBOOK_FILE to write!"; + } // quantizer->SaveQuantizer(ptr); ptr->ShutDown(); - if (!ptr->Initialize(CODEBOOK_FILE.c_str(), std::ios::binary | std::ios::in)) { - BOOST_ASSERT("Canot Open CODEBOOK_FILE to read!" == "Error"); - } - quantizer->LoadIQuantizer(ptr); - BOOST_ASSERT(quantizer); + if (!ptr->Initialize(CODEBOOK_FILE.c_str(), std::ios::binary | std::ios::in)) { + GTEST_FAIL() << "Cannot open CODEBOOK_FILE to read!"; + } + quantizer->LoadIQuantizer(ptr); + ASSERT_TRUE(quantizer != nullptr); rec_vecset.reset(new BasicVectorSet(ByteArray::Alloc(sizeof(R) * n * m), GetEnumValueType(), m, n)); quan_vecset.reset(new BasicVectorSet(ByteArray::Alloc(sizeof(std::uint8_t) * n * M), GetEnumValueType(), M, n)); @@ -579,9 +577,9 @@ void DistancePerfRandomized(IndexAlgoType algo, DistCalcMethod distMethod) } -BOOST_AUTO_TEST_SUITE(GPUPQPerfTest) +namespace GPUPQPerfTestSuite { -BOOST_AUTO_TEST_CASE(GPUPQCosineTest) +TEST(GPUPQPerfTest, GPUPQCosineTest) { DistancePerfSuite(IndexAlgoType::BKT, DistCalcMethod::L2); @@ -590,4 +588,4 @@ BOOST_AUTO_TEST_CASE(GPUPQCosineTest) } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/inc/Test.h b/Test/inc/Test.h index da6c096ba..f9a5ea9be 100644 --- a/Test/inc/Test.h +++ b/Test/inc/Test.h @@ -4,4 +4,4 @@ #pragma once #include -#include +#include diff --git a/Test/src/AlgoTest.cpp b/Test/src/AlgoTest.cpp index ad7f40d54..7ff0c0a68 100644 --- a/Test/src/AlgoTest.cpp +++ b/Test/src/AlgoTest.cpp @@ -14,7 +14,7 @@ void Build(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_pt { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); if (algo != SPTAG::IndexAlgoType::SPANN) { vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -41,8 +41,8 @@ void Build(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_pt vecIndex->SetParameter("SearchInternalResultNum", "64", "BuildSSDIndex"); } - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->BuildIndex(vec, meta)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); } template @@ -50,7 +50,7 @@ void BuildWithMetaMapping(SPTAG::IndexAlgoType algo, std::string distCalcMethod, { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); if (algo != SPTAG::IndexAlgoType::SPANN) { vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -77,16 +77,16 @@ void BuildWithMetaMapping(SPTAG::IndexAlgoType algo, std::string distCalcMethod, vecIndex->SetParameter("SearchInternalResultNum", "64", "BuildSSDIndex"); } - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta, true)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->BuildIndex(vec, meta, true)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); } template void Search(const std::string folder, T* vec, SPTAG::SizeType n, int k, std::string* truthmeta) { std::shared_ptr vecIndex; - BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); + ASSERT_NE(nullptr, vecIndex); for (SPTAG::SizeType i = 0; i < n; i++) { @@ -101,7 +101,7 @@ void Search(const std::string folder, T* vec, SPTAG::SizeType n, int k, std::str std::cout << std::endl; for (int j = 0; j < k; j++) { - BOOST_CHECK(resmeta.find(truthmeta[i * k + j]) != resmeta.end()); + EXPECT_NE(resmeta.end(), resmeta.find(truthmeta[i * k + j])); } vec += vecIndex->GetFeatureDim(); } @@ -112,11 +112,11 @@ template void Add(const std::string folder, std::shared_ptr& vec, std::shared_ptr& meta, const std::string out) { std::shared_ptr vecIndex; - BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); + ASSERT_NE(nullptr, vecIndex); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->AddIndex(vec, meta)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->AddIndex(vec, meta)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); vecIndex.reset(); } @@ -124,7 +124,7 @@ template void AddOneByOne(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr& vec, std::shared_ptr& meta, const std::string out) { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); vecIndex->SetParameter("NumberOfThreads", "16"); @@ -142,23 +142,23 @@ void AddOneByOne(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::sha Sleep(10000); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); } template void Delete(const std::string folder, T* vec, SPTAG::SizeType n, const std::string out) { std::shared_ptr vecIndex; - BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); + ASSERT_NE(nullptr, vecIndex); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->DeleteIndex((const void*)vec, n)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->DeleteIndex((const void*)vec, n)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); vecIndex.reset(); } template -void Test(SPTAG::IndexAlgoType algo, std::string distCalcMethod) +void RunTest(SPTAG::IndexAlgoType algo, std::string distCalcMethod) { SPTAG::SizeType n = 2000, q = 3; SPTAG::DimensionType m = 10; @@ -225,21 +225,18 @@ void Test(SPTAG::IndexAlgoType algo, std::string distCalcMethod) } } -BOOST_AUTO_TEST_SUITE (AlgoTest) +namespace AlgoTest { -BOOST_AUTO_TEST_CASE(KDTTest) -{ - Test(SPTAG::IndexAlgoType::KDT, "L2"); +TEST(AlgoTest, KDTTest) { + RunTest(SPTAG::IndexAlgoType::KDT, "L2"); } -BOOST_AUTO_TEST_CASE(BKTTest) -{ - Test(SPTAG::IndexAlgoType::BKT, "L2"); +TEST(AlgoTest, BKTTest) { + RunTest(SPTAG::IndexAlgoType::BKT, "L2"); } -BOOST_AUTO_TEST_CASE(SPANNTest) -{ - Test(SPTAG::IndexAlgoType::SPANN, "L2"); +TEST(AlgoTest, SPANNTest) { + RunTest(SPTAG::IndexAlgoType::SPANN, "L2"); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/Base64HelperTest.cpp b/Test/src/Base64HelperTest.cpp index 2ead4753e..8f1f9ecd1 100644 --- a/Test/src/Base64HelperTest.cpp +++ b/Test/src/Base64HelperTest.cpp @@ -6,10 +6,9 @@ #include -BOOST_AUTO_TEST_SUITE(Base64Test) +namespace Base64Test { -BOOST_AUTO_TEST_CASE(Base64EncDec) -{ +TEST(Base64Test, Base64EncDec) { using namespace SPTAG::Helper::Base64; const size_t bufferSize = 1 << 10; @@ -25,19 +24,19 @@ BOOST_AUTO_TEST_CASE(Base64EncDec) } size_t encBufLen = CapacityForEncode(inputSize); - BOOST_CHECK(encBufLen < bufferSize); + EXPECT_LT(encBufLen, bufferSize); size_t encOutLen = 0; - BOOST_CHECK(Encode(rawBuffer.get(), inputSize, encBuffer.get(), encOutLen)); - BOOST_CHECK(encBufLen >= encOutLen); + EXPECT_TRUE(Encode(rawBuffer.get(), inputSize, encBuffer.get(), encOutLen)); + EXPECT_GE(encBufLen, encOutLen); size_t decBufLen = CapacityForDecode(encOutLen); - BOOST_CHECK(decBufLen < bufferSize); + EXPECT_LT(decBufLen, bufferSize); size_t decOutLen = 0; - BOOST_CHECK(Decode(encBuffer.get(), encOutLen, rawBuffer.get(), decOutLen)); - BOOST_CHECK(decBufLen >= decOutLen); + EXPECT_TRUE(Decode(encBuffer.get(), encOutLen, rawBuffer.get(), decOutLen)); + EXPECT_GE(decBufLen, decOutLen); } } -BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file +} \ No newline at end of file diff --git a/Test/src/CommonHelperTest.cpp b/Test/src/CommonHelperTest.cpp index 17015642c..978d48fb7 100644 --- a/Test/src/CommonHelperTest.cpp +++ b/Test/src/CommonHelperTest.cpp @@ -6,15 +6,14 @@ #include -BOOST_AUTO_TEST_SUITE(CommonHelperTest) +namespace CommonHelperTest { -BOOST_AUTO_TEST_CASE(ToLowerInPlaceTest) -{ +TEST(CommonHelperTest, ToLowerInPlaceTest) { auto runTestCase = [](std::string p_input, const std::string& p_expected) { SPTAG::Helper::StrUtils::ToLowerInPlace(p_input); - BOOST_CHECK(p_input == p_expected); + EXPECT_EQ(p_input, p_expected); }; runTestCase("abc", "abc"); @@ -25,21 +24,19 @@ BOOST_AUTO_TEST_CASE(ToLowerInPlaceTest) } -BOOST_AUTO_TEST_CASE(SplitStringTest) -{ +TEST(CommonHelperTest, SplitStringTest) { std::string input("seg1 seg2 seg3 seg4"); const auto& segs = SPTAG::Helper::StrUtils::SplitString(input, " "); - BOOST_CHECK(segs.size() == 4); - BOOST_CHECK(segs[0] == "seg1"); - BOOST_CHECK(segs[1] == "seg2"); - BOOST_CHECK(segs[2] == "seg3"); - BOOST_CHECK(segs[3] == "seg4"); + EXPECT_EQ(segs.size(), 4u); + EXPECT_EQ(segs[0], "seg1"); + EXPECT_EQ(segs[1], "seg2"); + EXPECT_EQ(segs[2], "seg3"); + EXPECT_EQ(segs[3], "seg4"); } -BOOST_AUTO_TEST_CASE(FindTrimmedSegmentTest) -{ +TEST(CommonHelperTest, FindTrimmedSegmentTest) { using namespace SPTAG::Helper::StrUtils; std::string input("\t Space End \r\n\t"); @@ -50,44 +47,40 @@ BOOST_AUTO_TEST_CASE(FindTrimmedSegmentTest) return std::isspace(p_val) > 0; }); - BOOST_CHECK(pos.first == input.c_str() + 2); - BOOST_CHECK(pos.second == input.c_str() + 13); + EXPECT_EQ(pos.first, input.c_str() + 2); + EXPECT_EQ(pos.second, input.c_str() + 13); } -BOOST_AUTO_TEST_CASE(StartsWithTest) -{ +TEST(CommonHelperTest, StartsWithTest) { using namespace SPTAG::Helper::StrUtils; - BOOST_CHECK(StartsWith("Abcd", "A")); - BOOST_CHECK(StartsWith("Abcd", "Ab")); - BOOST_CHECK(StartsWith("Abcd", "Abc")); - BOOST_CHECK(StartsWith("Abcd", "Abcd")); - - BOOST_CHECK(!StartsWith("Abcd", "a")); - BOOST_CHECK(!StartsWith("Abcd", "F")); - BOOST_CHECK(!StartsWith("Abcd", "AF")); - BOOST_CHECK(!StartsWith("Abcd", "AbF")); - BOOST_CHECK(!StartsWith("Abcd", "AbcF")); - BOOST_CHECK(!StartsWith("Abcd", "Abcde")); + EXPECT_TRUE(StartsWith("Abcd", "A")); + EXPECT_TRUE(StartsWith("Abcd", "Ab")); + EXPECT_TRUE(StartsWith("Abcd", "Abc")); + EXPECT_TRUE(StartsWith("Abcd", "Abcd")); + + EXPECT_FALSE(StartsWith("Abcd", "a")); + EXPECT_FALSE(StartsWith("Abcd", "F")); + EXPECT_FALSE(StartsWith("Abcd", "AF")); + EXPECT_FALSE(StartsWith("Abcd", "AbF")); + EXPECT_FALSE(StartsWith("Abcd", "AbcF")); + EXPECT_FALSE(StartsWith("Abcd", "Abcde")); } -BOOST_AUTO_TEST_CASE(StrEqualIgnoreCaseTest) -{ +TEST(CommonHelperTest, StrEqualIgnoreCaseTest) { using namespace SPTAG::Helper::StrUtils; - BOOST_CHECK(StrEqualIgnoreCase("Abcd", "Abcd")); - BOOST_CHECK(StrEqualIgnoreCase("Abcd", "abcd")); - BOOST_CHECK(StrEqualIgnoreCase("Abcd", "abCD")); - BOOST_CHECK(StrEqualIgnoreCase("Abcd-123", "abcd-123")); - BOOST_CHECK(StrEqualIgnoreCase(" ZZZ", " zzz")); + EXPECT_TRUE(StrEqualIgnoreCase("Abcd", "Abcd")); + EXPECT_TRUE(StrEqualIgnoreCase("Abcd", "abcd")); + EXPECT_TRUE(StrEqualIgnoreCase("Abcd", "abCD")); + EXPECT_TRUE(StrEqualIgnoreCase("Abcd-123", "abcd-123")); + EXPECT_TRUE(StrEqualIgnoreCase(" ZZZ", " zzz")); - BOOST_CHECK(!StrEqualIgnoreCase("abcd", "abcd1")); - BOOST_CHECK(!StrEqualIgnoreCase("Abcd", " abcd")); - BOOST_CHECK(!StrEqualIgnoreCase("000", "OOO")); + EXPECT_FALSE(StrEqualIgnoreCase("abcd", "abcd1")); + EXPECT_FALSE(StrEqualIgnoreCase("Abcd", " abcd")); + EXPECT_FALSE(StrEqualIgnoreCase("000", "OOO")); } - - -BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file +} \ No newline at end of file diff --git a/Test/src/ConcurrentTest.cpp b/Test/src/ConcurrentTest.cpp index 0e742e96f..3ab087a85 100644 --- a/Test/src/ConcurrentTest.cpp +++ b/Test/src/ConcurrentTest.cpp @@ -14,7 +14,7 @@ template void ConcurrentAddSearchSave(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr& vec, std::shared_ptr& meta, const std::string out) { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); vecIndex->SetParameter("NumberOfThreads", "16"); @@ -122,16 +122,14 @@ void CTest(SPTAG::IndexAlgoType algo, std::string distCalcMethod) ConcurrentAddSearchSave(algo, distCalcMethod, vecset, metaset, "testindices"); } -BOOST_AUTO_TEST_SUITE(ConcurrentTest) +namespace ConcurrentTest { -BOOST_AUTO_TEST_CASE(BKTTest) -{ +TEST(ConcurrentTest, BKTTest) { CTest(SPTAG::IndexAlgoType::BKT, "L2"); } -BOOST_AUTO_TEST_CASE(KDTTest) -{ +TEST(ConcurrentTest, KDTTest) { CTest(SPTAG::IndexAlgoType::KDT, "L2"); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/DistanceTest.cpp b/Test/src/DistanceTest.cpp index 872fb01fe..3509f7fcd 100644 --- a/Test/src/DistanceTest.cpp +++ b/Test/src/DistanceTest.cpp @@ -37,13 +37,13 @@ template void test(int high) { SPTAG::DimensionType dimension = random(256, 2); T *X = new T[dimension], *Y = new T[dimension]; - BOOST_ASSERT(X != nullptr && Y != nullptr); + ASSERT_TRUE(X != nullptr && Y != nullptr); for (SPTAG::DimensionType i = 0; i < dimension; i++) { X[i] = random(high, -high); Y[i] = random(high, -high); } - BOOST_CHECK_CLOSE_FRACTION(ComputeL2Distance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::L2), 1e-5); - BOOST_CHECK_CLOSE_FRACTION(high * high - ComputeCosineDistance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::Cosine), 1e-5); + EXPECT_NEAR(ComputeL2Distance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::L2), 1e-5); + EXPECT_NEAR(high * high - ComputeCosineDistance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::Cosine), 1e-5); delete[] X; delete[] Y; @@ -83,17 +83,15 @@ void test_dist_calc_performance( delete[] Y; } -BOOST_AUTO_TEST_SUITE(DistanceTest) +namespace DistanceTest { -BOOST_AUTO_TEST_CASE(TestDistanceComputation) -{ +TEST(DistanceTest, TestDistanceComputation) { test(1); test(127); test(32767); } -BOOST_AUTO_TEST_CASE(TestDistanceComputationPerformance) -{ +TEST(DistanceTest, TestDistanceComputationPerformance) { std::vector dimensions{128, 256, 512, 1024}; std::vector nums_threads{1, 16, 40}; std::vector calc_methods{SPTAG::DistCalcMethod::L2, SPTAG::DistCalcMethod::Cosine}; @@ -115,4 +113,4 @@ BOOST_AUTO_TEST_CASE(TestDistanceComputationPerformance) } } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/FilterTest.cpp b/Test/src/FilterTest.cpp index 37aae674b..cc0727519 100644 --- a/Test/src/FilterTest.cpp +++ b/Test/src/FilterTest.cpp @@ -14,13 +14,13 @@ void BuildWithMetaMapping(SPTAG::IndexAlgoType algo, std::string distCalcMethod, { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); vecIndex->SetParameter("NumberOfThreads", "16"); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta, true)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->BuildIndex(vec, meta, true)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); } template @@ -28,8 +28,8 @@ void SearchWithFilter(const std::string folder, T* vec, SPTAG::SizeType n, int k { std::cout << "start search with filter" << std::endl; std::shared_ptr vecIndex; - BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); + ASSERT_NE(nullptr, vecIndex); std::string value = "2"; std::function filterFunction = [value](const SPTAG::ByteArray& meta) -> bool { std::string metaValue((char*)meta.Data(), meta.Length()); @@ -49,7 +49,7 @@ void SearchWithFilter(const std::string folder, T* vec, SPTAG::SizeType n, int k std::cout << std::endl; for (int j = 0; j < k; j++) { - BOOST_CHECK(resmeta.find("2") == resmeta.end()); + EXPECT_EQ(resmeta.end(), resmeta.find("2")); } vec += vecIndex->GetFeatureDim(); } @@ -101,11 +101,10 @@ void FTest(SPTAG::IndexAlgoType algo, std::string distCalcMethod) } -BOOST_AUTO_TEST_SUITE(FilterTest) +namespace FilterTest { -BOOST_AUTO_TEST_CASE(BKTTest) -{ +TEST(FilterTest, BKTTest) { FTest(SPTAG::IndexAlgoType::BKT, "L2"); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/IniReaderTest.cpp b/Test/src/IniReaderTest.cpp index c5dd0baaf..6e4278f21 100644 --- a/Test/src/IniReaderTest.cpp +++ b/Test/src/IniReaderTest.cpp @@ -6,10 +6,9 @@ #include -BOOST_AUTO_TEST_SUITE(IniReaderTest) +namespace IniReaderTest { -BOOST_AUTO_TEST_CASE(IniReaderLoadTest) -{ +TEST(IniReaderTest, IniReaderLoadTest) { std::ofstream tmpIni("temp.ini"); tmpIni << "[Common]" << std::endl; tmpIni << "; Comment " << std::endl; @@ -19,22 +18,21 @@ BOOST_AUTO_TEST_CASE(IniReaderLoadTest) tmpIni.close(); SPTAG::Helper::IniReader reader; - BOOST_CHECK(SPTAG::ErrorCode::Success == reader.LoadIniFile("temp.ini")); + ASSERT_EQ(SPTAG::ErrorCode::Success, reader.LoadIniFile("temp.ini")); - BOOST_CHECK(reader.DoesSectionExist("Common")); - BOOST_CHECK(reader.DoesParameterExist("Common", "Param1")); - BOOST_CHECK(reader.DoesParameterExist("Common", "Param2")); + EXPECT_TRUE(reader.DoesSectionExist("Common")); + EXPECT_TRUE(reader.DoesParameterExist("Common", "Param1")); + EXPECT_TRUE(reader.DoesParameterExist("Common", "Param2")); - BOOST_CHECK(!reader.DoesSectionExist("NotExist")); - BOOST_CHECK(!reader.DoesParameterExist("NotExist", "Param1")); - BOOST_CHECK(!reader.DoesParameterExist("Common", "ParamNotExist")); + EXPECT_FALSE(reader.DoesSectionExist("NotExist")); + EXPECT_FALSE(reader.DoesParameterExist("NotExist", "Param1")); + EXPECT_FALSE(reader.DoesParameterExist("Common", "ParamNotExist")); - BOOST_CHECK(1 == reader.GetParameter("Common", "Param1", 0)); - BOOST_CHECK(0 == reader.GetParameter("Common", "ParamNotExist", 0)); + EXPECT_EQ(1, reader.GetParameter("Common", "Param1", 0)); + EXPECT_EQ(0, reader.GetParameter("Common", "ParamNotExist", 0)); - BOOST_CHECK(std::string("Exp=2") == reader.GetParameter("Common", "Param2", std::string())); - BOOST_CHECK(std::string("1") == reader.GetParameter("Common", "Param1", std::string())); - BOOST_CHECK(std::string() == reader.GetParameter("Common", "ParamNotExist", std::string())); + EXPECT_EQ(std::string("Exp=2"), reader.GetParameter("Common", "Param2", std::string())); + EXPECT_EQ(std::string("1"), reader.GetParameter("Common", "Param1", std::string())); + EXPECT_EQ(std::string(), reader.GetParameter("Common", "ParamNotExist", std::string())); } - -BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file +} \ No newline at end of file diff --git a/Test/src/IterativeScanTest.cpp b/Test/src/IterativeScanTest.cpp index d4ee5bf29..e143d36a0 100644 --- a/Test/src/IterativeScanTest.cpp +++ b/Test/src/IterativeScanTest.cpp @@ -15,13 +15,13 @@ void BuildIndex(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shar { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); vecIndex->SetParameter("NumberOfThreads", "16"); vecIndex->SetParameter("MaxCheck", "5"); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->BuildIndex(vec, meta)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); } template @@ -29,8 +29,8 @@ void SearchIterativeBatch(const std::string folder, T* vec, SPTAG::SizeType n, s { std::shared_ptr vecIndex; - BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); + ASSERT_NE(nullptr, vecIndex); std::shared_ptr resultIterator = vecIndex->GetIterator(vec); //std::cout << "relaxedMono:" << resultIterator->GetRelaxedMono() << std::endl; @@ -40,11 +40,11 @@ void SearchIterativeBatch(const std::string folder, T* vec, SPTAG::SizeType n, s auto results = resultIterator->Next(batch); int resultCount = results->GetResultNum(); if (resultCount <= 0) break; - BOOST_CHECK(resultCount == batch); + ASSERT_EQ(resultCount, batch); for (int j = 0; j < resultCount; j++) { - BOOST_CHECK(std::string((char*)((results->GetMetadata(j)).Data()), (results->GetMetadata(j)).Length()) == truthmeta[ri]); - BOOST_CHECK(results->GetResult(j)->RelaxedMono == true); + EXPECT_EQ(std::string((char*)((results->GetMetadata(j)).Data()), (results->GetMetadata(j)).Length()), truthmeta[ri]); + EXPECT_TRUE(results->GetResult(j)->RelaxedMono == true); std::cout << "Result[" << ri << "] VID:" << results->GetResult(j)->VID << " Dist:" << results->GetResult(j)->Dist << " RelaxedMono:" << results->GetResult(j)->RelaxedMono << std::endl; ri++; @@ -96,11 +96,10 @@ void TestIterativeScan(SPTAG::IndexAlgoType algo, std::string distCalcMethod) SearchIterativeBatch("testindices", query.data(), q, truthmeta1); } -BOOST_AUTO_TEST_SUITE(IterativeScanTest) +namespace IterativeScanTest { -BOOST_AUTO_TEST_CASE(BKTTest) -{ +TEST(IterativeScanTest, BKTTest) { TestIterativeScan(SPTAG::IndexAlgoType::BKT, "L2"); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/KVTest.cpp b/Test/src/KVTest.cpp index 6dc501e6c..67092a7e2 100644 --- a/Test/src/KVTest.cpp +++ b/Test/src/KVTest.cpp @@ -44,7 +44,7 @@ void Search(std::shared_ptr db, int internalResultNum, int t } -void Test(std::string path, std::string type, bool debug = false) +void RunTest(std::string path, std::string type, bool debug = false) { int internalResultNum = 64; int totalNum = 1024; @@ -112,25 +112,22 @@ void Test(std::string path, std::string type, bool debug = false) // } } -BOOST_AUTO_TEST_SUITE(KVTest) +namespace KVTest { -BOOST_AUTO_TEST_CASE(RocksDBTest) -{ +TEST(KVTest, RocksDBTest) { if(!direxists("tmp_rocksdb")) mkdir("tmp_rocksdb"); - Test(std::string("tmp_rocksdb") + FolderSep + "test", "RocksDB", false); + RunTest(std::string("tmp_rocksdb") + FolderSep + "test", "RocksDB", false); } -BOOST_AUTO_TEST_CASE(SPDKTest) -{ +TEST(KVTest, SPDKTest) { if(!direxists("tmp_spdk")) mkdir("tmp_spdk"); - Test(std::string("tmp_spdk") + FolderSep + "test", "SPDK", false); + RunTest(std::string("tmp_spdk") + FolderSep + "test", "SPDK", false); } -BOOST_AUTO_TEST_CASE(FileTest) -{ +TEST(KVTest, FileTest) { if(!direxists("tmp_file")) mkdir("tmp_file"); - Test(std::string("tmp_file") + FolderSep + "test", "File", false); + RunTest(std::string("tmp_file") + FolderSep + "test", "File", false); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/MultiIndexExperiment.cpp b/Test/src/MultiIndexExperiment.cpp index 0fcfd8da7..4ca121094 100644 --- a/Test/src/MultiIndexExperiment.cpp +++ b/Test/src/MultiIndexExperiment.cpp @@ -40,13 +40,13 @@ void BuildIndex(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shar { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); vecIndex->SetParameter("NumberOfThreads", "16"); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->BuildIndex(vec, meta)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); } float sumFunc(std::vector in){ @@ -184,8 +184,8 @@ void TestMultiIndexScanN(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::vector p_targets; for ( unsigned int i = 0; i < n; i++ ) { std::shared_ptr vecIndex; - BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(indexName(i).c_str(), vecIndex)); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(indexName(i).c_str(), vecIndex)); + ASSERT_NE(nullptr, vecIndex); vecIndices.push_back(vecIndex); p_targets.push_back(query_current[i].data()); } @@ -220,11 +220,10 @@ void TestMultiIndexScanN(SPTAG::IndexAlgoType algo, std::string distCalcMethod, } } -BOOST_AUTO_TEST_SUITE(MultiIndexExperiment) +namespace MultiIndexExperimentTest { -BOOST_AUTO_TEST_CASE(BKTTest) -{ +TEST(MultiIndexExperiment, BKTTest) { TestMultiIndexScanN(SPTAG::IndexAlgoType::BKT, "InnerProduct", 2); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/MultiIndexScanTest.cpp b/Test/src/MultiIndexScanTest.cpp index 7077617b4..a2aa07c04 100644 --- a/Test/src/MultiIndexScanTest.cpp +++ b/Test/src/MultiIndexScanTest.cpp @@ -19,13 +19,13 @@ void BuildIndex(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shar { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); vecIndex->SetParameter("NumberOfThreads", "16"); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->BuildIndex(vec, meta)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); } float rankFunc(std::vector in){ @@ -40,8 +40,8 @@ void MultiIndexSearch(unsigned int n, std::vector> &queries, int std::vector p_targets; for ( unsigned int i = 0; i < n; i++ ) { std::shared_ptr vecIndex; - BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(indexName(i).c_str(), vecIndex)); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(indexName(i).c_str(), vecIndex)); + ASSERT_NE(nullptr, vecIndex); vecIndices.push_back(vecIndex); p_targets.push_back(queries[i].data()); } @@ -114,11 +114,10 @@ void TestMultiIndexScanN(SPTAG::IndexAlgoType algo, std::string distCalcMethod, } -BOOST_AUTO_TEST_SUITE(MultiIndexScanTest) +namespace MultiIndexScanTest { -BOOST_AUTO_TEST_CASE(BKTTest) -{ +TEST(MultiIndexScanTest, BKTTest) { TestMultiIndexScanN(SPTAG::IndexAlgoType::BKT, "L2", 2); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/PerfTest.cpp b/Test/src/PerfTest.cpp index 7b296e4d1..89e116288 100644 --- a/Test/src/PerfTest.cpp +++ b/Test/src/PerfTest.cpp @@ -53,7 +53,7 @@ template void PerfAdd(IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr& vec, std::shared_ptr& meta, std::shared_ptr& queryset, int k, std::shared_ptr& truth, std::string out) { std::shared_ptr vecIndex = VectorIndex::CreateInstance(algo, GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); if (algo == IndexAlgoType::KDT) vecIndex->SetParameter("KDTNumber", "2"); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -78,9 +78,9 @@ void PerfAdd(IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr(vecIndex, queryset, k, truth); - BOOST_CHECK(ErrorCode::Success == vecIndex->SaveIndex(out)); - BOOST_CHECK(ErrorCode::Success == VectorIndex::LoadIndex(out, vecIndex)); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_EQ(ErrorCode::Success, vecIndex->SaveIndex(out)); + ASSERT_EQ(ErrorCode::Success, VectorIndex::LoadIndex(out, vecIndex)); + ASSERT_NE(nullptr, vecIndex); Search(vecIndex, queryset, k, truth); } @@ -88,7 +88,7 @@ template void PerfBuild(IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr& vec, std::shared_ptr& meta, std::shared_ptr& queryset, int k, std::shared_ptr& truth, std::string out) { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_NE(nullptr, vecIndex); if (algo == IndexAlgoType::KDT) vecIndex->SetParameter("KDTNumber", "2"); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -97,8 +97,8 @@ void PerfBuild(IndexAlgoType algo, std::string distCalcMethod, std::shared_ptrSetParameter("MaxCheck", "4096"); vecIndex->SetParameter("MaxCheckForRefineGraph", "8192"); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta, true)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->BuildIndex(vec, meta, true)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); Search(vecIndex, queryset, k, truth); } @@ -211,21 +211,19 @@ void PTest(IndexAlgoType algo, std::string distCalcMethod) PerfAdd(algo, distCalcMethod, vecset, metaset, queryset, 10, truth, "testindices"); PerfBuild(algo, distCalcMethod, vecset, metaset, queryset, 10, truth, "testindices"); std::shared_ptr vecIndex; - BOOST_CHECK(ErrorCode::Success == VectorIndex::LoadIndex("testindices", vecIndex)); - BOOST_CHECK(nullptr != vecIndex); + ASSERT_EQ(ErrorCode::Success, VectorIndex::LoadIndex("testindices", vecIndex)); + ASSERT_NE(nullptr, vecIndex); Search(vecIndex, queryset, 10, truth); } -BOOST_AUTO_TEST_SUITE(PerfTest) +namespace PerfTest { -BOOST_AUTO_TEST_CASE(BKTTest) -{ +TEST(PerfTest, BKTTest) { PTest(IndexAlgoType::BKT, "Cosine"); } -BOOST_AUTO_TEST_CASE(KDTTest) -{ +TEST(PerfTest, KDTTest) { PTest(IndexAlgoType::KDT, "Cosine"); } -BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file +} \ No newline at end of file diff --git a/Test/src/ReconstructIndexSimilarityTest.cpp b/Test/src/ReconstructIndexSimilarityTest.cpp index 88a2f4563..14f5a3c08 100644 --- a/Test/src/ReconstructIndexSimilarityTest.cpp +++ b/Test/src/ReconstructIndexSimilarityTest.cpp @@ -67,7 +67,7 @@ std::shared_ptr PerfBuild(IndexAlgoType algo, std::string distCalcM { std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); vecIndex->SetQuantizer(quantizer); - BOOST_CHECK(nullptr != vecIndex); + EXPECT_NE(nullptr, vecIndex); if (algo != SPTAG::IndexAlgoType::SPANN) { if (algo == IndexAlgoType::KDT) vecIndex->SetParameter("KDTNumber", "2"); @@ -103,8 +103,8 @@ std::shared_ptr PerfBuild(IndexAlgoType algo, std::string distCalcM vecIndex->SetParameter("SearchInternalResultNum", "64", "BuildSSDIndex"); } - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta, true)); - BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out)); + EXPECT_EQ(SPTAG::ErrorCode::Success, vecIndex->BuildIndex(vec, meta, true)); + EXPECT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); //Search(vecIndex, queryset, k, truth); return vecIndex; } @@ -191,10 +191,10 @@ void GenerateReconstructData(std::shared_ptr& real_vecset, std::share if (fileexists(CODEBOOK_FILE.c_str()) && fileexists("quantest_quan_vector.bin") && fileexists("quantest_rec_vector.bin")) { auto ptr = SPTAG::f_createIO(); if (ptr == nullptr || !ptr->Initialize(CODEBOOK_FILE.c_str(), std::ios::binary | std::ios::in)) { - BOOST_ASSERT("Canot Open CODEBOOK_FILE to read!" == "Error"); + GTEST_FAIL() << "Cannot open CODEBOOK_FILE to read!"; } - quantizer = SPTAG::COMMON::IQuantizer::LoadIQuantizer(ptr); - BOOST_ASSERT(quantizer); + quantizer = SPTAG::COMMON::IQuantizer::LoadIQuantizer(ptr); + ASSERT_TRUE(quantizer != nullptr); std::shared_ptr options(new Helper::ReaderOptions(GetEnumValueType(), m, VectorFileType::DEFAULT)); auto vectorReader = Helper::VectorSetReader::CreateInstance(options); @@ -267,16 +267,16 @@ void GenerateReconstructData(std::shared_ptr& real_vecset, std::share quantizer = std::make_shared>(M, Ks, QuanDim, false, std::move(codebooks)); auto ptr = SPTAG::f_createIO(); if (ptr == nullptr || !ptr->Initialize(CODEBOOK_FILE.c_str(), std::ios::binary | std::ios::out)) { - BOOST_ASSERT("Canot Open CODEBOOK_FILE to write!" == "Error"); + GTEST_FAIL() << "Cannot open CODEBOOK_FILE to write!"; } quantizer->SaveQuantizer(ptr); ptr->ShutDown(); if (!ptr->Initialize(CODEBOOK_FILE.c_str(), std::ios::binary | std::ios::in)) { - BOOST_ASSERT("Canot Open CODEBOOK_FILE to read!" == "Error"); + GTEST_FAIL() << "Cannot open CODEBOOK_FILE to read!"; } - quantizer->LoadIQuantizer(ptr); - BOOST_ASSERT(quantizer); + quantizer->LoadIQuantizer(ptr); + ASSERT_TRUE(quantizer != nullptr); rec_vecset.reset(new BasicVectorSet(ByteArray::Alloc(sizeof(R) * n * m), GetEnumValueType(), m, n)); quan_vecset.reset(new BasicVectorSet(ByteArray::Alloc(sizeof(std::uint8_t) * n * M), GetEnumValueType(), M, n)); @@ -326,27 +326,18 @@ void ReconstructTest(IndexAlgoType algo, DistCalcMethod distMethod) } -BOOST_AUTO_TEST_SUITE(ReconstructIndexSimilarityTest) - -BOOST_AUTO_TEST_CASE(BKTReconstructTest) -{ +namespace ReconstructIndexSimilarityTest { +TEST(ReconstructIndexSimilarityTest, BKTReconstructTest) { ReconstructTest(IndexAlgoType::BKT, DistCalcMethod::L2); - } -BOOST_AUTO_TEST_CASE(KDTReconstructTest) -{ - +TEST(ReconstructIndexSimilarityTest, KDTReconstructTest) { ReconstructTest(IndexAlgoType::KDT, DistCalcMethod::L2); - } -BOOST_AUTO_TEST_CASE(SPANNReconstructTest) -{ - +TEST(ReconstructIndexSimilarityTest, SPANNReconstructTest) { ReconstructTest(IndexAlgoType::SPANN, DistCalcMethod::L2); - } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/SIMDTest.cpp b/Test/src/SIMDTest.cpp index d58f9298b..1fa4840ed 100644 --- a/Test/src/SIMDTest.cpp +++ b/Test/src/SIMDTest.cpp @@ -26,7 +26,7 @@ template void test(int high) { SPTAG::DimensionType dimension = random(256, 2); T *X = new T[dimension], *Y = new T[dimension]; - BOOST_ASSERT(X != nullptr && Y != nullptr); + ASSERT_TRUE(X != nullptr && Y != nullptr); for (SPTAG::DimensionType i = 0; i < dimension; i++) { X[i] = random(high, -high); Y[i] = random(high, -high); @@ -38,7 +38,7 @@ void test(int high) { ComputeSum(X, Y, dimension); SPTAG::COMMON::SIMDUtils::ComputeSum(X_copy, Y, dimension); for (SPTAG::DimensionType i = 0; i < dimension; i++) { - BOOST_CHECK_CLOSE_FRACTION(double(X[i]), double(X_copy[i]), 1e-5); + EXPECT_NEAR(double(X[i]), double(X_copy[i]), 1e-5); } delete[] X; @@ -46,14 +46,13 @@ void test(int high) { delete[] X_copy; } -BOOST_AUTO_TEST_SUITE(SIMDTest) +namespace SIMDTest { -BOOST_AUTO_TEST_CASE(TestDistanceComputation) -{ +TEST(SIMDTest, TestDistanceComputation) { test(1); test(127); test(32767); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/SPFreshTest.cpp b/Test/src/SPFreshTest.cpp index 6a8481a9f..1f1a20401 100644 --- a/Test/src/SPFreshTest.cpp +++ b/Test/src/SPFreshTest.cpp @@ -213,7 +213,7 @@ namespace SPFreshTest { std::uint64_t* offsets = new std::uint64_t[2]{ 0, p_meta.Length() }; std::shared_ptr meta(new SPTAG::MemMetadataSet(p_meta, ByteArray((std::uint8_t*)offsets, 2 * sizeof(std::uint64_t), true), 1)); auto status = p_index->AddIndex(addset->GetVector((SizeType)index), 1, p_opts.m_dim, meta, true); - BOOST_REQUIRE(status == ErrorCode::Success); + ASSERT_EQ(status, ErrorCode::Success); } else { @@ -348,9 +348,9 @@ std::shared_ptr get_embeddings(uint32_t row_id, uint32_t end_id, uint return std::make_shared(vec, GetEnumValueType(), embedding_dim, count); } -BOOST_AUTO_TEST_SUITE(SPFreshTest) +namespace SPFreshTestSuite { -BOOST_AUTO_TEST_CASE(TestLoadAndSave) +TEST(SPFreshTest, TestLoadAndSave) { using namespace SPFreshTest; @@ -362,14 +362,14 @@ BOOST_AUTO_TEST_CASE(TestLoadAndSave) generator.Run(vecset, metaset, queryset, truth, addvecset, addmetaset, addtruth); auto originalIndex = BuildIndex("original_index", vecset, metaset); - BOOST_REQUIRE(originalIndex != nullptr); - BOOST_REQUIRE(originalIndex->SaveIndex("original_index") == ErrorCode::Success); + ASSERT_NE(originalIndex, nullptr); + ASSERT_EQ(originalIndex->SaveIndex("original_index"), ErrorCode::Success); originalIndex = nullptr; std::shared_ptr loadedIndex; - BOOST_REQUIRE(VectorIndex::LoadIndex("original_index", loadedIndex) == ErrorCode::Success); - BOOST_REQUIRE(loadedIndex != nullptr); - BOOST_REQUIRE(loadedIndex->SaveIndex("loaded_and_saved_index") == ErrorCode::Success); + ASSERT_EQ(VectorIndex::LoadIndex("original_index", loadedIndex), ErrorCode::Success); + ASSERT_NE(loadedIndex, nullptr); + ASSERT_EQ(loadedIndex->SaveIndex("loaded_and_saved_index"), ErrorCode::Success); loadedIndex = nullptr; std::unordered_set exceptions = { @@ -377,16 +377,14 @@ BOOST_AUTO_TEST_CASE(TestLoadAndSave) }; // Compare files in both directories - BOOST_REQUIRE_MESSAGE( - CompareDirectoriesWithLogging("original_index", "loaded_and_saved_index", exceptions), - "Saved index does not match loaded-then-saved index" - ); + ASSERT_TRUE(CompareDirectoriesWithLogging("original_index", "loaded_and_saved_index", exceptions)) + << "Saved index does not match loaded-then-saved index"; std::filesystem::remove_all("original_index"); std::filesystem::remove_all("loaded_and_saved_index"); } -BOOST_AUTO_TEST_CASE(TestReopenIndexRecall) +TEST(SPFreshTest, TestReopenIndexRecall) { using namespace SPFreshTest; @@ -397,31 +395,30 @@ BOOST_AUTO_TEST_CASE(TestReopenIndexRecall) generator.Run(vecset, metaset, queryset, truth, addvecset, addmetaset, addtruth); auto originalIndex = BuildIndex("original_index", vecset, metaset); - BOOST_REQUIRE(originalIndex != nullptr); - BOOST_REQUIRE(originalIndex->SaveIndex("original_index") == ErrorCode::Success); + ASSERT_NE(originalIndex, nullptr); + ASSERT_EQ(originalIndex->SaveIndex("original_index"), ErrorCode::Success); float recall1 = Search(originalIndex, queryset, vecset, addvecset, K, truth, N); originalIndex = nullptr; std::shared_ptr loadedOnce; - BOOST_REQUIRE(VectorIndex::LoadIndex("original_index", loadedOnce) == ErrorCode::Success); - BOOST_REQUIRE(loadedOnce != nullptr); - BOOST_REQUIRE(loadedOnce->SaveIndex("reopened_index") == ErrorCode::Success); + ASSERT_EQ(VectorIndex::LoadIndex("original_index", loadedOnce), ErrorCode::Success); + ASSERT_NE(loadedOnce, nullptr); + ASSERT_EQ(loadedOnce->SaveIndex("reopened_index"), ErrorCode::Success); loadedOnce = nullptr; std::shared_ptr loadedTwice; - BOOST_REQUIRE(VectorIndex::LoadIndex("reopened_index", loadedTwice) == ErrorCode::Success); - BOOST_REQUIRE(loadedTwice != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("reopened_index", loadedTwice), ErrorCode::Success); + ASSERT_NE(loadedTwice, nullptr); float recall2 = Search(loadedTwice, queryset, vecset, addvecset, K, truth, N); loadedTwice = nullptr; - BOOST_REQUIRE_MESSAGE(std::fabs(recall1 - recall2) < 1e-5, - "Recall mismatch between original and reopened index"); + ASSERT_LT(std::fabs(recall1 - recall2), 1e-5) << "Recall mismatch between original and reopened index"; std::filesystem::remove_all("original_index"); std::filesystem::remove_all("reopened_index"); } -BOOST_AUTO_TEST_CASE(TestInsertAndSearch) +TEST(SPFreshTest, TestInsertAndSearch) { using namespace SPFreshTest; @@ -434,13 +431,13 @@ BOOST_AUTO_TEST_CASE(TestInsertAndSearch) // Build base index auto index = BuildIndex("insert_test_index", vecset, metaset); - BOOST_REQUIRE(index != nullptr); - BOOST_REQUIRE(index->SaveIndex("insert_test_index") == ErrorCode::Success); + ASSERT_NE(index, nullptr); + ASSERT_EQ(index->SaveIndex("insert_test_index"), ErrorCode::Success); index = nullptr; std::shared_ptr loadedOnce; - BOOST_REQUIRE(VectorIndex::LoadIndex("insert_test_index", loadedOnce) == ErrorCode::Success); - BOOST_REQUIRE(loadedOnce != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("insert_test_index", loadedOnce), ErrorCode::Success); + ASSERT_NE(loadedOnce, nullptr); InsertVectors(static_cast*>(loadedOnce.get()), 2, 1000, addvecset, addmetaset); SearchOnly(loadedOnce, queryset, K); @@ -449,7 +446,7 @@ BOOST_AUTO_TEST_CASE(TestInsertAndSearch) std::filesystem::remove_all("insert_test_index"); } -BOOST_AUTO_TEST_CASE(TestClone) +TEST(SPFreshTest, TestClone) { using namespace SPFreshTest; @@ -461,13 +458,13 @@ BOOST_AUTO_TEST_CASE(TestClone) generator.Run(vecset, metaset, queryset, truth, addvecset, addmetaset, addtruth); auto originalIndex = BuildIndex("original_index", vecset, metaset); - BOOST_REQUIRE(originalIndex != nullptr); - BOOST_REQUIRE(originalIndex->SaveIndex("original_index") == ErrorCode::Success); + ASSERT_NE(originalIndex, nullptr); + ASSERT_EQ(originalIndex->SaveIndex("original_index"), ErrorCode::Success); originalIndex = nullptr; auto clonedIndex = VectorIndex::Clone("original_index", "cloned_index"); - BOOST_REQUIRE(clonedIndex != nullptr); - BOOST_REQUIRE(clonedIndex->SaveIndex("cloned_index") == ErrorCode::Success); + ASSERT_NE(clonedIndex, nullptr); + ASSERT_EQ(clonedIndex->SaveIndex("cloned_index"), ErrorCode::Success); clonedIndex = nullptr; std::unordered_set exceptions = { @@ -475,16 +472,14 @@ BOOST_AUTO_TEST_CASE(TestClone) }; // Compare files in both directories - BOOST_REQUIRE_MESSAGE( - CompareDirectoriesWithLogging("original_index", "cloned_index", exceptions), - "Saved index does not match loaded-then-saved index" - ); + ASSERT_TRUE(CompareDirectoriesWithLogging("original_index", "cloned_index", exceptions)) + << "Saved index does not match loaded-then-saved index"; std::filesystem::remove_all("original_index"); std::filesystem::remove_all("cloned_index"); } -BOOST_AUTO_TEST_CASE(TestCloneRecall) +TEST(SPFreshTest, TestCloneRecall) { using namespace SPFreshTest; @@ -496,30 +491,30 @@ BOOST_AUTO_TEST_CASE(TestCloneRecall) generator.Run(vecset, metaset, queryset, truth, addvecset, addmetaset, addtruth); auto originalIndex = BuildIndex("original_index", vecset, metaset); - BOOST_REQUIRE(originalIndex != nullptr); - BOOST_REQUIRE(originalIndex->SaveIndex("original_index") == ErrorCode::Success); + ASSERT_NE(originalIndex, nullptr); + ASSERT_EQ(originalIndex->SaveIndex("original_index"), ErrorCode::Success); float originalRecall = Search(originalIndex, queryset, vecset, addvecset, K, truth, N); originalIndex = nullptr; auto clonedIndex = VectorIndex::Clone("original_index", "cloned_index"); - BOOST_REQUIRE(clonedIndex != nullptr); + ASSERT_NE(clonedIndex, nullptr); clonedIndex = nullptr; std::shared_ptr loadedClonedIndex; - BOOST_REQUIRE(VectorIndex::LoadIndex("cloned_index", loadedClonedIndex) == ErrorCode::Success); - BOOST_REQUIRE(loadedClonedIndex != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("cloned_index", loadedClonedIndex), ErrorCode::Success); + ASSERT_NE(loadedClonedIndex, nullptr); float clonedRecall = Search(loadedClonedIndex, queryset, vecset, addvecset, K, truth, N); loadedClonedIndex = nullptr; - BOOST_REQUIRE_MESSAGE(std::fabs(originalRecall - clonedRecall) < 1e-5, - "Recall mismatch between original and cloned index: " - << "original=" << originalRecall << ", cloned=" << clonedRecall); + ASSERT_LT(std::fabs(originalRecall - clonedRecall), 1e-5) + << "Recall mismatch between original and cloned index: " + << "original=" << originalRecall << ", cloned=" << clonedRecall; std::filesystem::remove_all("original_index"); std::filesystem::remove_all("cloned_index"); } -BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertSanity) +TEST(SPFreshTest, IndexPersistenceAndInsertSanity) { using namespace SPFreshTest; @@ -532,14 +527,14 @@ BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertSanity) // Build and save base index auto baseIndex = BuildIndex("insert_test_index", vecset, metaset); - BOOST_REQUIRE(baseIndex != nullptr); - BOOST_REQUIRE(baseIndex->SaveIndex("insert_test_index") == ErrorCode::Success); + ASSERT_NE(baseIndex, nullptr); + ASSERT_EQ(baseIndex->SaveIndex("insert_test_index"), ErrorCode::Success); baseIndex = nullptr; // Load the saved index std::shared_ptr loadedOnce; - BOOST_REQUIRE(VectorIndex::LoadIndex("insert_test_index", loadedOnce) == ErrorCode::Success); - BOOST_REQUIRE(loadedOnce != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("insert_test_index", loadedOnce), ErrorCode::Success); + ASSERT_NE(loadedOnce, nullptr); // Search sanity check SearchOnly(loadedOnce, queryset, K); @@ -547,15 +542,15 @@ BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertSanity) // Clone the loaded index auto clonedIndex = VectorIndex::Clone("insert_test_index", "insert_cloned_index"); - BOOST_REQUIRE(clonedIndex != nullptr); + ASSERT_NE(clonedIndex, nullptr); // Save and reload the cloned index - BOOST_REQUIRE(clonedIndex->SaveIndex("insert_cloned_index") == ErrorCode::Success); + ASSERT_EQ(clonedIndex->SaveIndex("insert_cloned_index"), ErrorCode::Success); clonedIndex = nullptr; std::shared_ptr loadedClone; - BOOST_REQUIRE(VectorIndex::LoadIndex("insert_cloned_index", loadedClone) == ErrorCode::Success); - BOOST_REQUIRE(loadedClone != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("insert_cloned_index", loadedClone), ErrorCode::Success); + ASSERT_NE(loadedClone, nullptr); // Insert new vectors InsertVectors( @@ -567,11 +562,11 @@ BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertSanity) ); // Final save and reload after insert - BOOST_REQUIRE(loadedClone->SaveIndex("insert_final_index") == ErrorCode::Success); + ASSERT_EQ(loadedClone->SaveIndex("insert_final_index"), ErrorCode::Success); loadedClone = nullptr; std::shared_ptr reloadedFinal; - BOOST_REQUIRE(VectorIndex::LoadIndex("insert_final_index", reloadedFinal) == ErrorCode::Success); + ASSERT_EQ(VectorIndex::LoadIndex("insert_final_index", reloadedFinal), ErrorCode::Success); // Final search sanity SearchOnly(reloadedFinal, queryset, K); @@ -583,7 +578,7 @@ BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertSanity) std::filesystem::remove_all("insert_final_index"); } -BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertMultipleThreads) +TEST(SPFreshTest, IndexPersistenceAndInsertMultipleThreads) { using namespace SPFreshTest; @@ -596,14 +591,14 @@ BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertMultipleThreads) // Build and save base index auto baseIndex = BuildIndex("insert_test_index_multi", vecset, metaset); - BOOST_REQUIRE(baseIndex != nullptr); - BOOST_REQUIRE(baseIndex->SaveIndex("insert_test_index_multi") == ErrorCode::Success); + ASSERT_NE(baseIndex, nullptr); + ASSERT_EQ(baseIndex->SaveIndex("insert_test_index_multi"), ErrorCode::Success); baseIndex = nullptr; // Load the saved index std::shared_ptr loadedOnce; - BOOST_REQUIRE(VectorIndex::LoadIndex("insert_test_index_multi", loadedOnce) == ErrorCode::Success); - BOOST_REQUIRE(loadedOnce != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("insert_test_index_multi", loadedOnce), ErrorCode::Success); + ASSERT_NE(loadedOnce, nullptr); // Search sanity check SearchOnly(loadedOnce, queryset, K); @@ -611,15 +606,15 @@ BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertMultipleThreads) // Clone the loaded index auto clonedIndex = VectorIndex::Clone("insert_test_index_multi", "insert_cloned_index_multi"); - BOOST_REQUIRE(clonedIndex != nullptr); + ASSERT_NE(clonedIndex, nullptr); // Save and reload the cloned index - BOOST_REQUIRE(clonedIndex->SaveIndex("insert_cloned_index_multi") == ErrorCode::Success); + ASSERT_EQ(clonedIndex->SaveIndex("insert_cloned_index_multi"), ErrorCode::Success); clonedIndex = nullptr; std::shared_ptr loadedClone; - BOOST_REQUIRE(VectorIndex::LoadIndex("insert_cloned_index_multi", loadedClone) == ErrorCode::Success); - BOOST_REQUIRE(loadedClone != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("insert_cloned_index_multi", loadedClone), ErrorCode::Success); + ASSERT_NE(loadedClone, nullptr); // Insert new vectors InsertVectors( @@ -631,12 +626,12 @@ BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertMultipleThreads) ); // Final save and reload after insert - BOOST_REQUIRE(loadedClone->SaveIndex("insert_final_index_multi") == ErrorCode::Success); + ASSERT_EQ(loadedClone->SaveIndex("insert_final_index_multi"), ErrorCode::Success); loadedClone = nullptr; std::shared_ptr reloadedFinal; - BOOST_REQUIRE(VectorIndex::LoadIndex("insert_final_index_multi", reloadedFinal) == ErrorCode::Success); - BOOST_REQUIRE(reloadedFinal != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("insert_final_index_multi", reloadedFinal), ErrorCode::Success); + ASSERT_NE(reloadedFinal, nullptr); // Final search sanity SearchOnly(reloadedFinal, queryset, K); reloadedFinal = nullptr; @@ -647,7 +642,7 @@ BOOST_AUTO_TEST_CASE(IndexPersistenceAndInsertMultipleThreads) std::filesystem::remove_all("insert_final_index_multi"); } -BOOST_AUTO_TEST_CASE(IndexSaveDuringQuery) +TEST(SPFreshTest, IndexSaveDuringQuery) { using namespace SPFreshTest; @@ -658,7 +653,7 @@ BOOST_AUTO_TEST_CASE(IndexSaveDuringQuery) generator.Run(vecset, metaset, queryset, truth, addvecset, addmetaset, addtruth); auto index = BuildIndex("save_during_query_index", vecset, metaset); - BOOST_REQUIRE(index != nullptr); + ASSERT_NE(index, nullptr); std::atomic keepQuerying(true); std::thread queryThread([&]() { @@ -673,7 +668,7 @@ BOOST_AUTO_TEST_CASE(IndexSaveDuringQuery) // Wait a bit before saving std::this_thread::sleep_for(std::chrono::milliseconds(100)); ErrorCode saveStatus = index->SaveIndex("save_during_query_index"); - BOOST_REQUIRE(saveStatus == ErrorCode::Success); + ASSERT_EQ(saveStatus, ErrorCode::Success); keepQuerying = false; queryThread.join(); @@ -681,8 +676,8 @@ BOOST_AUTO_TEST_CASE(IndexSaveDuringQuery) index = nullptr; std::shared_ptr reloaded; - BOOST_REQUIRE(VectorIndex::LoadIndex("save_during_query_index", reloaded) == ErrorCode::Success); - BOOST_REQUIRE(reloaded != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("save_during_query_index", reloaded), ErrorCode::Success); + ASSERT_NE(reloaded, nullptr); SearchOnly(reloaded, queryset, K); reloaded = nullptr; @@ -690,7 +685,7 @@ BOOST_AUTO_TEST_CASE(IndexSaveDuringQuery) std::filesystem::remove_all("save_during_query_index"); } -BOOST_AUTO_TEST_CASE(IndexMultiThreadedQuerySanity) +TEST(SPFreshTest, IndexMultiThreadedQuerySanity) { using namespace SPFreshTest; @@ -703,14 +698,14 @@ BOOST_AUTO_TEST_CASE(IndexMultiThreadedQuerySanity) // Build and save index auto index = BuildIndex("multi_query_index", vecset, metaset); - BOOST_REQUIRE(index != nullptr); - BOOST_REQUIRE(index->SaveIndex("multi_query_index") == ErrorCode::Success); + ASSERT_NE(index, nullptr); + ASSERT_EQ(index->SaveIndex("multi_query_index"), ErrorCode::Success); index = nullptr; // Reload the index std::shared_ptr loaded; - BOOST_REQUIRE(VectorIndex::LoadIndex("multi_query_index", loaded) == ErrorCode::Success); - BOOST_REQUIRE(loaded != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex("multi_query_index", loaded), ErrorCode::Success); + ASSERT_NE(loaded, nullptr); // Insert additional vectors InsertVectors( @@ -753,7 +748,7 @@ BOOST_AUTO_TEST_CASE(IndexMultiThreadedQuerySanity) std::filesystem::remove_all("multi_query_index"); } -BOOST_AUTO_TEST_CASE(IndexShadowCloneLifecycleKeepLast) +TEST(SPFreshTest, IndexShadowCloneLifecycleKeepLast) { using namespace SPFreshTest; @@ -767,7 +762,7 @@ BOOST_AUTO_TEST_CASE(IndexShadowCloneLifecycleKeepLast) generator.Run(vecset, metaset, queryset, truth, addvecset, addmetaset, addtruth); const std::string baseIndexName = "base_index"; - BOOST_REQUIRE(BuildIndex(baseIndexName, vecset, metaset)->SaveIndex(baseIndexName) == ErrorCode::Success); + ASSERT_EQ(BuildIndex(baseIndexName, vecset, metaset)->SaveIndex(baseIndexName), ErrorCode::Success); std::string previousIndexName = baseIndexName; @@ -778,8 +773,8 @@ BOOST_AUTO_TEST_CASE(IndexShadowCloneLifecycleKeepLast) // Load previous index std::shared_ptr loaded; - BOOST_REQUIRE(VectorIndex::LoadIndex(previousIndexName, loaded) == ErrorCode::Success); - BOOST_REQUIRE(loaded != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex(previousIndexName, loaded), ErrorCode::Success); + ASSERT_NE(loaded, nullptr); // Query check for (int i = 0; i < std::min(queryset->Count(), 5); ++i) { @@ -794,11 +789,11 @@ BOOST_AUTO_TEST_CASE(IndexShadowCloneLifecycleKeepLast) loaded = nullptr; // Clone to shadow - BOOST_REQUIRE(VectorIndex::Clone(previousIndexName, shadowIndexName) != nullptr); + ASSERT_NE(VectorIndex::Clone(previousIndexName, shadowIndexName), nullptr); std::shared_ptr shadowLoaded; - BOOST_REQUIRE(VectorIndex::LoadIndex(shadowIndexName, shadowLoaded) == ErrorCode::Success); - BOOST_REQUIRE(shadowLoaded != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex(shadowIndexName, shadowLoaded), ErrorCode::Success); + ASSERT_NE(shadowLoaded, nullptr); auto* shadowIndex = static_cast*>(shadowLoaded.get()); // Prepare insert batch @@ -831,7 +826,7 @@ BOOST_AUTO_TEST_CASE(IndexShadowCloneLifecycleKeepLast) std::this_thread::sleep_for(std::chrono::milliseconds(20)); } - BOOST_REQUIRE(shadowLoaded->SaveIndex(shadowIndexName) == ErrorCode::Success); + ASSERT_EQ(shadowLoaded->SaveIndex(shadowIndexName), ErrorCode::Success); SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "[%d] Created new shadow index: %s\n", iter, shadowIndexName.c_str()); shadowLoaded = nullptr; @@ -849,7 +844,7 @@ BOOST_AUTO_TEST_CASE(IndexShadowCloneLifecycleKeepLast) } } -BOOST_AUTO_TEST_CASE(IterativeSearch) +TEST(SPFreshTest, IterativeSearch) { using namespace SPFreshTest; @@ -860,8 +855,8 @@ BOOST_AUTO_TEST_CASE(IterativeSearch) std::shared_ptr metaset = TestUtils::TestDataGenerator::GenerateMetadataSet(insertBatchSize, 0); auto originalIndex = BuildIndex("original_index", vecset, metaset); - BOOST_REQUIRE(originalIndex != nullptr); - BOOST_REQUIRE(originalIndex->SaveIndex("original_index") == ErrorCode::Success); + ASSERT_NE(originalIndex, nullptr); + ASSERT_EQ(originalIndex->SaveIndex("original_index"), ErrorCode::Success); originalIndex = nullptr; for (int iter = 0; iter < insertIterations; iter++) { @@ -878,12 +873,12 @@ BOOST_AUTO_TEST_CASE(IterativeSearch) std::shared_ptr tmpmetas = TestUtils::TestDataGenerator::GenerateMetadataSet(insertBatchSize, (iter + 1) * insertBatchSize); InsertVectors(cloneIndexPtr, 1, insertBatchSize, tmpvecs, tmpmetas); - BOOST_REQUIRE(cloneIndex->SaveIndex(clone_path) == ErrorCode::Success); + ASSERT_EQ(cloneIndex->SaveIndex(clone_path), ErrorCode::Success); cloneIndex = nullptr; std::shared_ptr loadedIndex; - BOOST_REQUIRE(VectorIndex::LoadIndex(clone_path, loadedIndex) == ErrorCode::Success); - BOOST_REQUIRE(loadedIndex != nullptr); + ASSERT_EQ(VectorIndex::LoadIndex(clone_path, loadedIndex), ErrorCode::Success); + ASSERT_NE(loadedIndex, nullptr); std::shared_ptr embedding = get_embeddings((1000 * iter) + 500, ((1000 * iter) + 501), dimension, -1); std::shared_ptr resultIterator = loadedIndex->GetIterator(embedding->GetData(), false); @@ -895,7 +890,7 @@ BOOST_AUTO_TEST_CASE(IterativeSearch) auto results = resultIterator->Next(batch); int resultCount = results->GetResultNum(); if (resultCount <= 0) break; - BOOST_CHECK(resultCount == batch); + EXPECT_EQ(resultCount, batch); previous = current; current = 0; for (int j = 0; j < resultCount; j++) { @@ -917,4 +912,4 @@ BOOST_AUTO_TEST_CASE(IterativeSearch) std::filesystem::remove_all("original_index"); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/Test/src/SSDServingTest.cpp b/Test/src/SSDServingTest.cpp index b2263fd56..bcfade188 100644 --- a/Test/src/SSDServingTest.cpp +++ b/Test/src/SSDServingTest.cpp @@ -29,7 +29,7 @@ void GenerateVectors(std::string fileName, SPTAG::SizeType rows, SPTAG::Dimensio if (!of.is_open()) { fprintf(stderr, "%s can't be opened.\n", fileName.c_str()); - BOOST_CHECK(false); + GTEST_FAIL() << fileName << " can't be opened."; return; } @@ -136,7 +136,7 @@ void TestHead(std::string configName, std::string OutputIDFile, std::string Outp if (!config.is_open()) { fprintf(stderr, "%s can't be opened.\n", configName.c_str()); - BOOST_CHECK(false); + GTEST_FAIL() << configName << " can't be opened."; return; } @@ -180,7 +180,7 @@ void TestBuildHead( if (!config.is_open()) { fprintf(stderr, "%s can't be opened.\n", configName.c_str()); - BOOST_CHECK(false); + GTEST_FAIL() << configName << " can't be opened."; return; } @@ -188,7 +188,7 @@ void TestBuildHead( if (p_builderFile.empty()) { fprintf(stderr, "no builder file for head index build.\n"); - BOOST_CHECK(false); + GTEST_FAIL() << p_builderFile << " can't be opened."; return; } @@ -201,7 +201,7 @@ void TestBuildHead( if (!bf.is_open()) { fprintf(stderr, "%s can't be opened.\n", p_builderFile.c_str()); - BOOST_CHECK(false); + GTEST_FAIL() << p_builderFile << " can't be opened."; return; } bf.close(); @@ -232,7 +232,7 @@ void TestBuildSSDIndex(std::string configName, if (!config.is_open()) { fprintf(stderr, "%s can't be opened.\n", configName.c_str()); - BOOST_CHECK(false); + GTEST_FAIL() << configName << " can't be opened."; return; } @@ -247,7 +247,7 @@ void TestBuildSSDIndex(std::string configName, if (!bf.is_open()) { fprintf(stderr, "%s can't be opened.\n", p_headConfig.c_str()); - BOOST_CHECK(false); + GTEST_FAIL() << p_headConfig << " can't be opened."; return; } bf << "[Index]" << std::endl; @@ -294,7 +294,7 @@ void TestSearchSSDIndex( if (!config.is_open()) { fprintf(stderr, "%s can't be opened.\n", configName.c_str()); - BOOST_CHECK(false); + GTEST_FAIL() << configName << " can't be opened."; return; } @@ -309,7 +309,7 @@ void TestSearchSSDIndex( if (!bf.is_open()) { fprintf(stderr, "%s can't be opened.\n", p_headConfig.c_str()); - BOOST_CHECK(false); + GTEST_FAIL() << p_headConfig << " can't be opened."; return; } bf << "[Index]" << std::endl; @@ -394,7 +394,7 @@ void RunFromMap() { ); } -BOOST_AUTO_TEST_SUITE(SSDServingTest) +namespace SSDServingTestSuite { // #define RAW_VECTOR_NUM 1000 #define VECTOR_NUM 1000 @@ -429,7 +429,7 @@ BOOST_AUTO_TEST_SUITE(SSDServingTest) #define SEARCH_SSD_RESULT(VT, DM, ALGO, FT, TFT) SSDTEST_DIRECTORY "test_search_ssd_"#VT"_"#DM"_"#ALGO"_"#FT"_"#TFT".result" #define GVQ(VT, FT) \ -BOOST_AUTO_TEST_CASE(GenerateVectorsQueries##VT##FT) { \ +TEST(SSDServingTest, GenerateVectorsQueries##VT##FT) { \ boost::filesystem::create_directory(SSDTEST_DIRECTORY_NAME); \ GenVec(VECTORS(VT, FT), SPTAG::VectorValueType::VT, SPTAG::VectorFileType::FT, VECTOR_NUM, VECTOR_DIM); \ GenVec(QUERIES(VT, FT), SPTAG::VectorValueType::VT, SPTAG::VectorFileType::FT, QUERY_NUM, VECTOR_DIM); \ @@ -447,7 +447,7 @@ GVQ(Int8, XVEC) #undef GVQ #define WTEV(VT, DM, FT) \ -BOOST_AUTO_TEST_CASE(TestHead##VT##DM##FT) { \ +TEST(SSDServingTest, TestHead##VT##DM##FT) { \ std::string configName = SELECT_HEAD_CONFIG(VT, DM, FT); \ std::string OutputIDFile = HEAD_IDS(VT, DM, FT); \ std::string OutputVectorFile = HEAD_VECTORS(VT, DM, FT); \ @@ -516,7 +516,7 @@ WTEV(Int8, Cosine, XVEC) #undef WTEV #define BDHD(VT, DM, ALGO, FT) \ -BOOST_AUTO_TEST_CASE(TestBuildHead##VT##DM##ALGO##FT) { \ +TEST(SSDServingTest, TestBuildHead##VT##DM##ALGO##FT) { \ std::string configName = BUILD_HEAD_CONFIG(VT, DM, ALGO); \ std::string builderFile = BUILD_HEAD_BUILDER_CONFIG(VT, DM, ALGO); \ std::string base_config = CreateBaseConfig(SPTAG::VectorValueType::VT, SPTAG::DistCalcMethod::DM, SPTAG::IndexAlgoType::ALGO, VECTOR_DIM, \ @@ -607,7 +607,7 @@ BDHD(Int16, Cosine, KDT, XVEC) #undef BDHD #define BDSSD(VT, DM, ALGO, FT) \ -BOOST_AUTO_TEST_CASE(TestBuildSSDIndex##VT##DM##ALGO##FT) { \ +TEST(SSDServingTest, TestBuildSSDIndex##VT##DM##ALGO##FT) { \ std::string configName = BUILD_SSD_CONFIG(VT, DM, ALGO); \ std::string base_config = CreateBaseConfig(SPTAG::VectorValueType::VT, SPTAG::DistCalcMethod::DM, SPTAG::IndexAlgoType::ALGO, VECTOR_DIM, \ VECTORS(VT, FT), SPTAG::VectorFileType::FT, VECTOR_NUM, "", \ @@ -698,7 +698,7 @@ BDSSD(Int16, Cosine, KDT, XVEC) #define SCSSD(VT, DM, ALGO, FT, TFT) \ -BOOST_AUTO_TEST_CASE(TestSearchSSDIndex##VT##DM##ALGO##FT##TFT) { \ +TEST(SSDServingTest, TestSearchSSDIndex##VT##DM##ALGO##FT##TFT) { \ std::string configName = SEARCH_SSD_CONFIG(VT, DM, ALGO); \ std::string base_config = CreateBaseConfig(SPTAG::VectorValueType::VT, SPTAG::DistCalcMethod::DM, SPTAG::IndexAlgoType::ALGO, VECTOR_DIM, \ VECTORS(VT, FT), SPTAG::VectorFileType::FT, VECTOR_NUM, "", \ @@ -795,8 +795,8 @@ SCSSD(Int16, Cosine, KDT, XVEC, XVEC) #undef TDEFAULT #undef TXVEC -BOOST_AUTO_TEST_CASE(RUN_FROM_MAP) { +TEST(SSDServingTest, RUN_FROM_MAP) { RunFromMap(); } -BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file +} \ No newline at end of file diff --git a/Test/src/StringConvertTest.cpp b/Test/src/StringConvertTest.cpp index fa457debe..f89a91bd1 100644 --- a/Test/src/StringConvertTest.cpp +++ b/Test/src/StringConvertTest.cpp @@ -17,112 +17,99 @@ namespace std::string str = ConvertToString(p_val); if (nullptr != p_valStr) { - BOOST_CHECK(str == p_valStr); + EXPECT_EQ(str, p_valStr); } ValueType val; - BOOST_CHECK(ConvertStringTo(str.c_str(), val)); - BOOST_CHECK(val == p_val); + EXPECT_TRUE(ConvertStringTo(str.c_str(), val)); + EXPECT_EQ(val, p_val); } } } -BOOST_AUTO_TEST_SUITE(StringConvertTest) +namespace StringConvertTest { -BOOST_AUTO_TEST_CASE(ConvertInt8) -{ +TEST(StringConvertTest, ConvertInt8) { Local::TestConvertSuccCase(static_cast(-1), "-1"); Local::TestConvertSuccCase(static_cast(0), "0"); Local::TestConvertSuccCase(static_cast(3), "3"); Local::TestConvertSuccCase(static_cast(100), "100"); } -BOOST_AUTO_TEST_CASE(ConvertInt16) -{ +TEST(StringConvertTest, ConvertInt16) { Local::TestConvertSuccCase(static_cast(-1), "-1"); Local::TestConvertSuccCase(static_cast(0), "0"); Local::TestConvertSuccCase(static_cast(3), "3"); Local::TestConvertSuccCase(static_cast(100), "100"); } -BOOST_AUTO_TEST_CASE(ConvertInt32) -{ +TEST(StringConvertTest, ConvertInt32) { Local::TestConvertSuccCase(static_cast(-1), "-1"); Local::TestConvertSuccCase(static_cast(0), "0"); Local::TestConvertSuccCase(static_cast(3), "3"); Local::TestConvertSuccCase(static_cast(100), "100"); } -BOOST_AUTO_TEST_CASE(ConvertInt64) -{ +TEST(StringConvertTest, ConvertInt64) { Local::TestConvertSuccCase(static_cast(-1), "-1"); Local::TestConvertSuccCase(static_cast(0), "0"); Local::TestConvertSuccCase(static_cast(3), "3"); Local::TestConvertSuccCase(static_cast(100), "100"); } -BOOST_AUTO_TEST_CASE(ConvertUInt8) -{ +TEST(StringConvertTest, ConvertUInt8) { Local::TestConvertSuccCase(static_cast(0), "0"); Local::TestConvertSuccCase(static_cast(3), "3"); Local::TestConvertSuccCase(static_cast(100), "100"); } -BOOST_AUTO_TEST_CASE(ConvertUInt16) -{ +TEST(StringConvertTest, ConvertUInt16) { Local::TestConvertSuccCase(static_cast(0), "0"); Local::TestConvertSuccCase(static_cast(3), "3"); Local::TestConvertSuccCase(static_cast(100), "100"); } -BOOST_AUTO_TEST_CASE(ConvertUInt32) -{ +TEST(StringConvertTest, ConvertUInt32) { Local::TestConvertSuccCase(static_cast(0), "0"); Local::TestConvertSuccCase(static_cast(3), "3"); Local::TestConvertSuccCase(static_cast(100), "100"); } -BOOST_AUTO_TEST_CASE(ConvertUInt64) -{ +TEST(StringConvertTest, ConvertUInt64) { Local::TestConvertSuccCase(static_cast(0), "0"); Local::TestConvertSuccCase(static_cast(3), "3"); Local::TestConvertSuccCase(static_cast(100), "100"); } -BOOST_AUTO_TEST_CASE(ConvertFloat) -{ +TEST(StringConvertTest, ConvertFloat) { Local::TestConvertSuccCase(static_cast(-1), nullptr); Local::TestConvertSuccCase(static_cast(0), nullptr); Local::TestConvertSuccCase(static_cast(3), nullptr); Local::TestConvertSuccCase(static_cast(100), nullptr); } -BOOST_AUTO_TEST_CASE(ConvertDouble) -{ +TEST(StringConvertTest, ConvertDouble) { Local::TestConvertSuccCase(static_cast(-1), nullptr); Local::TestConvertSuccCase(static_cast(0), nullptr); Local::TestConvertSuccCase(static_cast(3), nullptr); Local::TestConvertSuccCase(static_cast(100), nullptr); } -BOOST_AUTO_TEST_CASE(ConvertIndexAlgoType) -{ +TEST(StringConvertTest, ConvertIndexAlgoType) { Local::TestConvertSuccCase(SPTAG::IndexAlgoType::BKT, "BKT"); Local::TestConvertSuccCase(SPTAG::IndexAlgoType::KDT, "KDT"); } -BOOST_AUTO_TEST_CASE(ConvertVectorValueType) -{ +TEST(StringConvertTest, ConvertVectorValueType) { Local::TestConvertSuccCase(SPTAG::VectorValueType::Float, "Float"); Local::TestConvertSuccCase(SPTAG::VectorValueType::Int8, "Int8"); Local::TestConvertSuccCase(SPTAG::VectorValueType::Int16, "Int16"); } -BOOST_AUTO_TEST_CASE(ConvertDistCalcMethod) -{ +TEST(StringConvertTest, ConvertDistCalcMethod) { Local::TestConvertSuccCase(SPTAG::DistCalcMethod::Cosine, "Cosine"); Local::TestConvertSuccCase(SPTAG::DistCalcMethod::L2, "L2"); } -BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file +} \ No newline at end of file diff --git a/Test/src/main.cpp b/Test/src/main.cpp index 7bf61ea11..aaf4ebf20 100644 --- a/Test/src/main.cpp +++ b/Test/src/main.cpp @@ -1,41 +1,11 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. -#define BOOST_TEST_MAIN -#define BOOST_TEST_MODULE Main +// GoogleTest main #include "inc/Test.h" -#include -#include - -using namespace boost::unit_test; - -class SPTAGVisitor : public test_tree_visitor -{ -public: - void visit(test_case const& test) - { - std::string prefix(2, '\t'); - std::cout << prefix << "Case: " << test.p_name << std::endl; - } - - bool test_suite_start(test_suite const& suite) - { - std::string prefix(1, '\t'); - std::cout << prefix << "Suite: " << suite.p_name << std::endl; - return true; - } -}; - -struct GlobalFixture -{ - GlobalFixture() - { - SPTAGVisitor visitor; - traverse_test_tree(framework::master_test_suite(), visitor, false); - } - -}; - -BOOST_TEST_GLOBAL_FIXTURE(GlobalFixture); +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} From 1de0323f47a9ff17cdddc9beac204b6dc6c60b53 Mon Sep 17 00:00:00 2001 From: Avinash Varma Date: Tue, 2 Sep 2025 15:10:54 +0530 Subject: [PATCH 2/4] Fixing test failure --- Test/src/DistanceTest.cpp | 4 ++-- Test/src/SIMDTest.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Test/src/DistanceTest.cpp b/Test/src/DistanceTest.cpp index 3509f7fcd..1acc0ff2d 100644 --- a/Test/src/DistanceTest.cpp +++ b/Test/src/DistanceTest.cpp @@ -42,8 +42,8 @@ void test(int high) { X[i] = random(high, -high); Y[i] = random(high, -high); } - EXPECT_NEAR(ComputeL2Distance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::L2), 1e-5); - EXPECT_NEAR(high * high - ComputeCosineDistance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::Cosine), 1e-5); + EXPECT_NEAR(ComputeL2Distance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::L2), 1e-5 * ComputeL2Distance(X, Y, dimension)); + EXPECT_NEAR(high * high - ComputeCosineDistance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::Cosine), 1e-5 * (std::abs(high * high - ComputeCosineDistance(X, Y, dimension)))); delete[] X; delete[] Y; diff --git a/Test/src/SIMDTest.cpp b/Test/src/SIMDTest.cpp index 1fa4840ed..41819768e 100644 --- a/Test/src/SIMDTest.cpp +++ b/Test/src/SIMDTest.cpp @@ -38,7 +38,7 @@ void test(int high) { ComputeSum(X, Y, dimension); SPTAG::COMMON::SIMDUtils::ComputeSum(X_copy, Y, dimension); for (SPTAG::DimensionType i = 0; i < dimension; i++) { - EXPECT_NEAR(double(X[i]), double(X_copy[i]), 1e-5); + EXPECT_NEAR(double(X[i]), double(X_copy[i]), 1e-5 * X[i]); } delete[] X; From e4bd5e702f90150a3663f0a1a6287dfc1b78bb51 Mon Sep 17 00:00:00 2001 From: Avinash Varma Date: Tue, 2 Sep 2025 18:10:54 +0530 Subject: [PATCH 3/4] Fixing formatting --- Test/cuda/cuda_tests.cpp | 15 +++++---- Test/src/AlgoTest.cpp | 28 ++++++++++------- Test/src/Base64HelperTest.cpp | 20 ++++++------ Test/src/CommonHelperTest.cpp | 32 +++++++++---------- Test/src/ConcurrentTest.cpp | 14 ++++++--- Test/src/DistanceTest.cpp | 22 ++++++++----- Test/src/FilterTest.cpp | 11 ++++--- Test/src/IniReaderTest.cpp | 8 +++-- Test/src/IterativeScanTest.cpp | 35 ++++++++++++--------- Test/src/KVTest.cpp | 23 +++++++++----- Test/src/MultiIndexExperiment.cpp | 11 ++++--- Test/src/MultiIndexScanTest.cpp | 15 +++++---- Test/src/PerfTest.cpp | 11 ++++--- Test/src/ReconstructIndexSimilarityTest.cpp | 2 +- Test/src/SPFreshTest.cpp | 4 +-- 15 files changed, 149 insertions(+), 102 deletions(-) diff --git a/Test/cuda/cuda_tests.cpp b/Test/cuda/cuda_tests.cpp index 6a9af94fb..144d624bd 100644 --- a/Test/cuda/cuda_tests.cpp +++ b/Test/cuda/cuda_tests.cpp @@ -1,22 +1,21 @@ -//#include "test_kernels.cu" +// #include "test_kernels.cu" -#include #include #include -#include #include "inc/Test.h" #include #include int GPUBuildKNNTest(); -TEST(GPUTest, RandomTests) { - EXPECT_EQ(1, 1); +TEST(GPUTest, RandomTests) +{ + EXPECT_EQ(1, 1); - int errors = GPUBuildKNNTest(); - printf("outside\n"); - EXPECT_EQ(errors, 0); + int errors = GPUBuildKNNTest(); + printf("outside\n"); + EXPECT_EQ(errors, 0); } /* diff --git a/Test/src/AlgoTest.cpp b/Test/src/AlgoTest.cpp index 5d91de5bf..4c438a0a4 100644 --- a/Test/src/AlgoTest.cpp +++ b/Test/src/AlgoTest.cpp @@ -14,7 +14,8 @@ void Build(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_pt std::shared_ptr &meta, const std::string out) { - std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); + std::shared_ptr vecIndex = + SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); ASSERT_NE(nullptr, vecIndex); if (algo != SPTAG::IndexAlgoType::SPANN) @@ -53,7 +54,8 @@ void BuildWithMetaMapping(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr &meta, const std::string out) { - std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); + std::shared_ptr vecIndex = + SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); ASSERT_NE(nullptr, vecIndex); if (algo != SPTAG::IndexAlgoType::SPANN) @@ -131,7 +133,8 @@ template void AddOneByOne(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr &vec, std::shared_ptr &meta, const std::string out) { - std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); + std::shared_ptr vecIndex = + SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -164,13 +167,12 @@ template void Delete(const std::string folder, T *vec, SPTAG::SizeT ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(folder, vecIndex)); ASSERT_NE(nullptr, vecIndex); - ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->DeleteIndex((const void*)vec, n)); + ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->DeleteIndex((const void *)vec, n)); ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); vecIndex.reset(); } -template -void RunTest(SPTAG::IndexAlgoType algo, std::string distCalcMethod) +template void RunTest(SPTAG::IndexAlgoType algo, std::string distCalcMethod) { SPTAG::SizeType n = 2000, q = 3; SPTAG::DimensionType m = 10; @@ -242,18 +244,22 @@ void RunTest(SPTAG::IndexAlgoType algo, std::string distCalcMethod) } } -namespace AlgoTest { +namespace AlgoTest +{ -TEST(AlgoTest, KDTTest) { +TEST(AlgoTest, KDTTest) +{ RunTest(SPTAG::IndexAlgoType::KDT, "L2"); } -TEST(AlgoTest, BKTTest) { +TEST(AlgoTest, BKTTest) +{ RunTest(SPTAG::IndexAlgoType::BKT, "L2"); } -TEST(AlgoTest, SPANNTest) { +TEST(AlgoTest, SPANNTest) +{ RunTest(SPTAG::IndexAlgoType::SPANN, "L2"); } -} +} // namespace AlgoTest diff --git a/Test/src/Base64HelperTest.cpp b/Test/src/Base64HelperTest.cpp index be607b51d..5a165babd 100644 --- a/Test/src/Base64HelperTest.cpp +++ b/Test/src/Base64HelperTest.cpp @@ -6,9 +6,11 @@ #include -namespace Base64Test { +namespace Base64Test +{ -TEST(Base64Test, Base64EncDec) { +TEST(Base64Test, Base64EncDec) +{ using namespace SPTAG::Helper::Base64; const size_t bufferSize = 1 << 10; @@ -24,19 +26,19 @@ TEST(Base64Test, Base64EncDec) { } size_t encBufLen = CapacityForEncode(inputSize); - EXPECT_LT(encBufLen, bufferSize); + EXPECT_LT(encBufLen, bufferSize); size_t encOutLen = 0; - EXPECT_TRUE(Encode(rawBuffer.get(), inputSize, encBuffer.get(), encOutLen)); - EXPECT_GE(encBufLen, encOutLen); + EXPECT_TRUE(Encode(rawBuffer.get(), inputSize, encBuffer.get(), encOutLen)); + EXPECT_GE(encBufLen, encOutLen); size_t decBufLen = CapacityForDecode(encOutLen); - EXPECT_LT(decBufLen, bufferSize); + EXPECT_LT(decBufLen, bufferSize); size_t decOutLen = 0; - EXPECT_TRUE(Decode(encBuffer.get(), encOutLen, rawBuffer.get(), decOutLen)); - EXPECT_GE(decBufLen, decOutLen); + EXPECT_TRUE(Decode(encBuffer.get(), encOutLen, rawBuffer.get(), decOutLen)); + EXPECT_GE(decBufLen, decOutLen); } } -} \ No newline at end of file +} // namespace Base64Test \ No newline at end of file diff --git a/Test/src/CommonHelperTest.cpp b/Test/src/CommonHelperTest.cpp index 0feef96c8..8d99276b6 100644 --- a/Test/src/CommonHelperTest.cpp +++ b/Test/src/CommonHelperTest.cpp @@ -6,14 +6,14 @@ #include -namespace CommonHelperTest { +namespace CommonHelperTest +{ - -TEST(CommonHelperTest, ToLowerInPlaceTest) { - auto runTestCase = [](std::string p_input, const std::string& p_expected) - { +TEST(CommonHelperTest, ToLowerInPlaceTest) +{ + auto runTestCase = [](std::string p_input, const std::string &p_expected) { SPTAG::Helper::StrUtils::ToLowerInPlace(p_input); - EXPECT_EQ(p_input, p_expected); + EXPECT_EQ(p_input, p_expected); }; runTestCase("abc", "abc"); @@ -23,11 +23,11 @@ TEST(CommonHelperTest, ToLowerInPlaceTest) { runTestCase("123!-=aBc", "123!-=abc"); } - -TEST(CommonHelperTest, SplitStringTest) { +TEST(CommonHelperTest, SplitStringTest) +{ std::string input("seg1 seg2 seg3 seg4"); - const auto& segs = SPTAG::Helper::StrUtils::SplitString(input, " "); + const auto &segs = SPTAG::Helper::StrUtils::SplitString(input, " "); EXPECT_EQ(segs.size(), 4u); EXPECT_EQ(segs[0], "seg1"); EXPECT_EQ(segs[1], "seg2"); @@ -35,8 +35,8 @@ TEST(CommonHelperTest, SplitStringTest) { EXPECT_EQ(segs[3], "seg4"); } - -TEST(CommonHelperTest, FindTrimmedSegmentTest) { +TEST(CommonHelperTest, FindTrimmedSegmentTest) +{ using namespace SPTAG::Helper::StrUtils; std::string input("\t Space End \r\n\t"); @@ -47,8 +47,8 @@ TEST(CommonHelperTest, FindTrimmedSegmentTest) { EXPECT_EQ(pos.second, input.c_str() + 13); } - -TEST(CommonHelperTest, StartsWithTest) { +TEST(CommonHelperTest, StartsWithTest) +{ using namespace SPTAG::Helper::StrUtils; EXPECT_TRUE(StartsWith("Abcd", "A")); @@ -64,8 +64,8 @@ TEST(CommonHelperTest, StartsWithTest) { EXPECT_FALSE(StartsWith("Abcd", "Abcde")); } - -TEST(CommonHelperTest, StrEqualIgnoreCaseTest) { +TEST(CommonHelperTest, StrEqualIgnoreCaseTest) +{ using namespace SPTAG::Helper::StrUtils; EXPECT_TRUE(StrEqualIgnoreCase("Abcd", "Abcd")); @@ -79,4 +79,4 @@ TEST(CommonHelperTest, StrEqualIgnoreCaseTest) { EXPECT_FALSE(StrEqualIgnoreCase("000", "OOO")); } -} +} // namespace CommonHelperTest diff --git a/Test/src/ConcurrentTest.cpp b/Test/src/ConcurrentTest.cpp index ea87c4aaf..9caac6836 100644 --- a/Test/src/ConcurrentTest.cpp +++ b/Test/src/ConcurrentTest.cpp @@ -15,7 +15,8 @@ void ConcurrentAddSearchSave(SPTAG::IndexAlgoType algo, std::string distCalcMeth std::shared_ptr &vec, std::shared_ptr &meta, const std::string out) { - std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); + std::shared_ptr vecIndex = + SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -132,14 +133,17 @@ template void CTest(SPTAG::IndexAlgoType algo, std::string distCalc ConcurrentAddSearchSave(algo, distCalcMethod, vecset, metaset, "testindices"); } -namespace ConcurrentTest { +namespace ConcurrentTest +{ -TEST(ConcurrentTest, BKTTest) { +TEST(ConcurrentTest, BKTTest) +{ CTest(SPTAG::IndexAlgoType::BKT, "L2"); } -TEST(ConcurrentTest, KDTTest) { +TEST(ConcurrentTest, KDTTest) +{ CTest(SPTAG::IndexAlgoType::KDT, "L2"); } -} +} // namespace ConcurrentTest diff --git a/Test/src/DistanceTest.cpp b/Test/src/DistanceTest.cpp index 43c3401a3..21b9d9f52 100644 --- a/Test/src/DistanceTest.cpp +++ b/Test/src/DistanceTest.cpp @@ -39,12 +39,17 @@ template void test(int high) SPTAG::DimensionType dimension = random(256, 2); T *X = new T[dimension], *Y = new T[dimension]; ASSERT_TRUE(X != nullptr && Y != nullptr); - for (SPTAG::DimensionType i = 0; i < dimension; i++) { + for (SPTAG::DimensionType i = 0; i < dimension; i++) + { X[i] = random(high, -high); Y[i] = random(high, -high); } - EXPECT_NEAR(ComputeL2Distance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::L2), 1e-5 * ComputeL2Distance(X, Y, dimension)); - EXPECT_NEAR(high * high - ComputeCosineDistance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::Cosine), 1e-5 * (std::abs(high * high - ComputeCosineDistance(X, Y, dimension)))); + EXPECT_NEAR(ComputeL2Distance(X, Y, dimension), + SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::L2), + 1e-5 * ComputeL2Distance(X, Y, dimension)); + EXPECT_NEAR(high * high - ComputeCosineDistance(X, Y, dimension), + SPTAG::COMMON::DistanceUtils::ComputeDistance(X, Y, dimension, SPTAG::DistCalcMethod::Cosine), + 1e-5 * (std::abs(high * high - ComputeCosineDistance(X, Y, dimension)))); delete[] X; delete[] Y; @@ -104,15 +109,18 @@ void test_dist_calc_performance(int high, SPTAG::DimensionType dimension = 256, delete[] Y; } -namespace DistanceTest { +namespace DistanceTest +{ -TEST(DistanceTest, TestDistanceComputation) { +TEST(DistanceTest, TestDistanceComputation) +{ test(1); test(127); test(32767); } -TEST(DistanceTest, TestDistanceComputationPerformance) { +TEST(DistanceTest, TestDistanceComputationPerformance) +{ std::vector dimensions{128, 256, 512, 1024}; std::vector nums_threads{1, 16, 40}; std::vector calc_methods{SPTAG::DistCalcMethod::L2, SPTAG::DistCalcMethod::Cosine}; @@ -133,4 +141,4 @@ TEST(DistanceTest, TestDistanceComputationPerformance) { } } -} +} // namespace DistanceTest diff --git a/Test/src/FilterTest.cpp b/Test/src/FilterTest.cpp index b46c49066..cd3c81248 100644 --- a/Test/src/FilterTest.cpp +++ b/Test/src/FilterTest.cpp @@ -14,7 +14,8 @@ void BuildWithMetaMapping(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr &meta, const std::string out) { - std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); + std::shared_ptr vecIndex = + SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -103,10 +104,12 @@ template void FTest(SPTAG::IndexAlgoType algo, std::string distCalc SearchWithFilter("testindices", query.data(), q, k); } -namespace FilterTest { +namespace FilterTest +{ -TEST(FilterTest, BKTTest) { +TEST(FilterTest, BKTTest) +{ FTest(SPTAG::IndexAlgoType::BKT, "L2"); } -} +} // namespace FilterTest diff --git a/Test/src/IniReaderTest.cpp b/Test/src/IniReaderTest.cpp index d20381bb5..27fd9153c 100644 --- a/Test/src/IniReaderTest.cpp +++ b/Test/src/IniReaderTest.cpp @@ -6,9 +6,11 @@ #include -namespace IniReaderTest { +namespace IniReaderTest +{ -TEST(IniReaderTest, IniReaderLoadTest) { +TEST(IniReaderTest, IniReaderLoadTest) +{ std::ofstream tmpIni("temp.ini"); tmpIni << "[Common]" << std::endl; tmpIni << "; Comment " << std::endl; @@ -35,4 +37,4 @@ TEST(IniReaderTest, IniReaderLoadTest) { EXPECT_EQ(std::string("1"), reader.GetParameter("Common", "Param1", std::string())); EXPECT_EQ(std::string(), reader.GetParameter("Common", "ParamNotExist", std::string())); } -} \ No newline at end of file +} // namespace IniReaderTest \ No newline at end of file diff --git a/Test/src/IterativeScanTest.cpp b/Test/src/IterativeScanTest.cpp index 288e0735d..b1d461037 100644 --- a/Test/src/IterativeScanTest.cpp +++ b/Test/src/IterativeScanTest.cpp @@ -18,7 +18,8 @@ void BuildIndex(IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr< std::shared_ptr &meta, const std::string out) { - std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); + std::shared_ptr vecIndex = + SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); ASSERT_NE(nullptr, vecIndex); if (algo != IndexAlgoType::SPANN) @@ -54,8 +55,7 @@ void BuildIndex(IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr< ASSERT_EQ(SPTAG::ErrorCode::Success, vecIndex->SaveIndex(out)); } -template -void SearchIterativeBatch(const std::string folder, T *vec, SizeType n, std::string *truthmeta) +template void SearchIterativeBatch(const std::string folder, T *vec, SizeType n, std::string *truthmeta) { std::shared_ptr vecIndex; @@ -70,14 +70,18 @@ void SearchIterativeBatch(const std::string folder, T *vec, SizeType n, std::str { auto results = resultIterator->Next(batch); int resultCount = results->GetResultNum(); - if (resultCount <= 0) break; - ASSERT_EQ(resultCount, batch); - for (int j = 0; j < resultCount; j++) { - - EXPECT_EQ(std::string((char*)((results->GetMetadata(j)).Data()), (results->GetMetadata(j)).Length()), truthmeta[ri]); + if (resultCount <= 0) + break; + ASSERT_EQ(resultCount, batch); + for (int j = 0; j < resultCount; j++) + { + + EXPECT_EQ(std::string((char *)((results->GetMetadata(j)).Data()), (results->GetMetadata(j)).Length()), + truthmeta[ri]); EXPECT_TRUE(results->GetResult(j)->RelaxedMono == true); - std::cout << "Result[" << ri << "] VID:" << results->GetResult(j)->VID << " Dist:" << results->GetResult(j)->Dist << " RelaxedMono:" - << results->GetResult(j)->RelaxedMono << std::endl; + std::cout << "Result[" << ri << "] VID:" << results->GetResult(j)->VID + << " Dist:" << results->GetResult(j)->Dist + << " RelaxedMono:" << results->GetResult(j)->RelaxedMono << std::endl; ri++; } } @@ -129,7 +133,8 @@ template void TestIterativeScan(IndexAlgoType algo, std::string dis SearchIterativeBatch("testindices", query.data(), q, truthmeta1); } -namespace IterativeScanTest { +namespace IterativeScanTest +{ template float EvaluateRecall(const std::vector &res, std::shared_ptr &vecIndex, @@ -203,12 +208,14 @@ template void TestIterativeScanRandom(IndexAlgoType algo, std::stri { auto results = resultIterator->Next(batch); int resultCount = results->GetResultNum(); - if (resultCount <= 0) break; + if (resultCount <= 0) + break; EXPECT_EQ(resultCount, batch); for (int j = 0; j < resultCount; j++) { relaxMono = results->GetResult(j)->RelaxedMono; - ((COMMON::QueryResultSet *)(&resiter[i]))->AddPoint(results->GetResult(j)->VID, results->GetResult(j)->Dist); + ((COMMON::QueryResultSet *)(&resiter[i])) + ->AddPoint(results->GetResult(j)->VID, results->GetResult(j)->Dist); } ri += resultCount; iterscanned = results->GetScanned(); @@ -236,4 +243,4 @@ TEST(IterativeScanTest, SPANNRandomTest) TestIterativeScanRandom(IndexAlgoType::SPANN, "L2"); } -} +} // namespace IterativeScanTest diff --git a/Test/src/KVTest.cpp b/Test/src/KVTest.cpp index 84da6d687..320fd9575 100644 --- a/Test/src/KVTest.cpp +++ b/Test/src/KVTest.cpp @@ -130,21 +130,28 @@ void RunTest(std::string path, std::string type, bool debug = false) // } } -namespace KVTest { +namespace KVTest +{ -TEST(KVTest, RocksDBTest) { - if(!direxists("tmp_rocksdb")) mkdir("tmp_rocksdb"); +TEST(KVTest, RocksDBTest) +{ + if (!direxists("tmp_rocksdb")) + mkdir("tmp_rocksdb"); RunTest(std::string("tmp_rocksdb") + FolderSep + "test", "RocksDB", false); } -TEST(KVTest, SPDKTest) { - if(!direxists("tmp_spdk")) mkdir("tmp_spdk"); +TEST(KVTest, SPDKTest) +{ + if (!direxists("tmp_spdk")) + mkdir("tmp_spdk"); RunTest(std::string("tmp_spdk") + FolderSep + "test", "SPDK", false); } -TEST(KVTest, FileTest) { - if(!direxists("tmp_file")) mkdir("tmp_file"); +TEST(KVTest, FileTest) +{ + if (!direxists("tmp_file")) + mkdir("tmp_file"); RunTest(std::string("tmp_file") + FolderSep + "test", "File", false); } -} +} // namespace KVTest diff --git a/Test/src/MultiIndexExperiment.cpp b/Test/src/MultiIndexExperiment.cpp index 478422a2a..5b4db1b75 100644 --- a/Test/src/MultiIndexExperiment.cpp +++ b/Test/src/MultiIndexExperiment.cpp @@ -43,7 +43,8 @@ void BuildIndex(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shar std::shared_ptr &meta, const std::string out) { - std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); + std::shared_ptr vecIndex = + SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -232,10 +233,12 @@ template void TestMultiIndexScanN(SPTAG::IndexAlgoType algo, std::s } } -namespace MultiIndexExperimentTest { +namespace MultiIndexExperimentTest +{ -TEST(MultiIndexExperiment, BKTTest) { +TEST(MultiIndexExperiment, BKTTest) +{ TestMultiIndexScanN(SPTAG::IndexAlgoType::BKT, "InnerProduct", 2); } -} +} // namespace MultiIndexExperimentTest diff --git a/Test/src/MultiIndexScanTest.cpp b/Test/src/MultiIndexScanTest.cpp index c3954b69c..2196bc1b7 100644 --- a/Test/src/MultiIndexScanTest.cpp +++ b/Test/src/MultiIndexScanTest.cpp @@ -20,7 +20,8 @@ void BuildIndex(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shar std::shared_ptr &meta, const std::string out) { - std::shared_ptr vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); + std::shared_ptr vecIndex = + SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType()); ASSERT_NE(nullptr, vecIndex); vecIndex->SetParameter("DistCalcMethod", distCalcMethod); @@ -44,8 +45,8 @@ void MultiIndexSearch(unsigned int n, std::vector> &queries, int for (unsigned int i = 0; i < n; i++) { std::shared_ptr vecIndex; - ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(indexName(i).c_str(), vecIndex)); - ASSERT_NE(nullptr, vecIndex); + ASSERT_EQ(SPTAG::ErrorCode::Success, SPTAG::VectorIndex::LoadIndex(indexName(i).c_str(), vecIndex)); + ASSERT_NE(nullptr, vecIndex); vecIndices.push_back(vecIndex); p_targets.push_back(queries[i].data()); } @@ -124,10 +125,12 @@ template void TestMultiIndexScanN(SPTAG::IndexAlgoType algo, std::s MultiIndexSearch(n, queries, k, false, 10); } -namespace MultiIndexScanTest { +namespace MultiIndexScanTest +{ -TEST(MultiIndexScanTest, BKTTest) { +TEST(MultiIndexScanTest, BKTTest) +{ TestMultiIndexScanN(SPTAG::IndexAlgoType::BKT, "L2", 2); } -} +} // namespace MultiIndexScanTest diff --git a/Test/src/PerfTest.cpp b/Test/src/PerfTest.cpp index 37492e064..0df541e3e 100644 --- a/Test/src/PerfTest.cpp +++ b/Test/src/PerfTest.cpp @@ -273,14 +273,17 @@ template void PTest(IndexAlgoType algo, std::string distCalcMethod) Search(vecIndex, queryset, 10, truth); } -namespace PerfTest { +namespace PerfTest +{ -TEST(PerfTest, BKTTest) { +TEST(PerfTest, BKTTest) +{ PTest(IndexAlgoType::BKT, "Cosine"); } -TEST(PerfTest, KDTTest) { +TEST(PerfTest, KDTTest) +{ PTest(IndexAlgoType::KDT, "Cosine"); } -} \ No newline at end of file +} // namespace PerfTest \ No newline at end of file diff --git a/Test/src/ReconstructIndexSimilarityTest.cpp b/Test/src/ReconstructIndexSimilarityTest.cpp index f5d7988ed..c9247e928 100644 --- a/Test/src/ReconstructIndexSimilarityTest.cpp +++ b/Test/src/ReconstructIndexSimilarityTest.cpp @@ -446,7 +446,7 @@ template void ReconstructTest(IndexAlgoType algo, DistCalcMethod di namespace ReconstructIndexSimilarityTest { -TEST(ReconstructIndexSimilarityTest, BKTReconstructTest) +TEST(ReconstructIndexSimilarityTest, DISABLE_BKTReconstructTest) { ReconstructTest(IndexAlgoType::BKT, DistCalcMethod::L2); } diff --git a/Test/src/SPFreshTest.cpp b/Test/src/SPFreshTest.cpp index 0cb8a2335..dc7dbfaf4 100644 --- a/Test/src/SPFreshTest.cpp +++ b/Test/src/SPFreshTest.cpp @@ -489,7 +489,7 @@ TEST(SPFreshTest, TestClone) ASSERT_EQ(originalIndex->SaveIndex("original_index"), ErrorCode::Success); originalIndex = nullptr; - auto clonedIndex = VectorIndex::Clone("original_index", "cloned_index"); + auto clonedIndex = originalIndex->Clone("cloned_index"); ASSERT_NE(clonedIndex, nullptr); ASSERT_EQ(clonedIndex->SaveIndex("cloned_index"), ErrorCode::Success); clonedIndex = nullptr; @@ -806,7 +806,7 @@ TEST(SPFreshTest, IndexShadowCloneLifecycleKeepLast) } // Clone to shadow - ASSERT_NE(loaded->Clone(shadowIndexName) != nullptr); + ASSERT_NE(loaded->Clone(shadowIndexName), nullptr); loaded.reset(); std::shared_ptr shadowLoaded; From 86336af021a6a8306d410b9993e7d531ed0c24df Mon Sep 17 00:00:00 2001 From: Avinash Varma Date: Tue, 2 Sep 2025 18:28:23 +0530 Subject: [PATCH 4/4] Enabling test --- Test/src/ReconstructIndexSimilarityTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Test/src/ReconstructIndexSimilarityTest.cpp b/Test/src/ReconstructIndexSimilarityTest.cpp index c9247e928..f5d7988ed 100644 --- a/Test/src/ReconstructIndexSimilarityTest.cpp +++ b/Test/src/ReconstructIndexSimilarityTest.cpp @@ -446,7 +446,7 @@ template void ReconstructTest(IndexAlgoType algo, DistCalcMethod di namespace ReconstructIndexSimilarityTest { -TEST(ReconstructIndexSimilarityTest, DISABLE_BKTReconstructTest) +TEST(ReconstructIndexSimilarityTest, BKTReconstructTest) { ReconstructTest(IndexAlgoType::BKT, DistCalcMethod::L2); }