Remove third_party/googletest/src/googlemock No tests are using GoogleMock now, so it can be removed. Change-Id: I8000f5fe428a4df828a53715772059088f28d803
diff --git a/test/test.cmake b/test/test.cmake index a3e0d6a..f697db1 100644 --- a/test/test.cmake +++ b/test/test.cmake
@@ -419,16 +419,6 @@ target_compile_definitions(aom_gtest PUBLIC GTEST_HAS_PTHREAD=0) endif() endif() - - add_library( - aom_gmock STATIC - "${AOM_ROOT}/third_party/googletest/src/googlemock/src/gmock-all.cc") - set_property(TARGET aom_gmock PROPERTY FOLDER ${AOM_IDE_TEST_FOLDER}) - target_include_directories( - aom_gmock - PUBLIC "${AOM_ROOT}/third_party/googletest/src/googlemock/include" - PRIVATE "${AOM_ROOT}/third_party/googletest/src/googlemock") - target_link_libraries(aom_gmock ${AOM_LIB_LINK_TYPE} aom_gtest) endif() # Setup testdata download targets, test build targets, and test run targets. The
diff --git a/third_party/googletest/README.libaom b/third_party/googletest/README.libaom index 5e429d4..3b21c8e 100644 --- a/third_party/googletest/README.libaom +++ b/third_party/googletest/README.libaom
@@ -16,12 +16,6 @@ .clang-format CMakeLists.txt CONTRIBUTORS - googlemock/ - cmake - CMakeLists.txt - include - README.md - src googletest/ cmake CMakeLists.txt
diff --git a/third_party/googletest/src/googlemock/CMakeLists.txt b/third_party/googletest/src/googlemock/CMakeLists.txt deleted file mode 100644 index 5c1f0da..0000000 --- a/third_party/googletest/src/googlemock/CMakeLists.txt +++ /dev/null
@@ -1,218 +0,0 @@ -######################################################################## -# Note: CMake support is community-based. The maintainers do not use CMake -# internally. -# -# CMake build script for Google Mock. -# -# To run the tests for Google Mock itself on Linux, use 'make test' or -# ctest. You can select which tests to run using 'ctest -R regex'. -# For more options, run 'ctest --help'. - -option(gmock_build_tests "Build all of Google Mock's own tests." OFF) - -# A directory to find Google Test sources. -if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/gtest/CMakeLists.txt") - set(gtest_dir gtest) -else() - set(gtest_dir ../googletest) -endif() - -# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build(). -include("${gtest_dir}/cmake/hermetic_build.cmake" OPTIONAL) - -if (COMMAND pre_project_set_up_hermetic_build) - # Google Test also calls hermetic setup functions from add_subdirectory, - # although its changes will not affect things at the current scope. - pre_project_set_up_hermetic_build() -endif() - -######################################################################## -# -# Project-wide settings - -# Name of the project. -# -# CMake files in this project can refer to the root source directory -# 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) -project(gmock VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C) - -if (COMMAND set_up_hermetic_build) - set_up_hermetic_build() -endif() - -# Instructs CMake to process Google Test's CMakeLists.txt and add its -# targets to the current scope. We are placing Google Test's binary -# directory in a subdirectory of our own as VC compilation may break -# if they are the same (the default). -add_subdirectory("${gtest_dir}" "${gmock_BINARY_DIR}/${gtest_dir}") - - -# These commands only run if this is the main project -if(CMAKE_PROJECT_NAME STREQUAL "gmock" OR CMAKE_PROJECT_NAME STREQUAL "googletest-distribution") - # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to - # make it prominent in the GUI. - option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF) -else() - mark_as_advanced(gmock_build_tests) -endif() - -# Although Google Test's CMakeLists.txt calls this function, the -# changes there don't affect the current scope. Therefore we have to -# call it again here. -config_compiler_and_linker() # from ${gtest_dir}/cmake/internal_utils.cmake - -# Adds Google Mock's and Google Test's header directories to the search path. -set(gmock_build_include_dirs - "${gmock_SOURCE_DIR}/include" - "${gmock_SOURCE_DIR}" - "${gtest_SOURCE_DIR}/include" - # This directory is needed to build directly from Google Test sources. - "${gtest_SOURCE_DIR}") -include_directories(${gmock_build_include_dirs}) - -######################################################################## -# -# Defines the gmock & gmock_main libraries. User tests should link -# with one of them. - -# Google Mock libraries. We build them using more strict warnings than what -# are used for other targets, to ensure that Google Mock can be compiled by -# a user aggressive about warnings. -if (MSVC) - cxx_library(gmock - "${cxx_strict}" - "${gtest_dir}/src/gtest-all.cc" - src/gmock-all.cc) - - cxx_library(gmock_main - "${cxx_strict}" - "${gtest_dir}/src/gtest-all.cc" - src/gmock-all.cc - src/gmock_main.cc) -else() - cxx_library(gmock "${cxx_strict}" src/gmock-all.cc) - target_link_libraries(gmock PUBLIC gtest) - set_target_properties(gmock PROPERTIES VERSION ${GOOGLETEST_VERSION}) - cxx_library(gmock_main "${cxx_strict}" src/gmock_main.cc) - 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 ";" "$<SEMICOLON>" dirs "${gmock_build_include_dirs}") - target_include_directories(gmock SYSTEM INTERFACE - "$<BUILD_INTERFACE:${dirs}>" - "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>") - target_include_directories(gmock_main SYSTEM INTERFACE - "$<BUILD_INTERFACE:${dirs}>" - "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>") -endif() - -######################################################################## -# -# Install rules -install_project(gmock gmock_main) - -######################################################################## -# -# Google Mock's own tests. -# -# You can skip this section if you aren't interested in testing -# Google Mock itself. -# -# The tests are not built by default. To build them, set the -# gmock_build_tests option to ON. You can do it by running ccmake -# or specifying the -Dgmock_build_tests=ON flag when running cmake. - -if (gmock_build_tests) - # This must be set in the root directory for the tests to be run by - # 'make test' or ctest. - 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() - endif() - - ############################################################ - # C++ tests built with standard compiler flags. - - cxx_test(gmock-actions_test gmock_main) - cxx_test(gmock-cardinalities_test gmock_main) - cxx_test(gmock_ex_test gmock_main) - cxx_test(gmock-function-mocker_test gmock_main) - cxx_test(gmock-internal-utils_test gmock_main) - cxx_test(gmock-matchers-arithmetic_test gmock_main) - cxx_test(gmock-matchers-comparisons_test gmock_main) - cxx_test(gmock-matchers-containers_test gmock_main) - cxx_test(gmock-matchers-misc_test gmock_main) - cxx_test(gmock-more-actions_test gmock_main) - cxx_test(gmock-nice-strict_test gmock_main) - cxx_test(gmock-port_test gmock_main) - cxx_test(gmock-spec-builders_test gmock_main) - cxx_test(gmock_link_test gmock_main test/gmock_link2_test.cc) - cxx_test(gmock_test gmock_main) - - if (DEFINED GTEST_HAS_PTHREAD) - cxx_test(gmock_stress_test gmock) - endif() - - # gmock_all_test is commented to save time building and running tests. - # Uncomment if necessary. - # cxx_test(gmock_all_test gmock_main) - - ############################################################ - # C++ tests built with non-standard compiler flags. - - if (MSVC) - cxx_library(gmock_main_no_exception "${cxx_no_exception}" - "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc) - - cxx_library(gmock_main_no_rtti "${cxx_no_rtti}" - "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc) - - else() - cxx_library(gmock_main_no_exception "${cxx_no_exception}" src/gmock_main.cc) - target_link_libraries(gmock_main_no_exception PUBLIC gmock) - - cxx_library(gmock_main_no_rtti "${cxx_no_rtti}" src/gmock_main.cc) - target_link_libraries(gmock_main_no_rtti PUBLIC gmock) - endif() - cxx_test_with_flags(gmock-more-actions_no_exception_test "${cxx_no_exception}" - gmock_main_no_exception test/gmock-more-actions_test.cc) - - cxx_test_with_flags(gmock_no_rtti_test "${cxx_no_rtti}" - gmock_main_no_rtti test/gmock-spec-builders_test.cc) - - cxx_shared_library(shared_gmock_main "${cxx_default}" - "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc) - - # Tests that a binary can be built with Google Mock as a shared library. On - # some system configurations, it may not possible to run the binary without - # knowing more details about the system configurations. We do not try to run - # this binary. To get a more robust shared library coverage, configure with - # -DBUILD_SHARED_LIBS=ON. - cxx_executable_with_flags(shared_gmock_test_ "${cxx_default}" - shared_gmock_main test/gmock-spec-builders_test.cc) - set_target_properties(shared_gmock_test_ - PROPERTIES - COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1") - - ############################################################ - # Python tests. - - cxx_executable(gmock_leak_test_ test gmock_main) - py_test(gmock_leak_test) - - cxx_executable(gmock_output_test_ test gmock) - py_test(gmock_output_test) -endif()
diff --git a/third_party/googletest/src/googlemock/README.md b/third_party/googletest/src/googlemock/README.md deleted file mode 100644 index 7da6065..0000000 --- a/third_party/googletest/src/googlemock/README.md +++ /dev/null
@@ -1,40 +0,0 @@ -# Googletest Mocking (gMock) Framework - -### Overview - -Google's framework for writing and using C++ mock classes. It can help you -derive better designs of your system and write better tests. - -It is inspired by: - -* [jMock](http://www.jmock.org/) -* [EasyMock](http://www.easymock.org/) -* [Hamcrest](http://code.google.com/p/hamcrest/) - -It is designed with C++'s specifics in mind. - -gMock: - -- Provides a declarative syntax for defining mocks. -- Can define partial (hybrid) mocks, which are a cross of real and mock - objects. -- Handles functions of arbitrary types and overloaded functions. -- Comes with a rich set of matchers for validating function arguments. -- Uses an intuitive syntax for controlling the behavior of a mock. -- Does automatic verification of expectations (no record-and-replay needed). -- Allows arbitrary (partial) ordering constraints on function calls to be - expressed. -- Lets a user extend it by defining new matchers and actions. -- Does not use exceptions. -- Is easy to learn and use. - -Details and examples can be found here: - -* [gMock for Dummies](https://google.github.io/googletest/gmock_for_dummies.html) -* [Legacy gMock FAQ](https://google.github.io/googletest/gmock_faq.html) -* [gMock Cookbook](https://google.github.io/googletest/gmock_cook_book.html) -* [gMock Cheat Sheet](https://google.github.io/googletest/gmock_cheat_sheet.html) - -GoogleMock is a part of -[GoogleTest C++ testing framework](http://github.com/google/googletest/) and a -subject to the same requirements.
diff --git a/third_party/googletest/src/googlemock/cmake/gmock.pc.in b/third_party/googletest/src/googlemock/cmake/gmock.pc.in deleted file mode 100644 index 23c67b5..0000000 --- a/third_party/googletest/src/googlemock/cmake/gmock.pc.in +++ /dev/null
@@ -1,10 +0,0 @@ -libdir=@CMAKE_INSTALL_FULL_LIBDIR@ -includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ - -Name: gmock -Description: GoogleMock (without main() function) -Version: @PROJECT_VERSION@ -URL: https://github.com/google/googletest -Requires: gtest = @PROJECT_VERSION@ -Libs: -L${libdir} -lgmock @CMAKE_THREAD_LIBS_INIT@ -Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@
diff --git a/third_party/googletest/src/googlemock/cmake/gmock_main.pc.in b/third_party/googletest/src/googlemock/cmake/gmock_main.pc.in deleted file mode 100644 index 66ffea7..0000000 --- a/third_party/googletest/src/googlemock/cmake/gmock_main.pc.in +++ /dev/null
@@ -1,10 +0,0 @@ -libdir=@CMAKE_INSTALL_FULL_LIBDIR@ -includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ - -Name: gmock_main -Description: GoogleMock (with main() function) -Version: @PROJECT_VERSION@ -URL: https://github.com/google/googletest -Requires: gmock = @PROJECT_VERSION@ -Libs: -L${libdir} -lgmock_main @CMAKE_THREAD_LIBS_INIT@ -Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@
diff --git a/third_party/googletest/src/googlemock/include/gmock/gmock-actions.h b/third_party/googletest/src/googlemock/include/gmock/gmock-actions.h deleted file mode 100644 index c785ad8..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/gmock-actions.h +++ /dev/null
@@ -1,2298 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// The ACTION* family of macros can be used in a namespace scope to -// define custom actions easily. The syntax: -// -// ACTION(name) { statements; } -// -// will define an action with the given name that executes the -// statements. The value returned by the statements will be used as -// the return value of the action. Inside the statements, you can -// refer to the K-th (0-based) argument of the mock function by -// 'argK', and refer to its type by 'argK_type'. For example: -// -// ACTION(IncrementArg1) { -// arg1_type temp = arg1; -// return ++(*temp); -// } -// -// allows you to write -// -// ...WillOnce(IncrementArg1()); -// -// You can also refer to the entire argument tuple and its type by -// 'args' and 'args_type', and refer to the mock function type and its -// return type by 'function_type' and 'return_type'. -// -// Note that you don't need to specify the types of the mock function -// arguments. However rest assured that your code is still type-safe: -// you'll get a compiler error if *arg1 doesn't support the ++ -// operator, or if the type of ++(*arg1) isn't compatible with the -// mock function's return type, for example. -// -// Sometimes you'll want to parameterize the action. For that you can use -// another macro: -// -// ACTION_P(name, param_name) { statements; } -// -// For example: -// -// ACTION_P(Add, n) { return arg0 + n; } -// -// will allow you to write: -// -// ...WillOnce(Add(5)); -// -// Note that you don't need to provide the type of the parameter -// either. If you need to reference the type of a parameter named -// 'foo', you can write 'foo_type'. For example, in the body of -// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type -// of 'n'. -// -// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support -// multi-parameter actions. -// -// For the purpose of typing, you can view -// -// ACTION_Pk(Foo, p1, ..., pk) { ... } -// -// as shorthand for -// -// template <typename p1_type, ..., typename pk_type> -// FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... } -// -// In particular, you can provide the template type arguments -// explicitly when invoking Foo(), as in Foo<long, bool>(5, false); -// although usually you can rely on the compiler to infer the types -// for you automatically. You can assign the result of expression -// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ..., -// pk_type>. This can be useful when composing actions. -// -// You can also overload actions with different numbers of parameters: -// -// ACTION_P(Plus, a) { ... } -// ACTION_P2(Plus, a, b) { ... } -// -// While it's tempting to always use the ACTION* macros when defining -// a new action, you should also consider implementing ActionInterface -// or using MakePolymorphicAction() instead, especially if you need to -// use the action a lot. While these approaches require more work, -// they give you more control on the types of the mock function -// arguments and the action parameters, which in general leads to -// better compiler error messages that pay off in the long run. They -// also allow overloading actions based on parameter types (as opposed -// to just based on the number of parameters). -// -// CAVEAT: -// -// ACTION*() can only be used in a namespace scope as templates cannot be -// declared inside of a local class. -// Users can, however, define any local functors (e.g. a lambda) that -// can be used as actions. -// -// MORE INFORMATION: -// -// To learn more about using these macros, please search for 'ACTION' on -// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ - -#ifndef _WIN32_WCE -#include <errno.h> -#endif - -#include <algorithm> -#include <functional> -#include <memory> -#include <string> -#include <tuple> -#include <type_traits> -#include <utility> - -#include "gmock/internal/gmock-internal-utils.h" -#include "gmock/internal/gmock-port.h" -#include "gmock/internal/gmock-pp.h" - -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4100) -#endif - -namespace testing { - -// To implement an action Foo, define: -// 1. a class FooAction that implements the ActionInterface interface, and -// 2. a factory function that creates an Action object from a -// const FooAction*. -// -// The two-level delegation design follows that of Matcher, providing -// consistency for extension developers. It also eases ownership -// management as Action objects can now be copied like plain values. - -namespace internal { - -// BuiltInDefaultValueGetter<T, true>::Get() returns a -// default-constructed T value. BuiltInDefaultValueGetter<T, -// false>::Get() crashes with an error. -// -// This primary template is used when kDefaultConstructible is true. -template <typename T, bool kDefaultConstructible> -struct BuiltInDefaultValueGetter { - static T Get() { return T(); } -}; -template <typename T> -struct BuiltInDefaultValueGetter<T, false> { - static T Get() { - Assert(false, __FILE__, __LINE__, - "Default action undefined for the function return type."); - return internal::Invalid<T>(); - // The above statement will never be reached, but is required in - // order for this function to compile. - } -}; - -// BuiltInDefaultValue<T>::Get() returns the "built-in" default value -// for type T, which is NULL when T is a raw pointer type, 0 when T is -// a numeric type, false when T is bool, or "" when T is string or -// std::string. In addition, in C++11 and above, it turns a -// default-constructed T value if T is default constructible. For any -// other type T, the built-in default T value is undefined, and the -// function will abort the process. -template <typename T> -class BuiltInDefaultValue { - public: - // This function returns true if and only if type T has a built-in default - // value. - static bool Exists() { return ::std::is_default_constructible<T>::value; } - - static T Get() { - return BuiltInDefaultValueGetter< - T, ::std::is_default_constructible<T>::value>::Get(); - } -}; - -// This partial specialization says that we use the same built-in -// default value for T and const T. -template <typename T> -class BuiltInDefaultValue<const T> { - public: - static bool Exists() { return BuiltInDefaultValue<T>::Exists(); } - static T Get() { return BuiltInDefaultValue<T>::Get(); } -}; - -// This partial specialization defines the default values for pointer -// types. -template <typename T> -class BuiltInDefaultValue<T*> { - public: - static bool Exists() { return true; } - static T* Get() { return nullptr; } -}; - -// The following specializations define the default values for -// specific types we care about. -#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \ - template <> \ - class BuiltInDefaultValue<type> { \ - public: \ - static bool Exists() { return true; } \ - static type Get() { return value; } \ - } - -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, ); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, ""); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0'); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0'); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0'); - -// There's no need for a default action for signed wchar_t, as that -// type is the same as wchar_t for gcc, and invalid for MSVC. -// -// There's also no need for a default action for unsigned wchar_t, as -// that type is the same as unsigned int for gcc, and invalid for -// MSVC. -#if GMOCK_WCHAR_T_IS_NATIVE_ -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U); // NOLINT -#endif - -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0); - -#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ - -// Partial implementations of metaprogramming types from the standard library -// not available in C++11. - -template <typename P> -struct negation - // NOLINTNEXTLINE - : std::integral_constant<bool, bool(!P::value)> {}; - -// Base case: with zero predicates the answer is always true. -template <typename...> -struct conjunction : std::true_type {}; - -// With a single predicate, the answer is that predicate. -template <typename P1> -struct conjunction<P1> : P1 {}; - -// With multiple predicates the answer is the first predicate if that is false, -// and we recurse otherwise. -template <typename P1, typename... Ps> -struct conjunction<P1, Ps...> - : std::conditional<bool(P1::value), conjunction<Ps...>, P1>::type {}; - -template <typename...> -struct disjunction : std::false_type {}; - -template <typename P1> -struct disjunction<P1> : P1 {}; - -template <typename P1, typename... Ps> -struct disjunction<P1, Ps...> - // NOLINTNEXTLINE - : std::conditional<!bool(P1::value), disjunction<Ps...>, P1>::type {}; - -template <typename...> -using void_t = void; - -// Detects whether an expression of type `From` can be implicitly converted to -// `To` according to [conv]. In C++17, [conv]/3 defines this as follows: -// -// An expression e can be implicitly converted to a type T if and only if -// the declaration T t=e; is well-formed, for some invented temporary -// variable t ([dcl.init]). -// -// [conv]/2 implies we can use function argument passing to detect whether this -// initialization is valid. -// -// Note that this is distinct from is_convertible, which requires this be valid: -// -// To test() { -// return declval<From>(); -// } -// -// In particular, is_convertible doesn't give the correct answer when `To` and -// `From` are the same non-moveable type since `declval<From>` will be an rvalue -// reference, defeating the guaranteed copy elision that would otherwise make -// this function work. -// -// REQUIRES: `From` is not cv void. -template <typename From, typename To> -struct is_implicitly_convertible { - private: - // A function that accepts a parameter of type T. This can be called with type - // U successfully only if U is implicitly convertible to T. - template <typename T> - static void Accept(T); - - // A function that creates a value of type T. - template <typename T> - static T Make(); - - // An overload be selected when implicit conversion from T to To is possible. - template <typename T, typename = decltype(Accept<To>(Make<T>()))> - static std::true_type TestImplicitConversion(int); - - // A fallback overload selected in all other cases. - template <typename T> - static std::false_type TestImplicitConversion(...); - - public: - using type = decltype(TestImplicitConversion<From>(0)); - static constexpr bool value = type::value; -}; - -// Like std::invoke_result_t from C++17, but works only for objects with call -// operators (not e.g. member function pointers, which we don't need specific -// support for in OnceAction because std::function deals with them). -template <typename F, typename... Args> -using call_result_t = decltype(std::declval<F>()(std::declval<Args>()...)); - -template <typename Void, typename R, typename F, typename... Args> -struct is_callable_r_impl : std::false_type {}; - -// Specialize the struct for those template arguments where call_result_t is -// well-formed. When it's not, the generic template above is chosen, resulting -// in std::false_type. -template <typename R, typename F, typename... Args> -struct is_callable_r_impl<void_t<call_result_t<F, Args...>>, R, F, Args...> - : std::conditional< - std::is_void<R>::value, // - std::true_type, // - is_implicitly_convertible<call_result_t<F, Args...>, R>>::type {}; - -// Like std::is_invocable_r from C++17, but works only for objects with call -// operators. See the note on call_result_t. -template <typename R, typename F, typename... Args> -using is_callable_r = is_callable_r_impl<void, R, F, Args...>; - -// Like std::as_const from C++17. -template <typename T> -typename std::add_const<T>::type& as_const(T& t) { - return t; -} - -} // namespace internal - -// Specialized for function types below. -template <typename F> -class OnceAction; - -// An action that can only be used once. -// -// This is accepted by WillOnce, which doesn't require the underlying action to -// be copy-constructible (only move-constructible), and promises to invoke it as -// an rvalue reference. This allows the action to work with move-only types like -// std::move_only_function in a type-safe manner. -// -// For example: -// -// // Assume we have some API that needs to accept a unique pointer to some -// // non-copyable object Foo. -// void AcceptUniquePointer(std::unique_ptr<Foo> foo); -// -// // We can define an action that provides a Foo to that API. Because It -// // has to give away its unique pointer, it must not be called more than -// // once, so its call operator is &&-qualified. -// struct ProvideFoo { -// std::unique_ptr<Foo> foo; -// -// void operator()() && { -// AcceptUniquePointer(std::move(Foo)); -// } -// }; -// -// // This action can be used with WillOnce. -// EXPECT_CALL(mock, Call) -// .WillOnce(ProvideFoo{std::make_unique<Foo>(...)}); -// -// // But a call to WillRepeatedly will fail to compile. This is correct, -// // since the action cannot correctly be used repeatedly. -// EXPECT_CALL(mock, Call) -// .WillRepeatedly(ProvideFoo{std::make_unique<Foo>(...)}); -// -// A less-contrived example would be an action that returns an arbitrary type, -// whose &&-qualified call operator is capable of dealing with move-only types. -template <typename Result, typename... Args> -class OnceAction<Result(Args...)> final { - private: - // True iff we can use the given callable type (or lvalue reference) directly - // via StdFunctionAdaptor. - template <typename Callable> - using IsDirectlyCompatible = internal::conjunction< - // It must be possible to capture the callable in StdFunctionAdaptor. - std::is_constructible<typename std::decay<Callable>::type, Callable>, - // The callable must be compatible with our signature. - internal::is_callable_r<Result, typename std::decay<Callable>::type, - Args...>>; - - // True iff we can use the given callable type via StdFunctionAdaptor once we - // ignore incoming arguments. - template <typename Callable> - using IsCompatibleAfterIgnoringArguments = internal::conjunction< - // It must be possible to capture the callable in a lambda. - std::is_constructible<typename std::decay<Callable>::type, Callable>, - // The callable must be invocable with zero arguments, returning something - // convertible to Result. - internal::is_callable_r<Result, typename std::decay<Callable>::type>>; - - public: - // Construct from a callable that is directly compatible with our mocked - // signature: it accepts our function type's arguments and returns something - // convertible to our result type. - template <typename Callable, - typename std::enable_if< - internal::conjunction< - // Teach clang on macOS that we're not talking about a - // copy/move constructor here. Otherwise it gets confused - // when checking the is_constructible requirement of our - // traits above. - internal::negation<std::is_same< - OnceAction, typename std::decay<Callable>::type>>, - IsDirectlyCompatible<Callable>> // - ::value, - int>::type = 0> - OnceAction(Callable&& callable) // NOLINT - : function_(StdFunctionAdaptor<typename std::decay<Callable>::type>( - {}, std::forward<Callable>(callable))) {} - - // As above, but for a callable that ignores the mocked function's arguments. - template <typename Callable, - typename std::enable_if< - internal::conjunction< - // Teach clang on macOS that we're not talking about a - // copy/move constructor here. Otherwise it gets confused - // when checking the is_constructible requirement of our - // traits above. - internal::negation<std::is_same< - OnceAction, typename std::decay<Callable>::type>>, - // Exclude callables for which the overload above works. - // We'd rather provide the arguments if possible. - internal::negation<IsDirectlyCompatible<Callable>>, - IsCompatibleAfterIgnoringArguments<Callable>>::value, - int>::type = 0> - OnceAction(Callable&& callable) // NOLINT - // Call the constructor above with a callable - // that ignores the input arguments. - : OnceAction(IgnoreIncomingArguments<typename std::decay<Callable>::type>{ - std::forward<Callable>(callable)}) {} - - // We are naturally copyable because we store only an std::function, but - // semantically we should not be copyable. - OnceAction(const OnceAction&) = delete; - OnceAction& operator=(const OnceAction&) = delete; - OnceAction(OnceAction&&) = default; - - // Invoke the underlying action callable with which we were constructed, - // handing it the supplied arguments. - Result Call(Args... args) && { - return function_(std::forward<Args>(args)...); - } - - private: - // An adaptor that wraps a callable that is compatible with our signature and - // being invoked as an rvalue reference so that it can be used as an - // StdFunctionAdaptor. This throws away type safety, but that's fine because - // this is only used by WillOnce, which we know calls at most once. - // - // Once we have something like std::move_only_function from C++23, we can do - // away with this. - template <typename Callable> - class StdFunctionAdaptor final { - public: - // A tag indicating that the (otherwise universal) constructor is accepting - // the callable itself, instead of e.g. stealing calls for the move - // constructor. - struct CallableTag final {}; - - template <typename F> - explicit StdFunctionAdaptor(CallableTag, F&& callable) - : callable_(std::make_shared<Callable>(std::forward<F>(callable))) {} - - // Rather than explicitly returning Result, we return whatever the wrapped - // callable returns. This allows for compatibility with existing uses like - // the following, when the mocked function returns void: - // - // EXPECT_CALL(mock_fn_, Call) - // .WillOnce([&] { - // [...] - // return 0; - // }); - // - // Such a callable can be turned into std::function<void()>. If we use an - // explicit return type of Result here then it *doesn't* work with - // std::function, because we'll get a "void function should not return a - // value" error. - // - // We need not worry about incompatible result types because the SFINAE on - // OnceAction already checks this for us. std::is_invocable_r_v itself makes - // the same allowance for void result types. - template <typename... ArgRefs> - internal::call_result_t<Callable, ArgRefs...> operator()( - ArgRefs&&... args) const { - return std::move(*callable_)(std::forward<ArgRefs>(args)...); - } - - private: - // We must put the callable on the heap so that we are copyable, which - // std::function needs. - std::shared_ptr<Callable> callable_; - }; - - // An adaptor that makes a callable that accepts zero arguments callable with - // our mocked arguments. - template <typename Callable> - struct IgnoreIncomingArguments { - internal::call_result_t<Callable> operator()(Args&&...) { - return std::move(callable)(); - } - - Callable callable; - }; - - std::function<Result(Args...)> function_; -}; - -// When an unexpected function call is encountered, Google Mock will -// let it return a default value if the user has specified one for its -// return type, or if the return type has a built-in default value; -// otherwise Google Mock won't know what value to return and will have -// to abort the process. -// -// The DefaultValue<T> class allows a user to specify the -// default value for a type T that is both copyable and publicly -// destructible (i.e. anything that can be used as a function return -// type). The usage is: -// -// // Sets the default value for type T to be foo. -// DefaultValue<T>::Set(foo); -template <typename T> -class DefaultValue { - public: - // Sets the default value for type T; requires T to be - // copy-constructable and have a public destructor. - static void Set(T x) { - delete producer_; - producer_ = new FixedValueProducer(x); - } - - // Provides a factory function to be called to generate the default value. - // This method can be used even if T is only move-constructible, but it is not - // limited to that case. - typedef T (*FactoryFunction)(); - static void SetFactory(FactoryFunction factory) { - delete producer_; - producer_ = new FactoryValueProducer(factory); - } - - // Unsets the default value for type T. - static void Clear() { - delete producer_; - producer_ = nullptr; - } - - // Returns true if and only if the user has set the default value for type T. - static bool IsSet() { return producer_ != nullptr; } - - // Returns true if T has a default return value set by the user or there - // exists a built-in default value. - static bool Exists() { - return IsSet() || internal::BuiltInDefaultValue<T>::Exists(); - } - - // Returns the default value for type T if the user has set one; - // otherwise returns the built-in default value. Requires that Exists() - // is true, which ensures that the return value is well-defined. - static T Get() { - return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get() - : producer_->Produce(); - } - - private: - class ValueProducer { - public: - virtual ~ValueProducer() {} - virtual T Produce() = 0; - }; - - class FixedValueProducer : public ValueProducer { - public: - explicit FixedValueProducer(T value) : value_(value) {} - T Produce() override { return value_; } - - private: - const T value_; - FixedValueProducer(const FixedValueProducer&) = delete; - FixedValueProducer& operator=(const FixedValueProducer&) = delete; - }; - - class FactoryValueProducer : public ValueProducer { - public: - explicit FactoryValueProducer(FactoryFunction factory) - : factory_(factory) {} - T Produce() override { return factory_(); } - - private: - const FactoryFunction factory_; - FactoryValueProducer(const FactoryValueProducer&) = delete; - FactoryValueProducer& operator=(const FactoryValueProducer&) = delete; - }; - - static ValueProducer* producer_; -}; - -// This partial specialization allows a user to set default values for -// reference types. -template <typename T> -class DefaultValue<T&> { - public: - // Sets the default value for type T&. - static void Set(T& x) { // NOLINT - address_ = &x; - } - - // Unsets the default value for type T&. - static void Clear() { address_ = nullptr; } - - // Returns true if and only if the user has set the default value for type T&. - static bool IsSet() { return address_ != nullptr; } - - // Returns true if T has a default return value set by the user or there - // exists a built-in default value. - static bool Exists() { - return IsSet() || internal::BuiltInDefaultValue<T&>::Exists(); - } - - // Returns the default value for type T& if the user has set one; - // otherwise returns the built-in default value if there is one; - // otherwise aborts the process. - static T& Get() { - return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get() - : *address_; - } - - private: - static T* address_; -}; - -// This specialization allows DefaultValue<void>::Get() to -// compile. -template <> -class DefaultValue<void> { - public: - static bool Exists() { return true; } - static void Get() {} -}; - -// Points to the user-set default value for type T. -template <typename T> -typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr; - -// Points to the user-set default value for type T&. -template <typename T> -T* DefaultValue<T&>::address_ = nullptr; - -// Implement this interface to define an action for function type F. -template <typename F> -class ActionInterface { - public: - typedef typename internal::Function<F>::Result Result; - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - - ActionInterface() {} - virtual ~ActionInterface() {} - - // Performs the action. This method is not const, as in general an - // action can have side effects and be stateful. For example, a - // get-the-next-element-from-the-collection action will need to - // remember the current element. - virtual Result Perform(const ArgumentTuple& args) = 0; - - private: - ActionInterface(const ActionInterface&) = delete; - ActionInterface& operator=(const ActionInterface&) = delete; -}; - -template <typename F> -class Action; - -// An Action<R(Args...)> is a copyable and IMMUTABLE (except by assignment) -// object that represents an action to be taken when a mock function of type -// R(Args...) is called. The implementation of Action<T> is just a -// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action! You -// can view an object implementing ActionInterface<F> as a concrete action -// (including its current state), and an Action<F> object as a handle to it. -template <typename R, typename... Args> -class Action<R(Args...)> { - private: - using F = R(Args...); - - // Adapter class to allow constructing Action from a legacy ActionInterface. - // New code should create Actions from functors instead. - struct ActionAdapter { - // Adapter must be copyable to satisfy std::function requirements. - ::std::shared_ptr<ActionInterface<F>> impl_; - - template <typename... InArgs> - typename internal::Function<F>::Result operator()(InArgs&&... args) { - return impl_->Perform( - ::std::forward_as_tuple(::std::forward<InArgs>(args)...)); - } - }; - - template <typename G> - using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>; - - public: - typedef typename internal::Function<F>::Result Result; - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - - // Constructs a null Action. Needed for storing Action objects in - // STL containers. - Action() {} - - // Construct an Action from a specified callable. - // This cannot take std::function directly, because then Action would not be - // directly constructible from lambda (it would require two conversions). - template < - typename G, - typename = typename std::enable_if<internal::disjunction< - IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>, - G>>::value>::type> - Action(G&& fun) { // NOLINT - Init(::std::forward<G>(fun), IsCompatibleFunctor<G>()); - } - - // Constructs an Action from its implementation. - explicit Action(ActionInterface<F>* impl) - : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {} - - // This constructor allows us to turn an Action<Func> object into an - // Action<F>, as long as F's arguments can be implicitly converted - // to Func's and Func's return type can be implicitly converted to F's. - template <typename Func> - Action(const Action<Func>& action) // NOLINT - : fun_(action.fun_) {} - - // Returns true if and only if this is the DoDefault() action. - bool IsDoDefault() const { return fun_ == nullptr; } - - // Performs the action. Note that this method is const even though - // the corresponding method in ActionInterface is not. The reason - // is that a const Action<F> means that it cannot be re-bound to - // another concrete action, not that the concrete action it binds to - // cannot change state. (Think of the difference between a const - // pointer and a pointer to const.) - Result Perform(ArgumentTuple args) const { - if (IsDoDefault()) { - internal::IllegalDoDefault(__FILE__, __LINE__); - } - return internal::Apply(fun_, ::std::move(args)); - } - - // An action can be used as a OnceAction, since it's obviously safe to call it - // once. - operator OnceAction<F>() const { // NOLINT - // Return a OnceAction-compatible callable that calls Perform with the - // arguments it is provided. We could instead just return fun_, but then - // we'd need to handle the IsDoDefault() case separately. - struct OA { - Action<F> action; - - R operator()(Args... args) && { - return action.Perform( - std::forward_as_tuple(std::forward<Args>(args)...)); - } - }; - - return OA{*this}; - } - - private: - template <typename G> - friend class Action; - - template <typename G> - void Init(G&& g, ::std::true_type) { - fun_ = ::std::forward<G>(g); - } - - template <typename G> - void Init(G&& g, ::std::false_type) { - fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)}; - } - - template <typename FunctionImpl> - struct IgnoreArgs { - template <typename... InArgs> - Result operator()(const InArgs&...) const { - return function_impl(); - } - - FunctionImpl function_impl; - }; - - // fun_ is an empty function if and only if this is the DoDefault() action. - ::std::function<F> fun_; -}; - -// The PolymorphicAction class template makes it easy to implement a -// polymorphic action (i.e. an action that can be used in mock -// functions of than one type, e.g. Return()). -// -// To define a polymorphic action, a user first provides a COPYABLE -// implementation class that has a Perform() method template: -// -// class FooAction { -// public: -// template <typename Result, typename ArgumentTuple> -// Result Perform(const ArgumentTuple& args) const { -// // Processes the arguments and returns a result, using -// // std::get<N>(args) to get the N-th (0-based) argument in the tuple. -// } -// ... -// }; -// -// Then the user creates the polymorphic action using -// MakePolymorphicAction(object) where object has type FooAction. See -// the definition of Return(void) and SetArgumentPointee<N>(value) for -// complete examples. -template <typename Impl> -class PolymorphicAction { - public: - explicit PolymorphicAction(const Impl& impl) : impl_(impl) {} - - template <typename F> - operator Action<F>() const { - return Action<F>(new MonomorphicImpl<F>(impl_)); - } - - private: - template <typename F> - class MonomorphicImpl : public ActionInterface<F> { - public: - typedef typename internal::Function<F>::Result Result; - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - - explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} - - Result Perform(const ArgumentTuple& args) override { - return impl_.template Perform<Result>(args); - } - - private: - Impl impl_; - }; - - Impl impl_; -}; - -// Creates an Action from its implementation and returns it. The -// created Action object owns the implementation. -template <typename F> -Action<F> MakeAction(ActionInterface<F>* impl) { - return Action<F>(impl); -} - -// Creates a polymorphic action from its implementation. This is -// easier to use than the PolymorphicAction<Impl> constructor as it -// doesn't require you to explicitly write the template argument, e.g. -// -// MakePolymorphicAction(foo); -// vs -// PolymorphicAction<TypeOfFoo>(foo); -template <typename Impl> -inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) { - return PolymorphicAction<Impl>(impl); -} - -namespace internal { - -// Helper struct to specialize ReturnAction to execute a move instead of a copy -// on return. Useful for move-only types, but could be used on any type. -template <typename T> -struct ByMoveWrapper { - explicit ByMoveWrapper(T value) : payload(std::move(value)) {} - T payload; -}; - -// The general implementation of Return(R). Specializations follow below. -template <typename R> -class ReturnAction final { - public: - explicit ReturnAction(R value) : value_(std::move(value)) {} - - template <typename U, typename... Args, - typename = typename std::enable_if<conjunction< - // See the requirements documented on Return. - negation<std::is_same<void, U>>, // - negation<std::is_reference<U>>, // - std::is_convertible<R, U>, // - std::is_move_constructible<U>>::value>::type> - operator OnceAction<U(Args...)>() && { // NOLINT - return Impl<U>(std::move(value_)); - } - - template <typename U, typename... Args, - typename = typename std::enable_if<conjunction< - // See the requirements documented on Return. - negation<std::is_same<void, U>>, // - negation<std::is_reference<U>>, // - std::is_convertible<const R&, U>, // - std::is_copy_constructible<U>>::value>::type> - operator Action<U(Args...)>() const { // NOLINT - return Impl<U>(value_); - } - - private: - // Implements the Return(x) action for a mock function that returns type U. - template <typename U> - class Impl final { - public: - // The constructor used when the return value is allowed to move from the - // input value (i.e. we are converting to OnceAction). - explicit Impl(R&& input_value) - : state_(new State(std::move(input_value))) {} - - // The constructor used when the return value is not allowed to move from - // the input value (i.e. we are converting to Action). - explicit Impl(const R& input_value) : state_(new State(input_value)) {} - - U operator()() && { return std::move(state_->value); } - U operator()() const& { return state_->value; } - - private: - // We put our state on the heap so that the compiler-generated copy/move - // constructors work correctly even when U is a reference-like type. This is - // necessary only because we eagerly create State::value (see the note on - // that symbol for details). If we instead had only the input value as a - // member then the default constructors would work fine. - // - // For example, when R is std::string and U is std::string_view, value is a - // reference to the string backed by input_value. The copy constructor would - // copy both, so that we wind up with a new input_value object (with the - // same contents) and a reference to the *old* input_value object rather - // than the new one. - struct State { - explicit State(const R& input_value_in) - : input_value(input_value_in), - // Make an implicit conversion to Result before initializing the U - // object we store, avoiding calling any explicit constructor of U - // from R. - // - // This simulates the language rules: a function with return type U - // that does `return R()` requires R to be implicitly convertible to - // U, and uses that path for the conversion, even U Result has an - // explicit constructor from R. - value(ImplicitCast_<U>(internal::as_const(input_value))) {} - - // As above, but for the case where we're moving from the ReturnAction - // object because it's being used as a OnceAction. - explicit State(R&& input_value_in) - : input_value(std::move(input_value_in)), - // For the same reason as above we make an implicit conversion to U - // before initializing the value. - // - // Unlike above we provide the input value as an rvalue to the - // implicit conversion because this is a OnceAction: it's fine if it - // wants to consume the input value. - value(ImplicitCast_<U>(std::move(input_value))) {} - - // A copy of the value originally provided by the user. We retain this in - // addition to the value of the mock function's result type below in case - // the latter is a reference-like type. See the std::string_view example - // in the documentation on Return. - R input_value; - - // The value we actually return, as the type returned by the mock function - // itself. - // - // We eagerly initialize this here, rather than lazily doing the implicit - // conversion automatically each time Perform is called, for historical - // reasons: in 2009-11, commit a070cbd91c (Google changelist 13540126) - // made the Action<U()> conversion operator eagerly convert the R value to - // U, but without keeping the R alive. This broke the use case discussed - // in the documentation for Return, making reference-like types such as - // std::string_view not safe to use as U where the input type R is a - // value-like type such as std::string. - // - // The example the commit gave was not very clear, nor was the issue - // thread (https://github.com/google/googlemock/issues/86), but it seems - // the worry was about reference-like input types R that flatten to a - // value-like type U when being implicitly converted. An example of this - // is std::vector<bool>::reference, which is often a proxy type with an - // reference to the underlying vector: - // - // // Helper method: have the mock function return bools according - // // to the supplied script. - // void SetActions(MockFunction<bool(size_t)>& mock, - // const std::vector<bool>& script) { - // for (size_t i = 0; i < script.size(); ++i) { - // EXPECT_CALL(mock, Call(i)).WillOnce(Return(script[i])); - // } - // } - // - // TEST(Foo, Bar) { - // // Set actions using a temporary vector, whose operator[] - // // returns proxy objects that references that will be - // // dangling once the call to SetActions finishes and the - // // vector is destroyed. - // MockFunction<bool(size_t)> mock; - // SetActions(mock, {false, true}); - // - // EXPECT_FALSE(mock.AsStdFunction()(0)); - // EXPECT_TRUE(mock.AsStdFunction()(1)); - // } - // - // This eager conversion helps with a simple case like this, but doesn't - // fully make these types work in general. For example the following still - // uses a dangling reference: - // - // TEST(Foo, Baz) { - // MockFunction<std::vector<std::string>()> mock; - // - // // Return the same vector twice, and then the empty vector - // // thereafter. - // auto action = Return(std::initializer_list<std::string>{ - // "taco", "burrito", - // }); - // - // EXPECT_CALL(mock, Call) - // .WillOnce(action) - // .WillOnce(action) - // .WillRepeatedly(Return(std::vector<std::string>{})); - // - // EXPECT_THAT(mock.AsStdFunction()(), - // ElementsAre("taco", "burrito")); - // EXPECT_THAT(mock.AsStdFunction()(), - // ElementsAre("taco", "burrito")); - // EXPECT_THAT(mock.AsStdFunction()(), IsEmpty()); - // } - // - U value; - }; - - const std::shared_ptr<State> state_; - }; - - R value_; -}; - -// A specialization of ReturnAction<R> when R is ByMoveWrapper<T> for some T. -// -// This version applies the type system-defeating hack of moving from T even in -// the const call operator, checking at runtime that it isn't called more than -// once, since the user has declared their intent to do so by using ByMove. -template <typename T> -class ReturnAction<ByMoveWrapper<T>> final { - public: - explicit ReturnAction(ByMoveWrapper<T> wrapper) - : state_(new State(std::move(wrapper.payload))) {} - - T operator()() const { - GTEST_CHECK_(!state_->called) - << "A ByMove() action must be performed at most once."; - - state_->called = true; - return std::move(state_->value); - } - - private: - // We store our state on the heap so that we are copyable as required by - // Action, despite the fact that we are stateful and T may not be copyable. - struct State { - explicit State(T&& value_in) : value(std::move(value_in)) {} - - T value; - bool called = false; - }; - - const std::shared_ptr<State> state_; -}; - -// Implements the ReturnNull() action. -class ReturnNullAction { - public: - // Allows ReturnNull() to be used in any pointer-returning function. In C++11 - // this is enforced by returning nullptr, and in non-C++11 by asserting a - // pointer type on compile time. - template <typename Result, typename ArgumentTuple> - static Result Perform(const ArgumentTuple&) { - return nullptr; - } -}; - -// Implements the Return() action. -class ReturnVoidAction { - public: - // Allows Return() to be used in any void-returning function. - template <typename Result, typename ArgumentTuple> - static void Perform(const ArgumentTuple&) { - static_assert(std::is_void<Result>::value, "Result should be void."); - } -}; - -// Implements the polymorphic ReturnRef(x) action, which can be used -// in any function that returns a reference to the type of x, -// regardless of the argument types. -template <typename T> -class ReturnRefAction { - public: - // Constructs a ReturnRefAction object from the reference to be returned. - explicit ReturnRefAction(T& ref) : ref_(ref) {} // NOLINT - - // This template type conversion operator allows ReturnRef(x) to be - // used in ANY function that returns a reference to x's type. - template <typename F> - operator Action<F>() const { - typedef typename Function<F>::Result Result; - // Asserts that the function return type is a reference. This - // catches the user error of using ReturnRef(x) when Return(x) - // should be used, and generates some helpful error message. - static_assert(std::is_reference<Result>::value, - "use Return instead of ReturnRef to return a value"); - return Action<F>(new Impl<F>(ref_)); - } - - private: - // Implements the ReturnRef(x) action for a particular function type F. - template <typename F> - class Impl : public ActionInterface<F> { - public: - typedef typename Function<F>::Result Result; - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - - explicit Impl(T& ref) : ref_(ref) {} // NOLINT - - Result Perform(const ArgumentTuple&) override { return ref_; } - - private: - T& ref_; - }; - - T& ref_; -}; - -// Implements the polymorphic ReturnRefOfCopy(x) action, which can be -// used in any function that returns a reference to the type of x, -// regardless of the argument types. -template <typename T> -class ReturnRefOfCopyAction { - public: - // Constructs a ReturnRefOfCopyAction object from the reference to - // be returned. - explicit ReturnRefOfCopyAction(const T& value) : value_(value) {} // NOLINT - - // This template type conversion operator allows ReturnRefOfCopy(x) to be - // used in ANY function that returns a reference to x's type. - template <typename F> - operator Action<F>() const { - typedef typename Function<F>::Result Result; - // Asserts that the function return type is a reference. This - // catches the user error of using ReturnRefOfCopy(x) when Return(x) - // should be used, and generates some helpful error message. - static_assert(std::is_reference<Result>::value, - "use Return instead of ReturnRefOfCopy to return a value"); - return Action<F>(new Impl<F>(value_)); - } - - private: - // Implements the ReturnRefOfCopy(x) action for a particular function type F. - template <typename F> - class Impl : public ActionInterface<F> { - public: - typedef typename Function<F>::Result Result; - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - - explicit Impl(const T& value) : value_(value) {} // NOLINT - - Result Perform(const ArgumentTuple&) override { return value_; } - - private: - T value_; - }; - - const T value_; -}; - -// Implements the polymorphic ReturnRoundRobin(v) action, which can be -// used in any function that returns the element_type of v. -template <typename T> -class ReturnRoundRobinAction { - public: - explicit ReturnRoundRobinAction(std::vector<T> values) { - GTEST_CHECK_(!values.empty()) - << "ReturnRoundRobin requires at least one element."; - state_->values = std::move(values); - } - - template <typename... Args> - T operator()(Args&&...) const { - return state_->Next(); - } - - private: - struct State { - T Next() { - T ret_val = values[i++]; - if (i == values.size()) i = 0; - return ret_val; - } - - std::vector<T> values; - size_t i = 0; - }; - std::shared_ptr<State> state_ = std::make_shared<State>(); -}; - -// Implements the polymorphic DoDefault() action. -class DoDefaultAction { - public: - // This template type conversion operator allows DoDefault() to be - // used in any function. - template <typename F> - operator Action<F>() const { - return Action<F>(); - } // NOLINT -}; - -// Implements the Assign action to set a given pointer referent to a -// particular value. -template <typename T1, typename T2> -class AssignAction { - public: - AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {} - - template <typename Result, typename ArgumentTuple> - void Perform(const ArgumentTuple& /* args */) const { - *ptr_ = value_; - } - - private: - T1* const ptr_; - const T2 value_; -}; - -#if !GTEST_OS_WINDOWS_MOBILE - -// Implements the SetErrnoAndReturn action to simulate return from -// various system calls and libc functions. -template <typename T> -class SetErrnoAndReturnAction { - public: - SetErrnoAndReturnAction(int errno_value, T result) - : errno_(errno_value), result_(result) {} - template <typename Result, typename ArgumentTuple> - Result Perform(const ArgumentTuple& /* args */) const { - errno = errno_; - return result_; - } - - private: - const int errno_; - const T result_; -}; - -#endif // !GTEST_OS_WINDOWS_MOBILE - -// Implements the SetArgumentPointee<N>(x) action for any function -// whose N-th argument (0-based) is a pointer to x's type. -template <size_t N, typename A, typename = void> -struct SetArgumentPointeeAction { - A value; - - template <typename... Args> - void operator()(const Args&... args) const { - *::std::get<N>(std::tie(args...)) = value; - } -}; - -// Implements the Invoke(object_ptr, &Class::Method) action. -template <class Class, typename MethodPtr> -struct InvokeMethodAction { - Class* const obj_ptr; - const MethodPtr method_ptr; - - template <typename... Args> - auto operator()(Args&&... args) const - -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) { - return (obj_ptr->*method_ptr)(std::forward<Args>(args)...); - } -}; - -// Implements the InvokeWithoutArgs(f) action. The template argument -// FunctionImpl is the implementation type of f, which can be either a -// function pointer or a functor. InvokeWithoutArgs(f) can be used as an -// Action<F> as long as f's type is compatible with F. -template <typename FunctionImpl> -struct InvokeWithoutArgsAction { - FunctionImpl function_impl; - - // Allows InvokeWithoutArgs(f) to be used as any action whose type is - // compatible with f. - template <typename... Args> - auto operator()(const Args&...) -> decltype(function_impl()) { - return function_impl(); - } -}; - -// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action. -template <class Class, typename MethodPtr> -struct InvokeMethodWithoutArgsAction { - Class* const obj_ptr; - const MethodPtr method_ptr; - - using ReturnType = - decltype((std::declval<Class*>()->*std::declval<MethodPtr>())()); - - template <typename... Args> - ReturnType operator()(const Args&...) const { - return (obj_ptr->*method_ptr)(); - } -}; - -// Implements the IgnoreResult(action) action. -template <typename A> -class IgnoreResultAction { - public: - explicit IgnoreResultAction(const A& action) : action_(action) {} - - template <typename F> - operator Action<F>() const { - // Assert statement belongs here because this is the best place to verify - // conditions on F. It produces the clearest error messages - // in most compilers. - // Impl really belongs in this scope as a local class but can't - // because MSVC produces duplicate symbols in different translation units - // in this case. Until MS fixes that bug we put Impl into the class scope - // and put the typedef both here (for use in assert statement) and - // in the Impl class. But both definitions must be the same. - typedef typename internal::Function<F>::Result Result; - - // Asserts at compile time that F returns void. - static_assert(std::is_void<Result>::value, "Result type should be void."); - - return Action<F>(new Impl<F>(action_)); - } - - private: - template <typename F> - class Impl : public ActionInterface<F> { - public: - typedef typename internal::Function<F>::Result Result; - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - - explicit Impl(const A& action) : action_(action) {} - - void Perform(const ArgumentTuple& args) override { - // Performs the action and ignores its result. - action_.Perform(args); - } - - private: - // Type OriginalFunction is the same as F except that its return - // type is IgnoredValue. - typedef - typename internal::Function<F>::MakeResultIgnoredValue OriginalFunction; - - const Action<OriginalFunction> action_; - }; - - const A action_; -}; - -template <typename InnerAction, size_t... I> -struct WithArgsAction { - InnerAction inner_action; - - // The signature of the function as seen by the inner action, given an out - // action with the given result and argument types. - template <typename R, typename... Args> - using InnerSignature = - R(typename std::tuple_element<I, std::tuple<Args...>>::type...); - - // Rather than a call operator, we must define conversion operators to - // particular action types. This is necessary for embedded actions like - // DoDefault(), which rely on an action conversion operators rather than - // providing a call operator because even with a particular set of arguments - // they don't have a fixed return type. - - template <typename R, typename... Args, - typename std::enable_if< - std::is_convertible< - InnerAction, - // Unfortunately we can't use the InnerSignature alias here; - // MSVC complains about the I parameter pack not being - // expanded (error C3520) despite it being expanded in the - // type alias. - OnceAction<R(typename std::tuple_element< - I, std::tuple<Args...>>::type...)>>::value, - int>::type = 0> - operator OnceAction<R(Args...)>() && { // NOLINT - struct OA { - OnceAction<InnerSignature<R, Args...>> inner_action; - - R operator()(Args&&... args) && { - return std::move(inner_action) - .Call(std::get<I>( - std::forward_as_tuple(std::forward<Args>(args)...))...); - } - }; - - return OA{std::move(inner_action)}; - } - - template <typename R, typename... Args, - typename std::enable_if< - std::is_convertible< - const InnerAction&, - // Unfortunately we can't use the InnerSignature alias here; - // MSVC complains about the I parameter pack not being - // expanded (error C3520) despite it being expanded in the - // type alias. - Action<R(typename std::tuple_element< - I, std::tuple<Args...>>::type...)>>::value, - int>::type = 0> - operator Action<R(Args...)>() const { // NOLINT - Action<InnerSignature<R, Args...>> converted(inner_action); - - return [converted](Args&&... args) -> R { - return converted.Perform(std::forward_as_tuple( - std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...)); - }; - } -}; - -template <typename... Actions> -class DoAllAction; - -// Base case: only a single action. -template <typename FinalAction> -class DoAllAction<FinalAction> { - public: - struct UserConstructorTag {}; - - template <typename T> - explicit DoAllAction(UserConstructorTag, T&& action) - : final_action_(std::forward<T>(action)) {} - - // Rather than a call operator, we must define conversion operators to - // particular action types. This is necessary for embedded actions like - // DoDefault(), which rely on an action conversion operators rather than - // providing a call operator because even with a particular set of arguments - // they don't have a fixed return type. - - template <typename R, typename... Args, - typename std::enable_if< - std::is_convertible<FinalAction, OnceAction<R(Args...)>>::value, - int>::type = 0> - operator OnceAction<R(Args...)>() && { // NOLINT - return std::move(final_action_); - } - - template < - typename R, typename... Args, - typename std::enable_if< - std::is_convertible<const FinalAction&, Action<R(Args...)>>::value, - int>::type = 0> - operator Action<R(Args...)>() const { // NOLINT - return final_action_; - } - - private: - FinalAction final_action_; -}; - -// Recursive case: support N actions by calling the initial action and then -// calling through to the base class containing N-1 actions. -template <typename InitialAction, typename... OtherActions> -class DoAllAction<InitialAction, OtherActions...> - : private DoAllAction<OtherActions...> { - private: - using Base = DoAllAction<OtherActions...>; - - // The type of reference that should be provided to an initial action for a - // mocked function parameter of type T. - // - // There are two quirks here: - // - // * Unlike most forwarding functions, we pass scalars through by value. - // This isn't strictly necessary because an lvalue reference would work - // fine too and be consistent with other non-reference types, but it's - // perhaps less surprising. - // - // For example if the mocked function has signature void(int), then it - // might seem surprising for the user's initial action to need to be - // convertible to Action<void(const int&)>. This is perhaps less - // surprising for a non-scalar type where there may be a performance - // impact, or it might even be impossible, to pass by value. - // - // * More surprisingly, `const T&` is often not a const reference type. - // By the reference collapsing rules in C++17 [dcl.ref]/6, if T refers to - // U& or U&& for some non-scalar type U, then InitialActionArgType<T> is - // U&. In other words, we may hand over a non-const reference. - // - // So for example, given some non-scalar type Obj we have the following - // mappings: - // - // T InitialActionArgType<T> - // ------- ----------------------- - // Obj const Obj& - // Obj& Obj& - // Obj&& Obj& - // const Obj const Obj& - // const Obj& const Obj& - // const Obj&& const Obj& - // - // In other words, the initial actions get a mutable view of an non-scalar - // argument if and only if the mock function itself accepts a non-const - // reference type. They are never given an rvalue reference to an - // non-scalar type. - // - // This situation makes sense if you imagine use with a matcher that is - // designed to write through a reference. For example, if the caller wants - // to fill in a reference argument and then return a canned value: - // - // EXPECT_CALL(mock, Call) - // .WillOnce(DoAll(SetArgReferee<0>(17), Return(19))); - // - template <typename T> - using InitialActionArgType = - typename std::conditional<std::is_scalar<T>::value, T, const T&>::type; - - public: - struct UserConstructorTag {}; - - template <typename T, typename... U> - explicit DoAllAction(UserConstructorTag, T&& initial_action, - U&&... other_actions) - : Base({}, std::forward<U>(other_actions)...), - initial_action_(std::forward<T>(initial_action)) {} - - template <typename R, typename... Args, - typename std::enable_if< - conjunction< - // Both the initial action and the rest must support - // conversion to OnceAction. - std::is_convertible< - InitialAction, - OnceAction<void(InitialActionArgType<Args>...)>>, - std::is_convertible<Base, OnceAction<R(Args...)>>>::value, - int>::type = 0> - operator OnceAction<R(Args...)>() && { // NOLINT - // Return an action that first calls the initial action with arguments - // filtered through InitialActionArgType, then forwards arguments directly - // to the base class to deal with the remaining actions. - struct OA { - OnceAction<void(InitialActionArgType<Args>...)> initial_action; - OnceAction<R(Args...)> remaining_actions; - - R operator()(Args... args) && { - std::move(initial_action) - .Call(static_cast<InitialActionArgType<Args>>(args)...); - - return std::move(remaining_actions).Call(std::forward<Args>(args)...); - } - }; - - return OA{ - std::move(initial_action_), - std::move(static_cast<Base&>(*this)), - }; - } - - template < - typename R, typename... Args, - typename std::enable_if< - conjunction< - // Both the initial action and the rest must support conversion to - // Action. - std::is_convertible<const InitialAction&, - Action<void(InitialActionArgType<Args>...)>>, - std::is_convertible<const Base&, Action<R(Args...)>>>::value, - int>::type = 0> - operator Action<R(Args...)>() const { // NOLINT - // Return an action that first calls the initial action with arguments - // filtered through InitialActionArgType, then forwards arguments directly - // to the base class to deal with the remaining actions. - struct OA { - Action<void(InitialActionArgType<Args>...)> initial_action; - Action<R(Args...)> remaining_actions; - - R operator()(Args... args) const { - initial_action.Perform(std::forward_as_tuple( - static_cast<InitialActionArgType<Args>>(args)...)); - - return remaining_actions.Perform( - std::forward_as_tuple(std::forward<Args>(args)...)); - } - }; - - return OA{ - initial_action_, - static_cast<const Base&>(*this), - }; - } - - private: - InitialAction initial_action_; -}; - -template <typename T, typename... Params> -struct ReturnNewAction { - T* operator()() const { - return internal::Apply( - [](const Params&... unpacked_params) { - return new T(unpacked_params...); - }, - params); - } - std::tuple<Params...> params; -}; - -template <size_t k> -struct ReturnArgAction { - template <typename... Args, - typename = typename std::enable_if<(k < sizeof...(Args))>::type> - auto operator()(Args&&... args) const -> decltype(std::get<k>( - std::forward_as_tuple(std::forward<Args>(args)...))) { - return std::get<k>(std::forward_as_tuple(std::forward<Args>(args)...)); - } -}; - -template <size_t k, typename Ptr> -struct SaveArgAction { - Ptr pointer; - - template <typename... Args> - void operator()(const Args&... args) const { - *pointer = std::get<k>(std::tie(args...)); - } -}; - -template <size_t k, typename Ptr> -struct SaveArgPointeeAction { - Ptr pointer; - - template <typename... Args> - void operator()(const Args&... args) const { - *pointer = *std::get<k>(std::tie(args...)); - } -}; - -template <size_t k, typename T> -struct SetArgRefereeAction { - T value; - - template <typename... Args> - void operator()(Args&&... args) const { - using argk_type = - typename ::std::tuple_element<k, std::tuple<Args...>>::type; - static_assert(std::is_lvalue_reference<argk_type>::value, - "Argument must be a reference type."); - std::get<k>(std::tie(args...)) = value; - } -}; - -template <size_t k, typename I1, typename I2> -struct SetArrayArgumentAction { - I1 first; - I2 last; - - template <typename... Args> - void operator()(const Args&... args) const { - auto value = std::get<k>(std::tie(args...)); - for (auto it = first; it != last; ++it, (void)++value) { - *value = *it; - } - } -}; - -template <size_t k> -struct DeleteArgAction { - template <typename... Args> - void operator()(const Args&... args) const { - delete std::get<k>(std::tie(args...)); - } -}; - -template <typename Ptr> -struct ReturnPointeeAction { - Ptr pointer; - template <typename... Args> - auto operator()(const Args&...) const -> decltype(*pointer) { - return *pointer; - } -}; - -#if GTEST_HAS_EXCEPTIONS -template <typename T> -struct ThrowAction { - T exception; - // We use a conversion operator to adapt to any return type. - template <typename R, typename... Args> - operator Action<R(Args...)>() const { // NOLINT - T copy = exception; - return [copy](Args...) -> R { throw copy; }; - } -}; -#endif // GTEST_HAS_EXCEPTIONS - -} // namespace internal - -// An Unused object can be implicitly constructed from ANY value. -// This is handy when defining actions that ignore some or all of the -// mock function arguments. For example, given -// -// MOCK_METHOD3(Foo, double(const string& label, double x, double y)); -// MOCK_METHOD3(Bar, double(int index, double x, double y)); -// -// instead of -// -// double DistanceToOriginWithLabel(const string& label, double x, double y) { -// return sqrt(x*x + y*y); -// } -// double DistanceToOriginWithIndex(int index, double x, double y) { -// return sqrt(x*x + y*y); -// } -// ... -// EXPECT_CALL(mock, Foo("abc", _, _)) -// .WillOnce(Invoke(DistanceToOriginWithLabel)); -// EXPECT_CALL(mock, Bar(5, _, _)) -// .WillOnce(Invoke(DistanceToOriginWithIndex)); -// -// you could write -// -// // We can declare any uninteresting argument as Unused. -// double DistanceToOrigin(Unused, double x, double y) { -// return sqrt(x*x + y*y); -// } -// ... -// EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin)); -// EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin)); -typedef internal::IgnoredValue Unused; - -// Creates an action that does actions a1, a2, ..., sequentially in -// each invocation. All but the last action will have a readonly view of the -// arguments. -template <typename... Action> -internal::DoAllAction<typename std::decay<Action>::type...> DoAll( - Action&&... action) { - return internal::DoAllAction<typename std::decay<Action>::type...>( - {}, std::forward<Action>(action)...); -} - -// WithArg<k>(an_action) creates an action that passes the k-th -// (0-based) argument of the mock function to an_action and performs -// it. It adapts an action accepting one argument to one that accepts -// multiple arguments. For convenience, we also provide -// WithArgs<k>(an_action) (defined below) as a synonym. -template <size_t k, typename InnerAction> -internal::WithArgsAction<typename std::decay<InnerAction>::type, k> WithArg( - InnerAction&& action) { - return {std::forward<InnerAction>(action)}; -} - -// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes -// the selected arguments of the mock function to an_action and -// performs it. It serves as an adaptor between actions with -// different argument lists. -template <size_t k, size_t... ks, typename InnerAction> -internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...> -WithArgs(InnerAction&& action) { - return {std::forward<InnerAction>(action)}; -} - -// WithoutArgs(inner_action) can be used in a mock function with a -// non-empty argument list to perform inner_action, which takes no -// argument. In other words, it adapts an action accepting no -// argument to one that accepts (and ignores) arguments. -template <typename InnerAction> -internal::WithArgsAction<typename std::decay<InnerAction>::type> WithoutArgs( - InnerAction&& action) { - return {std::forward<InnerAction>(action)}; -} - -// Creates an action that returns a value. -// -// The returned type can be used with a mock function returning a non-void, -// non-reference type U as follows: -// -// * If R is convertible to U and U is move-constructible, then the action can -// be used with WillOnce. -// -// * If const R& is convertible to U and U is copy-constructible, then the -// action can be used with both WillOnce and WillRepeatedly. -// -// The mock expectation contains the R value from which the U return value is -// constructed (a move/copy of the argument to Return). This means that the R -// value will survive at least until the mock object's expectations are cleared -// or the mock object is destroyed, meaning that U can safely be a -// reference-like type such as std::string_view: -// -// // The mock function returns a view of a copy of the string fed to -// // Return. The view is valid even after the action is performed. -// MockFunction<std::string_view()> mock; -// EXPECT_CALL(mock, Call).WillOnce(Return(std::string("taco"))); -// const std::string_view result = mock.AsStdFunction()(); -// EXPECT_EQ("taco", result); -// -template <typename R> -internal::ReturnAction<R> Return(R value) { - return internal::ReturnAction<R>(std::move(value)); -} - -// Creates an action that returns NULL. -inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() { - return MakePolymorphicAction(internal::ReturnNullAction()); -} - -// Creates an action that returns from a void function. -inline PolymorphicAction<internal::ReturnVoidAction> Return() { - return MakePolymorphicAction(internal::ReturnVoidAction()); -} - -// Creates an action that returns the reference to a variable. -template <typename R> -inline internal::ReturnRefAction<R> ReturnRef(R& x) { // NOLINT - return internal::ReturnRefAction<R>(x); -} - -// Prevent using ReturnRef on reference to temporary. -template <typename R, R* = nullptr> -internal::ReturnRefAction<R> ReturnRef(R&&) = delete; - -// Creates an action that returns the reference to a copy of the -// argument. The copy is created when the action is constructed and -// lives as long as the action. -template <typename R> -inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) { - return internal::ReturnRefOfCopyAction<R>(x); -} - -// DEPRECATED: use Return(x) directly with WillOnce. -// -// Modifies the parent action (a Return() action) to perform a move of the -// argument instead of a copy. -// Return(ByMove()) actions can only be executed once and will assert this -// invariant. -template <typename R> -internal::ByMoveWrapper<R> ByMove(R x) { - return internal::ByMoveWrapper<R>(std::move(x)); -} - -// Creates an action that returns an element of `vals`. Calling this action will -// repeatedly return the next value from `vals` until it reaches the end and -// will restart from the beginning. -template <typename T> -internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) { - return internal::ReturnRoundRobinAction<T>(std::move(vals)); -} - -// Creates an action that returns an element of `vals`. Calling this action will -// repeatedly return the next value from `vals` until it reaches the end and -// will restart from the beginning. -template <typename T> -internal::ReturnRoundRobinAction<T> ReturnRoundRobin( - std::initializer_list<T> vals) { - return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals)); -} - -// Creates an action that does the default action for the give mock function. -inline internal::DoDefaultAction DoDefault() { - return internal::DoDefaultAction(); -} - -// Creates an action that sets the variable pointed by the N-th -// (0-based) function argument to 'value'. -template <size_t N, typename T> -internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) { - return {std::move(value)}; -} - -// The following version is DEPRECATED. -template <size_t N, typename T> -internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) { - return {std::move(value)}; -} - -// Creates an action that sets a pointer referent to a given value. -template <typename T1, typename T2> -PolymorphicAction<internal::AssignAction<T1, T2>> Assign(T1* ptr, T2 val) { - return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val)); -} - -#if !GTEST_OS_WINDOWS_MOBILE - -// Creates an action that sets errno and returns the appropriate error. -template <typename T> -PolymorphicAction<internal::SetErrnoAndReturnAction<T>> SetErrnoAndReturn( - int errval, T result) { - return MakePolymorphicAction( - internal::SetErrnoAndReturnAction<T>(errval, result)); -} - -#endif // !GTEST_OS_WINDOWS_MOBILE - -// Various overloads for Invoke(). - -// Legacy function. -// Actions can now be implicitly constructed from callables. No need to create -// wrapper objects. -// This function exists for backwards compatibility. -template <typename FunctionImpl> -typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) { - return std::forward<FunctionImpl>(function_impl); -} - -// Creates an action that invokes the given method on the given object -// with the mock function's arguments. -template <class Class, typename MethodPtr> -internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr, - MethodPtr method_ptr) { - return {obj_ptr, method_ptr}; -} - -// Creates an action that invokes 'function_impl' with no argument. -template <typename FunctionImpl> -internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type> -InvokeWithoutArgs(FunctionImpl function_impl) { - return {std::move(function_impl)}; -} - -// Creates an action that invokes the given method on the given object -// with no argument. -template <class Class, typename MethodPtr> -internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs( - Class* obj_ptr, MethodPtr method_ptr) { - return {obj_ptr, method_ptr}; -} - -// Creates an action that performs an_action and throws away its -// result. In other words, it changes the return type of an_action to -// void. an_action MUST NOT return void, or the code won't compile. -template <typename A> -inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) { - return internal::IgnoreResultAction<A>(an_action); -} - -// Creates a reference wrapper for the given L-value. If necessary, -// you can explicitly specify the type of the reference. For example, -// suppose 'derived' is an object of type Derived, ByRef(derived) -// would wrap a Derived&. If you want to wrap a const Base& instead, -// where Base is a base class of Derived, just write: -// -// ByRef<const Base>(derived) -// -// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper. -// However, it may still be used for consistency with ByMove(). -template <typename T> -inline ::std::reference_wrapper<T> ByRef(T& l_value) { // NOLINT - return ::std::reference_wrapper<T>(l_value); -} - -// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new -// instance of type T, constructed on the heap with constructor arguments -// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. -template <typename T, typename... Params> -internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew( - Params&&... params) { - return {std::forward_as_tuple(std::forward<Params>(params)...)}; -} - -// Action ReturnArg<k>() returns the k-th argument of the mock function. -template <size_t k> -internal::ReturnArgAction<k> ReturnArg() { - return {}; -} - -// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the -// mock function to *pointer. -template <size_t k, typename Ptr> -internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) { - return {pointer}; -} - -// Action SaveArgPointee<k>(pointer) saves the value pointed to -// by the k-th (0-based) argument of the mock function to *pointer. -template <size_t k, typename Ptr> -internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) { - return {pointer}; -} - -// Action SetArgReferee<k>(value) assigns 'value' to the variable -// referenced by the k-th (0-based) argument of the mock function. -template <size_t k, typename T> -internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee( - T&& value) { - return {std::forward<T>(value)}; -} - -// Action SetArrayArgument<k>(first, last) copies the elements in -// source range [first, last) to the array pointed to by the k-th -// (0-based) argument, which can be either a pointer or an -// iterator. The action does not take ownership of the elements in the -// source range. -template <size_t k, typename I1, typename I2> -internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first, - I2 last) { - return {first, last}; -} - -// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock -// function. -template <size_t k> -internal::DeleteArgAction<k> DeleteArg() { - return {}; -} - -// This action returns the value pointed to by 'pointer'. -template <typename Ptr> -internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) { - return {pointer}; -} - -// Action Throw(exception) can be used in a mock function of any type -// to throw the given exception. Any copyable value can be thrown. -#if GTEST_HAS_EXCEPTIONS -template <typename T> -internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) { - return {std::forward<T>(exception)}; -} -#endif // GTEST_HAS_EXCEPTIONS - -namespace internal { - -// A macro from the ACTION* family (defined later in gmock-generated-actions.h) -// defines an action that can be used in a mock function. Typically, -// these actions only care about a subset of the arguments of the mock -// function. For example, if such an action only uses the second -// argument, it can be used in any mock function that takes >= 2 -// arguments where the type of the second argument is compatible. -// -// Therefore, the action implementation must be prepared to take more -// arguments than it needs. The ExcessiveArg type is used to -// represent those excessive arguments. In order to keep the compiler -// error messages tractable, we define it in the testing namespace -// instead of testing::internal. However, this is an INTERNAL TYPE -// and subject to change without notice, so a user MUST NOT USE THIS -// TYPE DIRECTLY. -struct ExcessiveArg {}; - -// Builds an implementation of an Action<> for some particular signature, using -// a class defined by an ACTION* macro. -template <typename F, typename Impl> -struct ActionImpl; - -template <typename Impl> -struct ImplBase { - struct Holder { - // Allows each copy of the Action<> to get to the Impl. - explicit operator const Impl&() const { return *ptr; } - std::shared_ptr<Impl> ptr; - }; - using type = typename std::conditional<std::is_constructible<Impl>::value, - Impl, Holder>::type; -}; - -template <typename R, typename... Args, typename Impl> -struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type { - using Base = typename ImplBase<Impl>::type; - using function_type = R(Args...); - using args_type = std::tuple<Args...>; - - ActionImpl() = default; // Only defined if appropriate for Base. - explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} {} - - R operator()(Args&&... arg) const { - static constexpr size_t kMaxArgs = - sizeof...(Args) <= 10 ? sizeof...(Args) : 10; - return Apply(MakeIndexSequence<kMaxArgs>{}, - MakeIndexSequence<10 - kMaxArgs>{}, - args_type{std::forward<Args>(arg)...}); - } - - template <std::size_t... arg_id, std::size_t... excess_id> - R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>, - const args_type& args) const { - // Impl need not be specific to the signature of action being implemented; - // only the implementing function body needs to have all of the specific - // types instantiated. Up to 10 of the args that are provided by the - // args_type get passed, followed by a dummy of unspecified type for the - // remainder up to 10 explicit args. - static constexpr ExcessiveArg kExcessArg{}; - return static_cast<const Impl&>(*this) - .template gmock_PerformImpl< - /*function_type=*/function_type, /*return_type=*/R, - /*args_type=*/args_type, - /*argN_type=*/ - typename std::tuple_element<arg_id, args_type>::type...>( - /*args=*/args, std::get<arg_id>(args)..., - ((void)excess_id, kExcessArg)...); - } -}; - -// Stores a default-constructed Impl as part of the Action<>'s -// std::function<>. The Impl should be trivial to copy. -template <typename F, typename Impl> -::testing::Action<F> MakeAction() { - return ::testing::Action<F>(ActionImpl<F, Impl>()); -} - -// Stores just the one given instance of Impl. -template <typename F, typename Impl> -::testing::Action<F> MakeAction(std::shared_ptr<Impl> impl) { - return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl))); -} - -#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \ - , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_ -#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_ \ - const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \ - GMOCK_INTERNAL_ARG_UNUSED, , 10) - -#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i -#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \ - const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10) - -#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type -#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \ - GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10)) - -#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type -#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params)) - -#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type -#define GMOCK_ACTION_TYPE_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params)) - -#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \ - , param##_type gmock_p##i -#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params)) - -#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \ - , std::forward<param##_type>(gmock_p##i) -#define GMOCK_ACTION_GVALUE_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params)) - -#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \ - , param(::std::forward<param##_type>(gmock_p##i)) -#define GMOCK_ACTION_INIT_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params)) - -#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param; -#define GMOCK_ACTION_FIELD_PARAMS_(params) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params) - -#define GMOCK_INTERNAL_ACTION(name, full_name, params) \ - template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \ - class full_name { \ - public: \ - explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ - : impl_(std::make_shared<gmock_Impl>( \ - GMOCK_ACTION_GVALUE_PARAMS_(params))) {} \ - full_name(const full_name&) = default; \ - full_name(full_name&&) noexcept = default; \ - template <typename F> \ - operator ::testing::Action<F>() const { \ - return ::testing::internal::MakeAction<F>(impl_); \ - } \ - \ - private: \ - class gmock_Impl { \ - public: \ - explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ - : GMOCK_ACTION_INIT_PARAMS_(params) {} \ - template <typename function_type, typename return_type, \ - typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ - GMOCK_ACTION_FIELD_PARAMS_(params) \ - }; \ - std::shared_ptr<const gmock_Impl> impl_; \ - }; \ - template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \ - inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name( \ - GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) GTEST_MUST_USE_RESULT_; \ - template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \ - inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name( \ - GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) { \ - return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>( \ - GMOCK_ACTION_GVALUE_PARAMS_(params)); \ - } \ - template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \ - template <typename function_type, typename return_type, typename args_type, \ - GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type \ - full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::gmock_PerformImpl( \ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -} // namespace internal - -// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored. -#define ACTION(name) \ - class name##Action { \ - public: \ - explicit name##Action() noexcept {} \ - name##Action(const name##Action&) noexcept {} \ - template <typename F> \ - operator ::testing::Action<F>() const { \ - return ::testing::internal::MakeAction<F, gmock_Impl>(); \ - } \ - \ - private: \ - class gmock_Impl { \ - public: \ - template <typename function_type, typename return_type, \ - typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ - }; \ - }; \ - inline name##Action name() GTEST_MUST_USE_RESULT_; \ - inline name##Action name() { return name##Action(); } \ - template <typename function_type, typename return_type, typename args_type, \ - GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type name##Action::gmock_Impl::gmock_PerformImpl( \ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__)) - -#define ACTION_P2(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__)) - -#define ACTION_P3(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__)) - -#define ACTION_P4(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__)) - -#define ACTION_P5(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__)) - -#define ACTION_P6(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__)) - -#define ACTION_P7(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__)) - -#define ACTION_P8(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__)) - -#define ACTION_P9(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__)) - -#define ACTION_P10(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__)) - -} // namespace testing - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/gmock-cardinalities.h b/third_party/googletest/src/googlemock/include/gmock/gmock-cardinalities.h deleted file mode 100644 index b6ab648..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/gmock-cardinalities.h +++ /dev/null
@@ -1,159 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some commonly used cardinalities. More -// cardinalities can be defined by the user implementing the -// CardinalityInterface interface if necessary. - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ - -#include <limits.h> - -#include <memory> -#include <ostream> // NOLINT - -#include "gmock/internal/gmock-port.h" -#include "gtest/gtest.h" - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { - -// To implement a cardinality Foo, define: -// 1. a class FooCardinality that implements the -// CardinalityInterface interface, and -// 2. a factory function that creates a Cardinality object from a -// const FooCardinality*. -// -// The two-level delegation design follows that of Matcher, providing -// consistency for extension developers. It also eases ownership -// management as Cardinality objects can now be copied like plain values. - -// The implementation of a cardinality. -class CardinalityInterface { - public: - virtual ~CardinalityInterface() {} - - // Conservative estimate on the lower/upper bound of the number of - // calls allowed. - virtual int ConservativeLowerBound() const { return 0; } - virtual int ConservativeUpperBound() const { return INT_MAX; } - - // Returns true if and only if call_count calls will satisfy this - // cardinality. - virtual bool IsSatisfiedByCallCount(int call_count) const = 0; - - // Returns true if and only if call_count calls will saturate this - // cardinality. - virtual bool IsSaturatedByCallCount(int call_count) const = 0; - - // Describes self to an ostream. - virtual void DescribeTo(::std::ostream* os) const = 0; -}; - -// A Cardinality is a copyable and IMMUTABLE (except by assignment) -// object that specifies how many times a mock function is expected to -// be called. The implementation of Cardinality is just a std::shared_ptr -// to const CardinalityInterface. Don't inherit from Cardinality! -class GTEST_API_ Cardinality { - public: - // Constructs a null cardinality. Needed for storing Cardinality - // objects in STL containers. - Cardinality() {} - - // Constructs a Cardinality from its implementation. - explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {} - - // Conservative estimate on the lower/upper bound of the number of - // calls allowed. - int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); } - int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); } - - // Returns true if and only if call_count calls will satisfy this - // cardinality. - bool IsSatisfiedByCallCount(int call_count) const { - return impl_->IsSatisfiedByCallCount(call_count); - } - - // Returns true if and only if call_count calls will saturate this - // cardinality. - bool IsSaturatedByCallCount(int call_count) const { - return impl_->IsSaturatedByCallCount(call_count); - } - - // Returns true if and only if call_count calls will over-saturate this - // cardinality, i.e. exceed the maximum number of allowed calls. - bool IsOverSaturatedByCallCount(int call_count) const { - return impl_->IsSaturatedByCallCount(call_count) && - !impl_->IsSatisfiedByCallCount(call_count); - } - - // Describes self to an ostream - void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); } - - // Describes the given actual call count to an ostream. - static void DescribeActualCallCountTo(int actual_call_count, - ::std::ostream* os); - - private: - std::shared_ptr<const CardinalityInterface> impl_; -}; - -// Creates a cardinality that allows at least n calls. -GTEST_API_ Cardinality AtLeast(int n); - -// Creates a cardinality that allows at most n calls. -GTEST_API_ Cardinality AtMost(int n); - -// Creates a cardinality that allows any number of calls. -GTEST_API_ Cardinality AnyNumber(); - -// Creates a cardinality that allows between min and max calls. -GTEST_API_ Cardinality Between(int min, int max); - -// Creates a cardinality that allows exactly n calls. -GTEST_API_ Cardinality Exactly(int n); - -// Creates a cardinality from its implementation. -inline Cardinality MakeCardinality(const CardinalityInterface* c) { - return Cardinality(c); -} - -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/gmock-function-mocker.h b/third_party/googletest/src/googlemock/include/gmock/gmock-function-mocker.h deleted file mode 100644 index f565d98..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/gmock-function-mocker.h +++ /dev/null
@@ -1,514 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements MOCK_METHOD. - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT - -#include <type_traits> // IWYU pragma: keep -#include <utility> // IWYU pragma: keep - -#include "gmock/gmock-spec-builders.h" -#include "gmock/internal/gmock-internal-utils.h" -#include "gmock/internal/gmock-pp.h" - -namespace testing { -namespace internal { -template <typename T> -using identity_t = T; - -template <typename Pattern> -struct ThisRefAdjuster { - template <typename T> - using AdjustT = typename std::conditional< - std::is_const<typename std::remove_reference<Pattern>::type>::value, - typename std::conditional<std::is_lvalue_reference<Pattern>::value, - const T&, const T&&>::type, - typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&, - T&&>::type>::type; - - template <typename MockType> - static AdjustT<MockType> Adjust(const MockType& mock) { - return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock)); - } -}; - -constexpr bool PrefixOf(const char* a, const char* b) { - return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1)); -} - -template <int N, int M> -constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) { - return N <= M && internal::PrefixOf(prefix, str); -} - -template <int N, int M> -constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) { - return N <= M && internal::PrefixOf(suffix, str + M - N); -} - -template <int N, int M> -constexpr bool Equals(const char (&a)[N], const char (&b)[M]) { - return N == M && internal::PrefixOf(a, b); -} - -template <int N> -constexpr bool ValidateSpec(const char (&spec)[N]) { - return internal::Equals("const", spec) || - internal::Equals("override", spec) || - internal::Equals("final", spec) || - internal::Equals("noexcept", spec) || - (internal::StartsWith("noexcept(", spec) && - internal::EndsWith(")", spec)) || - internal::Equals("ref(&)", spec) || - internal::Equals("ref(&&)", spec) || - (internal::StartsWith("Calltype(", spec) && - internal::EndsWith(")", spec)); -} - -} // namespace internal - -// The style guide prohibits "using" statements in a namespace scope -// inside a header file. However, the FunctionMocker class template -// is meant to be defined in the ::testing namespace. The following -// line is just a trick for working around a bug in MSVC 8.0, which -// cannot handle it if we define FunctionMocker in ::testing. -using internal::FunctionMocker; -} // namespace testing - -#define MOCK_METHOD(...) \ - GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \ - GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ()) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec) \ - GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args); \ - GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec); \ - GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ - GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)); \ - GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ - GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ - GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec), \ - GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \ - GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec), \ - GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Spec), \ - GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \ - (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_WRONG_ARITY(...) \ - static_assert( \ - false, \ - "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, " \ - "_MethodName, _Args and optionally _Spec. _Args and _Spec must be " \ - "enclosed in parentheses. If _Ret is a type with unprotected commas, " \ - "it must also be enclosed in parentheses.") - -#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \ - static_assert( \ - GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple), \ - GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.") - -#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...) \ - static_assert( \ - std::is_function<__VA_ARGS__>::value, \ - "Signature must be a function type, maybe return type contains " \ - "unprotected comma."); \ - static_assert( \ - ::testing::tuple_size<typename ::testing::internal::Function< \ - __VA_ARGS__>::ArgumentTuple>::value == _N, \ - "This method does not take " GMOCK_PP_STRINGIZE( \ - _N) " arguments. Parenthesize all types with unprotected commas.") - -#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec) - -#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness, \ - _Override, _Final, _NoexceptSpec, \ - _CallType, _RefSpec, _Signature) \ - typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS( \ - _Signature)>::Result \ - GMOCK_INTERNAL_EXPAND(_CallType) \ - _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) \ - GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec \ - GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) { \ - GMOCK_MOCKER_(_N, _Constness, _MethodName) \ - .SetOwnerAndName(this, #_MethodName); \ - return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ - .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \ - } \ - ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \ - GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \ - GMOCK_PP_IF(_Constness, const, ) _RefSpec { \ - GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this); \ - return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ - .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \ - } \ - ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \ - const ::testing::internal::WithoutMatchers&, \ - GMOCK_PP_IF(_Constness, const, )::testing::internal::Function< \ - GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \ - return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF( \ - _Constness, const, ) int _RefSpec>::Adjust(*this) \ - .gmock_##_MethodName(GMOCK_PP_REPEAT( \ - GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N)); \ - } \ - mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)> \ - GMOCK_MOCKER_(_N, _Constness, _MethodName) - -#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__ - -// Valid modifiers. -#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple)) - -#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \ - GMOCK_PP_HAS_COMMA( \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple)) - -#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple)) - -#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple) - -#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem) \ - GMOCK_PP_IF( \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \ - _elem, ) - -#define GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Tuple) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE, ~, _Tuple) - -#define GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE(_i, _, _elem) \ - GMOCK_PP_IF( \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem)), \ - GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) - -#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple) - -#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem) \ - GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \ - GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) - -#ifdef GMOCK_INTERNAL_STRICT_SPEC_ASSERT -#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \ - static_assert( \ - ::testing::internal::ValidateSpec(GMOCK_PP_STRINGIZE(_elem)), \ - "Token \'" GMOCK_PP_STRINGIZE( \ - _elem) "\' cannot be recognized as a valid specification " \ - "modifier. Is a ',' missing?"); -#else -#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \ - static_assert( \ - (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) + \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) + \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) + \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem))) == 1, \ - GMOCK_PP_STRINGIZE( \ - _elem) " cannot be recognized as a valid specification modifier."); -#endif // GMOCK_INTERNAL_STRICT_SPEC_ASSERT - -// Modifiers implementation. -#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_CONST_I_const , - -#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override , - -#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_FINAL_I_final , - -#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept , - -#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_REF_I_ref , - -#define GMOCK_INTERNAL_UNPACK_ref(x) x - -#define GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CALLTYPE_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_CALLTYPE_I_Calltype , - -#define GMOCK_INTERNAL_UNPACK_Calltype(...) __VA_ARGS__ - -// Note: The use of `identity_t` here allows _Ret to represent return types that -// would normally need to be specified in a different way. For example, a method -// returning a function pointer must be written as -// -// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...) -// -// But we only support placing the return type at the beginning. To handle this, -// we wrap all calls in identity_t, so that a declaration will be expanded to -// -// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...) -// -// This allows us to work around the syntactic oddities of function/method -// types. -#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args) \ - ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \ - GMOCK_PP_REMOVE_PARENS, \ - GMOCK_PP_IDENTITY)(_Ret)>( \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) - -#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem) \ - GMOCK_PP_COMMA_IF(_i) \ - GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \ - GMOCK_PP_IDENTITY) \ - (_elem) - -#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ - gmock_a##_i - -#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - ::std::forward<GMOCK_INTERNAL_ARG_O( \ - _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i) - -#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ - gmock_a##_i - -#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \ - GMOCK_PP_COMMA_IF(_i) \ - gmock_a##_i - -#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>() - -#define GMOCK_INTERNAL_ARG_O(_i, ...) \ - typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type - -#define GMOCK_INTERNAL_MATCHER_O(_i, ...) \ - const ::testing::Matcher<typename ::testing::internal::Function< \ - __VA_ARGS__>::template Arg<_i>::type>& - -#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__) -#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__) -#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__) -#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__) -#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__) -#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__) -#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__) -#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__) -#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__) -#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__) -#define MOCK_METHOD10(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__) - -#define MOCK_CONST_METHOD0(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__) -#define MOCK_CONST_METHOD1(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__) -#define MOCK_CONST_METHOD2(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__) -#define MOCK_CONST_METHOD3(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__) -#define MOCK_CONST_METHOD4(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__) -#define MOCK_CONST_METHOD5(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__) -#define MOCK_CONST_METHOD6(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__) -#define MOCK_CONST_METHOD7(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__) -#define MOCK_CONST_METHOD8(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__) -#define MOCK_CONST_METHOD9(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__) -#define MOCK_CONST_METHOD10(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__) - -#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__) -#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__) -#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__) -#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__) -#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__) -#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__) -#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__) -#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__) -#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__) -#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__) -#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__) - -#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__) -#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__) -#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__) -#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__) -#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__) -#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__) -#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__) -#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__) -#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__) -#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__) -#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__) - -#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__) -#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__) -#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__) -#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__) -#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__) -#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__) -#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__) -#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__) -#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__) -#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__) -#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__) - -#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__) -#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__) -#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__) -#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__) -#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__) -#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__) -#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__) -#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__) -#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__) -#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__) -#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__) - -#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) - -#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \ - GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ - args_num, ::testing::internal::identity_t<__VA_ARGS__>); \ - GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ - args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, , \ - (::testing::internal::identity_t<__VA_ARGS__>)) - -#define GMOCK_MOCKER_(arity, constness, Method) \ - GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/gmock-matchers.h b/third_party/googletest/src/googlemock/include/gmock/gmock-matchers.h deleted file mode 100644 index 6282901..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/gmock-matchers.h +++ /dev/null
@@ -1,5610 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// The MATCHER* family of macros can be used in a namespace scope to -// define custom matchers easily. -// -// Basic Usage -// =========== -// -// The syntax -// -// MATCHER(name, description_string) { statements; } -// -// defines a matcher with the given name that executes the statements, -// which must return a bool to indicate if the match succeeds. Inside -// the statements, you can refer to the value being matched by 'arg', -// and refer to its type by 'arg_type'. -// -// The description string documents what the matcher does, and is used -// to generate the failure message when the match fails. Since a -// MATCHER() is usually defined in a header file shared by multiple -// C++ source files, we require the description to be a C-string -// literal to avoid possible side effects. It can be empty, in which -// case we'll use the sequence of words in the matcher name as the -// description. -// -// For example: -// -// MATCHER(IsEven, "") { return (arg % 2) == 0; } -// -// allows you to write -// -// // Expects mock_foo.Bar(n) to be called where n is even. -// EXPECT_CALL(mock_foo, Bar(IsEven())); -// -// or, -// -// // Verifies that the value of some_expression is even. -// EXPECT_THAT(some_expression, IsEven()); -// -// If the above assertion fails, it will print something like: -// -// Value of: some_expression -// Expected: is even -// Actual: 7 -// -// where the description "is even" is automatically calculated from the -// matcher name IsEven. -// -// Argument Type -// ============= -// -// Note that the type of the value being matched (arg_type) is -// determined by the context in which you use the matcher and is -// supplied to you by the compiler, so you don't need to worry about -// declaring it (nor can you). This allows the matcher to be -// polymorphic. For example, IsEven() can be used to match any type -// where the value of "(arg % 2) == 0" can be implicitly converted to -// a bool. In the "Bar(IsEven())" example above, if method Bar() -// takes an int, 'arg_type' will be int; if it takes an unsigned long, -// 'arg_type' will be unsigned long; and so on. -// -// Parameterizing Matchers -// ======================= -// -// Sometimes you'll want to parameterize the matcher. For that you -// can use another macro: -// -// MATCHER_P(name, param_name, description_string) { statements; } -// -// For example: -// -// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } -// -// will allow you to write: -// -// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); -// -// which may lead to this message (assuming n is 10): -// -// Value of: Blah("a") -// Expected: has absolute value 10 -// Actual: -9 -// -// Note that both the matcher description and its parameter are -// printed, making the message human-friendly. -// -// In the matcher definition body, you can write 'foo_type' to -// reference the type of a parameter named 'foo'. For example, in the -// body of MATCHER_P(HasAbsoluteValue, value) above, you can write -// 'value_type' to refer to the type of 'value'. -// -// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to -// support multi-parameter matchers. -// -// Describing Parameterized Matchers -// ================================= -// -// The last argument to MATCHER*() is a string-typed expression. The -// expression can reference all of the matcher's parameters and a -// special bool-typed variable named 'negation'. When 'negation' is -// false, the expression should evaluate to the matcher's description; -// otherwise it should evaluate to the description of the negation of -// the matcher. For example, -// -// using testing::PrintToString; -// -// MATCHER_P2(InClosedRange, low, hi, -// std::string(negation ? "is not" : "is") + " in range [" + -// PrintToString(low) + ", " + PrintToString(hi) + "]") { -// return low <= arg && arg <= hi; -// } -// ... -// EXPECT_THAT(3, InClosedRange(4, 6)); -// EXPECT_THAT(3, Not(InClosedRange(2, 4))); -// -// would generate two failures that contain the text: -// -// Expected: is in range [4, 6] -// ... -// Expected: is not in range [2, 4] -// -// If you specify "" as the description, the failure message will -// contain the sequence of words in the matcher name followed by the -// parameter values printed as a tuple. For example, -// -// MATCHER_P2(InClosedRange, low, hi, "") { ... } -// ... -// EXPECT_THAT(3, InClosedRange(4, 6)); -// EXPECT_THAT(3, Not(InClosedRange(2, 4))); -// -// would generate two failures that contain the text: -// -// Expected: in closed range (4, 6) -// ... -// Expected: not (in closed range (2, 4)) -// -// Types of Matcher Parameters -// =========================== -// -// For the purpose of typing, you can view -// -// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } -// -// as shorthand for -// -// template <typename p1_type, ..., typename pk_type> -// FooMatcherPk<p1_type, ..., pk_type> -// Foo(p1_type p1, ..., pk_type pk) { ... } -// -// When you write Foo(v1, ..., vk), the compiler infers the types of -// the parameters v1, ..., and vk for you. If you are not happy with -// the result of the type inference, you can specify the types by -// explicitly instantiating the template, as in Foo<long, bool>(5, -// false). As said earlier, you don't get to (or need to) specify -// 'arg_type' as that's determined by the context in which the matcher -// is used. You can assign the result of expression Foo(p1, ..., pk) -// to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This -// can be useful when composing matchers. -// -// While you can instantiate a matcher template with reference types, -// passing the parameters by pointer usually makes your code more -// readable. If, however, you still want to pass a parameter by -// reference, be aware that in the failure message generated by the -// matcher you will see the value of the referenced object but not its -// address. -// -// Explaining Match Results -// ======================== -// -// Sometimes the matcher description alone isn't enough to explain why -// the match has failed or succeeded. For example, when expecting a -// long string, it can be very helpful to also print the diff between -// the expected string and the actual one. To achieve that, you can -// optionally stream additional information to a special variable -// named result_listener, whose type is a pointer to class -// MatchResultListener: -// -// MATCHER_P(EqualsLongString, str, "") { -// if (arg == str) return true; -// -// *result_listener << "the difference: " -/// << DiffStrings(str, arg); -// return false; -// } -// -// Overloading Matchers -// ==================== -// -// You can overload matchers with different numbers of parameters: -// -// MATCHER_P(Blah, a, description_string1) { ... } -// MATCHER_P2(Blah, a, b, description_string2) { ... } -// -// Caveats -// ======= -// -// When defining a new matcher, you should also consider implementing -// MatcherInterface or using MakePolymorphicMatcher(). These -// approaches require more work than the MATCHER* macros, but also -// give you more control on the types of the value being matched and -// the matcher parameters, which may leads to better compiler error -// messages when the matcher is used wrong. They also allow -// overloading matchers based on parameter types (as opposed to just -// based on the number of parameters). -// -// MATCHER*() can only be used in a namespace scope as templates cannot be -// declared inside of a local class. -// -// More Information -// ================ -// -// To learn more about using these macros, please search for 'MATCHER' -// on -// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md -// -// This file also implements some commonly used argument matchers. More -// matchers can be defined by the user implementing the -// MatcherInterface<T> interface if necessary. -// -// See googletest/include/gtest/gtest-matchers.h for the definition of class -// Matcher, class MatcherInterface, and others. - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ - -#include <algorithm> -#include <cmath> -#include <initializer_list> -#include <iterator> -#include <limits> -#include <memory> -#include <ostream> // NOLINT -#include <sstream> -#include <string> -#include <type_traits> -#include <utility> -#include <vector> - -#include "gmock/internal/gmock-internal-utils.h" -#include "gmock/internal/gmock-port.h" -#include "gmock/internal/gmock-pp.h" -#include "gtest/gtest.h" - -// MSVC warning C5046 is new as of VS2017 version 15.8. -#if defined(_MSC_VER) && _MSC_VER >= 1915 -#define GMOCK_MAYBE_5046_ 5046 -#else -#define GMOCK_MAYBE_5046_ -#endif - -GTEST_DISABLE_MSC_WARNINGS_PUSH_( - 4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by - clients of class B */ - /* Symbol involving type with internal linkage not defined */) - -namespace testing { - -// To implement a matcher Foo for type T, define: -// 1. a class FooMatcherImpl that implements the -// MatcherInterface<T> interface, and -// 2. a factory function that creates a Matcher<T> object from a -// FooMatcherImpl*. -// -// The two-level delegation design makes it possible to allow a user -// to write "v" instead of "Eq(v)" where a Matcher is expected, which -// is impossible if we pass matchers by pointers. It also eases -// ownership management as Matcher objects can now be copied like -// plain values. - -// A match result listener that stores the explanation in a string. -class StringMatchResultListener : public MatchResultListener { - public: - StringMatchResultListener() : MatchResultListener(&ss_) {} - - // Returns the explanation accumulated so far. - std::string str() const { return ss_.str(); } - - // Clears the explanation accumulated so far. - void Clear() { ss_.str(""); } - - private: - ::std::stringstream ss_; - - StringMatchResultListener(const StringMatchResultListener&) = delete; - StringMatchResultListener& operator=(const StringMatchResultListener&) = - delete; -}; - -// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION -// and MUST NOT BE USED IN USER CODE!!! -namespace internal { - -// The MatcherCastImpl class template is a helper for implementing -// MatcherCast(). We need this helper in order to partially -// specialize the implementation of MatcherCast() (C++ allows -// class/struct templates to be partially specialized, but not -// function templates.). - -// This general version is used when MatcherCast()'s argument is a -// polymorphic matcher (i.e. something that can be converted to a -// Matcher but is not one yet; for example, Eq(value)) or a value (for -// example, "hello"). -template <typename T, typename M> -class MatcherCastImpl { - public: - static Matcher<T> Cast(const M& polymorphic_matcher_or_value) { - // M can be a polymorphic matcher, in which case we want to use - // its conversion operator to create Matcher<T>. Or it can be a value - // that should be passed to the Matcher<T>'s constructor. - // - // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a - // polymorphic matcher because it'll be ambiguous if T has an implicit - // constructor from M (this usually happens when T has an implicit - // constructor from any type). - // - // It won't work to unconditionally implicit_cast - // polymorphic_matcher_or_value to Matcher<T> because it won't trigger - // a user-defined conversion from M to T if one exists (assuming M is - // a value). - return CastImpl(polymorphic_matcher_or_value, - std::is_convertible<M, Matcher<T>>{}, - std::is_convertible<M, T>{}); - } - - private: - template <bool Ignore> - static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value, - std::true_type /* convertible_to_matcher */, - std::integral_constant<bool, Ignore>) { - // M is implicitly convertible to Matcher<T>, which means that either - // M is a polymorphic matcher or Matcher<T> has an implicit constructor - // from M. In both cases using the implicit conversion will produce a - // matcher. - // - // Even if T has an implicit constructor from M, it won't be called because - // creating Matcher<T> would require a chain of two user-defined conversions - // (first to create T from M and then to create Matcher<T> from T). - return polymorphic_matcher_or_value; - } - - // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic - // matcher. It's a value of a type implicitly convertible to T. Use direct - // initialization to create a matcher. - static Matcher<T> CastImpl(const M& value, - std::false_type /* convertible_to_matcher */, - std::true_type /* convertible_to_T */) { - return Matcher<T>(ImplicitCast_<T>(value)); - } - - // M can't be implicitly converted to either Matcher<T> or T. Attempt to use - // polymorphic matcher Eq(value) in this case. - // - // Note that we first attempt to perform an implicit cast on the value and - // only fall back to the polymorphic Eq() matcher afterwards because the - // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end - // which might be undefined even when Rhs is implicitly convertible to Lhs - // (e.g. std::pair<const int, int> vs. std::pair<int, int>). - // - // We don't define this method inline as we need the declaration of Eq(). - static Matcher<T> CastImpl(const M& value, - std::false_type /* convertible_to_matcher */, - std::false_type /* convertible_to_T */); -}; - -// This more specialized version is used when MatcherCast()'s argument -// is already a Matcher. This only compiles when type T can be -// statically converted to type U. -template <typename T, typename U> -class MatcherCastImpl<T, Matcher<U>> { - public: - static Matcher<T> Cast(const Matcher<U>& source_matcher) { - return Matcher<T>(new Impl(source_matcher)); - } - - private: - class Impl : public MatcherInterface<T> { - public: - explicit Impl(const Matcher<U>& source_matcher) - : source_matcher_(source_matcher) {} - - // We delegate the matching logic to the source matcher. - bool MatchAndExplain(T x, MatchResultListener* listener) const override { - using FromType = typename std::remove_cv<typename std::remove_pointer< - typename std::remove_reference<T>::type>::type>::type; - using ToType = typename std::remove_cv<typename std::remove_pointer< - typename std::remove_reference<U>::type>::type>::type; - // Do not allow implicitly converting base*/& to derived*/&. - static_assert( - // Do not trigger if only one of them is a pointer. That implies a - // regular conversion and not a down_cast. - (std::is_pointer<typename std::remove_reference<T>::type>::value != - std::is_pointer<typename std::remove_reference<U>::type>::value) || - std::is_same<FromType, ToType>::value || - !std::is_base_of<FromType, ToType>::value, - "Can't implicitly convert from <base> to <derived>"); - - // Do the cast to `U` explicitly if necessary. - // Otherwise, let implicit conversions do the trick. - using CastType = - typename std::conditional<std::is_convertible<T&, const U&>::value, - T&, U>::type; - - return source_matcher_.MatchAndExplain(static_cast<CastType>(x), - listener); - } - - void DescribeTo(::std::ostream* os) const override { - source_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - source_matcher_.DescribeNegationTo(os); - } - - private: - const Matcher<U> source_matcher_; - }; -}; - -// This even more specialized version is used for efficiently casting -// a matcher to its own type. -template <typename T> -class MatcherCastImpl<T, Matcher<T>> { - public: - static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; } -}; - -// Template specialization for parameterless Matcher. -template <typename Derived> -class MatcherBaseImpl { - public: - MatcherBaseImpl() = default; - - template <typename T> - operator ::testing::Matcher<T>() const { // NOLINT(runtime/explicit) - return ::testing::Matcher<T>(new - typename Derived::template gmock_Impl<T>()); - } -}; - -// Template specialization for Matcher with parameters. -template <template <typename...> class Derived, typename... Ts> -class MatcherBaseImpl<Derived<Ts...>> { - public: - // Mark the constructor explicit for single argument T to avoid implicit - // conversions. - template <typename E = std::enable_if<sizeof...(Ts) == 1>, - typename E::type* = nullptr> - explicit MatcherBaseImpl(Ts... params) - : params_(std::forward<Ts>(params)...) {} - template <typename E = std::enable_if<sizeof...(Ts) != 1>, - typename = typename E::type> - MatcherBaseImpl(Ts... params) // NOLINT - : params_(std::forward<Ts>(params)...) {} - - template <typename F> - operator ::testing::Matcher<F>() const { // NOLINT(runtime/explicit) - return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{}); - } - - private: - template <typename F, std::size_t... tuple_ids> - ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const { - return ::testing::Matcher<F>( - new typename Derived<Ts...>::template gmock_Impl<F>( - std::get<tuple_ids>(params_)...)); - } - - const std::tuple<Ts...> params_; -}; - -} // namespace internal - -// In order to be safe and clear, casting between different matcher -// types is done explicitly via MatcherCast<T>(m), which takes a -// matcher m and returns a Matcher<T>. It compiles only when T can be -// statically converted to the argument type of m. -template <typename T, typename M> -inline Matcher<T> MatcherCast(const M& matcher) { - return internal::MatcherCastImpl<T, M>::Cast(matcher); -} - -// This overload handles polymorphic matchers and values only since -// monomorphic matchers are handled by the next one. -template <typename T, typename M> -inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) { - return MatcherCast<T>(polymorphic_matcher_or_value); -} - -// This overload handles monomorphic matchers. -// -// In general, if type T can be implicitly converted to type U, we can -// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is -// contravariant): just keep a copy of the original Matcher<U>, convert the -// argument from type T to U, and then pass it to the underlying Matcher<U>. -// The only exception is when U is a reference and T is not, as the -// underlying Matcher<U> may be interested in the argument's address, which -// is not preserved in the conversion from T to U. -template <typename T, typename U> -inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) { - // Enforce that T can be implicitly converted to U. - static_assert(std::is_convertible<const T&, const U&>::value, - "T must be implicitly convertible to U"); - // Enforce that we are not converting a non-reference type T to a reference - // type U. - static_assert(std::is_reference<T>::value || !std::is_reference<U>::value, - "cannot convert non reference arg to reference"); - // In case both T and U are arithmetic types, enforce that the - // conversion is not lossy. - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT; - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU; - constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther; - constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther; - static_assert( - kTIsOther || kUIsOther || - (internal::LosslessArithmeticConvertible<RawT, RawU>::value), - "conversion of arithmetic types must be lossless"); - return MatcherCast<T>(matcher); -} - -// A<T>() returns a matcher that matches any value of type T. -template <typename T> -Matcher<T> A(); - -// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION -// and MUST NOT BE USED IN USER CODE!!! -namespace internal { - -// If the explanation is not empty, prints it to the ostream. -inline void PrintIfNotEmpty(const std::string& explanation, - ::std::ostream* os) { - if (explanation != "" && os != nullptr) { - *os << ", " << explanation; - } -} - -// Returns true if the given type name is easy to read by a human. -// This is used to decide whether printing the type of a value might -// be helpful. -inline bool IsReadableTypeName(const std::string& type_name) { - // We consider a type name readable if it's short or doesn't contain - // a template or function type. - return (type_name.length() <= 20 || - type_name.find_first_of("<(") == std::string::npos); -} - -// Matches the value against the given matcher, prints the value and explains -// the match result to the listener. Returns the match result. -// 'listener' must not be NULL. -// Value cannot be passed by const reference, because some matchers take a -// non-const argument. -template <typename Value, typename T> -bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher, - MatchResultListener* listener) { - if (!listener->IsInterested()) { - // If the listener is not interested, we do not need to construct the - // inner explanation. - return matcher.Matches(value); - } - - StringMatchResultListener inner_listener; - const bool match = matcher.MatchAndExplain(value, &inner_listener); - - UniversalPrint(value, listener->stream()); -#if GTEST_HAS_RTTI - const std::string& type_name = GetTypeName<Value>(); - if (IsReadableTypeName(type_name)) - *listener->stream() << " (of type " << type_name << ")"; -#endif - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - - return match; -} - -// An internal helper class for doing compile-time loop on a tuple's -// fields. -template <size_t N> -class TuplePrefix { - public: - // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true - // if and only if the first N fields of matcher_tuple matches - // the first N fields of value_tuple, respectively. - template <typename MatcherTuple, typename ValueTuple> - static bool Matches(const MatcherTuple& matcher_tuple, - const ValueTuple& value_tuple) { - return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) && - std::get<N - 1>(matcher_tuple).Matches(std::get<N - 1>(value_tuple)); - } - - // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os) - // describes failures in matching the first N fields of matchers - // against the first N fields of values. If there is no failure, - // nothing will be streamed to os. - template <typename MatcherTuple, typename ValueTuple> - static void ExplainMatchFailuresTo(const MatcherTuple& matchers, - const ValueTuple& values, - ::std::ostream* os) { - // First, describes failures in the first N - 1 fields. - TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os); - - // Then describes the failure (if any) in the (N - 1)-th (0-based) - // field. - typename std::tuple_element<N - 1, MatcherTuple>::type matcher = - std::get<N - 1>(matchers); - typedef typename std::tuple_element<N - 1, ValueTuple>::type Value; - const Value& value = std::get<N - 1>(values); - StringMatchResultListener listener; - if (!matcher.MatchAndExplain(value, &listener)) { - *os << " Expected arg #" << N - 1 << ": "; - std::get<N - 1>(matchers).DescribeTo(os); - *os << "\n Actual: "; - // We remove the reference in type Value to prevent the - // universal printer from printing the address of value, which - // isn't interesting to the user most of the time. The - // matcher's MatchAndExplain() method handles the case when - // the address is interesting. - internal::UniversalPrint(value, os); - PrintIfNotEmpty(listener.str(), os); - *os << "\n"; - } - } -}; - -// The base case. -template <> -class TuplePrefix<0> { - public: - template <typename MatcherTuple, typename ValueTuple> - static bool Matches(const MatcherTuple& /* matcher_tuple */, - const ValueTuple& /* value_tuple */) { - return true; - } - - template <typename MatcherTuple, typename ValueTuple> - static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */, - const ValueTuple& /* values */, - ::std::ostream* /* os */) {} -}; - -// TupleMatches(matcher_tuple, value_tuple) returns true if and only if -// all matchers in matcher_tuple match the corresponding fields in -// value_tuple. It is a compiler error if matcher_tuple and -// value_tuple have different number of fields or incompatible field -// types. -template <typename MatcherTuple, typename ValueTuple> -bool TupleMatches(const MatcherTuple& matcher_tuple, - const ValueTuple& value_tuple) { - // Makes sure that matcher_tuple and value_tuple have the same - // number of fields. - static_assert(std::tuple_size<MatcherTuple>::value == - std::tuple_size<ValueTuple>::value, - "matcher and value have different numbers of fields"); - return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple, - value_tuple); -} - -// Describes failures in matching matchers against values. If there -// is no failure, nothing will be streamed to os. -template <typename MatcherTuple, typename ValueTuple> -void ExplainMatchFailureTupleTo(const MatcherTuple& matchers, - const ValueTuple& values, ::std::ostream* os) { - TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo( - matchers, values, os); -} - -// TransformTupleValues and its helper. -// -// TransformTupleValuesHelper hides the internal machinery that -// TransformTupleValues uses to implement a tuple traversal. -template <typename Tuple, typename Func, typename OutIter> -class TransformTupleValuesHelper { - private: - typedef ::std::tuple_size<Tuple> TupleSize; - - public: - // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'. - // Returns the final value of 'out' in case the caller needs it. - static OutIter Run(Func f, const Tuple& t, OutIter out) { - return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out); - } - - private: - template <typename Tup, size_t kRemainingSize> - struct IterateOverTuple { - OutIter operator()(Func f, const Tup& t, OutIter out) const { - *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t)); - return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out); - } - }; - template <typename Tup> - struct IterateOverTuple<Tup, 0> { - OutIter operator()(Func /* f */, const Tup& /* t */, OutIter out) const { - return out; - } - }; -}; - -// Successively invokes 'f(element)' on each element of the tuple 't', -// appending each result to the 'out' iterator. Returns the final value -// of 'out'. -template <typename Tuple, typename Func, typename OutIter> -OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) { - return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out); -} - -// Implements _, a matcher that matches any value of any -// type. This is a polymorphic matcher, so we need a template type -// conversion operator to make it appearing as a Matcher<T> for any -// type T. -class AnythingMatcher { - public: - using is_gtest_matcher = void; - - template <typename T> - bool MatchAndExplain(const T& /* x */, std::ostream* /* listener */) const { - return true; - } - void DescribeTo(std::ostream* os) const { *os << "is anything"; } - void DescribeNegationTo(::std::ostream* os) const { - // This is mostly for completeness' sake, as it's not very useful - // to write Not(A<bool>()). However we cannot completely rule out - // such a possibility, and it doesn't hurt to be prepared. - *os << "never matches"; - } -}; - -// Implements the polymorphic IsNull() matcher, which matches any raw or smart -// pointer that is NULL. -class IsNullMatcher { - public: - template <typename Pointer> - bool MatchAndExplain(const Pointer& p, - MatchResultListener* /* listener */) const { - return p == nullptr; - } - - void DescribeTo(::std::ostream* os) const { *os << "is NULL"; } - void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NULL"; } -}; - -// Implements the polymorphic NotNull() matcher, which matches any raw or smart -// pointer that is not NULL. -class NotNullMatcher { - public: - template <typename Pointer> - bool MatchAndExplain(const Pointer& p, - MatchResultListener* /* listener */) const { - return p != nullptr; - } - - void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; } - void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; } -}; - -// Ref(variable) matches any argument that is a reference to -// 'variable'. This matcher is polymorphic as it can match any -// super type of the type of 'variable'. -// -// The RefMatcher template class implements Ref(variable). It can -// only be instantiated with a reference type. This prevents a user -// from mistakenly using Ref(x) to match a non-reference function -// argument. For example, the following will righteously cause a -// compiler error: -// -// int n; -// Matcher<int> m1 = Ref(n); // This won't compile. -// Matcher<int&> m2 = Ref(n); // This will compile. -template <typename T> -class RefMatcher; - -template <typename T> -class RefMatcher<T&> { - // Google Mock is a generic framework and thus needs to support - // mocking any function types, including those that take non-const - // reference arguments. Therefore the template parameter T (and - // Super below) can be instantiated to either a const type or a - // non-const type. - public: - // RefMatcher() takes a T& instead of const T&, as we want the - // compiler to catch using Ref(const_value) as a matcher for a - // non-const reference. - explicit RefMatcher(T& x) : object_(x) {} // NOLINT - - template <typename Super> - operator Matcher<Super&>() const { - // By passing object_ (type T&) to Impl(), which expects a Super&, - // we make sure that Super is a super type of T. In particular, - // this catches using Ref(const_value) as a matcher for a - // non-const reference, as you cannot implicitly convert a const - // reference to a non-const reference. - return MakeMatcher(new Impl<Super>(object_)); - } - - private: - template <typename Super> - class Impl : public MatcherInterface<Super&> { - public: - explicit Impl(Super& x) : object_(x) {} // NOLINT - - // MatchAndExplain() takes a Super& (as opposed to const Super&) - // in order to match the interface MatcherInterface<Super&>. - bool MatchAndExplain(Super& x, - MatchResultListener* listener) const override { - *listener << "which is located @" << static_cast<const void*>(&x); - return &x == &object_; - } - - void DescribeTo(::std::ostream* os) const override { - *os << "references the variable "; - UniversalPrinter<Super&>::Print(object_, os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "does not reference the variable "; - UniversalPrinter<Super&>::Print(object_, os); - } - - private: - const Super& object_; - }; - - T& object_; -}; - -// Polymorphic helper functions for narrow and wide string matchers. -inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) { - return String::CaseInsensitiveCStringEquals(lhs, rhs); -} - -inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs, - const wchar_t* rhs) { - return String::CaseInsensitiveWideCStringEquals(lhs, rhs); -} - -// String comparison for narrow or wide strings that can have embedded NUL -// characters. -template <typename StringType> -bool CaseInsensitiveStringEquals(const StringType& s1, const StringType& s2) { - // Are the heads equal? - if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) { - return false; - } - - // Skip the equal heads. - const typename StringType::value_type nul = 0; - const size_t i1 = s1.find(nul), i2 = s2.find(nul); - - // Are we at the end of either s1 or s2? - if (i1 == StringType::npos || i2 == StringType::npos) { - return i1 == i2; - } - - // Are the tails equal? - return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1)); -} - -// String matchers. - -// Implements equality-based string matchers like StrEq, StrCaseNe, and etc. -template <typename StringType> -class StrEqualityMatcher { - public: - StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive) - : string_(std::move(str)), - expect_eq_(expect_eq), - case_sensitive_(case_sensitive) {} - -#if GTEST_INTERNAL_HAS_STRING_VIEW - bool MatchAndExplain(const internal::StringView& s, - MatchResultListener* listener) const { - // This should fail to compile if StringView is used with wide - // strings. - const StringType& str = std::string(s); - return MatchAndExplain(str, listener); - } -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - - // Accepts pointer types, particularly: - // const char* - // char* - // const wchar_t* - // wchar_t* - template <typename CharType> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { - if (s == nullptr) { - return !expect_eq_; - } - return MatchAndExplain(StringType(s), listener); - } - - // Matches anything that can convert to StringType. - // - // This is a template, not just a plain function with const StringType&, - // because StringView has some interfering non-explicit constructors. - template <typename MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* /* listener */) const { - const StringType s2(s); - const bool eq = case_sensitive_ ? s2 == string_ - : CaseInsensitiveStringEquals(s2, string_); - return expect_eq_ == eq; - } - - void DescribeTo(::std::ostream* os) const { - DescribeToHelper(expect_eq_, os); - } - - void DescribeNegationTo(::std::ostream* os) const { - DescribeToHelper(!expect_eq_, os); - } - - private: - void DescribeToHelper(bool expect_eq, ::std::ostream* os) const { - *os << (expect_eq ? "is " : "isn't "); - *os << "equal to "; - if (!case_sensitive_) { - *os << "(ignoring case) "; - } - UniversalPrint(string_, os); - } - - const StringType string_; - const bool expect_eq_; - const bool case_sensitive_; -}; - -// Implements the polymorphic HasSubstr(substring) matcher, which -// can be used as a Matcher<T> as long as T can be converted to a -// string. -template <typename StringType> -class HasSubstrMatcher { - public: - explicit HasSubstrMatcher(const StringType& substring) - : substring_(substring) {} - -#if GTEST_INTERNAL_HAS_STRING_VIEW - bool MatchAndExplain(const internal::StringView& s, - MatchResultListener* listener) const { - // This should fail to compile if StringView is used with wide - // strings. - const StringType& str = std::string(s); - return MatchAndExplain(str, listener); - } -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - - // Accepts pointer types, particularly: - // const char* - // char* - // const wchar_t* - // wchar_t* - template <typename CharType> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { - return s != nullptr && MatchAndExplain(StringType(s), listener); - } - - // Matches anything that can convert to StringType. - // - // This is a template, not just a plain function with const StringType&, - // because StringView has some interfering non-explicit constructors. - template <typename MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* /* listener */) const { - return StringType(s).find(substring_) != StringType::npos; - } - - // Describes what this matcher matches. - void DescribeTo(::std::ostream* os) const { - *os << "has substring "; - UniversalPrint(substring_, os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "has no substring "; - UniversalPrint(substring_, os); - } - - private: - const StringType substring_; -}; - -// Implements the polymorphic StartsWith(substring) matcher, which -// can be used as a Matcher<T> as long as T can be converted to a -// string. -template <typename StringType> -class StartsWithMatcher { - public: - explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {} - -#if GTEST_INTERNAL_HAS_STRING_VIEW - bool MatchAndExplain(const internal::StringView& s, - MatchResultListener* listener) const { - // This should fail to compile if StringView is used with wide - // strings. - const StringType& str = std::string(s); - return MatchAndExplain(str, listener); - } -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - - // Accepts pointer types, particularly: - // const char* - // char* - // const wchar_t* - // wchar_t* - template <typename CharType> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { - return s != nullptr && MatchAndExplain(StringType(s), listener); - } - - // Matches anything that can convert to StringType. - // - // This is a template, not just a plain function with const StringType&, - // because StringView has some interfering non-explicit constructors. - template <typename MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* /* listener */) const { - const StringType& s2(s); - return s2.length() >= prefix_.length() && - s2.substr(0, prefix_.length()) == prefix_; - } - - void DescribeTo(::std::ostream* os) const { - *os << "starts with "; - UniversalPrint(prefix_, os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "doesn't start with "; - UniversalPrint(prefix_, os); - } - - private: - const StringType prefix_; -}; - -// Implements the polymorphic EndsWith(substring) matcher, which -// can be used as a Matcher<T> as long as T can be converted to a -// string. -template <typename StringType> -class EndsWithMatcher { - public: - explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {} - -#if GTEST_INTERNAL_HAS_STRING_VIEW - bool MatchAndExplain(const internal::StringView& s, - MatchResultListener* listener) const { - // This should fail to compile if StringView is used with wide - // strings. - const StringType& str = std::string(s); - return MatchAndExplain(str, listener); - } -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - - // Accepts pointer types, particularly: - // const char* - // char* - // const wchar_t* - // wchar_t* - template <typename CharType> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { - return s != nullptr && MatchAndExplain(StringType(s), listener); - } - - // Matches anything that can convert to StringType. - // - // This is a template, not just a plain function with const StringType&, - // because StringView has some interfering non-explicit constructors. - template <typename MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* /* listener */) const { - const StringType& s2(s); - return s2.length() >= suffix_.length() && - s2.substr(s2.length() - suffix_.length()) == suffix_; - } - - void DescribeTo(::std::ostream* os) const { - *os << "ends with "; - UniversalPrint(suffix_, os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "doesn't end with "; - UniversalPrint(suffix_, os); - } - - private: - const StringType suffix_; -}; - -// Implements the polymorphic WhenBase64Unescaped(matcher) matcher, which can be -// used as a Matcher<T> as long as T can be converted to a string. -class WhenBase64UnescapedMatcher { - public: - using is_gtest_matcher = void; - - explicit WhenBase64UnescapedMatcher( - const Matcher<const std::string&>& internal_matcher) - : internal_matcher_(internal_matcher) {} - - // Matches anything that can convert to std::string. - template <typename MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* listener) const { - const std::string s2(s); // NOLINT (needed for working with string_view). - std::string unescaped; - if (!internal::Base64Unescape(s2, &unescaped)) { - if (listener != nullptr) { - *listener << "is not a valid base64 escaped string"; - } - return false; - } - return MatchPrintAndExplain(unescaped, internal_matcher_, listener); - } - - void DescribeTo(::std::ostream* os) const { - *os << "matches after Base64Unescape "; - internal_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "does not match after Base64Unescape "; - internal_matcher_.DescribeTo(os); - } - - private: - const Matcher<const std::string&> internal_matcher_; -}; - -// Implements a matcher that compares the two fields of a 2-tuple -// using one of the ==, <=, <, etc, operators. The two fields being -// compared don't have to have the same type. -// -// The matcher defined here is polymorphic (for example, Eq() can be -// used to match a std::tuple<int, short>, a std::tuple<const long&, double>, -// etc). Therefore we use a template type conversion operator in the -// implementation. -template <typename D, typename Op> -class PairMatchBase { - public: - template <typename T1, typename T2> - operator Matcher<::std::tuple<T1, T2>>() const { - return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1, T2>&>); - } - template <typename T1, typename T2> - operator Matcher<const ::std::tuple<T1, T2>&>() const { - return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>); - } - - private: - static ::std::ostream& GetDesc(::std::ostream& os) { // NOLINT - return os << D::Desc(); - } - - template <typename Tuple> - class Impl : public MatcherInterface<Tuple> { - public: - bool MatchAndExplain(Tuple args, - MatchResultListener* /* listener */) const override { - return Op()(::std::get<0>(args), ::std::get<1>(args)); - } - void DescribeTo(::std::ostream* os) const override { - *os << "are " << GetDesc; - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "aren't " << GetDesc; - } - }; -}; - -class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> { - public: - static const char* Desc() { return "an equal pair"; } -}; -class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> { - public: - static const char* Desc() { return "an unequal pair"; } -}; -class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> { - public: - static const char* Desc() { return "a pair where the first < the second"; } -}; -class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> { - public: - static const char* Desc() { return "a pair where the first > the second"; } -}; -class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> { - public: - static const char* Desc() { return "a pair where the first <= the second"; } -}; -class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> { - public: - static const char* Desc() { return "a pair where the first >= the second"; } -}; - -// Implements the Not(...) matcher for a particular argument type T. -// We do not nest it inside the NotMatcher class template, as that -// will prevent different instantiations of NotMatcher from sharing -// the same NotMatcherImpl<T> class. -template <typename T> -class NotMatcherImpl : public MatcherInterface<const T&> { - public: - explicit NotMatcherImpl(const Matcher<T>& matcher) : matcher_(matcher) {} - - bool MatchAndExplain(const T& x, - MatchResultListener* listener) const override { - return !matcher_.MatchAndExplain(x, listener); - } - - void DescribeTo(::std::ostream* os) const override { - matcher_.DescribeNegationTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - matcher_.DescribeTo(os); - } - - private: - const Matcher<T> matcher_; -}; - -// Implements the Not(m) matcher, which matches a value that doesn't -// match matcher m. -template <typename InnerMatcher> -class NotMatcher { - public: - explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {} - - // This template type conversion operator allows Not(m) to be used - // to match any type m can match. - template <typename T> - operator Matcher<T>() const { - return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_))); - } - - private: - InnerMatcher matcher_; -}; - -// Implements the AllOf(m1, m2) matcher for a particular argument type -// T. We do not nest it inside the BothOfMatcher class template, as -// that will prevent different instantiations of BothOfMatcher from -// sharing the same BothOfMatcherImpl<T> class. -template <typename T> -class AllOfMatcherImpl : public MatcherInterface<const T&> { - public: - explicit AllOfMatcherImpl(std::vector<Matcher<T>> matchers) - : matchers_(std::move(matchers)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "("; - for (size_t i = 0; i < matchers_.size(); ++i) { - if (i != 0) *os << ") and ("; - matchers_[i].DescribeTo(os); - } - *os << ")"; - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "("; - for (size_t i = 0; i < matchers_.size(); ++i) { - if (i != 0) *os << ") or ("; - matchers_[i].DescribeNegationTo(os); - } - *os << ")"; - } - - bool MatchAndExplain(const T& x, - MatchResultListener* listener) const override { - // If either matcher1_ or matcher2_ doesn't match x, we only need - // to explain why one of them fails. - std::string all_match_result; - - for (size_t i = 0; i < matchers_.size(); ++i) { - StringMatchResultListener slistener; - if (matchers_[i].MatchAndExplain(x, &slistener)) { - if (all_match_result.empty()) { - all_match_result = slistener.str(); - } else { - std::string result = slistener.str(); - if (!result.empty()) { - all_match_result += ", and "; - all_match_result += result; - } - } - } else { - *listener << slistener.str(); - return false; - } - } - - // Otherwise we need to explain why *both* of them match. - *listener << all_match_result; - return true; - } - - private: - const std::vector<Matcher<T>> matchers_; -}; - -// VariadicMatcher is used for the variadic implementation of -// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...). -// CombiningMatcher<T> is used to recursively combine the provided matchers -// (of type Args...). -template <template <typename T> class CombiningMatcher, typename... Args> -class VariadicMatcher { - public: - VariadicMatcher(const Args&... matchers) // NOLINT - : matchers_(matchers...) { - static_assert(sizeof...(Args) > 0, "Must have at least one matcher."); - } - - VariadicMatcher(const VariadicMatcher&) = default; - VariadicMatcher& operator=(const VariadicMatcher&) = delete; - - // This template type conversion operator allows an - // VariadicMatcher<Matcher1, Matcher2...> object to match any type that - // all of the provided matchers (Matcher1, Matcher2, ...) can match. - template <typename T> - operator Matcher<T>() const { - std::vector<Matcher<T>> values; - CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>()); - return Matcher<T>(new CombiningMatcher<T>(std::move(values))); - } - - private: - template <typename T, size_t I> - void CreateVariadicMatcher(std::vector<Matcher<T>>* values, - std::integral_constant<size_t, I>) const { - values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_))); - CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>()); - } - - template <typename T> - void CreateVariadicMatcher( - std::vector<Matcher<T>>*, - std::integral_constant<size_t, sizeof...(Args)>) const {} - - std::tuple<Args...> matchers_; -}; - -template <typename... Args> -using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>; - -// Implements the AnyOf(m1, m2) matcher for a particular argument type -// T. We do not nest it inside the AnyOfMatcher class template, as -// that will prevent different instantiations of AnyOfMatcher from -// sharing the same EitherOfMatcherImpl<T> class. -template <typename T> -class AnyOfMatcherImpl : public MatcherInterface<const T&> { - public: - explicit AnyOfMatcherImpl(std::vector<Matcher<T>> matchers) - : matchers_(std::move(matchers)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "("; - for (size_t i = 0; i < matchers_.size(); ++i) { - if (i != 0) *os << ") or ("; - matchers_[i].DescribeTo(os); - } - *os << ")"; - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "("; - for (size_t i = 0; i < matchers_.size(); ++i) { - if (i != 0) *os << ") and ("; - matchers_[i].DescribeNegationTo(os); - } - *os << ")"; - } - - bool MatchAndExplain(const T& x, - MatchResultListener* listener) const override { - std::string no_match_result; - - // If either matcher1_ or matcher2_ matches x, we just need to - // explain why *one* of them matches. - for (size_t i = 0; i < matchers_.size(); ++i) { - StringMatchResultListener slistener; - if (matchers_[i].MatchAndExplain(x, &slistener)) { - *listener << slistener.str(); - return true; - } else { - if (no_match_result.empty()) { - no_match_result = slistener.str(); - } else { - std::string result = slistener.str(); - if (!result.empty()) { - no_match_result += ", and "; - no_match_result += result; - } - } - } - } - - // Otherwise we need to explain why *both* of them fail. - *listener << no_match_result; - return false; - } - - private: - const std::vector<Matcher<T>> matchers_; -}; - -// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...). -template <typename... Args> -using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>; - -// ConditionalMatcher is the implementation of Conditional(cond, m1, m2) -template <typename MatcherTrue, typename MatcherFalse> -class ConditionalMatcher { - public: - ConditionalMatcher(bool condition, MatcherTrue matcher_true, - MatcherFalse matcher_false) - : condition_(condition), - matcher_true_(std::move(matcher_true)), - matcher_false_(std::move(matcher_false)) {} - - template <typename T> - operator Matcher<T>() const { // NOLINT(runtime/explicit) - return condition_ ? SafeMatcherCast<T>(matcher_true_) - : SafeMatcherCast<T>(matcher_false_); - } - - private: - bool condition_; - MatcherTrue matcher_true_; - MatcherFalse matcher_false_; -}; - -// Wrapper for implementation of Any/AllOfArray(). -template <template <class> class MatcherImpl, typename T> -class SomeOfArrayMatcher { - public: - // Constructs the matcher from a sequence of element values or - // element matchers. - template <typename Iter> - SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {} - - template <typename U> - operator Matcher<U>() const { // NOLINT - using RawU = typename std::decay<U>::type; - std::vector<Matcher<RawU>> matchers; - for (const auto& matcher : matchers_) { - matchers.push_back(MatcherCast<RawU>(matcher)); - } - return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers))); - } - - private: - const ::std::vector<T> matchers_; -}; - -template <typename T> -using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>; - -template <typename T> -using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>; - -// Used for implementing Truly(pred), which turns a predicate into a -// matcher. -template <typename Predicate> -class TrulyMatcher { - public: - explicit TrulyMatcher(Predicate pred) : predicate_(pred) {} - - // This method template allows Truly(pred) to be used as a matcher - // for type T where T is the argument type of predicate 'pred'. The - // argument is passed by reference as the predicate may be - // interested in the address of the argument. - template <typename T> - bool MatchAndExplain(T& x, // NOLINT - MatchResultListener* listener) const { - // Without the if-statement, MSVC sometimes warns about converting - // a value to bool (warning 4800). - // - // We cannot write 'return !!predicate_(x);' as that doesn't work - // when predicate_(x) returns a class convertible to bool but - // having no operator!(). - if (predicate_(x)) return true; - *listener << "didn't satisfy the given predicate"; - return false; - } - - void DescribeTo(::std::ostream* os) const { - *os << "satisfies the given predicate"; - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "doesn't satisfy the given predicate"; - } - - private: - Predicate predicate_; -}; - -// Used for implementing Matches(matcher), which turns a matcher into -// a predicate. -template <typename M> -class MatcherAsPredicate { - public: - explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {} - - // This template operator() allows Matches(m) to be used as a - // predicate on type T where m is a matcher on type T. - // - // The argument x is passed by reference instead of by value, as - // some matcher may be interested in its address (e.g. as in - // Matches(Ref(n))(x)). - template <typename T> - bool operator()(const T& x) const { - // We let matcher_ commit to a particular type here instead of - // when the MatcherAsPredicate object was constructed. This - // allows us to write Matches(m) where m is a polymorphic matcher - // (e.g. Eq(5)). - // - // If we write Matcher<T>(matcher_).Matches(x) here, it won't - // compile when matcher_ has type Matcher<const T&>; if we write - // Matcher<const T&>(matcher_).Matches(x) here, it won't compile - // when matcher_ has type Matcher<T>; if we just write - // matcher_.Matches(x), it won't compile when matcher_ is - // polymorphic, e.g. Eq(5). - // - // MatcherCast<const T&>() is necessary for making the code work - // in all of the above situations. - return MatcherCast<const T&>(matcher_).Matches(x); - } - - private: - M matcher_; -}; - -// For implementing ASSERT_THAT() and EXPECT_THAT(). The template -// argument M must be a type that can be converted to a matcher. -template <typename M> -class PredicateFormatterFromMatcher { - public: - explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {} - - // This template () operator allows a PredicateFormatterFromMatcher - // object to act as a predicate-formatter suitable for using with - // Google Test's EXPECT_PRED_FORMAT1() macro. - template <typename T> - AssertionResult operator()(const char* value_text, const T& x) const { - // We convert matcher_ to a Matcher<const T&> *now* instead of - // when the PredicateFormatterFromMatcher object was constructed, - // as matcher_ may be polymorphic (e.g. NotNull()) and we won't - // know which type to instantiate it to until we actually see the - // type of x here. - // - // We write SafeMatcherCast<const T&>(matcher_) instead of - // Matcher<const T&>(matcher_), as the latter won't compile when - // matcher_ has type Matcher<T> (e.g. An<int>()). - // We don't write MatcherCast<const T&> either, as that allows - // potentially unsafe downcasting of the matcher argument. - const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_); - - // The expected path here is that the matcher should match (i.e. that most - // tests pass) so optimize for this case. - if (matcher.Matches(x)) { - return AssertionSuccess(); - } - - ::std::stringstream ss; - ss << "Value of: " << value_text << "\n" - << "Expected: "; - matcher.DescribeTo(&ss); - - // Rerun the matcher to "PrintAndExplain" the failure. - StringMatchResultListener listener; - if (MatchPrintAndExplain(x, matcher, &listener)) { - ss << "\n The matcher failed on the initial attempt; but passed when " - "rerun to generate the explanation."; - } - ss << "\n Actual: " << listener.str(); - return AssertionFailure() << ss.str(); - } - - private: - const M matcher_; -}; - -// A helper function for converting a matcher to a predicate-formatter -// without the user needing to explicitly write the type. This is -// used for implementing ASSERT_THAT() and EXPECT_THAT(). -// Implementation detail: 'matcher' is received by-value to force decaying. -template <typename M> -inline PredicateFormatterFromMatcher<M> MakePredicateFormatterFromMatcher( - M matcher) { - return PredicateFormatterFromMatcher<M>(std::move(matcher)); -} - -// Implements the polymorphic IsNan() matcher, which matches any floating type -// value that is Nan. -class IsNanMatcher { - public: - template <typename FloatType> - bool MatchAndExplain(const FloatType& f, - MatchResultListener* /* listener */) const { - return (::std::isnan)(f); - } - - void DescribeTo(::std::ostream* os) const { *os << "is NaN"; } - void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NaN"; } -}; - -// Implements the polymorphic floating point equality matcher, which matches -// two float values using ULP-based approximation or, optionally, a -// user-specified epsilon. The template is meant to be instantiated with -// FloatType being either float or double. -template <typename FloatType> -class FloatingEqMatcher { - public: - // Constructor for FloatingEqMatcher. - // The matcher's input will be compared with expected. The matcher treats two - // NANs as equal if nan_eq_nan is true. Otherwise, under IEEE standards, - // equality comparisons between NANs will always return false. We specify a - // negative max_abs_error_ term to indicate that ULP-based approximation will - // be used for comparison. - FloatingEqMatcher(FloatType expected, bool nan_eq_nan) - : expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {} - - // Constructor that supports a user-specified max_abs_error that will be used - // for comparison instead of ULP-based approximation. The max absolute - // should be non-negative. - FloatingEqMatcher(FloatType expected, bool nan_eq_nan, - FloatType max_abs_error) - : expected_(expected), - nan_eq_nan_(nan_eq_nan), - max_abs_error_(max_abs_error) { - GTEST_CHECK_(max_abs_error >= 0) - << ", where max_abs_error is" << max_abs_error; - } - - // Implements floating point equality matcher as a Matcher<T>. - template <typename T> - class Impl : public MatcherInterface<T> { - public: - Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error) - : expected_(expected), - nan_eq_nan_(nan_eq_nan), - max_abs_error_(max_abs_error) {} - - bool MatchAndExplain(T value, - MatchResultListener* listener) const override { - const FloatingPoint<FloatType> actual(value), expected(expected_); - - // Compares NaNs first, if nan_eq_nan_ is true. - if (actual.is_nan() || expected.is_nan()) { - if (actual.is_nan() && expected.is_nan()) { - return nan_eq_nan_; - } - // One is nan; the other is not nan. - return false; - } - if (HasMaxAbsError()) { - // We perform an equality check so that inf will match inf, regardless - // of error bounds. If the result of value - expected_ would result in - // overflow or if either value is inf, the default result is infinity, - // which should only match if max_abs_error_ is also infinity. - if (value == expected_) { - return true; - } - - const FloatType diff = value - expected_; - if (::std::fabs(diff) <= max_abs_error_) { - return true; - } - - if (listener->IsInterested()) { - *listener << "which is " << diff << " from " << expected_; - } - return false; - } else { - return actual.AlmostEquals(expected); - } - } - - void DescribeTo(::std::ostream* os) const override { - // os->precision() returns the previously set precision, which we - // store to restore the ostream to its original configuration - // after outputting. - const ::std::streamsize old_precision = - os->precision(::std::numeric_limits<FloatType>::digits10 + 2); - if (FloatingPoint<FloatType>(expected_).is_nan()) { - if (nan_eq_nan_) { - *os << "is NaN"; - } else { - *os << "never matches"; - } - } else { - *os << "is approximately " << expected_; - if (HasMaxAbsError()) { - *os << " (absolute error <= " << max_abs_error_ << ")"; - } - } - os->precision(old_precision); - } - - void DescribeNegationTo(::std::ostream* os) const override { - // As before, get original precision. - const ::std::streamsize old_precision = - os->precision(::std::numeric_limits<FloatType>::digits10 + 2); - if (FloatingPoint<FloatType>(expected_).is_nan()) { - if (nan_eq_nan_) { - *os << "isn't NaN"; - } else { - *os << "is anything"; - } - } else { - *os << "isn't approximately " << expected_; - if (HasMaxAbsError()) { - *os << " (absolute error > " << max_abs_error_ << ")"; - } - } - // Restore original precision. - os->precision(old_precision); - } - - private: - bool HasMaxAbsError() const { return max_abs_error_ >= 0; } - - const FloatType expected_; - const bool nan_eq_nan_; - // max_abs_error will be used for value comparison when >= 0. - const FloatType max_abs_error_; - }; - - // The following 3 type conversion operators allow FloatEq(expected) and - // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a - // Matcher<const float&>, or a Matcher<float&>, but nothing else. - operator Matcher<FloatType>() const { - return MakeMatcher( - new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_)); - } - - operator Matcher<const FloatType&>() const { - return MakeMatcher( - new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_)); - } - - operator Matcher<FloatType&>() const { - return MakeMatcher( - new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_)); - } - - private: - const FloatType expected_; - const bool nan_eq_nan_; - // max_abs_error will be used for value comparison when >= 0. - const FloatType max_abs_error_; -}; - -// A 2-tuple ("binary") wrapper around FloatingEqMatcher: -// FloatingEq2Matcher() matches (x, y) by matching FloatingEqMatcher(x, false) -// against y, and FloatingEq2Matcher(e) matches FloatingEqMatcher(x, false, e) -// against y. The former implements "Eq", the latter "Near". At present, there -// is no version that compares NaNs as equal. -template <typename FloatType> -class FloatingEq2Matcher { - public: - FloatingEq2Matcher() { Init(-1, false); } - - explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); } - - explicit FloatingEq2Matcher(FloatType max_abs_error) { - Init(max_abs_error, false); - } - - FloatingEq2Matcher(FloatType max_abs_error, bool nan_eq_nan) { - Init(max_abs_error, nan_eq_nan); - } - - template <typename T1, typename T2> - operator Matcher<::std::tuple<T1, T2>>() const { - return MakeMatcher( - new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_)); - } - template <typename T1, typename T2> - operator Matcher<const ::std::tuple<T1, T2>&>() const { - return MakeMatcher( - new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_, nan_eq_nan_)); - } - - private: - static ::std::ostream& GetDesc(::std::ostream& os) { // NOLINT - return os << "an almost-equal pair"; - } - - template <typename Tuple> - class Impl : public MatcherInterface<Tuple> { - public: - Impl(FloatType max_abs_error, bool nan_eq_nan) - : max_abs_error_(max_abs_error), nan_eq_nan_(nan_eq_nan) {} - - bool MatchAndExplain(Tuple args, - MatchResultListener* listener) const override { - if (max_abs_error_ == -1) { - FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_); - return static_cast<Matcher<FloatType>>(fm).MatchAndExplain( - ::std::get<1>(args), listener); - } else { - FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_, - max_abs_error_); - return static_cast<Matcher<FloatType>>(fm).MatchAndExplain( - ::std::get<1>(args), listener); - } - } - void DescribeTo(::std::ostream* os) const override { - *os << "are " << GetDesc; - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "aren't " << GetDesc; - } - - private: - FloatType max_abs_error_; - const bool nan_eq_nan_; - }; - - void Init(FloatType max_abs_error_val, bool nan_eq_nan_val) { - max_abs_error_ = max_abs_error_val; - nan_eq_nan_ = nan_eq_nan_val; - } - FloatType max_abs_error_; - bool nan_eq_nan_; -}; - -// Implements the Pointee(m) matcher for matching a pointer whose -// pointee matches matcher m. The pointer can be either raw or smart. -template <typename InnerMatcher> -class PointeeMatcher { - public: - explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {} - - // This type conversion operator template allows Pointee(m) to be - // used as a matcher for any pointer type whose pointee type is - // compatible with the inner matcher, where type Pointer can be - // either a raw pointer or a smart pointer. - // - // The reason we do this instead of relying on - // MakePolymorphicMatcher() is that the latter is not flexible - // enough for implementing the DescribeTo() method of Pointee(). - template <typename Pointer> - operator Matcher<Pointer>() const { - return Matcher<Pointer>(new Impl<const Pointer&>(matcher_)); - } - - private: - // The monomorphic implementation that works for a particular pointer type. - template <typename Pointer> - class Impl : public MatcherInterface<Pointer> { - public: - using Pointee = - typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_( - Pointer)>::element_type; - - explicit Impl(const InnerMatcher& matcher) - : matcher_(MatcherCast<const Pointee&>(matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "points to a value that "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "does not point to a value that "; - matcher_.DescribeTo(os); - } - - bool MatchAndExplain(Pointer pointer, - MatchResultListener* listener) const override { - if (GetRawPointer(pointer) == nullptr) return false; - - *listener << "which points to "; - return MatchPrintAndExplain(*pointer, matcher_, listener); - } - - private: - const Matcher<const Pointee&> matcher_; - }; - - const InnerMatcher matcher_; -}; - -// Implements the Pointer(m) matcher -// Implements the Pointer(m) matcher for matching a pointer that matches matcher -// m. The pointer can be either raw or smart, and will match `m` against the -// raw pointer. -template <typename InnerMatcher> -class PointerMatcher { - public: - explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {} - - // This type conversion operator template allows Pointer(m) to be - // used as a matcher for any pointer type whose pointer type is - // compatible with the inner matcher, where type PointerType can be - // either a raw pointer or a smart pointer. - // - // The reason we do this instead of relying on - // MakePolymorphicMatcher() is that the latter is not flexible - // enough for implementing the DescribeTo() method of Pointer(). - template <typename PointerType> - operator Matcher<PointerType>() const { // NOLINT - return Matcher<PointerType>(new Impl<const PointerType&>(matcher_)); - } - - private: - // The monomorphic implementation that works for a particular pointer type. - template <typename PointerType> - class Impl : public MatcherInterface<PointerType> { - public: - using Pointer = - const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_( - PointerType)>::element_type*; - - explicit Impl(const InnerMatcher& matcher) - : matcher_(MatcherCast<Pointer>(matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "is a pointer that "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "is not a pointer that "; - matcher_.DescribeTo(os); - } - - bool MatchAndExplain(PointerType pointer, - MatchResultListener* listener) const override { - *listener << "which is a pointer that "; - Pointer p = GetRawPointer(pointer); - return MatchPrintAndExplain(p, matcher_, listener); - } - - private: - Matcher<Pointer> matcher_; - }; - - const InnerMatcher matcher_; -}; - -#if GTEST_HAS_RTTI -// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or -// reference that matches inner_matcher when dynamic_cast<T> is applied. -// The result of dynamic_cast<To> is forwarded to the inner matcher. -// If To is a pointer and the cast fails, the inner matcher will receive NULL. -// If To is a reference and the cast fails, this matcher returns false -// immediately. -template <typename To> -class WhenDynamicCastToMatcherBase { - public: - explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher) - : matcher_(matcher) {} - - void DescribeTo(::std::ostream* os) const { - GetCastTypeDescription(os); - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const { - GetCastTypeDescription(os); - matcher_.DescribeNegationTo(os); - } - - protected: - const Matcher<To> matcher_; - - static std::string GetToName() { return GetTypeName<To>(); } - - private: - static void GetCastTypeDescription(::std::ostream* os) { - *os << "when dynamic_cast to " << GetToName() << ", "; - } -}; - -// Primary template. -// To is a pointer. Cast and forward the result. -template <typename To> -class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> { - public: - explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher) - : WhenDynamicCastToMatcherBase<To>(matcher) {} - - template <typename From> - bool MatchAndExplain(From from, MatchResultListener* listener) const { - To to = dynamic_cast<To>(from); - return MatchPrintAndExplain(to, this->matcher_, listener); - } -}; - -// Specialize for references. -// In this case we return false if the dynamic_cast fails. -template <typename To> -class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> { - public: - explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher) - : WhenDynamicCastToMatcherBase<To&>(matcher) {} - - template <typename From> - bool MatchAndExplain(From& from, MatchResultListener* listener) const { - // We don't want an std::bad_cast here, so do the cast with pointers. - To* to = dynamic_cast<To*>(&from); - if (to == nullptr) { - *listener << "which cannot be dynamic_cast to " << this->GetToName(); - return false; - } - return MatchPrintAndExplain(*to, this->matcher_, listener); - } -}; -#endif // GTEST_HAS_RTTI - -// Implements the Field() matcher for matching a field (i.e. member -// variable) of an object. -template <typename Class, typename FieldType> -class FieldMatcher { - public: - FieldMatcher(FieldType Class::*field, - const Matcher<const FieldType&>& matcher) - : field_(field), matcher_(matcher), whose_field_("whose given field ") {} - - FieldMatcher(const std::string& field_name, FieldType Class::*field, - const Matcher<const FieldType&>& matcher) - : field_(field), - matcher_(matcher), - whose_field_("whose field `" + field_name + "` ") {} - - void DescribeTo(::std::ostream* os) const { - *os << "is an object " << whose_field_; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "is an object " << whose_field_; - matcher_.DescribeNegationTo(os); - } - - template <typename T> - bool MatchAndExplain(const T& value, MatchResultListener* listener) const { - // FIXME: The dispatch on std::is_pointer was introduced as a workaround for - // a compiler bug, and can now be removed. - return MatchAndExplainImpl( - typename std::is_pointer<typename std::remove_const<T>::type>::type(), - value, listener); - } - - private: - bool MatchAndExplainImpl(std::false_type /* is_not_pointer */, - const Class& obj, - MatchResultListener* listener) const { - *listener << whose_field_ << "is "; - return MatchPrintAndExplain(obj.*field_, matcher_, listener); - } - - bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p, - MatchResultListener* listener) const { - if (p == nullptr) return false; - - *listener << "which points to an object "; - // Since *p has a field, it must be a class/struct/union type and - // thus cannot be a pointer. Therefore we pass false_type() as - // the first argument. - return MatchAndExplainImpl(std::false_type(), *p, listener); - } - - const FieldType Class::*field_; - const Matcher<const FieldType&> matcher_; - - // Contains either "whose given field " if the name of the field is unknown - // or "whose field `name_of_field` " if the name is known. - const std::string whose_field_; -}; - -// Implements the Property() matcher for matching a property -// (i.e. return value of a getter method) of an object. -// -// Property is a const-qualified member function of Class returning -// PropertyType. -template <typename Class, typename PropertyType, typename Property> -class PropertyMatcher { - public: - typedef const PropertyType& RefToConstProperty; - - PropertyMatcher(Property property, const Matcher<RefToConstProperty>& matcher) - : property_(property), - matcher_(matcher), - whose_property_("whose given property ") {} - - PropertyMatcher(const std::string& property_name, Property property, - const Matcher<RefToConstProperty>& matcher) - : property_(property), - matcher_(matcher), - whose_property_("whose property `" + property_name + "` ") {} - - void DescribeTo(::std::ostream* os) const { - *os << "is an object " << whose_property_; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "is an object " << whose_property_; - matcher_.DescribeNegationTo(os); - } - - template <typename T> - bool MatchAndExplain(const T& value, MatchResultListener* listener) const { - return MatchAndExplainImpl( - typename std::is_pointer<typename std::remove_const<T>::type>::type(), - value, listener); - } - - private: - bool MatchAndExplainImpl(std::false_type /* is_not_pointer */, - const Class& obj, - MatchResultListener* listener) const { - *listener << whose_property_ << "is "; - // Cannot pass the return value (for example, int) to MatchPrintAndExplain, - // which takes a non-const reference as argument. - RefToConstProperty result = (obj.*property_)(); - return MatchPrintAndExplain(result, matcher_, listener); - } - - bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p, - MatchResultListener* listener) const { - if (p == nullptr) return false; - - *listener << "which points to an object "; - // Since *p has a property method, it must be a class/struct/union - // type and thus cannot be a pointer. Therefore we pass - // false_type() as the first argument. - return MatchAndExplainImpl(std::false_type(), *p, listener); - } - - Property property_; - const Matcher<RefToConstProperty> matcher_; - - // Contains either "whose given property " if the name of the property is - // unknown or "whose property `name_of_property` " if the name is known. - const std::string whose_property_; -}; - -// Type traits specifying various features of different functors for ResultOf. -// The default template specifies features for functor objects. -template <typename Functor> -struct CallableTraits { - typedef Functor StorageType; - - static void CheckIsValid(Functor /* functor */) {} - - template <typename T> - static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) { - return f(arg); - } -}; - -// Specialization for function pointers. -template <typename ArgType, typename ResType> -struct CallableTraits<ResType (*)(ArgType)> { - typedef ResType ResultType; - typedef ResType (*StorageType)(ArgType); - - static void CheckIsValid(ResType (*f)(ArgType)) { - GTEST_CHECK_(f != nullptr) - << "NULL function pointer is passed into ResultOf()."; - } - template <typename T> - static ResType Invoke(ResType (*f)(ArgType), T arg) { - return (*f)(arg); - } -}; - -// Implements the ResultOf() matcher for matching a return value of a -// unary function of an object. -template <typename Callable, typename InnerMatcher> -class ResultOfMatcher { - public: - ResultOfMatcher(Callable callable, InnerMatcher matcher) - : ResultOfMatcher(/*result_description=*/"", std::move(callable), - std::move(matcher)) {} - - ResultOfMatcher(const std::string& result_description, Callable callable, - InnerMatcher matcher) - : result_description_(result_description), - callable_(std::move(callable)), - matcher_(std::move(matcher)) { - CallableTraits<Callable>::CheckIsValid(callable_); - } - - template <typename T> - operator Matcher<T>() const { - return Matcher<T>( - new Impl<const T&>(result_description_, callable_, matcher_)); - } - - private: - typedef typename CallableTraits<Callable>::StorageType CallableStorageType; - - template <typename T> - class Impl : public MatcherInterface<T> { - using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>( - std::declval<CallableStorageType>(), std::declval<T>())); - - public: - template <typename M> - Impl(const std::string& result_description, - const CallableStorageType& callable, const M& matcher) - : result_description_(result_description), - callable_(callable), - matcher_(MatcherCast<ResultType>(matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - if (result_description_.empty()) { - *os << "is mapped by the given callable to a value that "; - } else { - *os << "whose " << result_description_ << " "; - } - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - if (result_description_.empty()) { - *os << "is mapped by the given callable to a value that "; - } else { - *os << "whose " << result_description_ << " "; - } - matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(T obj, MatchResultListener* listener) const override { - if (result_description_.empty()) { - *listener << "which is mapped by the given callable to "; - } else { - *listener << "whose " << result_description_ << " is "; - } - // Cannot pass the return value directly to MatchPrintAndExplain, which - // takes a non-const reference as argument. - // Also, specifying template argument explicitly is needed because T could - // be a non-const reference (e.g. Matcher<Uncopyable&>). - ResultType result = - CallableTraits<Callable>::template Invoke<T>(callable_, obj); - return MatchPrintAndExplain(result, matcher_, listener); - } - - private: - const std::string result_description_; - // Functors often define operator() as non-const method even though - // they are actually stateless. But we need to use them even when - // 'this' is a const pointer. It's the user's responsibility not to - // use stateful callables with ResultOf(), which doesn't guarantee - // how many times the callable will be invoked. - mutable CallableStorageType callable_; - const Matcher<ResultType> matcher_; - }; // class Impl - - const std::string result_description_; - const CallableStorageType callable_; - const InnerMatcher matcher_; -}; - -// Implements a matcher that checks the size of an STL-style container. -template <typename SizeMatcher> -class SizeIsMatcher { - public: - explicit SizeIsMatcher(const SizeMatcher& size_matcher) - : size_matcher_(size_matcher) {} - - template <typename Container> - operator Matcher<Container>() const { - return Matcher<Container>(new Impl<const Container&>(size_matcher_)); - } - - template <typename Container> - class Impl : public MatcherInterface<Container> { - public: - using SizeType = decltype(std::declval<Container>().size()); - explicit Impl(const SizeMatcher& size_matcher) - : size_matcher_(MatcherCast<SizeType>(size_matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "size "; - size_matcher_.DescribeTo(os); - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "size "; - size_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - SizeType size = container.size(); - StringMatchResultListener size_listener; - const bool result = size_matcher_.MatchAndExplain(size, &size_listener); - *listener << "whose size " << size - << (result ? " matches" : " doesn't match"); - PrintIfNotEmpty(size_listener.str(), listener->stream()); - return result; - } - - private: - const Matcher<SizeType> size_matcher_; - }; - - private: - const SizeMatcher size_matcher_; -}; - -// Implements a matcher that checks the begin()..end() distance of an STL-style -// container. -template <typename DistanceMatcher> -class BeginEndDistanceIsMatcher { - public: - explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher) - : distance_matcher_(distance_matcher) {} - - template <typename Container> - operator Matcher<Container>() const { - return Matcher<Container>(new Impl<const Container&>(distance_matcher_)); - } - - template <typename Container> - class Impl : public MatcherInterface<Container> { - public: - typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_( - Container)> - ContainerView; - typedef typename std::iterator_traits< - typename ContainerView::type::const_iterator>::difference_type - DistanceType; - explicit Impl(const DistanceMatcher& distance_matcher) - : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "distance between begin() and end() "; - distance_matcher_.DescribeTo(os); - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "distance between begin() and end() "; - distance_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - using std::begin; - using std::end; - DistanceType distance = std::distance(begin(container), end(container)); - StringMatchResultListener distance_listener; - const bool result = - distance_matcher_.MatchAndExplain(distance, &distance_listener); - *listener << "whose distance between begin() and end() " << distance - << (result ? " matches" : " doesn't match"); - PrintIfNotEmpty(distance_listener.str(), listener->stream()); - return result; - } - - private: - const Matcher<DistanceType> distance_matcher_; - }; - - private: - const DistanceMatcher distance_matcher_; -}; - -// Implements an equality matcher for any STL-style container whose elements -// support ==. This matcher is like Eq(), but its failure explanations provide -// more detailed information that is useful when the container is used as a set. -// The failure message reports elements that are in one of the operands but not -// the other. The failure messages do not report duplicate or out-of-order -// elements in the containers (which don't properly matter to sets, but can -// occur if the containers are vectors or lists, for example). -// -// Uses the container's const_iterator, value_type, operator ==, -// begin(), and end(). -template <typename Container> -class ContainerEqMatcher { - public: - typedef internal::StlContainerView<Container> View; - typedef typename View::type StlContainer; - typedef typename View::const_reference StlContainerReference; - - static_assert(!std::is_const<Container>::value, - "Container type must not be const"); - static_assert(!std::is_reference<Container>::value, - "Container type must not be a reference"); - - // We make a copy of expected in case the elements in it are modified - // after this matcher is created. - explicit ContainerEqMatcher(const Container& expected) - : expected_(View::Copy(expected)) {} - - void DescribeTo(::std::ostream* os) const { - *os << "equals "; - UniversalPrint(expected_, os); - } - void DescribeNegationTo(::std::ostream* os) const { - *os << "does not equal "; - UniversalPrint(expected_, os); - } - - template <typename LhsContainer> - bool MatchAndExplain(const LhsContainer& lhs, - MatchResultListener* listener) const { - typedef internal::StlContainerView< - typename std::remove_const<LhsContainer>::type> - LhsView; - StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs); - if (lhs_stl_container == expected_) return true; - - ::std::ostream* const os = listener->stream(); - if (os != nullptr) { - // Something is different. Check for extra values first. - bool printed_header = false; - for (auto it = lhs_stl_container.begin(); it != lhs_stl_container.end(); - ++it) { - if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) == - expected_.end()) { - if (printed_header) { - *os << ", "; - } else { - *os << "which has these unexpected elements: "; - printed_header = true; - } - UniversalPrint(*it, os); - } - } - - // Now check for missing values. - bool printed_header2 = false; - for (auto it = expected_.begin(); it != expected_.end(); ++it) { - if (internal::ArrayAwareFind(lhs_stl_container.begin(), - lhs_stl_container.end(), - *it) == lhs_stl_container.end()) { - if (printed_header2) { - *os << ", "; - } else { - *os << (printed_header ? ",\nand" : "which") - << " doesn't have these expected elements: "; - printed_header2 = true; - } - UniversalPrint(*it, os); - } - } - } - - return false; - } - - private: - const StlContainer expected_; -}; - -// A comparator functor that uses the < operator to compare two values. -struct LessComparator { - template <typename T, typename U> - bool operator()(const T& lhs, const U& rhs) const { - return lhs < rhs; - } -}; - -// Implements WhenSortedBy(comparator, container_matcher). -template <typename Comparator, typename ContainerMatcher> -class WhenSortedByMatcher { - public: - WhenSortedByMatcher(const Comparator& comparator, - const ContainerMatcher& matcher) - : comparator_(comparator), matcher_(matcher) {} - - template <typename LhsContainer> - operator Matcher<LhsContainer>() const { - return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_)); - } - - template <typename LhsContainer> - class Impl : public MatcherInterface<LhsContainer> { - public: - typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_( - LhsContainer)> - LhsView; - typedef typename LhsView::type LhsStlContainer; - typedef typename LhsView::const_reference LhsStlContainerReference; - // Transforms std::pair<const Key, Value> into std::pair<Key, Value> - // so that we can match associative containers. - typedef - typename RemoveConstFromKey<typename LhsStlContainer::value_type>::type - LhsValue; - - Impl(const Comparator& comparator, const ContainerMatcher& matcher) - : comparator_(comparator), matcher_(matcher) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "(when sorted) "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "(when sorted) "; - matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(LhsContainer lhs, - MatchResultListener* listener) const override { - LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs); - ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(), - lhs_stl_container.end()); - ::std::sort(sorted_container.begin(), sorted_container.end(), - comparator_); - - if (!listener->IsInterested()) { - // If the listener is not interested, we do not need to - // construct the inner explanation. - return matcher_.Matches(sorted_container); - } - - *listener << "which is "; - UniversalPrint(sorted_container, listener->stream()); - *listener << " when sorted"; - - StringMatchResultListener inner_listener; - const bool match = - matcher_.MatchAndExplain(sorted_container, &inner_listener); - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - return match; - } - - private: - const Comparator comparator_; - const Matcher<const ::std::vector<LhsValue>&> matcher_; - - Impl(const Impl&) = delete; - Impl& operator=(const Impl&) = delete; - }; - - private: - const Comparator comparator_; - const ContainerMatcher matcher_; -}; - -// Implements Pointwise(tuple_matcher, rhs_container). tuple_matcher -// must be able to be safely cast to Matcher<std::tuple<const T1&, const -// T2&> >, where T1 and T2 are the types of elements in the LHS -// container and the RHS container respectively. -template <typename TupleMatcher, typename RhsContainer> -class PointwiseMatcher { - static_assert( - !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value, - "use UnorderedPointwise with hash tables"); - - public: - typedef internal::StlContainerView<RhsContainer> RhsView; - typedef typename RhsView::type RhsStlContainer; - typedef typename RhsStlContainer::value_type RhsValue; - - static_assert(!std::is_const<RhsContainer>::value, - "RhsContainer type must not be const"); - static_assert(!std::is_reference<RhsContainer>::value, - "RhsContainer type must not be a reference"); - - // Like ContainerEq, we make a copy of rhs in case the elements in - // it are modified after this matcher is created. - PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs) - : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {} - - template <typename LhsContainer> - operator Matcher<LhsContainer>() const { - static_assert( - !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value, - "use UnorderedPointwise with hash tables"); - - return Matcher<LhsContainer>( - new Impl<const LhsContainer&>(tuple_matcher_, rhs_)); - } - - template <typename LhsContainer> - class Impl : public MatcherInterface<LhsContainer> { - public: - typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_( - LhsContainer)> - LhsView; - typedef typename LhsView::type LhsStlContainer; - typedef typename LhsView::const_reference LhsStlContainerReference; - typedef typename LhsStlContainer::value_type LhsValue; - // We pass the LHS value and the RHS value to the inner matcher by - // reference, as they may be expensive to copy. We must use tuple - // instead of pair here, as a pair cannot hold references (C++ 98, - // 20.2.2 [lib.pairs]). - typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg; - - Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs) - // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher. - : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)), - rhs_(rhs) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "contains " << rhs_.size() - << " values, where each value and its corresponding value in "; - UniversalPrinter<RhsStlContainer>::Print(rhs_, os); - *os << " "; - mono_tuple_matcher_.DescribeTo(os); - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "doesn't contain exactly " << rhs_.size() - << " values, or contains a value x at some index i" - << " where x and the i-th value of "; - UniversalPrint(rhs_, os); - *os << " "; - mono_tuple_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(LhsContainer lhs, - MatchResultListener* listener) const override { - LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs); - const size_t actual_size = lhs_stl_container.size(); - if (actual_size != rhs_.size()) { - *listener << "which contains " << actual_size << " values"; - return false; - } - - auto left = lhs_stl_container.begin(); - auto right = rhs_.begin(); - for (size_t i = 0; i != actual_size; ++i, ++left, ++right) { - if (listener->IsInterested()) { - StringMatchResultListener inner_listener; - // Create InnerMatcherArg as a temporarily object to avoid it outlives - // *left and *right. Dereference or the conversion to `const T&` may - // return temp objects, e.g. for vector<bool>. - if (!mono_tuple_matcher_.MatchAndExplain( - InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left), - ImplicitCast_<const RhsValue&>(*right)), - &inner_listener)) { - *listener << "where the value pair ("; - UniversalPrint(*left, listener->stream()); - *listener << ", "; - UniversalPrint(*right, listener->stream()); - *listener << ") at index #" << i << " don't match"; - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - return false; - } - } else { - if (!mono_tuple_matcher_.Matches( - InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left), - ImplicitCast_<const RhsValue&>(*right)))) - return false; - } - } - - return true; - } - - private: - const Matcher<InnerMatcherArg> mono_tuple_matcher_; - const RhsStlContainer rhs_; - }; - - private: - const TupleMatcher tuple_matcher_; - const RhsStlContainer rhs_; -}; - -// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl. -template <typename Container> -class QuantifierMatcherImpl : public MatcherInterface<Container> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef StlContainerView<RawContainer> View; - typedef typename View::type StlContainer; - typedef typename View::const_reference StlContainerReference; - typedef typename StlContainer::value_type Element; - - template <typename InnerMatcher> - explicit QuantifierMatcherImpl(InnerMatcher inner_matcher) - : inner_matcher_( - testing::SafeMatcherCast<const Element&>(inner_matcher)) {} - - // Checks whether: - // * All elements in the container match, if all_elements_should_match. - // * Any element in the container matches, if !all_elements_should_match. - bool MatchAndExplainImpl(bool all_elements_should_match, Container container, - MatchResultListener* listener) const { - StlContainerReference stl_container = View::ConstReference(container); - size_t i = 0; - for (auto it = stl_container.begin(); it != stl_container.end(); - ++it, ++i) { - StringMatchResultListener inner_listener; - const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener); - - if (matches != all_elements_should_match) { - *listener << "whose element #" << i - << (matches ? " matches" : " doesn't match"); - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - return !all_elements_should_match; - } - } - return all_elements_should_match; - } - - bool MatchAndExplainImpl(const Matcher<size_t>& count_matcher, - Container container, - MatchResultListener* listener) const { - StlContainerReference stl_container = View::ConstReference(container); - size_t i = 0; - std::vector<size_t> match_elements; - for (auto it = stl_container.begin(); it != stl_container.end(); - ++it, ++i) { - StringMatchResultListener inner_listener; - const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener); - if (matches) { - match_elements.push_back(i); - } - } - if (listener->IsInterested()) { - if (match_elements.empty()) { - *listener << "has no element that matches"; - } else if (match_elements.size() == 1) { - *listener << "whose element #" << match_elements[0] << " matches"; - } else { - *listener << "whose elements ("; - std::string sep = ""; - for (size_t e : match_elements) { - *listener << sep << e; - sep = ", "; - } - *listener << ") match"; - } - } - StringMatchResultListener count_listener; - if (count_matcher.MatchAndExplain(match_elements.size(), &count_listener)) { - *listener << " and whose match quantity of " << match_elements.size() - << " matches"; - PrintIfNotEmpty(count_listener.str(), listener->stream()); - return true; - } else { - if (match_elements.empty()) { - *listener << " and"; - } else { - *listener << " but"; - } - *listener << " whose match quantity of " << match_elements.size() - << " does not match"; - PrintIfNotEmpty(count_listener.str(), listener->stream()); - return false; - } - } - - protected: - const Matcher<const Element&> inner_matcher_; -}; - -// Implements Contains(element_matcher) for the given argument type Container. -// Symmetric to EachMatcherImpl. -template <typename Container> -class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> { - public: - template <typename InnerMatcher> - explicit ContainsMatcherImpl(InnerMatcher inner_matcher) - : QuantifierMatcherImpl<Container>(inner_matcher) {} - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - *os << "contains at least one element that "; - this->inner_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "doesn't contain any element that "; - this->inner_matcher_.DescribeTo(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - return this->MatchAndExplainImpl(false, container, listener); - } -}; - -// Implements Each(element_matcher) for the given argument type Container. -// Symmetric to ContainsMatcherImpl. -template <typename Container> -class EachMatcherImpl : public QuantifierMatcherImpl<Container> { - public: - template <typename InnerMatcher> - explicit EachMatcherImpl(InnerMatcher inner_matcher) - : QuantifierMatcherImpl<Container>(inner_matcher) {} - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - *os << "only contains elements that "; - this->inner_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "contains some element that "; - this->inner_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - return this->MatchAndExplainImpl(true, container, listener); - } -}; - -// Implements Contains(element_matcher).Times(n) for the given argument type -// Container. -template <typename Container> -class ContainsTimesMatcherImpl : public QuantifierMatcherImpl<Container> { - public: - template <typename InnerMatcher> - explicit ContainsTimesMatcherImpl(InnerMatcher inner_matcher, - Matcher<size_t> count_matcher) - : QuantifierMatcherImpl<Container>(inner_matcher), - count_matcher_(std::move(count_matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "quantity of elements that match "; - this->inner_matcher_.DescribeTo(os); - *os << " "; - count_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "quantity of elements that match "; - this->inner_matcher_.DescribeTo(os); - *os << " "; - count_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - return this->MatchAndExplainImpl(count_matcher_, container, listener); - } - - private: - const Matcher<size_t> count_matcher_; -}; - -// Implements polymorphic Contains(element_matcher).Times(n). -template <typename M> -class ContainsTimesMatcher { - public: - explicit ContainsTimesMatcher(M m, Matcher<size_t> count_matcher) - : inner_matcher_(m), count_matcher_(std::move(count_matcher)) {} - - template <typename Container> - operator Matcher<Container>() const { // NOLINT - return Matcher<Container>(new ContainsTimesMatcherImpl<const Container&>( - inner_matcher_, count_matcher_)); - } - - private: - const M inner_matcher_; - const Matcher<size_t> count_matcher_; -}; - -// Implements polymorphic Contains(element_matcher). -template <typename M> -class ContainsMatcher { - public: - explicit ContainsMatcher(M m) : inner_matcher_(m) {} - - template <typename Container> - operator Matcher<Container>() const { // NOLINT - return Matcher<Container>( - new ContainsMatcherImpl<const Container&>(inner_matcher_)); - } - - ContainsTimesMatcher<M> Times(Matcher<size_t> count_matcher) const { - return ContainsTimesMatcher<M>(inner_matcher_, std::move(count_matcher)); - } - - private: - const M inner_matcher_; -}; - -// Implements polymorphic Each(element_matcher). -template <typename M> -class EachMatcher { - public: - explicit EachMatcher(M m) : inner_matcher_(m) {} - - template <typename Container> - operator Matcher<Container>() const { // NOLINT - return Matcher<Container>( - new EachMatcherImpl<const Container&>(inner_matcher_)); - } - - private: - const M inner_matcher_; -}; - -struct Rank1 {}; -struct Rank0 : Rank1 {}; - -namespace pair_getters { -using std::get; -template <typename T> -auto First(T& x, Rank1) -> decltype(get<0>(x)) { // NOLINT - return get<0>(x); -} -template <typename T> -auto First(T& x, Rank0) -> decltype((x.first)) { // NOLINT - return x.first; -} - -template <typename T> -auto Second(T& x, Rank1) -> decltype(get<1>(x)) { // NOLINT - return get<1>(x); -} -template <typename T> -auto Second(T& x, Rank0) -> decltype((x.second)) { // NOLINT - return x.second; -} -} // namespace pair_getters - -// Implements Key(inner_matcher) for the given argument pair type. -// Key(inner_matcher) matches an std::pair whose 'first' field matches -// inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an -// std::map that contains at least one element whose key is >= 5. -template <typename PairType> -class KeyMatcherImpl : public MatcherInterface<PairType> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType; - typedef typename RawPairType::first_type KeyType; - - template <typename InnerMatcher> - explicit KeyMatcherImpl(InnerMatcher inner_matcher) - : inner_matcher_( - testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {} - - // Returns true if and only if 'key_value.first' (the key) matches the inner - // matcher. - bool MatchAndExplain(PairType key_value, - MatchResultListener* listener) const override { - StringMatchResultListener inner_listener; - const bool match = inner_matcher_.MatchAndExplain( - pair_getters::First(key_value, Rank0()), &inner_listener); - const std::string explanation = inner_listener.str(); - if (explanation != "") { - *listener << "whose first field is a value " << explanation; - } - return match; - } - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - *os << "has a key that "; - inner_matcher_.DescribeTo(os); - } - - // Describes what the negation of this matcher does. - void DescribeNegationTo(::std::ostream* os) const override { - *os << "doesn't have a key that "; - inner_matcher_.DescribeTo(os); - } - - private: - const Matcher<const KeyType&> inner_matcher_; -}; - -// Implements polymorphic Key(matcher_for_key). -template <typename M> -class KeyMatcher { - public: - explicit KeyMatcher(M m) : matcher_for_key_(m) {} - - template <typename PairType> - operator Matcher<PairType>() const { - return Matcher<PairType>( - new KeyMatcherImpl<const PairType&>(matcher_for_key_)); - } - - private: - const M matcher_for_key_; -}; - -// Implements polymorphic Address(matcher_for_address). -template <typename InnerMatcher> -class AddressMatcher { - public: - explicit AddressMatcher(InnerMatcher m) : matcher_(m) {} - - template <typename Type> - operator Matcher<Type>() const { // NOLINT - return Matcher<Type>(new Impl<const Type&>(matcher_)); - } - - private: - // The monomorphic implementation that works for a particular object type. - template <typename Type> - class Impl : public MatcherInterface<Type> { - public: - using Address = const GTEST_REMOVE_REFERENCE_AND_CONST_(Type) *; - explicit Impl(const InnerMatcher& matcher) - : matcher_(MatcherCast<Address>(matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "has address that "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "does not have address that "; - matcher_.DescribeTo(os); - } - - bool MatchAndExplain(Type object, - MatchResultListener* listener) const override { - *listener << "which has address "; - Address address = std::addressof(object); - return MatchPrintAndExplain(address, matcher_, listener); - } - - private: - const Matcher<Address> matcher_; - }; - const InnerMatcher matcher_; -}; - -// Implements Pair(first_matcher, second_matcher) for the given argument pair -// type with its two matchers. See Pair() function below. -template <typename PairType> -class PairMatcherImpl : public MatcherInterface<PairType> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType; - typedef typename RawPairType::first_type FirstType; - typedef typename RawPairType::second_type SecondType; - - template <typename FirstMatcher, typename SecondMatcher> - PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher) - : first_matcher_( - testing::SafeMatcherCast<const FirstType&>(first_matcher)), - second_matcher_( - testing::SafeMatcherCast<const SecondType&>(second_matcher)) {} - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - *os << "has a first field that "; - first_matcher_.DescribeTo(os); - *os << ", and has a second field that "; - second_matcher_.DescribeTo(os); - } - - // Describes what the negation of this matcher does. - void DescribeNegationTo(::std::ostream* os) const override { - *os << "has a first field that "; - first_matcher_.DescribeNegationTo(os); - *os << ", or has a second field that "; - second_matcher_.DescribeNegationTo(os); - } - - // Returns true if and only if 'a_pair.first' matches first_matcher and - // 'a_pair.second' matches second_matcher. - bool MatchAndExplain(PairType a_pair, - MatchResultListener* listener) const override { - if (!listener->IsInterested()) { - // If the listener is not interested, we don't need to construct the - // explanation. - return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) && - second_matcher_.Matches(pair_getters::Second(a_pair, Rank0())); - } - StringMatchResultListener first_inner_listener; - if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()), - &first_inner_listener)) { - *listener << "whose first field does not match"; - PrintIfNotEmpty(first_inner_listener.str(), listener->stream()); - return false; - } - StringMatchResultListener second_inner_listener; - if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()), - &second_inner_listener)) { - *listener << "whose second field does not match"; - PrintIfNotEmpty(second_inner_listener.str(), listener->stream()); - return false; - } - ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(), - listener); - return true; - } - - private: - void ExplainSuccess(const std::string& first_explanation, - const std::string& second_explanation, - MatchResultListener* listener) const { - *listener << "whose both fields match"; - if (first_explanation != "") { - *listener << ", where the first field is a value " << first_explanation; - } - if (second_explanation != "") { - *listener << ", "; - if (first_explanation != "") { - *listener << "and "; - } else { - *listener << "where "; - } - *listener << "the second field is a value " << second_explanation; - } - } - - const Matcher<const FirstType&> first_matcher_; - const Matcher<const SecondType&> second_matcher_; -}; - -// Implements polymorphic Pair(first_matcher, second_matcher). -template <typename FirstMatcher, typename SecondMatcher> -class PairMatcher { - public: - PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher) - : first_matcher_(first_matcher), second_matcher_(second_matcher) {} - - template <typename PairType> - operator Matcher<PairType>() const { - return Matcher<PairType>( - new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_)); - } - - private: - const FirstMatcher first_matcher_; - const SecondMatcher second_matcher_; -}; - -template <typename T, size_t... I> -auto UnpackStructImpl(const T& t, IndexSequence<I...>, int) - -> decltype(std::tie(get<I>(t)...)) { - static_assert(std::tuple_size<T>::value == sizeof...(I), - "Number of arguments doesn't match the number of fields."); - return std::tie(get<I>(t)...); -} - -#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606 -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) { - const auto& [a] = t; - return std::tie(a); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) { - const auto& [a, b] = t; - return std::tie(a, b); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) { - const auto& [a, b, c] = t; - return std::tie(a, b, c); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) { - const auto& [a, b, c, d] = t; - return std::tie(a, b, c, d); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) { - const auto& [a, b, c, d, e] = t; - return std::tie(a, b, c, d, e); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) { - const auto& [a, b, c, d, e, f] = t; - return std::tie(a, b, c, d, e, f); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) { - const auto& [a, b, c, d, e, f, g] = t; - return std::tie(a, b, c, d, e, f, g); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) { - const auto& [a, b, c, d, e, f, g, h] = t; - return std::tie(a, b, c, d, e, f, g, h); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) { - const auto& [a, b, c, d, e, f, g, h, i] = t; - return std::tie(a, b, c, d, e, f, g, h, i); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p); -} -#endif // defined(__cpp_structured_bindings) - -template <size_t I, typename T> -auto UnpackStruct(const T& t) - -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) { - return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0); -} - -// Helper function to do comma folding in C++11. -// The array ensures left-to-right order of evaluation. -// Usage: VariadicExpand({expr...}); -template <typename T, size_t N> -void VariadicExpand(const T (&)[N]) {} - -template <typename Struct, typename StructSize> -class FieldsAreMatcherImpl; - -template <typename Struct, size_t... I> -class FieldsAreMatcherImpl<Struct, IndexSequence<I...>> - : public MatcherInterface<Struct> { - using UnpackedType = - decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>())); - using MatchersType = std::tuple< - Matcher<const typename std::tuple_element<I, UnpackedType>::type&>...>; - - public: - template <typename Inner> - explicit FieldsAreMatcherImpl(const Inner& matchers) - : matchers_(testing::SafeMatcherCast< - const typename std::tuple_element<I, UnpackedType>::type&>( - std::get<I>(matchers))...) {} - - void DescribeTo(::std::ostream* os) const override { - const char* separator = ""; - VariadicExpand( - {(*os << separator << "has field #" << I << " that ", - std::get<I>(matchers_).DescribeTo(os), separator = ", and ")...}); - } - - void DescribeNegationTo(::std::ostream* os) const override { - const char* separator = ""; - VariadicExpand({(*os << separator << "has field #" << I << " that ", - std::get<I>(matchers_).DescribeNegationTo(os), - separator = ", or ")...}); - } - - bool MatchAndExplain(Struct t, MatchResultListener* listener) const override { - return MatchInternal((UnpackStruct<sizeof...(I)>)(t), listener); - } - - private: - bool MatchInternal(UnpackedType tuple, MatchResultListener* listener) const { - if (!listener->IsInterested()) { - // If the listener is not interested, we don't need to construct the - // explanation. - bool good = true; - VariadicExpand({good = good && std::get<I>(matchers_).Matches( - std::get<I>(tuple))...}); - return good; - } - - size_t failed_pos = ~size_t{}; - - std::vector<StringMatchResultListener> inner_listener(sizeof...(I)); - - VariadicExpand( - {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain( - std::get<I>(tuple), &inner_listener[I]) - ? failed_pos = I - : 0 ...}); - if (failed_pos != ~size_t{}) { - *listener << "whose field #" << failed_pos << " does not match"; - PrintIfNotEmpty(inner_listener[failed_pos].str(), listener->stream()); - return false; - } - - *listener << "whose all elements match"; - const char* separator = ", where"; - for (size_t index = 0; index < sizeof...(I); ++index) { - const std::string str = inner_listener[index].str(); - if (!str.empty()) { - *listener << separator << " field #" << index << " is a value " << str; - separator = ", and"; - } - } - - return true; - } - - MatchersType matchers_; -}; - -template <typename... Inner> -class FieldsAreMatcher { - public: - explicit FieldsAreMatcher(Inner... inner) : matchers_(std::move(inner)...) {} - - template <typename Struct> - operator Matcher<Struct>() const { // NOLINT - return Matcher<Struct>( - new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>( - matchers_)); - } - - private: - std::tuple<Inner...> matchers_; -}; - -// Implements ElementsAre() and ElementsAreArray(). -template <typename Container> -class ElementsAreMatcherImpl : public MatcherInterface<Container> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef internal::StlContainerView<RawContainer> View; - typedef typename View::type StlContainer; - typedef typename View::const_reference StlContainerReference; - typedef typename StlContainer::value_type Element; - - // Constructs the matcher from a sequence of element values or - // element matchers. - template <typename InputIter> - ElementsAreMatcherImpl(InputIter first, InputIter last) { - while (first != last) { - matchers_.push_back(MatcherCast<const Element&>(*first++)); - } - } - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - if (count() == 0) { - *os << "is empty"; - } else if (count() == 1) { - *os << "has 1 element that "; - matchers_[0].DescribeTo(os); - } else { - *os << "has " << Elements(count()) << " where\n"; - for (size_t i = 0; i != count(); ++i) { - *os << "element #" << i << " "; - matchers_[i].DescribeTo(os); - if (i + 1 < count()) { - *os << ",\n"; - } - } - } - } - - // Describes what the negation of this matcher does. - void DescribeNegationTo(::std::ostream* os) const override { - if (count() == 0) { - *os << "isn't empty"; - return; - } - - *os << "doesn't have " << Elements(count()) << ", or\n"; - for (size_t i = 0; i != count(); ++i) { - *os << "element #" << i << " "; - matchers_[i].DescribeNegationTo(os); - if (i + 1 < count()) { - *os << ", or\n"; - } - } - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - // To work with stream-like "containers", we must only walk - // through the elements in one pass. - - const bool listener_interested = listener->IsInterested(); - - // explanations[i] is the explanation of the element at index i. - ::std::vector<std::string> explanations(count()); - StlContainerReference stl_container = View::ConstReference(container); - auto it = stl_container.begin(); - size_t exam_pos = 0; - bool mismatch_found = false; // Have we found a mismatched element yet? - - // Go through the elements and matchers in pairs, until we reach - // the end of either the elements or the matchers, or until we find a - // mismatch. - for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) { - bool match; // Does the current element match the current matcher? - if (listener_interested) { - StringMatchResultListener s; - match = matchers_[exam_pos].MatchAndExplain(*it, &s); - explanations[exam_pos] = s.str(); - } else { - match = matchers_[exam_pos].Matches(*it); - } - - if (!match) { - mismatch_found = true; - break; - } - } - // If mismatch_found is true, 'exam_pos' is the index of the mismatch. - - // Find how many elements the actual container has. We avoid - // calling size() s.t. this code works for stream-like "containers" - // that don't define size(). - size_t actual_count = exam_pos; - for (; it != stl_container.end(); ++it) { - ++actual_count; - } - - if (actual_count != count()) { - // The element count doesn't match. If the container is empty, - // there's no need to explain anything as Google Mock already - // prints the empty container. Otherwise we just need to show - // how many elements there actually are. - if (listener_interested && (actual_count != 0)) { - *listener << "which has " << Elements(actual_count); - } - return false; - } - - if (mismatch_found) { - // The element count matches, but the exam_pos-th element doesn't match. - if (listener_interested) { - *listener << "whose element #" << exam_pos << " doesn't match"; - PrintIfNotEmpty(explanations[exam_pos], listener->stream()); - } - return false; - } - - // Every element matches its expectation. We need to explain why - // (the obvious ones can be skipped). - if (listener_interested) { - bool reason_printed = false; - for (size_t i = 0; i != count(); ++i) { - const std::string& s = explanations[i]; - if (!s.empty()) { - if (reason_printed) { - *listener << ",\nand "; - } - *listener << "whose element #" << i << " matches, " << s; - reason_printed = true; - } - } - } - return true; - } - - private: - static Message Elements(size_t count) { - return Message() << count << (count == 1 ? " element" : " elements"); - } - - size_t count() const { return matchers_.size(); } - - ::std::vector<Matcher<const Element&>> matchers_; -}; - -// Connectivity matrix of (elements X matchers), in element-major order. -// Initially, there are no edges. -// Use NextGraph() to iterate over all possible edge configurations. -// Use Randomize() to generate a random edge configuration. -class GTEST_API_ MatchMatrix { - public: - MatchMatrix(size_t num_elements, size_t num_matchers) - : num_elements_(num_elements), - num_matchers_(num_matchers), - matched_(num_elements_ * num_matchers_, 0) {} - - size_t LhsSize() const { return num_elements_; } - size_t RhsSize() const { return num_matchers_; } - bool HasEdge(size_t ilhs, size_t irhs) const { - return matched_[SpaceIndex(ilhs, irhs)] == 1; - } - void SetEdge(size_t ilhs, size_t irhs, bool b) { - matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0; - } - - // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number, - // adds 1 to that number; returns false if incrementing the graph left it - // empty. - bool NextGraph(); - - void Randomize(); - - std::string DebugString() const; - - private: - size_t SpaceIndex(size_t ilhs, size_t irhs) const { - return ilhs * num_matchers_ + irhs; - } - - size_t num_elements_; - size_t num_matchers_; - - // Each element is a char interpreted as bool. They are stored as a - // flattened array in lhs-major order, use 'SpaceIndex()' to translate - // a (ilhs, irhs) matrix coordinate into an offset. - ::std::vector<char> matched_; -}; - -typedef ::std::pair<size_t, size_t> ElementMatcherPair; -typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs; - -// Returns a maximum bipartite matching for the specified graph 'g'. -// The matching is represented as a vector of {element, matcher} pairs. -GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g); - -struct UnorderedMatcherRequire { - enum Flags { - Superset = 1 << 0, - Subset = 1 << 1, - ExactMatch = Superset | Subset, - }; -}; - -// Untyped base class for implementing UnorderedElementsAre. By -// putting logic that's not specific to the element type here, we -// reduce binary bloat and increase compilation speed. -class GTEST_API_ UnorderedElementsAreMatcherImplBase { - protected: - explicit UnorderedElementsAreMatcherImplBase( - UnorderedMatcherRequire::Flags matcher_flags) - : match_flags_(matcher_flags) {} - - // A vector of matcher describers, one for each element matcher. - // Does not own the describers (and thus can be used only when the - // element matchers are alive). - typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec; - - // Describes this UnorderedElementsAre matcher. - void DescribeToImpl(::std::ostream* os) const; - - // Describes the negation of this UnorderedElementsAre matcher. - void DescribeNegationToImpl(::std::ostream* os) const; - - bool VerifyMatchMatrix(const ::std::vector<std::string>& element_printouts, - const MatchMatrix& matrix, - MatchResultListener* listener) const; - - bool FindPairing(const MatchMatrix& matrix, - MatchResultListener* listener) const; - - MatcherDescriberVec& matcher_describers() { return matcher_describers_; } - - static Message Elements(size_t n) { - return Message() << n << " element" << (n == 1 ? "" : "s"); - } - - UnorderedMatcherRequire::Flags match_flags() const { return match_flags_; } - - private: - UnorderedMatcherRequire::Flags match_flags_; - MatcherDescriberVec matcher_describers_; -}; - -// Implements UnorderedElementsAre, UnorderedElementsAreArray, IsSubsetOf, and -// IsSupersetOf. -template <typename Container> -class UnorderedElementsAreMatcherImpl - : public MatcherInterface<Container>, - public UnorderedElementsAreMatcherImplBase { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef internal::StlContainerView<RawContainer> View; - typedef typename View::type StlContainer; - typedef typename View::const_reference StlContainerReference; - typedef typename StlContainer::value_type Element; - - template <typename InputIter> - UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags, - InputIter first, InputIter last) - : UnorderedElementsAreMatcherImplBase(matcher_flags) { - for (; first != last; ++first) { - matchers_.push_back(MatcherCast<const Element&>(*first)); - } - for (const auto& m : matchers_) { - matcher_describers().push_back(m.GetDescriber()); - } - } - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os); - } - - // Describes what the negation of this matcher does. - void DescribeNegationTo(::std::ostream* os) const override { - return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - StlContainerReference stl_container = View::ConstReference(container); - ::std::vector<std::string> element_printouts; - MatchMatrix matrix = - AnalyzeElements(stl_container.begin(), stl_container.end(), - &element_printouts, listener); - - if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) { - return true; - } - - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - if (matrix.LhsSize() != matrix.RhsSize()) { - // The element count doesn't match. If the container is empty, - // there's no need to explain anything as Google Mock already - // prints the empty container. Otherwise we just need to show - // how many elements there actually are. - if (matrix.LhsSize() != 0 && listener->IsInterested()) { - *listener << "which has " << Elements(matrix.LhsSize()); - } - return false; - } - } - - return VerifyMatchMatrix(element_printouts, matrix, listener) && - FindPairing(matrix, listener); - } - - private: - template <typename ElementIter> - MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last, - ::std::vector<std::string>* element_printouts, - MatchResultListener* listener) const { - element_printouts->clear(); - ::std::vector<char> did_match; - size_t num_elements = 0; - DummyMatchResultListener dummy; - for (; elem_first != elem_last; ++num_elements, ++elem_first) { - if (listener->IsInterested()) { - element_printouts->push_back(PrintToString(*elem_first)); - } - for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) { - did_match.push_back( - matchers_[irhs].MatchAndExplain(*elem_first, &dummy)); - } - } - - MatchMatrix matrix(num_elements, matchers_.size()); - ::std::vector<char>::const_iterator did_match_iter = did_match.begin(); - for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) { - for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) { - matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0); - } - } - return matrix; - } - - ::std::vector<Matcher<const Element&>> matchers_; -}; - -// Functor for use in TransformTuple. -// Performs MatcherCast<Target> on an input argument of any type. -template <typename Target> -struct CastAndAppendTransform { - template <typename Arg> - Matcher<Target> operator()(const Arg& a) const { - return MatcherCast<Target>(a); - } -}; - -// Implements UnorderedElementsAre. -template <typename MatcherTuple> -class UnorderedElementsAreMatcher { - public: - explicit UnorderedElementsAreMatcher(const MatcherTuple& args) - : matchers_(args) {} - - template <typename Container> - operator Matcher<Container>() const { - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef typename internal::StlContainerView<RawContainer>::type View; - typedef typename View::value_type Element; - typedef ::std::vector<Matcher<const Element&>> MatcherVec; - MatcherVec matchers; - matchers.reserve(::std::tuple_size<MatcherTuple>::value); - TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_, - ::std::back_inserter(matchers)); - return Matcher<Container>( - new UnorderedElementsAreMatcherImpl<const Container&>( - UnorderedMatcherRequire::ExactMatch, matchers.begin(), - matchers.end())); - } - - private: - const MatcherTuple matchers_; -}; - -// Implements ElementsAre. -template <typename MatcherTuple> -class ElementsAreMatcher { - public: - explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {} - - template <typename Container> - operator Matcher<Container>() const { - static_assert( - !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value || - ::std::tuple_size<MatcherTuple>::value < 2, - "use UnorderedElementsAre with hash tables"); - - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef typename internal::StlContainerView<RawContainer>::type View; - typedef typename View::value_type Element; - typedef ::std::vector<Matcher<const Element&>> MatcherVec; - MatcherVec matchers; - matchers.reserve(::std::tuple_size<MatcherTuple>::value); - TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_, - ::std::back_inserter(matchers)); - return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>( - matchers.begin(), matchers.end())); - } - - private: - const MatcherTuple matchers_; -}; - -// Implements UnorderedElementsAreArray(), IsSubsetOf(), and IsSupersetOf(). -template <typename T> -class UnorderedElementsAreArrayMatcher { - public: - template <typename Iter> - UnorderedElementsAreArrayMatcher(UnorderedMatcherRequire::Flags match_flags, - Iter first, Iter last) - : match_flags_(match_flags), matchers_(first, last) {} - - template <typename Container> - operator Matcher<Container>() const { - return Matcher<Container>( - new UnorderedElementsAreMatcherImpl<const Container&>( - match_flags_, matchers_.begin(), matchers_.end())); - } - - private: - UnorderedMatcherRequire::Flags match_flags_; - ::std::vector<T> matchers_; -}; - -// Implements ElementsAreArray(). -template <typename T> -class ElementsAreArrayMatcher { - public: - template <typename Iter> - ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {} - - template <typename Container> - operator Matcher<Container>() const { - static_assert( - !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value, - "use UnorderedElementsAreArray with hash tables"); - - return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>( - matchers_.begin(), matchers_.end())); - } - - private: - const ::std::vector<T> matchers_; -}; - -// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second -// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm, -// second) is a polymorphic matcher that matches a value x if and only if -// tm matches tuple (x, second). Useful for implementing -// UnorderedPointwise() in terms of UnorderedElementsAreArray(). -// -// BoundSecondMatcher is copyable and assignable, as we need to put -// instances of this class in a vector when implementing -// UnorderedPointwise(). -template <typename Tuple2Matcher, typename Second> -class BoundSecondMatcher { - public: - BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second) - : tuple2_matcher_(tm), second_value_(second) {} - - BoundSecondMatcher(const BoundSecondMatcher& other) = default; - - template <typename T> - operator Matcher<T>() const { - return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_)); - } - - // We have to define this for UnorderedPointwise() to compile in - // C++98 mode, as it puts BoundSecondMatcher instances in a vector, - // which requires the elements to be assignable in C++98. The - // compiler cannot generate the operator= for us, as Tuple2Matcher - // and Second may not be assignable. - // - // However, this should never be called, so the implementation just - // need to assert. - void operator=(const BoundSecondMatcher& /*rhs*/) { - GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned."; - } - - private: - template <typename T> - class Impl : public MatcherInterface<T> { - public: - typedef ::std::tuple<T, Second> ArgTuple; - - Impl(const Tuple2Matcher& tm, const Second& second) - : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)), - second_value_(second) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "and "; - UniversalPrint(second_value_, os); - *os << " "; - mono_tuple2_matcher_.DescribeTo(os); - } - - bool MatchAndExplain(T x, MatchResultListener* listener) const override { - return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_), - listener); - } - - private: - const Matcher<const ArgTuple&> mono_tuple2_matcher_; - const Second second_value_; - }; - - const Tuple2Matcher tuple2_matcher_; - const Second second_value_; -}; - -// Given a 2-tuple matcher tm and a value second, -// MatcherBindSecond(tm, second) returns a matcher that matches a -// value x if and only if tm matches tuple (x, second). Useful for -// implementing UnorderedPointwise() in terms of UnorderedElementsAreArray(). -template <typename Tuple2Matcher, typename Second> -BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond( - const Tuple2Matcher& tm, const Second& second) { - return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second); -} - -// Returns the description for a matcher defined using the MATCHER*() -// macro where the user-supplied description string is "", if -// 'negation' is false; otherwise returns the description of the -// negation of the matcher. 'param_values' contains a list of strings -// that are the print-out of the matcher's parameters. -GTEST_API_ std::string FormatMatcherDescription( - bool negation, const char* matcher_name, - const std::vector<const char*>& param_names, const Strings& param_values); - -// Implements a matcher that checks the value of a optional<> type variable. -template <typename ValueMatcher> -class OptionalMatcher { - public: - explicit OptionalMatcher(const ValueMatcher& value_matcher) - : value_matcher_(value_matcher) {} - - template <typename Optional> - operator Matcher<Optional>() const { - return Matcher<Optional>(new Impl<const Optional&>(value_matcher_)); - } - - template <typename Optional> - class Impl : public MatcherInterface<Optional> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Optional) OptionalView; - typedef typename OptionalView::value_type ValueType; - explicit Impl(const ValueMatcher& value_matcher) - : value_matcher_(MatcherCast<ValueType>(value_matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "value "; - value_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "value "; - value_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(Optional optional, - MatchResultListener* listener) const override { - if (!optional) { - *listener << "which is not engaged"; - return false; - } - const ValueType& value = *optional; - StringMatchResultListener value_listener; - const bool match = value_matcher_.MatchAndExplain(value, &value_listener); - *listener << "whose value " << PrintToString(value) - << (match ? " matches" : " doesn't match"); - PrintIfNotEmpty(value_listener.str(), listener->stream()); - return match; - } - - private: - const Matcher<ValueType> value_matcher_; - }; - - private: - const ValueMatcher value_matcher_; -}; - -namespace variant_matcher { -// Overloads to allow VariantMatcher to do proper ADL lookup. -template <typename T> -void holds_alternative() {} -template <typename T> -void get() {} - -// Implements a matcher that checks the value of a variant<> type variable. -template <typename T> -class VariantMatcher { - public: - explicit VariantMatcher(::testing::Matcher<const T&> matcher) - : matcher_(std::move(matcher)) {} - - template <typename Variant> - bool MatchAndExplain(const Variant& value, - ::testing::MatchResultListener* listener) const { - using std::get; - if (!listener->IsInterested()) { - return holds_alternative<T>(value) && matcher_.Matches(get<T>(value)); - } - - if (!holds_alternative<T>(value)) { - *listener << "whose value is not of type '" << GetTypeName() << "'"; - return false; - } - - const T& elem = get<T>(value); - StringMatchResultListener elem_listener; - const bool match = matcher_.MatchAndExplain(elem, &elem_listener); - *listener << "whose value " << PrintToString(elem) - << (match ? " matches" : " doesn't match"); - PrintIfNotEmpty(elem_listener.str(), listener->stream()); - return match; - } - - void DescribeTo(std::ostream* os) const { - *os << "is a variant<> with value of type '" << GetTypeName() - << "' and the value "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(std::ostream* os) const { - *os << "is a variant<> with value of type other than '" << GetTypeName() - << "' or the value "; - matcher_.DescribeNegationTo(os); - } - - private: - static std::string GetTypeName() { -#if GTEST_HAS_RTTI - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_( - return internal::GetTypeName<T>()); -#endif - return "the element type"; - } - - const ::testing::Matcher<const T&> matcher_; -}; - -} // namespace variant_matcher - -namespace any_cast_matcher { - -// Overloads to allow AnyCastMatcher to do proper ADL lookup. -template <typename T> -void any_cast() {} - -// Implements a matcher that any_casts the value. -template <typename T> -class AnyCastMatcher { - public: - explicit AnyCastMatcher(const ::testing::Matcher<const T&>& matcher) - : matcher_(matcher) {} - - template <typename AnyType> - bool MatchAndExplain(const AnyType& value, - ::testing::MatchResultListener* listener) const { - if (!listener->IsInterested()) { - const T* ptr = any_cast<T>(&value); - return ptr != nullptr && matcher_.Matches(*ptr); - } - - const T* elem = any_cast<T>(&value); - if (elem == nullptr) { - *listener << "whose value is not of type '" << GetTypeName() << "'"; - return false; - } - - StringMatchResultListener elem_listener; - const bool match = matcher_.MatchAndExplain(*elem, &elem_listener); - *listener << "whose value " << PrintToString(*elem) - << (match ? " matches" : " doesn't match"); - PrintIfNotEmpty(elem_listener.str(), listener->stream()); - return match; - } - - void DescribeTo(std::ostream* os) const { - *os << "is an 'any' type with value of type '" << GetTypeName() - << "' and the value "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(std::ostream* os) const { - *os << "is an 'any' type with value of type other than '" << GetTypeName() - << "' or the value "; - matcher_.DescribeNegationTo(os); - } - - private: - static std::string GetTypeName() { -#if GTEST_HAS_RTTI - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_( - return internal::GetTypeName<T>()); -#endif - return "the element type"; - } - - const ::testing::Matcher<const T&> matcher_; -}; - -} // namespace any_cast_matcher - -// Implements the Args() matcher. -template <class ArgsTuple, size_t... k> -class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> { - public: - using RawArgsTuple = typename std::decay<ArgsTuple>::type; - using SelectedArgs = - std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>; - using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>; - - template <typename InnerMatcher> - explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher) - : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {} - - bool MatchAndExplain(ArgsTuple args, - MatchResultListener* listener) const override { - // Workaround spurious C4100 on MSVC<=15.7 when k is empty. - (void)args; - const SelectedArgs& selected_args = - std::forward_as_tuple(std::get<k>(args)...); - if (!listener->IsInterested()) return inner_matcher_.Matches(selected_args); - - PrintIndices(listener->stream()); - *listener << "are " << PrintToString(selected_args); - - StringMatchResultListener inner_listener; - const bool match = - inner_matcher_.MatchAndExplain(selected_args, &inner_listener); - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - return match; - } - - void DescribeTo(::std::ostream* os) const override { - *os << "are a tuple "; - PrintIndices(os); - inner_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "are a tuple "; - PrintIndices(os); - inner_matcher_.DescribeNegationTo(os); - } - - private: - // Prints the indices of the selected fields. - static void PrintIndices(::std::ostream* os) { - *os << "whose fields ("; - const char* sep = ""; - // Workaround spurious C4189 on MSVC<=15.7 when k is empty. - (void)sep; - const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...}; - (void)dummy; - *os << ") "; - } - - MonomorphicInnerMatcher inner_matcher_; -}; - -template <class InnerMatcher, size_t... k> -class ArgsMatcher { - public: - explicit ArgsMatcher(InnerMatcher inner_matcher) - : inner_matcher_(std::move(inner_matcher)) {} - - template <typename ArgsTuple> - operator Matcher<ArgsTuple>() const { // NOLINT - return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k...>(inner_matcher_)); - } - - private: - InnerMatcher inner_matcher_; -}; - -} // namespace internal - -// ElementsAreArray(iterator_first, iterator_last) -// ElementsAreArray(pointer, count) -// ElementsAreArray(array) -// ElementsAreArray(container) -// ElementsAreArray({ e1, e2, ..., en }) -// -// The ElementsAreArray() functions are like ElementsAre(...), except -// that they are given a homogeneous sequence rather than taking each -// element as a function argument. The sequence can be specified as an -// array, a pointer and count, a vector, an initializer list, or an -// STL iterator range. In each of these cases, the underlying sequence -// can be either a sequence of values or a sequence of matchers. -// -// All forms of ElementsAreArray() make a copy of the input matcher sequence. - -template <typename Iter> -inline internal::ElementsAreArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -ElementsAreArray(Iter first, Iter last) { - typedef typename ::std::iterator_traits<Iter>::value_type T; - return internal::ElementsAreArrayMatcher<T>(first, last); -} - -template <typename T> -inline auto ElementsAreArray(const T* pointer, size_t count) - -> decltype(ElementsAreArray(pointer, pointer + count)) { - return ElementsAreArray(pointer, pointer + count); -} - -template <typename T, size_t N> -inline auto ElementsAreArray(const T (&array)[N]) - -> decltype(ElementsAreArray(array, N)) { - return ElementsAreArray(array, N); -} - -template <typename Container> -inline auto ElementsAreArray(const Container& container) - -> decltype(ElementsAreArray(container.begin(), container.end())) { - return ElementsAreArray(container.begin(), container.end()); -} - -template <typename T> -inline auto ElementsAreArray(::std::initializer_list<T> xs) - -> decltype(ElementsAreArray(xs.begin(), xs.end())) { - return ElementsAreArray(xs.begin(), xs.end()); -} - -// UnorderedElementsAreArray(iterator_first, iterator_last) -// UnorderedElementsAreArray(pointer, count) -// UnorderedElementsAreArray(array) -// UnorderedElementsAreArray(container) -// UnorderedElementsAreArray({ e1, e2, ..., en }) -// -// UnorderedElementsAreArray() verifies that a bijective mapping onto a -// collection of matchers exists. -// -// The matchers can be specified as an array, a pointer and count, a container, -// an initializer list, or an STL iterator range. In each of these cases, the -// underlying matchers can be either values or matchers. - -template <typename Iter> -inline internal::UnorderedElementsAreArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -UnorderedElementsAreArray(Iter first, Iter last) { - typedef typename ::std::iterator_traits<Iter>::value_type T; - return internal::UnorderedElementsAreArrayMatcher<T>( - internal::UnorderedMatcherRequire::ExactMatch, first, last); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray( - const T* pointer, size_t count) { - return UnorderedElementsAreArray(pointer, pointer + count); -} - -template <typename T, size_t N> -inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray( - const T (&array)[N]) { - return UnorderedElementsAreArray(array, N); -} - -template <typename Container> -inline internal::UnorderedElementsAreArrayMatcher< - typename Container::value_type> -UnorderedElementsAreArray(const Container& container) { - return UnorderedElementsAreArray(container.begin(), container.end()); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray( - ::std::initializer_list<T> xs) { - return UnorderedElementsAreArray(xs.begin(), xs.end()); -} - -// _ is a matcher that matches anything of any type. -// -// This definition is fine as: -// -// 1. The C++ standard permits using the name _ in a namespace that -// is not the global namespace or ::std. -// 2. The AnythingMatcher class has no data member or constructor, -// so it's OK to create global variables of this type. -// 3. c-style has approved of using _ in this case. -const internal::AnythingMatcher _ = {}; -// Creates a matcher that matches any value of the given type T. -template <typename T> -inline Matcher<T> A() { - return _; -} - -// Creates a matcher that matches any value of the given type T. -template <typename T> -inline Matcher<T> An() { - return _; -} - -template <typename T, typename M> -Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl( - const M& value, std::false_type /* convertible_to_matcher */, - std::false_type /* convertible_to_T */) { - return Eq(value); -} - -// Creates a polymorphic matcher that matches any NULL pointer. -inline PolymorphicMatcher<internal::IsNullMatcher> IsNull() { - return MakePolymorphicMatcher(internal::IsNullMatcher()); -} - -// Creates a polymorphic matcher that matches any non-NULL pointer. -// This is convenient as Not(NULL) doesn't compile (the compiler -// thinks that that expression is comparing a pointer with an integer). -inline PolymorphicMatcher<internal::NotNullMatcher> NotNull() { - return MakePolymorphicMatcher(internal::NotNullMatcher()); -} - -// Creates a polymorphic matcher that matches any argument that -// references variable x. -template <typename T> -inline internal::RefMatcher<T&> Ref(T& x) { // NOLINT - return internal::RefMatcher<T&>(x); -} - -// Creates a polymorphic matcher that matches any NaN floating point. -inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() { - return MakePolymorphicMatcher(internal::IsNanMatcher()); -} - -// Creates a matcher that matches any double argument approximately -// equal to rhs, where two NANs are considered unequal. -inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) { - return internal::FloatingEqMatcher<double>(rhs, false); -} - -// Creates a matcher that matches any double argument approximately -// equal to rhs, including NaN values when rhs is NaN. -inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) { - return internal::FloatingEqMatcher<double>(rhs, true); -} - -// Creates a matcher that matches any double argument approximately equal to -// rhs, up to the specified max absolute error bound, where two NANs are -// considered unequal. The max absolute error bound must be non-negative. -inline internal::FloatingEqMatcher<double> DoubleNear(double rhs, - double max_abs_error) { - return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error); -} - -// Creates a matcher that matches any double argument approximately equal to -// rhs, up to the specified max absolute error bound, including NaN values when -// rhs is NaN. The max absolute error bound must be non-negative. -inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear( - double rhs, double max_abs_error) { - return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error); -} - -// Creates a matcher that matches any float argument approximately -// equal to rhs, where two NANs are considered unequal. -inline internal::FloatingEqMatcher<float> FloatEq(float rhs) { - return internal::FloatingEqMatcher<float>(rhs, false); -} - -// Creates a matcher that matches any float argument approximately -// equal to rhs, including NaN values when rhs is NaN. -inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) { - return internal::FloatingEqMatcher<float>(rhs, true); -} - -// Creates a matcher that matches any float argument approximately equal to -// rhs, up to the specified max absolute error bound, where two NANs are -// considered unequal. The max absolute error bound must be non-negative. -inline internal::FloatingEqMatcher<float> FloatNear(float rhs, - float max_abs_error) { - return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error); -} - -// Creates a matcher that matches any float argument approximately equal to -// rhs, up to the specified max absolute error bound, including NaN values when -// rhs is NaN. The max absolute error bound must be non-negative. -inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear( - float rhs, float max_abs_error) { - return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error); -} - -// Creates a matcher that matches a pointer (raw or smart) that points -// to a value that matches inner_matcher. -template <typename InnerMatcher> -inline internal::PointeeMatcher<InnerMatcher> Pointee( - const InnerMatcher& inner_matcher) { - return internal::PointeeMatcher<InnerMatcher>(inner_matcher); -} - -#if GTEST_HAS_RTTI -// Creates a matcher that matches a pointer or reference that matches -// inner_matcher when dynamic_cast<To> is applied. -// The result of dynamic_cast<To> is forwarded to the inner matcher. -// If To is a pointer and the cast fails, the inner matcher will receive NULL. -// If To is a reference and the cast fails, this matcher returns false -// immediately. -template <typename To> -inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To>> -WhenDynamicCastTo(const Matcher<To>& inner_matcher) { - return MakePolymorphicMatcher( - internal::WhenDynamicCastToMatcher<To>(inner_matcher)); -} -#endif // GTEST_HAS_RTTI - -// Creates a matcher that matches an object whose given field matches -// 'matcher'. For example, -// Field(&Foo::number, Ge(5)) -// matches a Foo object x if and only if x.number >= 5. -template <typename Class, typename FieldType, typename FieldMatcher> -inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType>> Field( - FieldType Class::*field, const FieldMatcher& matcher) { - return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>( - field, MatcherCast<const FieldType&>(matcher))); - // The call to MatcherCast() is required for supporting inner - // matchers of compatible types. For example, it allows - // Field(&Foo::bar, m) - // to compile where bar is an int32 and m is a matcher for int64. -} - -// Same as Field() but also takes the name of the field to provide better error -// messages. -template <typename Class, typename FieldType, typename FieldMatcher> -inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType>> Field( - const std::string& field_name, FieldType Class::*field, - const FieldMatcher& matcher) { - return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>( - field_name, field, MatcherCast<const FieldType&>(matcher))); -} - -// Creates a matcher that matches an object whose given property -// matches 'matcher'. For example, -// Property(&Foo::str, StartsWith("hi")) -// matches a Foo object x if and only if x.str() starts with "hi". -template <typename Class, typename PropertyType, typename PropertyMatcher> -inline PolymorphicMatcher<internal::PropertyMatcher< - Class, PropertyType, PropertyType (Class::*)() const>> -Property(PropertyType (Class::*property)() const, - const PropertyMatcher& matcher) { - return MakePolymorphicMatcher( - internal::PropertyMatcher<Class, PropertyType, - PropertyType (Class::*)() const>( - property, MatcherCast<const PropertyType&>(matcher))); - // The call to MatcherCast() is required for supporting inner - // matchers of compatible types. For example, it allows - // Property(&Foo::bar, m) - // to compile where bar() returns an int32 and m is a matcher for int64. -} - -// Same as Property() above, but also takes the name of the property to provide -// better error messages. -template <typename Class, typename PropertyType, typename PropertyMatcher> -inline PolymorphicMatcher<internal::PropertyMatcher< - Class, PropertyType, PropertyType (Class::*)() const>> -Property(const std::string& property_name, - PropertyType (Class::*property)() const, - const PropertyMatcher& matcher) { - return MakePolymorphicMatcher( - internal::PropertyMatcher<Class, PropertyType, - PropertyType (Class::*)() const>( - property_name, property, MatcherCast<const PropertyType&>(matcher))); -} - -// The same as above but for reference-qualified member functions. -template <typename Class, typename PropertyType, typename PropertyMatcher> -inline PolymorphicMatcher<internal::PropertyMatcher< - Class, PropertyType, PropertyType (Class::*)() const&>> -Property(PropertyType (Class::*property)() const&, - const PropertyMatcher& matcher) { - return MakePolymorphicMatcher( - internal::PropertyMatcher<Class, PropertyType, - PropertyType (Class::*)() const&>( - property, MatcherCast<const PropertyType&>(matcher))); -} - -// Three-argument form for reference-qualified member functions. -template <typename Class, typename PropertyType, typename PropertyMatcher> -inline PolymorphicMatcher<internal::PropertyMatcher< - Class, PropertyType, PropertyType (Class::*)() const&>> -Property(const std::string& property_name, - PropertyType (Class::*property)() const&, - const PropertyMatcher& matcher) { - return MakePolymorphicMatcher( - internal::PropertyMatcher<Class, PropertyType, - PropertyType (Class::*)() const&>( - property_name, property, MatcherCast<const PropertyType&>(matcher))); -} - -// Creates a matcher that matches an object if and only if the result of -// applying a callable to x matches 'matcher'. For example, -// ResultOf(f, StartsWith("hi")) -// matches a Foo object x if and only if f(x) starts with "hi". -// `callable` parameter can be a function, function pointer, or a functor. It is -// required to keep no state affecting the results of the calls on it and make -// no assumptions about how many calls will be made. Any state it keeps must be -// protected from the concurrent access. -template <typename Callable, typename InnerMatcher> -internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf( - Callable callable, InnerMatcher matcher) { - return internal::ResultOfMatcher<Callable, InnerMatcher>(std::move(callable), - std::move(matcher)); -} - -// Same as ResultOf() above, but also takes a description of the `callable` -// result to provide better error messages. -template <typename Callable, typename InnerMatcher> -internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf( - const std::string& result_description, Callable callable, - InnerMatcher matcher) { - return internal::ResultOfMatcher<Callable, InnerMatcher>( - result_description, std::move(callable), std::move(matcher)); -} - -// String matchers. - -// Matches a string equal to str. -template <typename T = std::string> -PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrEq( - const internal::StringLike<T>& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::string>(std::string(str), true, true)); -} - -// Matches a string not equal to str. -template <typename T = std::string> -PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrNe( - const internal::StringLike<T>& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::string>(std::string(str), false, true)); -} - -// Matches a string equal to str, ignoring case. -template <typename T = std::string> -PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseEq( - const internal::StringLike<T>& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::string>(std::string(str), true, false)); -} - -// Matches a string not equal to str, ignoring case. -template <typename T = std::string> -PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseNe( - const internal::StringLike<T>& str) { - return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>( - std::string(str), false, false)); -} - -// Creates a matcher that matches any string, std::string, or C string -// that contains the given substring. -template <typename T = std::string> -PolymorphicMatcher<internal::HasSubstrMatcher<std::string>> HasSubstr( - const internal::StringLike<T>& substring) { - return MakePolymorphicMatcher( - internal::HasSubstrMatcher<std::string>(std::string(substring))); -} - -// Matches a string that starts with 'prefix' (case-sensitive). -template <typename T = std::string> -PolymorphicMatcher<internal::StartsWithMatcher<std::string>> StartsWith( - const internal::StringLike<T>& prefix) { - return MakePolymorphicMatcher( - internal::StartsWithMatcher<std::string>(std::string(prefix))); -} - -// Matches a string that ends with 'suffix' (case-sensitive). -template <typename T = std::string> -PolymorphicMatcher<internal::EndsWithMatcher<std::string>> EndsWith( - const internal::StringLike<T>& suffix) { - return MakePolymorphicMatcher( - internal::EndsWithMatcher<std::string>(std::string(suffix))); -} - -#if GTEST_HAS_STD_WSTRING -// Wide string matchers. - -// Matches a string equal to str. -inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrEq( - const std::wstring& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::wstring>(str, true, true)); -} - -// Matches a string not equal to str. -inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrNe( - const std::wstring& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::wstring>(str, false, true)); -} - -// Matches a string equal to str, ignoring case. -inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseEq( - const std::wstring& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::wstring>(str, true, false)); -} - -// Matches a string not equal to str, ignoring case. -inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseNe( - const std::wstring& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::wstring>(str, false, false)); -} - -// Creates a matcher that matches any ::wstring, std::wstring, or C wide string -// that contains the given substring. -inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring>> HasSubstr( - const std::wstring& substring) { - return MakePolymorphicMatcher( - internal::HasSubstrMatcher<std::wstring>(substring)); -} - -// Matches a string that starts with 'prefix' (case-sensitive). -inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring>> StartsWith( - const std::wstring& prefix) { - return MakePolymorphicMatcher( - internal::StartsWithMatcher<std::wstring>(prefix)); -} - -// Matches a string that ends with 'suffix' (case-sensitive). -inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring>> EndsWith( - const std::wstring& suffix) { - return MakePolymorphicMatcher( - internal::EndsWithMatcher<std::wstring>(suffix)); -} - -#endif // GTEST_HAS_STD_WSTRING - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field == the second field. -inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field >= the second field. -inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field > the second field. -inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field <= the second field. -inline internal::Le2Matcher Le() { return internal::Le2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field < the second field. -inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field != the second field. -inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where -// FloatEq(first field) matches the second field. -inline internal::FloatingEq2Matcher<float> FloatEq() { - return internal::FloatingEq2Matcher<float>(); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// DoubleEq(first field) matches the second field. -inline internal::FloatingEq2Matcher<double> DoubleEq() { - return internal::FloatingEq2Matcher<double>(); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// FloatEq(first field) matches the second field with NaN equality. -inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() { - return internal::FloatingEq2Matcher<float>(true); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// DoubleEq(first field) matches the second field with NaN equality. -inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() { - return internal::FloatingEq2Matcher<double>(true); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// FloatNear(first field, max_abs_error) matches the second field. -inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) { - return internal::FloatingEq2Matcher<float>(max_abs_error); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// DoubleNear(first field, max_abs_error) matches the second field. -inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_error) { - return internal::FloatingEq2Matcher<double>(max_abs_error); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// FloatNear(first field, max_abs_error) matches the second field with NaN -// equality. -inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear( - float max_abs_error) { - return internal::FloatingEq2Matcher<float>(max_abs_error, true); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// DoubleNear(first field, max_abs_error) matches the second field with NaN -// equality. -inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear( - double max_abs_error) { - return internal::FloatingEq2Matcher<double>(max_abs_error, true); -} - -// Creates a matcher that matches any value of type T that m doesn't -// match. -template <typename InnerMatcher> -inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) { - return internal::NotMatcher<InnerMatcher>(m); -} - -// Returns a matcher that matches anything that satisfies the given -// predicate. The predicate can be any unary function or functor -// whose return type can be implicitly converted to bool. -template <typename Predicate> -inline PolymorphicMatcher<internal::TrulyMatcher<Predicate>> Truly( - Predicate pred) { - return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred)); -} - -// Returns a matcher that matches the container size. The container must -// support both size() and size_type which all STL-like containers provide. -// Note that the parameter 'size' can be a value of type size_type as well as -// matcher. For instance: -// EXPECT_THAT(container, SizeIs(2)); // Checks container has 2 elements. -// EXPECT_THAT(container, SizeIs(Le(2)); // Checks container has at most 2. -template <typename SizeMatcher> -inline internal::SizeIsMatcher<SizeMatcher> SizeIs( - const SizeMatcher& size_matcher) { - return internal::SizeIsMatcher<SizeMatcher>(size_matcher); -} - -// Returns a matcher that matches the distance between the container's begin() -// iterator and its end() iterator, i.e. the size of the container. This matcher -// can be used instead of SizeIs with containers such as std::forward_list which -// do not implement size(). The container must provide const_iterator (with -// valid iterator_traits), begin() and end(). -template <typename DistanceMatcher> -inline internal::BeginEndDistanceIsMatcher<DistanceMatcher> BeginEndDistanceIs( - const DistanceMatcher& distance_matcher) { - return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher); -} - -// Returns a matcher that matches an equal container. -// This matcher behaves like Eq(), but in the event of mismatch lists the -// values that are included in one container but not the other. (Duplicate -// values and order differences are not explained.) -template <typename Container> -inline PolymorphicMatcher< - internal::ContainerEqMatcher<typename std::remove_const<Container>::type>> -ContainerEq(const Container& rhs) { - return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs)); -} - -// Returns a matcher that matches a container that, when sorted using -// the given comparator, matches container_matcher. -template <typename Comparator, typename ContainerMatcher> -inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher> WhenSortedBy( - const Comparator& comparator, const ContainerMatcher& container_matcher) { - return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>( - comparator, container_matcher); -} - -// Returns a matcher that matches a container that, when sorted using -// the < operator, matches container_matcher. -template <typename ContainerMatcher> -inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher> -WhenSorted(const ContainerMatcher& container_matcher) { - return internal::WhenSortedByMatcher<internal::LessComparator, - ContainerMatcher>( - internal::LessComparator(), container_matcher); -} - -// Matches an STL-style container or a native array that contains the -// same number of elements as in rhs, where its i-th element and rhs's -// i-th element (as a pair) satisfy the given pair matcher, for all i. -// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const -// T1&, const T2&> >, where T1 and T2 are the types of elements in the -// LHS container and the RHS container respectively. -template <typename TupleMatcher, typename Container> -inline internal::PointwiseMatcher<TupleMatcher, - typename std::remove_const<Container>::type> -Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) { - return internal::PointwiseMatcher<TupleMatcher, Container>(tuple_matcher, - rhs); -} - -// Supports the Pointwise(m, {a, b, c}) syntax. -template <typename TupleMatcher, typename T> -inline internal::PointwiseMatcher<TupleMatcher, std::vector<T>> Pointwise( - const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) { - return Pointwise(tuple_matcher, std::vector<T>(rhs)); -} - -// UnorderedPointwise(pair_matcher, rhs) matches an STL-style -// container or a native array that contains the same number of -// elements as in rhs, where in some permutation of the container, its -// i-th element and rhs's i-th element (as a pair) satisfy the given -// pair matcher, for all i. Tuple2Matcher must be able to be safely -// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are -// the types of elements in the LHS container and the RHS container -// respectively. -// -// This is like Pointwise(pair_matcher, rhs), except that the element -// order doesn't matter. -template <typename Tuple2Matcher, typename RhsContainer> -inline internal::UnorderedElementsAreArrayMatcher< - typename internal::BoundSecondMatcher< - Tuple2Matcher, - typename internal::StlContainerView< - typename std::remove_const<RhsContainer>::type>::type::value_type>> -UnorderedPointwise(const Tuple2Matcher& tuple2_matcher, - const RhsContainer& rhs_container) { - // RhsView allows the same code to handle RhsContainer being a - // STL-style container and it being a native C-style array. - typedef typename internal::StlContainerView<RhsContainer> RhsView; - typedef typename RhsView::type RhsStlContainer; - typedef typename RhsStlContainer::value_type Second; - const RhsStlContainer& rhs_stl_container = - RhsView::ConstReference(rhs_container); - - // Create a matcher for each element in rhs_container. - ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second>> matchers; - for (auto it = rhs_stl_container.begin(); it != rhs_stl_container.end(); - ++it) { - matchers.push_back(internal::MatcherBindSecond(tuple2_matcher, *it)); - } - - // Delegate the work to UnorderedElementsAreArray(). - return UnorderedElementsAreArray(matchers); -} - -// Supports the UnorderedPointwise(m, {a, b, c}) syntax. -template <typename Tuple2Matcher, typename T> -inline internal::UnorderedElementsAreArrayMatcher< - typename internal::BoundSecondMatcher<Tuple2Matcher, T>> -UnorderedPointwise(const Tuple2Matcher& tuple2_matcher, - std::initializer_list<T> rhs) { - return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs)); -} - -// Matches an STL-style container or a native array that contains at -// least one element matching the given value or matcher. -// -// Examples: -// ::std::set<int> page_ids; -// page_ids.insert(3); -// page_ids.insert(1); -// EXPECT_THAT(page_ids, Contains(1)); -// EXPECT_THAT(page_ids, Contains(Gt(2))); -// EXPECT_THAT(page_ids, Not(Contains(4))); // See below for Times(0) -// -// ::std::map<int, size_t> page_lengths; -// page_lengths[1] = 100; -// EXPECT_THAT(page_lengths, -// Contains(::std::pair<const int, size_t>(1, 100))); -// -// const char* user_ids[] = { "joe", "mike", "tom" }; -// EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom")))); -// -// The matcher supports a modifier `Times` that allows to check for arbitrary -// occurrences including testing for absence with Times(0). -// -// Examples: -// ::std::vector<int> ids; -// ids.insert(1); -// ids.insert(1); -// ids.insert(3); -// EXPECT_THAT(ids, Contains(1).Times(2)); // 1 occurs 2 times -// EXPECT_THAT(ids, Contains(2).Times(0)); // 2 is not present -// EXPECT_THAT(ids, Contains(3).Times(Ge(1))); // 3 occurs at least once - -template <typename M> -inline internal::ContainsMatcher<M> Contains(M matcher) { - return internal::ContainsMatcher<M>(matcher); -} - -// IsSupersetOf(iterator_first, iterator_last) -// IsSupersetOf(pointer, count) -// IsSupersetOf(array) -// IsSupersetOf(container) -// IsSupersetOf({e1, e2, ..., en}) -// -// IsSupersetOf() verifies that a surjective partial mapping onto a collection -// of matchers exists. In other words, a container matches -// IsSupersetOf({e1, ..., en}) if and only if there is a permutation -// {y1, ..., yn} of some of the container's elements where y1 matches e1, -// ..., and yn matches en. Obviously, the size of the container must be >= n -// in order to have a match. Examples: -// -// - {1, 2, 3} matches IsSupersetOf({Ge(3), Ne(0)}), as 3 matches Ge(3) and -// 1 matches Ne(0). -// - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches -// both Eq(1) and Lt(2). The reason is that different matchers must be used -// for elements in different slots of the container. -// - {1, 1, 2} matches IsSupersetOf({Eq(1), Lt(2)}), as (the first) 1 matches -// Eq(1) and (the second) 1 matches Lt(2). -// - {1, 2, 3} matches IsSupersetOf(Gt(1), Gt(1)), as 2 matches (the first) -// Gt(1) and 3 matches (the second) Gt(1). -// -// The matchers can be specified as an array, a pointer and count, a container, -// an initializer list, or an STL iterator range. In each of these cases, the -// underlying matchers can be either values or matchers. - -template <typename Iter> -inline internal::UnorderedElementsAreArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -IsSupersetOf(Iter first, Iter last) { - typedef typename ::std::iterator_traits<Iter>::value_type T; - return internal::UnorderedElementsAreArrayMatcher<T>( - internal::UnorderedMatcherRequire::Superset, first, last); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( - const T* pointer, size_t count) { - return IsSupersetOf(pointer, pointer + count); -} - -template <typename T, size_t N> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( - const T (&array)[N]) { - return IsSupersetOf(array, N); -} - -template <typename Container> -inline internal::UnorderedElementsAreArrayMatcher< - typename Container::value_type> -IsSupersetOf(const Container& container) { - return IsSupersetOf(container.begin(), container.end()); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( - ::std::initializer_list<T> xs) { - return IsSupersetOf(xs.begin(), xs.end()); -} - -// IsSubsetOf(iterator_first, iterator_last) -// IsSubsetOf(pointer, count) -// IsSubsetOf(array) -// IsSubsetOf(container) -// IsSubsetOf({e1, e2, ..., en}) -// -// IsSubsetOf() verifies that an injective mapping onto a collection of matchers -// exists. In other words, a container matches IsSubsetOf({e1, ..., en}) if and -// only if there is a subset of matchers {m1, ..., mk} which would match the -// container using UnorderedElementsAre. Obviously, the size of the container -// must be <= n in order to have a match. Examples: -// -// - {1} matches IsSubsetOf({Gt(0), Lt(0)}), as 1 matches Gt(0). -// - {1, -1} matches IsSubsetOf({Lt(0), Gt(0)}), as 1 matches Gt(0) and -1 -// matches Lt(0). -// - {1, 2} doesn't matches IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both -// match Gt(0). The reason is that different matchers must be used for -// elements in different slots of the container. -// -// The matchers can be specified as an array, a pointer and count, a container, -// an initializer list, or an STL iterator range. In each of these cases, the -// underlying matchers can be either values or matchers. - -template <typename Iter> -inline internal::UnorderedElementsAreArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -IsSubsetOf(Iter first, Iter last) { - typedef typename ::std::iterator_traits<Iter>::value_type T; - return internal::UnorderedElementsAreArrayMatcher<T>( - internal::UnorderedMatcherRequire::Subset, first, last); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( - const T* pointer, size_t count) { - return IsSubsetOf(pointer, pointer + count); -} - -template <typename T, size_t N> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( - const T (&array)[N]) { - return IsSubsetOf(array, N); -} - -template <typename Container> -inline internal::UnorderedElementsAreArrayMatcher< - typename Container::value_type> -IsSubsetOf(const Container& container) { - return IsSubsetOf(container.begin(), container.end()); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( - ::std::initializer_list<T> xs) { - return IsSubsetOf(xs.begin(), xs.end()); -} - -// Matches an STL-style container or a native array that contains only -// elements matching the given value or matcher. -// -// Each(m) is semantically equivalent to `Not(Contains(Not(m)))`. Only -// the messages are different. -// -// Examples: -// ::std::set<int> page_ids; -// // Each(m) matches an empty container, regardless of what m is. -// EXPECT_THAT(page_ids, Each(Eq(1))); -// EXPECT_THAT(page_ids, Each(Eq(77))); -// -// page_ids.insert(3); -// EXPECT_THAT(page_ids, Each(Gt(0))); -// EXPECT_THAT(page_ids, Not(Each(Gt(4)))); -// page_ids.insert(1); -// EXPECT_THAT(page_ids, Not(Each(Lt(2)))); -// -// ::std::map<int, size_t> page_lengths; -// page_lengths[1] = 100; -// page_lengths[2] = 200; -// page_lengths[3] = 300; -// EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100)))); -// EXPECT_THAT(page_lengths, Each(Key(Le(3)))); -// -// const char* user_ids[] = { "joe", "mike", "tom" }; -// EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom"))))); -template <typename M> -inline internal::EachMatcher<M> Each(M matcher) { - return internal::EachMatcher<M>(matcher); -} - -// Key(inner_matcher) matches an std::pair whose 'first' field matches -// inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an -// std::map that contains at least one element whose key is >= 5. -template <typename M> -inline internal::KeyMatcher<M> Key(M inner_matcher) { - return internal::KeyMatcher<M>(inner_matcher); -} - -// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field -// matches first_matcher and whose 'second' field matches second_matcher. For -// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used -// to match a std::map<int, string> that contains exactly one element whose key -// is >= 5 and whose value equals "foo". -template <typename FirstMatcher, typename SecondMatcher> -inline internal::PairMatcher<FirstMatcher, SecondMatcher> Pair( - FirstMatcher first_matcher, SecondMatcher second_matcher) { - return internal::PairMatcher<FirstMatcher, SecondMatcher>(first_matcher, - second_matcher); -} - -namespace no_adl { -// Conditional() creates a matcher that conditionally uses either the first or -// second matcher provided. For example, we could create an `equal if, and only -// if' matcher using the Conditional wrapper as follows: -// -// EXPECT_THAT(result, Conditional(condition, Eq(expected), Ne(expected))); -template <typename MatcherTrue, typename MatcherFalse> -internal::ConditionalMatcher<MatcherTrue, MatcherFalse> Conditional( - bool condition, MatcherTrue matcher_true, MatcherFalse matcher_false) { - return internal::ConditionalMatcher<MatcherTrue, MatcherFalse>( - condition, std::move(matcher_true), std::move(matcher_false)); -} - -// FieldsAre(matchers...) matches piecewise the fields of compatible structs. -// These include those that support `get<I>(obj)`, and when structured bindings -// are enabled any class that supports them. -// In particular, `std::tuple`, `std::pair`, `std::array` and aggregate types. -template <typename... M> -internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre( - M&&... matchers) { - return internal::FieldsAreMatcher<typename std::decay<M>::type...>( - std::forward<M>(matchers)...); -} - -// Creates a matcher that matches a pointer (raw or smart) that matches -// inner_matcher. -template <typename InnerMatcher> -inline internal::PointerMatcher<InnerMatcher> Pointer( - const InnerMatcher& inner_matcher) { - return internal::PointerMatcher<InnerMatcher>(inner_matcher); -} - -// Creates a matcher that matches an object that has an address that matches -// inner_matcher. -template <typename InnerMatcher> -inline internal::AddressMatcher<InnerMatcher> Address( - const InnerMatcher& inner_matcher) { - return internal::AddressMatcher<InnerMatcher>(inner_matcher); -} - -// Matches a base64 escaped string, when the unescaped string matches the -// internal matcher. -template <typename MatcherType> -internal::WhenBase64UnescapedMatcher WhenBase64Unescaped( - const MatcherType& internal_matcher) { - return internal::WhenBase64UnescapedMatcher(internal_matcher); -} -} // namespace no_adl - -// Returns a predicate that is satisfied by anything that matches the -// given matcher. -template <typename M> -inline internal::MatcherAsPredicate<M> Matches(M matcher) { - return internal::MatcherAsPredicate<M>(matcher); -} - -// Returns true if and only if the value matches the matcher. -template <typename T, typename M> -inline bool Value(const T& value, M matcher) { - return testing::Matches(matcher)(value); -} - -// Matches the value against the given matcher and explains the match -// result to listener. -template <typename T, typename M> -inline bool ExplainMatchResult(M matcher, const T& value, - MatchResultListener* listener) { - return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener); -} - -// Returns a string representation of the given matcher. Useful for description -// strings of matchers defined using MATCHER_P* macros that accept matchers as -// their arguments. For example: -// -// MATCHER_P(XAndYThat, matcher, -// "X that " + DescribeMatcher<int>(matcher, negation) + -// (negation ? " or" : " and") + " Y that " + -// DescribeMatcher<double>(matcher, negation)) { -// return ExplainMatchResult(matcher, arg.x(), result_listener) && -// ExplainMatchResult(matcher, arg.y(), result_listener); -// } -template <typename T, typename M> -std::string DescribeMatcher(const M& matcher, bool negation = false) { - ::std::stringstream ss; - Matcher<T> monomorphic_matcher = SafeMatcherCast<T>(matcher); - if (negation) { - monomorphic_matcher.DescribeNegationTo(&ss); - } else { - monomorphic_matcher.DescribeTo(&ss); - } - return ss.str(); -} - -template <typename... Args> -internal::ElementsAreMatcher< - std::tuple<typename std::decay<const Args&>::type...>> -ElementsAre(const Args&... matchers) { - return internal::ElementsAreMatcher< - std::tuple<typename std::decay<const Args&>::type...>>( - std::make_tuple(matchers...)); -} - -template <typename... Args> -internal::UnorderedElementsAreMatcher< - std::tuple<typename std::decay<const Args&>::type...>> -UnorderedElementsAre(const Args&... matchers) { - return internal::UnorderedElementsAreMatcher< - std::tuple<typename std::decay<const Args&>::type...>>( - std::make_tuple(matchers...)); -} - -// Define variadic matcher versions. -template <typename... Args> -internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf( - const Args&... matchers) { - return internal::AllOfMatcher<typename std::decay<const Args&>::type...>( - matchers...); -} - -template <typename... Args> -internal::AnyOfMatcher<typename std::decay<const Args&>::type...> AnyOf( - const Args&... matchers) { - return internal::AnyOfMatcher<typename std::decay<const Args&>::type...>( - matchers...); -} - -// AnyOfArray(array) -// AnyOfArray(pointer, count) -// AnyOfArray(container) -// AnyOfArray({ e1, e2, ..., en }) -// AnyOfArray(iterator_first, iterator_last) -// -// AnyOfArray() verifies whether a given value matches any member of a -// collection of matchers. -// -// AllOfArray(array) -// AllOfArray(pointer, count) -// AllOfArray(container) -// AllOfArray({ e1, e2, ..., en }) -// AllOfArray(iterator_first, iterator_last) -// -// AllOfArray() verifies whether a given value matches all members of a -// collection of matchers. -// -// The matchers can be specified as an array, a pointer and count, a container, -// an initializer list, or an STL iterator range. In each of these cases, the -// underlying matchers can be either values or matchers. - -template <typename Iter> -inline internal::AnyOfArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -AnyOfArray(Iter first, Iter last) { - return internal::AnyOfArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type>(first, last); -} - -template <typename Iter> -inline internal::AllOfArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -AllOfArray(Iter first, Iter last) { - return internal::AllOfArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type>(first, last); -} - -template <typename T> -inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t count) { - return AnyOfArray(ptr, ptr + count); -} - -template <typename T> -inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t count) { - return AllOfArray(ptr, ptr + count); -} - -template <typename T, size_t N> -inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) { - return AnyOfArray(array, N); -} - -template <typename T, size_t N> -inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) { - return AllOfArray(array, N); -} - -template <typename Container> -inline internal::AnyOfArrayMatcher<typename Container::value_type> AnyOfArray( - const Container& container) { - return AnyOfArray(container.begin(), container.end()); -} - -template <typename Container> -inline internal::AllOfArrayMatcher<typename Container::value_type> AllOfArray( - const Container& container) { - return AllOfArray(container.begin(), container.end()); -} - -template <typename T> -inline internal::AnyOfArrayMatcher<T> AnyOfArray( - ::std::initializer_list<T> xs) { - return AnyOfArray(xs.begin(), xs.end()); -} - -template <typename T> -inline internal::AllOfArrayMatcher<T> AllOfArray( - ::std::initializer_list<T> xs) { - return AllOfArray(xs.begin(), xs.end()); -} - -// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected -// fields of it matches a_matcher. C++ doesn't support default -// arguments for function templates, so we have to overload it. -template <size_t... k, typename InnerMatcher> -internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args( - InnerMatcher&& matcher) { - return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...>( - std::forward<InnerMatcher>(matcher)); -} - -// AllArgs(m) is a synonym of m. This is useful in -// -// EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq())); -// -// which is easier to read than -// -// EXPECT_CALL(foo, Bar(_, _)).With(Eq()); -template <typename InnerMatcher> -inline InnerMatcher AllArgs(const InnerMatcher& matcher) { - return matcher; -} - -// Returns a matcher that matches the value of an optional<> type variable. -// The matcher implementation only uses '!arg' and requires that the optional<> -// type has a 'value_type' member type and that '*arg' is of type 'value_type' -// and is printable using 'PrintToString'. It is compatible with -// std::optional/std::experimental::optional. -// Note that to compare an optional type variable against nullopt you should -// use Eq(nullopt) and not Eq(Optional(nullopt)). The latter implies that the -// optional value contains an optional itself. -template <typename ValueMatcher> -inline internal::OptionalMatcher<ValueMatcher> Optional( - const ValueMatcher& value_matcher) { - return internal::OptionalMatcher<ValueMatcher>(value_matcher); -} - -// Returns a matcher that matches the value of a absl::any type variable. -template <typename T> -PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T>> AnyWith( - const Matcher<const T&>& matcher) { - return MakePolymorphicMatcher( - internal::any_cast_matcher::AnyCastMatcher<T>(matcher)); -} - -// Returns a matcher that matches the value of a variant<> type variable. -// The matcher implementation uses ADL to find the holds_alternative and get -// functions. -// It is compatible with std::variant. -template <typename T> -PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T>> VariantWith( - const Matcher<const T&>& matcher) { - return MakePolymorphicMatcher( - internal::variant_matcher::VariantMatcher<T>(matcher)); -} - -#if GTEST_HAS_EXCEPTIONS - -// Anything inside the `internal` namespace is internal to the implementation -// and must not be used in user code! -namespace internal { - -class WithWhatMatcherImpl { - public: - WithWhatMatcherImpl(Matcher<std::string> matcher) - : matcher_(std::move(matcher)) {} - - void DescribeTo(std::ostream* os) const { - *os << "contains .what() that "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(std::ostream* os) const { - *os << "contains .what() that does not "; - matcher_.DescribeTo(os); - } - - template <typename Err> - bool MatchAndExplain(const Err& err, MatchResultListener* listener) const { - *listener << "which contains .what() (of value = " << err.what() - << ") that "; - return matcher_.MatchAndExplain(err.what(), listener); - } - - private: - const Matcher<std::string> matcher_; -}; - -inline PolymorphicMatcher<WithWhatMatcherImpl> WithWhat( - Matcher<std::string> m) { - return MakePolymorphicMatcher(WithWhatMatcherImpl(std::move(m))); -} - -template <typename Err> -class ExceptionMatcherImpl { - class NeverThrown { - public: - const char* what() const noexcept { - return "this exception should never be thrown"; - } - }; - - // If the matchee raises an exception of a wrong type, we'd like to - // catch it and print its message and type. To do that, we add an additional - // catch clause: - // - // try { ... } - // catch (const Err&) { /* an expected exception */ } - // catch (const std::exception&) { /* exception of a wrong type */ } - // - // However, if the `Err` itself is `std::exception`, we'd end up with two - // identical `catch` clauses: - // - // try { ... } - // catch (const std::exception&) { /* an expected exception */ } - // catch (const std::exception&) { /* exception of a wrong type */ } - // - // This can cause a warning or an error in some compilers. To resolve - // the issue, we use a fake error type whenever `Err` is `std::exception`: - // - // try { ... } - // catch (const std::exception&) { /* an expected exception */ } - // catch (const NeverThrown&) { /* exception of a wrong type */ } - using DefaultExceptionType = typename std::conditional< - std::is_same<typename std::remove_cv< - typename std::remove_reference<Err>::type>::type, - std::exception>::value, - const NeverThrown&, const std::exception&>::type; - - public: - ExceptionMatcherImpl(Matcher<const Err&> matcher) - : matcher_(std::move(matcher)) {} - - void DescribeTo(std::ostream* os) const { - *os << "throws an exception which is a " << GetTypeName<Err>(); - *os << " which "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(std::ostream* os) const { - *os << "throws an exception which is not a " << GetTypeName<Err>(); - *os << " which "; - matcher_.DescribeNegationTo(os); - } - - template <typename T> - bool MatchAndExplain(T&& x, MatchResultListener* listener) const { - try { - (void)(std::forward<T>(x)()); - } catch (const Err& err) { - *listener << "throws an exception which is a " << GetTypeName<Err>(); - *listener << " "; - return matcher_.MatchAndExplain(err, listener); - } catch (DefaultExceptionType err) { -#if GTEST_HAS_RTTI - *listener << "throws an exception of type " << GetTypeName(typeid(err)); - *listener << " "; -#else - *listener << "throws an std::exception-derived type "; -#endif - *listener << "with description \"" << err.what() << "\""; - return false; - } catch (...) { - *listener << "throws an exception of an unknown type"; - return false; - } - - *listener << "does not throw any exception"; - return false; - } - - private: - const Matcher<const Err&> matcher_; -}; - -} // namespace internal - -// Throws() -// Throws(exceptionMatcher) -// ThrowsMessage(messageMatcher) -// -// This matcher accepts a callable and verifies that when invoked, it throws -// an exception with the given type and properties. -// -// Examples: -// -// EXPECT_THAT( -// []() { throw std::runtime_error("message"); }, -// Throws<std::runtime_error>()); -// -// EXPECT_THAT( -// []() { throw std::runtime_error("message"); }, -// ThrowsMessage<std::runtime_error>(HasSubstr("message"))); -// -// EXPECT_THAT( -// []() { throw std::runtime_error("message"); }, -// Throws<std::runtime_error>( -// Property(&std::runtime_error::what, HasSubstr("message")))); - -template <typename Err> -PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws() { - return MakePolymorphicMatcher( - internal::ExceptionMatcherImpl<Err>(A<const Err&>())); -} - -template <typename Err, typename ExceptionMatcher> -PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws( - const ExceptionMatcher& exception_matcher) { - // Using matcher cast allows users to pass a matcher of a more broad type. - // For example user may want to pass Matcher<std::exception> - // to Throws<std::runtime_error>, or Matcher<int64> to Throws<int32>. - return MakePolymorphicMatcher(internal::ExceptionMatcherImpl<Err>( - SafeMatcherCast<const Err&>(exception_matcher))); -} - -template <typename Err, typename MessageMatcher> -PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage( - MessageMatcher&& message_matcher) { - static_assert(std::is_base_of<std::exception, Err>::value, - "expected an std::exception-derived type"); - return Throws<Err>(internal::WithWhat( - MatcherCast<std::string>(std::forward<MessageMatcher>(message_matcher)))); -} - -#endif // GTEST_HAS_EXCEPTIONS - -// These macros allow using matchers to check values in Google Test -// tests. ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher) -// succeed if and only if the value matches the matcher. If the assertion -// fails, the value and the description of the matcher will be printed. -#define ASSERT_THAT(value, matcher) \ - ASSERT_PRED_FORMAT1( \ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) -#define EXPECT_THAT(value, matcher) \ - EXPECT_PRED_FORMAT1( \ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) - -// MATCHER* macros itself are listed below. -#define MATCHER(name, description) \ - class name##Matcher \ - : public ::testing::internal::MatcherBaseImpl<name##Matcher> { \ - public: \ - template <typename arg_type> \ - class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> { \ - public: \ - gmock_Impl() {} \ - bool MatchAndExplain( \ - const arg_type& arg, \ - ::testing::MatchResultListener* result_listener) const override; \ - void DescribeTo(::std::ostream* gmock_os) const override { \ - *gmock_os << FormatDescription(false); \ - } \ - void DescribeNegationTo(::std::ostream* gmock_os) const override { \ - *gmock_os << FormatDescription(true); \ - } \ - \ - private: \ - ::std::string FormatDescription(bool negation) const { \ - /* NOLINTNEXTLINE readability-redundant-string-init */ \ - ::std::string gmock_description = (description); \ - if (!gmock_description.empty()) { \ - return gmock_description; \ - } \ - return ::testing::internal::FormatMatcherDescription(negation, #name, \ - {}, {}); \ - } \ - }; \ - }; \ - GTEST_ATTRIBUTE_UNUSED_ inline name##Matcher name() { return {}; } \ - template <typename arg_type> \ - bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain( \ - const arg_type& arg, \ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \ - const - -#define MATCHER_P(name, p0, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (#p0), (p0)) -#define MATCHER_P2(name, p0, p1, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (#p0, #p1), \ - (p0, p1)) -#define MATCHER_P3(name, p0, p1, p2, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (#p0, #p1, #p2), \ - (p0, p1, p2)) -#define MATCHER_P4(name, p0, p1, p2, p3, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, \ - (#p0, #p1, #p2, #p3), (p0, p1, p2, p3)) -#define MATCHER_P5(name, p0, p1, p2, p3, p4, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \ - (#p0, #p1, #p2, #p3, #p4), (p0, p1, p2, p3, p4)) -#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description, \ - (#p0, #p1, #p2, #p3, #p4, #p5), \ - (p0, p1, p2, p3, p4, p5)) -#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description, \ - (#p0, #p1, #p2, #p3, #p4, #p5, #p6), \ - (p0, p1, p2, p3, p4, p5, p6)) -#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description, \ - (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7), \ - (p0, p1, p2, p3, p4, p5, p6, p7)) -#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description, \ - (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7, #p8), \ - (p0, p1, p2, p3, p4, p5, p6, p7, p8)) -#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description, \ - (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7, #p8, #p9), \ - (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) - -#define GMOCK_INTERNAL_MATCHER(name, full_name, description, arg_names, args) \ - template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \ - class full_name : public ::testing::internal::MatcherBaseImpl< \ - full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \ - public: \ - using full_name::MatcherBaseImpl::MatcherBaseImpl; \ - template <typename arg_type> \ - class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> { \ - public: \ - explicit gmock_Impl(GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) \ - : GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) {} \ - bool MatchAndExplain( \ - const arg_type& arg, \ - ::testing::MatchResultListener* result_listener) const override; \ - void DescribeTo(::std::ostream* gmock_os) const override { \ - *gmock_os << FormatDescription(false); \ - } \ - void DescribeNegationTo(::std::ostream* gmock_os) const override { \ - *gmock_os << FormatDescription(true); \ - } \ - GMOCK_INTERNAL_MATCHER_MEMBERS(args) \ - \ - private: \ - ::std::string FormatDescription(bool negation) const { \ - ::std::string gmock_description = (description); \ - if (!gmock_description.empty()) { \ - return gmock_description; \ - } \ - return ::testing::internal::FormatMatcherDescription( \ - negation, #name, {GMOCK_PP_REMOVE_PARENS(arg_names)}, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings( \ - ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>( \ - GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args)))); \ - } \ - }; \ - }; \ - template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \ - inline full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)> name( \ - GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) { \ - return full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>( \ - GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args)); \ - } \ - template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \ - template <typename arg_type> \ - bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl< \ - arg_type>::MatchAndExplain(const arg_type& arg, \ - ::testing::MatchResultListener* \ - result_listener GTEST_ATTRIBUTE_UNUSED_) \ - const - -#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \ - GMOCK_PP_TAIL( \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM, , args)) -#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM(i_unused, data_unused, arg) \ - , typename arg##_type - -#define GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TYPE_PARAM, , args)) -#define GMOCK_INTERNAL_MATCHER_TYPE_PARAM(i_unused, data_unused, arg) \ - , arg##_type - -#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args) \ - GMOCK_PP_TAIL(dummy_first GMOCK_PP_FOR_EACH( \ - GMOCK_INTERNAL_MATCHER_FUNCTION_ARG, , args)) -#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARG(i, data_unused, arg) \ - , arg##_type gmock_p##i - -#define GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_FORWARD_ARG, , args)) -#define GMOCK_INTERNAL_MATCHER_FORWARD_ARG(i, data_unused, arg) \ - , arg(::std::forward<arg##_type>(gmock_p##i)) - -#define GMOCK_INTERNAL_MATCHER_MEMBERS(args) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER, , args) -#define GMOCK_INTERNAL_MATCHER_MEMBER(i_unused, data_unused, arg) \ - const arg##_type arg; - -#define GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER_USAGE, , args)) -#define GMOCK_INTERNAL_MATCHER_MEMBER_USAGE(i_unused, data_unused, arg) , arg - -#define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args)) -#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \ - , gmock_p##i - -// To prevent ADL on certain functions we put them on a separate namespace. -using namespace no_adl; // NOLINT - -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 5046 - -// Include any custom callback matchers added by the local installation. -// We must include this header at the end to make sure it can use the -// declarations from this file. -#include "gmock/internal/custom/gmock-matchers.h" - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/gmock-more-actions.h b/third_party/googletest/src/googlemock/include/gmock/gmock-more-actions.h deleted file mode 100644 index 148ac01..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/gmock-more-actions.h +++ /dev/null
@@ -1,662 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some commonly used variadic actions. - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ - -#include <memory> -#include <utility> - -#include "gmock/gmock-actions.h" -#include "gmock/internal/gmock-port.h" - -// Include any custom callback actions added by the local installation. -#include "gmock/internal/custom/gmock-generated-actions.h" - -// Sometimes you want to give an action explicit template parameters -// that cannot be inferred from its value parameters. ACTION() and -// ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that -// and can be viewed as an extension to ACTION() and ACTION_P*(). -// -// The syntax: -// -// ACTION_TEMPLATE(ActionName, -// HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), -// AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } -// -// defines an action template that takes m explicit template -// parameters and n value parameters. name_i is the name of the i-th -// template parameter, and kind_i specifies whether it's a typename, -// an integral constant, or a template. p_i is the name of the i-th -// value parameter. -// -// Example: -// -// // DuplicateArg<k, T>(output) converts the k-th argument of the mock -// // function to type T and copies it to *output. -// ACTION_TEMPLATE(DuplicateArg, -// HAS_2_TEMPLATE_PARAMS(int, k, typename, T), -// AND_1_VALUE_PARAMS(output)) { -// *output = T(::std::get<k>(args)); -// } -// ... -// int n; -// EXPECT_CALL(mock, Foo(_, _)) -// .WillOnce(DuplicateArg<1, unsigned char>(&n)); -// -// To create an instance of an action template, write: -// -// ActionName<t1, ..., t_m>(v1, ..., v_n) -// -// where the ts are the template arguments and the vs are the value -// arguments. The value argument types are inferred by the compiler. -// If you want to explicitly specify the value argument types, you can -// provide additional template arguments: -// -// ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n) -// -// where u_i is the desired type of v_i. -// -// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the -// number of value parameters, but not on the number of template -// parameters. Without the restriction, the meaning of the following -// is unclear: -// -// OverloadedAction<int, bool>(x); -// -// Are we using a single-template-parameter action where 'bool' refers -// to the type of x, or are we using a two-template-parameter action -// where the compiler is asked to infer the type of x? -// -// Implementation notes: -// -// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and -// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for -// implementing ACTION_TEMPLATE. The main trick we use is to create -// new macro invocations when expanding a macro. For example, we have -// -// #define ACTION_TEMPLATE(name, template_params, value_params) -// ... GMOCK_INTERNAL_DECL_##template_params ... -// -// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) -// to expand to -// -// ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... -// -// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the -// preprocessor will continue to expand it to -// -// ... typename T ... -// -// This technique conforms to the C++ standard and is portable. It -// allows us to implement action templates using O(N) code, where N is -// the maximum number of template/value parameters supported. Without -// using it, we'd have to devote O(N^2) amount of code to implement all -// combinations of m and n. - -// Declares the template parameters. -#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0 -#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, name1) \ - kind0 name0, kind1 name1 -#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2) \ - kind0 name0, kind1 name1, kind2 name2 -#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3) \ - kind0 name0, kind1 name1, kind2 name2, kind3 name3 -#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4) \ - kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4 -#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, \ - kind4, name4, kind5, name5) \ - kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5 -#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \ - kind5, name5, kind6, name6) \ - kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \ - kind5 name5, kind6 name6 -#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \ - kind5, name5, kind6, name6, kind7, name7) \ - kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \ - kind5 name5, kind6 name6, kind7 name7 -#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \ - kind5, name5, kind6, name6, kind7, name7, kind8, name8) \ - kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \ - kind5 name5, kind6 name6, kind7 name7, kind8 name8 -#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \ - kind5, name5, kind6, name6, kind7, name7, kind8, name8, kind9, name9) \ - kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \ - kind5 name5, kind6 name6, kind7 name7, kind8 name8, kind9 name9 - -// Lists the template parameters. -#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0 -#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, name1) \ - name0, name1 -#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2) \ - name0, name1, name2 -#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3) \ - name0, name1, name2, name3 -#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4) \ - name0, name1, name2, name3, name4 -#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, \ - kind4, name4, kind5, name5) \ - name0, name1, name2, name3, name4, name5 -#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \ - kind5, name5, kind6, name6) \ - name0, name1, name2, name3, name4, name5, name6 -#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \ - kind5, name5, kind6, name6, kind7, name7) \ - name0, name1, name2, name3, name4, name5, name6, name7 -#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \ - kind5, name5, kind6, name6, kind7, name7, kind8, name8) \ - name0, name1, name2, name3, name4, name5, name6, name7, name8 -#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS( \ - kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \ - kind5, name5, kind6, name6, kind7, name7, kind8, name8, kind9, name9) \ - name0, name1, name2, name3, name4, name5, name6, name7, name8, name9 - -// Declares the types of value parameters. -#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) \ - , typename p0##_type, typename p1##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) \ - , typename p0##_type, typename p1##_type, typename p2##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \ - , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \ - , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \ - , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) \ - , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7) \ - , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type, typename p7##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8) \ - , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type, typename p7##_type, typename p8##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8, p9) \ - , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type, typename p7##_type, typename p8##_type, \ - typename p9##_type - -// Initializes the value parameters. -#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS() () -#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0) \ - (p0##_type gmock_p0) : p0(::std::move(gmock_p0)) -#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1) \ - (p0##_type gmock_p0, p1##_type gmock_p1) \ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)) -#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2) \ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2) \ - : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)) -#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3) \ - : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)) -#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4) \ - : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)) -#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5) \ - : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)) -#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) \ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6) \ - : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), \ - p6(::std::move(gmock_p6)) -#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7) \ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7) \ - : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), \ - p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)) -#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, \ - p8) \ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8) \ - : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), \ - p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)), \ - p8(::std::move(gmock_p8)) -#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) \ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ - p9##_type gmock_p9) \ - : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), \ - p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)), \ - p8(::std::move(gmock_p8)), \ - p9(::std::move(gmock_p9)) - -// Defines the copy constructor -#define GMOCK_INTERNAL_DEFN_COPY_AND_0_VALUE_PARAMS() \ - {} // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134 -#define GMOCK_INTERNAL_DEFN_COPY_AND_1_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_2_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_3_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_4_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_5_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_6_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_7_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_8_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_9_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_10_VALUE_PARAMS(...) = default; - -// Declares the fields for storing the value parameters. -#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0; -#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) \ - p0##_type p0; \ - p1##_type p1; -#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) \ - p0##_type p0; \ - p1##_type p1; \ - p2##_type p2; -#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \ - p0##_type p0; \ - p1##_type p1; \ - p2##_type p2; \ - p3##_type p3; -#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \ - p0##_type p0; \ - p1##_type p1; \ - p2##_type p2; \ - p3##_type p3; \ - p4##_type p4; -#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \ - p0##_type p0; \ - p1##_type p1; \ - p2##_type p2; \ - p3##_type p3; \ - p4##_type p4; \ - p5##_type p5; -#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) \ - p0##_type p0; \ - p1##_type p1; \ - p2##_type p2; \ - p3##_type p3; \ - p4##_type p4; \ - p5##_type p5; \ - p6##_type p6; -#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7) \ - p0##_type p0; \ - p1##_type p1; \ - p2##_type p2; \ - p3##_type p3; \ - p4##_type p4; \ - p5##_type p5; \ - p6##_type p6; \ - p7##_type p7; -#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, \ - p8) \ - p0##_type p0; \ - p1##_type p1; \ - p2##_type p2; \ - p3##_type p3; \ - p4##_type p4; \ - p5##_type p5; \ - p6##_type p6; \ - p7##_type p7; \ - p8##_type p8; -#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) \ - p0##_type p0; \ - p1##_type p1; \ - p2##_type p2; \ - p3##_type p3; \ - p4##_type p4; \ - p5##_type p5; \ - p6##_type p6; \ - p7##_type p7; \ - p8##_type p8; \ - p9##_type p9; - -// Lists the value parameters. -#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0 -#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1 -#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2 -#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3 -#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \ - p0, p1, p2, p3, p4 -#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \ - p0, p1, p2, p3, p4, p5 -#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) \ - p0, p1, p2, p3, p4, p5, p6 -#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7) \ - p0, p1, p2, p3, p4, p5, p6, p7 -#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, \ - p8) \ - p0, p1, p2, p3, p4, p5, p6, p7, p8 -#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) \ - p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 - -// Lists the value parameter types. -#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) \ - , p0##_type, p1##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) \ - , p0##_type, p1##_type, p2##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \ - , p0##_type, p1##_type, p2##_type, p3##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \ - , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \ - , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) \ - , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, p6##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7) \ - , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \ - p6##_type, p7##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8) \ - , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \ - p6##_type, p7##_type, p8##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8, p9) \ - , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \ - p6##_type, p7##_type, p8##_type, p9##_type - -// Declares the value parameters. -#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0 -#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) \ - p0##_type p0, p1##_type p1 -#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) \ - p0##_type p0, p1##_type p1, p2##_type p2 -#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \ - p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3 -#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \ - p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4 -#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \ - p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5 -#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) \ - p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5, p6##_type p6 -#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7) \ - p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5, p6##_type p6, p7##_type p7 -#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, \ - p8) \ - p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8 -#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) \ - p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, p9##_type p9 - -// The suffix of the class template implementing the action template. -#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P -#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2 -#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3 -#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4 -#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5 -#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6 -#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7 -#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7) \ - P8 -#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8) \ - P9 -#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) \ - P10 - -// The name of the class template implementing the action template. -#define GMOCK_ACTION_CLASS_(name, value_params) \ - GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) - -#define ACTION_TEMPLATE(name, template_params, value_params) \ - template <GMOCK_INTERNAL_DECL_##template_params \ - GMOCK_INTERNAL_DECL_TYPE_##value_params> \ - class GMOCK_ACTION_CLASS_(name, value_params) { \ - public: \ - explicit GMOCK_ACTION_CLASS_(name, value_params)( \ - GMOCK_INTERNAL_DECL_##value_params) \ - GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params), \ - = default; \ - , \ - : impl_(std::make_shared<gmock_Impl>( \ - GMOCK_INTERNAL_LIST_##value_params)){}) \ - GMOCK_ACTION_CLASS_(name, value_params)(const GMOCK_ACTION_CLASS_( \ - name, value_params) &) noexcept GMOCK_INTERNAL_DEFN_COPY_ \ - ##value_params GMOCK_ACTION_CLASS_(name, value_params)( \ - GMOCK_ACTION_CLASS_(name, value_params) &&) noexcept \ - GMOCK_INTERNAL_DEFN_COPY_##value_params template <typename F> \ - operator ::testing::Action<F>() const { \ - return GMOCK_PP_IF( \ - GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params), \ - (::testing::internal::MakeAction<F, gmock_Impl>()), \ - (::testing::internal::MakeAction<F>(impl_))); \ - } \ - \ - private: \ - class gmock_Impl { \ - public: \ - explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {} \ - template <typename function_type, typename return_type, \ - typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ - GMOCK_INTERNAL_DEFN_##value_params \ - }; \ - GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params), , \ - std::shared_ptr<const gmock_Impl> impl_;) \ - }; \ - template <GMOCK_INTERNAL_DECL_##template_params \ - GMOCK_INTERNAL_DECL_TYPE_##value_params> \ - GMOCK_ACTION_CLASS_( \ - name, value_params)<GMOCK_INTERNAL_LIST_##template_params \ - GMOCK_INTERNAL_LIST_TYPE_##value_params> \ - name(GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_; \ - template <GMOCK_INTERNAL_DECL_##template_params \ - GMOCK_INTERNAL_DECL_TYPE_##value_params> \ - inline GMOCK_ACTION_CLASS_( \ - name, value_params)<GMOCK_INTERNAL_LIST_##template_params \ - GMOCK_INTERNAL_LIST_TYPE_##value_params> \ - name(GMOCK_INTERNAL_DECL_##value_params) { \ - return GMOCK_ACTION_CLASS_( \ - name, value_params)<GMOCK_INTERNAL_LIST_##template_params \ - GMOCK_INTERNAL_LIST_TYPE_##value_params>( \ - GMOCK_INTERNAL_LIST_##value_params); \ - } \ - template <GMOCK_INTERNAL_DECL_##template_params \ - GMOCK_INTERNAL_DECL_TYPE_##value_params> \ - template <typename function_type, typename return_type, typename args_type, \ - GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type GMOCK_ACTION_CLASS_( \ - name, value_params)<GMOCK_INTERNAL_LIST_##template_params \ - GMOCK_INTERNAL_LIST_TYPE_##value_params>:: \ - gmock_Impl::gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) \ - const - -namespace testing { - -// The ACTION*() macros trigger warning C4100 (unreferenced formal -// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in -// the macro definition, as the warnings are generated when the macro -// is expanded and macro expansion cannot contain #pragma. Therefore -// we suppress them here. -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4100) -#endif - -namespace internal { - -// internal::InvokeArgument - a helper for InvokeArgument action. -// The basic overloads are provided here for generic functors. -// Overloads for other custom-callables are provided in the -// internal/custom/gmock-generated-actions.h header. -template <typename F, typename... Args> -auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) { - return f(args...); -} - -template <std::size_t index, typename... Params> -struct InvokeArgumentAction { - template <typename... Args, - typename = typename std::enable_if<(index < sizeof...(Args))>::type> - auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument( - std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)), - std::declval<const Params&>()...)) { - internal::FlatTuple<Args&&...> args_tuple(FlatTupleConstructTag{}, - std::forward<Args>(args)...); - return params.Apply([&](const Params&... unpacked_params) { - auto&& callable = args_tuple.template Get<index>(); - return internal::InvokeArgument( - std::forward<decltype(callable)>(callable), unpacked_params...); - }); - } - - internal::FlatTuple<Params...> params; -}; - -} // namespace internal - -// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th -// (0-based) argument, which must be a k-ary callable, of the mock -// function, with arguments a1, a2, ..., a_k. -// -// Notes: -// -// 1. The arguments are passed by value by default. If you need to -// pass an argument by reference, wrap it inside std::ref(). For -// example, -// -// InvokeArgument<1>(5, string("Hello"), std::ref(foo)) -// -// passes 5 and string("Hello") by value, and passes foo by -// reference. -// -// 2. If the callable takes an argument by reference but std::ref() is -// not used, it will receive the reference to a copy of the value, -// instead of the original value. For example, when the 0-th -// argument of the mock function takes a const string&, the action -// -// InvokeArgument<0>(string("Hello")) -// -// makes a copy of the temporary string("Hello") object and passes a -// reference of the copy, instead of the original temporary object, -// to the callable. This makes it easy for a user to define an -// InvokeArgument action from temporary values and have it performed -// later. -template <std::size_t index, typename... Params> -internal::InvokeArgumentAction<index, typename std::decay<Params>::type...> -InvokeArgument(Params&&... params) { - return {internal::FlatTuple<typename std::decay<Params>::type...>( - internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)}; -} - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/gmock-more-matchers.h b/third_party/googletest/src/googlemock/include/gmock/gmock-more-matchers.h deleted file mode 100644 index 47aaf98..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/gmock-more-matchers.h +++ /dev/null
@@ -1,91 +0,0 @@ -// Copyright 2013, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some matchers that depend on gmock-matchers.h. -// -// Note that tests are implemented in gmock-matchers_test.cc rather than -// gmock-more-matchers-test.cc. - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_ - -#include "gmock/gmock-matchers.h" - -namespace testing { - -// Silence C4100 (unreferenced formal -// parameter) for MSVC -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4100) -#if (_MSC_VER == 1900) -// and silence C4800 (C4800: 'int *const ': forcing value -// to bool 'true' or 'false') for MSVC 14 -#pragma warning(disable : 4800) -#endif -#endif - -// Defines a matcher that matches an empty container. The container must -// support both size() and empty(), which all STL-like containers provide. -MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") { - if (arg.empty()) { - return true; - } - *result_listener << "whose size is " << arg.size(); - return false; -} - -// Define a matcher that matches a value that evaluates in boolean -// context to true. Useful for types that define "explicit operator -// bool" operators and so can't be compared for equality with true -// and false. -MATCHER(IsTrue, negation ? "is false" : "is true") { - return static_cast<bool>(arg); -} - -// Define a matcher that matches a value that evaluates in boolean -// context to false. Useful for types that define "explicit operator -// bool" operators and so can't be compared for equality with true -// and false. -MATCHER(IsFalse, negation ? "is true" : "is false") { - return !static_cast<bool>(arg); -} - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/gmock-nice-strict.h b/third_party/googletest/src/googlemock/include/gmock/gmock-nice-strict.h deleted file mode 100644 index 4f0eb35..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/gmock-nice-strict.h +++ /dev/null
@@ -1,277 +0,0 @@ -// Copyright 2008, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Implements class templates NiceMock, NaggyMock, and StrictMock. -// -// Given a mock class MockFoo that is created using Google Mock, -// NiceMock<MockFoo> is a subclass of MockFoo that allows -// uninteresting calls (i.e. calls to mock methods that have no -// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo -// that prints a warning when an uninteresting call occurs, and -// StrictMock<MockFoo> is a subclass of MockFoo that treats all -// uninteresting calls as errors. -// -// Currently a mock is naggy by default, so MockFoo and -// NaggyMock<MockFoo> behave like the same. However, we will soon -// switch the default behavior of mocks to be nice, as that in general -// leads to more maintainable tests. When that happens, MockFoo will -// stop behaving like NaggyMock<MockFoo> and start behaving like -// NiceMock<MockFoo>. -// -// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of -// their respective base class. Therefore you can write -// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo -// has a constructor that accepts (int, const char*), for example. -// -// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>, -// and StrictMock<MockFoo> only works for mock methods defined using -// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. -// If a mock method is defined in a base class of MockFoo, the "nice" -// or "strict" modifier may not affect it, depending on the compiler. -// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT -// supported. - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_ - -#include <cstdint> -#include <type_traits> - -#include "gmock/gmock-spec-builders.h" -#include "gmock/internal/gmock-port.h" - -namespace testing { -template <class MockClass> -class NiceMock; -template <class MockClass> -class NaggyMock; -template <class MockClass> -class StrictMock; - -namespace internal { -template <typename T> -std::true_type StrictnessModifierProbe(const NiceMock<T>&); -template <typename T> -std::true_type StrictnessModifierProbe(const NaggyMock<T>&); -template <typename T> -std::true_type StrictnessModifierProbe(const StrictMock<T>&); -std::false_type StrictnessModifierProbe(...); - -template <typename T> -constexpr bool HasStrictnessModifier() { - return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value; -} - -// Base classes that register and deregister with testing::Mock to alter the -// default behavior around uninteresting calls. Inheriting from one of these -// classes first and then MockClass ensures the MockClass constructor is run -// after registration, and that the MockClass destructor runs before -// deregistration. This guarantees that MockClass's constructor and destructor -// run with the same level of strictness as its instance methods. - -#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \ - (defined(_MSC_VER) || defined(__clang__)) -// We need to mark these classes with this declspec to ensure that -// the empty base class optimization is performed. -#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases) -#else -#define GTEST_INTERNAL_EMPTY_BASE_CLASS -#endif - -template <typename Base> -class NiceMockImpl { - public: - NiceMockImpl() { - ::testing::Mock::AllowUninterestingCalls(reinterpret_cast<uintptr_t>(this)); - } - - ~NiceMockImpl() { - ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this)); - } -}; - -template <typename Base> -class NaggyMockImpl { - public: - NaggyMockImpl() { - ::testing::Mock::WarnUninterestingCalls(reinterpret_cast<uintptr_t>(this)); - } - - ~NaggyMockImpl() { - ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this)); - } -}; - -template <typename Base> -class StrictMockImpl { - public: - StrictMockImpl() { - ::testing::Mock::FailUninterestingCalls(reinterpret_cast<uintptr_t>(this)); - } - - ~StrictMockImpl() { - ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this)); - } -}; - -} // namespace internal - -template <class MockClass> -class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock - : private internal::NiceMockImpl<MockClass>, - public MockClass { - public: - static_assert(!internal::HasStrictnessModifier<MockClass>(), - "Can't apply NiceMock to a class hierarchy that already has a " - "strictness modifier. See " - "https://google.github.io/googletest/" - "gmock_cook_book.html#NiceStrictNaggy"); - NiceMock() : MockClass() { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - // Ideally, we would inherit base class's constructors through a using - // declaration, which would preserve their visibility. However, many existing - // tests rely on the fact that current implementation reexports protected - // constructors as public. These tests would need to be cleaned up first. - - // Single argument constructor is special-cased so that it can be - // made explicit. - template <typename A> - explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - template <typename TArg1, typename TArg2, typename... An> - NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args) - : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2), - std::forward<An>(args)...) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - private: - NiceMock(const NiceMock&) = delete; - NiceMock& operator=(const NiceMock&) = delete; -}; - -template <class MockClass> -class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock - : private internal::NaggyMockImpl<MockClass>, - public MockClass { - static_assert(!internal::HasStrictnessModifier<MockClass>(), - "Can't apply NaggyMock to a class hierarchy that already has a " - "strictness modifier. See " - "https://google.github.io/googletest/" - "gmock_cook_book.html#NiceStrictNaggy"); - - public: - NaggyMock() : MockClass() { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - // Ideally, we would inherit base class's constructors through a using - // declaration, which would preserve their visibility. However, many existing - // tests rely on the fact that current implementation reexports protected - // constructors as public. These tests would need to be cleaned up first. - - // Single argument constructor is special-cased so that it can be - // made explicit. - template <typename A> - explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - template <typename TArg1, typename TArg2, typename... An> - NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args) - : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2), - std::forward<An>(args)...) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - private: - NaggyMock(const NaggyMock&) = delete; - NaggyMock& operator=(const NaggyMock&) = delete; -}; - -template <class MockClass> -class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock - : private internal::StrictMockImpl<MockClass>, - public MockClass { - public: - static_assert( - !internal::HasStrictnessModifier<MockClass>(), - "Can't apply StrictMock to a class hierarchy that already has a " - "strictness modifier. See " - "https://google.github.io/googletest/" - "gmock_cook_book.html#NiceStrictNaggy"); - StrictMock() : MockClass() { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - // Ideally, we would inherit base class's constructors through a using - // declaration, which would preserve their visibility. However, many existing - // tests rely on the fact that current implementation reexports protected - // constructors as public. These tests would need to be cleaned up first. - - // Single argument constructor is special-cased so that it can be - // made explicit. - template <typename A> - explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - template <typename TArg1, typename TArg2, typename... An> - StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args) - : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2), - std::forward<An>(args)...) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - private: - StrictMock(const StrictMock&) = delete; - StrictMock& operator=(const StrictMock&) = delete; -}; - -#undef GTEST_INTERNAL_EMPTY_BASE_CLASS - -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/gmock-spec-builders.h b/third_party/googletest/src/googlemock/include/gmock/gmock-spec-builders.h deleted file mode 100644 index 45cc605..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/gmock-spec-builders.h +++ /dev/null
@@ -1,2083 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements the ON_CALL() and EXPECT_CALL() macros. -// -// A user can use the ON_CALL() macro to specify the default action of -// a mock method. The syntax is: -// -// ON_CALL(mock_object, Method(argument-matchers)) -// .With(multi-argument-matcher) -// .WillByDefault(action); -// -// where the .With() clause is optional. -// -// A user can use the EXPECT_CALL() macro to specify an expectation on -// a mock method. The syntax is: -// -// EXPECT_CALL(mock_object, Method(argument-matchers)) -// .With(multi-argument-matchers) -// .Times(cardinality) -// .InSequence(sequences) -// .After(expectations) -// .WillOnce(action) -// .WillRepeatedly(action) -// .RetiresOnSaturation(); -// -// where all clauses are optional, and .InSequence()/.After()/ -// .WillOnce() can appear any number of times. - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ - -#include <cstdint> -#include <functional> -#include <map> -#include <memory> -#include <set> -#include <sstream> -#include <string> -#include <type_traits> -#include <utility> -#include <vector> - -#include "gmock/gmock-actions.h" -#include "gmock/gmock-cardinalities.h" -#include "gmock/gmock-matchers.h" -#include "gmock/internal/gmock-internal-utils.h" -#include "gmock/internal/gmock-port.h" -#include "gtest/gtest.h" - -#if GTEST_HAS_EXCEPTIONS -#include <stdexcept> // NOLINT -#endif - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { - -// An abstract handle of an expectation. -class Expectation; - -// A set of expectation handles. -class ExpectationSet; - -// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION -// and MUST NOT BE USED IN USER CODE!!! -namespace internal { - -// Implements a mock function. -template <typename F> -class FunctionMocker; - -// Base class for expectations. -class ExpectationBase; - -// Implements an expectation. -template <typename F> -class TypedExpectation; - -// Helper class for testing the Expectation class template. -class ExpectationTester; - -// Helper classes for implementing NiceMock, StrictMock, and NaggyMock. -template <typename MockClass> -class NiceMockImpl; -template <typename MockClass> -class StrictMockImpl; -template <typename MockClass> -class NaggyMockImpl; - -// Protects the mock object registry (in class Mock), all function -// mockers, and all expectations. -// -// The reason we don't use more fine-grained protection is: when a -// mock function Foo() is called, it needs to consult its expectations -// to see which one should be picked. If another thread is allowed to -// call a mock function (either Foo() or a different one) at the same -// time, it could affect the "retired" attributes of Foo()'s -// expectations when InSequence() is used, and thus affect which -// expectation gets picked. Therefore, we sequence all mock function -// calls to ensure the integrity of the mock objects' states. -GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex); - -// Abstract base class of FunctionMocker. This is the -// type-agnostic part of the function mocker interface. Its pure -// virtual methods are implemented by FunctionMocker. -class GTEST_API_ UntypedFunctionMockerBase { - public: - UntypedFunctionMockerBase(); - virtual ~UntypedFunctionMockerBase(); - - // Verifies that all expectations on this mock function have been - // satisfied. Reports one or more Google Test non-fatal failures - // and returns false if not. - bool VerifyAndClearExpectationsLocked() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // Clears the ON_CALL()s set on this mock function. - virtual void ClearDefaultActionsLocked() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0; - - // In all of the following Untyped* functions, it's the caller's - // responsibility to guarantee the correctness of the arguments' - // types. - - // Writes a message that the call is uninteresting (i.e. neither - // explicitly expected nor explicitly unexpected) to the given - // ostream. - virtual void UntypedDescribeUninterestingCall(const void* untyped_args, - ::std::ostream* os) const - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0; - - // Returns the expectation that matches the given function arguments - // (or NULL is there's no match); when a match is found, - // untyped_action is set to point to the action that should be - // performed (or NULL if the action is "do default"), and - // is_excessive is modified to indicate whether the call exceeds the - // expected number. - virtual const ExpectationBase* UntypedFindMatchingExpectation( - const void* untyped_args, const void** untyped_action, bool* is_excessive, - ::std::ostream* what, ::std::ostream* why) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0; - - // Prints the given function arguments to the ostream. - virtual void UntypedPrintArgs(const void* untyped_args, - ::std::ostream* os) const = 0; - - // Sets the mock object this mock method belongs to, and registers - // this information in the global mock registry. Will be called - // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock - // method. - void RegisterOwner(const void* mock_obj) GTEST_LOCK_EXCLUDED_(g_gmock_mutex); - - // Sets the mock object this mock method belongs to, and sets the - // name of the mock function. Will be called upon each invocation - // of this mock function. - void SetOwnerAndName(const void* mock_obj, const char* name) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex); - - // Returns the mock object this mock method belongs to. Must be - // called after RegisterOwner() or SetOwnerAndName() has been - // called. - const void* MockObject() const GTEST_LOCK_EXCLUDED_(g_gmock_mutex); - - // Returns the name of this mock method. Must be called after - // SetOwnerAndName() has been called. - const char* Name() const GTEST_LOCK_EXCLUDED_(g_gmock_mutex); - - protected: - typedef std::vector<const void*> UntypedOnCallSpecs; - - using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>; - - // Returns an Expectation object that references and co-owns exp, - // which must be an expectation on this mock function. - Expectation GetHandleOf(ExpectationBase* exp); - - // Address of the mock object this mock method belongs to. Only - // valid after this mock method has been called or - // ON_CALL/EXPECT_CALL has been invoked on it. - const void* mock_obj_; // Protected by g_gmock_mutex. - - // Name of the function being mocked. Only valid after this mock - // method has been called. - const char* name_; // Protected by g_gmock_mutex. - - // All default action specs for this function mocker. - UntypedOnCallSpecs untyped_on_call_specs_; - - // All expectations for this function mocker. - // - // It's undefined behavior to interleave expectations (EXPECT_CALLs - // or ON_CALLs) and mock function calls. Also, the order of - // expectations is important. Therefore it's a logic race condition - // to read/write untyped_expectations_ concurrently. In order for - // tools like tsan to catch concurrent read/write accesses to - // untyped_expectations, we deliberately leave accesses to it - // unprotected. - UntypedExpectations untyped_expectations_; -}; // class UntypedFunctionMockerBase - -// Untyped base class for OnCallSpec<F>. -class UntypedOnCallSpecBase { - public: - // The arguments are the location of the ON_CALL() statement. - UntypedOnCallSpecBase(const char* a_file, int a_line) - : file_(a_file), line_(a_line), last_clause_(kNone) {} - - // Where in the source file was the default action spec defined? - const char* file() const { return file_; } - int line() const { return line_; } - - protected: - // Gives each clause in the ON_CALL() statement a name. - enum Clause { - // Do not change the order of the enum members! The run-time - // syntax checking relies on it. - kNone, - kWith, - kWillByDefault - }; - - // Asserts that the ON_CALL() statement has a certain property. - void AssertSpecProperty(bool property, - const std::string& failure_message) const { - Assert(property, file_, line_, failure_message); - } - - // Expects that the ON_CALL() statement has a certain property. - void ExpectSpecProperty(bool property, - const std::string& failure_message) const { - Expect(property, file_, line_, failure_message); - } - - const char* file_; - int line_; - - // The last clause in the ON_CALL() statement as seen so far. - // Initially kNone and changes as the statement is parsed. - Clause last_clause_; -}; // class UntypedOnCallSpecBase - -// This template class implements an ON_CALL spec. -template <typename F> -class OnCallSpec : public UntypedOnCallSpecBase { - public: - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple; - - // Constructs an OnCallSpec object from the information inside - // the parenthesis of an ON_CALL() statement. - OnCallSpec(const char* a_file, int a_line, - const ArgumentMatcherTuple& matchers) - : UntypedOnCallSpecBase(a_file, a_line), - matchers_(matchers), - // By default, extra_matcher_ should match anything. However, - // we cannot initialize it with _ as that causes ambiguity between - // Matcher's copy and move constructor for some argument types. - extra_matcher_(A<const ArgumentTuple&>()) {} - - // Implements the .With() clause. - OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) { - // Makes sure this is called at most once. - ExpectSpecProperty(last_clause_ < kWith, - ".With() cannot appear " - "more than once in an ON_CALL()."); - last_clause_ = kWith; - - extra_matcher_ = m; - return *this; - } - - // Implements the .WillByDefault() clause. - OnCallSpec& WillByDefault(const Action<F>& action) { - ExpectSpecProperty(last_clause_ < kWillByDefault, - ".WillByDefault() must appear " - "exactly once in an ON_CALL()."); - last_clause_ = kWillByDefault; - - ExpectSpecProperty(!action.IsDoDefault(), - "DoDefault() cannot be used in ON_CALL()."); - action_ = action; - return *this; - } - - // Returns true if and only if the given arguments match the matchers. - bool Matches(const ArgumentTuple& args) const { - return TupleMatches(matchers_, args) && extra_matcher_.Matches(args); - } - - // Returns the action specified by the user. - const Action<F>& GetAction() const { - AssertSpecProperty(last_clause_ == kWillByDefault, - ".WillByDefault() must appear exactly " - "once in an ON_CALL()."); - return action_; - } - - private: - // The information in statement - // - // ON_CALL(mock_object, Method(matchers)) - // .With(multi-argument-matcher) - // .WillByDefault(action); - // - // is recorded in the data members like this: - // - // source file that contains the statement => file_ - // line number of the statement => line_ - // matchers => matchers_ - // multi-argument-matcher => extra_matcher_ - // action => action_ - ArgumentMatcherTuple matchers_; - Matcher<const ArgumentTuple&> extra_matcher_; - Action<F> action_; -}; // class OnCallSpec - -// Possible reactions on uninteresting calls. -enum CallReaction { - kAllow, - kWarn, - kFail, -}; - -} // namespace internal - -// Utilities for manipulating mock objects. -class GTEST_API_ Mock { - public: - // The following public methods can be called concurrently. - - // Tells Google Mock to ignore mock_obj when checking for leaked - // mock objects. - static void AllowLeak(const void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Verifies and clears all expectations on the given mock object. - // If the expectations aren't satisfied, generates one or more - // Google Test non-fatal failures and returns false. - static bool VerifyAndClearExpectations(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Verifies all expectations on the given mock object and clears its - // default actions and expectations. Returns true if and only if the - // verification was successful. - static bool VerifyAndClear(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Returns whether the mock was created as a naggy mock (default) - static bool IsNaggy(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - // Returns whether the mock was created as a nice mock - static bool IsNice(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - // Returns whether the mock was created as a strict mock - static bool IsStrict(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - private: - friend class internal::UntypedFunctionMockerBase; - - // Needed for a function mocker to register itself (so that we know - // how to clear a mock object). - template <typename F> - friend class internal::FunctionMocker; - - template <typename MockClass> - friend class internal::NiceMockImpl; - template <typename MockClass> - friend class internal::NaggyMockImpl; - template <typename MockClass> - friend class internal::StrictMockImpl; - - // Tells Google Mock to allow uninteresting calls on the given mock - // object. - static void AllowUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Tells Google Mock to warn the user about uninteresting calls on - // the given mock object. - static void WarnUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Tells Google Mock to fail uninteresting calls on the given mock - // object. - static void FailUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Tells Google Mock the given mock object is being destroyed and - // its entry in the call-reaction table should be removed. - static void UnregisterCallReaction(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Returns the reaction Google Mock will have on uninteresting calls - // made on the given mock object. - static internal::CallReaction GetReactionOnUninterestingCalls( - const void* mock_obj) GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Verifies that all expectations on the given mock object have been - // satisfied. Reports one or more Google Test non-fatal failures - // and returns false if not. - static bool VerifyAndClearExpectationsLocked(void* mock_obj) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex); - - // Clears all ON_CALL()s set on the given mock object. - static void ClearDefaultActionsLocked(void* mock_obj) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex); - - // Registers a mock object and a mock method it owns. - static void Register(const void* mock_obj, - internal::UntypedFunctionMockerBase* mocker) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Tells Google Mock where in the source code mock_obj is used in an - // ON_CALL or EXPECT_CALL. In case mock_obj is leaked, this - // information helps the user identify which object it is. - static void RegisterUseByOnCallOrExpectCall(const void* mock_obj, - const char* file, int line) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Unregisters a mock method; removes the owning mock object from - // the registry when the last mock method associated with it has - // been unregistered. This is called only in the destructor of - // FunctionMocker. - static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex); -}; // class Mock - -// An abstract handle of an expectation. Useful in the .After() -// clause of EXPECT_CALL() for setting the (partial) order of -// expectations. The syntax: -// -// Expectation e1 = EXPECT_CALL(...)...; -// EXPECT_CALL(...).After(e1)...; -// -// sets two expectations where the latter can only be matched after -// the former has been satisfied. -// -// Notes: -// - This class is copyable and has value semantics. -// - Constness is shallow: a const Expectation object itself cannot -// be modified, but the mutable methods of the ExpectationBase -// object it references can be called via expectation_base(). - -class GTEST_API_ Expectation { - public: - // Constructs a null object that doesn't reference any expectation. - Expectation(); - Expectation(Expectation&&) = default; - Expectation(const Expectation&) = default; - Expectation& operator=(Expectation&&) = default; - Expectation& operator=(const Expectation&) = default; - ~Expectation(); - - // This single-argument ctor must not be explicit, in order to support the - // Expectation e = EXPECT_CALL(...); - // syntax. - // - // A TypedExpectation object stores its pre-requisites as - // Expectation objects, and needs to call the non-const Retire() - // method on the ExpectationBase objects they reference. Therefore - // Expectation must receive a *non-const* reference to the - // ExpectationBase object. - Expectation(internal::ExpectationBase& exp); // NOLINT - - // The compiler-generated copy ctor and operator= work exactly as - // intended, so we don't need to define our own. - - // Returns true if and only if rhs references the same expectation as this - // object does. - bool operator==(const Expectation& rhs) const { - return expectation_base_ == rhs.expectation_base_; - } - - bool operator!=(const Expectation& rhs) const { return !(*this == rhs); } - - private: - friend class ExpectationSet; - friend class Sequence; - friend class ::testing::internal::ExpectationBase; - friend class ::testing::internal::UntypedFunctionMockerBase; - - template <typename F> - friend class ::testing::internal::FunctionMocker; - - template <typename F> - friend class ::testing::internal::TypedExpectation; - - // This comparator is needed for putting Expectation objects into a set. - class Less { - public: - bool operator()(const Expectation& lhs, const Expectation& rhs) const { - return lhs.expectation_base_.get() < rhs.expectation_base_.get(); - } - }; - - typedef ::std::set<Expectation, Less> Set; - - Expectation( - const std::shared_ptr<internal::ExpectationBase>& expectation_base); - - // Returns the expectation this object references. - const std::shared_ptr<internal::ExpectationBase>& expectation_base() const { - return expectation_base_; - } - - // A shared_ptr that co-owns the expectation this handle references. - std::shared_ptr<internal::ExpectationBase> expectation_base_; -}; - -// A set of expectation handles. Useful in the .After() clause of -// EXPECT_CALL() for setting the (partial) order of expectations. The -// syntax: -// -// ExpectationSet es; -// es += EXPECT_CALL(...)...; -// es += EXPECT_CALL(...)...; -// EXPECT_CALL(...).After(es)...; -// -// sets three expectations where the last one can only be matched -// after the first two have both been satisfied. -// -// This class is copyable and has value semantics. -class ExpectationSet { - public: - // A bidirectional iterator that can read a const element in the set. - typedef Expectation::Set::const_iterator const_iterator; - - // An object stored in the set. This is an alias of Expectation. - typedef Expectation::Set::value_type value_type; - - // Constructs an empty set. - ExpectationSet() {} - - // This single-argument ctor must not be explicit, in order to support the - // ExpectationSet es = EXPECT_CALL(...); - // syntax. - ExpectationSet(internal::ExpectationBase& exp) { // NOLINT - *this += Expectation(exp); - } - - // This single-argument ctor implements implicit conversion from - // Expectation and thus must not be explicit. This allows either an - // Expectation or an ExpectationSet to be used in .After(). - ExpectationSet(const Expectation& e) { // NOLINT - *this += e; - } - - // The compiler-generator ctor and operator= works exactly as - // intended, so we don't need to define our own. - - // Returns true if and only if rhs contains the same set of Expectation - // objects as this does. - bool operator==(const ExpectationSet& rhs) const { - return expectations_ == rhs.expectations_; - } - - bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); } - - // Implements the syntax - // expectation_set += EXPECT_CALL(...); - ExpectationSet& operator+=(const Expectation& e) { - expectations_.insert(e); - return *this; - } - - int size() const { return static_cast<int>(expectations_.size()); } - - const_iterator begin() const { return expectations_.begin(); } - const_iterator end() const { return expectations_.end(); } - - private: - Expectation::Set expectations_; -}; - -// Sequence objects are used by a user to specify the relative order -// in which the expectations should match. They are copyable (we rely -// on the compiler-defined copy constructor and assignment operator). -class GTEST_API_ Sequence { - public: - // Constructs an empty sequence. - Sequence() : last_expectation_(new Expectation) {} - - // Adds an expectation to this sequence. The caller must ensure - // that no other thread is accessing this Sequence object. - void AddExpectation(const Expectation& expectation) const; - - private: - // The last expectation in this sequence. - std::shared_ptr<Expectation> last_expectation_; -}; // class Sequence - -// An object of this type causes all EXPECT_CALL() statements -// encountered in its scope to be put in an anonymous sequence. The -// work is done in the constructor and destructor. You should only -// create an InSequence object on the stack. -// -// The sole purpose for this class is to support easy definition of -// sequential expectations, e.g. -// -// { -// InSequence dummy; // The name of the object doesn't matter. -// -// // The following expectations must match in the order they appear. -// EXPECT_CALL(a, Bar())...; -// EXPECT_CALL(a, Baz())...; -// ... -// EXPECT_CALL(b, Xyz())...; -// } -// -// You can create InSequence objects in multiple threads, as long as -// they are used to affect different mock objects. The idea is that -// each thread can create and set up its own mocks as if it's the only -// thread. However, for clarity of your tests we recommend you to set -// up mocks in the main thread unless you have a good reason not to do -// so. -class GTEST_API_ InSequence { - public: - InSequence(); - ~InSequence(); - - private: - bool sequence_created_; - - InSequence(const InSequence&) = delete; - InSequence& operator=(const InSequence&) = delete; -} GTEST_ATTRIBUTE_UNUSED_; - -namespace internal { - -// Points to the implicit sequence introduced by a living InSequence -// object (if any) in the current thread or NULL. -GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence; - -// Base class for implementing expectations. -// -// There are two reasons for having a type-agnostic base class for -// Expectation: -// -// 1. We need to store collections of expectations of different -// types (e.g. all pre-requisites of a particular expectation, all -// expectations in a sequence). Therefore these expectation objects -// must share a common base class. -// -// 2. We can avoid binary code bloat by moving methods not depending -// on the template argument of Expectation to the base class. -// -// This class is internal and mustn't be used by user code directly. -class GTEST_API_ ExpectationBase { - public: - // source_text is the EXPECT_CALL(...) source that created this Expectation. - ExpectationBase(const char* file, int line, const std::string& source_text); - - virtual ~ExpectationBase(); - - // Where in the source file was the expectation spec defined? - const char* file() const { return file_; } - int line() const { return line_; } - const char* source_text() const { return source_text_.c_str(); } - // Returns the cardinality specified in the expectation spec. - const Cardinality& cardinality() const { return cardinality_; } - - // Describes the source file location of this expectation. - void DescribeLocationTo(::std::ostream* os) const { - *os << FormatFileLocation(file(), line()) << " "; - } - - // Describes how many times a function call matching this - // expectation has occurred. - void DescribeCallCountTo(::std::ostream* os) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // If this mock method has an extra matcher (i.e. .With(matcher)), - // describes it to the ostream. - virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0; - - protected: - friend class ::testing::Expectation; - friend class UntypedFunctionMockerBase; - - enum Clause { - // Don't change the order of the enum members! - kNone, - kWith, - kTimes, - kInSequence, - kAfter, - kWillOnce, - kWillRepeatedly, - kRetiresOnSaturation - }; - - typedef std::vector<const void*> UntypedActions; - - // Returns an Expectation object that references and co-owns this - // expectation. - virtual Expectation GetHandle() = 0; - - // Asserts that the EXPECT_CALL() statement has the given property. - void AssertSpecProperty(bool property, - const std::string& failure_message) const { - Assert(property, file_, line_, failure_message); - } - - // Expects that the EXPECT_CALL() statement has the given property. - void ExpectSpecProperty(bool property, - const std::string& failure_message) const { - Expect(property, file_, line_, failure_message); - } - - // Explicitly specifies the cardinality of this expectation. Used - // by the subclasses to implement the .Times() clause. - void SpecifyCardinality(const Cardinality& cardinality); - - // Returns true if and only if the user specified the cardinality - // explicitly using a .Times(). - bool cardinality_specified() const { return cardinality_specified_; } - - // Sets the cardinality of this expectation spec. - void set_cardinality(const Cardinality& a_cardinality) { - cardinality_ = a_cardinality; - } - - // The following group of methods should only be called after the - // EXPECT_CALL() statement, and only when g_gmock_mutex is held by - // the current thread. - - // Retires all pre-requisites of this expectation. - void RetireAllPreRequisites() GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // Returns true if and only if this expectation is retired. - bool is_retired() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return retired_; - } - - // Retires this expectation. - void Retire() GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - retired_ = true; - } - - // Returns true if and only if this expectation is satisfied. - bool IsSatisfied() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return cardinality().IsSatisfiedByCallCount(call_count_); - } - - // Returns true if and only if this expectation is saturated. - bool IsSaturated() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return cardinality().IsSaturatedByCallCount(call_count_); - } - - // Returns true if and only if this expectation is over-saturated. - bool IsOverSaturated() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return cardinality().IsOverSaturatedByCallCount(call_count_); - } - - // Returns true if and only if all pre-requisites of this expectation are - // satisfied. - bool AllPrerequisitesAreSatisfied() const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // Adds unsatisfied pre-requisites of this expectation to 'result'. - void FindUnsatisfiedPrerequisites(ExpectationSet* result) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // Returns the number this expectation has been invoked. - int call_count() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return call_count_; - } - - // Increments the number this expectation has been invoked. - void IncrementCallCount() GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - call_count_++; - } - - // Checks the action count (i.e. the number of WillOnce() and - // WillRepeatedly() clauses) against the cardinality if this hasn't - // been done before. Prints a warning if there are too many or too - // few actions. - void CheckActionCountIfNotDone() const GTEST_LOCK_EXCLUDED_(mutex_); - - friend class ::testing::Sequence; - friend class ::testing::internal::ExpectationTester; - - template <typename Function> - friend class TypedExpectation; - - // Implements the .Times() clause. - void UntypedTimes(const Cardinality& a_cardinality); - - // This group of fields are part of the spec and won't change after - // an EXPECT_CALL() statement finishes. - const char* file_; // The file that contains the expectation. - int line_; // The line number of the expectation. - const std::string source_text_; // The EXPECT_CALL(...) source text. - // True if and only if the cardinality is specified explicitly. - bool cardinality_specified_; - Cardinality cardinality_; // The cardinality of the expectation. - // The immediate pre-requisites (i.e. expectations that must be - // satisfied before this expectation can be matched) of this - // expectation. We use std::shared_ptr in the set because we want an - // Expectation object to be co-owned by its FunctionMocker and its - // successors. This allows multiple mock objects to be deleted at - // different times. - ExpectationSet immediate_prerequisites_; - - // This group of fields are the current state of the expectation, - // and can change as the mock function is called. - int call_count_; // How many times this expectation has been invoked. - bool retired_; // True if and only if this expectation has retired. - UntypedActions untyped_actions_; - bool extra_matcher_specified_; - bool repeated_action_specified_; // True if a WillRepeatedly() was specified. - bool retires_on_saturation_; - Clause last_clause_; - mutable bool action_count_checked_; // Under mutex_. - mutable Mutex mutex_; // Protects action_count_checked_. -}; // class ExpectationBase - -template <typename F> -class TypedExpectation; - -// Implements an expectation for the given function type. -template <typename R, typename... Args> -class TypedExpectation<R(Args...)> : public ExpectationBase { - private: - using F = R(Args...); - - public: - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple; - typedef typename Function<F>::Result Result; - - TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line, - const std::string& a_source_text, - const ArgumentMatcherTuple& m) - : ExpectationBase(a_file, a_line, a_source_text), - owner_(owner), - matchers_(m), - // By default, extra_matcher_ should match anything. However, - // we cannot initialize it with _ as that causes ambiguity between - // Matcher's copy and move constructor for some argument types. - extra_matcher_(A<const ArgumentTuple&>()), - repeated_action_(DoDefault()) {} - - ~TypedExpectation() override { - // Check the validity of the action count if it hasn't been done - // yet (for example, if the expectation was never used). - CheckActionCountIfNotDone(); - for (UntypedActions::const_iterator it = untyped_actions_.begin(); - it != untyped_actions_.end(); ++it) { - delete static_cast<const Action<F>*>(*it); - } - } - - // Implements the .With() clause. - TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) { - if (last_clause_ == kWith) { - ExpectSpecProperty(false, - ".With() cannot appear " - "more than once in an EXPECT_CALL()."); - } else { - ExpectSpecProperty(last_clause_ < kWith, - ".With() must be the first " - "clause in an EXPECT_CALL()."); - } - last_clause_ = kWith; - - extra_matcher_ = m; - extra_matcher_specified_ = true; - return *this; - } - - // Implements the .Times() clause. - TypedExpectation& Times(const Cardinality& a_cardinality) { - ExpectationBase::UntypedTimes(a_cardinality); - return *this; - } - - // Implements the .Times() clause. - TypedExpectation& Times(int n) { return Times(Exactly(n)); } - - // Implements the .InSequence() clause. - TypedExpectation& InSequence(const Sequence& s) { - ExpectSpecProperty(last_clause_ <= kInSequence, - ".InSequence() cannot appear after .After()," - " .WillOnce(), .WillRepeatedly(), or " - ".RetiresOnSaturation()."); - last_clause_ = kInSequence; - - s.AddExpectation(GetHandle()); - return *this; - } - TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) { - return InSequence(s1).InSequence(s2); - } - TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, - const Sequence& s3) { - return InSequence(s1, s2).InSequence(s3); - } - TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, - const Sequence& s3, const Sequence& s4) { - return InSequence(s1, s2, s3).InSequence(s4); - } - TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, - const Sequence& s3, const Sequence& s4, - const Sequence& s5) { - return InSequence(s1, s2, s3, s4).InSequence(s5); - } - - // Implements that .After() clause. - TypedExpectation& After(const ExpectationSet& s) { - ExpectSpecProperty(last_clause_ <= kAfter, - ".After() cannot appear after .WillOnce()," - " .WillRepeatedly(), or " - ".RetiresOnSaturation()."); - last_clause_ = kAfter; - - for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) { - immediate_prerequisites_ += *it; - } - return *this; - } - TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) { - return After(s1).After(s2); - } - TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, - const ExpectationSet& s3) { - return After(s1, s2).After(s3); - } - TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, - const ExpectationSet& s3, const ExpectationSet& s4) { - return After(s1, s2, s3).After(s4); - } - TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, - const ExpectationSet& s3, const ExpectationSet& s4, - const ExpectationSet& s5) { - return After(s1, s2, s3, s4).After(s5); - } - - // Preferred, type-safe overload: consume anything that can be directly - // converted to a OnceAction, except for Action<F> objects themselves. - TypedExpectation& WillOnce(OnceAction<F> once_action) { - // Call the overload below, smuggling the OnceAction as a copyable callable. - // We know this is safe because a WillOnce action will not be called more - // than once. - return WillOnce(Action<F>(ActionAdaptor{ - std::make_shared<OnceAction<F>>(std::move(once_action)), - })); - } - - // Fallback overload: accept Action<F> objects and those actions that define - // `operator Action<F>` but not `operator OnceAction<F>`. - // - // This is templated in order to cause the overload above to be preferred - // when the input is convertible to either type. - template <int&... ExplicitArgumentBarrier, typename = void> - TypedExpectation& WillOnce(Action<F> action) { - ExpectSpecProperty(last_clause_ <= kWillOnce, - ".WillOnce() cannot appear after " - ".WillRepeatedly() or .RetiresOnSaturation()."); - last_clause_ = kWillOnce; - - untyped_actions_.push_back(new Action<F>(std::move(action))); - - if (!cardinality_specified()) { - set_cardinality(Exactly(static_cast<int>(untyped_actions_.size()))); - } - return *this; - } - - // Implements the .WillRepeatedly() clause. - TypedExpectation& WillRepeatedly(const Action<F>& action) { - if (last_clause_ == kWillRepeatedly) { - ExpectSpecProperty(false, - ".WillRepeatedly() cannot appear " - "more than once in an EXPECT_CALL()."); - } else { - ExpectSpecProperty(last_clause_ < kWillRepeatedly, - ".WillRepeatedly() cannot appear " - "after .RetiresOnSaturation()."); - } - last_clause_ = kWillRepeatedly; - repeated_action_specified_ = true; - - repeated_action_ = action; - if (!cardinality_specified()) { - set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size()))); - } - - // Now that no more action clauses can be specified, we check - // whether their count makes sense. - CheckActionCountIfNotDone(); - return *this; - } - - // Implements the .RetiresOnSaturation() clause. - TypedExpectation& RetiresOnSaturation() { - ExpectSpecProperty(last_clause_ < kRetiresOnSaturation, - ".RetiresOnSaturation() cannot appear " - "more than once."); - last_clause_ = kRetiresOnSaturation; - retires_on_saturation_ = true; - - // Now that no more action clauses can be specified, we check - // whether their count makes sense. - CheckActionCountIfNotDone(); - return *this; - } - - // Returns the matchers for the arguments as specified inside the - // EXPECT_CALL() macro. - const ArgumentMatcherTuple& matchers() const { return matchers_; } - - // Returns the matcher specified by the .With() clause. - const Matcher<const ArgumentTuple&>& extra_matcher() const { - return extra_matcher_; - } - - // Returns the action specified by the .WillRepeatedly() clause. - const Action<F>& repeated_action() const { return repeated_action_; } - - // If this mock method has an extra matcher (i.e. .With(matcher)), - // describes it to the ostream. - void MaybeDescribeExtraMatcherTo(::std::ostream* os) override { - if (extra_matcher_specified_) { - *os << " Expected args: "; - extra_matcher_.DescribeTo(os); - *os << "\n"; - } - } - - private: - template <typename Function> - friend class FunctionMocker; - - // An adaptor that turns a OneAction<F> into something compatible with - // Action<F>. Must be called at most once. - struct ActionAdaptor { - std::shared_ptr<OnceAction<R(Args...)>> once_action; - - R operator()(Args&&... args) const { - return std::move(*once_action).Call(std::forward<Args>(args)...); - } - }; - - // Returns an Expectation object that references and co-owns this - // expectation. - Expectation GetHandle() override { return owner_->GetHandleOf(this); } - - // The following methods will be called only after the EXPECT_CALL() - // statement finishes and when the current thread holds - // g_gmock_mutex. - - // Returns true if and only if this expectation matches the given arguments. - bool Matches(const ArgumentTuple& args) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return TupleMatches(matchers_, args) && extra_matcher_.Matches(args); - } - - // Returns true if and only if this expectation should handle the given - // arguments. - bool ShouldHandleArguments(const ArgumentTuple& args) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - - // In case the action count wasn't checked when the expectation - // was defined (e.g. if this expectation has no WillRepeatedly() - // or RetiresOnSaturation() clause), we check it when the - // expectation is used for the first time. - CheckActionCountIfNotDone(); - return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args); - } - - // Describes the result of matching the arguments against this - // expectation to the given ostream. - void ExplainMatchResultTo(const ArgumentTuple& args, ::std::ostream* os) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - - if (is_retired()) { - *os << " Expected: the expectation is active\n" - << " Actual: it is retired\n"; - } else if (!Matches(args)) { - if (!TupleMatches(matchers_, args)) { - ExplainMatchFailureTupleTo(matchers_, args, os); - } - StringMatchResultListener listener; - if (!extra_matcher_.MatchAndExplain(args, &listener)) { - *os << " Expected args: "; - extra_matcher_.DescribeTo(os); - *os << "\n Actual: don't match"; - - internal::PrintIfNotEmpty(listener.str(), os); - *os << "\n"; - } - } else if (!AllPrerequisitesAreSatisfied()) { - *os << " Expected: all pre-requisites are satisfied\n" - << " Actual: the following immediate pre-requisites " - << "are not satisfied:\n"; - ExpectationSet unsatisfied_prereqs; - FindUnsatisfiedPrerequisites(&unsatisfied_prereqs); - int i = 0; - for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin(); - it != unsatisfied_prereqs.end(); ++it) { - it->expectation_base()->DescribeLocationTo(os); - *os << "pre-requisite #" << i++ << "\n"; - } - *os << " (end of pre-requisites)\n"; - } else { - // This line is here just for completeness' sake. It will never - // be executed as currently the ExplainMatchResultTo() function - // is called only when the mock function call does NOT match the - // expectation. - *os << "The call matches the expectation.\n"; - } - } - - // Returns the action that should be taken for the current invocation. - const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker, - const ArgumentTuple& args) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - const int count = call_count(); - Assert(count >= 1, __FILE__, __LINE__, - "call_count() is <= 0 when GetCurrentAction() is " - "called - this should never happen."); - - const int action_count = static_cast<int>(untyped_actions_.size()); - if (action_count > 0 && !repeated_action_specified_ && - count > action_count) { - // If there is at least one WillOnce() and no WillRepeatedly(), - // we warn the user when the WillOnce() clauses ran out. - ::std::stringstream ss; - DescribeLocationTo(&ss); - ss << "Actions ran out in " << source_text() << "...\n" - << "Called " << count << " times, but only " << action_count - << " WillOnce()" << (action_count == 1 ? " is" : "s are") - << " specified - "; - mocker->DescribeDefaultActionTo(args, &ss); - Log(kWarning, ss.str(), 1); - } - - return count <= action_count - ? *static_cast<const Action<F>*>( - untyped_actions_[static_cast<size_t>(count - 1)]) - : repeated_action(); - } - - // Given the arguments of a mock function call, if the call will - // over-saturate this expectation, returns the default action; - // otherwise, returns the next action in this expectation. Also - // describes *what* happened to 'what', and explains *why* Google - // Mock does it to 'why'. This method is not const as it calls - // IncrementCallCount(). A return value of NULL means the default - // action. - const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker, - const ArgumentTuple& args, - ::std::ostream* what, - ::std::ostream* why) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - if (IsSaturated()) { - // We have an excessive call. - IncrementCallCount(); - *what << "Mock function called more times than expected - "; - mocker->DescribeDefaultActionTo(args, what); - DescribeCallCountTo(why); - - return nullptr; - } - - IncrementCallCount(); - RetireAllPreRequisites(); - - if (retires_on_saturation_ && IsSaturated()) { - Retire(); - } - - // Must be done after IncrementCount()! - *what << "Mock function call matches " << source_text() << "...\n"; - return &(GetCurrentAction(mocker, args)); - } - - // All the fields below won't change once the EXPECT_CALL() - // statement finishes. - FunctionMocker<F>* const owner_; - ArgumentMatcherTuple matchers_; - Matcher<const ArgumentTuple&> extra_matcher_; - Action<F> repeated_action_; - - TypedExpectation(const TypedExpectation&) = delete; - TypedExpectation& operator=(const TypedExpectation&) = delete; -}; // class TypedExpectation - -// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for -// specifying the default behavior of, or expectation on, a mock -// function. - -// Note: class MockSpec really belongs to the ::testing namespace. -// However if we define it in ::testing, MSVC will complain when -// classes in ::testing::internal declare it as a friend class -// template. To workaround this compiler bug, we define MockSpec in -// ::testing::internal and import it into ::testing. - -// Logs a message including file and line number information. -GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity, - const char* file, int line, - const std::string& message); - -template <typename F> -class MockSpec { - public: - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - typedef - typename internal::Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple; - - // Constructs a MockSpec object, given the function mocker object - // that the spec is associated with. - MockSpec(internal::FunctionMocker<F>* function_mocker, - const ArgumentMatcherTuple& matchers) - : function_mocker_(function_mocker), matchers_(matchers) {} - - // Adds a new default action spec to the function mocker and returns - // the newly created spec. - internal::OnCallSpec<F>& InternalDefaultActionSetAt(const char* file, - int line, const char* obj, - const char* call) { - LogWithLocation(internal::kInfo, file, line, - std::string("ON_CALL(") + obj + ", " + call + ") invoked"); - return function_mocker_->AddNewOnCallSpec(file, line, matchers_); - } - - // Adds a new expectation spec to the function mocker and returns - // the newly created spec. - internal::TypedExpectation<F>& InternalExpectedAt(const char* file, int line, - const char* obj, - const char* call) { - const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " + - call + ")"); - LogWithLocation(internal::kInfo, file, line, source_text + " invoked"); - return function_mocker_->AddNewExpectation(file, line, source_text, - matchers_); - } - - // This operator overload is used to swallow the superfluous parameter list - // introduced by the ON/EXPECT_CALL macros. See the macro comments for more - // explanation. - MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) { - return *this; - } - - private: - template <typename Function> - friend class internal::FunctionMocker; - - // The function mocker that owns this spec. - internal::FunctionMocker<F>* const function_mocker_; - // The argument matchers specified in the spec. - ArgumentMatcherTuple matchers_; -}; // class MockSpec - -// Wrapper type for generically holding an ordinary value or lvalue reference. -// If T is not a reference type, it must be copyable or movable. -// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless -// T is a move-only value type (which means that it will always be copyable -// if the current platform does not support move semantics). -// -// The primary template defines handling for values, but function header -// comments describe the contract for the whole template (including -// specializations). -template <typename T> -class ReferenceOrValueWrapper { - public: - // Constructs a wrapper from the given value/reference. - explicit ReferenceOrValueWrapper(T value) : value_(std::move(value)) {} - - // Unwraps and returns the underlying value/reference, exactly as - // originally passed. The behavior of calling this more than once on - // the same object is unspecified. - T Unwrap() { return std::move(value_); } - - // Provides nondestructive access to the underlying value/reference. - // Always returns a const reference (more precisely, - // const std::add_lvalue_reference<T>::type). The behavior of calling this - // after calling Unwrap on the same object is unspecified. - const T& Peek() const { return value_; } - - private: - T value_; -}; - -// Specialization for lvalue reference types. See primary template -// for documentation. -template <typename T> -class ReferenceOrValueWrapper<T&> { - public: - // Workaround for debatable pass-by-reference lint warning (c-library-team - // policy precludes NOLINT in this context) - typedef T& reference; - explicit ReferenceOrValueWrapper(reference ref) : value_ptr_(&ref) {} - T& Unwrap() { return *value_ptr_; } - const T& Peek() const { return *value_ptr_; } - - private: - T* value_ptr_; -}; - -// Prints the held value as an action's result to os. -template <typename T> -void PrintAsActionResult(const T& result, std::ostream& os) { - os << "\n Returns: "; - // T may be a reference type, so we don't use UniversalPrint(). - UniversalPrinter<T>::Print(result, &os); -} - -// Reports an uninteresting call (whose description is in msg) in the -// manner specified by 'reaction'. -GTEST_API_ void ReportUninterestingCall(CallReaction reaction, - const std::string& msg); - -// A generic RAII type that runs a user-provided function in its destructor. -class Cleanup final { - public: - explicit Cleanup(std::function<void()> f) : f_(std::move(f)) {} - ~Cleanup() { f_(); } - - private: - std::function<void()> f_; -}; - -template <typename F> -class FunctionMocker; - -template <typename R, typename... Args> -class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase { - using F = R(Args...); - - public: - using Result = R; - using ArgumentTuple = std::tuple<Args...>; - using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>; - - FunctionMocker() {} - - // There is no generally useful and implementable semantics of - // copying a mock object, so copying a mock is usually a user error. - // Thus we disallow copying function mockers. If the user really - // wants to copy a mock object, they should implement their own copy - // operation, for example: - // - // class MockFoo : public Foo { - // public: - // // Defines a copy constructor explicitly. - // MockFoo(const MockFoo& src) {} - // ... - // }; - FunctionMocker(const FunctionMocker&) = delete; - FunctionMocker& operator=(const FunctionMocker&) = delete; - - // The destructor verifies that all expectations on this mock - // function have been satisfied. If not, it will report Google Test - // non-fatal failures for the violations. - ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - MutexLock l(&g_gmock_mutex); - VerifyAndClearExpectationsLocked(); - Mock::UnregisterLocked(this); - ClearDefaultActionsLocked(); - } - - // Returns the ON_CALL spec that matches this mock function with the - // given arguments; returns NULL if no matching ON_CALL is found. - // L = * - const OnCallSpec<F>* FindOnCallSpec(const ArgumentTuple& args) const { - for (UntypedOnCallSpecs::const_reverse_iterator it = - untyped_on_call_specs_.rbegin(); - it != untyped_on_call_specs_.rend(); ++it) { - const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it); - if (spec->Matches(args)) return spec; - } - - return nullptr; - } - - // Performs the default action of this mock function on the given - // arguments and returns the result. Asserts (or throws if - // exceptions are enabled) with a helpful call description if there - // is no valid return value. This method doesn't depend on the - // mutable state of this object, and thus can be called concurrently - // without locking. - // L = * - Result PerformDefaultAction(ArgumentTuple&& args, - const std::string& call_description) const { - const OnCallSpec<F>* const spec = this->FindOnCallSpec(args); - if (spec != nullptr) { - return spec->GetAction().Perform(std::move(args)); - } - const std::string message = - call_description + - "\n The mock function has no default action " - "set, and its return type has no default value set."; -#if GTEST_HAS_EXCEPTIONS - if (!DefaultValue<Result>::Exists()) { - throw std::runtime_error(message); - } -#else - Assert(DefaultValue<Result>::Exists(), "", -1, message); -#endif - return DefaultValue<Result>::Get(); - } - - // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked(): - // clears the ON_CALL()s set on this mock function. - void ClearDefaultActionsLocked() override - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - - // Deleting our default actions may trigger other mock objects to be - // deleted, for example if an action contains a reference counted smart - // pointer to that mock object, and that is the last reference. So if we - // delete our actions within the context of the global mutex we may deadlock - // when this method is called again. Instead, make a copy of the set of - // actions to delete, clear our set within the mutex, and then delete the - // actions outside of the mutex. - UntypedOnCallSpecs specs_to_delete; - untyped_on_call_specs_.swap(specs_to_delete); - - g_gmock_mutex.Unlock(); - for (UntypedOnCallSpecs::const_iterator it = specs_to_delete.begin(); - it != specs_to_delete.end(); ++it) { - delete static_cast<const OnCallSpec<F>*>(*it); - } - - // Lock the mutex again, since the caller expects it to be locked when we - // return. - g_gmock_mutex.Lock(); - } - - // Returns the result of invoking this mock function with the given - // arguments. This function can be safely called from multiple - // threads concurrently. - Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - return InvokeWith(ArgumentTuple(std::forward<Args>(args)...)); - } - - MockSpec<F> With(Matcher<Args>... m) { - return MockSpec<F>(this, ::std::make_tuple(std::move(m)...)); - } - - protected: - template <typename Function> - friend class MockSpec; - - // Adds and returns a default action spec for this mock function. - OnCallSpec<F>& AddNewOnCallSpec(const char* file, int line, - const ArgumentMatcherTuple& m) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line); - OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m); - untyped_on_call_specs_.push_back(on_call_spec); - return *on_call_spec; - } - - // Adds and returns an expectation spec for this mock function. - TypedExpectation<F>& AddNewExpectation(const char* file, int line, - const std::string& source_text, - const ArgumentMatcherTuple& m) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line); - TypedExpectation<F>* const expectation = - new TypedExpectation<F>(this, file, line, source_text, m); - const std::shared_ptr<ExpectationBase> untyped_expectation(expectation); - // See the definition of untyped_expectations_ for why access to - // it is unprotected here. - untyped_expectations_.push_back(untyped_expectation); - - // Adds this expectation into the implicit sequence if there is one. - Sequence* const implicit_sequence = g_gmock_implicit_sequence.get(); - if (implicit_sequence != nullptr) { - implicit_sequence->AddExpectation(Expectation(untyped_expectation)); - } - - return *expectation; - } - - private: - template <typename Func> - friend class TypedExpectation; - - // Some utilities needed for implementing UntypedInvokeWith(). - - // Describes what default action will be performed for the given - // arguments. - // L = * - void DescribeDefaultActionTo(const ArgumentTuple& args, - ::std::ostream* os) const { - const OnCallSpec<F>* const spec = FindOnCallSpec(args); - - if (spec == nullptr) { - *os << (std::is_void<Result>::value ? "returning directly.\n" - : "returning default value.\n"); - } else { - *os << "taking default action specified at:\n" - << FormatFileLocation(spec->file(), spec->line()) << "\n"; - } - } - - // Writes a message that the call is uninteresting (i.e. neither - // explicitly expected nor explicitly unexpected) to the given - // ostream. - void UntypedDescribeUninterestingCall(const void* untyped_args, - ::std::ostream* os) const override - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - const ArgumentTuple& args = - *static_cast<const ArgumentTuple*>(untyped_args); - *os << "Uninteresting mock function call - "; - DescribeDefaultActionTo(args, os); - *os << " Function call: " << Name(); - UniversalPrint(args, os); - } - - // Returns the expectation that matches the given function arguments - // (or NULL is there's no match); when a match is found, - // untyped_action is set to point to the action that should be - // performed (or NULL if the action is "do default"), and - // is_excessive is modified to indicate whether the call exceeds the - // expected number. - // - // Critical section: We must find the matching expectation and the - // corresponding action that needs to be taken in an ATOMIC - // transaction. Otherwise another thread may call this mock - // method in the middle and mess up the state. - // - // However, performing the action has to be left out of the critical - // section. The reason is that we have no control on what the - // action does (it can invoke an arbitrary user function or even a - // mock function) and excessive locking could cause a dead lock. - const ExpectationBase* UntypedFindMatchingExpectation( - const void* untyped_args, const void** untyped_action, bool* is_excessive, - ::std::ostream* what, ::std::ostream* why) override - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - const ArgumentTuple& args = - *static_cast<const ArgumentTuple*>(untyped_args); - MutexLock l(&g_gmock_mutex); - TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args); - if (exp == nullptr) { // A match wasn't found. - this->FormatUnexpectedCallMessageLocked(args, what, why); - return nullptr; - } - - // This line must be done before calling GetActionForArguments(), - // which will increment the call count for *exp and thus affect - // its saturation status. - *is_excessive = exp->IsSaturated(); - const Action<F>* action = exp->GetActionForArguments(this, args, what, why); - if (action != nullptr && action->IsDoDefault()) - action = nullptr; // Normalize "do default" to NULL. - *untyped_action = action; - return exp; - } - - // Prints the given function arguments to the ostream. - void UntypedPrintArgs(const void* untyped_args, - ::std::ostream* os) const override { - const ArgumentTuple& args = - *static_cast<const ArgumentTuple*>(untyped_args); - UniversalPrint(args, os); - } - - // Returns the expectation that matches the arguments, or NULL if no - // expectation matches them. - TypedExpectation<F>* FindMatchingExpectationLocked(const ArgumentTuple& args) - const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - // See the definition of untyped_expectations_ for why access to - // it is unprotected here. - for (typename UntypedExpectations::const_reverse_iterator it = - untyped_expectations_.rbegin(); - it != untyped_expectations_.rend(); ++it) { - TypedExpectation<F>* const exp = - static_cast<TypedExpectation<F>*>(it->get()); - if (exp->ShouldHandleArguments(args)) { - return exp; - } - } - return nullptr; - } - - // Returns a message that the arguments don't match any expectation. - void FormatUnexpectedCallMessageLocked(const ArgumentTuple& args, - ::std::ostream* os, - ::std::ostream* why) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - *os << "\nUnexpected mock function call - "; - DescribeDefaultActionTo(args, os); - PrintTriedExpectationsLocked(args, why); - } - - // Prints a list of expectations that have been tried against the - // current mock function call. - void PrintTriedExpectationsLocked(const ArgumentTuple& args, - ::std::ostream* why) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - const size_t count = untyped_expectations_.size(); - *why << "Google Mock tried the following " << count << " " - << (count == 1 ? "expectation, but it didn't match" - : "expectations, but none matched") - << ":\n"; - for (size_t i = 0; i < count; i++) { - TypedExpectation<F>* const expectation = - static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get()); - *why << "\n"; - expectation->DescribeLocationTo(why); - if (count > 1) { - *why << "tried expectation #" << i << ": "; - } - *why << expectation->source_text() << "...\n"; - expectation->ExplainMatchResultTo(args, why); - expectation->DescribeCallCountTo(why); - } - } - - // Performs the given action (or the default if it's null) with the given - // arguments and returns the action's result. - // L = * - R PerformAction(const void* untyped_action, ArgumentTuple&& args, - const std::string& call_description) const { - if (untyped_action == nullptr) { - return PerformDefaultAction(std::move(args), call_description); - } - - // Make a copy of the action before performing it, in case the - // action deletes the mock object (and thus deletes itself). - const Action<F> action = *static_cast<const Action<F>*>(untyped_action); - return action.Perform(std::move(args)); - } - - // Is it possible to store an object of the supplied type in a local variable - // for the sake of printing it, then return it on to the caller? - template <typename T> - using can_print_result = internal::conjunction< - // void can't be stored as an object (and we also don't need to print it). - internal::negation<std::is_void<T>>, - // Non-moveable types can't be returned on to the user, so there's no way - // for us to intercept and print them. - std::is_move_constructible<T>>; - - // Perform the supplied action, printing the result to os. - template <typename T = R, - typename std::enable_if<can_print_result<T>::value, int>::type = 0> - R PerformActionAndPrintResult(const void* const untyped_action, - ArgumentTuple&& args, - const std::string& call_description, - std::ostream& os) { - R result = PerformAction(untyped_action, std::move(args), call_description); - - PrintAsActionResult(result, os); - return std::forward<R>(result); - } - - // An overload for when it's not possible to print the result. In this case we - // simply perform the action. - template <typename T = R, - typename std::enable_if< - internal::negation<can_print_result<T>>::value, int>::type = 0> - R PerformActionAndPrintResult(const void* const untyped_action, - ArgumentTuple&& args, - const std::string& call_description, - std::ostream&) { - return PerformAction(untyped_action, std::move(args), call_description); - } - - // Returns the result of invoking this mock function with the given - // arguments. This function can be safely called from multiple - // threads concurrently. - R InvokeWith(ArgumentTuple&& args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex); -}; // class FunctionMocker - -// Calculates the result of invoking this mock function with the given -// arguments, prints it, and returns it. -template <typename R, typename... Args> -R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - // See the definition of untyped_expectations_ for why access to it - // is unprotected here. - if (untyped_expectations_.size() == 0) { - // No expectation is set on this mock method - we have an - // uninteresting call. - - // We must get Google Mock's reaction on uninteresting calls - // made on this mock object BEFORE performing the action, - // because the action may DELETE the mock object and make the - // following expression meaningless. - const CallReaction reaction = - Mock::GetReactionOnUninterestingCalls(MockObject()); - - // True if and only if we need to print this call's arguments and return - // value. This definition must be kept in sync with - // the behavior of ReportUninterestingCall(). - const bool need_to_report_uninteresting_call = - // If the user allows this uninteresting call, we print it - // only when they want informational messages. - reaction == kAllow ? LogIsVisible(kInfo) : - // If the user wants this to be a warning, we print - // it only when they want to see warnings. - reaction == kWarn - ? LogIsVisible(kWarning) - : - // Otherwise, the user wants this to be an error, and we - // should always print detailed information in the error. - true; - - if (!need_to_report_uninteresting_call) { - // Perform the action without printing the call information. - return this->PerformDefaultAction( - std::move(args), "Function call: " + std::string(Name())); - } - - // Warns about the uninteresting call. - ::std::stringstream ss; - this->UntypedDescribeUninterestingCall(&args, &ss); - - // Perform the action, print the result, and then report the uninteresting - // call. - // - // We use RAII to do the latter in case R is void or a non-moveable type. In - // either case we can't assign it to a local variable. - const Cleanup report_uninteresting_call( - [&] { ReportUninterestingCall(reaction, ss.str()); }); - - return PerformActionAndPrintResult(nullptr, std::move(args), ss.str(), ss); - } - - bool is_excessive = false; - ::std::stringstream ss; - ::std::stringstream why; - ::std::stringstream loc; - const void* untyped_action = nullptr; - - // The UntypedFindMatchingExpectation() function acquires and - // releases g_gmock_mutex. - - const ExpectationBase* const untyped_expectation = - this->UntypedFindMatchingExpectation(&args, &untyped_action, - &is_excessive, &ss, &why); - const bool found = untyped_expectation != nullptr; - - // True if and only if we need to print the call's arguments - // and return value. - // This definition must be kept in sync with the uses of Expect() - // and Log() in this function. - const bool need_to_report_call = - !found || is_excessive || LogIsVisible(kInfo); - if (!need_to_report_call) { - // Perform the action without printing the call information. - return PerformAction(untyped_action, std::move(args), ""); - } - - ss << " Function call: " << Name(); - this->UntypedPrintArgs(&args, &ss); - - // In case the action deletes a piece of the expectation, we - // generate the message beforehand. - if (found && !is_excessive) { - untyped_expectation->DescribeLocationTo(&loc); - } - - // Perform the action, print the result, and then fail or log in whatever way - // is appropriate. - // - // We use RAII to do the latter in case R is void or a non-moveable type. In - // either case we can't assign it to a local variable. - const Cleanup handle_failures([&] { - ss << "\n" << why.str(); - - if (!found) { - // No expectation matches this call - reports a failure. - Expect(false, nullptr, -1, ss.str()); - } else if (is_excessive) { - // We had an upper-bound violation and the failure message is in ss. - Expect(false, untyped_expectation->file(), untyped_expectation->line(), - ss.str()); - } else { - // We had an expected call and the matching expectation is - // described in ss. - Log(kInfo, loc.str() + ss.str(), 2); - } - }); - - return PerformActionAndPrintResult(untyped_action, std::move(args), ss.str(), - ss); -} - -} // namespace internal - -namespace internal { - -template <typename F> -class MockFunction; - -template <typename R, typename... Args> -class MockFunction<R(Args...)> { - public: - MockFunction(const MockFunction&) = delete; - MockFunction& operator=(const MockFunction&) = delete; - - std::function<R(Args...)> AsStdFunction() { - return [this](Args... args) -> R { - return this->Call(std::forward<Args>(args)...); - }; - } - - // Implementation detail: the expansion of the MOCK_METHOD macro. - R Call(Args... args) { - mock_.SetOwnerAndName(this, "Call"); - return mock_.Invoke(std::forward<Args>(args)...); - } - - MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) { - mock_.RegisterOwner(this); - return mock_.With(std::move(m)...); - } - - MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) { - return this->gmock_Call(::testing::A<Args>()...); - } - - protected: - MockFunction() = default; - ~MockFunction() = default; - - private: - FunctionMocker<R(Args...)> mock_; -}; - -/* -The SignatureOf<F> struct is a meta-function returning function signature -corresponding to the provided F argument. - -It makes use of MockFunction easier by allowing it to accept more F arguments -than just function signatures. - -Specializations provided here cover a signature type itself and any template -that can be parameterized with a signature, including std::function and -boost::function. -*/ - -template <typename F, typename = void> -struct SignatureOf; - -template <typename R, typename... Args> -struct SignatureOf<R(Args...)> { - using type = R(Args...); -}; - -template <template <typename> class C, typename F> -struct SignatureOf<C<F>, - typename std::enable_if<std::is_function<F>::value>::type> - : SignatureOf<F> {}; - -template <typename F> -using SignatureOfT = typename SignatureOf<F>::type; - -} // namespace internal - -// A MockFunction<F> type has one mock method whose type is -// internal::SignatureOfT<F>. It is useful when you just want your -// test code to emit some messages and have Google Mock verify the -// right messages are sent (and perhaps at the right times). For -// example, if you are exercising code: -// -// Foo(1); -// Foo(2); -// Foo(3); -// -// and want to verify that Foo(1) and Foo(3) both invoke -// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write: -// -// TEST(FooTest, InvokesBarCorrectly) { -// MyMock mock; -// MockFunction<void(string check_point_name)> check; -// { -// InSequence s; -// -// EXPECT_CALL(mock, Bar("a")); -// EXPECT_CALL(check, Call("1")); -// EXPECT_CALL(check, Call("2")); -// EXPECT_CALL(mock, Bar("a")); -// } -// Foo(1); -// check.Call("1"); -// Foo(2); -// check.Call("2"); -// Foo(3); -// } -// -// The expectation spec says that the first Bar("a") must happen -// before check point "1", the second Bar("a") must happen after check -// point "2", and nothing should happen between the two check -// points. The explicit check points make it easy to tell which -// Bar("a") is called by which call to Foo(). -// -// MockFunction<F> can also be used to exercise code that accepts -// std::function<internal::SignatureOfT<F>> callbacks. To do so, use -// AsStdFunction() method to create std::function proxy forwarding to -// original object's Call. Example: -// -// TEST(FooTest, RunsCallbackWithBarArgument) { -// MockFunction<int(string)> callback; -// EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1)); -// Foo(callback.AsStdFunction()); -// } -// -// The internal::SignatureOfT<F> indirection allows to use other types -// than just function signature type. This is typically useful when -// providing a mock for a predefined std::function type. Example: -// -// using FilterPredicate = std::function<bool(string)>; -// void MyFilterAlgorithm(FilterPredicate predicate); -// -// TEST(FooTest, FilterPredicateAlwaysAccepts) { -// MockFunction<FilterPredicate> predicateMock; -// EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true)); -// MyFilterAlgorithm(predicateMock.AsStdFunction()); -// } -template <typename F> -class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> { - using Base = internal::MockFunction<internal::SignatureOfT<F>>; - - public: - using Base::Base; -}; - -// The style guide prohibits "using" statements in a namespace scope -// inside a header file. However, the MockSpec class template is -// meant to be defined in the ::testing namespace. The following line -// is just a trick for working around a bug in MSVC 8.0, which cannot -// handle it if we define MockSpec in ::testing. -using internal::MockSpec; - -// Const(x) is a convenient function for obtaining a const reference -// to x. This is useful for setting expectations on an overloaded -// const mock method, e.g. -// -// class MockFoo : public FooInterface { -// public: -// MOCK_METHOD0(Bar, int()); -// MOCK_CONST_METHOD0(Bar, int&()); -// }; -// -// MockFoo foo; -// // Expects a call to non-const MockFoo::Bar(). -// EXPECT_CALL(foo, Bar()); -// // Expects a call to const MockFoo::Bar(). -// EXPECT_CALL(Const(foo), Bar()); -template <typename T> -inline const T& Const(const T& x) { - return x; -} - -// Constructs an Expectation object that references and co-owns exp. -inline Expectation::Expectation(internal::ExpectationBase& exp) // NOLINT - : expectation_base_(exp.GetHandle().expectation_base()) {} - -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is -// required to avoid compile errors when the name of the method used in call is -// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro -// tests in internal/gmock-spec-builders_test.cc for more details. -// -// This macro supports statements both with and without parameter matchers. If -// the parameter list is omitted, gMock will accept any parameters, which allows -// tests to be written that don't need to encode the number of method -// parameter. This technique may only be used for non-overloaded methods. -// -// // These are the same: -// ON_CALL(mock, NoArgsMethod()).WillByDefault(...); -// ON_CALL(mock, NoArgsMethod).WillByDefault(...); -// -// // As are these: -// ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...); -// ON_CALL(mock, TwoArgsMethod).WillByDefault(...); -// -// // Can also specify args if you want, of course: -// ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...); -// -// // Overloads work as long as you specify parameters: -// ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...); -// ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...); -// -// // Oops! Which overload did you want? -// ON_CALL(mock, OverloadedMethod).WillByDefault(...); -// => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous -// -// How this works: The mock class uses two overloads of the gmock_Method -// expectation setter method plus an operator() overload on the MockSpec object. -// In the matcher list form, the macro expands to: -// -// // This statement: -// ON_CALL(mock, TwoArgsMethod(_, 45))... -// -// // ...expands to: -// mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)... -// |-------------v---------------||------------v-------------| -// invokes first overload swallowed by operator() -// -// // ...which is essentially: -// mock.gmock_TwoArgsMethod(_, 45)... -// -// Whereas the form without a matcher list: -// -// // This statement: -// ON_CALL(mock, TwoArgsMethod)... -// -// // ...expands to: -// mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)... -// |-----------------------v--------------------------| -// invokes second overload -// -// // ...which is essentially: -// mock.gmock_TwoArgsMethod(_, _)... -// -// The WithoutMatchers() argument is used to disambiguate overloads and to -// block the caller from accidentally invoking the second overload directly. The -// second argument is an internal type derived from the method signature. The -// failure to disambiguate two overloads of this method in the ON_CALL statement -// is how we block callers from setting expectations on overloaded methods. -#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call) \ - ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \ - nullptr) \ - .Setter(__FILE__, __LINE__, #mock_expr, #call) - -#define ON_CALL(obj, call) \ - GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call) - -#define EXPECT_CALL(obj, call) \ - GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call) - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/gmock.h b/third_party/googletest/src/googlemock/include/gmock/gmock.h deleted file mode 100644 index 568c8c7..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/gmock.h +++ /dev/null
@@ -1,96 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This is the main header file a user should include. - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_ - -// This file implements the following syntax: -// -// ON_CALL(mock_object, Method(...)) -// .With(...) ? -// .WillByDefault(...); -// -// where With() is optional and WillByDefault() must appear exactly -// once. -// -// EXPECT_CALL(mock_object, Method(...)) -// .With(...) ? -// .Times(...) ? -// .InSequence(...) * -// .WillOnce(...) * -// .WillRepeatedly(...) ? -// .RetiresOnSaturation() ? ; -// -// where all clauses are optional and WillOnce() can be repeated. - -#include "gmock/gmock-actions.h" -#include "gmock/gmock-cardinalities.h" -#include "gmock/gmock-function-mocker.h" -#include "gmock/gmock-matchers.h" -#include "gmock/gmock-more-actions.h" -#include "gmock/gmock-more-matchers.h" -#include "gmock/gmock-nice-strict.h" -#include "gmock/internal/gmock-internal-utils.h" -#include "gmock/internal/gmock-port.h" - -// Declares Google Mock flags that we want a user to use programmatically. -GMOCK_DECLARE_bool_(catch_leaked_mocks); -GMOCK_DECLARE_string_(verbose); -GMOCK_DECLARE_int32_(default_mock_behavior); - -namespace testing { - -// Initializes Google Mock. This must be called before running the -// tests. In particular, it parses the command line for the flags -// that Google Mock recognizes. Whenever a Google Mock flag is seen, -// it is removed from argv, and *argc is decremented. -// -// No value is returned. Instead, the Google Mock flag variables are -// updated. -// -// Since Google Test is needed for Google Mock to work, this function -// also initializes Google Test and parses its flags, if that hasn't -// been done. -GTEST_API_ void InitGoogleMock(int* argc, char** argv); - -// This overloaded version can be used in Windows programs compiled in -// UNICODE mode. -GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv); - -// This overloaded version can be used on Arduino/embedded platforms where -// there is no argc/argv. -GTEST_API_ void InitGoogleMock(); - -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/internal/custom/README.md b/third_party/googletest/src/googlemock/include/gmock/internal/custom/README.md deleted file mode 100644 index 9c4874f..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/internal/custom/README.md +++ /dev/null
@@ -1,18 +0,0 @@ -# Customization Points - -The custom directory is an injection point for custom user configurations. - -## Header `gmock-port.h` - -The following macros can be defined: - -### Flag related macros: - -* `GMOCK_DECLARE_bool_(name)` -* `GMOCK_DECLARE_int32_(name)` -* `GMOCK_DECLARE_string_(name)` -* `GMOCK_DEFINE_bool_(name, default_val, doc)` -* `GMOCK_DEFINE_int32_(name, default_val, doc)` -* `GMOCK_DEFINE_string_(name, default_val, doc)` -* `GMOCK_FLAG_GET(flag_name)` -* `GMOCK_FLAG_SET(flag_name, value)`
diff --git a/third_party/googletest/src/googlemock/include/gmock/internal/custom/gmock-generated-actions.h b/third_party/googletest/src/googlemock/include/gmock/internal/custom/gmock-generated-actions.h deleted file mode 100644 index bbcad31..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/internal/custom/gmock-generated-actions.h +++ /dev/null
@@ -1,7 +0,0 @@ -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/internal/custom/gmock-matchers.h b/third_party/googletest/src/googlemock/include/gmock/internal/custom/gmock-matchers.h deleted file mode 100644 index bb7dcba..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/internal/custom/gmock-matchers.h +++ /dev/null
@@ -1,37 +0,0 @@ -// Copyright 2015, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Injection point for custom user configurations. See README for details - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/internal/custom/gmock-port.h b/third_party/googletest/src/googlemock/include/gmock/internal/custom/gmock-port.h deleted file mode 100644 index f055f75..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/internal/custom/gmock-port.h +++ /dev/null
@@ -1,40 +0,0 @@ -// Copyright 2015, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Injection point for custom user configurations. See README for details -// -// ** Custom implementation starts here ** - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_ - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/internal/gmock-internal-utils.h b/third_party/googletest/src/googlemock/include/gmock/internal/gmock-internal-utils.h deleted file mode 100644 index b1343fd..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/internal/gmock-internal-utils.h +++ /dev/null
@@ -1,476 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file defines some utilities useful for implementing Google -// Mock. They are subject to change without notice, so please DO NOT -// USE THEM IN USER CODE. - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ - -#include <stdio.h> - -#include <ostream> // NOLINT -#include <string> -#include <type_traits> -#include <vector> - -#include "gmock/internal/gmock-port.h" -#include "gtest/gtest.h" - -namespace testing { - -template <typename> -class Matcher; - -namespace internal { - -// Silence MSVC C4100 (unreferenced formal parameter) and -// C4805('==': unsafe mix of type 'const int' and type 'const bool') -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4100) -#pragma warning(disable : 4805) -#endif - -// Joins a vector of strings as if they are fields of a tuple; returns -// the joined string. -GTEST_API_ std::string JoinAsKeyValueTuple( - const std::vector<const char*>& names, const Strings& values); - -// Converts an identifier name to a space-separated list of lower-case -// words. Each maximum substring of the form [A-Za-z][a-z]*|\d+ is -// treated as one word. For example, both "FooBar123" and -// "foo_bar_123" are converted to "foo bar 123". -GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name); - -// GetRawPointer(p) returns the raw pointer underlying p when p is a -// smart pointer, or returns p itself when p is already a raw pointer. -// The following default implementation is for the smart pointer case. -template <typename Pointer> -inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) { - return p.get(); -} -// This overload version is for std::reference_wrapper, which does not work with -// the overload above, as it does not have an `element_type`. -template <typename Element> -inline const Element* GetRawPointer(const std::reference_wrapper<Element>& r) { - return &r.get(); -} - -// This overloaded version is for the raw pointer case. -template <typename Element> -inline Element* GetRawPointer(Element* p) { - return p; -} - -// MSVC treats wchar_t as a native type usually, but treats it as the -// same as unsigned short when the compiler option /Zc:wchar_t- is -// specified. It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t -// is a native type. -#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED) -// wchar_t is a typedef. -#else -#define GMOCK_WCHAR_T_IS_NATIVE_ 1 -#endif - -// In what follows, we use the term "kind" to indicate whether a type -// is bool, an integer type (excluding bool), a floating-point type, -// or none of them. This categorization is useful for determining -// when a matcher argument type can be safely converted to another -// type in the implementation of SafeMatcherCast. -enum TypeKind { kBool, kInteger, kFloatingPoint, kOther }; - -// KindOf<T>::value is the kind of type T. -template <typename T> -struct KindOf { - enum { value = kOther }; // The default kind. -}; - -// This macro declares that the kind of 'type' is 'kind'. -#define GMOCK_DECLARE_KIND_(type, kind) \ - template <> \ - struct KindOf<type> { \ - enum { value = kind }; \ - } - -GMOCK_DECLARE_KIND_(bool, kBool); - -// All standard integer types. -GMOCK_DECLARE_KIND_(char, kInteger); -GMOCK_DECLARE_KIND_(signed char, kInteger); -GMOCK_DECLARE_KIND_(unsigned char, kInteger); -GMOCK_DECLARE_KIND_(short, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(unsigned short, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(int, kInteger); -GMOCK_DECLARE_KIND_(unsigned int, kInteger); -GMOCK_DECLARE_KIND_(long, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(unsigned long, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(long long, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(unsigned long long, kInteger); // NOLINT - -#if GMOCK_WCHAR_T_IS_NATIVE_ -GMOCK_DECLARE_KIND_(wchar_t, kInteger); -#endif - -// All standard floating-point types. -GMOCK_DECLARE_KIND_(float, kFloatingPoint); -GMOCK_DECLARE_KIND_(double, kFloatingPoint); -GMOCK_DECLARE_KIND_(long double, kFloatingPoint); - -#undef GMOCK_DECLARE_KIND_ - -// Evaluates to the kind of 'type'. -#define GMOCK_KIND_OF_(type) \ - static_cast< ::testing::internal::TypeKind>( \ - ::testing::internal::KindOf<type>::value) - -// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value -// is true if and only if arithmetic type From can be losslessly converted to -// arithmetic type To. -// -// It's the user's responsibility to ensure that both From and To are -// raw (i.e. has no CV modifier, is not a pointer, and is not a -// reference) built-in arithmetic types, kFromKind is the kind of -// From, and kToKind is the kind of To; the value is -// implementation-defined when the above pre-condition is violated. -template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To> -using LosslessArithmeticConvertibleImpl = std::integral_constant< - bool, - // clang-format off - // Converting from bool is always lossless - (kFromKind == kBool) ? true - // Converting between any other type kinds will be lossy if the type - // kinds are not the same. - : (kFromKind != kToKind) ? false - : (kFromKind == kInteger && - // Converting between integers of different widths is allowed so long - // as the conversion does not go from signed to unsigned. - (((sizeof(From) < sizeof(To)) && - !(std::is_signed<From>::value && !std::is_signed<To>::value)) || - // Converting between integers of the same width only requires the - // two types to have the same signedness. - ((sizeof(From) == sizeof(To)) && - (std::is_signed<From>::value == std::is_signed<To>::value))) - ) ? true - // Floating point conversions are lossless if and only if `To` is at least - // as wide as `From`. - : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true - : false - // clang-format on - >; - -// LosslessArithmeticConvertible<From, To>::value is true if and only if -// arithmetic type From can be losslessly converted to arithmetic type To. -// -// It's the user's responsibility to ensure that both From and To are -// raw (i.e. has no CV modifier, is not a pointer, and is not a -// reference) built-in arithmetic types; the value is -// implementation-defined when the above pre-condition is violated. -template <typename From, typename To> -using LosslessArithmeticConvertible = - LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From, - GMOCK_KIND_OF_(To), To>; - -// This interface knows how to report a Google Mock failure (either -// non-fatal or fatal). -class FailureReporterInterface { - public: - // The type of a failure (either non-fatal or fatal). - enum FailureType { kNonfatal, kFatal }; - - virtual ~FailureReporterInterface() {} - - // Reports a failure that occurred at the given source file location. - virtual void ReportFailure(FailureType type, const char* file, int line, - const std::string& message) = 0; -}; - -// Returns the failure reporter used by Google Mock. -GTEST_API_ FailureReporterInterface* GetFailureReporter(); - -// Asserts that condition is true; aborts the process with the given -// message if condition is false. We cannot use LOG(FATAL) or CHECK() -// as Google Mock might be used to mock the log sink itself. We -// inline this function to prevent it from showing up in the stack -// trace. -inline void Assert(bool condition, const char* file, int line, - const std::string& msg) { - if (!condition) { - GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal, file, - line, msg); - } -} -inline void Assert(bool condition, const char* file, int line) { - Assert(condition, file, line, "Assertion failed."); -} - -// Verifies that condition is true; generates a non-fatal failure if -// condition is false. -inline void Expect(bool condition, const char* file, int line, - const std::string& msg) { - if (!condition) { - GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal, - file, line, msg); - } -} -inline void Expect(bool condition, const char* file, int line) { - Expect(condition, file, line, "Expectation failed."); -} - -// Severity level of a log. -enum LogSeverity { kInfo = 0, kWarning = 1 }; - -// Valid values for the --gmock_verbose flag. - -// All logs (informational and warnings) are printed. -const char kInfoVerbosity[] = "info"; -// Only warnings are printed. -const char kWarningVerbosity[] = "warning"; -// No logs are printed. -const char kErrorVerbosity[] = "error"; - -// Returns true if and only if a log with the given severity is visible -// according to the --gmock_verbose flag. -GTEST_API_ bool LogIsVisible(LogSeverity severity); - -// Prints the given message to stdout if and only if 'severity' >= the level -// specified by the --gmock_verbose flag. If stack_frames_to_skip >= -// 0, also prints the stack trace excluding the top -// stack_frames_to_skip frames. In opt mode, any positive -// stack_frames_to_skip is treated as 0, since we don't know which -// function calls will be inlined by the compiler and need to be -// conservative. -GTEST_API_ void Log(LogSeverity severity, const std::string& message, - int stack_frames_to_skip); - -// A marker class that is used to resolve parameterless expectations to the -// correct overload. This must not be instantiable, to prevent client code from -// accidentally resolving to the overload; for example: -// -// ON_CALL(mock, Method({}, nullptr))... -// -class WithoutMatchers { - private: - WithoutMatchers() {} - friend GTEST_API_ WithoutMatchers GetWithoutMatchers(); -}; - -// Internal use only: access the singleton instance of WithoutMatchers. -GTEST_API_ WithoutMatchers GetWithoutMatchers(); - -// Disable MSVC warnings for infinite recursion, since in this case the -// recursion is unreachable. -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4717) -#endif - -// Invalid<T>() is usable as an expression of type T, but will terminate -// the program with an assertion failure if actually run. This is useful -// when a value of type T is needed for compilation, but the statement -// will not really be executed (or we don't care if the statement -// crashes). -template <typename T> -inline T Invalid() { - Assert(false, "", -1, "Internal error: attempt to return invalid value"); -#if defined(__GNUC__) || defined(__clang__) - __builtin_unreachable(); -#elif defined(_MSC_VER) - __assume(0); -#else - return Invalid<T>(); -#endif -} - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -// Given a raw type (i.e. having no top-level reference or const -// modifier) RawContainer that's either an STL-style container or a -// native array, class StlContainerView<RawContainer> has the -// following members: -// -// - type is a type that provides an STL-style container view to -// (i.e. implements the STL container concept for) RawContainer; -// - const_reference is a type that provides a reference to a const -// RawContainer; -// - ConstReference(raw_container) returns a const reference to an STL-style -// container view to raw_container, which is a RawContainer. -// - Copy(raw_container) returns an STL-style container view of a -// copy of raw_container, which is a RawContainer. -// -// This generic version is used when RawContainer itself is already an -// STL-style container. -template <class RawContainer> -class StlContainerView { - public: - typedef RawContainer type; - typedef const type& const_reference; - - static const_reference ConstReference(const RawContainer& container) { - static_assert(!std::is_const<RawContainer>::value, - "RawContainer type must not be const"); - return container; - } - static type Copy(const RawContainer& container) { return container; } -}; - -// This specialization is used when RawContainer is a native array type. -template <typename Element, size_t N> -class StlContainerView<Element[N]> { - public: - typedef typename std::remove_const<Element>::type RawElement; - typedef internal::NativeArray<RawElement> type; - // NativeArray<T> can represent a native array either by value or by - // reference (selected by a constructor argument), so 'const type' - // can be used to reference a const native array. We cannot - // 'typedef const type& const_reference' here, as that would mean - // ConstReference() has to return a reference to a local variable. - typedef const type const_reference; - - static const_reference ConstReference(const Element (&array)[N]) { - static_assert(std::is_same<Element, RawElement>::value, - "Element type must not be const"); - return type(array, N, RelationToSourceReference()); - } - static type Copy(const Element (&array)[N]) { - return type(array, N, RelationToSourceCopy()); - } -}; - -// This specialization is used when RawContainer is a native array -// represented as a (pointer, size) tuple. -template <typename ElementPointer, typename Size> -class StlContainerView< ::std::tuple<ElementPointer, Size> > { - public: - typedef typename std::remove_const< - typename std::pointer_traits<ElementPointer>::element_type>::type - RawElement; - typedef internal::NativeArray<RawElement> type; - typedef const type const_reference; - - static const_reference ConstReference( - const ::std::tuple<ElementPointer, Size>& array) { - return type(std::get<0>(array), std::get<1>(array), - RelationToSourceReference()); - } - static type Copy(const ::std::tuple<ElementPointer, Size>& array) { - return type(std::get<0>(array), std::get<1>(array), RelationToSourceCopy()); - } -}; - -// The following specialization prevents the user from instantiating -// StlContainer with a reference type. -template <typename T> -class StlContainerView<T&>; - -// A type transform to remove constness from the first part of a pair. -// Pairs like that are used as the value_type of associative containers, -// and this transform produces a similar but assignable pair. -template <typename T> -struct RemoveConstFromKey { - typedef T type; -}; - -// Partially specialized to remove constness from std::pair<const K, V>. -template <typename K, typename V> -struct RemoveConstFromKey<std::pair<const K, V> > { - typedef std::pair<K, V> type; -}; - -// Emit an assertion failure due to incorrect DoDefault() usage. Out-of-lined to -// reduce code size. -GTEST_API_ void IllegalDoDefault(const char* file, int line); - -template <typename F, typename Tuple, size_t... Idx> -auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>) - -> decltype(std::forward<F>(f)( - std::get<Idx>(std::forward<Tuple>(args))...)) { - return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...); -} - -// Apply the function to a tuple of arguments. -template <typename F, typename Tuple> -auto Apply(F&& f, Tuple&& args) -> decltype(ApplyImpl( - std::forward<F>(f), std::forward<Tuple>(args), - MakeIndexSequence<std::tuple_size< - typename std::remove_reference<Tuple>::type>::value>())) { - return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args), - MakeIndexSequence<std::tuple_size< - typename std::remove_reference<Tuple>::type>::value>()); -} - -// Template struct Function<F>, where F must be a function type, contains -// the following typedefs: -// -// Result: the function's return type. -// Arg<N>: the type of the N-th argument, where N starts with 0. -// ArgumentTuple: the tuple type consisting of all parameters of F. -// ArgumentMatcherTuple: the tuple type consisting of Matchers for all -// parameters of F. -// MakeResultVoid: the function type obtained by substituting void -// for the return type of F. -// MakeResultIgnoredValue: -// the function type obtained by substituting Something -// for the return type of F. -template <typename T> -struct Function; - -template <typename R, typename... Args> -struct Function<R(Args...)> { - using Result = R; - static constexpr size_t ArgumentCount = sizeof...(Args); - template <size_t I> - using Arg = ElemFromList<I, Args...>; - using ArgumentTuple = std::tuple<Args...>; - using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>; - using MakeResultVoid = void(Args...); - using MakeResultIgnoredValue = IgnoredValue(Args...); -}; - -template <typename R, typename... Args> -constexpr size_t Function<R(Args...)>::ArgumentCount; - -bool Base64Unescape(const std::string& encoded, std::string* decoded); - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -} // namespace internal -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/internal/gmock-port.h b/third_party/googletest/src/googlemock/include/gmock/internal/gmock-port.h deleted file mode 100644 index bc18a25..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/internal/gmock-port.h +++ /dev/null
@@ -1,139 +0,0 @@ -// Copyright 2008, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Low-level types and utilities for porting Google Mock to various -// platforms. All macros ending with _ and symbols defined in an -// internal namespace are subject to change without notice. Code -// outside Google Mock MUST NOT USE THEM DIRECTLY. Macros that don't -// end with _ are part of Google Mock's public API and can be used by -// code outside Google Mock. - -// IWYU pragma: private, include "gmock/gmock.h" -// IWYU pragma: friend gmock/.* - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ - -#include <assert.h> -#include <stdlib.h> -#include <cstdint> -#include <iostream> - -// Most of the utilities needed for porting Google Mock are also -// required for Google Test and are defined in gtest-port.h. -// -// Note to maintainers: to reduce code duplication, prefer adding -// portability utilities to Google Test's gtest-port.h instead of -// here, as Google Mock depends on Google Test. Only add a utility -// here if it's truly specific to Google Mock. - -#include "gmock/internal/custom/gmock-port.h" -#include "gtest/internal/gtest-port.h" - -#if GTEST_HAS_ABSL -#include "absl/flags/declare.h" -#include "absl/flags/flag.h" -#endif - -// For MS Visual C++, check the compiler version. At least VS 2015 is -// required to compile Google Mock. -#if defined(_MSC_VER) && _MSC_VER < 1900 -#error "At least Visual C++ 2015 (14.0) is required to compile Google Mock." -#endif - -// Macro for referencing flags. This is public as we want the user to -// use this syntax to reference Google Mock flags. -#define GMOCK_FLAG_NAME_(name) gmock_##name -#define GMOCK_FLAG(name) FLAGS_gmock_##name - -// Pick a command line flags implementation. -#if GTEST_HAS_ABSL - -// Macros for defining flags. -#define GMOCK_DEFINE_bool_(name, default_val, doc) \ - ABSL_FLAG(bool, GMOCK_FLAG_NAME_(name), default_val, doc) -#define GMOCK_DEFINE_int32_(name, default_val, doc) \ - ABSL_FLAG(int32_t, GMOCK_FLAG_NAME_(name), default_val, doc) -#define GMOCK_DEFINE_string_(name, default_val, doc) \ - ABSL_FLAG(std::string, GMOCK_FLAG_NAME_(name), default_val, doc) - -// Macros for declaring flags. -#define GMOCK_DECLARE_bool_(name) \ - ABSL_DECLARE_FLAG(bool, GMOCK_FLAG_NAME_(name)) -#define GMOCK_DECLARE_int32_(name) \ - ABSL_DECLARE_FLAG(int32_t, GMOCK_FLAG_NAME_(name)) -#define GMOCK_DECLARE_string_(name) \ - ABSL_DECLARE_FLAG(std::string, GMOCK_FLAG_NAME_(name)) - -#define GMOCK_FLAG_GET(name) ::absl::GetFlag(GMOCK_FLAG(name)) -#define GMOCK_FLAG_SET(name, value) \ - (void)(::absl::SetFlag(&GMOCK_FLAG(name), value)) - -#else // GTEST_HAS_ABSL - -// Macros for defining flags. -#define GMOCK_DEFINE_bool_(name, default_val, doc) \ - namespace testing { \ - GTEST_API_ bool GMOCK_FLAG(name) = (default_val); \ - } \ - static_assert(true, "no-op to require trailing semicolon") -#define GMOCK_DEFINE_int32_(name, default_val, doc) \ - namespace testing { \ - GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val); \ - } \ - static_assert(true, "no-op to require trailing semicolon") -#define GMOCK_DEFINE_string_(name, default_val, doc) \ - namespace testing { \ - GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val); \ - } \ - static_assert(true, "no-op to require trailing semicolon") - -// Macros for declaring flags. -#define GMOCK_DECLARE_bool_(name) \ - namespace testing { \ - GTEST_API_ extern bool GMOCK_FLAG(name); \ - } \ - static_assert(true, "no-op to require trailing semicolon") -#define GMOCK_DECLARE_int32_(name) \ - namespace testing { \ - GTEST_API_ extern int32_t GMOCK_FLAG(name); \ - } \ - static_assert(true, "no-op to require trailing semicolon") -#define GMOCK_DECLARE_string_(name) \ - namespace testing { \ - GTEST_API_ extern ::std::string GMOCK_FLAG(name); \ - } \ - static_assert(true, "no-op to require trailing semicolon") - -#define GMOCK_FLAG_GET(name) ::testing::GMOCK_FLAG(name) -#define GMOCK_FLAG_SET(name, value) (void)(::testing::GMOCK_FLAG(name) = value) - -#endif // GTEST_HAS_ABSL - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
diff --git a/third_party/googletest/src/googlemock/include/gmock/internal/gmock-pp.h b/third_party/googletest/src/googlemock/include/gmock/internal/gmock-pp.h deleted file mode 100644 index 94d61c0..0000000 --- a/third_party/googletest/src/googlemock/include/gmock/internal/gmock-pp.h +++ /dev/null
@@ -1,279 +0,0 @@ -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ - -// Expands and concatenates the arguments. Constructed macros reevaluate. -#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2) - -// Expands and stringifies the only argument. -#define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__) - -// Returns empty. Given a variadic number of arguments. -#define GMOCK_PP_EMPTY(...) - -// Returns a comma. Given a variadic number of arguments. -#define GMOCK_PP_COMMA(...) , - -// Returns the only argument. -#define GMOCK_PP_IDENTITY(_1) _1 - -// Evaluates to the number of arguments after expansion. -// -// #define PAIR x, y -// -// GMOCK_PP_NARG() => 1 -// GMOCK_PP_NARG(x) => 1 -// GMOCK_PP_NARG(x, y) => 2 -// GMOCK_PP_NARG(PAIR) => 2 -// -// Requires: the number of arguments after expansion is at most 15. -#define GMOCK_PP_NARG(...) \ - GMOCK_PP_INTERNAL_16TH( \ - (__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)) - -// Returns 1 if the expansion of arguments has an unprotected comma. Otherwise -// returns 0. Requires no more than 15 unprotected commas. -#define GMOCK_PP_HAS_COMMA(...) \ - GMOCK_PP_INTERNAL_16TH( \ - (__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0)) - -// Returns the first argument. -#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD((__VA_ARGS__, unusedArg)) - -// Returns the tail. A variadic list of all arguments minus the first. Requires -// at least one argument. -#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL((__VA_ARGS__)) - -// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__) -#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \ - GMOCK_PP_IDENTITY( \ - GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__)) - -// If the arguments after expansion have no tokens, evaluates to `1`. Otherwise -// evaluates to `0`. -// -// Requires: * the number of arguments after expansion is at most 15. -// * If the argument is a macro, it must be able to be called with one -// argument. -// -// Implementation details: -// -// There is one case when it generates a compile error: if the argument is macro -// that cannot be called with one argument. -// -// #define M(a, b) // it doesn't matter what it expands to -// -// // Expected: expands to `0`. -// // Actual: compile error. -// GMOCK_PP_IS_EMPTY(M) -// -// There are 4 cases tested: -// -// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0. -// * __VA_ARGS__ possible expansion is not enclosed in parenthesis. Expected 0. -// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a comma. -// Expected 0 -// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in -// parenthesis, or is a macro that ()-evaluates to comma. Expected 1. -// -// We trigger detection on '0001', i.e. on empty. -#define GMOCK_PP_IS_EMPTY(...) \ - GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__), \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__), \ - GMOCK_PP_HAS_COMMA(__VA_ARGS__()), \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__())) - -// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0. -#define GMOCK_PP_IF(_Cond, _Then, _Else) \ - GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else) - -// Similar to GMOCK_PP_IF but takes _Then and _Else in parentheses. -// -// GMOCK_PP_GENERIC_IF(1, (a, b, c), (d, e, f)) => a, b, c -// GMOCK_PP_GENERIC_IF(0, (a, b, c), (d, e, f)) => d, e, f -// -#define GMOCK_PP_GENERIC_IF(_Cond, _Then, _Else) \ - GMOCK_PP_REMOVE_PARENS(GMOCK_PP_IF(_Cond, _Then, _Else)) - -// Evaluates to the number of arguments after expansion. Identifies 'empty' as -// 0. -// -// #define PAIR x, y -// -// GMOCK_PP_NARG0() => 0 -// GMOCK_PP_NARG0(x) => 1 -// GMOCK_PP_NARG0(x, y) => 2 -// GMOCK_PP_NARG0(PAIR) => 2 -// -// Requires: * the number of arguments after expansion is at most 15. -// * If the argument is a macro, it must be able to be called with one -// argument. -#define GMOCK_PP_NARG0(...) \ - GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0, GMOCK_PP_NARG(__VA_ARGS__)) - -// Expands to 1 if the first argument starts with something in parentheses, -// otherwise to 0. -#define GMOCK_PP_IS_BEGIN_PARENS(...) \ - GMOCK_PP_HEAD(GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \ - GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__)) - -// Expands to 1 is there is only one argument and it is enclosed in parentheses. -#define GMOCK_PP_IS_ENCLOSED_PARENS(...) \ - GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \ - GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0) - -// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1. -#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS __VA_ARGS__ - -// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data, -// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple. -// Requires: * |_Macro| can be called with 3 arguments. -// * |_Tuple| expansion has no more than 15 elements. -#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple) \ - GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \ - (0, _Macro, _Data, _Tuple) - -// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, ) -// Empty if _K = 0. -// Requires: * |_Macro| can be called with 3 arguments. -// * |_K| literal between 0 and 15 -#define GMOCK_PP_REPEAT(_Macro, _Data, _N) \ - GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \ - (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE) - -// Increments the argument, requires the argument to be between 0 and 15. -#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i) - -// Returns comma if _i != 0. Requires _i to be between 0 and 15. -#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i) - -// Internal details follow. Do not use any of these symbols outside of this -// file or we will break your code. -#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , ) -#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2 -#define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__ -#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5 -#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4) \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_, \ - _1, _2, _3, _4)) -#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 , -#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then -#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else - -// Because of MSVC treating a token with a comma in it as a single token when -// passed to another macro, we need to force it to evaluate it as multiple -// tokens. We do that by using a "IDENTITY(MACRO PARENTHESIZED_ARGS)" macro. We -// define one per possible macro that relies on this behavior. Note "_Args" must -// be parenthesized. -#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \ - _10, _11, _12, _13, _14, _15, _16, \ - ...) \ - _16 -#define GMOCK_PP_INTERNAL_16TH(_Args) \ - GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_16TH _Args) -#define GMOCK_PP_INTERNAL_INTERNAL_HEAD(_1, ...) _1 -#define GMOCK_PP_INTERNAL_HEAD(_Args) \ - GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_HEAD _Args) -#define GMOCK_PP_INTERNAL_INTERNAL_TAIL(_1, ...) __VA_ARGS__ -#define GMOCK_PP_INTERNAL_TAIL(_Args) \ - GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_TAIL _Args) - -#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _ -#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1, -#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \ - 0, -#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__ -#define GMOCK_PP_INTERNAL_INC_0 1 -#define GMOCK_PP_INTERNAL_INC_1 2 -#define GMOCK_PP_INTERNAL_INC_2 3 -#define GMOCK_PP_INTERNAL_INC_3 4 -#define GMOCK_PP_INTERNAL_INC_4 5 -#define GMOCK_PP_INTERNAL_INC_5 6 -#define GMOCK_PP_INTERNAL_INC_6 7 -#define GMOCK_PP_INTERNAL_INC_7 8 -#define GMOCK_PP_INTERNAL_INC_8 9 -#define GMOCK_PP_INTERNAL_INC_9 10 -#define GMOCK_PP_INTERNAL_INC_10 11 -#define GMOCK_PP_INTERNAL_INC_11 12 -#define GMOCK_PP_INTERNAL_INC_12 13 -#define GMOCK_PP_INTERNAL_INC_13 14 -#define GMOCK_PP_INTERNAL_INC_14 15 -#define GMOCK_PP_INTERNAL_INC_15 16 -#define GMOCK_PP_INTERNAL_COMMA_IF_0 -#define GMOCK_PP_INTERNAL_COMMA_IF_1 , -#define GMOCK_PP_INTERNAL_COMMA_IF_2 , -#define GMOCK_PP_INTERNAL_COMMA_IF_3 , -#define GMOCK_PP_INTERNAL_COMMA_IF_4 , -#define GMOCK_PP_INTERNAL_COMMA_IF_5 , -#define GMOCK_PP_INTERNAL_COMMA_IF_6 , -#define GMOCK_PP_INTERNAL_COMMA_IF_7 , -#define GMOCK_PP_INTERNAL_COMMA_IF_8 , -#define GMOCK_PP_INTERNAL_COMMA_IF_9 , -#define GMOCK_PP_INTERNAL_COMMA_IF_10 , -#define GMOCK_PP_INTERNAL_COMMA_IF_11 , -#define GMOCK_PP_INTERNAL_COMMA_IF_12 , -#define GMOCK_PP_INTERNAL_COMMA_IF_13 , -#define GMOCK_PP_INTERNAL_COMMA_IF_14 , -#define GMOCK_PP_INTERNAL_COMMA_IF_15 , -#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \ - _Macro(_i, _Data, _element) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
diff --git a/third_party/googletest/src/googlemock/src/gmock-all.cc b/third_party/googletest/src/googlemock/src/gmock-all.cc deleted file mode 100644 index e43c9b7..0000000 --- a/third_party/googletest/src/googlemock/src/gmock-all.cc +++ /dev/null
@@ -1,46 +0,0 @@ -// Copyright 2008, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// -// Google C++ Mocking Framework (Google Mock) -// -// This file #includes all Google Mock implementation .cc files. The -// purpose is to allow a user to build Google Mock by compiling this -// file alone. - -// This line ensures that gmock.h can be compiled on its own, even -// when it's fused. -#include "gmock/gmock.h" - -// The following lines pull in the real gmock *.cc files. -#include "src/gmock-cardinalities.cc" -#include "src/gmock-internal-utils.cc" -#include "src/gmock-matchers.cc" -#include "src/gmock-spec-builders.cc" -#include "src/gmock.cc"
diff --git a/third_party/googletest/src/googlemock/src/gmock-cardinalities.cc b/third_party/googletest/src/googlemock/src/gmock-cardinalities.cc deleted file mode 100644 index 92cde34..0000000 --- a/third_party/googletest/src/googlemock/src/gmock-cardinalities.cc +++ /dev/null
@@ -1,155 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements cardinalities. - -#include "gmock/gmock-cardinalities.h" - -#include <limits.h> - -#include <ostream> // NOLINT -#include <sstream> -#include <string> - -#include "gmock/internal/gmock-internal-utils.h" -#include "gtest/gtest.h" - -namespace testing { - -namespace { - -// Implements the Between(m, n) cardinality. -class BetweenCardinalityImpl : public CardinalityInterface { - public: - BetweenCardinalityImpl(int min, int max) - : min_(min >= 0 ? min : 0), max_(max >= min_ ? max : min_) { - std::stringstream ss; - if (min < 0) { - ss << "The invocation lower bound must be >= 0, " - << "but is actually " << min << "."; - internal::Expect(false, __FILE__, __LINE__, ss.str()); - } else if (max < 0) { - ss << "The invocation upper bound must be >= 0, " - << "but is actually " << max << "."; - internal::Expect(false, __FILE__, __LINE__, ss.str()); - } else if (min > max) { - ss << "The invocation upper bound (" << max - << ") must be >= the invocation lower bound (" << min << ")."; - internal::Expect(false, __FILE__, __LINE__, ss.str()); - } - } - - // Conservative estimate on the lower/upper bound of the number of - // calls allowed. - int ConservativeLowerBound() const override { return min_; } - int ConservativeUpperBound() const override { return max_; } - - bool IsSatisfiedByCallCount(int call_count) const override { - return min_ <= call_count && call_count <= max_; - } - - bool IsSaturatedByCallCount(int call_count) const override { - return call_count >= max_; - } - - void DescribeTo(::std::ostream* os) const override; - - private: - const int min_; - const int max_; - - BetweenCardinalityImpl(const BetweenCardinalityImpl&) = delete; - BetweenCardinalityImpl& operator=(const BetweenCardinalityImpl&) = delete; -}; - -// Formats "n times" in a human-friendly way. -inline std::string FormatTimes(int n) { - if (n == 1) { - return "once"; - } else if (n == 2) { - return "twice"; - } else { - std::stringstream ss; - ss << n << " times"; - return ss.str(); - } -} - -// Describes the Between(m, n) cardinality in human-friendly text. -void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const { - if (min_ == 0) { - if (max_ == 0) { - *os << "never called"; - } else if (max_ == INT_MAX) { - *os << "called any number of times"; - } else { - *os << "called at most " << FormatTimes(max_); - } - } else if (min_ == max_) { - *os << "called " << FormatTimes(min_); - } else if (max_ == INT_MAX) { - *os << "called at least " << FormatTimes(min_); - } else { - // 0 < min_ < max_ < INT_MAX - *os << "called between " << min_ << " and " << max_ << " times"; - } -} - -} // Unnamed namespace - -// Describes the given call count to an ostream. -void Cardinality::DescribeActualCallCountTo(int actual_call_count, - ::std::ostream* os) { - if (actual_call_count > 0) { - *os << "called " << FormatTimes(actual_call_count); - } else { - *os << "never called"; - } -} - -// Creates a cardinality that allows at least n calls. -GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); } - -// Creates a cardinality that allows at most n calls. -GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); } - -// Creates a cardinality that allows any number of calls. -GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); } - -// Creates a cardinality that allows between min and max calls. -GTEST_API_ Cardinality Between(int min, int max) { - return Cardinality(new BetweenCardinalityImpl(min, max)); -} - -// Creates a cardinality that allows exactly n calls. -GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); } - -} // namespace testing
diff --git a/third_party/googletest/src/googlemock/src/gmock-internal-utils.cc b/third_party/googletest/src/googlemock/src/gmock-internal-utils.cc deleted file mode 100644 index 0a74841..0000000 --- a/third_party/googletest/src/googlemock/src/gmock-internal-utils.cc +++ /dev/null
@@ -1,250 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file defines some utilities useful for implementing Google -// Mock. They are subject to change without notice, so please DO NOT -// USE THEM IN USER CODE. - -#include "gmock/internal/gmock-internal-utils.h" - -#include <ctype.h> - -#include <array> -#include <cctype> -#include <cstdint> -#include <cstring> -#include <ostream> // NOLINT -#include <string> -#include <vector> - -#include "gmock/gmock.h" -#include "gmock/internal/gmock-port.h" -#include "gtest/gtest.h" - -namespace testing { -namespace internal { - -// Joins a vector of strings as if they are fields of a tuple; returns -// the joined string. -GTEST_API_ std::string JoinAsKeyValueTuple( - const std::vector<const char*>& names, const Strings& values) { - GTEST_CHECK_(names.size() == values.size()); - if (values.empty()) { - return ""; - } - const auto build_one = [&](const size_t i) { - return std::string(names[i]) + ": " + values[i]; - }; - std::string result = "(" + build_one(0); - for (size_t i = 1; i < values.size(); i++) { - result += ", "; - result += build_one(i); - } - result += ")"; - return result; -} - -// Converts an identifier name to a space-separated list of lower-case -// words. Each maximum substring of the form [A-Za-z][a-z]*|\d+ is -// treated as one word. For example, both "FooBar123" and -// "foo_bar_123" are converted to "foo bar 123". -GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) { - std::string result; - char prev_char = '\0'; - for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) { - // We don't care about the current locale as the input is - // guaranteed to be a valid C++ identifier name. - const bool starts_new_word = IsUpper(*p) || - (!IsAlpha(prev_char) && IsLower(*p)) || - (!IsDigit(prev_char) && IsDigit(*p)); - - if (IsAlNum(*p)) { - if (starts_new_word && result != "") result += ' '; - result += ToLower(*p); - } - } - return result; -} - -// This class reports Google Mock failures as Google Test failures. A -// user can define another class in a similar fashion if they intend to -// use Google Mock with a testing framework other than Google Test. -class GoogleTestFailureReporter : public FailureReporterInterface { - public: - void ReportFailure(FailureType type, const char* file, int line, - const std::string& message) override { - AssertHelper(type == kFatal ? TestPartResult::kFatalFailure - : TestPartResult::kNonFatalFailure, - file, line, message.c_str()) = Message(); - if (type == kFatal) { - posix::Abort(); - } - } -}; - -// Returns the global failure reporter. Will create a -// GoogleTestFailureReporter and return it the first time called. -GTEST_API_ FailureReporterInterface* GetFailureReporter() { - // Points to the global failure reporter used by Google Mock. gcc - // guarantees that the following use of failure_reporter is - // thread-safe. We may need to add additional synchronization to - // protect failure_reporter if we port Google Mock to other - // compilers. - static FailureReporterInterface* const failure_reporter = - new GoogleTestFailureReporter(); - return failure_reporter; -} - -// Protects global resources (stdout in particular) used by Log(). -static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex); - -// Returns true if and only if a log with the given severity is visible -// according to the --gmock_verbose flag. -GTEST_API_ bool LogIsVisible(LogSeverity severity) { - if (GMOCK_FLAG_GET(verbose) == kInfoVerbosity) { - // Always show the log if --gmock_verbose=info. - return true; - } else if (GMOCK_FLAG_GET(verbose) == kErrorVerbosity) { - // Always hide it if --gmock_verbose=error. - return false; - } else { - // If --gmock_verbose is neither "info" nor "error", we treat it - // as "warning" (its default value). - return severity == kWarning; - } -} - -// Prints the given message to stdout if and only if 'severity' >= the level -// specified by the --gmock_verbose flag. If stack_frames_to_skip >= -// 0, also prints the stack trace excluding the top -// stack_frames_to_skip frames. In opt mode, any positive -// stack_frames_to_skip is treated as 0, since we don't know which -// function calls will be inlined by the compiler and need to be -// conservative. -GTEST_API_ void Log(LogSeverity severity, const std::string& message, - int stack_frames_to_skip) { - if (!LogIsVisible(severity)) return; - - // Ensures that logs from different threads don't interleave. - MutexLock l(&g_log_mutex); - - if (severity == kWarning) { - // Prints a GMOCK WARNING marker to make the warnings easily searchable. - std::cout << "\nGMOCK WARNING:"; - } - // Pre-pends a new-line to message if it doesn't start with one. - if (message.empty() || message[0] != '\n') { - std::cout << "\n"; - } - std::cout << message; - if (stack_frames_to_skip >= 0) { -#ifdef NDEBUG - // In opt mode, we have to be conservative and skip no stack frame. - const int actual_to_skip = 0; -#else - // In dbg mode, we can do what the caller tell us to do (plus one - // for skipping this function's stack frame). - const int actual_to_skip = stack_frames_to_skip + 1; -#endif // NDEBUG - - // Appends a new-line to message if it doesn't end with one. - if (!message.empty() && *message.rbegin() != '\n') { - std::cout << "\n"; - } - std::cout << "Stack trace:\n" - << ::testing::internal::GetCurrentOsStackTraceExceptTop( - ::testing::UnitTest::GetInstance(), actual_to_skip); - } - std::cout << ::std::flush; -} - -GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); } - -GTEST_API_ void IllegalDoDefault(const char* file, int line) { - internal::Assert( - false, file, line, - "You are using DoDefault() inside a composite action like " - "DoAll() or WithArgs(). This is not supported for technical " - "reasons. Please instead spell out the default action, or " - "assign the default action to an Action variable and use " - "the variable in various places."); -} - -constexpr char UnBase64Impl(char c, const char* const base64, char carry) { - return *base64 == 0 ? static_cast<char>(65) - : *base64 == c ? carry - : UnBase64Impl(c, base64 + 1, carry + 1); -} - -template <size_t... I> -constexpr std::array<char, 256> UnBase64Impl(IndexSequence<I...>, - const char* const base64) { - return {{UnBase64Impl(static_cast<char>(I), base64, 0)...}}; -} - -constexpr std::array<char, 256> UnBase64(const char* const base64) { - return UnBase64Impl(MakeIndexSequence<256>{}, base64); -} - -static constexpr char kBase64[] = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; -static constexpr std::array<char, 256> kUnBase64 = UnBase64(kBase64); - -bool Base64Unescape(const std::string& encoded, std::string* decoded) { - decoded->clear(); - size_t encoded_len = encoded.size(); - decoded->reserve(3 * (encoded_len / 4) + (encoded_len % 4)); - int bit_pos = 0; - char dst = 0; - for (int src : encoded) { - if (std::isspace(src) || src == '=') { - continue; - } - char src_bin = kUnBase64[static_cast<size_t>(src)]; - if (src_bin >= 64) { - decoded->clear(); - return false; - } - if (bit_pos == 0) { - dst |= static_cast<char>(src_bin << 2); - bit_pos = 6; - } else { - dst |= static_cast<char>(src_bin >> (bit_pos - 2)); - decoded->push_back(dst); - dst = static_cast<char>(src_bin << (10 - bit_pos)); - bit_pos = (bit_pos + 6) % 8; - } - } - return true; -} - -} // namespace internal -} // namespace testing
diff --git a/third_party/googletest/src/googlemock/src/gmock-matchers.cc b/third_party/googletest/src/googlemock/src/gmock-matchers.cc deleted file mode 100644 index a8d04a6..0000000 --- a/third_party/googletest/src/googlemock/src/gmock-matchers.cc +++ /dev/null
@@ -1,462 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements Matcher<const string&>, Matcher<string>, and -// utilities for defining matchers. - -#include "gmock/gmock-matchers.h" - -#include <string.h> - -#include <iostream> -#include <sstream> -#include <string> -#include <vector> - -namespace testing { -namespace internal { - -// Returns the description for a matcher defined using the MATCHER*() -// macro where the user-supplied description string is "", if -// 'negation' is false; otherwise returns the description of the -// negation of the matcher. 'param_values' contains a list of strings -// that are the print-out of the matcher's parameters. -GTEST_API_ std::string FormatMatcherDescription( - bool negation, const char* matcher_name, - const std::vector<const char*>& param_names, const Strings& param_values) { - std::string result = ConvertIdentifierNameToWords(matcher_name); - if (param_values.size() >= 1) { - result += " " + JoinAsKeyValueTuple(param_names, param_values); - } - return negation ? "not (" + result + ")" : result; -} - -// FindMaxBipartiteMatching and its helper class. -// -// Uses the well-known Ford-Fulkerson max flow method to find a maximum -// bipartite matching. Flow is considered to be from left to right. -// There is an implicit source node that is connected to all of the left -// nodes, and an implicit sink node that is connected to all of the -// right nodes. All edges have unit capacity. -// -// Neither the flow graph nor the residual flow graph are represented -// explicitly. Instead, they are implied by the information in 'graph' and -// a vector<int> called 'left_' whose elements are initialized to the -// value kUnused. This represents the initial state of the algorithm, -// where the flow graph is empty, and the residual flow graph has the -// following edges: -// - An edge from source to each left_ node -// - An edge from each right_ node to sink -// - An edge from each left_ node to each right_ node, if the -// corresponding edge exists in 'graph'. -// -// When the TryAugment() method adds a flow, it sets left_[l] = r for some -// nodes l and r. This induces the following changes: -// - The edges (source, l), (l, r), and (r, sink) are added to the -// flow graph. -// - The same three edges are removed from the residual flow graph. -// - The reverse edges (l, source), (r, l), and (sink, r) are added -// to the residual flow graph, which is a directional graph -// representing unused flow capacity. -// -// When the method augments a flow (moving left_[l] from some r1 to some -// other r2), this can be thought of as "undoing" the above steps with -// respect to r1 and "redoing" them with respect to r2. -// -// It bears repeating that the flow graph and residual flow graph are -// never represented explicitly, but can be derived by looking at the -// information in 'graph' and in left_. -// -// As an optimization, there is a second vector<int> called right_ which -// does not provide any new information. Instead, it enables more -// efficient queries about edges entering or leaving the right-side nodes -// of the flow or residual flow graphs. The following invariants are -// maintained: -// -// left[l] == kUnused or right[left[l]] == l -// right[r] == kUnused or left[right[r]] == r -// -// . [ source ] . -// . ||| . -// . ||| . -// . ||\--> left[0]=1 ---\ right[0]=-1 ----\ . -// . || | | . -// . |\---> left[1]=-1 \--> right[1]=0 ---\| . -// . | || . -// . \----> left[2]=2 ------> right[2]=2 --\|| . -// . ||| . -// . elements matchers vvv . -// . [ sink ] . -// -// See Also: -// [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method". -// "Introduction to Algorithms (Second ed.)", pp. 651-664. -// [2] "Ford-Fulkerson algorithm", Wikipedia, -// 'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm' -class MaxBipartiteMatchState { - public: - explicit MaxBipartiteMatchState(const MatchMatrix& graph) - : graph_(&graph), - left_(graph_->LhsSize(), kUnused), - right_(graph_->RhsSize(), kUnused) {} - - // Returns the edges of a maximal match, each in the form {left, right}. - ElementMatcherPairs Compute() { - // 'seen' is used for path finding { 0: unseen, 1: seen }. - ::std::vector<char> seen; - // Searches the residual flow graph for a path from each left node to - // the sink in the residual flow graph, and if one is found, add flow - // to the graph. It's okay to search through the left nodes once. The - // edge from the implicit source node to each previously-visited left - // node will have flow if that left node has any path to the sink - // whatsoever. Subsequent augmentations can only add flow to the - // network, and cannot take away that previous flow unit from the source. - // Since the source-to-left edge can only carry one flow unit (or, - // each element can be matched to only one matcher), there is no need - // to visit the left nodes more than once looking for augmented paths. - // The flow is known to be possible or impossible by looking at the - // node once. - for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) { - // Reset the path-marking vector and try to find a path from - // source to sink starting at the left_[ilhs] node. - GTEST_CHECK_(left_[ilhs] == kUnused) - << "ilhs: " << ilhs << ", left_[ilhs]: " << left_[ilhs]; - // 'seen' initialized to 'graph_->RhsSize()' copies of 0. - seen.assign(graph_->RhsSize(), 0); - TryAugment(ilhs, &seen); - } - ElementMatcherPairs result; - for (size_t ilhs = 0; ilhs < left_.size(); ++ilhs) { - size_t irhs = left_[ilhs]; - if (irhs == kUnused) continue; - result.push_back(ElementMatcherPair(ilhs, irhs)); - } - return result; - } - - private: - static const size_t kUnused = static_cast<size_t>(-1); - - // Perform a depth-first search from left node ilhs to the sink. If a - // path is found, flow is added to the network by linking the left and - // right vector elements corresponding each segment of the path. - // Returns true if a path to sink was found, which means that a unit of - // flow was added to the network. The 'seen' vector elements correspond - // to right nodes and are marked to eliminate cycles from the search. - // - // Left nodes will only be explored at most once because they - // are accessible from at most one right node in the residual flow - // graph. - // - // Note that left_[ilhs] is the only element of left_ that TryAugment will - // potentially transition from kUnused to another value. Any other - // left_ element holding kUnused before TryAugment will be holding it - // when TryAugment returns. - // - bool TryAugment(size_t ilhs, ::std::vector<char>* seen) { - for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) { - if ((*seen)[irhs]) continue; - if (!graph_->HasEdge(ilhs, irhs)) continue; - // There's an available edge from ilhs to irhs. - (*seen)[irhs] = 1; - // Next a search is performed to determine whether - // this edge is a dead end or leads to the sink. - // - // right_[irhs] == kUnused means that there is residual flow from - // right node irhs to the sink, so we can use that to finish this - // flow path and return success. - // - // Otherwise there is residual flow to some ilhs. We push flow - // along that path and call ourselves recursively to see if this - // ultimately leads to sink. - if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) { - // Add flow from left_[ilhs] to right_[irhs]. - left_[ilhs] = irhs; - right_[irhs] = ilhs; - return true; - } - } - return false; - } - - const MatchMatrix* graph_; // not owned - // Each element of the left_ vector represents a left hand side node - // (i.e. an element) and each element of right_ is a right hand side - // node (i.e. a matcher). The values in the left_ vector indicate - // outflow from that node to a node on the right_ side. The values - // in the right_ indicate inflow, and specify which left_ node is - // feeding that right_ node, if any. For example, left_[3] == 1 means - // there's a flow from element #3 to matcher #1. Such a flow would also - // be redundantly represented in the right_ vector as right_[1] == 3. - // Elements of left_ and right_ are either kUnused or mutually - // referent. Mutually referent means that left_[right_[i]] = i and - // right_[left_[i]] = i. - ::std::vector<size_t> left_; - ::std::vector<size_t> right_; -}; - -const size_t MaxBipartiteMatchState::kUnused; - -GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g) { - return MaxBipartiteMatchState(g).Compute(); -} - -static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs, - ::std::ostream* stream) { - typedef ElementMatcherPairs::const_iterator Iter; - ::std::ostream& os = *stream; - os << "{"; - const char* sep = ""; - for (Iter it = pairs.begin(); it != pairs.end(); ++it) { - os << sep << "\n (" - << "element #" << it->first << ", " - << "matcher #" << it->second << ")"; - sep = ","; - } - os << "\n}"; -} - -bool MatchMatrix::NextGraph() { - for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) { - for (size_t irhs = 0; irhs < RhsSize(); ++irhs) { - char& b = matched_[SpaceIndex(ilhs, irhs)]; - if (!b) { - b = 1; - return true; - } - b = 0; - } - } - return false; -} - -void MatchMatrix::Randomize() { - for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) { - for (size_t irhs = 0; irhs < RhsSize(); ++irhs) { - char& b = matched_[SpaceIndex(ilhs, irhs)]; - b = static_cast<char>(rand() & 1); // NOLINT - } - } -} - -std::string MatchMatrix::DebugString() const { - ::std::stringstream ss; - const char* sep = ""; - for (size_t i = 0; i < LhsSize(); ++i) { - ss << sep; - for (size_t j = 0; j < RhsSize(); ++j) { - ss << HasEdge(i, j); - } - sep = ";"; - } - return ss.str(); -} - -void UnorderedElementsAreMatcherImplBase::DescribeToImpl( - ::std::ostream* os) const { - switch (match_flags()) { - case UnorderedMatcherRequire::ExactMatch: - if (matcher_describers_.empty()) { - *os << "is empty"; - return; - } - if (matcher_describers_.size() == 1) { - *os << "has " << Elements(1) << " and that element "; - matcher_describers_[0]->DescribeTo(os); - return; - } - *os << "has " << Elements(matcher_describers_.size()) - << " and there exists some permutation of elements such that:\n"; - break; - case UnorderedMatcherRequire::Superset: - *os << "a surjection from elements to requirements exists such that:\n"; - break; - case UnorderedMatcherRequire::Subset: - *os << "an injection from elements to requirements exists such that:\n"; - break; - } - - const char* sep = ""; - for (size_t i = 0; i != matcher_describers_.size(); ++i) { - *os << sep; - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - *os << " - element #" << i << " "; - } else { - *os << " - an element "; - } - matcher_describers_[i]->DescribeTo(os); - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - sep = ", and\n"; - } else { - sep = "\n"; - } - } -} - -void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl( - ::std::ostream* os) const { - switch (match_flags()) { - case UnorderedMatcherRequire::ExactMatch: - if (matcher_describers_.empty()) { - *os << "isn't empty"; - return; - } - if (matcher_describers_.size() == 1) { - *os << "doesn't have " << Elements(1) << ", or has " << Elements(1) - << " that "; - matcher_describers_[0]->DescribeNegationTo(os); - return; - } - *os << "doesn't have " << Elements(matcher_describers_.size()) - << ", or there exists no permutation of elements such that:\n"; - break; - case UnorderedMatcherRequire::Superset: - *os << "no surjection from elements to requirements exists such that:\n"; - break; - case UnorderedMatcherRequire::Subset: - *os << "no injection from elements to requirements exists such that:\n"; - break; - } - const char* sep = ""; - for (size_t i = 0; i != matcher_describers_.size(); ++i) { - *os << sep; - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - *os << " - element #" << i << " "; - } else { - *os << " - an element "; - } - matcher_describers_[i]->DescribeTo(os); - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - sep = ", and\n"; - } else { - sep = "\n"; - } - } -} - -// Checks that all matchers match at least one element, and that all -// elements match at least one matcher. This enables faster matching -// and better error reporting. -// Returns false, writing an explanation to 'listener', if and only -// if the success criteria are not met. -bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix( - const ::std::vector<std::string>& element_printouts, - const MatchMatrix& matrix, MatchResultListener* listener) const { - bool result = true; - ::std::vector<char> element_matched(matrix.LhsSize(), 0); - ::std::vector<char> matcher_matched(matrix.RhsSize(), 0); - - for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) { - for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) { - char matched = matrix.HasEdge(ilhs, irhs); - element_matched[ilhs] |= matched; - matcher_matched[irhs] |= matched; - } - } - - if (match_flags() & UnorderedMatcherRequire::Superset) { - const char* sep = - "where the following matchers don't match any elements:\n"; - for (size_t mi = 0; mi < matcher_matched.size(); ++mi) { - if (matcher_matched[mi]) continue; - result = false; - if (listener->IsInterested()) { - *listener << sep << "matcher #" << mi << ": "; - matcher_describers_[mi]->DescribeTo(listener->stream()); - sep = ",\n"; - } - } - } - - if (match_flags() & UnorderedMatcherRequire::Subset) { - const char* sep = - "where the following elements don't match any matchers:\n"; - const char* outer_sep = ""; - if (!result) { - outer_sep = "\nand "; - } - for (size_t ei = 0; ei < element_matched.size(); ++ei) { - if (element_matched[ei]) continue; - result = false; - if (listener->IsInterested()) { - *listener << outer_sep << sep << "element #" << ei << ": " - << element_printouts[ei]; - sep = ",\n"; - outer_sep = ""; - } - } - } - return result; -} - -bool UnorderedElementsAreMatcherImplBase::FindPairing( - const MatchMatrix& matrix, MatchResultListener* listener) const { - ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix); - - size_t max_flow = matches.size(); - if ((match_flags() & UnorderedMatcherRequire::Superset) && - max_flow < matrix.RhsSize()) { - if (listener->IsInterested()) { - *listener << "where no permutation of the elements can satisfy all " - "matchers, and the closest match is " - << max_flow << " of " << matrix.RhsSize() - << " matchers with the pairings:\n"; - LogElementMatcherPairVec(matches, listener->stream()); - } - return false; - } - if ((match_flags() & UnorderedMatcherRequire::Subset) && - max_flow < matrix.LhsSize()) { - if (listener->IsInterested()) { - *listener - << "where not all elements can be matched, and the closest match is " - << max_flow << " of " << matrix.RhsSize() - << " matchers with the pairings:\n"; - LogElementMatcherPairVec(matches, listener->stream()); - } - return false; - } - - if (matches.size() > 1) { - if (listener->IsInterested()) { - const char* sep = "where:\n"; - for (size_t mi = 0; mi < matches.size(); ++mi) { - *listener << sep << " - element #" << matches[mi].first - << " is matched by matcher #" << matches[mi].second; - sep = ",\n"; - } - } - } - return true; -} - -} // namespace internal -} // namespace testing
diff --git a/third_party/googletest/src/googlemock/src/gmock-spec-builders.cc b/third_party/googletest/src/googlemock/src/gmock-spec-builders.cc deleted file mode 100644 index 658ad3f..0000000 --- a/third_party/googletest/src/googlemock/src/gmock-spec-builders.cc +++ /dev/null
@@ -1,781 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements the spec builder syntax (ON_CALL and -// EXPECT_CALL). - -#include "gmock/gmock-spec-builders.h" - -#include <stdlib.h> - -#include <iostream> // NOLINT -#include <map> -#include <memory> -#include <set> -#include <string> -#include <unordered_map> -#include <vector> - -#include "gmock/gmock.h" -#include "gtest/gtest.h" -#include "gtest/internal/gtest-port.h" - -#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC -#include <unistd.h> // NOLINT -#endif - -// Silence C4800 (C4800: 'int *const ': forcing value -// to bool 'true' or 'false') for MSVC 15 -#ifdef _MSC_VER -#if _MSC_VER == 1900 -#pragma warning(push) -#pragma warning(disable : 4800) -#endif -#endif - -namespace testing { -namespace internal { - -// Protects the mock object registry (in class Mock), all function -// mockers, and all expectations. -GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex); - -// Logs a message including file and line number information. -GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity, - const char* file, int line, - const std::string& message) { - ::std::ostringstream s; - s << internal::FormatFileLocation(file, line) << " " << message - << ::std::endl; - Log(severity, s.str(), 0); -} - -// Constructs an ExpectationBase object. -ExpectationBase::ExpectationBase(const char* a_file, int a_line, - const std::string& a_source_text) - : file_(a_file), - line_(a_line), - source_text_(a_source_text), - cardinality_specified_(false), - cardinality_(Exactly(1)), - call_count_(0), - retired_(false), - extra_matcher_specified_(false), - repeated_action_specified_(false), - retires_on_saturation_(false), - last_clause_(kNone), - action_count_checked_(false) {} - -// Destructs an ExpectationBase object. -ExpectationBase::~ExpectationBase() {} - -// Explicitly specifies the cardinality of this expectation. Used by -// the subclasses to implement the .Times() clause. -void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) { - cardinality_specified_ = true; - cardinality_ = a_cardinality; -} - -// Retires all pre-requisites of this expectation. -void ExpectationBase::RetireAllPreRequisites() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - if (is_retired()) { - // We can take this short-cut as we never retire an expectation - // until we have retired all its pre-requisites. - return; - } - - ::std::vector<ExpectationBase*> expectations(1, this); - while (!expectations.empty()) { - ExpectationBase* exp = expectations.back(); - expectations.pop_back(); - - for (ExpectationSet::const_iterator it = - exp->immediate_prerequisites_.begin(); - it != exp->immediate_prerequisites_.end(); ++it) { - ExpectationBase* next = it->expectation_base().get(); - if (!next->is_retired()) { - next->Retire(); - expectations.push_back(next); - } - } - } -} - -// Returns true if and only if all pre-requisites of this expectation -// have been satisfied. -bool ExpectationBase::AllPrerequisitesAreSatisfied() const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - ::std::vector<const ExpectationBase*> expectations(1, this); - while (!expectations.empty()) { - const ExpectationBase* exp = expectations.back(); - expectations.pop_back(); - - for (ExpectationSet::const_iterator it = - exp->immediate_prerequisites_.begin(); - it != exp->immediate_prerequisites_.end(); ++it) { - const ExpectationBase* next = it->expectation_base().get(); - if (!next->IsSatisfied()) return false; - expectations.push_back(next); - } - } - return true; -} - -// Adds unsatisfied pre-requisites of this expectation to 'result'. -void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - ::std::vector<const ExpectationBase*> expectations(1, this); - while (!expectations.empty()) { - const ExpectationBase* exp = expectations.back(); - expectations.pop_back(); - - for (ExpectationSet::const_iterator it = - exp->immediate_prerequisites_.begin(); - it != exp->immediate_prerequisites_.end(); ++it) { - const ExpectationBase* next = it->expectation_base().get(); - - if (next->IsSatisfied()) { - // If *it is satisfied and has a call count of 0, some of its - // pre-requisites may not be satisfied yet. - if (next->call_count_ == 0) { - expectations.push_back(next); - } - } else { - // Now that we know next is unsatisfied, we are not so interested - // in whether its pre-requisites are satisfied. Therefore we - // don't iterate into it here. - *result += *it; - } - } - } -} - -// Describes how many times a function call matching this -// expectation has occurred. -void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - - // Describes how many times the function is expected to be called. - *os << " Expected: to be "; - cardinality().DescribeTo(os); - *os << "\n Actual: "; - Cardinality::DescribeActualCallCountTo(call_count(), os); - - // Describes the state of the expectation (e.g. is it satisfied? - // is it active?). - *os << " - " - << (IsOverSaturated() ? "over-saturated" - : IsSaturated() ? "saturated" - : IsSatisfied() ? "satisfied" - : "unsatisfied") - << " and " << (is_retired() ? "retired" : "active"); -} - -// Checks the action count (i.e. the number of WillOnce() and -// WillRepeatedly() clauses) against the cardinality if this hasn't -// been done before. Prints a warning if there are too many or too -// few actions. -void ExpectationBase::CheckActionCountIfNotDone() const - GTEST_LOCK_EXCLUDED_(mutex_) { - bool should_check = false; - { - MutexLock l(&mutex_); - if (!action_count_checked_) { - action_count_checked_ = true; - should_check = true; - } - } - - if (should_check) { - if (!cardinality_specified_) { - // The cardinality was inferred - no need to check the action - // count against it. - return; - } - - // The cardinality was explicitly specified. - const int action_count = static_cast<int>(untyped_actions_.size()); - const int upper_bound = cardinality().ConservativeUpperBound(); - const int lower_bound = cardinality().ConservativeLowerBound(); - bool too_many; // True if there are too many actions, or false - // if there are too few. - if (action_count > upper_bound || - (action_count == upper_bound && repeated_action_specified_)) { - too_many = true; - } else if (0 < action_count && action_count < lower_bound && - !repeated_action_specified_) { - too_many = false; - } else { - return; - } - - ::std::stringstream ss; - DescribeLocationTo(&ss); - ss << "Too " << (too_many ? "many" : "few") << " actions specified in " - << source_text() << "...\n" - << "Expected to be "; - cardinality().DescribeTo(&ss); - ss << ", but has " << (too_many ? "" : "only ") << action_count - << " WillOnce()" << (action_count == 1 ? "" : "s"); - if (repeated_action_specified_) { - ss << " and a WillRepeatedly()"; - } - ss << "."; - Log(kWarning, ss.str(), -1); // -1 means "don't print stack trace". - } -} - -// Implements the .Times() clause. -void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) { - if (last_clause_ == kTimes) { - ExpectSpecProperty(false, - ".Times() cannot appear " - "more than once in an EXPECT_CALL()."); - } else { - ExpectSpecProperty( - last_clause_ < kTimes, - ".Times() may only appear *before* .InSequence(), .WillOnce(), " - ".WillRepeatedly(), or .RetiresOnSaturation(), not after."); - } - last_clause_ = kTimes; - - SpecifyCardinality(a_cardinality); -} - -// Points to the implicit sequence introduced by a living InSequence -// object (if any) in the current thread or NULL. -GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence; - -// Reports an uninteresting call (whose description is in msg) in the -// manner specified by 'reaction'. -void ReportUninterestingCall(CallReaction reaction, const std::string& msg) { - // Include a stack trace only if --gmock_verbose=info is specified. - const int stack_frames_to_skip = - GMOCK_FLAG_GET(verbose) == kInfoVerbosity ? 3 : -1; - switch (reaction) { - case kAllow: - Log(kInfo, msg, stack_frames_to_skip); - break; - case kWarn: - Log(kWarning, - msg + - "\nNOTE: You can safely ignore the above warning unless this " - "call should not happen. Do not suppress it by blindly adding " - "an EXPECT_CALL() if you don't mean to enforce the call. " - "See " - "https://github.com/google/googletest/blob/master/docs/" - "gmock_cook_book.md#" - "knowing-when-to-expect for details.\n", - stack_frames_to_skip); - break; - default: // FAIL - Expect(false, nullptr, -1, msg); - } -} - -UntypedFunctionMockerBase::UntypedFunctionMockerBase() - : mock_obj_(nullptr), name_("") {} - -UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {} - -// Sets the mock object this mock method belongs to, and registers -// this information in the global mock registry. Will be called -// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock -// method. -void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - { - MutexLock l(&g_gmock_mutex); - mock_obj_ = mock_obj; - } - Mock::Register(mock_obj, this); -} - -// Sets the mock object this mock method belongs to, and sets the name -// of the mock function. Will be called upon each invocation of this -// mock function. -void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj, - const char* name) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - // We protect name_ under g_gmock_mutex in case this mock function - // is called from two threads concurrently. - MutexLock l(&g_gmock_mutex); - mock_obj_ = mock_obj; - name_ = name; -} - -// Returns the name of the function being mocked. Must be called -// after RegisterOwner() or SetOwnerAndName() has been called. -const void* UntypedFunctionMockerBase::MockObject() const - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - const void* mock_obj; - { - // We protect mock_obj_ under g_gmock_mutex in case this mock - // function is called from two threads concurrently. - MutexLock l(&g_gmock_mutex); - Assert(mock_obj_ != nullptr, __FILE__, __LINE__, - "MockObject() must not be called before RegisterOwner() or " - "SetOwnerAndName() has been called."); - mock_obj = mock_obj_; - } - return mock_obj; -} - -// Returns the name of this mock method. Must be called after -// SetOwnerAndName() has been called. -const char* UntypedFunctionMockerBase::Name() const - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - const char* name; - { - // We protect name_ under g_gmock_mutex in case this mock - // function is called from two threads concurrently. - MutexLock l(&g_gmock_mutex); - Assert(name_ != nullptr, __FILE__, __LINE__, - "Name() must not be called before SetOwnerAndName() has " - "been called."); - name = name_; - } - return name; -} - -// Returns an Expectation object that references and co-owns exp, -// which must be an expectation on this mock function. -Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) { - // See the definition of untyped_expectations_ for why access to it - // is unprotected here. - for (UntypedExpectations::const_iterator it = untyped_expectations_.begin(); - it != untyped_expectations_.end(); ++it) { - if (it->get() == exp) { - return Expectation(*it); - } - } - - Assert(false, __FILE__, __LINE__, "Cannot find expectation."); - return Expectation(); - // The above statement is just to make the code compile, and will - // never be executed. -} - -// Verifies that all expectations on this mock function have been -// satisfied. Reports one or more Google Test non-fatal failures -// and returns false if not. -bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - bool expectations_met = true; - for (UntypedExpectations::const_iterator it = untyped_expectations_.begin(); - it != untyped_expectations_.end(); ++it) { - ExpectationBase* const untyped_expectation = it->get(); - if (untyped_expectation->IsOverSaturated()) { - // There was an upper-bound violation. Since the error was - // already reported when it occurred, there is no need to do - // anything here. - expectations_met = false; - } else if (!untyped_expectation->IsSatisfied()) { - expectations_met = false; - ::std::stringstream ss; - ss << "Actual function call count doesn't match " - << untyped_expectation->source_text() << "...\n"; - // No need to show the source file location of the expectation - // in the description, as the Expect() call that follows already - // takes care of it. - untyped_expectation->MaybeDescribeExtraMatcherTo(&ss); - untyped_expectation->DescribeCallCountTo(&ss); - Expect(false, untyped_expectation->file(), untyped_expectation->line(), - ss.str()); - } - } - - // Deleting our expectations may trigger other mock objects to be deleted, for - // example if an action contains a reference counted smart pointer to that - // mock object, and that is the last reference. So if we delete our - // expectations within the context of the global mutex we may deadlock when - // this method is called again. Instead, make a copy of the set of - // expectations to delete, clear our set within the mutex, and then clear the - // copied set outside of it. - UntypedExpectations expectations_to_delete; - untyped_expectations_.swap(expectations_to_delete); - - g_gmock_mutex.Unlock(); - expectations_to_delete.clear(); - g_gmock_mutex.Lock(); - - return expectations_met; -} - -CallReaction intToCallReaction(int mock_behavior) { - if (mock_behavior >= kAllow && mock_behavior <= kFail) { - return static_cast<internal::CallReaction>(mock_behavior); - } - return kWarn; -} - -} // namespace internal - -// Class Mock. - -namespace { - -typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers; - -// The current state of a mock object. Such information is needed for -// detecting leaked mock objects and explicitly verifying a mock's -// expectations. -struct MockObjectState { - MockObjectState() - : first_used_file(nullptr), first_used_line(-1), leakable(false) {} - - // Where in the source file an ON_CALL or EXPECT_CALL is first - // invoked on this mock object. - const char* first_used_file; - int first_used_line; - ::std::string first_used_test_suite; - ::std::string first_used_test; - bool leakable; // true if and only if it's OK to leak the object. - FunctionMockers function_mockers; // All registered methods of the object. -}; - -// A global registry holding the state of all mock objects that are -// alive. A mock object is added to this registry the first time -// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it. It -// is removed from the registry in the mock object's destructor. -class MockObjectRegistry { - public: - // Maps a mock object (identified by its address) to its state. - typedef std::map<const void*, MockObjectState> StateMap; - - // This destructor will be called when a program exits, after all - // tests in it have been run. By then, there should be no mock - // object alive. Therefore we report any living object as test - // failure, unless the user explicitly asked us to ignore it. - ~MockObjectRegistry() { - if (!GMOCK_FLAG_GET(catch_leaked_mocks)) return; - - int leaked_count = 0; - for (StateMap::const_iterator it = states_.begin(); it != states_.end(); - ++it) { - if (it->second.leakable) // The user said it's fine to leak this object. - continue; - - // FIXME: Print the type of the leaked object. - // This can help the user identify the leaked object. - std::cout << "\n"; - const MockObjectState& state = it->second; - std::cout << internal::FormatFileLocation(state.first_used_file, - state.first_used_line); - std::cout << " ERROR: this mock object"; - if (state.first_used_test != "") { - std::cout << " (used in test " << state.first_used_test_suite << "." - << state.first_used_test << ")"; - } - std::cout << " should be deleted but never is. Its address is @" - << it->first << "."; - leaked_count++; - } - if (leaked_count > 0) { - std::cout << "\nERROR: " << leaked_count << " leaked mock " - << (leaked_count == 1 ? "object" : "objects") - << " found at program exit. Expectations on a mock object are " - "verified when the object is destructed. Leaking a mock " - "means that its expectations aren't verified, which is " - "usually a test bug. If you really intend to leak a mock, " - "you can suppress this error using " - "testing::Mock::AllowLeak(mock_object), or you may use a " - "fake or stub instead of a mock.\n"; - std::cout.flush(); - ::std::cerr.flush(); - // RUN_ALL_TESTS() has already returned when this destructor is - // called. Therefore we cannot use the normal Google Test - // failure reporting mechanism. - _exit(1); // We cannot call exit() as it is not reentrant and - // may already have been called. - } - } - - StateMap& states() { return states_; } - - private: - StateMap states_; -}; - -// Protected by g_gmock_mutex. -MockObjectRegistry g_mock_object_registry; - -// Maps a mock object to the reaction Google Mock should have when an -// uninteresting method is called. Protected by g_gmock_mutex. -std::unordered_map<uintptr_t, internal::CallReaction>& -UninterestingCallReactionMap() { - static auto* map = new std::unordered_map<uintptr_t, internal::CallReaction>; - return *map; -} - -// Sets the reaction Google Mock should have when an uninteresting -// method of the given mock object is called. -void SetReactionOnUninterestingCalls(uintptr_t mock_obj, - internal::CallReaction reaction) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - UninterestingCallReactionMap()[mock_obj] = reaction; -} - -} // namespace - -// Tells Google Mock to allow uninteresting calls on the given mock -// object. -void Mock::AllowUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - SetReactionOnUninterestingCalls(mock_obj, internal::kAllow); -} - -// Tells Google Mock to warn the user about uninteresting calls on the -// given mock object. -void Mock::WarnUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - SetReactionOnUninterestingCalls(mock_obj, internal::kWarn); -} - -// Tells Google Mock to fail uninteresting calls on the given mock -// object. -void Mock::FailUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - SetReactionOnUninterestingCalls(mock_obj, internal::kFail); -} - -// Tells Google Mock the given mock object is being destroyed and its -// entry in the call-reaction table should be removed. -void Mock::UnregisterCallReaction(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - UninterestingCallReactionMap().erase(static_cast<uintptr_t>(mock_obj)); -} - -// Returns the reaction Google Mock will have on uninteresting calls -// made on the given mock object. -internal::CallReaction Mock::GetReactionOnUninterestingCalls( - const void* mock_obj) GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - return (UninterestingCallReactionMap().count( - reinterpret_cast<uintptr_t>(mock_obj)) == 0) - ? internal::intToCallReaction( - GMOCK_FLAG_GET(default_mock_behavior)) - : UninterestingCallReactionMap()[reinterpret_cast<uintptr_t>( - mock_obj)]; -} - -// Tells Google Mock to ignore mock_obj when checking for leaked mock -// objects. -void Mock::AllowLeak(const void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - g_mock_object_registry.states()[mock_obj].leakable = true; -} - -// Verifies and clears all expectations on the given mock object. If -// the expectations aren't satisfied, generates one or more Google -// Test non-fatal failures and returns false. -bool Mock::VerifyAndClearExpectations(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - return VerifyAndClearExpectationsLocked(mock_obj); -} - -// Verifies all expectations on the given mock object and clears its -// default actions and expectations. Returns true if and only if the -// verification was successful. -bool Mock::VerifyAndClear(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - ClearDefaultActionsLocked(mock_obj); - return VerifyAndClearExpectationsLocked(mock_obj); -} - -// Verifies and clears all expectations on the given mock object. If -// the expectations aren't satisfied, generates one or more Google -// Test non-fatal failures and returns false. -bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) { - internal::g_gmock_mutex.AssertHeld(); - if (g_mock_object_registry.states().count(mock_obj) == 0) { - // No EXPECT_CALL() was set on the given mock object. - return true; - } - - // Verifies and clears the expectations on each mock method in the - // given mock object. - bool expectations_met = true; - FunctionMockers& mockers = - g_mock_object_registry.states()[mock_obj].function_mockers; - for (FunctionMockers::const_iterator it = mockers.begin(); - it != mockers.end(); ++it) { - if (!(*it)->VerifyAndClearExpectationsLocked()) { - expectations_met = false; - } - } - - // We don't clear the content of mockers, as they may still be - // needed by ClearDefaultActionsLocked(). - return expectations_met; -} - -bool Mock::IsNaggy(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kWarn; -} -bool Mock::IsNice(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kAllow; -} -bool Mock::IsStrict(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kFail; -} - -// Registers a mock object and a mock method it owns. -void Mock::Register(const void* mock_obj, - internal::UntypedFunctionMockerBase* mocker) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker); -} - -// Tells Google Mock where in the source code mock_obj is used in an -// ON_CALL or EXPECT_CALL. In case mock_obj is leaked, this -// information helps the user identify which object it is. -void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj, - const char* file, int line) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - MockObjectState& state = g_mock_object_registry.states()[mock_obj]; - if (state.first_used_file == nullptr) { - state.first_used_file = file; - state.first_used_line = line; - const TestInfo* const test_info = - UnitTest::GetInstance()->current_test_info(); - if (test_info != nullptr) { - state.first_used_test_suite = test_info->test_suite_name(); - state.first_used_test = test_info->name(); - } - } -} - -// Unregisters a mock method; removes the owning mock object from the -// registry when the last mock method associated with it has been -// unregistered. This is called only in the destructor of -// FunctionMockerBase. -void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) { - internal::g_gmock_mutex.AssertHeld(); - for (MockObjectRegistry::StateMap::iterator it = - g_mock_object_registry.states().begin(); - it != g_mock_object_registry.states().end(); ++it) { - FunctionMockers& mockers = it->second.function_mockers; - if (mockers.erase(mocker) > 0) { - // mocker was in mockers and has been just removed. - if (mockers.empty()) { - g_mock_object_registry.states().erase(it); - } - return; - } - } -} - -// Clears all ON_CALL()s set on the given mock object. -void Mock::ClearDefaultActionsLocked(void* mock_obj) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) { - internal::g_gmock_mutex.AssertHeld(); - - if (g_mock_object_registry.states().count(mock_obj) == 0) { - // No ON_CALL() was set on the given mock object. - return; - } - - // Clears the default actions for each mock method in the given mock - // object. - FunctionMockers& mockers = - g_mock_object_registry.states()[mock_obj].function_mockers; - for (FunctionMockers::const_iterator it = mockers.begin(); - it != mockers.end(); ++it) { - (*it)->ClearDefaultActionsLocked(); - } - - // We don't clear the content of mockers, as they may still be - // needed by VerifyAndClearExpectationsLocked(). -} - -Expectation::Expectation() {} - -Expectation::Expectation( - const std::shared_ptr<internal::ExpectationBase>& an_expectation_base) - : expectation_base_(an_expectation_base) {} - -Expectation::~Expectation() {} - -// Adds an expectation to a sequence. -void Sequence::AddExpectation(const Expectation& expectation) const { - if (*last_expectation_ != expectation) { - if (last_expectation_->expectation_base() != nullptr) { - expectation.expectation_base()->immediate_prerequisites_ += - *last_expectation_; - } - *last_expectation_ = expectation; - } -} - -// Creates the implicit sequence if there isn't one. -InSequence::InSequence() { - if (internal::g_gmock_implicit_sequence.get() == nullptr) { - internal::g_gmock_implicit_sequence.set(new Sequence); - sequence_created_ = true; - } else { - sequence_created_ = false; - } -} - -// Deletes the implicit sequence if it was created by the constructor -// of this object. -InSequence::~InSequence() { - if (sequence_created_) { - delete internal::g_gmock_implicit_sequence.get(); - internal::g_gmock_implicit_sequence.set(nullptr); - } -} - -} // namespace testing - -#ifdef _MSC_VER -#if _MSC_VER == 1900 -#pragma warning(pop) -#endif -#endif
diff --git a/third_party/googletest/src/googlemock/src/gmock.cc b/third_party/googletest/src/googlemock/src/gmock.cc deleted file mode 100644 index 5025656..0000000 --- a/third_party/googletest/src/googlemock/src/gmock.cc +++ /dev/null
@@ -1,223 +0,0 @@ -// Copyright 2008, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#include "gmock/gmock.h" - -#include "gmock/internal/gmock-port.h" - -GMOCK_DEFINE_bool_(catch_leaked_mocks, true, - "true if and only if Google Mock should report leaked " - "mock objects as failures."); - -GMOCK_DEFINE_string_(verbose, testing::internal::kWarningVerbosity, - "Controls how verbose Google Mock's output is." - " Valid values:\n" - " info - prints all messages.\n" - " warning - prints warnings and errors.\n" - " error - prints errors only."); - -GMOCK_DEFINE_int32_(default_mock_behavior, 1, - "Controls the default behavior of mocks." - " Valid values:\n" - " 0 - by default, mocks act as NiceMocks.\n" - " 1 - by default, mocks act as NaggyMocks.\n" - " 2 - by default, mocks act as StrictMocks."); - -namespace testing { -namespace internal { - -// Parses a string as a command line flag. The string should have the -// format "--gmock_flag=value". When def_optional is true, the -// "=value" part can be omitted. -// -// Returns the value of the flag, or NULL if the parsing failed. -static const char* ParseGoogleMockFlagValue(const char* str, - const char* flag_name, - bool def_optional) { - // str and flag must not be NULL. - if (str == nullptr || flag_name == nullptr) return nullptr; - - // The flag must start with "--gmock_". - const std::string flag_name_str = std::string("--gmock_") + flag_name; - const size_t flag_name_len = flag_name_str.length(); - if (strncmp(str, flag_name_str.c_str(), flag_name_len) != 0) return nullptr; - - // Skips the flag name. - const char* flag_end = str + flag_name_len; - - // When def_optional is true, it's OK to not have a "=value" part. - if (def_optional && (flag_end[0] == '\0')) { - return flag_end; - } - - // If def_optional is true and there are more characters after the - // flag name, or if def_optional is false, there must be a '=' after - // the flag name. - if (flag_end[0] != '=') return nullptr; - - // Returns the string after "=". - return flag_end + 1; -} - -// Parses a string for a Google Mock bool flag, in the form of -// "--gmock_flag=value". -// -// On success, stores the value of the flag in *value, and returns -// true. On failure, returns false without changing *value. -static bool ParseGoogleMockFlag(const char* str, const char* flag_name, - bool* value) { - // Gets the value of the flag as a string. - const char* const value_str = ParseGoogleMockFlagValue(str, flag_name, true); - - // Aborts if the parsing failed. - if (value_str == nullptr) return false; - - // Converts the string value to a bool. - *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); - return true; -} - -// Parses a string for a Google Mock string flag, in the form of -// "--gmock_flag=value". -// -// On success, stores the value of the flag in *value, and returns -// true. On failure, returns false without changing *value. -template <typename String> -static bool ParseGoogleMockFlag(const char* str, const char* flag_name, - String* value) { - // Gets the value of the flag as a string. - const char* const value_str = ParseGoogleMockFlagValue(str, flag_name, false); - - // Aborts if the parsing failed. - if (value_str == nullptr) return false; - - // Sets *value to the value of the flag. - *value = value_str; - return true; -} - -static bool ParseGoogleMockFlag(const char* str, const char* flag_name, - int32_t* value) { - // Gets the value of the flag as a string. - const char* const value_str = ParseGoogleMockFlagValue(str, flag_name, true); - - // Aborts if the parsing failed. - if (value_str == nullptr) return false; - - // Sets *value to the value of the flag. - return ParseInt32(Message() << "The value of flag --" << flag_name, value_str, - value); -} - -// The internal implementation of InitGoogleMock(). -// -// The type parameter CharType can be instantiated to either char or -// wchar_t. -template <typename CharType> -void InitGoogleMockImpl(int* argc, CharType** argv) { - // Makes sure Google Test is initialized. InitGoogleTest() is - // idempotent, so it's fine if the user has already called it. - InitGoogleTest(argc, argv); - if (*argc <= 0) return; - - for (int i = 1; i != *argc; i++) { - const std::string arg_string = StreamableToString(argv[i]); - const char* const arg = arg_string.c_str(); - - // Do we see a Google Mock flag? - bool found_gmock_flag = false; - -#define GMOCK_INTERNAL_PARSE_FLAG(flag_name) \ - if (!found_gmock_flag) { \ - auto value = GMOCK_FLAG_GET(flag_name); \ - if (ParseGoogleMockFlag(arg, #flag_name, &value)) { \ - GMOCK_FLAG_SET(flag_name, value); \ - found_gmock_flag = true; \ - } \ - } - - GMOCK_INTERNAL_PARSE_FLAG(catch_leaked_mocks) - GMOCK_INTERNAL_PARSE_FLAG(verbose) - GMOCK_INTERNAL_PARSE_FLAG(default_mock_behavior) - - if (found_gmock_flag) { - // Yes. Shift the remainder of the argv list left by one. Note - // that argv has (*argc + 1) elements, the last one always being - // NULL. The following loop moves the trailing NULL element as - // well. - for (int j = i; j != *argc; j++) { - argv[j] = argv[j + 1]; - } - - // Decrements the argument count. - (*argc)--; - - // We also need to decrement the iterator as we just removed - // an element. - i--; - } - } -} - -} // namespace internal - -// Initializes Google Mock. This must be called before running the -// tests. In particular, it parses a command line for the flags that -// Google Mock recognizes. Whenever a Google Mock flag is seen, it is -// removed from argv, and *argc is decremented. -// -// No value is returned. Instead, the Google Mock flag variables are -// updated. -// -// Since Google Test is needed for Google Mock to work, this function -// also initializes Google Test and parses its flags, if that hasn't -// been done. -GTEST_API_ void InitGoogleMock(int* argc, char** argv) { - internal::InitGoogleMockImpl(argc, argv); -} - -// This overloaded version can be used in Windows programs compiled in -// UNICODE mode. -GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) { - internal::InitGoogleMockImpl(argc, argv); -} - -// This overloaded version can be used on Arduino/embedded platforms where -// there is no argc/argv. -GTEST_API_ void InitGoogleMock() { - // Since Arduino doesn't have a command line, fake out the argc/argv arguments - int argc = 1; - const auto arg0 = "dummy"; - char* argv0 = const_cast<char*>(arg0); - char** argv = &argv0; - - internal::InitGoogleMockImpl(&argc, argv); -} - -} // namespace testing
diff --git a/third_party/googletest/src/googlemock/src/gmock_main.cc b/third_party/googletest/src/googlemock/src/gmock_main.cc deleted file mode 100644 index b411c5e..0000000 --- a/third_party/googletest/src/googlemock/src/gmock_main.cc +++ /dev/null
@@ -1,72 +0,0 @@ -// Copyright 2008, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#include <iostream> - -#include "gmock/gmock.h" -#include "gtest/gtest.h" - -#if GTEST_OS_ESP8266 || GTEST_OS_ESP32 -#if GTEST_OS_ESP8266 -extern "C" { -#endif -void setup() { - // Since Google Mock depends on Google Test, InitGoogleMock() is - // also responsible for initializing Google Test. Therefore there's - // no need for calling testing::InitGoogleTest() separately. - testing::InitGoogleMock(); -} -void loop() { RUN_ALL_TESTS(); } -#if GTEST_OS_ESP8266 -} -#endif - -#else - -// MS C++ compiler/linker has a bug on Windows (not on Windows CE), which -// causes a link error when _tmain is defined in a static library and UNICODE -// is enabled. For this reason instead of _tmain, main function is used on -// Windows. See the following link to track the current status of this bug: -// https://web.archive.org/web/20170912203238/connect.microsoft.com/VisualStudio/feedback/details/394464/wmain-link-error-in-the-static-library -// // NOLINT -#if GTEST_OS_WINDOWS_MOBILE -#include <tchar.h> // NOLINT - -GTEST_API_ int _tmain(int argc, TCHAR** argv) { -#else -GTEST_API_ int main(int argc, char** argv) { -#endif // GTEST_OS_WINDOWS_MOBILE - std::cout << "Running main() from gmock_main.cc\n"; - // Since Google Mock depends on Google Test, InitGoogleMock() is - // also responsible for initializing Google Test. Therefore there's - // no need for calling testing::InitGoogleTest() separately. - testing::InitGoogleMock(&argc, argv); - return RUN_ALL_TESTS(); -} -#endif