andreacavalli/rocksdb
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "Update googletest from 1.8.1 to 1.10.0 (#6808)" (#6923)

Browse Source 
Summary:
This reverts commit 8d87e9cea1.

Based on offline discussions, it's too early to upgrade to gtest 1.10, as it prevents some developers from using an older version of gtest to integrate to some other systems. Revert it for now.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6923

Reviewed By: pdillinger

Differential Revision: D21864799

fbshipit-source-id: d0726b1ff649fc911b9378f1763316200bd363fc
This commit is contained in:
sdong 2020-06-03 15:53:09 -07:00 committed by Facebook GitHub Bot
parent 0f85d163e6
commit afa3518839
49 changed files with 11989 additions and 5119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -523,7 +523,7 @@ endif()
include_directories(${PROJECT_SOURCE_DIR}) include_directories(${PROJECT_SOURCE_DIR})
include_directories(${PROJECT_SOURCE_DIR}/include) include_directories(${PROJECT_SOURCE_DIR}/include)
include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/third-party/gtest-1.10.0/fused-src) include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/third-party/gtest-1.8.1/fused-src)
if(WITH_FOLLY_DISTRIBUTED_MUTEX) if(WITH_FOLLY_DISTRIBUTED_MUTEX)
include_directories(${PROJECT_SOURCE_DIR}/third-party/folly) include_directories(${PROJECT_SOURCE_DIR}/third-party/folly)
endif() endif()
@ -969,7 +969,7 @@ endif()
CMAKE_DEPENDENT_OPTION(WITH_TESTS "build with tests" ON CMAKE_DEPENDENT_OPTION(WITH_TESTS "build with tests" ON
"CMAKE_BUILD_TYPE STREQUAL Debug" OFF) "CMAKE_BUILD_TYPE STREQUAL Debug" OFF)
if(WITH_TESTS) if(WITH_TESTS)
add_subdirectory(third-party/gtest-1.10.0/fused-src/gtest) add_subdirectory(third-party/gtest-1.8.1/fused-src/gtest)
add_library(testharness STATIC add_library(testharness STATIC
test_util/testharness.cc) test_util/testharness.cc)
target_link_libraries(testharness gtest) target_link_libraries(testharness gtest)

2
Makefile
View File

@ -334,7 +334,7 @@ endif
export GTEST_THROW_ON_FAILURE=1 export GTEST_THROW_ON_FAILURE=1
export GTEST_HAS_EXCEPTIONS=1 export GTEST_HAS_EXCEPTIONS=1
GTEST_DIR = third-party/gtest-1.10.0/fused-src GTEST_DIR = third-party/gtest-1.8.1/fused-src
# AIX: pre-defined system headers are surrounded by an extern "C" block # AIX: pre-defined system headers are surrounded by an extern "C" block
ifeq ($(PLATFORM), OS_AIX) ifeq ($(PLATFORM), OS_AIX)
PLATFORM_CCFLAGS += -I$(GTEST_DIR) PLATFORM_CCFLAGS += -I$(GTEST_DIR)

6
TARGETS
View File

