diff options
Diffstat (limited to 'googletest/include')
| -rw-r--r-- | googletest/include/gtest/gtest-matchers.h | 26 | ||||
| -rw-r--r-- | googletest/include/gtest/gtest-printers.h | 7 | ||||
| -rw-r--r-- | googletest/include/gtest/gtest.h | 32 | ||||
| -rw-r--r-- | googletest/include/gtest/internal/gtest-internal.h | 79 |
4 files changed, 49 insertions, 95 deletions
diff --git a/googletest/include/gtest/gtest-matchers.h b/googletest/include/gtest/gtest-matchers.h index 7bc855b..9a8841b 100644 --- a/googletest/include/gtest/gtest-matchers.h +++ b/googletest/include/gtest/gtest-matchers.h @@ -296,6 +296,11 @@ class MatcherBase { !internal::IsSame<U, const U&>::value>::type* = nullptr) : impl_(new internal::MatcherInterfaceAdapter<U>(impl)) {} + MatcherBase(const MatcherBase&) = default; + MatcherBase& operator=(const MatcherBase&) = default; + MatcherBase(MatcherBase&&) = default; + MatcherBase& operator=(MatcherBase&&) = default; + virtual ~MatcherBase() {} private: @@ -545,22 +550,17 @@ class PolymorphicMatcher { private: const Impl impl_; - - GTEST_DISALLOW_ASSIGN_(MonomorphicImpl); }; Impl impl_; - - GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher); }; -// Creates a matcher from its implementation. This is easier to use -// than the Matcher<T> constructor as it doesn't require you to -// explicitly write the template argument, e.g. +// Creates a matcher from its implementation. +// DEPRECATED: Especially in the generic code, prefer: +// Matcher<T>(new MyMatcherImpl<const T&>(...)); // -// MakeMatcher(foo); -// vs -// Matcher<const string&>(foo); +// MakeMatcher may create a Matcher that accepts its argument by value, which +// leads to unnecessary copies & lack of support for non-copyable types. template <typename T> inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) { return Matcher<T>(impl); @@ -595,7 +595,7 @@ class ComparisonBase { explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {} template <typename Lhs> operator Matcher<Lhs>() const { - return MakeMatcher(new Impl<Lhs>(rhs_)); + return Matcher<Lhs>(new Impl<const Lhs&>(rhs_)); } private: @@ -618,10 +618,8 @@ class ComparisonBase { private: Rhs rhs_; - GTEST_DISALLOW_ASSIGN_(Impl); }; Rhs rhs_; - GTEST_DISALLOW_ASSIGN_(ComparisonBase); }; template <typename Rhs> @@ -724,8 +722,6 @@ class MatchesRegexMatcher { private: const std::shared_ptr<const RE> regex_; const bool full_match_; - - GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher); }; } // namespace internal diff --git a/googletest/include/gtest/gtest-printers.h b/googletest/include/gtest/gtest-printers.h index d6596e4..ef166b0 100644 --- a/googletest/include/gtest/gtest-printers.h +++ b/googletest/include/gtest/gtest-printers.h @@ -232,12 +232,12 @@ template <typename Char, typename CharTraits, typename T> ::std::basic_ostream<Char, CharTraits>& os, const T& x) { TypeWithoutFormatter<T, (internal::IsAProtocolMessage<T>::value ? kProtobuf - : internal::ImplicitlyConvertible< + : std::is_convertible< const T&, internal::BiggestInt>::value ? kConvertibleToInteger : #if GTEST_HAS_ABSL - internal::ImplicitlyConvertible< + std::is_convertible< const T&, absl::string_view>::value ? kConvertibleToStringView : @@ -637,8 +637,7 @@ inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; } template <typename T> void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) { - // Delegate to wrapped value. - PrintTo(ref.get(), os); + UniversalPrinter<T&>::Print(ref.get(), os); } // Helper function for printing a tuple. T must be instantiated with diff --git a/googletest/include/gtest/gtest.h b/googletest/include/gtest/gtest.h index 70c93da..bcea145 100644 --- a/googletest/include/gtest/gtest.h +++ b/googletest/include/gtest/gtest.h @@ -306,7 +306,7 @@ class GTEST_API_ AssertionResult { explicit AssertionResult( const T& success, typename internal::EnableIf< - !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type* + !std::is_convertible<T, AssertionResult>::value>::type* /*enabler*/ = nullptr) : success_(success) {} @@ -1087,11 +1087,11 @@ class TestEventListener { virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0; // Fired before the test suite starts. - virtual void OnTestSuiteStart(const TestSuite& test_suite) {} + virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {} // Legacy API is deprecated but still available #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - virtual void OnTestCaseStart(const TestCase& test_case) {} + virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ // Fired before the test starts. @@ -1106,11 +1106,11 @@ class TestEventListener { virtual void OnTestEnd(const TestInfo& test_info) = 0; // Fired after the test suite ends. - virtual void OnTestSuiteEnd(const TestSuite& test_suite) {} + virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {} // Legacy API is deprecated but still available #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - virtual void OnTestCaseEnd(const TestCase& test_case) {} + virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {} #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ // Fired before environment tear-down for each iteration of tests starts. @@ -1142,7 +1142,7 @@ class EmptyTestEventListener : public TestEventListener { void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {} // Legacy API is deprecated but still available #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseStart(const TestCase& tc /*test_suite*/) override {} + void OnTestCaseStart(const TestCase& /*test_case*/) override {} #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ void OnTestStart(const TestInfo& /*test_info*/) override {} @@ -1150,7 +1150,7 @@ class EmptyTestEventListener : public TestEventListener { void OnTestEnd(const TestInfo& /*test_info*/) override {} void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {} #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseEnd(const TestCase& tc /*test_suite*/) override {} + void OnTestCaseEnd(const TestCase& /*test_case*/) override {} #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {} @@ -1484,6 +1484,10 @@ GTEST_API_ void InitGoogleTest(int* argc, char** argv); // UNICODE mode. GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv); +// This overloaded version can be used on Arduino/embedded platforms where +// there is no argc/argv. +GTEST_API_ void InitGoogleTest(); + namespace internal { // Separate the error generating code from the code path to reduce the stack @@ -2499,20 +2503,6 @@ inline int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->Run(); } -#ifdef ARDUINO -inline void gtest_setup() { - // Since Arduino doesn't have a command line, fake out the argc/argv arguments - int argc = 1; - const auto arg0 = "PlatformIO"; - char* argv0 = const_cast<char*>(arg0); - char** argv = &argv0; - - testing::InitGoogleTest(&argc, argv); -} - -inline void gtest_loop() { RUN_ALL_TESTS(); } -#endif - GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 #endif // GTEST_INCLUDE_GTEST_GTEST_H_ diff --git a/googletest/include/gtest/internal/gtest-internal.h b/googletest/include/gtest/internal/gtest-internal.h index 02ef3b3..94773df 100644 --- a/googletest/include/gtest/internal/gtest-internal.h +++ b/googletest/include/gtest/internal/gtest-internal.h @@ -58,6 +58,7 @@ #include <map> #include <set> #include <string> +#include <type_traits> #include <vector> #include "gtest/gtest-message.h" @@ -108,16 +109,29 @@ GTEST_API_ extern const char kStackTraceMarker[]; // An IgnoredValue object can be implicitly constructed from ANY value. class IgnoredValue { + struct Sink {}; public: // This constructor template allows any value to be implicitly // converted to IgnoredValue. The object has no data member and // doesn't try to remember anything about the argument. We // deliberately omit the 'explicit' keyword in order to allow the // conversion to be implicit. - template <typename T> + // Disable the conversion if T already has a magical conversion operator. + // Otherwise we get ambiguity. + template <typename T, + typename std::enable_if<!std::is_convertible<T, Sink>::value, + int>::type = 0> IgnoredValue(const T& /* ignored */) {} // NOLINT(runtime/explicit) }; +// The only type that should be convertible to Secret* is nullptr. +// The other null pointer constants are not of a type that is convertible to +// Secret*. Only the literal with the right value is. +template <typename T> +using TypeIsValidNullptrConstant = std::integral_constant< + bool, std::is_same<typename std::decay<T>::type, std::nullptr_t>::value || + !std::is_convertible<T, Secret*>::value>; + // Two overloaded helpers for checking at compile time whether an // expression is a null pointer literal (i.e. NULL or any 0-valued // compile-time integral constant). These helpers have no @@ -130,13 +144,16 @@ class IgnoredValue { // a null pointer literal. Therefore, we know that x is a null // pointer literal if and only if the first version is picked by the // compiler. -std::true_type IsNullLiteralHelper(Secret*); -std::false_type IsNullLiteralHelper(IgnoredValue); +std::true_type IsNullLiteralHelper(Secret*, std::true_type); +std::false_type IsNullLiteralHelper(IgnoredValue, std::false_type); +std::false_type IsNullLiteralHelper(IgnoredValue, std::true_type); // A compile-time bool constant that is true if and only if x is a null pointer // literal (i.e. nullptr, NULL or any 0-valued compile-time integral constant). -#define GTEST_IS_NULL_LITERAL_(x) \ - decltype(::testing::internal::IsNullLiteralHelper(x))::value +#define GTEST_IS_NULL_LITERAL_(x) \ + decltype(::testing::internal::IsNullLiteralHelper( \ + x, \ + ::testing::internal::TypeIsValidNullptrConstant<decltype(x)>()))::value // Appends the user-supplied message to the Google-Test-generated message. GTEST_API_ std::string AppendUserMessage( @@ -903,62 +920,14 @@ struct RemoveConst<const T[N]> { #define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \ GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T)) -// ImplicitlyConvertible<From, To>::value is a compile-time bool -// constant that's true iff type From can be implicitly converted to -// type To. -template <typename From, typename To> -class ImplicitlyConvertible { - private: - // We need the following helper functions only for their types. - // They have no implementations. - - // MakeFrom() is an expression whose type is From. We cannot simply - // use From(), as the type From may not have a public default - // constructor. - static typename AddReference<From>::type MakeFrom(); - - // These two functions are overloaded. Given an expression - // Helper(x), the compiler will pick the first version if x can be - // implicitly converted to type To; otherwise it will pick the - // second version. - // - // The first version returns a value of size 1, and the second - // version returns a value of size 2. Therefore, by checking the - // size of Helper(x), which can be done at compile time, we can tell - // which version of Helper() is used, and hence whether x can be - // implicitly converted to type To. - static char Helper(To); - static char (&Helper(...))[2]; // NOLINT - - // We have to put the 'public' section after the 'private' section, - // or MSVC refuses to compile the code. - public: -#if defined(__BORLANDC__) - // C++Builder cannot use member overload resolution during template - // instantiation. The simplest workaround is to use its C++0x type traits - // functions (C++Builder 2009 and above only). - static const bool value = __is_convertible(From, To); -#else - // MSVC warns about implicitly converting from double to int for - // possible loss of data, so we need to temporarily disable the - // warning. - GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244) - static const bool value = - sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; - GTEST_DISABLE_MSC_WARNINGS_POP_() -#endif // __BORLANDC__ -}; -template <typename From, typename To> -const bool ImplicitlyConvertible<From, To>::value; - // IsAProtocolMessage<T>::value is a compile-time bool constant that's // true iff T is type ProtocolMessage, proto2::Message, or a subclass // of those. template <typename T> struct IsAProtocolMessage : public bool_constant< - ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value || - ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> { + std::is_convertible<const T*, const ::ProtocolMessage*>::value || + std::is_convertible<const T*, const ::proto2::Message*>::value> { }; // When the compiler sees expression IsContainerTest<C>(0), if C is an |