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_ |
1100 | |