gmock-generated-matchers.h.pump
073060d11c24master

gmock-generated-matchers.h.pump
View Options

			$$ -- mode: c++; --
			$$ This is a Pump source file. Please use Pump to convert
			$$ it to gmock-generated-matchers.h.
			$$
			$var n = 10 $$ The maximum arity we support.
			$$ }} This line fixes auto-indentation of the following code in Emacs.
			// Copyright 2008, Google Inc.
			// All rights reserved.
			//
			// Redistribution and use in source and binary forms, with or without
			// modification, are permitted provided that the following conditions are
			// met:
			//
			// * Redistributions of source code must retain the above copyright
			// notice, this list of conditions and the following disclaimer.
			// * Redistributions in binary form must reproduce the above
			// copyright notice, this list of conditions and the following disclaimer
			// in the documentation and/or other materials provided with the
			// distribution.
			// * Neither the name of Google Inc. nor the names of its
			// contributors may be used to endorse or promote products derived from
			// this software without specific prior written permission.
			//
			// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
			// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
			// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
			// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
			// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
			// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
			// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
			// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
			// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
			// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
			// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

			// Google Mock - a framework for writing C++ mock classes.
			//
			// This file implements some commonly used variadic matchers.

			// GOOGLETEST_CM0002 DO NOT DELETE

			#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
			#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_

			#include <iterator>
			#include <sstream>
			#include <string>
			#include <vector>
			#include "gmock/gmock-matchers.h"

			namespace testing {
			namespace internal {

			$range i 0..n-1

			// The type of the i-th (0-based) field of Tuple.
			#define GMOCK_FIELD_TYPE_(Tuple, i) \
			typename ::testing::tuple_element<i, Tuple>::type

			// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
			// tuple of type Tuple. It has two members:
			//
			// type: a tuple type whose i-th field is the ki-th field of Tuple.
			// GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
			//
			// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
			//
			// type is tuple<int, bool>, and
			// GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).

			template <class Tuple$for i [[, int k$i = -1]]>
			class TupleFields;

			// This generic version is used when there are $n selectors.
			template <class Tuple$for i [[, int k$i]]>
			class TupleFields {
			public:
			typedef ::testing::tuple<$for i, [[GMOCK_FIELD_TYPE_(Tuple, k$i)]]> type;
			static type GetSelectedFields(const Tuple& t) {
			return type($for i, [[get<k$i>(t)]]);
			}
			};

			// The following specialization is used for 0 ~ $(n-1) selectors.

			$for i [[
			$$ }}}
			$range j 0..i-1
			$range k 0..n-1

			template <class Tuple$for j [[, int k$j]]>
			class TupleFields<Tuple, $for k, [[$if k < i [[k$k]] $else [[-1]]]]> {
			public:
			typedef ::testing::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type;
			static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {
			return type($for j, [[get<k$j>(t)]]);
			}
			};

			]]

			#undef GMOCK_FIELD_TYPE_

			// Implements the Args() matcher.

			$var ks = [[$for i, [[k$i]]]]
			template <class ArgsTuple$for i [[, int k$i = -1]]>
			class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
			public:
			// ArgsTuple may have top-level const or reference modifiers.
			typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
			typedef typename internal::TupleFields<RawArgsTuple, $ks>::type SelectedArgs;
			typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;

			template <typename InnerMatcher>
			explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
			: inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}

			virtual bool MatchAndExplain(ArgsTuple args,
			MatchResultListener* listener) const {
			const SelectedArgs& selected_args = GetSelectedArgs(args);
			if (!listener->IsInterested())
			return inner_matcher_.Matches(selected_args);

			PrintIndices(listener->stream());
			*listener << "are " << PrintToString(selected_args);

			StringMatchResultListener inner_listener;
			const bool match = inner_matcher_.MatchAndExplain(selected_args,
			&inner_listener);
			PrintIfNotEmpty(inner_listener.str(), listener->stream());
			return match;
			}

			virtual void DescribeTo(::std::ostream* os) const {
			*os << "are a tuple ";
			PrintIndices(os);
			inner_matcher_.DescribeTo(os);
			}

			virtual void DescribeNegationTo(::std::ostream* os) const {
			*os << "are a tuple ";
			PrintIndices(os);
			inner_matcher_.DescribeNegationTo(os);
			}

			private:
			static SelectedArgs GetSelectedArgs(ArgsTuple args) {
			return TupleFields<RawArgsTuple, $ks>::GetSelectedFields(args);
			}

			// Prints the indices of the selected fields.
			static void PrintIndices(::std::ostream* os) {
			*os << "whose fields (";
			const int indices[$n] = { $ks };
			for (int i = 0; i < $n; i++) {
			if (indices[i] < 0)
			break;

			if (i >= 1)
			*os << ", ";

			*os << "#" << indices[i];
			}
			*os << ") ";
			}

			const MonomorphicInnerMatcher inner_matcher_;

			GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
			};

			template <class InnerMatcher$for i [[, int k$i = -1]]>
			class ArgsMatcher {
			public:
			explicit ArgsMatcher(const InnerMatcher& inner_matcher)
			: inner_matcher_(inner_matcher) {}

			template <typename ArgsTuple>
			operator Matcher<ArgsTuple>() const {
			return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, $ks>(inner_matcher_));
			}

			private:
			const InnerMatcher inner_matcher_;

			GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
			};

			// A set of metafunctions for computing the result type of AllOf.
			// AllOf(m1, ..., mN) returns
			// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.

			// Although AllOf isn't defined for one argument, AllOfResult1 is defined
			// to simplify the implementation.
			template <typename M1>
			struct AllOfResult1 {
			typedef M1 type;
			};

			$range i 1..n

			$range i 2..n
			$for i [[
			$range j 2..i
			$var m = i/2
			$range k 1..m
			$range t m+1..i

			template <typename M1$for j [[, typename M$j]]>
			struct AllOfResult$i {
			typedef BothOfMatcher<
			typename AllOfResult$m<$for k, [[M$k]]>::type,
			typename AllOfResult$(i-m)<$for t, [[M$t]]>::type
			> type;
			};

			]]

			// A set of metafunctions for computing the result type of AnyOf.
			// AnyOf(m1, ..., mN) returns
			// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.

			// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
			// to simplify the implementation.
			template <typename M1>
			struct AnyOfResult1 {
			typedef M1 type;
			};

			$range i 1..n

			$range i 2..n
			$for i [[
			$range j 2..i
			$var m = i/2
			$range k 1..m
			$range t m+1..i

			template <typename M1$for j [[, typename M$j]]>
			struct AnyOfResult$i {
			typedef EitherOfMatcher<
			typename AnyOfResult$m<$for k, [[M$k]]>::type,
			typename AnyOfResult$(i-m)<$for t, [[M$t]]>::type
			> type;
			};

			]]

			} // namespace internal

			// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
			// fields of it matches a_matcher. C++ doesn't support default
			// arguments for function templates, so we have to overload it.

			$range i 0..n
			$for i [[
			$range j 1..i
			template <$for j [[int k$j, ]]typename InnerMatcher>
			inline internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>
			Args(const InnerMatcher& matcher) {
			return internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>(matcher);
			}


			]]
			// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
			// n elements, where the i-th element in the container must
			// match the i-th argument in the list. Each argument of
			// ElementsAre() can be either a value or a matcher. We support up to
			// $n arguments.
			//
			// The use of DecayArray in the implementation allows ElementsAre()
			// to accept string literals, whose type is const char[N], but we
			// want to treat them as const char*.
			//
			// NOTE: Since ElementsAre() cares about the order of the elements, it
			// must not be used with containers whose elements's order is
			// undefined (e.g. hash_map).

			$range i 0..n
			$for i [[

			$range j 1..i

			$if i>0 [[

			template <$for j, [[typename T$j]]>
			]]

			inline internal::ElementsAreMatcher<
			::testing::tuple<
			$for j, [[

			typename internal::DecayArray<T$j[[]]>::type]]> >
			ElementsAre($for j, [[const T$j& e$j]]) {
			typedef ::testing::tuple<
			$for j, [[

			typename internal::DecayArray<T$j[[]]>::type]]> Args;
			return internal::ElementsAreMatcher<Args>(Args($for j, [[e$j]]));
			}

			]]

			// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
			// that matches n elements in any order. We support up to n=$n arguments.
			//
			// If you have >$n elements, consider UnorderedElementsAreArray() or
			// UnorderedPointwise() instead.

			$range i 0..n
			$for i [[

			$range j 1..i

			$if i>0 [[

			template <$for j, [[typename T$j]]>
			]]

			inline internal::UnorderedElementsAreMatcher<
			::testing::tuple<
			$for j, [[

			typename internal::DecayArray<T$j[[]]>::type]]> >
			UnorderedElementsAre($for j, [[const T$j& e$j]]) {
			typedef ::testing::tuple<
			$for j, [[

			typename internal::DecayArray<T$j[[]]>::type]]> Args;
			return internal::UnorderedElementsAreMatcher<Args>(Args($for j, [[e$j]]));
			}

			]]

			// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
			// sub-matchers. AllOf is called fully qualified to prevent ADL from firing.

			$range i 2..n
			$for i [[
			$range j 1..i
			$var m = i/2
			$range k 1..m
			$range t m+1..i

			template <$for j, [[typename M$j]]>
			inline typename internal::AllOfResult$i<$for j, [[M$j]]>::type
			AllOf($for j, [[M$j m$j]]) {
			return typename internal::AllOfResult$i<$for j, [[M$j]]>::type(
			$if m == 1 [[m1]] $else [[::testing::AllOf($for k, [[m$k]])]],
			$if m+1 == i [[m$i]] $else [[::testing::AllOf($for t, [[m$t]])]]);
			}

			]]

			// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
			// sub-matchers. AnyOf is called fully qualified to prevent ADL from firing.

			$range i 2..n
			$for i [[
			$range j 1..i
			$var m = i/2
			$range k 1..m
			$range t m+1..i

			template <$for j, [[typename M$j]]>
			inline typename internal::AnyOfResult$i<$for j, [[M$j]]>::type
			AnyOf($for j, [[M$j m$j]]) {
			return typename internal::AnyOfResult$i<$for j, [[M$j]]>::type(
			$if m == 1 [[m1]] $else [[::testing::AnyOf($for k, [[m$k]])]],
			$if m+1 == i [[m$i]] $else [[::testing::AnyOf($for t, [[m$t]])]]);
			}

			]]

			} // namespace testing
			$$ } // This Pump meta comment fixes auto-indentation in Emacs. It will not
			$$ // show up in the generated code.


			// The MATCHER* family of macros can be used in a namespace scope to
			// define custom matchers easily.
			//
			// Basic Usage
			// ===========
			//
			// The syntax
			//
			// MATCHER(name, description_string) { statements; }
			//
			// defines a matcher with the given name that executes the statements,
			// which must return a bool to indicate if the match succeeds. Inside
			// the statements, you can refer to the value being matched by 'arg',
			// and refer to its type by 'arg_type'.
			//
			// The description string documents what the matcher does, and is used
			// to generate the failure message when the match fails. Since a
			// MATCHER() is usually defined in a header file shared by multiple
			// C++ source files, we require the description to be a C-string
			// literal to avoid possible side effects. It can be empty, in which
			// case we'll use the sequence of words in the matcher name as the
			// description.
			//
			// For example:
			//
			// MATCHER(IsEven, "") { return (arg % 2) == 0; }
			//
			// allows you to write
			//
			// // Expects mock_foo.Bar(n) to be called where n is even.
			// EXPECT_CALL(mock_foo, Bar(IsEven()));
			//
			// or,
			//
			// // Verifies that the value of some_expression is even.
			// EXPECT_THAT(some_expression, IsEven());
			//
			// If the above assertion fails, it will print something like:
			//
			// Value of: some_expression
			// Expected: is even
			// Actual: 7
			//
			// where the description "is even" is automatically calculated from the
			// matcher name IsEven.
			//
			// Argument Type
			// =============
			//
			// Note that the type of the value being matched (arg_type) is
			// determined by the context in which you use the matcher and is
			// supplied to you by the compiler, so you don't need to worry about
			// declaring it (nor can you). This allows the matcher to be
			// polymorphic. For example, IsEven() can be used to match any type
			// where the value of "(arg % 2) == 0" can be implicitly converted to
			// a bool. In the "Bar(IsEven())" example above, if method Bar()
			// takes an int, 'arg_type' will be int; if it takes an unsigned long,
			// 'arg_type' will be unsigned long; and so on.
			//
			// Parameterizing Matchers
			// =======================
			//
			// Sometimes you'll want to parameterize the matcher. For that you
			// can use another macro:
			//
			// MATCHER_P(name, param_name, description_string) { statements; }
			//
			// For example:
			//
			// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
			//
			// will allow you to write:
			//
			// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
			//
			// which may lead to this message (assuming n is 10):
			//
			// Value of: Blah("a")
			// Expected: has absolute value 10
			// Actual: -9
			//
			// Note that both the matcher description and its parameter are
			// printed, making the message human-friendly.
			//
			// In the matcher definition body, you can write 'foo_type' to
			// reference the type of a parameter named 'foo'. For example, in the
			// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
			// 'value_type' to refer to the type of 'value'.
			//
			// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to
			// support multi-parameter matchers.
			//
			// Describing Parameterized Matchers
			// =================================
			//
			// The last argument to MATCHER*() is a string-typed expression. The
			// expression can reference all of the matcher's parameters and a
			// special bool-typed variable named 'negation'. When 'negation' is
			// false, the expression should evaluate to the matcher's description;
			// otherwise it should evaluate to the description of the negation of
			// the matcher. For example,
			//
			// using testing::PrintToString;
			//
			// MATCHER_P2(InClosedRange, low, hi,
			// std::string(negation ? "is not" : "is") + " in range [" +
			// PrintToString(low) + ", " + PrintToString(hi) + "]") {
			// return low <= arg && arg <= hi;
			// }
			// ...
			// EXPECT_THAT(3, InClosedRange(4, 6));
			// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
			//
			// would generate two failures that contain the text:
			//
			// Expected: is in range [4, 6]
			// ...
			// Expected: is not in range [2, 4]
			//
			// If you specify "" as the description, the failure message will
			// contain the sequence of words in the matcher name followed by the
			// parameter values printed as a tuple. For example,
			//
			// MATCHER_P2(InClosedRange, low, hi, "") { ... }
			// ...
			// EXPECT_THAT(3, InClosedRange(4, 6));
			// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
			//
			// would generate two failures that contain the text:
			//
			// Expected: in closed range (4, 6)
			// ...
			// Expected: not (in closed range (2, 4))
			//
			// Types of Matcher Parameters
			// ===========================
			//
			// For the purpose of typing, you can view
			//
			// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
			//
			// as shorthand for
			//
			// template <typename p1_type, ..., typename pk_type>
			// FooMatcherPk<p1_type, ..., pk_type>
			// Foo(p1_type p1, ..., pk_type pk) { ... }
			//
			// When you write Foo(v1, ..., vk), the compiler infers the types of
			// the parameters v1, ..., and vk for you. If you are not happy with
			// the result of the type inference, you can specify the types by
			// explicitly instantiating the template, as in Foo<long, bool>(5,
			// false). As said earlier, you don't get to (or need to) specify
			// 'arg_type' as that's determined by the context in which the matcher
			// is used. You can assign the result of expression Foo(p1, ..., pk)
			// to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This
			// can be useful when composing matchers.
			//
			// While you can instantiate a matcher template with reference types,
			// passing the parameters by pointer usually makes your code more
			// readable. If, however, you still want to pass a parameter by
			// reference, be aware that in the failure message generated by the
			// matcher you will see the value of the referenced object but not its
			// address.
			//
			// Explaining Match Results
			// ========================
			//
			// Sometimes the matcher description alone isn't enough to explain why
			// the match has failed or succeeded. For example, when expecting a
			// long string, it can be very helpful to also print the diff between
			// the expected string and the actual one. To achieve that, you can
			// optionally stream additional information to a special variable
			// named result_listener, whose type is a pointer to class
			// MatchResultListener:
			//
			// MATCHER_P(EqualsLongString, str, "") {
			// if (arg == str) return true;
			//
			// *result_listener << "the difference: "
			/// << DiffStrings(str, arg);
			// return false;
			// }
			//
			// Overloading Matchers
			// ====================
			//
			// You can overload matchers with different numbers of parameters:
			//
			// MATCHER_P(Blah, a, description_string1) { ... }
			// MATCHER_P2(Blah, a, b, description_string2) { ... }
			//
			// Caveats
			// =======
			//
			// When defining a new matcher, you should also consider implementing
			// MatcherInterface or using MakePolymorphicMatcher(). These
			// approaches require more work than the MATCHER* macros, but also
			// give you more control on the types of the value being matched and
			// the matcher parameters, which may leads to better compiler error
			// messages when the matcher is used wrong. They also allow
			// overloading matchers based on parameter types (as opposed to just
			// based on the number of parameters).
			//
			// MATCHER*() can only be used in a namespace scope. The reason is
			// that C++ doesn't yet allow function-local types to be used to
			// instantiate templates. The up-coming C++0x standard will fix this.
			// Once that's done, we'll consider supporting using MATCHER*() inside
			// a function.
			//
			// More Information
			// ================
			//
			// To learn more about using these macros, please search for 'MATCHER'
			// on
			// https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md

			$range i 0..n
			$for i

			[[
			$var macro_name = [[$if i==0 [[MATCHER]] $elif i==1 [[MATCHER_P]]
			$else [[MATCHER_P$i]]]]
			$var class_name = [[name##Matcher[[$if i==0 [[]] $elif i==1 [[P]]
			$else [[P$i]]]]]]
			$range j 0..i-1
			$var template = [[$if i==0 [[]] $else [[

			template <$for j, [[typename p$j##_type]]>\
			]]]]
			$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
			$var impl_ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
			$var impl_inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::testing::internal::move(gmock_p$j))]]]]]]
			$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::testing::internal::move(gmock_p$j))]]]]]]
			$var params = [[$for j, [[p$j]]]]
			$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]
			$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]
			$var param_field_decls = [[$for j
			[[

			p$j##_type const p$j;\
			]]]]
			$var param_field_decls2 = [[$for j
			[[

			p$j##_type const p$j;\
			]]]]

			#define $macro_name(name$for j [[, p$j]], description)\$template
			class $class_name {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			[[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\
			$impl_inits {}\
			virtual bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const;\
			virtual void DescribeTo(::std::ostream* gmock_os) const {\
			*gmock_os << FormatDescription(false);\
			}\
			virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
			*gmock_os << FormatDescription(true);\
			}\$param_field_decls
			private:\
			::std::string FormatDescription(bool negation) const {\
			::std::string gmock_description = (description);\
			if (!gmock_description.empty())\
			return gmock_description;\
			return ::testing::internal::FormatMatcherDescription(\
			negation, #name, \
			::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
			::testing::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>($params));\
			}\
			[[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {\
			}\$param_field_decls2
			private:\
			};\$template
			inline $class_name$param_types name($param_types_and_names) {\
			return $class_name$param_types($params);\
			}\$template
			template <typename arg_type>\
			bool $class_name$param_types::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const
			]]


			#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_

R7934/googletest-release-1.8.1/googlemock/include/gmock/gmock-generated-matchers.h.pump073060d11c24master

gmock-generated-matchers.h.pumpView Options

R7934/googletest-release-1.8.1/googlemock/include/gmock/gmock-generated-matchers.h.pump
073060d11c24master

gmock-generated-matchers.h.pump
View Options