Diffusion sp4e-homework-lars-bertil (master) Browse

gmock-generated-matchers.h
ee3d0e538b70master

gmock-generated-matchers.h
View Options

			// This file was GENERATED by command:
			// pump.py gmock-generated-matchers.h.pump
			// DO NOT EDIT BY HAND!!!

			// 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 <utility>
			#include <vector>
			#include "gmock/gmock-matchers.h"

			// 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_P10 to
			// support multi-parameter matchers.
			//
			// Describing Parameterized Matchers
			// =================================
			//
			// The last argument to MATCHER*() is a string-typed expression. The
			// expression can reference all of the matcher's parameters and a
			// special bool-typed variable named 'negation'. When 'negation' is
			// false, the expression should evaluate to the matcher's description;
			// otherwise it should evaluate to the description of the negation of
			// the matcher. For example,
			//
			// using testing::PrintToString;
			//
			// MATCHER_P2(InClosedRange, low, hi,
			// std::string(negation ? "is not" : "is") + " in range [" +
			// PrintToString(low) + ", " + PrintToString(hi) + "]") {
			// return low <= arg && arg <= hi;
			// }
			// ...
			// EXPECT_THAT(3, InClosedRange(4, 6));
			// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
			//
			// would generate two failures that contain the text:
			//
			// Expected: is in range [4, 6]
			// ...
			// Expected: is not in range [2, 4]
			//
			// If you specify "" as the description, the failure message will
			// contain the sequence of words in the matcher name followed by the
			// parameter values printed as a tuple. For example,
			//
			// MATCHER_P2(InClosedRange, low, hi, "") { ... }
			// ...
			// EXPECT_THAT(3, InClosedRange(4, 6));
			// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
			//
			// would generate two failures that contain the text:
			//
			// Expected: in closed range (4, 6)
			// ...
			// Expected: not (in closed range (2, 4))
			//
			// Types of Matcher Parameters
			// ===========================
			//
			// For the purpose of typing, you can view
			//
			// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
			//
			// as shorthand for
			//
			// template <typename p1_type, ..., typename pk_type>
			// FooMatcherPk<p1_type, ..., pk_type>
			// Foo(p1_type p1, ..., pk_type pk) { ... }
			//
			// When you write Foo(v1, ..., vk), the compiler infers the types of
			// the parameters v1, ..., and vk for you. If you are not happy with
			// the result of the type inference, you can specify the types by
			// explicitly instantiating the template, as in Foo<long, bool>(5,
			// false). As said earlier, you don't get to (or need to) specify
			// 'arg_type' as that's determined by the context in which the matcher
			// is used. You can assign the result of expression Foo(p1, ..., pk)
			// to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This
			// can be useful when composing matchers.
			//
			// While you can instantiate a matcher template with reference types,
			// passing the parameters by pointer usually makes your code more
			// readable. If, however, you still want to pass a parameter by
			// reference, be aware that in the failure message generated by the
			// matcher you will see the value of the referenced object but not its
			// address.
			//
			// Explaining Match Results
			// ========================
			//
			// Sometimes the matcher description alone isn't enough to explain why
			// the match has failed or succeeded. For example, when expecting a
			// long string, it can be very helpful to also print the diff between
			// the expected string and the actual one. To achieve that, you can
			// optionally stream additional information to a special variable
			// named result_listener, whose type is a pointer to class
			// MatchResultListener:
			//
			// MATCHER_P(EqualsLongString, str, "") {
			// if (arg == str) return true;
			//
			// *result_listener << "the difference: "
			/// << DiffStrings(str, arg);
			// return false;
			// }
			//
			// Overloading Matchers
			// ====================
			//
			// You can overload matchers with different numbers of parameters:
			//
			// MATCHER_P(Blah, a, description_string1) { ... }
			// MATCHER_P2(Blah, a, b, description_string2) { ... }
			//
			// Caveats
			// =======
			//
			// When defining a new matcher, you should also consider implementing
			// MatcherInterface or using MakePolymorphicMatcher(). These
			// approaches require more work than the MATCHER* macros, but also
			// give you more control on the types of the value being matched and
			// the matcher parameters, which may leads to better compiler error
			// messages when the matcher is used wrong. They also allow
			// overloading matchers based on parameter types (as opposed to just
			// based on the number of parameters).
			//
			// MATCHER*() can only be used in a namespace scope as templates cannot be
			// declared inside of a local class.
			//
			// More Information
			// ================
			//
			// To learn more about using these macros, please search for 'MATCHER'
			// on
			// https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md

			#define MATCHER(name, description)\
			class name##Matcher {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl()\
			{}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			private:\
			::std::string FormatDescription(bool negation) const {\
			::std::string gmock_description = (description);\
			if (!gmock_description.empty()) {\
			return gmock_description;\
			}\
			return ::testing::internal::FormatMatcherDescription(\
			negation, #name, \
			::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
			::std::tuple<>()));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>());\
			}\
			name##Matcher() {\
			}\
			private:\
			};\
			inline name##Matcher name() {\
			return name##Matcher();\
			}\
			template <typename arg_type>\
			bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P(name, p0, description)\
			template <typename p0##_type>\
			class name##MatcherP {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			explicit gmock_Impl(p0##_type gmock_p0)\
			: p0(::std::move(gmock_p0)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			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(\
			::std::tuple<p0##_type>(p0)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0));\
			}\
			explicit name##MatcherP(p0##_type gmock_p0) : p0(::std::move(gmock_p0)) {\
			}\
			p0##_type const p0;\
			private:\
			};\
			template <typename p0##_type>\
			inline name##MatcherP<p0##_type> name(p0##_type p0) {\
			return name##MatcherP<p0##_type>(p0);\
			}\
			template <typename p0##_type>\
			template <typename arg_type>\
			bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P2(name, p0, p1, description)\
			template <typename p0##_type, typename p1##_type>\
			class name##MatcherP2 {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
			: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			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(\
			::std::tuple<p0##_type, p1##_type>(p0, p1)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0, p1));\
			}\
			name##MatcherP2(p0##_type gmock_p0, \
			p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
			p1(::std::move(gmock_p1)) {\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			private:\
			};\
			template <typename p0##_type, typename p1##_type>\
			inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
			p1##_type p1) {\
			return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
			}\
			template <typename p0##_type, typename p1##_type>\
			template <typename arg_type>\
			bool name##MatcherP2<p0##_type, \
			p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P3(name, p0, p1, p2, description)\
			template <typename p0##_type, typename p1##_type, typename p2##_type>\
			class name##MatcherP3 {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
			: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
			p2(::std::move(gmock_p2)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			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(\
			::std::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, p2)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0, p1, p2));\
			}\
			name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
			p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
			p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)) {\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			private:\
			};\
			template <typename p0##_type, typename p1##_type, typename p2##_type>\
			inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
			p1##_type p1, p2##_type p2) {\
			return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
			}\
			template <typename p0##_type, typename p1##_type, typename p2##_type>\
			template <typename arg_type>\
			bool name##MatcherP3<p0##_type, p1##_type, \
			p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P4(name, p0, p1, p2, p3, description)\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type>\
			class name##MatcherP4 {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
			p3##_type gmock_p3)\
			: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
			p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			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(\
			::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
			p1, p2, p3)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0, p1, p2, p3));\
			}\
			name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
			p2##_type gmock_p2, p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
			p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
			p3(::std::move(gmock_p3)) {\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			private:\
			};\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type>\
			inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
			p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
			p3##_type p3) {\
			return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
			p1, p2, p3);\
			}\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type>\
			template <typename arg_type>\
			bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
			p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type>\
			class name##MatcherP5 {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
			p3##_type gmock_p3, p4##_type gmock_p4)\
			: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
			p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
			p4(::std::move(gmock_p4)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			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(\
			::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type>(p0, p1, p2, p3, p4)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
			}\
			name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
			p2##_type gmock_p2, p3##_type gmock_p3, \
			p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
			p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
			p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)) {\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			private:\
			};\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type>\
			inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
			p4##_type p4) {\
			return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type>(p0, p1, p2, p3, p4);\
			}\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type>\
			template <typename arg_type>\
			bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type>\
			class name##MatcherP6 {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
			p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
			: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
			p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
			p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			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(\
			::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
			}\
			name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
			p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
			p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
			p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
			p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
			p5(::std::move(gmock_p5)) {\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			private:\
			};\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type>\
			inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
			p3##_type p3, p4##_type p4, p5##_type p5) {\
			return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
			}\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type>\
			template <typename arg_type>\
			bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
			p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type>\
			class name##MatcherP7 {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
			p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
			p6##_type gmock_p6)\
			: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
			p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
			p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
			p6(::std::move(gmock_p6)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			p6##_type const p6;\
			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(\
			::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
			p6)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
			}\
			name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
			p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
			p5##_type gmock_p5, p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
			p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
			p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
			p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)) {\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			p6##_type const p6;\
			private:\
			};\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type>\
			inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
			p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
			p6##_type p6) {\
			return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
			}\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type>\
			template <typename arg_type>\
			bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
			p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type, typename p7##_type>\
			class name##MatcherP8 {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
			p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
			p6##_type gmock_p6, p7##_type gmock_p7)\
			: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
			p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
			p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
			p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			p6##_type const p6;\
			p7##_type const p7;\
			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(\
			::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
			p3, p4, p5, p6, p7)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
			}\
			name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
			p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
			p5##_type gmock_p5, p6##_type gmock_p6, \
			p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
			p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
			p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
			p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
			p7(::std::move(gmock_p7)) {\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			p6##_type const p6;\
			p7##_type const p7;\
			private:\
			};\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type, typename p7##_type>\
			inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
			p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
			p6##_type p6, p7##_type p7) {\
			return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
			p6, p7);\
			}\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type, typename p7##_type>\
			template <typename arg_type>\
			bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
			p5##_type, p6##_type, \
			p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type, typename p7##_type, typename p8##_type>\
			class name##MatcherP9 {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
			p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
			p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
			: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
			p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
			p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
			p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \
			p8(::std::move(gmock_p8)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			p6##_type const p6;\
			p7##_type const p7;\
			p8##_type const p8;\
			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(\
			::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type, \
			p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
			}\
			name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
			p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
			p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
			p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
			p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
			p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
			p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
			p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)) {\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			p6##_type const p6;\
			p7##_type const p7;\
			p8##_type const p8;\
			private:\
			};\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type, typename p7##_type, typename p8##_type>\
			inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type, \
			p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
			p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
			p8##_type p8) {\
			return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
			p3, p4, p5, p6, p7, p8);\
			}\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type, typename p7##_type, typename p8##_type>\
			template <typename arg_type>\
			bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
			p5##_type, p6##_type, p7##_type, \
			p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
			const

			#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type, typename p7##_type, typename p8##_type, \
			typename p9##_type>\
			class name##MatcherP10 {\
			public:\
			template <typename arg_type>\
			class gmock_Impl : public ::testing::MatcherInterface<\
			GTEST_REFERENCE_TO_CONST_(arg_type)> {\
			public:\
			gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
			p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
			p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
			p9##_type gmock_p9)\
			: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
			p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
			p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
			p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \
			p8(::std::move(gmock_p8)), p9(::std::move(gmock_p9)) {}\
			bool MatchAndExplain(\
			GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
			::testing::MatchResultListener* result_listener) const override;\
			void DescribeTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(false);\
			}\
			void DescribeNegationTo(::std::ostream* gmock_os) const override {\
			*gmock_os << FormatDescription(true);\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			p6##_type const p6;\
			p7##_type const p7;\
			p8##_type const p8;\
			p9##_type const p9;\
			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(\
			::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
			p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
			}\
			};\
			template <typename arg_type>\
			operator ::testing::Matcher<arg_type>() const {\
			return ::testing::Matcher<arg_type>(\
			new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
			}\
			name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
			p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
			p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
			p8##_type gmock_p8, p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
			p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
			p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
			p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
			p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
			p9(::std::move(gmock_p9)) {\
			}\
			p0##_type const p0;\
			p1##_type const p1;\
			p2##_type const p2;\
			p3##_type const p3;\
			p4##_type const p4;\
			p5##_type const p5;\
			p6##_type const p6;\
			p7##_type const p7;\
			p8##_type const p8;\
			p9##_type const p9;\
			private:\
			};\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type, typename p7##_type, typename p8##_type, \
			typename p9##_type>\
			inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
			p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
			p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
			p9##_type p9) {\
			return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
			p1, p2, p3, p4, p5, p6, p7, p8, p9);\
			}\
			template <typename p0##_type, typename p1##_type, typename p2##_type, \
			typename p3##_type, typename p4##_type, typename p5##_type, \
			typename p6##_type, typename p7##_type, typename p8##_type, \
			typename p9##_type>\
			template <typename arg_type>\
			bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
			p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
			p9##_type>::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_

R9484/googletest/googlemock/include/gmock/gmock-generated-matchers.hee3d0e538b70master

gmock-generated-matchers.hView Options

R9484/googletest/googlemock/include/gmock/gmock-generated-matchers.h
ee3d0e538b70master

gmock-generated-matchers.h
View Options