| 1 |
// This file was GENERATED by command: |
| 2 |
// pump.py gmock-generated-matchers.h.pump |
| 3 |
// DO NOT EDIT BY HAND!!! |
| 4 |
|
| 5 |
// Copyright 2008, Google Inc. |
| 6 |
// All rights reserved. |
| 7 |
// |
| 8 |
// Redistribution and use in source and binary forms, with or without |
| 9 |
// modification, are permitted provided that the following conditions are |
| 10 |
// met: |
| 11 |
// |
| 12 |
// * Redistributions of source code must retain the above copyright |
| 13 |
// notice, this list of conditions and the following disclaimer. |
| 14 |
// * Redistributions in binary form must reproduce the above |
| 15 |
// copyright notice, this list of conditions and the following disclaimer |
| 16 |
// in the documentation and/or other materials provided with the |
| 17 |
// distribution. |
| 18 |
// * Neither the name of Google Inc. nor the names of its |
| 19 |
// contributors may be used to endorse or promote products derived from |
| 20 |
// this software without specific prior written permission. |
| 21 |
// |
| 22 |
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 23 |
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 24 |
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 25 |
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 26 |
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 27 |
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 28 |
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 29 |
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 30 |
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 31 |
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 32 |
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 33 |
|
| 34 |
// Google Mock - a framework for writing C++ mock classes. |
| 35 |
// |
| 36 |
// This file implements some commonly used variadic matchers. |
| 37 |
|
| 38 |
// GOOGLETEST_CM0002 DO NOT DELETE |
| 39 |
|
| 40 |
// IWYU pragma: private, include "gmock/gmock.h" |
| 41 |
|
| 42 |
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ |
| 43 |
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ |
| 44 |
|
| 45 |
#include <iterator> |
| 46 |
#include <sstream> |
| 47 |
#include <string> |
| 48 |
#include <utility> |
| 49 |
#include <vector> |
| 50 |
#include "gmock/gmock-matchers.h" |
| 51 |
|
| 52 |
// The MATCHER* family of macros can be used in a namespace scope to |
| 53 |
// define custom matchers easily. |
| 54 |
// |
| 55 |
// Basic Usage |
| 56 |
// =========== |
| 57 |
// |
| 58 |
// The syntax |
| 59 |
// |
| 60 |
// MATCHER(name, description_string) { statements; } |
| 61 |
// |
| 62 |
// defines a matcher with the given name that executes the statements, |
| 63 |
// which must return a bool to indicate if the match succeeds. Inside |
| 64 |
// the statements, you can refer to the value being matched by 'arg', |
| 65 |
// and refer to its type by 'arg_type'. |
| 66 |
// |
| 67 |
// The description string documents what the matcher does, and is used |
| 68 |
// to generate the failure message when the match fails. Since a |
| 69 |
// MATCHER() is usually defined in a header file shared by multiple |
| 70 |
// C++ source files, we require the description to be a C-string |
| 71 |
// literal to avoid possible side effects. It can be empty, in which |
| 72 |
// case we'll use the sequence of words in the matcher name as the |
| 73 |
// description. |
| 74 |
// |
| 75 |
// For example: |
| 76 |
// |
| 77 |
// MATCHER(IsEven, "") { return (arg % 2) == 0; } |
| 78 |
// |
| 79 |
// allows you to write |
| 80 |
// |
| 81 |
// // Expects mock_foo.Bar(n) to be called where n is even. |
| 82 |
// EXPECT_CALL(mock_foo, Bar(IsEven())); |
| 83 |
// |
| 84 |
// or, |
| 85 |
// |
| 86 |
// // Verifies that the value of some_expression is even. |
| 87 |
// EXPECT_THAT(some_expression, IsEven()); |
| 88 |
// |
| 89 |
// If the above assertion fails, it will print something like: |
| 90 |
// |
| 91 |
// Value of: some_expression |
| 92 |
// Expected: is even |
| 93 |
// Actual: 7 |
| 94 |
// |
| 95 |
// where the description "is even" is automatically calculated from the |
| 96 |
// matcher name IsEven. |
| 97 |
// |
| 98 |
// Argument Type |
| 99 |
// ============= |
| 100 |
// |
| 101 |
// Note that the type of the value being matched (arg_type) is |
| 102 |
// determined by the context in which you use the matcher and is |
| 103 |
// supplied to you by the compiler, so you don't need to worry about |
| 104 |
// declaring it (nor can you). This allows the matcher to be |
| 105 |
// polymorphic. For example, IsEven() can be used to match any type |
| 106 |
// where the value of "(arg % 2) == 0" can be implicitly converted to |
| 107 |
// a bool. In the "Bar(IsEven())" example above, if method Bar() |
| 108 |
// takes an int, 'arg_type' will be int; if it takes an unsigned long, |
| 109 |
// 'arg_type' will be unsigned long; and so on. |
| 110 |
// |
| 111 |
// Parameterizing Matchers |
| 112 |
// ======================= |
| 113 |
// |
| 114 |
// Sometimes you'll want to parameterize the matcher. For that you |
| 115 |
// can use another macro: |
| 116 |
// |
| 117 |
// MATCHER_P(name, param_name, description_string) { statements; } |
| 118 |
// |
| 119 |
// For example: |
| 120 |
// |
| 121 |
// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } |
| 122 |
// |
| 123 |
// will allow you to write: |
| 124 |
// |
| 125 |
// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); |
| 126 |
// |
| 127 |
// which may lead to this message (assuming n is 10): |
| 128 |
// |
| 129 |
// Value of: Blah("a") |
| 130 |
// Expected: has absolute value 10 |
| 131 |
// Actual: -9 |
| 132 |
// |
| 133 |
// Note that both the matcher description and its parameter are |
| 134 |
// printed, making the message human-friendly. |
| 135 |
// |
| 136 |
// In the matcher definition body, you can write 'foo_type' to |
| 137 |
// reference the type of a parameter named 'foo'. For example, in the |
| 138 |
// body of MATCHER_P(HasAbsoluteValue, value) above, you can write |
| 139 |
// 'value_type' to refer to the type of 'value'. |
| 140 |
// |
| 141 |
// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to |
| 142 |
// support multi-parameter matchers. |
| 143 |
// |
| 144 |
// Describing Parameterized Matchers |
| 145 |
// ================================= |
| 146 |
// |
| 147 |
// The last argument to MATCHER*() is a string-typed expression. The |
| 148 |
// expression can reference all of the matcher's parameters and a |
| 149 |
// special bool-typed variable named 'negation'. When 'negation' is |
| 150 |
// false, the expression should evaluate to the matcher's description; |
| 151 |
// otherwise it should evaluate to the description of the negation of |
| 152 |
// the matcher. For example, |
| 153 |
// |
| 154 |
// using testing::PrintToString; |
| 155 |
// |
| 156 |
// MATCHER_P2(InClosedRange, low, hi, |
| 157 |
// std::string(negation ? "is not" : "is") + " in range [" + |
| 158 |
// PrintToString(low) + ", " + PrintToString(hi) + "]") { |
| 159 |
// return low <= arg && arg <= hi; |
| 160 |
// } |
| 161 |
// ... |
| 162 |
// EXPECT_THAT(3, InClosedRange(4, 6)); |
| 163 |
// EXPECT_THAT(3, Not(InClosedRange(2, 4))); |
| 164 |
// |
| 165 |
// would generate two failures that contain the text: |
| 166 |
// |
| 167 |
// Expected: is in range [4, 6] |
| 168 |
// ... |
| 169 |
// Expected: is not in range [2, 4] |
| 170 |
// |
| 171 |
// If you specify "" as the description, the failure message will |
| 172 |
// contain the sequence of words in the matcher name followed by the |
| 173 |
// parameter values printed as a tuple. For example, |
| 174 |
// |
| 175 |
// MATCHER_P2(InClosedRange, low, hi, "") { ... } |
| 176 |
// ... |
| 177 |
// EXPECT_THAT(3, InClosedRange(4, 6)); |
| 178 |
// EXPECT_THAT(3, Not(InClosedRange(2, 4))); |
| 179 |
// |
| 180 |
// would generate two failures that contain the text: |
| 181 |
// |
| 182 |
// Expected: in closed range (4, 6) |
| 183 |
// ... |
| 184 |
// Expected: not (in closed range (2, 4)) |
| 185 |
// |
| 186 |
// Types of Matcher Parameters |
| 187 |
// =========================== |
| 188 |
// |
| 189 |
// For the purpose of typing, you can view |
| 190 |
// |
| 191 |
// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } |
| 192 |
// |
| 193 |
// as shorthand for |
| 194 |
// |
| 195 |
// template <typename p1_type, ..., typename pk_type> |
| 196 |
// FooMatcherPk<p1_type, ..., pk_type> |
| 197 |
// Foo(p1_type p1, ..., pk_type pk) { ... } |
| 198 |
// |
| 199 |
// When you write Foo(v1, ..., vk), the compiler infers the types of |
| 200 |
// the parameters v1, ..., and vk for you. If you are not happy with |
| 201 |
// the result of the type inference, you can specify the types by |
| 202 |
// explicitly instantiating the template, as in Foo<long, bool>(5, |
| 203 |
// false). As said earlier, you don't get to (or need to) specify |
| 204 |
// 'arg_type' as that's determined by the context in which the matcher |
| 205 |
// is used. You can assign the result of expression Foo(p1, ..., pk) |
| 206 |
// to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This |
| 207 |
// can be useful when composing matchers. |
| 208 |
// |
| 209 |
// While you can instantiate a matcher template with reference types, |
| 210 |
// passing the parameters by pointer usually makes your code more |
| 211 |
// readable. If, however, you still want to pass a parameter by |
| 212 |
// reference, be aware that in the failure message generated by the |
| 213 |
// matcher you will see the value of the referenced object but not its |
| 214 |
// address. |
| 215 |
// |
| 216 |
// Explaining Match Results |
| 217 |
// ======================== |
| 218 |
// |
| 219 |
// Sometimes the matcher description alone isn't enough to explain why |
| 220 |
// the match has failed or succeeded. For example, when expecting a |
| 221 |
// long string, it can be very helpful to also print the diff between |
| 222 |
// the expected string and the actual one. To achieve that, you can |
| 223 |
// optionally stream additional information to a special variable |
| 224 |
// named result_listener, whose type is a pointer to class |
| 225 |
// MatchResultListener: |
| 226 |
// |
| 227 |
// MATCHER_P(EqualsLongString, str, "") { |
| 228 |
// if (arg == str) return true; |
| 229 |
// |
| 230 |
// *result_listener << "the difference: " |
| 231 |
/// << DiffStrings(str, arg); |
| 232 |
// return false; |
| 233 |
// } |
| 234 |
// |
| 235 |
// Overloading Matchers |
| 236 |
// ==================== |
| 237 |
// |
| 238 |
// You can overload matchers with different numbers of parameters: |
| 239 |
// |
| 240 |
// MATCHER_P(Blah, a, description_string1) { ... } |
| 241 |
// MATCHER_P2(Blah, a, b, description_string2) { ... } |
| 242 |
// |
| 243 |
// Caveats |
| 244 |
// ======= |
| 245 |
// |
| 246 |
// When defining a new matcher, you should also consider implementing |
| 247 |
// MatcherInterface or using MakePolymorphicMatcher(). These |
| 248 |
// approaches require more work than the MATCHER* macros, but also |
| 249 |
// give you more control on the types of the value being matched and |
| 250 |
// the matcher parameters, which may leads to better compiler error |
| 251 |
// messages when the matcher is used wrong. They also allow |
| 252 |
// overloading matchers based on parameter types (as opposed to just |
| 253 |
// based on the number of parameters). |
| 254 |
// |
| 255 |
// MATCHER*() can only be used in a namespace scope as templates cannot be |
| 256 |
// declared inside of a local class. |
| 257 |
// |
| 258 |
// More Information |
| 259 |
// ================ |
| 260 |
// |
| 261 |
// To learn more about using these macros, please search for 'MATCHER' |
| 262 |
// on |
| 263 |
// https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md |
| 264 |
|
| 265 |
#define MATCHER(name, description)\ |
| 266 |
class name##Matcher {\ |
| 267 |
public:\ |
| 268 |
template <typename arg_type>\ |
| 269 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 270 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 271 |
public:\ |
| 272 |
gmock_Impl()\ |
| 273 |
{}\ |
| 274 |
virtual bool MatchAndExplain(\ |
| 275 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 276 |
::testing::MatchResultListener* result_listener) const;\ |
| 277 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 278 |
*gmock_os << FormatDescription(false);\ |
| 279 |
}\ |
| 280 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 281 |
*gmock_os << FormatDescription(true);\ |
| 282 |
}\ |
| 283 |
private:\ |
| 284 |
::std::string FormatDescription(bool negation) const {\ |
| 285 |
::std::string gmock_description = (description);\ |
| 286 |
if (!gmock_description.empty()) {\ |
| 287 |
return gmock_description;\ |
| 288 |
}\ |
| 289 |
return ::testing::internal::FormatMatcherDescription(\ |
| 290 |
negation, #name, \ |
| 291 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 292 |
::std::tuple<>()));\ |
| 293 |
}\ |
| 294 |
};\ |
| 295 |
template <typename arg_type>\ |
| 296 |
operator ::testing::Matcher<arg_type>() const {\ |
| 297 |
return ::testing::Matcher<arg_type>(\ |
| 298 |
new gmock_Impl<arg_type>());\ |
| 299 |
}\ |
| 300 |
name##Matcher() {\ |
| 301 |
}\ |
| 302 |
private:\ |
| 303 |
};\ |
| 304 |
inline name##Matcher name() {\ |
| 305 |
return name##Matcher();\ |
| 306 |
}\ |
| 307 |
template <typename arg_type>\ |
| 308 |
bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 309 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 310 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 311 |
const |
| 312 |
|
| 313 |
#define MATCHER_P(name, p0, description)\ |
| 314 |
template <typename p0##_type>\ |
| 315 |
class name##MatcherP {\ |
| 316 |
public:\ |
| 317 |
template <typename arg_type>\ |
| 318 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 319 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 320 |
public:\ |
| 321 |
explicit gmock_Impl(p0##_type gmock_p0)\ |
| 322 |
: p0(::std::move(gmock_p0)) {}\ |
| 323 |
virtual bool MatchAndExplain(\ |
| 324 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 325 |
::testing::MatchResultListener* result_listener) const;\ |
| 326 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 327 |
*gmock_os << FormatDescription(false);\ |
| 328 |
}\ |
| 329 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 330 |
*gmock_os << FormatDescription(true);\ |
| 331 |
}\ |
| 332 |
p0##_type const p0;\ |
| 333 |
private:\ |
| 334 |
::std::string FormatDescription(bool negation) const {\ |
| 335 |
::std::string gmock_description = (description);\ |
| 336 |
if (!gmock_description.empty()) {\ |
| 337 |
return gmock_description;\ |
| 338 |
}\ |
| 339 |
return ::testing::internal::FormatMatcherDescription(\ |
| 340 |
negation, #name, \ |
| 341 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 342 |
::std::tuple<p0##_type>(p0)));\ |
| 343 |
}\ |
| 344 |
};\ |
| 345 |
template <typename arg_type>\ |
| 346 |
operator ::testing::Matcher<arg_type>() const {\ |
| 347 |
return ::testing::Matcher<arg_type>(\ |
| 348 |
new gmock_Impl<arg_type>(p0));\ |
| 349 |
}\ |
| 350 |
explicit name##MatcherP(p0##_type gmock_p0) : p0(::std::move(gmock_p0)) {\ |
| 351 |
}\ |
| 352 |
p0##_type const p0;\ |
| 353 |
private:\ |
| 354 |
};\ |
| 355 |
template <typename p0##_type>\ |
| 356 |
inline name##MatcherP<p0##_type> name(p0##_type p0) {\ |
| 357 |
return name##MatcherP<p0##_type>(p0);\ |
| 358 |
}\ |
| 359 |
template <typename p0##_type>\ |
| 360 |
template <typename arg_type>\ |
| 361 |
bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 362 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 363 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 364 |
const |
| 365 |
|
| 366 |
#define MATCHER_P2(name, p0, p1, description)\ |
| 367 |
template <typename p0##_type, typename p1##_type>\ |
| 368 |
class name##MatcherP2 {\ |
| 369 |
public:\ |
| 370 |
template <typename arg_type>\ |
| 371 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 372 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 373 |
public:\ |
| 374 |
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\ |
| 375 |
: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)) {}\ |
| 376 |
virtual bool MatchAndExplain(\ |
| 377 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 378 |
::testing::MatchResultListener* result_listener) const;\ |
| 379 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 380 |
*gmock_os << FormatDescription(false);\ |
| 381 |
}\ |
| 382 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 383 |
*gmock_os << FormatDescription(true);\ |
| 384 |
}\ |
| 385 |
p0##_type const p0;\ |
| 386 |
p1##_type const p1;\ |
| 387 |
private:\ |
| 388 |
::std::string FormatDescription(bool negation) const {\ |
| 389 |
::std::string gmock_description = (description);\ |
| 390 |
if (!gmock_description.empty()) {\ |
| 391 |
return gmock_description;\ |
| 392 |
}\ |
| 393 |
return ::testing::internal::FormatMatcherDescription(\ |
| 394 |
negation, #name, \ |
| 395 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 396 |
::std::tuple<p0##_type, p1##_type>(p0, p1)));\ |
| 397 |
}\ |
| 398 |
};\ |
| 399 |
template <typename arg_type>\ |
| 400 |
operator ::testing::Matcher<arg_type>() const {\ |
| 401 |
return ::testing::Matcher<arg_type>(\ |
| 402 |
new gmock_Impl<arg_type>(p0, p1));\ |
| 403 |
}\ |
| 404 |
name##MatcherP2(p0##_type gmock_p0, \ |
| 405 |
p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \ |
| 406 |
p1(::std::move(gmock_p1)) {\ |
| 407 |
}\ |
| 408 |
p0##_type const p0;\ |
| 409 |
p1##_type const p1;\ |
| 410 |
private:\ |
| 411 |
};\ |
| 412 |
template <typename p0##_type, typename p1##_type>\ |
| 413 |
inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \ |
| 414 |
p1##_type p1) {\ |
| 415 |
return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\ |
| 416 |
}\ |
| 417 |
template <typename p0##_type, typename p1##_type>\ |
| 418 |
template <typename arg_type>\ |
| 419 |
bool name##MatcherP2<p0##_type, \ |
| 420 |
p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 421 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 422 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 423 |
const |
| 424 |
|
| 425 |
#define MATCHER_P3(name, p0, p1, p2, description)\ |
| 426 |
template <typename p0##_type, typename p1##_type, typename p2##_type>\ |
| 427 |
class name##MatcherP3 {\ |
| 428 |
public:\ |
| 429 |
template <typename arg_type>\ |
| 430 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 431 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 432 |
public:\ |
| 433 |
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\ |
| 434 |
: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ |
| 435 |
p2(::std::move(gmock_p2)) {}\ |
| 436 |
virtual bool MatchAndExplain(\ |
| 437 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 438 |
::testing::MatchResultListener* result_listener) const;\ |
| 439 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 440 |
*gmock_os << FormatDescription(false);\ |
| 441 |
}\ |
| 442 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 443 |
*gmock_os << FormatDescription(true);\ |
| 444 |
}\ |
| 445 |
p0##_type const p0;\ |
| 446 |
p1##_type const p1;\ |
| 447 |
p2##_type const p2;\ |
| 448 |
private:\ |
| 449 |
::std::string FormatDescription(bool negation) const {\ |
| 450 |
::std::string gmock_description = (description);\ |
| 451 |
if (!gmock_description.empty()) {\ |
| 452 |
return gmock_description;\ |
| 453 |
}\ |
| 454 |
return ::testing::internal::FormatMatcherDescription(\ |
| 455 |
negation, #name, \ |
| 456 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 457 |
::std::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, p2)));\ |
| 458 |
}\ |
| 459 |
};\ |
| 460 |
template <typename arg_type>\ |
| 461 |
operator ::testing::Matcher<arg_type>() const {\ |
| 462 |
return ::testing::Matcher<arg_type>(\ |
| 463 |
new gmock_Impl<arg_type>(p0, p1, p2));\ |
| 464 |
}\ |
| 465 |
name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \ |
| 466 |
p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \ |
| 467 |
p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)) {\ |
| 468 |
}\ |
| 469 |
p0##_type const p0;\ |
| 470 |
p1##_type const p1;\ |
| 471 |
p2##_type const p2;\ |
| 472 |
private:\ |
| 473 |
};\ |
| 474 |
template <typename p0##_type, typename p1##_type, typename p2##_type>\ |
| 475 |
inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \ |
| 476 |
p1##_type p1, p2##_type p2) {\ |
| 477 |
return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\ |
| 478 |
}\ |
| 479 |
template <typename p0##_type, typename p1##_type, typename p2##_type>\ |
| 480 |
template <typename arg_type>\ |
| 481 |
bool name##MatcherP3<p0##_type, p1##_type, \ |
| 482 |
p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 483 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 484 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 485 |
const |
| 486 |
|
| 487 |
#define MATCHER_P4(name, p0, p1, p2, p3, description)\ |
| 488 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 489 |
typename p3##_type>\ |
| 490 |
class name##MatcherP4 {\ |
| 491 |
public:\ |
| 492 |
template <typename arg_type>\ |
| 493 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 494 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 495 |
public:\ |
| 496 |
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
| 497 |
p3##_type gmock_p3)\ |
| 498 |
: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ |
| 499 |
p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)) {}\ |
| 500 |
virtual bool MatchAndExplain(\ |
| 501 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 502 |
::testing::MatchResultListener* result_listener) const;\ |
| 503 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 504 |
*gmock_os << FormatDescription(false);\ |
| 505 |
}\ |
| 506 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 507 |
*gmock_os << FormatDescription(true);\ |
| 508 |
}\ |
| 509 |
p0##_type const p0;\ |
| 510 |
p1##_type const p1;\ |
| 511 |
p2##_type const p2;\ |
| 512 |
p3##_type const p3;\ |
| 513 |
private:\ |
| 514 |
::std::string FormatDescription(bool negation) const {\ |
| 515 |
::std::string gmock_description = (description);\ |
| 516 |
if (!gmock_description.empty()) {\ |
| 517 |
return gmock_description;\ |
| 518 |
}\ |
| 519 |
return ::testing::internal::FormatMatcherDescription(\ |
| 520 |
negation, #name, \ |
| 521 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 522 |
::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \ |
| 523 |
p1, p2, p3)));\ |
| 524 |
}\ |
| 525 |
};\ |
| 526 |
template <typename arg_type>\ |
| 527 |
operator ::testing::Matcher<arg_type>() const {\ |
| 528 |
return ::testing::Matcher<arg_type>(\ |
| 529 |
new gmock_Impl<arg_type>(p0, p1, p2, p3));\ |
| 530 |
}\ |
| 531 |
name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \ |
| 532 |
p2##_type gmock_p2, p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \ |
| 533 |
p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ |
| 534 |
p3(::std::move(gmock_p3)) {\ |
| 535 |
}\ |
| 536 |
p0##_type const p0;\ |
| 537 |
p1##_type const p1;\ |
| 538 |
p2##_type const p2;\ |
| 539 |
p3##_type const p3;\ |
| 540 |
private:\ |
| 541 |
};\ |
| 542 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 543 |
typename p3##_type>\ |
| 544 |
inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \ |
| 545 |
p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \ |
| 546 |
p3##_type p3) {\ |
| 547 |
return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \ |
| 548 |
p1, p2, p3);\ |
| 549 |
}\ |
| 550 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 551 |
typename p3##_type>\ |
| 552 |
template <typename arg_type>\ |
| 553 |
bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \ |
| 554 |
p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 555 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 556 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 557 |
const |
| 558 |
|
| 559 |
#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\ |
| 560 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 561 |
typename p3##_type, typename p4##_type>\ |
| 562 |
class name##MatcherP5 {\ |
| 563 |
public:\ |
| 564 |
template <typename arg_type>\ |
| 565 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 566 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 567 |
public:\ |
| 568 |
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
| 569 |
p3##_type gmock_p3, p4##_type gmock_p4)\ |
| 570 |
: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ |
| 571 |
p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ |
| 572 |
p4(::std::move(gmock_p4)) {}\ |
| 573 |
virtual bool MatchAndExplain(\ |
| 574 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 575 |
::testing::MatchResultListener* result_listener) const;\ |
| 576 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 577 |
*gmock_os << FormatDescription(false);\ |
| 578 |
}\ |
| 579 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 580 |
*gmock_os << FormatDescription(true);\ |
| 581 |
}\ |
| 582 |
p0##_type const p0;\ |
| 583 |
p1##_type const p1;\ |
| 584 |
p2##_type const p2;\ |
| 585 |
p3##_type const p3;\ |
| 586 |
p4##_type const p4;\ |
| 587 |
private:\ |
| 588 |
::std::string FormatDescription(bool negation) const {\ |
| 589 |
::std::string gmock_description = (description);\ |
| 590 |
if (!gmock_description.empty()) {\ |
| 591 |
return gmock_description;\ |
| 592 |
}\ |
| 593 |
return ::testing::internal::FormatMatcherDescription(\ |
| 594 |
negation, #name, \ |
| 595 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 596 |
::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 597 |
p4##_type>(p0, p1, p2, p3, p4)));\ |
| 598 |
}\ |
| 599 |
};\ |
| 600 |
template <typename arg_type>\ |
| 601 |
operator ::testing::Matcher<arg_type>() const {\ |
| 602 |
return ::testing::Matcher<arg_type>(\ |
| 603 |
new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\ |
| 604 |
}\ |
| 605 |
name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \ |
| 606 |
p2##_type gmock_p2, p3##_type gmock_p3, \ |
| 607 |
p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \ |
| 608 |
p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ |
| 609 |
p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)) {\ |
| 610 |
}\ |
| 611 |
p0##_type const p0;\ |
| 612 |
p1##_type const p1;\ |
| 613 |
p2##_type const p2;\ |
| 614 |
p3##_type const p3;\ |
| 615 |
p4##_type const p4;\ |
| 616 |
private:\ |
| 617 |
};\ |
| 618 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 619 |
typename p3##_type, typename p4##_type>\ |
| 620 |
inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 621 |
p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ |
| 622 |
p4##_type p4) {\ |
| 623 |
return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 624 |
p4##_type>(p0, p1, p2, p3, p4);\ |
| 625 |
}\ |
| 626 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 627 |
typename p3##_type, typename p4##_type>\ |
| 628 |
template <typename arg_type>\ |
| 629 |
bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 630 |
p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 631 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 632 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 633 |
const |
| 634 |
|
| 635 |
#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\ |
| 636 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 637 |
typename p3##_type, typename p4##_type, typename p5##_type>\ |
| 638 |
class name##MatcherP6 {\ |
| 639 |
public:\ |
| 640 |
template <typename arg_type>\ |
| 641 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 642 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 643 |
public:\ |
| 644 |
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
| 645 |
p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\ |
| 646 |
: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ |
| 647 |
p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ |
| 648 |
p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)) {}\ |
| 649 |
virtual bool MatchAndExplain(\ |
| 650 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 651 |
::testing::MatchResultListener* result_listener) const;\ |
| 652 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 653 |
*gmock_os << FormatDescription(false);\ |
| 654 |
}\ |
| 655 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 656 |
*gmock_os << FormatDescription(true);\ |
| 657 |
}\ |
| 658 |
p0##_type const p0;\ |
| 659 |
p1##_type const p1;\ |
| 660 |
p2##_type const p2;\ |
| 661 |
p3##_type const p3;\ |
| 662 |
p4##_type const p4;\ |
| 663 |
p5##_type const p5;\ |
| 664 |
private:\ |
| 665 |
::std::string FormatDescription(bool negation) const {\ |
| 666 |
::std::string gmock_description = (description);\ |
| 667 |
if (!gmock_description.empty()) {\ |
| 668 |
return gmock_description;\ |
| 669 |
}\ |
| 670 |
return ::testing::internal::FormatMatcherDescription(\ |
| 671 |
negation, #name, \ |
| 672 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 673 |
::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 674 |
p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\ |
| 675 |
}\ |
| 676 |
};\ |
| 677 |
template <typename arg_type>\ |
| 678 |
operator ::testing::Matcher<arg_type>() const {\ |
| 679 |
return ::testing::Matcher<arg_type>(\ |
| 680 |
new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\ |
| 681 |
}\ |
| 682 |
name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \ |
| 683 |
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
| 684 |
p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \ |
| 685 |
p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ |
| 686 |
p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ |
| 687 |
p5(::std::move(gmock_p5)) {\ |
| 688 |
}\ |
| 689 |
p0##_type const p0;\ |
| 690 |
p1##_type const p1;\ |
| 691 |
p2##_type const p2;\ |
| 692 |
p3##_type const p3;\ |
| 693 |
p4##_type const p4;\ |
| 694 |
p5##_type const p5;\ |
| 695 |
private:\ |
| 696 |
};\ |
| 697 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 698 |
typename p3##_type, typename p4##_type, typename p5##_type>\ |
| 699 |
inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 700 |
p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \ |
| 701 |
p3##_type p3, p4##_type p4, p5##_type p5) {\ |
| 702 |
return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 703 |
p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\ |
| 704 |
}\ |
| 705 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 706 |
typename p3##_type, typename p4##_type, typename p5##_type>\ |
| 707 |
template <typename arg_type>\ |
| 708 |
bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ |
| 709 |
p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 710 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 711 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 712 |
const |
| 713 |
|
| 714 |
#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\ |
| 715 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 716 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 717 |
typename p6##_type>\ |
| 718 |
class name##MatcherP7 {\ |
| 719 |
public:\ |
| 720 |
template <typename arg_type>\ |
| 721 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 722 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 723 |
public:\ |
| 724 |
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
| 725 |
p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ |
| 726 |
p6##_type gmock_p6)\ |
| 727 |
: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ |
| 728 |
p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ |
| 729 |
p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \ |
| 730 |
p6(::std::move(gmock_p6)) {}\ |
| 731 |
virtual bool MatchAndExplain(\ |
| 732 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 733 |
::testing::MatchResultListener* result_listener) const;\ |
| 734 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 735 |
*gmock_os << FormatDescription(false);\ |
| 736 |
}\ |
| 737 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 738 |
*gmock_os << FormatDescription(true);\ |
| 739 |
}\ |
| 740 |
p0##_type const p0;\ |
| 741 |
p1##_type const p1;\ |
| 742 |
p2##_type const p2;\ |
| 743 |
p3##_type const p3;\ |
| 744 |
p4##_type const p4;\ |
| 745 |
p5##_type const p5;\ |
| 746 |
p6##_type const p6;\ |
| 747 |
private:\ |
| 748 |
::std::string FormatDescription(bool negation) const {\ |
| 749 |
::std::string gmock_description = (description);\ |
| 750 |
if (!gmock_description.empty()) {\ |
| 751 |
return gmock_description;\ |
| 752 |
}\ |
| 753 |
return ::testing::internal::FormatMatcherDescription(\ |
| 754 |
negation, #name, \ |
| 755 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 756 |
::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 757 |
p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \ |
| 758 |
p6)));\ |
| 759 |
}\ |
| 760 |
};\ |
| 761 |
template <typename arg_type>\ |
| 762 |
operator ::testing::Matcher<arg_type>() const {\ |
| 763 |
return ::testing::Matcher<arg_type>(\ |
| 764 |
new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\ |
| 765 |
}\ |
| 766 |
name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \ |
| 767 |
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
| 768 |
p5##_type gmock_p5, p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \ |
| 769 |
p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ |
| 770 |
p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ |
| 771 |
p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)) {\ |
| 772 |
}\ |
| 773 |
p0##_type const p0;\ |
| 774 |
p1##_type const p1;\ |
| 775 |
p2##_type const p2;\ |
| 776 |
p3##_type const p3;\ |
| 777 |
p4##_type const p4;\ |
| 778 |
p5##_type const p5;\ |
| 779 |
p6##_type const p6;\ |
| 780 |
private:\ |
| 781 |
};\ |
| 782 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 783 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 784 |
typename p6##_type>\ |
| 785 |
inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 786 |
p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \ |
| 787 |
p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ |
| 788 |
p6##_type p6) {\ |
| 789 |
return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 790 |
p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\ |
| 791 |
}\ |
| 792 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 793 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 794 |
typename p6##_type>\ |
| 795 |
template <typename arg_type>\ |
| 796 |
bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ |
| 797 |
p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 798 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 799 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 800 |
const |
| 801 |
|
| 802 |
#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\ |
| 803 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 804 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 805 |
typename p6##_type, typename p7##_type>\ |
| 806 |
class name##MatcherP8 {\ |
| 807 |
public:\ |
| 808 |
template <typename arg_type>\ |
| 809 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 810 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 811 |
public:\ |
| 812 |
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
| 813 |
p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ |
| 814 |
p6##_type gmock_p6, p7##_type gmock_p7)\ |
| 815 |
: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ |
| 816 |
p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ |
| 817 |
p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \ |
| 818 |
p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)) {}\ |
| 819 |
virtual bool MatchAndExplain(\ |
| 820 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 821 |
::testing::MatchResultListener* result_listener) const;\ |
| 822 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 823 |
*gmock_os << FormatDescription(false);\ |
| 824 |
}\ |
| 825 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 826 |
*gmock_os << FormatDescription(true);\ |
| 827 |
}\ |
| 828 |
p0##_type const p0;\ |
| 829 |
p1##_type const p1;\ |
| 830 |
p2##_type const p2;\ |
| 831 |
p3##_type const p3;\ |
| 832 |
p4##_type const p4;\ |
| 833 |
p5##_type const p5;\ |
| 834 |
p6##_type const p6;\ |
| 835 |
p7##_type const p7;\ |
| 836 |
private:\ |
| 837 |
::std::string FormatDescription(bool negation) const {\ |
| 838 |
::std::string gmock_description = (description);\ |
| 839 |
if (!gmock_description.empty()) {\ |
| 840 |
return gmock_description;\ |
| 841 |
}\ |
| 842 |
return ::testing::internal::FormatMatcherDescription(\ |
| 843 |
negation, #name, \ |
| 844 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 845 |
::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 846 |
p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \ |
| 847 |
p3, p4, p5, p6, p7)));\ |
| 848 |
}\ |
| 849 |
};\ |
| 850 |
template <typename arg_type>\ |
| 851 |
operator ::testing::Matcher<arg_type>() const {\ |
| 852 |
return ::testing::Matcher<arg_type>(\ |
| 853 |
new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\ |
| 854 |
}\ |
| 855 |
name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \ |
| 856 |
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
| 857 |
p5##_type gmock_p5, p6##_type gmock_p6, \ |
| 858 |
p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \ |
| 859 |
p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ |
| 860 |
p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ |
| 861 |
p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ |
| 862 |
p7(::std::move(gmock_p7)) {\ |
| 863 |
}\ |
| 864 |
p0##_type const p0;\ |
| 865 |
p1##_type const p1;\ |
| 866 |
p2##_type const p2;\ |
| 867 |
p3##_type const p3;\ |
| 868 |
p4##_type const p4;\ |
| 869 |
p5##_type const p5;\ |
| 870 |
p6##_type const p6;\ |
| 871 |
p7##_type const p7;\ |
| 872 |
private:\ |
| 873 |
};\ |
| 874 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 875 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 876 |
typename p6##_type, typename p7##_type>\ |
| 877 |
inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 878 |
p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \ |
| 879 |
p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ |
| 880 |
p6##_type p6, p7##_type p7) {\ |
| 881 |
return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 882 |
p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \ |
| 883 |
p6, p7);\ |
| 884 |
}\ |
| 885 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 886 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 887 |
typename p6##_type, typename p7##_type>\ |
| 888 |
template <typename arg_type>\ |
| 889 |
bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ |
| 890 |
p5##_type, p6##_type, \ |
| 891 |
p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 892 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 893 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 894 |
const |
| 895 |
|
| 896 |
#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\ |
| 897 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 898 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 899 |
typename p6##_type, typename p7##_type, typename p8##_type>\ |
| 900 |
class name##MatcherP9 {\ |
| 901 |
public:\ |
| 902 |
template <typename arg_type>\ |
| 903 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 904 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 905 |
public:\ |
| 906 |
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
| 907 |
p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ |
| 908 |
p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\ |
| 909 |
: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ |
| 910 |
p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ |
| 911 |
p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \ |
| 912 |
p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \ |
| 913 |
p8(::std::move(gmock_p8)) {}\ |
| 914 |
virtual bool MatchAndExplain(\ |
| 915 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 916 |
::testing::MatchResultListener* result_listener) const;\ |
| 917 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 918 |
*gmock_os << FormatDescription(false);\ |
| 919 |
}\ |
| 920 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 921 |
*gmock_os << FormatDescription(true);\ |
| 922 |
}\ |
| 923 |
p0##_type const p0;\ |
| 924 |
p1##_type const p1;\ |
| 925 |
p2##_type const p2;\ |
| 926 |
p3##_type const p3;\ |
| 927 |
p4##_type const p4;\ |
| 928 |
p5##_type const p5;\ |
| 929 |
p6##_type const p6;\ |
| 930 |
p7##_type const p7;\ |
| 931 |
p8##_type const p8;\ |
| 932 |
private:\ |
| 933 |
::std::string FormatDescription(bool negation) const {\ |
| 934 |
::std::string gmock_description = (description);\ |
| 935 |
if (!gmock_description.empty()) {\ |
| 936 |
return gmock_description;\ |
| 937 |
}\ |
| 938 |
return ::testing::internal::FormatMatcherDescription(\ |
| 939 |
negation, #name, \ |
| 940 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 941 |
::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 942 |
p4##_type, p5##_type, p6##_type, p7##_type, \ |
| 943 |
p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\ |
| 944 |
}\ |
| 945 |
};\ |
| 946 |
template <typename arg_type>\ |
| 947 |
operator ::testing::Matcher<arg_type>() const {\ |
| 948 |
return ::testing::Matcher<arg_type>(\ |
| 949 |
new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\ |
| 950 |
}\ |
| 951 |
name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \ |
| 952 |
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
| 953 |
p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ |
| 954 |
p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \ |
| 955 |
p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ |
| 956 |
p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ |
| 957 |
p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ |
| 958 |
p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)) {\ |
| 959 |
}\ |
| 960 |
p0##_type const p0;\ |
| 961 |
p1##_type const p1;\ |
| 962 |
p2##_type const p2;\ |
| 963 |
p3##_type const p3;\ |
| 964 |
p4##_type const p4;\ |
| 965 |
p5##_type const p5;\ |
| 966 |
p6##_type const p6;\ |
| 967 |
p7##_type const p7;\ |
| 968 |
p8##_type const p8;\ |
| 969 |
private:\ |
| 970 |
};\ |
| 971 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 972 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 973 |
typename p6##_type, typename p7##_type, typename p8##_type>\ |
| 974 |
inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 975 |
p4##_type, p5##_type, p6##_type, p7##_type, \ |
| 976 |
p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ |
| 977 |
p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \ |
| 978 |
p8##_type p8) {\ |
| 979 |
return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 980 |
p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \ |
| 981 |
p3, p4, p5, p6, p7, p8);\ |
| 982 |
}\ |
| 983 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 984 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 985 |
typename p6##_type, typename p7##_type, typename p8##_type>\ |
| 986 |
template <typename arg_type>\ |
| 987 |
bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ |
| 988 |
p5##_type, p6##_type, p7##_type, \ |
| 989 |
p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 990 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 991 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 992 |
const |
| 993 |
|
| 994 |
#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\ |
| 995 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 996 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 997 |
typename p6##_type, typename p7##_type, typename p8##_type, \ |
| 998 |
typename p9##_type>\ |
| 999 |
class name##MatcherP10 {\ |
| 1000 |
public:\ |
| 1001 |
template <typename arg_type>\ |
| 1002 |
class gmock_Impl : public ::testing::MatcherInterface<\ |
| 1003 |
GTEST_REFERENCE_TO_CONST_(arg_type)> {\ |
| 1004 |
public:\ |
| 1005 |
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
| 1006 |
p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ |
| 1007 |
p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ |
| 1008 |
p9##_type gmock_p9)\ |
| 1009 |
: p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ |
| 1010 |
p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ |
| 1011 |
p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \ |
| 1012 |
p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \ |
| 1013 |
p8(::std::move(gmock_p8)), p9(::std::move(gmock_p9)) {}\ |
| 1014 |
virtual bool MatchAndExplain(\ |
| 1015 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 1016 |
::testing::MatchResultListener* result_listener) const;\ |
| 1017 |
virtual void DescribeTo(::std::ostream* gmock_os) const {\ |
| 1018 |
*gmock_os << FormatDescription(false);\ |
| 1019 |
}\ |
| 1020 |
virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ |
| 1021 |
*gmock_os << FormatDescription(true);\ |
| 1022 |
}\ |
| 1023 |
p0##_type const p0;\ |
| 1024 |
p1##_type const p1;\ |
| 1025 |
p2##_type const p2;\ |
| 1026 |
p3##_type const p3;\ |
| 1027 |
p4##_type const p4;\ |
| 1028 |
p5##_type const p5;\ |
| 1029 |
p6##_type const p6;\ |
| 1030 |
p7##_type const p7;\ |
| 1031 |
p8##_type const p8;\ |
| 1032 |
p9##_type const p9;\ |
| 1033 |
private:\ |
| 1034 |
::std::string FormatDescription(bool negation) const {\ |
| 1035 |
::std::string gmock_description = (description);\ |
| 1036 |
if (!gmock_description.empty()) {\ |
| 1037 |
return gmock_description;\ |
| 1038 |
}\ |
| 1039 |
return ::testing::internal::FormatMatcherDescription(\ |
| 1040 |
negation, #name, \ |
| 1041 |
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ |
| 1042 |
::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 1043 |
p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \ |
| 1044 |
p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\ |
| 1045 |
}\ |
| 1046 |
};\ |
| 1047 |
template <typename arg_type>\ |
| 1048 |
operator ::testing::Matcher<arg_type>() const {\ |
| 1049 |
return ::testing::Matcher<arg_type>(\ |
| 1050 |
new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\ |
| 1051 |
}\ |
| 1052 |
name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \ |
| 1053 |
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
| 1054 |
p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ |
| 1055 |
p8##_type gmock_p8, p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \ |
| 1056 |
p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ |
| 1057 |
p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ |
| 1058 |
p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ |
| 1059 |
p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \ |
| 1060 |
p9(::std::move(gmock_p9)) {\ |
| 1061 |
}\ |
| 1062 |
p0##_type const p0;\ |
| 1063 |
p1##_type const p1;\ |
| 1064 |
p2##_type const p2;\ |
| 1065 |
p3##_type const p3;\ |
| 1066 |
p4##_type const p4;\ |
| 1067 |
p5##_type const p5;\ |
| 1068 |
p6##_type const p6;\ |
| 1069 |
p7##_type const p7;\ |
| 1070 |
p8##_type const p8;\ |
| 1071 |
p9##_type const p9;\ |
| 1072 |
private:\ |
| 1073 |
};\ |
| 1074 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 1075 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 1076 |
typename p6##_type, typename p7##_type, typename p8##_type, \ |
| 1077 |
typename p9##_type>\ |
| 1078 |
inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 1079 |
p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \ |
| 1080 |
p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ |
| 1081 |
p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ |
| 1082 |
p9##_type p9) {\ |
| 1083 |
return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 1084 |
p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \ |
| 1085 |
p1, p2, p3, p4, p5, p6, p7, p8, p9);\ |
| 1086 |
}\ |
| 1087 |
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
| 1088 |
typename p3##_type, typename p4##_type, typename p5##_type, \ |
| 1089 |
typename p6##_type, typename p7##_type, typename p8##_type, \ |
| 1090 |
typename p9##_type>\ |
| 1091 |
template <typename arg_type>\ |
| 1092 |
bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \ |
| 1093 |
p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \ |
| 1094 |
p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ |
| 1095 |
GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ |
| 1096 |
::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ |
| 1097 |
const |
| 1098 |
|
| 1099 |
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ |