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:46 UTC
[kudu] branch master updated (91f332a -> 78bd6c0)
This is an automated email from the ASF dual-hosted git repository.
bankim pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/kudu.git.
from 91f332a [test] use full specification for RedoType elements
new e74cdb3 [thirdparty] Upgrade gmock/gtest to 1.10.0
new 78bd6c0 [test] Start using GTEST_SKIP where applicable
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
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 | 38 ++++-----
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 | 7 +-
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 +-
src/kudu/integration-tests/alter_table-test.cc | 5 +-
.../integration-tests/auth_token_expire-itest.cc | 20 ++---
src/kudu/integration-tests/authz_token-itest.cc | 5 +-
.../client-negotiation-failover-itest.cc | 6 +-
.../integration-tests/client_failover-itest.cc | 4 +-
.../consensus_peer_health_status-itest.cc | 5 +-
src/kudu/integration-tests/consistency-itest.cc | 8 +-
src/kudu/integration-tests/create-table-itest.cc | 5 +-
.../integration-tests/create-table-stress-test.cc | 15 +---
src/kudu/integration-tests/delete_table-itest.cc | 21 ++---
src/kudu/integration-tests/disk_failure-itest.cc | 17 ++--
.../integration-tests/flex_partitioning-itest.cc | 7 +-
.../integration-tests/location_assignment-itest.cc | 18 ++---
.../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 +++---
.../master_cert_authority-itest.cc | 6 +-
.../integration-tests/master_failover-itest.cc | 23 ++----
.../integration-tests/open-readonly-fs-itest.cc | 2 +-
.../integration-tests/raft_config_change-itest.cc | 6 +-
src/kudu/integration-tests/raft_consensus-itest.cc | 17 ++--
.../raft_consensus_election-itest.cc | 2 +-
.../raft_consensus_failure_detector-imc-itest.cc | 6 +-
.../raft_consensus_nonvoter-itest.cc | 59 ++++----------
.../raft_consensus_stress-itest.cc | 5 +-
.../integration-tests/security-faults-itest.cc | 11 +--
src/kudu/integration-tests/security-itest.cc | 4 +-
.../security-unknown-tsk-itest.cc | 6 +-
src/kudu/integration-tests/stop_tablet-itest.cc | 2 +-
src/kudu/integration-tests/tablet_copy-itest.cc | 30 ++-----
.../tablet_copy_client_session-itest.cc | 10 +--
.../integration-tests/tablet_replacement-itest.cc | 30 +++----
.../tablet_server_quiescing-itest.cc | 2 +-
src/kudu/integration-tests/token_signer-itest.cc | 6 +-
.../tombstoned_voting-imc-itest.cc | 12 +--
.../tombstoned_voting-stress-test.cc | 2 +-
src/kudu/integration-tests/ts_authz-itest.cc | 3 +-
src/kudu/integration-tests/ts_recovery-itest.cc | 12 +--
.../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 | 7 +-
src/kudu/security/tls_handshake-test.cc | 8 +-
src/kudu/security/token-test.cc | 5 +-
src/kudu/tablet/all_types-scan-correctness-test.cc | 2 +-
src/kudu/tablet/compaction-test.cc | 10 +--
src/kudu/tablet/compaction_policy-test.cc | 5 +-
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/ksck_remote-test.cc | 5 +-
src/kudu/tools/kudu-admin-test.cc | 22 +++--
src/kudu/tools/kudu-tool-test.cc | 32 ++++----
src/kudu/tools/rebalancer_tool-test.cc | 94 +++++++---------------
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/monotime-test.cc | 5 +-
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/test_util.h | 2 +-
src/kudu/util/thread-test.cc | 11 +--
src/kudu/util/threadpool-test.cc | 10 +--
thirdparty/build-definitions.sh | 14 ++--
thirdparty/build-thirdparty.sh | 4 +-
thirdparty/vars.sh | 2 +-
121 files changed, 457 insertions(+), 700 deletions(-)
[kudu] 01/02: [thirdparty] Upgrade gmock/gtest to 1.10.0
Posted by ba...@apache.org.
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
[kudu] 02/02: [test] Start using GTEST_SKIP where applicable
Posted by ba...@apache.org.
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 78bd6c04ef37ca8906379a587140bc646433e28c
Author: Bankim Bhavsar <ba...@cloudera.com>
AuthorDate: Fri Feb 12 10:26:24 2021 -0800
[test] Start using GTEST_SKIP where applicable
Use the GTEST_SKIP() macro in SKIP_IF_SLOW_NOT_ALLOWED()
instead of early return so that test is marked
as SKIPPED instead of PASSED.
Replace instances where macro SKIP_IF_SLOW_NOT_ALLOWED()
is not used.
Use the GTEST_SKIP macro for a crypto test that is skipped
in FIPS mode.
On the dist-test UI, verified a skipped test is marked as
"successful" so no negative impact and same as earlier
but the test doesn't get marked as "skipped" or such.
Marking a test as skipped will require separate change to the
dist-test UI.
Sample output when tests are skipped:
[----------] Global test environment tear-down
[==========] 18 tests from 4 test suites ran. (27888 ms total)
[ PASSED ] 14 tests.
[ SKIPPED ] 4 tests, listed below:
[ SKIPPED ] ParameterizedAddMasterTest.TestAddMasterCatchupFromWAL/0
[ SKIPPED ] ParameterizedAddMasterTest.TestAddMasterCatchupFromWAL/1
[ SKIPPED ] ParameterizedAddMasterTest.TestAddMasterSysCatalogCopy/0
[ SKIPPED ] ParameterizedAddMasterTest.TestAddMasterSysCatalogCopy/1
Change-Id: I4466bdde3965921d527131e76ad221643ff05705
Reviewed-on: http://gerrit.cloudera.org:8080/17063
Tested-by: Kudu Jenkins
Reviewed-by: Alexey Serbin <as...@cloudera.com>
---
src/kudu/client/client-test.cc | 10 +---
src/kudu/fs/block_manager-test.cc | 5 +-
src/kudu/integration-tests/alter_table-test.cc | 5 +-
.../integration-tests/auth_token_expire-itest.cc | 16 ++-----
.../client-negotiation-failover-itest.cc | 6 +--
.../consensus_peer_health_status-itest.cc | 5 +-
src/kudu/integration-tests/create-table-itest.cc | 5 +-
.../integration-tests/create-table-stress-test.cc | 15 ++----
src/kudu/integration-tests/delete_table-itest.cc | 11 +----
.../integration-tests/location_assignment-itest.cc | 11 +----
.../master_cert_authority-itest.cc | 6 +--
.../integration-tests/master_failover-itest.cc | 21 ++-------
.../integration-tests/open-readonly-fs-itest.cc | 2 +-
.../integration-tests/raft_config_change-itest.cc | 6 +--
src/kudu/integration-tests/raft_consensus-itest.cc | 13 ++---
.../raft_consensus_failure_detector-imc-itest.cc | 6 +--
.../raft_consensus_nonvoter-itest.cc | 50 ++++----------------
.../raft_consensus_stress-itest.cc | 5 +-
.../integration-tests/security-faults-itest.cc | 11 +----
.../security-unknown-tsk-itest.cc | 6 +--
src/kudu/integration-tests/tablet_copy-itest.cc | 22 ++-------
.../tablet_copy_client_session-itest.cc | 10 +---
.../integration-tests/tablet_replacement-itest.cc | 17 ++-----
src/kudu/integration-tests/token_signer-itest.cc | 6 +--
.../tombstoned_voting-imc-itest.cc | 8 ++--
.../tombstoned_voting-stress-test.cc | 2 +-
src/kudu/integration-tests/ts_recovery-itest.cc | 2 +-
src/kudu/security/crypto-test.cc | 5 +-
src/kudu/security/token-test.cc | 5 +-
src/kudu/tablet/compaction-test.cc | 10 +---
src/kudu/tablet/compaction_policy-test.cc | 5 +-
src/kudu/tools/ksck_remote-test.cc | 5 +-
src/kudu/tools/kudu-admin-test.cc | 5 +-
src/kudu/tools/rebalancer_tool-test.cc | 55 +++++-----------------
src/kudu/util/monotime-test.cc | 5 +-
src/kudu/util/test_util.h | 2 +-
src/kudu/util/thread-test.cc | 11 +----
37 files changed, 86 insertions(+), 304 deletions(-)
diff --git a/src/kudu/client/client-test.cc b/src/kudu/client/client-test.cc
index 62d16b7..d210765 100644
--- a/src/kudu/client/client-test.cc
+++ b/src/kudu/client/client-test.cc
@@ -3861,10 +3861,7 @@ class FlushModeOpRatesTest : public ClientTest,
// in AUTO_FLUSH and AUTO_FLUSH_BACKGROUND mode; all the operations have
// the same pre-defined size.
TEST_P(FlushModeOpRatesTest, RunComparison) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const size_t kBufferSizeBytes = 1024;
const size_t kRowNum = 256;
@@ -5246,10 +5243,7 @@ shared_ptr<KuduSession> LoadedSession(const shared_ptr<KuduClient>& client,
// half update rows in descending order.
// This ensures that we don't hit a deadlock in such a situation.
TEST_F(ClientTest, TestDeadlockSimulation) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "TestDeadlockSimulation disabled since slow.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
// Make reverse client who will make batches that update rows
// in reverse order. Separate client used so rpc calls come in at same time.
diff --git a/src/kudu/fs/block_manager-test.cc b/src/kudu/fs/block_manager-test.cc
index 0064c31..588f091 100644
--- a/src/kudu/fs/block_manager-test.cc
+++ b/src/kudu/fs/block_manager-test.cc
@@ -599,10 +599,7 @@ TYPED_TEST(BlockManagerTest, CloseTwiceTest) {
TYPED_TEST(BlockManagerTest, CloseManyBlocksTest) {
const int kNumBlocks = 1000;
- if (!AllowSlowTests()) {
- LOG(INFO) << "Not running in slow-tests mode";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
Random rand(SeedRandom());
unique_ptr<BlockCreationTransaction> creation_transaction =
diff --git a/src/kudu/integration-tests/alter_table-test.cc b/src/kudu/integration-tests/alter_table-test.cc
index 3dad23f..6d6f65e 100644
--- a/src/kudu/integration-tests/alter_table-test.cc
+++ b/src/kudu/integration-tests/alter_table-test.cc
@@ -586,10 +586,7 @@ TEST_F(AlterTableTest, TestShutdownWithPendingTasks) {
// - get the new schema state, and mark the alter as complete
// - get the old schema state, and ask the TS again to perform the alter.
TEST_F(AlterTableTest, TestRestartTSDuringAlter) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping slow test";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
ASSERT_EQ(0, tablet_replica_->tablet()->metadata()->schema_version());
diff --git a/src/kudu/integration-tests/auth_token_expire-itest.cc b/src/kudu/integration-tests/auth_token_expire-itest.cc
index a22588c..b0f04c7 100644
--- a/src/kudu/integration-tests/auth_token_expire-itest.cc
+++ b/src/kudu/integration-tests/auth_token_expire-itest.cc
@@ -19,7 +19,6 @@
#include <cstdint>
#include <functional>
#include <memory>
-#include <ostream>
#include <string>
#include <vector>
@@ -285,10 +284,7 @@ INSTANTIATE_TEST_SUITE_P(ValidityIntervals, AuthTokenExpireDuringWorkloadITest,
TEST_P(AuthTokenExpireDuringWorkloadITest, InvalidTokenDuringMixedWorkload) {
static const int32_t kTimeoutMs = 10 * 60 * 1000;
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
ASSERT_OK(cluster_->Start());
@@ -327,10 +323,7 @@ TEST_P(AuthTokenExpireDuringWorkloadITest, InvalidTokenDuringSeparateWorkloads)
const string table_name = "authn-token-expire-separate-workloads";
static const int32_t kTimeoutMs = 10 * 60 * 1000;
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
ASSERT_OK(cluster_->Start());
@@ -547,10 +540,7 @@ class MultiMasterIdleConnectionsITest : public AuthTokenExpireITestBase {
// when the client tried to open the test table after master leader re-election:
// Timed out: GetTableSchema timed out after deadline expired
TEST_F(MultiMasterIdleConnectionsITest, ClientReacquiresAuthnToken) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const string kTableName = "keep-connection-to-former-master-leader";
const auto time_start = MonoTime::Now();
diff --git a/src/kudu/integration-tests/client-negotiation-failover-itest.cc b/src/kudu/integration-tests/client-negotiation-failover-itest.cc
index ee831b6..134d2d2 100644
--- a/src/kudu/integration-tests/client-negotiation-failover-itest.cc
+++ b/src/kudu/integration-tests/client-negotiation-failover-itest.cc
@@ -17,7 +17,6 @@
#include <cstdlib>
#include <memory>
-#include <ostream>
#include <string>
#include <thread>
#include <vector>
@@ -137,10 +136,7 @@ TEST_F(ClientFailoverOnNegotiationTimeoutITest, Kudu1580ConnectToTServer) {
static const int kTimeoutMs = 5 * 60 * 1000;
static const char* kTableName = "kudu1580";
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
cluster_opts_.num_tablet_servers = kNumTabletServers;
ASSERT_OK(CreateAndStartCluster());
diff --git a/src/kudu/integration-tests/consensus_peer_health_status-itest.cc b/src/kudu/integration-tests/consensus_peer_health_status-itest.cc
index bf328e1..855839b 100644
--- a/src/kudu/integration-tests/consensus_peer_health_status-itest.cc
+++ b/src/kudu/integration-tests/consensus_peer_health_status-itest.cc
@@ -62,10 +62,7 @@ class ConsensusPeerHealthStatusITest : public RaftConsensusITestBase {
// This is a functional test that verifies that when a replica goes into a bad
// state, its health status is detected by the leader replica.
TEST_F(ConsensusPeerHealthStatusITest, TestPeerHealthStatusTransitions) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "Test disabled in fast test mode. Set KUDU_ALLOW_SLOW_TESTS=1 to enable.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(30);
const vector<string> kMasterFlags = {
diff --git a/src/kudu/integration-tests/create-table-itest.cc b/src/kudu/integration-tests/create-table-itest.cc
index dce0bd3..71a1b48 100644
--- a/src/kudu/integration-tests/create-table-itest.cc
+++ b/src/kudu/integration-tests/create-table-itest.cc
@@ -443,10 +443,7 @@ static void LookUpRandomKeysLoop(const std::shared_ptr<master::MasterServiceProx
// This test replicates these conditions and hammers the master with key
// lookups, attempting to reproduce the master crashes.
TEST_F(CreateTableITest, TestCreateTableWithDeadTServers) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping slow test";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const char* kTableName = "test";
diff --git a/src/kudu/integration-tests/create-table-stress-test.cc b/src/kudu/integration-tests/create-table-stress-test.cc
index 8b6b83e..11f9b18 100644
--- a/src/kudu/integration-tests/create-table-stress-test.cc
+++ b/src/kudu/integration-tests/create-table-stress-test.cc
@@ -170,10 +170,7 @@ void CreateTableStressTest::CreateBigTable(const string& table_name, int num_tab
}
TEST_F(CreateTableStressTest, CreateAndDeleteBigTable) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping slow test";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
string table_name = "test_table";
NO_FATALS(CreateBigTable(table_name, FLAGS_num_test_tablets));
master::GetTableLocationsResponsePB resp;
@@ -204,10 +201,7 @@ TEST_F(CreateTableStressTest, CreateAndDeleteBigTable) {
}
TEST_F(CreateTableStressTest, RestartMasterDuringCreation) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping slow test";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
string table_name = "test_table";
NO_FATALS(CreateBigTable(table_name, FLAGS_num_test_tablets));
@@ -232,10 +226,7 @@ TEST_F(CreateTableStressTest, RestartMasterDuringCreation) {
}
TEST_F(CreateTableStressTest, TestGetTableLocationsOptions) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping slow test";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
string table_name = "test_table";
LOG(INFO) << CURRENT_TEST_NAME() << ": Step 1. Creating big table " << table_name << " ...";
diff --git a/src/kudu/integration-tests/delete_table-itest.cc b/src/kudu/integration-tests/delete_table-itest.cc
index 678d5cb..e53defc 100644
--- a/src/kudu/integration-tests/delete_table-itest.cc
+++ b/src/kudu/integration-tests/delete_table-itest.cc
@@ -858,11 +858,7 @@ TEST_F(DeleteTableITest, TestMergeConsensusMetadata) {
// state, which means they have not yet been committed to a majority, cannot
// shut down during a DeleteTablet() call.
TEST_F(DeleteTableITest, TestDeleteFollowerWithReplicatingOps) {
- if (!AllowSlowTests()) {
- // We will typically wait at least 5 seconds for timeouts to occur.
- LOG(INFO) << "Skipping test in fast-test mode.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta timeout = MonoDelta::FromSeconds(10);
@@ -1154,10 +1150,7 @@ TEST_F(DeleteTableITest, TestUnknownTabletsAreNotDeleted) {
// Ensure that the master doesn't try to delete tombstoned tablets.
// Regression test for KUDU-2114.
TEST_F(DeleteTableITest, TestNoDeleteTombstonedTablets) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "This test sleeps for several seconds and only runs in slow-test mode";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(30);
const vector<string> master_flags = {
diff --git a/src/kudu/integration-tests/location_assignment-itest.cc b/src/kudu/integration-tests/location_assignment-itest.cc
index 31d6937..8f7e211 100644
--- a/src/kudu/integration-tests/location_assignment-itest.cc
+++ b/src/kudu/integration-tests/location_assignment-itest.cc
@@ -18,7 +18,6 @@
#include <cstdint>
#include <functional>
#include <memory>
-#include <ostream>
#include <string>
#include <tuple>
#include <unordered_map>
@@ -215,10 +214,7 @@ class TsLocationAssignmentITest :
// is assigned the same location after restart once the location assignment
// script is kept the same between restarts.
TEST_P(TsLocationAssignmentITest, Basic) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(StartCluster());
NO_FATALS(CheckLocationInfo());
@@ -234,10 +230,7 @@ TEST_P(TsLocationAssignmentITest, Basic) {
// Verify the behavior of the location mapping cache upon tablet server
// registrations.
TEST_P(TsLocationAssignmentITest, LocationMappingCacheOnTabletServerRestart) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(StartCluster());
NO_FATALS(CheckLocationInfo());
diff --git a/src/kudu/integration-tests/master_cert_authority-itest.cc b/src/kudu/integration-tests/master_cert_authority-itest.cc
index 088bba9..6c0e142 100644
--- a/src/kudu/integration-tests/master_cert_authority-itest.cc
+++ b/src/kudu/integration-tests/master_cert_authority-itest.cc
@@ -18,7 +18,6 @@
#include <algorithm>
#include <iterator>
#include <memory>
-#include <ostream>
#include <string>
#include <thread>
#include <vector>
@@ -462,10 +461,7 @@ TEST_F(SingleMasterConnectToClusterTest, ConnectToCluster) {
}
TEST_F(MultiMasterConnectToClusterTest, ConnectToCluster) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
ASSERT_OK(cluster_->Start());
Run();
}
diff --git a/src/kudu/integration-tests/master_failover-itest.cc b/src/kudu/integration-tests/master_failover-itest.cc
index f671b0a..1a46fe3 100644
--- a/src/kudu/integration-tests/master_failover-itest.cc
+++ b/src/kudu/integration-tests/master_failover-itest.cc
@@ -173,10 +173,7 @@ INSTANTIATE_TEST_SUITE_P(HmsConfigurations, MasterFailoverTest, ::testing::Value
TEST_P(MasterFailoverTest, TestCreateTableSync) {
const char* kTableName = "default.test_create_table_sync";
- if (!AllowSlowTests()) {
- LOG(INFO) << "This test can only be run in slow mode.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
LOG(INFO) << "Pausing leader master";
int leader_idx;
@@ -206,10 +203,7 @@ TEST_P(MasterFailoverTest, TestCreateTableSync) {
TEST_P(MasterFailoverTest, TestPauseAfterCreateTableIssued) {
const char* kTableName = "default.test_pause_after_create_table_issued";
- if (!AllowSlowTests()) {
- LOG(INFO) << "This test can only be run in slow mode.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
ASSERT_OK(CreateTable(kTableName, kNoWaitForCreate));
@@ -236,10 +230,7 @@ TEST_P(MasterFailoverTest, TestPauseAfterCreateTableIssued) {
// elected leader master and succeed.
TEST_P(MasterFailoverTest, TestDeleteTableSync) {
const char* kTableName = "default.test_delete_table_sync";
- if (!AllowSlowTests()) {
- LOG(INFO) << "This test can only be run in slow mode.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
ASSERT_OK(CreateTable(kTableName, kWaitForCreate));
@@ -270,11 +261,7 @@ TEST_P(MasterFailoverTest, TestRenameTableSync) {
const char* kTableNameOrig = "default.test_alter_table_sync";
const char* kTableNameNew = "default.test_alter_table_sync_renamed";
- if (!AllowSlowTests()) {
- LOG(INFO) << "This test can only be run in slow mode.";
- return;
- }
-
+ SKIP_IF_SLOW_NOT_ALLOWED();
ASSERT_OK(CreateTable(kTableNameOrig, kWaitForCreate));
LOG(INFO) << "Pausing leader master";
diff --git a/src/kudu/integration-tests/open-readonly-fs-itest.cc b/src/kudu/integration-tests/open-readonly-fs-itest.cc
index f5eccfc..824f99d 100644
--- a/src/kudu/integration-tests/open-readonly-fs-itest.cc
+++ b/src/kudu/integration-tests/open-readonly-fs-itest.cc
@@ -99,7 +99,7 @@ class OpenReadonlyFsITest : public KuduTest {
// This is a regression test for KUDU-1657. It typically takes about 35 seconds
// to trigger that bug.
TEST_F(OpenReadonlyFsITest, TestWriteAndVerify) {
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
KuduSchema schema;
KuduSchemaBuilder b;
diff --git a/src/kudu/integration-tests/raft_config_change-itest.cc b/src/kudu/integration-tests/raft_config_change-itest.cc
index 83b7900..743bba4 100644
--- a/src/kudu/integration-tests/raft_config_change-itest.cc
+++ b/src/kudu/integration-tests/raft_config_change-itest.cc
@@ -111,11 +111,7 @@ class RaftConfigChangeITest : public ExternalMiniClusterITestBase {
// 8. Once that process completes, all 3 replicas will have identical logs,
// which is what we wait for at the end of the test.
TEST_F(RaftConfigChangeITest, TestKudu2147) {
- if (!AllowSlowTests()) {
- // This test injects seconds of latency so can take a while to converge.
- LOG(WARNING) << "Skipping test in fast-test mode.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(30);
// Slow down leader heartbeats so that in the explicit election below, the
// second leader does not immediately heartbeat to the initial leader. If
diff --git a/src/kudu/integration-tests/raft_consensus-itest.cc b/src/kudu/integration-tests/raft_consensus-itest.cc
index 0fae6e4..e8902b8 100644
--- a/src/kudu/integration-tests/raft_consensus-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus-itest.cc
@@ -2098,7 +2098,7 @@ static void EnableLogLatency(server::GenericServiceProxy* proxy) {
// Run a regular workload with a leader that's writing to its WAL slowly.
TEST_F(RaftConsensusITest, TestSlowLeader) {
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(BuildAndStart());
@@ -2178,7 +2178,7 @@ TEST_F(RaftConsensusITest, TestLargeBatches) {
TEST_F(RaftConsensusITest, TestCommitIndexFarBehindAfterLeaderElection) {
const MonoDelta kTimeout = MonoDelta::FromSeconds(10);
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
// Set the batch size low so that, after the new leader takes
// over below, the ops required to catch up from the committed index
@@ -2265,7 +2265,7 @@ TEST_F(RaftConsensusITest, TestCommitIndexFarBehindAfterLeaderElection) {
// Run a regular workload with one follower that's writing to its WAL slowly.
TEST_F(RaftConsensusITest, TestSlowFollower) {
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(BuildAndStart());
@@ -2296,7 +2296,7 @@ TEST_F(RaftConsensusITest, TestSlowFollower) {
// Run a special workload that constantly updates a single row on a cluster
// where every replica is writing to its WAL slowly.
TEST_F(RaftConsensusITest, TestHammerOneRow) {
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(BuildAndStart());
@@ -3070,10 +3070,7 @@ TEST_P(RaftConsensusParamReplicationModesITest, TestRestartWithDifferentUUID) {
// Designating graceful leadership transfer to a follower that cannot catch up
// should eventually fail.
TEST_F(RaftConsensusITest, TestLeaderTransferWhenFollowerFallsBehindLeaderGC) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const auto kTimeout = MonoDelta::FromSeconds(30);
vector<string> ts_flags = {
// Disable follower eviction.
diff --git a/src/kudu/integration-tests/raft_consensus_failure_detector-imc-itest.cc b/src/kudu/integration-tests/raft_consensus_failure_detector-imc-itest.cc
index 33af873..e104a8f 100644
--- a/src/kudu/integration-tests/raft_consensus_failure_detector-imc-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus_failure_detector-imc-itest.cc
@@ -17,7 +17,6 @@
#include <functional>
#include <memory>
-#include <ostream>
#include <string>
#include <unordered_map>
#include <utility>
@@ -62,10 +61,7 @@ class RaftConsensusFailureDetectorIMCTest : public MiniClusterITestBase {
// configuration change.
// Regression test for KUDU-2229.
TEST_F(RaftConsensusFailureDetectorIMCTest, TestFailureDetectorActivation) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(30);
diff --git a/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc b/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc
index b62a6d1..1c6c3cf 100644
--- a/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus_nonvoter-itest.cc
@@ -696,10 +696,7 @@ TEST_F(RaftConsensusNonVoterITest, AddThenRemoveNonVoterReplica) {
// * does not start leader elections
// * returns an error on RunLeaderElection() RPC call
TEST_F(RaftConsensusNonVoterITest, NonVoterReplicasDoNotVote) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(60);
const int kOriginalReplicasNum = 2;
@@ -831,10 +828,7 @@ TEST_F(RaftConsensusNonVoterITest, NonVoterReplicasDoNotVote) {
// Promote and demote a replica under active workload.
// Promote a replica and remove it, making sure it gets tombstoned.
TEST_F(RaftConsensusNonVoterITest, PromoteAndDemote) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(120);
const int kInitialReplicasNum = 3;
@@ -1020,10 +1014,7 @@ TEST_F(RaftConsensusNonVoterITest, PromoteAndDemote) {
// its failure detection mechanism works as expected.
//
TEST_F(RaftConsensusNonVoterITest, PromotedReplicaCanVote) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(60);
const int kInitialReplicasNum = 3;
@@ -1165,10 +1156,7 @@ TEST_F(RaftConsensusNonVoterITest, PromotedReplicaCanVote) {
// Add an extra non-voter replica to the tablet and make sure it's evicted
// by the catalog manager once catalog manager sees its state updated.
TEST_F(RaftConsensusNonVoterITest, CatalogManagerEvictsExcessNonVoter) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const int kReplicaUnavailableSec = 5;
const MonoDelta kTimeout = MonoDelta::FromSeconds(60);
@@ -1262,10 +1250,7 @@ TEST_F(RaftConsensusNonVoterITest, CatalogManagerEvictsExcessNonVoter) {
//
// TODO(aserbin): and make it run for 5 tablet servers.
TEST_F(RaftConsensusNonVoterITest, CatalogManagerAddsNonVoter) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const int kReplicaUnavailableSec = 10;
const MonoDelta kTimeout = MonoDelta::FromSeconds(6 * kReplicaUnavailableSec);
@@ -1323,10 +1308,7 @@ TEST_F(RaftConsensusNonVoterITest, CatalogManagerAddsNonVoter) {
// original voter replicas from the tablet server should stay, but the newly
// added non-voter replicas should be evicted.
TEST_F(RaftConsensusNonVoterITest, TabletServerIsGoneAndBack) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const auto kReplicasNum = 3;
const auto kReplicaUnavailableSec = 5;
@@ -1430,10 +1412,7 @@ TEST_F(RaftConsensusNonVoterITest, TabletServerIsGoneAndBack) {
// replace the failed voter replica, so eventually the tablet has appropriate
// number of functional replicas to guarantee the tablet's replication factor.
TEST_F(RaftConsensusNonVoterITest, FailedTabletCopy) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const auto kReplicasNum = 3;
const auto kConsensusRpcTimeout = MonoDelta::FromSeconds(5);
@@ -1613,10 +1592,7 @@ TEST_F(RaftConsensusNonVoterITest, FailedTabletCopy) {
// After that, all tablet servers except for the former leader replica's server
// are started again.
TEST_F(RaftConsensusNonVoterITest, RestartClusterWithNonVoter) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const auto kReplicasNum = 3;
const auto kConsensusRpcTimeout = MonoDelta::FromSeconds(5);
@@ -1771,10 +1747,7 @@ TEST_F(RaftConsensusNonVoterITest, RestartClusterWithNonVoter) {
// Raft cluster, adding a new non-voter replica, when a majority of voters
// is not online. Make sure the configuration change is not committed.
TEST_F(RaftConsensusNonVoterITest, NonVoterReplicasInConsensusQueue) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(60);
const int kOriginalReplicasNum = 3;
@@ -1977,10 +1950,7 @@ INSTANTIATE_TEST_SUITE_P(,
RaftConsensusITestBase::BehindWalGcBehavior::SHUTDOWN),
::testing::Bool()));
TEST_P(ReplicaBehindWalGcThresholdITest, ReplicaReplacement) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const auto kReplicasNum = 3;
const auto kTimeoutSec = 60;
diff --git a/src/kudu/integration-tests/raft_consensus_stress-itest.cc b/src/kudu/integration-tests/raft_consensus_stress-itest.cc
index 7191542..9700d61 100644
--- a/src/kudu/integration-tests/raft_consensus_stress-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus_stress-itest.cc
@@ -106,10 +106,7 @@ class RaftConsensusStressITest : public RaftConsensusITestBase {
// some point all replacement replicas are placed on top of previously
// tombstoned ones.
TEST_F(RaftConsensusStressITest, RemoveReplaceInCycle) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const bool is_343_scheme = FLAGS_test_raft_prepare_replacement_before_eviction;
const int kReplicaUnavailableSec = FLAGS_test_follower_unavailable_considered_failed_sec;
diff --git a/src/kudu/integration-tests/security-faults-itest.cc b/src/kudu/integration-tests/security-faults-itest.cc
index 67880b0..c25da19 100644
--- a/src/kudu/integration-tests/security-faults-itest.cc
+++ b/src/kudu/integration-tests/security-faults-itest.cc
@@ -19,7 +19,6 @@
#include <cstdint>
#include <iterator>
#include <memory>
-#include <ostream>
#include <string>
#include <vector>
@@ -165,10 +164,7 @@ class SecurityComponentsFaultsITest : public KuduTest {
// Check how the system behaves when KDC is not available upon start-up
// of Kudu server-side components.
TEST_F(SecurityComponentsFaultsITest, NoKdcOnStart) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
// Start with the KDC first: let's generate generate keytabs, get initial
// kerberos tickets, etc.
@@ -206,10 +202,7 @@ TEST_F(SecurityComponentsFaultsITest, NoKdcOnStart) {
// Check that restarting KDC does not affect running master and tablet servers:
// they are able to operate with no issues past ticket TTL once KDC is back.
TEST_F(SecurityComponentsFaultsITest, KdcRestartsInTheMiddle) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
// Enable KRPC negotiation tracing for the Kudu client running smoke test
// workload.
diff --git a/src/kudu/integration-tests/security-unknown-tsk-itest.cc b/src/kudu/integration-tests/security-unknown-tsk-itest.cc
index 35f90aa..c7d37ae 100644
--- a/src/kudu/integration-tests/security-unknown-tsk-itest.cc
+++ b/src/kudu/integration-tests/security-unknown-tsk-itest.cc
@@ -19,7 +19,6 @@
#include <cstdint>
#include <cstdlib>
#include <memory>
-#include <ostream>
#include <string>
#include <thread>
#include <vector>
@@ -346,10 +345,7 @@ TEST_F(SecurityUnknownTskTest, ErrorUnavailableCommonOperations) {
// this gives coverage of ERROR_UNAVAILABLE handling for all RPC calls involved
// in the workload scenario.
TEST_F(SecurityUnknownTskTest, ErrorUnavailableDuringWorkload) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
static const int64_t kTimeoutMs = 20 * 1000;
int64_t tsk_seq_num = 100;
diff --git a/src/kudu/integration-tests/tablet_copy-itest.cc b/src/kudu/integration-tests/tablet_copy-itest.cc
index 9e534a0..ced7108 100644
--- a/src/kudu/integration-tests/tablet_copy-itest.cc
+++ b/src/kudu/integration-tests/tablet_copy-itest.cc
@@ -167,11 +167,7 @@ class TabletCopyITest : public ExternalMiniClusterITestBase {
// A leader can "go rogue" due to a VM pause, CTRL-z, partition, etc.
TEST_F(TabletCopyITest, TestRejectRogueLeader) {
// This test pauses for at least 10 seconds. Only run in slow-test mode.
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping test in fast-test mode.";
- return;
- }
-
+ SKIP_IF_SLOW_NOT_ALLOWED();
vector<string> ts_flags, master_flags;
ts_flags.emplace_back("--enable_leader_failure_detection=false");
master_flags.emplace_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
@@ -620,10 +616,7 @@ TEST_F(TabletCopyITest, TestTabletCopyFollowerWithHigherTerm) {
// multiple tablets between the same tablet copy client host and source host
// could corrupt each other.
TEST_F(TabletCopyITest, TestConcurrentTabletCopys) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping test in fast-test mode.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
vector<string> ts_flags, master_flags;
ts_flags.emplace_back("--enable_leader_failure_detection=false");
@@ -730,10 +723,7 @@ TEST_F(TabletCopyITest, TestConcurrentTabletCopys) {
// KUDU-1047.
TEST_F(TabletCopyITest, TestDeleteLeaderDuringTabletCopyStressTest) {
// This test takes a while due to failure detection.
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping test in fast-test mode.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta timeout = MonoDelta::FromSeconds(60);
NO_FATALS(StartCluster(vector<string>(), vector<string>(), 5));
@@ -1472,11 +1462,7 @@ void BadTabletCopyITest::LoadTable(TestWorkload* workload, int min_rows, int min
// Ensure that a tablet copy failure results in no orphaned blocks and no data loss.
TEST_P(BadTabletCopyITest, TestBadCopy) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "Not running " << CURRENT_TEST_NAME() << " because it is a slow test.";
- return;
- }
-
+ SKIP_IF_SLOW_NOT_ALLOWED();
// Load 2 tablets with 3 replicas each across 3 tablet servers s.t. we end up
// with a replication distribution like: ([A], [A,B], [A,B], [B]).
const MonoDelta kTimeout = MonoDelta::FromSeconds(30);
diff --git a/src/kudu/integration-tests/tablet_copy_client_session-itest.cc b/src/kudu/integration-tests/tablet_copy_client_session-itest.cc
index 119a5bd..964f8da 100644
--- a/src/kudu/integration-tests/tablet_copy_client_session-itest.cc
+++ b/src/kudu/integration-tests/tablet_copy_client_session-itest.cc
@@ -122,10 +122,7 @@ void TabletCopyClientSessionITest::PrepareClusterForTabletCopy(
// Regression test for KUDU-1785. Ensure that starting a tablet copy session
// while a tablet is bootstrapping will result in a simple failure, not a crash.
TEST_F(TabletCopyClientSessionITest, TestStartTabletCopyWhileSourceBootstrapping) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Test only runs in slow test mode";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(90); // Can be very slow on TSAN.
NO_FATALS(PrepareClusterForTabletCopy());
@@ -282,10 +279,7 @@ TEST_F(TabletCopyClientSessionITest, TestCopyFromCrashedSource) {
// Regression for KUDU-2125: ensure that a heavily loaded source cluster can
// satisfy many concurrent tablet copies.
TEST_F(TabletCopyClientSessionITest, TestTabletCopyWithBusySource) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const int kNumTablets = 20;
ExternalMiniClusterOptions opts;
diff --git a/src/kudu/integration-tests/tablet_replacement-itest.cc b/src/kudu/integration-tests/tablet_replacement-itest.cc
index 10982b1..65ca217 100644
--- a/src/kudu/integration-tests/tablet_replacement-itest.cc
+++ b/src/kudu/integration-tests/tablet_replacement-itest.cc
@@ -136,10 +136,7 @@ void TabletReplacementITest::GetTsMapForReplicas(
void TabletReplacementITest::TestDontEvictIfRemainingConfigIsUnstable(
InstabilityType type, bool is_3_4_3_mode) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
// The configuration is tuned to minimize chances of reporting on failed
// tablet replicas one-by-one. That's because by the scenario 2 replicas out
@@ -319,7 +316,7 @@ TEST_F(TabletReplacementITest, TestMasterTombstoneEvictedReplica) {
// The rest of this test has multi-second waits, so we do it in slow test mode.
LOG(WARNING) << "not verifying that a newly-added replica won't be tombstoned; "
"run with KUDU_ALLOW_SLOW_TESTS=1 to verify";
- return;
+ GTEST_SKIP();
}
// Shut down a majority of followers (3 servers) and then try to add the
@@ -485,10 +482,7 @@ class EvictAndReplaceDeadFollowerITest :
// Test that unreachable followers are evicted and replaced.
TEST_P(EvictAndReplaceDeadFollowerITest, UnreachableFollower) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const bool is_3_4_3_mode = GetParam();
MonoDelta kTimeout = MonoDelta::FromSeconds(30);
@@ -590,10 +584,7 @@ INSTANTIATE_TEST_SUITE_P(,
// copied tablet should detect that these config change
// operations have already been applied and skip them.
TEST_F(TabletReplacementITest, TestRemoteBoostrapWithPendingConfigChangeCommits) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta timeout = MonoDelta::FromSeconds(30);
vector<string> ts_flags;
diff --git a/src/kudu/integration-tests/token_signer-itest.cc b/src/kudu/integration-tests/token_signer-itest.cc
index 32d1626..be07721 100644
--- a/src/kudu/integration-tests/token_signer-itest.cc
+++ b/src/kudu/integration-tests/token_signer-itest.cc
@@ -19,7 +19,6 @@
#include <cstdint>
#include <functional>
#include <memory>
-#include <ostream>
#include <string>
#include <vector>
@@ -214,10 +213,7 @@ TEST_F(TokenSignerITest, TskMasterLeadershipChange) {
// * Make sure the TSK stays valid and can be used for token verification
// up to the very end of the token validity interval.
TEST_F(TokenSignerITest, AuthnTokenLifecycle) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
vector<TokenSigningPublicKeyPB> public_keys;
ASSERT_OK(GetLeaderPublicKeys(&public_keys));
ASSERT_EQ(1, public_keys.size());
diff --git a/src/kudu/integration-tests/tombstoned_voting-imc-itest.cc b/src/kudu/integration-tests/tombstoned_voting-imc-itest.cc
index 6409e1a..485dbfc 100644
--- a/src/kudu/integration-tests/tombstoned_voting-imc-itest.cc
+++ b/src/kudu/integration-tests/tombstoned_voting-imc-itest.cc
@@ -79,7 +79,7 @@ class TombstonedVotingIMCITest : public MiniClusterITestBase {
// Ensure that a tombstoned replica cannot vote after we call Shutdown() on it.
TEST_F(TombstonedVotingIMCITest, TestNoVoteAfterShutdown) {
// This test waits for several seconds, so only run it in slow mode.
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
FLAGS_allow_unsafe_replication_factor = true; // Allow an even replication factor.
FLAGS_enable_tablet_copy = false; // Tablet copy would interfere with this test.
@@ -152,7 +152,7 @@ TEST_F(TombstonedVotingIMCITest, TestNoVoteAfterShutdown) {
// This is implemented by directly exercising the RPC API with different vote request parameters.
TEST_F(TombstonedVotingIMCITest, TestVotingLogic) {
// This test waits for several seconds, so only run it in slow mode.
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
FLAGS_allow_unsafe_replication_factor = true; // Allow an even replication factor.
FLAGS_enable_tablet_copy = false; // Tablet copy would interfere with this test.
@@ -251,7 +251,7 @@ TEST_F(TombstonedVotingIMCITest, TestVotingLogic) {
// Disable tombstoned voting and ensure that an election that would require it fails.
TEST_F(TombstonedVotingIMCITest, TestNoVoteIfTombstonedVotingDisabled) {
// This test waits for several seconds, so only run it in slow mode.
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
FLAGS_raft_enable_tombstoned_voting = false; // Disable tombstoned voting.
FLAGS_allow_unsafe_replication_factor = true; // Allow an even replication factor.
@@ -301,7 +301,7 @@ TEST_F(TombstonedVotingIMCITest, TestNoVoteIfTombstonedVotingDisabled) {
// the last-logged opid was unknown. This may occur if a tablet is tombstoned
// while in a FAILED state.
TEST_F(TombstonedVotingIMCITest, TestNoVoteIfNoLastLoggedOpId) {
- if (!AllowSlowTests()) return; // This test waits for several seconds.
+ SKIP_IF_SLOW_NOT_ALLOWED();
FLAGS_allow_unsafe_replication_factor = true; // Allow an even replication factor.
diff --git a/src/kudu/integration-tests/tombstoned_voting-stress-test.cc b/src/kudu/integration-tests/tombstoned_voting-stress-test.cc
index 7f77f03..41496f0 100644
--- a/src/kudu/integration-tests/tombstoned_voting-stress-test.cc
+++ b/src/kudu/integration-tests/tombstoned_voting-stress-test.cc
@@ -217,7 +217,7 @@ void TombstonedVotingStressTest::RunVoteRequestLoop() {
// copying replicas.
TEST_F(TombstonedVotingStressTest, TestTombstonedVotingUnderStress) {
// This test waits for several seconds, so only run it in slow mode.
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(30);
diff --git a/src/kudu/integration-tests/ts_recovery-itest.cc b/src/kudu/integration-tests/ts_recovery-itest.cc
index cb25cfc..94ae9cc 100644
--- a/src/kudu/integration-tests/ts_recovery-itest.cc
+++ b/src/kudu/integration-tests/ts_recovery-itest.cc
@@ -785,7 +785,7 @@ INSTANTIATE_TEST_SUITE_P(DifferentFaultPoints,
"fault_crash_before_flush_tablet_meta_after_flush_mrs"));
TEST_P(Kudu969Test, Test) {
- if (!AllowSlowTests()) return;
+ SKIP_IF_SLOW_NOT_ALLOWED();
// We use a replicated cluster here so that the 'REPLICATE' messages
// and 'COMMIT' messages are spread out further in time, and it's
diff --git a/src/kudu/security/crypto-test.cc b/src/kudu/security/crypto-test.cc
index 1918094..b0312e0 100644
--- a/src/kudu/security/crypto-test.cc
+++ b/src/kudu/security/crypto-test.cc
@@ -20,10 +20,12 @@
#include <openssl/crypto.h>
#include <cstring>
+#include <ostream>
#include <string>
#include <utility>
#include <vector>
+#include <glog/logging.h>
#include <gtest/gtest.h>
#include "kudu/gutil/strings/strip.h"
@@ -97,7 +99,8 @@ class CryptoTest : public KuduTest {
TEST_F(CryptoTest, RsaPrivateKeyInputOutputPEM) {
// TODO(KUDU-3207): Skip when run in FIPS mode due to different private key format.
if (FIPS_mode()) {
- return;
+ LOG(WARNING) << "Skipping test in FIPS mode. See KUDU-3207.";
+ GTEST_SKIP();
}
PrivateKey key;
ASSERT_OK(key.FromFile(private_key_file_, DataFormat::PEM));
diff --git a/src/kudu/security/token-test.cc b/src/kudu/security/token-test.cc
index 00e4f61..e0cf0f7 100644
--- a/src/kudu/security/token-test.cc
+++ b/src/kudu/security/token-test.cc
@@ -791,10 +791,7 @@ TEST_F(TokenTest, TestVaryingTokenValidityIntervals) {
// Test to check the invariant that all tokens signed within a TSK's activity
// interval must be expired by the end of the TSK's validity interval.
TEST_F(TokenTest, TestKeyValidity) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
// Note: this test's runtime is roughly the length of a key-validity
// interval, which is determined by the token validity intervals and the key
// rotation interval.
diff --git a/src/kudu/tablet/compaction-test.cc b/src/kudu/tablet/compaction-test.cc
index 4788ee2..aeb9570 100644
--- a/src/kudu/tablet/compaction-test.cc
+++ b/src/kudu/tablet/compaction-test.cc
@@ -1124,20 +1124,14 @@ TEST_F(TestCompaction, TestMergeMRSWithAllInvisibleRows) {
// contain non-overlapping data. In this case the merge can be optimized
// to be block-wise.
TEST_F(TestCompaction, BenchmarkMergeWithoutOverlap) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipped: must enable slow tests.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(DoBenchmark<false>());
}
// Benchmark for the compaction merge input when the inputs are entirely
// overlapping (i.e the inputs become fully interleaved in the output)
TEST_F(TestCompaction, BenchmarkMergeWithOverlap) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipped: must enable slow tests.";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(DoBenchmark<true>());
}
#endif
diff --git a/src/kudu/tablet/compaction_policy-test.cc b/src/kudu/tablet/compaction_policy-test.cc
index eb2e398..fe09583 100644
--- a/src/kudu/tablet/compaction_policy-test.cc
+++ b/src/kudu/tablet/compaction_policy-test.cc
@@ -265,10 +265,7 @@ static RowSetVector LoadFile(const string& name) {
// data. This test can be used as a benchmark for optimizing the compaction
// policy, and also serves as a basic regression/stress test using real data.
TEST_F(TestCompactionPolicy, TestYcsbCompaction) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const RowSetVector rowsets = LoadFile("testdata/ycsb-test-rowsets.tsv");
RowSetTree tree;
ASSERT_OK(tree.Reset(rowsets));
diff --git a/src/kudu/tools/ksck_remote-test.cc b/src/kudu/tools/ksck_remote-test.cc
index 63f81e9..344f740 100644
--- a/src/kudu/tools/ksck_remote-test.cc
+++ b/src/kudu/tools/ksck_remote-test.cc
@@ -509,10 +509,7 @@ TEST_F(RemoteKsckTest, TestChecksumSnapshotCurrentTimestamp) {
TEST_F(RemoteKsckTest, TestChecksumSnapshotLastingLongerThanAHM) {
// This test is really slow because -tablet_history_max_age_sec's lowest
// acceptable value is 1.
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
// This test relies on somewhat precise timing: the timestamp update must
// happen during the wait to start the checksum, for each tablet. It's likely
diff --git a/src/kudu/tools/kudu-admin-test.cc b/src/kudu/tools/kudu-admin-test.cc
index ae90e87..bf30864 100644
--- a/src/kudu/tools/kudu-admin-test.cc
+++ b/src/kudu/tools/kudu-admin-test.cc
@@ -1475,10 +1475,7 @@ TEST_F(AdminCliTest, TestLeaderTransferToNonVoter) {
// abrupt stepdowns are happening, as long as the writes have long enough
// timeouts to ride over the unstable leadership.
TEST_F(AdminCliTest, TestSimultaneousLeaderTransferAndAbruptStepdown) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const MonoDelta kTimeout = MonoDelta::FromSeconds(10);
FLAGS_num_tablet_servers = 3;
diff --git a/src/kudu/tools/rebalancer_tool-test.cc b/src/kudu/tools/rebalancer_tool-test.cc
index 044c54d..208854c 100644
--- a/src/kudu/tools/rebalancer_tool-test.cc
+++ b/src/kudu/tools/rebalancer_tool-test.cc
@@ -301,10 +301,7 @@ class RebalanceIgnoredTserversTest :
public AdminCliTest {
};
TEST_F(RebalanceIgnoredTserversTest, Basic) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
FLAGS_num_tablet_servers = 5;
// Start a cluster with a single tablet.
@@ -475,10 +472,7 @@ INSTANTIATE_TEST_SUITE_P(, RebalanceParamTest,
::testing::Combine(::testing::Values(1, 2, 3, 5),
::testing::Values(Kudu1097::Disable, Kudu1097::Enable)));
TEST_P(RebalanceParamTest, Rebalance) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const auto& param = GetParam();
const auto kRepFactor = std::get<0>(param);
@@ -771,10 +765,7 @@ class IgnoredTserverGoesDownDuringRebalancingTest : public RebalancingTest {
}
};
TEST_F(IgnoredTserverGoesDownDuringRebalancingTest, TserverDown) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const vector<string> kTserverExtraFlags = {
// Slow down tablet copy to make rebalancing step running longer
@@ -895,10 +886,7 @@ class DDLDuringRebalancingTest : public RebalancingTest,
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";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(Prepare());
@@ -1087,10 +1075,7 @@ class ConcurrentRebalancersTest : public RebalancingTest,
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";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(Prepare());
@@ -1180,10 +1165,7 @@ class TserverGoesDownDuringRebalancingTest : public RebalancingTest,
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";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const vector<string> kTserverExtraFlags = {
// Slow down tablet copy to make rebalancing step running longer
@@ -1267,10 +1249,7 @@ class TserverAddedDuringRebalancingTest : public RebalancingTest,
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";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const vector<string> kTserverExtraFlags = {
// Slow down tablet copy to make rebalancing step running longer
@@ -1339,10 +1318,7 @@ class RebalancingDuringElectionStormTest : public RebalancingTest,
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";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
NO_FATALS(Prepare());
@@ -1598,10 +1574,7 @@ class LocationAwareRebalancingBasicTest : public RebalancingTest {
// and the placement policy constraints should be reimposed after running
// the rebalancer tool.
TEST_F(LocationAwareRebalancingBasicTest, Basic) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const LocationInfo location_info = { { "/A", 2 }, { "/B", 2 }, { "/C", 2 }, };
vector<string> table_names;
@@ -1935,10 +1908,7 @@ 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";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const auto& param = GetParam();
const auto& location_info = param.location_info;
const auto& excluded_locations = param.excluded_locations;
@@ -2012,10 +1982,7 @@ public:
};
TEST_F(IntraLocationRebalancingBasicTest, LocationsWithEmptyTabletServers) {
- if (!AllowSlowTests()) {
- LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
const string first_table_name_pattern = "rebalance_test_first_table_$0";
const string second_table_name_pattern = "rebalance_test_second_table_$0";
const LocationInfo location_info = { { "/A", 3 }, { "/B", 3 }, { "/C", 3 },
diff --git a/src/kudu/util/monotime-test.cc b/src/kudu/util/monotime-test.cc
index 826e3a4..a75d6fa 100644
--- a/src/kudu/util/monotime-test.cc
+++ b/src/kudu/util/monotime-test.cc
@@ -170,10 +170,7 @@ TEST(TestMonoTime, TestSleepFor) {
}
TEST(TestMonoTime, TestSleepForOverflow) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping test because it sleeps for ~4s";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
// This quantity (~4s sleep) overflows a 32-bit integer such that
// the value becomes 0.
diff --git a/src/kudu/util/test_util.h b/src/kudu/util/test_util.h
index 6dbb37b..d9150d7 100644
--- a/src/kudu/util/test_util.h
+++ b/src/kudu/util/test_util.h
@@ -35,7 +35,7 @@
#define SKIP_IF_SLOW_NOT_ALLOWED() do { \
if (!AllowSlowTests()) { \
LOG(WARNING) << "test is skipped; set KUDU_ALLOW_SLOW_TESTS=1 to run"; \
- return; \
+ GTEST_SKIP(); \
} \
} while (0)
diff --git a/src/kudu/util/thread-test.cc b/src/kudu/util/thread-test.cc
index 4da7223..524027c 100644
--- a/src/kudu/util/thread-test.cc
+++ b/src/kudu/util/thread-test.cc
@@ -20,7 +20,6 @@
#include <unistd.h>
#include <functional>
-#include <ostream>
#include <string>
#include <vector>
@@ -46,10 +45,7 @@ class ThreadTest : public KuduTest {};
// Join with a thread and emit warnings while waiting to join.
// This has to be manually verified.
TEST_F(ThreadTest, TestJoinAndWarn) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping test in quick test mode, since this sleeps";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
scoped_refptr<Thread> holder;
ASSERT_OK(Thread::Create("test", "sleeper thread",
@@ -61,10 +57,7 @@ TEST_F(ThreadTest, TestJoinAndWarn) {
}
TEST_F(ThreadTest, TestFailedJoin) {
- if (!AllowSlowTests()) {
- LOG(INFO) << "Skipping test in quick test mode, since this sleeps";
- return;
- }
+ SKIP_IF_SLOW_NOT_ALLOWED();
scoped_refptr<Thread> holder;
ASSERT_OK(Thread::Create("test", "sleeper thread",