5676 lines · c
1// Copyright 2007, Google Inc.2// All rights reserved.3//4// Redistribution and use in source and binary forms, with or without5// modification, are permitted provided that the following conditions are6// met:7//8// * Redistributions of source code must retain the above copyright9// notice, this list of conditions and the following disclaimer.10// * Redistributions in binary form must reproduce the above11// copyright notice, this list of conditions and the following disclaimer12// in the documentation and/or other materials provided with the13// distribution.14// * Neither the name of Google Inc. nor the names of its15// contributors may be used to endorse or promote products derived from16// this software without specific prior written permission.17//18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.29 30// Google Mock - a framework for writing C++ mock classes.31//32// The MATCHER* family of macros can be used in a namespace scope to33// define custom matchers easily.34//35// Basic Usage36// ===========37//38// The syntax39//40// MATCHER(name, description_string) { statements; }41//42// defines a matcher with the given name that executes the statements,43// which must return a bool to indicate if the match succeeds. Inside44// the statements, you can refer to the value being matched by 'arg',45// and refer to its type by 'arg_type'.46//47// The description string documents what the matcher does, and is used48// to generate the failure message when the match fails. Since a49// MATCHER() is usually defined in a header file shared by multiple50// C++ source files, we require the description to be a C-string51// literal to avoid possible side effects. It can be empty, in which52// case we'll use the sequence of words in the matcher name as the53// description.54//55// For example:56//57// MATCHER(IsEven, "") { return (arg % 2) == 0; }58//59// allows you to write60//61// // Expects mock_foo.Bar(n) to be called where n is even.62// EXPECT_CALL(mock_foo, Bar(IsEven()));63//64// or,65//66// // Verifies that the value of some_expression is even.67// EXPECT_THAT(some_expression, IsEven());68//69// If the above assertion fails, it will print something like:70//71// Value of: some_expression72// Expected: is even73// Actual: 774//75// where the description "is even" is automatically calculated from the76// matcher name IsEven.77//78// Argument Type79// =============80//81// Note that the type of the value being matched (arg_type) is82// determined by the context in which you use the matcher and is83// supplied to you by the compiler, so you don't need to worry about84// declaring it (nor can you). This allows the matcher to be85// polymorphic. For example, IsEven() can be used to match any type86// where the value of "(arg % 2) == 0" can be implicitly converted to87// a bool. In the "Bar(IsEven())" example above, if method Bar()88// takes an int, 'arg_type' will be int; if it takes an unsigned long,89// 'arg_type' will be unsigned long; and so on.90//91// Parameterizing Matchers92// =======================93//94// Sometimes you'll want to parameterize the matcher. For that you95// can use another macro:96//97// MATCHER_P(name, param_name, description_string) { statements; }98//99// For example:100//101// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }102//103// will allow you to write:104//105// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));106//107// which may lead to this message (assuming n is 10):108//109// Value of: Blah("a")110// Expected: has absolute value 10111// Actual: -9112//113// Note that both the matcher description and its parameter are114// printed, making the message human-friendly.115//116// In the matcher definition body, you can write 'foo_type' to117// reference the type of a parameter named 'foo'. For example, in the118// body of MATCHER_P(HasAbsoluteValue, value) above, you can write119// 'value_type' to refer to the type of 'value'.120//121// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to122// support multi-parameter matchers.123//124// Describing Parameterized Matchers125// =================================126//127// The last argument to MATCHER*() is a string-typed expression. The128// expression can reference all of the matcher's parameters and a129// special bool-typed variable named 'negation'. When 'negation' is130// false, the expression should evaluate to the matcher's description;131// otherwise it should evaluate to the description of the negation of132// the matcher. For example,133//134// using testing::PrintToString;135//136// MATCHER_P2(InClosedRange, low, hi,137// std::string(negation ? "is not" : "is") + " in range [" +138// PrintToString(low) + ", " + PrintToString(hi) + "]") {139// return low <= arg && arg <= hi;140// }141// ...142// EXPECT_THAT(3, InClosedRange(4, 6));143// EXPECT_THAT(3, Not(InClosedRange(2, 4)));144//145// would generate two failures that contain the text:146//147// Expected: is in range [4, 6]148// ...149// Expected: is not in range [2, 4]150//151// If you specify "" as the description, the failure message will152// contain the sequence of words in the matcher name followed by the153// parameter values printed as a tuple. For example,154//155// MATCHER_P2(InClosedRange, low, hi, "") { ... }156// ...157// EXPECT_THAT(3, InClosedRange(4, 6));158// EXPECT_THAT(3, Not(InClosedRange(2, 4)));159//160// would generate two failures that contain the text:161//162// Expected: in closed range (4, 6)163// ...164// Expected: not (in closed range (2, 4))165//166// Types of Matcher Parameters167// ===========================168//169// For the purpose of typing, you can view170//171// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }172//173// as shorthand for174//175// template <typename p1_type, ..., typename pk_type>176// FooMatcherPk<p1_type, ..., pk_type>177// Foo(p1_type p1, ..., pk_type pk) { ... }178//179// When you write Foo(v1, ..., vk), the compiler infers the types of180// the parameters v1, ..., and vk for you. If you are not happy with181// the result of the type inference, you can specify the types by182// explicitly instantiating the template, as in Foo<long, bool>(5,183// false). As said earlier, you don't get to (or need to) specify184// 'arg_type' as that's determined by the context in which the matcher185// is used. You can assign the result of expression Foo(p1, ..., pk)186// to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This187// can be useful when composing matchers.188//189// While you can instantiate a matcher template with reference types,190// passing the parameters by pointer usually makes your code more191// readable. If, however, you still want to pass a parameter by192// reference, be aware that in the failure message generated by the193// matcher you will see the value of the referenced object but not its194// address.195//196// Explaining Match Results197// ========================198//199// Sometimes the matcher description alone isn't enough to explain why200// the match has failed or succeeded. For example, when expecting a201// long string, it can be very helpful to also print the diff between202// the expected string and the actual one. To achieve that, you can203// optionally stream additional information to a special variable204// named result_listener, whose type is a pointer to class205// MatchResultListener:206//207// MATCHER_P(EqualsLongString, str, "") {208// if (arg == str) return true;209//210// *result_listener << "the difference: "211/// << DiffStrings(str, arg);212// return false;213// }214//215// Overloading Matchers216// ====================217//218// You can overload matchers with different numbers of parameters:219//220// MATCHER_P(Blah, a, description_string1) { ... }221// MATCHER_P2(Blah, a, b, description_string2) { ... }222//223// Caveats224// =======225//226// When defining a new matcher, you should also consider implementing227// MatcherInterface or using MakePolymorphicMatcher(). These228// approaches require more work than the MATCHER* macros, but also229// give you more control on the types of the value being matched and230// the matcher parameters, which may leads to better compiler error231// messages when the matcher is used wrong. They also allow232// overloading matchers based on parameter types (as opposed to just233// based on the number of parameters).234//235// MATCHER*() can only be used in a namespace scope as templates cannot be236// declared inside of a local class.237//238// More Information239// ================240//241// To learn more about using these macros, please search for 'MATCHER'242// on243// https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md244//245// This file also implements some commonly used argument matchers. More246// matchers can be defined by the user implementing the247// MatcherInterface<T> interface if necessary.248//249// See googletest/include/gtest/gtest-matchers.h for the definition of class250// Matcher, class MatcherInterface, and others.251 252// IWYU pragma: private, include "gmock/gmock.h"253// IWYU pragma: friend gmock/.*254 255#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_256#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_257 258#include <algorithm>259#include <cmath>260#include <exception>261#include <functional>262#include <initializer_list>263#include <ios>264#include <iterator>265#include <limits>266#include <memory>267#include <ostream> // NOLINT268#include <sstream>269#include <string>270#include <type_traits>271#include <utility>272#include <vector>273 274#include "gmock/internal/gmock-internal-utils.h"275#include "gmock/internal/gmock-port.h"276#include "gmock/internal/gmock-pp.h"277#include "gtest/gtest.h"278 279// MSVC warning C5046 is new as of VS2017 version 15.8.280#if defined(_MSC_VER) && _MSC_VER >= 1915281#define GMOCK_MAYBE_5046_ 5046282#else283#define GMOCK_MAYBE_5046_284#endif285 286GTEST_DISABLE_MSC_WARNINGS_PUSH_(287 4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by288 clients of class B */289 /* Symbol involving type with internal linkage not defined */)290 291namespace testing {292 293// To implement a matcher Foo for type T, define:294// 1. a class FooMatcherImpl that implements the295// MatcherInterface<T> interface, and296// 2. a factory function that creates a Matcher<T> object from a297// FooMatcherImpl*.298//299// The two-level delegation design makes it possible to allow a user300// to write "v" instead of "Eq(v)" where a Matcher is expected, which301// is impossible if we pass matchers by pointers. It also eases302// ownership management as Matcher objects can now be copied like303// plain values.304 305// A match result listener that stores the explanation in a string.306class StringMatchResultListener : public MatchResultListener {307 public:308 StringMatchResultListener() : MatchResultListener(&ss_) {}309 310 // Returns the explanation accumulated so far.311 std::string str() const { return ss_.str(); }312 313 // Clears the explanation accumulated so far.314 void Clear() { ss_.str(""); }315 316 private:317 ::std::stringstream ss_;318 319 StringMatchResultListener(const StringMatchResultListener&) = delete;320 StringMatchResultListener& operator=(const StringMatchResultListener&) =321 delete;322};323 324// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION325// and MUST NOT BE USED IN USER CODE!!!326namespace internal {327 328// The MatcherCastImpl class template is a helper for implementing329// MatcherCast(). We need this helper in order to partially330// specialize the implementation of MatcherCast() (C++ allows331// class/struct templates to be partially specialized, but not332// function templates.).333 334// This general version is used when MatcherCast()'s argument is a335// polymorphic matcher (i.e. something that can be converted to a336// Matcher but is not one yet; for example, Eq(value)) or a value (for337// example, "hello").338template <typename T, typename M>339class MatcherCastImpl {340 public:341 static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {342 // M can be a polymorphic matcher, in which case we want to use343 // its conversion operator to create Matcher<T>. Or it can be a value344 // that should be passed to the Matcher<T>'s constructor.345 //346 // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a347 // polymorphic matcher because it'll be ambiguous if T has an implicit348 // constructor from M (this usually happens when T has an implicit349 // constructor from any type).350 //351 // It won't work to unconditionally implicit_cast352 // polymorphic_matcher_or_value to Matcher<T> because it won't trigger353 // a user-defined conversion from M to T if one exists (assuming M is354 // a value).355 return CastImpl(polymorphic_matcher_or_value,356 std::is_convertible<M, Matcher<T>>{},357 std::is_convertible<M, T>{});358 }359 360 private:361 template <bool Ignore>362 static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,363 std::true_type /* convertible_to_matcher */,364 std::integral_constant<bool, Ignore>) {365 // M is implicitly convertible to Matcher<T>, which means that either366 // M is a polymorphic matcher or Matcher<T> has an implicit constructor367 // from M. In both cases using the implicit conversion will produce a368 // matcher.369 //370 // Even if T has an implicit constructor from M, it won't be called because371 // creating Matcher<T> would require a chain of two user-defined conversions372 // (first to create T from M and then to create Matcher<T> from T).373 return polymorphic_matcher_or_value;374 }375 376 // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic377 // matcher. It's a value of a type implicitly convertible to T. Use direct378 // initialization to create a matcher.379 static Matcher<T> CastImpl(const M& value,380 std::false_type /* convertible_to_matcher */,381 std::true_type /* convertible_to_T */) {382 return Matcher<T>(ImplicitCast_<T>(value));383 }384 385 // M can't be implicitly converted to either Matcher<T> or T. Attempt to use386 // polymorphic matcher Eq(value) in this case.387 //388 // Note that we first attempt to perform an implicit cast on the value and389 // only fall back to the polymorphic Eq() matcher afterwards because the390 // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end391 // which might be undefined even when Rhs is implicitly convertible to Lhs392 // (e.g. std::pair<const int, int> vs. std::pair<int, int>).393 //394 // We don't define this method inline as we need the declaration of Eq().395 static Matcher<T> CastImpl(const M& value,396 std::false_type /* convertible_to_matcher */,397 std::false_type /* convertible_to_T */);398};399 400// This more specialized version is used when MatcherCast()'s argument401// is already a Matcher. This only compiles when type T can be402// statically converted to type U.403template <typename T, typename U>404class MatcherCastImpl<T, Matcher<U>> {405 public:406 static Matcher<T> Cast(const Matcher<U>& source_matcher) {407 return Matcher<T>(new Impl(source_matcher));408 }409 410 private:411 class Impl : public MatcherInterface<T> {412 public:413 explicit Impl(const Matcher<U>& source_matcher)414 : source_matcher_(source_matcher) {}415 416 // We delegate the matching logic to the source matcher.417 bool MatchAndExplain(T x, MatchResultListener* listener) const override {418 using FromType = typename std::remove_cv<typename std::remove_pointer<419 typename std::remove_reference<T>::type>::type>::type;420 using ToType = typename std::remove_cv<typename std::remove_pointer<421 typename std::remove_reference<U>::type>::type>::type;422 // Do not allow implicitly converting base*/& to derived*/&.423 static_assert(424 // Do not trigger if only one of them is a pointer. That implies a425 // regular conversion and not a down_cast.426 (std::is_pointer<typename std::remove_reference<T>::type>::value !=427 std::is_pointer<typename std::remove_reference<U>::type>::value) ||428 std::is_same<FromType, ToType>::value ||429 !std::is_base_of<FromType, ToType>::value,430 "Can't implicitly convert from <base> to <derived>");431 432 // Do the cast to `U` explicitly if necessary.433 // Otherwise, let implicit conversions do the trick.434 using CastType =435 typename std::conditional<std::is_convertible<T&, const U&>::value,436 T&, U>::type;437 438 return source_matcher_.MatchAndExplain(static_cast<CastType>(x),439 listener);440 }441 442 void DescribeTo(::std::ostream* os) const override {443 source_matcher_.DescribeTo(os);444 }445 446 void DescribeNegationTo(::std::ostream* os) const override {447 source_matcher_.DescribeNegationTo(os);448 }449 450 private:451 const Matcher<U> source_matcher_;452 };453};454 455// This even more specialized version is used for efficiently casting456// a matcher to its own type.457template <typename T>458class MatcherCastImpl<T, Matcher<T>> {459 public:460 static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }461};462 463// Template specialization for parameterless Matcher.464template <typename Derived>465class MatcherBaseImpl {466 public:467 MatcherBaseImpl() = default;468 469 template <typename T>470 operator ::testing::Matcher<T>() const { // NOLINT(runtime/explicit)471 return ::testing::Matcher<T>(new472 typename Derived::template gmock_Impl<T>());473 }474};475 476// Template specialization for Matcher with parameters.477template <template <typename...> class Derived, typename... Ts>478class MatcherBaseImpl<Derived<Ts...>> {479 public:480 // Mark the constructor explicit for single argument T to avoid implicit481 // conversions.482 template <typename E = std::enable_if<sizeof...(Ts) == 1>,483 typename E::type* = nullptr>484 explicit MatcherBaseImpl(Ts... params)485 : params_(std::forward<Ts>(params)...) {}486 template <typename E = std::enable_if<sizeof...(Ts) != 1>,487 typename = typename E::type>488 MatcherBaseImpl(Ts... params) // NOLINT489 : params_(std::forward<Ts>(params)...) {}490 491 template <typename F>492 operator ::testing::Matcher<F>() const { // NOLINT(runtime/explicit)493 return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{});494 }495 496 private:497 template <typename F, std::size_t... tuple_ids>498 ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const {499 return ::testing::Matcher<F>(500 new typename Derived<Ts...>::template gmock_Impl<F>(501 std::get<tuple_ids>(params_)...));502 }503 504 const std::tuple<Ts...> params_;505};506 507} // namespace internal508 509// In order to be safe and clear, casting between different matcher510// types is done explicitly via MatcherCast<T>(m), which takes a511// matcher m and returns a Matcher<T>. It compiles only when T can be512// statically converted to the argument type of m.513template <typename T, typename M>514inline Matcher<T> MatcherCast(const M& matcher) {515 return internal::MatcherCastImpl<T, M>::Cast(matcher);516}517 518// This overload handles polymorphic matchers and values only since519// monomorphic matchers are handled by the next one.520template <typename T, typename M>521inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) {522 return MatcherCast<T>(polymorphic_matcher_or_value);523}524 525// This overload handles monomorphic matchers.526//527// In general, if type T can be implicitly converted to type U, we can528// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is529// contravariant): just keep a copy of the original Matcher<U>, convert the530// argument from type T to U, and then pass it to the underlying Matcher<U>.531// The only exception is when U is a reference and T is not, as the532// underlying Matcher<U> may be interested in the argument's address, which533// is not preserved in the conversion from T to U.534template <typename T, typename U>535inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {536 // Enforce that T can be implicitly converted to U.537 static_assert(std::is_convertible<const T&, const U&>::value,538 "T must be implicitly convertible to U");539 // Enforce that we are not converting a non-reference type T to a reference540 // type U.541 static_assert(std::is_reference<T>::value || !std::is_reference<U>::value,542 "cannot convert non reference arg to reference");543 // In case both T and U are arithmetic types, enforce that the544 // conversion is not lossy.545 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;546 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;547 constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;548 constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;549 static_assert(550 kTIsOther || kUIsOther ||551 (internal::LosslessArithmeticConvertible<RawT, RawU>::value),552 "conversion of arithmetic types must be lossless");553 return MatcherCast<T>(matcher);554}555 556// A<T>() returns a matcher that matches any value of type T.557template <typename T>558Matcher<T> A();559 560// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION561// and MUST NOT BE USED IN USER CODE!!!562namespace internal {563 564// If the explanation is not empty, prints it to the ostream.565inline void PrintIfNotEmpty(const std::string& explanation,566 ::std::ostream* os) {567 if (!explanation.empty() && os != nullptr) {568 *os << ", " << explanation;569 }570}571 572// Returns true if the given type name is easy to read by a human.573// This is used to decide whether printing the type of a value might574// be helpful.575inline bool IsReadableTypeName(const std::string& type_name) {576 // We consider a type name readable if it's short or doesn't contain577 // a template or function type.578 return (type_name.length() <= 20 ||579 type_name.find_first_of("<(") == std::string::npos);580}581 582// Matches the value against the given matcher, prints the value and explains583// the match result to the listener. Returns the match result.584// 'listener' must not be NULL.585// Value cannot be passed by const reference, because some matchers take a586// non-const argument.587template <typename Value, typename T>588bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,589 MatchResultListener* listener) {590 if (!listener->IsInterested()) {591 // If the listener is not interested, we do not need to construct the592 // inner explanation.593 return matcher.Matches(value);594 }595 596 StringMatchResultListener inner_listener;597 const bool match = matcher.MatchAndExplain(value, &inner_listener);598 599 UniversalPrint(value, listener->stream());600#if GTEST_HAS_RTTI601 const std::string& type_name = GetTypeName<Value>();602 if (IsReadableTypeName(type_name))603 *listener->stream() << " (of type " << type_name << ")";604#endif605 PrintIfNotEmpty(inner_listener.str(), listener->stream());606 607 return match;608}609 610// An internal helper class for doing compile-time loop on a tuple's611// fields.612template <size_t N>613class TuplePrefix {614 public:615 // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true616 // if and only if the first N fields of matcher_tuple matches617 // the first N fields of value_tuple, respectively.618 template <typename MatcherTuple, typename ValueTuple>619 static bool Matches(const MatcherTuple& matcher_tuple,620 const ValueTuple& value_tuple) {621 return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) &&622 std::get<N - 1>(matcher_tuple).Matches(std::get<N - 1>(value_tuple));623 }624 625 // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)626 // describes failures in matching the first N fields of matchers627 // against the first N fields of values. If there is no failure,628 // nothing will be streamed to os.629 template <typename MatcherTuple, typename ValueTuple>630 static void ExplainMatchFailuresTo(const MatcherTuple& matchers,631 const ValueTuple& values,632 ::std::ostream* os) {633 // First, describes failures in the first N - 1 fields.634 TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);635 636 // Then describes the failure (if any) in the (N - 1)-th (0-based)637 // field.638 typename std::tuple_element<N - 1, MatcherTuple>::type matcher =639 std::get<N - 1>(matchers);640 typedef typename std::tuple_element<N - 1, ValueTuple>::type Value;641 const Value& value = std::get<N - 1>(values);642 StringMatchResultListener listener;643 if (!matcher.MatchAndExplain(value, &listener)) {644 *os << " Expected arg #" << N - 1 << ": ";645 std::get<N - 1>(matchers).DescribeTo(os);646 *os << "\n Actual: ";647 // We remove the reference in type Value to prevent the648 // universal printer from printing the address of value, which649 // isn't interesting to the user most of the time. The650 // matcher's MatchAndExplain() method handles the case when651 // the address is interesting.652 internal::UniversalPrint(value, os);653 PrintIfNotEmpty(listener.str(), os);654 *os << "\n";655 }656 }657};658 659// The base case.660template <>661class TuplePrefix<0> {662 public:663 template <typename MatcherTuple, typename ValueTuple>664 static bool Matches(const MatcherTuple& /* matcher_tuple */,665 const ValueTuple& /* value_tuple */) {666 return true;667 }668 669 template <typename MatcherTuple, typename ValueTuple>670 static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,671 const ValueTuple& /* values */,672 ::std::ostream* /* os */) {}673};674 675// TupleMatches(matcher_tuple, value_tuple) returns true if and only if676// all matchers in matcher_tuple match the corresponding fields in677// value_tuple. It is a compiler error if matcher_tuple and678// value_tuple have different number of fields or incompatible field679// types.680template <typename MatcherTuple, typename ValueTuple>681bool TupleMatches(const MatcherTuple& matcher_tuple,682 const ValueTuple& value_tuple) {683 // Makes sure that matcher_tuple and value_tuple have the same684 // number of fields.685 static_assert(std::tuple_size<MatcherTuple>::value ==686 std::tuple_size<ValueTuple>::value,687 "matcher and value have different numbers of fields");688 return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple,689 value_tuple);690}691 692// Describes failures in matching matchers against values. If there693// is no failure, nothing will be streamed to os.694template <typename MatcherTuple, typename ValueTuple>695void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,696 const ValueTuple& values, ::std::ostream* os) {697 TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(698 matchers, values, os);699}700 701// TransformTupleValues and its helper.702//703// TransformTupleValuesHelper hides the internal machinery that704// TransformTupleValues uses to implement a tuple traversal.705template <typename Tuple, typename Func, typename OutIter>706class TransformTupleValuesHelper {707 private:708 typedef ::std::tuple_size<Tuple> TupleSize;709 710 public:711 // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.712 // Returns the final value of 'out' in case the caller needs it.713 static OutIter Run(Func f, const Tuple& t, OutIter out) {714 return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);715 }716 717 private:718 template <typename Tup, size_t kRemainingSize>719 struct IterateOverTuple {720 OutIter operator()(Func f, const Tup& t, OutIter out) const {721 *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t));722 return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);723 }724 };725 template <typename Tup>726 struct IterateOverTuple<Tup, 0> {727 OutIter operator()(Func /* f */, const Tup& /* t */, OutIter out) const {728 return out;729 }730 };731};732 733// Successively invokes 'f(element)' on each element of the tuple 't',734// appending each result to the 'out' iterator. Returns the final value735// of 'out'.736template <typename Tuple, typename Func, typename OutIter>737OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {738 return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);739}740 741// Implements _, a matcher that matches any value of any742// type. This is a polymorphic matcher, so we need a template type743// conversion operator to make it appearing as a Matcher<T> for any744// type T.745class AnythingMatcher {746 public:747 using is_gtest_matcher = void;748 749 template <typename T>750 bool MatchAndExplain(const T& /* x */, std::ostream* /* listener */) const {751 return true;752 }753 void DescribeTo(std::ostream* os) const { *os << "is anything"; }754 void DescribeNegationTo(::std::ostream* os) const {755 // This is mostly for completeness' sake, as it's not very useful756 // to write Not(A<bool>()). However we cannot completely rule out757 // such a possibility, and it doesn't hurt to be prepared.758 *os << "never matches";759 }760};761 762// Implements the polymorphic IsNull() matcher, which matches any raw or smart763// pointer that is NULL.764class IsNullMatcher {765 public:766 template <typename Pointer>767 bool MatchAndExplain(const Pointer& p,768 MatchResultListener* /* listener */) const {769 return p == nullptr;770 }771 772 void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }773 void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NULL"; }774};775 776// Implements the polymorphic NotNull() matcher, which matches any raw or smart777// pointer that is not NULL.778class NotNullMatcher {779 public:780 template <typename Pointer>781 bool MatchAndExplain(const Pointer& p,782 MatchResultListener* /* listener */) const {783 return p != nullptr;784 }785 786 void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }787 void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }788};789 790// Ref(variable) matches any argument that is a reference to791// 'variable'. This matcher is polymorphic as it can match any792// super type of the type of 'variable'.793//794// The RefMatcher template class implements Ref(variable). It can795// only be instantiated with a reference type. This prevents a user796// from mistakenly using Ref(x) to match a non-reference function797// argument. For example, the following will righteously cause a798// compiler error:799//800// int n;801// Matcher<int> m1 = Ref(n); // This won't compile.802// Matcher<int&> m2 = Ref(n); // This will compile.803template <typename T>804class RefMatcher;805 806template <typename T>807class RefMatcher<T&> {808 // Google Mock is a generic framework and thus needs to support809 // mocking any function types, including those that take non-const810 // reference arguments. Therefore the template parameter T (and811 // Super below) can be instantiated to either a const type or a812 // non-const type.813 public:814 // RefMatcher() takes a T& instead of const T&, as we want the815 // compiler to catch using Ref(const_value) as a matcher for a816 // non-const reference.817 explicit RefMatcher(T& x) : object_(x) {} // NOLINT818 819 template <typename Super>820 operator Matcher<Super&>() const {821 // By passing object_ (type T&) to Impl(), which expects a Super&,822 // we make sure that Super is a super type of T. In particular,823 // this catches using Ref(const_value) as a matcher for a824 // non-const reference, as you cannot implicitly convert a const825 // reference to a non-const reference.826 return MakeMatcher(new Impl<Super>(object_));827 }828 829 private:830 template <typename Super>831 class Impl : public MatcherInterface<Super&> {832 public:833 explicit Impl(Super& x) : object_(x) {} // NOLINT834 835 // MatchAndExplain() takes a Super& (as opposed to const Super&)836 // in order to match the interface MatcherInterface<Super&>.837 bool MatchAndExplain(Super& x,838 MatchResultListener* listener) const override {839 *listener << "which is located @" << static_cast<const void*>(&x);840 return &x == &object_;841 }842 843 void DescribeTo(::std::ostream* os) const override {844 *os << "references the variable ";845 UniversalPrinter<Super&>::Print(object_, os);846 }847 848 void DescribeNegationTo(::std::ostream* os) const override {849 *os << "does not reference the variable ";850 UniversalPrinter<Super&>::Print(object_, os);851 }852 853 private:854 const Super& object_;855 };856 857 T& object_;858};859 860// Polymorphic helper functions for narrow and wide string matchers.861inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {862 return String::CaseInsensitiveCStringEquals(lhs, rhs);863}864 865inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,866 const wchar_t* rhs) {867 return String::CaseInsensitiveWideCStringEquals(lhs, rhs);868}869 870// String comparison for narrow or wide strings that can have embedded NUL871// characters.872template <typename StringType>873bool CaseInsensitiveStringEquals(const StringType& s1, const StringType& s2) {874 // Are the heads equal?875 if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {876 return false;877 }878 879 // Skip the equal heads.880 const typename StringType::value_type nul = 0;881 const size_t i1 = s1.find(nul), i2 = s2.find(nul);882 883 // Are we at the end of either s1 or s2?884 if (i1 == StringType::npos || i2 == StringType::npos) {885 return i1 == i2;886 }887 888 // Are the tails equal?889 return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));890}891 892// String matchers.893 894// Implements equality-based string matchers like StrEq, StrCaseNe, and etc.895template <typename StringType>896class StrEqualityMatcher {897 public:898 StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive)899 : string_(std::move(str)),900 expect_eq_(expect_eq),901 case_sensitive_(case_sensitive) {}902 903#if GTEST_INTERNAL_HAS_STRING_VIEW904 bool MatchAndExplain(const internal::StringView& s,905 MatchResultListener* listener) const {906 // This should fail to compile if StringView is used with wide907 // strings.908 const StringType& str = std::string(s);909 return MatchAndExplain(str, listener);910 }911#endif // GTEST_INTERNAL_HAS_STRING_VIEW912 913 // Accepts pointer types, particularly:914 // const char*915 // char*916 // const wchar_t*917 // wchar_t*918 template <typename CharType>919 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {920 if (s == nullptr) {921 return !expect_eq_;922 }923 return MatchAndExplain(StringType(s), listener);924 }925 926 // Matches anything that can convert to StringType.927 //928 // This is a template, not just a plain function with const StringType&,929 // because StringView has some interfering non-explicit constructors.930 template <typename MatcheeStringType>931 bool MatchAndExplain(const MatcheeStringType& s,932 MatchResultListener* /* listener */) const {933 const StringType s2(s);934 const bool eq = case_sensitive_ ? s2 == string_935 : CaseInsensitiveStringEquals(s2, string_);936 return expect_eq_ == eq;937 }938 939 void DescribeTo(::std::ostream* os) const {940 DescribeToHelper(expect_eq_, os);941 }942 943 void DescribeNegationTo(::std::ostream* os) const {944 DescribeToHelper(!expect_eq_, os);945 }946 947 private:948 void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {949 *os << (expect_eq ? "is " : "isn't ");950 *os << "equal to ";951 if (!case_sensitive_) {952 *os << "(ignoring case) ";953 }954 UniversalPrint(string_, os);955 }956 957 const StringType string_;958 const bool expect_eq_;959 const bool case_sensitive_;960};961 962// Implements the polymorphic HasSubstr(substring) matcher, which963// can be used as a Matcher<T> as long as T can be converted to a964// string.965template <typename StringType>966class HasSubstrMatcher {967 public:968 explicit HasSubstrMatcher(const StringType& substring)969 : substring_(substring) {}970 971#if GTEST_INTERNAL_HAS_STRING_VIEW972 bool MatchAndExplain(const internal::StringView& s,973 MatchResultListener* listener) const {974 // This should fail to compile if StringView is used with wide975 // strings.976 const StringType& str = std::string(s);977 return MatchAndExplain(str, listener);978 }979#endif // GTEST_INTERNAL_HAS_STRING_VIEW980 981 // Accepts pointer types, particularly:982 // const char*983 // char*984 // const wchar_t*985 // wchar_t*986 template <typename CharType>987 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {988 return s != nullptr && MatchAndExplain(StringType(s), listener);989 }990 991 // Matches anything that can convert to StringType.992 //993 // This is a template, not just a plain function with const StringType&,994 // because StringView has some interfering non-explicit constructors.995 template <typename MatcheeStringType>996 bool MatchAndExplain(const MatcheeStringType& s,997 MatchResultListener* /* listener */) const {998 return StringType(s).find(substring_) != StringType::npos;999 }1000 1001 // Describes what this matcher matches.1002 void DescribeTo(::std::ostream* os) const {1003 *os << "has substring ";1004 UniversalPrint(substring_, os);1005 }1006 1007 void DescribeNegationTo(::std::ostream* os) const {1008 *os << "has no substring ";1009 UniversalPrint(substring_, os);1010 }1011 1012 private:1013 const StringType substring_;1014};1015 1016// Implements the polymorphic StartsWith(substring) matcher, which1017// can be used as a Matcher<T> as long as T can be converted to a1018// string.1019template <typename StringType>1020class StartsWithMatcher {1021 public:1022 explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {}1023 1024#if GTEST_INTERNAL_HAS_STRING_VIEW1025 bool MatchAndExplain(const internal::StringView& s,1026 MatchResultListener* listener) const {1027 // This should fail to compile if StringView is used with wide1028 // strings.1029 const StringType& str = std::string(s);1030 return MatchAndExplain(str, listener);1031 }1032#endif // GTEST_INTERNAL_HAS_STRING_VIEW1033 1034 // Accepts pointer types, particularly:1035 // const char*1036 // char*1037 // const wchar_t*1038 // wchar_t*1039 template <typename CharType>1040 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {1041 return s != nullptr && MatchAndExplain(StringType(s), listener);1042 }1043 1044 // Matches anything that can convert to StringType.1045 //1046 // This is a template, not just a plain function with const StringType&,1047 // because StringView has some interfering non-explicit constructors.1048 template <typename MatcheeStringType>1049 bool MatchAndExplain(const MatcheeStringType& s,1050 MatchResultListener* /* listener */) const {1051 const StringType& s2(s);1052 return s2.length() >= prefix_.length() &&1053 s2.substr(0, prefix_.length()) == prefix_;1054 }1055 1056 void DescribeTo(::std::ostream* os) const {1057 *os << "starts with ";1058 UniversalPrint(prefix_, os);1059 }1060 1061 void DescribeNegationTo(::std::ostream* os) const {1062 *os << "doesn't start with ";1063 UniversalPrint(prefix_, os);1064 }1065 1066 private:1067 const StringType prefix_;1068};1069 1070// Implements the polymorphic EndsWith(substring) matcher, which1071// can be used as a Matcher<T> as long as T can be converted to a1072// string.1073template <typename StringType>1074class EndsWithMatcher {1075 public:1076 explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}1077 1078#if GTEST_INTERNAL_HAS_STRING_VIEW1079 bool MatchAndExplain(const internal::StringView& s,1080 MatchResultListener* listener) const {1081 // This should fail to compile if StringView is used with wide1082 // strings.1083 const StringType& str = std::string(s);1084 return MatchAndExplain(str, listener);1085 }1086#endif // GTEST_INTERNAL_HAS_STRING_VIEW1087 1088 // Accepts pointer types, particularly:1089 // const char*1090 // char*1091 // const wchar_t*1092 // wchar_t*1093 template <typename CharType>1094 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {1095 return s != nullptr && MatchAndExplain(StringType(s), listener);1096 }1097 1098 // Matches anything that can convert to StringType.1099 //1100 // This is a template, not just a plain function with const StringType&,1101 // because StringView has some interfering non-explicit constructors.1102 template <typename MatcheeStringType>1103 bool MatchAndExplain(const MatcheeStringType& s,1104 MatchResultListener* /* listener */) const {1105 const StringType& s2(s);1106 return s2.length() >= suffix_.length() &&1107 s2.substr(s2.length() - suffix_.length()) == suffix_;1108 }1109 1110 void DescribeTo(::std::ostream* os) const {1111 *os << "ends with ";1112 UniversalPrint(suffix_, os);1113 }1114 1115 void DescribeNegationTo(::std::ostream* os) const {1116 *os << "doesn't end with ";1117 UniversalPrint(suffix_, os);1118 }1119 1120 private:1121 const StringType suffix_;1122};1123 1124// Implements the polymorphic WhenBase64Unescaped(matcher) matcher, which can be1125// used as a Matcher<T> as long as T can be converted to a string.1126class WhenBase64UnescapedMatcher {1127 public:1128 using is_gtest_matcher = void;1129 1130 explicit WhenBase64UnescapedMatcher(1131 const Matcher<const std::string&>& internal_matcher)1132 : internal_matcher_(internal_matcher) {}1133 1134 // Matches anything that can convert to std::string.1135 template <typename MatcheeStringType>1136 bool MatchAndExplain(const MatcheeStringType& s,1137 MatchResultListener* listener) const {1138 const std::string s2(s); // NOLINT (needed for working with string_view).1139 std::string unescaped;1140 if (!internal::Base64Unescape(s2, &unescaped)) {1141 if (listener != nullptr) {1142 *listener << "is not a valid base64 escaped string";1143 }1144 return false;1145 }1146 return MatchPrintAndExplain(unescaped, internal_matcher_, listener);1147 }1148 1149 void DescribeTo(::std::ostream* os) const {1150 *os << "matches after Base64Unescape ";1151 internal_matcher_.DescribeTo(os);1152 }1153 1154 void DescribeNegationTo(::std::ostream* os) const {1155 *os << "does not match after Base64Unescape ";1156 internal_matcher_.DescribeTo(os);1157 }1158 1159 private:1160 const Matcher<const std::string&> internal_matcher_;1161};1162 1163// Implements a matcher that compares the two fields of a 2-tuple1164// using one of the ==, <=, <, etc, operators. The two fields being1165// compared don't have to have the same type.1166//1167// The matcher defined here is polymorphic (for example, Eq() can be1168// used to match a std::tuple<int, short>, a std::tuple<const long&, double>,1169// etc). Therefore we use a template type conversion operator in the1170// implementation.1171template <typename D, typename Op>1172class PairMatchBase {1173 public:1174 template <typename T1, typename T2>1175 operator Matcher<::std::tuple<T1, T2>>() const {1176 return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1, T2>&>);1177 }1178 template <typename T1, typename T2>1179 operator Matcher<const ::std::tuple<T1, T2>&>() const {1180 return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>);1181 }1182 1183 private:1184 static ::std::ostream& GetDesc(::std::ostream& os) { // NOLINT1185 return os << D::Desc();1186 }1187 1188 template <typename Tuple>1189 class Impl : public MatcherInterface<Tuple> {1190 public:1191 bool MatchAndExplain(Tuple args,1192 MatchResultListener* /* listener */) const override {1193 return Op()(::std::get<0>(args), ::std::get<1>(args));1194 }1195 void DescribeTo(::std::ostream* os) const override {1196 *os << "are " << GetDesc;1197 }1198 void DescribeNegationTo(::std::ostream* os) const override {1199 *os << "aren't " << GetDesc;1200 }1201 };1202};1203 1204class Eq2Matcher : public PairMatchBase<Eq2Matcher, std::equal_to<>> {1205 public:1206 static const char* Desc() { return "an equal pair"; }1207};1208class Ne2Matcher : public PairMatchBase<Ne2Matcher, std::not_equal_to<>> {1209 public:1210 static const char* Desc() { return "an unequal pair"; }1211};1212class Lt2Matcher : public PairMatchBase<Lt2Matcher, std::less<>> {1213 public:1214 static const char* Desc() { return "a pair where the first < the second"; }1215};1216class Gt2Matcher : public PairMatchBase<Gt2Matcher, std::greater<>> {1217 public:1218 static const char* Desc() { return "a pair where the first > the second"; }1219};1220class Le2Matcher : public PairMatchBase<Le2Matcher, std::less_equal<>> {1221 public:1222 static const char* Desc() { return "a pair where the first <= the second"; }1223};1224class Ge2Matcher : public PairMatchBase<Ge2Matcher, std::greater_equal<>> {1225 public:1226 static const char* Desc() { return "a pair where the first >= the second"; }1227};1228 1229// Implements the Not(...) matcher for a particular argument type T.1230// We do not nest it inside the NotMatcher class template, as that1231// will prevent different instantiations of NotMatcher from sharing1232// the same NotMatcherImpl<T> class.1233template <typename T>1234class NotMatcherImpl : public MatcherInterface<const T&> {1235 public:1236 explicit NotMatcherImpl(const Matcher<T>& matcher) : matcher_(matcher) {}1237 1238 bool MatchAndExplain(const T& x,1239 MatchResultListener* listener) const override {1240 return !matcher_.MatchAndExplain(x, listener);1241 }1242 1243 void DescribeTo(::std::ostream* os) const override {1244 matcher_.DescribeNegationTo(os);1245 }1246 1247 void DescribeNegationTo(::std::ostream* os) const override {1248 matcher_.DescribeTo(os);1249 }1250 1251 private:1252 const Matcher<T> matcher_;1253};1254 1255// Implements the Not(m) matcher, which matches a value that doesn't1256// match matcher m.1257template <typename InnerMatcher>1258class NotMatcher {1259 public:1260 explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}1261 1262 // This template type conversion operator allows Not(m) to be used1263 // to match any type m can match.1264 template <typename T>1265 operator Matcher<T>() const {1266 return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));1267 }1268 1269 private:1270 InnerMatcher matcher_;1271};1272 1273// Implements the AllOf(m1, m2) matcher for a particular argument type1274// T. We do not nest it inside the BothOfMatcher class template, as1275// that will prevent different instantiations of BothOfMatcher from1276// sharing the same BothOfMatcherImpl<T> class.1277template <typename T>1278class AllOfMatcherImpl : public MatcherInterface<const T&> {1279 public:1280 explicit AllOfMatcherImpl(std::vector<Matcher<T>> matchers)1281 : matchers_(std::move(matchers)) {}1282 1283 void DescribeTo(::std::ostream* os) const override {1284 *os << "(";1285 for (size_t i = 0; i < matchers_.size(); ++i) {1286 if (i != 0) *os << ") and (";1287 matchers_[i].DescribeTo(os);1288 }1289 *os << ")";1290 }1291 1292 void DescribeNegationTo(::std::ostream* os) const override {1293 *os << "(";1294 for (size_t i = 0; i < matchers_.size(); ++i) {1295 if (i != 0) *os << ") or (";1296 matchers_[i].DescribeNegationTo(os);1297 }1298 *os << ")";1299 }1300 1301 bool MatchAndExplain(const T& x,1302 MatchResultListener* listener) const override {1303 // If either matcher1_ or matcher2_ doesn't match x, we only need1304 // to explain why one of them fails.1305 std::string all_match_result;1306 1307 for (size_t i = 0; i < matchers_.size(); ++i) {1308 StringMatchResultListener slistener;1309 if (matchers_[i].MatchAndExplain(x, &slistener)) {1310 if (all_match_result.empty()) {1311 all_match_result = slistener.str();1312 } else {1313 std::string result = slistener.str();1314 if (!result.empty()) {1315 all_match_result += ", and ";1316 all_match_result += result;1317 }1318 }1319 } else {1320 *listener << slistener.str();1321 return false;1322 }1323 }1324 1325 // Otherwise we need to explain why *both* of them match.1326 *listener << all_match_result;1327 return true;1328 }1329 1330 private:1331 const std::vector<Matcher<T>> matchers_;1332};1333 1334// VariadicMatcher is used for the variadic implementation of1335// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).1336// CombiningMatcher<T> is used to recursively combine the provided matchers1337// (of type Args...).1338template <template <typename T> class CombiningMatcher, typename... Args>1339class VariadicMatcher {1340 public:1341 VariadicMatcher(const Args&... matchers) // NOLINT1342 : matchers_(matchers...) {1343 static_assert(sizeof...(Args) > 0, "Must have at least one matcher.");1344 }1345 1346 VariadicMatcher(const VariadicMatcher&) = default;1347 VariadicMatcher& operator=(const VariadicMatcher&) = delete;1348 1349 // This template type conversion operator allows an1350 // VariadicMatcher<Matcher1, Matcher2...> object to match any type that1351 // all of the provided matchers (Matcher1, Matcher2, ...) can match.1352 template <typename T>1353 operator Matcher<T>() const {1354 std::vector<Matcher<T>> values;1355 CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>());1356 return Matcher<T>(new CombiningMatcher<T>(std::move(values)));1357 }1358 1359 private:1360 template <typename T, size_t I>1361 void CreateVariadicMatcher(std::vector<Matcher<T>>* values,1362 std::integral_constant<size_t, I>) const {1363 values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_)));1364 CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>());1365 }1366 1367 template <typename T>1368 void CreateVariadicMatcher(1369 std::vector<Matcher<T>>*,1370 std::integral_constant<size_t, sizeof...(Args)>) const {}1371 1372 std::tuple<Args...> matchers_;1373};1374 1375template <typename... Args>1376using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>;1377 1378// Implements the AnyOf(m1, m2) matcher for a particular argument type1379// T. We do not nest it inside the AnyOfMatcher class template, as1380// that will prevent different instantiations of AnyOfMatcher from1381// sharing the same EitherOfMatcherImpl<T> class.1382template <typename T>1383class AnyOfMatcherImpl : public MatcherInterface<const T&> {1384 public:1385 explicit AnyOfMatcherImpl(std::vector<Matcher<T>> matchers)1386 : matchers_(std::move(matchers)) {}1387 1388 void DescribeTo(::std::ostream* os) const override {1389 *os << "(";1390 for (size_t i = 0; i < matchers_.size(); ++i) {1391 if (i != 0) *os << ") or (";1392 matchers_[i].DescribeTo(os);1393 }1394 *os << ")";1395 }1396 1397 void DescribeNegationTo(::std::ostream* os) const override {1398 *os << "(";1399 for (size_t i = 0; i < matchers_.size(); ++i) {1400 if (i != 0) *os << ") and (";1401 matchers_[i].DescribeNegationTo(os);1402 }1403 *os << ")";1404 }1405 1406 bool MatchAndExplain(const T& x,1407 MatchResultListener* listener) const override {1408 std::string no_match_result;1409 1410 // If either matcher1_ or matcher2_ matches x, we just need to1411 // explain why *one* of them matches.1412 for (size_t i = 0; i < matchers_.size(); ++i) {1413 StringMatchResultListener slistener;1414 if (matchers_[i].MatchAndExplain(x, &slistener)) {1415 *listener << slistener.str();1416 return true;1417 } else {1418 if (no_match_result.empty()) {1419 no_match_result = slistener.str();1420 } else {1421 std::string result = slistener.str();1422 if (!result.empty()) {1423 no_match_result += ", and ";1424 no_match_result += result;1425 }1426 }1427 }1428 }1429 1430 // Otherwise we need to explain why *both* of them fail.1431 *listener << no_match_result;1432 return false;1433 }1434 1435 private:1436 const std::vector<Matcher<T>> matchers_;1437};1438 1439// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).1440template <typename... Args>1441using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>;1442 1443// ConditionalMatcher is the implementation of Conditional(cond, m1, m2)1444template <typename MatcherTrue, typename MatcherFalse>1445class ConditionalMatcher {1446 public:1447 ConditionalMatcher(bool condition, MatcherTrue matcher_true,1448 MatcherFalse matcher_false)1449 : condition_(condition),1450 matcher_true_(std::move(matcher_true)),1451 matcher_false_(std::move(matcher_false)) {}1452 1453 template <typename T>1454 operator Matcher<T>() const { // NOLINT(runtime/explicit)1455 return condition_ ? SafeMatcherCast<T>(matcher_true_)1456 : SafeMatcherCast<T>(matcher_false_);1457 }1458 1459 private:1460 bool condition_;1461 MatcherTrue matcher_true_;1462 MatcherFalse matcher_false_;1463};1464 1465// Wrapper for implementation of Any/AllOfArray().1466template <template <class> class MatcherImpl, typename T>1467class SomeOfArrayMatcher {1468 public:1469 // Constructs the matcher from a sequence of element values or1470 // element matchers.1471 template <typename Iter>1472 SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}1473 1474 template <typename U>1475 operator Matcher<U>() const { // NOLINT1476 using RawU = typename std::decay<U>::type;1477 std::vector<Matcher<RawU>> matchers;1478 matchers.reserve(matchers_.size());1479 for (const auto& matcher : matchers_) {1480 matchers.push_back(MatcherCast<RawU>(matcher));1481 }1482 return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers)));1483 }1484 1485 private:1486 const ::std::vector<T> matchers_;1487};1488 1489template <typename T>1490using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>;1491 1492template <typename T>1493using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>;1494 1495// Used for implementing Truly(pred), which turns a predicate into a1496// matcher.1497template <typename Predicate>1498class TrulyMatcher {1499 public:1500 explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}1501 1502 // This method template allows Truly(pred) to be used as a matcher1503 // for type T where T is the argument type of predicate 'pred'. The1504 // argument is passed by reference as the predicate may be1505 // interested in the address of the argument.1506 template <typename T>1507 bool MatchAndExplain(T& x, // NOLINT1508 MatchResultListener* listener) const {1509 // Without the if-statement, MSVC sometimes warns about converting1510 // a value to bool (warning 4800).1511 //1512 // We cannot write 'return !!predicate_(x);' as that doesn't work1513 // when predicate_(x) returns a class convertible to bool but1514 // having no operator!().1515 if (predicate_(x)) return true;1516 *listener << "didn't satisfy the given predicate";1517 return false;1518 }1519 1520 void DescribeTo(::std::ostream* os) const {1521 *os << "satisfies the given predicate";1522 }1523 1524 void DescribeNegationTo(::std::ostream* os) const {1525 *os << "doesn't satisfy the given predicate";1526 }1527 1528 private:1529 Predicate predicate_;1530};1531 1532// Used for implementing Matches(matcher), which turns a matcher into1533// a predicate.1534template <typename M>1535class MatcherAsPredicate {1536 public:1537 explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}1538 1539 // This template operator() allows Matches(m) to be used as a1540 // predicate on type T where m is a matcher on type T.1541 //1542 // The argument x is passed by reference instead of by value, as1543 // some matcher may be interested in its address (e.g. as in1544 // Matches(Ref(n))(x)).1545 template <typename T>1546 bool operator()(const T& x) const {1547 // We let matcher_ commit to a particular type here instead of1548 // when the MatcherAsPredicate object was constructed. This1549 // allows us to write Matches(m) where m is a polymorphic matcher1550 // (e.g. Eq(5)).1551 //1552 // If we write Matcher<T>(matcher_).Matches(x) here, it won't1553 // compile when matcher_ has type Matcher<const T&>; if we write1554 // Matcher<const T&>(matcher_).Matches(x) here, it won't compile1555 // when matcher_ has type Matcher<T>; if we just write1556 // matcher_.Matches(x), it won't compile when matcher_ is1557 // polymorphic, e.g. Eq(5).1558 //1559 // MatcherCast<const T&>() is necessary for making the code work1560 // in all of the above situations.1561 return MatcherCast<const T&>(matcher_).Matches(x);1562 }1563 1564 private:1565 M matcher_;1566};1567 1568// For implementing ASSERT_THAT() and EXPECT_THAT(). The template1569// argument M must be a type that can be converted to a matcher.1570template <typename M>1571class PredicateFormatterFromMatcher {1572 public:1573 explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {}1574 1575 // This template () operator allows a PredicateFormatterFromMatcher1576 // object to act as a predicate-formatter suitable for using with1577 // Google Test's EXPECT_PRED_FORMAT1() macro.1578 template <typename T>1579 AssertionResult operator()(const char* value_text, const T& x) const {1580 // We convert matcher_ to a Matcher<const T&> *now* instead of1581 // when the PredicateFormatterFromMatcher object was constructed,1582 // as matcher_ may be polymorphic (e.g. NotNull()) and we won't1583 // know which type to instantiate it to until we actually see the1584 // type of x here.1585 //1586 // We write SafeMatcherCast<const T&>(matcher_) instead of1587 // Matcher<const T&>(matcher_), as the latter won't compile when1588 // matcher_ has type Matcher<T> (e.g. An<int>()).1589 // We don't write MatcherCast<const T&> either, as that allows1590 // potentially unsafe downcasting of the matcher argument.1591 const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);1592 1593 // The expected path here is that the matcher should match (i.e. that most1594 // tests pass) so optimize for this case.1595 if (matcher.Matches(x)) {1596 return AssertionSuccess();1597 }1598 1599 ::std::stringstream ss;1600 ss << "Value of: " << value_text << "\n"1601 << "Expected: ";1602 matcher.DescribeTo(&ss);1603 1604 // Rerun the matcher to "PrintAndExplain" the failure.1605 StringMatchResultListener listener;1606 if (MatchPrintAndExplain(x, matcher, &listener)) {1607 ss << "\n The matcher failed on the initial attempt; but passed when "1608 "rerun to generate the explanation.";1609 }1610 ss << "\n Actual: " << listener.str();1611 return AssertionFailure() << ss.str();1612 }1613 1614 private:1615 const M matcher_;1616};1617 1618// A helper function for converting a matcher to a predicate-formatter1619// without the user needing to explicitly write the type. This is1620// used for implementing ASSERT_THAT() and EXPECT_THAT().1621// Implementation detail: 'matcher' is received by-value to force decaying.1622template <typename M>1623inline PredicateFormatterFromMatcher<M> MakePredicateFormatterFromMatcher(1624 M matcher) {1625 return PredicateFormatterFromMatcher<M>(std::move(matcher));1626}1627 1628// Implements the polymorphic IsNan() matcher, which matches any floating type1629// value that is Nan.1630class IsNanMatcher {1631 public:1632 template <typename FloatType>1633 bool MatchAndExplain(const FloatType& f,1634 MatchResultListener* /* listener */) const {1635 return (::std::isnan)(f);1636 }1637 1638 void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }1639 void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NaN"; }1640};1641 1642// Implements the polymorphic floating point equality matcher, which matches1643// two float values using ULP-based approximation or, optionally, a1644// user-specified epsilon. The template is meant to be instantiated with1645// FloatType being either float or double.1646template <typename FloatType>1647class FloatingEqMatcher {1648 public:1649 // Constructor for FloatingEqMatcher.1650 // The matcher's input will be compared with expected. The matcher treats two1651 // NANs as equal if nan_eq_nan is true. Otherwise, under IEEE standards,1652 // equality comparisons between NANs will always return false. We specify a1653 // negative max_abs_error_ term to indicate that ULP-based approximation will1654 // be used for comparison.1655 FloatingEqMatcher(FloatType expected, bool nan_eq_nan)1656 : expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {}1657 1658 // Constructor that supports a user-specified max_abs_error that will be used1659 // for comparison instead of ULP-based approximation. The max absolute1660 // should be non-negative.1661 FloatingEqMatcher(FloatType expected, bool nan_eq_nan,1662 FloatType max_abs_error)1663 : expected_(expected),1664 nan_eq_nan_(nan_eq_nan),1665 max_abs_error_(max_abs_error) {1666 GTEST_CHECK_(max_abs_error >= 0)1667 << ", where max_abs_error is" << max_abs_error;1668 }1669 1670 // Implements floating point equality matcher as a Matcher<T>.1671 template <typename T>1672 class Impl : public MatcherInterface<T> {1673 public:1674 Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)1675 : expected_(expected),1676 nan_eq_nan_(nan_eq_nan),1677 max_abs_error_(max_abs_error) {}1678 1679 bool MatchAndExplain(T value,1680 MatchResultListener* listener) const override {1681 const FloatingPoint<FloatType> actual(value), expected(expected_);1682 1683 // Compares NaNs first, if nan_eq_nan_ is true.1684 if (actual.is_nan() || expected.is_nan()) {1685 if (actual.is_nan() && expected.is_nan()) {1686 return nan_eq_nan_;1687 }1688 // One is nan; the other is not nan.1689 return false;1690 }1691 if (HasMaxAbsError()) {1692 // We perform an equality check so that inf will match inf, regardless1693 // of error bounds. If the result of value - expected_ would result in1694 // overflow or if either value is inf, the default result is infinity,1695 // which should only match if max_abs_error_ is also infinity.1696 if (value == expected_) {1697 return true;1698 }1699 1700 const FloatType diff = value - expected_;1701 if (::std::fabs(diff) <= max_abs_error_) {1702 return true;1703 }1704 1705 if (listener->IsInterested()) {1706 *listener << "which is " << diff << " from " << expected_;1707 }1708 return false;1709 } else {1710 return actual.AlmostEquals(expected);1711 }1712 }1713 1714 void DescribeTo(::std::ostream* os) const override {1715 // os->precision() returns the previously set precision, which we1716 // store to restore the ostream to its original configuration1717 // after outputting.1718 const ::std::streamsize old_precision =1719 os->precision(::std::numeric_limits<FloatType>::digits10 + 2);1720 if (FloatingPoint<FloatType>(expected_).is_nan()) {1721 if (nan_eq_nan_) {1722 *os << "is NaN";1723 } else {1724 *os << "never matches";1725 }1726 } else {1727 *os << "is approximately " << expected_;1728 if (HasMaxAbsError()) {1729 *os << " (absolute error <= " << max_abs_error_ << ")";1730 }1731 }1732 os->precision(old_precision);1733 }1734 1735 void DescribeNegationTo(::std::ostream* os) const override {1736 // As before, get original precision.1737 const ::std::streamsize old_precision =1738 os->precision(::std::numeric_limits<FloatType>::digits10 + 2);1739 if (FloatingPoint<FloatType>(expected_).is_nan()) {1740 if (nan_eq_nan_) {1741 *os << "isn't NaN";1742 } else {1743 *os << "is anything";1744 }1745 } else {1746 *os << "isn't approximately " << expected_;1747 if (HasMaxAbsError()) {1748 *os << " (absolute error > " << max_abs_error_ << ")";1749 }1750 }1751 // Restore original precision.1752 os->precision(old_precision);1753 }1754 1755 private:1756 bool HasMaxAbsError() const { return max_abs_error_ >= 0; }1757 1758 const FloatType expected_;1759 const bool nan_eq_nan_;1760 // max_abs_error will be used for value comparison when >= 0.1761 const FloatType max_abs_error_;1762 };1763 1764 // The following 3 type conversion operators allow FloatEq(expected) and1765 // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a1766 // Matcher<const float&>, or a Matcher<float&>, but nothing else.1767 operator Matcher<FloatType>() const {1768 return MakeMatcher(1769 new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));1770 }1771 1772 operator Matcher<const FloatType&>() const {1773 return MakeMatcher(1774 new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));1775 }1776 1777 operator Matcher<FloatType&>() const {1778 return MakeMatcher(1779 new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));1780 }1781 1782 private:1783 const FloatType expected_;1784 const bool nan_eq_nan_;1785 // max_abs_error will be used for value comparison when >= 0.1786 const FloatType max_abs_error_;1787};1788 1789// A 2-tuple ("binary") wrapper around FloatingEqMatcher:1790// FloatingEq2Matcher() matches (x, y) by matching FloatingEqMatcher(x, false)1791// against y, and FloatingEq2Matcher(e) matches FloatingEqMatcher(x, false, e)1792// against y. The former implements "Eq", the latter "Near". At present, there1793// is no version that compares NaNs as equal.1794template <typename FloatType>1795class FloatingEq2Matcher {1796 public:1797 FloatingEq2Matcher() { Init(-1, false); }1798 1799 explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); }1800 1801 explicit FloatingEq2Matcher(FloatType max_abs_error) {1802 Init(max_abs_error, false);1803 }1804 1805 FloatingEq2Matcher(FloatType max_abs_error, bool nan_eq_nan) {1806 Init(max_abs_error, nan_eq_nan);1807 }1808 1809 template <typename T1, typename T2>1810 operator Matcher<::std::tuple<T1, T2>>() const {1811 return MakeMatcher(1812 new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_));1813 }1814 template <typename T1, typename T2>1815 operator Matcher<const ::std::tuple<T1, T2>&>() const {1816 return MakeMatcher(1817 new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_, nan_eq_nan_));1818 }1819 1820 private:1821 static ::std::ostream& GetDesc(::std::ostream& os) { // NOLINT1822 return os << "an almost-equal pair";1823 }1824 1825 template <typename Tuple>1826 class Impl : public MatcherInterface<Tuple> {1827 public:1828 Impl(FloatType max_abs_error, bool nan_eq_nan)1829 : max_abs_error_(max_abs_error), nan_eq_nan_(nan_eq_nan) {}1830 1831 bool MatchAndExplain(Tuple args,1832 MatchResultListener* listener) const override {1833 if (max_abs_error_ == -1) {1834 FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_);1835 return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(1836 ::std::get<1>(args), listener);1837 } else {1838 FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_,1839 max_abs_error_);1840 return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(1841 ::std::get<1>(args), listener);1842 }1843 }1844 void DescribeTo(::std::ostream* os) const override {1845 *os << "are " << GetDesc;1846 }1847 void DescribeNegationTo(::std::ostream* os) const override {1848 *os << "aren't " << GetDesc;1849 }1850 1851 private:1852 FloatType max_abs_error_;1853 const bool nan_eq_nan_;1854 };1855 1856 void Init(FloatType max_abs_error_val, bool nan_eq_nan_val) {1857 max_abs_error_ = max_abs_error_val;1858 nan_eq_nan_ = nan_eq_nan_val;1859 }1860 FloatType max_abs_error_;1861 bool nan_eq_nan_;1862};1863 1864// Implements the Pointee(m) matcher for matching a pointer whose1865// pointee matches matcher m. The pointer can be either raw or smart.1866template <typename InnerMatcher>1867class PointeeMatcher {1868 public:1869 explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}1870 1871 // This type conversion operator template allows Pointee(m) to be1872 // used as a matcher for any pointer type whose pointee type is1873 // compatible with the inner matcher, where type Pointer can be1874 // either a raw pointer or a smart pointer.1875 //1876 // The reason we do this instead of relying on1877 // MakePolymorphicMatcher() is that the latter is not flexible1878 // enough for implementing the DescribeTo() method of Pointee().1879 template <typename Pointer>1880 operator Matcher<Pointer>() const {1881 return Matcher<Pointer>(new Impl<const Pointer&>(matcher_));1882 }1883 1884 private:1885 // The monomorphic implementation that works for a particular pointer type.1886 template <typename Pointer>1887 class Impl : public MatcherInterface<Pointer> {1888 public:1889 using Pointee =1890 typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(1891 Pointer)>::element_type;1892 1893 explicit Impl(const InnerMatcher& matcher)1894 : matcher_(MatcherCast<const Pointee&>(matcher)) {}1895 1896 void DescribeTo(::std::ostream* os) const override {1897 *os << "points to a value that ";1898 matcher_.DescribeTo(os);1899 }1900 1901 void DescribeNegationTo(::std::ostream* os) const override {1902 *os << "does not point to a value that ";1903 matcher_.DescribeTo(os);1904 }1905 1906 bool MatchAndExplain(Pointer pointer,1907 MatchResultListener* listener) const override {1908 if (GetRawPointer(pointer) == nullptr) return false;1909 1910 *listener << "which points to ";1911 return MatchPrintAndExplain(*pointer, matcher_, listener);1912 }1913 1914 private:1915 const Matcher<const Pointee&> matcher_;1916 };1917 1918 const InnerMatcher matcher_;1919};1920 1921// Implements the Pointer(m) matcher1922// Implements the Pointer(m) matcher for matching a pointer that matches matcher1923// m. The pointer can be either raw or smart, and will match `m` against the1924// raw pointer.1925template <typename InnerMatcher>1926class PointerMatcher {1927 public:1928 explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}1929 1930 // This type conversion operator template allows Pointer(m) to be1931 // used as a matcher for any pointer type whose pointer type is1932 // compatible with the inner matcher, where type PointerType can be1933 // either a raw pointer or a smart pointer.1934 //1935 // The reason we do this instead of relying on1936 // MakePolymorphicMatcher() is that the latter is not flexible1937 // enough for implementing the DescribeTo() method of Pointer().1938 template <typename PointerType>1939 operator Matcher<PointerType>() const { // NOLINT1940 return Matcher<PointerType>(new Impl<const PointerType&>(matcher_));1941 }1942 1943 private:1944 // The monomorphic implementation that works for a particular pointer type.1945 template <typename PointerType>1946 class Impl : public MatcherInterface<PointerType> {1947 public:1948 using Pointer =1949 const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(1950 PointerType)>::element_type*;1951 1952 explicit Impl(const InnerMatcher& matcher)1953 : matcher_(MatcherCast<Pointer>(matcher)) {}1954 1955 void DescribeTo(::std::ostream* os) const override {1956 *os << "is a pointer that ";1957 matcher_.DescribeTo(os);1958 }1959 1960 void DescribeNegationTo(::std::ostream* os) const override {1961 *os << "is not a pointer that ";1962 matcher_.DescribeTo(os);1963 }1964 1965 bool MatchAndExplain(PointerType pointer,1966 MatchResultListener* listener) const override {1967 *listener << "which is a pointer that ";1968 Pointer p = GetRawPointer(pointer);1969 return MatchPrintAndExplain(p, matcher_, listener);1970 }1971 1972 private:1973 Matcher<Pointer> matcher_;1974 };1975 1976 const InnerMatcher matcher_;1977};1978 1979#if GTEST_HAS_RTTI1980// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or1981// reference that matches inner_matcher when dynamic_cast<T> is applied.1982// The result of dynamic_cast<To> is forwarded to the inner matcher.1983// If To is a pointer and the cast fails, the inner matcher will receive NULL.1984// If To is a reference and the cast fails, this matcher returns false1985// immediately.1986template <typename To>1987class WhenDynamicCastToMatcherBase {1988 public:1989 explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)1990 : matcher_(matcher) {}1991 1992 void DescribeTo(::std::ostream* os) const {1993 GetCastTypeDescription(os);1994 matcher_.DescribeTo(os);1995 }1996 1997 void DescribeNegationTo(::std::ostream* os) const {1998 GetCastTypeDescription(os);1999 matcher_.DescribeNegationTo(os);2000 }2001 2002 protected:2003 const Matcher<To> matcher_;2004 2005 static std::string GetToName() { return GetTypeName<To>(); }2006 2007 private:2008 static void GetCastTypeDescription(::std::ostream* os) {2009 *os << "when dynamic_cast to " << GetToName() << ", ";2010 }2011};2012 2013// Primary template.2014// To is a pointer. Cast and forward the result.2015template <typename To>2016class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {2017 public:2018 explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)2019 : WhenDynamicCastToMatcherBase<To>(matcher) {}2020 2021 template <typename From>2022 bool MatchAndExplain(From from, MatchResultListener* listener) const {2023 To to = dynamic_cast<To>(from);2024 return MatchPrintAndExplain(to, this->matcher_, listener);2025 }2026};2027 2028// Specialize for references.2029// In this case we return false if the dynamic_cast fails.2030template <typename To>2031class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {2032 public:2033 explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)2034 : WhenDynamicCastToMatcherBase<To&>(matcher) {}2035 2036 template <typename From>2037 bool MatchAndExplain(From& from, MatchResultListener* listener) const {2038 // We don't want an std::bad_cast here, so do the cast with pointers.2039 To* to = dynamic_cast<To*>(&from);2040 if (to == nullptr) {2041 *listener << "which cannot be dynamic_cast to " << this->GetToName();2042 return false;2043 }2044 return MatchPrintAndExplain(*to, this->matcher_, listener);2045 }2046};2047#endif // GTEST_HAS_RTTI2048 2049// Implements the Field() matcher for matching a field (i.e. member2050// variable) of an object.2051template <typename Class, typename FieldType>2052class FieldMatcher {2053 public:2054 FieldMatcher(FieldType Class::*field,2055 const Matcher<const FieldType&>& matcher)2056 : field_(field), matcher_(matcher), whose_field_("whose given field ") {}2057 2058 FieldMatcher(const std::string& field_name, FieldType Class::*field,2059 const Matcher<const FieldType&>& matcher)2060 : field_(field),2061 matcher_(matcher),2062 whose_field_("whose field `" + field_name + "` ") {}2063 2064 void DescribeTo(::std::ostream* os) const {2065 *os << "is an object " << whose_field_;2066 matcher_.DescribeTo(os);2067 }2068 2069 void DescribeNegationTo(::std::ostream* os) const {2070 *os << "is an object " << whose_field_;2071 matcher_.DescribeNegationTo(os);2072 }2073 2074 template <typename T>2075 bool MatchAndExplain(const T& value, MatchResultListener* listener) const {2076 // FIXME: The dispatch on std::is_pointer was introduced as a workaround for2077 // a compiler bug, and can now be removed.2078 return MatchAndExplainImpl(2079 typename std::is_pointer<typename std::remove_const<T>::type>::type(),2080 value, listener);2081 }2082 2083 private:2084 bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,2085 const Class& obj,2086 MatchResultListener* listener) const {2087 *listener << whose_field_ << "is ";2088 return MatchPrintAndExplain(obj.*field_, matcher_, listener);2089 }2090 2091 bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,2092 MatchResultListener* listener) const {2093 if (p == nullptr) return false;2094 2095 *listener << "which points to an object ";2096 // Since *p has a field, it must be a class/struct/union type and2097 // thus cannot be a pointer. Therefore we pass false_type() as2098 // the first argument.2099 return MatchAndExplainImpl(std::false_type(), *p, listener);2100 }2101 2102 const FieldType Class::*field_;2103 const Matcher<const FieldType&> matcher_;2104 2105 // Contains either "whose given field " if the name of the field is unknown2106 // or "whose field `name_of_field` " if the name is known.2107 const std::string whose_field_;2108};2109 2110// Implements the Property() matcher for matching a property2111// (i.e. return value of a getter method) of an object.2112//2113// Property is a const-qualified member function of Class returning2114// PropertyType.2115template <typename Class, typename PropertyType, typename Property>2116class PropertyMatcher {2117 public:2118 typedef const PropertyType& RefToConstProperty;2119 2120 PropertyMatcher(Property property, const Matcher<RefToConstProperty>& matcher)2121 : property_(property),2122 matcher_(matcher),2123 whose_property_("whose given property ") {}2124 2125 PropertyMatcher(const std::string& property_name, Property property,2126 const Matcher<RefToConstProperty>& matcher)2127 : property_(property),2128 matcher_(matcher),2129 whose_property_("whose property `" + property_name + "` ") {}2130 2131 void DescribeTo(::std::ostream* os) const {2132 *os << "is an object " << whose_property_;2133 matcher_.DescribeTo(os);2134 }2135 2136 void DescribeNegationTo(::std::ostream* os) const {2137 *os << "is an object " << whose_property_;2138 matcher_.DescribeNegationTo(os);2139 }2140 2141 template <typename T>2142 bool MatchAndExplain(const T& value, MatchResultListener* listener) const {2143 return MatchAndExplainImpl(2144 typename std::is_pointer<typename std::remove_const<T>::type>::type(),2145 value, listener);2146 }2147 2148 private:2149 bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,2150 const Class& obj,2151 MatchResultListener* listener) const {2152 *listener << whose_property_ << "is ";2153 // Cannot pass the return value (for example, int) to MatchPrintAndExplain,2154 // which takes a non-const reference as argument.2155 RefToConstProperty result = (obj.*property_)();2156 return MatchPrintAndExplain(result, matcher_, listener);2157 }2158 2159 bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,2160 MatchResultListener* listener) const {2161 if (p == nullptr) return false;2162 2163 *listener << "which points to an object ";2164 // Since *p has a property method, it must be a class/struct/union2165 // type and thus cannot be a pointer. Therefore we pass2166 // false_type() as the first argument.2167 return MatchAndExplainImpl(std::false_type(), *p, listener);2168 }2169 2170 Property property_;2171 const Matcher<RefToConstProperty> matcher_;2172 2173 // Contains either "whose given property " if the name of the property is2174 // unknown or "whose property `name_of_property` " if the name is known.2175 const std::string whose_property_;2176};2177 2178// Type traits specifying various features of different functors for ResultOf.2179// The default template specifies features for functor objects.2180template <typename Functor>2181struct CallableTraits {2182 typedef Functor StorageType;2183 2184 static void CheckIsValid(Functor /* functor */) {}2185 2186 template <typename T>2187 static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) {2188 return f(arg);2189 }2190};2191 2192// Specialization for function pointers.2193template <typename ArgType, typename ResType>2194struct CallableTraits<ResType (*)(ArgType)> {2195 typedef ResType ResultType;2196 typedef ResType (*StorageType)(ArgType);2197 2198 static void CheckIsValid(ResType (*f)(ArgType)) {2199 GTEST_CHECK_(f != nullptr)2200 << "NULL function pointer is passed into ResultOf().";2201 }2202 template <typename T>2203 static ResType Invoke(ResType (*f)(ArgType), T arg) {2204 return (*f)(arg);2205 }2206};2207 2208// Implements the ResultOf() matcher for matching a return value of a2209// unary function of an object.2210template <typename Callable, typename InnerMatcher>2211class ResultOfMatcher {2212 public:2213 ResultOfMatcher(Callable callable, InnerMatcher matcher)2214 : ResultOfMatcher(/*result_description=*/"", std::move(callable),2215 std::move(matcher)) {}2216 2217 ResultOfMatcher(const std::string& result_description, Callable callable,2218 InnerMatcher matcher)2219 : result_description_(result_description),2220 callable_(std::move(callable)),2221 matcher_(std::move(matcher)) {2222 CallableTraits<Callable>::CheckIsValid(callable_);2223 }2224 2225 template <typename T>2226 operator Matcher<T>() const {2227 return Matcher<T>(2228 new Impl<const T&>(result_description_, callable_, matcher_));2229 }2230 2231 private:2232 typedef typename CallableTraits<Callable>::StorageType CallableStorageType;2233 2234 template <typename T>2235 class Impl : public MatcherInterface<T> {2236 using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>(2237 std::declval<CallableStorageType>(), std::declval<T>()));2238 2239 public:2240 template <typename M>2241 Impl(const std::string& result_description,2242 const CallableStorageType& callable, const M& matcher)2243 : result_description_(result_description),2244 callable_(callable),2245 matcher_(MatcherCast<ResultType>(matcher)) {}2246 2247 void DescribeTo(::std::ostream* os) const override {2248 if (result_description_.empty()) {2249 *os << "is mapped by the given callable to a value that ";2250 } else {2251 *os << "whose " << result_description_ << " ";2252 }2253 matcher_.DescribeTo(os);2254 }2255 2256 void DescribeNegationTo(::std::ostream* os) const override {2257 if (result_description_.empty()) {2258 *os << "is mapped by the given callable to a value that ";2259 } else {2260 *os << "whose " << result_description_ << " ";2261 }2262 matcher_.DescribeNegationTo(os);2263 }2264 2265 bool MatchAndExplain(T obj, MatchResultListener* listener) const override {2266 if (result_description_.empty()) {2267 *listener << "which is mapped by the given callable to ";2268 } else {2269 *listener << "whose " << result_description_ << " is ";2270 }2271 // Cannot pass the return value directly to MatchPrintAndExplain, which2272 // takes a non-const reference as argument.2273 // Also, specifying template argument explicitly is needed because T could2274 // be a non-const reference (e.g. Matcher<Uncopyable&>).2275 ResultType result =2276 CallableTraits<Callable>::template Invoke<T>(callable_, obj);2277 return MatchPrintAndExplain(result, matcher_, listener);2278 }2279 2280 private:2281 const std::string result_description_;2282 // Functors often define operator() as non-const method even though2283 // they are actually stateless. But we need to use them even when2284 // 'this' is a const pointer. It's the user's responsibility not to2285 // use stateful callables with ResultOf(), which doesn't guarantee2286 // how many times the callable will be invoked.2287 mutable CallableStorageType callable_;2288 const Matcher<ResultType> matcher_;2289 }; // class Impl2290 2291 const std::string result_description_;2292 const CallableStorageType callable_;2293 const InnerMatcher matcher_;2294};2295 2296// Implements a matcher that checks the size of an STL-style container.2297template <typename SizeMatcher>2298class SizeIsMatcher {2299 public:2300 explicit SizeIsMatcher(const SizeMatcher& size_matcher)2301 : size_matcher_(size_matcher) {}2302 2303 template <typename Container>2304 operator Matcher<Container>() const {2305 return Matcher<Container>(new Impl<const Container&>(size_matcher_));2306 }2307 2308 template <typename Container>2309 class Impl : public MatcherInterface<Container> {2310 public:2311 using SizeType = decltype(std::declval<Container>().size());2312 explicit Impl(const SizeMatcher& size_matcher)2313 : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}2314 2315 void DescribeTo(::std::ostream* os) const override {2316 *os << "has a size that ";2317 size_matcher_.DescribeTo(os);2318 }2319 void DescribeNegationTo(::std::ostream* os) const override {2320 *os << "has a size that ";2321 size_matcher_.DescribeNegationTo(os);2322 }2323 2324 bool MatchAndExplain(Container container,2325 MatchResultListener* listener) const override {2326 SizeType size = container.size();2327 StringMatchResultListener size_listener;2328 const bool result = size_matcher_.MatchAndExplain(size, &size_listener);2329 *listener << "whose size " << size2330 << (result ? " matches" : " doesn't match");2331 PrintIfNotEmpty(size_listener.str(), listener->stream());2332 return result;2333 }2334 2335 private:2336 const Matcher<SizeType> size_matcher_;2337 };2338 2339 private:2340 const SizeMatcher size_matcher_;2341};2342 2343// Implements a matcher that checks the begin()..end() distance of an STL-style2344// container.2345template <typename DistanceMatcher>2346class BeginEndDistanceIsMatcher {2347 public:2348 explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)2349 : distance_matcher_(distance_matcher) {}2350 2351 template <typename Container>2352 operator Matcher<Container>() const {2353 return Matcher<Container>(new Impl<const Container&>(distance_matcher_));2354 }2355 2356 template <typename Container>2357 class Impl : public MatcherInterface<Container> {2358 public:2359 // LLVM local change to support std::begin/std::end.2360 //2361 // typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_(2362 // Container)>2363 // ContainerView;2364 // typedef typename std::iterator_traits<2365 // typename ContainerView::type::const_iterator>::difference_type2366 // DistanceType;2367 //2368 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;2369 typedef internal::StlContainerView<RawContainer> View;2370 typedef typename View::type StlContainer;2371 typedef typename View::const_reference StlContainerReference;2372 typedef decltype(std::begin(2373 std::declval<StlContainerReference>())) StlContainerConstIterator;2374 typedef typename std::iterator_traits<2375 StlContainerConstIterator>::difference_type DistanceType;2376 // LLVM local change end.2377 explicit Impl(const DistanceMatcher& distance_matcher)2378 : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}2379 2380 void DescribeTo(::std::ostream* os) const override {2381 *os << "distance between begin() and end() ";2382 distance_matcher_.DescribeTo(os);2383 }2384 void DescribeNegationTo(::std::ostream* os) const override {2385 *os << "distance between begin() and end() ";2386 distance_matcher_.DescribeNegationTo(os);2387 }2388 2389 bool MatchAndExplain(Container container,2390 MatchResultListener* listener) const override {2391 using std::begin;2392 using std::end;2393 DistanceType distance = std::distance(begin(container), end(container));2394 StringMatchResultListener distance_listener;2395 const bool result =2396 distance_matcher_.MatchAndExplain(distance, &distance_listener);2397 *listener << "whose distance between begin() and end() " << distance2398 << (result ? " matches" : " doesn't match");2399 PrintIfNotEmpty(distance_listener.str(), listener->stream());2400 return result;2401 }2402 2403 private:2404 const Matcher<DistanceType> distance_matcher_;2405 };2406 2407 private:2408 const DistanceMatcher distance_matcher_;2409};2410 2411// Implements an equality matcher for any STL-style container whose elements2412// support ==. This matcher is like Eq(), but its failure explanations provide2413// more detailed information that is useful when the container is used as a set.2414// The failure message reports elements that are in one of the operands but not2415// the other. The failure messages do not report duplicate or out-of-order2416// elements in the containers (which don't properly matter to sets, but can2417// occur if the containers are vectors or lists, for example).2418//2419// Uses the container's const_iterator, value_type, operator ==,2420// begin(), and end().2421template <typename Container>2422class ContainerEqMatcher {2423 public:2424 typedef internal::StlContainerView<Container> View;2425 typedef typename View::type StlContainer;2426 typedef typename View::const_reference StlContainerReference;2427 2428 static_assert(!std::is_const<Container>::value,2429 "Container type must not be const");2430 static_assert(!std::is_reference<Container>::value,2431 "Container type must not be a reference");2432 2433 // We make a copy of expected in case the elements in it are modified2434 // after this matcher is created.2435 explicit ContainerEqMatcher(const Container& expected)2436 : expected_(View::Copy(expected)) {}2437 2438 void DescribeTo(::std::ostream* os) const {2439 *os << "equals ";2440 UniversalPrint(expected_, os);2441 }2442 void DescribeNegationTo(::std::ostream* os) const {2443 *os << "does not equal ";2444 UniversalPrint(expected_, os);2445 }2446 2447 template <typename LhsContainer>2448 bool MatchAndExplain(const LhsContainer& lhs,2449 MatchResultListener* listener) const {2450 typedef internal::StlContainerView<2451 typename std::remove_const<LhsContainer>::type>2452 LhsView;2453 StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);2454 if (lhs_stl_container == expected_) return true;2455 2456 ::std::ostream* const os = listener->stream();2457 if (os != nullptr) {2458 // Something is different. Check for extra values first.2459 bool printed_header = false;2460 for (auto it = lhs_stl_container.begin(); it != lhs_stl_container.end();2461 ++it) {2462 if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==2463 expected_.end()) {2464 if (printed_header) {2465 *os << ", ";2466 } else {2467 *os << "which has these unexpected elements: ";2468 printed_header = true;2469 }2470 UniversalPrint(*it, os);2471 }2472 }2473 2474 // Now check for missing values.2475 bool printed_header2 = false;2476 for (auto it = expected_.begin(); it != expected_.end(); ++it) {2477 if (internal::ArrayAwareFind(lhs_stl_container.begin(),2478 lhs_stl_container.end(),2479 *it) == lhs_stl_container.end()) {2480 if (printed_header2) {2481 *os << ", ";2482 } else {2483 *os << (printed_header ? ",\nand" : "which")2484 << " doesn't have these expected elements: ";2485 printed_header2 = true;2486 }2487 UniversalPrint(*it, os);2488 }2489 }2490 }2491 2492 return false;2493 }2494 2495 private:2496 const StlContainer expected_;2497};2498 2499// A comparator functor that uses the < operator to compare two values.2500struct LessComparator {2501 template <typename T, typename U>2502 bool operator()(const T& lhs, const U& rhs) const {2503 return lhs < rhs;2504 }2505};2506 2507// Implements WhenSortedBy(comparator, container_matcher).2508template <typename Comparator, typename ContainerMatcher>2509class WhenSortedByMatcher {2510 public:2511 WhenSortedByMatcher(const Comparator& comparator,2512 const ContainerMatcher& matcher)2513 : comparator_(comparator), matcher_(matcher) {}2514 2515 template <typename LhsContainer>2516 operator Matcher<LhsContainer>() const {2517 return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));2518 }2519 2520 template <typename LhsContainer>2521 class Impl : public MatcherInterface<LhsContainer> {2522 public:2523 typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_(2524 LhsContainer)>2525 LhsView;2526 typedef typename LhsView::type LhsStlContainer;2527 typedef typename LhsView::const_reference LhsStlContainerReference;2528 // Transforms std::pair<const Key, Value> into std::pair<Key, Value>2529 // so that we can match associative containers.2530 typedef2531 typename RemoveConstFromKey<typename LhsStlContainer::value_type>::type2532 LhsValue;2533 2534 Impl(const Comparator& comparator, const ContainerMatcher& matcher)2535 : comparator_(comparator), matcher_(matcher) {}2536 2537 void DescribeTo(::std::ostream* os) const override {2538 *os << "(when sorted) ";2539 matcher_.DescribeTo(os);2540 }2541 2542 void DescribeNegationTo(::std::ostream* os) const override {2543 *os << "(when sorted) ";2544 matcher_.DescribeNegationTo(os);2545 }2546 2547 bool MatchAndExplain(LhsContainer lhs,2548 MatchResultListener* listener) const override {2549 LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);2550 ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),2551 lhs_stl_container.end());2552 ::std::sort(sorted_container.begin(), sorted_container.end(),2553 comparator_);2554 2555 if (!listener->IsInterested()) {2556 // If the listener is not interested, we do not need to2557 // construct the inner explanation.2558 return matcher_.Matches(sorted_container);2559 }2560 2561 *listener << "which is ";2562 UniversalPrint(sorted_container, listener->stream());2563 *listener << " when sorted";2564 2565 StringMatchResultListener inner_listener;2566 const bool match =2567 matcher_.MatchAndExplain(sorted_container, &inner_listener);2568 PrintIfNotEmpty(inner_listener.str(), listener->stream());2569 return match;2570 }2571 2572 private:2573 const Comparator comparator_;2574 const Matcher<const ::std::vector<LhsValue>&> matcher_;2575 2576 Impl(const Impl&) = delete;2577 Impl& operator=(const Impl&) = delete;2578 };2579 2580 private:2581 const Comparator comparator_;2582 const ContainerMatcher matcher_;2583};2584 2585// Implements Pointwise(tuple_matcher, rhs_container). tuple_matcher2586// must be able to be safely cast to Matcher<std::tuple<const T1&, const2587// T2&> >, where T1 and T2 are the types of elements in the LHS2588// container and the RHS container respectively.2589template <typename TupleMatcher, typename RhsContainer>2590class PointwiseMatcher {2591 static_assert(2592 !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value,2593 "use UnorderedPointwise with hash tables");2594 2595 public:2596 typedef internal::StlContainerView<RhsContainer> RhsView;2597 typedef typename RhsView::type RhsStlContainer;2598 typedef typename RhsStlContainer::value_type RhsValue;2599 2600 static_assert(!std::is_const<RhsContainer>::value,2601 "RhsContainer type must not be const");2602 static_assert(!std::is_reference<RhsContainer>::value,2603 "RhsContainer type must not be a reference");2604 2605 // Like ContainerEq, we make a copy of rhs in case the elements in2606 // it are modified after this matcher is created.2607 PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)2608 : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {}2609 2610 template <typename LhsContainer>2611 operator Matcher<LhsContainer>() const {2612 static_assert(2613 !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value,2614 "use UnorderedPointwise with hash tables");2615 2616 return Matcher<LhsContainer>(2617 new Impl<const LhsContainer&>(tuple_matcher_, rhs_));2618 }2619 2620 template <typename LhsContainer>2621 class Impl : public MatcherInterface<LhsContainer> {2622 public:2623 typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_(2624 LhsContainer)>2625 LhsView;2626 typedef typename LhsView::type LhsStlContainer;2627 typedef typename LhsView::const_reference LhsStlContainerReference;2628 typedef typename LhsStlContainer::value_type LhsValue;2629 // We pass the LHS value and the RHS value to the inner matcher by2630 // reference, as they may be expensive to copy. We must use tuple2631 // instead of pair here, as a pair cannot hold references (C++ 98,2632 // 20.2.2 [lib.pairs]).2633 typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;2634 2635 Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)2636 // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher.2637 : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),2638 rhs_(rhs) {}2639 2640 void DescribeTo(::std::ostream* os) const override {2641 *os << "contains " << rhs_.size()2642 << " values, where each value and its corresponding value in ";2643 UniversalPrinter<RhsStlContainer>::Print(rhs_, os);2644 *os << " ";2645 mono_tuple_matcher_.DescribeTo(os);2646 }2647 void DescribeNegationTo(::std::ostream* os) const override {2648 *os << "doesn't contain exactly " << rhs_.size()2649 << " values, or contains a value x at some index i"2650 << " where x and the i-th value of ";2651 UniversalPrint(rhs_, os);2652 *os << " ";2653 mono_tuple_matcher_.DescribeNegationTo(os);2654 }2655 2656 bool MatchAndExplain(LhsContainer lhs,2657 MatchResultListener* listener) const override {2658 LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);2659 const size_t actual_size = lhs_stl_container.size();2660 if (actual_size != rhs_.size()) {2661 *listener << "which contains " << actual_size << " values";2662 return false;2663 }2664 2665 auto left = lhs_stl_container.begin();2666 auto right = rhs_.begin();2667 for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {2668 if (listener->IsInterested()) {2669 StringMatchResultListener inner_listener;2670 // Create InnerMatcherArg as a temporarily object to avoid it outlives2671 // *left and *right. Dereference or the conversion to `const T&` may2672 // return temp objects, e.g. for vector<bool>.2673 if (!mono_tuple_matcher_.MatchAndExplain(2674 InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),2675 ImplicitCast_<const RhsValue&>(*right)),2676 &inner_listener)) {2677 *listener << "where the value pair (";2678 UniversalPrint(*left, listener->stream());2679 *listener << ", ";2680 UniversalPrint(*right, listener->stream());2681 *listener << ") at index #" << i << " don't match";2682 PrintIfNotEmpty(inner_listener.str(), listener->stream());2683 return false;2684 }2685 } else {2686 if (!mono_tuple_matcher_.Matches(2687 InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),2688 ImplicitCast_<const RhsValue&>(*right))))2689 return false;2690 }2691 }2692 2693 return true;2694 }2695 2696 private:2697 const Matcher<InnerMatcherArg> mono_tuple_matcher_;2698 const RhsStlContainer rhs_;2699 };2700 2701 private:2702 const TupleMatcher tuple_matcher_;2703 const RhsStlContainer rhs_;2704};2705 2706// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.2707template <typename Container>2708class QuantifierMatcherImpl : public MatcherInterface<Container> {2709 public:2710 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;2711 typedef StlContainerView<RawContainer> View;2712 typedef typename View::type StlContainer;2713 typedef typename View::const_reference StlContainerReference;2714 typedef typename StlContainer::value_type Element;2715 2716 template <typename InnerMatcher>2717 explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)2718 : inner_matcher_(2719 testing::SafeMatcherCast<const Element&>(inner_matcher)) {}2720 2721 // Checks whether:2722 // * All elements in the container match, if all_elements_should_match.2723 // * Any element in the container matches, if !all_elements_should_match.2724 bool MatchAndExplainImpl(bool all_elements_should_match, Container container,2725 MatchResultListener* listener) const {2726 StlContainerReference stl_container = View::ConstReference(container);2727 size_t i = 0;2728 for (auto it = stl_container.begin(); it != stl_container.end();2729 ++it, ++i) {2730 StringMatchResultListener inner_listener;2731 const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);2732 2733 if (matches != all_elements_should_match) {2734 *listener << "whose element #" << i2735 << (matches ? " matches" : " doesn't match");2736 PrintIfNotEmpty(inner_listener.str(), listener->stream());2737 return !all_elements_should_match;2738 }2739 }2740 return all_elements_should_match;2741 }2742 2743 bool MatchAndExplainImpl(const Matcher<size_t>& count_matcher,2744 Container container,2745 MatchResultListener* listener) const {2746 StlContainerReference stl_container = View::ConstReference(container);2747 size_t i = 0;2748 std::vector<size_t> match_elements;2749 for (auto it = stl_container.begin(); it != stl_container.end();2750 ++it, ++i) {2751 StringMatchResultListener inner_listener;2752 const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);2753 if (matches) {2754 match_elements.push_back(i);2755 }2756 }2757 if (listener->IsInterested()) {2758 if (match_elements.empty()) {2759 *listener << "has no element that matches";2760 } else if (match_elements.size() == 1) {2761 *listener << "whose element #" << match_elements[0] << " matches";2762 } else {2763 *listener << "whose elements (";2764 std::string sep = "";2765 for (size_t e : match_elements) {2766 *listener << sep << e;2767 sep = ", ";2768 }2769 *listener << ") match";2770 }2771 }2772 StringMatchResultListener count_listener;2773 if (count_matcher.MatchAndExplain(match_elements.size(), &count_listener)) {2774 *listener << " and whose match quantity of " << match_elements.size()2775 << " matches";2776 PrintIfNotEmpty(count_listener.str(), listener->stream());2777 return true;2778 } else {2779 if (match_elements.empty()) {2780 *listener << " and";2781 } else {2782 *listener << " but";2783 }2784 *listener << " whose match quantity of " << match_elements.size()2785 << " does not match";2786 PrintIfNotEmpty(count_listener.str(), listener->stream());2787 return false;2788 }2789 }2790 2791 protected:2792 const Matcher<const Element&> inner_matcher_;2793};2794 2795// Implements Contains(element_matcher) for the given argument type Container.2796// Symmetric to EachMatcherImpl.2797template <typename Container>2798class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {2799 public:2800 template <typename InnerMatcher>2801 explicit ContainsMatcherImpl(InnerMatcher inner_matcher)2802 : QuantifierMatcherImpl<Container>(inner_matcher) {}2803 2804 // Describes what this matcher does.2805 void DescribeTo(::std::ostream* os) const override {2806 *os << "contains at least one element that ";2807 this->inner_matcher_.DescribeTo(os);2808 }2809 2810 void DescribeNegationTo(::std::ostream* os) const override {2811 *os << "doesn't contain any element that ";2812 this->inner_matcher_.DescribeTo(os);2813 }2814 2815 bool MatchAndExplain(Container container,2816 MatchResultListener* listener) const override {2817 return this->MatchAndExplainImpl(false, container, listener);2818 }2819};2820 2821// Implements Each(element_matcher) for the given argument type Container.2822// Symmetric to ContainsMatcherImpl.2823template <typename Container>2824class EachMatcherImpl : public QuantifierMatcherImpl<Container> {2825 public:2826 template <typename InnerMatcher>2827 explicit EachMatcherImpl(InnerMatcher inner_matcher)2828 : QuantifierMatcherImpl<Container>(inner_matcher) {}2829 2830 // Describes what this matcher does.2831 void DescribeTo(::std::ostream* os) const override {2832 *os << "only contains elements that ";2833 this->inner_matcher_.DescribeTo(os);2834 }2835 2836 void DescribeNegationTo(::std::ostream* os) const override {2837 *os << "contains some element that ";2838 this->inner_matcher_.DescribeNegationTo(os);2839 }2840 2841 bool MatchAndExplain(Container container,2842 MatchResultListener* listener) const override {2843 return this->MatchAndExplainImpl(true, container, listener);2844 }2845};2846 2847// Implements Contains(element_matcher).Times(n) for the given argument type2848// Container.2849template <typename Container>2850class ContainsTimesMatcherImpl : public QuantifierMatcherImpl<Container> {2851 public:2852 template <typename InnerMatcher>2853 explicit ContainsTimesMatcherImpl(InnerMatcher inner_matcher,2854 Matcher<size_t> count_matcher)2855 : QuantifierMatcherImpl<Container>(inner_matcher),2856 count_matcher_(std::move(count_matcher)) {}2857 2858 void DescribeTo(::std::ostream* os) const override {2859 *os << "quantity of elements that match ";2860 this->inner_matcher_.DescribeTo(os);2861 *os << " ";2862 count_matcher_.DescribeTo(os);2863 }2864 2865 void DescribeNegationTo(::std::ostream* os) const override {2866 *os << "quantity of elements that match ";2867 this->inner_matcher_.DescribeTo(os);2868 *os << " ";2869 count_matcher_.DescribeNegationTo(os);2870 }2871 2872 bool MatchAndExplain(Container container,2873 MatchResultListener* listener) const override {2874 return this->MatchAndExplainImpl(count_matcher_, container, listener);2875 }2876 2877 private:2878 const Matcher<size_t> count_matcher_;2879};2880 2881// Implements polymorphic Contains(element_matcher).Times(n).2882template <typename M>2883class ContainsTimesMatcher {2884 public:2885 explicit ContainsTimesMatcher(M m, Matcher<size_t> count_matcher)2886 : inner_matcher_(m), count_matcher_(std::move(count_matcher)) {}2887 2888 template <typename Container>2889 operator Matcher<Container>() const { // NOLINT2890 return Matcher<Container>(new ContainsTimesMatcherImpl<const Container&>(2891 inner_matcher_, count_matcher_));2892 }2893 2894 private:2895 const M inner_matcher_;2896 const Matcher<size_t> count_matcher_;2897};2898 2899// Implements polymorphic Contains(element_matcher).2900template <typename M>2901class ContainsMatcher {2902 public:2903 explicit ContainsMatcher(M m) : inner_matcher_(m) {}2904 2905 template <typename Container>2906 operator Matcher<Container>() const { // NOLINT2907 return Matcher<Container>(2908 new ContainsMatcherImpl<const Container&>(inner_matcher_));2909 }2910 2911 ContainsTimesMatcher<M> Times(Matcher<size_t> count_matcher) const {2912 return ContainsTimesMatcher<M>(inner_matcher_, std::move(count_matcher));2913 }2914 2915 private:2916 const M inner_matcher_;2917};2918 2919// Implements polymorphic Each(element_matcher).2920template <typename M>2921class EachMatcher {2922 public:2923 explicit EachMatcher(M m) : inner_matcher_(m) {}2924 2925 template <typename Container>2926 operator Matcher<Container>() const { // NOLINT2927 return Matcher<Container>(2928 new EachMatcherImpl<const Container&>(inner_matcher_));2929 }2930 2931 private:2932 const M inner_matcher_;2933};2934 2935struct Rank1 {};2936struct Rank0 : Rank1 {};2937 2938namespace pair_getters {2939using std::get;2940template <typename T>2941auto First(T& x, Rank1) -> decltype(get<0>(x)) { // NOLINT2942 return get<0>(x);2943}2944template <typename T>2945auto First(T& x, Rank0) -> decltype((x.first)) { // NOLINT2946 return x.first;2947}2948 2949template <typename T>2950auto Second(T& x, Rank1) -> decltype(get<1>(x)) { // NOLINT2951 return get<1>(x);2952}2953template <typename T>2954auto Second(T& x, Rank0) -> decltype((x.second)) { // NOLINT2955 return x.second;2956}2957} // namespace pair_getters2958 2959// Implements Key(inner_matcher) for the given argument pair type.2960// Key(inner_matcher) matches an std::pair whose 'first' field matches2961// inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an2962// std::map that contains at least one element whose key is >= 5.2963template <typename PairType>2964class KeyMatcherImpl : public MatcherInterface<PairType> {2965 public:2966 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;2967 typedef typename RawPairType::first_type KeyType;2968 2969 template <typename InnerMatcher>2970 explicit KeyMatcherImpl(InnerMatcher inner_matcher)2971 : inner_matcher_(2972 testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {}2973 2974 // Returns true if and only if 'key_value.first' (the key) matches the inner2975 // matcher.2976 bool MatchAndExplain(PairType key_value,2977 MatchResultListener* listener) const override {2978 StringMatchResultListener inner_listener;2979 const bool match = inner_matcher_.MatchAndExplain(2980 pair_getters::First(key_value, Rank0()), &inner_listener);2981 const std::string explanation = inner_listener.str();2982 if (!explanation.empty()) {2983 *listener << "whose first field is a value " << explanation;2984 }2985 return match;2986 }2987 2988 // Describes what this matcher does.2989 void DescribeTo(::std::ostream* os) const override {2990 *os << "has a key that ";2991 inner_matcher_.DescribeTo(os);2992 }2993 2994 // Describes what the negation of this matcher does.2995 void DescribeNegationTo(::std::ostream* os) const override {2996 *os << "doesn't have a key that ";2997 inner_matcher_.DescribeTo(os);2998 }2999 3000 private:3001 const Matcher<const KeyType&> inner_matcher_;3002};3003 3004// Implements polymorphic Key(matcher_for_key).3005template <typename M>3006class KeyMatcher {3007 public:3008 explicit KeyMatcher(M m) : matcher_for_key_(m) {}3009 3010 template <typename PairType>3011 operator Matcher<PairType>() const {3012 return Matcher<PairType>(3013 new KeyMatcherImpl<const PairType&>(matcher_for_key_));3014 }3015 3016 private:3017 const M matcher_for_key_;3018};3019 3020// Implements polymorphic Address(matcher_for_address).3021template <typename InnerMatcher>3022class AddressMatcher {3023 public:3024 explicit AddressMatcher(InnerMatcher m) : matcher_(m) {}3025 3026 template <typename Type>3027 operator Matcher<Type>() const { // NOLINT3028 return Matcher<Type>(new Impl<const Type&>(matcher_));3029 }3030 3031 private:3032 // The monomorphic implementation that works for a particular object type.3033 template <typename Type>3034 class Impl : public MatcherInterface<Type> {3035 public:3036 using Address = const GTEST_REMOVE_REFERENCE_AND_CONST_(Type) *;3037 explicit Impl(const InnerMatcher& matcher)3038 : matcher_(MatcherCast<Address>(matcher)) {}3039 3040 void DescribeTo(::std::ostream* os) const override {3041 *os << "has address that ";3042 matcher_.DescribeTo(os);3043 }3044 3045 void DescribeNegationTo(::std::ostream* os) const override {3046 *os << "does not have address that ";3047 matcher_.DescribeTo(os);3048 }3049 3050 bool MatchAndExplain(Type object,3051 MatchResultListener* listener) const override {3052 *listener << "which has address ";3053 Address address = std::addressof(object);3054 return MatchPrintAndExplain(address, matcher_, listener);3055 }3056 3057 private:3058 const Matcher<Address> matcher_;3059 };3060 const InnerMatcher matcher_;3061};3062 3063// Implements Pair(first_matcher, second_matcher) for the given argument pair3064// type with its two matchers. See Pair() function below.3065template <typename PairType>3066class PairMatcherImpl : public MatcherInterface<PairType> {3067 public:3068 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;3069 typedef typename RawPairType::first_type FirstType;3070 typedef typename RawPairType::second_type SecondType;3071 3072 template <typename FirstMatcher, typename SecondMatcher>3073 PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)3074 : first_matcher_(3075 testing::SafeMatcherCast<const FirstType&>(first_matcher)),3076 second_matcher_(3077 testing::SafeMatcherCast<const SecondType&>(second_matcher)) {}3078 3079 // Describes what this matcher does.3080 void DescribeTo(::std::ostream* os) const override {3081 *os << "has a first field that ";3082 first_matcher_.DescribeTo(os);3083 *os << ", and has a second field that ";3084 second_matcher_.DescribeTo(os);3085 }3086 3087 // Describes what the negation of this matcher does.3088 void DescribeNegationTo(::std::ostream* os) const override {3089 *os << "has a first field that ";3090 first_matcher_.DescribeNegationTo(os);3091 *os << ", or has a second field that ";3092 second_matcher_.DescribeNegationTo(os);3093 }3094 3095 // Returns true if and only if 'a_pair.first' matches first_matcher and3096 // 'a_pair.second' matches second_matcher.3097 bool MatchAndExplain(PairType a_pair,3098 MatchResultListener* listener) const override {3099 if (!listener->IsInterested()) {3100 // If the listener is not interested, we don't need to construct the3101 // explanation.3102 return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) &&3103 second_matcher_.Matches(pair_getters::Second(a_pair, Rank0()));3104 }3105 StringMatchResultListener first_inner_listener;3106 if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()),3107 &first_inner_listener)) {3108 *listener << "whose first field does not match";3109 PrintIfNotEmpty(first_inner_listener.str(), listener->stream());3110 return false;3111 }3112 StringMatchResultListener second_inner_listener;3113 if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()),3114 &second_inner_listener)) {3115 *listener << "whose second field does not match";3116 PrintIfNotEmpty(second_inner_listener.str(), listener->stream());3117 return false;3118 }3119 ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),3120 listener);3121 return true;3122 }3123 3124 private:3125 void ExplainSuccess(const std::string& first_explanation,3126 const std::string& second_explanation,3127 MatchResultListener* listener) const {3128 *listener << "whose both fields match";3129 if (!first_explanation.empty()) {3130 *listener << ", where the first field is a value " << first_explanation;3131 }3132 if (!second_explanation.empty()) {3133 *listener << ", ";3134 if (!first_explanation.empty()) {3135 *listener << "and ";3136 } else {3137 *listener << "where ";3138 }3139 *listener << "the second field is a value " << second_explanation;3140 }3141 }3142 3143 const Matcher<const FirstType&> first_matcher_;3144 const Matcher<const SecondType&> second_matcher_;3145};3146 3147// Implements polymorphic Pair(first_matcher, second_matcher).3148template <typename FirstMatcher, typename SecondMatcher>3149class PairMatcher {3150 public:3151 PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)3152 : first_matcher_(first_matcher), second_matcher_(second_matcher) {}3153 3154 template <typename PairType>3155 operator Matcher<PairType>() const {3156 return Matcher<PairType>(3157 new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_));3158 }3159 3160 private:3161 const FirstMatcher first_matcher_;3162 const SecondMatcher second_matcher_;3163};3164 3165template <typename T, size_t... I>3166auto UnpackStructImpl(const T& t, IndexSequence<I...>, int)3167 -> decltype(std::tie(get<I>(t)...)) {3168 static_assert(std::tuple_size<T>::value == sizeof...(I),3169 "Number of arguments doesn't match the number of fields.");3170 return std::tie(get<I>(t)...);3171}3172 3173#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 2016063174template <typename T>3175auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) {3176 const auto& [a] = t;3177 return std::tie(a);3178}3179template <typename T>3180auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) {3181 const auto& [a, b] = t;3182 return std::tie(a, b);3183}3184template <typename T>3185auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) {3186 const auto& [a, b, c] = t;3187 return std::tie(a, b, c);3188}3189template <typename T>3190auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) {3191 const auto& [a, b, c, d] = t;3192 return std::tie(a, b, c, d);3193}3194template <typename T>3195auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) {3196 const auto& [a, b, c, d, e] = t;3197 return std::tie(a, b, c, d, e);3198}3199template <typename T>3200auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) {3201 const auto& [a, b, c, d, e, f] = t;3202 return std::tie(a, b, c, d, e, f);3203}3204template <typename T>3205auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) {3206 const auto& [a, b, c, d, e, f, g] = t;3207 return std::tie(a, b, c, d, e, f, g);3208}3209template <typename T>3210auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) {3211 const auto& [a, b, c, d, e, f, g, h] = t;3212 return std::tie(a, b, c, d, e, f, g, h);3213}3214template <typename T>3215auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) {3216 const auto& [a, b, c, d, e, f, g, h, i] = t;3217 return std::tie(a, b, c, d, e, f, g, h, i);3218}3219template <typename T>3220auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) {3221 const auto& [a, b, c, d, e, f, g, h, i, j] = t;3222 return std::tie(a, b, c, d, e, f, g, h, i, j);3223}3224template <typename T>3225auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) {3226 const auto& [a, b, c, d, e, f, g, h, i, j, k] = t;3227 return std::tie(a, b, c, d, e, f, g, h, i, j, k);3228}3229template <typename T>3230auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) {3231 const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t;3232 return std::tie(a, b, c, d, e, f, g, h, i, j, k, l);3233}3234template <typename T>3235auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) {3236 const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t;3237 return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m);3238}3239template <typename T>3240auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) {3241 const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t;3242 return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n);3243}3244template <typename T>3245auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) {3246 const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t;3247 return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);3248}3249template <typename T>3250auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) {3251 const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t;3252 return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);3253}3254template <typename T>3255auto UnpackStructImpl(const T& t, MakeIndexSequence<17>, char) {3256 const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] = t;3257 return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q);3258}3259template <typename T>3260auto UnpackStructImpl(const T& t, MakeIndexSequence<18>, char) {3261 const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r] = t;3262 return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r);3263}3264template <typename T>3265auto UnpackStructImpl(const T& t, MakeIndexSequence<19>, char) {3266 const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s] = t;3267 return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s);3268}3269#endif // defined(__cpp_structured_bindings)3270 3271template <size_t I, typename T>3272auto UnpackStruct(const T& t)3273 -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) {3274 return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0);3275}3276 3277// Helper function to do comma folding in C++11.3278// The array ensures left-to-right order of evaluation.3279// Usage: VariadicExpand({expr...});3280template <typename T, size_t N>3281void VariadicExpand(const T (&)[N]) {}3282 3283template <typename Struct, typename StructSize>3284class FieldsAreMatcherImpl;3285 3286template <typename Struct, size_t... I>3287class FieldsAreMatcherImpl<Struct, IndexSequence<I...>>3288 : public MatcherInterface<Struct> {3289 using UnpackedType =3290 decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>()));3291 using MatchersType = std::tuple<3292 Matcher<const typename std::tuple_element<I, UnpackedType>::type&>...>;3293 3294 public:3295 template <typename Inner>3296 explicit FieldsAreMatcherImpl(const Inner& matchers)3297 : matchers_(testing::SafeMatcherCast<3298 const typename std::tuple_element<I, UnpackedType>::type&>(3299 std::get<I>(matchers))...) {}3300 3301 void DescribeTo(::std::ostream* os) const override {3302 const char* separator = "";3303 VariadicExpand(3304 {(*os << separator << "has field #" << I << " that ",3305 std::get<I>(matchers_).DescribeTo(os), separator = ", and ")...});3306 }3307 3308 void DescribeNegationTo(::std::ostream* os) const override {3309 const char* separator = "";3310 VariadicExpand({(*os << separator << "has field #" << I << " that ",3311 std::get<I>(matchers_).DescribeNegationTo(os),3312 separator = ", or ")...});3313 }3314 3315 bool MatchAndExplain(Struct t, MatchResultListener* listener) const override {3316 return MatchInternal((UnpackStruct<sizeof...(I)>)(t), listener);3317 }3318 3319 private:3320 bool MatchInternal(UnpackedType tuple, MatchResultListener* listener) const {3321 if (!listener->IsInterested()) {3322 // If the listener is not interested, we don't need to construct the3323 // explanation.3324 bool good = true;3325 VariadicExpand({good = good && std::get<I>(matchers_).Matches(3326 std::get<I>(tuple))...});3327 return good;3328 }3329 3330 size_t failed_pos = ~size_t{};3331 3332 std::vector<StringMatchResultListener> inner_listener(sizeof...(I));3333 3334 VariadicExpand(3335 {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain(3336 std::get<I>(tuple), &inner_listener[I])3337 ? failed_pos = I3338 : 0 ...});3339 if (failed_pos != ~size_t{}) {3340 *listener << "whose field #" << failed_pos << " does not match";3341 PrintIfNotEmpty(inner_listener[failed_pos].str(), listener->stream());3342 return false;3343 }3344 3345 *listener << "whose all elements match";3346 const char* separator = ", where";3347 for (size_t index = 0; index < sizeof...(I); ++index) {3348 const std::string str = inner_listener[index].str();3349 if (!str.empty()) {3350 *listener << separator << " field #" << index << " is a value " << str;3351 separator = ", and";3352 }3353 }3354 3355 return true;3356 }3357 3358 MatchersType matchers_;3359};3360 3361template <typename... Inner>3362class FieldsAreMatcher {3363 public:3364 explicit FieldsAreMatcher(Inner... inner) : matchers_(std::move(inner)...) {}3365 3366 template <typename Struct>3367 operator Matcher<Struct>() const { // NOLINT3368 return Matcher<Struct>(3369 new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>(3370 matchers_));3371 }3372 3373 private:3374 std::tuple<Inner...> matchers_;3375};3376 3377// Implements ElementsAre() and ElementsAreArray().3378template <typename Container>3379class ElementsAreMatcherImpl : public MatcherInterface<Container> {3380 public:3381 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;3382 typedef internal::StlContainerView<RawContainer> View;3383 typedef typename View::type StlContainer;3384 typedef typename View::const_reference StlContainerReference;3385 3386 // LLVM local change to support std::begin/std::end.3387 //3388 // typedef typename StlContainer::value_type Element;3389 //3390 typedef decltype(std::begin(3391 std::declval<StlContainerReference>())) StlContainerConstIterator;3392 typedef typename std::remove_reference<3393 decltype(*std::declval<StlContainerConstIterator &>())>::type Element;3394 // LLVM local change end.3395 3396 // Constructs the matcher from a sequence of element values or3397 // element matchers.3398 template <typename InputIter>3399 ElementsAreMatcherImpl(InputIter first, InputIter last) {3400 while (first != last) {3401 matchers_.push_back(MatcherCast<const Element&>(*first++));3402 }3403 }3404 3405 // Describes what this matcher does.3406 void DescribeTo(::std::ostream* os) const override {3407 if (count() == 0) {3408 *os << "is empty";3409 } else if (count() == 1) {3410 *os << "has 1 element that ";3411 matchers_[0].DescribeTo(os);3412 } else {3413 *os << "has " << Elements(count()) << " where\n";3414 for (size_t i = 0; i != count(); ++i) {3415 *os << "element #" << i << " ";3416 matchers_[i].DescribeTo(os);3417 if (i + 1 < count()) {3418 *os << ",\n";3419 }3420 }3421 }3422 }3423 3424 // Describes what the negation of this matcher does.3425 void DescribeNegationTo(::std::ostream* os) const override {3426 if (count() == 0) {3427 *os << "isn't empty";3428 return;3429 }3430 3431 *os << "doesn't have " << Elements(count()) << ", or\n";3432 for (size_t i = 0; i != count(); ++i) {3433 *os << "element #" << i << " ";3434 matchers_[i].DescribeNegationTo(os);3435 if (i + 1 < count()) {3436 *os << ", or\n";3437 }3438 }3439 }3440 3441 bool MatchAndExplain(Container container,3442 MatchResultListener* listener) const override {3443 // To work with stream-like "containers", we must only walk3444 // through the elements in one pass.3445 3446 const bool listener_interested = listener->IsInterested();3447 3448 // explanations[i] is the explanation of the element at index i.3449 ::std::vector<std::string> explanations(count());3450 StlContainerReference stl_container = View::ConstReference(container);3451 // LLVM local change to support std::begin/std::end.3452 //3453 // auto it = stl_container.begin();3454 //3455 StlContainerConstIterator it = stl_container.begin();3456 // LLVM local change end.3457 size_t exam_pos = 0;3458 bool mismatch_found = false; // Have we found a mismatched element yet?3459 3460 // Go through the elements and matchers in pairs, until we reach3461 // the end of either the elements or the matchers, or until we find a3462 // mismatch.3463 for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {3464 bool match; // Does the current element match the current matcher?3465 if (listener_interested) {3466 StringMatchResultListener s;3467 match = matchers_[exam_pos].MatchAndExplain(*it, &s);3468 explanations[exam_pos] = s.str();3469 } else {3470 match = matchers_[exam_pos].Matches(*it);3471 }3472 3473 if (!match) {3474 mismatch_found = true;3475 break;3476 }3477 }3478 // If mismatch_found is true, 'exam_pos' is the index of the mismatch.3479 3480 // Find how many elements the actual container has. We avoid3481 // calling size() s.t. this code works for stream-like "containers"3482 // that don't define size().3483 size_t actual_count = exam_pos;3484 for (; it != stl_container.end(); ++it) {3485 ++actual_count;3486 }3487 3488 if (actual_count != count()) {3489 // The element count doesn't match. If the container is empty,3490 // there's no need to explain anything as Google Mock already3491 // prints the empty container. Otherwise we just need to show3492 // how many elements there actually are.3493 if (listener_interested && (actual_count != 0)) {3494 *listener << "which has " << Elements(actual_count);3495 }3496 return false;3497 }3498 3499 if (mismatch_found) {3500 // The element count matches, but the exam_pos-th element doesn't match.3501 if (listener_interested) {3502 *listener << "whose element #" << exam_pos << " doesn't match";3503 PrintIfNotEmpty(explanations[exam_pos], listener->stream());3504 }3505 return false;3506 }3507 3508 // Every element matches its expectation. We need to explain why3509 // (the obvious ones can be skipped).3510 if (listener_interested) {3511 bool reason_printed = false;3512 for (size_t i = 0; i != count(); ++i) {3513 const std::string& s = explanations[i];3514 if (!s.empty()) {3515 if (reason_printed) {3516 *listener << ",\nand ";3517 }3518 *listener << "whose element #" << i << " matches, " << s;3519 reason_printed = true;3520 }3521 }3522 }3523 return true;3524 }3525 3526 private:3527 static Message Elements(size_t count) {3528 return Message() << count << (count == 1 ? " element" : " elements");3529 }3530 3531 size_t count() const { return matchers_.size(); }3532 3533 ::std::vector<Matcher<const Element&>> matchers_;3534};3535 3536// Connectivity matrix of (elements X matchers), in element-major order.3537// Initially, there are no edges.3538// Use NextGraph() to iterate over all possible edge configurations.3539// Use Randomize() to generate a random edge configuration.3540class GTEST_API_ MatchMatrix {3541 public:3542 MatchMatrix(size_t num_elements, size_t num_matchers)3543 : num_elements_(num_elements),3544 num_matchers_(num_matchers),3545 matched_(num_elements_ * num_matchers_, 0) {}3546 3547 size_t LhsSize() const { return num_elements_; }3548 size_t RhsSize() const { return num_matchers_; }3549 bool HasEdge(size_t ilhs, size_t irhs) const {3550 return matched_[SpaceIndex(ilhs, irhs)] == 1;3551 }3552 void SetEdge(size_t ilhs, size_t irhs, bool b) {3553 matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;3554 }3555 3556 // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,3557 // adds 1 to that number; returns false if incrementing the graph left it3558 // empty.3559 bool NextGraph();3560 3561 void Randomize();3562 3563 std::string DebugString() const;3564 3565 private:3566 size_t SpaceIndex(size_t ilhs, size_t irhs) const {3567 return ilhs * num_matchers_ + irhs;3568 }3569 3570 size_t num_elements_;3571 size_t num_matchers_;3572 3573 // Each element is a char interpreted as bool. They are stored as a3574 // flattened array in lhs-major order, use 'SpaceIndex()' to translate3575 // a (ilhs, irhs) matrix coordinate into an offset.3576 ::std::vector<char> matched_;3577};3578 3579typedef ::std::pair<size_t, size_t> ElementMatcherPair;3580typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;3581 3582// Returns a maximum bipartite matching for the specified graph 'g'.3583// The matching is represented as a vector of {element, matcher} pairs.3584GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g);3585 3586struct UnorderedMatcherRequire {3587 enum Flags {3588 Superset = 1 << 0,3589 Subset = 1 << 1,3590 ExactMatch = Superset | Subset,3591 };3592};3593 3594// Untyped base class for implementing UnorderedElementsAre. By3595// putting logic that's not specific to the element type here, we3596// reduce binary bloat and increase compilation speed.3597class GTEST_API_ UnorderedElementsAreMatcherImplBase {3598 protected:3599 explicit UnorderedElementsAreMatcherImplBase(3600 UnorderedMatcherRequire::Flags matcher_flags)3601 : match_flags_(matcher_flags) {}3602 3603 // A vector of matcher describers, one for each element matcher.3604 // Does not own the describers (and thus can be used only when the3605 // element matchers are alive).3606 typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;3607 3608 // Describes this UnorderedElementsAre matcher.3609 void DescribeToImpl(::std::ostream* os) const;3610 3611 // Describes the negation of this UnorderedElementsAre matcher.3612 void DescribeNegationToImpl(::std::ostream* os) const;3613 3614 bool VerifyMatchMatrix(const ::std::vector<std::string>& element_printouts,3615 const MatchMatrix& matrix,3616 MatchResultListener* listener) const;3617 3618 bool FindPairing(const MatchMatrix& matrix,3619 MatchResultListener* listener) const;3620 3621 MatcherDescriberVec& matcher_describers() { return matcher_describers_; }3622 3623 static Message Elements(size_t n) {3624 return Message() << n << " element" << (n == 1 ? "" : "s");3625 }3626 3627 UnorderedMatcherRequire::Flags match_flags() const { return match_flags_; }3628 3629 private:3630 UnorderedMatcherRequire::Flags match_flags_;3631 MatcherDescriberVec matcher_describers_;3632};3633 3634// Implements UnorderedElementsAre, UnorderedElementsAreArray, IsSubsetOf, and3635// IsSupersetOf.3636template <typename Container>3637class UnorderedElementsAreMatcherImpl3638 : public MatcherInterface<Container>,3639 public UnorderedElementsAreMatcherImplBase {3640 public:3641 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;3642 typedef internal::StlContainerView<RawContainer> View;3643 typedef typename View::type StlContainer;3644 typedef typename View::const_reference StlContainerReference;3645 // LLVM local change to support std::begin/std::end.3646 //3647 // typedef typename StlContainer::value_type Element;3648 typedef decltype(std::begin(3649 std::declval<StlContainerReference>())) StlContainerConstIterator;3650 typedef typename std::remove_reference<3651 decltype(*std::declval<StlContainerConstIterator &>())>::type Element;3652 // LLVM local change end.3653 template <typename InputIter>3654 UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags,3655 InputIter first, InputIter last)3656 : UnorderedElementsAreMatcherImplBase(matcher_flags) {3657 for (; first != last; ++first) {3658 matchers_.push_back(MatcherCast<const Element&>(*first));3659 }3660 for (const auto& m : matchers_) {3661 matcher_describers().push_back(m.GetDescriber());3662 }3663 }3664 3665 // Describes what this matcher does.3666 void DescribeTo(::std::ostream* os) const override {3667 return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);3668 }3669 3670 // Describes what the negation of this matcher does.3671 void DescribeNegationTo(::std::ostream* os) const override {3672 return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);3673 }3674 3675 bool MatchAndExplain(Container container,3676 MatchResultListener* listener) const override {3677 StlContainerReference stl_container = View::ConstReference(container);3678 ::std::vector<std::string> element_printouts;3679 MatchMatrix matrix =3680 AnalyzeElements(stl_container.begin(), stl_container.end(),3681 &element_printouts, listener);3682 3683 return VerifyMatchMatrix(element_printouts, matrix, listener) &&3684 FindPairing(matrix, listener);3685 }3686 3687 private:3688 template <typename ElementIter>3689 MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,3690 ::std::vector<std::string>* element_printouts,3691 MatchResultListener* listener) const {3692 element_printouts->clear();3693 ::std::vector<char> did_match;3694 size_t num_elements = 0;3695 DummyMatchResultListener dummy;3696 for (; elem_first != elem_last; ++num_elements, ++elem_first) {3697 if (listener->IsInterested()) {3698 element_printouts->push_back(PrintToString(*elem_first));3699 }3700 for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {3701 did_match.push_back(3702 matchers_[irhs].MatchAndExplain(*elem_first, &dummy));3703 }3704 }3705 3706 MatchMatrix matrix(num_elements, matchers_.size());3707 ::std::vector<char>::const_iterator did_match_iter = did_match.begin();3708 for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) {3709 for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {3710 matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);3711 }3712 }3713 return matrix;3714 }3715 3716 ::std::vector<Matcher<const Element&>> matchers_;3717};3718 3719// Functor for use in TransformTuple.3720// Performs MatcherCast<Target> on an input argument of any type.3721template <typename Target>3722struct CastAndAppendTransform {3723 template <typename Arg>3724 Matcher<Target> operator()(const Arg& a) const {3725 return MatcherCast<Target>(a);3726 }3727};3728 3729// Implements UnorderedElementsAre.3730template <typename MatcherTuple>3731class UnorderedElementsAreMatcher {3732 public:3733 explicit UnorderedElementsAreMatcher(const MatcherTuple& args)3734 : matchers_(args) {}3735 3736 template <typename Container>3737 operator Matcher<Container>() const {3738 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;3739 // LLVM local change to support std::begin/std::end.3740 //3741 // typedef typename internal::StlContainerView<RawContainer>::type View;3742 // typedef typename View::value_type Element;3743 //3744 typedef internal::StlContainerView<RawContainer> View;3745 typedef typename View::const_reference StlContainerReference;3746 typedef decltype(std::begin(3747 std::declval<StlContainerReference>())) StlContainerConstIterator;3748 typedef typename std::remove_reference<3749 decltype(*std::declval<StlContainerConstIterator &>())>::type Element;3750 // LLVM local change end.3751 typedef ::std::vector<Matcher<const Element&>> MatcherVec;3752 MatcherVec matchers;3753 matchers.reserve(::std::tuple_size<MatcherTuple>::value);3754 TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,3755 ::std::back_inserter(matchers));3756 return Matcher<Container>(3757 new UnorderedElementsAreMatcherImpl<const Container&>(3758 UnorderedMatcherRequire::ExactMatch, matchers.begin(),3759 matchers.end()));3760 }3761 3762 private:3763 const MatcherTuple matchers_;3764};3765 3766// Implements ElementsAre.3767template <typename MatcherTuple>3768class ElementsAreMatcher {3769 public:3770 explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}3771 3772 template <typename Container>3773 operator Matcher<Container>() const {3774 static_assert(3775 !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||3776 ::std::tuple_size<MatcherTuple>::value < 2,3777 "use UnorderedElementsAre with hash tables");3778 3779 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;3780 // LLVM local change to support std::begin/std::end.3781 //3782 // typedef typename internal::StlContainerView<RawContainer>::type View;3783 // typedef typename View::value_type Element;3784 //3785 typedef internal::StlContainerView<RawContainer> View;3786 typedef typename View::const_reference StlContainerReference;3787 typedef decltype(std::begin(3788 std::declval<StlContainerReference>())) StlContainerConstIterator;3789 typedef typename std::remove_reference<3790 decltype(*std::declval<StlContainerConstIterator &>())>::type Element;3791 // LLVM local change end.3792 typedef ::std::vector<Matcher<const Element&>> MatcherVec;3793 MatcherVec matchers;3794 matchers.reserve(::std::tuple_size<MatcherTuple>::value);3795 TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,3796 ::std::back_inserter(matchers));3797 return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(3798 matchers.begin(), matchers.end()));3799 }3800 3801 private:3802 const MatcherTuple matchers_;3803};3804 3805// Implements UnorderedElementsAreArray(), IsSubsetOf(), and IsSupersetOf().3806template <typename T>3807class UnorderedElementsAreArrayMatcher {3808 public:3809 template <typename Iter>3810 UnorderedElementsAreArrayMatcher(UnorderedMatcherRequire::Flags match_flags,3811 Iter first, Iter last)3812 : match_flags_(match_flags), matchers_(first, last) {}3813 3814 template <typename Container>3815 operator Matcher<Container>() const {3816 return Matcher<Container>(3817 new UnorderedElementsAreMatcherImpl<const Container&>(3818 match_flags_, matchers_.begin(), matchers_.end()));3819 }3820 3821 private:3822 UnorderedMatcherRequire::Flags match_flags_;3823 ::std::vector<T> matchers_;3824};3825 3826// Implements ElementsAreArray().3827template <typename T>3828class ElementsAreArrayMatcher {3829 public:3830 template <typename Iter>3831 ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}3832 3833 template <typename Container>3834 operator Matcher<Container>() const {3835 static_assert(3836 !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value,3837 "use UnorderedElementsAreArray with hash tables");3838 3839 return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(3840 matchers_.begin(), matchers_.end()));3841 }3842 3843 private:3844 const ::std::vector<T> matchers_;3845};3846 3847// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second3848// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,3849// second) is a polymorphic matcher that matches a value x if and only if3850// tm matches tuple (x, second). Useful for implementing3851// UnorderedPointwise() in terms of UnorderedElementsAreArray().3852//3853// BoundSecondMatcher is copyable and assignable, as we need to put3854// instances of this class in a vector when implementing3855// UnorderedPointwise().3856template <typename Tuple2Matcher, typename Second>3857class BoundSecondMatcher {3858 public:3859 BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)3860 : tuple2_matcher_(tm), second_value_(second) {}3861 3862 BoundSecondMatcher(const BoundSecondMatcher& other) = default;3863 3864 template <typename T>3865 operator Matcher<T>() const {3866 return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));3867 }3868 3869 // We have to define this for UnorderedPointwise() to compile in3870 // C++98 mode, as it puts BoundSecondMatcher instances in a vector,3871 // which requires the elements to be assignable in C++98. The3872 // compiler cannot generate the operator= for us, as Tuple2Matcher3873 // and Second may not be assignable.3874 //3875 // However, this should never be called, so the implementation just3876 // need to assert.3877 void operator=(const BoundSecondMatcher& /*rhs*/) {3878 GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";3879 }3880 3881 private:3882 template <typename T>3883 class Impl : public MatcherInterface<T> {3884 public:3885 typedef ::std::tuple<T, Second> ArgTuple;3886 3887 Impl(const Tuple2Matcher& tm, const Second& second)3888 : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),3889 second_value_(second) {}3890 3891 void DescribeTo(::std::ostream* os) const override {3892 *os << "and ";3893 UniversalPrint(second_value_, os);3894 *os << " ";3895 mono_tuple2_matcher_.DescribeTo(os);3896 }3897 3898 bool MatchAndExplain(T x, MatchResultListener* listener) const override {3899 return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),3900 listener);3901 }3902 3903 private:3904 const Matcher<const ArgTuple&> mono_tuple2_matcher_;3905 const Second second_value_;3906 };3907 3908 const Tuple2Matcher tuple2_matcher_;3909 const Second second_value_;3910};3911 3912// Given a 2-tuple matcher tm and a value second,3913// MatcherBindSecond(tm, second) returns a matcher that matches a3914// value x if and only if tm matches tuple (x, second). Useful for3915// implementing UnorderedPointwise() in terms of UnorderedElementsAreArray().3916template <typename Tuple2Matcher, typename Second>3917BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(3918 const Tuple2Matcher& tm, const Second& second) {3919 return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);3920}3921 3922// Returns the description for a matcher defined using the MATCHER*()3923// macro where the user-supplied description string is "", if3924// 'negation' is false; otherwise returns the description of the3925// negation of the matcher. 'param_values' contains a list of strings3926// that are the print-out of the matcher's parameters.3927GTEST_API_ std::string FormatMatcherDescription(3928 bool negation, const char* matcher_name,3929 const std::vector<const char*>& param_names, const Strings& param_values);3930 3931// Implements a matcher that checks the value of a optional<> type variable.3932template <typename ValueMatcher>3933class OptionalMatcher {3934 public:3935 explicit OptionalMatcher(const ValueMatcher& value_matcher)3936 : value_matcher_(value_matcher) {}3937 3938 template <typename Optional>3939 operator Matcher<Optional>() const {3940 return Matcher<Optional>(new Impl<const Optional&>(value_matcher_));3941 }3942 3943 template <typename Optional>3944 class Impl : public MatcherInterface<Optional> {3945 public:3946 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Optional) OptionalView;3947 typedef typename OptionalView::value_type ValueType;3948 explicit Impl(const ValueMatcher& value_matcher)3949 : value_matcher_(MatcherCast<ValueType>(value_matcher)) {}3950 3951 void DescribeTo(::std::ostream* os) const override {3952 *os << "value ";3953 value_matcher_.DescribeTo(os);3954 }3955 3956 void DescribeNegationTo(::std::ostream* os) const override {3957 *os << "value ";3958 value_matcher_.DescribeNegationTo(os);3959 }3960 3961 bool MatchAndExplain(Optional optional,3962 MatchResultListener* listener) const override {3963 if (!optional) {3964 *listener << "which is not engaged";3965 return false;3966 }3967 const ValueType& value = *optional;3968 StringMatchResultListener value_listener;3969 const bool match = value_matcher_.MatchAndExplain(value, &value_listener);3970 *listener << "whose value " << PrintToString(value)3971 << (match ? " matches" : " doesn't match");3972 PrintIfNotEmpty(value_listener.str(), listener->stream());3973 return match;3974 }3975 3976 private:3977 const Matcher<ValueType> value_matcher_;3978 };3979 3980 private:3981 const ValueMatcher value_matcher_;3982};3983 3984namespace variant_matcher {3985// Overloads to allow VariantMatcher to do proper ADL lookup.3986template <typename T>3987void holds_alternative() {}3988template <typename T>3989void get() {}3990 3991// Implements a matcher that checks the value of a variant<> type variable.3992template <typename T>3993class VariantMatcher {3994 public:3995 explicit VariantMatcher(::testing::Matcher<const T&> matcher)3996 : matcher_(std::move(matcher)) {}3997 3998 template <typename Variant>3999 bool MatchAndExplain(const Variant& value,4000 ::testing::MatchResultListener* listener) const {4001 using std::get;4002 if (!listener->IsInterested()) {4003 return holds_alternative<T>(value) && matcher_.Matches(get<T>(value));4004 }4005 4006 if (!holds_alternative<T>(value)) {4007 *listener << "whose value is not of type '" << GetTypeName() << "'";4008 return false;4009 }4010 4011 const T& elem = get<T>(value);4012 StringMatchResultListener elem_listener;4013 const bool match = matcher_.MatchAndExplain(elem, &elem_listener);4014 *listener << "whose value " << PrintToString(elem)4015 << (match ? " matches" : " doesn't match");4016 PrintIfNotEmpty(elem_listener.str(), listener->stream());4017 return match;4018 }4019 4020 void DescribeTo(std::ostream* os) const {4021 *os << "is a variant<> with value of type '" << GetTypeName()4022 << "' and the value ";4023 matcher_.DescribeTo(os);4024 }4025 4026 void DescribeNegationTo(std::ostream* os) const {4027 *os << "is a variant<> with value of type other than '" << GetTypeName()4028 << "' or the value ";4029 matcher_.DescribeNegationTo(os);4030 }4031 4032 private:4033 static std::string GetTypeName() {4034#if GTEST_HAS_RTTI4035 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(4036 return internal::GetTypeName<T>());4037#endif4038 return "the element type";4039 }4040 4041 const ::testing::Matcher<const T&> matcher_;4042};4043 4044} // namespace variant_matcher4045 4046namespace any_cast_matcher {4047 4048// Overloads to allow AnyCastMatcher to do proper ADL lookup.4049template <typename T>4050void any_cast() {}4051 4052// Implements a matcher that any_casts the value.4053template <typename T>4054class AnyCastMatcher {4055 public:4056 explicit AnyCastMatcher(const ::testing::Matcher<const T&>& matcher)4057 : matcher_(matcher) {}4058 4059 template <typename AnyType>4060 bool MatchAndExplain(const AnyType& value,4061 ::testing::MatchResultListener* listener) const {4062 if (!listener->IsInterested()) {4063 const T* ptr = any_cast<T>(&value);4064 return ptr != nullptr && matcher_.Matches(*ptr);4065 }4066 4067 const T* elem = any_cast<T>(&value);4068 if (elem == nullptr) {4069 *listener << "whose value is not of type '" << GetTypeName() << "'";4070 return false;4071 }4072 4073 StringMatchResultListener elem_listener;4074 const bool match = matcher_.MatchAndExplain(*elem, &elem_listener);4075 *listener << "whose value " << PrintToString(*elem)4076 << (match ? " matches" : " doesn't match");4077 PrintIfNotEmpty(elem_listener.str(), listener->stream());4078 return match;4079 }4080 4081 void DescribeTo(std::ostream* os) const {4082 *os << "is an 'any' type with value of type '" << GetTypeName()4083 << "' and the value ";4084 matcher_.DescribeTo(os);4085 }4086 4087 void DescribeNegationTo(std::ostream* os) const {4088 *os << "is an 'any' type with value of type other than '" << GetTypeName()4089 << "' or the value ";4090 matcher_.DescribeNegationTo(os);4091 }4092 4093 private:4094 static std::string GetTypeName() {4095#if GTEST_HAS_RTTI4096 GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(4097 return internal::GetTypeName<T>());4098#endif4099 return "the element type";4100 }4101 4102 const ::testing::Matcher<const T&> matcher_;4103};4104 4105} // namespace any_cast_matcher4106 4107// Implements the Args() matcher.4108template <class ArgsTuple, size_t... k>4109class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {4110 public:4111 using RawArgsTuple = typename std::decay<ArgsTuple>::type;4112 using SelectedArgs =4113 std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>;4114 using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>;4115 4116 template <typename InnerMatcher>4117 explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)4118 : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}4119 4120 bool MatchAndExplain(ArgsTuple args,4121 MatchResultListener* listener) const override {4122 // Workaround spurious C4100 on MSVC<=15.7 when k is empty.4123 (void)args;4124 const SelectedArgs& selected_args =4125 std::forward_as_tuple(std::get<k>(args)...);4126 if (!listener->IsInterested()) return inner_matcher_.Matches(selected_args);4127 4128 PrintIndices(listener->stream());4129 *listener << "are " << PrintToString(selected_args);4130 4131 StringMatchResultListener inner_listener;4132 const bool match =4133 inner_matcher_.MatchAndExplain(selected_args, &inner_listener);4134 PrintIfNotEmpty(inner_listener.str(), listener->stream());4135 return match;4136 }4137 4138 void DescribeTo(::std::ostream* os) const override {4139 *os << "are a tuple ";4140 PrintIndices(os);4141 inner_matcher_.DescribeTo(os);4142 }4143 4144 void DescribeNegationTo(::std::ostream* os) const override {4145 *os << "are a tuple ";4146 PrintIndices(os);4147 inner_matcher_.DescribeNegationTo(os);4148 }4149 4150 private:4151 // Prints the indices of the selected fields.4152 static void PrintIndices(::std::ostream* os) {4153 *os << "whose fields (";4154 const char* sep = "";4155 // Workaround spurious C4189 on MSVC<=15.7 when k is empty.4156 (void)sep;4157 // The static_cast to void is needed to silence Clang's -Wcomma warning.4158 // This pattern looks suspiciously like we may have mismatched parentheses4159 // and may have been trying to use the first operation of the comma operator4160 // as a member of the array, so Clang warns that we may have made a mistake.4161 const char* dummy[] = {4162 "", (static_cast<void>(*os << sep << "#" << k), sep = ", ")...};4163 (void)dummy;4164 *os << ") ";4165 }4166 4167 MonomorphicInnerMatcher inner_matcher_;4168};4169 4170template <class InnerMatcher, size_t... k>4171class ArgsMatcher {4172 public:4173 explicit ArgsMatcher(InnerMatcher inner_matcher)4174 : inner_matcher_(std::move(inner_matcher)) {}4175 4176 template <typename ArgsTuple>4177 operator Matcher<ArgsTuple>() const { // NOLINT4178 return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k...>(inner_matcher_));4179 }4180 4181 private:4182 InnerMatcher inner_matcher_;4183};4184 4185} // namespace internal4186 4187// ElementsAreArray(iterator_first, iterator_last)4188// ElementsAreArray(pointer, count)4189// ElementsAreArray(array)4190// ElementsAreArray(container)4191// ElementsAreArray({ e1, e2, ..., en })4192//4193// The ElementsAreArray() functions are like ElementsAre(...), except4194// that they are given a homogeneous sequence rather than taking each4195// element as a function argument. The sequence can be specified as an4196// array, a pointer and count, a vector, an initializer list, or an4197// STL iterator range. In each of these cases, the underlying sequence4198// can be either a sequence of values or a sequence of matchers.4199//4200// All forms of ElementsAreArray() make a copy of the input matcher sequence.4201 4202template <typename Iter>4203inline internal::ElementsAreArrayMatcher<4204 typename ::std::iterator_traits<Iter>::value_type>4205ElementsAreArray(Iter first, Iter last) {4206 typedef typename ::std::iterator_traits<Iter>::value_type T;4207 return internal::ElementsAreArrayMatcher<T>(first, last);4208}4209 4210template <typename T>4211inline auto ElementsAreArray(const T* pointer, size_t count)4212 -> decltype(ElementsAreArray(pointer, pointer + count)) {4213 return ElementsAreArray(pointer, pointer + count);4214}4215 4216template <typename T, size_t N>4217inline auto ElementsAreArray(const T (&array)[N])4218 -> decltype(ElementsAreArray(array, N)) {4219 return ElementsAreArray(array, N);4220}4221 4222template <typename Container>4223inline auto ElementsAreArray(const Container& container)4224 -> decltype(ElementsAreArray(container.begin(), container.end())) {4225 return ElementsAreArray(container.begin(), container.end());4226}4227 4228template <typename T>4229inline auto ElementsAreArray(::std::initializer_list<T> xs)4230 -> decltype(ElementsAreArray(xs.begin(), xs.end())) {4231 return ElementsAreArray(xs.begin(), xs.end());4232}4233 4234// UnorderedElementsAreArray(iterator_first, iterator_last)4235// UnorderedElementsAreArray(pointer, count)4236// UnorderedElementsAreArray(array)4237// UnorderedElementsAreArray(container)4238// UnorderedElementsAreArray({ e1, e2, ..., en })4239//4240// UnorderedElementsAreArray() verifies that a bijective mapping onto a4241// collection of matchers exists.4242//4243// The matchers can be specified as an array, a pointer and count, a container,4244// an initializer list, or an STL iterator range. In each of these cases, the4245// underlying matchers can be either values or matchers.4246 4247template <typename Iter>4248inline internal::UnorderedElementsAreArrayMatcher<4249 typename ::std::iterator_traits<Iter>::value_type>4250UnorderedElementsAreArray(Iter first, Iter last) {4251 typedef typename ::std::iterator_traits<Iter>::value_type T;4252 return internal::UnorderedElementsAreArrayMatcher<T>(4253 internal::UnorderedMatcherRequire::ExactMatch, first, last);4254}4255 4256template <typename T>4257inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray(4258 const T* pointer, size_t count) {4259 return UnorderedElementsAreArray(pointer, pointer + count);4260}4261 4262template <typename T, size_t N>4263inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray(4264 const T (&array)[N]) {4265 return UnorderedElementsAreArray(array, N);4266}4267 4268template <typename Container>4269inline internal::UnorderedElementsAreArrayMatcher<4270 typename Container::value_type>4271UnorderedElementsAreArray(const Container& container) {4272 return UnorderedElementsAreArray(container.begin(), container.end());4273}4274 4275template <typename T>4276inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray(4277 ::std::initializer_list<T> xs) {4278 return UnorderedElementsAreArray(xs.begin(), xs.end());4279}4280 4281// _ is a matcher that matches anything of any type.4282//4283// This definition is fine as:4284//4285// 1. The C++ standard permits using the name _ in a namespace that4286// is not the global namespace or ::std.4287// 2. The AnythingMatcher class has no data member or constructor,4288// so it's OK to create global variables of this type.4289// 3. c-style has approved of using _ in this case.4290const internal::AnythingMatcher _ = {};4291// Creates a matcher that matches any value of the given type T.4292template <typename T>4293inline Matcher<T> A() {4294 return _;4295}4296 4297// Creates a matcher that matches any value of the given type T.4298template <typename T>4299inline Matcher<T> An() {4300 return _;4301}4302 4303template <typename T, typename M>4304Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl(4305 const M& value, std::false_type /* convertible_to_matcher */,4306 std::false_type /* convertible_to_T */) {4307 return Eq(value);4308}4309 4310// Creates a polymorphic matcher that matches any NULL pointer.4311inline PolymorphicMatcher<internal::IsNullMatcher> IsNull() {4312 return MakePolymorphicMatcher(internal::IsNullMatcher());4313}4314 4315// Creates a polymorphic matcher that matches any non-NULL pointer.4316// This is convenient as Not(NULL) doesn't compile (the compiler4317// thinks that that expression is comparing a pointer with an integer).4318inline PolymorphicMatcher<internal::NotNullMatcher> NotNull() {4319 return MakePolymorphicMatcher(internal::NotNullMatcher());4320}4321 4322// Creates a polymorphic matcher that matches any argument that4323// references variable x.4324template <typename T>4325inline internal::RefMatcher<T&> Ref(T& x) { // NOLINT4326 return internal::RefMatcher<T&>(x);4327}4328 4329// Creates a polymorphic matcher that matches any NaN floating point.4330inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() {4331 return MakePolymorphicMatcher(internal::IsNanMatcher());4332}4333 4334// Creates a matcher that matches any double argument approximately4335// equal to rhs, where two NANs are considered unequal.4336inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {4337 return internal::FloatingEqMatcher<double>(rhs, false);4338}4339 4340// Creates a matcher that matches any double argument approximately4341// equal to rhs, including NaN values when rhs is NaN.4342inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {4343 return internal::FloatingEqMatcher<double>(rhs, true);4344}4345 4346// Creates a matcher that matches any double argument approximately equal to4347// rhs, up to the specified max absolute error bound, where two NANs are4348// considered unequal. The max absolute error bound must be non-negative.4349inline internal::FloatingEqMatcher<double> DoubleNear(double rhs,4350 double max_abs_error) {4351 return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);4352}4353 4354// Creates a matcher that matches any double argument approximately equal to4355// rhs, up to the specified max absolute error bound, including NaN values when4356// rhs is NaN. The max absolute error bound must be non-negative.4357inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(4358 double rhs, double max_abs_error) {4359 return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);4360}4361 4362// Creates a matcher that matches any float argument approximately4363// equal to rhs, where two NANs are considered unequal.4364inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {4365 return internal::FloatingEqMatcher<float>(rhs, false);4366}4367 4368// Creates a matcher that matches any float argument approximately4369// equal to rhs, including NaN values when rhs is NaN.4370inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {4371 return internal::FloatingEqMatcher<float>(rhs, true);4372}4373 4374// Creates a matcher that matches any float argument approximately equal to4375// rhs, up to the specified max absolute error bound, where two NANs are4376// considered unequal. The max absolute error bound must be non-negative.4377inline internal::FloatingEqMatcher<float> FloatNear(float rhs,4378 float max_abs_error) {4379 return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);4380}4381 4382// Creates a matcher that matches any float argument approximately equal to4383// rhs, up to the specified max absolute error bound, including NaN values when4384// rhs is NaN. The max absolute error bound must be non-negative.4385inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(4386 float rhs, float max_abs_error) {4387 return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);4388}4389 4390// Creates a matcher that matches a pointer (raw or smart) that points4391// to a value that matches inner_matcher.4392template <typename InnerMatcher>4393inline internal::PointeeMatcher<InnerMatcher> Pointee(4394 const InnerMatcher& inner_matcher) {4395 return internal::PointeeMatcher<InnerMatcher>(inner_matcher);4396}4397 4398#if GTEST_HAS_RTTI4399// Creates a matcher that matches a pointer or reference that matches4400// inner_matcher when dynamic_cast<To> is applied.4401// The result of dynamic_cast<To> is forwarded to the inner matcher.4402// If To is a pointer and the cast fails, the inner matcher will receive NULL.4403// If To is a reference and the cast fails, this matcher returns false4404// immediately.4405template <typename To>4406inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To>>4407WhenDynamicCastTo(const Matcher<To>& inner_matcher) {4408 return MakePolymorphicMatcher(4409 internal::WhenDynamicCastToMatcher<To>(inner_matcher));4410}4411#endif // GTEST_HAS_RTTI4412 4413// Creates a matcher that matches an object whose given field matches4414// 'matcher'. For example,4415// Field(&Foo::number, Ge(5))4416// matches a Foo object x if and only if x.number >= 5.4417template <typename Class, typename FieldType, typename FieldMatcher>4418inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType>> Field(4419 FieldType Class::*field, const FieldMatcher& matcher) {4420 return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(4421 field, MatcherCast<const FieldType&>(matcher)));4422 // The call to MatcherCast() is required for supporting inner4423 // matchers of compatible types. For example, it allows4424 // Field(&Foo::bar, m)4425 // to compile where bar is an int32 and m is a matcher for int64.4426}4427 4428// Same as Field() but also takes the name of the field to provide better error4429// messages.4430template <typename Class, typename FieldType, typename FieldMatcher>4431inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType>> Field(4432 const std::string& field_name, FieldType Class::*field,4433 const FieldMatcher& matcher) {4434 return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(4435 field_name, field, MatcherCast<const FieldType&>(matcher)));4436}4437 4438// Creates a matcher that matches an object whose given property4439// matches 'matcher'. For example,4440// Property(&Foo::str, StartsWith("hi"))4441// matches a Foo object x if and only if x.str() starts with "hi".4442template <typename Class, typename PropertyType, typename PropertyMatcher>4443inline PolymorphicMatcher<internal::PropertyMatcher<4444 Class, PropertyType, PropertyType (Class::*)() const>>4445Property(PropertyType (Class::*property)() const,4446 const PropertyMatcher& matcher) {4447 return MakePolymorphicMatcher(4448 internal::PropertyMatcher<Class, PropertyType,4449 PropertyType (Class::*)() const>(4450 property, MatcherCast<const PropertyType&>(matcher)));4451 // The call to MatcherCast() is required for supporting inner4452 // matchers of compatible types. For example, it allows4453 // Property(&Foo::bar, m)4454 // to compile where bar() returns an int32 and m is a matcher for int64.4455}4456 4457// Same as Property() above, but also takes the name of the property to provide4458// better error messages.4459template <typename Class, typename PropertyType, typename PropertyMatcher>4460inline PolymorphicMatcher<internal::PropertyMatcher<4461 Class, PropertyType, PropertyType (Class::*)() const>>4462Property(const std::string& property_name,4463 PropertyType (Class::*property)() const,4464 const PropertyMatcher& matcher) {4465 return MakePolymorphicMatcher(4466 internal::PropertyMatcher<Class, PropertyType,4467 PropertyType (Class::*)() const>(4468 property_name, property, MatcherCast<const PropertyType&>(matcher)));4469}4470 4471// The same as above but for reference-qualified member functions.4472template <typename Class, typename PropertyType, typename PropertyMatcher>4473inline PolymorphicMatcher<internal::PropertyMatcher<4474 Class, PropertyType, PropertyType (Class::*)() const&>>4475Property(PropertyType (Class::*property)() const&,4476 const PropertyMatcher& matcher) {4477 return MakePolymorphicMatcher(4478 internal::PropertyMatcher<Class, PropertyType,4479 PropertyType (Class::*)() const&>(4480 property, MatcherCast<const PropertyType&>(matcher)));4481}4482 4483// Three-argument form for reference-qualified member functions.4484template <typename Class, typename PropertyType, typename PropertyMatcher>4485inline PolymorphicMatcher<internal::PropertyMatcher<4486 Class, PropertyType, PropertyType (Class::*)() const&>>4487Property(const std::string& property_name,4488 PropertyType (Class::*property)() const&,4489 const PropertyMatcher& matcher) {4490 return MakePolymorphicMatcher(4491 internal::PropertyMatcher<Class, PropertyType,4492 PropertyType (Class::*)() const&>(4493 property_name, property, MatcherCast<const PropertyType&>(matcher)));4494}4495 4496// Creates a matcher that matches an object if and only if the result of4497// applying a callable to x matches 'matcher'. For example,4498// ResultOf(f, StartsWith("hi"))4499// matches a Foo object x if and only if f(x) starts with "hi".4500// `callable` parameter can be a function, function pointer, or a functor. It is4501// required to keep no state affecting the results of the calls on it and make4502// no assumptions about how many calls will be made. Any state it keeps must be4503// protected from the concurrent access.4504template <typename Callable, typename InnerMatcher>4505internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(4506 Callable callable, InnerMatcher matcher) {4507 return internal::ResultOfMatcher<Callable, InnerMatcher>(std::move(callable),4508 std::move(matcher));4509}4510 4511// Same as ResultOf() above, but also takes a description of the `callable`4512// result to provide better error messages.4513template <typename Callable, typename InnerMatcher>4514internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(4515 const std::string& result_description, Callable callable,4516 InnerMatcher matcher) {4517 return internal::ResultOfMatcher<Callable, InnerMatcher>(4518 result_description, std::move(callable), std::move(matcher));4519}4520 4521// String matchers.4522 4523// Matches a string equal to str.4524template <typename T = std::string>4525PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrEq(4526 const internal::StringLike<T>& str) {4527 return MakePolymorphicMatcher(4528 internal::StrEqualityMatcher<std::string>(std::string(str), true, true));4529}4530 4531// Matches a string not equal to str.4532template <typename T = std::string>4533PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrNe(4534 const internal::StringLike<T>& str) {4535 return MakePolymorphicMatcher(4536 internal::StrEqualityMatcher<std::string>(std::string(str), false, true));4537}4538 4539// Matches a string equal to str, ignoring case.4540template <typename T = std::string>4541PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseEq(4542 const internal::StringLike<T>& str) {4543 return MakePolymorphicMatcher(4544 internal::StrEqualityMatcher<std::string>(std::string(str), true, false));4545}4546 4547// Matches a string not equal to str, ignoring case.4548template <typename T = std::string>4549PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseNe(4550 const internal::StringLike<T>& str) {4551 return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>(4552 std::string(str), false, false));4553}4554 4555// Creates a matcher that matches any string, std::string, or C string4556// that contains the given substring.4557template <typename T = std::string>4558PolymorphicMatcher<internal::HasSubstrMatcher<std::string>> HasSubstr(4559 const internal::StringLike<T>& substring) {4560 return MakePolymorphicMatcher(4561 internal::HasSubstrMatcher<std::string>(std::string(substring)));4562}4563 4564// Matches a string that starts with 'prefix' (case-sensitive).4565template <typename T = std::string>4566PolymorphicMatcher<internal::StartsWithMatcher<std::string>> StartsWith(4567 const internal::StringLike<T>& prefix) {4568 return MakePolymorphicMatcher(4569 internal::StartsWithMatcher<std::string>(std::string(prefix)));4570}4571 4572// Matches a string that ends with 'suffix' (case-sensitive).4573template <typename T = std::string>4574PolymorphicMatcher<internal::EndsWithMatcher<std::string>> EndsWith(4575 const internal::StringLike<T>& suffix) {4576 return MakePolymorphicMatcher(4577 internal::EndsWithMatcher<std::string>(std::string(suffix)));4578}4579 4580#if GTEST_HAS_STD_WSTRING4581// Wide string matchers.4582 4583// Matches a string equal to str.4584inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrEq(4585 const std::wstring& str) {4586 return MakePolymorphicMatcher(4587 internal::StrEqualityMatcher<std::wstring>(str, true, true));4588}4589 4590// Matches a string not equal to str.4591inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrNe(4592 const std::wstring& str) {4593 return MakePolymorphicMatcher(4594 internal::StrEqualityMatcher<std::wstring>(str, false, true));4595}4596 4597// Matches a string equal to str, ignoring case.4598inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseEq(4599 const std::wstring& str) {4600 return MakePolymorphicMatcher(4601 internal::StrEqualityMatcher<std::wstring>(str, true, false));4602}4603 4604// Matches a string not equal to str, ignoring case.4605inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseNe(4606 const std::wstring& str) {4607 return MakePolymorphicMatcher(4608 internal::StrEqualityMatcher<std::wstring>(str, false, false));4609}4610 4611// Creates a matcher that matches any ::wstring, std::wstring, or C wide string4612// that contains the given substring.4613inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring>> HasSubstr(4614 const std::wstring& substring) {4615 return MakePolymorphicMatcher(4616 internal::HasSubstrMatcher<std::wstring>(substring));4617}4618 4619// Matches a string that starts with 'prefix' (case-sensitive).4620inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring>> StartsWith(4621 const std::wstring& prefix) {4622 return MakePolymorphicMatcher(4623 internal::StartsWithMatcher<std::wstring>(prefix));4624}4625 4626// Matches a string that ends with 'suffix' (case-sensitive).4627inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring>> EndsWith(4628 const std::wstring& suffix) {4629 return MakePolymorphicMatcher(4630 internal::EndsWithMatcher<std::wstring>(suffix));4631}4632 4633#endif // GTEST_HAS_STD_WSTRING4634 4635// Creates a polymorphic matcher that matches a 2-tuple where the4636// first field == the second field.4637inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }4638 4639// Creates a polymorphic matcher that matches a 2-tuple where the4640// first field >= the second field.4641inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }4642 4643// Creates a polymorphic matcher that matches a 2-tuple where the4644// first field > the second field.4645inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }4646 4647// Creates a polymorphic matcher that matches a 2-tuple where the4648// first field <= the second field.4649inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }4650 4651// Creates a polymorphic matcher that matches a 2-tuple where the4652// first field < the second field.4653inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }4654 4655// Creates a polymorphic matcher that matches a 2-tuple where the4656// first field != the second field.4657inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }4658 4659// Creates a polymorphic matcher that matches a 2-tuple where4660// FloatEq(first field) matches the second field.4661inline internal::FloatingEq2Matcher<float> FloatEq() {4662 return internal::FloatingEq2Matcher<float>();4663}4664 4665// Creates a polymorphic matcher that matches a 2-tuple where4666// DoubleEq(first field) matches the second field.4667inline internal::FloatingEq2Matcher<double> DoubleEq() {4668 return internal::FloatingEq2Matcher<double>();4669}4670 4671// Creates a polymorphic matcher that matches a 2-tuple where4672// FloatEq(first field) matches the second field with NaN equality.4673inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() {4674 return internal::FloatingEq2Matcher<float>(true);4675}4676 4677// Creates a polymorphic matcher that matches a 2-tuple where4678// DoubleEq(first field) matches the second field with NaN equality.4679inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() {4680 return internal::FloatingEq2Matcher<double>(true);4681}4682 4683// Creates a polymorphic matcher that matches a 2-tuple where4684// FloatNear(first field, max_abs_error) matches the second field.4685inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) {4686 return internal::FloatingEq2Matcher<float>(max_abs_error);4687}4688 4689// Creates a polymorphic matcher that matches a 2-tuple where4690// DoubleNear(first field, max_abs_error) matches the second field.4691inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_error) {4692 return internal::FloatingEq2Matcher<double>(max_abs_error);4693}4694 4695// Creates a polymorphic matcher that matches a 2-tuple where4696// FloatNear(first field, max_abs_error) matches the second field with NaN4697// equality.4698inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear(4699 float max_abs_error) {4700 return internal::FloatingEq2Matcher<float>(max_abs_error, true);4701}4702 4703// Creates a polymorphic matcher that matches a 2-tuple where4704// DoubleNear(first field, max_abs_error) matches the second field with NaN4705// equality.4706inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear(4707 double max_abs_error) {4708 return internal::FloatingEq2Matcher<double>(max_abs_error, true);4709}4710 4711// Creates a matcher that matches any value of type T that m doesn't4712// match.4713template <typename InnerMatcher>4714inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {4715 return internal::NotMatcher<InnerMatcher>(m);4716}4717 4718// Returns a matcher that matches anything that satisfies the given4719// predicate. The predicate can be any unary function or functor4720// whose return type can be implicitly converted to bool.4721template <typename Predicate>4722inline PolymorphicMatcher<internal::TrulyMatcher<Predicate>> Truly(4723 Predicate pred) {4724 return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));4725}4726 4727// Returns a matcher that matches the container size. The container must4728// support both size() and size_type which all STL-like containers provide.4729// Note that the parameter 'size' can be a value of type size_type as well as4730// matcher. For instance:4731// EXPECT_THAT(container, SizeIs(2)); // Checks container has 2 elements.4732// EXPECT_THAT(container, SizeIs(Le(2)); // Checks container has at most 2.4733template <typename SizeMatcher>4734inline internal::SizeIsMatcher<SizeMatcher> SizeIs(4735 const SizeMatcher& size_matcher) {4736 return internal::SizeIsMatcher<SizeMatcher>(size_matcher);4737}4738 4739// Returns a matcher that matches the distance between the container's begin()4740// iterator and its end() iterator, i.e. the size of the container. This matcher4741// can be used instead of SizeIs with containers such as std::forward_list which4742// do not implement size(). The container must provide const_iterator (with4743// valid iterator_traits), begin() and end().4744template <typename DistanceMatcher>4745inline internal::BeginEndDistanceIsMatcher<DistanceMatcher> BeginEndDistanceIs(4746 const DistanceMatcher& distance_matcher) {4747 return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);4748}4749 4750// Returns a matcher that matches an equal container.4751// This matcher behaves like Eq(), but in the event of mismatch lists the4752// values that are included in one container but not the other. (Duplicate4753// values and order differences are not explained.)4754template <typename Container>4755inline PolymorphicMatcher<4756 internal::ContainerEqMatcher<typename std::remove_const<Container>::type>>4757ContainerEq(const Container& rhs) {4758 return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs));4759}4760 4761// Returns a matcher that matches a container that, when sorted using4762// the given comparator, matches container_matcher.4763template <typename Comparator, typename ContainerMatcher>4764inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher> WhenSortedBy(4765 const Comparator& comparator, const ContainerMatcher& container_matcher) {4766 return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(4767 comparator, container_matcher);4768}4769 4770// Returns a matcher that matches a container that, when sorted using4771// the < operator, matches container_matcher.4772template <typename ContainerMatcher>4773inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>4774WhenSorted(const ContainerMatcher& container_matcher) {4775 return internal::WhenSortedByMatcher<internal::LessComparator,4776 ContainerMatcher>(4777 internal::LessComparator(), container_matcher);4778}4779 4780// Matches an STL-style container or a native array that contains the4781// same number of elements as in rhs, where its i-th element and rhs's4782// i-th element (as a pair) satisfy the given pair matcher, for all i.4783// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const4784// T1&, const T2&> >, where T1 and T2 are the types of elements in the4785// LHS container and the RHS container respectively.4786template <typename TupleMatcher, typename Container>4787inline internal::PointwiseMatcher<TupleMatcher,4788 typename std::remove_const<Container>::type>4789Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {4790 return internal::PointwiseMatcher<TupleMatcher, Container>(tuple_matcher,4791 rhs);4792}4793 4794// Supports the Pointwise(m, {a, b, c}) syntax.4795template <typename TupleMatcher, typename T>4796inline internal::PointwiseMatcher<TupleMatcher, std::vector<T>> Pointwise(4797 const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {4798 return Pointwise(tuple_matcher, std::vector<T>(rhs));4799}4800 4801// UnorderedPointwise(pair_matcher, rhs) matches an STL-style4802// container or a native array that contains the same number of4803// elements as in rhs, where in some permutation of the container, its4804// i-th element and rhs's i-th element (as a pair) satisfy the given4805// pair matcher, for all i. Tuple2Matcher must be able to be safely4806// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are4807// the types of elements in the LHS container and the RHS container4808// respectively.4809//4810// This is like Pointwise(pair_matcher, rhs), except that the element4811// order doesn't matter.4812template <typename Tuple2Matcher, typename RhsContainer>4813inline internal::UnorderedElementsAreArrayMatcher<4814 typename internal::BoundSecondMatcher<4815 Tuple2Matcher,4816 typename internal::StlContainerView<4817 typename std::remove_const<RhsContainer>::type>::type::value_type>>4818UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,4819 const RhsContainer& rhs_container) {4820 // RhsView allows the same code to handle RhsContainer being a4821 // STL-style container and it being a native C-style array.4822 typedef typename internal::StlContainerView<RhsContainer> RhsView;4823 typedef typename RhsView::type RhsStlContainer;4824 typedef typename RhsStlContainer::value_type Second;4825 const RhsStlContainer& rhs_stl_container =4826 RhsView::ConstReference(rhs_container);4827 4828 // Create a matcher for each element in rhs_container.4829 ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second>> matchers;4830 for (auto it = rhs_stl_container.begin(); it != rhs_stl_container.end();4831 ++it) {4832 matchers.push_back(internal::MatcherBindSecond(tuple2_matcher, *it));4833 }4834 4835 // Delegate the work to UnorderedElementsAreArray().4836 return UnorderedElementsAreArray(matchers);4837}4838 4839// Supports the UnorderedPointwise(m, {a, b, c}) syntax.4840template <typename Tuple2Matcher, typename T>4841inline internal::UnorderedElementsAreArrayMatcher<4842 typename internal::BoundSecondMatcher<Tuple2Matcher, T>>4843UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,4844 std::initializer_list<T> rhs) {4845 return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));4846}4847 4848// Matches an STL-style container or a native array that contains at4849// least one element matching the given value or matcher.4850//4851// Examples:4852// ::std::set<int> page_ids;4853// page_ids.insert(3);4854// page_ids.insert(1);4855// EXPECT_THAT(page_ids, Contains(1));4856// EXPECT_THAT(page_ids, Contains(Gt(2)));4857// EXPECT_THAT(page_ids, Not(Contains(4))); // See below for Times(0)4858//4859// ::std::map<int, size_t> page_lengths;4860// page_lengths[1] = 100;4861// EXPECT_THAT(page_lengths,4862// Contains(::std::pair<const int, size_t>(1, 100)));4863//4864// const char* user_ids[] = { "joe", "mike", "tom" };4865// EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));4866//4867// The matcher supports a modifier `Times` that allows to check for arbitrary4868// occurrences including testing for absence with Times(0).4869//4870// Examples:4871// ::std::vector<int> ids;4872// ids.insert(1);4873// ids.insert(1);4874// ids.insert(3);4875// EXPECT_THAT(ids, Contains(1).Times(2)); // 1 occurs 2 times4876// EXPECT_THAT(ids, Contains(2).Times(0)); // 2 is not present4877// EXPECT_THAT(ids, Contains(3).Times(Ge(1))); // 3 occurs at least once4878 4879template <typename M>4880inline internal::ContainsMatcher<M> Contains(M matcher) {4881 return internal::ContainsMatcher<M>(matcher);4882}4883 4884// IsSupersetOf(iterator_first, iterator_last)4885// IsSupersetOf(pointer, count)4886// IsSupersetOf(array)4887// IsSupersetOf(container)4888// IsSupersetOf({e1, e2, ..., en})4889//4890// IsSupersetOf() verifies that a surjective partial mapping onto a collection4891// of matchers exists. In other words, a container matches4892// IsSupersetOf({e1, ..., en}) if and only if there is a permutation4893// {y1, ..., yn} of some of the container's elements where y1 matches e1,4894// ..., and yn matches en. Obviously, the size of the container must be >= n4895// in order to have a match. Examples:4896//4897// - {1, 2, 3} matches IsSupersetOf({Ge(3), Ne(0)}), as 3 matches Ge(3) and4898// 1 matches Ne(0).4899// - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches4900// both Eq(1) and Lt(2). The reason is that different matchers must be used4901// for elements in different slots of the container.4902// - {1, 1, 2} matches IsSupersetOf({Eq(1), Lt(2)}), as (the first) 1 matches4903// Eq(1) and (the second) 1 matches Lt(2).4904// - {1, 2, 3} matches IsSupersetOf(Gt(1), Gt(1)), as 2 matches (the first)4905// Gt(1) and 3 matches (the second) Gt(1).4906//4907// The matchers can be specified as an array, a pointer and count, a container,4908// an initializer list, or an STL iterator range. In each of these cases, the4909// underlying matchers can be either values or matchers.4910 4911template <typename Iter>4912inline internal::UnorderedElementsAreArrayMatcher<4913 typename ::std::iterator_traits<Iter>::value_type>4914IsSupersetOf(Iter first, Iter last) {4915 typedef typename ::std::iterator_traits<Iter>::value_type T;4916 return internal::UnorderedElementsAreArrayMatcher<T>(4917 internal::UnorderedMatcherRequire::Superset, first, last);4918}4919 4920template <typename T>4921inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(4922 const T* pointer, size_t count) {4923 return IsSupersetOf(pointer, pointer + count);4924}4925 4926template <typename T, size_t N>4927inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(4928 const T (&array)[N]) {4929 return IsSupersetOf(array, N);4930}4931 4932template <typename Container>4933inline internal::UnorderedElementsAreArrayMatcher<4934 typename Container::value_type>4935IsSupersetOf(const Container& container) {4936 return IsSupersetOf(container.begin(), container.end());4937}4938 4939template <typename T>4940inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(4941 ::std::initializer_list<T> xs) {4942 return IsSupersetOf(xs.begin(), xs.end());4943}4944 4945// IsSubsetOf(iterator_first, iterator_last)4946// IsSubsetOf(pointer, count)4947// IsSubsetOf(array)4948// IsSubsetOf(container)4949// IsSubsetOf({e1, e2, ..., en})4950//4951// IsSubsetOf() verifies that an injective mapping onto a collection of matchers4952// exists. In other words, a container matches IsSubsetOf({e1, ..., en}) if and4953// only if there is a subset of matchers {m1, ..., mk} which would match the4954// container using UnorderedElementsAre. Obviously, the size of the container4955// must be <= n in order to have a match. Examples:4956//4957// - {1} matches IsSubsetOf({Gt(0), Lt(0)}), as 1 matches Gt(0).4958// - {1, -1} matches IsSubsetOf({Lt(0), Gt(0)}), as 1 matches Gt(0) and -14959// matches Lt(0).4960// - {1, 2} doesn't matches IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both4961// match Gt(0). The reason is that different matchers must be used for4962// elements in different slots of the container.4963//4964// The matchers can be specified as an array, a pointer and count, a container,4965// an initializer list, or an STL iterator range. In each of these cases, the4966// underlying matchers can be either values or matchers.4967 4968template <typename Iter>4969inline internal::UnorderedElementsAreArrayMatcher<4970 typename ::std::iterator_traits<Iter>::value_type>4971IsSubsetOf(Iter first, Iter last) {4972 typedef typename ::std::iterator_traits<Iter>::value_type T;4973 return internal::UnorderedElementsAreArrayMatcher<T>(4974 internal::UnorderedMatcherRequire::Subset, first, last);4975}4976 4977template <typename T>4978inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(4979 const T* pointer, size_t count) {4980 return IsSubsetOf(pointer, pointer + count);4981}4982 4983template <typename T, size_t N>4984inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(4985 const T (&array)[N]) {4986 return IsSubsetOf(array, N);4987}4988 4989template <typename Container>4990inline internal::UnorderedElementsAreArrayMatcher<4991 typename Container::value_type>4992IsSubsetOf(const Container& container) {4993 return IsSubsetOf(container.begin(), container.end());4994}4995 4996template <typename T>4997inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(4998 ::std::initializer_list<T> xs) {4999 return IsSubsetOf(xs.begin(), xs.end());5000}5001 5002// Matches an STL-style container or a native array that contains only5003// elements matching the given value or matcher.5004//5005// Each(m) is semantically equivalent to `Not(Contains(Not(m)))`. Only5006// the messages are different.5007//5008// Examples:5009// ::std::set<int> page_ids;5010// // Each(m) matches an empty container, regardless of what m is.5011// EXPECT_THAT(page_ids, Each(Eq(1)));5012// EXPECT_THAT(page_ids, Each(Eq(77)));5013//5014// page_ids.insert(3);5015// EXPECT_THAT(page_ids, Each(Gt(0)));5016// EXPECT_THAT(page_ids, Not(Each(Gt(4))));5017// page_ids.insert(1);5018// EXPECT_THAT(page_ids, Not(Each(Lt(2))));5019//5020// ::std::map<int, size_t> page_lengths;5021// page_lengths[1] = 100;5022// page_lengths[2] = 200;5023// page_lengths[3] = 300;5024// EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));5025// EXPECT_THAT(page_lengths, Each(Key(Le(3))));5026//5027// const char* user_ids[] = { "joe", "mike", "tom" };5028// EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));5029template <typename M>5030inline internal::EachMatcher<M> Each(M matcher) {5031 return internal::EachMatcher<M>(matcher);5032}5033 5034// Key(inner_matcher) matches an std::pair whose 'first' field matches5035// inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an5036// std::map that contains at least one element whose key is >= 5.5037template <typename M>5038inline internal::KeyMatcher<M> Key(M inner_matcher) {5039 return internal::KeyMatcher<M>(inner_matcher);5040}5041 5042// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field5043// matches first_matcher and whose 'second' field matches second_matcher. For5044// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used5045// to match a std::map<int, string> that contains exactly one element whose key5046// is >= 5 and whose value equals "foo".5047template <typename FirstMatcher, typename SecondMatcher>5048inline internal::PairMatcher<FirstMatcher, SecondMatcher> Pair(5049 FirstMatcher first_matcher, SecondMatcher second_matcher) {5050 return internal::PairMatcher<FirstMatcher, SecondMatcher>(first_matcher,5051 second_matcher);5052}5053 5054namespace no_adl {5055// Conditional() creates a matcher that conditionally uses either the first or5056// second matcher provided. For example, we could create an `equal if, and only5057// if' matcher using the Conditional wrapper as follows:5058//5059// EXPECT_THAT(result, Conditional(condition, Eq(expected), Ne(expected)));5060template <typename MatcherTrue, typename MatcherFalse>5061internal::ConditionalMatcher<MatcherTrue, MatcherFalse> Conditional(5062 bool condition, MatcherTrue matcher_true, MatcherFalse matcher_false) {5063 return internal::ConditionalMatcher<MatcherTrue, MatcherFalse>(5064 condition, std::move(matcher_true), std::move(matcher_false));5065}5066 5067// FieldsAre(matchers...) matches piecewise the fields of compatible structs.5068// These include those that support `get<I>(obj)`, and when structured bindings5069// are enabled any class that supports them.5070// In particular, `std::tuple`, `std::pair`, `std::array` and aggregate types.5071template <typename... M>5072internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre(5073 M&&... matchers) {5074 return internal::FieldsAreMatcher<typename std::decay<M>::type...>(5075 std::forward<M>(matchers)...);5076}5077 5078// Creates a matcher that matches a pointer (raw or smart) that matches5079// inner_matcher.5080template <typename InnerMatcher>5081inline internal::PointerMatcher<InnerMatcher> Pointer(5082 const InnerMatcher& inner_matcher) {5083 return internal::PointerMatcher<InnerMatcher>(inner_matcher);5084}5085 5086// Creates a matcher that matches an object that has an address that matches5087// inner_matcher.5088template <typename InnerMatcher>5089inline internal::AddressMatcher<InnerMatcher> Address(5090 const InnerMatcher& inner_matcher) {5091 return internal::AddressMatcher<InnerMatcher>(inner_matcher);5092}5093 5094// Matches a base64 escaped string, when the unescaped string matches the5095// internal matcher.5096template <typename MatcherType>5097internal::WhenBase64UnescapedMatcher WhenBase64Unescaped(5098 const MatcherType& internal_matcher) {5099 return internal::WhenBase64UnescapedMatcher(internal_matcher);5100}5101} // namespace no_adl5102 5103// Returns a predicate that is satisfied by anything that matches the5104// given matcher.5105template <typename M>5106inline internal::MatcherAsPredicate<M> Matches(M matcher) {5107 return internal::MatcherAsPredicate<M>(matcher);5108}5109 5110// Returns true if and only if the value matches the matcher.5111template <typename T, typename M>5112inline bool Value(const T& value, M matcher) {5113 return testing::Matches(matcher)(value);5114}5115 5116// Matches the value against the given matcher and explains the match5117// result to listener.5118template <typename T, typename M>5119inline bool ExplainMatchResult(M matcher, const T& value,5120 MatchResultListener* listener) {5121 return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);5122}5123 5124// Returns a string representation of the given matcher. Useful for description5125// strings of matchers defined using MATCHER_P* macros that accept matchers as5126// their arguments. For example:5127//5128// MATCHER_P(XAndYThat, matcher,5129// "X that " + DescribeMatcher<int>(matcher, negation) +5130// (negation ? " or" : " and") + " Y that " +5131// DescribeMatcher<double>(matcher, negation)) {5132// return ExplainMatchResult(matcher, arg.x(), result_listener) &&5133// ExplainMatchResult(matcher, arg.y(), result_listener);5134// }5135template <typename T, typename M>5136std::string DescribeMatcher(const M& matcher, bool negation = false) {5137 ::std::stringstream ss;5138 Matcher<T> monomorphic_matcher = SafeMatcherCast<T>(matcher);5139 if (negation) {5140 monomorphic_matcher.DescribeNegationTo(&ss);5141 } else {5142 monomorphic_matcher.DescribeTo(&ss);5143 }5144 return ss.str();5145}5146 5147template <typename... Args>5148internal::ElementsAreMatcher<5149 std::tuple<typename std::decay<const Args&>::type...>>5150ElementsAre(const Args&... matchers) {5151 return internal::ElementsAreMatcher<5152 std::tuple<typename std::decay<const Args&>::type...>>(5153 std::make_tuple(matchers...));5154}5155 5156template <typename... Args>5157internal::UnorderedElementsAreMatcher<5158 std::tuple<typename std::decay<const Args&>::type...>>5159UnorderedElementsAre(const Args&... matchers) {5160 return internal::UnorderedElementsAreMatcher<5161 std::tuple<typename std::decay<const Args&>::type...>>(5162 std::make_tuple(matchers...));5163}5164 5165// Define variadic matcher versions.5166template <typename... Args>5167internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf(5168 const Args&... matchers) {5169 return internal::AllOfMatcher<typename std::decay<const Args&>::type...>(5170 matchers...);5171}5172 5173template <typename... Args>5174internal::AnyOfMatcher<typename std::decay<const Args&>::type...> AnyOf(5175 const Args&... matchers) {5176 return internal::AnyOfMatcher<typename std::decay<const Args&>::type...>(5177 matchers...);5178}5179 5180// AnyOfArray(array)5181// AnyOfArray(pointer, count)5182// AnyOfArray(container)5183// AnyOfArray({ e1, e2, ..., en })5184// AnyOfArray(iterator_first, iterator_last)5185//5186// AnyOfArray() verifies whether a given value matches any member of a5187// collection of matchers.5188//5189// AllOfArray(array)5190// AllOfArray(pointer, count)5191// AllOfArray(container)5192// AllOfArray({ e1, e2, ..., en })5193// AllOfArray(iterator_first, iterator_last)5194//5195// AllOfArray() verifies whether a given value matches all members of a5196// collection of matchers.5197//5198// The matchers can be specified as an array, a pointer and count, a container,5199// an initializer list, or an STL iterator range. In each of these cases, the5200// underlying matchers can be either values or matchers.5201 5202template <typename Iter>5203inline internal::AnyOfArrayMatcher<5204 typename ::std::iterator_traits<Iter>::value_type>5205AnyOfArray(Iter first, Iter last) {5206 return internal::AnyOfArrayMatcher<5207 typename ::std::iterator_traits<Iter>::value_type>(first, last);5208}5209 5210template <typename Iter>5211inline internal::AllOfArrayMatcher<5212 typename ::std::iterator_traits<Iter>::value_type>5213AllOfArray(Iter first, Iter last) {5214 return internal::AllOfArrayMatcher<5215 typename ::std::iterator_traits<Iter>::value_type>(first, last);5216}5217 5218template <typename T>5219inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t count) {5220 return AnyOfArray(ptr, ptr + count);5221}5222 5223template <typename T>5224inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t count) {5225 return AllOfArray(ptr, ptr + count);5226}5227 5228template <typename T, size_t N>5229inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) {5230 return AnyOfArray(array, N);5231}5232 5233template <typename T, size_t N>5234inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) {5235 return AllOfArray(array, N);5236}5237 5238template <typename Container>5239inline internal::AnyOfArrayMatcher<typename Container::value_type> AnyOfArray(5240 const Container& container) {5241 return AnyOfArray(container.begin(), container.end());5242}5243 5244template <typename Container>5245inline internal::AllOfArrayMatcher<typename Container::value_type> AllOfArray(5246 const Container& container) {5247 return AllOfArray(container.begin(), container.end());5248}5249 5250template <typename T>5251inline internal::AnyOfArrayMatcher<T> AnyOfArray(5252 ::std::initializer_list<T> xs) {5253 return AnyOfArray(xs.begin(), xs.end());5254}5255 5256template <typename T>5257inline internal::AllOfArrayMatcher<T> AllOfArray(5258 ::std::initializer_list<T> xs) {5259 return AllOfArray(xs.begin(), xs.end());5260}5261 5262// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected5263// fields of it matches a_matcher. C++ doesn't support default5264// arguments for function templates, so we have to overload it.5265template <size_t... k, typename InnerMatcher>5266internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args(5267 InnerMatcher&& matcher) {5268 return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...>(5269 std::forward<InnerMatcher>(matcher));5270}5271 5272// AllArgs(m) is a synonym of m. This is useful in5273//5274// EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));5275//5276// which is easier to read than5277//5278// EXPECT_CALL(foo, Bar(_, _)).With(Eq());5279template <typename InnerMatcher>5280inline InnerMatcher AllArgs(const InnerMatcher& matcher) {5281 return matcher;5282}5283 5284// Returns a matcher that matches the value of an optional<> type variable.5285// The matcher implementation only uses '!arg' and requires that the optional<>5286// type has a 'value_type' member type and that '*arg' is of type 'value_type'5287// and is printable using 'PrintToString'. It is compatible with5288// std::optional/std::experimental::optional.5289// Note that to compare an optional type variable against nullopt you should5290// use Eq(nullopt) and not Eq(Optional(nullopt)). The latter implies that the5291// optional value contains an optional itself.5292template <typename ValueMatcher>5293inline internal::OptionalMatcher<ValueMatcher> Optional(5294 const ValueMatcher& value_matcher) {5295 return internal::OptionalMatcher<ValueMatcher>(value_matcher);5296}5297 5298// Returns a matcher that matches the value of a absl::any type variable.5299template <typename T>5300PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T>> AnyWith(5301 const Matcher<const T&>& matcher) {5302 return MakePolymorphicMatcher(5303 internal::any_cast_matcher::AnyCastMatcher<T>(matcher));5304}5305 5306// Returns a matcher that matches the value of a variant<> type variable.5307// The matcher implementation uses ADL to find the holds_alternative and get5308// functions.5309// It is compatible with std::variant.5310template <typename T>5311PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T>> VariantWith(5312 const Matcher<const T&>& matcher) {5313 return MakePolymorphicMatcher(5314 internal::variant_matcher::VariantMatcher<T>(matcher));5315}5316 5317#if GTEST_HAS_EXCEPTIONS5318 5319// Anything inside the `internal` namespace is internal to the implementation5320// and must not be used in user code!5321namespace internal {5322 5323class WithWhatMatcherImpl {5324 public:5325 WithWhatMatcherImpl(Matcher<std::string> matcher)5326 : matcher_(std::move(matcher)) {}5327 5328 void DescribeTo(std::ostream* os) const {5329 *os << "contains .what() that ";5330 matcher_.DescribeTo(os);5331 }5332 5333 void DescribeNegationTo(std::ostream* os) const {5334 *os << "contains .what() that does not ";5335 matcher_.DescribeTo(os);5336 }5337 5338 template <typename Err>5339 bool MatchAndExplain(const Err& err, MatchResultListener* listener) const {5340 *listener << "which contains .what() (of value = " << err.what()5341 << ") that ";5342 return matcher_.MatchAndExplain(err.what(), listener);5343 }5344 5345 private:5346 const Matcher<std::string> matcher_;5347};5348 5349inline PolymorphicMatcher<WithWhatMatcherImpl> WithWhat(5350 Matcher<std::string> m) {5351 return MakePolymorphicMatcher(WithWhatMatcherImpl(std::move(m)));5352}5353 5354template <typename Err>5355class ExceptionMatcherImpl {5356 class NeverThrown {5357 public:5358 const char* what() const noexcept {5359 return "this exception should never be thrown";5360 }5361 };5362 5363 // If the matchee raises an exception of a wrong type, we'd like to5364 // catch it and print its message and type. To do that, we add an additional5365 // catch clause:5366 //5367 // try { ... }5368 // catch (const Err&) { /* an expected exception */ }5369 // catch (const std::exception&) { /* exception of a wrong type */ }5370 //5371 // However, if the `Err` itself is `std::exception`, we'd end up with two5372 // identical `catch` clauses:5373 //5374 // try { ... }5375 // catch (const std::exception&) { /* an expected exception */ }5376 // catch (const std::exception&) { /* exception of a wrong type */ }5377 //5378 // This can cause a warning or an error in some compilers. To resolve5379 // the issue, we use a fake error type whenever `Err` is `std::exception`:5380 //5381 // try { ... }5382 // catch (const std::exception&) { /* an expected exception */ }5383 // catch (const NeverThrown&) { /* exception of a wrong type */ }5384 using DefaultExceptionType = typename std::conditional<5385 std::is_same<typename std::remove_cv<5386 typename std::remove_reference<Err>::type>::type,5387 std::exception>::value,5388 const NeverThrown&, const std::exception&>::type;5389 5390 public:5391 ExceptionMatcherImpl(Matcher<const Err&> matcher)5392 : matcher_(std::move(matcher)) {}5393 5394 void DescribeTo(std::ostream* os) const {5395 *os << "throws an exception which is a " << GetTypeName<Err>();5396 *os << " which ";5397 matcher_.DescribeTo(os);5398 }5399 5400 void DescribeNegationTo(std::ostream* os) const {5401 *os << "throws an exception which is not a " << GetTypeName<Err>();5402 *os << " which ";5403 matcher_.DescribeNegationTo(os);5404 }5405 5406 template <typename T>5407 bool MatchAndExplain(T&& x, MatchResultListener* listener) const {5408 try {5409 (void)(std::forward<T>(x)());5410 } catch (const Err& err) {5411 *listener << "throws an exception which is a " << GetTypeName<Err>();5412 *listener << " ";5413 return matcher_.MatchAndExplain(err, listener);5414 } catch (DefaultExceptionType err) {5415#if GTEST_HAS_RTTI5416 *listener << "throws an exception of type " << GetTypeName(typeid(err));5417 *listener << " ";5418#else5419 *listener << "throws an std::exception-derived type ";5420#endif5421 *listener << "with description \"" << err.what() << "\"";5422 return false;5423 } catch (...) {5424 *listener << "throws an exception of an unknown type";5425 return false;5426 }5427 5428 *listener << "does not throw any exception";5429 return false;5430 }5431 5432 private:5433 const Matcher<const Err&> matcher_;5434};5435 5436} // namespace internal5437 5438// Throws()5439// Throws(exceptionMatcher)5440// ThrowsMessage(messageMatcher)5441//5442// This matcher accepts a callable and verifies that when invoked, it throws5443// an exception with the given type and properties.5444//5445// Examples:5446//5447// EXPECT_THAT(5448// []() { throw std::runtime_error("message"); },5449// Throws<std::runtime_error>());5450//5451// EXPECT_THAT(5452// []() { throw std::runtime_error("message"); },5453// ThrowsMessage<std::runtime_error>(HasSubstr("message")));5454//5455// EXPECT_THAT(5456// []() { throw std::runtime_error("message"); },5457// Throws<std::runtime_error>(5458// Property(&std::runtime_error::what, HasSubstr("message"))));5459 5460template <typename Err>5461PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws() {5462 return MakePolymorphicMatcher(5463 internal::ExceptionMatcherImpl<Err>(A<const Err&>()));5464}5465 5466template <typename Err, typename ExceptionMatcher>5467PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws(5468 const ExceptionMatcher& exception_matcher) {5469 // Using matcher cast allows users to pass a matcher of a more broad type.5470 // For example user may want to pass Matcher<std::exception>5471 // to Throws<std::runtime_error>, or Matcher<int64> to Throws<int32>.5472 return MakePolymorphicMatcher(internal::ExceptionMatcherImpl<Err>(5473 SafeMatcherCast<const Err&>(exception_matcher)));5474}5475 5476template <typename Err, typename MessageMatcher>5477PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(5478 MessageMatcher&& message_matcher) {5479 static_assert(std::is_base_of<std::exception, Err>::value,5480 "expected an std::exception-derived type");5481 return Throws<Err>(internal::WithWhat(5482 MatcherCast<std::string>(std::forward<MessageMatcher>(message_matcher))));5483}5484 5485#endif // GTEST_HAS_EXCEPTIONS5486 5487// These macros allow using matchers to check values in Google Test5488// tests. ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)5489// succeed if and only if the value matches the matcher. If the assertion5490// fails, the value and the description of the matcher will be printed.5491#define ASSERT_THAT(value, matcher) \5492 ASSERT_PRED_FORMAT1( \5493 ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)5494#define EXPECT_THAT(value, matcher) \5495 EXPECT_PRED_FORMAT1( \5496 ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)5497 5498// MATCHER* macros itself are listed below.5499#define MATCHER(name, description) \5500 class name##Matcher \5501 : public ::testing::internal::MatcherBaseImpl<name##Matcher> { \5502 public: \5503 template <typename arg_type> \5504 class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> { \5505 public: \5506 gmock_Impl() {} \5507 bool MatchAndExplain( \5508 const arg_type& arg, \5509 ::testing::MatchResultListener* result_listener) const override; \5510 void DescribeTo(::std::ostream* gmock_os) const override { \5511 *gmock_os << FormatDescription(false); \5512 } \5513 void DescribeNegationTo(::std::ostream* gmock_os) const override { \5514 *gmock_os << FormatDescription(true); \5515 } \5516 \5517 private: \5518 ::std::string FormatDescription(bool negation) const { \5519 /* NOLINTNEXTLINE readability-redundant-string-init */ \5520 ::std::string gmock_description = (description); \5521 if (!gmock_description.empty()) { \5522 return gmock_description; \5523 } \5524 return ::testing::internal::FormatMatcherDescription(negation, #name, \5525 {}, {}); \5526 } \5527 }; \5528 }; \5529 inline name##Matcher GMOCK_INTERNAL_WARNING_PUSH() \5530 GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-function") \5531 GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function") \5532 name GMOCK_INTERNAL_WARNING_POP()() { \5533 return {}; \5534 } \5535 template <typename arg_type> \5536 bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain( \5537 const arg_type& arg, \5538 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \5539 const5540 5541#define MATCHER_P(name, p0, description) \5542 GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (#p0), (p0))5543#define MATCHER_P2(name, p0, p1, description) \5544 GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (#p0, #p1), \5545 (p0, p1))5546#define MATCHER_P3(name, p0, p1, p2, description) \5547 GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (#p0, #p1, #p2), \5548 (p0, p1, p2))5549#define MATCHER_P4(name, p0, p1, p2, p3, description) \5550 GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, \5551 (#p0, #p1, #p2, #p3), (p0, p1, p2, p3))5552#define MATCHER_P5(name, p0, p1, p2, p3, p4, description) \5553 GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \5554 (#p0, #p1, #p2, #p3, #p4), (p0, p1, p2, p3, p4))5555#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \5556 GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description, \5557 (#p0, #p1, #p2, #p3, #p4, #p5), \5558 (p0, p1, p2, p3, p4, p5))5559#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \5560 GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description, \5561 (#p0, #p1, #p2, #p3, #p4, #p5, #p6), \5562 (p0, p1, p2, p3, p4, p5, p6))5563#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \5564 GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description, \5565 (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7), \5566 (p0, p1, p2, p3, p4, p5, p6, p7))5567#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \5568 GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description, \5569 (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7, #p8), \5570 (p0, p1, p2, p3, p4, p5, p6, p7, p8))5571#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \5572 GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description, \5573 (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7, #p8, #p9), \5574 (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))5575 5576#define GMOCK_INTERNAL_MATCHER(name, full_name, description, arg_names, args) \5577 template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \5578 class full_name : public ::testing::internal::MatcherBaseImpl< \5579 full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \5580 public: \5581 using full_name::MatcherBaseImpl::MatcherBaseImpl; \5582 template <typename arg_type> \5583 class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> { \5584 public: \5585 explicit gmock_Impl(GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) \5586 : GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) {} \5587 bool MatchAndExplain( \5588 const arg_type& arg, \5589 ::testing::MatchResultListener* result_listener) const override; \5590 void DescribeTo(::std::ostream* gmock_os) const override { \5591 *gmock_os << FormatDescription(false); \5592 } \5593 void DescribeNegationTo(::std::ostream* gmock_os) const override { \5594 *gmock_os << FormatDescription(true); \5595 } \5596 GMOCK_INTERNAL_MATCHER_MEMBERS(args) \5597 \5598 private: \5599 ::std::string FormatDescription(bool negation) const { \5600 ::std::string gmock_description; \5601 gmock_description = (description); \5602 if (!gmock_description.empty()) { \5603 return gmock_description; \5604 } \5605 return ::testing::internal::FormatMatcherDescription( \5606 negation, #name, {GMOCK_PP_REMOVE_PARENS(arg_names)}, \5607 ::testing::internal::UniversalTersePrintTupleFieldsToStrings( \5608 ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>( \5609 GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args)))); \5610 } \5611 }; \5612 }; \5613 template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \5614 inline full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)> name( \5615 GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) { \5616 return full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>( \5617 GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args)); \5618 } \5619 template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \5620 template <typename arg_type> \5621 bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl< \5622 arg_type>::MatchAndExplain(const arg_type& arg, \5623 ::testing::MatchResultListener* \5624 result_listener GTEST_ATTRIBUTE_UNUSED_) \5625 const5626 5627#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \5628 GMOCK_PP_TAIL( \5629 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM, , args))5630#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM(i_unused, data_unused, arg) \5631 , typename arg##_type5632 5633#define GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args) \5634 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TYPE_PARAM, , args))5635#define GMOCK_INTERNAL_MATCHER_TYPE_PARAM(i_unused, data_unused, arg) \5636 , arg##_type5637 5638#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args) \5639 GMOCK_PP_TAIL(dummy_first GMOCK_PP_FOR_EACH( \5640 GMOCK_INTERNAL_MATCHER_FUNCTION_ARG, , args))5641#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARG(i, data_unused, arg) \5642 , arg##_type gmock_p##i5643 5644#define GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) \5645 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_FORWARD_ARG, , args))5646#define GMOCK_INTERNAL_MATCHER_FORWARD_ARG(i, data_unused, arg) \5647 , arg(::std::forward<arg##_type>(gmock_p##i))5648 5649#define GMOCK_INTERNAL_MATCHER_MEMBERS(args) \5650 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER, , args)5651#define GMOCK_INTERNAL_MATCHER_MEMBER(i_unused, data_unused, arg) \5652 const arg##_type arg;5653 5654#define GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args) \5655 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER_USAGE, , args))5656#define GMOCK_INTERNAL_MATCHER_MEMBER_USAGE(i_unused, data_unused, arg) , arg5657 5658#define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \5659 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args))5660#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \5661 , gmock_p##i5662 5663// To prevent ADL on certain functions we put them on a separate namespace.5664using namespace no_adl; // NOLINT5665 5666} // namespace testing5667 5668GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 50465669 5670// Include any custom callback matchers added by the local installation.5671// We must include this header at the end to make sure it can use the5672// declarations from this file.5673#include "gmock/internal/custom/gmock-matchers.h"5674 5675#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_5676