You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kudu.apache.org by ba...@apache.org on 2021/02/22 05:35:47 UTC
[kudu] 01/02: [thirdparty] Upgrade gmock/gtest to 1.10.0
This is an automated email from the ASF dual-hosted git repository.
bankim pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/kudu.git
commit e74cdb3f8c33212618c090d90075b8d928f942f7
Author: Bankim Bhavsar <ba...@cloudera.com>
AuthorDate: Tue Feb 9 18:01:02 2021 -0800
[thirdparty] Upgrade gmock/gtest to 1.10.0
Upgrade gmock/gtest from 1.8.0 to latest stable 1.10.0 release
mainly to allow explicitly skipping tests using GTEST_SKIP()
macro. Includes bunch of other enhancements as well:
https://github.com/google/googletest/releases/tag/release-1.10.0
Earlier we were simply using gtest headers and not linking
gtest library. With the upgrade, kudu build fails with gtest
linker errors and hence building and linking gtest as well.
As per the gtest upgrade notes _TEST_CASE has been deprecated
in favor of _TEST_SUITE and hence replaced the usage accordingly
otherwise deprecation warnings are spewed on Mac OS build.
Note:
- Building the gmock/gtest in Debug mode names the library as
libgmockd/libgtestd instead of the expected libgmock/libgtest.
Though we could possibly update cmake modules to use the
explicitly debug named libraries or simply rename when copying
to installed directories. Using the default cmake build type
for building gmock/gtest instead of the earlier debug mode.
Tests:
- Verified debug build on Ubuntu 18.04, va1022 RHEL7 and
Mac OS 10.15.7
Change-Id: I1f7f5c11bef29a0d428d8d55d70ebdf888c6f645
Reviewed-on: http://gerrit.cloudera.org:8080/17056
Tested-by: Alexey Serbin <as...@cloudera.com>
Reviewed-by: Alexey Serbin <as...@cloudera.com>
---
CMakeLists.txt | 13 ++++-
cmake_modules/FindGMock.cmake | 31 ++++------
cmake_modules/FindGTest.cmake | 67 ++++++----------------
src/kudu/cfile/cfile-test.cc | 12 ++--
src/kudu/cfile/encoding-test.cc | 4 +-
src/kudu/client/CMakeLists.txt | 1 +
src/kudu/client/client-test.cc | 28 +++++----
src/kudu/client/predicate-test.cc | 15 ++---
src/kudu/client/scan_token-test.cc | 4 +-
src/kudu/common/column_predicate-test.cc | 2 +-
src/kudu/common/generic_iterators-test.cc | 2 +-
src/kudu/common/schema-test.cc | 4 +-
src/kudu/common/wire_protocol-test.cc | 3 +-
src/kudu/consensus/CMakeLists.txt | 8 ---
src/kudu/consensus/log-test.cc | 3 +-
src/kudu/fs/block_manager-stress-test.cc | 2 +-
src/kudu/fs/block_manager-test.cc | 2 +-
src/kudu/fs/fs_manager-test.cc | 5 +-
src/kudu/hms/hms_catalog-test.cc | 4 +-
src/kudu/hms/hms_client-test.cc | 7 +--
src/kudu/integration-tests/all_types-itest.cc | 2 +-
.../alter_table-randomized-test.cc | 2 +-
.../integration-tests/auth_token_expire-itest.cc | 4 +-
src/kudu/integration-tests/authz_token-itest.cc | 5 +-
.../integration-tests/client_failover-itest.cc | 4 +-
src/kudu/integration-tests/consistency-itest.cc | 8 +--
src/kudu/integration-tests/delete_table-itest.cc | 10 ++--
src/kudu/integration-tests/disk_failure-itest.cc | 17 +++---
.../integration-tests/flex_partitioning-itest.cc | 7 ++-
.../integration-tests/location_assignment-itest.cc | 7 ++-
.../integration-tests/maintenance_mode-itest.cc | 2 +-
src/kudu/integration-tests/master-stress-test.cc | 2 +-
src/kudu/integration-tests/master_authz-itest.cc | 24 ++++----
.../integration-tests/master_failover-itest.cc | 2 +-
src/kudu/integration-tests/raft_consensus-itest.cc | 4 +-
.../raft_consensus_election-itest.cc | 2 +-
.../raft_consensus_nonvoter-itest.cc | 9 +--
src/kudu/integration-tests/security-itest.cc | 4 +-
src/kudu/integration-tests/stop_tablet-itest.cc | 2 +-
src/kudu/integration-tests/tablet_copy-itest.cc | 8 +--
.../integration-tests/tablet_replacement-itest.cc | 13 ++---
.../tablet_server_quiescing-itest.cc | 2 +-
.../tombstoned_voting-imc-itest.cc | 4 +-
src/kudu/integration-tests/ts_authz-itest.cc | 3 +-
src/kudu/integration-tests/ts_recovery-itest.cc | 10 ++--
.../integration-tests/ts_tablet_manager-itest.cc | 6 +-
.../integration-tests/txn_participant-itest.cc | 2 +-
.../integration-tests/txn_status_table-itest.cc | 10 ++--
.../integration-tests/webserver-crawl-itest.cc | 4 +-
src/kudu/master/dynamic_multi_master-test.cc | 7 ++-
src/kudu/master/master-test.cc | 6 +-
src/kudu/mini-cluster/CMakeLists.txt | 1 +
.../mini-cluster/external_mini_cluster-test.cc | 3 +-
src/kudu/rpc/negotiation-test.cc | 8 +--
src/kudu/rpc/periodic-test.cc | 12 ++--
src/kudu/rpc/rpc-test.cc | 17 +++---
src/kudu/security/crypto-test.cc | 2 +-
src/kudu/security/tls_handshake-test.cc | 8 +--
src/kudu/tablet/all_types-scan-correctness-test.cc | 2 +-
src/kudu/tablet/deltafile-test.cc | 2 +-
src/kudu/tablet/deltamemstore-test.cc | 8 +--
src/kudu/tablet/diff_scan-test.cc | 5 +-
src/kudu/tablet/diskrowset-test.cc | 7 ++-
src/kudu/tablet/memrowset-test.cc | 7 ++-
src/kudu/tablet/mt-tablet-test.cc | 4 +-
src/kudu/tablet/mvcc-test.cc | 5 +-
src/kudu/tablet/ops/op_tracker-test.cc | 2 +-
src/kudu/tablet/rowset_tree-test.cc | 3 +-
src/kudu/tablet/tablet-decoder-eval-test.cc | 8 +--
src/kudu/tablet/tablet-pushdown-test.cc | 6 +-
src/kudu/tablet/tablet-test-base.h | 2 +-
src/kudu/tablet/tablet-test.cc | 2 +-
src/kudu/tablet/txn_participant-test.cc | 6 +-
src/kudu/tools/kudu-admin-test.cc | 17 +++---
src/kudu/tools/kudu-tool-test.cc | 32 +++++------
src/kudu/tools/rebalancer_tool-test.cc | 39 +++++++------
src/kudu/tserver/tablet_copy_client-test.cc | 11 ++--
src/kudu/tserver/tablet_server-test.cc | 30 +++++-----
.../tserver/tablet_server_authorization-test.cc | 14 ++---
src/kudu/util/CMakeLists.txt | 2 +
src/kudu/util/async_util-test.cc | 8 +--
src/kudu/util/atomic-test.cc | 2 +-
src/kudu/util/cache-bench.cc | 2 +-
src/kudu/util/cache-test.cc | 5 +-
src/kudu/util/debug-util-test.cc | 10 ++--
src/kudu/util/env-test.cc | 8 +--
src/kudu/util/env_util-test.cc | 2 +-
src/kudu/util/file_cache-test.cc | 2 +-
src/kudu/util/minidump-test.cc | 4 +-
src/kudu/util/once-test.cc | 2 +-
src/kudu/util/pb_util-test.cc | 4 +-
src/kudu/util/random_util-test.cc | 2 +-
src/kudu/util/rle-test.cc | 2 +-
src/kudu/util/rw_mutex-test.cc | 6 +-
src/kudu/util/test_macros.h | 4 +-
src/kudu/util/threadpool-test.cc | 10 ++--
thirdparty/build-definitions.sh | 14 +++--
thirdparty/build-thirdparty.sh | 4 +-
thirdparty/vars.sh | 2 +-
99 files changed, 371 insertions(+), 396 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4e6c8f2..4390b4c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -990,10 +990,17 @@ list(APPEND KUDU_BASE_LIBS gflags)
## GMock
find_package(GMock REQUIRED)
-include_directories(SYSTEM ${GMOCK_INCLUDE_DIR} ${GTEST_INCLUDE_DIR})
+include_directories(SYSTEM ${GMOCK_INCLUDE_DIR})
ADD_THIRDPARTY_LIB(gmock
- STATIC_LIB ${GMOCK_STATIC_LIBRARY}
- SHARED_LIB ${GMOCK_SHARED_LIBRARY})
+ STATIC_LIB "${GMOCK_STATIC_LIBRARY}"
+ SHARED_LIB "${GMOCK_SHARED_LIBRARY}")
+
+## GTest
+find_package(GTest REQUIRED)
+include_directories(SYSTEM ${GTEST_INCLUDE_DIR})
+ADD_THIRDPARTY_LIB(gtest
+ STATIC_LIB "${GTEST_STATIC_LIBRARY}"
+ SHARED_LIB "${GTEST_SHARED_LIBRARY}")
## Protobuf
find_package(Protobuf REQUIRED)
diff --git a/cmake_modules/FindGMock.cmake b/cmake_modules/FindGMock.cmake
index 48f8997..050f7d2 100644
--- a/cmake_modules/FindGMock.cmake
+++ b/cmake_modules/FindGMock.cmake
@@ -21,37 +21,28 @@
# Author: Konstantin Lepa <ko...@gmail.com>
#
# Find the Google Mock Framework, heavily cribbed from FindGTest.cmake.
-# gmock ships a copy of gtest and bundles it in its libraries, so this also
-# finds the gtest headers.
#
# This module defines
# GMOCK_INCLUDE_DIR, where to find gmock include files, etc.
-# GTEST_INCLUDE_DIR, where to find gtest include files
# GMOCK_SHARED_LIBRARY, Location of libgmock's shared library
# GMOCK_STATIC_LIBRARY, Location of libgmock's static library
-# GMOCK_FOUND, If false, do not try to use gmock.
+# GMock_FOUND, If false, do not try to use gmock.
find_path(GMOCK_INCLUDE_DIR gmock/gmock.h
- DOC "Path to the gmock header file"
- NO_CMAKE_SYSTEM_PATH
- NO_SYSTEM_ENVIRONMENT_PATH)
-
-find_path(GTEST_INCLUDE_DIR gtest/gtest.h
- DOC "Path to the gtest header file"
- NO_CMAKE_SYSTEM_PATH
- NO_SYSTEM_ENVIRONMENT_PATH)
+ DOC "Path to the gmock header file"
+ NO_CMAKE_SYSTEM_PATH
+ NO_SYSTEM_ENVIRONMENT_PATH)
find_library(GMOCK_SHARED_LIBRARY gmock
- DOC "Google's framework for writing C++ tests (gmock)"
- NO_CMAKE_SYSTEM_PATH
- NO_SYSTEM_ENVIRONMENT_PATH)
+ DOC "Google's framework for writing C++ tests (gmock)"
+ NO_CMAKE_SYSTEM_PATH
+ NO_SYSTEM_ENVIRONMENT_PATH)
find_library(GMOCK_STATIC_LIBRARY libgmock.a
- DOC "Google's framework for writing C++ tests (gmock) static"
- NO_CMAKE_SYSTEM_PATH
- NO_SYSTEM_ENVIRONMENT_PATH)
-
+ DOC "Google's framework for writing C++ tests (gmock) static"
+ NO_CMAKE_SYSTEM_PATH
+ NO_SYSTEM_ENVIRONMENT_PATH)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(GMock REQUIRED_VARS
- GMOCK_SHARED_LIBRARY GMOCK_STATIC_LIBRARY GMOCK_INCLUDE_DIR GTEST_INCLUDE_DIR)
+ GMOCK_SHARED_LIBRARY GMOCK_STATIC_LIBRARY GMOCK_INCLUDE_DIR)
diff --git a/cmake_modules/FindGTest.cmake b/cmake_modules/FindGTest.cmake
index 06fc02e..c68fb4e 100644
--- a/cmake_modules/FindGTest.cmake
+++ b/cmake_modules/FindGTest.cmake
@@ -26,27 +26,22 @@
# GTEST_INCLUDE_DIR, where to find gtest include files, etc.
# GTest_FOUND, If false, do not try to use gtest.
# GTEST_STATIC_LIBRARY, Location of libgtest.a
-# GTEST_SHARED_LIBRARY, Location of libttest's shared library
+# GTEST_SHARED_LIBRARY, Location of libgtest's shared library
-# also defined, but not for general use are
-# GTEST_LIBRARY, where to find the GTest library.
+find_path(GTEST_INCLUDE_DIR gtest/gtest.h
+ DOC "Path to the gtest header file"
+ NO_CMAKE_SYSTEM_PATH
+ NO_SYSTEM_ENVIRONMENT_PATH)
-set(GTEST_SEARCH_PATH ${CMAKE_SOURCE_DIR}/thirdparty/gtest-1.7.0)
-
-set(GTEST_H gtest/gtest.h)
-
-find_path(GTEST_INCLUDE_DIR ${GTEST_H}
- PATHS ${GTEST_SEARCH_PATH}/include
- NO_DEFAULT_PATH
- DOC "Path to the ${GTEST_H} file"
-)
-
-find_library(GTEST_LIBRARY
- NAMES gtest
- PATHS ${GTEST_SEARCH_PATH}
- NO_DEFAULT_PATH
+find_library(GTEST_SHARED_LIBRARY gtest
DOC "Google's framework for writing C++ tests (gtest)"
-)
+ NO_CMAKE_SYSTEM_PATH
+ NO_SYSTEM_ENVIRONMENT_PATH)
+
+find_library(GTEST_STATIC_LIBRARY libgtest.a
+ DOC "Google's framework for writing C++ tests (gtest) static"
+ NO_CMAKE_SYSTEM_PATH
+ NO_SYSTEM_ENVIRONMENT_PATH)
# Kudu does not use the gtest_main library (we have kudu_test_main).
#find_library(GTEST_MAIN_LIBRARY_PATH
@@ -55,37 +50,7 @@ find_library(GTEST_LIBRARY
# NO_DEFAULT_PATH
# DOC "Google's framework for writing C++ tests (gtest_main)"
#)
-set(GTEST_LIB_NAME libgtest)
-if(GTEST_INCLUDE_DIR AND GTEST_LIBRARY)
- set(GTEST_STATIC_LIBRARY ${GTEST_SEARCH_PATH}/${GTEST_LIB_NAME}.a)
- if(EXISTS "${GTEST_STATIC_LIBRARY}")
- set(GTEST_FOUND TRUE)
- endif()
-
- set(GTEST_SHARED_LIBRARY ${GTEST_SEARCH_PATH}/${GTEST_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX})
- if(EXISTS "${GTEST_SHARED_LIBRARY}")
- set(GTEST_FOUND TRUE)
- endif()
-else()
- set(GTEST_FOUND FALSE)
-endif()
-
-if(GTEST_FOUND)
- if(NOT GTest_FIND_QUIETLY)
- message(STATUS "Found the GTest library: ${GTEST_STATIC_LIBRARY} ${GTEST_SHARED_LIBRARY}")
- endif(NOT GTest_FIND_QUIETLY)
-else(GTEST_FOUND)
- if(NOT GTest_FIND_QUIETLY)
- if(GTest_FIND_REQUIRED)
- message(FATAL_ERROR "Could not find the GTest library")
- else(GTest_FIND_REQUIRED)
- message(STATUS "Could not find the GTest library")
- endif(GTest_FIND_REQUIRED)
- endif(NOT GTest_FIND_QUIETLY)
-endif(GTEST_FOUND)
-
-mark_as_advanced(
- GTEST_INCLUDE_DIR
- GTEST_STATIC_LIBRARY
- GTEST_SHARED_LIBRARY)
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GTest REQUIRED_VARS
+ GTEST_SHARED_LIBRARY GTEST_STATIC_LIBRARY GTEST_INCLUDE_DIR)
diff --git a/src/kudu/cfile/cfile-test.cc b/src/kudu/cfile/cfile-test.cc
index 6e64f1f..4294eee 100644
--- a/src/kudu/cfile/cfile-test.cc
+++ b/src/kudu/cfile/cfile-test.cc
@@ -434,9 +434,9 @@ class TestCFileBothCacheMemoryTypes :
}
};
-INSTANTIATE_TEST_CASE_P(CacheMemoryTypes, TestCFileBothCacheMemoryTypes,
- ::testing::Values(Cache::MemoryType::DRAM,
- Cache::MemoryType::NVM));
+INSTANTIATE_TEST_SUITE_P(CacheMemoryTypes, TestCFileBothCacheMemoryTypes,
+ ::testing::Values(Cache::MemoryType::DRAM,
+ Cache::MemoryType::NVM));
template <DataType type>
void CopyOne(CFileIterator* it, typename TypeTraits<type>::cpp_type* ret, RowBlockMemory* mem) {
@@ -601,7 +601,7 @@ typedef ::testing::Types<UInt8DataGenerator<false>,
Int128DataGenerator<false>,
FPDataGenerator<FLOAT, false>,
FPDataGenerator<DOUBLE, false> > MyTypes;
-TYPED_TEST_CASE(BitShuffleTest, MyTypes);
+TYPED_TEST_SUITE(BitShuffleTest, MyTypes);
TYPED_TEST(BitShuffleTest, TestFixedSizeReadWriteBitShuffle) {
this->TestBitShuffle();
}
@@ -1109,8 +1109,8 @@ class TestCFileDifferentCodecs : public TestCFile,
public testing::WithParamInterface<CompressionType> {
};
-INSTANTIATE_TEST_CASE_P(Codecs, TestCFileDifferentCodecs,
- ::testing::Values(NO_COMPRESSION, SNAPPY, LZ4, ZLIB));
+INSTANTIATE_TEST_SUITE_P(Codecs, TestCFileDifferentCodecs,
+ ::testing::Values(NO_COMPRESSION, SNAPPY, LZ4, ZLIB));
// Read/write a file with uncompressible data (random int32s)
TEST_P(TestCFileDifferentCodecs, TestUncompressible) {
diff --git a/src/kudu/cfile/encoding-test.cc b/src/kudu/cfile/encoding-test.cc
index c889175..ea03329 100644
--- a/src/kudu/cfile/encoding-test.cc
+++ b/src/kudu/cfile/encoding-test.cc
@@ -881,8 +881,8 @@ class IntEncodingTest : public TestEncoding, public ::testing::WithParamInterfac
TestIntBlockRoundTrip<IntType>(GetParam());
}
};
-INSTANTIATE_TEST_CASE_P(Encodings, IntEncodingTest,
- ::testing::Values(RLE, PLAIN_ENCODING, BIT_SHUFFLE));
+INSTANTIATE_TEST_SUITE_P(Encodings, IntEncodingTest,
+ ::testing::Values(RLE, PLAIN_ENCODING, BIT_SHUFFLE));
TEST_P(IntEncodingTest, TestSeekAllTypes) {
this->template DoIntSeekTest<UINT8>(100, 1000, true);
diff --git a/src/kudu/client/CMakeLists.txt b/src/kudu/client/CMakeLists.txt
index 53344f1..5c07020 100644
--- a/src/kudu/client/CMakeLists.txt
+++ b/src/kudu/client/CMakeLists.txt
@@ -249,6 +249,7 @@ add_library(kudu_client_test_util
client-test-util.cc)
target_link_libraries(kudu_client_test_util
gmock
+ gtest
kudu_client)
# Tests
diff --git a/src/kudu/client/client-test.cc b/src/kudu/client/client-test.cc
index a7c8f24..62d16b7 100644
--- a/src/kudu/client/client-test.cc
+++ b/src/kudu/client/client-test.cc
@@ -41,7 +41,6 @@
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <glog/stl_logging.h>
-#include <gmock/gmock-generated-matchers.h>
#include <gmock/gmock-matchers.h>
#include <google/protobuf/util/message_differencer.h>
#include <gtest/gtest.h>
@@ -1404,8 +1403,8 @@ TEST_P(ScanMultiTabletParamTest, Test) {
ASSERT_EQ(0, CountRowsFromClient(table.get(), read_mode, kTabletsNum * kRowsPerTablet,
kNoBound));
}
-INSTANTIATE_TEST_CASE_P(Params, ScanMultiTabletParamTest,
- testing::ValuesIn(read_modes));
+INSTANTIATE_TEST_SUITE_P(Params, ScanMultiTabletParamTest,
+ testing::ValuesIn(read_modes));
TEST_F(ClientTest, TestScanEmptyTable) {
KuduScanner scanner(client_table_.get());
@@ -3906,9 +3905,8 @@ TEST_P(FlushModeOpRatesTest, RunComparison) {
EXPECT_GT(t_afs_wall, t_afb_wall);
}
-INSTANTIATE_TEST_CASE_P(,
- FlushModeOpRatesTest,
- ::testing::Values(RowSize::CONSTANT, RowSize::RANDOM));
+INSTANTIATE_TEST_SUITE_P(, FlushModeOpRatesTest,
+ ::testing::Values(RowSize::CONSTANT, RowSize::RANDOM));
// A test to verify that it's safe to perform synchronous and/or asynchronous
// flush while having the auto-flusher thread running in the background.
@@ -5665,8 +5663,8 @@ TEST_P(LatestObservedTimestampParamTest, Test) {
latest_ts = ts;
}
}
-INSTANTIATE_TEST_CASE_P(Params, LatestObservedTimestampParamTest,
- testing::ValuesIn(read_modes));
+INSTANTIATE_TEST_SUITE_P(Params, LatestObservedTimestampParamTest,
+ testing::ValuesIn(read_modes));
// Insert bunch of rows, delete a row, and then insert the row back.
// Run scans several scan and check the results are consistent with the
@@ -6041,9 +6039,9 @@ TEST_P(IntEncodingNullPredicatesTest, TestIntEncodings) {
}
}
-INSTANTIATE_TEST_CASE_P(IntColEncodings,
- IntEncodingNullPredicatesTest,
- ::testing::Values(kPlain, kBitShuffle, kRunLength));
+INSTANTIATE_TEST_SUITE_P(IntColEncodings,
+ IntEncodingNullPredicatesTest,
+ ::testing::Values(kPlain, kBitShuffle, kRunLength));
enum BinaryEncoding {
@@ -6138,9 +6136,9 @@ TEST_P(BinaryEncodingNullPredicatesTest, TestBinaryEncodings) {
}
}
-INSTANTIATE_TEST_CASE_P(BinaryColEncodings,
- BinaryEncodingNullPredicatesTest,
- ::testing::Values(kPlainBin, kPrefix, kDictionary));
+INSTANTIATE_TEST_SUITE_P(BinaryColEncodings,
+ BinaryEncodingNullPredicatesTest,
+ ::testing::Values(kPlainBin, kPrefix, kDictionary));
TEST_F(ClientTest, TestClonePredicates) {
NO_FATALS(InsertTestRows(client_table_.get(), 2, 0));
@@ -6617,7 +6615,7 @@ static const ServiceUnavailableRetryParams service_unavailable_retry_cases[] = {
},
};
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
, ServiceUnavailableRetryClientTest,
::testing::ValuesIn(service_unavailable_retry_cases));
diff --git a/src/kudu/client/predicate-test.cc b/src/kudu/client/predicate-test.cc
index b91c363..becf186 100644
--- a/src/kudu/client/predicate-test.cc
+++ b/src/kudu/client/predicate-test.cc
@@ -27,6 +27,7 @@
#include <ostream>
#include <random>
#include <string>
+#include <tuple>
#include <type_traits>
#include <unordered_set>
#include <utility>
@@ -1525,9 +1526,9 @@ class ParameterizedBloomFilterPredicateTest :
public PredicateTest,
public ::testing::WithParamInterface<std::tuple<bool, bool>> {};
-INSTANTIATE_TEST_CASE_P(, ParameterizedBloomFilterPredicateTest,
- ::testing::Combine(::testing::Bool(),
- ::testing::Bool()));
+INSTANTIATE_TEST_SUITE_P(, ParameterizedBloomFilterPredicateTest,
+ ::testing::Combine(::testing::Bool(),
+ ::testing::Bool()));
// Test to verify that an ineffective Bloom filter predicate will be disabled
// using a pattern of repeated strings.
@@ -1601,10 +1602,10 @@ TEST_P(ParameterizedBloomFilterPredicateTest, TestDisabledBloomFilterWithRepeate
class ParameterizedPredicateTest : public PredicateTest,
public ::testing::WithParamInterface<KuduColumnSchema::DataType> {};
-INSTANTIATE_TEST_CASE_P(, ParameterizedPredicateTest,
- ::testing::Values(KuduColumnSchema::STRING,
- KuduColumnSchema::BINARY,
- KuduColumnSchema::VARCHAR));
+INSTANTIATE_TEST_SUITE_P(, ParameterizedPredicateTest,
+ ::testing::Values(KuduColumnSchema::STRING,
+ KuduColumnSchema::BINARY,
+ KuduColumnSchema::VARCHAR));
TEST_P(ParameterizedPredicateTest, TestIndirectDataPredicates) {
shared_ptr<KuduTable> table = CreateAndOpenTable(GetParam());
diff --git a/src/kudu/client/scan_token-test.cc b/src/kudu/client/scan_token-test.cc
index da1753c..0a0b991 100644
--- a/src/kudu/client/scan_token-test.cc
+++ b/src/kudu/client/scan_token-test.cc
@@ -606,8 +606,8 @@ TEST_P(TimestampPropagationParamTest, Test) {
}
}
-INSTANTIATE_TEST_CASE_P(Params, TimestampPropagationParamTest,
- testing::ValuesIn(read_modes));
+INSTANTIATE_TEST_SUITE_P(Params, TimestampPropagationParamTest,
+ testing::ValuesIn(read_modes));
// Tests the results of creating scan tokens, altering the columns being
// scanned, and then executing the scan tokens.
diff --git a/src/kudu/common/column_predicate-test.cc b/src/kudu/common/column_predicate-test.cc
index 151ce8a..caba11c 100644
--- a/src/kudu/common/column_predicate-test.cc
+++ b/src/kudu/common/column_predicate-test.cc
@@ -1553,7 +1553,7 @@ using test_types = ::testing::Types<
DataTypeTraits<FLOAT>,
DataTypeTraits<DOUBLE>>;
-TYPED_TEST_CASE(RangePredicateBenchmark, test_types);
+TYPED_TEST_SUITE(RangePredicateBenchmark, test_types);
TYPED_TEST(RangePredicateBenchmark, TestEquals) {
const typename TypeParam::cpp_type ref_val = 0;
diff --git a/src/kudu/common/generic_iterators-test.cc b/src/kudu/common/generic_iterators-test.cc
index 08b39ea..d6411af 100644
--- a/src/kudu/common/generic_iterators-test.cc
+++ b/src/kudu/common/generic_iterators-test.cc
@@ -830,6 +830,6 @@ TEST_P(PredicateEffectivenessTest, MaterializingIterator) {
VerifyPredicateEffectiveness(all_values, mat_iter);
}
-INSTANTIATE_TEST_CASE_P(, PredicateEffectivenessTest, ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(, PredicateEffectivenessTest, ::testing::Bool());
} // namespace kudu
diff --git a/src/kudu/common/schema-test.cc b/src/kudu/common/schema-test.cc
index 3c66496..d71fbb6 100644
--- a/src/kudu/common/schema-test.cc
+++ b/src/kudu/common/schema-test.cc
@@ -128,8 +128,8 @@ enum IncludeColumnIds {
class ParameterizedSchemaTest : public KuduTest,
public ::testing::WithParamInterface<IncludeColumnIds> {};
-INSTANTIATE_TEST_CASE_P(SchemaTypes, ParameterizedSchemaTest,
- ::testing::Values(INCLUDE_COL_IDS, NO_COL_IDS));
+INSTANTIATE_TEST_SUITE_P(SchemaTypes, ParameterizedSchemaTest,
+ ::testing::Values(INCLUDE_COL_IDS, NO_COL_IDS));
TEST_P(ParameterizedSchemaTest, TestCopyAndMove) {
auto check_schema = [](const Schema& schema) {
diff --git a/src/kudu/common/wire_protocol-test.cc b/src/kudu/common/wire_protocol-test.cc
index ca53b0e..51e5bb3 100644
--- a/src/kudu/common/wire_protocol-test.cc
+++ b/src/kudu/common/wire_protocol-test.cc
@@ -25,6 +25,7 @@
#include <ostream>
#include <random>
#include <string>
+#include <tuple>
#include <vector>
#include <boost/optional/optional.hpp>
@@ -632,7 +633,7 @@ BenchmarkColumnsSpec UniformColumns(int n_cols, DataType type, double null_fract
null_str) };
}
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
ColumnarRowBlockToPBBenchmarkParams, WireProtocolBenchmark,
testing::Combine(
testing::Values(
diff --git a/src/kudu/consensus/CMakeLists.txt b/src/kudu/consensus/CMakeLists.txt
index f506107..e559ce2 100644
--- a/src/kudu/consensus/CMakeLists.txt
+++ b/src/kudu/consensus/CMakeLists.txt
@@ -139,11 +139,3 @@ ADD_KUDU_TEST(mt-log-test PROCESSORS 5)
ADD_KUDU_TEST(quorum_util-test)
ADD_KUDU_TEST(raft_consensus_quorum-test)
ADD_KUDU_TEST(time_manager-test)
-
-# Our current version of gmock overrides virtual functions without adding
-# the 'override' keyword which, since our move to c++11, make the compiler
-# issue warnings. This suppresses those warnings.
-# TODO This problem has been resolved in recent versions of gtest/gmock (now
-# googletest). Remove this when we upgrade.
-set_source_files_properties(raft_consensus-test.cc
- PROPERTIES COMPILE_FLAGS -Wno-inconsistent-missing-override)
diff --git a/src/kudu/consensus/log-test.cc b/src/kudu/consensus/log-test.cc
index 096bf05..13db7eb 100644
--- a/src/kudu/consensus/log-test.cc
+++ b/src/kudu/consensus/log-test.cc
@@ -176,7 +176,8 @@ class LogTestOptionalCompression : public LogTest,
FLAGS_log_compression_codec = name;
}
};
-INSTANTIATE_TEST_CASE_P(Codecs, LogTestOptionalCompression, ::testing::Values(NO_COMPRESSION, LZ4));
+INSTANTIATE_TEST_SUITE_P(Codecs, LogTestOptionalCompression,
+ ::testing::Values(NO_COMPRESSION, LZ4));
// If we write more than one entry in a batch, we should be able to
// read all of those entries back.
diff --git a/src/kudu/fs/block_manager-stress-test.cc b/src/kudu/fs/block_manager-stress-test.cc
index 5ecd850..b9aeae9 100644
--- a/src/kudu/fs/block_manager-stress-test.cc
+++ b/src/kudu/fs/block_manager-stress-test.cc
@@ -509,7 +509,7 @@ typedef ::testing::Types<FileBlockManager, LogBlockManager> BlockManagers;
#else
typedef ::testing::Types<FileBlockManager> BlockManagers;
#endif
-TYPED_TEST_CASE(BlockManagerStressTest, BlockManagers);
+TYPED_TEST_SUITE(BlockManagerStressTest, BlockManagers);
TYPED_TEST(BlockManagerStressTest, StressTest) {
OverrideFlagForSlowTests("test_duration_secs", "30");
diff --git a/src/kudu/fs/block_manager-test.cc b/src/kudu/fs/block_manager-test.cc
index a29b730..0064c31 100644
--- a/src/kudu/fs/block_manager-test.cc
+++ b/src/kudu/fs/block_manager-test.cc
@@ -437,7 +437,7 @@ typedef ::testing::Types<FileBlockManager, LogBlockManager> BlockManagers;
#else
typedef ::testing::Types<FileBlockManager> BlockManagers;
#endif
-TYPED_TEST_CASE(BlockManagerTest, BlockManagers);
+TYPED_TEST_SUITE(BlockManagerTest, BlockManagers);
// Test to make sure that we don't break the file block manager, which depends
// on a static set of directories to function properly. Internally, the
diff --git a/src/kudu/fs/fs_manager-test.cc b/src/kudu/fs/fs_manager-test.cc
index 051b0ca..0c2d1c3 100644
--- a/src/kudu/fs/fs_manager-test.cc
+++ b/src/kudu/fs/fs_manager-test.cc
@@ -28,7 +28,6 @@
#include <memory>
#include <set>
#include <string>
-#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
@@ -140,8 +139,8 @@ class FsManagerTestBase : public KuduTest,
private:
unique_ptr<FsManager> fs_manager_;
};
-INSTANTIATE_TEST_CASE_P(BlockManagerTypes, FsManagerTestBase,
- ::testing::ValuesIn(BlockManager::block_manager_types()));
+INSTANTIATE_TEST_SUITE_P(BlockManagerTypes, FsManagerTestBase,
+ ::testing::ValuesIn(BlockManager::block_manager_types()));
TEST_P(FsManagerTestBase, TestBaseOperations) {
fs_manager()->DumpFileSystemTree(std::cout);
diff --git a/src/kudu/hms/hms_catalog-test.cc b/src/kudu/hms/hms_catalog-test.cc
index d0692c0..974876b 100644
--- a/src/kudu/hms/hms_catalog-test.cc
+++ b/src/kudu/hms/hms_catalog-test.cc
@@ -291,8 +291,8 @@ class HmsCatalogTestParameterized : public HmsCatalogTest,
return GetParam();
}
};
-INSTANTIATE_TEST_CASE_P(HmsCatalogTests, HmsCatalogTestParameterized,
- ::testing::Values(false, true));
+INSTANTIATE_TEST_SUITE_P(HmsCatalogTests, HmsCatalogTestParameterized,
+ ::testing::Values(false, true));
// Test creating, altering, and dropping a table with the HMS Catalog.
TEST_P(HmsCatalogTestParameterized, TestTableLifecycle) {
diff --git a/src/kudu/hms/hms_client-test.cc b/src/kudu/hms/hms_client-test.cc
index 96484ff..b3543cd 100644
--- a/src/kudu/hms/hms_client-test.cc
+++ b/src/kudu/hms/hms_client-test.cc
@@ -24,7 +24,6 @@
#include <utility>
#include <vector>
-#include <boost/none_t.hpp>
#include <boost/optional/optional.hpp>
#include <glog/stl_logging.h>
#include <gtest/gtest.h>
@@ -90,9 +89,9 @@ class HmsClientTest : public KuduTest,
}
};
-INSTANTIATE_TEST_CASE_P(ProtectionTypes,
- HmsClientTest,
- ::testing::Values(boost::none
+INSTANTIATE_TEST_SUITE_P(ProtectionTypes,
+ HmsClientTest,
+ ::testing::Values(boost::none
, SaslProtection::kIntegrity
// On macos, krb5 has issues repeatedly spinning up new KDCs ('unable to reach
// any KDC in realm KRBTEST.COM, tried 1 KDC'). Integrity protection gives us
diff --git a/src/kudu/integration-tests/all_types-itest.cc b/src/kudu/integration-tests/all_types-itest.cc
index 40831b1..193995e 100644
--- a/src/kudu/integration-tests/all_types-itest.cc
+++ b/src/kudu/integration-tests/all_types-itest.cc
@@ -657,7 +657,7 @@ typedef ::testing::Types<IntKeysTestSetup<KeyTypeWrapper<INT8> >,
SliceKeysTestSetup<KeyTypeWrapper<BINARY> >
> KeyTypes;
-TYPED_TEST_CASE(AllTypesItest, KeyTypes);
+TYPED_TEST_SUITE(AllTypesItest, KeyTypes);
TYPED_TEST(AllTypesItest, TestAllKeyTypes) {
vector<string> projection;
diff --git a/src/kudu/integration-tests/alter_table-randomized-test.cc b/src/kudu/integration-tests/alter_table-randomized-test.cc
index 2d00231..0facbd6 100644
--- a/src/kudu/integration-tests/alter_table-randomized-test.cc
+++ b/src/kudu/integration-tests/alter_table-randomized-test.cc
@@ -141,7 +141,7 @@ class AlterTableRandomized : public KuduTest,
};
// Run the test with the HMS integration enabled and disabled.
-INSTANTIATE_TEST_CASE_P(HmsConfigurations, AlterTableRandomized, ::testing::ValuesIn(
+INSTANTIATE_TEST_SUITE_P(HmsConfigurations, AlterTableRandomized, ::testing::ValuesIn(
vector<HmsMode> { HmsMode::NONE, HmsMode::ENABLE_METASTORE_INTEGRATION }
));
diff --git a/src/kudu/integration-tests/auth_token_expire-itest.cc b/src/kudu/integration-tests/auth_token_expire-itest.cc
index b553cce..a22588c 100644
--- a/src/kudu/integration-tests/auth_token_expire-itest.cc
+++ b/src/kudu/integration-tests/auth_token_expire-itest.cc
@@ -276,8 +276,8 @@ class AuthTokenExpireDuringWorkloadITest : public AuthTokenExpireITest,
GetParam().authz_validity_secs);
};
-INSTANTIATE_TEST_CASE_P(ValidityIntervals, AuthTokenExpireDuringWorkloadITest,
- ::testing::Values(kEvenValidity, kLongerAuthn, kLongerAuthz));
+INSTANTIATE_TEST_SUITE_P(ValidityIntervals, AuthTokenExpireDuringWorkloadITest,
+ ::testing::Values(kEvenValidity, kLongerAuthn, kLongerAuthz));
// Run a mixed write/read test workload and check that client retries upon
// receiving the appropriate invalid token error, eventually succeeding with
diff --git a/src/kudu/integration-tests/authz_token-itest.cc b/src/kudu/integration-tests/authz_token-itest.cc
index ecec994..4c58df7 100644
--- a/src/kudu/integration-tests/authz_token-itest.cc
+++ b/src/kudu/integration-tests/authz_token-itest.cc
@@ -325,8 +325,9 @@ TEST_P(ReacquireAuthzTokenTest, TestExpiredAuthzTokens) {
ASSERT_GT(NumGetTableSchemaRequests(), initial_reqs);
}
-INSTANTIATE_TEST_CASE_P(RequestorFuncs, ReacquireAuthzTokenTest,
- ::testing::ValuesIn(vector<RequestorFunc>({ &InsertRequestor, &ScanRequestor })));
+INSTANTIATE_TEST_SUITE_P(RequestorFuncs, ReacquireAuthzTokenTest,
+ ::testing::ValuesIn(vector<RequestorFunc>({&InsertRequestor,
+ &ScanRequestor})));
// Test to ensure tokens with no privileges will disallow operations.
TEST_F(AuthzTokenTest, TestUnprivilegedAuthzTokens) {
diff --git a/src/kudu/integration-tests/client_failover-itest.cc b/src/kudu/integration-tests/client_failover-itest.cc
index 8183b78..a9c97a6 100644
--- a/src/kudu/integration-tests/client_failover-itest.cc
+++ b/src/kudu/integration-tests/client_failover-itest.cc
@@ -222,8 +222,8 @@ TEST_P(ClientFailoverParamITest, TestDeleteLeaderWhileScanning) {
ClientTestBehavior test_type[] = { kWrite, kRead, kReadWrite };
-INSTANTIATE_TEST_CASE_P(ClientBehavior, ClientFailoverParamITest,
- ::testing::ValuesIn(test_type));
+INSTANTIATE_TEST_SUITE_P(ClientBehavior, ClientFailoverParamITest,
+ ::testing::ValuesIn(test_type));
class ClientFailoverITest : public ExternalMiniClusterITestBase {
diff --git a/src/kudu/integration-tests/consistency-itest.cc b/src/kudu/integration-tests/consistency-itest.cc
index 9006cc4..d27a86f 100644
--- a/src/kudu/integration-tests/consistency-itest.cc
+++ b/src/kudu/integration-tests/consistency-itest.cc
@@ -797,8 +797,8 @@ TEST_P(ScanYourWritesParamTest, Test) {
EXPECT_EQ(rows_to_insert, row_count);
}
-INSTANTIATE_TEST_CASE_P(Params, ScanYourWritesParamTest,
- testing::ValuesIn(replica_selectors));
+INSTANTIATE_TEST_SUITE_P(Params, ScanYourWritesParamTest,
+ testing::ValuesIn(replica_selectors));
class ScanYourWritesMultiClientsParamTest :
public ConsistencyITest,
@@ -859,7 +859,7 @@ TEST_P(ScanYourWritesMultiClientsParamTest, Test) {
}
}
-INSTANTIATE_TEST_CASE_P(Params, ScanYourWritesMultiClientsParamTest,
- testing::ValuesIn(replica_selectors));
+INSTANTIATE_TEST_SUITE_P(Params, ScanYourWritesMultiClientsParamTest,
+ testing::ValuesIn(replica_selectors));
} // namespace client
} // namespace kudu
diff --git a/src/kudu/integration-tests/delete_table-itest.cc b/src/kudu/integration-tests/delete_table-itest.cc
index 213ec70..678d5cb 100644
--- a/src/kudu/integration-tests/delete_table-itest.cc
+++ b/src/kudu/integration-tests/delete_table-itest.cc
@@ -1345,8 +1345,8 @@ const char* deleted_faults[] = {"fault_crash_after_blocks_deleted",
"fault_crash_after_wal_deleted",
"fault_crash_after_cmeta_deleted"};
-INSTANTIATE_TEST_CASE_P(FaultFlags, DeleteTableDeletedParamTest,
- ::testing::ValuesIn(deleted_faults));
+INSTANTIATE_TEST_SUITE_P(FaultFlags, DeleteTableDeletedParamTest,
+ ::testing::ValuesIn(deleted_faults));
// Parameterized test case for TABLET_DATA_TOMBSTONED deletions.
class DeleteTableTombstonedParamTest : public DeleteTableITest,
@@ -1503,8 +1503,8 @@ TEST_P(DeleteTableTombstonedParamTest, TestTabletTombstone) {
// Tombstoning a tablet does not delete the consensus metadata.
const char* tombstoned_faults[] = {"fault_crash_after_blocks_deleted",
"fault_crash_after_wal_deleted"};
-INSTANTIATE_TEST_CASE_P(FaultFlags, DeleteTableTombstonedParamTest,
- ::testing::ValuesIn(tombstoned_faults));
+INSTANTIATE_TEST_SUITE_P(FaultFlags, DeleteTableTombstonedParamTest,
+ ::testing::ValuesIn(tombstoned_faults));
class DeleteTableWhileScanInProgressParamTest :
@@ -1655,7 +1655,7 @@ const KuduClient::ReplicaSelection replica_selectors[] = {
KuduClient::CLOSEST_REPLICA,
KuduClient::FIRST_REPLICA,
};
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
Params, DeleteTableWhileScanInProgressParamTest,
::testing::Combine(::testing::ValuesIn(read_modes),
::testing::ValuesIn(replica_selectors)));
diff --git a/src/kudu/integration-tests/disk_failure-itest.cc b/src/kudu/integration-tests/disk_failure-itest.cc
index 0feaca4..ae15976 100644
--- a/src/kudu/integration-tests/disk_failure-itest.cc
+++ b/src/kudu/integration-tests/disk_failure-itest.cc
@@ -20,6 +20,7 @@
#include <memory>
#include <ostream>
#include <string>
+#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
@@ -162,7 +163,7 @@ TEST_P(DiskFailureITest, TestFailDuringServerStartup) {
write_workload.batches_completed()));
}
-INSTANTIATE_TEST_CASE_P(DiskFailure, DiskFailureITest,
+INSTANTIATE_TEST_SUITE_P(DiskFailure, DiskFailureITest,
::testing::Combine(
::testing::ValuesIn(BlockManager::block_manager_types()),
::testing::Bool()));
@@ -291,8 +292,8 @@ class TabletServerDiskErrorITest : public DiskErrorITestBase {
}
};
-INSTANTIATE_TEST_CASE_P(TabletServerDiskError, TabletServerDiskErrorITest,
- ::testing::Values(ErrorType::CFILE_CORRUPTION, ErrorType::DISK_FAILURE));
+INSTANTIATE_TEST_SUITE_P(TabletServerDiskError, TabletServerDiskErrorITest,
+ ::testing::Values(ErrorType::CFILE_CORRUPTION, ErrorType::DISK_FAILURE));
TEST_P(TabletServerDiskErrorITest, TestFailOnBootstrap) {
// Inject the errors into one of the non-empty servers.
@@ -420,15 +421,15 @@ TEST_P(CompactionsAndDeletionsFailureITest, TestRecovery) {
NO_FATALS(v.CheckCluster());
}
-INSTANTIATE_TEST_CASE_P(ErrorType, CompactionsAndDeletionsFailureITest,
- ::testing::Values(ErrorType::CFILE_CORRUPTION, ErrorType::DISK_FAILURE,
- ErrorType::KUDU_2233_CORRUPTION));
+INSTANTIATE_TEST_SUITE_P(ErrorType, CompactionsAndDeletionsFailureITest,
+ ::testing::Values(ErrorType::CFILE_CORRUPTION, ErrorType::DISK_FAILURE,
+ ErrorType::KUDU_2233_CORRUPTION));
class MasterDiskErrorITest : public DiskErrorITestBase {
};
-INSTANTIATE_TEST_CASE_P(MasterDiskError, MasterDiskErrorITest,
- ::testing::Values(ErrorType::CFILE_CORRUPTION, ErrorType::DISK_FAILURE));
+INSTANTIATE_TEST_SUITE_P(MasterDiskError, MasterDiskErrorITest,
+ ::testing::Values(ErrorType::CFILE_CORRUPTION, ErrorType::DISK_FAILURE));
// Test that triggers disk error in master during maintenance manager operations like compaction.
TEST_P(MasterDiskErrorITest, TestMasterDiskFailure) {
diff --git a/src/kudu/integration-tests/flex_partitioning-itest.cc b/src/kudu/integration-tests/flex_partitioning-itest.cc
index 6da3b1f..a5a5818 100644
--- a/src/kudu/integration-tests/flex_partitioning-itest.cc
+++ b/src/kudu/integration-tests/flex_partitioning-itest.cc
@@ -23,6 +23,7 @@
#include <memory>
#include <ostream>
#include <string>
+#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
@@ -33,9 +34,9 @@
#include "kudu/client/client-test-util.h"
#include "kudu/client/client.h"
-#include "kudu/client/shared_ptr.h" // IWYU pragma: keep
#include "kudu/client/scan_predicate.h"
#include "kudu/client/schema.h"
+#include "kudu/client/shared_ptr.h" // IWYU pragma: keep
#include "kudu/client/value.h"
#include "kudu/client/write_op.h"
#include "kudu/common/common.pb.h"
@@ -607,8 +608,8 @@ const vector<RangePartitionOptions> kRangeOptions {
};
// Instantiate all combinations of hash options and range options.
-INSTANTIATE_TEST_CASE_P(Shards, FlexPartitioningITest,
- testing::Combine(
+INSTANTIATE_TEST_SUITE_P(Shards, FlexPartitioningITest,
+ testing::Combine(
testing::ValuesIn(kHashOptions),
testing::ValuesIn(kRangeOptions)));
diff --git a/src/kudu/integration-tests/location_assignment-itest.cc b/src/kudu/integration-tests/location_assignment-itest.cc
index 502ae4b..31d6937 100644
--- a/src/kudu/integration-tests/location_assignment-itest.cc
+++ b/src/kudu/integration-tests/location_assignment-itest.cc
@@ -20,6 +20,7 @@
#include <memory>
#include <ostream>
#include <string>
+#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
@@ -298,8 +299,8 @@ TEST_P(TsLocationAssignmentITest, LocationMappingCacheOnTabletServerRestart) {
});
}
-INSTANTIATE_TEST_CASE_P(, TsLocationAssignmentITest,
- ::testing::Combine(::testing::Values(1, 3),
- ::testing::Values(1, 8, 16, 32)));
+INSTANTIATE_TEST_SUITE_P(, TsLocationAssignmentITest,
+ ::testing::Combine(::testing::Values(1, 3),
+ ::testing::Values(1, 8, 16, 32)));
} // namespace kudu
diff --git a/src/kudu/integration-tests/maintenance_mode-itest.cc b/src/kudu/integration-tests/maintenance_mode-itest.cc
index fb56824..d28cfe3 100644
--- a/src/kudu/integration-tests/maintenance_mode-itest.cc
+++ b/src/kudu/integration-tests/maintenance_mode-itest.cc
@@ -759,7 +759,7 @@ TEST_P(RollingRestartITest, TestWorkloads) {
}
}
-INSTANTIATE_TEST_CASE_P(RollingRestartArgs, RollingRestartITest, ::testing::Values(
+INSTANTIATE_TEST_SUITE_P(RollingRestartArgs, RollingRestartITest, ::testing::Values(
// Basic RF=3 case.
ArgsBuilder().num_tservers(4)
.num_locations(1)
diff --git a/src/kudu/integration-tests/master-stress-test.cc b/src/kudu/integration-tests/master-stress-test.cc
index d5b075e..58bf519 100644
--- a/src/kudu/integration-tests/master-stress-test.cc
+++ b/src/kudu/integration-tests/master-stress-test.cc
@@ -526,7 +526,7 @@ class MasterStressTest : public ExternalMiniClusterITestBase,
};
// Run the test with the HMS integration enabled and disabled.
-INSTANTIATE_TEST_CASE_P(HmsConfigurations, MasterStressTest, ::testing::ValuesIn(
+INSTANTIATE_TEST_SUITE_P(HmsConfigurations, MasterStressTest, ::testing::ValuesIn(
vector<HmsMode> { HmsMode::NONE, HmsMode::ENABLE_METASTORE_INTEGRATION }
));
diff --git a/src/kudu/integration-tests/master_authz-itest.cc b/src/kudu/integration-tests/master_authz-itest.cc
index cf1864c..9ea64f6 100644
--- a/src/kudu/integration-tests/master_authz-itest.cc
+++ b/src/kudu/integration-tests/master_authz-itest.cc
@@ -20,6 +20,7 @@
#include <ostream>
#include <string>
#include <thread>
+#include <tuple>
#include <unordered_set>
#include <utility>
#include <vector>
@@ -729,7 +730,7 @@ class MasterAuthzITest : public MasterAuthzITestBase,
}
};
-INSTANTIATE_TEST_CASE_P(AuthzProviders, MasterAuthzITest,
+INSTANTIATE_TEST_SUITE_P(AuthzProviders, MasterAuthzITest,
::testing::Values(kRanger),
[] (const testing::TestParamInfo<MasterAuthzITest::ParamType>& info) {
return HarnessEnumToString(info.param);
@@ -984,7 +985,7 @@ class MasterAuthzOwnerITest : public MasterAuthzITestBase,
}
};
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
AuthzProvidersWithOwner, MasterAuthzOwnerITest,
::testing::Combine(::testing::Values(kRanger),
::testing::Values(kTestUser, "{OWNER}")),
@@ -1208,7 +1209,7 @@ static const AuthzDescriptor kAuthzCombinations[] = {
kTableName,
},
};
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
AuthzCombinations, TestAuthzTable,
::testing::Combine(::testing::Values(kRanger),
::testing::ValuesIn(kAuthzCombinations),
@@ -1301,14 +1302,13 @@ static const AuthzFuncs kAuthzFuncCombinations[] = {
},
};
-INSTANTIATE_TEST_CASE_P(AuthzFuncCombinations,
- AuthzErrorHandlingTest,
- ::testing::Combine(
- ::testing::Values(kRanger),
- ::testing::ValuesIn(kAuthzFuncCombinations)),
- [] (const testing::TestParamInfo<AuthzErrorHandlingTest::ParamType>& info) {
- return Substitute("$0_$1", HarnessEnumToString(std::get<0>(info.param)),
- std::get<1>(info.param).description);
- });
+INSTANTIATE_TEST_SUITE_P(AuthzFuncCombinations,
+ AuthzErrorHandlingTest,
+ ::testing::Combine(::testing::Values(kRanger),
+ ::testing::ValuesIn(kAuthzFuncCombinations)),
+ [](const testing::TestParamInfo<AuthzErrorHandlingTest::ParamType>& info) {
+ return Substitute("$0_$1", HarnessEnumToString(std::get<0>(info.param)),
+ std::get<1>(info.param).description);
+ });
} // namespace kudu
diff --git a/src/kudu/integration-tests/master_failover-itest.cc b/src/kudu/integration-tests/master_failover-itest.cc
index d10d5e7..f671b0a 100644
--- a/src/kudu/integration-tests/master_failover-itest.cc
+++ b/src/kudu/integration-tests/master_failover-itest.cc
@@ -163,7 +163,7 @@ class MasterFailoverTest : public KuduTest,
};
// Run the test with the HMS integration enabled and disabled.
-INSTANTIATE_TEST_CASE_P(HmsConfigurations, MasterFailoverTest, ::testing::ValuesIn(
+INSTANTIATE_TEST_SUITE_P(HmsConfigurations, MasterFailoverTest, ::testing::ValuesIn(
vector<HmsMode> { HmsMode::NONE, HmsMode::ENABLE_METASTORE_INTEGRATION }
));
diff --git a/src/kudu/integration-tests/raft_consensus-itest.cc b/src/kudu/integration-tests/raft_consensus-itest.cc
index 1f6a74c..0fae6e4 100644
--- a/src/kudu/integration-tests/raft_consensus-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus-itest.cc
@@ -2458,8 +2458,8 @@ class RaftConsensusParamReplicationModesITest :
public RaftConsensusITest,
public ::testing::WithParamInterface<bool> {
};
-INSTANTIATE_TEST_CASE_P(, RaftConsensusParamReplicationModesITest,
- ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(, RaftConsensusParamReplicationModesITest,
+ ::testing::Bool());
// Regression test for KUDU-1735, a crash in the case where a pending
// config change operation is aborted during tablet deletion when that config
diff --git a/src/kudu/integration-tests/raft_consensus_election-itest.cc b/src/kudu/integration-tests/raft_consensus_election-itest.cc
index fed341f..5f98b61 100644
--- a/src/kudu/integration-tests/raft_consensus_election-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus_election-itest.cc
@@ -431,7 +431,7 @@ TEST_P(RaftConsensusNumLeadersMetricTest, TestNumLeadersMetric) {
}
}
-INSTANTIATE_TEST_CASE_P(NumReplicas, RaftConsensusNumLeadersMetricTest, ::testing::Values(1, 3));
+INSTANTIATE_TEST_SUITE_P(NumReplicas, RaftConsensusNumLeadersMetricTest, ::testing::Values(1, 3));
// Test for KUDU-699: sets the consensus RPC timeout to be long,
// and freezes both followers before asking the leader to step down.
diff --git a/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc b/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc
index 8e11136..b62a6d1 100644
--- a/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc
@@ -23,6 +23,7 @@
#include <ostream>
#include <string>
#include <thread>
+#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
@@ -1880,9 +1881,9 @@ class IncompatibleReplicaReplacementSchemesITest :
public RaftConsensusNonVoterITest,
public ::testing::WithParamInterface<std::tuple<bool, bool>> {
};
-INSTANTIATE_TEST_CASE_P(, IncompatibleReplicaReplacementSchemesITest,
- ::testing::Combine(::testing::Bool(),
- ::testing::Bool()));
+INSTANTIATE_TEST_SUITE_P(, IncompatibleReplicaReplacementSchemesITest,
+ ::testing::Combine(::testing::Bool(),
+ ::testing::Bool()));
TEST_P(IncompatibleReplicaReplacementSchemesITest, MasterAndTserverMisconfig) {
FLAGS_num_tablet_servers = 1;
FLAGS_num_replicas = 1;
@@ -1968,7 +1969,7 @@ class ReplicaBehindWalGcThresholdITest :
public ::testing::WithParamInterface<
std::tuple<RaftConsensusITestBase::BehindWalGcBehavior, bool>> {
};
-INSTANTIATE_TEST_CASE_P(,
+INSTANTIATE_TEST_SUITE_P(,
ReplicaBehindWalGcThresholdITest,
::testing::Combine(
::testing::Values(RaftConsensusITestBase::BehindWalGcBehavior::STOP_CONTINUE,
diff --git a/src/kudu/integration-tests/security-itest.cc b/src/kudu/integration-tests/security-itest.cc
index 0db25f7..370f55f 100644
--- a/src/kudu/integration-tests/security-itest.cc
+++ b/src/kudu/integration-tests/security-itest.cc
@@ -496,7 +496,7 @@ class AuthTokenIssuingTest :
public ::testing::WithParamInterface<AuthTokenIssuingTestParams> {
};
-INSTANTIATE_TEST_CASE_P(, AuthTokenIssuingTest, ::testing::ValuesIn(
+INSTANTIATE_TEST_SUITE_P(, AuthTokenIssuingTest, ::testing::ValuesIn(
vector<AuthTokenIssuingTestParams>{
// The following 3 test cases cover passing authn token over an
// encrypted loopback connection.
@@ -631,7 +631,7 @@ class ConnectToFollowerMasterTest :
public SecurityITest,
public ::testing::WithParamInterface<ConnectToFollowerMasterTestParams> {
};
-INSTANTIATE_TEST_CASE_P(, ConnectToFollowerMasterTest, ::testing::ValuesIn(
+INSTANTIATE_TEST_SUITE_P(, ConnectToFollowerMasterTest, ::testing::ValuesIn(
vector<ConnectToFollowerMasterTestParams>{
{ "required", "optional", },
{ "required", "required", },
diff --git a/src/kudu/integration-tests/stop_tablet-itest.cc b/src/kudu/integration-tests/stop_tablet-itest.cc
index 571ff6d..e79b7f3 100644
--- a/src/kudu/integration-tests/stop_tablet-itest.cc
+++ b/src/kudu/integration-tests/stop_tablet-itest.cc
@@ -322,7 +322,7 @@ TEST_P(StopTabletITest, TestShutdownWhileWriting) {
NO_FATALS(cv.CheckCluster());
}
-INSTANTIATE_TEST_CASE_P(StopTablets, StopTabletITest, ::testing::Values(LEADER, FOLLOWER));
+INSTANTIATE_TEST_SUITE_P(StopTablets, StopTabletITest, ::testing::Values(LEADER, FOLLOWER));
} // namespace tserver
} // namespace kudu
diff --git a/src/kudu/integration-tests/tablet_copy-itest.cc b/src/kudu/integration-tests/tablet_copy-itest.cc
index 68521a6..9e534a0 100644
--- a/src/kudu/integration-tests/tablet_copy-itest.cc
+++ b/src/kudu/integration-tests/tablet_copy-itest.cc
@@ -1230,8 +1230,8 @@ const char* kTabletCopyFailureITestFlags[] = {
"--tablet_copy_early_session_timeout_prob=1.0",
"--tablet_copy_fault_crash_on_fetch_all=1.0"
};
-INSTANTIATE_TEST_CASE_P(FailureCause, TabletCopyFailureITest,
- ::testing::ValuesIn(kTabletCopyFailureITestFlags));
+INSTANTIATE_TEST_SUITE_P(FailureCause, TabletCopyFailureITest,
+ ::testing::ValuesIn(kTabletCopyFailureITestFlags));
// Test that a failed tablet copy of a brand-new replica results in still being
// able to vote while tombstoned.
@@ -1426,8 +1426,8 @@ class BadTabletCopyITest : public TabletCopyITest,
const char* kFlagFaultOnFetch = "fault_crash_on_handle_tc_fetch_data";
const char* kFlagEarlyTimeout = "tablet_copy_early_session_timeout_prob";
const char* kBadTabletCopyITestFlags[] = { kFlagFaultOnFetch, kFlagEarlyTimeout };
-INSTANTIATE_TEST_CASE_P(FaultFlags, BadTabletCopyITest,
- ::testing::ValuesIn(kBadTabletCopyITestFlags));
+INSTANTIATE_TEST_SUITE_P(FaultFlags, BadTabletCopyITest,
+ ::testing::ValuesIn(kBadTabletCopyITestFlags));
void BadTabletCopyITest::LoadTable(TestWorkload* workload, int min_rows, int min_blocks) {
const MonoDelta kTimeout = MonoDelta::FromSeconds(30);
diff --git a/src/kudu/integration-tests/tablet_replacement-itest.cc b/src/kudu/integration-tests/tablet_replacement-itest.cc
index 4cbd217..10982b1 100644
--- a/src/kudu/integration-tests/tablet_replacement-itest.cc
+++ b/src/kudu/integration-tests/tablet_replacement-itest.cc
@@ -22,7 +22,6 @@
#include <ostream>
#include <set>
#include <string>
-#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
@@ -554,9 +553,9 @@ TEST_P(EvictAndReplaceDeadFollowerITest, UnreachableFollower) {
ASSERT_OK(cluster_->tablet_server_by_uuid(kFollowerId)->Restart());
}
-INSTANTIATE_TEST_CASE_P(,
- EvictAndReplaceDeadFollowerITest,
- ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(,
+ EvictAndReplaceDeadFollowerITest,
+ ::testing::Bool());
/////////////////////////////////////////////////////////////////////////////
@@ -575,9 +574,9 @@ TEST_P(DontEvictIfRemainingConfigIsUnstableITest, NodesStopped) {
TestDontEvictIfRemainingConfigIsUnstable(NODE_STOPPED, GetParam());
}
-INSTANTIATE_TEST_CASE_P(,
- DontEvictIfRemainingConfigIsUnstableITest,
- ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(,
+ DontEvictIfRemainingConfigIsUnstableITest,
+ ::testing::Bool());
/////////////////////////////////////////////////////////////////////////////
diff --git a/src/kudu/integration-tests/tablet_server_quiescing-itest.cc b/src/kudu/integration-tests/tablet_server_quiescing-itest.cc
index 2fc6eb5..d66bfcd 100644
--- a/src/kudu/integration-tests/tablet_server_quiescing-itest.cc
+++ b/src/kudu/integration-tests/tablet_server_quiescing-itest.cc
@@ -765,7 +765,7 @@ TEST_P(TServerQuiescingParamITest, TestAbruptStepdownWhileAllQuiescing) {
});
}
-INSTANTIATE_TEST_CASE_P(NumReplicas, TServerQuiescingParamITest, ::testing::Values(1, 3));
+INSTANTIATE_TEST_SUITE_P(NumReplicas, TServerQuiescingParamITest, ::testing::Values(1, 3));
} // namespace itest
} // namespace kudu
diff --git a/src/kudu/integration-tests/tombstoned_voting-imc-itest.cc b/src/kudu/integration-tests/tombstoned_voting-imc-itest.cc
index 6027cd8..6409e1a 100644
--- a/src/kudu/integration-tests/tombstoned_voting-imc-itest.cc
+++ b/src/kudu/integration-tests/tombstoned_voting-imc-itest.cc
@@ -388,8 +388,8 @@ class TsRecoveryTombstonedIMCITest : public MiniClusterITestBase,
public ::testing::WithParamInterface<RestartAfterTombstone> {
};
-INSTANTIATE_TEST_CASE_P(Restart, TsRecoveryTombstonedIMCITest,
- ::testing::Values(kNoRestart, kRestart));
+INSTANTIATE_TEST_SUITE_P(Restart, TsRecoveryTombstonedIMCITest,
+ ::testing::Values(kNoRestart, kRestart));
// Basic tombstoned voting test.
TEST_P(TsRecoveryTombstonedIMCITest, TestTombstonedVoter) {
diff --git a/src/kudu/integration-tests/ts_authz-itest.cc b/src/kudu/integration-tests/ts_authz-itest.cc
index df0843e..25aac97 100644
--- a/src/kudu/integration-tests/ts_authz-itest.cc
+++ b/src/kudu/integration-tests/ts_authz-itest.cc
@@ -20,7 +20,6 @@
#include <ostream>
#include <string>
#include <thread>
-#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
@@ -655,7 +654,7 @@ TEST_P(TSAuthzITest, TestAlters) {
ASSERT_OK(PerformScan({ another_column }, nullptr, table.get()));
}
-INSTANTIATE_TEST_CASE_P(AuthzProviders, TSAuthzITest,
+INSTANTIATE_TEST_SUITE_P(AuthzProviders, TSAuthzITest,
::testing::Values(kRanger),
[] (const testing::TestParamInfo<TSAuthzITest::ParamType>& info) {
return HarnessEnumToString(info.param);
diff --git a/src/kudu/integration-tests/ts_recovery-itest.cc b/src/kudu/integration-tests/ts_recovery-itest.cc
index c1cb77c..cb25cfc 100644
--- a/src/kudu/integration-tests/ts_recovery-itest.cc
+++ b/src/kudu/integration-tests/ts_recovery-itest.cc
@@ -779,9 +779,9 @@ class UpdaterThreads {
// never hit disk.
class Kudu969Test : public TsRecoveryITest {
};
-INSTANTIATE_TEST_CASE_P(DifferentFaultPoints,
- Kudu969Test,
- ::testing::Values("fault_crash_before_flush_tablet_meta_after_compaction",
+INSTANTIATE_TEST_SUITE_P(DifferentFaultPoints,
+ Kudu969Test,
+ ::testing::Values("fault_crash_before_flush_tablet_meta_after_compaction",
"fault_crash_before_flush_tablet_meta_after_flush_mrs"));
TEST_P(Kudu969Test, Test) {
@@ -857,7 +857,7 @@ TEST_P(Kudu969Test, Test) {
// Passes block manager types to the recovery test so we get some extra
// testing to cover non-default block manager types.
-INSTANTIATE_TEST_CASE_P(BlockManagerType, TsRecoveryITest,
- ::testing::ValuesIn(BlockManager::block_manager_types()));
+INSTANTIATE_TEST_SUITE_P(BlockManagerType, TsRecoveryITest,
+ ::testing::ValuesIn(BlockManager::block_manager_types()));
} // namespace kudu
diff --git a/src/kudu/integration-tests/ts_tablet_manager-itest.cc b/src/kudu/integration-tests/ts_tablet_manager-itest.cc
index a6a0d50..dfa7324 100644
--- a/src/kudu/integration-tests/ts_tablet_manager-itest.cc
+++ b/src/kudu/integration-tests/ts_tablet_manager-itest.cc
@@ -296,9 +296,9 @@ TEST_P(FailedTabletsAreReplacedITest, OneReplica) {
// Ensure the tablet eventually is replicated.
NO_FATALS(v.CheckCluster());
}
-INSTANTIATE_TEST_CASE_P(,
- FailedTabletsAreReplacedITest,
- ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(,
+ FailedTabletsAreReplacedITest,
+ ::testing::Bool());
class LeadershipChangeReportingTest : public TsTabletManagerITest {
public:
diff --git a/src/kudu/integration-tests/txn_participant-itest.cc b/src/kudu/integration-tests/txn_participant-itest.cc
index b270bea..6a7e21e 100644
--- a/src/kudu/integration-tests/txn_participant-itest.cc
+++ b/src/kudu/integration-tests/txn_participant-itest.cc
@@ -428,7 +428,7 @@ TEST_P(ParticipantCopyITest, TestCopyParticipantOps) {
}
});
}
-INSTANTIATE_TEST_CASE_P(ShouldGCWals, ParticipantCopyITest, ::testing::Values(true, false));
+INSTANTIATE_TEST_SUITE_P(ShouldGCWals, ParticipantCopyITest, ::testing::Values(true, false));
// Test to ensure that the mechanisms built to allow snapshot scans to wait for
// safe time advancement will actually wait for transactions to commit.
diff --git a/src/kudu/integration-tests/txn_status_table-itest.cc b/src/kudu/integration-tests/txn_status_table-itest.cc
index 0f38400..d018beb 100644
--- a/src/kudu/integration-tests/txn_status_table-itest.cc
+++ b/src/kudu/integration-tests/txn_status_table-itest.cc
@@ -910,11 +910,11 @@ TEST_P(TxnStatusTableRetryITest, TestRetryOnError) {
// 1) timeout on waiting the replica to catch up with all replicated
// operations in previous term.
// 2) leader status is not initialized yet.
-INSTANTIATE_TEST_CASE_P(TestTxnStatusTableRetryOnError,
- TxnStatusTableRetryITest,
- ::testing::Values(kFailoverTimeoutError,
- kLeaderStatusError,
- kLoadFromTabletError));
+INSTANTIATE_TEST_SUITE_P(TestTxnStatusTableRetryOnError,
+ TxnStatusTableRetryITest,
+ ::testing::Values(kFailoverTimeoutError,
+ kLeaderStatusError,
+ kLoadFromTabletError));
class TxnStatusTableElectionStormITest : public TxnStatusTableITest {
public:
diff --git a/src/kudu/integration-tests/webserver-crawl-itest.cc b/src/kudu/integration-tests/webserver-crawl-itest.cc
index 077d57b..707d539 100644
--- a/src/kudu/integration-tests/webserver-crawl-itest.cc
+++ b/src/kudu/integration-tests/webserver-crawl-itest.cc
@@ -19,7 +19,7 @@
#include <deque>
#include <ostream>
#include <string>
-#include <type_traits>
+#include <tuple>
#include <unordered_set>
#include <utility>
#include <vector>
@@ -127,7 +127,7 @@ class WebserverCrawlITest : public KuduTest,
}
};
-INSTANTIATE_TEST_CASE_P(,
+INSTANTIATE_TEST_SUITE_P(,
WebserverCrawlITest,
::testing::Combine(
::testing::Values(UseSsl::NO, UseSsl::YES),
diff --git a/src/kudu/master/dynamic_multi_master-test.cc b/src/kudu/master/dynamic_multi_master-test.cc
index b6d5593..801ba07 100644
--- a/src/kudu/master/dynamic_multi_master-test.cc
+++ b/src/kudu/master/dynamic_multi_master-test.cc
@@ -22,6 +22,7 @@
#include <ostream>
#include <set>
#include <string>
+#include <tuple>
#include <unordered_set>
#include <utility>
#include <vector>
@@ -628,9 +629,9 @@ class ParameterizedAddMasterTest : public DynamicMultiMasterTest,
}
};
-INSTANTIATE_TEST_CASE_P(, ParameterizedAddMasterTest,
- // Initial number of masters in the cluster before adding a new master
- ::testing::Values(1, 2));
+INSTANTIATE_TEST_SUITE_P(, ParameterizedAddMasterTest,
+ // Initial number of masters in the cluster before adding a new master
+ ::testing::Values(1, 2));
// This test starts a cluster, creates a table and then adds a new master.
// For a system catalog with little data, the new master can be caught up from WAL and
diff --git a/src/kudu/master/master-test.cc b/src/kudu/master/master-test.cc
index 0450585..402f688 100644
--- a/src/kudu/master/master-test.cc
+++ b/src/kudu/master/master-test.cc
@@ -1431,8 +1431,8 @@ TEST_P(ConcurrentGetTableSchemaTest, DirectMethodCall) {
total / kRunInterval.ToSeconds(), supports_authz_ ? "enabled" : "disabled");
}
-INSTANTIATE_TEST_CASE_P(SupportsAuthzTokens,
- ConcurrentGetTableSchemaTest, ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(SupportsAuthzTokens,
+ ConcurrentGetTableSchemaTest, ::testing::Bool());
// Verifies that on-disk master metadata is self-consistent and matches a set
// of expected contents.
@@ -2424,7 +2424,7 @@ TEST_P(AuthzTokenMasterTest, TestGenerateAuthzTokens) {
}
}
-INSTANTIATE_TEST_CASE_P(SupportsAuthzTokens, AuthzTokenMasterTest, ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(SupportsAuthzTokens, AuthzTokenMasterTest, ::testing::Bool());
} // namespace master
} // namespace kudu
diff --git a/src/kudu/mini-cluster/CMakeLists.txt b/src/kudu/mini-cluster/CMakeLists.txt
index f92aee8..047c08c 100644
--- a/src/kudu/mini-cluster/CMakeLists.txt
+++ b/src/kudu/mini-cluster/CMakeLists.txt
@@ -26,6 +26,7 @@ set(MINI_CLUSTER_LIBS
gflags
glog
gmock
+ gtest
gutil
krpc
kudu_client
diff --git a/src/kudu/mini-cluster/external_mini_cluster-test.cc b/src/kudu/mini-cluster/external_mini_cluster-test.cc
index ee00dd2..74dd860 100644
--- a/src/kudu/mini-cluster/external_mini_cluster-test.cc
+++ b/src/kudu/mini-cluster/external_mini_cluster-test.cc
@@ -21,6 +21,7 @@
#include <memory>
#include <ostream>
#include <string>
+#include <tuple>
#include <utility>
#include <vector>
@@ -109,7 +110,7 @@ class ExternalMiniClusterTest :
{
};
-INSTANTIATE_TEST_CASE_P(,
+INSTANTIATE_TEST_SUITE_P(,
ExternalMiniClusterTest,
::testing::Combine(
::testing::Values(Kerberos::DISABLED, Kerberos::ENABLED),
diff --git a/src/kudu/rpc/negotiation-test.cc b/src/kudu/rpc/negotiation-test.cc
index 4498e4a..8b2db2d 100644
--- a/src/kudu/rpc/negotiation-test.cc
+++ b/src/kudu/rpc/negotiation-test.cc
@@ -397,9 +397,9 @@ TEST_P(TestNegotiation, TestNegotiation) {
}
}
-INSTANTIATE_TEST_CASE_P(NegotiationCombinations,
- TestNegotiation,
- ::testing::Values(
+INSTANTIATE_TEST_SUITE_P(NegotiationCombinations,
+ TestNegotiation,
+ ::testing::Values(
// client: no authn/mechs
// server: no authn/mechs
@@ -1291,7 +1291,7 @@ class TestDisableInit : public KuduTest {
// Invoke the currently-running test case in a new subprocess.
string filter_flag = strings::Substitute("--gtest_filter=$0.$1",
- CURRENT_TEST_CASE_NAME(), CURRENT_TEST_NAME());
+ CURRENT_TEST_SUITE_NAME(), CURRENT_TEST_NAME());
string executable_path;
CHECK_OK(env_->GetExecutablePath(&executable_path));
string stdout;
diff --git a/src/kudu/rpc/periodic-test.cc b/src/kudu/rpc/periodic-test.cc
index ea21994..a6082ae 100644
--- a/src/kudu/rpc/periodic-test.cc
+++ b/src/kudu/rpc/periodic-test.cc
@@ -99,9 +99,9 @@ class JitteredPeriodicTimerTest : public PeriodicTimerTest,
shared_ptr<PeriodicTimer> timer_;
};
-INSTANTIATE_TEST_CASE_P(AllJitterModes,
- JitteredPeriodicTimerTest,
- ::testing::Values(0.0, 0.25));
+INSTANTIATE_TEST_SUITE_P(AllJitterModes,
+ JitteredPeriodicTimerTest,
+ ::testing::Values(0.0, 0.25));
TEST_P(JitteredPeriodicTimerTest, TestStartStop) {
// Before the timer starts, the counter's value should not change.
@@ -210,9 +210,9 @@ class JitteredOneShotPeriodicTimerTest : public JitteredPeriodicTimerTest {
}
};
-INSTANTIATE_TEST_CASE_P(AllJitterModes,
- JitteredOneShotPeriodicTimerTest,
- ::testing::Values(0.0, 0.25));
+INSTANTIATE_TEST_SUITE_P(AllJitterModes,
+ JitteredOneShotPeriodicTimerTest,
+ ::testing::Values(0.0, 0.25));
TEST_P(JitteredOneShotPeriodicTimerTest, TestBasics) {
// Kick off the one-shot timer a few times.
diff --git a/src/kudu/rpc/rpc-test.cc b/src/kudu/rpc/rpc-test.cc
index 593749f..a3eaa04 100644
--- a/src/kudu/rpc/rpc-test.cc
+++ b/src/kudu/rpc/rpc-test.cc
@@ -28,6 +28,7 @@
#include <set>
#include <string>
#include <thread>
+#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
@@ -138,14 +139,14 @@ class TestRpc : public RpcTestBase, public ::testing::WithParamInterface<tuple<b
// This is used to run all parameterized tests with and without SSL, on Unix sockets
// and TCP.
-INSTANTIATE_TEST_CASE_P(Parameters, TestRpc,
- testing::Combine(testing::Values(false, true),
- testing::Values(false, true)),
- [](const testing::TestParamInfo<tuple<bool, bool>>& info) {
- return Substitute("$0_$1",
- std::get<0>(info.param) ? "SSL" : "NoSSL",
- std::get<1>(info.param) ? "UnixSocket" : "TCP");
- });
+INSTANTIATE_TEST_SUITE_P(Parameters, TestRpc,
+ testing::Combine(testing::Values(false, true),
+ testing::Values(false, true)),
+ [](const testing::TestParamInfo<tuple<bool, bool>>& info) {
+ return Substitute("$0_$1",
+ std::get<0>(info.param) ? "SSL" : "NoSSL",
+ std::get<1>(info.param) ? "UnixSocket" : "TCP");
+ });
TEST_P(TestRpc, TestMessengerCreateDestroy) {
diff --git a/src/kudu/security/crypto-test.cc b/src/kudu/security/crypto-test.cc
index 845df33..1918094 100644
--- a/src/kudu/security/crypto-test.cc
+++ b/src/kudu/security/crypto-test.cc
@@ -192,7 +192,7 @@ TEST_P(CryptoKeySerDesTest, ToAndFromString) {
NO_FATALS(CheckToAndFromString(public_key, format));
}
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
DataFormats, CryptoKeySerDesTest,
::testing::Values(DataFormat::DER, DataFormat::PEM));
diff --git a/src/kudu/security/tls_handshake-test.cc b/src/kudu/security/tls_handshake-test.cc
index c863d05..5e6a71d 100644
--- a/src/kudu/security/tls_handshake-test.cc
+++ b/src/kudu/security/tls_handshake-test.cc
@@ -143,7 +143,7 @@ class TestTlsHandshakeConcurrent : public TestTlsHandshakeBase,
// Test concurrently running handshakes while changing the certificates on the TLS
// context. We parameterize across different numbers of threads, because surprisingly,
// fewer threads seems to trigger issues more easily in some cases.
-INSTANTIATE_TEST_CASE_P(NumThreads, TestTlsHandshakeConcurrent, ::testing::Values(1, 2, 4, 8));
+INSTANTIATE_TEST_SUITE_P(NumThreads, TestTlsHandshakeConcurrent, ::testing::Values(1, 2, 4, 8));
TEST_P(TestTlsHandshakeConcurrent, TestConcurrentAdoptCert) {
const int kNumThreads = GetParam();
@@ -296,9 +296,9 @@ TEST_P(TestTlsHandshake, TestHandshake) {
ASSERT_STR_MATCHES(s.ToString(), test_case.expected_status.message().ToString());
}
-INSTANTIATE_TEST_CASE_P(CertCombinations,
- TestTlsHandshake,
- ::testing::Values(
+INSTANTIATE_TEST_SUITE_P(CertCombinations,
+ TestTlsHandshake,
+ ::testing::Values(
// We don't test any cases where the server has no cert or the client
// has a self-signed cert, since we don't expect those to occur in
diff --git a/src/kudu/tablet/all_types-scan-correctness-test.cc b/src/kudu/tablet/all_types-scan-correctness-test.cc
index af7f34f..7dfa1d6 100644
--- a/src/kudu/tablet/all_types-scan-correctness-test.cc
+++ b/src/kudu/tablet/all_types-scan-correctness-test.cc
@@ -748,7 +748,7 @@ typedef ::testing::Types<NumTypeRowOps<KeyTypeWrapper<INT8, BIT_SHUFFLE>>,
SliceTypeRowOps<KeyTypeWrapper<BINARY, PREFIX_ENCODING>>
> KeyTypes;
-TYPED_TEST_CASE(AllTypesScanCorrectnessTest, KeyTypes);
+TYPED_TEST_SUITE(AllTypesScanCorrectnessTest, KeyTypes);
TYPED_TEST(AllTypesScanCorrectnessTest, AllNonNullSequential) {
int null_upper = 0;
diff --git a/src/kudu/tablet/deltafile-test.cc b/src/kudu/tablet/deltafile-test.cc
index b31a229..ee118d9 100644
--- a/src/kudu/tablet/deltafile-test.cc
+++ b/src/kudu/tablet/deltafile-test.cc
@@ -423,7 +423,7 @@ class DeltaTypeTestDeltaFile : public TestDeltaFile {
};
using MyTypes = ::testing::Types<DeltaTypeSelector<REDO>, DeltaTypeSelector<UNDO>>;
-TYPED_TEST_CASE(DeltaTypeTestDeltaFile, MyTypes);
+TYPED_TEST_SUITE(DeltaTypeTestDeltaFile, MyTypes);
// Generates a series of random deltas, writes them to a DeltaFile, reads them
// back using a DeltaFileIterator, and verifies the results.
diff --git a/src/kudu/tablet/deltamemstore-test.cc b/src/kudu/tablet/deltamemstore-test.cc
index a6dc408..fc3b9c1 100644
--- a/src/kudu/tablet/deltamemstore-test.cc
+++ b/src/kudu/tablet/deltamemstore-test.cc
@@ -294,8 +294,8 @@ class TestDeltaMemStoreNumUpdates : public TestDeltaMemStore,
public ::testing::WithParamInterface<int> {
};
-INSTANTIATE_TEST_CASE_P(DifferentNumUpdates,
- TestDeltaMemStoreNumUpdates, ::testing::Values(2, 20, 200));
+INSTANTIATE_TEST_SUITE_P(DifferentNumUpdates,
+ TestDeltaMemStoreNumUpdates, ::testing::Values(2, 20, 200));
TEST_P(TestDeltaMemStoreNumUpdates, BenchmarkSnapshotScans) {
const int kNumRows = 100;
@@ -340,8 +340,8 @@ class TestDeltaMemStoreNumDeletes : public TestDeltaMemStore,
public ::testing::WithParamInterface<int> {
};
-INSTANTIATE_TEST_CASE_P(DifferentNumDeletes,
- TestDeltaMemStoreNumDeletes, ::testing::Values(0, 10, 100, 1000));
+INSTANTIATE_TEST_SUITE_P(DifferentNumDeletes,
+ TestDeltaMemStoreNumDeletes, ::testing::Values(0, 10, 100, 1000));
TEST_P(TestDeltaMemStoreNumDeletes, BenchmarkScansWithVaryingNumberOfDeletes) {
const int kNumUpdates = 10000;
diff --git a/src/kudu/tablet/diff_scan-test.cc b/src/kudu/tablet/diff_scan-test.cc
index dc3edc6..ced3cb0 100644
--- a/src/kudu/tablet/diff_scan-test.cc
+++ b/src/kudu/tablet/diff_scan-test.cc
@@ -19,6 +19,7 @@
#include <cstdint>
#include <memory>
#include <string>
+#include <tuple>
#include <utility>
#include <vector>
@@ -56,8 +57,8 @@ class DiffScanTest : public TabletTestBase<IntKeyTestSetup<INT64>>,
using Superclass = TabletTestBase<IntKeyTestSetup<INT64>>;
};
-INSTANTIATE_TEST_CASE_P(DiffScanModes, DiffScanTest,
- ::testing::Combine(
+INSTANTIATE_TEST_SUITE_P(DiffScanModes, DiffScanTest,
+ ::testing::Combine(
/*order_mode*/ ::testing::Values(UNORDERED, ORDERED),
/*include_deleted_rows*/ ::testing::Bool()));
diff --git a/src/kudu/tablet/diskrowset-test.cc b/src/kudu/tablet/diskrowset-test.cc
index 0674008..cce3d47 100644
--- a/src/kudu/tablet/diskrowset-test.cc
+++ b/src/kudu/tablet/diskrowset-test.cc
@@ -23,6 +23,7 @@
#include <memory>
#include <ostream>
#include <string>
+#include <tuple>
#include <unordered_set>
#include <vector>
@@ -735,9 +736,9 @@ class DiffScanRowSetTest : public KuduRowSetTest,
// Tests the Cartesian product of two boolean parameters:
// 1. Whether to include deleted rows in the scan.
// 2. Whether to include the "is deleted" virtual column in the scan's projection.
-INSTANTIATE_TEST_CASE_P(RowIteratorOptionsPermutations, DiffScanRowSetTest,
- ::testing::Combine(::testing::Bool(),
- ::testing::Bool()));
+INSTANTIATE_TEST_SUITE_P(RowIteratorOptionsPermutations, DiffScanRowSetTest,
+ ::testing::Combine(::testing::Bool(),
+ ::testing::Bool()));
// Tests diff scans on a diskrowset. The rowset is generated with only a handful
// of rows, but we randomly flush/compact between each update operation so that
diff --git a/src/kudu/tablet/memrowset-test.cc b/src/kudu/tablet/memrowset-test.cc
index 65205e4..1bb7b6f 100644
--- a/src/kudu/tablet/memrowset-test.cc
+++ b/src/kudu/tablet/memrowset-test.cc
@@ -23,6 +23,7 @@
#include <memory>
#include <ostream>
#include <string>
+#include <tuple>
#include <unordered_set>
#include <vector>
@@ -658,9 +659,9 @@ class ParameterizedTestMemRowSet : public TestMemRowSet,
// Tests the Cartesian product of two boolean parameters:
// 1. Whether to include deleted rows in the scan.
// 2. Whether to include the "is deleted" virtual column in the scan's projection.
-INSTANTIATE_TEST_CASE_P(RowIteratorOptionsPermutations, ParameterizedTestMemRowSet,
- ::testing::Combine(::testing::Bool(),
- ::testing::Bool()));
+INSTANTIATE_TEST_SUITE_P(RowIteratorOptionsPermutations, ParameterizedTestMemRowSet,
+ ::testing::Combine(::testing::Bool(),
+ ::testing::Bool()));
TEST_P(ParameterizedTestMemRowSet, TestScanSnapToExclude) {
shared_ptr<MemRowSet> mrs;
diff --git a/src/kudu/tablet/mt-tablet-test.cc b/src/kudu/tablet/mt-tablet-test.cc
index f85d595..937f4a0 100644
--- a/src/kudu/tablet/mt-tablet-test.cc
+++ b/src/kudu/tablet/mt-tablet-test.cc
@@ -465,7 +465,7 @@ class MultiThreadedTabletTest : public TabletTestBase<SETUP> {
};
-TYPED_TEST_CASE(MultiThreadedTabletTest, TabletTestHelperTypes);
+TYPED_TEST_SUITE(MultiThreadedTabletTest, TabletTestHelperTypes);
TYPED_TEST(MultiThreadedTabletTest, DoTestAllAtOnce) {
@@ -563,7 +563,7 @@ class MultiThreadedHybridClockTabletTest : public MultiThreadedTabletTest<SETUP>
}
};
-TYPED_TEST_CASE(MultiThreadedHybridClockTabletTest, TabletTestHelperTypes);
+TYPED_TEST_SUITE(MultiThreadedHybridClockTabletTest, TabletTestHelperTypes);
// Perform many updates and continuously flush and major compact deltas, as
// well as run undo delta gc.
diff --git a/src/kudu/tablet/mvcc-test.cc b/src/kudu/tablet/mvcc-test.cc
index a47eec1..75b7b6e 100644
--- a/src/kudu/tablet/mvcc-test.cc
+++ b/src/kudu/tablet/mvcc-test.cc
@@ -934,8 +934,9 @@ TEST_P(ParamedTransactionMvccTest, TestConcurrentLatestSnapshots) {
ASSERT_EQ(is_committed[i], snaps[i].IsCommitted(*txn_meta.get()));
}
}
-INSTANTIATE_TEST_CASE_P(Op, ParamedTransactionMvccTest,
- ::testing::Values(kCommit, kAbortAfterBeginCommit, kAbortBeforeBeginCommit));
+INSTANTIATE_TEST_SUITE_P(Op, ParamedTransactionMvccTest,
+ ::testing::Values(kCommit, kAbortAfterBeginCommit,
+ kAbortBeforeBeginCommit));
} // namespace tablet
} // namespace kudu
diff --git a/src/kudu/tablet/ops/op_tracker-test.cc b/src/kudu/tablet/ops/op_tracker-test.cc
index e7035f0..2699a0c 100644
--- a/src/kudu/tablet/ops/op_tracker-test.cc
+++ b/src/kudu/tablet/ops/op_tracker-test.cc
@@ -283,7 +283,7 @@ TEST_P(OpTrackerTest, TestTooManyOps) {
// Tests too many ops with two memory tracker limits. First is the root tracker
// memory limit and the second is current tracker memory limit.
-INSTANTIATE_TEST_CASE_P(MemoryLimitsMb, OpTrackerTest, ::testing::ValuesIn(
+INSTANTIATE_TEST_SUITE_P(MemoryLimitsMb, OpTrackerTest, ::testing::ValuesIn(
vector<pair<int, int>> { {2, 1}, {1, 2}, {2, 2} }));
} // namespace tablet
diff --git a/src/kudu/tablet/rowset_tree-test.cc b/src/kudu/tablet/rowset_tree-test.cc
index 8c861268..7a39a2a 100644
--- a/src/kudu/tablet/rowset_tree-test.cc
+++ b/src/kudu/tablet/rowset_tree-test.cc
@@ -24,6 +24,7 @@
#include <memory>
#include <ostream>
#include <string>
+#include <tuple>
#include <unordered_set>
#include <utility>
#include <vector>
@@ -279,7 +280,7 @@ TEST_F(TestRowSetTree, TestTreeRandomized) {
class TestRowSetTreePerformance : public TestRowSetTree,
public testing::WithParamInterface<std::tuple<int, int>> {
};
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
Parameters, TestRowSetTreePerformance,
testing::Combine(
// Number of rowsets.
diff --git a/src/kudu/tablet/tablet-decoder-eval-test.cc b/src/kudu/tablet/tablet-decoder-eval-test.cc
index c811912..fbd92a9 100644
--- a/src/kudu/tablet/tablet-decoder-eval-test.cc
+++ b/src/kudu/tablet/tablet-decoder-eval-test.cc
@@ -327,10 +327,10 @@ TEST_P(TabletDecoderEvalTest, MultipleColumns) {
TestMultipleColumnPredicates(10, 3, 5);
}
-INSTANTIATE_TEST_CASE_P(DecoderEvaluation, TabletDecoderEvalTest, ::testing::Values(EMPTY,
- SMALL,
- MEDIUM,
- LARGE));
+INSTANTIATE_TEST_SUITE_P(DecoderEvaluation, TabletDecoderEvalTest, ::testing::Values(EMPTY,
+ SMALL,
+ MEDIUM,
+ LARGE));
} // namespace tablet
} // namespace kudu
diff --git a/src/kudu/tablet/tablet-pushdown-test.cc b/src/kudu/tablet/tablet-pushdown-test.cc
index 3658e83..130a832 100644
--- a/src/kudu/tablet/tablet-pushdown-test.cc
+++ b/src/kudu/tablet/tablet-pushdown-test.cc
@@ -220,9 +220,9 @@ TEST_P(TabletPushdownTest, TestPushdownIntValueRange) {
// were not read.
}
-INSTANTIATE_TEST_CASE_P(AllMemory, TabletPushdownTest, ::testing::Values(ALL_IN_MEMORY));
-INSTANTIATE_TEST_CASE_P(SplitMemoryDisk, TabletPushdownTest, ::testing::Values(SPLIT_MEMORY_DISK));
-INSTANTIATE_TEST_CASE_P(AllDisk, TabletPushdownTest, ::testing::Values(ALL_ON_DISK));
+INSTANTIATE_TEST_SUITE_P(AllMemory, TabletPushdownTest, ::testing::Values(ALL_IN_MEMORY));
+INSTANTIATE_TEST_SUITE_P(SplitMemoryDisk, TabletPushdownTest, ::testing::Values(SPLIT_MEMORY_DISK));
+INSTANTIATE_TEST_SUITE_P(AllDisk, TabletPushdownTest, ::testing::Values(ALL_ON_DISK));
class TabletSparsePushdownTest : public KuduTabletTest {
public:
diff --git a/src/kudu/tablet/tablet-test-base.h b/src/kudu/tablet/tablet-test-base.h
index 9f9b406..6c3de17 100644
--- a/src/kudu/tablet/tablet-test-base.h
+++ b/src/kudu/tablet/tablet-test-base.h
@@ -292,7 +292,7 @@ struct NullableValueTestSetup {
}
};
-// Use this with TYPED_TEST_CASE from gtest
+// Use this with TYPED_TEST_SUITE from gtest
typedef ::testing::Types<
StringKeyTestSetup,
IntKeyTestSetup<INT8>,
diff --git a/src/kudu/tablet/tablet-test.cc b/src/kudu/tablet/tablet-test.cc
index 891e379..d534605 100644
--- a/src/kudu/tablet/tablet-test.cc
+++ b/src/kudu/tablet/tablet-test.cc
@@ -106,7 +106,7 @@ public:
ASSERT_EQ(expect, count);
}
};
-TYPED_TEST_CASE(TestTablet, TabletTestHelperTypes);
+TYPED_TEST_SUITE(TestTablet, TabletTestHelperTypes);
TYPED_TEST(TestTablet, TestFlush) {
// Insert 1000 rows into memrowset
diff --git a/src/kudu/tablet/txn_participant-test.cc b/src/kudu/tablet/txn_participant-test.cc
index 9373110..7cdbc39 100644
--- a/src/kudu/tablet/txn_participant-test.cc
+++ b/src/kudu/tablet/txn_participant-test.cc
@@ -800,8 +800,8 @@ TEST_P(MetadataFlushTxnParticipantTest, TestReplayUpdatesToTransactionalMRS) {
ASSERT_EQ(1, rows.size());
}
-INSTANTIATE_TEST_CASE_P(ShouldFlushMetadata, MetadataFlushTxnParticipantTest,
- ::testing::Values(true, false));
+INSTANTIATE_TEST_SUITE_P(ShouldFlushMetadata, MetadataFlushTxnParticipantTest,
+ ::testing::Values(true, false));
// Similar to the above test, but checking that in-flight ops anchor the WALs.
TEST_F(TxnParticipantTest, TestActiveParticipantOpsAnchorWALs) {
@@ -1365,7 +1365,7 @@ TEST_P(TxnParticipantConcurrencyTest, TestConcurrentDisjointInsertsTxn) {
ASSERT_EQ(kNumThreads * rows_per_thread * (txn_id + 1) / num_txns, rows.size());
}
}
-INSTANTIATE_TEST_CASE_P(ConcurrencyParams, TxnParticipantConcurrencyTest,
+INSTANTIATE_TEST_SUITE_P(ConcurrencyParams, TxnParticipantConcurrencyTest,
::testing::Values(
ConcurrencyParams{ /*num_txns*/1, /*num_rows_per_thread*/1 },
ConcurrencyParams{ /*num_txns*/10, /*num_rows_per_thread*/1 },
diff --git a/src/kudu/tools/kudu-admin-test.cc b/src/kudu/tools/kudu-admin-test.cc
index cbd5a68..ae90e87 100644
--- a/src/kudu/tools/kudu-admin-test.cc
+++ b/src/kudu/tools/kudu-admin-test.cc
@@ -27,6 +27,7 @@
#include <ostream>
#include <string>
#include <thread>
+#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
@@ -460,12 +461,12 @@ TEST_P(MoveTabletParamTest, Test) {
}
}
-INSTANTIATE_TEST_CASE_P(EnableKudu1097AndDownTS, MoveTabletParamTest,
- ::testing::Combine(::testing::Values(Kudu1097::Disable,
+INSTANTIATE_TEST_SUITE_P(EnableKudu1097AndDownTS, MoveTabletParamTest,
+ ::testing::Combine(::testing::Values(Kudu1097::Disable,
Kudu1097::Enable),
- ::testing::Values(DownTS::None,
- DownTS::TabletPeer,
- DownTS::UninvolvedTS)));
+ ::testing::Values(DownTS::None,
+ DownTS::TabletPeer,
+ DownTS::UninvolvedTS)));
Status RunUnsafeChangeConfig(const string& tablet_id,
const string& dst_host,
@@ -1539,9 +1540,9 @@ class TestLeaderStepDown :
public AdminCliTest,
public ::testing::WithParamInterface<LeaderStepDownMode> {
};
-INSTANTIATE_TEST_CASE_P(, TestLeaderStepDown,
- ::testing::Values(LeaderStepDownMode::ABRUPT,
- LeaderStepDownMode::GRACEFUL));
+INSTANTIATE_TEST_SUITE_P(, TestLeaderStepDown,
+ ::testing::Values(LeaderStepDownMode::ABRUPT,
+ LeaderStepDownMode::GRACEFUL));
TEST_P(TestLeaderStepDown, TestLeaderStepDownWhenNotPresent) {
FLAGS_num_tablet_servers = 3;
FLAGS_num_replicas = 3;
diff --git a/src/kudu/tools/kudu-tool-test.cc b/src/kudu/tools/kudu-tool-test.cc
index 14541fb..7a2bcc0 100644
--- a/src/kudu/tools/kudu-tool-test.cc
+++ b/src/kudu/tools/kudu-tool-test.cc
@@ -683,8 +683,8 @@ class ToolTestKerberosParameterized : public ToolTest, public ::testing::WithPar
return GetParam();
}
};
-INSTANTIATE_TEST_CASE_P(ToolTestKerberosParameterized, ToolTestKerberosParameterized,
- ::testing::Values(false, true));
+INSTANTIATE_TEST_SUITE_P(ToolTestKerberosParameterized, ToolTestKerberosParameterized,
+ ::testing::Values(false, true));
enum RunCopyTableCheckArgsType {
kTestCopyTableDstTableExist,
@@ -919,14 +919,14 @@ const char ToolTestCopyTableParameterized::kComplexSchemaColumns[]
= "key_hash0,key_hash1,key_hash2,key_range,int8_val,int16_val,int32_val,int64_val,"
"timestamp_val,string_val,bool_val,float_val,double_val,binary_val,decimal_val";
-INSTANTIATE_TEST_CASE_P(CopyTableParameterized,
- ToolTestCopyTableParameterized,
- ::testing::Values(kTestCopyTableDstTableExist,
- kTestCopyTableDstTableNotExist,
- kTestCopyTableUpsert,
- kTestCopyTableSchemaOnly,
- kTestCopyTableComplexSchema,
- kTestCopyTablePredicates));
+INSTANTIATE_TEST_SUITE_P(CopyTableParameterized,
+ ToolTestCopyTableParameterized,
+ ::testing::Values(kTestCopyTableDstTableExist,
+ kTestCopyTableDstTableNotExist,
+ kTestCopyTableUpsert,
+ kTestCopyTableSchemaOnly,
+ kTestCopyTableComplexSchema,
+ kTestCopyTablePredicates));
void ToolTest::StartExternalMiniCluster(ExternalMiniClusterOptions opts) {
cluster_.reset(new ExternalMiniCluster(std::move(opts)));
@@ -4921,11 +4921,11 @@ class ControlShellToolTest :
unique_ptr<SubprocessProtocol> proto_;
};
-INSTANTIATE_TEST_CASE_P(SerializationModes, ControlShellToolTest,
- ::testing::Combine(::testing::Values(
- SubprocessProtocol::SerializationMode::PB,
- SubprocessProtocol::SerializationMode::JSON),
- ::testing::Bool()));
+INSTANTIATE_TEST_SUITE_P(SerializationModes, ControlShellToolTest,
+ ::testing::Combine(::testing::Values(
+ SubprocessProtocol::SerializationMode::PB,
+ SubprocessProtocol::SerializationMode::JSON),
+ ::testing::Bool()));
TEST_P(ControlShellToolTest, TestControlShell) {
const int kNumMasters = 1;
@@ -5915,7 +5915,7 @@ class Is343ReplicaUtilTest :
public ToolTest,
public ::testing::WithParamInterface<bool> {
};
-INSTANTIATE_TEST_CASE_P(, Is343ReplicaUtilTest, ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(, Is343ReplicaUtilTest, ::testing::Bool());
TEST_P(Is343ReplicaUtilTest, Is343Cluster) {
constexpr auto kReplicationFactor = 3;
const auto is_343_scheme = GetParam();
diff --git a/src/kudu/tools/rebalancer_tool-test.cc b/src/kudu/tools/rebalancer_tool-test.cc
index 3cf4fd2..044c54d 100644
--- a/src/kudu/tools/rebalancer_tool-test.cc
+++ b/src/kudu/tools/rebalancer_tool-test.cc
@@ -27,6 +27,7 @@
#include <ostream>
#include <string>
#include <thread>
+#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
@@ -179,8 +180,8 @@ class RebalanceStartCriteriaTest :
public AdminCliTest,
public ::testing::WithParamInterface<Kudu1097> {
};
-INSTANTIATE_TEST_CASE_P(, RebalanceStartCriteriaTest,
- ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
+INSTANTIATE_TEST_SUITE_P(, RebalanceStartCriteriaTest,
+ ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
TEST_P(RebalanceStartCriteriaTest, TabletServerIsDown) {
const bool is_343_scheme = (GetParam() == Kudu1097::Enable);
const vector<string> kMasterFlags = {
@@ -240,8 +241,8 @@ class RebalanceStartSafetyTest :
public AdminCliTest,
public ::testing::WithParamInterface<Kudu1097> {
};
-INSTANTIATE_TEST_CASE_P(, RebalanceStartSafetyTest,
- ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
+INSTANTIATE_TEST_SUITE_P(, RebalanceStartSafetyTest,
+ ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
TEST_P(RebalanceStartSafetyTest, TooManyIgnoredTservers) {
const bool is_343_scheme = (GetParam() == Kudu1097::Enable);
const vector<string> kMasterFlags = {
@@ -470,7 +471,7 @@ class RebalanceParamTest :
public AdminCliTest,
public ::testing::WithParamInterface<tuple<int, Kudu1097>> {
};
-INSTANTIATE_TEST_CASE_P(, RebalanceParamTest,
+INSTANTIATE_TEST_SUITE_P(, RebalanceParamTest,
::testing::Combine(::testing::Values(1, 2, 3, 5),
::testing::Values(Kudu1097::Disable, Kudu1097::Enable)));
TEST_P(RebalanceParamTest, Rebalance) {
@@ -891,8 +892,8 @@ class DDLDuringRebalancingTest : public RebalancingTest,
return GetParam() == Kudu1097::Enable;
}
};
-INSTANTIATE_TEST_CASE_P(, DDLDuringRebalancingTest,
- ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
+INSTANTIATE_TEST_SUITE_P(, DDLDuringRebalancingTest,
+ ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
TEST_P(DDLDuringRebalancingTest, TablesCreatedAndDeletedDuringRebalancing) {
if (!AllowSlowTests()) {
LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
@@ -1083,8 +1084,8 @@ class ConcurrentRebalancersTest : public RebalancingTest,
return GetParam() == Kudu1097::Enable;
}
};
-INSTANTIATE_TEST_CASE_P(, ConcurrentRebalancersTest,
- ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
+INSTANTIATE_TEST_SUITE_P(, ConcurrentRebalancersTest,
+ ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
TEST_P(ConcurrentRebalancersTest, TwoConcurrentRebalancers) {
if (!AllowSlowTests()) {
LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
@@ -1176,8 +1177,8 @@ class TserverGoesDownDuringRebalancingTest : public RebalancingTest,
return GetParam() == Kudu1097::Enable;
}
};
-INSTANTIATE_TEST_CASE_P(, TserverGoesDownDuringRebalancingTest,
- ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
+INSTANTIATE_TEST_SUITE_P(, TserverGoesDownDuringRebalancingTest,
+ ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
TEST_P(TserverGoesDownDuringRebalancingTest, TserverDown) {
if (!AllowSlowTests()) {
LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
@@ -1263,8 +1264,8 @@ class TserverAddedDuringRebalancingTest : public RebalancingTest,
return GetParam() == Kudu1097::Enable;
}
};
-INSTANTIATE_TEST_CASE_P(, TserverAddedDuringRebalancingTest,
- ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
+INSTANTIATE_TEST_SUITE_P(, TserverAddedDuringRebalancingTest,
+ ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
TEST_P(TserverAddedDuringRebalancingTest, TserverStarts) {
if (!AllowSlowTests()) {
LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
@@ -1335,8 +1336,8 @@ class RebalancingDuringElectionStormTest : public RebalancingTest,
return GetParam() == Kudu1097::Enable;
}
};
-INSTANTIATE_TEST_CASE_P(, RebalancingDuringElectionStormTest,
- ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
+INSTANTIATE_TEST_SUITE_P(, RebalancingDuringElectionStormTest,
+ ::testing::Values(Kudu1097::Disable, Kudu1097::Enable));
TEST_P(RebalancingDuringElectionStormTest, RoundRobin) {
if (!AllowSlowTests()) {
LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
@@ -1484,7 +1485,7 @@ class RebalancerAndSingleReplicaTablets :
public AdminCliTest,
public ::testing::WithParamInterface<tuple<string, Kudu1097>> {
};
-INSTANTIATE_TEST_CASE_P(, RebalancerAndSingleReplicaTablets,
+INSTANTIATE_TEST_SUITE_P(, RebalancerAndSingleReplicaTablets,
::testing::Combine(::testing::Values("auto", "enabled", "disabled"),
::testing::Values(Kudu1097::Disable, Kudu1097::Enable)));
TEST_P(RebalancerAndSingleReplicaTablets, SingleReplicasStayOrMove) {
@@ -1930,9 +1931,9 @@ class LocationAwareRebalancingParamTest :
return true;
}
};
-INSTANTIATE_TEST_CASE_P(, LocationAwareRebalancingParamTest,
- ::testing::ValuesIn(kLaRebalancingParams),
- LaRebalancingTestName);
+INSTANTIATE_TEST_SUITE_P(, LocationAwareRebalancingParamTest,
+ ::testing::ValuesIn(kLaRebalancingParams),
+ LaRebalancingTestName);
TEST_P(LocationAwareRebalancingParamTest, Rebalance) {
if (!AllowSlowTests()) {
LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
diff --git a/src/kudu/tserver/tablet_copy_client-test.cc b/src/kudu/tserver/tablet_copy_client-test.cc
index f50fa52..ae49633 100644
--- a/src/kudu/tserver/tablet_copy_client-test.cc
+++ b/src/kudu/tserver/tablet_copy_client-test.cc
@@ -24,6 +24,7 @@
#include <ostream>
#include <string>
#include <thread>
+#include <tuple>
#include <vector>
#include <gflags/gflags.h>
@@ -473,11 +474,11 @@ class TabletCopyClientAbortTest : public TabletCopyClientTest,
void CreateTestBlocks(int num_blocks);
};
-INSTANTIATE_TEST_CASE_P(BlockDeleteTriggers,
- TabletCopyClientAbortTest,
- ::testing::Combine(
- ::testing::Values(kDownloadBlocks, kNoDownloadBlocks),
- ::testing::Values(kAbortMethod, kDestructor, kNoDelete)));
+INSTANTIATE_TEST_SUITE_P(BlockDeleteTriggers,
+ TabletCopyClientAbortTest,
+ ::testing::Combine(
+ ::testing::Values(kDownloadBlocks, kNoDownloadBlocks),
+ ::testing::Values(kAbortMethod, kDestructor, kNoDelete)));
void TabletCopyClientAbortTest::CreateTestBlocks(int num_blocks) {
for (int i = 0; i < num_blocks; i++) {
diff --git a/src/kudu/tserver/tablet_server-test.cc b/src/kudu/tserver/tablet_server-test.cc
index 8673ba5..555bd47 100644
--- a/src/kudu/tserver/tablet_server-test.cc
+++ b/src/kudu/tserver/tablet_server-test.cc
@@ -754,8 +754,8 @@ TEST_P(TabletServerDiskSpaceTest, TestFullGroupAddsDir) {
ASSERT_TRUE(dd_manager->IsTabletInFailedDir(kTabletId));
}
-INSTANTIATE_TEST_CASE_P(BlockManager, TabletServerDiskSpaceTest,
- ::testing::ValuesIn(BlockManager::block_manager_types()));
+INSTANTIATE_TEST_SUITE_P(BlockManager, TabletServerDiskSpaceTest,
+ ::testing::ValuesIn(BlockManager::block_manager_types()));
enum class ErrorType {
DISK_FAILURE,
@@ -781,7 +781,7 @@ class TabletServerDiskErrorTest : public TabletServerTestBase,
}
};
-INSTANTIATE_TEST_CASE_P(ErrorType, TabletServerDiskErrorTest, ::testing::Values(
+INSTANTIATE_TEST_SUITE_P(ErrorType, TabletServerDiskErrorTest, ::testing::Values(
ErrorType::DISK_FAILURE, ErrorType::CFILE_CORRUPTION, ErrorType::KUDU_2233_CORRUPTION));
// Test that applies random write operations to a tablet with a high
@@ -2043,8 +2043,8 @@ static const ReadMode kReadModes[] = {
READ_YOUR_WRITES,
};
-INSTANTIATE_TEST_CASE_P(Params, ExpiredScannerParamTest,
- testing::ValuesIn(kReadModes));
+INSTANTIATE_TEST_SUITE_P(Params, ExpiredScannerParamTest,
+ testing::ValuesIn(kReadModes));
class ScanCorruptedDeltasParamTest :
public TabletServerTest,
@@ -2134,8 +2134,8 @@ TEST_P(ScanCorruptedDeltasParamTest, Test) {
}
}
-INSTANTIATE_TEST_CASE_P(Params, ScanCorruptedDeltasParamTest,
- testing::ValuesIn(kReadModes));
+INSTANTIATE_TEST_SUITE_P(Params, ScanCorruptedDeltasParamTest,
+ testing::ValuesIn(kReadModes));
class ScannerOpenWhenServerShutsDownParamTest :
public TabletServerTest,
@@ -2157,8 +2157,8 @@ TEST_P(ScannerOpenWhenServerShutsDownParamTest, Test) {
// stayed open longer than the anchor registry
}
-INSTANTIATE_TEST_CASE_P(Params, ScannerOpenWhenServerShutsDownParamTest,
- testing::ValuesIn(kReadModes));
+INSTANTIATE_TEST_SUITE_P(Params, ScannerOpenWhenServerShutsDownParamTest,
+ testing::ValuesIn(kReadModes));
TEST_F(TabletServerTest, TestSnapshotScan) {
const int num_rows = AllowSlowTests() ? 1000 : 100;
@@ -3195,8 +3195,8 @@ TEST_P(InvalidScanRequest_NewScanAndScannerIDParamTest, Test) {
ASSERT_STR_CONTAINS(s.ToString(), "Must not pass both a scanner_id and new_scan_request");
}
-INSTANTIATE_TEST_CASE_P(Params, InvalidScanRequest_NewScanAndScannerIDParamTest,
- testing::ValuesIn(kReadModes));
+INSTANTIATE_TEST_SUITE_P(Params, InvalidScanRequest_NewScanAndScannerIDParamTest,
+ testing::ValuesIn(kReadModes));
// Test that passing a projection with fields not present in the tablet schema
// throws an exception.
@@ -3276,8 +3276,8 @@ TEST_P(InvalidScanRequest_WithIdsParamTest, Test) {
"User requests should not have Column IDs");
}
-INSTANTIATE_TEST_CASE_P(Params, InvalidScanRequest_WithIdsParamTest,
- testing::ValuesIn(kReadModes));
+INSTANTIATE_TEST_SUITE_P(Params, InvalidScanRequest_WithIdsParamTest,
+ testing::ValuesIn(kReadModes));
// Test scanning a tablet that has no entries.
TEST_F(TabletServerTest, TestScan_NoResults) {
@@ -3353,8 +3353,8 @@ TEST_P(InvalidScanSeqIdParamTest, Test) {
}
}
-INSTANTIATE_TEST_CASE_P(Params, InvalidScanSeqIdParamTest,
- testing::ValuesIn(kReadModes));
+INSTANTIATE_TEST_SUITE_P(Params, InvalidScanSeqIdParamTest,
+ testing::ValuesIn(kReadModes));
// Regression test for KUDU-1789: when ScannerKeepAlive is called on a non-existent
// scanner, it should properly respond with an error.
diff --git a/src/kudu/tserver/tablet_server_authorization-test.cc b/src/kudu/tserver/tablet_server_authorization-test.cc
index 5713176..469146a 100644
--- a/src/kudu/tserver/tablet_server_authorization-test.cc
+++ b/src/kudu/tserver/tablet_server_authorization-test.cc
@@ -24,7 +24,7 @@
#include <ostream>
#include <set>
#include <string>
-#include <type_traits>
+#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
@@ -351,7 +351,7 @@ TEST_P(AuthzTabletServerTest, TestInvalidAuthzTokens) {
}
}
-INSTANTIATE_TEST_CASE_P(RequestorFuncs, AuthzTabletServerTest,
+INSTANTIATE_TEST_SUITE_P(RequestorFuncs, AuthzTabletServerTest,
::testing::Values(&WriteGenerator, &ScanGenerator,
&SplitKeyRangeGenerator, &ChecksumGenerator));
@@ -895,7 +895,7 @@ TEST_P(ScanPrivilegeAuthzTest, TestWrongTableId) {
NO_FATALS(check_wrong_table());
}
-INSTANTIATE_TEST_CASE_P(RequestorFuncs, ScanPrivilegeAuthzTest,
+INSTANTIATE_TEST_SUITE_P(RequestorFuncs, ScanPrivilegeAuthzTest,
::testing::Combine(
::testing::ValuesIn(vector<ScanFunc>({
&ScanRequestor<DeprecatedField::DONT_USE, SpecialColumn::NONE>,
@@ -937,8 +937,8 @@ TEST_P(ScanPrivilegeNoProjectionAuthzTest, TestNoProjection) {
NO_FATALS(CheckPrivileges(req_func, scan, privileges, ExpectedAuthz::DENIED));
}
}
-INSTANTIATE_TEST_CASE_P(RequestorFuncs, ScanPrivilegeNoProjectionAuthzTest,
- ::testing::Combine(
+INSTANTIATE_TEST_SUITE_P(RequestorFuncs, ScanPrivilegeNoProjectionAuthzTest,
+ ::testing::Combine(
::testing::ValuesIn(vector<ScanFunc>({
&ScanRequestor<DeprecatedField::DONT_USE, SpecialColumn::NONE>,
&ScanRequestor<DeprecatedField::USE, SpecialColumn::NONE>,
@@ -1005,7 +1005,7 @@ TEST_P(ScanPrivilegeWithBadNamesTest, TestColumnNotFound) {
ASSERT_TRUE(s.IsInvalidArgument());
ASSERT_STR_CONTAINS(s.ToString(), kDummyColumn);
}
-INSTANTIATE_TEST_CASE_P(RequestorFuncs, ScanPrivilegeWithBadNamesTest,
+INSTANTIATE_TEST_SUITE_P(RequestorFuncs, ScanPrivilegeWithBadNamesTest,
::testing::Combine(
::testing::ValuesIn(vector<ScanFunc>({
&ScanRequestor<DeprecatedField::DONT_USE, SpecialColumn::MISNAMED>,
@@ -1055,7 +1055,7 @@ TEST_P(ScanPrivilegeWithVirtualColumnsTest, TestIsDeletedColumn) {
SCOPED_TRACE(scan.ToString());
NO_FATALS(CheckPrivileges(req_func, scan, privileges, ExpectedAuthz::DENIED));
}
-INSTANTIATE_TEST_CASE_P(RequestorFuncs, ScanPrivilegeWithVirtualColumnsTest,
+INSTANTIATE_TEST_SUITE_P(RequestorFuncs, ScanPrivilegeWithVirtualColumnsTest,
::testing::Combine(
::testing::ValuesIn(vector<ScanFunc>({
&ScanRequestor<DeprecatedField::DONT_USE, SpecialColumn::VIRTUAL>,
diff --git a/src/kudu/util/CMakeLists.txt b/src/kudu/util/CMakeLists.txt
index fc5955b..c454a29 100644
--- a/src/kudu/util/CMakeLists.txt
+++ b/src/kudu/util/CMakeLists.txt
@@ -392,6 +392,7 @@ target_link_libraries(kudu_test_util
gflags
glog
gmock
+ gtest
kudu_util)
#######################################
@@ -405,6 +406,7 @@ if(NOT NO_TESTS)
gflags
glog
gmock
+ gtest
kudu_util
kudu_test_util)
diff --git a/src/kudu/util/async_util-test.cc b/src/kudu/util/async_util-test.cc
index 3fcad25..17ba5d9 100644
--- a/src/kudu/util/async_util-test.cc
+++ b/src/kudu/util/async_util-test.cc
@@ -162,9 +162,9 @@ TEST_P(AsyncUtilTimedWaitTest, SynchronizerTimedWaitTimeout) {
}
}
-INSTANTIATE_TEST_CASE_P(WaitFlavors,
- AsyncUtilTimedWaitTest,
- ::testing::Values(TimedWaitFlavor::WaitFor,
- TimedWaitFlavor::WaitUntil));
+INSTANTIATE_TEST_SUITE_P(WaitFlavors,
+ AsyncUtilTimedWaitTest,
+ ::testing::Values(TimedWaitFlavor::WaitFor,
+ TimedWaitFlavor::WaitUntil));
} // namespace kudu
diff --git a/src/kudu/util/atomic-test.cc b/src/kudu/util/atomic-test.cc
index a65d55d..3bbcb97 100644
--- a/src/kudu/util/atomic-test.cc
+++ b/src/kudu/util/atomic-test.cc
@@ -54,7 +54,7 @@ class AtomicIntTest : public KuduTest {
};
typedef ::testing::Types<int32_t, int64_t, uint32_t, uint64_t> IntTypes;
-TYPED_TEST_CASE(AtomicIntTest, IntTypes);
+TYPED_TEST_SUITE(AtomicIntTest, IntTypes);
TYPED_TEST(AtomicIntTest, LoadStore) {
for (const MemoryOrder mem_order : this->acquire_release_) {
diff --git a/src/kudu/util/cache-bench.cc b/src/kudu/util/cache-bench.cc
index 91026ae..64016b2 100644
--- a/src/kudu/util/cache-bench.cc
+++ b/src/kudu/util/cache-bench.cc
@@ -156,7 +156,7 @@ class CacheBench : public KuduTest,
// Test both distributions, and for each, test both the case where the data
// fits in the cache and where it is a bit larger.
-INSTANTIATE_TEST_CASE_P(Patterns, CacheBench, testing::ValuesIn(std::vector<BenchSetup>{
+INSTANTIATE_TEST_SUITE_P(Patterns, CacheBench, testing::ValuesIn(std::vector<BenchSetup>{
{BenchSetup::Pattern::ZIPFIAN, 1.0},
{BenchSetup::Pattern::ZIPFIAN, 3.0},
{BenchSetup::Pattern::UNIFORM, 1.0},
diff --git a/src/kudu/util/cache-test.cc b/src/kudu/util/cache-test.cc
index 9ec9bfa..88368cb 100644
--- a/src/kudu/util/cache-test.cc
+++ b/src/kudu/util/cache-test.cc
@@ -8,6 +8,7 @@
#include <functional>
#include <memory>
#include <string>
+#include <tuple>
#include <utility>
#include <vector>
@@ -192,7 +193,7 @@ class CacheTest :
}
};
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
CacheTypes, CacheTest,
::testing::Values(
make_tuple(Cache::MemoryType::DRAM,
@@ -504,7 +505,7 @@ class LRUCacheTest :
}
};
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
CacheTypes, LRUCacheTest,
::testing::Combine(::testing::Values(Cache::MemoryType::DRAM,
Cache::MemoryType::NVM),
diff --git a/src/kudu/util/debug-util-test.cc b/src/kudu/util/debug-util-test.cc
index c69dbbc..322e17e 100644
--- a/src/kudu/util/debug-util-test.cc
+++ b/src/kudu/util/debug-util-test.cc
@@ -325,11 +325,11 @@ enum DangerousOp {
MALLOC_AND_FREE
};
class RaceTest : public DebugUtilTest, public ::testing::WithParamInterface<DangerousOp> {};
-INSTANTIATE_TEST_CASE_P(DifferentRaces, RaceTest,
- ::testing::Values(DLOPEN_AND_CLOSE,
- DL_ITERATE_PHDR,
- GET_STACK_TRACE,
- MALLOC_AND_FREE));
+INSTANTIATE_TEST_SUITE_P(DifferentRaces, RaceTest,
+ ::testing::Values(DLOPEN_AND_CLOSE,
+ DL_ITERATE_PHDR,
+ GET_STACK_TRACE,
+ MALLOC_AND_FREE));
void DangerousOperationThread(DangerousOp op, CountDownLatch* l) {
while (l->count()) {
diff --git a/src/kudu/util/env-test.cc b/src/kudu/util/env-test.cc
index 3eb4253..287ec6b 100644
--- a/src/kudu/util/env-test.cc
+++ b/src/kudu/util/env-test.cc
@@ -674,10 +674,10 @@ TEST_F(TestEnv, TestIsDirectory) {
class ResourceLimitTypeTest : public TestEnv,
public ::testing::WithParamInterface<Env::ResourceLimitType> {};
-INSTANTIATE_TEST_CASE_P(ResourceLimitTypes,
- ResourceLimitTypeTest,
- ::testing::Values(Env::ResourceLimitType::OPEN_FILES_PER_PROCESS,
- Env::ResourceLimitType::RUNNING_THREADS_PER_EUID));
+INSTANTIATE_TEST_SUITE_P(ResourceLimitTypes,
+ ResourceLimitTypeTest,
+ ::testing::Values(Env::ResourceLimitType::OPEN_FILES_PER_PROCESS,
+ Env::ResourceLimitType::RUNNING_THREADS_PER_EUID));
// Regression test for KUDU-1798.
TEST_P(ResourceLimitTypeTest, TestIncreaseLimit) {
diff --git a/src/kudu/util/env_util-test.cc b/src/kudu/util/env_util-test.cc
index 32c69b4..d771905 100644
--- a/src/kudu/util/env_util-test.cc
+++ b/src/kudu/util/env_util-test.cc
@@ -108,7 +108,7 @@ TEST_F(EnvUtilTest, TestCreateDirsRecursively) {
// Relative path.
ASSERT_OK(env_->ChangeDir(test_dir_)); // Change to test dir to keep CWD clean.
- string rel_base = Substitute("$0-$1", CURRENT_TEST_CASE_NAME(), CURRENT_TEST_NAME());
+ string rel_base = Substitute("$0-$1", CURRENT_TEST_SUITE_NAME(), CURRENT_TEST_NAME());
ASSERT_FALSE(env_->FileExists(rel_base));
path = JoinPathSegments(rel_base, "x/y/z");
ASSERT_OK(CreateDirsRecursively(env_, path));
diff --git a/src/kudu/util/file_cache-test.cc b/src/kudu/util/file_cache-test.cc
index 01ecfd5..59c3976 100644
--- a/src/kudu/util/file_cache-test.cc
+++ b/src/kudu/util/file_cache-test.cc
@@ -115,7 +115,7 @@ class FileCacheTest : public KuduTest {
};
typedef ::testing::Types<RWFile, RandomAccessFile> FileTypes;
-TYPED_TEST_CASE(FileCacheTest, FileTypes);
+TYPED_TEST_SUITE(FileCacheTest, FileTypes);
TYPED_TEST(FileCacheTest, TestBasicOperations) {
// Open a non-existent file.
diff --git a/src/kudu/util/minidump-test.cc b/src/kudu/util/minidump-test.cc
index 5d02918..798f468 100644
--- a/src/kudu/util/minidump-test.cc
+++ b/src/kudu/util/minidump-test.cc
@@ -146,7 +146,7 @@ TEST_P(MinidumpSignalDeathTest, TestHaveMinidumpAndStackTrace) {
NO_FATALS(WaitForMinidumps(num_expected_minidumps, minidump_handler.minidump_dir()));
}
-INSTANTIATE_TEST_CASE_P(DeadlySignals, MinidumpSignalDeathTest,
- ::testing::Values(SIGABRT, SIGBUS, SIGSEGV, SIGILL, SIGFPE, SIGTERM));
+INSTANTIATE_TEST_SUITE_P(DeadlySignals, MinidumpSignalDeathTest,
+ ::testing::Values(SIGABRT, SIGBUS, SIGSEGV, SIGILL, SIGFPE, SIGTERM));
} // namespace kudu
diff --git a/src/kudu/util/once-test.cc b/src/kudu/util/once-test.cc
index 0db8ec4..ff83220 100644
--- a/src/kudu/util/once-test.cc
+++ b/src/kudu/util/once-test.cc
@@ -79,7 +79,7 @@ static void InitOrGetInitted(Thing<KuduOnceType>* t, int i) {
} // anonymous namespace
typedef ::testing::Types<KuduOnceDynamic, KuduOnceLambda> KuduOnceTypes;
-TYPED_TEST_CASE(TestOnce, KuduOnceTypes);
+TYPED_TEST_SUITE(TestOnce, KuduOnceTypes);
template<class KuduOnceType>
class TestOnce : public KuduTest {};
diff --git a/src/kudu/util/pb_util-test.cc b/src/kudu/util/pb_util-test.cc
index a1635b4..c4d8ba3 100644
--- a/src/kudu/util/pb_util-test.cc
+++ b/src/kudu/util/pb_util-test.cc
@@ -110,8 +110,8 @@ class TestPBContainerVersions : public TestPBUtil,
const int version_; // The parameterized container version we are testing.
};
-INSTANTIATE_TEST_CASE_P(SupportedVersions, TestPBContainerVersions,
- ::testing::Values(1, 2, kUseDefaultVersion));
+INSTANTIATE_TEST_SUITE_P(SupportedVersions, TestPBContainerVersions,
+ ::testing::Values(1, 2, kUseDefaultVersion));
Status TestPBUtil::CreateKnownGoodContainerFile(CreateMode create, SyncMode sync) {
ProtoContainerTestPB test_pb;
diff --git a/src/kudu/util/random_util-test.cc b/src/kudu/util/random_util-test.cc
index 9170aca..e86b232 100644
--- a/src/kudu/util/random_util-test.cc
+++ b/src/kudu/util/random_util-test.cc
@@ -132,7 +132,7 @@ class TemplateRandomUtilTest : public RandomUtilTest {
// Testing with char, short data-types will result in compile-time error, as expected.
// Hence no run-time unit tests for non-32/64-bit integers.
typedef ::testing::Types<int32_t, uint32_t, int64_t, uint64_t> IntTypes;
-TYPED_TEST_CASE(TemplateRandomUtilTest, IntTypes);
+TYPED_TEST_SUITE(TemplateRandomUtilTest, IntTypes);
TYPED_TEST(TemplateRandomUtilTest, RunCreateRandomUniqueIntegers) {
this->RunCreateRandomUniqueIntegers();
diff --git a/src/kudu/util/rle-test.cc b/src/kudu/util/rle-test.cc
index 9295a0f..e443b6d 100644
--- a/src/kudu/util/rle-test.cc
+++ b/src/kudu/util/rle-test.cc
@@ -593,7 +593,7 @@ class TestRleLiteralGetNextRun : public KuduTest {
};
typedef ::testing::Types<int8_t, int16_t, int32_t, int64_t> IntDataTypes;
-TYPED_TEST_CASE(TestRleLiteralGetNextRun, IntDataTypes);
+TYPED_TEST_SUITE(TestRleLiteralGetNextRun, IntDataTypes);
TYPED_TEST(TestRleLiteralGetNextRun, RleGetNextRunIntDataTypes) {
this->RunTest();
diff --git a/src/kudu/util/rw_mutex-test.cc b/src/kudu/util/rw_mutex-test.cc
index c2cb394..a8254d8 100644
--- a/src/kudu/util/rw_mutex-test.cc
+++ b/src/kudu/util/rw_mutex-test.cc
@@ -49,9 +49,9 @@ class RWMutexTest : public KuduTest,
};
// Instantiate every test for each kind of RWMutex priority.
-INSTANTIATE_TEST_CASE_P(Priorities, RWMutexTest,
- ::testing::Values(RWMutex::Priority::PREFER_READING,
- RWMutex::Priority::PREFER_WRITING));
+INSTANTIATE_TEST_SUITE_P(Priorities, RWMutexTest,
+ ::testing::Values(RWMutex::Priority::PREFER_READING,
+ RWMutex::Priority::PREFER_WRITING));
// Multi-threaded test that tries to find deadlocks in the RWMutex wrapper.
TEST_P(RWMutexTest, TestDeadlocks) {
diff --git a/src/kudu/util/test_macros.h b/src/kudu/util/test_macros.h
index b82c453..28dcb26 100644
--- a/src/kudu/util/test_macros.h
+++ b/src/kudu/util/test_macros.h
@@ -125,7 +125,7 @@
#define CURRENT_TEST_NAME() \
::testing::UnitTest::GetInstance()->current_test_info()->name()
-#define CURRENT_TEST_CASE_NAME() \
- ::testing::UnitTest::GetInstance()->current_test_info()->test_case_name()
+#define CURRENT_TEST_SUITE_NAME() \
+ ::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name()
#endif
diff --git a/src/kudu/util/threadpool-test.cc b/src/kudu/util/threadpool-test.cc
index 7e98818..528701c 100644
--- a/src/kudu/util/threadpool-test.cc
+++ b/src/kudu/util/threadpool-test.cc
@@ -713,8 +713,8 @@ class ThreadPoolPerformanceTest :
public ThreadPoolTest,
public testing::WithParamInterface<bool> {
};
-INSTANTIATE_TEST_CASE_P(LoadMeterPresence, ThreadPoolPerformanceTest,
- ::testing::Values(false, true));
+INSTANTIATE_TEST_SUITE_P(LoadMeterPresence, ThreadPoolPerformanceTest,
+ ::testing::Values(false, true));
// A scenario to assess ThreadPool's performance in the absence/presence
// of the QueueLoadMeter. The scenario uses a mix of serial and concurrent
@@ -846,9 +846,9 @@ TEST_F(ThreadPoolTest, TestSlowDestructor) {
class ThreadPoolTestTokenTypes : public ThreadPoolTest,
public testing::WithParamInterface<ThreadPool::ExecutionMode> {};
-INSTANTIATE_TEST_CASE_P(Tokens, ThreadPoolTestTokenTypes,
- ::testing::Values(ThreadPool::ExecutionMode::SERIAL,
- ThreadPool::ExecutionMode::CONCURRENT));
+INSTANTIATE_TEST_SUITE_P(Tokens, ThreadPoolTestTokenTypes,
+ ::testing::Values(ThreadPool::ExecutionMode::SERIAL,
+ ThreadPool::ExecutionMode::CONCURRENT));
TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmitAndWait) {
diff --git a/thirdparty/build-definitions.sh b/thirdparty/build-definitions.sh
index a4ac427..fab73d8 100644
--- a/thirdparty/build-definitions.sh
+++ b/thirdparty/build-definitions.sh
@@ -481,7 +481,8 @@ build_gperftools() {
popd
}
-build_gmock() {
+build_gmock_gtest() {
+ # Build both gmock and gtest
GMOCK_SHARED_BDIR=$TP_BUILD_DIR/$GMOCK_NAME.shared$MODE_SUFFIX
GMOCK_STATIC_BDIR=$TP_BUILD_DIR/$GMOCK_NAME.static$MODE_SUFFIX
for SHARED in ON OFF; do
@@ -494,7 +495,6 @@ build_gmock() {
pushd $GMOCK_BDIR
rm -rf CMakeCache.txt CMakeFiles/
cmake \
- -DCMAKE_BUILD_TYPE=Debug \
-DCMAKE_POSITION_INDEPENDENT_CODE=On \
-DCMAKE_CXX_FLAGS="$EXTRA_CXXFLAGS" \
-DCMAKE_EXE_LINKER_FLAGS="$EXTRA_LDFLAGS $EXTRA_LIBS" \
@@ -502,7 +502,7 @@ build_gmock() {
-DCMAKE_SHARED_LINKER_FLAGS="$EXTRA_LDFLAGS $EXTRA_LIBS" \
-DBUILD_SHARED_LIBS=$SHARED \
$EXTRA_CMAKE_FLAGS \
- $GMOCK_SOURCE/googlemock
+ $GMOCK_SOURCE
${NINJA:-make} -j$PARALLEL $EXTRA_MAKEFLAGS
popd
done
@@ -510,9 +510,11 @@ build_gmock() {
# Install gmock/gtest libraries and headers manually instead of using make
# install. Make install results in libraries with a malformed lib name on
# macOS.
- echo Installing gmock...
- cp -a $GMOCK_SHARED_BDIR/libgmock.$DYLIB_SUFFIX $PREFIX/lib/
- cp -a $GMOCK_STATIC_BDIR/libgmock.a $PREFIX/lib/
+ echo Installing gmock and gtest...
+ cp -a $GMOCK_SHARED_BDIR/lib/libgmock.$DYLIB_SUFFIX $PREFIX/lib/
+ cp -a $GMOCK_STATIC_BDIR/lib/libgmock.a $PREFIX/lib/
+ cp -a $GMOCK_SHARED_BDIR/lib/libgtest.$DYLIB_SUFFIX $PREFIX/lib/
+ cp -a $GMOCK_STATIC_BDIR/lib/libgtest.a $PREFIX/lib/
rsync -av $GMOCK_SOURCE/googlemock/include/ $PREFIX/include/
rsync -av $GMOCK_SOURCE/googletest/include/ $PREFIX/include/
}
diff --git a/thirdparty/build-thirdparty.sh b/thirdparty/build-thirdparty.sh
index 3487550..101f324 100755
--- a/thirdparty/build-thirdparty.sh
+++ b/thirdparty/build-thirdparty.sh
@@ -375,7 +375,7 @@ if [ -n "$F_UNINSTRUMENTED" -o -n "$F_GPERFTOOLS" ]; then
fi
if [ -n "$F_UNINSTRUMENTED" -o -n "$F_GMOCK" ]; then
- build_gmock
+ build_gmock_gtest
fi
if [ -n "$F_UNINSTRUMENTED" -o -n "$F_PROTOBUF" ]; then
@@ -561,7 +561,7 @@ if [ -n "$F_TSAN" -o -n "$F_GLOG" ]; then
fi
if [ -n "$F_TSAN" -o -n "$F_GMOCK" ]; then
- build_gmock
+ build_gmock_gtest
fi
if [ -n "$F_TSAN" -o -n "$F_SNAPPY" ]; then
diff --git a/thirdparty/vars.sh b/thirdparty/vars.sh
index 6b8eab8..ca034bd 100644
--- a/thirdparty/vars.sh
+++ b/thirdparty/vars.sh
@@ -46,7 +46,7 @@ GLOG_VERSION=0.3.5
GLOG_NAME=glog-$GLOG_VERSION
GLOG_SOURCE=$TP_SOURCE_DIR/$GLOG_NAME
-GMOCK_VERSION=1.8.0
+GMOCK_VERSION=1.10.0
GMOCK_NAME=googletest-release-$GMOCK_VERSION
GMOCK_SOURCE=$TP_SOURCE_DIR/$GMOCK_NAME