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