1 // Copyright 2007, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30
31 // Google Mock - a framework for writing C++ mock classes.
32 //
33 // This file tests some commonly used argument matchers.
34
35 #include "gmock/gmock-matchers.h"
36 #include "gmock/gmock-more-matchers.h"
37
38 #include <string.h>
39 #include <time.h>
40 #include <deque>
41 #include <functional>
42 #include <iostream>
43 #include <iterator>
44 #include <limits>
45 #include <list>
46 #include <map>
47 #include <memory>
48 #include <set>
49 #include <sstream>
50 #include <string>
51 #include <utility>
52 #include <vector>
53 #include "gmock/gmock.h"
54 #include "gtest/gtest.h"
55 #include "gtest/gtest-spi.h"
56
57 #if GTEST_HAS_STD_FORWARD_LIST_
58 # include <forward_list> // NOLINT
59 #endif
60
61 #if GTEST_LANG_CXX11
62 # include <type_traits>
63 #endif
64
65 namespace testing {
66 namespace gmock_matchers_test {
67
68 using std::greater;
69 using std::less;
70 using std::list;
71 using std::make_pair;
72 using std::map;
73 using std::multimap;
74 using std::multiset;
75 using std::ostream;
76 using std::pair;
77 using std::set;
78 using std::stringstream;
79 using std::vector;
80 using testing::A;
81 using testing::AllArgs;
82 using testing::AllOf;
83 using testing::An;
84 using testing::AnyOf;
85 using testing::ByRef;
86 using testing::ContainsRegex;
87 using testing::DoubleEq;
88 using testing::DoubleNear;
89 using testing::EndsWith;
90 using testing::Eq;
91 using testing::ExplainMatchResult;
92 using testing::Field;
93 using testing::FloatEq;
94 using testing::FloatNear;
95 using testing::Ge;
96 using testing::Gt;
97 using testing::HasSubstr;
98 using testing::IsEmpty;
99 using testing::IsNull;
100 using testing::Key;
101 using testing::Le;
102 using testing::Lt;
103 using testing::MakeMatcher;
104 using testing::MakePolymorphicMatcher;
105 using testing::MatchResultListener;
106 using testing::Matcher;
107 using testing::MatcherCast;
108 using testing::MatcherInterface;
109 using testing::Matches;
110 using testing::MatchesRegex;
111 using testing::NanSensitiveDoubleEq;
112 using testing::NanSensitiveDoubleNear;
113 using testing::NanSensitiveFloatEq;
114 using testing::NanSensitiveFloatNear;
115 using testing::Ne;
116 using testing::Not;
117 using testing::NotNull;
118 using testing::Pair;
119 using testing::Pointee;
120 using testing::Pointwise;
121 using testing::PolymorphicMatcher;
122 using testing::Property;
123 using testing::Ref;
124 using testing::ResultOf;
125 using testing::SizeIs;
126 using testing::StartsWith;
127 using testing::StrCaseEq;
128 using testing::StrCaseNe;
129 using testing::StrEq;
130 using testing::StrNe;
131 using testing::StringMatchResultListener;
132 using testing::Truly;
133 using testing::TypedEq;
134 using testing::UnorderedPointwise;
135 using testing::Value;
136 using testing::WhenSorted;
137 using testing::WhenSortedBy;
138 using testing::_;
139 using testing::get;
140 using testing::internal::DummyMatchResultListener;
141 using testing::internal::ElementMatcherPair;
142 using testing::internal::ElementMatcherPairs;
143 using testing::internal::ExplainMatchFailureTupleTo;
144 using testing::internal::FloatingEqMatcher;
145 using testing::internal::FormatMatcherDescription;
146 using testing::internal::IsReadableTypeName;
147 using testing::internal::linked_ptr;
148 using testing::internal::MatchMatrix;
149 using testing::internal::RE;
150 using testing::internal::scoped_ptr;
151 using testing::internal::StreamMatchResultListener;
152 using testing::internal::Strings;
153 using testing::internal::linked_ptr;
154 using testing::internal::scoped_ptr;
155 using testing::internal::string;
156 using testing::make_tuple;
157 using testing::tuple;
158
159 // For testing ExplainMatchResultTo().
160 class GreaterThanMatcher : public MatcherInterface<int> {
161 public:
GreaterThanMatcher(int rhs)162 explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {}
163
DescribeTo(ostream * os) const164 virtual void DescribeTo(ostream* os) const {
165 *os << "is > " << rhs_;
166 }
167
MatchAndExplain(int lhs,MatchResultListener * listener) const168 virtual bool MatchAndExplain(int lhs,
169 MatchResultListener* listener) const {
170 const int diff = lhs - rhs_;
171 if (diff > 0) {
172 *listener << "which is " << diff << " more than " << rhs_;
173 } else if (diff == 0) {
174 *listener << "which is the same as " << rhs_;
175 } else {
176 *listener << "which is " << -diff << " less than " << rhs_;
177 }
178
179 return lhs > rhs_;
180 }
181
182 private:
183 int rhs_;
184 };
185
GreaterThan(int n)186 Matcher<int> GreaterThan(int n) {
187 return MakeMatcher(new GreaterThanMatcher(n));
188 }
189
OfType(const std::string & type_name)190 std::string OfType(const std::string& type_name) {
191 #if GTEST_HAS_RTTI
192 return " (of type " + type_name + ")";
193 #else
194 return "";
195 #endif
196 }
197
198 // Returns the description of the given matcher.
199 template <typename T>
Describe(const Matcher<T> & m)200 std::string Describe(const Matcher<T>& m) {
201 return DescribeMatcher<T>(m);
202 }
203
204 // Returns the description of the negation of the given matcher.
205 template <typename T>
DescribeNegation(const Matcher<T> & m)206 std::string DescribeNegation(const Matcher<T>& m) {
207 return DescribeMatcher<T>(m, true);
208 }
209
210 // Returns the reason why x matches, or doesn't match, m.
211 template <typename MatcherType, typename Value>
Explain(const MatcherType & m,const Value & x)212 std::string Explain(const MatcherType& m, const Value& x) {
213 StringMatchResultListener listener;
214 ExplainMatchResult(m, x, &listener);
215 return listener.str();
216 }
217
TEST(MonotonicMatcherTest,IsPrintable)218 TEST(MonotonicMatcherTest, IsPrintable) {
219 stringstream ss;
220 ss << GreaterThan(5);
221 EXPECT_EQ("is > 5", ss.str());
222 }
223
TEST(MatchResultListenerTest,StreamingWorks)224 TEST(MatchResultListenerTest, StreamingWorks) {
225 StringMatchResultListener listener;
226 listener << "hi" << 5;
227 EXPECT_EQ("hi5", listener.str());
228
229 listener.Clear();
230 EXPECT_EQ("", listener.str());
231
232 listener << 42;
233 EXPECT_EQ("42", listener.str());
234
235 // Streaming shouldn't crash when the underlying ostream is NULL.
236 DummyMatchResultListener dummy;
237 dummy << "hi" << 5;
238 }
239
TEST(MatchResultListenerTest,CanAccessUnderlyingStream)240 TEST(MatchResultListenerTest, CanAccessUnderlyingStream) {
241 EXPECT_TRUE(DummyMatchResultListener().stream() == NULL);
242 EXPECT_TRUE(StreamMatchResultListener(NULL).stream() == NULL);
243
244 EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream());
245 }
246
TEST(MatchResultListenerTest,IsInterestedWorks)247 TEST(MatchResultListenerTest, IsInterestedWorks) {
248 EXPECT_TRUE(StringMatchResultListener().IsInterested());
249 EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested());
250
251 EXPECT_FALSE(DummyMatchResultListener().IsInterested());
252 EXPECT_FALSE(StreamMatchResultListener(NULL).IsInterested());
253 }
254
255 // Makes sure that the MatcherInterface<T> interface doesn't
256 // change.
257 class EvenMatcherImpl : public MatcherInterface<int> {
258 public:
MatchAndExplain(int x,MatchResultListener *) const259 virtual bool MatchAndExplain(int x,
260 MatchResultListener* /* listener */) const {
261 return x % 2 == 0;
262 }
263
DescribeTo(ostream * os) const264 virtual void DescribeTo(ostream* os) const {
265 *os << "is an even number";
266 }
267
268 // We deliberately don't define DescribeNegationTo() and
269 // ExplainMatchResultTo() here, to make sure the definition of these
270 // two methods is optional.
271 };
272
273 // Makes sure that the MatcherInterface API doesn't change.
TEST(MatcherInterfaceTest,CanBeImplementedUsingPublishedAPI)274 TEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) {
275 EvenMatcherImpl m;
276 }
277
278 // Tests implementing a monomorphic matcher using MatchAndExplain().
279
280 class NewEvenMatcherImpl : public MatcherInterface<int> {
281 public:
MatchAndExplain(int x,MatchResultListener * listener) const282 virtual bool MatchAndExplain(int x, MatchResultListener* listener) const {
283 const bool match = x % 2 == 0;
284 // Verifies that we can stream to a listener directly.
285 *listener << "value % " << 2;
286 if (listener->stream() != NULL) {
287 // Verifies that we can stream to a listener's underlying stream
288 // too.
289 *listener->stream() << " == " << (x % 2);
290 }
291 return match;
292 }
293
DescribeTo(ostream * os) const294 virtual void DescribeTo(ostream* os) const {
295 *os << "is an even number";
296 }
297 };
298
TEST(MatcherInterfaceTest,CanBeImplementedUsingNewAPI)299 TEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) {
300 Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl);
301 EXPECT_TRUE(m.Matches(2));
302 EXPECT_FALSE(m.Matches(3));
303 EXPECT_EQ("value % 2 == 0", Explain(m, 2));
304 EXPECT_EQ("value % 2 == 1", Explain(m, 3));
305 }
306
307 // Tests default-constructing a matcher.
TEST(MatcherTest,CanBeDefaultConstructed)308 TEST(MatcherTest, CanBeDefaultConstructed) {
309 Matcher<double> m;
310 }
311
312 // Tests that Matcher<T> can be constructed from a MatcherInterface<T>*.
TEST(MatcherTest,CanBeConstructedFromMatcherInterface)313 TEST(MatcherTest, CanBeConstructedFromMatcherInterface) {
314 const MatcherInterface<int>* impl = new EvenMatcherImpl;
315 Matcher<int> m(impl);
316 EXPECT_TRUE(m.Matches(4));
317 EXPECT_FALSE(m.Matches(5));
318 }
319
320 // Tests that value can be used in place of Eq(value).
TEST(MatcherTest,CanBeImplicitlyConstructedFromValue)321 TEST(MatcherTest, CanBeImplicitlyConstructedFromValue) {
322 Matcher<int> m1 = 5;
323 EXPECT_TRUE(m1.Matches(5));
324 EXPECT_FALSE(m1.Matches(6));
325 }
326
327 // Tests that NULL can be used in place of Eq(NULL).
TEST(MatcherTest,CanBeImplicitlyConstructedFromNULL)328 TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) {
329 Matcher<int*> m1 = NULL;
330 EXPECT_TRUE(m1.Matches(NULL));
331 int n = 0;
332 EXPECT_FALSE(m1.Matches(&n));
333 }
334
335 // Tests that matchers can be constructed from a variable that is not properly
336 // defined. This should be illegal, but many users rely on this accidentally.
337 struct Undefined {
338 virtual ~Undefined() = 0;
339 static const int kInt = 1;
340 };
341
TEST(MatcherTest,CanBeConstructedFromUndefinedVariable)342 TEST(MatcherTest, CanBeConstructedFromUndefinedVariable) {
343 Matcher<int> m1 = Undefined::kInt;
344 EXPECT_TRUE(m1.Matches(1));
345 EXPECT_FALSE(m1.Matches(2));
346 }
347
348 // Test that a matcher parameterized with an abstract class compiles.
TEST(MatcherTest,CanAcceptAbstractClass)349 TEST(MatcherTest, CanAcceptAbstractClass) { Matcher<const Undefined&> m = _; }
350
351 // Tests that matchers are copyable.
TEST(MatcherTest,IsCopyable)352 TEST(MatcherTest, IsCopyable) {
353 // Tests the copy constructor.
354 Matcher<bool> m1 = Eq(false);
355 EXPECT_TRUE(m1.Matches(false));
356 EXPECT_FALSE(m1.Matches(true));
357
358 // Tests the assignment operator.
359 m1 = Eq(true);
360 EXPECT_TRUE(m1.Matches(true));
361 EXPECT_FALSE(m1.Matches(false));
362 }
363
364 // Tests that Matcher<T>::DescribeTo() calls
365 // MatcherInterface<T>::DescribeTo().
TEST(MatcherTest,CanDescribeItself)366 TEST(MatcherTest, CanDescribeItself) {
367 EXPECT_EQ("is an even number",
368 Describe(Matcher<int>(new EvenMatcherImpl)));
369 }
370
371 // Tests Matcher<T>::MatchAndExplain().
TEST(MatcherTest,MatchAndExplain)372 TEST(MatcherTest, MatchAndExplain) {
373 Matcher<int> m = GreaterThan(0);
374 StringMatchResultListener listener1;
375 EXPECT_TRUE(m.MatchAndExplain(42, &listener1));
376 EXPECT_EQ("which is 42 more than 0", listener1.str());
377
378 StringMatchResultListener listener2;
379 EXPECT_FALSE(m.MatchAndExplain(-9, &listener2));
380 EXPECT_EQ("which is 9 less than 0", listener2.str());
381 }
382
383 // Tests that a C-string literal can be implicitly converted to a
384 // Matcher<std::string> or Matcher<const std::string&>.
TEST(StringMatcherTest,CanBeImplicitlyConstructedFromCStringLiteral)385 TEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
386 Matcher<std::string> m1 = "hi";
387 EXPECT_TRUE(m1.Matches("hi"));
388 EXPECT_FALSE(m1.Matches("hello"));
389
390 Matcher<const std::string&> m2 = "hi";
391 EXPECT_TRUE(m2.Matches("hi"));
392 EXPECT_FALSE(m2.Matches("hello"));
393 }
394
395 // Tests that a string object can be implicitly converted to a
396 // Matcher<std::string> or Matcher<const std::string&>.
TEST(StringMatcherTest,CanBeImplicitlyConstructedFromString)397 TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
398 Matcher<std::string> m1 = std::string("hi");
399 EXPECT_TRUE(m1.Matches("hi"));
400 EXPECT_FALSE(m1.Matches("hello"));
401
402 Matcher<const std::string&> m2 = std::string("hi");
403 EXPECT_TRUE(m2.Matches("hi"));
404 EXPECT_FALSE(m2.Matches("hello"));
405 }
406
407 #if GTEST_HAS_GLOBAL_STRING
408 // Tests that a ::string object can be implicitly converted to a
409 // Matcher<std::string> or Matcher<const std::string&>.
TEST(StringMatcherTest,CanBeImplicitlyConstructedFromGlobalString)410 TEST(StringMatcherTest, CanBeImplicitlyConstructedFromGlobalString) {
411 Matcher<std::string> m1 = ::string("hi");
412 EXPECT_TRUE(m1.Matches("hi"));
413 EXPECT_FALSE(m1.Matches("hello"));
414
415 Matcher<const std::string&> m2 = ::string("hi");
416 EXPECT_TRUE(m2.Matches("hi"));
417 EXPECT_FALSE(m2.Matches("hello"));
418 }
419 #endif // GTEST_HAS_GLOBAL_STRING
420
421 #if GTEST_HAS_GLOBAL_STRING
422 // Tests that a C-string literal can be implicitly converted to a
423 // Matcher<::string> or Matcher<const ::string&>.
TEST(GlobalStringMatcherTest,CanBeImplicitlyConstructedFromCStringLiteral)424 TEST(GlobalStringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
425 Matcher< ::string> m1 = "hi";
426 EXPECT_TRUE(m1.Matches("hi"));
427 EXPECT_FALSE(m1.Matches("hello"));
428
429 Matcher<const ::string&> m2 = "hi";
430 EXPECT_TRUE(m2.Matches("hi"));
431 EXPECT_FALSE(m2.Matches("hello"));
432 }
433
434 // Tests that a std::string object can be implicitly converted to a
435 // Matcher<::string> or Matcher<const ::string&>.
TEST(GlobalStringMatcherTest,CanBeImplicitlyConstructedFromString)436 TEST(GlobalStringMatcherTest, CanBeImplicitlyConstructedFromString) {
437 Matcher< ::string> m1 = std::string("hi");
438 EXPECT_TRUE(m1.Matches("hi"));
439 EXPECT_FALSE(m1.Matches("hello"));
440
441 Matcher<const ::string&> m2 = std::string("hi");
442 EXPECT_TRUE(m2.Matches("hi"));
443 EXPECT_FALSE(m2.Matches("hello"));
444 }
445
446 // Tests that a ::string object can be implicitly converted to a
447 // Matcher<::string> or Matcher<const ::string&>.
TEST(GlobalStringMatcherTest,CanBeImplicitlyConstructedFromGlobalString)448 TEST(GlobalStringMatcherTest, CanBeImplicitlyConstructedFromGlobalString) {
449 Matcher< ::string> m1 = ::string("hi");
450 EXPECT_TRUE(m1.Matches("hi"));
451 EXPECT_FALSE(m1.Matches("hello"));
452
453 Matcher<const ::string&> m2 = ::string("hi");
454 EXPECT_TRUE(m2.Matches("hi"));
455 EXPECT_FALSE(m2.Matches("hello"));
456 }
457 #endif // GTEST_HAS_GLOBAL_STRING
458
459 #if GTEST_HAS_ABSL
460 // Tests that a C-string literal can be implicitly converted to a
461 // Matcher<absl::string_view> or Matcher<const absl::string_view&>.
TEST(StringViewMatcherTest,CanBeImplicitlyConstructedFromCStringLiteral)462 TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
463 Matcher<absl::string_view> m1 = "cats";
464 EXPECT_TRUE(m1.Matches("cats"));
465 EXPECT_FALSE(m1.Matches("dogs"));
466
467 Matcher<const absl::string_view&> m2 = "cats";
468 EXPECT_TRUE(m2.Matches("cats"));
469 EXPECT_FALSE(m2.Matches("dogs"));
470 }
471
472 // Tests that a std::string object can be implicitly converted to a
473 // Matcher<absl::string_view> or Matcher<const absl::string_view&>.
TEST(StringViewMatcherTest,CanBeImplicitlyConstructedFromString)474 TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromString) {
475 Matcher<absl::string_view> m1 = std::string("cats");
476 EXPECT_TRUE(m1.Matches("cats"));
477 EXPECT_FALSE(m1.Matches("dogs"));
478
479 Matcher<const absl::string_view&> m2 = std::string("cats");
480 EXPECT_TRUE(m2.Matches("cats"));
481 EXPECT_FALSE(m2.Matches("dogs"));
482 }
483
484 #if GTEST_HAS_GLOBAL_STRING
485 // Tests that a ::string object can be implicitly converted to a
486 // Matcher<absl::string_view> or Matcher<const absl::string_view&>.
TEST(StringViewMatcherTest,CanBeImplicitlyConstructedFromGlobalString)487 TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromGlobalString) {
488 Matcher<absl::string_view> m1 = ::string("cats");
489 EXPECT_TRUE(m1.Matches("cats"));
490 EXPECT_FALSE(m1.Matches("dogs"));
491
492 Matcher<const absl::string_view&> m2 = ::string("cats");
493 EXPECT_TRUE(m2.Matches("cats"));
494 EXPECT_FALSE(m2.Matches("dogs"));
495 }
496 #endif // GTEST_HAS_GLOBAL_STRING
497
498 // Tests that a absl::string_view object can be implicitly converted to a
499 // Matcher<absl::string_view> or Matcher<const absl::string_view&>.
TEST(StringViewMatcherTest,CanBeImplicitlyConstructedFromStringView)500 TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
501 Matcher<absl::string_view> m1 = absl::string_view("cats");
502 EXPECT_TRUE(m1.Matches("cats"));
503 EXPECT_FALSE(m1.Matches("dogs"));
504
505 Matcher<const absl::string_view&> m2 = absl::string_view("cats");
506 EXPECT_TRUE(m2.Matches("cats"));
507 EXPECT_FALSE(m2.Matches("dogs"));
508 }
509 #endif // GTEST_HAS_ABSL
510
511 // Tests that MakeMatcher() constructs a Matcher<T> from a
512 // MatcherInterface* without requiring the user to explicitly
513 // write the type.
TEST(MakeMatcherTest,ConstructsMatcherFromMatcherInterface)514 TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) {
515 const MatcherInterface<int>* dummy_impl = NULL;
516 Matcher<int> m = MakeMatcher(dummy_impl);
517 }
518
519 // Tests that MakePolymorphicMatcher() can construct a polymorphic
520 // matcher from its implementation using the old API.
521 const int g_bar = 1;
522 class ReferencesBarOrIsZeroImpl {
523 public:
524 template <typename T>
MatchAndExplain(const T & x,MatchResultListener *) const525 bool MatchAndExplain(const T& x,
526 MatchResultListener* /* listener */) const {
527 const void* p = &x;
528 return p == &g_bar || x == 0;
529 }
530
DescribeTo(ostream * os) const531 void DescribeTo(ostream* os) const { *os << "g_bar or zero"; }
532
DescribeNegationTo(ostream * os) const533 void DescribeNegationTo(ostream* os) const {
534 *os << "doesn't reference g_bar and is not zero";
535 }
536 };
537
538 // This function verifies that MakePolymorphicMatcher() returns a
539 // PolymorphicMatcher<T> where T is the argument's type.
ReferencesBarOrIsZero()540 PolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() {
541 return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl());
542 }
543
TEST(MakePolymorphicMatcherTest,ConstructsMatcherUsingOldAPI)544 TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) {
545 // Using a polymorphic matcher to match a reference type.
546 Matcher<const int&> m1 = ReferencesBarOrIsZero();
547 EXPECT_TRUE(m1.Matches(0));
548 // Verifies that the identity of a by-reference argument is preserved.
549 EXPECT_TRUE(m1.Matches(g_bar));
550 EXPECT_FALSE(m1.Matches(1));
551 EXPECT_EQ("g_bar or zero", Describe(m1));
552
553 // Using a polymorphic matcher to match a value type.
554 Matcher<double> m2 = ReferencesBarOrIsZero();
555 EXPECT_TRUE(m2.Matches(0.0));
556 EXPECT_FALSE(m2.Matches(0.1));
557 EXPECT_EQ("g_bar or zero", Describe(m2));
558 }
559
560 // Tests implementing a polymorphic matcher using MatchAndExplain().
561
562 class PolymorphicIsEvenImpl {
563 public:
DescribeTo(ostream * os) const564 void DescribeTo(ostream* os) const { *os << "is even"; }
565
DescribeNegationTo(ostream * os) const566 void DescribeNegationTo(ostream* os) const {
567 *os << "is odd";
568 }
569
570 template <typename T>
MatchAndExplain(const T & x,MatchResultListener * listener) const571 bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
572 // Verifies that we can stream to the listener directly.
573 *listener << "% " << 2;
574 if (listener->stream() != NULL) {
575 // Verifies that we can stream to the listener's underlying stream
576 // too.
577 *listener->stream() << " == " << (x % 2);
578 }
579 return (x % 2) == 0;
580 }
581 };
582
PolymorphicIsEven()583 PolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() {
584 return MakePolymorphicMatcher(PolymorphicIsEvenImpl());
585 }
586
TEST(MakePolymorphicMatcherTest,ConstructsMatcherUsingNewAPI)587 TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) {
588 // Using PolymorphicIsEven() as a Matcher<int>.
589 const Matcher<int> m1 = PolymorphicIsEven();
590 EXPECT_TRUE(m1.Matches(42));
591 EXPECT_FALSE(m1.Matches(43));
592 EXPECT_EQ("is even", Describe(m1));
593
594 const Matcher<int> not_m1 = Not(m1);
595 EXPECT_EQ("is odd", Describe(not_m1));
596
597 EXPECT_EQ("% 2 == 0", Explain(m1, 42));
598
599 // Using PolymorphicIsEven() as a Matcher<char>.
600 const Matcher<char> m2 = PolymorphicIsEven();
601 EXPECT_TRUE(m2.Matches('\x42'));
602 EXPECT_FALSE(m2.Matches('\x43'));
603 EXPECT_EQ("is even", Describe(m2));
604
605 const Matcher<char> not_m2 = Not(m2);
606 EXPECT_EQ("is odd", Describe(not_m2));
607
608 EXPECT_EQ("% 2 == 0", Explain(m2, '\x42'));
609 }
610
611 // Tests that MatcherCast<T>(m) works when m is a polymorphic matcher.
TEST(MatcherCastTest,FromPolymorphicMatcher)612 TEST(MatcherCastTest, FromPolymorphicMatcher) {
613 Matcher<int> m = MatcherCast<int>(Eq(5));
614 EXPECT_TRUE(m.Matches(5));
615 EXPECT_FALSE(m.Matches(6));
616 }
617
618 // For testing casting matchers between compatible types.
619 class IntValue {
620 public:
621 // An int can be statically (although not implicitly) cast to a
622 // IntValue.
IntValue(int a_value)623 explicit IntValue(int a_value) : value_(a_value) {}
624
value() const625 int value() const { return value_; }
626 private:
627 int value_;
628 };
629
630 // For testing casting matchers between compatible types.
IsPositiveIntValue(const IntValue & foo)631 bool IsPositiveIntValue(const IntValue& foo) {
632 return foo.value() > 0;
633 }
634
635 // Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T
636 // can be statically converted to U.
TEST(MatcherCastTest,FromCompatibleType)637 TEST(MatcherCastTest, FromCompatibleType) {
638 Matcher<double> m1 = Eq(2.0);
639 Matcher<int> m2 = MatcherCast<int>(m1);
640 EXPECT_TRUE(m2.Matches(2));
641 EXPECT_FALSE(m2.Matches(3));
642
643 Matcher<IntValue> m3 = Truly(IsPositiveIntValue);
644 Matcher<int> m4 = MatcherCast<int>(m3);
645 // In the following, the arguments 1 and 0 are statically converted
646 // to IntValue objects, and then tested by the IsPositiveIntValue()
647 // predicate.
648 EXPECT_TRUE(m4.Matches(1));
649 EXPECT_FALSE(m4.Matches(0));
650 }
651
652 // Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
TEST(MatcherCastTest,FromConstReferenceToNonReference)653 TEST(MatcherCastTest, FromConstReferenceToNonReference) {
654 Matcher<const int&> m1 = Eq(0);
655 Matcher<int> m2 = MatcherCast<int>(m1);
656 EXPECT_TRUE(m2.Matches(0));
657 EXPECT_FALSE(m2.Matches(1));
658 }
659
660 // Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
TEST(MatcherCastTest,FromReferenceToNonReference)661 TEST(MatcherCastTest, FromReferenceToNonReference) {
662 Matcher<int&> m1 = Eq(0);
663 Matcher<int> m2 = MatcherCast<int>(m1);
664 EXPECT_TRUE(m2.Matches(0));
665 EXPECT_FALSE(m2.Matches(1));
666 }
667
668 // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
TEST(MatcherCastTest,FromNonReferenceToConstReference)669 TEST(MatcherCastTest, FromNonReferenceToConstReference) {
670 Matcher<int> m1 = Eq(0);
671 Matcher<const int&> m2 = MatcherCast<const int&>(m1);
672 EXPECT_TRUE(m2.Matches(0));
673 EXPECT_FALSE(m2.Matches(1));
674 }
675
676 // Tests that MatcherCast<T&>(m) works when m is a Matcher<T>.
TEST(MatcherCastTest,FromNonReferenceToReference)677 TEST(MatcherCastTest, FromNonReferenceToReference) {
678 Matcher<int> m1 = Eq(0);
679 Matcher<int&> m2 = MatcherCast<int&>(m1);
680 int n = 0;
681 EXPECT_TRUE(m2.Matches(n));
682 n = 1;
683 EXPECT_FALSE(m2.Matches(n));
684 }
685
686 // Tests that MatcherCast<T>(m) works when m is a Matcher<T>.
TEST(MatcherCastTest,FromSameType)687 TEST(MatcherCastTest, FromSameType) {
688 Matcher<int> m1 = Eq(0);
689 Matcher<int> m2 = MatcherCast<int>(m1);
690 EXPECT_TRUE(m2.Matches(0));
691 EXPECT_FALSE(m2.Matches(1));
692 }
693
694 // Tests that MatcherCast<T>(m) works when m is a value of the same type as the
695 // value type of the Matcher.
TEST(MatcherCastTest,FromAValue)696 TEST(MatcherCastTest, FromAValue) {
697 Matcher<int> m = MatcherCast<int>(42);
698 EXPECT_TRUE(m.Matches(42));
699 EXPECT_FALSE(m.Matches(239));
700 }
701
702 // Tests that MatcherCast<T>(m) works when m is a value of the type implicitly
703 // convertible to the value type of the Matcher.
TEST(MatcherCastTest,FromAnImplicitlyConvertibleValue)704 TEST(MatcherCastTest, FromAnImplicitlyConvertibleValue) {
705 const int kExpected = 'c';
706 Matcher<int> m = MatcherCast<int>('c');
707 EXPECT_TRUE(m.Matches(kExpected));
708 EXPECT_FALSE(m.Matches(kExpected + 1));
709 }
710
711 struct NonImplicitlyConstructibleTypeWithOperatorEq {
operator ==(const NonImplicitlyConstructibleTypeWithOperatorEq &,int rhs)712 friend bool operator==(
713 const NonImplicitlyConstructibleTypeWithOperatorEq& /* ignored */,
714 int rhs) {
715 return 42 == rhs;
716 }
operator ==(int lhs,const NonImplicitlyConstructibleTypeWithOperatorEq &)717 friend bool operator==(
718 int lhs,
719 const NonImplicitlyConstructibleTypeWithOperatorEq& /* ignored */) {
720 return lhs == 42;
721 }
722 };
723
724 // Tests that MatcherCast<T>(m) works when m is a neither a matcher nor
725 // implicitly convertible to the value type of the Matcher, but the value type
726 // of the matcher has operator==() overload accepting m.
TEST(MatcherCastTest,NonImplicitlyConstructibleTypeWithOperatorEq)727 TEST(MatcherCastTest, NonImplicitlyConstructibleTypeWithOperatorEq) {
728 Matcher<NonImplicitlyConstructibleTypeWithOperatorEq> m1 =
729 MatcherCast<NonImplicitlyConstructibleTypeWithOperatorEq>(42);
730 EXPECT_TRUE(m1.Matches(NonImplicitlyConstructibleTypeWithOperatorEq()));
731
732 Matcher<NonImplicitlyConstructibleTypeWithOperatorEq> m2 =
733 MatcherCast<NonImplicitlyConstructibleTypeWithOperatorEq>(239);
734 EXPECT_FALSE(m2.Matches(NonImplicitlyConstructibleTypeWithOperatorEq()));
735
736 // When updating the following lines please also change the comment to
737 // namespace convertible_from_any.
738 Matcher<int> m3 =
739 MatcherCast<int>(NonImplicitlyConstructibleTypeWithOperatorEq());
740 EXPECT_TRUE(m3.Matches(42));
741 EXPECT_FALSE(m3.Matches(239));
742 }
743
744 // ConvertibleFromAny does not work with MSVC. resulting in
745 // error C2440: 'initializing': cannot convert from 'Eq' to 'M'
746 // No constructor could take the source type, or constructor overload
747 // resolution was ambiguous
748
749 #if !defined _MSC_VER
750
751 // The below ConvertibleFromAny struct is implicitly constructible from anything
752 // and when in the same namespace can interact with other tests. In particular,
753 // if it is in the same namespace as other tests and one removes
754 // NonImplicitlyConstructibleTypeWithOperatorEq::operator==(int lhs, ...);
755 // then the corresponding test still compiles (and it should not!) by implicitly
756 // converting NonImplicitlyConstructibleTypeWithOperatorEq to ConvertibleFromAny
757 // in m3.Matcher().
758 namespace convertible_from_any {
759 // Implicitly convertible from any type.
760 struct ConvertibleFromAny {
ConvertibleFromAnytesting::gmock_matchers_test::convertible_from_any::ConvertibleFromAny761 ConvertibleFromAny(int a_value) : value(a_value) {}
762 template <typename T>
ConvertibleFromAnytesting::gmock_matchers_test::convertible_from_any::ConvertibleFromAny763 ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
764 ADD_FAILURE() << "Conversion constructor called";
765 }
766 int value;
767 };
768
operator ==(const ConvertibleFromAny & a,const ConvertibleFromAny & b)769 bool operator==(const ConvertibleFromAny& a, const ConvertibleFromAny& b) {
770 return a.value == b.value;
771 }
772
operator <<(ostream & os,const ConvertibleFromAny & a)773 ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
774 return os << a.value;
775 }
776
TEST(MatcherCastTest,ConversionConstructorIsUsed)777 TEST(MatcherCastTest, ConversionConstructorIsUsed) {
778 Matcher<ConvertibleFromAny> m = MatcherCast<ConvertibleFromAny>(1);
779 EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
780 EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
781 }
782
TEST(MatcherCastTest,FromConvertibleFromAny)783 TEST(MatcherCastTest, FromConvertibleFromAny) {
784 Matcher<ConvertibleFromAny> m =
785 MatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
786 EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
787 EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
788 }
789 } // namespace convertible_from_any
790
791 #endif // !defined _MSC_VER
792
793 struct IntReferenceWrapper {
IntReferenceWrappertesting::gmock_matchers_test::IntReferenceWrapper794 IntReferenceWrapper(const int& a_value) : value(&a_value) {}
795 const int* value;
796 };
797
operator ==(const IntReferenceWrapper & a,const IntReferenceWrapper & b)798 bool operator==(const IntReferenceWrapper& a, const IntReferenceWrapper& b) {
799 return a.value == b.value;
800 }
801
TEST(MatcherCastTest,ValueIsNotCopied)802 TEST(MatcherCastTest, ValueIsNotCopied) {
803 int n = 42;
804 Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n);
805 // Verify that the matcher holds a reference to n, not to its temporary copy.
806 EXPECT_TRUE(m.Matches(n));
807 }
808
809 class Base {
810 public:
~Base()811 virtual ~Base() {}
Base()812 Base() {}
813 private:
814 GTEST_DISALLOW_COPY_AND_ASSIGN_(Base);
815 };
816
817 class Derived : public Base {
818 public:
Derived()819 Derived() : Base() {}
820 int i;
821 };
822
823 class OtherDerived : public Base {};
824
825 // Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher.
TEST(SafeMatcherCastTest,FromPolymorphicMatcher)826 TEST(SafeMatcherCastTest, FromPolymorphicMatcher) {
827 Matcher<char> m2 = SafeMatcherCast<char>(Eq(32));
828 EXPECT_TRUE(m2.Matches(' '));
829 EXPECT_FALSE(m2.Matches('\n'));
830 }
831
832 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where
833 // T and U are arithmetic types and T can be losslessly converted to
834 // U.
TEST(SafeMatcherCastTest,FromLosslesslyConvertibleArithmeticType)835 TEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) {
836 Matcher<double> m1 = DoubleEq(1.0);
837 Matcher<float> m2 = SafeMatcherCast<float>(m1);
838 EXPECT_TRUE(m2.Matches(1.0f));
839 EXPECT_FALSE(m2.Matches(2.0f));
840
841 Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a'));
842 EXPECT_TRUE(m3.Matches('a'));
843 EXPECT_FALSE(m3.Matches('b'));
844 }
845
846 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U
847 // are pointers or references to a derived and a base class, correspondingly.
TEST(SafeMatcherCastTest,FromBaseClass)848 TEST(SafeMatcherCastTest, FromBaseClass) {
849 Derived d, d2;
850 Matcher<Base*> m1 = Eq(&d);
851 Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1);
852 EXPECT_TRUE(m2.Matches(&d));
853 EXPECT_FALSE(m2.Matches(&d2));
854
855 Matcher<Base&> m3 = Ref(d);
856 Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3);
857 EXPECT_TRUE(m4.Matches(d));
858 EXPECT_FALSE(m4.Matches(d2));
859 }
860
861 // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
TEST(SafeMatcherCastTest,FromConstReferenceToReference)862 TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
863 int n = 0;
864 Matcher<const int&> m1 = Ref(n);
865 Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
866 int n1 = 0;
867 EXPECT_TRUE(m2.Matches(n));
868 EXPECT_FALSE(m2.Matches(n1));
869 }
870
871 // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
TEST(SafeMatcherCastTest,FromNonReferenceToConstReference)872 TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
873 Matcher<int> m1 = Eq(0);
874 Matcher<const int&> m2 = SafeMatcherCast<const int&>(m1);
875 EXPECT_TRUE(m2.Matches(0));
876 EXPECT_FALSE(m2.Matches(1));
877 }
878
879 // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
TEST(SafeMatcherCastTest,FromNonReferenceToReference)880 TEST(SafeMatcherCastTest, FromNonReferenceToReference) {
881 Matcher<int> m1 = Eq(0);
882 Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
883 int n = 0;
884 EXPECT_TRUE(m2.Matches(n));
885 n = 1;
886 EXPECT_FALSE(m2.Matches(n));
887 }
888
889 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>.
TEST(SafeMatcherCastTest,FromSameType)890 TEST(SafeMatcherCastTest, FromSameType) {
891 Matcher<int> m1 = Eq(0);
892 Matcher<int> m2 = SafeMatcherCast<int>(m1);
893 EXPECT_TRUE(m2.Matches(0));
894 EXPECT_FALSE(m2.Matches(1));
895 }
896
897 #if !defined _MSC_VER
898
899 namespace convertible_from_any {
TEST(SafeMatcherCastTest,ConversionConstructorIsUsed)900 TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
901 Matcher<ConvertibleFromAny> m = SafeMatcherCast<ConvertibleFromAny>(1);
902 EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
903 EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
904 }
905
TEST(SafeMatcherCastTest,FromConvertibleFromAny)906 TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
907 Matcher<ConvertibleFromAny> m =
908 SafeMatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
909 EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
910 EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
911 }
912 } // namespace convertible_from_any
913
914 #endif // !defined _MSC_VER
915
TEST(SafeMatcherCastTest,ValueIsNotCopied)916 TEST(SafeMatcherCastTest, ValueIsNotCopied) {
917 int n = 42;
918 Matcher<IntReferenceWrapper> m = SafeMatcherCast<IntReferenceWrapper>(n);
919 // Verify that the matcher holds a reference to n, not to its temporary copy.
920 EXPECT_TRUE(m.Matches(n));
921 }
922
TEST(ExpectThat,TakesLiterals)923 TEST(ExpectThat, TakesLiterals) {
924 EXPECT_THAT(1, 1);
925 EXPECT_THAT(1.0, 1.0);
926 EXPECT_THAT(std::string(), "");
927 }
928
TEST(ExpectThat,TakesFunctions)929 TEST(ExpectThat, TakesFunctions) {
930 struct Helper {
931 static void Func() {}
932 };
933 void (*func)() = Helper::Func;
934 EXPECT_THAT(func, Helper::Func);
935 EXPECT_THAT(func, &Helper::Func);
936 }
937
938 // Tests that A<T>() matches any value of type T.
TEST(ATest,MatchesAnyValue)939 TEST(ATest, MatchesAnyValue) {
940 // Tests a matcher for a value type.
941 Matcher<double> m1 = A<double>();
942 EXPECT_TRUE(m1.Matches(91.43));
943 EXPECT_TRUE(m1.Matches(-15.32));
944
945 // Tests a matcher for a reference type.
946 int a = 2;
947 int b = -6;
948 Matcher<int&> m2 = A<int&>();
949 EXPECT_TRUE(m2.Matches(a));
950 EXPECT_TRUE(m2.Matches(b));
951 }
952
TEST(ATest,WorksForDerivedClass)953 TEST(ATest, WorksForDerivedClass) {
954 Base base;
955 Derived derived;
956 EXPECT_THAT(&base, A<Base*>());
957 // This shouldn't compile: EXPECT_THAT(&base, A<Derived*>());
958 EXPECT_THAT(&derived, A<Base*>());
959 EXPECT_THAT(&derived, A<Derived*>());
960 }
961
962 // Tests that A<T>() describes itself properly.
TEST(ATest,CanDescribeSelf)963 TEST(ATest, CanDescribeSelf) {
964 EXPECT_EQ("is anything", Describe(A<bool>()));
965 }
966
967 // Tests that An<T>() matches any value of type T.
TEST(AnTest,MatchesAnyValue)968 TEST(AnTest, MatchesAnyValue) {
969 // Tests a matcher for a value type.
970 Matcher<int> m1 = An<int>();
971 EXPECT_TRUE(m1.Matches(9143));
972 EXPECT_TRUE(m1.Matches(-1532));
973
974 // Tests a matcher for a reference type.
975 int a = 2;
976 int b = -6;
977 Matcher<int&> m2 = An<int&>();
978 EXPECT_TRUE(m2.Matches(a));
979 EXPECT_TRUE(m2.Matches(b));
980 }
981
982 // Tests that An<T>() describes itself properly.
TEST(AnTest,CanDescribeSelf)983 TEST(AnTest, CanDescribeSelf) {
984 EXPECT_EQ("is anything", Describe(An<int>()));
985 }
986
987 // Tests that _ can be used as a matcher for any type and matches any
988 // value of that type.
TEST(UnderscoreTest,MatchesAnyValue)989 TEST(UnderscoreTest, MatchesAnyValue) {
990 // Uses _ as a matcher for a value type.
991 Matcher<int> m1 = _;
992 EXPECT_TRUE(m1.Matches(123));
993 EXPECT_TRUE(m1.Matches(-242));
994
995 // Uses _ as a matcher for a reference type.
996 bool a = false;
997 const bool b = true;
998 Matcher<const bool&> m2 = _;
999 EXPECT_TRUE(m2.Matches(a));
1000 EXPECT_TRUE(m2.Matches(b));
1001 }
1002
1003 // Tests that _ describes itself properly.
TEST(UnderscoreTest,CanDescribeSelf)1004 TEST(UnderscoreTest, CanDescribeSelf) {
1005 Matcher<int> m = _;
1006 EXPECT_EQ("is anything", Describe(m));
1007 }
1008
1009 // Tests that Eq(x) matches any value equal to x.
TEST(EqTest,MatchesEqualValue)1010 TEST(EqTest, MatchesEqualValue) {
1011 // 2 C-strings with same content but different addresses.
1012 const char a1[] = "hi";
1013 const char a2[] = "hi";
1014
1015 Matcher<const char*> m1 = Eq(a1);
1016 EXPECT_TRUE(m1.Matches(a1));
1017 EXPECT_FALSE(m1.Matches(a2));
1018 }
1019
1020 // Tests that Eq(v) describes itself properly.
1021
1022 class Unprintable {
1023 public:
Unprintable()1024 Unprintable() : c_('a') {}
1025
operator ==(const Unprintable &) const1026 bool operator==(const Unprintable& /* rhs */) const { return true; }
1027 private:
1028 char c_;
1029 };
1030
TEST(EqTest,CanDescribeSelf)1031 TEST(EqTest, CanDescribeSelf) {
1032 Matcher<Unprintable> m = Eq(Unprintable());
1033 EXPECT_EQ("is equal to 1-byte object <61>", Describe(m));
1034 }
1035
1036 // Tests that Eq(v) can be used to match any type that supports
1037 // comparing with type T, where T is v's type.
TEST(EqTest,IsPolymorphic)1038 TEST(EqTest, IsPolymorphic) {
1039 Matcher<int> m1 = Eq(1);
1040 EXPECT_TRUE(m1.Matches(1));
1041 EXPECT_FALSE(m1.Matches(2));
1042
1043 Matcher<char> m2 = Eq(1);
1044 EXPECT_TRUE(m2.Matches('\1'));
1045 EXPECT_FALSE(m2.Matches('a'));
1046 }
1047
1048 // Tests that TypedEq<T>(v) matches values of type T that's equal to v.
TEST(TypedEqTest,ChecksEqualityForGivenType)1049 TEST(TypedEqTest, ChecksEqualityForGivenType) {
1050 Matcher<char> m1 = TypedEq<char>('a');
1051 EXPECT_TRUE(m1.Matches('a'));
1052 EXPECT_FALSE(m1.Matches('b'));
1053
1054 Matcher<int> m2 = TypedEq<int>(6);
1055 EXPECT_TRUE(m2.Matches(6));
1056 EXPECT_FALSE(m2.Matches(7));
1057 }
1058
1059 // Tests that TypedEq(v) describes itself properly.
TEST(TypedEqTest,CanDescribeSelf)1060 TEST(TypedEqTest, CanDescribeSelf) {
1061 EXPECT_EQ("is equal to 2", Describe(TypedEq<int>(2)));
1062 }
1063
1064 // Tests that TypedEq<T>(v) has type Matcher<T>.
1065
1066 // Type<T>::IsTypeOf(v) compiles iff the type of value v is T, where T
1067 // is a "bare" type (i.e. not in the form of const U or U&). If v's
1068 // type is not T, the compiler will generate a message about
1069 // "undefined reference".
1070 template <typename T>
1071 struct Type {
IsTypeOftesting::gmock_matchers_test::Type1072 static bool IsTypeOf(const T& /* v */) { return true; }
1073
1074 template <typename T2>
1075 static void IsTypeOf(T2 v);
1076 };
1077
TEST(TypedEqTest,HasSpecifiedType)1078 TEST(TypedEqTest, HasSpecifiedType) {
1079 // Verfies that the type of TypedEq<T>(v) is Matcher<T>.
1080 Type<Matcher<int> >::IsTypeOf(TypedEq<int>(5));
1081 Type<Matcher<double> >::IsTypeOf(TypedEq<double>(5));
1082 }
1083
1084 // Tests that Ge(v) matches anything >= v.
TEST(GeTest,ImplementsGreaterThanOrEqual)1085 TEST(GeTest, ImplementsGreaterThanOrEqual) {
1086 Matcher<int> m1 = Ge(0);
1087 EXPECT_TRUE(m1.Matches(1));
1088 EXPECT_TRUE(m1.Matches(0));
1089 EXPECT_FALSE(m1.Matches(-1));
1090 }
1091
1092 // Tests that Ge(v) describes itself properly.
TEST(GeTest,CanDescribeSelf)1093 TEST(GeTest, CanDescribeSelf) {
1094 Matcher<int> m = Ge(5);
1095 EXPECT_EQ("is >= 5", Describe(m));
1096 }
1097
1098 // Tests that Gt(v) matches anything > v.
TEST(GtTest,ImplementsGreaterThan)1099 TEST(GtTest, ImplementsGreaterThan) {
1100 Matcher<double> m1 = Gt(0);
1101 EXPECT_TRUE(m1.Matches(1.0));
1102 EXPECT_FALSE(m1.Matches(0.0));
1103 EXPECT_FALSE(m1.Matches(-1.0));
1104 }
1105
1106 // Tests that Gt(v) describes itself properly.
TEST(GtTest,CanDescribeSelf)1107 TEST(GtTest, CanDescribeSelf) {
1108 Matcher<int> m = Gt(5);
1109 EXPECT_EQ("is > 5", Describe(m));
1110 }
1111
1112 // Tests that Le(v) matches anything <= v.
TEST(LeTest,ImplementsLessThanOrEqual)1113 TEST(LeTest, ImplementsLessThanOrEqual) {
1114 Matcher<char> m1 = Le('b');
1115 EXPECT_TRUE(m1.Matches('a'));
1116 EXPECT_TRUE(m1.Matches('b'));
1117 EXPECT_FALSE(m1.Matches('c'));
1118 }
1119
1120 // Tests that Le(v) describes itself properly.
TEST(LeTest,CanDescribeSelf)1121 TEST(LeTest, CanDescribeSelf) {
1122 Matcher<int> m = Le(5);
1123 EXPECT_EQ("is <= 5", Describe(m));
1124 }
1125
1126 // Tests that Lt(v) matches anything < v.
TEST(LtTest,ImplementsLessThan)1127 TEST(LtTest, ImplementsLessThan) {
1128 Matcher<const std::string&> m1 = Lt("Hello");
1129 EXPECT_TRUE(m1.Matches("Abc"));
1130 EXPECT_FALSE(m1.Matches("Hello"));
1131 EXPECT_FALSE(m1.Matches("Hello, world!"));
1132 }
1133
1134 // Tests that Lt(v) describes itself properly.
TEST(LtTest,CanDescribeSelf)1135 TEST(LtTest, CanDescribeSelf) {
1136 Matcher<int> m = Lt(5);
1137 EXPECT_EQ("is < 5", Describe(m));
1138 }
1139
1140 // Tests that Ne(v) matches anything != v.
TEST(NeTest,ImplementsNotEqual)1141 TEST(NeTest, ImplementsNotEqual) {
1142 Matcher<int> m1 = Ne(0);
1143 EXPECT_TRUE(m1.Matches(1));
1144 EXPECT_TRUE(m1.Matches(-1));
1145 EXPECT_FALSE(m1.Matches(0));
1146 }
1147
1148 // Tests that Ne(v) describes itself properly.
TEST(NeTest,CanDescribeSelf)1149 TEST(NeTest, CanDescribeSelf) {
1150 Matcher<int> m = Ne(5);
1151 EXPECT_EQ("isn't equal to 5", Describe(m));
1152 }
1153
1154 // Tests that IsNull() matches any NULL pointer of any type.
TEST(IsNullTest,MatchesNullPointer)1155 TEST(IsNullTest, MatchesNullPointer) {
1156 Matcher<int*> m1 = IsNull();
1157 int* p1 = NULL;
1158 int n = 0;
1159 EXPECT_TRUE(m1.Matches(p1));
1160 EXPECT_FALSE(m1.Matches(&n));
1161
1162 Matcher<const char*> m2 = IsNull();
1163 const char* p2 = NULL;
1164 EXPECT_TRUE(m2.Matches(p2));
1165 EXPECT_FALSE(m2.Matches("hi"));
1166
1167 #if !GTEST_OS_SYMBIAN
1168 // Nokia's Symbian compiler generates:
1169 // gmock-matchers.h: ambiguous access to overloaded function
1170 // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(void *)'
1171 // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(const testing::
1172 // MatcherInterface<void *> *)'
1173 // gmock-matchers.h: (point of instantiation: 'testing::
1174 // gmock_matchers_test::IsNullTest_MatchesNullPointer_Test::TestBody()')
1175 // gmock-matchers.h: (instantiating: 'testing::PolymorphicMatc
1176 Matcher<void*> m3 = IsNull();
1177 void* p3 = NULL;
1178 EXPECT_TRUE(m3.Matches(p3));
1179 EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef)));
1180 #endif
1181 }
1182
TEST(IsNullTest,LinkedPtr)1183 TEST(IsNullTest, LinkedPtr) {
1184 const Matcher<linked_ptr<int> > m = IsNull();
1185 const linked_ptr<int> null_p;
1186 const linked_ptr<int> non_null_p(new int);
1187
1188 EXPECT_TRUE(m.Matches(null_p));
1189 EXPECT_FALSE(m.Matches(non_null_p));
1190 }
1191
TEST(IsNullTest,ReferenceToConstLinkedPtr)1192 TEST(IsNullTest, ReferenceToConstLinkedPtr) {
1193 const Matcher<const linked_ptr<double>&> m = IsNull();
1194 const linked_ptr<double> null_p;
1195 const linked_ptr<double> non_null_p(new double);
1196
1197 EXPECT_TRUE(m.Matches(null_p));
1198 EXPECT_FALSE(m.Matches(non_null_p));
1199 }
1200
1201 #if GTEST_LANG_CXX11
TEST(IsNullTest,StdFunction)1202 TEST(IsNullTest, StdFunction) {
1203 const Matcher<std::function<void()>> m = IsNull();
1204
1205 EXPECT_TRUE(m.Matches(std::function<void()>()));
1206 EXPECT_FALSE(m.Matches([]{}));
1207 }
1208 #endif // GTEST_LANG_CXX11
1209
1210 // Tests that IsNull() describes itself properly.
TEST(IsNullTest,CanDescribeSelf)1211 TEST(IsNullTest, CanDescribeSelf) {
1212 Matcher<int*> m = IsNull();
1213 EXPECT_EQ("is NULL", Describe(m));
1214 EXPECT_EQ("isn't NULL", DescribeNegation(m));
1215 }
1216
1217 // Tests that NotNull() matches any non-NULL pointer of any type.
TEST(NotNullTest,MatchesNonNullPointer)1218 TEST(NotNullTest, MatchesNonNullPointer) {
1219 Matcher<int*> m1 = NotNull();
1220 int* p1 = NULL;
1221 int n = 0;
1222 EXPECT_FALSE(m1.Matches(p1));
1223 EXPECT_TRUE(m1.Matches(&n));
1224
1225 Matcher<const char*> m2 = NotNull();
1226 const char* p2 = NULL;
1227 EXPECT_FALSE(m2.Matches(p2));
1228 EXPECT_TRUE(m2.Matches("hi"));
1229 }
1230
TEST(NotNullTest,LinkedPtr)1231 TEST(NotNullTest, LinkedPtr) {
1232 const Matcher<linked_ptr<int> > m = NotNull();
1233 const linked_ptr<int> null_p;
1234 const linked_ptr<int> non_null_p(new int);
1235
1236 EXPECT_FALSE(m.Matches(null_p));
1237 EXPECT_TRUE(m.Matches(non_null_p));
1238 }
1239
TEST(NotNullTest,ReferenceToConstLinkedPtr)1240 TEST(NotNullTest, ReferenceToConstLinkedPtr) {
1241 const Matcher<const linked_ptr<double>&> m = NotNull();
1242 const linked_ptr<double> null_p;
1243 const linked_ptr<double> non_null_p(new double);
1244
1245 EXPECT_FALSE(m.Matches(null_p));
1246 EXPECT_TRUE(m.Matches(non_null_p));
1247 }
1248
1249 #if GTEST_LANG_CXX11
TEST(NotNullTest,StdFunction)1250 TEST(NotNullTest, StdFunction) {
1251 const Matcher<std::function<void()>> m = NotNull();
1252
1253 EXPECT_TRUE(m.Matches([]{}));
1254 EXPECT_FALSE(m.Matches(std::function<void()>()));
1255 }
1256 #endif // GTEST_LANG_CXX11
1257
1258 // Tests that NotNull() describes itself properly.
TEST(NotNullTest,CanDescribeSelf)1259 TEST(NotNullTest, CanDescribeSelf) {
1260 Matcher<int*> m = NotNull();
1261 EXPECT_EQ("isn't NULL", Describe(m));
1262 }
1263
1264 // Tests that Ref(variable) matches an argument that references
1265 // 'variable'.
TEST(RefTest,MatchesSameVariable)1266 TEST(RefTest, MatchesSameVariable) {
1267 int a = 0;
1268 int b = 0;
1269 Matcher<int&> m = Ref(a);
1270 EXPECT_TRUE(m.Matches(a));
1271 EXPECT_FALSE(m.Matches(b));
1272 }
1273
1274 // Tests that Ref(variable) describes itself properly.
TEST(RefTest,CanDescribeSelf)1275 TEST(RefTest, CanDescribeSelf) {
1276 int n = 5;
1277 Matcher<int&> m = Ref(n);
1278 stringstream ss;
1279 ss << "references the variable @" << &n << " 5";
1280 EXPECT_EQ(ss.str(), Describe(m));
1281 }
1282
1283 // Test that Ref(non_const_varialbe) can be used as a matcher for a
1284 // const reference.
TEST(RefTest,CanBeUsedAsMatcherForConstReference)1285 TEST(RefTest, CanBeUsedAsMatcherForConstReference) {
1286 int a = 0;
1287 int b = 0;
1288 Matcher<const int&> m = Ref(a);
1289 EXPECT_TRUE(m.Matches(a));
1290 EXPECT_FALSE(m.Matches(b));
1291 }
1292
1293 // Tests that Ref(variable) is covariant, i.e. Ref(derived) can be
1294 // used wherever Ref(base) can be used (Ref(derived) is a sub-type
1295 // of Ref(base), but not vice versa.
1296
TEST(RefTest,IsCovariant)1297 TEST(RefTest, IsCovariant) {
1298 Base base, base2;
1299 Derived derived;
1300 Matcher<const Base&> m1 = Ref(base);
1301 EXPECT_TRUE(m1.Matches(base));
1302 EXPECT_FALSE(m1.Matches(base2));
1303 EXPECT_FALSE(m1.Matches(derived));
1304
1305 m1 = Ref(derived);
1306 EXPECT_TRUE(m1.Matches(derived));
1307 EXPECT_FALSE(m1.Matches(base));
1308 EXPECT_FALSE(m1.Matches(base2));
1309 }
1310
TEST(RefTest,ExplainsResult)1311 TEST(RefTest, ExplainsResult) {
1312 int n = 0;
1313 EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n),
1314 StartsWith("which is located @"));
1315
1316 int m = 0;
1317 EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m),
1318 StartsWith("which is located @"));
1319 }
1320
1321 // Tests string comparison matchers.
1322
TEST(StrEqTest,MatchesEqualString)1323 TEST(StrEqTest, MatchesEqualString) {
1324 Matcher<const char*> m = StrEq(std::string("Hello"));
1325 EXPECT_TRUE(m.Matches("Hello"));
1326 EXPECT_FALSE(m.Matches("hello"));
1327 EXPECT_FALSE(m.Matches(NULL));
1328
1329 Matcher<const std::string&> m2 = StrEq("Hello");
1330 EXPECT_TRUE(m2.Matches("Hello"));
1331 EXPECT_FALSE(m2.Matches("Hi"));
1332
1333 #if GTEST_HAS_ABSL
1334 Matcher<const absl::string_view&> m3 = StrEq("Hello");
1335 EXPECT_TRUE(m3.Matches(absl::string_view("Hello")));
1336 EXPECT_FALSE(m3.Matches(absl::string_view("hello")));
1337 EXPECT_FALSE(m3.Matches(absl::string_view()));
1338 #endif // GTEST_HAS_ABSL
1339 }
1340
TEST(StrEqTest,CanDescribeSelf)1341 TEST(StrEqTest, CanDescribeSelf) {
1342 Matcher<std::string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
1343 EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"",
1344 Describe(m));
1345
1346 std::string str("01204500800");
1347 str[3] = '\0';
1348 Matcher<std::string> m2 = StrEq(str);
1349 EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2));
1350 str[0] = str[6] = str[7] = str[9] = str[10] = '\0';
1351 Matcher<std::string> m3 = StrEq(str);
1352 EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3));
1353 }
1354
TEST(StrNeTest,MatchesUnequalString)1355 TEST(StrNeTest, MatchesUnequalString) {
1356 Matcher<const char*> m = StrNe("Hello");
1357 EXPECT_TRUE(m.Matches(""));
1358 EXPECT_TRUE(m.Matches(NULL));
1359 EXPECT_FALSE(m.Matches("Hello"));
1360
1361 Matcher<std::string> m2 = StrNe(std::string("Hello"));
1362 EXPECT_TRUE(m2.Matches("hello"));
1363 EXPECT_FALSE(m2.Matches("Hello"));
1364
1365 #if GTEST_HAS_ABSL
1366 Matcher<const absl::string_view> m3 = StrNe("Hello");
1367 EXPECT_TRUE(m3.Matches(absl::string_view("")));
1368 EXPECT_TRUE(m3.Matches(absl::string_view()));
1369 EXPECT_FALSE(m3.Matches(absl::string_view("Hello")));
1370 #endif // GTEST_HAS_ABSL
1371 }
1372
TEST(StrNeTest,CanDescribeSelf)1373 TEST(StrNeTest, CanDescribeSelf) {
1374 Matcher<const char*> m = StrNe("Hi");
1375 EXPECT_EQ("isn't equal to \"Hi\"", Describe(m));
1376 }
1377
TEST(StrCaseEqTest,MatchesEqualStringIgnoringCase)1378 TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
1379 Matcher<const char*> m = StrCaseEq(std::string("Hello"));
1380 EXPECT_TRUE(m.Matches("Hello"));
1381 EXPECT_TRUE(m.Matches("hello"));
1382 EXPECT_FALSE(m.Matches("Hi"));
1383 EXPECT_FALSE(m.Matches(NULL));
1384
1385 Matcher<const std::string&> m2 = StrCaseEq("Hello");
1386 EXPECT_TRUE(m2.Matches("hello"));
1387 EXPECT_FALSE(m2.Matches("Hi"));
1388
1389 #if GTEST_HAS_ABSL
1390 Matcher<const absl::string_view&> m3 = StrCaseEq(std::string("Hello"));
1391 EXPECT_TRUE(m3.Matches(absl::string_view("Hello")));
1392 EXPECT_TRUE(m3.Matches(absl::string_view("hello")));
1393 EXPECT_FALSE(m3.Matches(absl::string_view("Hi")));
1394 EXPECT_FALSE(m3.Matches(absl::string_view()));
1395 #endif // GTEST_HAS_ABSL
1396 }
1397
TEST(StrCaseEqTest,MatchesEqualStringWith0IgnoringCase)1398 TEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
1399 std::string str1("oabocdooeoo");
1400 std::string str2("OABOCDOOEOO");
1401 Matcher<const std::string&> m0 = StrCaseEq(str1);
1402 EXPECT_FALSE(m0.Matches(str2 + std::string(1, '\0')));
1403
1404 str1[3] = str2[3] = '\0';
1405 Matcher<const std::string&> m1 = StrCaseEq(str1);
1406 EXPECT_TRUE(m1.Matches(str2));
1407
1408 str1[0] = str1[6] = str1[7] = str1[10] = '\0';
1409 str2[0] = str2[6] = str2[7] = str2[10] = '\0';
1410 Matcher<const std::string&> m2 = StrCaseEq(str1);
1411 str1[9] = str2[9] = '\0';
1412 EXPECT_FALSE(m2.Matches(str2));
1413
1414 Matcher<const std::string&> m3 = StrCaseEq(str1);
1415 EXPECT_TRUE(m3.Matches(str2));
1416
1417 EXPECT_FALSE(m3.Matches(str2 + "x"));
1418 str2.append(1, '\0');
1419 EXPECT_FALSE(m3.Matches(str2));
1420 EXPECT_FALSE(m3.Matches(std::string(str2, 0, 9)));
1421 }
1422
TEST(StrCaseEqTest,CanDescribeSelf)1423 TEST(StrCaseEqTest, CanDescribeSelf) {
1424 Matcher<std::string> m = StrCaseEq("Hi");
1425 EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m));
1426 }
1427
TEST(StrCaseNeTest,MatchesUnequalStringIgnoringCase)1428 TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
1429 Matcher<const char*> m = StrCaseNe("Hello");
1430 EXPECT_TRUE(m.Matches("Hi"));
1431 EXPECT_TRUE(m.Matches(NULL));
1432 EXPECT_FALSE(m.Matches("Hello"));
1433 EXPECT_FALSE(m.Matches("hello"));
1434
1435 Matcher<std::string> m2 = StrCaseNe(std::string("Hello"));
1436 EXPECT_TRUE(m2.Matches(""));
1437 EXPECT_FALSE(m2.Matches("Hello"));
1438
1439 #if GTEST_HAS_ABSL
1440 Matcher<const absl::string_view> m3 = StrCaseNe("Hello");
1441 EXPECT_TRUE(m3.Matches(absl::string_view("Hi")));
1442 EXPECT_TRUE(m3.Matches(absl::string_view()));
1443 EXPECT_FALSE(m3.Matches(absl::string_view("Hello")));
1444 EXPECT_FALSE(m3.Matches(absl::string_view("hello")));
1445 #endif // GTEST_HAS_ABSL
1446 }
1447
TEST(StrCaseNeTest,CanDescribeSelf)1448 TEST(StrCaseNeTest, CanDescribeSelf) {
1449 Matcher<const char*> m = StrCaseNe("Hi");
1450 EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m));
1451 }
1452
1453 // Tests that HasSubstr() works for matching string-typed values.
TEST(HasSubstrTest,WorksForStringClasses)1454 TEST(HasSubstrTest, WorksForStringClasses) {
1455 const Matcher<std::string> m1 = HasSubstr("foo");
1456 EXPECT_TRUE(m1.Matches(std::string("I love food.")));
1457 EXPECT_FALSE(m1.Matches(std::string("tofo")));
1458
1459 const Matcher<const std::string&> m2 = HasSubstr("foo");
1460 EXPECT_TRUE(m2.Matches(std::string("I love food.")));
1461 EXPECT_FALSE(m2.Matches(std::string("tofo")));
1462 }
1463
1464 // Tests that HasSubstr() works for matching C-string-typed values.
TEST(HasSubstrTest,WorksForCStrings)1465 TEST(HasSubstrTest, WorksForCStrings) {
1466 const Matcher<char*> m1 = HasSubstr("foo");
1467 EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food.")));
1468 EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo")));
1469 EXPECT_FALSE(m1.Matches(NULL));
1470
1471 const Matcher<const char*> m2 = HasSubstr("foo");
1472 EXPECT_TRUE(m2.Matches("I love food."));
1473 EXPECT_FALSE(m2.Matches("tofo"));
1474 EXPECT_FALSE(m2.Matches(NULL));
1475 }
1476
1477 #if GTEST_HAS_ABSL
1478 // Tests that HasSubstr() works for matching absl::string_view-typed values.
TEST(HasSubstrTest,WorksForStringViewClasses)1479 TEST(HasSubstrTest, WorksForStringViewClasses) {
1480 const Matcher<absl::string_view> m1 = HasSubstr("foo");
1481 EXPECT_TRUE(m1.Matches(absl::string_view("I love food.")));
1482 EXPECT_FALSE(m1.Matches(absl::string_view("tofo")));
1483 EXPECT_FALSE(m1.Matches(absl::string_view()));
1484
1485 const Matcher<const absl::string_view&> m2 = HasSubstr("foo");
1486 EXPECT_TRUE(m2.Matches(absl::string_view("I love food.")));
1487 EXPECT_FALSE(m2.Matches(absl::string_view("tofo")));
1488 EXPECT_FALSE(m2.Matches(absl::string_view()));
1489
1490 const Matcher<const absl::string_view&> m3 = HasSubstr("");
1491 EXPECT_TRUE(m3.Matches(absl::string_view("foo")));
1492 EXPECT_FALSE(m3.Matches(absl::string_view()));
1493 }
1494 #endif // GTEST_HAS_ABSL
1495
1496 // Tests that HasSubstr(s) describes itself properly.
TEST(HasSubstrTest,CanDescribeSelf)1497 TEST(HasSubstrTest, CanDescribeSelf) {
1498 Matcher<std::string> m = HasSubstr("foo\n\"");
1499 EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m));
1500 }
1501
TEST(KeyTest,CanDescribeSelf)1502 TEST(KeyTest, CanDescribeSelf) {
1503 Matcher<const pair<std::string, int>&> m = Key("foo");
1504 EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m));
1505 EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m));
1506 }
1507
TEST(KeyTest,ExplainsResult)1508 TEST(KeyTest, ExplainsResult) {
1509 Matcher<pair<int, bool> > m = Key(GreaterThan(10));
1510 EXPECT_EQ("whose first field is a value which is 5 less than 10",
1511 Explain(m, make_pair(5, true)));
1512 EXPECT_EQ("whose first field is a value which is 5 more than 10",
1513 Explain(m, make_pair(15, true)));
1514 }
1515
TEST(KeyTest,MatchesCorrectly)1516 TEST(KeyTest, MatchesCorrectly) {
1517 pair<int, std::string> p(25, "foo");
1518 EXPECT_THAT(p, Key(25));
1519 EXPECT_THAT(p, Not(Key(42)));
1520 EXPECT_THAT(p, Key(Ge(20)));
1521 EXPECT_THAT(p, Not(Key(Lt(25))));
1522 }
1523
1524 #if GTEST_LANG_CXX11
1525 template <size_t I>
1526 struct Tag {};
1527
1528 struct PairWithGet {
1529 int member_1;
1530 string member_2;
1531 using first_type = int;
1532 using second_type = string;
1533
GetImpltesting::gmock_matchers_test::PairWithGet1534 const int& GetImpl(Tag<0>) const { return member_1; }
GetImpltesting::gmock_matchers_test::PairWithGet1535 const string& GetImpl(Tag<1>) const { return member_2; }
1536 };
1537 template <size_t I>
get(const PairWithGet & value)1538 auto get(const PairWithGet& value) -> decltype(value.GetImpl(Tag<I>())) {
1539 return value.GetImpl(Tag<I>());
1540 }
TEST(PairTest,MatchesPairWithGetCorrectly)1541 TEST(PairTest, MatchesPairWithGetCorrectly) {
1542 PairWithGet p{25, "foo"};
1543 EXPECT_THAT(p, Key(25));
1544 EXPECT_THAT(p, Not(Key(42)));
1545 EXPECT_THAT(p, Key(Ge(20)));
1546 EXPECT_THAT(p, Not(Key(Lt(25))));
1547
1548 std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
1549 EXPECT_THAT(v, Contains(Key(29)));
1550 }
1551 #endif // GTEST_LANG_CXX11
1552
TEST(KeyTest,SafelyCastsInnerMatcher)1553 TEST(KeyTest, SafelyCastsInnerMatcher) {
1554 Matcher<int> is_positive = Gt(0);
1555 Matcher<int> is_negative = Lt(0);
1556 pair<char, bool> p('a', true);
1557 EXPECT_THAT(p, Key(is_positive));
1558 EXPECT_THAT(p, Not(Key(is_negative)));
1559 }
1560
TEST(KeyTest,InsideContainsUsingMap)1561 TEST(KeyTest, InsideContainsUsingMap) {
1562 map<int, char> container;
1563 container.insert(make_pair(1, 'a'));
1564 container.insert(make_pair(2, 'b'));
1565 container.insert(make_pair(4, 'c'));
1566 EXPECT_THAT(container, Contains(Key(1)));
1567 EXPECT_THAT(container, Not(Contains(Key(3))));
1568 }
1569
TEST(KeyTest,InsideContainsUsingMultimap)1570 TEST(KeyTest, InsideContainsUsingMultimap) {
1571 multimap<int, char> container;
1572 container.insert(make_pair(1, 'a'));
1573 container.insert(make_pair(2, 'b'));
1574 container.insert(make_pair(4, 'c'));
1575
1576 EXPECT_THAT(container, Not(Contains(Key(25))));
1577 container.insert(make_pair(25, 'd'));
1578 EXPECT_THAT(container, Contains(Key(25)));
1579 container.insert(make_pair(25, 'e'));
1580 EXPECT_THAT(container, Contains(Key(25)));
1581
1582 EXPECT_THAT(container, Contains(Key(1)));
1583 EXPECT_THAT(container, Not(Contains(Key(3))));
1584 }
1585
TEST(PairTest,Typing)1586 TEST(PairTest, Typing) {
1587 // Test verifies the following type conversions can be compiled.
1588 Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42);
1589 Matcher<const pair<const char*, int> > m2 = Pair("foo", 42);
1590 Matcher<pair<const char*, int> > m3 = Pair("foo", 42);
1591
1592 Matcher<pair<int, const std::string> > m4 = Pair(25, "42");
1593 Matcher<pair<const std::string, int> > m5 = Pair("25", 42);
1594 }
1595
TEST(PairTest,CanDescribeSelf)1596 TEST(PairTest, CanDescribeSelf) {
1597 Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42);
1598 EXPECT_EQ("has a first field that is equal to \"foo\""
1599 ", and has a second field that is equal to 42",
1600 Describe(m1));
1601 EXPECT_EQ("has a first field that isn't equal to \"foo\""
1602 ", or has a second field that isn't equal to 42",
1603 DescribeNegation(m1));
1604 // Double and triple negation (1 or 2 times not and description of negation).
1605 Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42));
1606 EXPECT_EQ("has a first field that isn't equal to 13"
1607 ", and has a second field that is equal to 42",
1608 DescribeNegation(m2));
1609 }
1610
TEST(PairTest,CanExplainMatchResultTo)1611 TEST(PairTest, CanExplainMatchResultTo) {
1612 // If neither field matches, Pair() should explain about the first
1613 // field.
1614 const Matcher<pair<int, int> > m = Pair(GreaterThan(0), GreaterThan(0));
1615 EXPECT_EQ("whose first field does not match, which is 1 less than 0",
1616 Explain(m, make_pair(-1, -2)));
1617
1618 // If the first field matches but the second doesn't, Pair() should
1619 // explain about the second field.
1620 EXPECT_EQ("whose second field does not match, which is 2 less than 0",
1621 Explain(m, make_pair(1, -2)));
1622
1623 // If the first field doesn't match but the second does, Pair()
1624 // should explain about the first field.
1625 EXPECT_EQ("whose first field does not match, which is 1 less than 0",
1626 Explain(m, make_pair(-1, 2)));
1627
1628 // If both fields match, Pair() should explain about them both.
1629 EXPECT_EQ("whose both fields match, where the first field is a value "
1630 "which is 1 more than 0, and the second field is a value "
1631 "which is 2 more than 0",
1632 Explain(m, make_pair(1, 2)));
1633
1634 // If only the first match has an explanation, only this explanation should
1635 // be printed.
1636 const Matcher<pair<int, int> > explain_first = Pair(GreaterThan(0), 0);
1637 EXPECT_EQ("whose both fields match, where the first field is a value "
1638 "which is 1 more than 0",
1639 Explain(explain_first, make_pair(1, 0)));
1640
1641 // If only the second match has an explanation, only this explanation should
1642 // be printed.
1643 const Matcher<pair<int, int> > explain_second = Pair(0, GreaterThan(0));
1644 EXPECT_EQ("whose both fields match, where the second field is a value "
1645 "which is 1 more than 0",
1646 Explain(explain_second, make_pair(0, 1)));
1647 }
1648
TEST(PairTest,MatchesCorrectly)1649 TEST(PairTest, MatchesCorrectly) {
1650 pair<int, std::string> p(25, "foo");
1651
1652 // Both fields match.
1653 EXPECT_THAT(p, Pair(25, "foo"));
1654 EXPECT_THAT(p, Pair(Ge(20), HasSubstr("o")));
1655
1656 // 'first' doesnt' match, but 'second' matches.
1657 EXPECT_THAT(p, Not(Pair(42, "foo")));
1658 EXPECT_THAT(p, Not(Pair(Lt(25), "foo")));
1659
1660 // 'first' matches, but 'second' doesn't match.
1661 EXPECT_THAT(p, Not(Pair(25, "bar")));
1662 EXPECT_THAT(p, Not(Pair(25, Not("foo"))));
1663
1664 // Neither field matches.
1665 EXPECT_THAT(p, Not(Pair(13, "bar")));
1666 EXPECT_THAT(p, Not(Pair(Lt(13), HasSubstr("a"))));
1667 }
1668
TEST(PairTest,SafelyCastsInnerMatchers)1669 TEST(PairTest, SafelyCastsInnerMatchers) {
1670 Matcher<int> is_positive = Gt(0);
1671 Matcher<int> is_negative = Lt(0);
1672 pair<char, bool> p('a', true);
1673 EXPECT_THAT(p, Pair(is_positive, _));
1674 EXPECT_THAT(p, Not(Pair(is_negative, _)));
1675 EXPECT_THAT(p, Pair(_, is_positive));
1676 EXPECT_THAT(p, Not(Pair(_, is_negative)));
1677 }
1678
TEST(PairTest,InsideContainsUsingMap)1679 TEST(PairTest, InsideContainsUsingMap) {
1680 map<int, char> container;
1681 container.insert(make_pair(1, 'a'));
1682 container.insert(make_pair(2, 'b'));
1683 container.insert(make_pair(4, 'c'));
1684 EXPECT_THAT(container, Contains(Pair(1, 'a')));
1685 EXPECT_THAT(container, Contains(Pair(1, _)));
1686 EXPECT_THAT(container, Contains(Pair(_, 'a')));
1687 EXPECT_THAT(container, Not(Contains(Pair(3, _))));
1688 }
1689
1690 #if GTEST_LANG_CXX11
TEST(PairTest,UseGetInsteadOfMembers)1691 TEST(PairTest, UseGetInsteadOfMembers) {
1692 PairWithGet pair{7, "ABC"};
1693 EXPECT_THAT(pair, Pair(7, "ABC"));
1694 EXPECT_THAT(pair, Pair(Ge(7), HasSubstr("AB")));
1695 EXPECT_THAT(pair, Not(Pair(Lt(7), "ABC")));
1696
1697 std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
1698 EXPECT_THAT(v, ElementsAre(Pair(11, string("Foo")), Pair(Ge(10), Not(""))));
1699 }
1700 #endif // GTEST_LANG_CXX11
1701
1702 // Tests StartsWith(s).
1703
TEST(StartsWithTest,MatchesStringWithGivenPrefix)1704 TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
1705 const Matcher<const char*> m1 = StartsWith(std::string(""));
1706 EXPECT_TRUE(m1.Matches("Hi"));
1707 EXPECT_TRUE(m1.Matches(""));
1708 EXPECT_FALSE(m1.Matches(NULL));
1709
1710 const Matcher<const std::string&> m2 = StartsWith("Hi");
1711 EXPECT_TRUE(m2.Matches("Hi"));
1712 EXPECT_TRUE(m2.Matches("Hi Hi!"));
1713 EXPECT_TRUE(m2.Matches("High"));
1714 EXPECT_FALSE(m2.Matches("H"));
1715 EXPECT_FALSE(m2.Matches(" Hi"));
1716 }
1717
TEST(StartsWithTest,CanDescribeSelf)1718 TEST(StartsWithTest, CanDescribeSelf) {
1719 Matcher<const std::string> m = StartsWith("Hi");
1720 EXPECT_EQ("starts with \"Hi\"", Describe(m));
1721 }
1722
1723 // Tests EndsWith(s).
1724
TEST(EndsWithTest,MatchesStringWithGivenSuffix)1725 TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
1726 const Matcher<const char*> m1 = EndsWith("");
1727 EXPECT_TRUE(m1.Matches("Hi"));
1728 EXPECT_TRUE(m1.Matches(""));
1729 EXPECT_FALSE(m1.Matches(NULL));
1730
1731 const Matcher<const std::string&> m2 = EndsWith(std::string("Hi"));
1732 EXPECT_TRUE(m2.Matches("Hi"));
1733 EXPECT_TRUE(m2.Matches("Wow Hi Hi"));
1734 EXPECT_TRUE(m2.Matches("Super Hi"));
1735 EXPECT_FALSE(m2.Matches("i"));
1736 EXPECT_FALSE(m2.Matches("Hi "));
1737
1738 #if GTEST_HAS_GLOBAL_STRING
1739 const Matcher<const ::string&> m3 = EndsWith(::string("Hi"));
1740 EXPECT_TRUE(m3.Matches("Hi"));
1741 EXPECT_TRUE(m3.Matches("Wow Hi Hi"));
1742 EXPECT_TRUE(m3.Matches("Super Hi"));
1743 EXPECT_FALSE(m3.Matches("i"));
1744 EXPECT_FALSE(m3.Matches("Hi "));
1745 #endif // GTEST_HAS_GLOBAL_STRING
1746
1747 #if GTEST_HAS_ABSL
1748 const Matcher<const absl::string_view&> m4 = EndsWith("");
1749 EXPECT_TRUE(m4.Matches("Hi"));
1750 EXPECT_TRUE(m4.Matches(""));
1751 // Default-constructed absl::string_view should not match anything, in order
1752 // to distinguish it from an empty string.
1753 EXPECT_FALSE(m4.Matches(absl::string_view()));
1754 #endif // GTEST_HAS_ABSL
1755 }
1756
TEST(EndsWithTest,CanDescribeSelf)1757 TEST(EndsWithTest, CanDescribeSelf) {
1758 Matcher<const std::string> m = EndsWith("Hi");
1759 EXPECT_EQ("ends with \"Hi\"", Describe(m));
1760 }
1761
1762 // Tests MatchesRegex().
1763
TEST(MatchesRegexTest,MatchesStringMatchingGivenRegex)1764 TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
1765 const Matcher<const char*> m1 = MatchesRegex("a.*z");
1766 EXPECT_TRUE(m1.Matches("az"));
1767 EXPECT_TRUE(m1.Matches("abcz"));
1768 EXPECT_FALSE(m1.Matches(NULL));
1769
1770 const Matcher<const std::string&> m2 = MatchesRegex(new RE("a.*z"));
1771 EXPECT_TRUE(m2.Matches("azbz"));
1772 EXPECT_FALSE(m2.Matches("az1"));
1773 EXPECT_FALSE(m2.Matches("1az"));
1774
1775 #if GTEST_HAS_ABSL
1776 const Matcher<const absl::string_view&> m3 = MatchesRegex("a.*z");
1777 EXPECT_TRUE(m3.Matches(absl::string_view("az")));
1778 EXPECT_TRUE(m3.Matches(absl::string_view("abcz")));
1779 EXPECT_FALSE(m3.Matches(absl::string_view("1az")));
1780 // Default-constructed absl::string_view should not match anything, in order
1781 // to distinguish it from an empty string.
1782 EXPECT_FALSE(m3.Matches(absl::string_view()));
1783 const Matcher<const absl::string_view&> m4 = MatchesRegex("");
1784 EXPECT_FALSE(m4.Matches(absl::string_view()));
1785 #endif // GTEST_HAS_ABSL
1786 }
1787
TEST(MatchesRegexTest,CanDescribeSelf)1788 TEST(MatchesRegexTest, CanDescribeSelf) {
1789 Matcher<const std::string> m1 = MatchesRegex(std::string("Hi.*"));
1790 EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1));
1791
1792 Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
1793 EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2));
1794
1795 #if GTEST_HAS_ABSL
1796 Matcher<const absl::string_view> m3 = MatchesRegex(new RE("0.*"));
1797 EXPECT_EQ("matches regular expression \"0.*\"", Describe(m3));
1798 #endif // GTEST_HAS_ABSL
1799 }
1800
1801 // Tests ContainsRegex().
1802
TEST(ContainsRegexTest,MatchesStringContainingGivenRegex)1803 TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
1804 const Matcher<const char*> m1 = ContainsRegex(std::string("a.*z"));
1805 EXPECT_TRUE(m1.Matches("az"));
1806 EXPECT_TRUE(m1.Matches("0abcz1"));
1807 EXPECT_FALSE(m1.Matches(NULL));
1808
1809 const Matcher<const std::string&> m2 = ContainsRegex(new RE("a.*z"));
1810 EXPECT_TRUE(m2.Matches("azbz"));
1811 EXPECT_TRUE(m2.Matches("az1"));
1812 EXPECT_FALSE(m2.Matches("1a"));
1813
1814 #if GTEST_HAS_ABSL
1815 const Matcher<const absl::string_view&> m3 = ContainsRegex(new RE("a.*z"));
1816 EXPECT_TRUE(m3.Matches(absl::string_view("azbz")));
1817 EXPECT_TRUE(m3.Matches(absl::string_view("az1")));
1818 EXPECT_FALSE(m3.Matches(absl::string_view("1a")));
1819 // Default-constructed absl::string_view should not match anything, in order
1820 // to distinguish it from an empty string.
1821 EXPECT_FALSE(m3.Matches(absl::string_view()));
1822 const Matcher<const absl::string_view&> m4 = ContainsRegex("");
1823 EXPECT_FALSE(m4.Matches(absl::string_view()));
1824 #endif // GTEST_HAS_ABSL
1825 }
1826
TEST(ContainsRegexTest,CanDescribeSelf)1827 TEST(ContainsRegexTest, CanDescribeSelf) {
1828 Matcher<const std::string> m1 = ContainsRegex("Hi.*");
1829 EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1));
1830
1831 Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
1832 EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2));
1833
1834 #if GTEST_HAS_ABSL
1835 Matcher<const absl::string_view> m3 = ContainsRegex(new RE("0.*"));
1836 EXPECT_EQ("contains regular expression \"0.*\"", Describe(m3));
1837 #endif // GTEST_HAS_ABSL
1838 }
1839
1840 // Tests for wide strings.
1841 #if GTEST_HAS_STD_WSTRING
TEST(StdWideStrEqTest,MatchesEqual)1842 TEST(StdWideStrEqTest, MatchesEqual) {
1843 Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello"));
1844 EXPECT_TRUE(m.Matches(L"Hello"));
1845 EXPECT_FALSE(m.Matches(L"hello"));
1846 EXPECT_FALSE(m.Matches(NULL));
1847
1848 Matcher<const ::std::wstring&> m2 = StrEq(L"Hello");
1849 EXPECT_TRUE(m2.Matches(L"Hello"));
1850 EXPECT_FALSE(m2.Matches(L"Hi"));
1851
1852 Matcher<const ::std::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
1853 EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D"));
1854 EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E"));
1855
1856 ::std::wstring str(L"01204500800");
1857 str[3] = L'\0';
1858 Matcher<const ::std::wstring&> m4 = StrEq(str);
1859 EXPECT_TRUE(m4.Matches(str));
1860 str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
1861 Matcher<const ::std::wstring&> m5 = StrEq(str);
1862 EXPECT_TRUE(m5.Matches(str));
1863 }
1864
TEST(StdWideStrEqTest,CanDescribeSelf)1865 TEST(StdWideStrEqTest, CanDescribeSelf) {
1866 Matcher< ::std::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
1867 EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
1868 Describe(m));
1869
1870 Matcher< ::std::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
1871 EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"",
1872 Describe(m2));
1873
1874 ::std::wstring str(L"01204500800");
1875 str[3] = L'\0';
1876 Matcher<const ::std::wstring&> m4 = StrEq(str);
1877 EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4));
1878 str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
1879 Matcher<const ::std::wstring&> m5 = StrEq(str);
1880 EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5));
1881 }
1882
TEST(StdWideStrNeTest,MatchesUnequalString)1883 TEST(StdWideStrNeTest, MatchesUnequalString) {
1884 Matcher<const wchar_t*> m = StrNe(L"Hello");
1885 EXPECT_TRUE(m.Matches(L""));
1886 EXPECT_TRUE(m.Matches(NULL));
1887 EXPECT_FALSE(m.Matches(L"Hello"));
1888
1889 Matcher< ::std::wstring> m2 = StrNe(::std::wstring(L"Hello"));
1890 EXPECT_TRUE(m2.Matches(L"hello"));
1891 EXPECT_FALSE(m2.Matches(L"Hello"));
1892 }
1893
TEST(StdWideStrNeTest,CanDescribeSelf)1894 TEST(StdWideStrNeTest, CanDescribeSelf) {
1895 Matcher<const wchar_t*> m = StrNe(L"Hi");
1896 EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
1897 }
1898
TEST(StdWideStrCaseEqTest,MatchesEqualStringIgnoringCase)1899 TEST(StdWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
1900 Matcher<const wchar_t*> m = StrCaseEq(::std::wstring(L"Hello"));
1901 EXPECT_TRUE(m.Matches(L"Hello"));
1902 EXPECT_TRUE(m.Matches(L"hello"));
1903 EXPECT_FALSE(m.Matches(L"Hi"));
1904 EXPECT_FALSE(m.Matches(NULL));
1905
1906 Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello");
1907 EXPECT_TRUE(m2.Matches(L"hello"));
1908 EXPECT_FALSE(m2.Matches(L"Hi"));
1909 }
1910
TEST(StdWideStrCaseEqTest,MatchesEqualStringWith0IgnoringCase)1911 TEST(StdWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
1912 ::std::wstring str1(L"oabocdooeoo");
1913 ::std::wstring str2(L"OABOCDOOEOO");
1914 Matcher<const ::std::wstring&> m0 = StrCaseEq(str1);
1915 EXPECT_FALSE(m0.Matches(str2 + ::std::wstring(1, L'\0')));
1916
1917 str1[3] = str2[3] = L'\0';
1918 Matcher<const ::std::wstring&> m1 = StrCaseEq(str1);
1919 EXPECT_TRUE(m1.Matches(str2));
1920
1921 str1[0] = str1[6] = str1[7] = str1[10] = L'\0';
1922 str2[0] = str2[6] = str2[7] = str2[10] = L'\0';
1923 Matcher<const ::std::wstring&> m2 = StrCaseEq(str1);
1924 str1[9] = str2[9] = L'\0';
1925 EXPECT_FALSE(m2.Matches(str2));
1926
1927 Matcher<const ::std::wstring&> m3 = StrCaseEq(str1);
1928 EXPECT_TRUE(m3.Matches(str2));
1929
1930 EXPECT_FALSE(m3.Matches(str2 + L"x"));
1931 str2.append(1, L'\0');
1932 EXPECT_FALSE(m3.Matches(str2));
1933 EXPECT_FALSE(m3.Matches(::std::wstring(str2, 0, 9)));
1934 }
1935
TEST(StdWideStrCaseEqTest,CanDescribeSelf)1936 TEST(StdWideStrCaseEqTest, CanDescribeSelf) {
1937 Matcher< ::std::wstring> m = StrCaseEq(L"Hi");
1938 EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m));
1939 }
1940
TEST(StdWideStrCaseNeTest,MatchesUnequalStringIgnoringCase)1941 TEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
1942 Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
1943 EXPECT_TRUE(m.Matches(L"Hi"));
1944 EXPECT_TRUE(m.Matches(NULL));
1945 EXPECT_FALSE(m.Matches(L"Hello"));
1946 EXPECT_FALSE(m.Matches(L"hello"));
1947
1948 Matcher< ::std::wstring> m2 = StrCaseNe(::std::wstring(L"Hello"));
1949 EXPECT_TRUE(m2.Matches(L""));
1950 EXPECT_FALSE(m2.Matches(L"Hello"));
1951 }
1952
TEST(StdWideStrCaseNeTest,CanDescribeSelf)1953 TEST(StdWideStrCaseNeTest, CanDescribeSelf) {
1954 Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
1955 EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
1956 }
1957
1958 // Tests that HasSubstr() works for matching wstring-typed values.
TEST(StdWideHasSubstrTest,WorksForStringClasses)1959 TEST(StdWideHasSubstrTest, WorksForStringClasses) {
1960 const Matcher< ::std::wstring> m1 = HasSubstr(L"foo");
1961 EXPECT_TRUE(m1.Matches(::std::wstring(L"I love food.")));
1962 EXPECT_FALSE(m1.Matches(::std::wstring(L"tofo")));
1963
1964 const Matcher<const ::std::wstring&> m2 = HasSubstr(L"foo");
1965 EXPECT_TRUE(m2.Matches(::std::wstring(L"I love food.")));
1966 EXPECT_FALSE(m2.Matches(::std::wstring(L"tofo")));
1967 }
1968
1969 // Tests that HasSubstr() works for matching C-wide-string-typed values.
TEST(StdWideHasSubstrTest,WorksForCStrings)1970 TEST(StdWideHasSubstrTest, WorksForCStrings) {
1971 const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
1972 EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
1973 EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
1974 EXPECT_FALSE(m1.Matches(NULL));
1975
1976 const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
1977 EXPECT_TRUE(m2.Matches(L"I love food."));
1978 EXPECT_FALSE(m2.Matches(L"tofo"));
1979 EXPECT_FALSE(m2.Matches(NULL));
1980 }
1981
1982 // Tests that HasSubstr(s) describes itself properly.
TEST(StdWideHasSubstrTest,CanDescribeSelf)1983 TEST(StdWideHasSubstrTest, CanDescribeSelf) {
1984 Matcher< ::std::wstring> m = HasSubstr(L"foo\n\"");
1985 EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m));
1986 }
1987
1988 // Tests StartsWith(s).
1989
TEST(StdWideStartsWithTest,MatchesStringWithGivenPrefix)1990 TEST(StdWideStartsWithTest, MatchesStringWithGivenPrefix) {
1991 const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L""));
1992 EXPECT_TRUE(m1.Matches(L"Hi"));
1993 EXPECT_TRUE(m1.Matches(L""));
1994 EXPECT_FALSE(m1.Matches(NULL));
1995
1996 const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi");
1997 EXPECT_TRUE(m2.Matches(L"Hi"));
1998 EXPECT_TRUE(m2.Matches(L"Hi Hi!"));
1999 EXPECT_TRUE(m2.Matches(L"High"));
2000 EXPECT_FALSE(m2.Matches(L"H"));
2001 EXPECT_FALSE(m2.Matches(L" Hi"));
2002 }
2003
TEST(StdWideStartsWithTest,CanDescribeSelf)2004 TEST(StdWideStartsWithTest, CanDescribeSelf) {
2005 Matcher<const ::std::wstring> m = StartsWith(L"Hi");
2006 EXPECT_EQ("starts with L\"Hi\"", Describe(m));
2007 }
2008
2009 // Tests EndsWith(s).
2010
TEST(StdWideEndsWithTest,MatchesStringWithGivenSuffix)2011 TEST(StdWideEndsWithTest, MatchesStringWithGivenSuffix) {
2012 const Matcher<const wchar_t*> m1 = EndsWith(L"");
2013 EXPECT_TRUE(m1.Matches(L"Hi"));
2014 EXPECT_TRUE(m1.Matches(L""));
2015 EXPECT_FALSE(m1.Matches(NULL));
2016
2017 const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi"));
2018 EXPECT_TRUE(m2.Matches(L"Hi"));
2019 EXPECT_TRUE(m2.Matches(L"Wow Hi Hi"));
2020 EXPECT_TRUE(m2.Matches(L"Super Hi"));
2021 EXPECT_FALSE(m2.Matches(L"i"));
2022 EXPECT_FALSE(m2.Matches(L"Hi "));
2023 }
2024
TEST(StdWideEndsWithTest,CanDescribeSelf)2025 TEST(StdWideEndsWithTest, CanDescribeSelf) {
2026 Matcher<const ::std::wstring> m = EndsWith(L"Hi");
2027 EXPECT_EQ("ends with L\"Hi\"", Describe(m));
2028 }
2029
2030 #endif // GTEST_HAS_STD_WSTRING
2031
2032 #if GTEST_HAS_GLOBAL_WSTRING
TEST(GlobalWideStrEqTest,MatchesEqual)2033 TEST(GlobalWideStrEqTest, MatchesEqual) {
2034 Matcher<const wchar_t*> m = StrEq(::wstring(L"Hello"));
2035 EXPECT_TRUE(m.Matches(L"Hello"));
2036 EXPECT_FALSE(m.Matches(L"hello"));
2037 EXPECT_FALSE(m.Matches(NULL));
2038
2039 Matcher<const ::wstring&> m2 = StrEq(L"Hello");
2040 EXPECT_TRUE(m2.Matches(L"Hello"));
2041 EXPECT_FALSE(m2.Matches(L"Hi"));
2042
2043 Matcher<const ::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
2044 EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D"));
2045 EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E"));
2046
2047 ::wstring str(L"01204500800");
2048 str[3] = L'\0';
2049 Matcher<const ::wstring&> m4 = StrEq(str);
2050 EXPECT_TRUE(m4.Matches(str));
2051 str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
2052 Matcher<const ::wstring&> m5 = StrEq(str);
2053 EXPECT_TRUE(m5.Matches(str));
2054 }
2055
TEST(GlobalWideStrEqTest,CanDescribeSelf)2056 TEST(GlobalWideStrEqTest, CanDescribeSelf) {
2057 Matcher< ::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
2058 EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
2059 Describe(m));
2060
2061 Matcher< ::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
2062 EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"",
2063 Describe(m2));
2064
2065 ::wstring str(L"01204500800");
2066 str[3] = L'\0';
2067 Matcher<const ::wstring&> m4 = StrEq(str);
2068 EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4));
2069 str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
2070 Matcher<const ::wstring&> m5 = StrEq(str);
2071 EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5));
2072 }
2073
TEST(GlobalWideStrNeTest,MatchesUnequalString)2074 TEST(GlobalWideStrNeTest, MatchesUnequalString) {
2075 Matcher<const wchar_t*> m = StrNe(L"Hello");
2076 EXPECT_TRUE(m.Matches(L""));
2077 EXPECT_TRUE(m.Matches(NULL));
2078 EXPECT_FALSE(m.Matches(L"Hello"));
2079
2080 Matcher< ::wstring> m2 = StrNe(::wstring(L"Hello"));
2081 EXPECT_TRUE(m2.Matches(L"hello"));
2082 EXPECT_FALSE(m2.Matches(L"Hello"));
2083 }
2084
TEST(GlobalWideStrNeTest,CanDescribeSelf)2085 TEST(GlobalWideStrNeTest, CanDescribeSelf) {
2086 Matcher<const wchar_t*> m = StrNe(L"Hi");
2087 EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
2088 }
2089
TEST(GlobalWideStrCaseEqTest,MatchesEqualStringIgnoringCase)2090 TEST(GlobalWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
2091 Matcher<const wchar_t*> m = StrCaseEq(::wstring(L"Hello"));
2092 EXPECT_TRUE(m.Matches(L"Hello"));
2093 EXPECT_TRUE(m.Matches(L"hello"));
2094 EXPECT_FALSE(m.Matches(L"Hi"));
2095 EXPECT_FALSE(m.Matches(NULL));
2096
2097 Matcher<const ::wstring&> m2 = StrCaseEq(L"Hello");
2098 EXPECT_TRUE(m2.Matches(L"hello"));
2099 EXPECT_FALSE(m2.Matches(L"Hi"));
2100 }
2101
TEST(GlobalWideStrCaseEqTest,MatchesEqualStringWith0IgnoringCase)2102 TEST(GlobalWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
2103 ::wstring str1(L"oabocdooeoo");
2104 ::wstring str2(L"OABOCDOOEOO");
2105 Matcher<const ::wstring&> m0 = StrCaseEq(str1);
2106 EXPECT_FALSE(m0.Matches(str2 + ::wstring(1, L'\0')));
2107
2108 str1[3] = str2[3] = L'\0';
2109 Matcher<const ::wstring&> m1 = StrCaseEq(str1);
2110 EXPECT_TRUE(m1.Matches(str2));
2111
2112 str1[0] = str1[6] = str1[7] = str1[10] = L'\0';
2113 str2[0] = str2[6] = str2[7] = str2[10] = L'\0';
2114 Matcher<const ::wstring&> m2 = StrCaseEq(str1);
2115 str1[9] = str2[9] = L'\0';
2116 EXPECT_FALSE(m2.Matches(str2));
2117
2118 Matcher<const ::wstring&> m3 = StrCaseEq(str1);
2119 EXPECT_TRUE(m3.Matches(str2));
2120
2121 EXPECT_FALSE(m3.Matches(str2 + L"x"));
2122 str2.append(1, L'\0');
2123 EXPECT_FALSE(m3.Matches(str2));
2124 EXPECT_FALSE(m3.Matches(::wstring(str2, 0, 9)));
2125 }
2126
TEST(GlobalWideStrCaseEqTest,CanDescribeSelf)2127 TEST(GlobalWideStrCaseEqTest, CanDescribeSelf) {
2128 Matcher< ::wstring> m = StrCaseEq(L"Hi");
2129 EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m));
2130 }
2131
TEST(GlobalWideStrCaseNeTest,MatchesUnequalStringIgnoringCase)2132 TEST(GlobalWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
2133 Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
2134 EXPECT_TRUE(m.Matches(L"Hi"));
2135 EXPECT_TRUE(m.Matches(NULL));
2136 EXPECT_FALSE(m.Matches(L"Hello"));
2137 EXPECT_FALSE(m.Matches(L"hello"));
2138
2139 Matcher< ::wstring> m2 = StrCaseNe(::wstring(L"Hello"));
2140 EXPECT_TRUE(m2.Matches(L""));
2141 EXPECT_FALSE(m2.Matches(L"Hello"));
2142 }
2143
TEST(GlobalWideStrCaseNeTest,CanDescribeSelf)2144 TEST(GlobalWideStrCaseNeTest, CanDescribeSelf) {
2145 Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
2146 EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
2147 }
2148
2149 // Tests that HasSubstr() works for matching wstring-typed values.
TEST(GlobalWideHasSubstrTest,WorksForStringClasses)2150 TEST(GlobalWideHasSubstrTest, WorksForStringClasses) {
2151 const Matcher< ::wstring> m1 = HasSubstr(L"foo");
2152 EXPECT_TRUE(m1.Matches(::wstring(L"I love food.")));
2153 EXPECT_FALSE(m1.Matches(::wstring(L"tofo")));
2154
2155 const Matcher<const ::wstring&> m2 = HasSubstr(L"foo");
2156 EXPECT_TRUE(m2.Matches(::wstring(L"I love food.")));
2157 EXPECT_FALSE(m2.Matches(::wstring(L"tofo")));
2158 }
2159
2160 // Tests that HasSubstr() works for matching C-wide-string-typed values.
TEST(GlobalWideHasSubstrTest,WorksForCStrings)2161 TEST(GlobalWideHasSubstrTest, WorksForCStrings) {
2162 const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
2163 EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
2164 EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
2165 EXPECT_FALSE(m1.Matches(NULL));
2166
2167 const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
2168 EXPECT_TRUE(m2.Matches(L"I love food."));
2169 EXPECT_FALSE(m2.Matches(L"tofo"));
2170 EXPECT_FALSE(m2.Matches(NULL));
2171 }
2172
2173 // Tests that HasSubstr(s) describes itself properly.
TEST(GlobalWideHasSubstrTest,CanDescribeSelf)2174 TEST(GlobalWideHasSubstrTest, CanDescribeSelf) {
2175 Matcher< ::wstring> m = HasSubstr(L"foo\n\"");
2176 EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m));
2177 }
2178
2179 // Tests StartsWith(s).
2180
TEST(GlobalWideStartsWithTest,MatchesStringWithGivenPrefix)2181 TEST(GlobalWideStartsWithTest, MatchesStringWithGivenPrefix) {
2182 const Matcher<const wchar_t*> m1 = StartsWith(::wstring(L""));
2183 EXPECT_TRUE(m1.Matches(L"Hi"));
2184 EXPECT_TRUE(m1.Matches(L""));
2185 EXPECT_FALSE(m1.Matches(NULL));
2186
2187 const Matcher<const ::wstring&> m2 = StartsWith(L"Hi");
2188 EXPECT_TRUE(m2.Matches(L"Hi"));
2189 EXPECT_TRUE(m2.Matches(L"Hi Hi!"));
2190 EXPECT_TRUE(m2.Matches(L"High"));
2191 EXPECT_FALSE(m2.Matches(L"H"));
2192 EXPECT_FALSE(m2.Matches(L" Hi"));
2193 }
2194
TEST(GlobalWideStartsWithTest,CanDescribeSelf)2195 TEST(GlobalWideStartsWithTest, CanDescribeSelf) {
2196 Matcher<const ::wstring> m = StartsWith(L"Hi");
2197 EXPECT_EQ("starts with L\"Hi\"", Describe(m));
2198 }
2199
2200 // Tests EndsWith(s).
2201
TEST(GlobalWideEndsWithTest,MatchesStringWithGivenSuffix)2202 TEST(GlobalWideEndsWithTest, MatchesStringWithGivenSuffix) {
2203 const Matcher<const wchar_t*> m1 = EndsWith(L"");
2204 EXPECT_TRUE(m1.Matches(L"Hi"));
2205 EXPECT_TRUE(m1.Matches(L""));
2206 EXPECT_FALSE(m1.Matches(NULL));
2207
2208 const Matcher<const ::wstring&> m2 = EndsWith(::wstring(L"Hi"));
2209 EXPECT_TRUE(m2.Matches(L"Hi"));
2210 EXPECT_TRUE(m2.Matches(L"Wow Hi Hi"));
2211 EXPECT_TRUE(m2.Matches(L"Super Hi"));
2212 EXPECT_FALSE(m2.Matches(L"i"));
2213 EXPECT_FALSE(m2.Matches(L"Hi "));
2214 }
2215
TEST(GlobalWideEndsWithTest,CanDescribeSelf)2216 TEST(GlobalWideEndsWithTest, CanDescribeSelf) {
2217 Matcher<const ::wstring> m = EndsWith(L"Hi");
2218 EXPECT_EQ("ends with L\"Hi\"", Describe(m));
2219 }
2220
2221 #endif // GTEST_HAS_GLOBAL_WSTRING
2222
2223
2224 typedef ::testing::tuple<long, int> Tuple2; // NOLINT
2225
2226 // Tests that Eq() matches a 2-tuple where the first field == the
2227 // second field.
TEST(Eq2Test,MatchesEqualArguments)2228 TEST(Eq2Test, MatchesEqualArguments) {
2229 Matcher<const Tuple2&> m = Eq();
2230 EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
2231 EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
2232 }
2233
2234 // Tests that Eq() describes itself properly.
TEST(Eq2Test,CanDescribeSelf)2235 TEST(Eq2Test, CanDescribeSelf) {
2236 Matcher<const Tuple2&> m = Eq();
2237 EXPECT_EQ("are an equal pair", Describe(m));
2238 }
2239
2240 // Tests that Ge() matches a 2-tuple where the first field >= the
2241 // second field.
TEST(Ge2Test,MatchesGreaterThanOrEqualArguments)2242 TEST(Ge2Test, MatchesGreaterThanOrEqualArguments) {
2243 Matcher<const Tuple2&> m = Ge();
2244 EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
2245 EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
2246 EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
2247 }
2248
2249 // Tests that Ge() describes itself properly.
TEST(Ge2Test,CanDescribeSelf)2250 TEST(Ge2Test, CanDescribeSelf) {
2251 Matcher<const Tuple2&> m = Ge();
2252 EXPECT_EQ("are a pair where the first >= the second", Describe(m));
2253 }
2254
2255 // Tests that Gt() matches a 2-tuple where the first field > the
2256 // second field.
TEST(Gt2Test,MatchesGreaterThanArguments)2257 TEST(Gt2Test, MatchesGreaterThanArguments) {
2258 Matcher<const Tuple2&> m = Gt();
2259 EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
2260 EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
2261 EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
2262 }
2263
2264 // Tests that Gt() describes itself properly.
TEST(Gt2Test,CanDescribeSelf)2265 TEST(Gt2Test, CanDescribeSelf) {
2266 Matcher<const Tuple2&> m = Gt();
2267 EXPECT_EQ("are a pair where the first > the second", Describe(m));
2268 }
2269
2270 // Tests that Le() matches a 2-tuple where the first field <= the
2271 // second field.
TEST(Le2Test,MatchesLessThanOrEqualArguments)2272 TEST(Le2Test, MatchesLessThanOrEqualArguments) {
2273 Matcher<const Tuple2&> m = Le();
2274 EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
2275 EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
2276 EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
2277 }
2278
2279 // Tests that Le() describes itself properly.
TEST(Le2Test,CanDescribeSelf)2280 TEST(Le2Test, CanDescribeSelf) {
2281 Matcher<const Tuple2&> m = Le();
2282 EXPECT_EQ("are a pair where the first <= the second", Describe(m));
2283 }
2284
2285 // Tests that Lt() matches a 2-tuple where the first field < the
2286 // second field.
TEST(Lt2Test,MatchesLessThanArguments)2287 TEST(Lt2Test, MatchesLessThanArguments) {
2288 Matcher<const Tuple2&> m = Lt();
2289 EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
2290 EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
2291 EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
2292 }
2293
2294 // Tests that Lt() describes itself properly.
TEST(Lt2Test,CanDescribeSelf)2295 TEST(Lt2Test, CanDescribeSelf) {
2296 Matcher<const Tuple2&> m = Lt();
2297 EXPECT_EQ("are a pair where the first < the second", Describe(m));
2298 }
2299
2300 // Tests that Ne() matches a 2-tuple where the first field != the
2301 // second field.
TEST(Ne2Test,MatchesUnequalArguments)2302 TEST(Ne2Test, MatchesUnequalArguments) {
2303 Matcher<const Tuple2&> m = Ne();
2304 EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
2305 EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
2306 EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
2307 }
2308
2309 // Tests that Ne() describes itself properly.
TEST(Ne2Test,CanDescribeSelf)2310 TEST(Ne2Test, CanDescribeSelf) {
2311 Matcher<const Tuple2&> m = Ne();
2312 EXPECT_EQ("are an unequal pair", Describe(m));
2313 }
2314
2315 // Tests that FloatEq() matches a 2-tuple where
2316 // FloatEq(first field) matches the second field.
TEST(FloatEq2Test,MatchesEqualArguments)2317 TEST(FloatEq2Test, MatchesEqualArguments) {
2318 typedef ::testing::tuple<float, float> Tpl;
2319 Matcher<const Tpl&> m = FloatEq();
2320 EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
2321 EXPECT_TRUE(m.Matches(Tpl(0.3f, 0.1f + 0.1f + 0.1f)));
2322 EXPECT_FALSE(m.Matches(Tpl(1.1f, 1.0f)));
2323 }
2324
2325 // Tests that FloatEq() describes itself properly.
TEST(FloatEq2Test,CanDescribeSelf)2326 TEST(FloatEq2Test, CanDescribeSelf) {
2327 Matcher<const ::testing::tuple<float, float>&> m = FloatEq();
2328 EXPECT_EQ("are an almost-equal pair", Describe(m));
2329 }
2330
2331 // Tests that NanSensitiveFloatEq() matches a 2-tuple where
2332 // NanSensitiveFloatEq(first field) matches the second field.
TEST(NanSensitiveFloatEqTest,MatchesEqualArgumentsWithNaN)2333 TEST(NanSensitiveFloatEqTest, MatchesEqualArgumentsWithNaN) {
2334 typedef ::testing::tuple<float, float> Tpl;
2335 Matcher<const Tpl&> m = NanSensitiveFloatEq();
2336 EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
2337 EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(),
2338 std::numeric_limits<float>::quiet_NaN())));
2339 EXPECT_FALSE(m.Matches(Tpl(1.1f, 1.0f)));
2340 EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<float>::quiet_NaN())));
2341 EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(), 1.0f)));
2342 }
2343
2344 // Tests that NanSensitiveFloatEq() describes itself properly.
TEST(NanSensitiveFloatEqTest,CanDescribeSelfWithNaNs)2345 TEST(NanSensitiveFloatEqTest, CanDescribeSelfWithNaNs) {
2346 Matcher<const ::testing::tuple<float, float>&> m = NanSensitiveFloatEq();
2347 EXPECT_EQ("are an almost-equal pair", Describe(m));
2348 }
2349
2350 // Tests that DoubleEq() matches a 2-tuple where
2351 // DoubleEq(first field) matches the second field.
TEST(DoubleEq2Test,MatchesEqualArguments)2352 TEST(DoubleEq2Test, MatchesEqualArguments) {
2353 typedef ::testing::tuple<double, double> Tpl;
2354 Matcher<const Tpl&> m = DoubleEq();
2355 EXPECT_TRUE(m.Matches(Tpl(1.0, 1.0)));
2356 EXPECT_TRUE(m.Matches(Tpl(0.3, 0.1 + 0.1 + 0.1)));
2357 EXPECT_FALSE(m.Matches(Tpl(1.1, 1.0)));
2358 }
2359
2360 // Tests that DoubleEq() describes itself properly.
TEST(DoubleEq2Test,CanDescribeSelf)2361 TEST(DoubleEq2Test, CanDescribeSelf) {
2362 Matcher<const ::testing::tuple<double, double>&> m = DoubleEq();
2363 EXPECT_EQ("are an almost-equal pair", Describe(m));
2364 }
2365
2366 // Tests that NanSensitiveDoubleEq() matches a 2-tuple where
2367 // NanSensitiveDoubleEq(first field) matches the second field.
TEST(NanSensitiveDoubleEqTest,MatchesEqualArgumentsWithNaN)2368 TEST(NanSensitiveDoubleEqTest, MatchesEqualArgumentsWithNaN) {
2369 typedef ::testing::tuple<double, double> Tpl;
2370 Matcher<const Tpl&> m = NanSensitiveDoubleEq();
2371 EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
2372 EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(),
2373 std::numeric_limits<double>::quiet_NaN())));
2374 EXPECT_FALSE(m.Matches(Tpl(1.1f, 1.0f)));
2375 EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<double>::quiet_NaN())));
2376 EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(), 1.0f)));
2377 }
2378
2379 // Tests that DoubleEq() describes itself properly.
TEST(NanSensitiveDoubleEqTest,CanDescribeSelfWithNaNs)2380 TEST(NanSensitiveDoubleEqTest, CanDescribeSelfWithNaNs) {
2381 Matcher<const ::testing::tuple<double, double>&> m = NanSensitiveDoubleEq();
2382 EXPECT_EQ("are an almost-equal pair", Describe(m));
2383 }
2384
2385 // Tests that FloatEq() matches a 2-tuple where
2386 // FloatNear(first field, max_abs_error) matches the second field.
TEST(FloatNear2Test,MatchesEqualArguments)2387 TEST(FloatNear2Test, MatchesEqualArguments) {
2388 typedef ::testing::tuple<float, float> Tpl;
2389 Matcher<const Tpl&> m = FloatNear(0.5f);
2390 EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
2391 EXPECT_TRUE(m.Matches(Tpl(1.3f, 1.0f)));
2392 EXPECT_FALSE(m.Matches(Tpl(1.8f, 1.0f)));
2393 }
2394
2395 // Tests that FloatNear() describes itself properly.
TEST(FloatNear2Test,CanDescribeSelf)2396 TEST(FloatNear2Test, CanDescribeSelf) {
2397 Matcher<const ::testing::tuple<float, float>&> m = FloatNear(0.5f);
2398 EXPECT_EQ("are an almost-equal pair", Describe(m));
2399 }
2400
2401 // Tests that NanSensitiveFloatNear() matches a 2-tuple where
2402 // NanSensitiveFloatNear(first field) matches the second field.
TEST(NanSensitiveFloatNearTest,MatchesNearbyArgumentsWithNaN)2403 TEST(NanSensitiveFloatNearTest, MatchesNearbyArgumentsWithNaN) {
2404 typedef ::testing::tuple<float, float> Tpl;
2405 Matcher<const Tpl&> m = NanSensitiveFloatNear(0.5f);
2406 EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
2407 EXPECT_TRUE(m.Matches(Tpl(1.1f, 1.0f)));
2408 EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(),
2409 std::numeric_limits<float>::quiet_NaN())));
2410 EXPECT_FALSE(m.Matches(Tpl(1.6f, 1.0f)));
2411 EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<float>::quiet_NaN())));
2412 EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(), 1.0f)));
2413 }
2414
2415 // Tests that NanSensitiveFloatNear() describes itself properly.
TEST(NanSensitiveFloatNearTest,CanDescribeSelfWithNaNs)2416 TEST(NanSensitiveFloatNearTest, CanDescribeSelfWithNaNs) {
2417 Matcher<const ::testing::tuple<float, float>&> m =
2418 NanSensitiveFloatNear(0.5f);
2419 EXPECT_EQ("are an almost-equal pair", Describe(m));
2420 }
2421
2422 // Tests that FloatEq() matches a 2-tuple where
2423 // DoubleNear(first field, max_abs_error) matches the second field.
TEST(DoubleNear2Test,MatchesEqualArguments)2424 TEST(DoubleNear2Test, MatchesEqualArguments) {
2425 typedef ::testing::tuple<double, double> Tpl;
2426 Matcher<const Tpl&> m = DoubleNear(0.5);
2427 EXPECT_TRUE(m.Matches(Tpl(1.0, 1.0)));
2428 EXPECT_TRUE(m.Matches(Tpl(1.3, 1.0)));
2429 EXPECT_FALSE(m.Matches(Tpl(1.8, 1.0)));
2430 }
2431
2432 // Tests that DoubleNear() describes itself properly.
TEST(DoubleNear2Test,CanDescribeSelf)2433 TEST(DoubleNear2Test, CanDescribeSelf) {
2434 Matcher<const ::testing::tuple<double, double>&> m = DoubleNear(0.5);
2435 EXPECT_EQ("are an almost-equal pair", Describe(m));
2436 }
2437
2438 // Tests that NanSensitiveDoubleNear() matches a 2-tuple where
2439 // NanSensitiveDoubleNear(first field) matches the second field.
TEST(NanSensitiveDoubleNearTest,MatchesNearbyArgumentsWithNaN)2440 TEST(NanSensitiveDoubleNearTest, MatchesNearbyArgumentsWithNaN) {
2441 typedef ::testing::tuple<double, double> Tpl;
2442 Matcher<const Tpl&> m = NanSensitiveDoubleNear(0.5f);
2443 EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
2444 EXPECT_TRUE(m.Matches(Tpl(1.1f, 1.0f)));
2445 EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(),
2446 std::numeric_limits<double>::quiet_NaN())));
2447 EXPECT_FALSE(m.Matches(Tpl(1.6f, 1.0f)));
2448 EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<double>::quiet_NaN())));
2449 EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(), 1.0f)));
2450 }
2451
2452 // Tests that NanSensitiveDoubleNear() describes itself properly.
TEST(NanSensitiveDoubleNearTest,CanDescribeSelfWithNaNs)2453 TEST(NanSensitiveDoubleNearTest, CanDescribeSelfWithNaNs) {
2454 Matcher<const ::testing::tuple<double, double>&> m =
2455 NanSensitiveDoubleNear(0.5f);
2456 EXPECT_EQ("are an almost-equal pair", Describe(m));
2457 }
2458
2459 // Tests that Not(m) matches any value that doesn't match m.
TEST(NotTest,NegatesMatcher)2460 TEST(NotTest, NegatesMatcher) {
2461 Matcher<int> m;
2462 m = Not(Eq(2));
2463 EXPECT_TRUE(m.Matches(3));
2464 EXPECT_FALSE(m.Matches(2));
2465 }
2466
2467 // Tests that Not(m) describes itself properly.
TEST(NotTest,CanDescribeSelf)2468 TEST(NotTest, CanDescribeSelf) {
2469 Matcher<int> m = Not(Eq(5));
2470 EXPECT_EQ("isn't equal to 5", Describe(m));
2471 }
2472
2473 // Tests that monomorphic matchers are safely cast by the Not matcher.
TEST(NotTest,NotMatcherSafelyCastsMonomorphicMatchers)2474 TEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) {
2475 // greater_than_5 is a monomorphic matcher.
2476 Matcher<int> greater_than_5 = Gt(5);
2477
2478 Matcher<const int&> m = Not(greater_than_5);
2479 Matcher<int&> m2 = Not(greater_than_5);
2480 Matcher<int&> m3 = Not(m);
2481 }
2482
2483 // Helper to allow easy testing of AllOf matchers with num parameters.
AllOfMatches(int num,const Matcher<int> & m)2484 void AllOfMatches(int num, const Matcher<int>& m) {
2485 SCOPED_TRACE(Describe(m));
2486 EXPECT_TRUE(m.Matches(0));
2487 for (int i = 1; i <= num; ++i) {
2488 EXPECT_FALSE(m.Matches(i));
2489 }
2490 EXPECT_TRUE(m.Matches(num + 1));
2491 }
2492
2493 // Tests that AllOf(m1, ..., mn) matches any value that matches all of
2494 // the given matchers.
TEST(AllOfTest,MatchesWhenAllMatch)2495 TEST(AllOfTest, MatchesWhenAllMatch) {
2496 Matcher<int> m;
2497 m = AllOf(Le(2), Ge(1));
2498 EXPECT_TRUE(m.Matches(1));
2499 EXPECT_TRUE(m.Matches(2));
2500 EXPECT_FALSE(m.Matches(0));
2501 EXPECT_FALSE(m.Matches(3));
2502
2503 m = AllOf(Gt(0), Ne(1), Ne(2));
2504 EXPECT_TRUE(m.Matches(3));
2505 EXPECT_FALSE(m.Matches(2));
2506 EXPECT_FALSE(m.Matches(1));
2507 EXPECT_FALSE(m.Matches(0));
2508
2509 m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
2510 EXPECT_TRUE(m.Matches(4));
2511 EXPECT_FALSE(m.Matches(3));
2512 EXPECT_FALSE(m.Matches(2));
2513 EXPECT_FALSE(m.Matches(1));
2514 EXPECT_FALSE(m.Matches(0));
2515
2516 m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
2517 EXPECT_TRUE(m.Matches(0));
2518 EXPECT_TRUE(m.Matches(1));
2519 EXPECT_FALSE(m.Matches(3));
2520
2521 // The following tests for varying number of sub-matchers. Due to the way
2522 // the sub-matchers are handled it is enough to test every sub-matcher once
2523 // with sub-matchers using the same matcher type. Varying matcher types are
2524 // checked for above.
2525 AllOfMatches(2, AllOf(Ne(1), Ne(2)));
2526 AllOfMatches(3, AllOf(Ne(1), Ne(2), Ne(3)));
2527 AllOfMatches(4, AllOf(Ne(1), Ne(2), Ne(3), Ne(4)));
2528 AllOfMatches(5, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5)));
2529 AllOfMatches(6, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6)));
2530 AllOfMatches(7, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7)));
2531 AllOfMatches(8, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
2532 Ne(8)));
2533 AllOfMatches(9, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
2534 Ne(8), Ne(9)));
2535 AllOfMatches(10, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
2536 Ne(9), Ne(10)));
2537 }
2538
2539 #if GTEST_LANG_CXX11
2540 // Tests the variadic version of the AllOfMatcher.
TEST(AllOfTest,VariadicMatchesWhenAllMatch)2541 TEST(AllOfTest, VariadicMatchesWhenAllMatch) {
2542 // Make sure AllOf is defined in the right namespace and does not depend on
2543 // ADL.
2544 ::testing::AllOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
2545 Matcher<int> m = AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
2546 Ne(9), Ne(10), Ne(11));
2547 EXPECT_THAT(Describe(m), EndsWith("and (isn't equal to 11)"));
2548 AllOfMatches(11, m);
2549 AllOfMatches(50, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
2550 Ne(9), Ne(10), Ne(11), Ne(12), Ne(13), Ne(14), Ne(15),
2551 Ne(16), Ne(17), Ne(18), Ne(19), Ne(20), Ne(21), Ne(22),
2552 Ne(23), Ne(24), Ne(25), Ne(26), Ne(27), Ne(28), Ne(29),
2553 Ne(30), Ne(31), Ne(32), Ne(33), Ne(34), Ne(35), Ne(36),
2554 Ne(37), Ne(38), Ne(39), Ne(40), Ne(41), Ne(42), Ne(43),
2555 Ne(44), Ne(45), Ne(46), Ne(47), Ne(48), Ne(49),
2556 Ne(50)));
2557 }
2558
2559 #endif // GTEST_LANG_CXX11
2560
2561 // Tests that AllOf(m1, ..., mn) describes itself properly.
TEST(AllOfTest,CanDescribeSelf)2562 TEST(AllOfTest, CanDescribeSelf) {
2563 Matcher<int> m;
2564 m = AllOf(Le(2), Ge(1));
2565 EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m));
2566
2567 m = AllOf(Gt(0), Ne(1), Ne(2));
2568 EXPECT_EQ("(is > 0) and "
2569 "((isn't equal to 1) and "
2570 "(isn't equal to 2))",
2571 Describe(m));
2572
2573
2574 m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
2575 EXPECT_EQ("((is > 0) and "
2576 "(isn't equal to 1)) and "
2577 "((isn't equal to 2) and "
2578 "(isn't equal to 3))",
2579 Describe(m));
2580
2581
2582 m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
2583 EXPECT_EQ("((is >= 0) and "
2584 "(is < 10)) and "
2585 "((isn't equal to 3) and "
2586 "((isn't equal to 5) and "
2587 "(isn't equal to 7)))",
2588 Describe(m));
2589 }
2590
2591 // Tests that AllOf(m1, ..., mn) describes its negation properly.
TEST(AllOfTest,CanDescribeNegation)2592 TEST(AllOfTest, CanDescribeNegation) {
2593 Matcher<int> m;
2594 m = AllOf(Le(2), Ge(1));
2595 EXPECT_EQ("(isn't <= 2) or "
2596 "(isn't >= 1)",
2597 DescribeNegation(m));
2598
2599 m = AllOf(Gt(0), Ne(1), Ne(2));
2600 EXPECT_EQ("(isn't > 0) or "
2601 "((is equal to 1) or "
2602 "(is equal to 2))",
2603 DescribeNegation(m));
2604
2605
2606 m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
2607 EXPECT_EQ("((isn't > 0) or "
2608 "(is equal to 1)) or "
2609 "((is equal to 2) or "
2610 "(is equal to 3))",
2611 DescribeNegation(m));
2612
2613
2614 m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
2615 EXPECT_EQ("((isn't >= 0) or "
2616 "(isn't < 10)) or "
2617 "((is equal to 3) or "
2618 "((is equal to 5) or "
2619 "(is equal to 7)))",
2620 DescribeNegation(m));
2621 }
2622
2623 // Tests that monomorphic matchers are safely cast by the AllOf matcher.
TEST(AllOfTest,AllOfMatcherSafelyCastsMonomorphicMatchers)2624 TEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) {
2625 // greater_than_5 and less_than_10 are monomorphic matchers.
2626 Matcher<int> greater_than_5 = Gt(5);
2627 Matcher<int> less_than_10 = Lt(10);
2628
2629 Matcher<const int&> m = AllOf(greater_than_5, less_than_10);
2630 Matcher<int&> m2 = AllOf(greater_than_5, less_than_10);
2631 Matcher<int&> m3 = AllOf(greater_than_5, m2);
2632
2633 // Tests that BothOf works when composing itself.
2634 Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10);
2635 Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10);
2636 }
2637
TEST(AllOfTest,ExplainsResult)2638 TEST(AllOfTest, ExplainsResult) {
2639 Matcher<int> m;
2640
2641 // Successful match. Both matchers need to explain. The second
2642 // matcher doesn't give an explanation, so only the first matcher's
2643 // explanation is printed.
2644 m = AllOf(GreaterThan(10), Lt(30));
2645 EXPECT_EQ("which is 15 more than 10", Explain(m, 25));
2646
2647 // Successful match. Both matchers need to explain.
2648 m = AllOf(GreaterThan(10), GreaterThan(20));
2649 EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20",
2650 Explain(m, 30));
2651
2652 // Successful match. All matchers need to explain. The second
2653 // matcher doesn't given an explanation.
2654 m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
2655 EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
2656 Explain(m, 25));
2657
2658 // Successful match. All matchers need to explain.
2659 m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
2660 EXPECT_EQ("which is 30 more than 10, and which is 20 more than 20, "
2661 "and which is 10 more than 30",
2662 Explain(m, 40));
2663
2664 // Failed match. The first matcher, which failed, needs to
2665 // explain.
2666 m = AllOf(GreaterThan(10), GreaterThan(20));
2667 EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
2668
2669 // Failed match. The second matcher, which failed, needs to
2670 // explain. Since it doesn't given an explanation, nothing is
2671 // printed.
2672 m = AllOf(GreaterThan(10), Lt(30));
2673 EXPECT_EQ("", Explain(m, 40));
2674
2675 // Failed match. The second matcher, which failed, needs to
2676 // explain.
2677 m = AllOf(GreaterThan(10), GreaterThan(20));
2678 EXPECT_EQ("which is 5 less than 20", Explain(m, 15));
2679 }
2680
2681 // Helper to allow easy testing of AnyOf matchers with num parameters.
AnyOfMatches(int num,const Matcher<int> & m)2682 static void AnyOfMatches(int num, const Matcher<int>& m) {
2683 SCOPED_TRACE(Describe(m));
2684 EXPECT_FALSE(m.Matches(0));
2685 for (int i = 1; i <= num; ++i) {
2686 EXPECT_TRUE(m.Matches(i));
2687 }
2688 EXPECT_FALSE(m.Matches(num + 1));
2689 }
2690
2691 #if GTEST_LANG_CXX11
AnyOfStringMatches(int num,const Matcher<std::string> & m)2692 static void AnyOfStringMatches(int num, const Matcher<std::string>& m) {
2693 SCOPED_TRACE(Describe(m));
2694 EXPECT_FALSE(m.Matches(std::to_string(0)));
2695
2696 for (int i = 1; i <= num; ++i) {
2697 EXPECT_TRUE(m.Matches(std::to_string(i)));
2698 }
2699 EXPECT_FALSE(m.Matches(std::to_string(num + 1)));
2700 }
2701 #endif
2702
2703 // Tests that AnyOf(m1, ..., mn) matches any value that matches at
2704 // least one of the given matchers.
TEST(AnyOfTest,MatchesWhenAnyMatches)2705 TEST(AnyOfTest, MatchesWhenAnyMatches) {
2706 Matcher<int> m;
2707 m = AnyOf(Le(1), Ge(3));
2708 EXPECT_TRUE(m.Matches(1));
2709 EXPECT_TRUE(m.Matches(4));
2710 EXPECT_FALSE(m.Matches(2));
2711
2712 m = AnyOf(Lt(0), Eq(1), Eq(2));
2713 EXPECT_TRUE(m.Matches(-1));
2714 EXPECT_TRUE(m.Matches(1));
2715 EXPECT_TRUE(m.Matches(2));
2716 EXPECT_FALSE(m.Matches(0));
2717
2718 m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
2719 EXPECT_TRUE(m.Matches(-1));
2720 EXPECT_TRUE(m.Matches(1));
2721 EXPECT_TRUE(m.Matches(2));
2722 EXPECT_TRUE(m.Matches(3));
2723 EXPECT_FALSE(m.Matches(0));
2724
2725 m = AnyOf(Le(0), Gt(10), 3, 5, 7);
2726 EXPECT_TRUE(m.Matches(0));
2727 EXPECT_TRUE(m.Matches(11));
2728 EXPECT_TRUE(m.Matches(3));
2729 EXPECT_FALSE(m.Matches(2));
2730
2731 // The following tests for varying number of sub-matchers. Due to the way
2732 // the sub-matchers are handled it is enough to test every sub-matcher once
2733 // with sub-matchers using the same matcher type. Varying matcher types are
2734 // checked for above.
2735 AnyOfMatches(2, AnyOf(1, 2));
2736 AnyOfMatches(3, AnyOf(1, 2, 3));
2737 AnyOfMatches(4, AnyOf(1, 2, 3, 4));
2738 AnyOfMatches(5, AnyOf(1, 2, 3, 4, 5));
2739 AnyOfMatches(6, AnyOf(1, 2, 3, 4, 5, 6));
2740 AnyOfMatches(7, AnyOf(1, 2, 3, 4, 5, 6, 7));
2741 AnyOfMatches(8, AnyOf(1, 2, 3, 4, 5, 6, 7, 8));
2742 AnyOfMatches(9, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9));
2743 AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
2744 }
2745
2746 #if GTEST_LANG_CXX11
2747 // Tests the variadic version of the AnyOfMatcher.
TEST(AnyOfTest,VariadicMatchesWhenAnyMatches)2748 TEST(AnyOfTest, VariadicMatchesWhenAnyMatches) {
2749 // Also make sure AnyOf is defined in the right namespace and does not depend
2750 // on ADL.
2751 Matcher<int> m = ::testing::AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
2752
2753 EXPECT_THAT(Describe(m), EndsWith("or (is equal to 11)"));
2754 AnyOfMatches(11, m);
2755 AnyOfMatches(50, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
2756 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
2757 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
2758 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2759 41, 42, 43, 44, 45, 46, 47, 48, 49, 50));
2760 AnyOfStringMatches(
2761 50, AnyOf("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
2762 "13", "14", "15", "16", "17", "18", "19", "20", "21", "22",
2763 "23", "24", "25", "26", "27", "28", "29", "30", "31", "32",
2764 "33", "34", "35", "36", "37", "38", "39", "40", "41", "42",
2765 "43", "44", "45", "46", "47", "48", "49", "50"));
2766 }
2767
2768 // Tests the variadic version of the ElementsAreMatcher
TEST(ElementsAreTest,HugeMatcher)2769 TEST(ElementsAreTest, HugeMatcher) {
2770 vector<int> test_vector{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
2771
2772 EXPECT_THAT(test_vector,
2773 ElementsAre(Eq(1), Eq(2), Lt(13), Eq(4), Eq(5), Eq(6), Eq(7),
2774 Eq(8), Eq(9), Eq(10), Gt(1), Eq(12)));
2775 }
2776
2777 // Tests the variadic version of the UnorderedElementsAreMatcher
TEST(ElementsAreTest,HugeMatcherStr)2778 TEST(ElementsAreTest, HugeMatcherStr) {
2779 vector<string> test_vector{
2780 "literal_string", "", "", "", "", "", "", "", "", "", "", ""};
2781
2782 EXPECT_THAT(test_vector, UnorderedElementsAre("literal_string", _, _, _, _, _,
2783 _, _, _, _, _, _));
2784 }
2785
2786 // Tests the variadic version of the UnorderedElementsAreMatcher
TEST(ElementsAreTest,HugeMatcherUnordered)2787 TEST(ElementsAreTest, HugeMatcherUnordered) {
2788 vector<int> test_vector{2, 1, 8, 5, 4, 6, 7, 3, 9, 12, 11, 10};
2789
2790 EXPECT_THAT(test_vector, UnorderedElementsAre(
2791 Eq(2), Eq(1), Gt(7), Eq(5), Eq(4), Eq(6), Eq(7),
2792 Eq(3), Eq(9), Eq(12), Eq(11), Ne(122)));
2793 }
2794
2795 #endif // GTEST_LANG_CXX11
2796
2797 // Tests that AnyOf(m1, ..., mn) describes itself properly.
TEST(AnyOfTest,CanDescribeSelf)2798 TEST(AnyOfTest, CanDescribeSelf) {
2799 Matcher<int> m;
2800 m = AnyOf(Le(1), Ge(3));
2801 EXPECT_EQ("(is <= 1) or (is >= 3)",
2802 Describe(m));
2803
2804 m = AnyOf(Lt(0), Eq(1), Eq(2));
2805 EXPECT_EQ("(is < 0) or "
2806 "((is equal to 1) or (is equal to 2))",
2807 Describe(m));
2808
2809 m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
2810 EXPECT_EQ("((is < 0) or "
2811 "(is equal to 1)) or "
2812 "((is equal to 2) or "
2813 "(is equal to 3))",
2814 Describe(m));
2815
2816 m = AnyOf(Le(0), Gt(10), 3, 5, 7);
2817 EXPECT_EQ("((is <= 0) or "
2818 "(is > 10)) or "
2819 "((is equal to 3) or "
2820 "((is equal to 5) or "
2821 "(is equal to 7)))",
2822 Describe(m));
2823 }
2824
2825 // Tests that AnyOf(m1, ..., mn) describes its negation properly.
TEST(AnyOfTest,CanDescribeNegation)2826 TEST(AnyOfTest, CanDescribeNegation) {
2827 Matcher<int> m;
2828 m = AnyOf(Le(1), Ge(3));
2829 EXPECT_EQ("(isn't <= 1) and (isn't >= 3)",
2830 DescribeNegation(m));
2831
2832 m = AnyOf(Lt(0), Eq(1), Eq(2));
2833 EXPECT_EQ("(isn't < 0) and "
2834 "((isn't equal to 1) and (isn't equal to 2))",
2835 DescribeNegation(m));
2836
2837 m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
2838 EXPECT_EQ("((isn't < 0) and "
2839 "(isn't equal to 1)) and "
2840 "((isn't equal to 2) and "
2841 "(isn't equal to 3))",
2842 DescribeNegation(m));
2843
2844 m = AnyOf(Le(0), Gt(10), 3, 5, 7);
2845 EXPECT_EQ("((isn't <= 0) and "
2846 "(isn't > 10)) and "
2847 "((isn't equal to 3) and "
2848 "((isn't equal to 5) and "
2849 "(isn't equal to 7)))",
2850 DescribeNegation(m));
2851 }
2852
2853 // Tests that monomorphic matchers are safely cast by the AnyOf matcher.
TEST(AnyOfTest,AnyOfMatcherSafelyCastsMonomorphicMatchers)2854 TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
2855 // greater_than_5 and less_than_10 are monomorphic matchers.
2856 Matcher<int> greater_than_5 = Gt(5);
2857 Matcher<int> less_than_10 = Lt(10);
2858
2859 Matcher<const int&> m = AnyOf(greater_than_5, less_than_10);
2860 Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10);
2861 Matcher<int&> m3 = AnyOf(greater_than_5, m2);
2862
2863 // Tests that EitherOf works when composing itself.
2864 Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10);
2865 Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10);
2866 }
2867
TEST(AnyOfTest,ExplainsResult)2868 TEST(AnyOfTest, ExplainsResult) {
2869 Matcher<int> m;
2870
2871 // Failed match. Both matchers need to explain. The second
2872 // matcher doesn't give an explanation, so only the first matcher's
2873 // explanation is printed.
2874 m = AnyOf(GreaterThan(10), Lt(0));
2875 EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
2876
2877 // Failed match. Both matchers need to explain.
2878 m = AnyOf(GreaterThan(10), GreaterThan(20));
2879 EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
2880 Explain(m, 5));
2881
2882 // Failed match. All matchers need to explain. The second
2883 // matcher doesn't given an explanation.
2884 m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
2885 EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
2886 Explain(m, 5));
2887
2888 // Failed match. All matchers need to explain.
2889 m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
2890 EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20, "
2891 "and which is 25 less than 30",
2892 Explain(m, 5));
2893
2894 // Successful match. The first matcher, which succeeded, needs to
2895 // explain.
2896 m = AnyOf(GreaterThan(10), GreaterThan(20));
2897 EXPECT_EQ("which is 5 more than 10", Explain(m, 15));
2898
2899 // Successful match. The second matcher, which succeeded, needs to
2900 // explain. Since it doesn't given an explanation, nothing is
2901 // printed.
2902 m = AnyOf(GreaterThan(10), Lt(30));
2903 EXPECT_EQ("", Explain(m, 0));
2904
2905 // Successful match. The second matcher, which succeeded, needs to
2906 // explain.
2907 m = AnyOf(GreaterThan(30), GreaterThan(20));
2908 EXPECT_EQ("which is 5 more than 20", Explain(m, 25));
2909 }
2910
2911 // The following predicate function and predicate functor are for
2912 // testing the Truly(predicate) matcher.
2913
2914 // Returns non-zero if the input is positive. Note that the return
2915 // type of this function is not bool. It's OK as Truly() accepts any
2916 // unary function or functor whose return type can be implicitly
2917 // converted to bool.
IsPositive(double x)2918 int IsPositive(double x) {
2919 return x > 0 ? 1 : 0;
2920 }
2921
2922 // This functor returns true if the input is greater than the given
2923 // number.
2924 class IsGreaterThan {
2925 public:
IsGreaterThan(int threshold)2926 explicit IsGreaterThan(int threshold) : threshold_(threshold) {}
2927
operator ()(int n) const2928 bool operator()(int n) const { return n > threshold_; }
2929
2930 private:
2931 int threshold_;
2932 };
2933
2934 // For testing Truly().
2935 const int foo = 0;
2936
2937 // This predicate returns true iff the argument references foo and has
2938 // a zero value.
ReferencesFooAndIsZero(const int & n)2939 bool ReferencesFooAndIsZero(const int& n) {
2940 return (&n == &foo) && (n == 0);
2941 }
2942
2943 // Tests that Truly(predicate) matches what satisfies the given
2944 // predicate.
TEST(TrulyTest,MatchesWhatSatisfiesThePredicate)2945 TEST(TrulyTest, MatchesWhatSatisfiesThePredicate) {
2946 Matcher<double> m = Truly(IsPositive);
2947 EXPECT_TRUE(m.Matches(2.0));
2948 EXPECT_FALSE(m.Matches(-1.5));
2949 }
2950
2951 // Tests that Truly(predicate_functor) works too.
TEST(TrulyTest,CanBeUsedWithFunctor)2952 TEST(TrulyTest, CanBeUsedWithFunctor) {
2953 Matcher<int> m = Truly(IsGreaterThan(5));
2954 EXPECT_TRUE(m.Matches(6));
2955 EXPECT_FALSE(m.Matches(4));
2956 }
2957
2958 // A class that can be implicitly converted to bool.
2959 class ConvertibleToBool {
2960 public:
ConvertibleToBool(int number)2961 explicit ConvertibleToBool(int number) : number_(number) {}
operator bool() const2962 operator bool() const { return number_ != 0; }
2963
2964 private:
2965 int number_;
2966 };
2967
IsNotZero(int number)2968 ConvertibleToBool IsNotZero(int number) {
2969 return ConvertibleToBool(number);
2970 }
2971
2972 // Tests that the predicate used in Truly() may return a class that's
2973 // implicitly convertible to bool, even when the class has no
2974 // operator!().
TEST(TrulyTest,PredicateCanReturnAClassConvertibleToBool)2975 TEST(TrulyTest, PredicateCanReturnAClassConvertibleToBool) {
2976 Matcher<int> m = Truly(IsNotZero);
2977 EXPECT_TRUE(m.Matches(1));
2978 EXPECT_FALSE(m.Matches(0));
2979 }
2980
2981 // Tests that Truly(predicate) can describe itself properly.
TEST(TrulyTest,CanDescribeSelf)2982 TEST(TrulyTest, CanDescribeSelf) {
2983 Matcher<double> m = Truly(IsPositive);
2984 EXPECT_EQ("satisfies the given predicate",
2985 Describe(m));
2986 }
2987
2988 // Tests that Truly(predicate) works when the matcher takes its
2989 // argument by reference.
TEST(TrulyTest,WorksForByRefArguments)2990 TEST(TrulyTest, WorksForByRefArguments) {
2991 Matcher<const int&> m = Truly(ReferencesFooAndIsZero);
2992 EXPECT_TRUE(m.Matches(foo));
2993 int n = 0;
2994 EXPECT_FALSE(m.Matches(n));
2995 }
2996
2997 // Tests that Matches(m) is a predicate satisfied by whatever that
2998 // matches matcher m.
TEST(MatchesTest,IsSatisfiedByWhatMatchesTheMatcher)2999 TEST(MatchesTest, IsSatisfiedByWhatMatchesTheMatcher) {
3000 EXPECT_TRUE(Matches(Ge(0))(1));
3001 EXPECT_FALSE(Matches(Eq('a'))('b'));
3002 }
3003
3004 // Tests that Matches(m) works when the matcher takes its argument by
3005 // reference.
TEST(MatchesTest,WorksOnByRefArguments)3006 TEST(MatchesTest, WorksOnByRefArguments) {
3007 int m = 0, n = 0;
3008 EXPECT_TRUE(Matches(AllOf(Ref(n), Eq(0)))(n));
3009 EXPECT_FALSE(Matches(Ref(m))(n));
3010 }
3011
3012 // Tests that a Matcher on non-reference type can be used in
3013 // Matches().
TEST(MatchesTest,WorksWithMatcherOnNonRefType)3014 TEST(MatchesTest, WorksWithMatcherOnNonRefType) {
3015 Matcher<int> eq5 = Eq(5);
3016 EXPECT_TRUE(Matches(eq5)(5));
3017 EXPECT_FALSE(Matches(eq5)(2));
3018 }
3019
3020 // Tests Value(value, matcher). Since Value() is a simple wrapper for
3021 // Matches(), which has been tested already, we don't spend a lot of
3022 // effort on testing Value().
TEST(ValueTest,WorksWithPolymorphicMatcher)3023 TEST(ValueTest, WorksWithPolymorphicMatcher) {
3024 EXPECT_TRUE(Value("hi", StartsWith("h")));
3025 EXPECT_FALSE(Value(5, Gt(10)));
3026 }
3027
TEST(ValueTest,WorksWithMonomorphicMatcher)3028 TEST(ValueTest, WorksWithMonomorphicMatcher) {
3029 const Matcher<int> is_zero = Eq(0);
3030 EXPECT_TRUE(Value(0, is_zero));
3031 EXPECT_FALSE(Value('a', is_zero));
3032
3033 int n = 0;
3034 const Matcher<const int&> ref_n = Ref(n);
3035 EXPECT_TRUE(Value(n, ref_n));
3036 EXPECT_FALSE(Value(1, ref_n));
3037 }
3038
TEST(ExplainMatchResultTest,WorksWithPolymorphicMatcher)3039 TEST(ExplainMatchResultTest, WorksWithPolymorphicMatcher) {
3040 StringMatchResultListener listener1;
3041 EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1));
3042 EXPECT_EQ("% 2 == 0", listener1.str());
3043
3044 StringMatchResultListener listener2;
3045 EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2));
3046 EXPECT_EQ("", listener2.str());
3047 }
3048
TEST(ExplainMatchResultTest,WorksWithMonomorphicMatcher)3049 TEST(ExplainMatchResultTest, WorksWithMonomorphicMatcher) {
3050 const Matcher<int> is_even = PolymorphicIsEven();
3051 StringMatchResultListener listener1;
3052 EXPECT_TRUE(ExplainMatchResult(is_even, 42, &listener1));
3053 EXPECT_EQ("% 2 == 0", listener1.str());
3054
3055 const Matcher<const double&> is_zero = Eq(0);
3056 StringMatchResultListener listener2;
3057 EXPECT_FALSE(ExplainMatchResult(is_zero, 1.5, &listener2));
3058 EXPECT_EQ("", listener2.str());
3059 }
3060
3061 MATCHER_P(Really, inner_matcher, "") {
3062 return ExplainMatchResult(inner_matcher, arg, result_listener);
3063 }
3064
TEST(ExplainMatchResultTest,WorksInsideMATCHER)3065 TEST(ExplainMatchResultTest, WorksInsideMATCHER) {
3066 EXPECT_THAT(0, Really(Eq(0)));
3067 }
3068
TEST(DescribeMatcherTest,WorksWithValue)3069 TEST(DescribeMatcherTest, WorksWithValue) {
3070 EXPECT_EQ("is equal to 42", DescribeMatcher<int>(42));
3071 EXPECT_EQ("isn't equal to 42", DescribeMatcher<int>(42, true));
3072 }
3073
TEST(DescribeMatcherTest,WorksWithMonomorphicMatcher)3074 TEST(DescribeMatcherTest, WorksWithMonomorphicMatcher) {
3075 const Matcher<int> monomorphic = Le(0);
3076 EXPECT_EQ("is <= 0", DescribeMatcher<int>(monomorphic));
3077 EXPECT_EQ("isn't <= 0", DescribeMatcher<int>(monomorphic, true));
3078 }
3079
TEST(DescribeMatcherTest,WorksWithPolymorphicMatcher)3080 TEST(DescribeMatcherTest, WorksWithPolymorphicMatcher) {
3081 EXPECT_EQ("is even", DescribeMatcher<int>(PolymorphicIsEven()));
3082 EXPECT_EQ("is odd", DescribeMatcher<int>(PolymorphicIsEven(), true));
3083 }
3084
TEST(AllArgsTest,WorksForTuple)3085 TEST(AllArgsTest, WorksForTuple) {
3086 EXPECT_THAT(make_tuple(1, 2L), AllArgs(Lt()));
3087 EXPECT_THAT(make_tuple(2L, 1), Not(AllArgs(Lt())));
3088 }
3089
TEST(AllArgsTest,WorksForNonTuple)3090 TEST(AllArgsTest, WorksForNonTuple) {
3091 EXPECT_THAT(42, AllArgs(Gt(0)));
3092 EXPECT_THAT('a', Not(AllArgs(Eq('b'))));
3093 }
3094
3095 class AllArgsHelper {
3096 public:
AllArgsHelper()3097 AllArgsHelper() {}
3098
3099 MOCK_METHOD2(Helper, int(char x, int y));
3100
3101 private:
3102 GTEST_DISALLOW_COPY_AND_ASSIGN_(AllArgsHelper);
3103 };
3104
TEST(AllArgsTest,WorksInWithClause)3105 TEST(AllArgsTest, WorksInWithClause) {
3106 AllArgsHelper helper;
3107 ON_CALL(helper, Helper(_, _))
3108 .With(AllArgs(Lt()))
3109 .WillByDefault(Return(1));
3110 EXPECT_CALL(helper, Helper(_, _));
3111 EXPECT_CALL(helper, Helper(_, _))
3112 .With(AllArgs(Gt()))
3113 .WillOnce(Return(2));
3114
3115 EXPECT_EQ(1, helper.Helper('\1', 2));
3116 EXPECT_EQ(2, helper.Helper('a', 1));
3117 }
3118
3119 class OptionalMatchersHelper {
3120 public:
OptionalMatchersHelper()3121 OptionalMatchersHelper() {}
3122
3123 MOCK_METHOD0(NoArgs, int());
3124
3125 MOCK_METHOD1(OneArg, int(int y));
3126
3127 MOCK_METHOD2(TwoArgs, int(char x, int y));
3128
3129 MOCK_METHOD1(Overloaded, int(char x));
3130 MOCK_METHOD2(Overloaded, int(char x, int y));
3131
3132 private:
3133 GTEST_DISALLOW_COPY_AND_ASSIGN_(OptionalMatchersHelper);
3134 };
3135
TEST(AllArgsTest,WorksWithoutMatchers)3136 TEST(AllArgsTest, WorksWithoutMatchers) {
3137 OptionalMatchersHelper helper;
3138
3139 ON_CALL(helper, NoArgs).WillByDefault(Return(10));
3140 ON_CALL(helper, OneArg).WillByDefault(Return(20));
3141 ON_CALL(helper, TwoArgs).WillByDefault(Return(30));
3142
3143 EXPECT_EQ(10, helper.NoArgs());
3144 EXPECT_EQ(20, helper.OneArg(1));
3145 EXPECT_EQ(30, helper.TwoArgs('\1', 2));
3146
3147 EXPECT_CALL(helper, NoArgs).Times(1);
3148 EXPECT_CALL(helper, OneArg).WillOnce(Return(100));
3149 EXPECT_CALL(helper, OneArg(17)).WillOnce(Return(200));
3150 EXPECT_CALL(helper, TwoArgs).Times(0);
3151
3152 EXPECT_EQ(10, helper.NoArgs());
3153 EXPECT_EQ(100, helper.OneArg(1));
3154 EXPECT_EQ(200, helper.OneArg(17));
3155 }
3156
3157 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
3158 // matches the matcher.
TEST(MatcherAssertionTest,WorksWhenMatcherIsSatisfied)3159 TEST(MatcherAssertionTest, WorksWhenMatcherIsSatisfied) {
3160 ASSERT_THAT(5, Ge(2)) << "This should succeed.";
3161 ASSERT_THAT("Foo", EndsWith("oo"));
3162 EXPECT_THAT(2, AllOf(Le(7), Ge(0))) << "This should succeed too.";
3163 EXPECT_THAT("Hello", StartsWith("Hell"));
3164 }
3165
3166 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
3167 // doesn't match the matcher.
TEST(MatcherAssertionTest,WorksWhenMatcherIsNotSatisfied)3168 TEST(MatcherAssertionTest, WorksWhenMatcherIsNotSatisfied) {
3169 // 'n' must be static as it is used in an EXPECT_FATAL_FAILURE(),
3170 // which cannot reference auto variables.
3171 static unsigned short n; // NOLINT
3172 n = 5;
3173
3174 // VC++ prior to version 8.0 SP1 has a bug where it will not see any
3175 // functions declared in the namespace scope from within nested classes.
3176 // EXPECT/ASSERT_(NON)FATAL_FAILURE macros use nested classes so that all
3177 // namespace-level functions invoked inside them need to be explicitly
3178 // resolved.
3179 EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Gt(10)),
3180 "Value of: n\n"
3181 "Expected: is > 10\n"
3182 " Actual: 5" + OfType("unsigned short"));
3183 n = 0;
3184 EXPECT_NONFATAL_FAILURE(
3185 EXPECT_THAT(n, ::testing::AllOf(::testing::Le(7), ::testing::Ge(5))),
3186 "Value of: n\n"
3187 "Expected: (is <= 7) and (is >= 5)\n"
3188 " Actual: 0" + OfType("unsigned short"));
3189 }
3190
3191 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the argument
3192 // has a reference type.
TEST(MatcherAssertionTest,WorksForByRefArguments)3193 TEST(MatcherAssertionTest, WorksForByRefArguments) {
3194 // We use a static variable here as EXPECT_FATAL_FAILURE() cannot
3195 // reference auto variables.
3196 static int n;
3197 n = 0;
3198 EXPECT_THAT(n, AllOf(Le(7), Ref(n)));
3199 EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
3200 "Value of: n\n"
3201 "Expected: does not reference the variable @");
3202 // Tests the "Actual" part.
3203 EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
3204 "Actual: 0" + OfType("int") + ", which is located @");
3205 }
3206
3207 #if !GTEST_OS_SYMBIAN
3208 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the matcher is
3209 // monomorphic.
3210
3211 // ASSERT_THAT("hello", starts_with_he) fails to compile with Nokia's
3212 // Symbian compiler: it tries to compile
3213 // template<T, U> class MatcherCastImpl { ...
3214 // virtual bool MatchAndExplain(T x, ...) const {
3215 // return source_matcher_.MatchAndExplain(static_cast<U>(x), ...);
3216 // with U == string and T == const char*
3217 // With ASSERT_THAT("hello"...) changed to ASSERT_THAT(string("hello") ... )
3218 // the compiler silently crashes with no output.
3219 // If MatcherCastImpl is changed to use U(x) instead of static_cast<U>(x)
3220 // the code compiles but the converted string is bogus.
TEST(MatcherAssertionTest,WorksForMonomorphicMatcher)3221 TEST(MatcherAssertionTest, WorksForMonomorphicMatcher) {
3222 Matcher<const char*> starts_with_he = StartsWith("he");
3223 ASSERT_THAT("hello", starts_with_he);
3224
3225 Matcher<const std::string&> ends_with_ok = EndsWith("ok");
3226 ASSERT_THAT("book", ends_with_ok);
3227 const std::string bad = "bad";
3228 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(bad, ends_with_ok),
3229 "Value of: bad\n"
3230 "Expected: ends with \"ok\"\n"
3231 " Actual: \"bad\"");
3232 Matcher<int> is_greater_than_5 = Gt(5);
3233 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(5, is_greater_than_5),
3234 "Value of: 5\n"
3235 "Expected: is > 5\n"
3236 " Actual: 5" + OfType("int"));
3237 }
3238 #endif // !GTEST_OS_SYMBIAN
3239
3240 // Tests floating-point matchers.
3241 template <typename RawType>
3242 class FloatingPointTest : public testing::Test {
3243 protected:
3244 typedef testing::internal::FloatingPoint<RawType> Floating;
3245 typedef typename Floating::Bits Bits;
3246
FloatingPointTest()3247 FloatingPointTest()
3248 : max_ulps_(Floating::kMaxUlps),
3249 zero_bits_(Floating(0).bits()),
3250 one_bits_(Floating(1).bits()),
3251 infinity_bits_(Floating(Floating::Infinity()).bits()),
3252 close_to_positive_zero_(
3253 Floating::ReinterpretBits(zero_bits_ + max_ulps_/2)),
3254 close_to_negative_zero_(
3255 -Floating::ReinterpretBits(zero_bits_ + max_ulps_ - max_ulps_/2)),
3256 further_from_negative_zero_(-Floating::ReinterpretBits(
3257 zero_bits_ + max_ulps_ + 1 - max_ulps_/2)),
3258 close_to_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_)),
3259 further_from_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_ + 1)),
3260 infinity_(Floating::Infinity()),
3261 close_to_infinity_(
3262 Floating::ReinterpretBits(infinity_bits_ - max_ulps_)),
3263 further_from_infinity_(
3264 Floating::ReinterpretBits(infinity_bits_ - max_ulps_ - 1)),
3265 max_(Floating::Max()),
3266 nan1_(Floating::ReinterpretBits(Floating::kExponentBitMask | 1)),
3267 nan2_(Floating::ReinterpretBits(Floating::kExponentBitMask | 200)) {
3268 }
3269
TestSize()3270 void TestSize() {
3271 EXPECT_EQ(sizeof(RawType), sizeof(Bits));
3272 }
3273
3274 // A battery of tests for FloatingEqMatcher::Matches.
3275 // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
TestMatches(testing::internal::FloatingEqMatcher<RawType> (* matcher_maker)(RawType))3276 void TestMatches(
3277 testing::internal::FloatingEqMatcher<RawType> (*matcher_maker)(RawType)) {
3278 Matcher<RawType> m1 = matcher_maker(0.0);
3279 EXPECT_TRUE(m1.Matches(-0.0));
3280 EXPECT_TRUE(m1.Matches(close_to_positive_zero_));
3281 EXPECT_TRUE(m1.Matches(close_to_negative_zero_));
3282 EXPECT_FALSE(m1.Matches(1.0));
3283
3284 Matcher<RawType> m2 = matcher_maker(close_to_positive_zero_);
3285 EXPECT_FALSE(m2.Matches(further_from_negative_zero_));
3286
3287 Matcher<RawType> m3 = matcher_maker(1.0);
3288 EXPECT_TRUE(m3.Matches(close_to_one_));
3289 EXPECT_FALSE(m3.Matches(further_from_one_));
3290
3291 // Test commutativity: matcher_maker(0.0).Matches(1.0) was tested above.
3292 EXPECT_FALSE(m3.Matches(0.0));
3293
3294 Matcher<RawType> m4 = matcher_maker(-infinity_);
3295 EXPECT_TRUE(m4.Matches(-close_to_infinity_));
3296
3297 Matcher<RawType> m5 = matcher_maker(infinity_);
3298 EXPECT_TRUE(m5.Matches(close_to_infinity_));
3299
3300 // This is interesting as the representations of infinity_ and nan1_
3301 // are only 1 DLP apart.
3302 EXPECT_FALSE(m5.Matches(nan1_));
3303
3304 // matcher_maker can produce a Matcher<const RawType&>, which is needed in
3305 // some cases.
3306 Matcher<const RawType&> m6 = matcher_maker(0.0);
3307 EXPECT_TRUE(m6.Matches(-0.0));
3308 EXPECT_TRUE(m6.Matches(close_to_positive_zero_));
3309 EXPECT_FALSE(m6.Matches(1.0));
3310
3311 // matcher_maker can produce a Matcher<RawType&>, which is needed in some
3312 // cases.
3313 Matcher<RawType&> m7 = matcher_maker(0.0);
3314 RawType x = 0.0;
3315 EXPECT_TRUE(m7.Matches(x));
3316 x = 0.01f;
3317 EXPECT_FALSE(m7.Matches(x));
3318 }
3319
3320 // Pre-calculated numbers to be used by the tests.
3321
3322 const Bits max_ulps_;
3323
3324 const Bits zero_bits_; // The bits that represent 0.0.
3325 const Bits one_bits_; // The bits that represent 1.0.
3326 const Bits infinity_bits_; // The bits that represent +infinity.
3327
3328 // Some numbers close to 0.0.
3329 const RawType close_to_positive_zero_;
3330 const RawType close_to_negative_zero_;
3331 const RawType further_from_negative_zero_;
3332
3333 // Some numbers close to 1.0.
3334 const RawType close_to_one_;
3335 const RawType further_from_one_;
3336
3337 // Some numbers close to +infinity.
3338 const RawType infinity_;
3339 const RawType close_to_infinity_;
3340 const RawType further_from_infinity_;
3341
3342 // Maximum representable value that's not infinity.
3343 const RawType max_;
3344
3345 // Some NaNs.
3346 const RawType nan1_;
3347 const RawType nan2_;
3348 };
3349
3350 // Tests floating-point matchers with fixed epsilons.
3351 template <typename RawType>
3352 class FloatingPointNearTest : public FloatingPointTest<RawType> {
3353 protected:
3354 typedef FloatingPointTest<RawType> ParentType;
3355
3356 // A battery of tests for FloatingEqMatcher::Matches with a fixed epsilon.
3357 // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
TestNearMatches(testing::internal::FloatingEqMatcher<RawType> (* matcher_maker)(RawType,RawType))3358 void TestNearMatches(
3359 testing::internal::FloatingEqMatcher<RawType>
3360 (*matcher_maker)(RawType, RawType)) {
3361 Matcher<RawType> m1 = matcher_maker(0.0, 0.0);
3362 EXPECT_TRUE(m1.Matches(0.0));
3363 EXPECT_TRUE(m1.Matches(-0.0));
3364 EXPECT_FALSE(m1.Matches(ParentType::close_to_positive_zero_));
3365 EXPECT_FALSE(m1.Matches(ParentType::close_to_negative_zero_));
3366 EXPECT_FALSE(m1.Matches(1.0));
3367
3368 Matcher<RawType> m2 = matcher_maker(0.0, 1.0);
3369 EXPECT_TRUE(m2.Matches(0.0));
3370 EXPECT_TRUE(m2.Matches(-0.0));
3371 EXPECT_TRUE(m2.Matches(1.0));
3372 EXPECT_TRUE(m2.Matches(-1.0));
3373 EXPECT_FALSE(m2.Matches(ParentType::close_to_one_));
3374 EXPECT_FALSE(m2.Matches(-ParentType::close_to_one_));
3375
3376 // Check that inf matches inf, regardless of the of the specified max
3377 // absolute error.
3378 Matcher<RawType> m3 = matcher_maker(ParentType::infinity_, 0.0);
3379 EXPECT_TRUE(m3.Matches(ParentType::infinity_));
3380 EXPECT_FALSE(m3.Matches(ParentType::close_to_infinity_));
3381 EXPECT_FALSE(m3.Matches(-ParentType::infinity_));
3382
3383 Matcher<RawType> m4 = matcher_maker(-ParentType::infinity_, 0.0);
3384 EXPECT_TRUE(m4.Matches(-ParentType::infinity_));
3385 EXPECT_FALSE(m4.Matches(-ParentType::close_to_infinity_));
3386 EXPECT_FALSE(m4.Matches(ParentType::infinity_));
3387
3388 // Test various overflow scenarios.
3389 Matcher<RawType> m5 = matcher_maker(ParentType::max_, ParentType::max_);
3390 EXPECT_TRUE(m5.Matches(ParentType::max_));
3391 EXPECT_FALSE(m5.Matches(-ParentType::max_));
3392
3393 Matcher<RawType> m6 = matcher_maker(-ParentType::max_, ParentType::max_);
3394 EXPECT_FALSE(m6.Matches(ParentType::max_));
3395 EXPECT_TRUE(m6.Matches(-ParentType::max_));
3396
3397 Matcher<RawType> m7 = matcher_maker(ParentType::max_, 0);
3398 EXPECT_TRUE(m7.Matches(ParentType::max_));
3399 EXPECT_FALSE(m7.Matches(-ParentType::max_));
3400
3401 Matcher<RawType> m8 = matcher_maker(-ParentType::max_, 0);
3402 EXPECT_FALSE(m8.Matches(ParentType::max_));
3403 EXPECT_TRUE(m8.Matches(-ParentType::max_));
3404
3405 // The difference between max() and -max() normally overflows to infinity,
3406 // but it should still match if the max_abs_error is also infinity.
3407 Matcher<RawType> m9 = matcher_maker(
3408 ParentType::max_, ParentType::infinity_);
3409 EXPECT_TRUE(m8.Matches(-ParentType::max_));
3410
3411 // matcher_maker can produce a Matcher<const RawType&>, which is needed in
3412 // some cases.
3413 Matcher<const RawType&> m10 = matcher_maker(0.0, 1.0);
3414 EXPECT_TRUE(m10.Matches(-0.0));
3415 EXPECT_TRUE(m10.Matches(ParentType::close_to_positive_zero_));
3416 EXPECT_FALSE(m10.Matches(ParentType::close_to_one_));
3417
3418 // matcher_maker can produce a Matcher<RawType&>, which is needed in some
3419 // cases.
3420 Matcher<RawType&> m11 = matcher_maker(0.0, 1.0);
3421 RawType x = 0.0;
3422 EXPECT_TRUE(m11.Matches(x));
3423 x = 1.0f;
3424 EXPECT_TRUE(m11.Matches(x));
3425 x = -1.0f;
3426 EXPECT_TRUE(m11.Matches(x));
3427 x = 1.1f;
3428 EXPECT_FALSE(m11.Matches(x));
3429 x = -1.1f;
3430 EXPECT_FALSE(m11.Matches(x));
3431 }
3432 };
3433
3434 // Instantiate FloatingPointTest for testing floats.
3435 typedef FloatingPointTest<float> FloatTest;
3436
TEST_F(FloatTest,FloatEqApproximatelyMatchesFloats)3437 TEST_F(FloatTest, FloatEqApproximatelyMatchesFloats) {
3438 TestMatches(&FloatEq);
3439 }
3440
TEST_F(FloatTest,NanSensitiveFloatEqApproximatelyMatchesFloats)3441 TEST_F(FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats) {
3442 TestMatches(&NanSensitiveFloatEq);
3443 }
3444
TEST_F(FloatTest,FloatEqCannotMatchNaN)3445 TEST_F(FloatTest, FloatEqCannotMatchNaN) {
3446 // FloatEq never matches NaN.
3447 Matcher<float> m = FloatEq(nan1_);
3448 EXPECT_FALSE(m.Matches(nan1_));
3449 EXPECT_FALSE(m.Matches(nan2_));
3450 EXPECT_FALSE(m.Matches(1.0));
3451 }
3452
TEST_F(FloatTest,NanSensitiveFloatEqCanMatchNaN)3453 TEST_F(FloatTest, NanSensitiveFloatEqCanMatchNaN) {
3454 // NanSensitiveFloatEq will match NaN.
3455 Matcher<float> m = NanSensitiveFloatEq(nan1_);
3456 EXPECT_TRUE(m.Matches(nan1_));
3457 EXPECT_TRUE(m.Matches(nan2_));
3458 EXPECT_FALSE(m.Matches(1.0));
3459 }
3460
TEST_F(FloatTest,FloatEqCanDescribeSelf)3461 TEST_F(FloatTest, FloatEqCanDescribeSelf) {
3462 Matcher<float> m1 = FloatEq(2.0f);
3463 EXPECT_EQ("is approximately 2", Describe(m1));
3464 EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
3465
3466 Matcher<float> m2 = FloatEq(0.5f);
3467 EXPECT_EQ("is approximately 0.5", Describe(m2));
3468 EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
3469
3470 Matcher<float> m3 = FloatEq(nan1_);
3471 EXPECT_EQ("never matches", Describe(m3));
3472 EXPECT_EQ("is anything", DescribeNegation(m3));
3473 }
3474
TEST_F(FloatTest,NanSensitiveFloatEqCanDescribeSelf)3475 TEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) {
3476 Matcher<float> m1 = NanSensitiveFloatEq(2.0f);
3477 EXPECT_EQ("is approximately 2", Describe(m1));
3478 EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
3479
3480 Matcher<float> m2 = NanSensitiveFloatEq(0.5f);
3481 EXPECT_EQ("is approximately 0.5", Describe(m2));
3482 EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
3483
3484 Matcher<float> m3 = NanSensitiveFloatEq(nan1_);
3485 EXPECT_EQ("is NaN", Describe(m3));
3486 EXPECT_EQ("isn't NaN", DescribeNegation(m3));
3487 }
3488
3489 // Instantiate FloatingPointTest for testing floats with a user-specified
3490 // max absolute error.
3491 typedef FloatingPointNearTest<float> FloatNearTest;
3492
TEST_F(FloatNearTest,FloatNearMatches)3493 TEST_F(FloatNearTest, FloatNearMatches) {
3494 TestNearMatches(&FloatNear);
3495 }
3496
TEST_F(FloatNearTest,NanSensitiveFloatNearApproximatelyMatchesFloats)3497 TEST_F(FloatNearTest, NanSensitiveFloatNearApproximatelyMatchesFloats) {
3498 TestNearMatches(&NanSensitiveFloatNear);
3499 }
3500
TEST_F(FloatNearTest,FloatNearCanDescribeSelf)3501 TEST_F(FloatNearTest, FloatNearCanDescribeSelf) {
3502 Matcher<float> m1 = FloatNear(2.0f, 0.5f);
3503 EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
3504 EXPECT_EQ(
3505 "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
3506
3507 Matcher<float> m2 = FloatNear(0.5f, 0.5f);
3508 EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
3509 EXPECT_EQ(
3510 "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
3511
3512 Matcher<float> m3 = FloatNear(nan1_, 0.0);
3513 EXPECT_EQ("never matches", Describe(m3));
3514 EXPECT_EQ("is anything", DescribeNegation(m3));
3515 }
3516
TEST_F(FloatNearTest,NanSensitiveFloatNearCanDescribeSelf)3517 TEST_F(FloatNearTest, NanSensitiveFloatNearCanDescribeSelf) {
3518 Matcher<float> m1 = NanSensitiveFloatNear(2.0f, 0.5f);
3519 EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
3520 EXPECT_EQ(
3521 "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
3522
3523 Matcher<float> m2 = NanSensitiveFloatNear(0.5f, 0.5f);
3524 EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
3525 EXPECT_EQ(
3526 "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
3527
3528 Matcher<float> m3 = NanSensitiveFloatNear(nan1_, 0.1f);
3529 EXPECT_EQ("is NaN", Describe(m3));
3530 EXPECT_EQ("isn't NaN", DescribeNegation(m3));
3531 }
3532
TEST_F(FloatNearTest,FloatNearCannotMatchNaN)3533 TEST_F(FloatNearTest, FloatNearCannotMatchNaN) {
3534 // FloatNear never matches NaN.
3535 Matcher<float> m = FloatNear(ParentType::nan1_, 0.1f);
3536 EXPECT_FALSE(m.Matches(nan1_));
3537 EXPECT_FALSE(m.Matches(nan2_));
3538 EXPECT_FALSE(m.Matches(1.0));
3539 }
3540
TEST_F(FloatNearTest,NanSensitiveFloatNearCanMatchNaN)3541 TEST_F(FloatNearTest, NanSensitiveFloatNearCanMatchNaN) {
3542 // NanSensitiveFloatNear will match NaN.
3543 Matcher<float> m = NanSensitiveFloatNear(nan1_, 0.1f);
3544 EXPECT_TRUE(m.Matches(nan1_));
3545 EXPECT_TRUE(m.Matches(nan2_));
3546 EXPECT_FALSE(m.Matches(1.0));
3547 }
3548
3549 // Instantiate FloatingPointTest for testing doubles.
3550 typedef FloatingPointTest<double> DoubleTest;
3551
TEST_F(DoubleTest,DoubleEqApproximatelyMatchesDoubles)3552 TEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) {
3553 TestMatches(&DoubleEq);
3554 }
3555
TEST_F(DoubleTest,NanSensitiveDoubleEqApproximatelyMatchesDoubles)3556 TEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) {
3557 TestMatches(&NanSensitiveDoubleEq);
3558 }
3559
TEST_F(DoubleTest,DoubleEqCannotMatchNaN)3560 TEST_F(DoubleTest, DoubleEqCannotMatchNaN) {
3561 // DoubleEq never matches NaN.
3562 Matcher<double> m = DoubleEq(nan1_);
3563 EXPECT_FALSE(m.Matches(nan1_));
3564 EXPECT_FALSE(m.Matches(nan2_));
3565 EXPECT_FALSE(m.Matches(1.0));
3566 }
3567
TEST_F(DoubleTest,NanSensitiveDoubleEqCanMatchNaN)3568 TEST_F(DoubleTest, NanSensitiveDoubleEqCanMatchNaN) {
3569 // NanSensitiveDoubleEq will match NaN.
3570 Matcher<double> m = NanSensitiveDoubleEq(nan1_);
3571 EXPECT_TRUE(m.Matches(nan1_));
3572 EXPECT_TRUE(m.Matches(nan2_));
3573 EXPECT_FALSE(m.Matches(1.0));
3574 }
3575
TEST_F(DoubleTest,DoubleEqCanDescribeSelf)3576 TEST_F(DoubleTest, DoubleEqCanDescribeSelf) {
3577 Matcher<double> m1 = DoubleEq(2.0);
3578 EXPECT_EQ("is approximately 2", Describe(m1));
3579 EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
3580
3581 Matcher<double> m2 = DoubleEq(0.5);
3582 EXPECT_EQ("is approximately 0.5", Describe(m2));
3583 EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
3584
3585 Matcher<double> m3 = DoubleEq(nan1_);
3586 EXPECT_EQ("never matches", Describe(m3));
3587 EXPECT_EQ("is anything", DescribeNegation(m3));
3588 }
3589
TEST_F(DoubleTest,NanSensitiveDoubleEqCanDescribeSelf)3590 TEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) {
3591 Matcher<double> m1 = NanSensitiveDoubleEq(2.0);
3592 EXPECT_EQ("is approximately 2", Describe(m1));
3593 EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
3594
3595 Matcher<double> m2 = NanSensitiveDoubleEq(0.5);
3596 EXPECT_EQ("is approximately 0.5", Describe(m2));
3597 EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
3598
3599 Matcher<double> m3 = NanSensitiveDoubleEq(nan1_);
3600 EXPECT_EQ("is NaN", Describe(m3));
3601 EXPECT_EQ("isn't NaN", DescribeNegation(m3));
3602 }
3603
3604 // Instantiate FloatingPointTest for testing floats with a user-specified
3605 // max absolute error.
3606 typedef FloatingPointNearTest<double> DoubleNearTest;
3607
TEST_F(DoubleNearTest,DoubleNearMatches)3608 TEST_F(DoubleNearTest, DoubleNearMatches) {
3609 TestNearMatches(&DoubleNear);
3610 }
3611
TEST_F(DoubleNearTest,NanSensitiveDoubleNearApproximatelyMatchesDoubles)3612 TEST_F(DoubleNearTest, NanSensitiveDoubleNearApproximatelyMatchesDoubles) {
3613 TestNearMatches(&NanSensitiveDoubleNear);
3614 }
3615
TEST_F(DoubleNearTest,DoubleNearCanDescribeSelf)3616 TEST_F(DoubleNearTest, DoubleNearCanDescribeSelf) {
3617 Matcher<double> m1 = DoubleNear(2.0, 0.5);
3618 EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
3619 EXPECT_EQ(
3620 "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
3621
3622 Matcher<double> m2 = DoubleNear(0.5, 0.5);
3623 EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
3624 EXPECT_EQ(
3625 "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
3626
3627 Matcher<double> m3 = DoubleNear(nan1_, 0.0);
3628 EXPECT_EQ("never matches", Describe(m3));
3629 EXPECT_EQ("is anything", DescribeNegation(m3));
3630 }
3631
TEST_F(DoubleNearTest,ExplainsResultWhenMatchFails)3632 TEST_F(DoubleNearTest, ExplainsResultWhenMatchFails) {
3633 EXPECT_EQ("", Explain(DoubleNear(2.0, 0.1), 2.05));
3634 EXPECT_EQ("which is 0.2 from 2", Explain(DoubleNear(2.0, 0.1), 2.2));
3635 EXPECT_EQ("which is -0.3 from 2", Explain(DoubleNear(2.0, 0.1), 1.7));
3636
3637 const std::string explanation =
3638 Explain(DoubleNear(2.1, 1e-10), 2.1 + 1.2e-10);
3639 // Different C++ implementations may print floating-point numbers
3640 // slightly differently.
3641 EXPECT_TRUE(explanation == "which is 1.2e-10 from 2.1" || // GCC
3642 explanation == "which is 1.2e-010 from 2.1") // MSVC
3643 << " where explanation is \"" << explanation << "\".";
3644 }
3645
TEST_F(DoubleNearTest,NanSensitiveDoubleNearCanDescribeSelf)3646 TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanDescribeSelf) {
3647 Matcher<double> m1 = NanSensitiveDoubleNear(2.0, 0.5);
3648 EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
3649 EXPECT_EQ(
3650 "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
3651
3652 Matcher<double> m2 = NanSensitiveDoubleNear(0.5, 0.5);
3653 EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
3654 EXPECT_EQ(
3655 "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
3656
3657 Matcher<double> m3 = NanSensitiveDoubleNear(nan1_, 0.1);
3658 EXPECT_EQ("is NaN", Describe(m3));
3659 EXPECT_EQ("isn't NaN", DescribeNegation(m3));
3660 }
3661
TEST_F(DoubleNearTest,DoubleNearCannotMatchNaN)3662 TEST_F(DoubleNearTest, DoubleNearCannotMatchNaN) {
3663 // DoubleNear never matches NaN.
3664 Matcher<double> m = DoubleNear(ParentType::nan1_, 0.1);
3665 EXPECT_FALSE(m.Matches(nan1_));
3666 EXPECT_FALSE(m.Matches(nan2_));
3667 EXPECT_FALSE(m.Matches(1.0));
3668 }
3669
TEST_F(DoubleNearTest,NanSensitiveDoubleNearCanMatchNaN)3670 TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) {
3671 // NanSensitiveDoubleNear will match NaN.
3672 Matcher<double> m = NanSensitiveDoubleNear(nan1_, 0.1);
3673 EXPECT_TRUE(m.Matches(nan1_));
3674 EXPECT_TRUE(m.Matches(nan2_));
3675 EXPECT_FALSE(m.Matches(1.0));
3676 }
3677
TEST(PointeeTest,RawPointer)3678 TEST(PointeeTest, RawPointer) {
3679 const Matcher<int*> m = Pointee(Ge(0));
3680
3681 int n = 1;
3682 EXPECT_TRUE(m.Matches(&n));
3683 n = -1;
3684 EXPECT_FALSE(m.Matches(&n));
3685 EXPECT_FALSE(m.Matches(NULL));
3686 }
3687
TEST(PointeeTest,RawPointerToConst)3688 TEST(PointeeTest, RawPointerToConst) {
3689 const Matcher<const double*> m = Pointee(Ge(0));
3690
3691 double x = 1;
3692 EXPECT_TRUE(m.Matches(&x));
3693 x = -1;
3694 EXPECT_FALSE(m.Matches(&x));
3695 EXPECT_FALSE(m.Matches(NULL));
3696 }
3697
TEST(PointeeTest,ReferenceToConstRawPointer)3698 TEST(PointeeTest, ReferenceToConstRawPointer) {
3699 const Matcher<int* const &> m = Pointee(Ge(0));
3700
3701 int n = 1;
3702 EXPECT_TRUE(m.Matches(&n));
3703 n = -1;
3704 EXPECT_FALSE(m.Matches(&n));
3705 EXPECT_FALSE(m.Matches(NULL));
3706 }
3707
TEST(PointeeTest,ReferenceToNonConstRawPointer)3708 TEST(PointeeTest, ReferenceToNonConstRawPointer) {
3709 const Matcher<double* &> m = Pointee(Ge(0));
3710
3711 double x = 1.0;
3712 double* p = &x;
3713 EXPECT_TRUE(m.Matches(p));
3714 x = -1;
3715 EXPECT_FALSE(m.Matches(p));
3716 p = NULL;
3717 EXPECT_FALSE(m.Matches(p));
3718 }
3719
3720 MATCHER_P(FieldIIs, inner_matcher, "") {
3721 return ExplainMatchResult(inner_matcher, arg.i, result_listener);
3722 }
3723
3724 #if GTEST_HAS_RTTI
TEST(WhenDynamicCastToTest,SameType)3725 TEST(WhenDynamicCastToTest, SameType) {
3726 Derived derived;
3727 derived.i = 4;
3728
3729 // Right type. A pointer is passed down.
3730 Base* as_base_ptr = &derived;
3731 EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Not(IsNull())));
3732 EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(4))));
3733 EXPECT_THAT(as_base_ptr,
3734 Not(WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(5)))));
3735 }
3736
TEST(WhenDynamicCastToTest,WrongTypes)3737 TEST(WhenDynamicCastToTest, WrongTypes) {
3738 Base base;
3739 Derived derived;
3740 OtherDerived other_derived;
3741
3742 // Wrong types. NULL is passed.
3743 EXPECT_THAT(&base, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
3744 EXPECT_THAT(&base, WhenDynamicCastTo<Derived*>(IsNull()));
3745 Base* as_base_ptr = &derived;
3746 EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<OtherDerived*>(Pointee(_))));
3747 EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<OtherDerived*>(IsNull()));
3748 as_base_ptr = &other_derived;
3749 EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
3750 EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
3751 }
3752
TEST(WhenDynamicCastToTest,AlreadyNull)3753 TEST(WhenDynamicCastToTest, AlreadyNull) {
3754 // Already NULL.
3755 Base* as_base_ptr = NULL;
3756 EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
3757 }
3758
3759 struct AmbiguousCastTypes {
3760 class VirtualDerived : public virtual Base {};
3761 class DerivedSub1 : public VirtualDerived {};
3762 class DerivedSub2 : public VirtualDerived {};
3763 class ManyDerivedInHierarchy : public DerivedSub1, public DerivedSub2 {};
3764 };
3765
TEST(WhenDynamicCastToTest,AmbiguousCast)3766 TEST(WhenDynamicCastToTest, AmbiguousCast) {
3767 AmbiguousCastTypes::DerivedSub1 sub1;
3768 AmbiguousCastTypes::ManyDerivedInHierarchy many_derived;
3769 // Multiply derived from Base. dynamic_cast<> returns NULL.
3770 Base* as_base_ptr =
3771 static_cast<AmbiguousCastTypes::DerivedSub1*>(&many_derived);
3772 EXPECT_THAT(as_base_ptr,
3773 WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(IsNull()));
3774 as_base_ptr = &sub1;
3775 EXPECT_THAT(
3776 as_base_ptr,
3777 WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(Not(IsNull())));
3778 }
3779
TEST(WhenDynamicCastToTest,Describe)3780 TEST(WhenDynamicCastToTest, Describe) {
3781 Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
3782 const std::string prefix =
3783 "when dynamic_cast to " + internal::GetTypeName<Derived*>() + ", ";
3784 EXPECT_EQ(prefix + "points to a value that is anything", Describe(matcher));
3785 EXPECT_EQ(prefix + "does not point to a value that is anything",
3786 DescribeNegation(matcher));
3787 }
3788
TEST(WhenDynamicCastToTest,Explain)3789 TEST(WhenDynamicCastToTest, Explain) {
3790 Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
3791 Base* null = NULL;
3792 EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL"));
3793 Derived derived;
3794 EXPECT_TRUE(matcher.Matches(&derived));
3795 EXPECT_THAT(Explain(matcher, &derived), HasSubstr("which points to "));
3796
3797 // With references, the matcher itself can fail. Test for that one.
3798 Matcher<const Base&> ref_matcher = WhenDynamicCastTo<const OtherDerived&>(_);
3799 EXPECT_THAT(Explain(ref_matcher, derived),
3800 HasSubstr("which cannot be dynamic_cast"));
3801 }
3802
TEST(WhenDynamicCastToTest,GoodReference)3803 TEST(WhenDynamicCastToTest, GoodReference) {
3804 Derived derived;
3805 derived.i = 4;
3806 Base& as_base_ref = derived;
3807 EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(FieldIIs(4)));
3808 EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(Not(FieldIIs(5))));
3809 }
3810
TEST(WhenDynamicCastToTest,BadReference)3811 TEST(WhenDynamicCastToTest, BadReference) {
3812 Derived derived;
3813 Base& as_base_ref = derived;
3814 EXPECT_THAT(as_base_ref, Not(WhenDynamicCastTo<const OtherDerived&>(_)));
3815 }
3816 #endif // GTEST_HAS_RTTI
3817
3818 // Minimal const-propagating pointer.
3819 template <typename T>
3820 class ConstPropagatingPtr {
3821 public:
3822 typedef T element_type;
3823
ConstPropagatingPtr()3824 ConstPropagatingPtr() : val_() {}
ConstPropagatingPtr(T * t)3825 explicit ConstPropagatingPtr(T* t) : val_(t) {}
ConstPropagatingPtr(const ConstPropagatingPtr & other)3826 ConstPropagatingPtr(const ConstPropagatingPtr& other) : val_(other.val_) {}
3827
get()3828 T* get() { return val_; }
operator *()3829 T& operator*() { return *val_; }
3830 // Most smart pointers return non-const T* and T& from the next methods.
get() const3831 const T* get() const { return val_; }
operator *() const3832 const T& operator*() const { return *val_; }
3833
3834 private:
3835 T* val_;
3836 };
3837
TEST(PointeeTest,WorksWithConstPropagatingPointers)3838 TEST(PointeeTest, WorksWithConstPropagatingPointers) {
3839 const Matcher< ConstPropagatingPtr<int> > m = Pointee(Lt(5));
3840 int three = 3;
3841 const ConstPropagatingPtr<int> co(&three);
3842 ConstPropagatingPtr<int> o(&three);
3843 EXPECT_TRUE(m.Matches(o));
3844 EXPECT_TRUE(m.Matches(co));
3845 *o = 6;
3846 EXPECT_FALSE(m.Matches(o));
3847 EXPECT_FALSE(m.Matches(ConstPropagatingPtr<int>()));
3848 }
3849
TEST(PointeeTest,NeverMatchesNull)3850 TEST(PointeeTest, NeverMatchesNull) {
3851 const Matcher<const char*> m = Pointee(_);
3852 EXPECT_FALSE(m.Matches(NULL));
3853 }
3854
3855 // Tests that we can write Pointee(value) instead of Pointee(Eq(value)).
TEST(PointeeTest,MatchesAgainstAValue)3856 TEST(PointeeTest, MatchesAgainstAValue) {
3857 const Matcher<int*> m = Pointee(5);
3858
3859 int n = 5;
3860 EXPECT_TRUE(m.Matches(&n));
3861 n = -1;
3862 EXPECT_FALSE(m.Matches(&n));
3863 EXPECT_FALSE(m.Matches(NULL));
3864 }
3865
TEST(PointeeTest,CanDescribeSelf)3866 TEST(PointeeTest, CanDescribeSelf) {
3867 const Matcher<int*> m = Pointee(Gt(3));
3868 EXPECT_EQ("points to a value that is > 3", Describe(m));
3869 EXPECT_EQ("does not point to a value that is > 3",
3870 DescribeNegation(m));
3871 }
3872
TEST(PointeeTest,CanExplainMatchResult)3873 TEST(PointeeTest, CanExplainMatchResult) {
3874 const Matcher<const std::string*> m = Pointee(StartsWith("Hi"));
3875
3876 EXPECT_EQ("", Explain(m, static_cast<const std::string*>(NULL)));
3877
3878 const Matcher<long*> m2 = Pointee(GreaterThan(1)); // NOLINT
3879 long n = 3; // NOLINT
3880 EXPECT_EQ("which points to 3" + OfType("long") + ", which is 2 more than 1",
3881 Explain(m2, &n));
3882 }
3883
TEST(PointeeTest,AlwaysExplainsPointee)3884 TEST(PointeeTest, AlwaysExplainsPointee) {
3885 const Matcher<int*> m = Pointee(0);
3886 int n = 42;
3887 EXPECT_EQ("which points to 42" + OfType("int"), Explain(m, &n));
3888 }
3889
3890 // An uncopyable class.
3891 class Uncopyable {
3892 public:
Uncopyable()3893 Uncopyable() : value_(-1) {}
Uncopyable(int a_value)3894 explicit Uncopyable(int a_value) : value_(a_value) {}
3895
value() const3896 int value() const { return value_; }
set_value(int i)3897 void set_value(int i) { value_ = i; }
3898
3899 private:
3900 int value_;
3901 GTEST_DISALLOW_COPY_AND_ASSIGN_(Uncopyable);
3902 };
3903
3904 // Returns true iff x.value() is positive.
ValueIsPositive(const Uncopyable & x)3905 bool ValueIsPositive(const Uncopyable& x) { return x.value() > 0; }
3906
3907 MATCHER_P(UncopyableIs, inner_matcher, "") {
3908 return ExplainMatchResult(inner_matcher, arg.value(), result_listener);
3909 }
3910
3911 // A user-defined struct for testing Field().
3912 struct AStruct {
AStructtesting::gmock_matchers_test::AStruct3913 AStruct() : x(0), y(1.0), z(5), p(NULL) {}
AStructtesting::gmock_matchers_test::AStruct3914 AStruct(const AStruct& rhs)
3915 : x(rhs.x), y(rhs.y), z(rhs.z.value()), p(rhs.p) {}
3916
3917 int x; // A non-const field.
3918 const double y; // A const field.
3919 Uncopyable z; // An uncopyable field.
3920 const char* p; // A pointer field.
3921
3922 private:
3923 GTEST_DISALLOW_ASSIGN_(AStruct);
3924 };
3925
3926 // A derived struct for testing Field().
3927 struct DerivedStruct : public AStruct {
3928 char ch;
3929
3930 private:
3931 GTEST_DISALLOW_ASSIGN_(DerivedStruct);
3932 };
3933
3934 // Tests that Field(&Foo::field, ...) works when field is non-const.
TEST(FieldTest,WorksForNonConstField)3935 TEST(FieldTest, WorksForNonConstField) {
3936 Matcher<AStruct> m = Field(&AStruct::x, Ge(0));
3937 Matcher<AStruct> m_with_name = Field("x", &AStruct::x, Ge(0));
3938
3939 AStruct a;
3940 EXPECT_TRUE(m.Matches(a));
3941 EXPECT_TRUE(m_with_name.Matches(a));
3942 a.x = -1;
3943 EXPECT_FALSE(m.Matches(a));
3944 EXPECT_FALSE(m_with_name.Matches(a));
3945 }
3946
3947 // Tests that Field(&Foo::field, ...) works when field is const.
TEST(FieldTest,WorksForConstField)3948 TEST(FieldTest, WorksForConstField) {
3949 AStruct a;
3950
3951 Matcher<AStruct> m = Field(&AStruct::y, Ge(0.0));
3952 Matcher<AStruct> m_with_name = Field("y", &AStruct::y, Ge(0.0));
3953 EXPECT_TRUE(m.Matches(a));
3954 EXPECT_TRUE(m_with_name.Matches(a));
3955 m = Field(&AStruct::y, Le(0.0));
3956 m_with_name = Field("y", &AStruct::y, Le(0.0));
3957 EXPECT_FALSE(m.Matches(a));
3958 EXPECT_FALSE(m_with_name.Matches(a));
3959 }
3960
3961 // Tests that Field(&Foo::field, ...) works when field is not copyable.
TEST(FieldTest,WorksForUncopyableField)3962 TEST(FieldTest, WorksForUncopyableField) {
3963 AStruct a;
3964
3965 Matcher<AStruct> m = Field(&AStruct::z, Truly(ValueIsPositive));
3966 EXPECT_TRUE(m.Matches(a));
3967 m = Field(&AStruct::z, Not(Truly(ValueIsPositive)));
3968 EXPECT_FALSE(m.Matches(a));
3969 }
3970
3971 // Tests that Field(&Foo::field, ...) works when field is a pointer.
TEST(FieldTest,WorksForPointerField)3972 TEST(FieldTest, WorksForPointerField) {
3973 // Matching against NULL.
3974 Matcher<AStruct> m = Field(&AStruct::p, static_cast<const char*>(NULL));
3975 AStruct a;
3976 EXPECT_TRUE(m.Matches(a));
3977 a.p = "hi";
3978 EXPECT_FALSE(m.Matches(a));
3979
3980 // Matching a pointer that is not NULL.
3981 m = Field(&AStruct::p, StartsWith("hi"));
3982 a.p = "hill";
3983 EXPECT_TRUE(m.Matches(a));
3984 a.p = "hole";
3985 EXPECT_FALSE(m.Matches(a));
3986 }
3987
3988 // Tests that Field() works when the object is passed by reference.
TEST(FieldTest,WorksForByRefArgument)3989 TEST(FieldTest, WorksForByRefArgument) {
3990 Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
3991
3992 AStruct a;
3993 EXPECT_TRUE(m.Matches(a));
3994 a.x = -1;
3995 EXPECT_FALSE(m.Matches(a));
3996 }
3997
3998 // Tests that Field(&Foo::field, ...) works when the argument's type
3999 // is a sub-type of Foo.
TEST(FieldTest,WorksForArgumentOfSubType)4000 TEST(FieldTest, WorksForArgumentOfSubType) {
4001 // Note that the matcher expects DerivedStruct but we say AStruct
4002 // inside Field().
4003 Matcher<const DerivedStruct&> m = Field(&AStruct::x, Ge(0));
4004
4005 DerivedStruct d;
4006 EXPECT_TRUE(m.Matches(d));
4007 d.x = -1;
4008 EXPECT_FALSE(m.Matches(d));
4009 }
4010
4011 // Tests that Field(&Foo::field, m) works when field's type and m's
4012 // argument type are compatible but not the same.
TEST(FieldTest,WorksForCompatibleMatcherType)4013 TEST(FieldTest, WorksForCompatibleMatcherType) {
4014 // The field is an int, but the inner matcher expects a signed char.
4015 Matcher<const AStruct&> m = Field(&AStruct::x,
4016 Matcher<signed char>(Ge(0)));
4017
4018 AStruct a;
4019 EXPECT_TRUE(m.Matches(a));
4020 a.x = -1;
4021 EXPECT_FALSE(m.Matches(a));
4022 }
4023
4024 // Tests that Field() can describe itself.
TEST(FieldTest,CanDescribeSelf)4025 TEST(FieldTest, CanDescribeSelf) {
4026 Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
4027
4028 EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
4029 EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
4030 }
4031
TEST(FieldTest,CanDescribeSelfWithFieldName)4032 TEST(FieldTest, CanDescribeSelfWithFieldName) {
4033 Matcher<const AStruct&> m = Field("field_name", &AStruct::x, Ge(0));
4034
4035 EXPECT_EQ("is an object whose field `field_name` is >= 0", Describe(m));
4036 EXPECT_EQ("is an object whose field `field_name` isn't >= 0",
4037 DescribeNegation(m));
4038 }
4039
4040 // Tests that Field() can explain the match result.
TEST(FieldTest,CanExplainMatchResult)4041 TEST(FieldTest, CanExplainMatchResult) {
4042 Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
4043
4044 AStruct a;
4045 a.x = 1;
4046 EXPECT_EQ("whose given field is 1" + OfType("int"), Explain(m, a));
4047
4048 m = Field(&AStruct::x, GreaterThan(0));
4049 EXPECT_EQ(
4050 "whose given field is 1" + OfType("int") + ", which is 1 more than 0",
4051 Explain(m, a));
4052 }
4053
TEST(FieldTest,CanExplainMatchResultWithFieldName)4054 TEST(FieldTest, CanExplainMatchResultWithFieldName) {
4055 Matcher<const AStruct&> m = Field("field_name", &AStruct::x, Ge(0));
4056
4057 AStruct a;
4058 a.x = 1;
4059 EXPECT_EQ("whose field `field_name` is 1" + OfType("int"), Explain(m, a));
4060
4061 m = Field("field_name", &AStruct::x, GreaterThan(0));
4062 EXPECT_EQ("whose field `field_name` is 1" + OfType("int") +
4063 ", which is 1 more than 0",
4064 Explain(m, a));
4065 }
4066
4067 // Tests that Field() works when the argument is a pointer to const.
TEST(FieldForPointerTest,WorksForPointerToConst)4068 TEST(FieldForPointerTest, WorksForPointerToConst) {
4069 Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
4070
4071 AStruct a;
4072 EXPECT_TRUE(m.Matches(&a));
4073 a.x = -1;
4074 EXPECT_FALSE(m.Matches(&a));
4075 }
4076
4077 // Tests that Field() works when the argument is a pointer to non-const.
TEST(FieldForPointerTest,WorksForPointerToNonConst)4078 TEST(FieldForPointerTest, WorksForPointerToNonConst) {
4079 Matcher<AStruct*> m = Field(&AStruct::x, Ge(0));
4080
4081 AStruct a;
4082 EXPECT_TRUE(m.Matches(&a));
4083 a.x = -1;
4084 EXPECT_FALSE(m.Matches(&a));
4085 }
4086
4087 // Tests that Field() works when the argument is a reference to a const pointer.
TEST(FieldForPointerTest,WorksForReferenceToConstPointer)4088 TEST(FieldForPointerTest, WorksForReferenceToConstPointer) {
4089 Matcher<AStruct* const&> m = Field(&AStruct::x, Ge(0));
4090
4091 AStruct a;
4092 EXPECT_TRUE(m.Matches(&a));
4093 a.x = -1;
4094 EXPECT_FALSE(m.Matches(&a));
4095 }
4096
4097 // Tests that Field() does not match the NULL pointer.
TEST(FieldForPointerTest,DoesNotMatchNull)4098 TEST(FieldForPointerTest, DoesNotMatchNull) {
4099 Matcher<const AStruct*> m = Field(&AStruct::x, _);
4100 EXPECT_FALSE(m.Matches(NULL));
4101 }
4102
4103 // Tests that Field(&Foo::field, ...) works when the argument's type
4104 // is a sub-type of const Foo*.
TEST(FieldForPointerTest,WorksForArgumentOfSubType)4105 TEST(FieldForPointerTest, WorksForArgumentOfSubType) {
4106 // Note that the matcher expects DerivedStruct but we say AStruct
4107 // inside Field().
4108 Matcher<DerivedStruct*> m = Field(&AStruct::x, Ge(0));
4109
4110 DerivedStruct d;
4111 EXPECT_TRUE(m.Matches(&d));
4112 d.x = -1;
4113 EXPECT_FALSE(m.Matches(&d));
4114 }
4115
4116 // Tests that Field() can describe itself when used to match a pointer.
TEST(FieldForPointerTest,CanDescribeSelf)4117 TEST(FieldForPointerTest, CanDescribeSelf) {
4118 Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
4119
4120 EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
4121 EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
4122 }
4123
TEST(FieldForPointerTest,CanDescribeSelfWithFieldName)4124 TEST(FieldForPointerTest, CanDescribeSelfWithFieldName) {
4125 Matcher<const AStruct*> m = Field("field_name", &AStruct::x, Ge(0));
4126
4127 EXPECT_EQ("is an object whose field `field_name` is >= 0", Describe(m));
4128 EXPECT_EQ("is an object whose field `field_name` isn't >= 0",
4129 DescribeNegation(m));
4130 }
4131
4132 // Tests that Field() can explain the result of matching a pointer.
TEST(FieldForPointerTest,CanExplainMatchResult)4133 TEST(FieldForPointerTest, CanExplainMatchResult) {
4134 Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
4135
4136 AStruct a;
4137 a.x = 1;
4138 EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL)));
4139 EXPECT_EQ("which points to an object whose given field is 1" + OfType("int"),
4140 Explain(m, &a));
4141
4142 m = Field(&AStruct::x, GreaterThan(0));
4143 EXPECT_EQ("which points to an object whose given field is 1" + OfType("int") +
4144 ", which is 1 more than 0", Explain(m, &a));
4145 }
4146
TEST(FieldForPointerTest,CanExplainMatchResultWithFieldName)4147 TEST(FieldForPointerTest, CanExplainMatchResultWithFieldName) {
4148 Matcher<const AStruct*> m = Field("field_name", &AStruct::x, Ge(0));
4149
4150 AStruct a;
4151 a.x = 1;
4152 EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL)));
4153 EXPECT_EQ(
4154 "which points to an object whose field `field_name` is 1" + OfType("int"),
4155 Explain(m, &a));
4156
4157 m = Field("field_name", &AStruct::x, GreaterThan(0));
4158 EXPECT_EQ("which points to an object whose field `field_name` is 1" +
4159 OfType("int") + ", which is 1 more than 0",
4160 Explain(m, &a));
4161 }
4162
4163 // A user-defined class for testing Property().
4164 class AClass {
4165 public:
AClass()4166 AClass() : n_(0) {}
4167
4168 // A getter that returns a non-reference.
n() const4169 int n() const { return n_; }
4170
set_n(int new_n)4171 void set_n(int new_n) { n_ = new_n; }
4172
4173 // A getter that returns a reference to const.
s() const4174 const std::string& s() const { return s_; }
4175
4176 #if GTEST_LANG_CXX11
s_ref() const4177 const std::string& s_ref() const & { return s_; }
4178 #endif
4179
set_s(const std::string & new_s)4180 void set_s(const std::string& new_s) { s_ = new_s; }
4181
4182 // A getter that returns a reference to non-const.
x() const4183 double& x() const { return x_; }
4184
4185 private:
4186 int n_;
4187 std::string s_;
4188
4189 static double x_;
4190 };
4191
4192 double AClass::x_ = 0.0;
4193
4194 // A derived class for testing Property().
4195 class DerivedClass : public AClass {
4196 public:
k() const4197 int k() const { return k_; }
4198 private:
4199 int k_;
4200 };
4201
4202 // Tests that Property(&Foo::property, ...) works when property()
4203 // returns a non-reference.
TEST(PropertyTest,WorksForNonReferenceProperty)4204 TEST(PropertyTest, WorksForNonReferenceProperty) {
4205 Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
4206 Matcher<const AClass&> m_with_name = Property("n", &AClass::n, Ge(0));
4207
4208 AClass a;
4209 a.set_n(1);
4210 EXPECT_TRUE(m.Matches(a));
4211 EXPECT_TRUE(m_with_name.Matches(a));
4212
4213 a.set_n(-1);
4214 EXPECT_FALSE(m.Matches(a));
4215 EXPECT_FALSE(m_with_name.Matches(a));
4216 }
4217
4218 // Tests that Property(&Foo::property, ...) works when property()
4219 // returns a reference to const.
TEST(PropertyTest,WorksForReferenceToConstProperty)4220 TEST(PropertyTest, WorksForReferenceToConstProperty) {
4221 Matcher<const AClass&> m = Property(&AClass::s, StartsWith("hi"));
4222 Matcher<const AClass&> m_with_name =
4223 Property("s", &AClass::s, StartsWith("hi"));
4224
4225 AClass a;
4226 a.set_s("hill");
4227 EXPECT_TRUE(m.Matches(a));
4228 EXPECT_TRUE(m_with_name.Matches(a));
4229
4230 a.set_s("hole");
4231 EXPECT_FALSE(m.Matches(a));
4232 EXPECT_FALSE(m_with_name.Matches(a));
4233 }
4234
4235 #if GTEST_LANG_CXX11
4236 // Tests that Property(&Foo::property, ...) works when property() is
4237 // ref-qualified.
TEST(PropertyTest,WorksForRefQualifiedProperty)4238 TEST(PropertyTest, WorksForRefQualifiedProperty) {
4239 Matcher<const AClass&> m = Property(&AClass::s_ref, StartsWith("hi"));
4240 Matcher<const AClass&> m_with_name =
4241 Property("s", &AClass::s_ref, StartsWith("hi"));
4242
4243 AClass a;
4244 a.set_s("hill");
4245 EXPECT_TRUE(m.Matches(a));
4246 EXPECT_TRUE(m_with_name.Matches(a));
4247
4248 a.set_s("hole");
4249 EXPECT_FALSE(m.Matches(a));
4250 EXPECT_FALSE(m_with_name.Matches(a));
4251 }
4252 #endif
4253
4254 // Tests that Property(&Foo::property, ...) works when property()
4255 // returns a reference to non-const.
TEST(PropertyTest,WorksForReferenceToNonConstProperty)4256 TEST(PropertyTest, WorksForReferenceToNonConstProperty) {
4257 double x = 0.0;
4258 AClass a;
4259
4260 Matcher<const AClass&> m = Property(&AClass::x, Ref(x));
4261 EXPECT_FALSE(m.Matches(a));
4262
4263 m = Property(&AClass::x, Not(Ref(x)));
4264 EXPECT_TRUE(m.Matches(a));
4265 }
4266
4267 // Tests that Property(&Foo::property, ...) works when the argument is
4268 // passed by value.
TEST(PropertyTest,WorksForByValueArgument)4269 TEST(PropertyTest, WorksForByValueArgument) {
4270 Matcher<AClass> m = Property(&AClass::s, StartsWith("hi"));
4271
4272 AClass a;
4273 a.set_s("hill");
4274 EXPECT_TRUE(m.Matches(a));
4275
4276 a.set_s("hole");
4277 EXPECT_FALSE(m.Matches(a));
4278 }
4279
4280 // Tests that Property(&Foo::property, ...) works when the argument's
4281 // type is a sub-type of Foo.
TEST(PropertyTest,WorksForArgumentOfSubType)4282 TEST(PropertyTest, WorksForArgumentOfSubType) {
4283 // The matcher expects a DerivedClass, but inside the Property() we
4284 // say AClass.
4285 Matcher<const DerivedClass&> m = Property(&AClass::n, Ge(0));
4286
4287 DerivedClass d;
4288 d.set_n(1);
4289 EXPECT_TRUE(m.Matches(d));
4290
4291 d.set_n(-1);
4292 EXPECT_FALSE(m.Matches(d));
4293 }
4294
4295 // Tests that Property(&Foo::property, m) works when property()'s type
4296 // and m's argument type are compatible but different.
TEST(PropertyTest,WorksForCompatibleMatcherType)4297 TEST(PropertyTest, WorksForCompatibleMatcherType) {
4298 // n() returns an int but the inner matcher expects a signed char.
4299 Matcher<const AClass&> m = Property(&AClass::n,
4300 Matcher<signed char>(Ge(0)));
4301
4302 Matcher<const AClass&> m_with_name =
4303 Property("n", &AClass::n, Matcher<signed char>(Ge(0)));
4304
4305 AClass a;
4306 EXPECT_TRUE(m.Matches(a));
4307 EXPECT_TRUE(m_with_name.Matches(a));
4308 a.set_n(-1);
4309 EXPECT_FALSE(m.Matches(a));
4310 EXPECT_FALSE(m_with_name.Matches(a));
4311 }
4312
4313 // Tests that Property() can describe itself.
TEST(PropertyTest,CanDescribeSelf)4314 TEST(PropertyTest, CanDescribeSelf) {
4315 Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
4316
4317 EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
4318 EXPECT_EQ("is an object whose given property isn't >= 0",
4319 DescribeNegation(m));
4320 }
4321
TEST(PropertyTest,CanDescribeSelfWithPropertyName)4322 TEST(PropertyTest, CanDescribeSelfWithPropertyName) {
4323 Matcher<const AClass&> m = Property("fancy_name", &AClass::n, Ge(0));
4324
4325 EXPECT_EQ("is an object whose property `fancy_name` is >= 0", Describe(m));
4326 EXPECT_EQ("is an object whose property `fancy_name` isn't >= 0",
4327 DescribeNegation(m));
4328 }
4329
4330 // Tests that Property() can explain the match result.
TEST(PropertyTest,CanExplainMatchResult)4331 TEST(PropertyTest, CanExplainMatchResult) {
4332 Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
4333
4334 AClass a;
4335 a.set_n(1);
4336 EXPECT_EQ("whose given property is 1" + OfType("int"), Explain(m, a));
4337
4338 m = Property(&AClass::n, GreaterThan(0));
4339 EXPECT_EQ(
4340 "whose given property is 1" + OfType("int") + ", which is 1 more than 0",
4341 Explain(m, a));
4342 }
4343
TEST(PropertyTest,CanExplainMatchResultWithPropertyName)4344 TEST(PropertyTest, CanExplainMatchResultWithPropertyName) {
4345 Matcher<const AClass&> m = Property("fancy_name", &AClass::n, Ge(0));
4346
4347 AClass a;
4348 a.set_n(1);
4349 EXPECT_EQ("whose property `fancy_name` is 1" + OfType("int"), Explain(m, a));
4350
4351 m = Property("fancy_name", &AClass::n, GreaterThan(0));
4352 EXPECT_EQ("whose property `fancy_name` is 1" + OfType("int") +
4353 ", which is 1 more than 0",
4354 Explain(m, a));
4355 }
4356
4357 // Tests that Property() works when the argument is a pointer to const.
TEST(PropertyForPointerTest,WorksForPointerToConst)4358 TEST(PropertyForPointerTest, WorksForPointerToConst) {
4359 Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
4360
4361 AClass a;
4362 a.set_n(1);
4363 EXPECT_TRUE(m.Matches(&a));
4364
4365 a.set_n(-1);
4366 EXPECT_FALSE(m.Matches(&a));
4367 }
4368
4369 // Tests that Property() works when the argument is a pointer to non-const.
TEST(PropertyForPointerTest,WorksForPointerToNonConst)4370 TEST(PropertyForPointerTest, WorksForPointerToNonConst) {
4371 Matcher<AClass*> m = Property(&AClass::s, StartsWith("hi"));
4372
4373 AClass a;
4374 a.set_s("hill");
4375 EXPECT_TRUE(m.Matches(&a));
4376
4377 a.set_s("hole");
4378 EXPECT_FALSE(m.Matches(&a));
4379 }
4380
4381 // Tests that Property() works when the argument is a reference to a
4382 // const pointer.
TEST(PropertyForPointerTest,WorksForReferenceToConstPointer)4383 TEST(PropertyForPointerTest, WorksForReferenceToConstPointer) {
4384 Matcher<AClass* const&> m = Property(&AClass::s, StartsWith("hi"));
4385
4386 AClass a;
4387 a.set_s("hill");
4388 EXPECT_TRUE(m.Matches(&a));
4389
4390 a.set_s("hole");
4391 EXPECT_FALSE(m.Matches(&a));
4392 }
4393
4394 // Tests that Property() does not match the NULL pointer.
TEST(PropertyForPointerTest,WorksForReferenceToNonConstProperty)4395 TEST(PropertyForPointerTest, WorksForReferenceToNonConstProperty) {
4396 Matcher<const AClass*> m = Property(&AClass::x, _);
4397 EXPECT_FALSE(m.Matches(NULL));
4398 }
4399
4400 // Tests that Property(&Foo::property, ...) works when the argument's
4401 // type is a sub-type of const Foo*.
TEST(PropertyForPointerTest,WorksForArgumentOfSubType)4402 TEST(PropertyForPointerTest, WorksForArgumentOfSubType) {
4403 // The matcher expects a DerivedClass, but inside the Property() we
4404 // say AClass.
4405 Matcher<const DerivedClass*> m = Property(&AClass::n, Ge(0));
4406
4407 DerivedClass d;
4408 d.set_n(1);
4409 EXPECT_TRUE(m.Matches(&d));
4410
4411 d.set_n(-1);
4412 EXPECT_FALSE(m.Matches(&d));
4413 }
4414
4415 // Tests that Property() can describe itself when used to match a pointer.
TEST(PropertyForPointerTest,CanDescribeSelf)4416 TEST(PropertyForPointerTest, CanDescribeSelf) {
4417 Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
4418
4419 EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
4420 EXPECT_EQ("is an object whose given property isn't >= 0",
4421 DescribeNegation(m));
4422 }
4423
TEST(PropertyForPointerTest,CanDescribeSelfWithPropertyDescription)4424 TEST(PropertyForPointerTest, CanDescribeSelfWithPropertyDescription) {
4425 Matcher<const AClass*> m = Property("fancy_name", &AClass::n, Ge(0));
4426
4427 EXPECT_EQ("is an object whose property `fancy_name` is >= 0", Describe(m));
4428 EXPECT_EQ("is an object whose property `fancy_name` isn't >= 0",
4429 DescribeNegation(m));
4430 }
4431
4432 // Tests that Property() can explain the result of matching a pointer.
TEST(PropertyForPointerTest,CanExplainMatchResult)4433 TEST(PropertyForPointerTest, CanExplainMatchResult) {
4434 Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
4435
4436 AClass a;
4437 a.set_n(1);
4438 EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL)));
4439 EXPECT_EQ(
4440 "which points to an object whose given property is 1" + OfType("int"),
4441 Explain(m, &a));
4442
4443 m = Property(&AClass::n, GreaterThan(0));
4444 EXPECT_EQ("which points to an object whose given property is 1" +
4445 OfType("int") + ", which is 1 more than 0",
4446 Explain(m, &a));
4447 }
4448
TEST(PropertyForPointerTest,CanExplainMatchResultWithPropertyName)4449 TEST(PropertyForPointerTest, CanExplainMatchResultWithPropertyName) {
4450 Matcher<const AClass*> m = Property("fancy_name", &AClass::n, Ge(0));
4451
4452 AClass a;
4453 a.set_n(1);
4454 EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL)));
4455 EXPECT_EQ("which points to an object whose property `fancy_name` is 1" +
4456 OfType("int"),
4457 Explain(m, &a));
4458
4459 m = Property("fancy_name", &AClass::n, GreaterThan(0));
4460 EXPECT_EQ("which points to an object whose property `fancy_name` is 1" +
4461 OfType("int") + ", which is 1 more than 0",
4462 Explain(m, &a));
4463 }
4464
4465 // Tests ResultOf.
4466
4467 // Tests that ResultOf(f, ...) compiles and works as expected when f is a
4468 // function pointer.
IntToStringFunction(int input)4469 std::string IntToStringFunction(int input) {
4470 return input == 1 ? "foo" : "bar";
4471 }
4472
TEST(ResultOfTest,WorksForFunctionPointers)4473 TEST(ResultOfTest, WorksForFunctionPointers) {
4474 Matcher<int> matcher = ResultOf(&IntToStringFunction, Eq(std::string("foo")));
4475
4476 EXPECT_TRUE(matcher.Matches(1));
4477 EXPECT_FALSE(matcher.Matches(2));
4478 }
4479
4480 // Tests that ResultOf() can describe itself.
TEST(ResultOfTest,CanDescribeItself)4481 TEST(ResultOfTest, CanDescribeItself) {
4482 Matcher<int> matcher = ResultOf(&IntToStringFunction, StrEq("foo"));
4483
4484 EXPECT_EQ("is mapped by the given callable to a value that "
4485 "is equal to \"foo\"", Describe(matcher));
4486 EXPECT_EQ("is mapped by the given callable to a value that "
4487 "isn't equal to \"foo\"", DescribeNegation(matcher));
4488 }
4489
4490 // Tests that ResultOf() can explain the match result.
IntFunction(int input)4491 int IntFunction(int input) { return input == 42 ? 80 : 90; }
4492
TEST(ResultOfTest,CanExplainMatchResult)4493 TEST(ResultOfTest, CanExplainMatchResult) {
4494 Matcher<int> matcher = ResultOf(&IntFunction, Ge(85));
4495 EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int"),
4496 Explain(matcher, 36));
4497
4498 matcher = ResultOf(&IntFunction, GreaterThan(85));
4499 EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int") +
4500 ", which is 5 more than 85", Explain(matcher, 36));
4501 }
4502
4503 // Tests that ResultOf(f, ...) compiles and works as expected when f(x)
4504 // returns a non-reference.
TEST(ResultOfTest,WorksForNonReferenceResults)4505 TEST(ResultOfTest, WorksForNonReferenceResults) {
4506 Matcher<int> matcher = ResultOf(&IntFunction, Eq(80));
4507
4508 EXPECT_TRUE(matcher.Matches(42));
4509 EXPECT_FALSE(matcher.Matches(36));
4510 }
4511
4512 // Tests that ResultOf(f, ...) compiles and works as expected when f(x)
4513 // returns a reference to non-const.
DoubleFunction(double & input)4514 double& DoubleFunction(double& input) { return input; } // NOLINT
4515
RefUncopyableFunction(Uncopyable & obj)4516 Uncopyable& RefUncopyableFunction(Uncopyable& obj) { // NOLINT
4517 return obj;
4518 }
4519
TEST(ResultOfTest,WorksForReferenceToNonConstResults)4520 TEST(ResultOfTest, WorksForReferenceToNonConstResults) {
4521 double x = 3.14;
4522 double x2 = x;
4523 Matcher<double&> matcher = ResultOf(&DoubleFunction, Ref(x));
4524
4525 EXPECT_TRUE(matcher.Matches(x));
4526 EXPECT_FALSE(matcher.Matches(x2));
4527
4528 // Test that ResultOf works with uncopyable objects
4529 Uncopyable obj(0);
4530 Uncopyable obj2(0);
4531 Matcher<Uncopyable&> matcher2 =
4532 ResultOf(&RefUncopyableFunction, Ref(obj));
4533
4534 EXPECT_TRUE(matcher2.Matches(obj));
4535 EXPECT_FALSE(matcher2.Matches(obj2));
4536 }
4537
4538 // Tests that ResultOf(f, ...) compiles and works as expected when f(x)
4539 // returns a reference to const.
StringFunction(const std::string & input)4540 const std::string& StringFunction(const std::string& input) { return input; }
4541
TEST(ResultOfTest,WorksForReferenceToConstResults)4542 TEST(ResultOfTest, WorksForReferenceToConstResults) {
4543 std::string s = "foo";
4544 std::string s2 = s;
4545 Matcher<const std::string&> matcher = ResultOf(&StringFunction, Ref(s));
4546
4547 EXPECT_TRUE(matcher.Matches(s));
4548 EXPECT_FALSE(matcher.Matches(s2));
4549 }
4550
4551 // Tests that ResultOf(f, m) works when f(x) and m's
4552 // argument types are compatible but different.
TEST(ResultOfTest,WorksForCompatibleMatcherTypes)4553 TEST(ResultOfTest, WorksForCompatibleMatcherTypes) {
4554 // IntFunction() returns int but the inner matcher expects a signed char.
4555 Matcher<int> matcher = ResultOf(IntFunction, Matcher<signed char>(Ge(85)));
4556
4557 EXPECT_TRUE(matcher.Matches(36));
4558 EXPECT_FALSE(matcher.Matches(42));
4559 }
4560
4561 // Tests that the program aborts when ResultOf is passed
4562 // a NULL function pointer.
TEST(ResultOfDeathTest,DiesOnNullFunctionPointers)4563 TEST(ResultOfDeathTest, DiesOnNullFunctionPointers) {
4564 EXPECT_DEATH_IF_SUPPORTED(
4565 ResultOf(static_cast<std::string (*)(int dummy)>(NULL),
4566 Eq(std::string("foo"))),
4567 "NULL function pointer is passed into ResultOf\\(\\)\\.");
4568 }
4569
4570 // Tests that ResultOf(f, ...) compiles and works as expected when f is a
4571 // function reference.
TEST(ResultOfTest,WorksForFunctionReferences)4572 TEST(ResultOfTest, WorksForFunctionReferences) {
4573 Matcher<int> matcher = ResultOf(IntToStringFunction, StrEq("foo"));
4574 EXPECT_TRUE(matcher.Matches(1));
4575 EXPECT_FALSE(matcher.Matches(2));
4576 }
4577
4578 // Tests that ResultOf(f, ...) compiles and works as expected when f is a
4579 // function object.
4580 struct Functor : public ::std::unary_function<int, std::string> {
operator ()testing::gmock_matchers_test::Functor4581 result_type operator()(argument_type input) const {
4582 return IntToStringFunction(input);
4583 }
4584 };
4585
TEST(ResultOfTest,WorksForFunctors)4586 TEST(ResultOfTest, WorksForFunctors) {
4587 Matcher<int> matcher = ResultOf(Functor(), Eq(std::string("foo")));
4588
4589 EXPECT_TRUE(matcher.Matches(1));
4590 EXPECT_FALSE(matcher.Matches(2));
4591 }
4592
4593 // Tests that ResultOf(f, ...) compiles and works as expected when f is a
4594 // functor with more than one operator() defined. ResultOf() must work
4595 // for each defined operator().
4596 struct PolymorphicFunctor {
4597 typedef int result_type;
operator ()testing::gmock_matchers_test::PolymorphicFunctor4598 int operator()(int n) { return n; }
operator ()testing::gmock_matchers_test::PolymorphicFunctor4599 int operator()(const char* s) { return static_cast<int>(strlen(s)); }
operator ()testing::gmock_matchers_test::PolymorphicFunctor4600 std::string operator()(int *p) { return p ? "good ptr" : "null"; }
4601 };
4602
TEST(ResultOfTest,WorksForPolymorphicFunctors)4603 TEST(ResultOfTest, WorksForPolymorphicFunctors) {
4604 Matcher<int> matcher_int = ResultOf(PolymorphicFunctor(), Ge(5));
4605
4606 EXPECT_TRUE(matcher_int.Matches(10));
4607 EXPECT_FALSE(matcher_int.Matches(2));
4608
4609 Matcher<const char*> matcher_string = ResultOf(PolymorphicFunctor(), Ge(5));
4610
4611 EXPECT_TRUE(matcher_string.Matches("long string"));
4612 EXPECT_FALSE(matcher_string.Matches("shrt"));
4613 }
4614
4615 #if GTEST_LANG_CXX11
TEST(ResultOfTest,WorksForPolymorphicFunctorsIgnoringResultType)4616 TEST(ResultOfTest, WorksForPolymorphicFunctorsIgnoringResultType) {
4617 Matcher<int*> matcher = ResultOf(PolymorphicFunctor(), "good ptr");
4618
4619 int n = 0;
4620 EXPECT_TRUE(matcher.Matches(&n));
4621 EXPECT_FALSE(matcher.Matches(nullptr));
4622 }
4623
TEST(ResultOfTest,WorksForLambdas)4624 TEST(ResultOfTest, WorksForLambdas) {
4625 Matcher<int> matcher =
4626 ResultOf([](int str_len) { return std::string(str_len, 'x'); }, "xxx");
4627 EXPECT_TRUE(matcher.Matches(3));
4628 EXPECT_FALSE(matcher.Matches(1));
4629 }
4630 #endif
4631
ReferencingFunction(const int & n)4632 const int* ReferencingFunction(const int& n) { return &n; }
4633
4634 struct ReferencingFunctor {
4635 typedef const int* result_type;
operator ()testing::gmock_matchers_test::ReferencingFunctor4636 result_type operator()(const int& n) { return &n; }
4637 };
4638
TEST(ResultOfTest,WorksForReferencingCallables)4639 TEST(ResultOfTest, WorksForReferencingCallables) {
4640 const int n = 1;
4641 const int n2 = 1;
4642 Matcher<const int&> matcher2 = ResultOf(ReferencingFunction, Eq(&n));
4643 EXPECT_TRUE(matcher2.Matches(n));
4644 EXPECT_FALSE(matcher2.Matches(n2));
4645
4646 Matcher<const int&> matcher3 = ResultOf(ReferencingFunctor(), Eq(&n));
4647 EXPECT_TRUE(matcher3.Matches(n));
4648 EXPECT_FALSE(matcher3.Matches(n2));
4649 }
4650
4651 class DivisibleByImpl {
4652 public:
DivisibleByImpl(int a_divider)4653 explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {}
4654
4655 // For testing using ExplainMatchResultTo() with polymorphic matchers.
4656 template <typename T>
MatchAndExplain(const T & n,MatchResultListener * listener) const4657 bool MatchAndExplain(const T& n, MatchResultListener* listener) const {
4658 *listener << "which is " << (n % divider_) << " modulo "
4659 << divider_;
4660 return (n % divider_) == 0;
4661 }
4662
DescribeTo(ostream * os) const4663 void DescribeTo(ostream* os) const {
4664 *os << "is divisible by " << divider_;
4665 }
4666
DescribeNegationTo(ostream * os) const4667 void DescribeNegationTo(ostream* os) const {
4668 *os << "is not divisible by " << divider_;
4669 }
4670
set_divider(int a_divider)4671 void set_divider(int a_divider) { divider_ = a_divider; }
divider() const4672 int divider() const { return divider_; }
4673
4674 private:
4675 int divider_;
4676 };
4677
DivisibleBy(int n)4678 PolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) {
4679 return MakePolymorphicMatcher(DivisibleByImpl(n));
4680 }
4681
4682 // Tests that when AllOf() fails, only the first failing matcher is
4683 // asked to explain why.
TEST(ExplainMatchResultTest,AllOf_False_False)4684 TEST(ExplainMatchResultTest, AllOf_False_False) {
4685 const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
4686 EXPECT_EQ("which is 1 modulo 4", Explain(m, 5));
4687 }
4688
4689 // Tests that when AllOf() fails, only the first failing matcher is
4690 // asked to explain why.
TEST(ExplainMatchResultTest,AllOf_False_True)4691 TEST(ExplainMatchResultTest, AllOf_False_True) {
4692 const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
4693 EXPECT_EQ("which is 2 modulo 4", Explain(m, 6));
4694 }
4695
4696 // Tests that when AllOf() fails, only the first failing matcher is
4697 // asked to explain why.
TEST(ExplainMatchResultTest,AllOf_True_False)4698 TEST(ExplainMatchResultTest, AllOf_True_False) {
4699 const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3));
4700 EXPECT_EQ("which is 2 modulo 3", Explain(m, 5));
4701 }
4702
4703 // Tests that when AllOf() succeeds, all matchers are asked to explain
4704 // why.
TEST(ExplainMatchResultTest,AllOf_True_True)4705 TEST(ExplainMatchResultTest, AllOf_True_True) {
4706 const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3));
4707 EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6));
4708 }
4709
TEST(ExplainMatchResultTest,AllOf_True_True_2)4710 TEST(ExplainMatchResultTest, AllOf_True_True_2) {
4711 const Matcher<int> m = AllOf(Ge(2), Le(3));
4712 EXPECT_EQ("", Explain(m, 2));
4713 }
4714
TEST(ExplainmatcherResultTest,MonomorphicMatcher)4715 TEST(ExplainmatcherResultTest, MonomorphicMatcher) {
4716 const Matcher<int> m = GreaterThan(5);
4717 EXPECT_EQ("which is 1 more than 5", Explain(m, 6));
4718 }
4719
4720 // The following two tests verify that values without a public copy
4721 // ctor can be used as arguments to matchers like Eq(), Ge(), and etc
4722 // with the help of ByRef().
4723
4724 class NotCopyable {
4725 public:
NotCopyable(int a_value)4726 explicit NotCopyable(int a_value) : value_(a_value) {}
4727
value() const4728 int value() const { return value_; }
4729
operator ==(const NotCopyable & rhs) const4730 bool operator==(const NotCopyable& rhs) const {
4731 return value() == rhs.value();
4732 }
4733
operator >=(const NotCopyable & rhs) const4734 bool operator>=(const NotCopyable& rhs) const {
4735 return value() >= rhs.value();
4736 }
4737 private:
4738 int value_;
4739
4740 GTEST_DISALLOW_COPY_AND_ASSIGN_(NotCopyable);
4741 };
4742
TEST(ByRefTest,AllowsNotCopyableConstValueInMatchers)4743 TEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) {
4744 const NotCopyable const_value1(1);
4745 const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1));
4746
4747 const NotCopyable n1(1), n2(2);
4748 EXPECT_TRUE(m.Matches(n1));
4749 EXPECT_FALSE(m.Matches(n2));
4750 }
4751
TEST(ByRefTest,AllowsNotCopyableValueInMatchers)4752 TEST(ByRefTest, AllowsNotCopyableValueInMatchers) {
4753 NotCopyable value2(2);
4754 const Matcher<NotCopyable&> m = Ge(ByRef(value2));
4755
4756 NotCopyable n1(1), n2(2);
4757 EXPECT_FALSE(m.Matches(n1));
4758 EXPECT_TRUE(m.Matches(n2));
4759 }
4760
TEST(IsEmptyTest,ImplementsIsEmpty)4761 TEST(IsEmptyTest, ImplementsIsEmpty) {
4762 vector<int> container;
4763 EXPECT_THAT(container, IsEmpty());
4764 container.push_back(0);
4765 EXPECT_THAT(container, Not(IsEmpty()));
4766 container.push_back(1);
4767 EXPECT_THAT(container, Not(IsEmpty()));
4768 }
4769
TEST(IsEmptyTest,WorksWithString)4770 TEST(IsEmptyTest, WorksWithString) {
4771 std::string text;
4772 EXPECT_THAT(text, IsEmpty());
4773 text = "foo";
4774 EXPECT_THAT(text, Not(IsEmpty()));
4775 text = std::string("\0", 1);
4776 EXPECT_THAT(text, Not(IsEmpty()));
4777 }
4778
TEST(IsEmptyTest,CanDescribeSelf)4779 TEST(IsEmptyTest, CanDescribeSelf) {
4780 Matcher<vector<int> > m = IsEmpty();
4781 EXPECT_EQ("is empty", Describe(m));
4782 EXPECT_EQ("isn't empty", DescribeNegation(m));
4783 }
4784
TEST(IsEmptyTest,ExplainsResult)4785 TEST(IsEmptyTest, ExplainsResult) {
4786 Matcher<vector<int> > m = IsEmpty();
4787 vector<int> container;
4788 EXPECT_EQ("", Explain(m, container));
4789 container.push_back(0);
4790 EXPECT_EQ("whose size is 1", Explain(m, container));
4791 }
4792
TEST(IsTrueTest,IsTrueIsFalse)4793 TEST(IsTrueTest, IsTrueIsFalse) {
4794 EXPECT_THAT(true, IsTrue());
4795 EXPECT_THAT(false, IsFalse());
4796 EXPECT_THAT(true, Not(IsFalse()));
4797 EXPECT_THAT(false, Not(IsTrue()));
4798 EXPECT_THAT(0, Not(IsTrue()));
4799 EXPECT_THAT(0, IsFalse());
4800 EXPECT_THAT(NULL, Not(IsTrue()));
4801 EXPECT_THAT(NULL, IsFalse());
4802 EXPECT_THAT(-1, IsTrue());
4803 EXPECT_THAT(-1, Not(IsFalse()));
4804 EXPECT_THAT(1, IsTrue());
4805 EXPECT_THAT(1, Not(IsFalse()));
4806 EXPECT_THAT(2, IsTrue());
4807 EXPECT_THAT(2, Not(IsFalse()));
4808 int a = 42;
4809 EXPECT_THAT(a, IsTrue());
4810 EXPECT_THAT(a, Not(IsFalse()));
4811 EXPECT_THAT(&a, IsTrue());
4812 EXPECT_THAT(&a, Not(IsFalse()));
4813 EXPECT_THAT(false, Not(IsTrue()));
4814 EXPECT_THAT(true, Not(IsFalse()));
4815 #if GTEST_LANG_CXX11
4816 EXPECT_THAT(std::true_type(), IsTrue());
4817 EXPECT_THAT(std::true_type(), Not(IsFalse()));
4818 EXPECT_THAT(std::false_type(), IsFalse());
4819 EXPECT_THAT(std::false_type(), Not(IsTrue()));
4820 EXPECT_THAT(nullptr, Not(IsTrue()));
4821 EXPECT_THAT(nullptr, IsFalse());
4822 std::unique_ptr<int> null_unique;
4823 std::unique_ptr<int> nonnull_unique(new int(0));
4824 EXPECT_THAT(null_unique, Not(IsTrue()));
4825 EXPECT_THAT(null_unique, IsFalse());
4826 EXPECT_THAT(nonnull_unique, IsTrue());
4827 EXPECT_THAT(nonnull_unique, Not(IsFalse()));
4828 #endif // GTEST_LANG_CXX11
4829 }
4830
TEST(SizeIsTest,ImplementsSizeIs)4831 TEST(SizeIsTest, ImplementsSizeIs) {
4832 vector<int> container;
4833 EXPECT_THAT(container, SizeIs(0));
4834 EXPECT_THAT(container, Not(SizeIs(1)));
4835 container.push_back(0);
4836 EXPECT_THAT(container, Not(SizeIs(0)));
4837 EXPECT_THAT(container, SizeIs(1));
4838 container.push_back(0);
4839 EXPECT_THAT(container, Not(SizeIs(0)));
4840 EXPECT_THAT(container, SizeIs(2));
4841 }
4842
TEST(SizeIsTest,WorksWithMap)4843 TEST(SizeIsTest, WorksWithMap) {
4844 map<std::string, int> container;
4845 EXPECT_THAT(container, SizeIs(0));
4846 EXPECT_THAT(container, Not(SizeIs(1)));
4847 container.insert(make_pair("foo", 1));
4848 EXPECT_THAT(container, Not(SizeIs(0)));
4849 EXPECT_THAT(container, SizeIs(1));
4850 container.insert(make_pair("bar", 2));
4851 EXPECT_THAT(container, Not(SizeIs(0)));
4852 EXPECT_THAT(container, SizeIs(2));
4853 }
4854
TEST(SizeIsTest,WorksWithReferences)4855 TEST(SizeIsTest, WorksWithReferences) {
4856 vector<int> container;
4857 Matcher<const vector<int>&> m = SizeIs(1);
4858 EXPECT_THAT(container, Not(m));
4859 container.push_back(0);
4860 EXPECT_THAT(container, m);
4861 }
4862
TEST(SizeIsTest,CanDescribeSelf)4863 TEST(SizeIsTest, CanDescribeSelf) {
4864 Matcher<vector<int> > m = SizeIs(2);
4865 EXPECT_EQ("size is equal to 2", Describe(m));
4866 EXPECT_EQ("size isn't equal to 2", DescribeNegation(m));
4867 }
4868
TEST(SizeIsTest,ExplainsResult)4869 TEST(SizeIsTest, ExplainsResult) {
4870 Matcher<vector<int> > m1 = SizeIs(2);
4871 Matcher<vector<int> > m2 = SizeIs(Lt(2u));
4872 Matcher<vector<int> > m3 = SizeIs(AnyOf(0, 3));
4873 Matcher<vector<int> > m4 = SizeIs(GreaterThan(1));
4874 vector<int> container;
4875 EXPECT_EQ("whose size 0 doesn't match", Explain(m1, container));
4876 EXPECT_EQ("whose size 0 matches", Explain(m2, container));
4877 EXPECT_EQ("whose size 0 matches", Explain(m3, container));
4878 EXPECT_EQ("whose size 0 doesn't match, which is 1 less than 1",
4879 Explain(m4, container));
4880 container.push_back(0);
4881 container.push_back(0);
4882 EXPECT_EQ("whose size 2 matches", Explain(m1, container));
4883 EXPECT_EQ("whose size 2 doesn't match", Explain(m2, container));
4884 EXPECT_EQ("whose size 2 doesn't match", Explain(m3, container));
4885 EXPECT_EQ("whose size 2 matches, which is 1 more than 1",
4886 Explain(m4, container));
4887 }
4888
4889 #if GTEST_HAS_TYPED_TEST
4890 // Tests ContainerEq with different container types, and
4891 // different element types.
4892
4893 template <typename T>
4894 class ContainerEqTest : public testing::Test {};
4895
4896 typedef testing::Types<
4897 set<int>,
4898 vector<size_t>,
4899 multiset<size_t>,
4900 list<int> >
4901 ContainerEqTestTypes;
4902
4903 TYPED_TEST_CASE(ContainerEqTest, ContainerEqTestTypes);
4904
4905 // Tests that the filled container is equal to itself.
TYPED_TEST(ContainerEqTest,EqualsSelf)4906 TYPED_TEST(ContainerEqTest, EqualsSelf) {
4907 static const int vals[] = {1, 1, 2, 3, 5, 8};
4908 TypeParam my_set(vals, vals + 6);
4909 const Matcher<TypeParam> m = ContainerEq(my_set);
4910 EXPECT_TRUE(m.Matches(my_set));
4911 EXPECT_EQ("", Explain(m, my_set));
4912 }
4913
4914 // Tests that missing values are reported.
TYPED_TEST(ContainerEqTest,ValueMissing)4915 TYPED_TEST(ContainerEqTest, ValueMissing) {
4916 static const int vals[] = {1, 1, 2, 3, 5, 8};
4917 static const int test_vals[] = {2, 1, 8, 5};
4918 TypeParam my_set(vals, vals + 6);
4919 TypeParam test_set(test_vals, test_vals + 4);
4920 const Matcher<TypeParam> m = ContainerEq(my_set);
4921 EXPECT_FALSE(m.Matches(test_set));
4922 EXPECT_EQ("which doesn't have these expected elements: 3",
4923 Explain(m, test_set));
4924 }
4925
4926 // Tests that added values are reported.
TYPED_TEST(ContainerEqTest,ValueAdded)4927 TYPED_TEST(ContainerEqTest, ValueAdded) {
4928 static const int vals[] = {1, 1, 2, 3, 5, 8};
4929 static const int test_vals[] = {1, 2, 3, 5, 8, 46};
4930 TypeParam my_set(vals, vals + 6);
4931 TypeParam test_set(test_vals, test_vals + 6);
4932 const Matcher<const TypeParam&> m = ContainerEq(my_set);
4933 EXPECT_FALSE(m.Matches(test_set));
4934 EXPECT_EQ("which has these unexpected elements: 46", Explain(m, test_set));
4935 }
4936
4937 // Tests that added and missing values are reported together.
TYPED_TEST(ContainerEqTest,ValueAddedAndRemoved)4938 TYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) {
4939 static const int vals[] = {1, 1, 2, 3, 5, 8};
4940 static const int test_vals[] = {1, 2, 3, 8, 46};
4941 TypeParam my_set(vals, vals + 6);
4942 TypeParam test_set(test_vals, test_vals + 5);
4943 const Matcher<TypeParam> m = ContainerEq(my_set);
4944 EXPECT_FALSE(m.Matches(test_set));
4945 EXPECT_EQ("which has these unexpected elements: 46,\n"
4946 "and doesn't have these expected elements: 5",
4947 Explain(m, test_set));
4948 }
4949
4950 // Tests duplicated value -- expect no explanation.
TYPED_TEST(ContainerEqTest,DuplicateDifference)4951 TYPED_TEST(ContainerEqTest, DuplicateDifference) {
4952 static const int vals[] = {1, 1, 2, 3, 5, 8};
4953 static const int test_vals[] = {1, 2, 3, 5, 8};
4954 TypeParam my_set(vals, vals + 6);
4955 TypeParam test_set(test_vals, test_vals + 5);
4956 const Matcher<const TypeParam&> m = ContainerEq(my_set);
4957 // Depending on the container, match may be true or false
4958 // But in any case there should be no explanation.
4959 EXPECT_EQ("", Explain(m, test_set));
4960 }
4961 #endif // GTEST_HAS_TYPED_TEST
4962
4963 // Tests that mutliple missing values are reported.
4964 // Using just vector here, so order is predictable.
TEST(ContainerEqExtraTest,MultipleValuesMissing)4965 TEST(ContainerEqExtraTest, MultipleValuesMissing) {
4966 static const int vals[] = {1, 1, 2, 3, 5, 8};
4967 static const int test_vals[] = {2, 1, 5};
4968 vector<int> my_set(vals, vals + 6);
4969 vector<int> test_set(test_vals, test_vals + 3);
4970 const Matcher<vector<int> > m = ContainerEq(my_set);
4971 EXPECT_FALSE(m.Matches(test_set));
4972 EXPECT_EQ("which doesn't have these expected elements: 3, 8",
4973 Explain(m, test_set));
4974 }
4975
4976 // Tests that added values are reported.
4977 // Using just vector here, so order is predictable.
TEST(ContainerEqExtraTest,MultipleValuesAdded)4978 TEST(ContainerEqExtraTest, MultipleValuesAdded) {
4979 static const int vals[] = {1, 1, 2, 3, 5, 8};
4980 static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46};
4981 list<size_t> my_set(vals, vals + 6);
4982 list<size_t> test_set(test_vals, test_vals + 7);
4983 const Matcher<const list<size_t>&> m = ContainerEq(my_set);
4984 EXPECT_FALSE(m.Matches(test_set));
4985 EXPECT_EQ("which has these unexpected elements: 92, 46",
4986 Explain(m, test_set));
4987 }
4988
4989 // Tests that added and missing values are reported together.
TEST(ContainerEqExtraTest,MultipleValuesAddedAndRemoved)4990 TEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) {
4991 static const int vals[] = {1, 1, 2, 3, 5, 8};
4992 static const int test_vals[] = {1, 2, 3, 92, 46};
4993 list<size_t> my_set(vals, vals + 6);
4994 list<size_t> test_set(test_vals, test_vals + 5);
4995 const Matcher<const list<size_t> > m = ContainerEq(my_set);
4996 EXPECT_FALSE(m.Matches(test_set));
4997 EXPECT_EQ("which has these unexpected elements: 92, 46,\n"
4998 "and doesn't have these expected elements: 5, 8",
4999 Explain(m, test_set));
5000 }
5001
5002 // Tests to see that duplicate elements are detected,
5003 // but (as above) not reported in the explanation.
TEST(ContainerEqExtraTest,MultiSetOfIntDuplicateDifference)5004 TEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) {
5005 static const int vals[] = {1, 1, 2, 3, 5, 8};
5006 static const int test_vals[] = {1, 2, 3, 5, 8};
5007 vector<int> my_set(vals, vals + 6);
5008 vector<int> test_set(test_vals, test_vals + 5);
5009 const Matcher<vector<int> > m = ContainerEq(my_set);
5010 EXPECT_TRUE(m.Matches(my_set));
5011 EXPECT_FALSE(m.Matches(test_set));
5012 // There is nothing to report when both sets contain all the same values.
5013 EXPECT_EQ("", Explain(m, test_set));
5014 }
5015
5016 // Tests that ContainerEq works for non-trivial associative containers,
5017 // like maps.
TEST(ContainerEqExtraTest,WorksForMaps)5018 TEST(ContainerEqExtraTest, WorksForMaps) {
5019 map<int, std::string> my_map;
5020 my_map[0] = "a";
5021 my_map[1] = "b";
5022
5023 map<int, std::string> test_map;
5024 test_map[0] = "aa";
5025 test_map[1] = "b";
5026
5027 const Matcher<const map<int, std::string>&> m = ContainerEq(my_map);
5028 EXPECT_TRUE(m.Matches(my_map));
5029 EXPECT_FALSE(m.Matches(test_map));
5030
5031 EXPECT_EQ("which has these unexpected elements: (0, \"aa\"),\n"
5032 "and doesn't have these expected elements: (0, \"a\")",
5033 Explain(m, test_map));
5034 }
5035
TEST(ContainerEqExtraTest,WorksForNativeArray)5036 TEST(ContainerEqExtraTest, WorksForNativeArray) {
5037 int a1[] = {1, 2, 3};
5038 int a2[] = {1, 2, 3};
5039 int b[] = {1, 2, 4};
5040
5041 EXPECT_THAT(a1, ContainerEq(a2));
5042 EXPECT_THAT(a1, Not(ContainerEq(b)));
5043 }
5044
TEST(ContainerEqExtraTest,WorksForTwoDimensionalNativeArray)5045 TEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) {
5046 const char a1[][3] = {"hi", "lo"};
5047 const char a2[][3] = {"hi", "lo"};
5048 const char b[][3] = {"lo", "hi"};
5049
5050 // Tests using ContainerEq() in the first dimension.
5051 EXPECT_THAT(a1, ContainerEq(a2));
5052 EXPECT_THAT(a1, Not(ContainerEq(b)));
5053
5054 // Tests using ContainerEq() in the second dimension.
5055 EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1])));
5056 EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1])));
5057 }
5058
TEST(ContainerEqExtraTest,WorksForNativeArrayAsTuple)5059 TEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) {
5060 const int a1[] = {1, 2, 3};
5061 const int a2[] = {1, 2, 3};
5062 const int b[] = {1, 2, 3, 4};
5063
5064 const int* const p1 = a1;
5065 EXPECT_THAT(make_tuple(p1, 3), ContainerEq(a2));
5066 EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(b)));
5067
5068 const int c[] = {1, 3, 2};
5069 EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(c)));
5070 }
5071
TEST(ContainerEqExtraTest,CopiesNativeArrayParameter)5072 TEST(ContainerEqExtraTest, CopiesNativeArrayParameter) {
5073 std::string a1[][3] = {
5074 {"hi", "hello", "ciao"},
5075 {"bye", "see you", "ciao"}
5076 };
5077
5078 std::string a2[][3] = {
5079 {"hi", "hello", "ciao"},
5080 {"bye", "see you", "ciao"}
5081 };
5082
5083 const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2);
5084 EXPECT_THAT(a1, m);
5085
5086 a2[0][0] = "ha";
5087 EXPECT_THAT(a1, m);
5088 }
5089
TEST(WhenSortedByTest,WorksForEmptyContainer)5090 TEST(WhenSortedByTest, WorksForEmptyContainer) {
5091 const vector<int> numbers;
5092 EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre()));
5093 EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1))));
5094 }
5095
TEST(WhenSortedByTest,WorksForNonEmptyContainer)5096 TEST(WhenSortedByTest, WorksForNonEmptyContainer) {
5097 vector<unsigned> numbers;
5098 numbers.push_back(3);
5099 numbers.push_back(1);
5100 numbers.push_back(2);
5101 numbers.push_back(2);
5102 EXPECT_THAT(numbers, WhenSortedBy(greater<unsigned>(),
5103 ElementsAre(3, 2, 2, 1)));
5104 EXPECT_THAT(numbers, Not(WhenSortedBy(greater<unsigned>(),
5105 ElementsAre(1, 2, 2, 3))));
5106 }
5107
TEST(WhenSortedByTest,WorksForNonVectorContainer)5108 TEST(WhenSortedByTest, WorksForNonVectorContainer) {
5109 list<std::string> words;
5110 words.push_back("say");
5111 words.push_back("hello");
5112 words.push_back("world");
5113 EXPECT_THAT(words, WhenSortedBy(less<std::string>(),
5114 ElementsAre("hello", "say", "world")));
5115 EXPECT_THAT(words, Not(WhenSortedBy(less<std::string>(),
5116 ElementsAre("say", "hello", "world"))));
5117 }
5118
TEST(WhenSortedByTest,WorksForNativeArray)5119 TEST(WhenSortedByTest, WorksForNativeArray) {
5120 const int numbers[] = {1, 3, 2, 4};
5121 const int sorted_numbers[] = {1, 2, 3, 4};
5122 EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre(1, 2, 3, 4)));
5123 EXPECT_THAT(numbers, WhenSortedBy(less<int>(),
5124 ElementsAreArray(sorted_numbers)));
5125 EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1, 3, 2, 4))));
5126 }
5127
TEST(WhenSortedByTest,CanDescribeSelf)5128 TEST(WhenSortedByTest, CanDescribeSelf) {
5129 const Matcher<vector<int> > m = WhenSortedBy(less<int>(), ElementsAre(1, 2));
5130 EXPECT_EQ("(when sorted) has 2 elements where\n"
5131 "element #0 is equal to 1,\n"
5132 "element #1 is equal to 2",
5133 Describe(m));
5134 EXPECT_EQ("(when sorted) doesn't have 2 elements, or\n"
5135 "element #0 isn't equal to 1, or\n"
5136 "element #1 isn't equal to 2",
5137 DescribeNegation(m));
5138 }
5139
TEST(WhenSortedByTest,ExplainsMatchResult)5140 TEST(WhenSortedByTest, ExplainsMatchResult) {
5141 const int a[] = {2, 1};
5142 EXPECT_EQ("which is { 1, 2 } when sorted, whose element #0 doesn't match",
5143 Explain(WhenSortedBy(less<int>(), ElementsAre(2, 3)), a));
5144 EXPECT_EQ("which is { 1, 2 } when sorted",
5145 Explain(WhenSortedBy(less<int>(), ElementsAre(1, 2)), a));
5146 }
5147
5148 // WhenSorted() is a simple wrapper on WhenSortedBy(). Hence we don't
5149 // need to test it as exhaustively as we test the latter.
5150
TEST(WhenSortedTest,WorksForEmptyContainer)5151 TEST(WhenSortedTest, WorksForEmptyContainer) {
5152 const vector<int> numbers;
5153 EXPECT_THAT(numbers, WhenSorted(ElementsAre()));
5154 EXPECT_THAT(numbers, Not(WhenSorted(ElementsAre(1))));
5155 }
5156
TEST(WhenSortedTest,WorksForNonEmptyContainer)5157 TEST(WhenSortedTest, WorksForNonEmptyContainer) {
5158 list<std::string> words;
5159 words.push_back("3");
5160 words.push_back("1");
5161 words.push_back("2");
5162 words.push_back("2");
5163 EXPECT_THAT(words, WhenSorted(ElementsAre("1", "2", "2", "3")));
5164 EXPECT_THAT(words, Not(WhenSorted(ElementsAre("3", "1", "2", "2"))));
5165 }
5166
TEST(WhenSortedTest,WorksForMapTypes)5167 TEST(WhenSortedTest, WorksForMapTypes) {
5168 map<std::string, int> word_counts;
5169 word_counts["and"] = 1;
5170 word_counts["the"] = 1;
5171 word_counts["buffalo"] = 2;
5172 EXPECT_THAT(word_counts,
5173 WhenSorted(ElementsAre(Pair("and", 1), Pair("buffalo", 2),
5174 Pair("the", 1))));
5175 EXPECT_THAT(word_counts,
5176 Not(WhenSorted(ElementsAre(Pair("and", 1), Pair("the", 1),
5177 Pair("buffalo", 2)))));
5178 }
5179
TEST(WhenSortedTest,WorksForMultiMapTypes)5180 TEST(WhenSortedTest, WorksForMultiMapTypes) {
5181 multimap<int, int> ifib;
5182 ifib.insert(make_pair(8, 6));
5183 ifib.insert(make_pair(2, 3));
5184 ifib.insert(make_pair(1, 1));
5185 ifib.insert(make_pair(3, 4));
5186 ifib.insert(make_pair(1, 2));
5187 ifib.insert(make_pair(5, 5));
5188 EXPECT_THAT(ifib, WhenSorted(ElementsAre(Pair(1, 1),
5189 Pair(1, 2),
5190 Pair(2, 3),
5191 Pair(3, 4),
5192 Pair(5, 5),
5193 Pair(8, 6))));
5194 EXPECT_THAT(ifib, Not(WhenSorted(ElementsAre(Pair(8, 6),
5195 Pair(2, 3),
5196 Pair(1, 1),
5197 Pair(3, 4),
5198 Pair(1, 2),
5199 Pair(5, 5)))));
5200 }
5201
TEST(WhenSortedTest,WorksForPolymorphicMatcher)5202 TEST(WhenSortedTest, WorksForPolymorphicMatcher) {
5203 std::deque<int> d;
5204 d.push_back(2);
5205 d.push_back(1);
5206 EXPECT_THAT(d, WhenSorted(ElementsAre(1, 2)));
5207 EXPECT_THAT(d, Not(WhenSorted(ElementsAre(2, 1))));
5208 }
5209
TEST(WhenSortedTest,WorksForVectorConstRefMatcher)5210 TEST(WhenSortedTest, WorksForVectorConstRefMatcher) {
5211 std::deque<int> d;
5212 d.push_back(2);
5213 d.push_back(1);
5214 Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2);
5215 EXPECT_THAT(d, WhenSorted(vector_match));
5216 Matcher<const std::vector<int>&> not_vector_match = ElementsAre(2, 1);
5217 EXPECT_THAT(d, Not(WhenSorted(not_vector_match)));
5218 }
5219
5220 // Deliberately bare pseudo-container.
5221 // Offers only begin() and end() accessors, yielding InputIterator.
5222 template <typename T>
5223 class Streamlike {
5224 private:
5225 class ConstIter;
5226 public:
5227 typedef ConstIter const_iterator;
5228 typedef T value_type;
5229
5230 template <typename InIter>
Streamlike(InIter first,InIter last)5231 Streamlike(InIter first, InIter last) : remainder_(first, last) {}
5232
begin() const5233 const_iterator begin() const {
5234 return const_iterator(this, remainder_.begin());
5235 }
end() const5236 const_iterator end() const {
5237 return const_iterator(this, remainder_.end());
5238 }
5239
5240 private:
5241 class ConstIter : public std::iterator<std::input_iterator_tag,
5242 value_type,
5243 ptrdiff_t,
5244 const value_type*,
5245 const value_type&> {
5246 public:
ConstIter(const Streamlike * s,typename std::list<value_type>::iterator pos)5247 ConstIter(const Streamlike* s,
5248 typename std::list<value_type>::iterator pos)
5249 : s_(s), pos_(pos) {}
5250
operator *() const5251 const value_type& operator*() const { return *pos_; }
operator ->() const5252 const value_type* operator->() const { return &*pos_; }
operator ++()5253 ConstIter& operator++() {
5254 s_->remainder_.erase(pos_++);
5255 return *this;
5256 }
5257
5258 // *iter++ is required to work (see std::istreambuf_iterator).
5259 // (void)iter++ is also required to work.
5260 class PostIncrProxy {
5261 public:
PostIncrProxy(const value_type & value)5262 explicit PostIncrProxy(const value_type& value) : value_(value) {}
operator *() const5263 value_type operator*() const { return value_; }
5264 private:
5265 value_type value_;
5266 };
operator ++(int)5267 PostIncrProxy operator++(int) {
5268 PostIncrProxy proxy(**this);
5269 ++(*this);
5270 return proxy;
5271 }
5272
operator ==(const ConstIter & a,const ConstIter & b)5273 friend bool operator==(const ConstIter& a, const ConstIter& b) {
5274 return a.s_ == b.s_ && a.pos_ == b.pos_;
5275 }
operator !=(const ConstIter & a,const ConstIter & b)5276 friend bool operator!=(const ConstIter& a, const ConstIter& b) {
5277 return !(a == b);
5278 }
5279
5280 private:
5281 const Streamlike* s_;
5282 typename std::list<value_type>::iterator pos_;
5283 };
5284
operator <<(std::ostream & os,const Streamlike & s)5285 friend std::ostream& operator<<(std::ostream& os, const Streamlike& s) {
5286 os << "[";
5287 typedef typename std::list<value_type>::const_iterator Iter;
5288 const char* sep = "";
5289 for (Iter it = s.remainder_.begin(); it != s.remainder_.end(); ++it) {
5290 os << sep << *it;
5291 sep = ",";
5292 }
5293 os << "]";
5294 return os;
5295 }
5296
5297 mutable std::list<value_type> remainder_; // modified by iteration
5298 };
5299
TEST(StreamlikeTest,Iteration)5300 TEST(StreamlikeTest, Iteration) {
5301 const int a[5] = {2, 1, 4, 5, 3};
5302 Streamlike<int> s(a, a + 5);
5303 Streamlike<int>::const_iterator it = s.begin();
5304 const int* ip = a;
5305 while (it != s.end()) {
5306 SCOPED_TRACE(ip - a);
5307 EXPECT_EQ(*ip++, *it++);
5308 }
5309 }
5310
5311 #if GTEST_HAS_STD_FORWARD_LIST_
TEST(BeginEndDistanceIsTest,WorksWithForwardList)5312 TEST(BeginEndDistanceIsTest, WorksWithForwardList) {
5313 std::forward_list<int> container;
5314 EXPECT_THAT(container, BeginEndDistanceIs(0));
5315 EXPECT_THAT(container, Not(BeginEndDistanceIs(1)));
5316 container.push_front(0);
5317 EXPECT_THAT(container, Not(BeginEndDistanceIs(0)));
5318 EXPECT_THAT(container, BeginEndDistanceIs(1));
5319 container.push_front(0);
5320 EXPECT_THAT(container, Not(BeginEndDistanceIs(0)));
5321 EXPECT_THAT(container, BeginEndDistanceIs(2));
5322 }
5323 #endif // GTEST_HAS_STD_FORWARD_LIST_
5324
TEST(BeginEndDistanceIsTest,WorksWithNonStdList)5325 TEST(BeginEndDistanceIsTest, WorksWithNonStdList) {
5326 const int a[5] = {1, 2, 3, 4, 5};
5327 Streamlike<int> s(a, a + 5);
5328 EXPECT_THAT(s, BeginEndDistanceIs(5));
5329 }
5330
TEST(BeginEndDistanceIsTest,CanDescribeSelf)5331 TEST(BeginEndDistanceIsTest, CanDescribeSelf) {
5332 Matcher<vector<int> > m = BeginEndDistanceIs(2);
5333 EXPECT_EQ("distance between begin() and end() is equal to 2", Describe(m));
5334 EXPECT_EQ("distance between begin() and end() isn't equal to 2",
5335 DescribeNegation(m));
5336 }
5337
TEST(BeginEndDistanceIsTest,ExplainsResult)5338 TEST(BeginEndDistanceIsTest, ExplainsResult) {
5339 Matcher<vector<int> > m1 = BeginEndDistanceIs(2);
5340 Matcher<vector<int> > m2 = BeginEndDistanceIs(Lt(2));
5341 Matcher<vector<int> > m3 = BeginEndDistanceIs(AnyOf(0, 3));
5342 Matcher<vector<int> > m4 = BeginEndDistanceIs(GreaterThan(1));
5343 vector<int> container;
5344 EXPECT_EQ("whose distance between begin() and end() 0 doesn't match",
5345 Explain(m1, container));
5346 EXPECT_EQ("whose distance between begin() and end() 0 matches",
5347 Explain(m2, container));
5348 EXPECT_EQ("whose distance between begin() and end() 0 matches",
5349 Explain(m3, container));
5350 EXPECT_EQ(
5351 "whose distance between begin() and end() 0 doesn't match, which is 1 "
5352 "less than 1",
5353 Explain(m4, container));
5354 container.push_back(0);
5355 container.push_back(0);
5356 EXPECT_EQ("whose distance between begin() and end() 2 matches",
5357 Explain(m1, container));
5358 EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
5359 Explain(m2, container));
5360 EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
5361 Explain(m3, container));
5362 EXPECT_EQ(
5363 "whose distance between begin() and end() 2 matches, which is 1 more "
5364 "than 1",
5365 Explain(m4, container));
5366 }
5367
TEST(WhenSortedTest,WorksForStreamlike)5368 TEST(WhenSortedTest, WorksForStreamlike) {
5369 // Streamlike 'container' provides only minimal iterator support.
5370 // Its iterators are tagged with input_iterator_tag.
5371 const int a[5] = {2, 1, 4, 5, 3};
5372 Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5373 EXPECT_THAT(s, WhenSorted(ElementsAre(1, 2, 3, 4, 5)));
5374 EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
5375 }
5376
TEST(WhenSortedTest,WorksForVectorConstRefMatcherOnStreamlike)5377 TEST(WhenSortedTest, WorksForVectorConstRefMatcherOnStreamlike) {
5378 const int a[] = {2, 1, 4, 5, 3};
5379 Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5380 Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2, 3, 4, 5);
5381 EXPECT_THAT(s, WhenSorted(vector_match));
5382 EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
5383 }
5384
TEST(IsSupersetOfTest,WorksForNativeArray)5385 TEST(IsSupersetOfTest, WorksForNativeArray) {
5386 const int subset[] = {1, 4};
5387 const int superset[] = {1, 2, 4};
5388 const int disjoint[] = {1, 0, 3};
5389 EXPECT_THAT(subset, IsSupersetOf(subset));
5390 EXPECT_THAT(subset, Not(IsSupersetOf(superset)));
5391 EXPECT_THAT(superset, IsSupersetOf(subset));
5392 EXPECT_THAT(subset, Not(IsSupersetOf(disjoint)));
5393 EXPECT_THAT(disjoint, Not(IsSupersetOf(subset)));
5394 }
5395
TEST(IsSupersetOfTest,WorksWithDuplicates)5396 TEST(IsSupersetOfTest, WorksWithDuplicates) {
5397 const int not_enough[] = {1, 2};
5398 const int enough[] = {1, 1, 2};
5399 const int expected[] = {1, 1};
5400 EXPECT_THAT(not_enough, Not(IsSupersetOf(expected)));
5401 EXPECT_THAT(enough, IsSupersetOf(expected));
5402 }
5403
TEST(IsSupersetOfTest,WorksForEmpty)5404 TEST(IsSupersetOfTest, WorksForEmpty) {
5405 vector<int> numbers;
5406 vector<int> expected;
5407 EXPECT_THAT(numbers, IsSupersetOf(expected));
5408 expected.push_back(1);
5409 EXPECT_THAT(numbers, Not(IsSupersetOf(expected)));
5410 expected.clear();
5411 numbers.push_back(1);
5412 numbers.push_back(2);
5413 EXPECT_THAT(numbers, IsSupersetOf(expected));
5414 expected.push_back(1);
5415 EXPECT_THAT(numbers, IsSupersetOf(expected));
5416 expected.push_back(2);
5417 EXPECT_THAT(numbers, IsSupersetOf(expected));
5418 expected.push_back(3);
5419 EXPECT_THAT(numbers, Not(IsSupersetOf(expected)));
5420 }
5421
TEST(IsSupersetOfTest,WorksForStreamlike)5422 TEST(IsSupersetOfTest, WorksForStreamlike) {
5423 const int a[5] = {1, 2, 3, 4, 5};
5424 Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5425
5426 vector<int> expected;
5427 expected.push_back(1);
5428 expected.push_back(2);
5429 expected.push_back(5);
5430 EXPECT_THAT(s, IsSupersetOf(expected));
5431
5432 expected.push_back(0);
5433 EXPECT_THAT(s, Not(IsSupersetOf(expected)));
5434 }
5435
TEST(IsSupersetOfTest,TakesStlContainer)5436 TEST(IsSupersetOfTest, TakesStlContainer) {
5437 const int actual[] = {3, 1, 2};
5438
5439 ::std::list<int> expected;
5440 expected.push_back(1);
5441 expected.push_back(3);
5442 EXPECT_THAT(actual, IsSupersetOf(expected));
5443
5444 expected.push_back(4);
5445 EXPECT_THAT(actual, Not(IsSupersetOf(expected)));
5446 }
5447
TEST(IsSupersetOfTest,Describe)5448 TEST(IsSupersetOfTest, Describe) {
5449 typedef std::vector<int> IntVec;
5450 IntVec expected;
5451 expected.push_back(111);
5452 expected.push_back(222);
5453 expected.push_back(333);
5454 EXPECT_THAT(
5455 Describe<IntVec>(IsSupersetOf(expected)),
5456 Eq("a surjection from elements to requirements exists such that:\n"
5457 " - an element is equal to 111\n"
5458 " - an element is equal to 222\n"
5459 " - an element is equal to 333"));
5460 }
5461
TEST(IsSupersetOfTest,DescribeNegation)5462 TEST(IsSupersetOfTest, DescribeNegation) {
5463 typedef std::vector<int> IntVec;
5464 IntVec expected;
5465 expected.push_back(111);
5466 expected.push_back(222);
5467 expected.push_back(333);
5468 EXPECT_THAT(
5469 DescribeNegation<IntVec>(IsSupersetOf(expected)),
5470 Eq("no surjection from elements to requirements exists such that:\n"
5471 " - an element is equal to 111\n"
5472 " - an element is equal to 222\n"
5473 " - an element is equal to 333"));
5474 }
5475
TEST(IsSupersetOfTest,MatchAndExplain)5476 TEST(IsSupersetOfTest, MatchAndExplain) {
5477 std::vector<int> v;
5478 v.push_back(2);
5479 v.push_back(3);
5480 std::vector<int> expected;
5481 expected.push_back(1);
5482 expected.push_back(2);
5483 StringMatchResultListener listener;
5484 ASSERT_FALSE(ExplainMatchResult(IsSupersetOf(expected), v, &listener))
5485 << listener.str();
5486 EXPECT_THAT(listener.str(),
5487 Eq("where the following matchers don't match any elements:\n"
5488 "matcher #0: is equal to 1"));
5489
5490 v.push_back(1);
5491 listener.Clear();
5492 ASSERT_TRUE(ExplainMatchResult(IsSupersetOf(expected), v, &listener))
5493 << listener.str();
5494 EXPECT_THAT(listener.str(), Eq("where:\n"
5495 " - element #0 is matched by matcher #1,\n"
5496 " - element #2 is matched by matcher #0"));
5497 }
5498
5499 #if GTEST_HAS_STD_INITIALIZER_LIST_
TEST(IsSupersetOfTest,WorksForRhsInitializerList)5500 TEST(IsSupersetOfTest, WorksForRhsInitializerList) {
5501 const int numbers[] = {1, 3, 6, 2, 4, 5};
5502 EXPECT_THAT(numbers, IsSupersetOf({1, 2}));
5503 EXPECT_THAT(numbers, Not(IsSupersetOf({3, 0})));
5504 }
5505 #endif
5506
TEST(IsSubsetOfTest,WorksForNativeArray)5507 TEST(IsSubsetOfTest, WorksForNativeArray) {
5508 const int subset[] = {1, 4};
5509 const int superset[] = {1, 2, 4};
5510 const int disjoint[] = {1, 0, 3};
5511 EXPECT_THAT(subset, IsSubsetOf(subset));
5512 EXPECT_THAT(subset, IsSubsetOf(superset));
5513 EXPECT_THAT(superset, Not(IsSubsetOf(subset)));
5514 EXPECT_THAT(subset, Not(IsSubsetOf(disjoint)));
5515 EXPECT_THAT(disjoint, Not(IsSubsetOf(subset)));
5516 }
5517
TEST(IsSubsetOfTest,WorksWithDuplicates)5518 TEST(IsSubsetOfTest, WorksWithDuplicates) {
5519 const int not_enough[] = {1, 2};
5520 const int enough[] = {1, 1, 2};
5521 const int actual[] = {1, 1};
5522 EXPECT_THAT(actual, Not(IsSubsetOf(not_enough)));
5523 EXPECT_THAT(actual, IsSubsetOf(enough));
5524 }
5525
TEST(IsSubsetOfTest,WorksForEmpty)5526 TEST(IsSubsetOfTest, WorksForEmpty) {
5527 vector<int> numbers;
5528 vector<int> expected;
5529 EXPECT_THAT(numbers, IsSubsetOf(expected));
5530 expected.push_back(1);
5531 EXPECT_THAT(numbers, IsSubsetOf(expected));
5532 expected.clear();
5533 numbers.push_back(1);
5534 numbers.push_back(2);
5535 EXPECT_THAT(numbers, Not(IsSubsetOf(expected)));
5536 expected.push_back(1);
5537 EXPECT_THAT(numbers, Not(IsSubsetOf(expected)));
5538 expected.push_back(2);
5539 EXPECT_THAT(numbers, IsSubsetOf(expected));
5540 expected.push_back(3);
5541 EXPECT_THAT(numbers, IsSubsetOf(expected));
5542 }
5543
TEST(IsSubsetOfTest,WorksForStreamlike)5544 TEST(IsSubsetOfTest, WorksForStreamlike) {
5545 const int a[5] = {1, 2};
5546 Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5547
5548 vector<int> expected;
5549 expected.push_back(1);
5550 EXPECT_THAT(s, Not(IsSubsetOf(expected)));
5551 expected.push_back(2);
5552 expected.push_back(5);
5553 EXPECT_THAT(s, IsSubsetOf(expected));
5554 }
5555
TEST(IsSubsetOfTest,TakesStlContainer)5556 TEST(IsSubsetOfTest, TakesStlContainer) {
5557 const int actual[] = {3, 1, 2};
5558
5559 ::std::list<int> expected;
5560 expected.push_back(1);
5561 expected.push_back(3);
5562 EXPECT_THAT(actual, Not(IsSubsetOf(expected)));
5563
5564 expected.push_back(2);
5565 expected.push_back(4);
5566 EXPECT_THAT(actual, IsSubsetOf(expected));
5567 }
5568
TEST(IsSubsetOfTest,Describe)5569 TEST(IsSubsetOfTest, Describe) {
5570 typedef std::vector<int> IntVec;
5571 IntVec expected;
5572 expected.push_back(111);
5573 expected.push_back(222);
5574 expected.push_back(333);
5575
5576 EXPECT_THAT(
5577 Describe<IntVec>(IsSubsetOf(expected)),
5578 Eq("an injection from elements to requirements exists such that:\n"
5579 " - an element is equal to 111\n"
5580 " - an element is equal to 222\n"
5581 " - an element is equal to 333"));
5582 }
5583
TEST(IsSubsetOfTest,DescribeNegation)5584 TEST(IsSubsetOfTest, DescribeNegation) {
5585 typedef std::vector<int> IntVec;
5586 IntVec expected;
5587 expected.push_back(111);
5588 expected.push_back(222);
5589 expected.push_back(333);
5590 EXPECT_THAT(
5591 DescribeNegation<IntVec>(IsSubsetOf(expected)),
5592 Eq("no injection from elements to requirements exists such that:\n"
5593 " - an element is equal to 111\n"
5594 " - an element is equal to 222\n"
5595 " - an element is equal to 333"));
5596 }
5597
TEST(IsSubsetOfTest,MatchAndExplain)5598 TEST(IsSubsetOfTest, MatchAndExplain) {
5599 std::vector<int> v;
5600 v.push_back(2);
5601 v.push_back(3);
5602 std::vector<int> expected;
5603 expected.push_back(1);
5604 expected.push_back(2);
5605 StringMatchResultListener listener;
5606 ASSERT_FALSE(ExplainMatchResult(IsSubsetOf(expected), v, &listener))
5607 << listener.str();
5608 EXPECT_THAT(listener.str(),
5609 Eq("where the following elements don't match any matchers:\n"
5610 "element #1: 3"));
5611
5612 expected.push_back(3);
5613 listener.Clear();
5614 ASSERT_TRUE(ExplainMatchResult(IsSubsetOf(expected), v, &listener))
5615 << listener.str();
5616 EXPECT_THAT(listener.str(), Eq("where:\n"
5617 " - element #0 is matched by matcher #1,\n"
5618 " - element #1 is matched by matcher #2"));
5619 }
5620
5621 #if GTEST_HAS_STD_INITIALIZER_LIST_
TEST(IsSubsetOfTest,WorksForRhsInitializerList)5622 TEST(IsSubsetOfTest, WorksForRhsInitializerList) {
5623 const int numbers[] = {1, 2, 3};
5624 EXPECT_THAT(numbers, IsSubsetOf({1, 2, 3, 4}));
5625 EXPECT_THAT(numbers, Not(IsSubsetOf({1, 2})));
5626 }
5627 #endif
5628
5629 // Tests using ElementsAre() and ElementsAreArray() with stream-like
5630 // "containers".
5631
TEST(ElemensAreStreamTest,WorksForStreamlike)5632 TEST(ElemensAreStreamTest, WorksForStreamlike) {
5633 const int a[5] = {1, 2, 3, 4, 5};
5634 Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5635 EXPECT_THAT(s, ElementsAre(1, 2, 3, 4, 5));
5636 EXPECT_THAT(s, Not(ElementsAre(2, 1, 4, 5, 3)));
5637 }
5638
TEST(ElemensAreArrayStreamTest,WorksForStreamlike)5639 TEST(ElemensAreArrayStreamTest, WorksForStreamlike) {
5640 const int a[5] = {1, 2, 3, 4, 5};
5641 Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5642
5643 vector<int> expected;
5644 expected.push_back(1);
5645 expected.push_back(2);
5646 expected.push_back(3);
5647 expected.push_back(4);
5648 expected.push_back(5);
5649 EXPECT_THAT(s, ElementsAreArray(expected));
5650
5651 expected[3] = 0;
5652 EXPECT_THAT(s, Not(ElementsAreArray(expected)));
5653 }
5654
TEST(ElementsAreTest,WorksWithUncopyable)5655 TEST(ElementsAreTest, WorksWithUncopyable) {
5656 Uncopyable objs[2];
5657 objs[0].set_value(-3);
5658 objs[1].set_value(1);
5659 EXPECT_THAT(objs, ElementsAre(UncopyableIs(-3), Truly(ValueIsPositive)));
5660 }
5661
TEST(ElementsAreTest,TakesStlContainer)5662 TEST(ElementsAreTest, TakesStlContainer) {
5663 const int actual[] = {3, 1, 2};
5664
5665 ::std::list<int> expected;
5666 expected.push_back(3);
5667 expected.push_back(1);
5668 expected.push_back(2);
5669 EXPECT_THAT(actual, ElementsAreArray(expected));
5670
5671 expected.push_back(4);
5672 EXPECT_THAT(actual, Not(ElementsAreArray(expected)));
5673 }
5674
5675 // Tests for UnorderedElementsAreArray()
5676
TEST(UnorderedElementsAreArrayTest,SucceedsWhenExpected)5677 TEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) {
5678 const int a[] = {0, 1, 2, 3, 4};
5679 std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5680 do {
5681 StringMatchResultListener listener;
5682 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(a),
5683 s, &listener)) << listener.str();
5684 } while (std::next_permutation(s.begin(), s.end()));
5685 }
5686
TEST(UnorderedElementsAreArrayTest,VectorBool)5687 TEST(UnorderedElementsAreArrayTest, VectorBool) {
5688 const bool a[] = {0, 1, 0, 1, 1};
5689 const bool b[] = {1, 0, 1, 1, 0};
5690 std::vector<bool> expected(a, a + GTEST_ARRAY_SIZE_(a));
5691 std::vector<bool> actual(b, b + GTEST_ARRAY_SIZE_(b));
5692 StringMatchResultListener listener;
5693 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(expected),
5694 actual, &listener)) << listener.str();
5695 }
5696
TEST(UnorderedElementsAreArrayTest,WorksForStreamlike)5697 TEST(UnorderedElementsAreArrayTest, WorksForStreamlike) {
5698 // Streamlike 'container' provides only minimal iterator support.
5699 // Its iterators are tagged with input_iterator_tag, and it has no
5700 // size() or empty() methods.
5701 const int a[5] = {2, 1, 4, 5, 3};
5702 Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5703
5704 ::std::vector<int> expected;
5705 expected.push_back(1);
5706 expected.push_back(2);
5707 expected.push_back(3);
5708 expected.push_back(4);
5709 expected.push_back(5);
5710 EXPECT_THAT(s, UnorderedElementsAreArray(expected));
5711
5712 expected.push_back(6);
5713 EXPECT_THAT(s, Not(UnorderedElementsAreArray(expected)));
5714 }
5715
TEST(UnorderedElementsAreArrayTest,TakesStlContainer)5716 TEST(UnorderedElementsAreArrayTest, TakesStlContainer) {
5717 const int actual[] = {3, 1, 2};
5718
5719 ::std::list<int> expected;
5720 expected.push_back(1);
5721 expected.push_back(2);
5722 expected.push_back(3);
5723 EXPECT_THAT(actual, UnorderedElementsAreArray(expected));
5724
5725 expected.push_back(4);
5726 EXPECT_THAT(actual, Not(UnorderedElementsAreArray(expected)));
5727 }
5728
5729 #if GTEST_HAS_STD_INITIALIZER_LIST_
5730
TEST(UnorderedElementsAreArrayTest,TakesInitializerList)5731 TEST(UnorderedElementsAreArrayTest, TakesInitializerList) {
5732 const int a[5] = {2, 1, 4, 5, 3};
5733 EXPECT_THAT(a, UnorderedElementsAreArray({1, 2, 3, 4, 5}));
5734 EXPECT_THAT(a, Not(UnorderedElementsAreArray({1, 2, 3, 4, 6})));
5735 }
5736
TEST(UnorderedElementsAreArrayTest,TakesInitializerListOfCStrings)5737 TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfCStrings) {
5738 const std::string a[5] = {"a", "b", "c", "d", "e"};
5739 EXPECT_THAT(a, UnorderedElementsAreArray({"a", "b", "c", "d", "e"}));
5740 EXPECT_THAT(a, Not(UnorderedElementsAreArray({"a", "b", "c", "d", "ef"})));
5741 }
5742
TEST(UnorderedElementsAreArrayTest,TakesInitializerListOfSameTypedMatchers)5743 TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) {
5744 const int a[5] = {2, 1, 4, 5, 3};
5745 EXPECT_THAT(a, UnorderedElementsAreArray(
5746 {Eq(1), Eq(2), Eq(3), Eq(4), Eq(5)}));
5747 EXPECT_THAT(a, Not(UnorderedElementsAreArray(
5748 {Eq(1), Eq(2), Eq(3), Eq(4), Eq(6)})));
5749 }
5750
TEST(UnorderedElementsAreArrayTest,TakesInitializerListOfDifferentTypedMatchers)5751 TEST(UnorderedElementsAreArrayTest,
5752 TakesInitializerListOfDifferentTypedMatchers) {
5753 const int a[5] = {2, 1, 4, 5, 3};
5754 // The compiler cannot infer the type of the initializer list if its
5755 // elements have different types. We must explicitly specify the
5756 // unified element type in this case.
5757 EXPECT_THAT(a, UnorderedElementsAreArray<Matcher<int> >(
5758 {Eq(1), Ne(-2), Ge(3), Le(4), Eq(5)}));
5759 EXPECT_THAT(a, Not(UnorderedElementsAreArray<Matcher<int> >(
5760 {Eq(1), Ne(-2), Ge(3), Le(4), Eq(6)})));
5761 }
5762
5763 #endif // GTEST_HAS_STD_INITIALIZER_LIST_
5764
5765 class UnorderedElementsAreTest : public testing::Test {
5766 protected:
5767 typedef std::vector<int> IntVec;
5768 };
5769
TEST_F(UnorderedElementsAreTest,WorksWithUncopyable)5770 TEST_F(UnorderedElementsAreTest, WorksWithUncopyable) {
5771 Uncopyable objs[2];
5772 objs[0].set_value(-3);
5773 objs[1].set_value(1);
5774 EXPECT_THAT(objs,
5775 UnorderedElementsAre(Truly(ValueIsPositive), UncopyableIs(-3)));
5776 }
5777
TEST_F(UnorderedElementsAreTest,SucceedsWhenExpected)5778 TEST_F(UnorderedElementsAreTest, SucceedsWhenExpected) {
5779 const int a[] = {1, 2, 3};
5780 std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5781 do {
5782 StringMatchResultListener listener;
5783 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
5784 s, &listener)) << listener.str();
5785 } while (std::next_permutation(s.begin(), s.end()));
5786 }
5787
TEST_F(UnorderedElementsAreTest,FailsWhenAnElementMatchesNoMatcher)5788 TEST_F(UnorderedElementsAreTest, FailsWhenAnElementMatchesNoMatcher) {
5789 const int a[] = {1, 2, 3};
5790 std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5791 std::vector<Matcher<int> > mv;
5792 mv.push_back(1);
5793 mv.push_back(2);
5794 mv.push_back(2);
5795 // The element with value '3' matches nothing: fail fast.
5796 StringMatchResultListener listener;
5797 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAreArray(mv),
5798 s, &listener)) << listener.str();
5799 }
5800
TEST_F(UnorderedElementsAreTest,WorksForStreamlike)5801 TEST_F(UnorderedElementsAreTest, WorksForStreamlike) {
5802 // Streamlike 'container' provides only minimal iterator support.
5803 // Its iterators are tagged with input_iterator_tag, and it has no
5804 // size() or empty() methods.
5805 const int a[5] = {2, 1, 4, 5, 3};
5806 Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
5807
5808 EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
5809 EXPECT_THAT(s, Not(UnorderedElementsAre(2, 2, 3, 4, 5)));
5810 }
5811
5812 // One naive implementation of the matcher runs in O(N!) time, which is too
5813 // slow for many real-world inputs. This test shows that our matcher can match
5814 // 100 inputs very quickly (a few milliseconds). An O(100!) is 10^158
5815 // iterations and obviously effectively incomputable.
5816 // [ RUN ] UnorderedElementsAreTest.Performance
5817 // [ OK ] UnorderedElementsAreTest.Performance (4 ms)
TEST_F(UnorderedElementsAreTest,Performance)5818 TEST_F(UnorderedElementsAreTest, Performance) {
5819 std::vector<int> s;
5820 std::vector<Matcher<int> > mv;
5821 for (int i = 0; i < 100; ++i) {
5822 s.push_back(i);
5823 mv.push_back(_);
5824 }
5825 mv[50] = Eq(0);
5826 StringMatchResultListener listener;
5827 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
5828 s, &listener)) << listener.str();
5829 }
5830
5831 // Another variant of 'Performance' with similar expectations.
5832 // [ RUN ] UnorderedElementsAreTest.PerformanceHalfStrict
5833 // [ OK ] UnorderedElementsAreTest.PerformanceHalfStrict (4 ms)
TEST_F(UnorderedElementsAreTest,PerformanceHalfStrict)5834 TEST_F(UnorderedElementsAreTest, PerformanceHalfStrict) {
5835 std::vector<int> s;
5836 std::vector<Matcher<int> > mv;
5837 for (int i = 0; i < 100; ++i) {
5838 s.push_back(i);
5839 if (i & 1) {
5840 mv.push_back(_);
5841 } else {
5842 mv.push_back(i);
5843 }
5844 }
5845 StringMatchResultListener listener;
5846 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
5847 s, &listener)) << listener.str();
5848 }
5849
TEST_F(UnorderedElementsAreTest,FailMessageCountWrong)5850 TEST_F(UnorderedElementsAreTest, FailMessageCountWrong) {
5851 std::vector<int> v;
5852 v.push_back(4);
5853 StringMatchResultListener listener;
5854 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
5855 v, &listener)) << listener.str();
5856 EXPECT_THAT(listener.str(), Eq("which has 1 element"));
5857 }
5858
TEST_F(UnorderedElementsAreTest,FailMessageCountWrongZero)5859 TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
5860 std::vector<int> v;
5861 StringMatchResultListener listener;
5862 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
5863 v, &listener)) << listener.str();
5864 EXPECT_THAT(listener.str(), Eq(""));
5865 }
5866
TEST_F(UnorderedElementsAreTest,FailMessageUnmatchedMatchers)5867 TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) {
5868 std::vector<int> v;
5869 v.push_back(1);
5870 v.push_back(1);
5871 StringMatchResultListener listener;
5872 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
5873 v, &listener)) << listener.str();
5874 EXPECT_THAT(
5875 listener.str(),
5876 Eq("where the following matchers don't match any elements:\n"
5877 "matcher #1: is equal to 2"));
5878 }
5879
TEST_F(UnorderedElementsAreTest,FailMessageUnmatchedElements)5880 TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedElements) {
5881 std::vector<int> v;
5882 v.push_back(1);
5883 v.push_back(2);
5884 StringMatchResultListener listener;
5885 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 1),
5886 v, &listener)) << listener.str();
5887 EXPECT_THAT(
5888 listener.str(),
5889 Eq("where the following elements don't match any matchers:\n"
5890 "element #1: 2"));
5891 }
5892
TEST_F(UnorderedElementsAreTest,FailMessageUnmatchedMatcherAndElement)5893 TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatcherAndElement) {
5894 std::vector<int> v;
5895 v.push_back(2);
5896 v.push_back(3);
5897 StringMatchResultListener listener;
5898 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
5899 v, &listener)) << listener.str();
5900 EXPECT_THAT(
5901 listener.str(),
5902 Eq("where"
5903 " the following matchers don't match any elements:\n"
5904 "matcher #0: is equal to 1\n"
5905 "and"
5906 " where"
5907 " the following elements don't match any matchers:\n"
5908 "element #1: 3"));
5909 }
5910
5911 // Test helper for formatting element, matcher index pairs in expectations.
EMString(int element,int matcher)5912 static std::string EMString(int element, int matcher) {
5913 stringstream ss;
5914 ss << "(element #" << element << ", matcher #" << matcher << ")";
5915 return ss.str();
5916 }
5917
TEST_F(UnorderedElementsAreTest,FailMessageImperfectMatchOnly)5918 TEST_F(UnorderedElementsAreTest, FailMessageImperfectMatchOnly) {
5919 // A situation where all elements and matchers have a match
5920 // associated with them, but the max matching is not perfect.
5921 std::vector<std::string> v;
5922 v.push_back("a");
5923 v.push_back("b");
5924 v.push_back("c");
5925 StringMatchResultListener listener;
5926 EXPECT_FALSE(ExplainMatchResult(
5927 UnorderedElementsAre("a", "a", AnyOf("b", "c")), v, &listener))
5928 << listener.str();
5929
5930 std::string prefix =
5931 "where no permutation of the elements can satisfy all matchers, "
5932 "and the closest match is 2 of 3 matchers with the "
5933 "pairings:\n";
5934
5935 // We have to be a bit loose here, because there are 4 valid max matches.
5936 EXPECT_THAT(
5937 listener.str(),
5938 AnyOf(prefix + "{\n " + EMString(0, 0) +
5939 ",\n " + EMString(1, 2) + "\n}",
5940 prefix + "{\n " + EMString(0, 1) +
5941 ",\n " + EMString(1, 2) + "\n}",
5942 prefix + "{\n " + EMString(0, 0) +
5943 ",\n " + EMString(2, 2) + "\n}",
5944 prefix + "{\n " + EMString(0, 1) +
5945 ",\n " + EMString(2, 2) + "\n}"));
5946 }
5947
TEST_F(UnorderedElementsAreTest,Describe)5948 TEST_F(UnorderedElementsAreTest, Describe) {
5949 EXPECT_THAT(Describe<IntVec>(UnorderedElementsAre()),
5950 Eq("is empty"));
5951 EXPECT_THAT(
5952 Describe<IntVec>(UnorderedElementsAre(345)),
5953 Eq("has 1 element and that element is equal to 345"));
5954 EXPECT_THAT(
5955 Describe<IntVec>(UnorderedElementsAre(111, 222, 333)),
5956 Eq("has 3 elements and there exists some permutation "
5957 "of elements such that:\n"
5958 " - element #0 is equal to 111, and\n"
5959 " - element #1 is equal to 222, and\n"
5960 " - element #2 is equal to 333"));
5961 }
5962
TEST_F(UnorderedElementsAreTest,DescribeNegation)5963 TEST_F(UnorderedElementsAreTest, DescribeNegation) {
5964 EXPECT_THAT(DescribeNegation<IntVec>(UnorderedElementsAre()),
5965 Eq("isn't empty"));
5966 EXPECT_THAT(
5967 DescribeNegation<IntVec>(UnorderedElementsAre(345)),
5968 Eq("doesn't have 1 element, or has 1 element that isn't equal to 345"));
5969 EXPECT_THAT(
5970 DescribeNegation<IntVec>(UnorderedElementsAre(123, 234, 345)),
5971 Eq("doesn't have 3 elements, or there exists no permutation "
5972 "of elements such that:\n"
5973 " - element #0 is equal to 123, and\n"
5974 " - element #1 is equal to 234, and\n"
5975 " - element #2 is equal to 345"));
5976 }
5977
5978 namespace {
5979
5980 // Used as a check on the more complex max flow method used in the
5981 // real testing::internal::FindMaxBipartiteMatching. This method is
5982 // compatible but runs in worst-case factorial time, so we only
5983 // use it in testing for small problem sizes.
5984 template <typename Graph>
5985 class BacktrackingMaxBPMState {
5986 public:
5987 // Does not take ownership of 'g'.
BacktrackingMaxBPMState(const Graph * g)5988 explicit BacktrackingMaxBPMState(const Graph* g) : graph_(g) { }
5989
Compute()5990 ElementMatcherPairs Compute() {
5991 if (graph_->LhsSize() == 0 || graph_->RhsSize() == 0) {
5992 return best_so_far_;
5993 }
5994 lhs_used_.assign(graph_->LhsSize(), kUnused);
5995 rhs_used_.assign(graph_->RhsSize(), kUnused);
5996 for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
5997 matches_.clear();
5998 RecurseInto(irhs);
5999 if (best_so_far_.size() == graph_->RhsSize())
6000 break;
6001 }
6002 return best_so_far_;
6003 }
6004
6005 private:
6006 static const size_t kUnused = static_cast<size_t>(-1);
6007
PushMatch(size_t lhs,size_t rhs)6008 void PushMatch(size_t lhs, size_t rhs) {
6009 matches_.push_back(ElementMatcherPair(lhs, rhs));
6010 lhs_used_[lhs] = rhs;
6011 rhs_used_[rhs] = lhs;
6012 if (matches_.size() > best_so_far_.size()) {
6013 best_so_far_ = matches_;
6014 }
6015 }
6016
PopMatch()6017 void PopMatch() {
6018 const ElementMatcherPair& back = matches_.back();
6019 lhs_used_[back.first] = kUnused;
6020 rhs_used_[back.second] = kUnused;
6021 matches_.pop_back();
6022 }
6023
RecurseInto(size_t irhs)6024 bool RecurseInto(size_t irhs) {
6025 if (rhs_used_[irhs] != kUnused) {
6026 return true;
6027 }
6028 for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
6029 if (lhs_used_[ilhs] != kUnused) {
6030 continue;
6031 }
6032 if (!graph_->HasEdge(ilhs, irhs)) {
6033 continue;
6034 }
6035 PushMatch(ilhs, irhs);
6036 if (best_so_far_.size() == graph_->RhsSize()) {
6037 return false;
6038 }
6039 for (size_t mi = irhs + 1; mi < graph_->RhsSize(); ++mi) {
6040 if (!RecurseInto(mi)) return false;
6041 }
6042 PopMatch();
6043 }
6044 return true;
6045 }
6046
6047 const Graph* graph_; // not owned
6048 std::vector<size_t> lhs_used_;
6049 std::vector<size_t> rhs_used_;
6050 ElementMatcherPairs matches_;
6051 ElementMatcherPairs best_so_far_;
6052 };
6053
6054 template <typename Graph>
6055 const size_t BacktrackingMaxBPMState<Graph>::kUnused;
6056
6057 } // namespace
6058
6059 // Implement a simple backtracking algorithm to determine if it is possible
6060 // to find one element per matcher, without reusing elements.
6061 template <typename Graph>
6062 ElementMatcherPairs
FindBacktrackingMaxBPM(const Graph & g)6063 FindBacktrackingMaxBPM(const Graph& g) {
6064 return BacktrackingMaxBPMState<Graph>(&g).Compute();
6065 }
6066
6067 class BacktrackingBPMTest : public ::testing::Test { };
6068
6069 // Tests the MaxBipartiteMatching algorithm with square matrices.
6070 // The single int param is the # of nodes on each of the left and right sides.
6071 class BipartiteTest : public ::testing::TestWithParam<int> { };
6072
6073 // Verify all match graphs up to some moderate number of edges.
TEST_P(BipartiteTest,Exhaustive)6074 TEST_P(BipartiteTest, Exhaustive) {
6075 int nodes = GetParam();
6076 MatchMatrix graph(nodes, nodes);
6077 do {
6078 ElementMatcherPairs matches =
6079 internal::FindMaxBipartiteMatching(graph);
6080 EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), matches.size())
6081 << "graph: " << graph.DebugString();
6082 // Check that all elements of matches are in the graph.
6083 // Check that elements of first and second are unique.
6084 std::vector<bool> seen_element(graph.LhsSize());
6085 std::vector<bool> seen_matcher(graph.RhsSize());
6086 SCOPED_TRACE(PrintToString(matches));
6087 for (size_t i = 0; i < matches.size(); ++i) {
6088 size_t ilhs = matches[i].first;
6089 size_t irhs = matches[i].second;
6090 EXPECT_TRUE(graph.HasEdge(ilhs, irhs));
6091 EXPECT_FALSE(seen_element[ilhs]);
6092 EXPECT_FALSE(seen_matcher[irhs]);
6093 seen_element[ilhs] = true;
6094 seen_matcher[irhs] = true;
6095 }
6096 } while (graph.NextGraph());
6097 }
6098
6099 INSTANTIATE_TEST_CASE_P(AllGraphs, BipartiteTest,
6100 ::testing::Range(0, 5));
6101
6102 // Parameterized by a pair interpreted as (LhsSize, RhsSize).
6103 class BipartiteNonSquareTest
6104 : public ::testing::TestWithParam<std::pair<size_t, size_t> > {
6105 };
6106
TEST_F(BipartiteNonSquareTest,SimpleBacktracking)6107 TEST_F(BipartiteNonSquareTest, SimpleBacktracking) {
6108 // .......
6109 // 0:-----\ :
6110 // 1:---\ | :
6111 // 2:---\ | :
6112 // 3:-\ | | :
6113 // :.......:
6114 // 0 1 2
6115 MatchMatrix g(4, 3);
6116 static const int kEdges[][2] = {{0, 2}, {1, 1}, {2, 1}, {3, 0}};
6117 for (size_t i = 0; i < GTEST_ARRAY_SIZE_(kEdges); ++i) {
6118 g.SetEdge(kEdges[i][0], kEdges[i][1], true);
6119 }
6120 EXPECT_THAT(FindBacktrackingMaxBPM(g),
6121 ElementsAre(Pair(3, 0),
6122 Pair(AnyOf(1, 2), 1),
6123 Pair(0, 2))) << g.DebugString();
6124 }
6125
6126 // Verify a few nonsquare matrices.
TEST_P(BipartiteNonSquareTest,Exhaustive)6127 TEST_P(BipartiteNonSquareTest, Exhaustive) {
6128 size_t nlhs = GetParam().first;
6129 size_t nrhs = GetParam().second;
6130 MatchMatrix graph(nlhs, nrhs);
6131 do {
6132 EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
6133 internal::FindMaxBipartiteMatching(graph).size())
6134 << "graph: " << graph.DebugString()
6135 << "\nbacktracking: "
6136 << PrintToString(FindBacktrackingMaxBPM(graph))
6137 << "\nmax flow: "
6138 << PrintToString(internal::FindMaxBipartiteMatching(graph));
6139 } while (graph.NextGraph());
6140 }
6141
6142 INSTANTIATE_TEST_CASE_P(AllGraphs, BipartiteNonSquareTest,
6143 testing::Values(
6144 std::make_pair(1, 2),
6145 std::make_pair(2, 1),
6146 std::make_pair(3, 2),
6147 std::make_pair(2, 3),
6148 std::make_pair(4, 1),
6149 std::make_pair(1, 4),
6150 std::make_pair(4, 3),
6151 std::make_pair(3, 4)));
6152
6153 class BipartiteRandomTest
6154 : public ::testing::TestWithParam<std::pair<int, int> > {
6155 };
6156
6157 // Verifies a large sample of larger graphs.
TEST_P(BipartiteRandomTest,LargerNets)6158 TEST_P(BipartiteRandomTest, LargerNets) {
6159 int nodes = GetParam().first;
6160 int iters = GetParam().second;
6161 MatchMatrix graph(nodes, nodes);
6162
6163 testing::internal::Int32 seed = GTEST_FLAG(random_seed);
6164 if (seed == 0) {
6165 seed = static_cast<testing::internal::Int32>(time(NULL));
6166 }
6167
6168 for (; iters > 0; --iters, ++seed) {
6169 srand(static_cast<int>(seed));
6170 graph.Randomize();
6171 EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
6172 internal::FindMaxBipartiteMatching(graph).size())
6173 << " graph: " << graph.DebugString()
6174 << "\nTo reproduce the failure, rerun the test with the flag"
6175 " --" << GTEST_FLAG_PREFIX_ << "random_seed=" << seed;
6176 }
6177 }
6178
6179 // Test argument is a std::pair<int, int> representing (nodes, iters).
6180 INSTANTIATE_TEST_CASE_P(Samples, BipartiteRandomTest,
6181 testing::Values(
6182 std::make_pair(5, 10000),
6183 std::make_pair(6, 5000),
6184 std::make_pair(7, 2000),
6185 std::make_pair(8, 500),
6186 std::make_pair(9, 100)));
6187
6188 // Tests IsReadableTypeName().
6189
TEST(IsReadableTypeNameTest,ReturnsTrueForShortNames)6190 TEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) {
6191 EXPECT_TRUE(IsReadableTypeName("int"));
6192 EXPECT_TRUE(IsReadableTypeName("const unsigned char*"));
6193 EXPECT_TRUE(IsReadableTypeName("MyMap<int, void*>"));
6194 EXPECT_TRUE(IsReadableTypeName("void (*)(int, bool)"));
6195 }
6196
TEST(IsReadableTypeNameTest,ReturnsTrueForLongNonTemplateNonFunctionNames)6197 TEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctionNames) {
6198 EXPECT_TRUE(IsReadableTypeName("my_long_namespace::MyClassName"));
6199 EXPECT_TRUE(IsReadableTypeName("int [5][6][7][8][9][10][11]"));
6200 EXPECT_TRUE(IsReadableTypeName("my_namespace::MyOuterClass::MyInnerClass"));
6201 }
6202
TEST(IsReadableTypeNameTest,ReturnsFalseForLongTemplateNames)6203 TEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) {
6204 EXPECT_FALSE(
6205 IsReadableTypeName("basic_string<char, std::char_traits<char> >"));
6206 EXPECT_FALSE(IsReadableTypeName("std::vector<int, std::alloc_traits<int> >"));
6207 }
6208
TEST(IsReadableTypeNameTest,ReturnsFalseForLongFunctionTypeNames)6209 TEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) {
6210 EXPECT_FALSE(IsReadableTypeName("void (&)(int, bool, char, float)"));
6211 }
6212
6213 // Tests FormatMatcherDescription().
6214
TEST(FormatMatcherDescriptionTest,WorksForEmptyDescription)6215 TEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) {
6216 EXPECT_EQ("is even",
6217 FormatMatcherDescription(false, "IsEven", Strings()));
6218 EXPECT_EQ("not (is even)",
6219 FormatMatcherDescription(true, "IsEven", Strings()));
6220
6221 const char* params[] = {"5"};
6222 EXPECT_EQ("equals 5",
6223 FormatMatcherDescription(false, "Equals",
6224 Strings(params, params + 1)));
6225
6226 const char* params2[] = {"5", "8"};
6227 EXPECT_EQ("is in range (5, 8)",
6228 FormatMatcherDescription(false, "IsInRange",
6229 Strings(params2, params2 + 2)));
6230 }
6231
6232 // Tests PolymorphicMatcher::mutable_impl().
TEST(PolymorphicMatcherTest,CanAccessMutableImpl)6233 TEST(PolymorphicMatcherTest, CanAccessMutableImpl) {
6234 PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
6235 DivisibleByImpl& impl = m.mutable_impl();
6236 EXPECT_EQ(42, impl.divider());
6237
6238 impl.set_divider(0);
6239 EXPECT_EQ(0, m.mutable_impl().divider());
6240 }
6241
6242 // Tests PolymorphicMatcher::impl().
TEST(PolymorphicMatcherTest,CanAccessImpl)6243 TEST(PolymorphicMatcherTest, CanAccessImpl) {
6244 const PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
6245 const DivisibleByImpl& impl = m.impl();
6246 EXPECT_EQ(42, impl.divider());
6247 }
6248
TEST(MatcherTupleTest,ExplainsMatchFailure)6249 TEST(MatcherTupleTest, ExplainsMatchFailure) {
6250 stringstream ss1;
6251 ExplainMatchFailureTupleTo(make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)),
6252 make_tuple('a', 10), &ss1);
6253 EXPECT_EQ("", ss1.str()); // Successful match.
6254
6255 stringstream ss2;
6256 ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
6257 make_tuple(2, 'b'), &ss2);
6258 EXPECT_EQ(" Expected arg #0: is > 5\n"
6259 " Actual: 2, which is 3 less than 5\n"
6260 " Expected arg #1: is equal to 'a' (97, 0x61)\n"
6261 " Actual: 'b' (98, 0x62)\n",
6262 ss2.str()); // Failed match where both arguments need explanation.
6263
6264 stringstream ss3;
6265 ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
6266 make_tuple(2, 'a'), &ss3);
6267 EXPECT_EQ(" Expected arg #0: is > 5\n"
6268 " Actual: 2, which is 3 less than 5\n",
6269 ss3.str()); // Failed match where only one argument needs
6270 // explanation.
6271 }
6272
6273 // Tests Each().
6274
TEST(EachTest,ExplainsMatchResultCorrectly)6275 TEST(EachTest, ExplainsMatchResultCorrectly) {
6276 set<int> a; // empty
6277
6278 Matcher<set<int> > m = Each(2);
6279 EXPECT_EQ("", Explain(m, a));
6280
6281 Matcher<const int(&)[1]> n = Each(1); // NOLINT
6282
6283 const int b[1] = {1};
6284 EXPECT_EQ("", Explain(n, b));
6285
6286 n = Each(3);
6287 EXPECT_EQ("whose element #0 doesn't match", Explain(n, b));
6288
6289 a.insert(1);
6290 a.insert(2);
6291 a.insert(3);
6292 m = Each(GreaterThan(0));
6293 EXPECT_EQ("", Explain(m, a));
6294
6295 m = Each(GreaterThan(10));
6296 EXPECT_EQ("whose element #0 doesn't match, which is 9 less than 10",
6297 Explain(m, a));
6298 }
6299
TEST(EachTest,DescribesItselfCorrectly)6300 TEST(EachTest, DescribesItselfCorrectly) {
6301 Matcher<vector<int> > m = Each(1);
6302 EXPECT_EQ("only contains elements that is equal to 1", Describe(m));
6303
6304 Matcher<vector<int> > m2 = Not(m);
6305 EXPECT_EQ("contains some element that isn't equal to 1", Describe(m2));
6306 }
6307
TEST(EachTest,MatchesVectorWhenAllElementsMatch)6308 TEST(EachTest, MatchesVectorWhenAllElementsMatch) {
6309 vector<int> some_vector;
6310 EXPECT_THAT(some_vector, Each(1));
6311 some_vector.push_back(3);
6312 EXPECT_THAT(some_vector, Not(Each(1)));
6313 EXPECT_THAT(some_vector, Each(3));
6314 some_vector.push_back(1);
6315 some_vector.push_back(2);
6316 EXPECT_THAT(some_vector, Not(Each(3)));
6317 EXPECT_THAT(some_vector, Each(Lt(3.5)));
6318
6319 vector<std::string> another_vector;
6320 another_vector.push_back("fee");
6321 EXPECT_THAT(another_vector, Each(std::string("fee")));
6322 another_vector.push_back("fie");
6323 another_vector.push_back("foe");
6324 another_vector.push_back("fum");
6325 EXPECT_THAT(another_vector, Not(Each(std::string("fee"))));
6326 }
6327
TEST(EachTest,MatchesMapWhenAllElementsMatch)6328 TEST(EachTest, MatchesMapWhenAllElementsMatch) {
6329 map<const char*, int> my_map;
6330 const char* bar = "a string";
6331 my_map[bar] = 2;
6332 EXPECT_THAT(my_map, Each(make_pair(bar, 2)));
6333
6334 map<std::string, int> another_map;
6335 EXPECT_THAT(another_map, Each(make_pair(std::string("fee"), 1)));
6336 another_map["fee"] = 1;
6337 EXPECT_THAT(another_map, Each(make_pair(std::string("fee"), 1)));
6338 another_map["fie"] = 2;
6339 another_map["foe"] = 3;
6340 another_map["fum"] = 4;
6341 EXPECT_THAT(another_map, Not(Each(make_pair(std::string("fee"), 1))));
6342 EXPECT_THAT(another_map, Not(Each(make_pair(std::string("fum"), 1))));
6343 EXPECT_THAT(another_map, Each(Pair(_, Gt(0))));
6344 }
6345
TEST(EachTest,AcceptsMatcher)6346 TEST(EachTest, AcceptsMatcher) {
6347 const int a[] = {1, 2, 3};
6348 EXPECT_THAT(a, Each(Gt(0)));
6349 EXPECT_THAT(a, Not(Each(Gt(1))));
6350 }
6351
TEST(EachTest,WorksForNativeArrayAsTuple)6352 TEST(EachTest, WorksForNativeArrayAsTuple) {
6353 const int a[] = {1, 2};
6354 const int* const pointer = a;
6355 EXPECT_THAT(make_tuple(pointer, 2), Each(Gt(0)));
6356 EXPECT_THAT(make_tuple(pointer, 2), Not(Each(Gt(1))));
6357 }
6358
6359 // For testing Pointwise().
6360 class IsHalfOfMatcher {
6361 public:
6362 template <typename T1, typename T2>
MatchAndExplain(const tuple<T1,T2> & a_pair,MatchResultListener * listener) const6363 bool MatchAndExplain(const tuple<T1, T2>& a_pair,
6364 MatchResultListener* listener) const {
6365 if (get<0>(a_pair) == get<1>(a_pair)/2) {
6366 *listener << "where the second is " << get<1>(a_pair);
6367 return true;
6368 } else {
6369 *listener << "where the second/2 is " << get<1>(a_pair)/2;
6370 return false;
6371 }
6372 }
6373
DescribeTo(ostream * os) const6374 void DescribeTo(ostream* os) const {
6375 *os << "are a pair where the first is half of the second";
6376 }
6377
DescribeNegationTo(ostream * os) const6378 void DescribeNegationTo(ostream* os) const {
6379 *os << "are a pair where the first isn't half of the second";
6380 }
6381 };
6382
IsHalfOf()6383 PolymorphicMatcher<IsHalfOfMatcher> IsHalfOf() {
6384 return MakePolymorphicMatcher(IsHalfOfMatcher());
6385 }
6386
TEST(PointwiseTest,DescribesSelf)6387 TEST(PointwiseTest, DescribesSelf) {
6388 vector<int> rhs;
6389 rhs.push_back(1);
6390 rhs.push_back(2);
6391 rhs.push_back(3);
6392 const Matcher<const vector<int>&> m = Pointwise(IsHalfOf(), rhs);
6393 EXPECT_EQ("contains 3 values, where each value and its corresponding value "
6394 "in { 1, 2, 3 } are a pair where the first is half of the second",
6395 Describe(m));
6396 EXPECT_EQ("doesn't contain exactly 3 values, or contains a value x at some "
6397 "index i where x and the i-th value of { 1, 2, 3 } are a pair "
6398 "where the first isn't half of the second",
6399 DescribeNegation(m));
6400 }
6401
TEST(PointwiseTest,MakesCopyOfRhs)6402 TEST(PointwiseTest, MakesCopyOfRhs) {
6403 list<signed char> rhs;
6404 rhs.push_back(2);
6405 rhs.push_back(4);
6406
6407 int lhs[] = {1, 2};
6408 const Matcher<const int (&)[2]> m = Pointwise(IsHalfOf(), rhs);
6409 EXPECT_THAT(lhs, m);
6410
6411 // Changing rhs now shouldn't affect m, which made a copy of rhs.
6412 rhs.push_back(6);
6413 EXPECT_THAT(lhs, m);
6414 }
6415
TEST(PointwiseTest,WorksForLhsNativeArray)6416 TEST(PointwiseTest, WorksForLhsNativeArray) {
6417 const int lhs[] = {1, 2, 3};
6418 vector<int> rhs;
6419 rhs.push_back(2);
6420 rhs.push_back(4);
6421 rhs.push_back(6);
6422 EXPECT_THAT(lhs, Pointwise(Lt(), rhs));
6423 EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
6424 }
6425
TEST(PointwiseTest,WorksForRhsNativeArray)6426 TEST(PointwiseTest, WorksForRhsNativeArray) {
6427 const int rhs[] = {1, 2, 3};
6428 vector<int> lhs;
6429 lhs.push_back(2);
6430 lhs.push_back(4);
6431 lhs.push_back(6);
6432 EXPECT_THAT(lhs, Pointwise(Gt(), rhs));
6433 EXPECT_THAT(lhs, Not(Pointwise(Lt(), rhs)));
6434 }
6435
6436 // Test is effective only with sanitizers.
TEST(PointwiseTest,WorksForVectorOfBool)6437 TEST(PointwiseTest, WorksForVectorOfBool) {
6438 vector<bool> rhs(3, false);
6439 rhs[1] = true;
6440 vector<bool> lhs = rhs;
6441 EXPECT_THAT(lhs, Pointwise(Eq(), rhs));
6442 rhs[0] = true;
6443 EXPECT_THAT(lhs, Not(Pointwise(Eq(), rhs)));
6444 }
6445
6446 #if GTEST_HAS_STD_INITIALIZER_LIST_
6447
TEST(PointwiseTest,WorksForRhsInitializerList)6448 TEST(PointwiseTest, WorksForRhsInitializerList) {
6449 const vector<int> lhs{2, 4, 6};
6450 EXPECT_THAT(lhs, Pointwise(Gt(), {1, 2, 3}));
6451 EXPECT_THAT(lhs, Not(Pointwise(Lt(), {3, 3, 7})));
6452 }
6453
6454 #endif // GTEST_HAS_STD_INITIALIZER_LIST_
6455
TEST(PointwiseTest,RejectsWrongSize)6456 TEST(PointwiseTest, RejectsWrongSize) {
6457 const double lhs[2] = {1, 2};
6458 const int rhs[1] = {0};
6459 EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
6460 EXPECT_EQ("which contains 2 values",
6461 Explain(Pointwise(Gt(), rhs), lhs));
6462
6463 const int rhs2[3] = {0, 1, 2};
6464 EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs2)));
6465 }
6466
TEST(PointwiseTest,RejectsWrongContent)6467 TEST(PointwiseTest, RejectsWrongContent) {
6468 const double lhs[3] = {1, 2, 3};
6469 const int rhs[3] = {2, 6, 4};
6470 EXPECT_THAT(lhs, Not(Pointwise(IsHalfOf(), rhs)));
6471 EXPECT_EQ("where the value pair (2, 6) at index #1 don't match, "
6472 "where the second/2 is 3",
6473 Explain(Pointwise(IsHalfOf(), rhs), lhs));
6474 }
6475
TEST(PointwiseTest,AcceptsCorrectContent)6476 TEST(PointwiseTest, AcceptsCorrectContent) {
6477 const double lhs[3] = {1, 2, 3};
6478 const int rhs[3] = {2, 4, 6};
6479 EXPECT_THAT(lhs, Pointwise(IsHalfOf(), rhs));
6480 EXPECT_EQ("", Explain(Pointwise(IsHalfOf(), rhs), lhs));
6481 }
6482
TEST(PointwiseTest,AllowsMonomorphicInnerMatcher)6483 TEST(PointwiseTest, AllowsMonomorphicInnerMatcher) {
6484 const double lhs[3] = {1, 2, 3};
6485 const int rhs[3] = {2, 4, 6};
6486 const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
6487 EXPECT_THAT(lhs, Pointwise(m1, rhs));
6488 EXPECT_EQ("", Explain(Pointwise(m1, rhs), lhs));
6489
6490 // This type works as a tuple<const double&, const int&> can be
6491 // implicitly cast to tuple<double, int>.
6492 const Matcher<tuple<double, int> > m2 = IsHalfOf();
6493 EXPECT_THAT(lhs, Pointwise(m2, rhs));
6494 EXPECT_EQ("", Explain(Pointwise(m2, rhs), lhs));
6495 }
6496
TEST(UnorderedPointwiseTest,DescribesSelf)6497 TEST(UnorderedPointwiseTest, DescribesSelf) {
6498 vector<int> rhs;
6499 rhs.push_back(1);
6500 rhs.push_back(2);
6501 rhs.push_back(3);
6502 const Matcher<const vector<int>&> m = UnorderedPointwise(IsHalfOf(), rhs);
6503 EXPECT_EQ(
6504 "has 3 elements and there exists some permutation of elements such "
6505 "that:\n"
6506 " - element #0 and 1 are a pair where the first is half of the second, "
6507 "and\n"
6508 " - element #1 and 2 are a pair where the first is half of the second, "
6509 "and\n"
6510 " - element #2 and 3 are a pair where the first is half of the second",
6511 Describe(m));
6512 EXPECT_EQ(
6513 "doesn't have 3 elements, or there exists no permutation of elements "
6514 "such that:\n"
6515 " - element #0 and 1 are a pair where the first is half of the second, "
6516 "and\n"
6517 " - element #1 and 2 are a pair where the first is half of the second, "
6518 "and\n"
6519 " - element #2 and 3 are a pair where the first is half of the second",
6520 DescribeNegation(m));
6521 }
6522
TEST(UnorderedPointwiseTest,MakesCopyOfRhs)6523 TEST(UnorderedPointwiseTest, MakesCopyOfRhs) {
6524 list<signed char> rhs;
6525 rhs.push_back(2);
6526 rhs.push_back(4);
6527
6528 int lhs[] = {2, 1};
6529 const Matcher<const int (&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs);
6530 EXPECT_THAT(lhs, m);
6531
6532 // Changing rhs now shouldn't affect m, which made a copy of rhs.
6533 rhs.push_back(6);
6534 EXPECT_THAT(lhs, m);
6535 }
6536
TEST(UnorderedPointwiseTest,WorksForLhsNativeArray)6537 TEST(UnorderedPointwiseTest, WorksForLhsNativeArray) {
6538 const int lhs[] = {1, 2, 3};
6539 vector<int> rhs;
6540 rhs.push_back(4);
6541 rhs.push_back(6);
6542 rhs.push_back(2);
6543 EXPECT_THAT(lhs, UnorderedPointwise(Lt(), rhs));
6544 EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
6545 }
6546
TEST(UnorderedPointwiseTest,WorksForRhsNativeArray)6547 TEST(UnorderedPointwiseTest, WorksForRhsNativeArray) {
6548 const int rhs[] = {1, 2, 3};
6549 vector<int> lhs;
6550 lhs.push_back(4);
6551 lhs.push_back(2);
6552 lhs.push_back(6);
6553 EXPECT_THAT(lhs, UnorderedPointwise(Gt(), rhs));
6554 EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), rhs)));
6555 }
6556
6557 #if GTEST_HAS_STD_INITIALIZER_LIST_
6558
TEST(UnorderedPointwiseTest,WorksForRhsInitializerList)6559 TEST(UnorderedPointwiseTest, WorksForRhsInitializerList) {
6560 const vector<int> lhs{2, 4, 6};
6561 EXPECT_THAT(lhs, UnorderedPointwise(Gt(), {5, 1, 3}));
6562 EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), {1, 1, 7})));
6563 }
6564
6565 #endif // GTEST_HAS_STD_INITIALIZER_LIST_
6566
TEST(UnorderedPointwiseTest,RejectsWrongSize)6567 TEST(UnorderedPointwiseTest, RejectsWrongSize) {
6568 const double lhs[2] = {1, 2};
6569 const int rhs[1] = {0};
6570 EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
6571 EXPECT_EQ("which has 2 elements",
6572 Explain(UnorderedPointwise(Gt(), rhs), lhs));
6573
6574 const int rhs2[3] = {0, 1, 2};
6575 EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs2)));
6576 }
6577
TEST(UnorderedPointwiseTest,RejectsWrongContent)6578 TEST(UnorderedPointwiseTest, RejectsWrongContent) {
6579 const double lhs[3] = {1, 2, 3};
6580 const int rhs[3] = {2, 6, 6};
6581 EXPECT_THAT(lhs, Not(UnorderedPointwise(IsHalfOf(), rhs)));
6582 EXPECT_EQ("where the following elements don't match any matchers:\n"
6583 "element #1: 2",
6584 Explain(UnorderedPointwise(IsHalfOf(), rhs), lhs));
6585 }
6586
TEST(UnorderedPointwiseTest,AcceptsCorrectContentInSameOrder)6587 TEST(UnorderedPointwiseTest, AcceptsCorrectContentInSameOrder) {
6588 const double lhs[3] = {1, 2, 3};
6589 const int rhs[3] = {2, 4, 6};
6590 EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs));
6591 }
6592
TEST(UnorderedPointwiseTest,AcceptsCorrectContentInDifferentOrder)6593 TEST(UnorderedPointwiseTest, AcceptsCorrectContentInDifferentOrder) {
6594 const double lhs[3] = {1, 2, 3};
6595 const int rhs[3] = {6, 4, 2};
6596 EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs));
6597 }
6598
TEST(UnorderedPointwiseTest,AllowsMonomorphicInnerMatcher)6599 TEST(UnorderedPointwiseTest, AllowsMonomorphicInnerMatcher) {
6600 const double lhs[3] = {1, 2, 3};
6601 const int rhs[3] = {4, 6, 2};
6602 const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
6603 EXPECT_THAT(lhs, UnorderedPointwise(m1, rhs));
6604
6605 // This type works as a tuple<const double&, const int&> can be
6606 // implicitly cast to tuple<double, int>.
6607 const Matcher<tuple<double, int> > m2 = IsHalfOf();
6608 EXPECT_THAT(lhs, UnorderedPointwise(m2, rhs));
6609 }
6610
6611 // Sample optional type implementation with minimal requirements for use with
6612 // Optional matcher.
6613 class SampleOptionalInt {
6614 public:
6615 typedef int value_type;
SampleOptionalInt(int value)6616 explicit SampleOptionalInt(int value) : value_(value), has_value_(true) {}
SampleOptionalInt()6617 SampleOptionalInt() : value_(0), has_value_(false) {}
operator bool() const6618 operator bool() const {
6619 return has_value_;
6620 }
operator *() const6621 const int& operator*() const {
6622 return value_;
6623 }
6624 private:
6625 int value_;
6626 bool has_value_;
6627 };
6628
TEST(OptionalTest,DescribesSelf)6629 TEST(OptionalTest, DescribesSelf) {
6630 const Matcher<SampleOptionalInt> m = Optional(Eq(1));
6631 EXPECT_EQ("value is equal to 1", Describe(m));
6632 }
6633
TEST(OptionalTest,ExplainsSelf)6634 TEST(OptionalTest, ExplainsSelf) {
6635 const Matcher<SampleOptionalInt> m = Optional(Eq(1));
6636 EXPECT_EQ("whose value 1 matches", Explain(m, SampleOptionalInt(1)));
6637 EXPECT_EQ("whose value 2 doesn't match", Explain(m, SampleOptionalInt(2)));
6638 }
6639
TEST(OptionalTest,MatchesNonEmptyOptional)6640 TEST(OptionalTest, MatchesNonEmptyOptional) {
6641 const Matcher<SampleOptionalInt> m1 = Optional(1);
6642 const Matcher<SampleOptionalInt> m2 = Optional(Eq(2));
6643 const Matcher<SampleOptionalInt> m3 = Optional(Lt(3));
6644 SampleOptionalInt opt(1);
6645 EXPECT_TRUE(m1.Matches(opt));
6646 EXPECT_FALSE(m2.Matches(opt));
6647 EXPECT_TRUE(m3.Matches(opt));
6648 }
6649
TEST(OptionalTest,DoesNotMatchNullopt)6650 TEST(OptionalTest, DoesNotMatchNullopt) {
6651 const Matcher<SampleOptionalInt> m = Optional(1);
6652 SampleOptionalInt empty;
6653 EXPECT_FALSE(m.Matches(empty));
6654 }
6655
6656 class SampleVariantIntString {
6657 public:
SampleVariantIntString(int i)6658 SampleVariantIntString(int i) : i_(i), has_int_(true) {}
SampleVariantIntString(const std::string & s)6659 SampleVariantIntString(const std::string& s) : s_(s), has_int_(false) {}
6660
6661 template <typename T>
holds_alternative(const SampleVariantIntString & value)6662 friend bool holds_alternative(const SampleVariantIntString& value) {
6663 return value.has_int_ == internal::IsSame<T, int>::value;
6664 }
6665
6666 template <typename T>
get(const SampleVariantIntString & value)6667 friend const T& get(const SampleVariantIntString& value) {
6668 return value.get_impl(static_cast<T*>(NULL));
6669 }
6670
6671 private:
get_impl(int *) const6672 const int& get_impl(int*) const { return i_; }
get_impl(std::string *) const6673 const std::string& get_impl(std::string*) const { return s_; }
6674
6675 int i_;
6676 std::string s_;
6677 bool has_int_;
6678 };
6679
TEST(VariantTest,DescribesSelf)6680 TEST(VariantTest, DescribesSelf) {
6681 const Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
6682 EXPECT_THAT(Describe(m), ContainsRegex("is a variant<> with value of type "
6683 "'.*' and the value is equal to 1"));
6684 }
6685
TEST(VariantTest,ExplainsSelf)6686 TEST(VariantTest, ExplainsSelf) {
6687 const Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
6688 EXPECT_THAT(Explain(m, SampleVariantIntString(1)),
6689 ContainsRegex("whose value 1"));
6690 EXPECT_THAT(Explain(m, SampleVariantIntString("A")),
6691 HasSubstr("whose value is not of type '"));
6692 EXPECT_THAT(Explain(m, SampleVariantIntString(2)),
6693 "whose value 2 doesn't match");
6694 }
6695
TEST(VariantTest,FullMatch)6696 TEST(VariantTest, FullMatch) {
6697 Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
6698 EXPECT_TRUE(m.Matches(SampleVariantIntString(1)));
6699
6700 m = VariantWith<std::string>(Eq("1"));
6701 EXPECT_TRUE(m.Matches(SampleVariantIntString("1")));
6702 }
6703
TEST(VariantTest,TypeDoesNotMatch)6704 TEST(VariantTest, TypeDoesNotMatch) {
6705 Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
6706 EXPECT_FALSE(m.Matches(SampleVariantIntString("1")));
6707
6708 m = VariantWith<std::string>(Eq("1"));
6709 EXPECT_FALSE(m.Matches(SampleVariantIntString(1)));
6710 }
6711
TEST(VariantTest,InnerDoesNotMatch)6712 TEST(VariantTest, InnerDoesNotMatch) {
6713 Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
6714 EXPECT_FALSE(m.Matches(SampleVariantIntString(2)));
6715
6716 m = VariantWith<std::string>(Eq("1"));
6717 EXPECT_FALSE(m.Matches(SampleVariantIntString("2")));
6718 }
6719
6720 class SampleAnyType {
6721 public:
SampleAnyType(int i)6722 explicit SampleAnyType(int i) : index_(0), i_(i) {}
SampleAnyType(const std::string & s)6723 explicit SampleAnyType(const std::string& s) : index_(1), s_(s) {}
6724
6725 template <typename T>
any_cast(const SampleAnyType * any)6726 friend const T* any_cast(const SampleAnyType* any) {
6727 return any->get_impl(static_cast<T*>(NULL));
6728 }
6729
6730 private:
6731 int index_;
6732 int i_;
6733 std::string s_;
6734
get_impl(int *) const6735 const int* get_impl(int*) const { return index_ == 0 ? &i_ : NULL; }
get_impl(std::string *) const6736 const std::string* get_impl(std::string*) const {
6737 return index_ == 1 ? &s_ : NULL;
6738 }
6739 };
6740
TEST(AnyWithTest,FullMatch)6741 TEST(AnyWithTest, FullMatch) {
6742 Matcher<SampleAnyType> m = AnyWith<int>(Eq(1));
6743 EXPECT_TRUE(m.Matches(SampleAnyType(1)));
6744 }
6745
TEST(AnyWithTest,TestBadCastType)6746 TEST(AnyWithTest, TestBadCastType) {
6747 Matcher<SampleAnyType> m = AnyWith<std::string>(Eq("fail"));
6748 EXPECT_FALSE(m.Matches(SampleAnyType(1)));
6749 }
6750
6751 #if GTEST_LANG_CXX11
TEST(AnyWithTest,TestUseInContainers)6752 TEST(AnyWithTest, TestUseInContainers) {
6753 std::vector<SampleAnyType> a;
6754 a.emplace_back(1);
6755 a.emplace_back(2);
6756 a.emplace_back(3);
6757 EXPECT_THAT(
6758 a, ElementsAreArray({AnyWith<int>(1), AnyWith<int>(2), AnyWith<int>(3)}));
6759
6760 std::vector<SampleAnyType> b;
6761 b.emplace_back("hello");
6762 b.emplace_back("merhaba");
6763 b.emplace_back("salut");
6764 EXPECT_THAT(b, ElementsAreArray({AnyWith<std::string>("hello"),
6765 AnyWith<std::string>("merhaba"),
6766 AnyWith<std::string>("salut")}));
6767 }
6768 #endif // GTEST_LANG_CXX11
TEST(AnyWithTest,TestCompare)6769 TEST(AnyWithTest, TestCompare) {
6770 EXPECT_THAT(SampleAnyType(1), AnyWith<int>(Gt(0)));
6771 }
6772
TEST(AnyWithTest,DescribesSelf)6773 TEST(AnyWithTest, DescribesSelf) {
6774 const Matcher<const SampleAnyType&> m = AnyWith<int>(Eq(1));
6775 EXPECT_THAT(Describe(m), ContainsRegex("is an 'any' type with value of type "
6776 "'.*' and the value is equal to 1"));
6777 }
6778
TEST(AnyWithTest,ExplainsSelf)6779 TEST(AnyWithTest, ExplainsSelf) {
6780 const Matcher<const SampleAnyType&> m = AnyWith<int>(Eq(1));
6781
6782 EXPECT_THAT(Explain(m, SampleAnyType(1)), ContainsRegex("whose value 1"));
6783 EXPECT_THAT(Explain(m, SampleAnyType("A")),
6784 HasSubstr("whose value is not of type '"));
6785 EXPECT_THAT(Explain(m, SampleAnyType(2)), "whose value 2 doesn't match");
6786 }
6787
6788 #if GTEST_LANG_CXX11
6789
TEST(PointeeTest,WorksOnMoveOnlyType)6790 TEST(PointeeTest, WorksOnMoveOnlyType) {
6791 std::unique_ptr<int> p(new int(3));
6792 EXPECT_THAT(p, Pointee(Eq(3)));
6793 EXPECT_THAT(p, Not(Pointee(Eq(2))));
6794 }
6795
TEST(NotTest,WorksOnMoveOnlyType)6796 TEST(NotTest, WorksOnMoveOnlyType) {
6797 std::unique_ptr<int> p(new int(3));
6798 EXPECT_THAT(p, Pointee(Eq(3)));
6799 EXPECT_THAT(p, Not(Pointee(Eq(2))));
6800 }
6801
6802 #endif // GTEST_LANG_CXX11
6803
6804 } // namespace gmock_matchers_test
6805 } // namespace testing
6806