@ -78,7 +78,7 @@ ROCKSDB_PREPROCESSOR_FLAGS = [
# Directories with files for #include # Directories with files for #include
"-I" + REPO_PATH + "include/", "-I" + REPO_PATH + "include/",
"-I" + REPO_PATH, "-I" + REPO_PATH,
"-I" + REPO_PATH + "third-party/gtest-1.10.0/fused-src/", "-I" + REPO_PATH + "third-party/gtest-1.8.1/fused-src/",
] ]
ROCKSDB_ARCH_PREPROCESSOR_FLAGS = { ROCKSDB_ARCH_PREPROCESSOR_FLAGS = {
@ -451,8 +451,8 @@ cpp_library(
cpp_library( cpp_library(
name = "rocksdb_third_party_gtest", name = "rocksdb_third_party_gtest",
srcs = ["third-party/gtest-1.10.0/fused-src/gtest/gtest-all.cc"], srcs = ["third-party/gtest-1.8.1/fused-src/gtest/gtest-all.cc"],
headers = ["third-party/gtest-1.10.0/fused-src/gtest/gtest.h"], headers = ["third-party/gtest-1.8.1/fused-src/gtest/gtest.h"],
arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS, arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
compiler_flags = ROCKSDB_COMPILER_FLAGS, compiler_flags = ROCKSDB_COMPILER_FLAGS,
os_deps = ROCKSDB_OS_DEPS, os_deps = ROCKSDB_OS_DEPS,

9
cache/cache_test.cc vendored
View File

@ -758,13 +758,12 @@ TEST_P(CacheTest, GetCharge) {
#ifdef SUPPORT_CLOCK_CACHE #ifdef SUPPORT_CLOCK_CACHE
std::shared_ptr<Cache> (*new_clock_cache_func)( std::shared_ptr<Cache> (*new_clock_cache_func)(
size_t, int, bool, CacheMetadataChargePolicy) = NewClockCache; size_t, int, bool, CacheMetadataChargePolicy) = NewClockCache;
INSTANTIATE_TEST_SUITE_P(CacheTestInstance, CacheTest, INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest,
testing::Values(kLRU, kClock)); testing::Values(kLRU, kClock));
#else #else
INSTANTIATE_TEST_SUITE_P(CacheTestInstance, CacheTest, testing::Values(kLRU)); INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest, testing::Values(kLRU));
#endif // SUPPORT_CLOCK_CACHE #endif // SUPPORT_CLOCK_CACHE
INSTANTIATE_TEST_SUITE_P(CacheTestInstance, LRUCacheTest, INSTANTIATE_TEST_CASE_P(CacheTestInstance, LRUCacheTest, testing::Values(kLRU));
testing::Values(kLRU));
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

12
db/column_family_test.cc
View File

@ -560,10 +560,10 @@ class ColumnFamilyTest
ColumnFamilyTest() : ColumnFamilyTestBase(GetParam()) {} ColumnFamilyTest() : ColumnFamilyTestBase(GetParam()) {}
}; };
INSTANTIATE_TEST_SUITE_P(FormatDef, ColumnFamilyTest, INSTANTIATE_TEST_CASE_P(FormatDef, ColumnFamilyTest,
testing::Values(test::kDefaultFormatVersion)); testing::Values(test::kDefaultFormatVersion));
INSTANTIATE_TEST_SUITE_P(FormatLatest, ColumnFamilyTest, INSTANTIATE_TEST_CASE_P(FormatLatest, ColumnFamilyTest,
testing::Values(test::kLatestFormatVersion)); testing::Values(test::kLatestFormatVersion));
TEST_P(ColumnFamilyTest, DontReuseColumnFamilyID) { TEST_P(ColumnFamilyTest, DontReuseColumnFamilyID) {
for (int iter = 0; iter < 3; ++iter) { for (int iter = 0; iter < 3; ++iter) {
@ -749,11 +749,11 @@ TEST_P(FlushEmptyCFTestWithParam, FlushEmptyCFTest2) {
db_options_.env = env_; db_options_.env = env_;
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
FormatDef, FlushEmptyCFTestWithParam, FormatDef, FlushEmptyCFTestWithParam,
testing::Values(std::make_tuple(test::kDefaultFormatVersion, true), testing::Values(std::make_tuple(test::kDefaultFormatVersion, true),
std::make_tuple(test::kDefaultFormatVersion, false))); std::make_tuple(test::kDefaultFormatVersion, false)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
FormatLatest, FlushEmptyCFTestWithParam, FormatLatest, FlushEmptyCFTestWithParam,
testing::Values(std::make_tuple(test::kLatestFormatVersion, true), testing::Values(std::make_tuple(test::kLatestFormatVersion, true),
std::make_tuple(test::kLatestFormatVersion, false))); std::make_tuple(test::kLatestFormatVersion, false)));

4
db/compaction/compaction_iterator_test.cc
View File

@ -697,8 +697,8 @@ TEST_P(CompactionIteratorTest, RemoveSingleDeletionAtBottomLevel) {
nullptr /*compaction_filter*/, true /*bottommost_level*/); nullptr /*compaction_filter*/, true /*bottommost_level*/);
} }
INSTANTIATE_TEST_SUITE_P(CompactionIteratorTestInstance, CompactionIteratorTest, INSTANTIATE_TEST_CASE_P(CompactionIteratorTestInstance, CompactionIteratorTest,
testing::Values(true, false)); testing::Values(true, false));
// Tests how CompactionIterator work together with SnapshotChecker. // Tests how CompactionIterator work together with SnapshotChecker.
class CompactionIteratorWithSnapshotCheckerTest class CompactionIteratorWithSnapshotCheckerTest

4
db/compaction/compaction_job_stats_test.cc
View File

@ -1017,8 +1017,8 @@ TEST_P(CompactionJobStatsTest, UniversalCompactionTest) {
ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 0U); ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 0U);
} }
INSTANTIATE_TEST_SUITE_P(CompactionJobStatsTest, CompactionJobStatsTest, INSTANTIATE_TEST_CASE_P(CompactionJobStatsTest, CompactionJobStatsTest,
::testing::Values(1, 4)); ::testing::Values(1, 4));
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE
int main(int argc, char** argv) { int main(int argc, char** argv) {

8
db/comparator_db_test.cc
View File

@ -314,10 +314,10 @@ class ComparatorDBTest
} }
}; };
INSTANTIATE_TEST_SUITE_P(FormatDef, ComparatorDBTest, INSTANTIATE_TEST_CASE_P(FormatDef, ComparatorDBTest,
testing::Values(test::kDefaultFormatVersion)); testing::Values(test::kDefaultFormatVersion));
INSTANTIATE_TEST_SUITE_P(FormatLatest, ComparatorDBTest, INSTANTIATE_TEST_CASE_P(FormatLatest, ComparatorDBTest,
testing::Values(test::kLatestFormatVersion)); testing::Values(test::kLatestFormatVersion));
TEST_P(ComparatorDBTest, Bytewise) { TEST_P(ComparatorDBTest, Bytewise) {
for (int rand_seed = 301; rand_seed < 306; rand_seed++) { for (int rand_seed = 301; rand_seed < 306; rand_seed++) {

32
db/db_basic_test.cc
View File

@ -1251,8 +1251,8 @@ TEST_P(DBMultiGetTestWithParam, MultiGetMultiCFSnapshot) {
} }
} }
INSTANTIATE_TEST_SUITE_P(DBMultiGetTestWithParam, DBMultiGetTestWithParam, INSTANTIATE_TEST_CASE_P(DBMultiGetTestWithParam, DBMultiGetTestWithParam,
testing::Bool()); testing::Bool());
TEST_F(DBBasicTest, MultiGetBatchedSimpleUnsorted) { TEST_F(DBBasicTest, MultiGetBatchedSimpleUnsorted) {
do { do {
@ -1773,8 +1773,8 @@ TEST_P(MultiGetPrefixExtractorTest, Batched) {
ASSERT_EQ(get_perf_context()->bloom_sst_hit_count, 4); ASSERT_EQ(get_perf_context()->bloom_sst_hit_count, 4);
} }
INSTANTIATE_TEST_SUITE_P(MultiGetPrefix, MultiGetPrefixExtractorTest, INSTANTIATE_TEST_CASE_P(MultiGetPrefix, MultiGetPrefixExtractorTest,
::testing::Bool()); ::testing::Bool());
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
class DBMultiGetRowCacheTest : public DBBasicTest, class DBMultiGetRowCacheTest : public DBBasicTest,
@ -1865,8 +1865,8 @@ TEST_P(DBMultiGetRowCacheTest, MultiGetBatched) {
} while (ChangeCompactOptions()); } while (ChangeCompactOptions());
} }
INSTANTIATE_TEST_SUITE_P(DBMultiGetRowCacheTest, DBMultiGetRowCacheTest, INSTANTIATE_TEST_CASE_P(DBMultiGetRowCacheTest, DBMultiGetRowCacheTest,
testing::Values(true, false)); testing::Values(true, false));
TEST_F(DBBasicTest, GetAllKeyVersions) { TEST_F(DBBasicTest, GetAllKeyVersions) {
Options options = CurrentOptions(); Options options = CurrentOptions();
@ -2630,16 +2630,16 @@ TEST_P(DBBasicTestWithParallelIO, MultiGetWithMissingFile) {
SyncPoint::GetInstance()->DisableProcessing(); SyncPoint::GetInstance()->DisableProcessing();
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(ParallelIO, DBBasicTestWithParallelIO,
ParallelIO, DBBasicTestWithParallelIO, // Params are as follows -
// Params are as follows - // Param 0 - Compressed cache enabled
// Param 0 - Compressed cache enabled // Param 1 - Uncompressed cache enabled
// Param 1 - Uncompressed cache enabled // Param 2 - Data compression enabled
// Param 2 - Data compression enabled // Param 3 - ReadOptions::fill_cache
// Param 3 - ReadOptions::fill_cache // Param 4 - CompressionOptions::parallel_threads
// Param 4 - CompressionOptions::parallel_threads ::testing::Combine(::testing::Bool(), ::testing::Bool(),
::testing::Combine(::testing::Bool(), ::testing::Bool(), ::testing::Bool(), ::testing::Bool(), ::testing::Bool(),
::testing::Bool(), ::testing::Values(1, 4))); ::testing::Values(1, 4)));
// A test class for intercepting random reads and injecting artificial // A test class for intercepting random reads and injecting artificial
// delays. Used for testing the deadline/timeout feature // delays. Used for testing the deadline/timeout feature

29
db/db_bloom_filter_test.cc
View File

@ -504,7 +504,7 @@ TEST_P(DBBloomFilterTestWithParam, BloomFilter) {
} }
#ifndef ROCKSDB_VALGRIND_RUN #ifndef ROCKSDB_VALGRIND_RUN
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
FormatDef, DBBloomFilterTestDefFormatVersion, FormatDef, DBBloomFilterTestDefFormatVersion,
::testing::Values( ::testing::Values(
std::make_tuple(BFP::kDeprecatedBlock, false, std::make_tuple(BFP::kDeprecatedBlock, false,
@ -512,7 +512,7 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple(BFP::kAuto, true, test::kDefaultFormatVersion), std::make_tuple(BFP::kAuto, true, test::kDefaultFormatVersion),
std::make_tuple(BFP::kAuto, false, test::kDefaultFormatVersion))); std::make_tuple(BFP::kAuto, false, test::kDefaultFormatVersion)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
FormatDef, DBBloomFilterTestWithParam, FormatDef, DBBloomFilterTestWithParam,
::testing::Values( ::testing::Values(
std::make_tuple(BFP::kDeprecatedBlock, false, std::make_tuple(BFP::kDeprecatedBlock, false,
@ -520,7 +520,7 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple(BFP::kAuto, true, test::kDefaultFormatVersion), std::make_tuple(BFP::kAuto, true, test::kDefaultFormatVersion),
std::make_tuple(BFP::kAuto, false, test::kDefaultFormatVersion))); std::make_tuple(BFP::kAuto, false, test::kDefaultFormatVersion)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
FormatLatest, DBBloomFilterTestWithParam, FormatLatest, DBBloomFilterTestWithParam,
::testing::Values( ::testing::Values(
std::make_tuple(BFP::kDeprecatedBlock, false, std::make_tuple(BFP::kDeprecatedBlock, false,
@ -1226,15 +1226,18 @@ TEST_P(DBBloomFilterTestVaryPrefixAndFormatVer, PartitionedMultiGet) {
EXPECT_TRUE(found_spanning >= 2); EXPECT_TRUE(found_spanning >= 2);
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(DBBloomFilterTestVaryPrefixAndFormatVer,
DBBloomFilterTestVaryPrefixAndFormatVer, DBBloomFilterTestVaryPrefixAndFormatVer,
DBBloomFilterTestVaryPrefixAndFormatVer, ::testing::Values(
::testing::Values( // (use_prefix, format_version)
// (use_prefix, format_version) std::make_tuple(false, 2),
std::make_tuple(false, 2), std::make_tuple(false, 3), std::make_tuple(false, 3),
std::make_tuple(false, 4), std::make_tuple(false, 5), std::make_tuple(false, 4),
std::make_tuple(true, 2), std::make_tuple(true, 3), std::make_tuple(false, 5),
std::make_tuple(true, 4), std::make_tuple(true, 5))); std::make_tuple(true, 2),
std::make_tuple(true, 3),
std::make_tuple(true, 4),
std::make_tuple(true, 5)));
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
namespace { namespace {
@ -1404,7 +1407,7 @@ TEST_P(BloomStatsTestWithParam, BloomStatsTestWithIter) {
ASSERT_EQ(expected_hits, get_perf_context()->bloom_sst_hit_count); ASSERT_EQ(expected_hits, get_perf_context()->bloom_sst_hit_count);
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
BloomStatsTestWithParam, BloomStatsTestWithParam, BloomStatsTestWithParam, BloomStatsTestWithParam,
::testing::Values(std::make_tuple(BFP::kDeprecatedBlock, false), ::testing::Values(std::make_tuple(BFP::kDeprecatedBlock, false),
std::make_tuple(BFP::kLegacyBloom, false), std::make_tuple(BFP::kLegacyBloom, false),

8
db/db_compaction_filter_test.cc
View File

@ -46,7 +46,7 @@ class DBTestCompactionFilterWithCompactParam
}; };
#ifndef ROCKSDB_VALGRIND_RUN #ifndef ROCKSDB_VALGRIND_RUN
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
CompactionFilterWithOption, DBTestCompactionFilterWithCompactParam, CompactionFilterWithOption, DBTestCompactionFilterWithCompactParam,
::testing::Values(DBTestBase::OptionConfig::kDefault, ::testing::Values(DBTestBase::OptionConfig::kDefault,
DBTestBase::OptionConfig::kUniversalCompaction, DBTestBase::OptionConfig::kUniversalCompaction,
@ -55,9 +55,9 @@ INSTANTIATE_TEST_SUITE_P(
DBTestBase::OptionConfig::kUniversalSubcompactions)); DBTestBase::OptionConfig::kUniversalSubcompactions));
#else #else
// Run fewer cases in valgrind // Run fewer cases in valgrind
INSTANTIATE_TEST_SUITE_P(CompactionFilterWithOption, INSTANTIATE_TEST_CASE_P(CompactionFilterWithOption,
DBTestCompactionFilterWithCompactParam, DBTestCompactionFilterWithCompactParam,
::testing::Values(DBTestBase::OptionConfig::kDefault)); ::testing::Values(DBTestBase::OptionConfig::kDefault));
#endif // ROCKSDB_VALGRIND_RUN #endif // ROCKSDB_VALGRIND_RUN
class KeepFilter : public CompactionFilter { class KeepFilter : public CompactionFilter {

25
db/db_compaction_test.cc
View File

@ -4690,11 +4690,11 @@ TEST_F(DBCompactionTest, CompactionLimiter) {
ASSERT_OK(dbfull()->TEST_WaitForCompact()); ASSERT_OK(dbfull()->TEST_WaitForCompact());
} }
INSTANTIATE_TEST_SUITE_P(DBCompactionTestWithParam, DBCompactionTestWithParam, INSTANTIATE_TEST_CASE_P(DBCompactionTestWithParam, DBCompactionTestWithParam,
testing::Values(std::make_tuple(1, true), ::testing::Values(std::make_tuple(1, true),
std::make_tuple(1, false), std::make_tuple(1, false),
std::make_tuple(4, true), std::make_tuple(4, true),
std::make_tuple(4, false))); std::make_tuple(4, false)));
TEST_P(DBCompactionDirectIOTest, DirectIO) { TEST_P(DBCompactionDirectIOTest, DirectIO) {
Options options = CurrentOptions(); Options options = CurrentOptions();
@ -4728,8 +4728,8 @@ TEST_P(DBCompactionDirectIOTest, DirectIO) {
delete options.env; delete options.env;
} }
INSTANTIATE_TEST_SUITE_P(DBCompactionDirectIOTest, DBCompactionDirectIOTest, INSTANTIATE_TEST_CASE_P(DBCompactionDirectIOTest, DBCompactionDirectIOTest,
testing::Bool()); testing::Bool());
class CompactionPriTest : public DBTestBase, class CompactionPriTest : public DBTestBase,
public testing::WithParamInterface<uint32_t> { public testing::WithParamInterface<uint32_t> {
@ -4774,11 +4774,12 @@ TEST_P(CompactionPriTest, Test) {
} }
} }
INSTANTIATE_TEST_SUITE_P(CompactionPriTest, CompactionPriTest, INSTANTIATE_TEST_CASE_P(
testing::Values(CompactionPri::kByCompensatedSize, CompactionPriTest, CompactionPriTest,
CompactionPri::kOldestLargestSeqFirst, ::testing::Values(CompactionPri::kByCompensatedSize,
CompactionPri::kOldestSmallestSeqFirst, CompactionPri::kOldestLargestSeqFirst,
CompactionPri::kMinOverlappingRatio)); CompactionPri::kOldestSmallestSeqFirst,
CompactionPri::kMinOverlappingRatio));
class NoopMergeOperator : public MergeOperator { class NoopMergeOperator : public MergeOperator {
public: public:

6
db/db_flush_test.cc
View File

@ -770,10 +770,10 @@ TEST_P(DBAtomicFlushTest, RollbackAfterFailToInstallResults) {
SyncPoint::GetInstance()->ClearAllCallBacks(); SyncPoint::GetInstance()->ClearAllCallBacks();
} }
INSTANTIATE_TEST_SUITE_P(DBFlushDirectIOTest, DBFlushDirectIOTest, INSTANTIATE_TEST_CASE_P(DBFlushDirectIOTest, DBFlushDirectIOTest,
testing::Bool()); testing::Bool());
INSTANTIATE_TEST_SUITE_P(DBAtomicFlushTest, DBAtomicFlushTest, testing::Bool()); INSTANTIATE_TEST_CASE_P(DBAtomicFlushTest, DBAtomicFlushTest, testing::Bool());
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

4
db/db_iterator_test.cc
View File

@ -2881,8 +2881,8 @@ TEST_P(DBIteratorTest, IterateWithLowerBoundAcrossFileBoundary) {
ASSERT_OK(iter->status()); ASSERT_OK(iter->status());
} }
INSTANTIATE_TEST_SUITE_P(DBIteratorTestInstance, DBIteratorTest, INSTANTIATE_TEST_CASE_P(DBIteratorTestInstance, DBIteratorTest,
testing::Values(true, false)); testing::Values(true, false));
// Tests how DBIter work with ReadCallback // Tests how DBIter work with ReadCallback
class DBIteratorWithReadCallbackTest : public DBIteratorTest {}; class DBIteratorWithReadCallbackTest : public DBIteratorTest {};

6
db/db_merge_operator_test.cc
View File

@ -210,8 +210,8 @@ class MergeOperatorPinningTest : public DBMergeOperatorTest,
bool disable_block_cache_; bool disable_block_cache_;
}; };
INSTANTIATE_TEST_SUITE_P(MergeOperatorPinningTest, MergeOperatorPinningTest, INSTANTIATE_TEST_CASE_P(MergeOperatorPinningTest, MergeOperatorPinningTest,
::testing::Bool()); ::testing::Bool());
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
TEST_P(MergeOperatorPinningTest, OperandsMultiBlocks) { TEST_P(MergeOperatorPinningTest, OperandsMultiBlocks) {
@ -588,7 +588,7 @@ class PerConfigMergeOperatorPinningTest
bool disable_block_cache_; bool disable_block_cache_;
}; };
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
MergeOperatorPinningTest, PerConfigMergeOperatorPinningTest, MergeOperatorPinningTest, PerConfigMergeOperatorPinningTest,
::testing::Combine(::testing::Bool(), ::testing::Combine(::testing::Bool(),
::testing::Range(static_cast<int>(DBTestBase::kDefault), ::testing::Range(static_cast<int>(DBTestBase::kDefault),

6
db/db_sst_test.cc
View File

@ -582,9 +582,9 @@ TEST_P(DBWALTestWithParam, WALTrashCleanupOnOpen) {
Close(); Close();
} }
INSTANTIATE_TEST_SUITE_P(DBWALTestWithParam, DBWALTestWithParam, INSTANTIATE_TEST_CASE_P(DBWALTestWithParam, DBWALTestWithParam,
::testing::Values(std::make_tuple("", true), ::testing::Values(std::make_tuple("", true),
std::make_tuple("_wal_dir", false))); std::make_tuple("_wal_dir", false)));
TEST_F(DBSSTTest, OpenDBWithExistingTrash) { TEST_F(DBSSTTest, OpenDBWithExistingTrash) {
Options options = CurrentOptions(); Options options = CurrentOptions();

10
db/db_table_properties_test.cc
View File

@ -345,9 +345,13 @@ TEST_P(DBTablePropertiesTest, DeletionTriggeredCompactionMarking) {
ASSERT_EQ(1, NumTableFilesAtLevel(0)); ASSERT_EQ(1, NumTableFilesAtLevel(0));
} }
INSTANTIATE_TEST_SUITE_P(DBTablePropertiesTest, DBTablePropertiesTest, INSTANTIATE_TEST_CASE_P(
::testing::Values("kCompactionStyleLevel", DBTablePropertiesTest,
"kCompactionStyleUniversal")); DBTablePropertiesTest,
::testing::Values(
"kCompactionStyleLevel",
"kCompactionStyleUniversal"
));
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

10
db/db_test.cc
View File

@ -2609,7 +2609,7 @@ TEST_P(MultiThreadedDBTest, MultiThreaded) {
} }
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
MultiThreaded, MultiThreadedDBTest, MultiThreaded, MultiThreadedDBTest,
::testing::Combine( ::testing::Combine(
::testing::ValuesIn(MultiThreadedDBTest::GenerateOptionConfigs()), ::testing::ValuesIn(MultiThreadedDBTest::GenerateOptionConfigs()),
@ -3158,7 +3158,7 @@ class DBTestRandomized : public DBTest,
} }
}; };
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
DBTestRandomized, DBTestRandomized, DBTestRandomized, DBTestRandomized,
::testing::ValuesIn(DBTestRandomized::GenerateOptionConfigs())); ::testing::ValuesIn(DBTestRandomized::GenerateOptionConfigs()));
@ -6458,9 +6458,9 @@ TEST_F(DBTest, UnsupportedManualSync) {
ASSERT_TRUE(s.IsNotSupported()); ASSERT_TRUE(s.IsNotSupported());
} }
INSTANTIATE_TEST_SUITE_P(DBTestWithParam, DBTestWithParam, INSTANTIATE_TEST_CASE_P(DBTestWithParam, DBTestWithParam,
::testing::Combine(::testing::Values(1, 4), ::testing::Combine(::testing::Values(1, 4),
::testing::Bool())); ::testing::Bool()));
TEST_F(DBTest, PauseBackgroundWorkTest) { TEST_F(DBTest, PauseBackgroundWorkTest) {
Options options = CurrentOptions(); Options options = CurrentOptions();

24
db/db_test2.cc
View File

@ -84,8 +84,8 @@ TEST_P(PrefixFullBloomWithReverseComparator,
ASSERT_TRUE(!iter->Valid()); ASSERT_TRUE(!iter->Valid());
} }
INSTANTIATE_TEST_SUITE_P(PrefixFullBloomWithReverseComparator, INSTANTIATE_TEST_CASE_P(PrefixFullBloomWithReverseComparator,
PrefixFullBloomWithReverseComparator, testing::Bool()); PrefixFullBloomWithReverseComparator, testing::Bool());
TEST_F(DBTest2, IteratorPropertyVersionNumber) { TEST_F(DBTest2, IteratorPropertyVersionNumber) {
Put("", ""); Put("", "");
@ -349,11 +349,11 @@ TEST_P(DBTestSharedWriteBufferAcrossCFs, SharedWriteBufferAcrossCFs) {
ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
} }
INSTANTIATE_TEST_SUITE_P(DBTestSharedWriteBufferAcrossCFs, INSTANTIATE_TEST_CASE_P(DBTestSharedWriteBufferAcrossCFs,
DBTestSharedWriteBufferAcrossCFs, DBTestSharedWriteBufferAcrossCFs,
::testing::Values(std::make_tuple(true, false), ::testing::Values(std::make_tuple(true, false),
std::make_tuple(false, false), std::make_tuple(false, false),
std::make_tuple(false, true))); std::make_tuple(false, true)));
TEST_F(DBTest2, SharedWriteBufferLimitAcrossDB) { TEST_F(DBTest2, SharedWriteBufferLimitAcrossDB) {
std::string dbname2 = test::PerThreadDBPath("db_shared_wb_db2"); std::string dbname2 = test::PerThreadDBPath("db_shared_wb_db2");
@ -1862,11 +1862,11 @@ TEST_P(PinL0IndexAndFilterBlocksTest, DisablePrefetchingNonL0IndexAndFilter) {
} }
} }
INSTANTIATE_TEST_SUITE_P(PinL0IndexAndFilterBlocksTest, INSTANTIATE_TEST_CASE_P(PinL0IndexAndFilterBlocksTest,
PinL0IndexAndFilterBlocksTest, PinL0IndexAndFilterBlocksTest,
::testing::Values(std::make_tuple(true, false), ::testing::Values(std::make_tuple(true, false),
std::make_tuple(false, false), std::make_tuple(false, false),
std::make_tuple(false, true))); std::make_tuple(false, true)));
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
TEST_F(DBTest2, MaxCompactionBytesTest) { TEST_F(DBTest2, MaxCompactionBytesTest) {

26
db/db_universal_compaction_test.cc
View File

@ -748,9 +748,9 @@ TEST_P(DBTestUniversalCompactionMultiLevels, UniversalCompactionTrivialMove) {
ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
} }
INSTANTIATE_TEST_SUITE_P(MultiLevels, DBTestUniversalCompactionMultiLevels, INSTANTIATE_TEST_CASE_P(MultiLevels, DBTestUniversalCompactionMultiLevels,
::testing::Combine(::testing::Values(3, 20), ::testing::Combine(::testing::Values(3, 20),
::testing::Bool())); ::testing::Bool()));
class DBTestUniversalCompactionParallel : class DBTestUniversalCompactionParallel :
public DBTestUniversalCompactionBase { public DBTestUniversalCompactionBase {
@ -937,9 +937,9 @@ TEST_P(DBTestUniversalCompactionParallel, PickByFileNumberBug) {
EXPECT_GE(total_picked_compactions, 2); EXPECT_GE(total_picked_compactions, 2);
} }
INSTANTIATE_TEST_SUITE_P(Parallel, DBTestUniversalCompactionParallel, INSTANTIATE_TEST_CASE_P(Parallel, DBTestUniversalCompactionParallel,
::testing::Combine(::testing::Values(1, 10), ::testing::Combine(::testing::Values(1, 10),
::testing::Values(false))); ::testing::Values(false)));
#endif // ROCKSDB_VALGRIND_RUN #endif // ROCKSDB_VALGRIND_RUN
TEST_P(DBTestUniversalCompaction, UniversalCompactionOptions) { TEST_P(DBTestUniversalCompaction, UniversalCompactionOptions) {
@ -1837,9 +1837,9 @@ TEST_P(DBTestUniversalCompaction, FinalSortedRunCompactFilesConflict) {
compact_files_thread.join(); compact_files_thread.join();
} }
INSTANTIATE_TEST_SUITE_P(NumLevels, DBTestUniversalCompaction, INSTANTIATE_TEST_CASE_P(NumLevels, DBTestUniversalCompaction,
::testing::Combine(::testing::Values(1, 3, 5), ::testing::Combine(::testing::Values(1, 3, 5),
::testing::Bool())); ::testing::Bool()));
class DBTestUniversalManualCompactionOutputPathId class DBTestUniversalManualCompactionOutputPathId
: public DBTestUniversalCompactionBase { : public DBTestUniversalCompactionBase {
@ -1907,10 +1907,10 @@ TEST_P(DBTestUniversalManualCompactionOutputPathId,
.IsInvalidArgument()); .IsInvalidArgument());
} }
INSTANTIATE_TEST_SUITE_P(OutputPathId, INSTANTIATE_TEST_CASE_P(OutputPathId,
DBTestUniversalManualCompactionOutputPathId, DBTestUniversalManualCompactionOutputPathId,
::testing::Combine(::testing::Values(1, 8), ::testing::Combine(::testing::Values(1, 8),
::testing::Bool())); ::testing::Bool()));
TEST_F(DBTestUniversalCompaction2, BasicL0toL1) { TEST_F(DBTestUniversalCompaction2, BasicL0toL1) {
const int kNumKeys = 3000; const int kNumKeys = 3000;

6
db/db_with_timestamp_basic_test.cc
View File

@ -982,7 +982,7 @@ TEST_F(DBBasicTestWithTimestamp, MultiGetNoReturnTs) {
#endif // !ROCKSDB_LITE #endif // !ROCKSDB_LITE
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
Timestamp, DBBasicTestWithTimestampCompressionSettings, Timestamp, DBBasicTestWithTimestampCompressionSettings,
::testing::Combine( ::testing::Combine(
::testing::Values(std::shared_ptr<const FilterPolicy>(nullptr), ::testing::Values(std::shared_ptr<const FilterPolicy>(nullptr),
@ -1099,7 +1099,7 @@ TEST_P(DBBasicTestWithTimestampPrefixSeek, ForwardIterateWithPrefix) {
// TODO(yanqin): consider handling non-fixed-length prefix extractors, e.g. // TODO(yanqin): consider handling non-fixed-length prefix extractors, e.g.
// NoopTransform. // NoopTransform.
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
Timestamp, DBBasicTestWithTimestampPrefixSeek, Timestamp, DBBasicTestWithTimestampPrefixSeek,
::testing::Combine( ::testing::Combine(
::testing::Values( ::testing::Values(
@ -1185,7 +1185,7 @@ TEST_P(DBBasicTestWithTsIterTombstones, ForwardIterDelete) {
Close(); Close();
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
Timestamp, DBBasicTestWithTsIterTombstones, Timestamp, DBBasicTestWithTsIterTombstones,
::testing::Combine( ::testing::Combine(
::testing::Values( ::testing::Values(

8
db/db_write_test.cc
View File

@ -315,10 +315,10 @@ TEST_P(DBWriteTest, ConcurrentlyDisabledWAL) {
ASSERT_LE(bytes_num, 1024 * 100); ASSERT_LE(bytes_num, 1024 * 100);
} }
INSTANTIATE_TEST_SUITE_P(DBWriteTestInstance, DBWriteTest, INSTANTIATE_TEST_CASE_P(DBWriteTestInstance, DBWriteTest,
testing::Values(DBTestBase::kDefault, testing::Values(DBTestBase::kDefault,
DBTestBase::kConcurrentWALWrites, DBTestBase::kConcurrentWALWrites,
DBTestBase::kPipelinedWrite)); DBTestBase::kPipelinedWrite));
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

10
db/external_sst_file_basic_test.cc
View File

@ -1256,11 +1256,11 @@ TEST_F(ExternalSSTFileBasicTest, OverlappingFiles) {
ASSERT_EQ(2, NumTableFilesAtLevel(0)); ASSERT_EQ(2, NumTableFilesAtLevel(0));
} }
INSTANTIATE_TEST_SUITE_P(ExternalSSTFileBasicTest, ExternalSSTFileBasicTest, INSTANTIATE_TEST_CASE_P(ExternalSSTFileBasicTest, ExternalSSTFileBasicTest,
testing::Values(std::make_tuple(true, true), testing::Values(std::make_tuple(true, true),
std::make_tuple(true, false), std::make_tuple(true, false),
std::make_tuple(false, true), std::make_tuple(false, true),
std::make_tuple(false, false))); std::make_tuple(false, false)));
#endif // ROCKSDB_LITE #endif // ROCKSDB_LITE

20
db/external_sst_file_test.cc
View File

@ -2897,17 +2897,17 @@ TEST_P(ExternalSSTFileTest,
delete iter; delete iter;
} }
INSTANTIATE_TEST_SUITE_P(ExternalSSTFileTest, ExternalSSTFileTest, INSTANTIATE_TEST_CASE_P(ExternalSSTFileTest, ExternalSSTFileTest,
testing::Values(std::make_tuple(false, false), testing::Values(std::make_tuple(false, false),
std::make_tuple(false, true), std::make_tuple(false, true),
std::make_tuple(true, false), std::make_tuple(true, false),
std::make_tuple(true, true))); std::make_tuple(true, true)));
INSTANTIATE_TEST_SUITE_P(ExternSSTFileLinkFailFallbackTest, INSTANTIATE_TEST_CASE_P(ExternSSTFileLinkFailFallbackTest,
ExternSSTFileLinkFailFallbackTest, ExternSSTFileLinkFailFallbackTest,
testing::Values(std::make_tuple(true, false), testing::Values(std::make_tuple(true, false),
std::make_tuple(true, true), std::make_tuple(true, true),
std::make_tuple(false, false))); std::make_tuple(false, false)));
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

4
db/fault_injection_test.cc
View File

@ -535,12 +535,12 @@ TEST_P(FaultInjectionTest, WriteBatchWalTerminationTest) {
ASSERT_EQ(db_->Get(ro, "boys", &val), Status::NotFound()); ASSERT_EQ(db_->Get(ro, "boys", &val), Status::NotFound());
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
FaultTest, FaultInjectionTest, FaultTest, FaultInjectionTest,
::testing::Values(std::make_tuple(false, kDefault, kEnd), ::testing::Values(std::make_tuple(false, kDefault, kEnd),
std::make_tuple(true, kDefault, kEnd))); std::make_tuple(true, kDefault, kEnd)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
FaultTest, FaultInjectionTestSplitted, FaultTest, FaultInjectionTestSplitted,
::testing::Values(std::make_tuple(false, kDefault, kSyncWal), ::testing::Values(std::make_tuple(false, kDefault, kSyncWal),
std::make_tuple(true, kDefault, kSyncWal), std::make_tuple(true, kDefault, kSyncWal),

12
db/log_test.cc
View File

@ -699,11 +699,11 @@ TEST_P(LogTest, Recycle) {
ASSERT_EQ("EOF", Read()); ASSERT_EQ("EOF", Read());
} }
INSTANTIATE_TEST_SUITE_P(bool, LogTest, INSTANTIATE_TEST_CASE_P(bool, LogTest,
::testing::Values(std::make_tuple(0, false), ::testing::Values(std::make_tuple(0, false),
std::make_tuple(0, true), std::make_tuple(0, true),
std::make_tuple(1, false), std::make_tuple(1, false),
std::make_tuple(1, true))); std::make_tuple(1, true)));
class RetriableLogTest : public ::testing::TestWithParam<int> { class RetriableLogTest : public ::testing::TestWithParam<int> {
private: private:
@ -917,7 +917,7 @@ TEST_P(RetriableLogTest, NonBlockingReadFullRecord) {
ASSERT_EQ("foo-bar", record); ASSERT_EQ("foo-bar", record);
} }
INSTANTIATE_TEST_SUITE_P(bool, RetriableLogTest, ::testing::Values(0, 2)); INSTANTIATE_TEST_CASE_P(bool, RetriableLogTest, ::testing::Values(0, 2));
} // namespace log } // namespace log
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

2
db/plain_table_db_test.cc
View File

@ -1355,7 +1355,7 @@ TEST_P(PlainTableDBTest, AdaptiveTable) {
ASSERT_NE("v5", Get("3000000000000bar")); ASSERT_NE("v5", Get("3000000000000bar"));
} }
INSTANTIATE_TEST_SUITE_P(PlainTableDBTest, PlainTableDBTest, ::testing::Bool()); INSTANTIATE_TEST_CASE_P(PlainTableDBTest, PlainTableDBTest, ::testing::Bool());
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

8
db/table_properties_collector_test.cc
View File

@ -501,11 +501,11 @@ TEST_P(TablePropertiesTest, InternalKeyPropertiesCollector) {
#endif // !ROCKSDB_LITE #endif // !ROCKSDB_LITE
} }
INSTANTIATE_TEST_SUITE_P(InternalKeyPropertiesCollector, TablePropertiesTest, INSTANTIATE_TEST_CASE_P(InternalKeyPropertiesCollector, TablePropertiesTest,
::testing::Bool()); ::testing::Bool());
INSTANTIATE_TEST_SUITE_P(CustomizedTablePropertiesCollector, INSTANTIATE_TEST_CASE_P(CustomizedTablePropertiesCollector, TablePropertiesTest,
TablePropertiesTest, ::testing::Bool()); ::testing::Bool());
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

4
db/version_set_test.cc
View File

@ -1636,7 +1636,7 @@ TEST_P(VersionSetTestDropOneCF, HandleDroppedColumnFamilyInAtomicGroup) {
} }
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
AtomicGroup, VersionSetTestDropOneCF, AtomicGroup, VersionSetTestDropOneCF,
testing::Values(VersionSetTestBase::kColumnFamilyName1, testing::Values(VersionSetTestBase::kColumnFamilyName1,
VersionSetTestBase::kColumnFamilyName2, VersionSetTestBase::kColumnFamilyName2,
@ -1992,7 +1992,7 @@ TEST_P(VersionSetTestEmptyDb, OpenCompleteManifest) {
} }
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
BestEffortRecovery, VersionSetTestEmptyDb, BestEffortRecovery, VersionSetTestEmptyDb,
testing::Combine( testing::Combine(
/*write_dbid_to_manifest=*/testing::Bool(), /*write_dbid_to_manifest=*/testing::Bool(),

24
env/env_basic_test.cc vendored
View File

@ -81,18 +81,18 @@ class EnvBasicTestWithParam : public testing::Test,
class EnvMoreTestWithParam : public EnvBasicTestWithParam {}; class EnvMoreTestWithParam : public EnvBasicTestWithParam {};
static std::unique_ptr<Env> def_env(new NormalizingEnvWrapper(Env::Default())); static std::unique_ptr<Env> def_env(new NormalizingEnvWrapper(Env::Default()));
INSTANTIATE_TEST_SUITE_P(EnvDefault, EnvBasicTestWithParam, INSTANTIATE_TEST_CASE_P(EnvDefault, EnvBasicTestWithParam,
::testing::Values(def_env.get())); ::testing::Values(def_env.get()));
INSTANTIATE_TEST_SUITE_P(EnvDefault, EnvMoreTestWithParam, INSTANTIATE_TEST_CASE_P(EnvDefault, EnvMoreTestWithParam,
::testing::Values(def_env.get())); ::testing::Values(def_env.get()));
static std::unique_ptr<Env> mock_env(new MockEnv(Env::Default())); static std::unique_ptr<Env> mock_env(new MockEnv(Env::Default()));
INSTANTIATE_TEST_SUITE_P(MockEnv, EnvBasicTestWithParam, INSTANTIATE_TEST_CASE_P(MockEnv, EnvBasicTestWithParam,
::testing::Values(mock_env.get())); ::testing::Values(mock_env.get()));
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
static std::unique_ptr<Env> mem_env(NewMemEnv(Env::Default())); static std::unique_ptr<Env> mem_env(NewMemEnv(Env::Default()));
INSTANTIATE_TEST_SUITE_P(MemEnv, EnvBasicTestWithParam, INSTANTIATE_TEST_CASE_P(MemEnv, EnvBasicTestWithParam,
::testing::Values(mem_env.get())); ::testing::Values(mem_env.get()));
namespace { namespace {
@ -121,11 +121,11 @@ std::vector<Env*> GetCustomEnvs() {
} // anonymous namespace } // anonymous namespace
INSTANTIATE_TEST_SUITE_P(CustomEnv, EnvBasicTestWithParam, INSTANTIATE_TEST_CASE_P(CustomEnv, EnvBasicTestWithParam,
::testing::ValuesIn(GetCustomEnvs())); ::testing::ValuesIn(GetCustomEnvs()));
INSTANTIATE_TEST_SUITE_P(CustomEnv, EnvMoreTestWithParam, INSTANTIATE_TEST_CASE_P(CustomEnv, EnvMoreTestWithParam,
::testing::ValuesIn(GetCustomEnvs())); ::testing::ValuesIn(GetCustomEnvs()));
#endif // ROCKSDB_LITE #endif // ROCKSDB_LITE

24
env/env_test.cc vendored
View File

@ -1968,22 +1968,22 @@ TEST_F(EnvTest, Close) {
delete env; delete env;
} }
INSTANTIATE_TEST_SUITE_P(DefaultEnvWithoutDirectIO, EnvPosixTestWithParam, INSTANTIATE_TEST_CASE_P(DefaultEnvWithoutDirectIO, EnvPosixTestWithParam,
::testing::Values(std::pair<Env*, bool>(Env::Default(), ::testing::Values(std::pair<Env*, bool>(Env::Default(),
false))); false)));
#if !defined(ROCKSDB_LITE) #if !defined(ROCKSDB_LITE)
INSTANTIATE_TEST_SUITE_P(DefaultEnvWithDirectIO, EnvPosixTestWithParam, INSTANTIATE_TEST_CASE_P(DefaultEnvWithDirectIO, EnvPosixTestWithParam,
::testing::Values(std::pair<Env*, bool>(Env::Default(), ::testing::Values(std::pair<Env*, bool>(Env::Default(),
true))); true)));
#endif // !defined(ROCKSDB_LITE) #endif // !defined(ROCKSDB_LITE)
#if !defined(ROCKSDB_LITE) && !defined(OS_WIN) #if !defined(ROCKSDB_LITE) && !defined(OS_WIN)
static std::unique_ptr<Env> chroot_env( static std::unique_ptr<Env> chroot_env(
NewChrootEnv(Env::Default(), test::TmpDir(Env::Default()))); NewChrootEnv(Env::Default(), test::TmpDir(Env::Default())));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
ChrootEnvWithoutDirectIO, EnvPosixTestWithParam, ChrootEnvWithoutDirectIO, EnvPosixTestWithParam,
::testing::Values(std::pair<Env*, bool>(chroot_env.get(), false))); ::testing::Values(std::pair<Env*, bool>(chroot_env.get(), false)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
ChrootEnvWithDirectIO, EnvPosixTestWithParam, ChrootEnvWithDirectIO, EnvPosixTestWithParam,
::testing::Values(std::pair<Env*, bool>(chroot_env.get(), true))); ::testing::Values(std::pair<Env*, bool>(chroot_env.get(), true)));
#endif // !defined(ROCKSDB_LITE) && !defined(OS_WIN) #endif // !defined(ROCKSDB_LITE) && !defined(OS_WIN)
@ -2073,10 +2073,10 @@ TEST_P(EnvFSTestWithParam, OptionsTest) {
// 1. True means Options::env is non-null, false means null // 1. True means Options::env is non-null, false means null
// 2. True means use Env::Default, false means custom // 2. True means use Env::Default, false means custom
// 3. True means use FileSystem::Default, false means custom // 3. True means use FileSystem::Default, false means custom
INSTANTIATE_TEST_SUITE_P(EnvFSTest, EnvFSTestWithParam, INSTANTIATE_TEST_CASE_P(
::testing::Combine(::testing::Bool(), EnvFSTest, EnvFSTestWithParam,
::testing::Bool(), ::testing::Combine(::testing::Bool(), ::testing::Bool(),
::testing::Bool())); ::testing::Bool()));
// This test ensures that default Env and those allocated by // This test ensures that default Env and those allocated by
// NewCompositeEnv() all share the same threadpool // NewCompositeEnv() all share the same threadpool

2
src.mk
View File

@ -428,7 +428,7 @@ MAIN_SOURCES = \
table/table_reader_bench.cc \ table/table_reader_bench.cc \
table/table_test.cc \ table/table_test.cc \
table/block_fetcher_test.cc \ table/block_fetcher_test.cc \
third-party/gtest-1.10.0/fused-src/gtest/gtest-all.cc \ third-party/gtest-1.8.1/fused-src/gtest/gtest-all.cc \
tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc \ tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc \
tools/block_cache_analyzer/block_cache_trace_analyzer_tool.cc \ tools/block_cache_analyzer/block_cache_trace_analyzer_tool.cc \
tools/db_bench.cc \ tools/db_bench.cc \

4
table/block_based/block_based_table_reader_test.cc
View File

@ -223,12 +223,12 @@ TEST_P(BlockBasedTableReaderTest, MultiGet) {
// Param 2: whether to use direct reads // Param 2: whether to use direct reads
#ifdef ROCKSDB_LITE #ifdef ROCKSDB_LITE
// Skip direct I/O tests in lite mode since direct I/O is unsupported. // Skip direct I/O tests in lite mode since direct I/O is unsupported.
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
MultiGet, BlockBasedTableReaderTest, MultiGet, BlockBasedTableReaderTest,
::testing::Combine(::testing::ValuesIn(GetSupportedCompressions()), ::testing::Combine(::testing::ValuesIn(GetSupportedCompressions()),
::testing::Values(false))); ::testing::Values(false)));
#else // ROCKSDB_LITE #else // ROCKSDB_LITE
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
MultiGet, BlockBasedTableReaderTest, MultiGet, BlockBasedTableReaderTest,
::testing::Combine(::testing::ValuesIn(GetSupportedCompressions()), ::testing::Combine(::testing::ValuesIn(GetSupportedCompressions()),
::testing::Bool())); ::testing::Bool()));

10
table/block_based/block_test.cc
View File

@ -617,11 +617,11 @@ TEST_P(IndexBlockTest, IndexValueEncodingTest) {
delete iter; delete iter;
} }
INSTANTIATE_TEST_SUITE_P(P, IndexBlockTest, INSTANTIATE_TEST_CASE_P(P, IndexBlockTest,
::testing::Values(std::make_tuple(false, false), ::testing::Values(std::make_tuple(false, false),
std::make_tuple(false, true), std::make_tuple(false, true),
std::make_tuple(true, false), std::make_tuple(true, false),
std::make_tuple(true, true))); std::make_tuple(true, true)));
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

8
table/block_based/partitioned_filter_block_test.cc
View File

@ -292,10 +292,10 @@ class PartitionedFilterBlockTest
} }
}; };
INSTANTIATE_TEST_SUITE_P(FormatDef, PartitionedFilterBlockTest, INSTANTIATE_TEST_CASE_P(FormatDef, PartitionedFilterBlockTest,
testing::Values(test::kDefaultFormatVersion)); testing::Values(test::kDefaultFormatVersion));
INSTANTIATE_TEST_SUITE_P(FormatLatest, PartitionedFilterBlockTest, INSTANTIATE_TEST_CASE_P(FormatLatest, PartitionedFilterBlockTest,
testing::Values(test::kLatestFormatVersion)); testing::Values(test::kLatestFormatVersion));
TEST_P(PartitionedFilterBlockTest, EmptyBuilder) { TEST_P(PartitionedFilterBlockTest, EmptyBuilder) {
std::unique_ptr<PartitionedIndexBuilder> pib(NewIndexBuilder()); std::unique_ptr<PartitionedIndexBuilder> pib(NewIndexBuilder());

10
table/table_test.cc
View File

@ -1298,10 +1298,10 @@ class FileChecksumTestHelper {
uint64_t FileChecksumTestHelper::checksum_uniq_id_ = 1; uint64_t FileChecksumTestHelper::checksum_uniq_id_ = 1;
INSTANTIATE_TEST_SUITE_P(FormatDef, BlockBasedTableTest, INSTANTIATE_TEST_CASE_P(FormatDef, BlockBasedTableTest,
testing::Values(test::kDefaultFormatVersion)); testing::Values(test::kDefaultFormatVersion));
INSTANTIATE_TEST_SUITE_P(FormatLatest, BlockBasedTableTest, INSTANTIATE_TEST_CASE_P(FormatLatest, BlockBasedTableTest,
testing::Values(test::kLatestFormatVersion)); testing::Values(test::kLatestFormatVersion));
// This test serves as the living tutorial for the prefix scan of user collected // This test serves as the living tutorial for the prefix scan of user collected
// properties. // properties.
@ -3924,7 +3924,7 @@ class IndexBlockRestartIntervalTest
} }
}; };
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
IndexBlockRestartIntervalTest, IndexBlockRestartIntervalTest, IndexBlockRestartIntervalTest, IndexBlockRestartIntervalTest,
::testing::ValuesIn(IndexBlockRestartIntervalTest::GetRestartValues())); ::testing::ValuesIn(IndexBlockRestartIntervalTest::GetRestartValues()));

0
third-party/gtest-1.10.0/fused-src/gtest/CMakeLists.txt → third-party/gtest-1.8.1/fused-src/gtest/CMakeLists.txt vendored
View File

2722
third-party/gtest-1.10.0/fused-src/gtest/gtest-all.cc → third-party/gtest-1.8.1/fused-src/gtest/gtest-all.cc vendored
View File

File diff suppressed because it is too large Load Diff

13898
third-party/gtest-1.10.0/fused-src/gtest/gtest.h → third-party/gtest-1.8.1/fused-src/gtest/gtest.h vendored
View File

File diff suppressed because it is too large Load Diff

12
third-party/gtest-1.10.0/fused-src/gtest/gtest_main.cc → third-party/gtest-1.8.1/fused-src/gtest/gtest_main.cc vendored
View File

@ -27,21 +27,11 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <cstdio> #include <stdio.h>
#include "gtest/gtest.h" #include "gtest/gtest.h"
#ifdef ARDUINO
void setup() {
testing::InitGoogleTest();
}
void loop() { RUN_ALL_TESTS(); }
#else
GTEST_API_ int main(int argc, char **argv) { GTEST_API_ int main(int argc, char **argv) {
printf("Running main() from %s\n", __FILE__); printf("Running main() from %s\n", __FILE__);
testing::InitGoogleTest(&argc, argv); testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS(); return RUN_ALL_TESTS();
} }
#endif

6
util/bloom_test.cc
View File

@ -899,9 +899,9 @@ TEST_P(FullBloomTest, CorruptFilters) {
} }
} }
INSTANTIATE_TEST_SUITE_P(Full, FullBloomTest, INSTANTIATE_TEST_CASE_P(Full, FullBloomTest,
testing::Values(BloomFilterPolicy::kLegacyBloom, testing::Values(BloomFilterPolicy::kLegacyBloom,
BloomFilterPolicy::kFastLocalBloom)); BloomFilterPolicy::kFastLocalBloom));
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

16
util/file_reader_writer_test.cc
View File

@ -316,16 +316,16 @@ TEST_P(ReadaheadRandomAccessFileTest, ReadExceedsReadaheadSize) {
} }
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
EmptySourceStr, ReadaheadRandomAccessFileTest, EmptySourceStr, ReadaheadRandomAccessFileTest,
::testing::ValuesIn(ReadaheadRandomAccessFileTest::GetReadaheadSizeList())); ::testing::ValuesIn(ReadaheadRandomAccessFileTest::GetReadaheadSizeList()));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
SourceStrLenLessThanReadaheadSize, ReadaheadRandomAccessFileTest, SourceStrLenLessThanReadaheadSize, ReadaheadRandomAccessFileTest,
::testing::ValuesIn(ReadaheadRandomAccessFileTest::GetReadaheadSizeList())); ::testing::ValuesIn(ReadaheadRandomAccessFileTest::GetReadaheadSizeList()));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
SourceStrLenGreaterThanReadaheadSize, ReadaheadRandomAccessFileTest, SourceStrLenGreaterThanReadaheadSize, ReadaheadRandomAccessFileTest,
::testing::ValuesIn(ReadaheadRandomAccessFileTest::GetReadaheadSizeList())); ::testing::ValuesIn(ReadaheadRandomAccessFileTest::GetReadaheadSizeList()));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
ReadExceedsReadaheadSize, ReadaheadRandomAccessFileTest, ReadExceedsReadaheadSize, ReadaheadRandomAccessFileTest,
::testing::ValuesIn(ReadaheadRandomAccessFileTest::GetReadaheadSizeList())); ::testing::ValuesIn(ReadaheadRandomAccessFileTest::GetReadaheadSizeList()));
@ -424,16 +424,16 @@ TEST_P(ReadaheadSequentialFileTest, ReadExceedsReadaheadSize) {
} }
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
EmptySourceStr, ReadaheadSequentialFileTest, EmptySourceStr, ReadaheadSequentialFileTest,
::testing::ValuesIn(ReadaheadSequentialFileTest::GetReadaheadSizeList())); ::testing::ValuesIn(ReadaheadSequentialFileTest::GetReadaheadSizeList()));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
SourceStrLenLessThanReadaheadSize, ReadaheadSequentialFileTest, SourceStrLenLessThanReadaheadSize, ReadaheadSequentialFileTest,
::testing::ValuesIn(ReadaheadSequentialFileTest::GetReadaheadSizeList())); ::testing::ValuesIn(ReadaheadSequentialFileTest::GetReadaheadSizeList()));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
SourceStrLenGreaterThanReadaheadSize, ReadaheadSequentialFileTest, SourceStrLenGreaterThanReadaheadSize, ReadaheadSequentialFileTest,
::testing::ValuesIn(ReadaheadSequentialFileTest::GetReadaheadSizeList())); ::testing::ValuesIn(ReadaheadSequentialFileTest::GetReadaheadSizeList()));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
ReadExceedsReadaheadSize, ReadaheadSequentialFileTest, ReadExceedsReadaheadSize, ReadaheadSequentialFileTest,
::testing::ValuesIn(ReadaheadSequentialFileTest::GetReadaheadSizeList())); ::testing::ValuesIn(ReadaheadSequentialFileTest::GetReadaheadSizeList()));
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

