From abad8af018b232a089ea6397383a2b8fc4422cc2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20Sroczy=C5=84ski?= Date: Tue, 14 Mar 2023 23:48:08 +0100 Subject: [PATCH 01/14] Add COMPONENT to install --- googletest/CMakeLists.txt | 2 ++ googletest/cmake/internal_utils.cmake | 4 ++++ 2 files changed, 6 insertions(+) diff --git a/googletest/CMakeLists.txt b/googletest/CMakeLists.txt index 95bfa44204..d06c147979 100644 --- a/googletest/CMakeLists.txt +++ b/googletest/CMakeLists.txt @@ -100,12 +100,14 @@ if (INSTALL_GTEST) set(version_file "${generated_dir}/${cmake_package_name}ConfigVersion.cmake") write_basic_package_version_file(${version_file} VERSION ${GOOGLETEST_VERSION} COMPATIBILITY AnyNewerVersion) install(EXPORT ${targets_export_name} + COMPONENT "${PROJECT_NAME}" NAMESPACE ${cmake_package_name}:: DESTINATION ${cmake_files_install_dir}) set(config_file "${generated_dir}/${cmake_package_name}Config.cmake") configure_package_config_file("${gtest_SOURCE_DIR}/cmake/Config.cmake.in" "${config_file}" INSTALL_DESTINATION ${cmake_files_install_dir}) install(FILES ${version_file} ${config_file} + COMPONENT "${PROJECT_NAME}" DESTINATION ${cmake_files_install_dir}) endif() diff --git a/googletest/cmake/internal_utils.cmake b/googletest/cmake/internal_utils.cmake index b09da33fae..edf637e227 100644 --- a/googletest/cmake/internal_utils.cmake +++ b/googletest/cmake/internal_utils.cmake @@ -327,10 +327,12 @@ endfunction() function(install_project) if(INSTALL_GTEST) install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/" + COMPONENT "${PROJECT_NAME}" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") # Install the project targets. install(TARGETS ${ARGN} EXPORT ${targets_export_name} + COMPONENT "${PROJECT_NAME}" RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}") @@ -342,6 +344,7 @@ function(install_project) get_target_property(t_pdb_output_directory ${t} PDB_OUTPUT_DIRECTORY) install(FILES "${t_pdb_output_directory}/\${CMAKE_INSTALL_CONFIG_NAME}/$<$:${t_pdb_name_debug}>$<$>:${t_pdb_name}>.pdb" + COMPONENT "${PROJECT_NAME}" DESTINATION ${CMAKE_INSTALL_LIBDIR} OPTIONAL) endforeach() @@ -352,6 +355,7 @@ function(install_project) configure_file("${PROJECT_SOURCE_DIR}/cmake/${t}.pc.in" "${configured_pc}" @ONLY) install(FILES "${configured_pc}" + COMPONENT "${PROJECT_NAME}" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig") endforeach() endif() From ded275d75e0756e9659226f94bd4b8399af721d7 Mon Sep 17 00:00:00 2001 From: Pro3757 Date: Tue, 30 May 2023 13:50:23 +0530 Subject: [PATCH 02/14] fix README table --- README.md | 46 +++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/README.md b/README.md index 10d1f86f1b..c53a5eceec 100644 --- a/README.md +++ b/README.md @@ -55,37 +55,37 @@ More information about building GoogleTest can be found at | Feature | Description | | ---------------------------- | --------------------------------------------- | | xUnit test framework | Googletest is based on the | -: : [xUnit](https\://en.wikipedia.org/wiki/XUnit) : -: : testing framework, a popular architecture for : -: : unit testing : +| | [xUnit](https\://en.wikipedia.org/wiki/XUnit) | +| | testing framework, a popular architecture for | +| | unit testing | | Test discovery | Googletest automatically discovers and runs | -: : your tests, eliminating the need to manually : -: : register your tests : +| | your tests, eliminating the need to manually | +| | register your tests | | Rich set of assertions | Googletest provides a variety of assertions, | -: : such as equality, inequality, exceptions, and : -: : more, making it easy to test your code : +| | such as equality, inequality, exceptions, and | +| | more, making it easy to test your code | | User-defined assertions | You can define your own assertions with | -: : Googletest, making it simple to write tests : -: : that are specific to your code : +| | Googletest, making it simple to write tests | +| | that are specific to your code | | Death tests | Googletest supports death tests, which verify | -: : that your code exits in a certain way, making : -: : it useful for testing error-handling code : +| | that your code exits in a certain way, making | +| | it useful for testing error-handling code | | Fatal and non-fatal failures | You can specify whether a test failure should | -: : be treated as fatal or non-fatal with : -: : Googletest, allowing tests to continue : -: : running even if a failure occurs : +| | be treated as fatal or non-fatal with | +| | Googletest, allowing tests to continue | +| | running even if a failure occurs | | Value-parameterized tests | Googletest supports value-parameterized | -: : tests, which run multiple times with : -: : different input values, making it useful for : -: : testing functions that take different inputs : +| | tests, which run multiple times with | +| | different input values, making it useful for | +| | testing functions that take different inputs | | Type-parameterized tests | Googletest also supports type-parameterized | -: : tests, which run with different data types, : -: : making it useful for testing functions that : -: : work with different data types : +| | tests, which run with different data types, | +| | making it useful for testing functions that | +| | work with different data types | | Various options for running | Googletest provides many options for running | -: tests : tests, including running individual tests, : -: : running tests in a specific order, and : -: : running tests in parallel : +| tests | tests, including running individual tests, | +| | running tests in a specific order, and | +| | running tests in parallel | ## Supported Platforms From a5b94f6819d2c296958ae1f6b9130df99a37ec6d Mon Sep 17 00:00:00 2001 From: Niranjan Nilakantan Date: Thu, 1 Jun 2023 09:48:54 -0700 Subject: [PATCH 03/14] Ignore the .cache directory create by VSCode. This is populated by the clangd language service provider. Also ignore the cmake-variants.yaml file. This can be created locally to select various build/test configurations. Fixes #4266 --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index f08cb72a33..fede02f650 100644 --- a/.gitignore +++ b/.gitignore @@ -24,6 +24,10 @@ Win32-Release/ x64-Debug/ x64-Release/ +# VSCode files +.cache/ +cmake-variants.yaml + # Ignore autoconf / automake files Makefile.in aclocal.m4 From 5ca3ab833168674ff417845941fc46691769ed36 Mon Sep 17 00:00:00 2001 From: Pro3757 Date: Fri, 2 Jun 2023 00:58:00 +0530 Subject: [PATCH 04/14] change table to unordered list --- README.md | 66 +++++++++++++++++++++++++++---------------------------- 1 file changed, 32 insertions(+), 34 deletions(-) diff --git a/README.md b/README.md index c53a5eceec..927222713e 100644 --- a/README.md +++ b/README.md @@ -52,40 +52,38 @@ documentation. We recommend starting with the More information about building GoogleTest can be found at [googletest/README.md](googletest/README.md). -| Feature | Description | -| ---------------------------- | --------------------------------------------- | -| xUnit test framework | Googletest is based on the | -| | [xUnit](https\://en.wikipedia.org/wiki/XUnit) | -| | testing framework, a popular architecture for | -| | unit testing | -| Test discovery | Googletest automatically discovers and runs | -| | your tests, eliminating the need to manually | -| | register your tests | -| Rich set of assertions | Googletest provides a variety of assertions, | -| | such as equality, inequality, exceptions, and | -| | more, making it easy to test your code | -| User-defined assertions | You can define your own assertions with | -| | Googletest, making it simple to write tests | -| | that are specific to your code | -| Death tests | Googletest supports death tests, which verify | -| | that your code exits in a certain way, making | -| | it useful for testing error-handling code | -| Fatal and non-fatal failures | You can specify whether a test failure should | -| | be treated as fatal or non-fatal with | -| | Googletest, allowing tests to continue | -| | running even if a failure occurs | -| Value-parameterized tests | Googletest supports value-parameterized | -| | tests, which run multiple times with | -| | different input values, making it useful for | -| | testing functions that take different inputs | -| Type-parameterized tests | Googletest also supports type-parameterized | -| | tests, which run with different data types, | -| | making it useful for testing functions that | -| | work with different data types | -| Various options for running | Googletest provides many options for running | -| tests | tests, including running individual tests, | -| | running tests in a specific order, and | -| | running tests in parallel | +## Features +* xUnit test framework: + Googletest is based on the [xUnit](https\://en.wikipedia.org/wiki/XUnit) + testing framework, a popular architecture for unit testing +* Test discovery: + Googletest automatically discovers and runs your tests, eliminating the need + to manually register your tests +* Rich set of assertions: + Googletest provides a variety of assertions, such as equality, inequality, + exceptions, and more, making it easy to test your code +* User-defined assertions: + You can define your own assertions with Googletest, making it simple to + write tests that are specific to your code +* Death tests: + Googletest supports death tests, which verify that your code exits in a + certain way, making it useful for testing error-handling code +* Fatal and non-fatal failures: + You can specify whether a test failure should be treated as fatal or + non-fatal with Googletest, allowing tests to continue running even if a + failure occurs +* Value-parameterized tests: + Googletest supports value-parameterized tests, which run multiple times with + different input values, making it useful for testing functions that take + different inputs +* Type-parameterized tests: + Googletest also supports type-parameterized tests, which run with different + data types, making it useful for testing functions that work with different + data types +* Various options for running tests: + Googletest provides many options for running tests including running + individual tests, running tests in a specific order, and running tests in + parallel ## Supported Platforms From 001f281926c74a819e9266bb4ec525515ff39418 Mon Sep 17 00:00:00 2001 From: Joakim Plate Date: Fri, 2 Jun 2023 12:17:43 +0200 Subject: [PATCH 05/14] Check for file system for current directory Check for current directory instead of death test to get original directory. A port may support filesystems but not death tests. --- googletest/src/gtest-internal-inl.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/googletest/src/gtest-internal-inl.h b/googletest/src/gtest-internal-inl.h index 5ba557fe12..be821662c1 100644 --- a/googletest/src/gtest-internal-inl.h +++ b/googletest/src/gtest-internal-inl.h @@ -672,7 +672,7 @@ class GTEST_API_ UnitTestImpl { void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc, internal::TearDownTestSuiteFunc tear_down_tc, TestInfo* test_info) { -#ifdef GTEST_HAS_DEATH_TEST +#ifdef GTEST_HAS_FILE_SYSTEM // In order to support thread-safe death tests, we need to // remember the original working directory when the test program // was first invoked. We cannot do this in RUN_ALL_TESTS(), as @@ -685,7 +685,7 @@ class GTEST_API_ UnitTestImpl { GTEST_CHECK_(!original_working_dir_.IsEmpty()) << "Failed to get the current working directory."; } -#endif // GTEST_HAS_DEATH_TEST +#endif // GTEST_HAS_FILE_SYSTEM GetTestSuite(test_info->test_suite_name(), test_info->type_param(), set_up_tc, tear_down_tc) From 65cfeca1a1eebca291b59395f79a60a4497d0f73 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Fri, 9 Jun 2023 11:28:44 -0700 Subject: [PATCH 06/14] internal g3doc documentation change. PiperOrigin-RevId: 539134110 Change-Id: I28041f77e18bc67aa0ffabdc7205e350deed22c8 --- docs/primer.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/primer.md b/docs/primer.md index 31d63160e6..c3aee3cc64 100644 --- a/docs/primer.md +++ b/docs/primer.md @@ -42,7 +42,7 @@ Since GoogleTest is based on the popular xUnit architecture, you'll feel right at home if you've used JUnit or PyUnit before. If not, it will take you about 10 minutes to learn the basics and get started. So let's go! -## Beware of the nomenclature +## Beware of the Nomenclature {: .callout .note} *Note:* There might be some confusion arising from different definitions of the From 4c7aee827e16aa338189b88f6e3aa6d3d927dba4 Mon Sep 17 00:00:00 2001 From: Dino Radakovic Date: Wed, 14 Jun 2023 06:40:34 -0700 Subject: [PATCH 07/14] Skip entire test suite with `GTEST_SKIP()` in `SetUpTestSuite` Fixes #4273 PiperOrigin-RevId: 540254167 Change-Id: I2555740d10284223539035bf73f88554fcf73f8a --- googletest/src/gtest.cc | 3 ++- .../test/googletest-output-test-golden-lin.txt | 16 +++++++++++++--- googletest/test/googletest-output-test_.cc | 6 ++++++ 3 files changed, 21 insertions(+), 4 deletions(-) diff --git a/googletest/src/gtest.cc b/googletest/src/gtest.cc index fb7512c1b5..a88ac2557a 100644 --- a/googletest/src/gtest.cc +++ b/googletest/src/gtest.cc @@ -3019,7 +3019,8 @@ void TestSuite::Run() { internal::HandleExceptionsInMethodIfSupported( this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()"); - const bool skip_all = ad_hoc_test_result().Failed(); + const bool skip_all = + ad_hoc_test_result().Failed() || ad_hoc_test_result().Skipped(); start_timestamp_ = internal::GetTimeInMillis(); internal::Timer timer; diff --git a/googletest/test/googletest-output-test-golden-lin.txt b/googletest/test/googletest-output-test-golden-lin.txt index 1f24fb7915..6ddf822ffb 100644 --- a/googletest/test/googletest-output-test-golden-lin.txt +++ b/googletest/test/googletest-output-test-golden-lin.txt @@ -12,7 +12,7 @@ Expected equality of these values: 3 Stack trace: (omitted) -[==========] Running 89 tests from 42 test suites. +[==========] Running 90 tests from 43 test suites. [----------] Global test environment set-up. FooEnvironment::SetUp() called. BarEnvironment::SetUp() called. @@ -967,6 +967,15 @@ Stack trace: (omitted) googletest-output-test_.cc:#: Skipped [ SKIPPED ] TestSuiteThatFailsToSetUp.ShouldNotRun +[----------] 1 test from TestSuiteThatSkipsInSetUp +googletest-output-test_.cc:#: Skipped +Skip entire test suite +Stack trace: (omitted) + +[ RUN ] TestSuiteThatSkipsInSetUp.ShouldNotRun +googletest-output-test_.cc:#: Skipped + +[ SKIPPED ] TestSuiteThatSkipsInSetUp.ShouldNotRun [----------] 1 test from PrintingFailingParams/FailingParamTest [ RUN ] PrintingFailingParams/FailingParamTest.Fails/0 googletest-output-test_.cc:#: Failure @@ -1043,10 +1052,11 @@ Failed Expected fatal failure. Stack trace: (omitted) -[==========] 89 tests from 42 test suites ran. +[==========] 90 tests from 43 test suites ran. [ PASSED ] 31 tests. -[ SKIPPED ] 1 test, listed below: +[ SKIPPED ] 2 tests, listed below: [ SKIPPED ] TestSuiteThatFailsToSetUp.ShouldNotRun +[ SKIPPED ] TestSuiteThatSkipsInSetUp.ShouldNotRun [ FAILED ] 57 tests, listed below: [ FAILED ] NonfatalFailureTest.EscapesStringOperands [ FAILED ] NonfatalFailureTest.DiffForLongStrings diff --git a/googletest/test/googletest-output-test_.cc b/googletest/test/googletest-output-test_.cc index f1facf570a..e3560c0182 100644 --- a/googletest/test/googletest-output-test_.cc +++ b/googletest/test/googletest-output-test_.cc @@ -1007,6 +1007,12 @@ class TestSuiteThatFailsToSetUp : public testing::Test { }; TEST_F(TestSuiteThatFailsToSetUp, ShouldNotRun) { std::abort(); } +class TestSuiteThatSkipsInSetUp : public testing::Test { + public: + static void SetUpTestSuite() { GTEST_SKIP() << "Skip entire test suite"; } +}; +TEST_F(TestSuiteThatSkipsInSetUp, ShouldNotRun) { std::abort(); } + // The main function. // // The idea is to use Google Test to run all the tests we have defined (some From 18fa6a4db32a30675c0b19bf72f8b5f693d21a23 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Thu, 15 Jun 2023 07:52:03 -0700 Subject: [PATCH 08/14] Allow clients to un-suppress output from gUnit EXPECT_EXIT tests. This is useful for running individual tests in a separate process, which is useful for testing e.g. flag changes which have a process-global effect. PiperOrigin-RevId: 540580573 Change-Id: I18a5d24d79425a9d595be3369efc44e2f655f6f8 --- googletest/include/gtest/gtest.h | 5 ++++- googletest/src/gtest-death-test.cc | 2 +- googletest/src/gtest.cc | 6 +++--- googletest/test/gtest_unittest.cc | 2 +- 4 files changed, 9 insertions(+), 6 deletions(-) diff --git a/googletest/include/gtest/gtest.h b/googletest/include/gtest/gtest.h index 8412503493..86777c8544 100644 --- a/googletest/include/gtest/gtest.h +++ b/googletest/include/gtest/gtest.h @@ -1055,6 +1055,10 @@ class GTEST_API_ TestEventListeners { return default_xml_generator_; } + // Controls whether events will be forwarded by the repeater to the + // listeners in the list. + void SuppressEventForwarding(bool); + private: friend class TestSuite; friend class TestInfo; @@ -1084,7 +1088,6 @@ class GTEST_API_ TestEventListeners { // Controls whether events will be forwarded by the repeater to the // listeners in the list. bool EventForwardingEnabled() const; - void SuppressEventForwarding(); // The actual list of listeners. internal::TestEventRepeater* repeater_; diff --git a/googletest/src/gtest-death-test.cc b/googletest/src/gtest-death-test.cc index 4cf78e71ab..0eb6e38b2a 100644 --- a/googletest/src/gtest-death-test.cc +++ b/googletest/src/gtest-death-test.cc @@ -1128,7 +1128,7 @@ DeathTest::TestRole NoExecDeathTest::AssumeRole() { LogToStderr(); // Event forwarding to the listeners of event listener API mush be shut // down in death test subprocesses. - GetUnitTestImpl()->listeners()->SuppressEventForwarding(); + GetUnitTestImpl()->listeners()->SuppressEventForwarding(true); g_in_fast_death_test_child = true; return EXECUTE_TEST; } else { diff --git a/googletest/src/gtest.cc b/googletest/src/gtest.cc index a88ac2557a..d9fd27709a 100644 --- a/googletest/src/gtest.cc +++ b/googletest/src/gtest.cc @@ -5156,8 +5156,8 @@ bool TestEventListeners::EventForwardingEnabled() const { return repeater_->forwarding_enabled(); } -void TestEventListeners::SuppressEventForwarding() { - repeater_->set_forwarding_enabled(false); +void TestEventListeners::SuppressEventForwarding(bool suppress) { + repeater_->set_forwarding_enabled(!suppress); } // class UnitTest @@ -5635,7 +5635,7 @@ void UnitTestImpl::RecordProperty(const TestProperty& test_property) { // subprocess. Must not be called before InitGoogleTest. void UnitTestImpl::SuppressTestEventsIfInSubprocess() { if (internal_run_death_test_flag_ != nullptr) - listeners()->SuppressEventForwarding(); + listeners()->SuppressEventForwarding(true); } #endif // GTEST_HAS_DEATH_TEST diff --git a/googletest/test/gtest_unittest.cc b/googletest/test/gtest_unittest.cc index 77d968a724..dd049a00d5 100644 --- a/googletest/test/gtest_unittest.cc +++ b/googletest/test/gtest_unittest.cc @@ -173,7 +173,7 @@ class TestEventListenersAccessor { } static void SuppressEventForwarding(TestEventListeners* listeners) { - listeners->SuppressEventForwarding(); + listeners->SuppressEventForwarding(true); } }; From 148b327ffa6f7f97cffd1606342a136cf497210b Mon Sep 17 00:00:00 2001 From: Kasra Hashemi <73937934+zencatalyst@users.noreply.github.com> Date: Fri, 16 Jun 2023 13:59:16 +0330 Subject: [PATCH 09/14] Update README.md Fixed punctuation issues --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index ef0c288d5d..443e020695 100644 --- a/README.md +++ b/README.md @@ -27,8 +27,8 @@ The 1.13.x branch requires at least C++14. #### Continuous Integration We use Google's internal systems for continuous integration. \ -GitHub Actions were added for the convenience of open source contributors. They -are exclusively maintained by the open source community and not used by the +GitHub Actions were added for the convenience of open-source contributors. They +are exclusively maintained by the open-source community and not used by the GoogleTest team. #### Coming Soon @@ -83,7 +83,7 @@ More information about building GoogleTest can be found at data types * Various options for running tests: \ Googletest provides many options for running tests including running - individual tests, running tests in a specific order, and running tests in + individual tests, running tests in a specific order and running tests in parallel ## Supported Platforms @@ -92,7 +92,7 @@ GoogleTest follows Google's [Foundational C++ Support Policy](https://opensource.google/documentation/policies/cplusplus-support). See [this table](https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md) -for a list of currently supported versions compilers, platforms, and build +for a list of currently supported versions of compilers, platforms, and build tools. ## Who Is Using GoogleTest? From 124bc587f0f6157f0bf49a05deb68956db307732 Mon Sep 17 00:00:00 2001 From: Ryan Schmidt Date: Mon, 19 Jun 2023 06:18:12 -0500 Subject: [PATCH 10/14] Change C++11 requirement to C++14 Version 1.13.x and later require C++14. Also fix missing closing backtick. --- googletest/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/googletest/README.md b/googletest/README.md index 4cad12f758..6bbd7f875f 100644 --- a/googletest/README.md +++ b/googletest/README.md @@ -124,10 +124,10 @@ match the project in which it is included. #### C++ Standard Version -An environment that supports C++11 is required in order to successfully build +An environment that supports C++14 is required in order to successfully build GoogleTest. One way to ensure this is to specify the standard in the top-level -project, for example by using the `set(CMAKE_CXX_STANDARD 11)` command along -with `set(CMAKE_CXX_STANDARD_REQUIRED ON). If this is not feasible, for example +project, for example by using the `set(CMAKE_CXX_STANDARD 14)` command along +with `set(CMAKE_CXX_STANDARD_REQUIRED ON)`. If this is not feasible, for example in a C project using GoogleTest for validation, then it can be specified by adding it to the options for cmake via the`-DCMAKE_CXX_FLAGS` option. From 4fed5f285030085b096c930ff03e42c7814739b2 Mon Sep 17 00:00:00 2001 From: Juan Ramos Date: Mon, 19 Jun 2023 11:21:44 -0600 Subject: [PATCH 11/14] cmake: Raise min to 3.6 From the CMake 3.27 release notes: Compatibility with versions of CMake older than 3.5 is now deprecated and will be removed from a future version. Calls to cmake_minimum_required() or cmake_policy() that set the policy version to an older value now issue a deprecation diagnostic. This PR also removes manually setting policy CMP0048. This is redundant since the CMake min is already 3.X --- CMakeLists.txt | 6 +----- docs/pkgconfig.md | 14 +++++--------- googlemock/CMakeLists.txt | 3 +-- googletest/CMakeLists.txt | 3 +-- 4 files changed, 8 insertions(+), 18 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6af414371f..33a6c6ff40 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,11 +1,7 @@ # Note: CMake support is community-based. The maintainers do not use CMake # internally. -cmake_minimum_required(VERSION 3.5) - -if (POLICY CMP0048) - cmake_policy(SET CMP0048 NEW) -endif (POLICY CMP0048) +cmake_minimum_required(VERSION 3.6) if (POLICY CMP0069) cmake_policy(SET CMP0069 NEW) diff --git a/docs/pkgconfig.md b/docs/pkgconfig.md index 18a2546a38..bf05d59316 100644 --- a/docs/pkgconfig.md +++ b/docs/pkgconfig.md @@ -19,19 +19,15 @@ examples here we assume you want to compile the sample Using `pkg-config` in CMake is fairly easy: ```cmake -cmake_minimum_required(VERSION 3.0) - -cmake_policy(SET CMP0048 NEW) -project(my_gtest_pkgconfig VERSION 0.0.1 LANGUAGES CXX) - find_package(PkgConfig) pkg_search_module(GTEST REQUIRED gtest_main) -add_executable(testapp samples/sample3_unittest.cc) -target_link_libraries(testapp ${GTEST_LDFLAGS}) -target_compile_options(testapp PUBLIC ${GTEST_CFLAGS}) +add_executable(testapp) +target_sources(testapp PRIVATE samples/sample3_unittest.cc) +target_link_libraries(testapp PRIVATE ${GTEST_LDFLAGS}) +target_compile_options(testapp PRIVATE ${GTEST_CFLAGS}) -include(CTest) +enable_testing() add_test(first_and_only_test testapp) ``` diff --git a/googlemock/CMakeLists.txt b/googlemock/CMakeLists.txt index 5c1f0dafea..444c5ae804 100644 --- a/googlemock/CMakeLists.txt +++ b/googlemock/CMakeLists.txt @@ -36,8 +36,7 @@ endif() # as ${gmock_SOURCE_DIR} and to the root binary directory as # ${gmock_BINARY_DIR}. # Language "C" is required for find_package(Threads). -cmake_minimum_required(VERSION 3.5) -cmake_policy(SET CMP0048 NEW) +cmake_minimum_required(VERSION 3.6) project(gmock VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C) if (COMMAND set_up_hermetic_build) diff --git a/googletest/CMakeLists.txt b/googletest/CMakeLists.txt index d06c147979..efc2c3cbe9 100644 --- a/googletest/CMakeLists.txt +++ b/googletest/CMakeLists.txt @@ -46,8 +46,7 @@ endif() # Project version: -cmake_minimum_required(VERSION 3.5) -cmake_policy(SET CMP0048 NEW) +cmake_minimum_required(VERSION 3.6) project(gtest VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C) if (POLICY CMP0063) # Visibility From efd8db1627631079dec02de2622071d8ec9ff5fa Mon Sep 17 00:00:00 2001 From: Juan Ramos Date: Tue, 20 Jun 2023 13:03:00 -0600 Subject: [PATCH 12/14] cmake: Clean up policy code Now that the min is 3.13 these policies don't need to be set manually anymore. CMP0054 - 3.1 CMP0063 - 3.3 CMP0069 - 3.9 CMP0077 - 3.13 --- CMakeLists.txt | 8 -------- googletest/CMakeLists.txt | 4 ---- googletest/cmake/internal_utils.cmake | 14 -------------- 3 files changed, 26 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 890e495ef3..3b5cf3c485 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,14 +3,6 @@ cmake_minimum_required(VERSION 3.13) -if (POLICY CMP0069) - cmake_policy(SET CMP0069 NEW) -endif (POLICY CMP0069) - -if (POLICY CMP0077) - cmake_policy(SET CMP0077 NEW) -endif (POLICY CMP0077) - project(googletest-distribution) set(GOOGLETEST_VERSION 1.13.0) diff --git a/googletest/CMakeLists.txt b/googletest/CMakeLists.txt index e76b8c8a5b..a944dddbea 100644 --- a/googletest/CMakeLists.txt +++ b/googletest/CMakeLists.txt @@ -49,10 +49,6 @@ endif() cmake_minimum_required(VERSION 3.13) project(gtest VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C) -if (POLICY CMP0063) # Visibility - cmake_policy(SET CMP0063 NEW) -endif (POLICY CMP0063) - if (COMMAND set_up_hermetic_build) set_up_hermetic_build() endif() diff --git a/googletest/cmake/internal_utils.cmake b/googletest/cmake/internal_utils.cmake index 6573d30032..4810911356 100644 --- a/googletest/cmake/internal_utils.cmake +++ b/googletest/cmake/internal_utils.cmake @@ -12,14 +12,6 @@ # Test and Google Mock's option() definitions, and thus must be # called *after* the options have been defined. -if (POLICY CMP0054) - cmake_policy(SET CMP0054 NEW) -endif (POLICY CMP0054) - -if (POLICY CMP0069) - cmake_policy(SET CMP0069 NEW) -endif (POLICY CMP0069) - # Tweaks CMake's default compiler/linker settings to suit Google Test's needs. # # This must be a macro(), as inside a function string() can only @@ -264,12 +256,6 @@ function(cxx_executable name dir libs) ${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN}) endfunction() -# CMP0094 policy enables finding a Python executable in the LOCATION order, as -# specified by the PATH environment variable. -if (POLICY CMP0094) - cmake_policy(SET CMP0094 NEW) -endif() - # Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE. if ("${CMAKE_VERSION}" VERSION_LESS "3.12.0") find_package(PythonInterp) From 812f35b26b88ab1607a806b87539175591bba8c2 Mon Sep 17 00:00:00 2001 From: Juan Ramos Date: Tue, 20 Jun 2023 19:02:23 -0600 Subject: [PATCH 13/14] cmake: Remove remaining checks for CMAKE_VERSION Remove conditional code that doesn't need to exist anymore. --- googlemock/CMakeLists.txt | 26 ++++------ googletest/CMakeLists.txt | 19 +++----- googletest/cmake/internal_utils.cmake | 68 ++++++++------------------- 3 files changed, 35 insertions(+), 78 deletions(-) diff --git a/googlemock/CMakeLists.txt b/googlemock/CMakeLists.txt index 5833d20c11..a9aa0723fb 100644 --- a/googlemock/CMakeLists.txt +++ b/googlemock/CMakeLists.txt @@ -100,18 +100,14 @@ else() target_link_libraries(gmock_main PUBLIC gmock) set_target_properties(gmock_main PROPERTIES VERSION ${GOOGLETEST_VERSION}) endif() -# If the CMake version supports it, attach header directory information -# to the targets for when we are part of a parent build (ie being pulled -# in via add_subdirectory() rather than being a standalone build). -if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11") - string(REPLACE ";" "$" dirs "${gmock_build_include_dirs}") - target_include_directories(gmock SYSTEM INTERFACE - "$" - "$/${CMAKE_INSTALL_INCLUDEDIR}>") - target_include_directories(gmock_main SYSTEM INTERFACE - "$" - "$/${CMAKE_INSTALL_INCLUDEDIR}>") -endif() + +string(REPLACE ";" "$" dirs "${gmock_build_include_dirs}") +target_include_directories(gmock SYSTEM INTERFACE + "$" + "$/${CMAKE_INSTALL_INCLUDEDIR}>") +target_include_directories(gmock_main SYSTEM INTERFACE + "$" + "$/${CMAKE_INSTALL_INCLUDEDIR}>") ######################################################################## # @@ -135,11 +131,7 @@ if (gmock_build_tests) enable_testing() if (MINGW OR CYGWIN) - if (CMAKE_VERSION VERSION_LESS "2.8.12") - add_compile_options("-Wa,-mbig-obj") - else() - add_definitions("-Wa,-mbig-obj") - endif() + add_compile_options("-Wa,-mbig-obj") endif() ############################################################ diff --git a/googletest/CMakeLists.txt b/googletest/CMakeLists.txt index a944dddbea..caafa8c768 100644 --- a/googletest/CMakeLists.txt +++ b/googletest/CMakeLists.txt @@ -140,18 +140,13 @@ if(GTEST_HAS_ABSL) endif() cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc) set_target_properties(gtest_main PROPERTIES VERSION ${GOOGLETEST_VERSION}) -# If the CMake version supports it, attach header directory information -# to the targets for when we are part of a parent build (ie being pulled -# in via add_subdirectory() rather than being a standalone build). -if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11") - string(REPLACE ";" "$" dirs "${gtest_build_include_dirs}") - target_include_directories(gtest SYSTEM INTERFACE - "$" - "$/${CMAKE_INSTALL_INCLUDEDIR}>") - target_include_directories(gtest_main SYSTEM INTERFACE - "$" - "$/${CMAKE_INSTALL_INCLUDEDIR}>") -endif() +string(REPLACE ";" "$" dirs "${gtest_build_include_dirs}") +target_include_directories(gtest SYSTEM INTERFACE + "$" + "$/${CMAKE_INSTALL_INCLUDEDIR}>") +target_include_directories(gtest_main SYSTEM INTERFACE + "$" + "$/${CMAKE_INSTALL_INCLUDEDIR}>") if(CMAKE_SYSTEM_NAME MATCHES "QNX") target_link_libraries(gtest PUBLIC regex) endif() diff --git a/googletest/cmake/internal_utils.cmake b/googletest/cmake/internal_utils.cmake index 4810911356..e572077913 100644 --- a/googletest/cmake/internal_utils.cmake +++ b/googletest/cmake/internal_utils.cmake @@ -188,23 +188,14 @@ function(cxx_library_with_type name type cxx_flags) set_target_properties(${name} PROPERTIES COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1") - if (NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11") target_compile_definitions(${name} INTERFACE $) - endif() endif() if (DEFINED GTEST_HAS_PTHREAD) - if ("${CMAKE_VERSION}" VERSION_LESS "3.1.0") - set(threads_spec ${CMAKE_THREAD_LIBS_INIT}) - else() - set(threads_spec Threads::Threads) - endif() - target_link_libraries(${name} PUBLIC ${threads_spec}) + target_link_libraries(${name} PUBLIC Threads::Threads) endif() - if (NOT "${CMAKE_VERSION}" VERSION_LESS "3.8") - target_compile_features(${name} PUBLIC cxx_std_14) - endif() + target_compile_features(${name} PUBLIC cxx_std_14) endfunction() ######################################################################## @@ -256,16 +247,7 @@ function(cxx_executable name dir libs) ${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN}) endfunction() -# Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE. -if ("${CMAKE_VERSION}" VERSION_LESS "3.12.0") - find_package(PythonInterp) - set(PYTHONINTERP_FOUND ${PYTHONINTERP_FOUND} CACHE INTERNAL "") - set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} CACHE INTERNAL "") -else() - find_package(Python COMPONENTS Interpreter) - set(PYTHONINTERP_FOUND ${Python_Interpreter_FOUND} CACHE INTERNAL "") - set(PYTHON_EXECUTABLE ${Python_EXECUTABLE} CACHE INTERNAL "") -endif() +find_package(Python3) # cxx_test_with_flags(name cxx_flags libs srcs...) # @@ -291,34 +273,22 @@ endfunction() # creates a Python test with the given name whose main module is in # test/name.py. It does nothing if Python is not installed. function(py_test name) - if (PYTHONINTERP_FOUND) - if ("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" VERSION_GREATER 3.1) - if (CMAKE_CONFIGURATION_TYPES) - # Multi-configuration build generators as for Visual Studio save - # output in a subdirectory of CMAKE_CURRENT_BINARY_DIR (Debug, - # Release etc.), so we have to provide it here. - add_test(NAME ${name} - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py - --build_dir=${CMAKE_CURRENT_BINARY_DIR}/$ ${ARGN}) - else (CMAKE_CONFIGURATION_TYPES) - # Single-configuration build generators like Makefile generators - # don't have subdirs below CMAKE_CURRENT_BINARY_DIR. - add_test(NAME ${name} - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py - --build_dir=${CMAKE_CURRENT_BINARY_DIR} ${ARGN}) - endif (CMAKE_CONFIGURATION_TYPES) - else() - # ${CMAKE_CURRENT_BINARY_DIR} is known at configuration time, so we can - # directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known - # only at ctest runtime (by calling ctest -c ), so - # we have to escape $ to delay variable substitution here. - add_test(NAME ${name} - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py - --build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE} ${ARGN}) - endif() - # Make the Python import path consistent between Bazel and CMake. - set_tests_properties(${name} PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_SOURCE_DIR}) - endif(PYTHONINTERP_FOUND) + if (NOT Python3_Interpreter_FOUND) + return() + endif() + + get_cmake_property(is_multi "GENERATOR_IS_MULTI_CONFIG") + set(build_dir "${CMAKE_CURRENT_BINARY_DIR}") + if (is_multi) + set(build_dir "${CMAKE_CURRENT_BINARY_DIR}/$") + endif() + + add_test(NAME ${name} + COMMAND Python3::Interpreter ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py + --build_dir=${build_dir} ${ARGN}) + + # Make the Python import path consistent between Bazel and CMake. + set_tests_properties(${name} PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_SOURCE_DIR}) endfunction() # install_project(targets...) From ec4fed93217bc2830959bb8e86798c1d86956949 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Thu, 22 Jun 2023 08:14:44 -0700 Subject: [PATCH 14/14] Update code examples in the gMock Cookbook following C++ best practices. PiperOrigin-RevId: 542564354 Change-Id: Ia3307f13f845c662c88fb7303112f41ef8c56b28 --- docs/gmock_cook_book.md | 46 +++++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 22 deletions(-) diff --git a/docs/gmock_cook_book.md b/docs/gmock_cook_book.md index d57be58dde..f736b9fb8a 100644 --- a/docs/gmock_cook_book.md +++ b/docs/gmock_cook_book.md @@ -697,9 +697,9 @@ TEST(AbcTest, Xyz) { EXPECT_CALL(foo, DoThat(_, _)); int n = 0; - EXPECT_EQ('+', foo.DoThis(5)); // FakeFoo::DoThis() is invoked. + EXPECT_EQ(foo.DoThis(5), '+'); // FakeFoo::DoThis() is invoked. foo.DoThat("Hi", &n); // FakeFoo::DoThat() is invoked. - EXPECT_EQ(2, n); + EXPECT_EQ(n, 2); } ``` @@ -1129,11 +1129,11 @@ using STL's `` header is just painful). For example, here's a predicate that's satisfied by any number that is >= 0, <= 100, and != 50: ```cpp -using testing::AllOf; -using testing::Ge; -using testing::Le; -using testing::Matches; -using testing::Ne; +using ::testing::AllOf; +using ::testing::Ge; +using ::testing::Le; +using ::testing::Matches; +using ::testing::Ne; ... Matches(AllOf(Ge(0), Le(100), Ne(50))) ``` @@ -1861,7 +1861,7 @@ error. So, what shall you do? Though you may be tempted, DO NOT use `std::ref()`: ```cpp -using testing::Return; +using ::testing::Return; class MockFoo : public Foo { public: @@ -1873,7 +1873,7 @@ class MockFoo : public Foo { EXPECT_CALL(foo, GetValue()) .WillRepeatedly(Return(std::ref(x))); // Wrong! x = 42; - EXPECT_EQ(42, foo.GetValue()); + EXPECT_EQ(foo.GetValue(), 42); ``` Unfortunately, it doesn't work here. The above code will fail with error: @@ -1895,14 +1895,14 @@ the expectation is set, and `Return(std::ref(x))` will always return 0. returns the value pointed to by `pointer` at the time the action is *executed*: ```cpp -using testing::ReturnPointee; +using ::testing::ReturnPointee; ... int x = 0; MockFoo foo; EXPECT_CALL(foo, GetValue()) .WillRepeatedly(ReturnPointee(&x)); // Note the & here. x = 42; - EXPECT_EQ(42, foo.GetValue()); // This will succeed now. + EXPECT_EQ(foo.GetValue(), 42); // This will succeed now. ``` ### Combining Actions @@ -2264,7 +2264,7 @@ TEST_F(FooTest, Test) { EXPECT_CALL(foo, DoThis(2)) .WillOnce(Invoke(NewPermanentCallback(SignOfSum, 5))); - EXPECT_EQ('+', foo.DoThis(2)); // Invokes SignOfSum(5, 2). + EXPECT_EQ(foo.DoThis(2), '+'); // Invokes SignOfSum(5, 2). } ``` @@ -2771,11 +2771,13 @@ returns a null `unique_ptr`, that’s what you’ll get if you don’t specify a action: ```cpp +using ::testing::IsNull; +... // Use the default action. EXPECT_CALL(mock_buzzer_, MakeBuzz("hello")); // Triggers the previous EXPECT_CALL. - EXPECT_EQ(nullptr, mock_buzzer_.MakeBuzz("hello")); + EXPECT_THAT(mock_buzzer_.MakeBuzz("hello"), IsNull()); ``` If you are not happy with the default action, you can tweak it as usual; see @@ -3194,9 +3196,9 @@ flag. For example, given the test program: ```cpp #include "gmock/gmock.h" -using testing::_; -using testing::HasSubstr; -using testing::Return; +using ::testing::_; +using ::testing::HasSubstr; +using ::testing::Return; class MockFoo { public: @@ -3817,15 +3819,15 @@ If the built-in actions don't work for you, you can easily define your own one. All you need is a call operator with a signature compatible with the mocked function. So you can use a lambda: -``` +```cpp MockFunction mock; EXPECT_CALL(mock, Call).WillOnce([](const int input) { return input * 7; }); -EXPECT_EQ(14, mock.AsStdFunction()(2)); +EXPECT_EQ(mock.AsStdFunction()(2), 14); ``` Or a struct with a call operator (even a templated one): -``` +```cpp struct MultiplyBy { template T operator()(T arg) { return arg * multiplier; } @@ -3840,16 +3842,16 @@ struct MultiplyBy { It's also fine for the callable to take no arguments, ignoring the arguments supplied to the mock function: -``` +```cpp MockFunction mock; EXPECT_CALL(mock, Call).WillOnce([] { return 17; }); -EXPECT_EQ(17, mock.AsStdFunction()(0)); +EXPECT_EQ(mock.AsStdFunction()(0), 17); ``` When used with `WillOnce`, the callable can assume it will be called at most once and is allowed to be a move-only type: -``` +```cpp // An action that contains move-only types and has an &&-qualified operator, // demanding in the type system that it be called at most once. This can be // used with WillOnce, but the compiler will reject it if handed to