Enable for faiss tests (#3002)

Summary:
Pull Request resolved: https://github.com/facebookresearch/faiss/pull/3002

title

Reviewed By: jbardini

Differential Revision: D48266242

fbshipit-source-id: b53e186f1954916a90dc8dbba67963f40d0aead7

tests/test_RCQ_cropping.cpp

@@ -13,7 +13,7 @@
 /* This test creates a 3-level RCQ and performs a search on it.
  * Then it crops the RCQ to just the 2 first levels and verifies that
  * the 3-level vectors are in a subtree that was visited in the 2-level RCQ. */
-TEST(RCQ_cropping, test_cropping) {
+TEST(RCQCropping, test_cropping) {
     size_t nq = 10, nt = 2000, nb = 1000, d = 32;
 
     using idx_t = faiss::idx_t;
@@ -74,7 +74,7 @@ TEST(RCQ_cropping, test_cropping) {
     }
 }
 
-TEST(RCQ_cropping, search_params) {
+TEST(RCQCropping, search_params) {
     size_t nq = 10, nt = 2000, nb = 1000, d = 32;
 
     using idx_t = faiss::idx_t;

tests/test_approx_topk.cpp

@@ -188,7 +188,7 @@ void test_approx_topk(
 }
 
 //
-TEST(TEST_APPROX_TOPK, COMMON) {
+TEST(testApproxTopk, COMMON) {
     constexpr bool verbose = false;
 
     //

tests/test_code_distance.cpp

@@ -223,18 +223,18 @@ void test(
 
 constexpr size_t NELEMENTS = 10000;
 
-TEST(TEST_CODE_DISTANCE, SUBQ4_NBITS8) {
+TEST(TestCodeDistance, SUBQ4_NBITS8) {
     test(256, 4, 8, NELEMENTS);
 }
 
-TEST(TEST_CODE_DISTANCE, SUBQ8_NBITS8) {
+TEST(TestCodeDistance, SUBQ8_NBITS8) {
     test(256, 8, 8, NELEMENTS);
 }
 
-TEST(TEST_CODE_DISTANCE, SUBQ16_NBITS8) {
+TEST(TestCodeDistance, SUBQ16_NBITS8) {
     test(256, 16, 8, NELEMENTS);
 }
 
-TEST(TEST_CODE_DISTANCE, SUBQ32_NBITS8) {
+TEST(TestCodeDistance, SUBQ32_NBITS8) {
     test(256, 32, 8, NELEMENTS);
 }

tests/test_cppcontrib_sa_decode.cpp

@@ -1034,147 +1034,147 @@ void testMinMaxIndexPQDecoder(
 constexpr size_t NSAMPLES = 256;
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_IVF256_PQ16) {
+TEST(testCppcontribSaDecode, D256_IVF256_PQ16) {
     using T = faiss::cppcontrib::Index2LevelDecoder<256, 256, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 256, "IVF256,PQ16np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_IVF256_PQ8) {
+TEST(testCppcontribSaDecode, D256_IVF256_PQ8) {
     using T = faiss::cppcontrib::Index2LevelDecoder<256, 256, 32>;
     testIndex2LevelDecoder<T>(NSAMPLES, 256, "IVF256,PQ8np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D192_IVF256_PQ24) {
+TEST(testCppcontribSaDecode, D192_IVF256_PQ24) {
     using T = faiss::cppcontrib::Index2LevelDecoder<192, 192, 8>;
     testIndex2LevelDecoder<T>(NSAMPLES, 192, "IVF256,PQ24np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D192_IVF256_PQ16) {
+TEST(testCppcontribSaDecode, D192_IVF256_PQ16) {
     using T = faiss::cppcontrib::Index2LevelDecoder<192, 192, 12>;
     testIndex2LevelDecoder<T>(NSAMPLES, 192, "IVF256,PQ16np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D192_IVF256_PQ12) {
+TEST(testCppcontribSaDecode, D192_IVF256_PQ12) {
     using T = faiss::cppcontrib::Index2LevelDecoder<192, 192, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 192, "IVF256,PQ12np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_IVF256_PQ40) {
+TEST(testCppcontribSaDecode, D160_IVF256_PQ40) {
     using T = faiss::cppcontrib::Index2LevelDecoder<160, 160, 4>;
     testIndex2LevelDecoder<T>(NSAMPLES, 160, "IVF256,PQ40np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_IVF256_PQ20) {
+TEST(testCppcontribSaDecode, D160_IVF256_PQ20) {
     using T = faiss::cppcontrib::Index2LevelDecoder<160, 160, 8>;
     testIndex2LevelDecoder<T>(NSAMPLES, 160, "IVF256,PQ20np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_IVF256_PQ10) {
+TEST(testCppcontribSaDecode, D160_IVF256_PQ10) {
     using T = faiss::cppcontrib::Index2LevelDecoder<160, 160, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 160, "IVF256,PQ10np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_IVF256_PQ8) {
+TEST(testCppcontribSaDecode, D160_IVF256_PQ8) {
     using T = faiss::cppcontrib::Index2LevelDecoder<160, 160, 20>;
     testIndex2LevelDecoder<T>(NSAMPLES, 160, "IVF256,PQ8np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D128_IVF256_PQ8) {
+TEST(testCppcontribSaDecode, D128_IVF256_PQ8) {
     using T = faiss::cppcontrib::Index2LevelDecoder<128, 128, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 128, "IVF256,PQ8np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D128_IVF256_PQ4) {
+TEST(testCppcontribSaDecode, D128_IVF256_PQ4) {
     using T = faiss::cppcontrib::Index2LevelDecoder<128, 128, 32>;
     testIndex2LevelDecoder<T>(NSAMPLES, 128, "IVF256,PQ4np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D64_IVF256_PQ16) {
+TEST(testCppcontribSaDecode, D64_IVF256_PQ16) {
     using T = faiss::cppcontrib::Index2LevelDecoder<64, 64, 8>;
     testIndex2LevelDecoder<T>(NSAMPLES, 64, "IVF256,PQ8np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D64_IVF256_PQ8) {
+TEST(testCppcontribSaDecode, D64_IVF256_PQ8) {
     using T = faiss::cppcontrib::Index2LevelDecoder<64, 64, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 64, "IVF256,PQ4np");
 }
 
 #if defined(__AVX2__)
-TEST(TEST_CPPCONTRIB_SA_DECODE, D40_IVF256_PQ20) {
+TEST(testCppcontribSaDecode, D40_IVF256_PQ20) {
     using T = faiss::cppcontrib::Index2LevelDecoder<40, 40, 2>;
     testIndex2LevelDecoder<T>(NSAMPLES, 40, "IVF256,PQ20np");
 }
 #endif
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_Residual4x8_PQ16) {
+TEST(testCppcontribSaDecode, D256_Residual4x8_PQ16) {
     using T = faiss::cppcontrib::Index2LevelDecoder<256, 64, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 256, "Residual4x8,PQ16");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_Residual4x8_PQ8) {
+TEST(testCppcontribSaDecode, D256_Residual4x8_PQ8) {
     using T = faiss::cppcontrib::Index2LevelDecoder<256, 64, 32>;
     testIndex2LevelDecoder<T>(NSAMPLES, 256, "Residual4x8,PQ8");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_Residual4x8_PQ10) {
+TEST(testCppcontribSaDecode, D160_Residual4x8_PQ10) {
     using T = faiss::cppcontrib::Index2LevelDecoder<160, 40, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 160, "Residual4x8,PQ10");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_Residual2x8_PQ10) {
+TEST(testCppcontribSaDecode, D160_Residual2x8_PQ10) {
     using T = faiss::cppcontrib::Index2LevelDecoder<160, 80, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 160, "Residual2x8,PQ10");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_Residual1x8_PQ10) {
+TEST(testCppcontribSaDecode, D160_Residual1x8_PQ10) {
     using T = faiss::cppcontrib::Index2LevelDecoder<160, 160, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 160, "Residual1x8,PQ10");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D128_Residual4x8_PQ8) {
+TEST(testCppcontribSaDecode, D128_Residual4x8_PQ8) {
     using T = faiss::cppcontrib::Index2LevelDecoder<128, 32, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 128, "Residual4x8,PQ8");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D128_Residual4x8_PQ4) {
+TEST(testCppcontribSaDecode, D128_Residual4x8_PQ4) {
     using T = faiss::cppcontrib::Index2LevelDecoder<128, 32, 32>;
     testIndex2LevelDecoder<T>(NSAMPLES, 128, "Residual4x8,PQ4");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D64_Residual4x8_PQ8) {
+TEST(testCppcontribSaDecode, D64_Residual4x8_PQ8) {
     using T = faiss::cppcontrib::Index2LevelDecoder<64, 16, 8>;
     testIndex2LevelDecoder<T>(NSAMPLES, 64, "Residual4x8,PQ8");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D64_Residual4x8_PQ4) {
+TEST(testCppcontribSaDecode, D64_Residual4x8_PQ4) {
     using T = faiss::cppcontrib::Index2LevelDecoder<64, 16, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES, 64, "Residual4x8,PQ4");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_IVF1024_PQ16) {
+TEST(testCppcontribSaDecode, D256_IVF1024_PQ16) {
     // It is acceptable to use COARSE_BITS=16 in this case,
     // because there's only one coarse quantizer element.
     using T = faiss::cppcontrib::Index2LevelDecoder<256, 256, 16, 16>;
     testIndex2LevelDecoder<T>(NSAMPLES * 4, 256, "IVF1024,PQ16np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D64_Residual1x9_PQ8) {
+TEST(testCppcontribSaDecode, D64_Residual1x9_PQ8) {
     // It is acceptable to use COARSE_BITS=16 in this case,
     // because there's only one coarse quantizer element.
     // It won't work for "Residual2x9,PQ8".
@@ -1183,45 +1183,45 @@ TEST(TEST_CPPCONTRIB_SA_DECODE, D64_Residual1x9_PQ8) {
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_PQ16) {
+TEST(testCppcontribSaDecode, D256_PQ16) {
     using T = faiss::cppcontrib::IndexPQDecoder<256, 16>;
     testIndexPQDecoder<T>(NSAMPLES, 256, "PQ16np");
 }
 
 //
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_PQ20) {
+TEST(testCppcontribSaDecode, D160_PQ20) {
     using T = faiss::cppcontrib::IndexPQDecoder<160, 8>;
     testIndexPQDecoder<T>(NSAMPLES, 160, "PQ20np");
 }
 
 #if defined(__AVX2__)
-TEST(TEST_CPPCONTRIB_SA_DECODE, D40_PQ20) {
+TEST(testCppcontribSaDecode, D40_PQ20) {
     using T = faiss::cppcontrib::IndexPQDecoder<40, 2>;
     testIndexPQDecoder<T>(NSAMPLES, 40, "PQ20np");
 }
 #endif
 
 // test IndexRowwiseMinMaxFP16
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_MINMAXFP16_IVF256_PQ16) {
+TEST(testCppcontribSaDecode, D256_MINMAXFP16_IVF256_PQ16) {
     using SubT = faiss::cppcontrib::Index2LevelDecoder<256, 256, 16>;
     using T = faiss::cppcontrib::IndexMinMaxFP16Decoder<SubT>;
     testMinMaxIndex2LevelDecoder<T>(NSAMPLES, 256, "MinMaxFP16,IVF256,PQ16np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_MINMAXFP16_PQ16) {
+TEST(testCppcontribSaDecode, D256_MINMAXFP16_PQ16) {
     using SubT = faiss::cppcontrib::IndexPQDecoder<256, 16>;
     using T = faiss::cppcontrib::IndexMinMaxFP16Decoder<SubT>;
     testMinMaxIndexPQDecoder<T>(NSAMPLES, 256, "MinMaxFP16,PQ16np");
 }
 
 // test IndexRowwiseMinMax
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_MINMAX_IVF256_PQ16) {
+TEST(testCppcontribSaDecode, D256_MINMAX_IVF256_PQ16) {
     using SubT = faiss::cppcontrib::Index2LevelDecoder<256, 256, 16>;
     using T = faiss::cppcontrib::IndexMinMaxDecoder<SubT>;
     testMinMaxIndex2LevelDecoder<T>(NSAMPLES, 256, "MinMax,IVF256,PQ16np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_MINMAX_PQ16) {
+TEST(testCppcontribSaDecode, D256_MINMAX_PQ16) {
     using SubT = faiss::cppcontrib::IndexPQDecoder<256, 16>;
     using T = faiss::cppcontrib::IndexMinMaxDecoder<SubT>;
     testMinMaxIndexPQDecoder<T>(NSAMPLES, 256, "MinMax,PQ16np");
@@ -1229,63 +1229,63 @@ TEST(TEST_CPPCONTRIB_SA_DECODE, D256_MINMAX_PQ16) {
 
 // implemented for AVX2 and ARM so far
 #if defined(__AVX2__) || defined(__ARM_NEON)
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_PQ16x10) {
+TEST(testCppcontribSaDecode, D256_PQ16x10) {
     using T = faiss::cppcontrib::IndexPQDecoder<256, 16, 10>;
     testIndexPQDecoder<T>(NSAMPLES * 4, 256, "PQ16x10np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_PQ16x12) {
+TEST(testCppcontribSaDecode, D256_PQ16x12) {
     using T = faiss::cppcontrib::IndexPQDecoder<256, 16, 12>;
     testIndexPQDecoder<T>(NSAMPLES * 16, 256, "PQ16x12np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_PQ20x10) {
+TEST(testCppcontribSaDecode, D160_PQ20x10) {
     using T = faiss::cppcontrib::IndexPQDecoder<160, 8, 10>;
     testIndexPQDecoder<T>(NSAMPLES * 4, 160, "PQ20x10np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_PQ20x12) {
+TEST(testCppcontribSaDecode, D160_PQ20x12) {
     using T = faiss::cppcontrib::IndexPQDecoder<160, 8, 12>;
     testIndexPQDecoder<T>(NSAMPLES * 16, 160, "PQ20x12np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_IVF256_PQ16x10) {
+TEST(testCppcontribSaDecode, D256_IVF256_PQ16x10) {
     using T = faiss::cppcontrib::Index2LevelDecoder<256, 256, 16, 8, 10>;
     testIndex2LevelDecoder<T>(NSAMPLES * 4, 256, "IVF256,PQ16x10np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_IVF256_PQ16x12) {
+TEST(testCppcontribSaDecode, D256_IVF256_PQ16x12) {
     using T = faiss::cppcontrib::Index2LevelDecoder<256, 256, 16, 8, 12>;
     testIndex2LevelDecoder<T>(NSAMPLES * 16, 256, "IVF256,PQ16x12np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_MINMAXFP16_IVF256_PQ16x10) {
+TEST(testCppcontribSaDecode, D256_MINMAXFP16_IVF256_PQ16x10) {
     using SubT = faiss::cppcontrib::Index2LevelDecoder<256, 256, 16, 8, 10>;
     using T = faiss::cppcontrib::IndexMinMaxFP16Decoder<SubT>;
     testMinMaxIndex2LevelDecoder<T>(
             NSAMPLES * 4, 256, "MinMaxFP16,IVF256,PQ16x10np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_MINMAXFP16_IVF1024_PQ16x10) {
+TEST(testCppcontribSaDecode, D256_MINMAXFP16_IVF1024_PQ16x10) {
     using SubT = faiss::cppcontrib::Index2LevelDecoder<256, 256, 16, 10, 10>;
     using T = faiss::cppcontrib::IndexMinMaxFP16Decoder<SubT>;
     testMinMaxIndex2LevelDecoder<T>(
             NSAMPLES * 4, 256, "MinMaxFP16,IVF1024,PQ16x10np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_MINMAXFP16_IVF1024_PQ16x10_ALTERNATIVE) {
+TEST(testCppcontribSaDecode, D256_MINMAXFP16_IVF1024_PQ16x10_ALTERNATIVE) {
     using SubT = faiss::cppcontrib::Index2LevelDecoder<256, 256, 16, 16, 10>;
     using T = faiss::cppcontrib::IndexMinMaxFP16Decoder<SubT>;
     testMinMaxIndex2LevelDecoder<T>(
             NSAMPLES * 4, 256, "MinMaxFP16,IVF1024,PQ16x10np");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D160_Residual4x8_PQ8x10) {
+TEST(testCppcontribSaDecode, D160_Residual4x8_PQ8x10) {
     using T = faiss::cppcontrib::Index2LevelDecoder<160, 40, 20, 8, 10>;
     testIndex2LevelDecoder<T>(NSAMPLES * 4, 160, "Residual4x8,PQ8x10");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_Residual1x9_PQ16x10) {
+TEST(testCppcontribSaDecode, D256_Residual1x9_PQ16x10) {
     // It is acceptable to use COARSE_BITS=16 in this case,
     // because there's only one coarse quantizer element.
     // It won't work for "Residual2x9,PQ16x10".
@@ -1293,12 +1293,12 @@ TEST(TEST_CPPCONTRIB_SA_DECODE, D256_Residual1x9_PQ16x10) {
     testIndex2LevelDecoder<T>(NSAMPLES * 4, 256, "Residual1x9,PQ16x10");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_Residual4x10_PQ16x10) {
+TEST(testCppcontribSaDecode, D256_Residual4x10_PQ16x10) {
     using T = faiss::cppcontrib::Index2LevelDecoder<256, 64, 16, 10, 10>;
     testIndex2LevelDecoder<T>(NSAMPLES * 4, 256, "Residual4x10,PQ16x10");
 }
 
-TEST(TEST_CPPCONTRIB_SA_DECODE, D256_Residual4x12_PQ16x12) {
+TEST(testCppcontribSaDecode, D256_Residual4x12_PQ16x12) {
     using T = faiss::cppcontrib::Index2LevelDecoder<256, 64, 16, 12, 12>;
     testIndex2LevelDecoder<T>(NSAMPLES * 16, 256, "Residual4x12,PQ16x12");
 }

tests/test_cppcontrib_uintreader.cpp

@@ -97,18 +97,18 @@ void TestUintReaderBits() {
     TestUintReader<17, CODE_BITS>();
 }
 
-TEST(TEST_CPPCONTRIB_UINTREADER, Test8bit) {
+TEST(testCppcontribUintreader, Test8bit) {
     TestUintReaderBits<8>();
 }
 
-TEST(TEST_CPPCONTRIB_UINTREADER, Test10bit) {
+TEST(testCppcontribUintreader, Test10bit) {
     TestUintReaderBits<10>();
 }
 
-TEST(TEST_CPPCONTRIB_UINTREADER, Test12bit) {
+TEST(testCppcontribUintreader, Test12bit) {
     TestUintReaderBits<12>();
 }
 
-TEST(TEST_CPPCONTRIB_UINTREADER, Test16bit) {
+TEST(testCppcontribUintreader, Test16bit) {
     TestUintReaderBits<16>();
 }

tests/test_distances_simd.cpp

@@ -41,7 +41,7 @@ void fvec_L2sqr_ny_ref(
 }
 
 // test templated versions of fvec_L2sqr_ny
-TEST(TEST_FVEC_L2SQR_NY, D2) {
+TEST(TestFvecL2sqrNy, D2) {
     // we're using int values in order to get 100% accurate
     // results with floats.
     std::default_random_engine rng(123);
@@ -75,7 +75,7 @@ TEST(TEST_FVEC_L2SQR_NY, D2) {
 }
 
 // fvec_inner_products_ny
-TEST(TEST_FVEC_INNER_PRODUCTS_NY, D2) {
+TEST(TestFvecInnerProductsNy, D2) {
     // we're using int values in order to get 100% accurate
     // results with floats.
     std::default_random_engine rng(123);

tests/test_pairs_decoding.cpp

@@ -171,23 +171,23 @@ int test_search_and_return_centroids(const char* index_key) {
  * Test entry points
  *************************************************************/
 
-TEST(test_search_centroid, IVFFlat) {
+TEST(testSearchCentroid, IVFFlat) {
     bool ok = test_search_centroid("IVF32,Flat");
     EXPECT_TRUE(ok);
 }
 
-TEST(test_search_centroid, PCAIVFFlat) {
+TEST(testSearchCentroid, PCAIVFFlat) {
     bool ok = test_search_centroid("PCA16,IVF32,Flat");
     EXPECT_TRUE(ok);
 }
 
-TEST(test_search_and_return_centroids, IVFFlat) {
+TEST(testSearchAndReturnCentroids, IVFFlat) {
     int err = test_search_and_return_centroids("IVF32,Flat");
     EXPECT_NE(err, 1);
     EXPECT_NE(err, 2);
 }
 
-TEST(test_search_and_return_centroids, PCAIVFFlat) {
+TEST(testSearchAndReturnCentroids, PCAIVFFlat) {
     int err = test_search_and_return_centroids("PCA16,IVF32,Flat");
     EXPECT_NE(err, 1);
     EXPECT_NE(err, 2);

tests/test_simdlib.cpp

@@ -11,7 +11,7 @@
 
 using namespace faiss;
 
-TEST(TEST_SIMDLIB, TestCmpltAndBlendInplace) {
+TEST(TestSIMDLib, TestCmpltAndBlendInplace) {
     simd8float32 lowestValues(0, 1, 2, 3, 4, 5, 6, 7);
     simd8uint32 lowestIndices(0, 1, 2, 3, 4, 5, 6, 7);
 
@@ -36,7 +36,7 @@ TEST(TEST_SIMDLIB, TestCmpltAndBlendInplace) {
     ASSERT_TRUE(lowestIndices.is_same_as(expectedIndices));
 }
 
-TEST(TEST_SIMDLIB, TestCmpltMinMaxFloat) {
+TEST(TestSIMDLib, TestCmpltMinMaxFloat) {
     simd8float32 minValues(0, 0, 0, 0, 0, 0, 0, 0);
     simd8uint32 minIndices(0, 0, 0, 0, 0, 0, 0, 0);
     simd8float32 maxValues(0, 0, 0, 0, 0, 0, 0, 0);
@@ -69,7 +69,7 @@ TEST(TEST_SIMDLIB, TestCmpltMinMaxFloat) {
     ASSERT_TRUE(maxIndices.is_same_as(expectedMaxIndices));
 }
 
-TEST(TEST_SIMDLIB, TestCmpltMinMaxInt) {
+TEST(TestSIMDLib, TestCmpltMinMaxInt) {
     simd8uint32 minValues(0, 0, 0, 0, 0, 0, 0, 0);
     simd8uint32 minIndices(0, 0, 0, 0, 0, 0, 0, 0);
     simd8uint32 maxValues(0, 0, 0, 0, 0, 0, 0, 0);
@@ -102,7 +102,7 @@ TEST(TEST_SIMDLIB, TestCmpltMinMaxInt) {
     ASSERT_TRUE(maxIndices.is_same_as(expectedMaxIndices));
 }
 
-TEST(TEST_SIMDLIB, TestCmpltMinMaxInt16) {
+TEST(TestSIMDLib, TestCmpltMinMaxInt16) {
     simd16uint16 minValues(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
     simd16uint16 minIndices(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
     simd16uint16 maxValues(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);