33
util/heap_test.cc
View File

@ -103,23 +103,30 @@ TEST_P(HeapTest, Test) {
} }
// Basic test, MAX_VALUE = 3*MAX_HEAP_SIZE (occasional duplicates) // Basic test, MAX_VALUE = 3*MAX_HEAP_SIZE (occasional duplicates)
INSTANTIATE_TEST_SUITE_P(Basic, HeapTest, INSTANTIATE_TEST_CASE_P(
::testing::Values(Params(1000, 3000, Basic, HeapTest,
0x1b575cf05b708945))); ::testing::Values(Params(1000, 3000, 0x1b575cf05b708945))
);
// Mid-size heap with small values (many duplicates) // Mid-size heap with small values (many duplicates)
INSTANTIATE_TEST_SUITE_P(SmallValues, HeapTest, INSTANTIATE_TEST_CASE_P(
::testing::Values(Params(100, 10, SmallValues, HeapTest,
0x5ae213f7bd5dccd0))); ::testing::Values(Params(100, 10, 0x5ae213f7bd5dccd0))
);
// Small heap, large value range (no duplicates) // Small heap, large value range (no duplicates)
INSTANTIATE_TEST_SUITE_P(SmallHeap, HeapTest, INSTANTIATE_TEST_CASE_P(
::testing::Values(Params(10, ULLONG_MAX, SmallHeap, HeapTest,
0x3e1fa8f4d01707cf))); ::testing::Values(Params(10, ULLONG_MAX, 0x3e1fa8f4d01707cf))
);
// Two-element heap // Two-element heap
INSTANTIATE_TEST_SUITE_P(TwoElementHeap, HeapTest, INSTANTIATE_TEST_CASE_P(
::testing::Values(Params(2, 5, 0x4b5e13ea988c6abc))); TwoElementHeap, HeapTest,
::testing::Values(Params(2, 5, 0x4b5e13ea988c6abc))
);
// One-element heap // One-element heap
INSTANTIATE_TEST_SUITE_P(OneElementHeap, HeapTest, INSTANTIATE_TEST_CASE_P(
::testing::Values(Params(1, 3, 0x176a1019ab0b612e))); OneElementHeap, HeapTest,
::testing::Values(Params(1, 3, 0x176a1019ab0b612e))
);
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

4
utilities/backupable/backupable_db_test.cc
View File

@ -840,8 +840,8 @@ TEST_P(BackupableDBTestWithParam, OnlineIntegrationTest) {
CloseBackupEngine(); CloseBackupEngine();
} }
INSTANTIATE_TEST_SUITE_P(BackupableDBTestWithParam, BackupableDBTestWithParam, INSTANTIATE_TEST_CASE_P(BackupableDBTestWithParam, BackupableDBTestWithParam,
::testing::Bool()); ::testing::Bool());
// this will make sure that backup does not copy the same file twice // this will make sure that backup does not copy the same file twice
TEST_F(BackupableDBTest, NoDoubleCopy_And_AutoGC) { TEST_F(BackupableDBTest, NoDoubleCopy_And_AutoGC) {

2
utilities/option_change_migration/option_change_migration_test.cc
View File

@ -329,7 +329,7 @@ TEST_P(DBOptionChangeMigrationTests, Migrate4) {
} }
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
DBOptionChangeMigrationTests, DBOptionChangeMigrationTests, DBOptionChangeMigrationTests, DBOptionChangeMigrationTests,
::testing::Values(std::make_tuple(3, 0, false, 4, 0, false), ::testing::Values(std::make_tuple(3, 0, false, 4, 0, false),
std::make_tuple(3, 0, true, 4, 0, true), std::make_tuple(3, 0, true, 4, 0, true),

2
utilities/transactions/optimistic_transaction_test.cc
View File

@ -1510,7 +1510,7 @@ TEST_P(OptimisticTransactionTest, SequenceNumberAfterRecoverTest) {
delete transaction; delete transaction;
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
InstanceOccGroup, OptimisticTransactionTest, InstanceOccGroup, OptimisticTransactionTest,
testing::Values(OccValidationPolicy::kValidateSerial, testing::Values(OccValidationPolicy::kValidateSerial,
OccValidationPolicy::kValidateParallel)); OccValidationPolicy::kValidateParallel));

8
utilities/transactions/transaction_test.cc
View File

@ -36,7 +36,7 @@ using std::string;
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
DBAsBaseDB, TransactionTest, DBAsBaseDB, TransactionTest,
::testing::Values( ::testing::Values(
std::make_tuple(false, false, WRITE_COMMITTED, kOrderedWrite), std::make_tuple(false, false, WRITE_COMMITTED, kOrderedWrite),
@ -46,7 +46,7 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite), std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite),
std::make_tuple(false, false, WRITE_UNPREPARED, kOrderedWrite), std::make_tuple(false, false, WRITE_UNPREPARED, kOrderedWrite),
std::make_tuple(false, true, WRITE_UNPREPARED, kOrderedWrite))); std::make_tuple(false, true, WRITE_UNPREPARED, kOrderedWrite)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
DBAsBaseDB, TransactionStressTest, DBAsBaseDB, TransactionStressTest,
::testing::Values( ::testing::Values(
std::make_tuple(false, false, WRITE_COMMITTED, kOrderedWrite), std::make_tuple(false, false, WRITE_COMMITTED, kOrderedWrite),
@ -56,7 +56,7 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite), std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite),
std::make_tuple(false, false, WRITE_UNPREPARED, kOrderedWrite), std::make_tuple(false, false, WRITE_UNPREPARED, kOrderedWrite),
std::make_tuple(false, true, WRITE_UNPREPARED, kOrderedWrite))); std::make_tuple(false, true, WRITE_UNPREPARED, kOrderedWrite)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
StackableDBAsBaseDB, TransactionTest, StackableDBAsBaseDB, TransactionTest,
::testing::Values( ::testing::Values(
std::make_tuple(true, true, WRITE_COMMITTED, kOrderedWrite), std::make_tuple(true, true, WRITE_COMMITTED, kOrderedWrite),
@ -65,7 +65,7 @@ INSTANTIATE_TEST_SUITE_P(
// MySQLStyleTransactionTest takes far too long for valgrind to run. // MySQLStyleTransactionTest takes far too long for valgrind to run.
#ifndef ROCKSDB_VALGRIND_RUN #ifndef ROCKSDB_VALGRIND_RUN
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
MySQLStyleTransactionTest, MySQLStyleTransactionTest, MySQLStyleTransactionTest, MySQLStyleTransactionTest,
::testing::Values( ::testing::Values(
std::make_tuple(false, false, WRITE_COMMITTED, kOrderedWrite, false), std::make_tuple(false, false, WRITE_COMMITTED, kOrderedWrite, false),

10
utilities/transactions/write_prepared_transaction_test.cc
View File

@ -584,7 +584,7 @@ class SeqAdvanceConcurrentTest
size_t split_cnt_; size_t split_cnt_;
}; };
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
WritePreparedTransaction, WritePreparedTransactionTest, WritePreparedTransaction, WritePreparedTransactionTest,
::testing::Values( ::testing::Values(
std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite), std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite),
@ -592,7 +592,7 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite))); std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite)));
#ifndef ROCKSDB_VALGRIND_RUN #ifndef ROCKSDB_VALGRIND_RUN
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
TwoWriteQueues, SnapshotConcurrentAccessTest, TwoWriteQueues, SnapshotConcurrentAccessTest,
::testing::Values( ::testing::Values(
std::make_tuple(false, true, WRITE_PREPARED, kOrderedWrite, 0, 20), std::make_tuple(false, true, WRITE_PREPARED, kOrderedWrite, 0, 20),
@ -637,7 +637,7 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, 18, 20), std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, 18, 20),
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, 19, 20))); std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, 19, 20)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
OneWriteQueue, SnapshotConcurrentAccessTest, OneWriteQueue, SnapshotConcurrentAccessTest,
::testing::Values( ::testing::Values(
std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 0, 20), std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 0, 20),
@ -661,7 +661,7 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 18, 20), std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 18, 20),
std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 19, 20))); std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 19, 20)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
TwoWriteQueues, SeqAdvanceConcurrentTest, TwoWriteQueues, SeqAdvanceConcurrentTest,
::testing::Values( ::testing::Values(
std::make_tuple(false, true, WRITE_PREPARED, kOrderedWrite, 0, 10), std::make_tuple(false, true, WRITE_PREPARED, kOrderedWrite, 0, 10),
@ -685,7 +685,7 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, 8, 10), std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, 8, 10),
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, 9, 10))); std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, 9, 10)));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
OneWriteQueue, SeqAdvanceConcurrentTest, OneWriteQueue, SeqAdvanceConcurrentTest,
::testing::Values( ::testing::Values(
std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 0, 10), std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 0, 10),

4
utilities/transactions/write_unprepared_transaction_test.cc
View File

@ -31,7 +31,7 @@ class WriteUnpreparedTransactionTest
std::get<2>(GetParam())){} std::get<2>(GetParam())){}
}; };
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
WriteUnpreparedTransactionTest, WriteUnpreparedTransactionTest, WriteUnpreparedTransactionTest, WriteUnpreparedTransactionTest,
::testing::Values(std::make_tuple(false, false, WRITE_UNPREPARED), ::testing::Values(std::make_tuple(false, false, WRITE_UNPREPARED),
std::make_tuple(false, true, WRITE_UNPREPARED))); std::make_tuple(false, true, WRITE_UNPREPARED)));
@ -48,7 +48,7 @@ class WriteUnpreparedStressTest : public WriteUnpreparedTransactionTestBase,
StressAction action_; StressAction action_;
}; };
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_CASE_P(
WriteUnpreparedStressTest, WriteUnpreparedStressTest, WriteUnpreparedStressTest, WriteUnpreparedStressTest,
::testing::Values(std::make_tuple(false, NO_SNAPSHOT), ::testing::Values(std::make_tuple(false, NO_SNAPSHOT),
std::make_tuple(false, RO_SNAPSHOT), std::make_tuple(false, RO_SNAPSHOT),