1 // Copyright 2007, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
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
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.
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.
30 // Author: wan@google.com (Zhanyong Wan)
32 // Google Mock - a framework for writing C++ mock classes.
34 // This file tests some commonly used argument matchers.
36 #include "gmock/gmock-matchers.h"
37 #include "gmock/gmock-more-matchers.h"
53 #include "gmock/gmock.h"
54 #include "gtest/gtest.h"
55 #include "gtest/gtest-spi.h"
57 #if GTEST_HAS_STD_FORWARD_LIST_
58 # include <forward_list> // NOLINT
64 GTEST_API_ string
JoinAsTuple(const Strings
& fields
);
65 } // namespace internal
67 namespace gmock_matchers_test
{
79 using std::stringstream
;
82 using testing::AllArgs
;
87 using testing::ContainsRegex
;
88 using testing::DoubleEq
;
89 using testing::DoubleNear
;
90 using testing::EndsWith
;
92 using testing::ExplainMatchResult
;
94 using testing::FloatEq
;
95 using testing::FloatNear
;
98 using testing::HasSubstr
;
99 using testing::IsEmpty
;
100 using testing::IsNull
;
104 using testing::MakeMatcher
;
105 using testing::MakePolymorphicMatcher
;
106 using testing::MatchResultListener
;
107 using testing::Matcher
;
108 using testing::MatcherCast
;
109 using testing::MatcherInterface
;
110 using testing::Matches
;
111 using testing::MatchesRegex
;
112 using testing::NanSensitiveDoubleEq
;
113 using testing::NanSensitiveDoubleNear
;
114 using testing::NanSensitiveFloatEq
;
115 using testing::NanSensitiveFloatNear
;
118 using testing::NotNull
;
120 using testing::Pointee
;
121 using testing::Pointwise
;
122 using testing::PolymorphicMatcher
;
123 using testing::Property
;
125 using testing::ResultOf
;
126 using testing::SizeIs
;
127 using testing::StartsWith
;
128 using testing::StrCaseEq
;
129 using testing::StrCaseNe
;
130 using testing::StrEq
;
131 using testing::StrNe
;
132 using testing::StringMatchResultListener
;
133 using testing::Truly
;
134 using testing::TypedEq
;
135 using testing::UnorderedPointwise
;
136 using testing::Value
;
137 using testing::WhenSorted
;
138 using testing::WhenSortedBy
;
141 using testing::internal::DummyMatchResultListener
;
142 using testing::internal::ElementMatcherPair
;
143 using testing::internal::ElementMatcherPairs
;
144 using testing::internal::ExplainMatchFailureTupleTo
;
145 using testing::internal::FloatingEqMatcher
;
146 using testing::internal::FormatMatcherDescription
;
147 using testing::internal::IsReadableTypeName
;
148 using testing::internal::JoinAsTuple
;
149 using testing::internal::linked_ptr
;
150 using testing::internal::MatchMatrix
;
151 using testing::internal::RE
;
152 using testing::internal::scoped_ptr
;
153 using testing::internal::StreamMatchResultListener
;
154 using testing::internal::Strings
;
155 using testing::internal::linked_ptr
;
156 using testing::internal::scoped_ptr
;
157 using testing::internal::string
;
158 using testing::make_tuple
;
159 using testing::tuple
;
161 // For testing ExplainMatchResultTo().
162 class GreaterThanMatcher
: public MatcherInterface
<int> {
164 explicit GreaterThanMatcher(int rhs
) : rhs_(rhs
) {}
166 virtual void DescribeTo(ostream
* os
) const {
167 *os
<< "is > " << rhs_
;
170 virtual bool MatchAndExplain(int lhs
,
171 MatchResultListener
* listener
) const {
172 const int diff
= lhs
- rhs_
;
174 *listener
<< "which is " << diff
<< " more than " << rhs_
;
175 } else if (diff
== 0) {
176 *listener
<< "which is the same as " << rhs_
;
178 *listener
<< "which is " << -diff
<< " less than " << rhs_
;
188 Matcher
<int> GreaterThan(int n
) {
189 return MakeMatcher(new GreaterThanMatcher(n
));
192 string
OfType(const string
& type_name
) {
194 return " (of type " + type_name
+ ")";
200 // Returns the description of the given matcher.
201 template <typename T
>
202 string
Describe(const Matcher
<T
>& m
) {
208 // Returns the description of the negation of the given matcher.
209 template <typename T
>
210 string
DescribeNegation(const Matcher
<T
>& m
) {
212 m
.DescribeNegationTo(&ss
);
216 // Returns the reason why x matches, or doesn't match, m.
217 template <typename MatcherType
, typename Value
>
218 string
Explain(const MatcherType
& m
, const Value
& x
) {
219 StringMatchResultListener listener
;
220 ExplainMatchResult(m
, x
, &listener
);
221 return listener
.str();
224 TEST(MatchResultListenerTest
, StreamingWorks
) {
225 StringMatchResultListener listener
;
226 listener
<< "hi" << 5;
227 EXPECT_EQ("hi5", listener
.str());
230 EXPECT_EQ("", listener
.str());
233 EXPECT_EQ("42", listener
.str());
235 // Streaming shouldn't crash when the underlying ostream is NULL.
236 DummyMatchResultListener dummy
;
240 TEST(MatchResultListenerTest
, CanAccessUnderlyingStream
) {
241 EXPECT_TRUE(DummyMatchResultListener().stream() == NULL
);
242 EXPECT_TRUE(StreamMatchResultListener(NULL
).stream() == NULL
);
244 EXPECT_EQ(&std::cout
, StreamMatchResultListener(&std::cout
).stream());
247 TEST(MatchResultListenerTest
, IsInterestedWorks
) {
248 EXPECT_TRUE(StringMatchResultListener().IsInterested());
249 EXPECT_TRUE(StreamMatchResultListener(&std::cout
).IsInterested());
251 EXPECT_FALSE(DummyMatchResultListener().IsInterested());
252 EXPECT_FALSE(StreamMatchResultListener(NULL
).IsInterested());
255 // Makes sure that the MatcherInterface<T> interface doesn't
257 class EvenMatcherImpl
: public MatcherInterface
<int> {
259 virtual bool MatchAndExplain(int x
,
260 MatchResultListener
* /* listener */) const {
264 virtual void DescribeTo(ostream
* os
) const {
265 *os
<< "is an even number";
268 // We deliberately don't define DescribeNegationTo() and
269 // ExplainMatchResultTo() here, to make sure the definition of these
270 // two methods is optional.
273 // Makes sure that the MatcherInterface API doesn't change.
274 TEST(MatcherInterfaceTest
, CanBeImplementedUsingPublishedAPI
) {
278 // Tests implementing a monomorphic matcher using MatchAndExplain().
280 class NewEvenMatcherImpl
: public MatcherInterface
<int> {
282 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
289 *listener
->stream() << " == " << (x
% 2);
294 virtual void DescribeTo(ostream
* os
) const {
295 *os
<< "is an even number";
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));
307 // Tests default-constructing a matcher.
308 TEST(MatcherTest
, CanBeDefaultConstructed
) {
312 // Tests that Matcher<T> can be constructed from a MatcherInterface<T>*.
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));
320 // Tests that value can be used in place of Eq(value).
321 TEST(MatcherTest
, CanBeImplicitlyConstructedFromValue
) {
323 EXPECT_TRUE(m1
.Matches(5));
324 EXPECT_FALSE(m1
.Matches(6));
327 // Tests that NULL can be used in place of Eq(NULL).
328 TEST(MatcherTest
, CanBeImplicitlyConstructedFromNULL
) {
329 Matcher
<int*> m1
= NULL
;
330 EXPECT_TRUE(m1
.Matches(NULL
));
332 EXPECT_FALSE(m1
.Matches(&n
));
335 // Tests that matchers are copyable.
336 TEST(MatcherTest
, IsCopyable
) {
337 // Tests the copy constructor.
338 Matcher
<bool> m1
= Eq(false);
339 EXPECT_TRUE(m1
.Matches(false));
340 EXPECT_FALSE(m1
.Matches(true));
342 // Tests the assignment operator.
344 EXPECT_TRUE(m1
.Matches(true));
345 EXPECT_FALSE(m1
.Matches(false));
348 // Tests that Matcher<T>::DescribeTo() calls
349 // MatcherInterface<T>::DescribeTo().
350 TEST(MatcherTest
, CanDescribeItself
) {
351 EXPECT_EQ("is an even number",
352 Describe(Matcher
<int>(new EvenMatcherImpl
)));
355 // Tests Matcher<T>::MatchAndExplain().
356 TEST(MatcherTest
, MatchAndExplain
) {
357 Matcher
<int> m
= GreaterThan(0);
358 StringMatchResultListener listener1
;
359 EXPECT_TRUE(m
.MatchAndExplain(42, &listener1
));
360 EXPECT_EQ("which is 42 more than 0", listener1
.str());
362 StringMatchResultListener listener2
;
363 EXPECT_FALSE(m
.MatchAndExplain(-9, &listener2
));
364 EXPECT_EQ("which is 9 less than 0", listener2
.str());
367 // Tests that a C-string literal can be implicitly converted to a
368 // Matcher<string> or Matcher<const string&>.
369 TEST(StringMatcherTest
, CanBeImplicitlyConstructedFromCStringLiteral
) {
370 Matcher
<string
> m1
= "hi";
371 EXPECT_TRUE(m1
.Matches("hi"));
372 EXPECT_FALSE(m1
.Matches("hello"));
374 Matcher
<const string
&> m2
= "hi";
375 EXPECT_TRUE(m2
.Matches("hi"));
376 EXPECT_FALSE(m2
.Matches("hello"));
379 // Tests that a string object can be implicitly converted to a
380 // Matcher<string> or Matcher<const string&>.
381 TEST(StringMatcherTest
, CanBeImplicitlyConstructedFromString
) {
382 Matcher
<string
> m1
= string("hi");
383 EXPECT_TRUE(m1
.Matches("hi"));
384 EXPECT_FALSE(m1
.Matches("hello"));
386 Matcher
<const string
&> m2
= string("hi");
387 EXPECT_TRUE(m2
.Matches("hi"));
388 EXPECT_FALSE(m2
.Matches("hello"));
391 #if GTEST_HAS_STRING_PIECE_
392 // Tests that a C-string literal can be implicitly converted to a
393 // Matcher<StringPiece> or Matcher<const StringPiece&>.
394 TEST(StringPieceMatcherTest
, CanBeImplicitlyConstructedFromCStringLiteral
) {
395 Matcher
<StringPiece
> m1
= "cats";
396 EXPECT_TRUE(m1
.Matches("cats"));
397 EXPECT_FALSE(m1
.Matches("dogs"));
399 Matcher
<const StringPiece
&> m2
= "cats";
400 EXPECT_TRUE(m2
.Matches("cats"));
401 EXPECT_FALSE(m2
.Matches("dogs"));
404 // Tests that a string object can be implicitly converted to a
405 // Matcher<StringPiece> or Matcher<const StringPiece&>.
406 TEST(StringPieceMatcherTest
, CanBeImplicitlyConstructedFromString
) {
407 Matcher
<StringPiece
> m1
= string("cats");
408 EXPECT_TRUE(m1
.Matches("cats"));
409 EXPECT_FALSE(m1
.Matches("dogs"));
411 Matcher
<const StringPiece
&> m2
= string("cats");
412 EXPECT_TRUE(m2
.Matches("cats"));
413 EXPECT_FALSE(m2
.Matches("dogs"));
416 // Tests that a StringPiece object can be implicitly converted to a
417 // Matcher<StringPiece> or Matcher<const StringPiece&>.
418 TEST(StringPieceMatcherTest
, CanBeImplicitlyConstructedFromStringPiece
) {
419 Matcher
<StringPiece
> m1
= StringPiece("cats");
420 EXPECT_TRUE(m1
.Matches("cats"));
421 EXPECT_FALSE(m1
.Matches("dogs"));
423 Matcher
<const StringPiece
&> m2
= StringPiece("cats");
424 EXPECT_TRUE(m2
.Matches("cats"));
425 EXPECT_FALSE(m2
.Matches("dogs"));
427 #endif // GTEST_HAS_STRING_PIECE_
429 // Tests that MakeMatcher() constructs a Matcher<T> from a
430 // MatcherInterface* without requiring the user to explicitly
432 TEST(MakeMatcherTest
, ConstructsMatcherFromMatcherInterface
) {
433 const MatcherInterface
<int>* dummy_impl
= NULL
;
434 Matcher
<int> m
= MakeMatcher(dummy_impl
);
437 // Tests that MakePolymorphicMatcher() can construct a polymorphic
438 // matcher from its implementation using the old API.
440 class ReferencesBarOrIsZeroImpl
{
442 template <typename T
>
443 bool MatchAndExplain(const T
& x
,
444 MatchResultListener
* /* listener */) const {
446 return p
== &g_bar
|| x
== 0;
449 void DescribeTo(ostream
* os
) const { *os
<< "g_bar or zero"; }
451 void DescribeNegationTo(ostream
* os
) const {
452 *os
<< "doesn't reference g_bar and is not zero";
456 // This function verifies that MakePolymorphicMatcher() returns a
457 // PolymorphicMatcher<T> where T is the argument's type.
458 PolymorphicMatcher
<ReferencesBarOrIsZeroImpl
> ReferencesBarOrIsZero() {
459 return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl());
462 TEST(MakePolymorphicMatcherTest
, ConstructsMatcherUsingOldAPI
) {
463 // Using a polymorphic matcher to match a reference type.
464 Matcher
<const int&> m1
= ReferencesBarOrIsZero();
465 EXPECT_TRUE(m1
.Matches(0));
466 // Verifies that the identity of a by-reference argument is preserved.
467 EXPECT_TRUE(m1
.Matches(g_bar
));
468 EXPECT_FALSE(m1
.Matches(1));
469 EXPECT_EQ("g_bar or zero", Describe(m1
));
471 // Using a polymorphic matcher to match a value type.
472 Matcher
<double> m2
= ReferencesBarOrIsZero();
473 EXPECT_TRUE(m2
.Matches(0.0));
474 EXPECT_FALSE(m2
.Matches(0.1));
475 EXPECT_EQ("g_bar or zero", Describe(m2
));
478 // Tests implementing a polymorphic matcher using MatchAndExplain().
480 class PolymorphicIsEvenImpl
{
482 void DescribeTo(ostream
* os
) const { *os
<< "is even"; }
484 void DescribeNegationTo(ostream
* os
) const {
488 template <typename T
>
489 bool MatchAndExplain(const T
& x
, MatchResultListener
* listener
) const {
490 // Verifies that we can stream to the listener directly.
491 *listener
<< "% " << 2;
492 if (listener
->stream() != NULL
) {
493 // Verifies that we can stream to the listener's underlying stream
495 *listener
->stream() << " == " << (x
% 2);
501 PolymorphicMatcher
<PolymorphicIsEvenImpl
> PolymorphicIsEven() {
502 return MakePolymorphicMatcher(PolymorphicIsEvenImpl());
505 TEST(MakePolymorphicMatcherTest
, ConstructsMatcherUsingNewAPI
) {
506 // Using PolymorphicIsEven() as a Matcher<int>.
507 const Matcher
<int> m1
= PolymorphicIsEven();
508 EXPECT_TRUE(m1
.Matches(42));
509 EXPECT_FALSE(m1
.Matches(43));
510 EXPECT_EQ("is even", Describe(m1
));
512 const Matcher
<int> not_m1
= Not(m1
);
513 EXPECT_EQ("is odd", Describe(not_m1
));
515 EXPECT_EQ("% 2 == 0", Explain(m1
, 42));
517 // Using PolymorphicIsEven() as a Matcher<char>.
518 const Matcher
<char> m2
= PolymorphicIsEven();
519 EXPECT_TRUE(m2
.Matches('\x42'));
520 EXPECT_FALSE(m2
.Matches('\x43'));
521 EXPECT_EQ("is even", Describe(m2
));
523 const Matcher
<char> not_m2
= Not(m2
);
524 EXPECT_EQ("is odd", Describe(not_m2
));
526 EXPECT_EQ("% 2 == 0", Explain(m2
, '\x42'));
529 // Tests that MatcherCast<T>(m) works when m is a polymorphic matcher.
530 TEST(MatcherCastTest
, FromPolymorphicMatcher
) {
531 Matcher
<int> m
= MatcherCast
<int>(Eq(5));
532 EXPECT_TRUE(m
.Matches(5));
533 EXPECT_FALSE(m
.Matches(6));
536 // For testing casting matchers between compatible types.
539 // An int can be statically (although not implicitly) cast to a
541 explicit IntValue(int a_value
) : value_(a_value
) {}
543 int value() const { return value_
; }
548 // For testing casting matchers between compatible types.
549 bool IsPositiveIntValue(const IntValue
& foo
) {
550 return foo
.value() > 0;
553 // Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T
554 // can be statically converted to U.
555 TEST(MatcherCastTest
, FromCompatibleType
) {
556 Matcher
<double> m1
= Eq(2.0);
557 Matcher
<int> m2
= MatcherCast
<int>(m1
);
558 EXPECT_TRUE(m2
.Matches(2));
559 EXPECT_FALSE(m2
.Matches(3));
561 Matcher
<IntValue
> m3
= Truly(IsPositiveIntValue
);
562 Matcher
<int> m4
= MatcherCast
<int>(m3
);
563 // In the following, the arguments 1 and 0 are statically converted
564 // to IntValue objects, and then tested by the IsPositiveIntValue()
566 EXPECT_TRUE(m4
.Matches(1));
567 EXPECT_FALSE(m4
.Matches(0));
570 // Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
571 TEST(MatcherCastTest
, FromConstReferenceToNonReference
) {
572 Matcher
<const int&> m1
= Eq(0);
573 Matcher
<int> m2
= MatcherCast
<int>(m1
);
574 EXPECT_TRUE(m2
.Matches(0));
575 EXPECT_FALSE(m2
.Matches(1));
578 // Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
579 TEST(MatcherCastTest
, FromReferenceToNonReference
) {
580 Matcher
<int&> m1
= Eq(0);
581 Matcher
<int> m2
= MatcherCast
<int>(m1
);
582 EXPECT_TRUE(m2
.Matches(0));
583 EXPECT_FALSE(m2
.Matches(1));
586 // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
587 TEST(MatcherCastTest
, FromNonReferenceToConstReference
) {
588 Matcher
<int> m1
= Eq(0);
589 Matcher
<const int&> m2
= MatcherCast
<const int&>(m1
);
590 EXPECT_TRUE(m2
.Matches(0));
591 EXPECT_FALSE(m2
.Matches(1));
594 // Tests that MatcherCast<T&>(m) works when m is a Matcher<T>.
595 TEST(MatcherCastTest
, FromNonReferenceToReference
) {
596 Matcher
<int> m1
= Eq(0);
597 Matcher
<int&> m2
= MatcherCast
<int&>(m1
);
599 EXPECT_TRUE(m2
.Matches(n
));
601 EXPECT_FALSE(m2
.Matches(n
));
604 // Tests that MatcherCast<T>(m) works when m is a Matcher<T>.
605 TEST(MatcherCastTest
, FromSameType
) {
606 Matcher
<int> m1
= Eq(0);
607 Matcher
<int> m2
= MatcherCast
<int>(m1
);
608 EXPECT_TRUE(m2
.Matches(0));
609 EXPECT_FALSE(m2
.Matches(1));
612 // Implicitly convertible from any type.
613 struct ConvertibleFromAny
{
614 ConvertibleFromAny(int a_value
) : value(a_value
) {}
615 template <typename T
>
616 ConvertibleFromAny(const T
& /*a_value*/) : value(-1) {
617 ADD_FAILURE() << "Conversion constructor called";
622 bool operator==(const ConvertibleFromAny
& a
, const ConvertibleFromAny
& b
) {
623 return a
.value
== b
.value
;
626 ostream
& operator<<(ostream
& os
, const ConvertibleFromAny
& a
) {
627 return os
<< a
.value
;
630 TEST(MatcherCastTest
, ConversionConstructorIsUsed
) {
631 Matcher
<ConvertibleFromAny
> m
= MatcherCast
<ConvertibleFromAny
>(1);
632 EXPECT_TRUE(m
.Matches(ConvertibleFromAny(1)));
633 EXPECT_FALSE(m
.Matches(ConvertibleFromAny(2)));
636 TEST(MatcherCastTest
, FromConvertibleFromAny
) {
637 Matcher
<ConvertibleFromAny
> m
=
638 MatcherCast
<ConvertibleFromAny
>(Eq(ConvertibleFromAny(1)));
639 EXPECT_TRUE(m
.Matches(ConvertibleFromAny(1)));
640 EXPECT_FALSE(m
.Matches(ConvertibleFromAny(2)));
643 struct IntReferenceWrapper
{
644 IntReferenceWrapper(const int& a_value
) : value(&a_value
) {}
648 bool operator==(const IntReferenceWrapper
& a
, const IntReferenceWrapper
& b
) {
649 return a
.value
== b
.value
;
652 TEST(MatcherCastTest
, ValueIsNotCopied
) {
654 Matcher
<IntReferenceWrapper
> m
= MatcherCast
<IntReferenceWrapper
>(n
);
655 // Verify that the matcher holds a reference to n, not to its temporary copy.
656 EXPECT_TRUE(m
.Matches(n
));
664 GTEST_DISALLOW_COPY_AND_ASSIGN_(Base
);
667 class Derived
: public Base
{
669 Derived() : Base() {}
673 class OtherDerived
: public Base
{};
675 // Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher.
676 TEST(SafeMatcherCastTest
, FromPolymorphicMatcher
) {
677 Matcher
<char> m2
= SafeMatcherCast
<char>(Eq(32));
678 EXPECT_TRUE(m2
.Matches(' '));
679 EXPECT_FALSE(m2
.Matches('\n'));
682 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where
683 // T and U are arithmetic types and T can be losslessly converted to
685 TEST(SafeMatcherCastTest
, FromLosslesslyConvertibleArithmeticType
) {
686 Matcher
<double> m1
= DoubleEq(1.0);
687 Matcher
<float> m2
= SafeMatcherCast
<float>(m1
);
688 EXPECT_TRUE(m2
.Matches(1.0f
));
689 EXPECT_FALSE(m2
.Matches(2.0f
));
691 Matcher
<char> m3
= SafeMatcherCast
<char>(TypedEq
<int>('a'));
692 EXPECT_TRUE(m3
.Matches('a'));
693 EXPECT_FALSE(m3
.Matches('b'));
696 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U
697 // are pointers or references to a derived and a base class, correspondingly.
698 TEST(SafeMatcherCastTest
, FromBaseClass
) {
700 Matcher
<Base
*> m1
= Eq(&d
);
701 Matcher
<Derived
*> m2
= SafeMatcherCast
<Derived
*>(m1
);
702 EXPECT_TRUE(m2
.Matches(&d
));
703 EXPECT_FALSE(m2
.Matches(&d2
));
705 Matcher
<Base
&> m3
= Ref(d
);
706 Matcher
<Derived
&> m4
= SafeMatcherCast
<Derived
&>(m3
);
707 EXPECT_TRUE(m4
.Matches(d
));
708 EXPECT_FALSE(m4
.Matches(d2
));
711 // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
712 TEST(SafeMatcherCastTest
, FromConstReferenceToReference
) {
714 Matcher
<const int&> m1
= Ref(n
);
715 Matcher
<int&> m2
= SafeMatcherCast
<int&>(m1
);
717 EXPECT_TRUE(m2
.Matches(n
));
718 EXPECT_FALSE(m2
.Matches(n1
));
721 // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
722 TEST(SafeMatcherCastTest
, FromNonReferenceToConstReference
) {
723 Matcher
<int> m1
= Eq(0);
724 Matcher
<const int&> m2
= SafeMatcherCast
<const int&>(m1
);
725 EXPECT_TRUE(m2
.Matches(0));
726 EXPECT_FALSE(m2
.Matches(1));
729 // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
730 TEST(SafeMatcherCastTest
, FromNonReferenceToReference
) {
731 Matcher
<int> m1
= Eq(0);
732 Matcher
<int&> m2
= SafeMatcherCast
<int&>(m1
);
734 EXPECT_TRUE(m2
.Matches(n
));
736 EXPECT_FALSE(m2
.Matches(n
));
739 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>.
740 TEST(SafeMatcherCastTest
, FromSameType
) {
741 Matcher
<int> m1
= Eq(0);
742 Matcher
<int> m2
= SafeMatcherCast
<int>(m1
);
743 EXPECT_TRUE(m2
.Matches(0));
744 EXPECT_FALSE(m2
.Matches(1));
747 TEST(SafeMatcherCastTest
, ConversionConstructorIsUsed
) {
748 Matcher
<ConvertibleFromAny
> m
= SafeMatcherCast
<ConvertibleFromAny
>(1);
749 EXPECT_TRUE(m
.Matches(ConvertibleFromAny(1)));
750 EXPECT_FALSE(m
.Matches(ConvertibleFromAny(2)));
753 TEST(SafeMatcherCastTest
, FromConvertibleFromAny
) {
754 Matcher
<ConvertibleFromAny
> m
=
755 SafeMatcherCast
<ConvertibleFromAny
>(Eq(ConvertibleFromAny(1)));
756 EXPECT_TRUE(m
.Matches(ConvertibleFromAny(1)));
757 EXPECT_FALSE(m
.Matches(ConvertibleFromAny(2)));
760 TEST(SafeMatcherCastTest
, ValueIsNotCopied
) {
762 Matcher
<IntReferenceWrapper
> m
= SafeMatcherCast
<IntReferenceWrapper
>(n
);
763 // Verify that the matcher holds a reference to n, not to its temporary copy.
764 EXPECT_TRUE(m
.Matches(n
));
767 TEST(ExpectThat
, TakesLiterals
) {
769 EXPECT_THAT(1.0, 1.0);
770 EXPECT_THAT(string(), "");
773 TEST(ExpectThat
, TakesFunctions
) {
775 static void Func() {}
777 void (*func
)() = Helper::Func
;
778 EXPECT_THAT(func
, Helper::Func
);
779 EXPECT_THAT(func
, &Helper::Func
);
782 // Tests that A<T>() matches any value of type T.
783 TEST(ATest
, MatchesAnyValue
) {
784 // Tests a matcher for a value type.
785 Matcher
<double> m1
= A
<double>();
786 EXPECT_TRUE(m1
.Matches(91.43));
787 EXPECT_TRUE(m1
.Matches(-15.32));
789 // Tests a matcher for a reference type.
792 Matcher
<int&> m2
= A
<int&>();
793 EXPECT_TRUE(m2
.Matches(a
));
794 EXPECT_TRUE(m2
.Matches(b
));
797 TEST(ATest
, WorksForDerivedClass
) {
800 EXPECT_THAT(&base
, A
<Base
*>());
801 // This shouldn't compile: EXPECT_THAT(&base, A<Derived*>());
802 EXPECT_THAT(&derived
, A
<Base
*>());
803 EXPECT_THAT(&derived
, A
<Derived
*>());
806 // Tests that A<T>() describes itself properly.
807 TEST(ATest
, CanDescribeSelf
) {
808 EXPECT_EQ("is anything", Describe(A
<bool>()));
811 // Tests that An<T>() matches any value of type T.
812 TEST(AnTest
, MatchesAnyValue
) {
813 // Tests a matcher for a value type.
814 Matcher
<int> m1
= An
<int>();
815 EXPECT_TRUE(m1
.Matches(9143));
816 EXPECT_TRUE(m1
.Matches(-1532));
818 // Tests a matcher for a reference type.
821 Matcher
<int&> m2
= An
<int&>();
822 EXPECT_TRUE(m2
.Matches(a
));
823 EXPECT_TRUE(m2
.Matches(b
));
826 // Tests that An<T>() describes itself properly.
827 TEST(AnTest
, CanDescribeSelf
) {
828 EXPECT_EQ("is anything", Describe(An
<int>()));
831 // Tests that _ can be used as a matcher for any type and matches any
832 // value of that type.
833 TEST(UnderscoreTest
, MatchesAnyValue
) {
834 // Uses _ as a matcher for a value type.
836 EXPECT_TRUE(m1
.Matches(123));
837 EXPECT_TRUE(m1
.Matches(-242));
839 // Uses _ as a matcher for a reference type.
842 Matcher
<const bool&> m2
= _
;
843 EXPECT_TRUE(m2
.Matches(a
));
844 EXPECT_TRUE(m2
.Matches(b
));
847 // Tests that _ describes itself properly.
848 TEST(UnderscoreTest
, CanDescribeSelf
) {
850 EXPECT_EQ("is anything", Describe(m
));
853 // Tests that Eq(x) matches any value equal to x.
854 TEST(EqTest
, MatchesEqualValue
) {
855 // 2 C-strings with same content but different addresses.
856 const char a1
[] = "hi";
857 const char a2
[] = "hi";
859 Matcher
<const char*> m1
= Eq(a1
);
860 EXPECT_TRUE(m1
.Matches(a1
));
861 EXPECT_FALSE(m1
.Matches(a2
));
864 // Tests that Eq(v) describes itself properly.
868 Unprintable() : c_('a') {}
870 bool operator==(const Unprintable
& /* rhs */) { return true; }
875 TEST(EqTest
, CanDescribeSelf
) {
876 Matcher
<Unprintable
> m
= Eq(Unprintable());
877 EXPECT_EQ("is equal to 1-byte object <61>", Describe(m
));
880 // Tests that Eq(v) can be used to match any type that supports
881 // comparing with type T, where T is v's type.
882 TEST(EqTest
, IsPolymorphic
) {
883 Matcher
<int> m1
= Eq(1);
884 EXPECT_TRUE(m1
.Matches(1));
885 EXPECT_FALSE(m1
.Matches(2));
887 Matcher
<char> m2
= Eq(1);
888 EXPECT_TRUE(m2
.Matches('\1'));
889 EXPECT_FALSE(m2
.Matches('a'));
892 // Tests that TypedEq<T>(v) matches values of type T that's equal to v.
893 TEST(TypedEqTest
, ChecksEqualityForGivenType
) {
894 Matcher
<char> m1
= TypedEq
<char>('a');
895 EXPECT_TRUE(m1
.Matches('a'));
896 EXPECT_FALSE(m1
.Matches('b'));
898 Matcher
<int> m2
= TypedEq
<int>(6);
899 EXPECT_TRUE(m2
.Matches(6));
900 EXPECT_FALSE(m2
.Matches(7));
903 // Tests that TypedEq(v) describes itself properly.
904 TEST(TypedEqTest
, CanDescribeSelf
) {
905 EXPECT_EQ("is equal to 2", Describe(TypedEq
<int>(2)));
908 // Tests that TypedEq<T>(v) has type Matcher<T>.
910 // Type<T>::IsTypeOf(v) compiles iff the type of value v is T, where T
911 // is a "bare" type (i.e. not in the form of const U or U&). If v's
912 // type is not T, the compiler will generate a message about
913 // "undefined referece".
914 template <typename T
>
916 static bool IsTypeOf(const T
& /* v */) { return true; }
918 template <typename T2
>
919 static void IsTypeOf(T2 v
);
922 TEST(TypedEqTest
, HasSpecifiedType
) {
923 // Verfies that the type of TypedEq<T>(v) is Matcher<T>.
924 Type
<Matcher
<int> >::IsTypeOf(TypedEq
<int>(5));
925 Type
<Matcher
<double> >::IsTypeOf(TypedEq
<double>(5));
928 // Tests that Ge(v) matches anything >= v.
929 TEST(GeTest
, ImplementsGreaterThanOrEqual
) {
930 Matcher
<int> m1
= Ge(0);
931 EXPECT_TRUE(m1
.Matches(1));
932 EXPECT_TRUE(m1
.Matches(0));
933 EXPECT_FALSE(m1
.Matches(-1));
936 // Tests that Ge(v) describes itself properly.
937 TEST(GeTest
, CanDescribeSelf
) {
938 Matcher
<int> m
= Ge(5);
939 EXPECT_EQ("is >= 5", Describe(m
));
942 // Tests that Gt(v) matches anything > v.
943 TEST(GtTest
, ImplementsGreaterThan
) {
944 Matcher
<double> m1
= Gt(0);
945 EXPECT_TRUE(m1
.Matches(1.0));
946 EXPECT_FALSE(m1
.Matches(0.0));
947 EXPECT_FALSE(m1
.Matches(-1.0));
950 // Tests that Gt(v) describes itself properly.
951 TEST(GtTest
, CanDescribeSelf
) {
952 Matcher
<int> m
= Gt(5);
953 EXPECT_EQ("is > 5", Describe(m
));
956 // Tests that Le(v) matches anything <= v.
957 TEST(LeTest
, ImplementsLessThanOrEqual
) {
958 Matcher
<char> m1
= Le('b');
959 EXPECT_TRUE(m1
.Matches('a'));
960 EXPECT_TRUE(m1
.Matches('b'));
961 EXPECT_FALSE(m1
.Matches('c'));
964 // Tests that Le(v) describes itself properly.
965 TEST(LeTest
, CanDescribeSelf
) {
966 Matcher
<int> m
= Le(5);
967 EXPECT_EQ("is <= 5", Describe(m
));
970 // Tests that Lt(v) matches anything < v.
971 TEST(LtTest
, ImplementsLessThan
) {
972 Matcher
<const string
&> m1
= Lt("Hello");
973 EXPECT_TRUE(m1
.Matches("Abc"));
974 EXPECT_FALSE(m1
.Matches("Hello"));
975 EXPECT_FALSE(m1
.Matches("Hello, world!"));
978 // Tests that Lt(v) describes itself properly.
979 TEST(LtTest
, CanDescribeSelf
) {
980 Matcher
<int> m
= Lt(5);
981 EXPECT_EQ("is < 5", Describe(m
));
984 // Tests that Ne(v) matches anything != v.
985 TEST(NeTest
, ImplementsNotEqual
) {
986 Matcher
<int> m1
= Ne(0);
987 EXPECT_TRUE(m1
.Matches(1));
988 EXPECT_TRUE(m1
.Matches(-1));
989 EXPECT_FALSE(m1
.Matches(0));
992 // Tests that Ne(v) describes itself properly.
993 TEST(NeTest
, CanDescribeSelf
) {
994 Matcher
<int> m
= Ne(5);
995 EXPECT_EQ("isn't equal to 5", Describe(m
));
998 // Tests that IsNull() matches any NULL pointer of any type.
999 TEST(IsNullTest
, MatchesNullPointer
) {
1000 Matcher
<int*> m1
= IsNull();
1003 EXPECT_TRUE(m1
.Matches(p1
));
1004 EXPECT_FALSE(m1
.Matches(&n
));
1006 Matcher
<const char*> m2
= IsNull();
1007 const char* p2
= NULL
;
1008 EXPECT_TRUE(m2
.Matches(p2
));
1009 EXPECT_FALSE(m2
.Matches("hi"));
1011 #if !GTEST_OS_SYMBIAN
1012 // Nokia's Symbian compiler generates:
1013 // gmock-matchers.h: ambiguous access to overloaded function
1014 // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(void *)'
1015 // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(const testing::
1016 // MatcherInterface<void *> *)'
1017 // gmock-matchers.h: (point of instantiation: 'testing::
1018 // gmock_matchers_test::IsNullTest_MatchesNullPointer_Test::TestBody()')
1019 // gmock-matchers.h: (instantiating: 'testing::PolymorphicMatc
1020 Matcher
<void*> m3
= IsNull();
1022 EXPECT_TRUE(m3
.Matches(p3
));
1023 EXPECT_FALSE(m3
.Matches(reinterpret_cast<void*>(0xbeef)));
1027 TEST(IsNullTest
, LinkedPtr
) {
1028 const Matcher
<linked_ptr
<int> > m
= IsNull();
1029 const linked_ptr
<int> null_p
;
1030 const linked_ptr
<int> non_null_p(new int);
1032 EXPECT_TRUE(m
.Matches(null_p
));
1033 EXPECT_FALSE(m
.Matches(non_null_p
));
1036 TEST(IsNullTest
, ReferenceToConstLinkedPtr
) {
1037 const Matcher
<const linked_ptr
<double>&> m
= IsNull();
1038 const linked_ptr
<double> null_p
;
1039 const linked_ptr
<double> non_null_p(new double);
1041 EXPECT_TRUE(m
.Matches(null_p
));
1042 EXPECT_FALSE(m
.Matches(non_null_p
));
1045 #if GTEST_HAS_STD_FUNCTION_
1046 TEST(IsNullTest
, StdFunction
) {
1047 const Matcher
<std::function
<void()>> m
= IsNull();
1049 EXPECT_TRUE(m
.Matches(std::function
<void()>()));
1050 EXPECT_FALSE(m
.Matches([]{}));
1052 #endif // GTEST_HAS_STD_FUNCTION_
1054 // Tests that IsNull() describes itself properly.
1055 TEST(IsNullTest
, CanDescribeSelf
) {
1056 Matcher
<int*> m
= IsNull();
1057 EXPECT_EQ("is NULL", Describe(m
));
1058 EXPECT_EQ("isn't NULL", DescribeNegation(m
));
1061 // Tests that NotNull() matches any non-NULL pointer of any type.
1062 TEST(NotNullTest
, MatchesNonNullPointer
) {
1063 Matcher
<int*> m1
= NotNull();
1066 EXPECT_FALSE(m1
.Matches(p1
));
1067 EXPECT_TRUE(m1
.Matches(&n
));
1069 Matcher
<const char*> m2
= NotNull();
1070 const char* p2
= NULL
;
1071 EXPECT_FALSE(m2
.Matches(p2
));
1072 EXPECT_TRUE(m2
.Matches("hi"));
1075 TEST(NotNullTest
, LinkedPtr
) {
1076 const Matcher
<linked_ptr
<int> > m
= NotNull();
1077 const linked_ptr
<int> null_p
;
1078 const linked_ptr
<int> non_null_p(new int);
1080 EXPECT_FALSE(m
.Matches(null_p
));
1081 EXPECT_TRUE(m
.Matches(non_null_p
));
1084 TEST(NotNullTest
, ReferenceToConstLinkedPtr
) {
1085 const Matcher
<const linked_ptr
<double>&> m
= NotNull();
1086 const linked_ptr
<double> null_p
;
1087 const linked_ptr
<double> non_null_p(new double);
1089 EXPECT_FALSE(m
.Matches(null_p
));
1090 EXPECT_TRUE(m
.Matches(non_null_p
));
1093 #if GTEST_HAS_STD_FUNCTION_
1094 TEST(NotNullTest
, StdFunction
) {
1095 const Matcher
<std::function
<void()>> m
= NotNull();
1097 EXPECT_TRUE(m
.Matches([]{}));
1098 EXPECT_FALSE(m
.Matches(std::function
<void()>()));
1100 #endif // GTEST_HAS_STD_FUNCTION_
1102 // Tests that NotNull() describes itself properly.
1103 TEST(NotNullTest
, CanDescribeSelf
) {
1104 Matcher
<int*> m
= NotNull();
1105 EXPECT_EQ("isn't NULL", Describe(m
));
1108 // Tests that Ref(variable) matches an argument that references
1110 TEST(RefTest
, MatchesSameVariable
) {
1113 Matcher
<int&> m
= Ref(a
);
1114 EXPECT_TRUE(m
.Matches(a
));
1115 EXPECT_FALSE(m
.Matches(b
));
1118 // Tests that Ref(variable) describes itself properly.
1119 TEST(RefTest
, CanDescribeSelf
) {
1121 Matcher
<int&> m
= Ref(n
);
1123 ss
<< "references the variable @" << &n
<< " 5";
1124 EXPECT_EQ(string(ss
.str()), Describe(m
));
1127 // Test that Ref(non_const_varialbe) can be used as a matcher for a
1129 TEST(RefTest
, CanBeUsedAsMatcherForConstReference
) {
1132 Matcher
<const int&> m
= Ref(a
);
1133 EXPECT_TRUE(m
.Matches(a
));
1134 EXPECT_FALSE(m
.Matches(b
));
1137 // Tests that Ref(variable) is covariant, i.e. Ref(derived) can be
1138 // used wherever Ref(base) can be used (Ref(derived) is a sub-type
1139 // of Ref(base), but not vice versa.
1141 TEST(RefTest
, IsCovariant
) {
1144 Matcher
<const Base
&> m1
= Ref(base
);
1145 EXPECT_TRUE(m1
.Matches(base
));
1146 EXPECT_FALSE(m1
.Matches(base2
));
1147 EXPECT_FALSE(m1
.Matches(derived
));
1150 EXPECT_TRUE(m1
.Matches(derived
));
1151 EXPECT_FALSE(m1
.Matches(base
));
1152 EXPECT_FALSE(m1
.Matches(base2
));
1155 TEST(RefTest
, ExplainsResult
) {
1157 EXPECT_THAT(Explain(Matcher
<const int&>(Ref(n
)), n
),
1158 StartsWith("which is located @"));
1161 EXPECT_THAT(Explain(Matcher
<const int&>(Ref(n
)), m
),
1162 StartsWith("which is located @"));
1165 // Tests string comparison matchers.
1167 TEST(StrEqTest
, MatchesEqualString
) {
1168 Matcher
<const char*> m
= StrEq(string("Hello"));
1169 EXPECT_TRUE(m
.Matches("Hello"));
1170 EXPECT_FALSE(m
.Matches("hello"));
1171 EXPECT_FALSE(m
.Matches(NULL
));
1173 Matcher
<const string
&> m2
= StrEq("Hello");
1174 EXPECT_TRUE(m2
.Matches("Hello"));
1175 EXPECT_FALSE(m2
.Matches("Hi"));
1178 TEST(StrEqTest
, CanDescribeSelf
) {
1179 Matcher
<string
> m
= StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
1180 EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"",
1183 string
str("01204500800");
1185 Matcher
<string
> m2
= StrEq(str
);
1186 EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2
));
1187 str
[0] = str
[6] = str
[7] = str
[9] = str
[10] = '\0';
1188 Matcher
<string
> m3
= StrEq(str
);
1189 EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3
));
1192 TEST(StrNeTest
, MatchesUnequalString
) {
1193 Matcher
<const char*> m
= StrNe("Hello");
1194 EXPECT_TRUE(m
.Matches(""));
1195 EXPECT_TRUE(m
.Matches(NULL
));
1196 EXPECT_FALSE(m
.Matches("Hello"));
1198 Matcher
<string
> m2
= StrNe(string("Hello"));
1199 EXPECT_TRUE(m2
.Matches("hello"));
1200 EXPECT_FALSE(m2
.Matches("Hello"));
1203 TEST(StrNeTest
, CanDescribeSelf
) {
1204 Matcher
<const char*> m
= StrNe("Hi");
1205 EXPECT_EQ("isn't equal to \"Hi\"", Describe(m
));
1208 TEST(StrCaseEqTest
, MatchesEqualStringIgnoringCase
) {
1209 Matcher
<const char*> m
= StrCaseEq(string("Hello"));
1210 EXPECT_TRUE(m
.Matches("Hello"));
1211 EXPECT_TRUE(m
.Matches("hello"));
1212 EXPECT_FALSE(m
.Matches("Hi"));
1213 EXPECT_FALSE(m
.Matches(NULL
));
1215 Matcher
<const string
&> m2
= StrCaseEq("Hello");
1216 EXPECT_TRUE(m2
.Matches("hello"));
1217 EXPECT_FALSE(m2
.Matches("Hi"));
1220 TEST(StrCaseEqTest
, MatchesEqualStringWith0IgnoringCase
) {
1221 string
str1("oabocdooeoo");
1222 string
str2("OABOCDOOEOO");
1223 Matcher
<const string
&> m0
= StrCaseEq(str1
);
1224 EXPECT_FALSE(m0
.Matches(str2
+ string(1, '\0')));
1226 str1
[3] = str2
[3] = '\0';
1227 Matcher
<const string
&> m1
= StrCaseEq(str1
);
1228 EXPECT_TRUE(m1
.Matches(str2
));
1230 str1
[0] = str1
[6] = str1
[7] = str1
[10] = '\0';
1231 str2
[0] = str2
[6] = str2
[7] = str2
[10] = '\0';
1232 Matcher
<const string
&> m2
= StrCaseEq(str1
);
1233 str1
[9] = str2
[9] = '\0';
1234 EXPECT_FALSE(m2
.Matches(str2
));
1236 Matcher
<const string
&> m3
= StrCaseEq(str1
);
1237 EXPECT_TRUE(m3
.Matches(str2
));
1239 EXPECT_FALSE(m3
.Matches(str2
+ "x"));
1240 str2
.append(1, '\0');
1241 EXPECT_FALSE(m3
.Matches(str2
));
1242 EXPECT_FALSE(m3
.Matches(string(str2
, 0, 9)));
1245 TEST(StrCaseEqTest
, CanDescribeSelf
) {
1246 Matcher
<string
> m
= StrCaseEq("Hi");
1247 EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m
));
1250 TEST(StrCaseNeTest
, MatchesUnequalStringIgnoringCase
) {
1251 Matcher
<const char*> m
= StrCaseNe("Hello");
1252 EXPECT_TRUE(m
.Matches("Hi"));
1253 EXPECT_TRUE(m
.Matches(NULL
));
1254 EXPECT_FALSE(m
.Matches("Hello"));
1255 EXPECT_FALSE(m
.Matches("hello"));
1257 Matcher
<string
> m2
= StrCaseNe(string("Hello"));
1258 EXPECT_TRUE(m2
.Matches(""));
1259 EXPECT_FALSE(m2
.Matches("Hello"));
1262 TEST(StrCaseNeTest
, CanDescribeSelf
) {
1263 Matcher
<const char*> m
= StrCaseNe("Hi");
1264 EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m
));
1267 // Tests that HasSubstr() works for matching string-typed values.
1268 TEST(HasSubstrTest
, WorksForStringClasses
) {
1269 const Matcher
<string
> m1
= HasSubstr("foo");
1270 EXPECT_TRUE(m1
.Matches(string("I love food.")));
1271 EXPECT_FALSE(m1
.Matches(string("tofo")));
1273 const Matcher
<const std::string
&> m2
= HasSubstr("foo");
1274 EXPECT_TRUE(m2
.Matches(std::string("I love food.")));
1275 EXPECT_FALSE(m2
.Matches(std::string("tofo")));
1278 // Tests that HasSubstr() works for matching C-string-typed values.
1279 TEST(HasSubstrTest
, WorksForCStrings
) {
1280 const Matcher
<char*> m1
= HasSubstr("foo");
1281 EXPECT_TRUE(m1
.Matches(const_cast<char*>("I love food.")));
1282 EXPECT_FALSE(m1
.Matches(const_cast<char*>("tofo")));
1283 EXPECT_FALSE(m1
.Matches(NULL
));
1285 const Matcher
<const char*> m2
= HasSubstr("foo");
1286 EXPECT_TRUE(m2
.Matches("I love food."));
1287 EXPECT_FALSE(m2
.Matches("tofo"));
1288 EXPECT_FALSE(m2
.Matches(NULL
));
1291 // Tests that HasSubstr(s) describes itself properly.
1292 TEST(HasSubstrTest
, CanDescribeSelf
) {
1293 Matcher
<string
> m
= HasSubstr("foo\n\"");
1294 EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m
));
1297 TEST(KeyTest
, CanDescribeSelf
) {
1298 Matcher
<const pair
<std::string
, int>&> m
= Key("foo");
1299 EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m
));
1300 EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m
));
1303 TEST(KeyTest
, ExplainsResult
) {
1304 Matcher
<pair
<int, bool> > m
= Key(GreaterThan(10));
1305 EXPECT_EQ("whose first field is a value which is 5 less than 10",
1306 Explain(m
, make_pair(5, true)));
1307 EXPECT_EQ("whose first field is a value which is 5 more than 10",
1308 Explain(m
, make_pair(15, true)));
1311 TEST(KeyTest
, MatchesCorrectly
) {
1312 pair
<int, std::string
> p(25, "foo");
1313 EXPECT_THAT(p
, Key(25));
1314 EXPECT_THAT(p
, Not(Key(42)));
1315 EXPECT_THAT(p
, Key(Ge(20)));
1316 EXPECT_THAT(p
, Not(Key(Lt(25))));
1319 TEST(KeyTest
, SafelyCastsInnerMatcher
) {
1320 Matcher
<int> is_positive
= Gt(0);
1321 Matcher
<int> is_negative
= Lt(0);
1322 pair
<char, bool> p('a', true);
1323 EXPECT_THAT(p
, Key(is_positive
));
1324 EXPECT_THAT(p
, Not(Key(is_negative
)));
1327 TEST(KeyTest
, InsideContainsUsingMap
) {
1328 map
<int, char> container
;
1329 container
.insert(make_pair(1, 'a'));
1330 container
.insert(make_pair(2, 'b'));
1331 container
.insert(make_pair(4, 'c'));
1332 EXPECT_THAT(container
, Contains(Key(1)));
1333 EXPECT_THAT(container
, Not(Contains(Key(3))));
1336 TEST(KeyTest
, InsideContainsUsingMultimap
) {
1337 multimap
<int, char> container
;
1338 container
.insert(make_pair(1, 'a'));
1339 container
.insert(make_pair(2, 'b'));
1340 container
.insert(make_pair(4, 'c'));
1342 EXPECT_THAT(container
, Not(Contains(Key(25))));
1343 container
.insert(make_pair(25, 'd'));
1344 EXPECT_THAT(container
, Contains(Key(25)));
1345 container
.insert(make_pair(25, 'e'));
1346 EXPECT_THAT(container
, Contains(Key(25)));
1348 EXPECT_THAT(container
, Contains(Key(1)));
1349 EXPECT_THAT(container
, Not(Contains(Key(3))));
1352 TEST(PairTest
, Typing
) {
1353 // Test verifies the following type conversions can be compiled.
1354 Matcher
<const pair
<const char*, int>&> m1
= Pair("foo", 42);
1355 Matcher
<const pair
<const char*, int> > m2
= Pair("foo", 42);
1356 Matcher
<pair
<const char*, int> > m3
= Pair("foo", 42);
1358 Matcher
<pair
<int, const std::string
> > m4
= Pair(25, "42");
1359 Matcher
<pair
<const std::string
, int> > m5
= Pair("25", 42);
1362 TEST(PairTest
, CanDescribeSelf
) {
1363 Matcher
<const pair
<std::string
, int>&> m1
= Pair("foo", 42);
1364 EXPECT_EQ("has a first field that is equal to \"foo\""
1365 ", and has a second field that is equal to 42",
1367 EXPECT_EQ("has a first field that isn't equal to \"foo\""
1368 ", or has a second field that isn't equal to 42",
1369 DescribeNegation(m1
));
1370 // Double and triple negation (1 or 2 times not and description of negation).
1371 Matcher
<const pair
<int, int>&> m2
= Not(Pair(Not(13), 42));
1372 EXPECT_EQ("has a first field that isn't equal to 13"
1373 ", and has a second field that is equal to 42",
1374 DescribeNegation(m2
));
1377 TEST(PairTest
, CanExplainMatchResultTo
) {
1378 // If neither field matches, Pair() should explain about the first
1380 const Matcher
<pair
<int, int> > m
= Pair(GreaterThan(0), GreaterThan(0));
1381 EXPECT_EQ("whose first field does not match, which is 1 less than 0",
1382 Explain(m
, make_pair(-1, -2)));
1384 // If the first field matches but the second doesn't, Pair() should
1385 // explain about the second field.
1386 EXPECT_EQ("whose second field does not match, which is 2 less than 0",
1387 Explain(m
, make_pair(1, -2)));
1389 // If the first field doesn't match but the second does, Pair()
1390 // should explain about the first field.
1391 EXPECT_EQ("whose first field does not match, which is 1 less than 0",
1392 Explain(m
, make_pair(-1, 2)));
1394 // If both fields match, Pair() should explain about them both.
1395 EXPECT_EQ("whose both fields match, where the first field is a value "
1396 "which is 1 more than 0, and the second field is a value "
1397 "which is 2 more than 0",
1398 Explain(m
, make_pair(1, 2)));
1400 // If only the first match has an explanation, only this explanation should
1402 const Matcher
<pair
<int, int> > explain_first
= Pair(GreaterThan(0), 0);
1403 EXPECT_EQ("whose both fields match, where the first field is a value "
1404 "which is 1 more than 0",
1405 Explain(explain_first
, make_pair(1, 0)));
1407 // If only the second match has an explanation, only this explanation should
1409 const Matcher
<pair
<int, int> > explain_second
= Pair(0, GreaterThan(0));
1410 EXPECT_EQ("whose both fields match, where the second field is a value "
1411 "which is 1 more than 0",
1412 Explain(explain_second
, make_pair(0, 1)));
1415 TEST(PairTest
, MatchesCorrectly
) {
1416 pair
<int, std::string
> p(25, "foo");
1418 // Both fields match.
1419 EXPECT_THAT(p
, Pair(25, "foo"));
1420 EXPECT_THAT(p
, Pair(Ge(20), HasSubstr("o")));
1422 // 'first' doesnt' match, but 'second' matches.
1423 EXPECT_THAT(p
, Not(Pair(42, "foo")));
1424 EXPECT_THAT(p
, Not(Pair(Lt(25), "foo")));
1426 // 'first' matches, but 'second' doesn't match.
1427 EXPECT_THAT(p
, Not(Pair(25, "bar")));
1428 EXPECT_THAT(p
, Not(Pair(25, Not("foo"))));
1430 // Neither field matches.
1431 EXPECT_THAT(p
, Not(Pair(13, "bar")));
1432 EXPECT_THAT(p
, Not(Pair(Lt(13), HasSubstr("a"))));
1435 TEST(PairTest
, SafelyCastsInnerMatchers
) {
1436 Matcher
<int> is_positive
= Gt(0);
1437 Matcher
<int> is_negative
= Lt(0);
1438 pair
<char, bool> p('a', true);
1439 EXPECT_THAT(p
, Pair(is_positive
, _
));
1440 EXPECT_THAT(p
, Not(Pair(is_negative
, _
)));
1441 EXPECT_THAT(p
, Pair(_
, is_positive
));
1442 EXPECT_THAT(p
, Not(Pair(_
, is_negative
)));
1445 TEST(PairTest
, InsideContainsUsingMap
) {
1446 map
<int, char> container
;
1447 container
.insert(make_pair(1, 'a'));
1448 container
.insert(make_pair(2, 'b'));
1449 container
.insert(make_pair(4, 'c'));
1450 EXPECT_THAT(container
, Contains(Pair(1, 'a')));
1451 EXPECT_THAT(container
, Contains(Pair(1, _
)));
1452 EXPECT_THAT(container
, Contains(Pair(_
, 'a')));
1453 EXPECT_THAT(container
, Not(Contains(Pair(3, _
))));
1456 // Tests StartsWith(s).
1458 TEST(StartsWithTest
, MatchesStringWithGivenPrefix
) {
1459 const Matcher
<const char*> m1
= StartsWith(string(""));
1460 EXPECT_TRUE(m1
.Matches("Hi"));
1461 EXPECT_TRUE(m1
.Matches(""));
1462 EXPECT_FALSE(m1
.Matches(NULL
));
1464 const Matcher
<const string
&> m2
= StartsWith("Hi");
1465 EXPECT_TRUE(m2
.Matches("Hi"));
1466 EXPECT_TRUE(m2
.Matches("Hi Hi!"));
1467 EXPECT_TRUE(m2
.Matches("High"));
1468 EXPECT_FALSE(m2
.Matches("H"));
1469 EXPECT_FALSE(m2
.Matches(" Hi"));
1472 TEST(StartsWithTest
, CanDescribeSelf
) {
1473 Matcher
<const std::string
> m
= StartsWith("Hi");
1474 EXPECT_EQ("starts with \"Hi\"", Describe(m
));
1477 // Tests EndsWith(s).
1479 TEST(EndsWithTest
, MatchesStringWithGivenSuffix
) {
1480 const Matcher
<const char*> m1
= EndsWith("");
1481 EXPECT_TRUE(m1
.Matches("Hi"));
1482 EXPECT_TRUE(m1
.Matches(""));
1483 EXPECT_FALSE(m1
.Matches(NULL
));
1485 const Matcher
<const string
&> m2
= EndsWith(string("Hi"));
1486 EXPECT_TRUE(m2
.Matches("Hi"));
1487 EXPECT_TRUE(m2
.Matches("Wow Hi Hi"));
1488 EXPECT_TRUE(m2
.Matches("Super Hi"));
1489 EXPECT_FALSE(m2
.Matches("i"));
1490 EXPECT_FALSE(m2
.Matches("Hi "));
1493 TEST(EndsWithTest
, CanDescribeSelf
) {
1494 Matcher
<const std::string
> m
= EndsWith("Hi");
1495 EXPECT_EQ("ends with \"Hi\"", Describe(m
));
1498 // Tests MatchesRegex().
1500 TEST(MatchesRegexTest
, MatchesStringMatchingGivenRegex
) {
1501 const Matcher
<const char*> m1
= MatchesRegex("a.*z");
1502 EXPECT_TRUE(m1
.Matches("az"));
1503 EXPECT_TRUE(m1
.Matches("abcz"));
1504 EXPECT_FALSE(m1
.Matches(NULL
));
1506 const Matcher
<const string
&> m2
= MatchesRegex(new RE("a.*z"));
1507 EXPECT_TRUE(m2
.Matches("azbz"));
1508 EXPECT_FALSE(m2
.Matches("az1"));
1509 EXPECT_FALSE(m2
.Matches("1az"));
1512 TEST(MatchesRegexTest
, CanDescribeSelf
) {
1513 Matcher
<const std::string
> m1
= MatchesRegex(string("Hi.*"));
1514 EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1
));
1516 Matcher
<const char*> m2
= MatchesRegex(new RE("a.*"));
1517 EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2
));
1520 // Tests ContainsRegex().
1522 TEST(ContainsRegexTest
, MatchesStringContainingGivenRegex
) {
1523 const Matcher
<const char*> m1
= ContainsRegex(string("a.*z"));
1524 EXPECT_TRUE(m1
.Matches("az"));
1525 EXPECT_TRUE(m1
.Matches("0abcz1"));
1526 EXPECT_FALSE(m1
.Matches(NULL
));
1528 const Matcher
<const string
&> m2
= ContainsRegex(new RE("a.*z"));
1529 EXPECT_TRUE(m2
.Matches("azbz"));
1530 EXPECT_TRUE(m2
.Matches("az1"));
1531 EXPECT_FALSE(m2
.Matches("1a"));
1534 TEST(ContainsRegexTest
, CanDescribeSelf
) {
1535 Matcher
<const std::string
> m1
= ContainsRegex("Hi.*");
1536 EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1
));
1538 Matcher
<const char*> m2
= ContainsRegex(new RE("a.*"));
1539 EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2
));
1542 // Tests for wide strings.
1543 #if GTEST_HAS_STD_WSTRING
1544 TEST(StdWideStrEqTest
, MatchesEqual
) {
1545 Matcher
<const wchar_t*> m
= StrEq(::std::wstring(L
"Hello"));
1546 EXPECT_TRUE(m
.Matches(L
"Hello"));
1547 EXPECT_FALSE(m
.Matches(L
"hello"));
1548 EXPECT_FALSE(m
.Matches(NULL
));
1550 Matcher
<const ::std::wstring
&> m2
= StrEq(L
"Hello");
1551 EXPECT_TRUE(m2
.Matches(L
"Hello"));
1552 EXPECT_FALSE(m2
.Matches(L
"Hi"));
1554 Matcher
<const ::std::wstring
&> m3
= StrEq(L
"\xD3\x576\x8D3\xC74D");
1555 EXPECT_TRUE(m3
.Matches(L
"\xD3\x576\x8D3\xC74D"));
1556 EXPECT_FALSE(m3
.Matches(L
"\xD3\x576\x8D3\xC74E"));
1558 ::std::wstring
str(L
"01204500800");
1560 Matcher
<const ::std::wstring
&> m4
= StrEq(str
);
1561 EXPECT_TRUE(m4
.Matches(str
));
1562 str
[0] = str
[6] = str
[7] = str
[9] = str
[10] = L
'\0';
1563 Matcher
<const ::std::wstring
&> m5
= StrEq(str
);
1564 EXPECT_TRUE(m5
.Matches(str
));
1567 TEST(StdWideStrEqTest
, CanDescribeSelf
) {
1568 Matcher
< ::std::wstring
> m
= StrEq(L
"Hi-\'\"?\\\a\b\f\n\r\t\v");
1569 EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
1572 Matcher
< ::std::wstring
> m2
= StrEq(L
"\xD3\x576\x8D3\xC74D");
1573 EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"",
1576 ::std::wstring
str(L
"01204500800");
1578 Matcher
<const ::std::wstring
&> m4
= StrEq(str
);
1579 EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4
));
1580 str
[0] = str
[6] = str
[7] = str
[9] = str
[10] = L
'\0';
1581 Matcher
<const ::std::wstring
&> m5
= StrEq(str
);
1582 EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5
));
1585 TEST(StdWideStrNeTest
, MatchesUnequalString
) {
1586 Matcher
<const wchar_t*> m
= StrNe(L
"Hello");
1587 EXPECT_TRUE(m
.Matches(L
""));
1588 EXPECT_TRUE(m
.Matches(NULL
));
1589 EXPECT_FALSE(m
.Matches(L
"Hello"));
1591 Matcher
< ::std::wstring
> m2
= StrNe(::std::wstring(L
"Hello"));
1592 EXPECT_TRUE(m2
.Matches(L
"hello"));
1593 EXPECT_FALSE(m2
.Matches(L
"Hello"));
1596 TEST(StdWideStrNeTest
, CanDescribeSelf
) {
1597 Matcher
<const wchar_t*> m
= StrNe(L
"Hi");
1598 EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m
));
1601 TEST(StdWideStrCaseEqTest
, MatchesEqualStringIgnoringCase
) {
1602 Matcher
<const wchar_t*> m
= StrCaseEq(::std::wstring(L
"Hello"));
1603 EXPECT_TRUE(m
.Matches(L
"Hello"));
1604 EXPECT_TRUE(m
.Matches(L
"hello"));
1605 EXPECT_FALSE(m
.Matches(L
"Hi"));
1606 EXPECT_FALSE(m
.Matches(NULL
));
1608 Matcher
<const ::std::wstring
&> m2
= StrCaseEq(L
"Hello");
1609 EXPECT_TRUE(m2
.Matches(L
"hello"));
1610 EXPECT_FALSE(m2
.Matches(L
"Hi"));
1613 TEST(StdWideStrCaseEqTest
, MatchesEqualStringWith0IgnoringCase
) {
1614 ::std::wstring
str1(L
"oabocdooeoo");
1615 ::std::wstring
str2(L
"OABOCDOOEOO");
1616 Matcher
<const ::std::wstring
&> m0
= StrCaseEq(str1
);
1617 EXPECT_FALSE(m0
.Matches(str2
+ ::std::wstring(1, L
'\0')));
1619 str1
[3] = str2
[3] = L
'\0';
1620 Matcher
<const ::std::wstring
&> m1
= StrCaseEq(str1
);
1621 EXPECT_TRUE(m1
.Matches(str2
));
1623 str1
[0] = str1
[6] = str1
[7] = str1
[10] = L
'\0';
1624 str2
[0] = str2
[6] = str2
[7] = str2
[10] = L
'\0';
1625 Matcher
<const ::std::wstring
&> m2
= StrCaseEq(str1
);
1626 str1
[9] = str2
[9] = L
'\0';
1627 EXPECT_FALSE(m2
.Matches(str2
));
1629 Matcher
<const ::std::wstring
&> m3
= StrCaseEq(str1
);
1630 EXPECT_TRUE(m3
.Matches(str2
));
1632 EXPECT_FALSE(m3
.Matches(str2
+ L
"x"));
1633 str2
.append(1, L
'\0');
1634 EXPECT_FALSE(m3
.Matches(str2
));
1635 EXPECT_FALSE(m3
.Matches(::std::wstring(str2
, 0, 9)));
1638 TEST(StdWideStrCaseEqTest
, CanDescribeSelf
) {
1639 Matcher
< ::std::wstring
> m
= StrCaseEq(L
"Hi");
1640 EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m
));
1643 TEST(StdWideStrCaseNeTest
, MatchesUnequalStringIgnoringCase
) {
1644 Matcher
<const wchar_t*> m
= StrCaseNe(L
"Hello");
1645 EXPECT_TRUE(m
.Matches(L
"Hi"));
1646 EXPECT_TRUE(m
.Matches(NULL
));
1647 EXPECT_FALSE(m
.Matches(L
"Hello"));
1648 EXPECT_FALSE(m
.Matches(L
"hello"));
1650 Matcher
< ::std::wstring
> m2
= StrCaseNe(::std::wstring(L
"Hello"));
1651 EXPECT_TRUE(m2
.Matches(L
""));
1652 EXPECT_FALSE(m2
.Matches(L
"Hello"));
1655 TEST(StdWideStrCaseNeTest
, CanDescribeSelf
) {
1656 Matcher
<const wchar_t*> m
= StrCaseNe(L
"Hi");
1657 EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m
));
1660 // Tests that HasSubstr() works for matching wstring-typed values.
1661 TEST(StdWideHasSubstrTest
, WorksForStringClasses
) {
1662 const Matcher
< ::std::wstring
> m1
= HasSubstr(L
"foo");
1663 EXPECT_TRUE(m1
.Matches(::std::wstring(L
"I love food.")));
1664 EXPECT_FALSE(m1
.Matches(::std::wstring(L
"tofo")));
1666 const Matcher
<const ::std::wstring
&> m2
= HasSubstr(L
"foo");
1667 EXPECT_TRUE(m2
.Matches(::std::wstring(L
"I love food.")));
1668 EXPECT_FALSE(m2
.Matches(::std::wstring(L
"tofo")));
1671 // Tests that HasSubstr() works for matching C-wide-string-typed values.
1672 TEST(StdWideHasSubstrTest
, WorksForCStrings
) {
1673 const Matcher
<wchar_t*> m1
= HasSubstr(L
"foo");
1674 EXPECT_TRUE(m1
.Matches(const_cast<wchar_t*>(L
"I love food.")));
1675 EXPECT_FALSE(m1
.Matches(const_cast<wchar_t*>(L
"tofo")));
1676 EXPECT_FALSE(m1
.Matches(NULL
));
1678 const Matcher
<const wchar_t*> m2
= HasSubstr(L
"foo");
1679 EXPECT_TRUE(m2
.Matches(L
"I love food."));
1680 EXPECT_FALSE(m2
.Matches(L
"tofo"));
1681 EXPECT_FALSE(m2
.Matches(NULL
));
1684 // Tests that HasSubstr(s) describes itself properly.
1685 TEST(StdWideHasSubstrTest
, CanDescribeSelf
) {
1686 Matcher
< ::std::wstring
> m
= HasSubstr(L
"foo\n\"");
1687 EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m
));
1690 // Tests StartsWith(s).
1692 TEST(StdWideStartsWithTest
, MatchesStringWithGivenPrefix
) {
1693 const Matcher
<const wchar_t*> m1
= StartsWith(::std::wstring(L
""));
1694 EXPECT_TRUE(m1
.Matches(L
"Hi"));
1695 EXPECT_TRUE(m1
.Matches(L
""));
1696 EXPECT_FALSE(m1
.Matches(NULL
));
1698 const Matcher
<const ::std::wstring
&> m2
= StartsWith(L
"Hi");
1699 EXPECT_TRUE(m2
.Matches(L
"Hi"));
1700 EXPECT_TRUE(m2
.Matches(L
"Hi Hi!"));
1701 EXPECT_TRUE(m2
.Matches(L
"High"));
1702 EXPECT_FALSE(m2
.Matches(L
"H"));
1703 EXPECT_FALSE(m2
.Matches(L
" Hi"));
1706 TEST(StdWideStartsWithTest
, CanDescribeSelf
) {
1707 Matcher
<const ::std::wstring
> m
= StartsWith(L
"Hi");
1708 EXPECT_EQ("starts with L\"Hi\"", Describe(m
));
1711 // Tests EndsWith(s).
1713 TEST(StdWideEndsWithTest
, MatchesStringWithGivenSuffix
) {
1714 const Matcher
<const wchar_t*> m1
= EndsWith(L
"");
1715 EXPECT_TRUE(m1
.Matches(L
"Hi"));
1716 EXPECT_TRUE(m1
.Matches(L
""));
1717 EXPECT_FALSE(m1
.Matches(NULL
));
1719 const Matcher
<const ::std::wstring
&> m2
= EndsWith(::std::wstring(L
"Hi"));
1720 EXPECT_TRUE(m2
.Matches(L
"Hi"));
1721 EXPECT_TRUE(m2
.Matches(L
"Wow Hi Hi"));
1722 EXPECT_TRUE(m2
.Matches(L
"Super Hi"));
1723 EXPECT_FALSE(m2
.Matches(L
"i"));
1724 EXPECT_FALSE(m2
.Matches(L
"Hi "));
1727 TEST(StdWideEndsWithTest
, CanDescribeSelf
) {
1728 Matcher
<const ::std::wstring
> m
= EndsWith(L
"Hi");
1729 EXPECT_EQ("ends with L\"Hi\"", Describe(m
));
1732 #endif // GTEST_HAS_STD_WSTRING
1734 #if GTEST_HAS_GLOBAL_WSTRING
1735 TEST(GlobalWideStrEqTest
, MatchesEqual
) {
1736 Matcher
<const wchar_t*> m
= StrEq(::wstring(L
"Hello"));
1737 EXPECT_TRUE(m
.Matches(L
"Hello"));
1738 EXPECT_FALSE(m
.Matches(L
"hello"));
1739 EXPECT_FALSE(m
.Matches(NULL
));
1741 Matcher
<const ::wstring
&> m2
= StrEq(L
"Hello");
1742 EXPECT_TRUE(m2
.Matches(L
"Hello"));
1743 EXPECT_FALSE(m2
.Matches(L
"Hi"));
1745 Matcher
<const ::wstring
&> m3
= StrEq(L
"\xD3\x576\x8D3\xC74D");
1746 EXPECT_TRUE(m3
.Matches(L
"\xD3\x576\x8D3\xC74D"));
1747 EXPECT_FALSE(m3
.Matches(L
"\xD3\x576\x8D3\xC74E"));
1749 ::wstring
str(L
"01204500800");
1751 Matcher
<const ::wstring
&> m4
= StrEq(str
);
1752 EXPECT_TRUE(m4
.Matches(str
));
1753 str
[0] = str
[6] = str
[7] = str
[9] = str
[10] = L
'\0';
1754 Matcher
<const ::wstring
&> m5
= StrEq(str
);
1755 EXPECT_TRUE(m5
.Matches(str
));
1758 TEST(GlobalWideStrEqTest
, CanDescribeSelf
) {
1759 Matcher
< ::wstring
> m
= StrEq(L
"Hi-\'\"?\\\a\b\f\n\r\t\v");
1760 EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
1763 Matcher
< ::wstring
> m2
= StrEq(L
"\xD3\x576\x8D3\xC74D");
1764 EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"",
1767 ::wstring
str(L
"01204500800");
1769 Matcher
<const ::wstring
&> m4
= StrEq(str
);
1770 EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4
));
1771 str
[0] = str
[6] = str
[7] = str
[9] = str
[10] = L
'\0';
1772 Matcher
<const ::wstring
&> m5
= StrEq(str
);
1773 EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5
));
1776 TEST(GlobalWideStrNeTest
, MatchesUnequalString
) {
1777 Matcher
<const wchar_t*> m
= StrNe(L
"Hello");
1778 EXPECT_TRUE(m
.Matches(L
""));
1779 EXPECT_TRUE(m
.Matches(NULL
));
1780 EXPECT_FALSE(m
.Matches(L
"Hello"));
1782 Matcher
< ::wstring
> m2
= StrNe(::wstring(L
"Hello"));
1783 EXPECT_TRUE(m2
.Matches(L
"hello"));
1784 EXPECT_FALSE(m2
.Matches(L
"Hello"));
1787 TEST(GlobalWideStrNeTest
, CanDescribeSelf
) {
1788 Matcher
<const wchar_t*> m
= StrNe(L
"Hi");
1789 EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m
));
1792 TEST(GlobalWideStrCaseEqTest
, MatchesEqualStringIgnoringCase
) {
1793 Matcher
<const wchar_t*> m
= StrCaseEq(::wstring(L
"Hello"));
1794 EXPECT_TRUE(m
.Matches(L
"Hello"));
1795 EXPECT_TRUE(m
.Matches(L
"hello"));
1796 EXPECT_FALSE(m
.Matches(L
"Hi"));
1797 EXPECT_FALSE(m
.Matches(NULL
));
1799 Matcher
<const ::wstring
&> m2
= StrCaseEq(L
"Hello");
1800 EXPECT_TRUE(m2
.Matches(L
"hello"));
1801 EXPECT_FALSE(m2
.Matches(L
"Hi"));
1804 TEST(GlobalWideStrCaseEqTest
, MatchesEqualStringWith0IgnoringCase
) {
1805 ::wstring
str1(L
"oabocdooeoo");
1806 ::wstring
str2(L
"OABOCDOOEOO");
1807 Matcher
<const ::wstring
&> m0
= StrCaseEq(str1
);
1808 EXPECT_FALSE(m0
.Matches(str2
+ ::wstring(1, L
'\0')));
1810 str1
[3] = str2
[3] = L
'\0';
1811 Matcher
<const ::wstring
&> m1
= StrCaseEq(str1
);
1812 EXPECT_TRUE(m1
.Matches(str2
));
1814 str1
[0] = str1
[6] = str1
[7] = str1
[10] = L
'\0';
1815 str2
[0] = str2
[6] = str2
[7] = str2
[10] = L
'\0';
1816 Matcher
<const ::wstring
&> m2
= StrCaseEq(str1
);
1817 str1
[9] = str2
[9] = L
'\0';
1818 EXPECT_FALSE(m2
.Matches(str2
));
1820 Matcher
<const ::wstring
&> m3
= StrCaseEq(str1
);
1821 EXPECT_TRUE(m3
.Matches(str2
));
1823 EXPECT_FALSE(m3
.Matches(str2
+ L
"x"));
1824 str2
.append(1, L
'\0');
1825 EXPECT_FALSE(m3
.Matches(str2
));
1826 EXPECT_FALSE(m3
.Matches(::wstring(str2
, 0, 9)));
1829 TEST(GlobalWideStrCaseEqTest
, CanDescribeSelf
) {
1830 Matcher
< ::wstring
> m
= StrCaseEq(L
"Hi");
1831 EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m
));
1834 TEST(GlobalWideStrCaseNeTest
, MatchesUnequalStringIgnoringCase
) {
1835 Matcher
<const wchar_t*> m
= StrCaseNe(L
"Hello");
1836 EXPECT_TRUE(m
.Matches(L
"Hi"));
1837 EXPECT_TRUE(m
.Matches(NULL
));
1838 EXPECT_FALSE(m
.Matches(L
"Hello"));
1839 EXPECT_FALSE(m
.Matches(L
"hello"));
1841 Matcher
< ::wstring
> m2
= StrCaseNe(::wstring(L
"Hello"));
1842 EXPECT_TRUE(m2
.Matches(L
""));
1843 EXPECT_FALSE(m2
.Matches(L
"Hello"));
1846 TEST(GlobalWideStrCaseNeTest
, CanDescribeSelf
) {
1847 Matcher
<const wchar_t*> m
= StrCaseNe(L
"Hi");
1848 EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m
));
1851 // Tests that HasSubstr() works for matching wstring-typed values.
1852 TEST(GlobalWideHasSubstrTest
, WorksForStringClasses
) {
1853 const Matcher
< ::wstring
> m1
= HasSubstr(L
"foo");
1854 EXPECT_TRUE(m1
.Matches(::wstring(L
"I love food.")));
1855 EXPECT_FALSE(m1
.Matches(::wstring(L
"tofo")));
1857 const Matcher
<const ::wstring
&> m2
= HasSubstr(L
"foo");
1858 EXPECT_TRUE(m2
.Matches(::wstring(L
"I love food.")));
1859 EXPECT_FALSE(m2
.Matches(::wstring(L
"tofo")));
1862 // Tests that HasSubstr() works for matching C-wide-string-typed values.
1863 TEST(GlobalWideHasSubstrTest
, WorksForCStrings
) {
1864 const Matcher
<wchar_t*> m1
= HasSubstr(L
"foo");
1865 EXPECT_TRUE(m1
.Matches(const_cast<wchar_t*>(L
"I love food.")));
1866 EXPECT_FALSE(m1
.Matches(const_cast<wchar_t*>(L
"tofo")));
1867 EXPECT_FALSE(m1
.Matches(NULL
));
1869 const Matcher
<const wchar_t*> m2
= HasSubstr(L
"foo");
1870 EXPECT_TRUE(m2
.Matches(L
"I love food."));
1871 EXPECT_FALSE(m2
.Matches(L
"tofo"));
1872 EXPECT_FALSE(m2
.Matches(NULL
));
1875 // Tests that HasSubstr(s) describes itself properly.
1876 TEST(GlobalWideHasSubstrTest
, CanDescribeSelf
) {
1877 Matcher
< ::wstring
> m
= HasSubstr(L
"foo\n\"");
1878 EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m
));
1881 // Tests StartsWith(s).
1883 TEST(GlobalWideStartsWithTest
, MatchesStringWithGivenPrefix
) {
1884 const Matcher
<const wchar_t*> m1
= StartsWith(::wstring(L
""));
1885 EXPECT_TRUE(m1
.Matches(L
"Hi"));
1886 EXPECT_TRUE(m1
.Matches(L
""));
1887 EXPECT_FALSE(m1
.Matches(NULL
));
1889 const Matcher
<const ::wstring
&> m2
= StartsWith(L
"Hi");
1890 EXPECT_TRUE(m2
.Matches(L
"Hi"));
1891 EXPECT_TRUE(m2
.Matches(L
"Hi Hi!"));
1892 EXPECT_TRUE(m2
.Matches(L
"High"));
1893 EXPECT_FALSE(m2
.Matches(L
"H"));
1894 EXPECT_FALSE(m2
.Matches(L
" Hi"));
1897 TEST(GlobalWideStartsWithTest
, CanDescribeSelf
) {
1898 Matcher
<const ::wstring
> m
= StartsWith(L
"Hi");
1899 EXPECT_EQ("starts with L\"Hi\"", Describe(m
));
1902 // Tests EndsWith(s).
1904 TEST(GlobalWideEndsWithTest
, MatchesStringWithGivenSuffix
) {
1905 const Matcher
<const wchar_t*> m1
= EndsWith(L
"");
1906 EXPECT_TRUE(m1
.Matches(L
"Hi"));
1907 EXPECT_TRUE(m1
.Matches(L
""));
1908 EXPECT_FALSE(m1
.Matches(NULL
));
1910 const Matcher
<const ::wstring
&> m2
= EndsWith(::wstring(L
"Hi"));
1911 EXPECT_TRUE(m2
.Matches(L
"Hi"));
1912 EXPECT_TRUE(m2
.Matches(L
"Wow Hi Hi"));
1913 EXPECT_TRUE(m2
.Matches(L
"Super Hi"));
1914 EXPECT_FALSE(m2
.Matches(L
"i"));
1915 EXPECT_FALSE(m2
.Matches(L
"Hi "));
1918 TEST(GlobalWideEndsWithTest
, CanDescribeSelf
) {
1919 Matcher
<const ::wstring
> m
= EndsWith(L
"Hi");
1920 EXPECT_EQ("ends with L\"Hi\"", Describe(m
));
1923 #endif // GTEST_HAS_GLOBAL_WSTRING
1926 typedef ::testing::tuple
<long, int> Tuple2
; // NOLINT
1928 // Tests that Eq() matches a 2-tuple where the first field == the
1930 TEST(Eq2Test
, MatchesEqualArguments
) {
1931 Matcher
<const Tuple2
&> m
= Eq();
1932 EXPECT_TRUE(m
.Matches(Tuple2(5L, 5)));
1933 EXPECT_FALSE(m
.Matches(Tuple2(5L, 6)));
1936 // Tests that Eq() describes itself properly.
1937 TEST(Eq2Test
, CanDescribeSelf
) {
1938 Matcher
<const Tuple2
&> m
= Eq();
1939 EXPECT_EQ("are an equal pair", Describe(m
));
1942 // Tests that Ge() matches a 2-tuple where the first field >= the
1944 TEST(Ge2Test
, MatchesGreaterThanOrEqualArguments
) {
1945 Matcher
<const Tuple2
&> m
= Ge();
1946 EXPECT_TRUE(m
.Matches(Tuple2(5L, 4)));
1947 EXPECT_TRUE(m
.Matches(Tuple2(5L, 5)));
1948 EXPECT_FALSE(m
.Matches(Tuple2(5L, 6)));
1951 // Tests that Ge() describes itself properly.
1952 TEST(Ge2Test
, CanDescribeSelf
) {
1953 Matcher
<const Tuple2
&> m
= Ge();
1954 EXPECT_EQ("are a pair where the first >= the second", Describe(m
));
1957 // Tests that Gt() matches a 2-tuple where the first field > the
1959 TEST(Gt2Test
, MatchesGreaterThanArguments
) {
1960 Matcher
<const Tuple2
&> m
= Gt();
1961 EXPECT_TRUE(m
.Matches(Tuple2(5L, 4)));
1962 EXPECT_FALSE(m
.Matches(Tuple2(5L, 5)));
1963 EXPECT_FALSE(m
.Matches(Tuple2(5L, 6)));
1966 // Tests that Gt() describes itself properly.
1967 TEST(Gt2Test
, CanDescribeSelf
) {
1968 Matcher
<const Tuple2
&> m
= Gt();
1969 EXPECT_EQ("are a pair where the first > the second", Describe(m
));
1972 // Tests that Le() matches a 2-tuple where the first field <= the
1974 TEST(Le2Test
, MatchesLessThanOrEqualArguments
) {
1975 Matcher
<const Tuple2
&> m
= Le();
1976 EXPECT_TRUE(m
.Matches(Tuple2(5L, 6)));
1977 EXPECT_TRUE(m
.Matches(Tuple2(5L, 5)));
1978 EXPECT_FALSE(m
.Matches(Tuple2(5L, 4)));
1981 // Tests that Le() describes itself properly.
1982 TEST(Le2Test
, CanDescribeSelf
) {
1983 Matcher
<const Tuple2
&> m
= Le();
1984 EXPECT_EQ("are a pair where the first <= the second", Describe(m
));
1987 // Tests that Lt() matches a 2-tuple where the first field < the
1989 TEST(Lt2Test
, MatchesLessThanArguments
) {
1990 Matcher
<const Tuple2
&> m
= Lt();
1991 EXPECT_TRUE(m
.Matches(Tuple2(5L, 6)));
1992 EXPECT_FALSE(m
.Matches(Tuple2(5L, 5)));
1993 EXPECT_FALSE(m
.Matches(Tuple2(5L, 4)));
1996 // Tests that Lt() describes itself properly.
1997 TEST(Lt2Test
, CanDescribeSelf
) {
1998 Matcher
<const Tuple2
&> m
= Lt();
1999 EXPECT_EQ("are a pair where the first < the second", Describe(m
));
2002 // Tests that Ne() matches a 2-tuple where the first field != the
2004 TEST(Ne2Test
, MatchesUnequalArguments
) {
2005 Matcher
<const Tuple2
&> m
= Ne();
2006 EXPECT_TRUE(m
.Matches(Tuple2(5L, 6)));
2007 EXPECT_TRUE(m
.Matches(Tuple2(5L, 4)));
2008 EXPECT_FALSE(m
.Matches(Tuple2(5L, 5)));
2011 // Tests that Ne() describes itself properly.
2012 TEST(Ne2Test
, CanDescribeSelf
) {
2013 Matcher
<const Tuple2
&> m
= Ne();
2014 EXPECT_EQ("are an unequal pair", Describe(m
));
2017 // Tests that Not(m) matches any value that doesn't match m.
2018 TEST(NotTest
, NegatesMatcher
) {
2021 EXPECT_TRUE(m
.Matches(3));
2022 EXPECT_FALSE(m
.Matches(2));
2025 // Tests that Not(m) describes itself properly.
2026 TEST(NotTest
, CanDescribeSelf
) {
2027 Matcher
<int> m
= Not(Eq(5));
2028 EXPECT_EQ("isn't equal to 5", Describe(m
));
2031 // Tests that monomorphic matchers are safely cast by the Not matcher.
2032 TEST(NotTest
, NotMatcherSafelyCastsMonomorphicMatchers
) {
2033 // greater_than_5 is a monomorphic matcher.
2034 Matcher
<int> greater_than_5
= Gt(5);
2036 Matcher
<const int&> m
= Not(greater_than_5
);
2037 Matcher
<int&> m2
= Not(greater_than_5
);
2038 Matcher
<int&> m3
= Not(m
);
2041 // Helper to allow easy testing of AllOf matchers with num parameters.
2042 void AllOfMatches(int num
, const Matcher
<int>& m
) {
2043 SCOPED_TRACE(Describe(m
));
2044 EXPECT_TRUE(m
.Matches(0));
2045 for (int i
= 1; i
<= num
; ++i
) {
2046 EXPECT_FALSE(m
.Matches(i
));
2048 EXPECT_TRUE(m
.Matches(num
+ 1));
2051 // Tests that AllOf(m1, ..., mn) matches any value that matches all of
2052 // the given matchers.
2053 TEST(AllOfTest
, MatchesWhenAllMatch
) {
2055 m
= AllOf(Le(2), Ge(1));
2056 EXPECT_TRUE(m
.Matches(1));
2057 EXPECT_TRUE(m
.Matches(2));
2058 EXPECT_FALSE(m
.Matches(0));
2059 EXPECT_FALSE(m
.Matches(3));
2061 m
= AllOf(Gt(0), Ne(1), Ne(2));
2062 EXPECT_TRUE(m
.Matches(3));
2063 EXPECT_FALSE(m
.Matches(2));
2064 EXPECT_FALSE(m
.Matches(1));
2065 EXPECT_FALSE(m
.Matches(0));
2067 m
= AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
2068 EXPECT_TRUE(m
.Matches(4));
2069 EXPECT_FALSE(m
.Matches(3));
2070 EXPECT_FALSE(m
.Matches(2));
2071 EXPECT_FALSE(m
.Matches(1));
2072 EXPECT_FALSE(m
.Matches(0));
2074 m
= AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
2075 EXPECT_TRUE(m
.Matches(0));
2076 EXPECT_TRUE(m
.Matches(1));
2077 EXPECT_FALSE(m
.Matches(3));
2079 // The following tests for varying number of sub-matchers. Due to the way
2080 // the sub-matchers are handled it is enough to test every sub-matcher once
2081 // with sub-matchers using the same matcher type. Varying matcher types are
2082 // checked for above.
2083 AllOfMatches(2, AllOf(Ne(1), Ne(2)));
2084 AllOfMatches(3, AllOf(Ne(1), Ne(2), Ne(3)));
2085 AllOfMatches(4, AllOf(Ne(1), Ne(2), Ne(3), Ne(4)));
2086 AllOfMatches(5, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5)));
2087 AllOfMatches(6, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6)));
2088 AllOfMatches(7, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7)));
2089 AllOfMatches(8, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
2091 AllOfMatches(9, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
2093 AllOfMatches(10, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
2097 #if GTEST_LANG_CXX11
2098 // Tests the variadic version of the AllOfMatcher.
2099 TEST(AllOfTest
, VariadicMatchesWhenAllMatch
) {
2100 // Make sure AllOf is defined in the right namespace and does not depend on
2102 ::testing::AllOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
2103 Matcher
<int> m
= AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
2104 Ne(9), Ne(10), Ne(11));
2105 EXPECT_THAT(Describe(m
), EndsWith("and (isn't equal to 11))))))))))"));
2106 AllOfMatches(11, m
);
2107 AllOfMatches(50, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
2108 Ne(9), Ne(10), Ne(11), Ne(12), Ne(13), Ne(14), Ne(15),
2109 Ne(16), Ne(17), Ne(18), Ne(19), Ne(20), Ne(21), Ne(22),
2110 Ne(23), Ne(24), Ne(25), Ne(26), Ne(27), Ne(28), Ne(29),
2111 Ne(30), Ne(31), Ne(32), Ne(33), Ne(34), Ne(35), Ne(36),
2112 Ne(37), Ne(38), Ne(39), Ne(40), Ne(41), Ne(42), Ne(43),
2113 Ne(44), Ne(45), Ne(46), Ne(47), Ne(48), Ne(49),
2117 #endif // GTEST_LANG_CXX11
2119 // Tests that AllOf(m1, ..., mn) describes itself properly.
2120 TEST(AllOfTest
, CanDescribeSelf
) {
2122 m
= AllOf(Le(2), Ge(1));
2123 EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m
));
2125 m
= AllOf(Gt(0), Ne(1), Ne(2));
2126 EXPECT_EQ("(is > 0) and "
2127 "((isn't equal to 1) and "
2128 "(isn't equal to 2))",
2132 m
= AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
2133 EXPECT_EQ("((is > 0) and "
2134 "(isn't equal to 1)) and "
2135 "((isn't equal to 2) and "
2136 "(isn't equal to 3))",
2140 m
= AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
2141 EXPECT_EQ("((is >= 0) and "
2143 "((isn't equal to 3) and "
2144 "((isn't equal to 5) and "
2145 "(isn't equal to 7)))",
2149 // Tests that AllOf(m1, ..., mn) describes its negation properly.
2150 TEST(AllOfTest
, CanDescribeNegation
) {
2152 m
= AllOf(Le(2), Ge(1));
2153 EXPECT_EQ("(isn't <= 2) or "
2155 DescribeNegation(m
));
2157 m
= AllOf(Gt(0), Ne(1), Ne(2));
2158 EXPECT_EQ("(isn't > 0) or "
2159 "((is equal to 1) or "
2161 DescribeNegation(m
));
2164 m
= AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
2165 EXPECT_EQ("((isn't > 0) or "
2166 "(is equal to 1)) or "
2167 "((is equal to 2) or "
2169 DescribeNegation(m
));
2172 m
= AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
2173 EXPECT_EQ("((isn't >= 0) or "
2175 "((is equal to 3) or "
2176 "((is equal to 5) or "
2177 "(is equal to 7)))",
2178 DescribeNegation(m
));
2181 // Tests that monomorphic matchers are safely cast by the AllOf matcher.
2182 TEST(AllOfTest
, AllOfMatcherSafelyCastsMonomorphicMatchers
) {
2183 // greater_than_5 and less_than_10 are monomorphic matchers.
2184 Matcher
<int> greater_than_5
= Gt(5);
2185 Matcher
<int> less_than_10
= Lt(10);
2187 Matcher
<const int&> m
= AllOf(greater_than_5
, less_than_10
);
2188 Matcher
<int&> m2
= AllOf(greater_than_5
, less_than_10
);
2189 Matcher
<int&> m3
= AllOf(greater_than_5
, m2
);
2191 // Tests that BothOf works when composing itself.
2192 Matcher
<const int&> m4
= AllOf(greater_than_5
, less_than_10
, less_than_10
);
2193 Matcher
<int&> m5
= AllOf(greater_than_5
, less_than_10
, less_than_10
);
2196 TEST(AllOfTest
, ExplainsResult
) {
2199 // Successful match. Both matchers need to explain. The second
2200 // matcher doesn't give an explanation, so only the first matcher's
2201 // explanation is printed.
2202 m
= AllOf(GreaterThan(10), Lt(30));
2203 EXPECT_EQ("which is 15 more than 10", Explain(m
, 25));
2205 // Successful match. Both matchers need to explain.
2206 m
= AllOf(GreaterThan(10), GreaterThan(20));
2207 EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20",
2210 // Successful match. All matchers need to explain. The second
2211 // matcher doesn't given an explanation.
2212 m
= AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
2213 EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
2216 // Successful match. All matchers need to explain.
2217 m
= AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
2218 EXPECT_EQ("which is 30 more than 10, and which is 20 more than 20, "
2219 "and which is 10 more than 30",
2222 // Failed match. The first matcher, which failed, needs to
2224 m
= AllOf(GreaterThan(10), GreaterThan(20));
2225 EXPECT_EQ("which is 5 less than 10", Explain(m
, 5));
2227 // Failed match. The second matcher, which failed, needs to
2228 // explain. Since it doesn't given an explanation, nothing is
2230 m
= AllOf(GreaterThan(10), Lt(30));
2231 EXPECT_EQ("", Explain(m
, 40));
2233 // Failed match. The second matcher, which failed, needs to
2235 m
= AllOf(GreaterThan(10), GreaterThan(20));
2236 EXPECT_EQ("which is 5 less than 20", Explain(m
, 15));
2239 // Helper to allow easy testing of AnyOf matchers with num parameters.
2240 void AnyOfMatches(int num
, const Matcher
<int>& m
) {
2241 SCOPED_TRACE(Describe(m
));
2242 EXPECT_FALSE(m
.Matches(0));
2243 for (int i
= 1; i
<= num
; ++i
) {
2244 EXPECT_TRUE(m
.Matches(i
));
2246 EXPECT_FALSE(m
.Matches(num
+ 1));
2249 // Tests that AnyOf(m1, ..., mn) matches any value that matches at
2250 // least one of the given matchers.
2251 TEST(AnyOfTest
, MatchesWhenAnyMatches
) {
2253 m
= AnyOf(Le(1), Ge(3));
2254 EXPECT_TRUE(m
.Matches(1));
2255 EXPECT_TRUE(m
.Matches(4));
2256 EXPECT_FALSE(m
.Matches(2));
2258 m
= AnyOf(Lt(0), Eq(1), Eq(2));
2259 EXPECT_TRUE(m
.Matches(-1));
2260 EXPECT_TRUE(m
.Matches(1));
2261 EXPECT_TRUE(m
.Matches(2));
2262 EXPECT_FALSE(m
.Matches(0));
2264 m
= AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
2265 EXPECT_TRUE(m
.Matches(-1));
2266 EXPECT_TRUE(m
.Matches(1));
2267 EXPECT_TRUE(m
.Matches(2));
2268 EXPECT_TRUE(m
.Matches(3));
2269 EXPECT_FALSE(m
.Matches(0));
2271 m
= AnyOf(Le(0), Gt(10), 3, 5, 7);
2272 EXPECT_TRUE(m
.Matches(0));
2273 EXPECT_TRUE(m
.Matches(11));
2274 EXPECT_TRUE(m
.Matches(3));
2275 EXPECT_FALSE(m
.Matches(2));
2277 // The following tests for varying number of sub-matchers. Due to the way
2278 // the sub-matchers are handled it is enough to test every sub-matcher once
2279 // with sub-matchers using the same matcher type. Varying matcher types are
2280 // checked for above.
2281 AnyOfMatches(2, AnyOf(1, 2));
2282 AnyOfMatches(3, AnyOf(1, 2, 3));
2283 AnyOfMatches(4, AnyOf(1, 2, 3, 4));
2284 AnyOfMatches(5, AnyOf(1, 2, 3, 4, 5));
2285 AnyOfMatches(6, AnyOf(1, 2, 3, 4, 5, 6));
2286 AnyOfMatches(7, AnyOf(1, 2, 3, 4, 5, 6, 7));
2287 AnyOfMatches(8, AnyOf(1, 2, 3, 4, 5, 6, 7, 8));
2288 AnyOfMatches(9, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9));
2289 AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
2292 #if GTEST_LANG_CXX11
2293 // Tests the variadic version of the AnyOfMatcher.
2294 TEST(AnyOfTest
, VariadicMatchesWhenAnyMatches
) {
2295 // Also make sure AnyOf is defined in the right namespace and does not depend
2297 Matcher
<int> m
= ::testing::AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
2299 EXPECT_THAT(Describe(m
), EndsWith("or (is equal to 11))))))))))"));
2300 AnyOfMatches(11, m
);
2301 AnyOfMatches(50, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
2302 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
2303 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
2304 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2305 41, 42, 43, 44, 45, 46, 47, 48, 49, 50));
2308 #endif // GTEST_LANG_CXX11
2310 // Tests that AnyOf(m1, ..., mn) describes itself properly.
2311 TEST(AnyOfTest
, CanDescribeSelf
) {
2313 m
= AnyOf(Le(1), Ge(3));
2314 EXPECT_EQ("(is <= 1) or (is >= 3)",
2317 m
= AnyOf(Lt(0), Eq(1), Eq(2));
2318 EXPECT_EQ("(is < 0) or "
2319 "((is equal to 1) or (is equal to 2))",
2322 m
= AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
2323 EXPECT_EQ("((is < 0) or "
2324 "(is equal to 1)) or "
2325 "((is equal to 2) or "
2329 m
= AnyOf(Le(0), Gt(10), 3, 5, 7);
2330 EXPECT_EQ("((is <= 0) or "
2332 "((is equal to 3) or "
2333 "((is equal to 5) or "
2334 "(is equal to 7)))",
2338 // Tests that AnyOf(m1, ..., mn) describes its negation properly.
2339 TEST(AnyOfTest
, CanDescribeNegation
) {
2341 m
= AnyOf(Le(1), Ge(3));
2342 EXPECT_EQ("(isn't <= 1) and (isn't >= 3)",
2343 DescribeNegation(m
));
2345 m
= AnyOf(Lt(0), Eq(1), Eq(2));
2346 EXPECT_EQ("(isn't < 0) and "
2347 "((isn't equal to 1) and (isn't equal to 2))",
2348 DescribeNegation(m
));
2350 m
= AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
2351 EXPECT_EQ("((isn't < 0) and "
2352 "(isn't equal to 1)) and "
2353 "((isn't equal to 2) and "
2354 "(isn't equal to 3))",
2355 DescribeNegation(m
));
2357 m
= AnyOf(Le(0), Gt(10), 3, 5, 7);
2358 EXPECT_EQ("((isn't <= 0) and "
2359 "(isn't > 10)) and "
2360 "((isn't equal to 3) and "
2361 "((isn't equal to 5) and "
2362 "(isn't equal to 7)))",
2363 DescribeNegation(m
));
2366 // Tests that monomorphic matchers are safely cast by the AnyOf matcher.
2367 TEST(AnyOfTest
, AnyOfMatcherSafelyCastsMonomorphicMatchers
) {
2368 // greater_than_5 and less_than_10 are monomorphic matchers.
2369 Matcher
<int> greater_than_5
= Gt(5);
2370 Matcher
<int> less_than_10
= Lt(10);
2372 Matcher
<const int&> m
= AnyOf(greater_than_5
, less_than_10
);
2373 Matcher
<int&> m2
= AnyOf(greater_than_5
, less_than_10
);
2374 Matcher
<int&> m3
= AnyOf(greater_than_5
, m2
);
2376 // Tests that EitherOf works when composing itself.
2377 Matcher
<const int&> m4
= AnyOf(greater_than_5
, less_than_10
, less_than_10
);
2378 Matcher
<int&> m5
= AnyOf(greater_than_5
, less_than_10
, less_than_10
);
2381 TEST(AnyOfTest
, ExplainsResult
) {
2384 // Failed match. Both matchers need to explain. The second
2385 // matcher doesn't give an explanation, so only the first matcher's
2386 // explanation is printed.
2387 m
= AnyOf(GreaterThan(10), Lt(0));
2388 EXPECT_EQ("which is 5 less than 10", Explain(m
, 5));
2390 // Failed match. Both matchers need to explain.
2391 m
= AnyOf(GreaterThan(10), GreaterThan(20));
2392 EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
2395 // Failed match. All matchers need to explain. The second
2396 // matcher doesn't given an explanation.
2397 m
= AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
2398 EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
2401 // Failed match. All matchers need to explain.
2402 m
= AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
2403 EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20, "
2404 "and which is 25 less than 30",
2407 // Successful match. The first matcher, which succeeded, needs to
2409 m
= AnyOf(GreaterThan(10), GreaterThan(20));
2410 EXPECT_EQ("which is 5 more than 10", Explain(m
, 15));
2412 // Successful match. The second matcher, which succeeded, needs to
2413 // explain. Since it doesn't given an explanation, nothing is
2415 m
= AnyOf(GreaterThan(10), Lt(30));
2416 EXPECT_EQ("", Explain(m
, 0));
2418 // Successful match. The second matcher, which succeeded, needs to
2420 m
= AnyOf(GreaterThan(30), GreaterThan(20));
2421 EXPECT_EQ("which is 5 more than 20", Explain(m
, 25));
2424 // The following predicate function and predicate functor are for
2425 // testing the Truly(predicate) matcher.
2427 // Returns non-zero if the input is positive. Note that the return
2428 // type of this function is not bool. It's OK as Truly() accepts any
2429 // unary function or functor whose return type can be implicitly
2430 // converted to bool.
2431 int IsPositive(double x
) {
2432 return x
> 0 ? 1 : 0;
2435 // This functor returns true if the input is greater than the given
2437 class IsGreaterThan
{
2439 explicit IsGreaterThan(int threshold
) : threshold_(threshold
) {}
2441 bool operator()(int n
) const { return n
> threshold_
; }
2447 // For testing Truly().
2450 // This predicate returns true iff the argument references foo and has
2452 bool ReferencesFooAndIsZero(const int& n
) {
2453 return (&n
== &foo
) && (n
== 0);
2456 // Tests that Truly(predicate) matches what satisfies the given
2458 TEST(TrulyTest
, MatchesWhatSatisfiesThePredicate
) {
2459 Matcher
<double> m
= Truly(IsPositive
);
2460 EXPECT_TRUE(m
.Matches(2.0));
2461 EXPECT_FALSE(m
.Matches(-1.5));
2464 // Tests that Truly(predicate_functor) works too.
2465 TEST(TrulyTest
, CanBeUsedWithFunctor
) {
2466 Matcher
<int> m
= Truly(IsGreaterThan(5));
2467 EXPECT_TRUE(m
.Matches(6));
2468 EXPECT_FALSE(m
.Matches(4));
2471 // A class that can be implicitly converted to bool.
2472 class ConvertibleToBool
{
2474 explicit ConvertibleToBool(int number
) : number_(number
) {}
2475 operator bool() const { return number_
!= 0; }
2481 ConvertibleToBool
IsNotZero(int number
) {
2482 return ConvertibleToBool(number
);
2485 // Tests that the predicate used in Truly() may return a class that's
2486 // implicitly convertible to bool, even when the class has no
2488 TEST(TrulyTest
, PredicateCanReturnAClassConvertibleToBool
) {
2489 Matcher
<int> m
= Truly(IsNotZero
);
2490 EXPECT_TRUE(m
.Matches(1));
2491 EXPECT_FALSE(m
.Matches(0));
2494 // Tests that Truly(predicate) can describe itself properly.
2495 TEST(TrulyTest
, CanDescribeSelf
) {
2496 Matcher
<double> m
= Truly(IsPositive
);
2497 EXPECT_EQ("satisfies the given predicate",
2501 // Tests that Truly(predicate) works when the matcher takes its
2502 // argument by reference.
2503 TEST(TrulyTest
, WorksForByRefArguments
) {
2504 Matcher
<const int&> m
= Truly(ReferencesFooAndIsZero
);
2505 EXPECT_TRUE(m
.Matches(foo
));
2507 EXPECT_FALSE(m
.Matches(n
));
2510 // Tests that Matches(m) is a predicate satisfied by whatever that
2511 // matches matcher m.
2512 TEST(MatchesTest
, IsSatisfiedByWhatMatchesTheMatcher
) {
2513 EXPECT_TRUE(Matches(Ge(0))(1));
2514 EXPECT_FALSE(Matches(Eq('a'))('b'));
2517 // Tests that Matches(m) works when the matcher takes its argument by
2519 TEST(MatchesTest
, WorksOnByRefArguments
) {
2521 EXPECT_TRUE(Matches(AllOf(Ref(n
), Eq(0)))(n
));
2522 EXPECT_FALSE(Matches(Ref(m
))(n
));
2525 // Tests that a Matcher on non-reference type can be used in
2527 TEST(MatchesTest
, WorksWithMatcherOnNonRefType
) {
2528 Matcher
<int> eq5
= Eq(5);
2529 EXPECT_TRUE(Matches(eq5
)(5));
2530 EXPECT_FALSE(Matches(eq5
)(2));
2533 // Tests Value(value, matcher). Since Value() is a simple wrapper for
2534 // Matches(), which has been tested already, we don't spend a lot of
2535 // effort on testing Value().
2536 TEST(ValueTest
, WorksWithPolymorphicMatcher
) {
2537 EXPECT_TRUE(Value("hi", StartsWith("h")));
2538 EXPECT_FALSE(Value(5, Gt(10)));
2541 TEST(ValueTest
, WorksWithMonomorphicMatcher
) {
2542 const Matcher
<int> is_zero
= Eq(0);
2543 EXPECT_TRUE(Value(0, is_zero
));
2544 EXPECT_FALSE(Value('a', is_zero
));
2547 const Matcher
<const int&> ref_n
= Ref(n
);
2548 EXPECT_TRUE(Value(n
, ref_n
));
2549 EXPECT_FALSE(Value(1, ref_n
));
2552 TEST(ExplainMatchResultTest
, WorksWithPolymorphicMatcher
) {
2553 StringMatchResultListener listener1
;
2554 EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1
));
2555 EXPECT_EQ("% 2 == 0", listener1
.str());
2557 StringMatchResultListener listener2
;
2558 EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2
));
2559 EXPECT_EQ("", listener2
.str());
2562 TEST(ExplainMatchResultTest
, WorksWithMonomorphicMatcher
) {
2563 const Matcher
<int> is_even
= PolymorphicIsEven();
2564 StringMatchResultListener listener1
;
2565 EXPECT_TRUE(ExplainMatchResult(is_even
, 42, &listener1
));
2566 EXPECT_EQ("% 2 == 0", listener1
.str());
2568 const Matcher
<const double&> is_zero
= Eq(0);
2569 StringMatchResultListener listener2
;
2570 EXPECT_FALSE(ExplainMatchResult(is_zero
, 1.5, &listener2
));
2571 EXPECT_EQ("", listener2
.str());
2574 MATCHER_P(Really
, inner_matcher
, "") {
2575 return ExplainMatchResult(inner_matcher
, arg
, result_listener
);
2578 TEST(ExplainMatchResultTest
, WorksInsideMATCHER
) {
2579 EXPECT_THAT(0, Really(Eq(0)));
2582 TEST(AllArgsTest
, WorksForTuple
) {
2583 EXPECT_THAT(make_tuple(1, 2L), AllArgs(Lt()));
2584 EXPECT_THAT(make_tuple(2L, 1), Not(AllArgs(Lt())));
2587 TEST(AllArgsTest
, WorksForNonTuple
) {
2588 EXPECT_THAT(42, AllArgs(Gt(0)));
2589 EXPECT_THAT('a', Not(AllArgs(Eq('b'))));
2592 class AllArgsHelper
{
2596 MOCK_METHOD2(Helper
, int(char x
, int y
));
2599 GTEST_DISALLOW_COPY_AND_ASSIGN_(AllArgsHelper
);
2602 TEST(AllArgsTest
, WorksInWithClause
) {
2603 AllArgsHelper helper
;
2604 ON_CALL(helper
, Helper(_
, _
))
2605 .With(AllArgs(Lt()))
2606 .WillByDefault(Return(1));
2607 EXPECT_CALL(helper
, Helper(_
, _
));
2608 EXPECT_CALL(helper
, Helper(_
, _
))
2609 .With(AllArgs(Gt()))
2610 .WillOnce(Return(2));
2612 EXPECT_EQ(1, helper
.Helper('\1', 2));
2613 EXPECT_EQ(2, helper
.Helper('a', 1));
2616 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
2617 // matches the matcher.
2618 TEST(MatcherAssertionTest
, WorksWhenMatcherIsSatisfied
) {
2619 ASSERT_THAT(5, Ge(2)) << "This should succeed.";
2620 ASSERT_THAT("Foo", EndsWith("oo"));
2621 EXPECT_THAT(2, AllOf(Le(7), Ge(0))) << "This should succeed too.";
2622 EXPECT_THAT("Hello", StartsWith("Hell"));
2625 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
2626 // doesn't match the matcher.
2627 TEST(MatcherAssertionTest
, WorksWhenMatcherIsNotSatisfied
) {
2628 // 'n' must be static as it is used in an EXPECT_FATAL_FAILURE(),
2629 // which cannot reference auto variables.
2630 static unsigned short n
; // NOLINT
2633 // VC++ prior to version 8.0 SP1 has a bug where it will not see any
2634 // functions declared in the namespace scope from within nested classes.
2635 // EXPECT/ASSERT_(NON)FATAL_FAILURE macros use nested classes so that all
2636 // namespace-level functions invoked inside them need to be explicitly
2638 EXPECT_FATAL_FAILURE(ASSERT_THAT(n
, ::testing::Gt(10)),
2640 "Expected: is > 10\n"
2641 " Actual: 5" + OfType("unsigned short"));
2643 EXPECT_NONFATAL_FAILURE(
2644 EXPECT_THAT(n
, ::testing::AllOf(::testing::Le(7), ::testing::Ge(5))),
2646 "Expected: (is <= 7) and (is >= 5)\n"
2647 " Actual: 0" + OfType("unsigned short"));
2650 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the argument
2651 // has a reference type.
2652 TEST(MatcherAssertionTest
, WorksForByRefArguments
) {
2653 // We use a static variable here as EXPECT_FATAL_FAILURE() cannot
2654 // reference auto variables.
2657 EXPECT_THAT(n
, AllOf(Le(7), Ref(n
)));
2658 EXPECT_FATAL_FAILURE(ASSERT_THAT(n
, ::testing::Not(::testing::Ref(n
))),
2660 "Expected: does not reference the variable @");
2661 // Tests the "Actual" part.
2662 EXPECT_FATAL_FAILURE(ASSERT_THAT(n
, ::testing::Not(::testing::Ref(n
))),
2663 "Actual: 0" + OfType("int") + ", which is located @");
2666 #if !GTEST_OS_SYMBIAN
2667 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the matcher is
2670 // ASSERT_THAT("hello", starts_with_he) fails to compile with Nokia's
2671 // Symbian compiler: it tries to compile
2672 // template<T, U> class MatcherCastImpl { ...
2673 // virtual bool MatchAndExplain(T x, ...) const {
2674 // return source_matcher_.MatchAndExplain(static_cast<U>(x), ...);
2675 // with U == string and T == const char*
2676 // With ASSERT_THAT("hello"...) changed to ASSERT_THAT(string("hello") ... )
2677 // the compiler silently crashes with no output.
2678 // If MatcherCastImpl is changed to use U(x) instead of static_cast<U>(x)
2679 // the code compiles but the converted string is bogus.
2680 TEST(MatcherAssertionTest
, WorksForMonomorphicMatcher
) {
2681 Matcher
<const char*> starts_with_he
= StartsWith("he");
2682 ASSERT_THAT("hello", starts_with_he
);
2684 Matcher
<const string
&> ends_with_ok
= EndsWith("ok");
2685 ASSERT_THAT("book", ends_with_ok
);
2686 const string bad
= "bad";
2687 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(bad
, ends_with_ok
),
2689 "Expected: ends with \"ok\"\n"
2690 " Actual: \"bad\"");
2691 Matcher
<int> is_greater_than_5
= Gt(5);
2692 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(5, is_greater_than_5
),
2694 "Expected: is > 5\n"
2695 " Actual: 5" + OfType("int"));
2697 #endif // !GTEST_OS_SYMBIAN
2699 // Tests floating-point matchers.
2700 template <typename RawType
>
2701 class FloatingPointTest
: public testing::Test
{
2703 typedef testing::internal::FloatingPoint
<RawType
> Floating
;
2704 typedef typename
Floating::Bits Bits
;
2707 : max_ulps_(Floating::kMaxUlps
),
2708 zero_bits_(Floating(0).bits()),
2709 one_bits_(Floating(1).bits()),
2710 infinity_bits_(Floating(Floating::Infinity()).bits()),
2711 close_to_positive_zero_(AsBits(zero_bits_
+ max_ulps_
/2)),
2712 close_to_negative_zero_(AsBits(zero_bits_
+ max_ulps_
- max_ulps_
/2)),
2713 further_from_negative_zero_(-AsBits(
2714 zero_bits_
+ max_ulps_
+ 1 - max_ulps_
/2)),
2715 close_to_one_(AsBits(one_bits_
+ max_ulps_
)),
2716 further_from_one_(AsBits(one_bits_
+ max_ulps_
+ 1)),
2717 infinity_(Floating::Infinity()),
2718 close_to_infinity_(AsBits(infinity_bits_
- max_ulps_
)),
2719 further_from_infinity_(AsBits(infinity_bits_
- max_ulps_
- 1)),
2720 max_(Floating::Max()),
2721 nan1_(AsBits(Floating::kExponentBitMask
| 1)),
2722 nan2_(AsBits(Floating::kExponentBitMask
| 200)) {
2726 EXPECT_EQ(sizeof(RawType
), sizeof(Bits
));
2729 // A battery of tests for FloatingEqMatcher::Matches.
2730 // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
2732 testing::internal::FloatingEqMatcher
<RawType
> (*matcher_maker
)(RawType
)) {
2733 Matcher
<RawType
> m1
= matcher_maker(0.0);
2734 EXPECT_TRUE(m1
.Matches(-0.0));
2735 EXPECT_TRUE(m1
.Matches(close_to_positive_zero_
));
2736 EXPECT_TRUE(m1
.Matches(close_to_negative_zero_
));
2737 EXPECT_FALSE(m1
.Matches(1.0));
2739 Matcher
<RawType
> m2
= matcher_maker(close_to_positive_zero_
);
2740 EXPECT_FALSE(m2
.Matches(further_from_negative_zero_
));
2742 Matcher
<RawType
> m3
= matcher_maker(1.0);
2743 EXPECT_TRUE(m3
.Matches(close_to_one_
));
2744 EXPECT_FALSE(m3
.Matches(further_from_one_
));
2746 // Test commutativity: matcher_maker(0.0).Matches(1.0) was tested above.
2747 EXPECT_FALSE(m3
.Matches(0.0));
2749 Matcher
<RawType
> m4
= matcher_maker(-infinity_
);
2750 EXPECT_TRUE(m4
.Matches(-close_to_infinity_
));
2752 Matcher
<RawType
> m5
= matcher_maker(infinity_
);
2753 EXPECT_TRUE(m5
.Matches(close_to_infinity_
));
2755 // This is interesting as the representations of infinity_ and nan1_
2756 // are only 1 DLP apart.
2757 EXPECT_FALSE(m5
.Matches(nan1_
));
2759 // matcher_maker can produce a Matcher<const RawType&>, which is needed in
2761 Matcher
<const RawType
&> m6
= matcher_maker(0.0);
2762 EXPECT_TRUE(m6
.Matches(-0.0));
2763 EXPECT_TRUE(m6
.Matches(close_to_positive_zero_
));
2764 EXPECT_FALSE(m6
.Matches(1.0));
2766 // matcher_maker can produce a Matcher<RawType&>, which is needed in some
2768 Matcher
<RawType
&> m7
= matcher_maker(0.0);
2770 EXPECT_TRUE(m7
.Matches(x
));
2772 EXPECT_FALSE(m7
.Matches(x
));
2775 // Pre-calculated numbers to be used by the tests.
2777 const size_t max_ulps_
;
2779 const Bits zero_bits_
; // The bits that represent 0.0.
2780 const Bits one_bits_
; // The bits that represent 1.0.
2781 const Bits infinity_bits_
; // The bits that represent +infinity.
2783 // Some numbers close to 0.0.
2784 const RawType close_to_positive_zero_
;
2785 const RawType close_to_negative_zero_
;
2786 const RawType further_from_negative_zero_
;
2788 // Some numbers close to 1.0.
2789 const RawType close_to_one_
;
2790 const RawType further_from_one_
;
2792 // Some numbers close to +infinity.
2793 const RawType infinity_
;
2794 const RawType close_to_infinity_
;
2795 const RawType further_from_infinity_
;
2797 // Maximum representable value that's not infinity.
2801 const RawType nan1_
;
2802 const RawType nan2_
;
2805 template <typename T
>
2806 static RawType
AsBits(T value
) {
2807 return Floating::ReinterpretBits(static_cast<Bits
>(value
));
2811 // Tests floating-point matchers with fixed epsilons.
2812 template <typename RawType
>
2813 class FloatingPointNearTest
: public FloatingPointTest
<RawType
> {
2815 typedef FloatingPointTest
<RawType
> ParentType
;
2817 // A battery of tests for FloatingEqMatcher::Matches with a fixed epsilon.
2818 // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
2819 void TestNearMatches(
2820 testing::internal::FloatingEqMatcher
<RawType
>
2821 (*matcher_maker
)(RawType
, RawType
)) {
2822 Matcher
<RawType
> m1
= matcher_maker(0.0, 0.0);
2823 EXPECT_TRUE(m1
.Matches(0.0));
2824 EXPECT_TRUE(m1
.Matches(-0.0));
2825 EXPECT_FALSE(m1
.Matches(ParentType::close_to_positive_zero_
));
2826 EXPECT_FALSE(m1
.Matches(ParentType::close_to_negative_zero_
));
2827 EXPECT_FALSE(m1
.Matches(1.0));
2829 Matcher
<RawType
> m2
= matcher_maker(0.0, 1.0);
2830 EXPECT_TRUE(m2
.Matches(0.0));
2831 EXPECT_TRUE(m2
.Matches(-0.0));
2832 EXPECT_TRUE(m2
.Matches(1.0));
2833 EXPECT_TRUE(m2
.Matches(-1.0));
2834 EXPECT_FALSE(m2
.Matches(ParentType::close_to_one_
));
2835 EXPECT_FALSE(m2
.Matches(-ParentType::close_to_one_
));
2837 // Check that inf matches inf, regardless of the of the specified max
2839 Matcher
<RawType
> m3
= matcher_maker(ParentType::infinity_
, 0.0);
2840 EXPECT_TRUE(m3
.Matches(ParentType::infinity_
));
2841 EXPECT_FALSE(m3
.Matches(ParentType::close_to_infinity_
));
2842 EXPECT_FALSE(m3
.Matches(-ParentType::infinity_
));
2844 Matcher
<RawType
> m4
= matcher_maker(-ParentType::infinity_
, 0.0);
2845 EXPECT_TRUE(m4
.Matches(-ParentType::infinity_
));
2846 EXPECT_FALSE(m4
.Matches(-ParentType::close_to_infinity_
));
2847 EXPECT_FALSE(m4
.Matches(ParentType::infinity_
));
2849 // Test various overflow scenarios.
2850 Matcher
<RawType
> m5
= matcher_maker(ParentType::max_
, ParentType::max_
);
2851 EXPECT_TRUE(m5
.Matches(ParentType::max_
));
2852 EXPECT_FALSE(m5
.Matches(-ParentType::max_
));
2854 Matcher
<RawType
> m6
= matcher_maker(-ParentType::max_
, ParentType::max_
);
2855 EXPECT_FALSE(m6
.Matches(ParentType::max_
));
2856 EXPECT_TRUE(m6
.Matches(-ParentType::max_
));
2858 Matcher
<RawType
> m7
= matcher_maker(ParentType::max_
, 0);
2859 EXPECT_TRUE(m7
.Matches(ParentType::max_
));
2860 EXPECT_FALSE(m7
.Matches(-ParentType::max_
));
2862 Matcher
<RawType
> m8
= matcher_maker(-ParentType::max_
, 0);
2863 EXPECT_FALSE(m8
.Matches(ParentType::max_
));
2864 EXPECT_TRUE(m8
.Matches(-ParentType::max_
));
2866 // The difference between max() and -max() normally overflows to infinity,
2867 // but it should still match if the max_abs_error is also infinity.
2868 Matcher
<RawType
> m9
= matcher_maker(
2869 ParentType::max_
, ParentType::infinity_
);
2870 EXPECT_TRUE(m8
.Matches(-ParentType::max_
));
2872 // matcher_maker can produce a Matcher<const RawType&>, which is needed in
2874 Matcher
<const RawType
&> m10
= matcher_maker(0.0, 1.0);
2875 EXPECT_TRUE(m10
.Matches(-0.0));
2876 EXPECT_TRUE(m10
.Matches(ParentType::close_to_positive_zero_
));
2877 EXPECT_FALSE(m10
.Matches(ParentType::close_to_one_
));
2879 // matcher_maker can produce a Matcher<RawType&>, which is needed in some
2881 Matcher
<RawType
&> m11
= matcher_maker(0.0, 1.0);
2883 EXPECT_TRUE(m11
.Matches(x
));
2885 EXPECT_TRUE(m11
.Matches(x
));
2887 EXPECT_TRUE(m11
.Matches(x
));
2889 EXPECT_FALSE(m11
.Matches(x
));
2891 EXPECT_FALSE(m11
.Matches(x
));
2895 // Instantiate FloatingPointTest for testing floats.
2896 typedef FloatingPointTest
<float> FloatTest
;
2898 TEST_F(FloatTest
, FloatEqApproximatelyMatchesFloats
) {
2899 TestMatches(&FloatEq
);
2902 TEST_F(FloatTest
, NanSensitiveFloatEqApproximatelyMatchesFloats
) {
2903 TestMatches(&NanSensitiveFloatEq
);
2906 TEST_F(FloatTest
, FloatEqCannotMatchNaN
) {
2907 // FloatEq never matches NaN.
2908 Matcher
<float> m
= FloatEq(nan1_
);
2909 EXPECT_FALSE(m
.Matches(nan1_
));
2910 EXPECT_FALSE(m
.Matches(nan2_
));
2911 EXPECT_FALSE(m
.Matches(1.0));
2914 TEST_F(FloatTest
, NanSensitiveFloatEqCanMatchNaN
) {
2915 // NanSensitiveFloatEq will match NaN.
2916 Matcher
<float> m
= NanSensitiveFloatEq(nan1_
);
2917 EXPECT_TRUE(m
.Matches(nan1_
));
2918 EXPECT_TRUE(m
.Matches(nan2_
));
2919 EXPECT_FALSE(m
.Matches(1.0));
2922 TEST_F(FloatTest
, FloatEqCanDescribeSelf
) {
2923 Matcher
<float> m1
= FloatEq(2.0f
);
2924 EXPECT_EQ("is approximately 2", Describe(m1
));
2925 EXPECT_EQ("isn't approximately 2", DescribeNegation(m1
));
2927 Matcher
<float> m2
= FloatEq(0.5f
);
2928 EXPECT_EQ("is approximately 0.5", Describe(m2
));
2929 EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2
));
2931 Matcher
<float> m3
= FloatEq(nan1_
);
2932 EXPECT_EQ("never matches", Describe(m3
));
2933 EXPECT_EQ("is anything", DescribeNegation(m3
));
2936 TEST_F(FloatTest
, NanSensitiveFloatEqCanDescribeSelf
) {
2937 Matcher
<float> m1
= NanSensitiveFloatEq(2.0f
);
2938 EXPECT_EQ("is approximately 2", Describe(m1
));
2939 EXPECT_EQ("isn't approximately 2", DescribeNegation(m1
));
2941 Matcher
<float> m2
= NanSensitiveFloatEq(0.5f
);
2942 EXPECT_EQ("is approximately 0.5", Describe(m2
));
2943 EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2
));
2945 Matcher
<float> m3
= NanSensitiveFloatEq(nan1_
);
2946 EXPECT_EQ("is NaN", Describe(m3
));
2947 EXPECT_EQ("isn't NaN", DescribeNegation(m3
));
2950 // Instantiate FloatingPointTest for testing floats with a user-specified
2951 // max absolute error.
2952 typedef FloatingPointNearTest
<float> FloatNearTest
;
2954 TEST_F(FloatNearTest
, FloatNearMatches
) {
2955 TestNearMatches(&FloatNear
);
2958 TEST_F(FloatNearTest
, NanSensitiveFloatNearApproximatelyMatchesFloats
) {
2959 TestNearMatches(&NanSensitiveFloatNear
);
2962 TEST_F(FloatNearTest
, FloatNearCanDescribeSelf
) {
2963 Matcher
<float> m1
= FloatNear(2.0f
, 0.5f
);
2964 EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1
));
2966 "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1
));
2968 Matcher
<float> m2
= FloatNear(0.5f
, 0.5f
);
2969 EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2
));
2971 "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2
));
2973 Matcher
<float> m3
= FloatNear(nan1_
, 0.0);
2974 EXPECT_EQ("never matches", Describe(m3
));
2975 EXPECT_EQ("is anything", DescribeNegation(m3
));
2978 TEST_F(FloatNearTest
, NanSensitiveFloatNearCanDescribeSelf
) {
2979 Matcher
<float> m1
= NanSensitiveFloatNear(2.0f
, 0.5f
);
2980 EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1
));
2982 "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1
));
2984 Matcher
<float> m2
= NanSensitiveFloatNear(0.5f
, 0.5f
);
2985 EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2
));
2987 "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2
));
2989 Matcher
<float> m3
= NanSensitiveFloatNear(nan1_
, 0.1f
);
2990 EXPECT_EQ("is NaN", Describe(m3
));
2991 EXPECT_EQ("isn't NaN", DescribeNegation(m3
));
2994 TEST_F(FloatNearTest
, FloatNearCannotMatchNaN
) {
2995 // FloatNear never matches NaN.
2996 Matcher
<float> m
= FloatNear(ParentType::nan1_
, 0.1f
);
2997 EXPECT_FALSE(m
.Matches(nan1_
));
2998 EXPECT_FALSE(m
.Matches(nan2_
));
2999 EXPECT_FALSE(m
.Matches(1.0));
3002 TEST_F(FloatNearTest
, NanSensitiveFloatNearCanMatchNaN
) {
3003 // NanSensitiveFloatNear will match NaN.
3004 Matcher
<float> m
= NanSensitiveFloatNear(nan1_
, 0.1f
);
3005 EXPECT_TRUE(m
.Matches(nan1_
));
3006 EXPECT_TRUE(m
.Matches(nan2_
));
3007 EXPECT_FALSE(m
.Matches(1.0));
3010 // Instantiate FloatingPointTest for testing doubles.
3011 typedef FloatingPointTest
<double> DoubleTest
;
3013 TEST_F(DoubleTest
, DoubleEqApproximatelyMatchesDoubles
) {
3014 TestMatches(&DoubleEq
);
3017 TEST_F(DoubleTest
, NanSensitiveDoubleEqApproximatelyMatchesDoubles
) {
3018 TestMatches(&NanSensitiveDoubleEq
);
3021 TEST_F(DoubleTest
, DoubleEqCannotMatchNaN
) {
3022 // DoubleEq never matches NaN.
3023 Matcher
<double> m
= DoubleEq(nan1_
);
3024 EXPECT_FALSE(m
.Matches(nan1_
));
3025 EXPECT_FALSE(m
.Matches(nan2_
));
3026 EXPECT_FALSE(m
.Matches(1.0));
3029 TEST_F(DoubleTest
, NanSensitiveDoubleEqCanMatchNaN
) {
3030 // NanSensitiveDoubleEq will match NaN.
3031 Matcher
<double> m
= NanSensitiveDoubleEq(nan1_
);
3032 EXPECT_TRUE(m
.Matches(nan1_
));
3033 EXPECT_TRUE(m
.Matches(nan2_
));
3034 EXPECT_FALSE(m
.Matches(1.0));
3037 TEST_F(DoubleTest
, DoubleEqCanDescribeSelf
) {
3038 Matcher
<double> m1
= DoubleEq(2.0);
3039 EXPECT_EQ("is approximately 2", Describe(m1
));
3040 EXPECT_EQ("isn't approximately 2", DescribeNegation(m1
));
3042 Matcher
<double> m2
= DoubleEq(0.5);
3043 EXPECT_EQ("is approximately 0.5", Describe(m2
));
3044 EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2
));
3046 Matcher
<double> m3
= DoubleEq(nan1_
);
3047 EXPECT_EQ("never matches", Describe(m3
));
3048 EXPECT_EQ("is anything", DescribeNegation(m3
));
3051 TEST_F(DoubleTest
, NanSensitiveDoubleEqCanDescribeSelf
) {
3052 Matcher
<double> m1
= NanSensitiveDoubleEq(2.0);
3053 EXPECT_EQ("is approximately 2", Describe(m1
));
3054 EXPECT_EQ("isn't approximately 2", DescribeNegation(m1
));
3056 Matcher
<double> m2
= NanSensitiveDoubleEq(0.5);
3057 EXPECT_EQ("is approximately 0.5", Describe(m2
));
3058 EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2
));
3060 Matcher
<double> m3
= NanSensitiveDoubleEq(nan1_
);
3061 EXPECT_EQ("is NaN", Describe(m3
));
3062 EXPECT_EQ("isn't NaN", DescribeNegation(m3
));
3065 // Instantiate FloatingPointTest for testing floats with a user-specified
3066 // max absolute error.
3067 typedef FloatingPointNearTest
<double> DoubleNearTest
;
3069 TEST_F(DoubleNearTest
, DoubleNearMatches
) {
3070 TestNearMatches(&DoubleNear
);
3073 TEST_F(DoubleNearTest
, NanSensitiveDoubleNearApproximatelyMatchesDoubles
) {
3074 TestNearMatches(&NanSensitiveDoubleNear
);
3077 TEST_F(DoubleNearTest
, DoubleNearCanDescribeSelf
) {
3078 Matcher
<double> m1
= DoubleNear(2.0, 0.5);
3079 EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1
));
3081 "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1
));
3083 Matcher
<double> m2
= DoubleNear(0.5, 0.5);
3084 EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2
));
3086 "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2
));
3088 Matcher
<double> m3
= DoubleNear(nan1_
, 0.0);
3089 EXPECT_EQ("never matches", Describe(m3
));
3090 EXPECT_EQ("is anything", DescribeNegation(m3
));
3093 TEST_F(DoubleNearTest
, ExplainsResultWhenMatchFails
) {
3094 EXPECT_EQ("", Explain(DoubleNear(2.0, 0.1), 2.05));
3095 EXPECT_EQ("which is 0.2 from 2", Explain(DoubleNear(2.0, 0.1), 2.2));
3096 EXPECT_EQ("which is -0.3 from 2", Explain(DoubleNear(2.0, 0.1), 1.7));
3098 const string explanation
= Explain(DoubleNear(2.1, 1e-10), 2.1 + 1.2e-10);
3099 // Different C++ implementations may print floating-point numbers
3100 // slightly differently.
3101 EXPECT_TRUE(explanation
== "which is 1.2e-10 from 2.1" || // GCC
3102 explanation
== "which is 1.2e-010 from 2.1") // MSVC
3103 << " where explanation is \"" << explanation
<< "\".";
3106 TEST_F(DoubleNearTest
, NanSensitiveDoubleNearCanDescribeSelf
) {
3107 Matcher
<double> m1
= NanSensitiveDoubleNear(2.0, 0.5);
3108 EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1
));
3110 "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1
));
3112 Matcher
<double> m2
= NanSensitiveDoubleNear(0.5, 0.5);
3113 EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2
));
3115 "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2
));
3117 Matcher
<double> m3
= NanSensitiveDoubleNear(nan1_
, 0.1);
3118 EXPECT_EQ("is NaN", Describe(m3
));
3119 EXPECT_EQ("isn't NaN", DescribeNegation(m3
));
3122 TEST_F(DoubleNearTest
, DoubleNearCannotMatchNaN
) {
3123 // DoubleNear never matches NaN.
3124 Matcher
<double> m
= DoubleNear(ParentType::nan1_
, 0.1);
3125 EXPECT_FALSE(m
.Matches(nan1_
));
3126 EXPECT_FALSE(m
.Matches(nan2_
));
3127 EXPECT_FALSE(m
.Matches(1.0));
3130 TEST_F(DoubleNearTest
, NanSensitiveDoubleNearCanMatchNaN
) {
3131 // NanSensitiveDoubleNear will match NaN.
3132 Matcher
<double> m
= NanSensitiveDoubleNear(nan1_
, 0.1);
3133 EXPECT_TRUE(m
.Matches(nan1_
));
3134 EXPECT_TRUE(m
.Matches(nan2_
));
3135 EXPECT_FALSE(m
.Matches(1.0));
3138 TEST(PointeeTest
, RawPointer
) {
3139 const Matcher
<int*> m
= Pointee(Ge(0));
3142 EXPECT_TRUE(m
.Matches(&n
));
3144 EXPECT_FALSE(m
.Matches(&n
));
3145 EXPECT_FALSE(m
.Matches(NULL
));
3148 TEST(PointeeTest
, RawPointerToConst
) {
3149 const Matcher
<const double*> m
= Pointee(Ge(0));
3152 EXPECT_TRUE(m
.Matches(&x
));
3154 EXPECT_FALSE(m
.Matches(&x
));
3155 EXPECT_FALSE(m
.Matches(NULL
));
3158 TEST(PointeeTest
, ReferenceToConstRawPointer
) {
3159 const Matcher
<int* const &> m
= Pointee(Ge(0));
3162 EXPECT_TRUE(m
.Matches(&n
));
3164 EXPECT_FALSE(m
.Matches(&n
));
3165 EXPECT_FALSE(m
.Matches(NULL
));
3168 TEST(PointeeTest
, ReferenceToNonConstRawPointer
) {
3169 const Matcher
<double* &> m
= Pointee(Ge(0));
3173 EXPECT_TRUE(m
.Matches(p
));
3175 EXPECT_FALSE(m
.Matches(p
));
3177 EXPECT_FALSE(m
.Matches(p
));
3180 MATCHER_P(FieldIIs
, inner_matcher
, "") {
3181 return ExplainMatchResult(inner_matcher
, arg
.i
, result_listener
);
3186 TEST(WhenDynamicCastToTest
, SameType
) {
3190 // Right type. A pointer is passed down.
3191 Base
* as_base_ptr
= &derived
;
3192 EXPECT_THAT(as_base_ptr
, WhenDynamicCastTo
<Derived
*>(Not(IsNull())));
3193 EXPECT_THAT(as_base_ptr
, WhenDynamicCastTo
<Derived
*>(Pointee(FieldIIs(4))));
3194 EXPECT_THAT(as_base_ptr
,
3195 Not(WhenDynamicCastTo
<Derived
*>(Pointee(FieldIIs(5)))));
3198 TEST(WhenDynamicCastToTest
, WrongTypes
) {
3201 OtherDerived other_derived
;
3203 // Wrong types. NULL is passed.
3204 EXPECT_THAT(&base
, Not(WhenDynamicCastTo
<Derived
*>(Pointee(_
))));
3205 EXPECT_THAT(&base
, WhenDynamicCastTo
<Derived
*>(IsNull()));
3206 Base
* as_base_ptr
= &derived
;
3207 EXPECT_THAT(as_base_ptr
, Not(WhenDynamicCastTo
<OtherDerived
*>(Pointee(_
))));
3208 EXPECT_THAT(as_base_ptr
, WhenDynamicCastTo
<OtherDerived
*>(IsNull()));
3209 as_base_ptr
= &other_derived
;
3210 EXPECT_THAT(as_base_ptr
, Not(WhenDynamicCastTo
<Derived
*>(Pointee(_
))));
3211 EXPECT_THAT(as_base_ptr
, WhenDynamicCastTo
<Derived
*>(IsNull()));
3214 TEST(WhenDynamicCastToTest
, AlreadyNull
) {
3216 Base
* as_base_ptr
= NULL
;
3217 EXPECT_THAT(as_base_ptr
, WhenDynamicCastTo
<Derived
*>(IsNull()));
3220 struct AmbiguousCastTypes
{
3221 class VirtualDerived
: public virtual Base
{};
3222 class DerivedSub1
: public VirtualDerived
{};
3223 class DerivedSub2
: public VirtualDerived
{};
3224 class ManyDerivedInHierarchy
: public DerivedSub1
, public DerivedSub2
{};
3227 TEST(WhenDynamicCastToTest
, AmbiguousCast
) {
3228 AmbiguousCastTypes::DerivedSub1 sub1
;
3229 AmbiguousCastTypes::ManyDerivedInHierarchy many_derived
;
3230 // Multiply derived from Base. dynamic_cast<> returns NULL.
3232 static_cast<AmbiguousCastTypes::DerivedSub1
*>(&many_derived
);
3233 EXPECT_THAT(as_base_ptr
,
3234 WhenDynamicCastTo
<AmbiguousCastTypes::VirtualDerived
*>(IsNull()));
3235 as_base_ptr
= &sub1
;
3238 WhenDynamicCastTo
<AmbiguousCastTypes::VirtualDerived
*>(Not(IsNull())));
3241 TEST(WhenDynamicCastToTest
, Describe
) {
3242 Matcher
<Base
*> matcher
= WhenDynamicCastTo
<Derived
*>(Pointee(_
));
3243 const string prefix
=
3244 "when dynamic_cast to " + internal::GetTypeName
<Derived
*>() + ", ";
3245 EXPECT_EQ(prefix
+ "points to a value that is anything", Describe(matcher
));
3246 EXPECT_EQ(prefix
+ "does not point to a value that is anything",
3247 DescribeNegation(matcher
));
3250 TEST(WhenDynamicCastToTest
, Explain
) {
3251 Matcher
<Base
*> matcher
= WhenDynamicCastTo
<Derived
*>(Pointee(_
));
3253 EXPECT_THAT(Explain(matcher
, null
), HasSubstr("NULL"));
3255 EXPECT_TRUE(matcher
.Matches(&derived
));
3256 EXPECT_THAT(Explain(matcher
, &derived
), HasSubstr("which points to "));
3258 // With references, the matcher itself can fail. Test for that one.
3259 Matcher
<const Base
&> ref_matcher
= WhenDynamicCastTo
<const OtherDerived
&>(_
);
3260 EXPECT_THAT(Explain(ref_matcher
, derived
),
3261 HasSubstr("which cannot be dynamic_cast"));
3264 TEST(WhenDynamicCastToTest
, GoodReference
) {
3267 Base
& as_base_ref
= derived
;
3268 EXPECT_THAT(as_base_ref
, WhenDynamicCastTo
<const Derived
&>(FieldIIs(4)));
3269 EXPECT_THAT(as_base_ref
, WhenDynamicCastTo
<const Derived
&>(Not(FieldIIs(5))));
3272 TEST(WhenDynamicCastToTest
, BadReference
) {
3274 Base
& as_base_ref
= derived
;
3275 EXPECT_THAT(as_base_ref
, Not(WhenDynamicCastTo
<const OtherDerived
&>(_
)));
3278 #endif // GTEST_HAS_RTTI
3280 // Minimal const-propagating pointer.
3281 template <typename T
>
3282 class ConstPropagatingPtr
{
3284 typedef T element_type
;
3286 ConstPropagatingPtr() : val_() {}
3287 explicit ConstPropagatingPtr(T
* t
) : val_(t
) {}
3288 ConstPropagatingPtr(const ConstPropagatingPtr
& other
) : val_(other
.val_
) {}
3290 T
* get() { return val_
; }
3291 T
& operator*() { return *val_
; }
3292 // Most smart pointers return non-const T* and T& from the next methods.
3293 const T
* get() const { return val_
; }
3294 const T
& operator*() const { return *val_
; }
3300 TEST(PointeeTest
, WorksWithConstPropagatingPointers
) {
3301 const Matcher
< ConstPropagatingPtr
<int> > m
= Pointee(Lt(5));
3303 const ConstPropagatingPtr
<int> co(&three
);
3304 ConstPropagatingPtr
<int> o(&three
);
3305 EXPECT_TRUE(m
.Matches(o
));
3306 EXPECT_TRUE(m
.Matches(co
));
3308 EXPECT_FALSE(m
.Matches(o
));
3309 EXPECT_FALSE(m
.Matches(ConstPropagatingPtr
<int>()));
3312 TEST(PointeeTest
, NeverMatchesNull
) {
3313 const Matcher
<const char*> m
= Pointee(_
);
3314 EXPECT_FALSE(m
.Matches(NULL
));
3317 // Tests that we can write Pointee(value) instead of Pointee(Eq(value)).
3318 TEST(PointeeTest
, MatchesAgainstAValue
) {
3319 const Matcher
<int*> m
= Pointee(5);
3322 EXPECT_TRUE(m
.Matches(&n
));
3324 EXPECT_FALSE(m
.Matches(&n
));
3325 EXPECT_FALSE(m
.Matches(NULL
));
3328 TEST(PointeeTest
, CanDescribeSelf
) {
3329 const Matcher
<int*> m
= Pointee(Gt(3));
3330 EXPECT_EQ("points to a value that is > 3", Describe(m
));
3331 EXPECT_EQ("does not point to a value that is > 3",
3332 DescribeNegation(m
));
3335 TEST(PointeeTest
, CanExplainMatchResult
) {
3336 const Matcher
<const string
*> m
= Pointee(StartsWith("Hi"));
3338 EXPECT_EQ("", Explain(m
, static_cast<const string
*>(NULL
)));
3340 const Matcher
<long*> m2
= Pointee(GreaterThan(1)); // NOLINT
3341 long n
= 3; // NOLINT
3342 EXPECT_EQ("which points to 3" + OfType("long") + ", which is 2 more than 1",
3346 TEST(PointeeTest
, AlwaysExplainsPointee
) {
3347 const Matcher
<int*> m
= Pointee(0);
3349 EXPECT_EQ("which points to 42" + OfType("int"), Explain(m
, &n
));
3352 // An uncopyable class.
3355 Uncopyable() : value_(-1) {}
3356 explicit Uncopyable(int a_value
) : value_(a_value
) {}
3358 int value() const { return value_
; }
3359 void set_value(int i
) { value_
= i
; }
3363 GTEST_DISALLOW_COPY_AND_ASSIGN_(Uncopyable
);
3366 // Returns true iff x.value() is positive.
3367 bool ValueIsPositive(const Uncopyable
& x
) { return x
.value() > 0; }
3369 MATCHER_P(UncopyableIs
, inner_matcher
, "") {
3370 return ExplainMatchResult(inner_matcher
, arg
.value(), result_listener
);
3373 // A user-defined struct for testing Field().
3375 AStruct() : x(0), y(1.0), z(5), p(NULL
) {}
3376 AStruct(const AStruct
& rhs
)
3377 : x(rhs
.x
), y(rhs
.y
), z(rhs
.z
.value()), p(rhs
.p
) {}
3379 int x
; // A non-const field.
3380 const double y
; // A const field.
3381 Uncopyable z
; // An uncopyable field.
3382 const char* p
; // A pointer field.
3385 GTEST_DISALLOW_ASSIGN_(AStruct
);
3388 // A derived struct for testing Field().
3389 struct DerivedStruct
: public AStruct
{
3393 GTEST_DISALLOW_ASSIGN_(DerivedStruct
);
3396 // Tests that Field(&Foo::field, ...) works when field is non-const.
3397 TEST(FieldTest
, WorksForNonConstField
) {
3398 Matcher
<AStruct
> m
= Field(&AStruct::x
, Ge(0));
3401 EXPECT_TRUE(m
.Matches(a
));
3403 EXPECT_FALSE(m
.Matches(a
));
3406 // Tests that Field(&Foo::field, ...) works when field is const.
3407 TEST(FieldTest
, WorksForConstField
) {
3410 Matcher
<AStruct
> m
= Field(&AStruct::y
, Ge(0.0));
3411 EXPECT_TRUE(m
.Matches(a
));
3412 m
= Field(&AStruct::y
, Le(0.0));
3413 EXPECT_FALSE(m
.Matches(a
));
3416 // Tests that Field(&Foo::field, ...) works when field is not copyable.
3417 TEST(FieldTest
, WorksForUncopyableField
) {
3420 Matcher
<AStruct
> m
= Field(&AStruct::z
, Truly(ValueIsPositive
));
3421 EXPECT_TRUE(m
.Matches(a
));
3422 m
= Field(&AStruct::z
, Not(Truly(ValueIsPositive
)));
3423 EXPECT_FALSE(m
.Matches(a
));
3426 // Tests that Field(&Foo::field, ...) works when field is a pointer.
3427 TEST(FieldTest
, WorksForPointerField
) {
3428 // Matching against NULL.
3429 Matcher
<AStruct
> m
= Field(&AStruct::p
, static_cast<const char*>(NULL
));
3431 EXPECT_TRUE(m
.Matches(a
));
3433 EXPECT_FALSE(m
.Matches(a
));
3435 // Matching a pointer that is not NULL.
3436 m
= Field(&AStruct::p
, StartsWith("hi"));
3438 EXPECT_TRUE(m
.Matches(a
));
3440 EXPECT_FALSE(m
.Matches(a
));
3443 // Tests that Field() works when the object is passed by reference.
3444 TEST(FieldTest
, WorksForByRefArgument
) {
3445 Matcher
<const AStruct
&> m
= Field(&AStruct::x
, Ge(0));
3448 EXPECT_TRUE(m
.Matches(a
));
3450 EXPECT_FALSE(m
.Matches(a
));
3453 // Tests that Field(&Foo::field, ...) works when the argument's type
3454 // is a sub-type of Foo.
3455 TEST(FieldTest
, WorksForArgumentOfSubType
) {
3456 // Note that the matcher expects DerivedStruct but we say AStruct
3458 Matcher
<const DerivedStruct
&> m
= Field(&AStruct::x
, Ge(0));
3461 EXPECT_TRUE(m
.Matches(d
));
3463 EXPECT_FALSE(m
.Matches(d
));
3466 // Tests that Field(&Foo::field, m) works when field's type and m's
3467 // argument type are compatible but not the same.
3468 TEST(FieldTest
, WorksForCompatibleMatcherType
) {
3469 // The field is an int, but the inner matcher expects a signed char.
3470 Matcher
<const AStruct
&> m
= Field(&AStruct::x
,
3471 Matcher
<signed char>(Ge(0)));
3474 EXPECT_TRUE(m
.Matches(a
));
3476 EXPECT_FALSE(m
.Matches(a
));
3479 // Tests that Field() can describe itself.
3480 TEST(FieldTest
, CanDescribeSelf
) {
3481 Matcher
<const AStruct
&> m
= Field(&AStruct::x
, Ge(0));
3483 EXPECT_EQ("is an object whose given field is >= 0", Describe(m
));
3484 EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m
));
3487 // Tests that Field() can explain the match result.
3488 TEST(FieldTest
, CanExplainMatchResult
) {
3489 Matcher
<const AStruct
&> m
= Field(&AStruct::x
, Ge(0));
3493 EXPECT_EQ("whose given field is 1" + OfType("int"), Explain(m
, a
));
3495 m
= Field(&AStruct::x
, GreaterThan(0));
3497 "whose given field is 1" + OfType("int") + ", which is 1 more than 0",
3501 // Tests that Field() works when the argument is a pointer to const.
3502 TEST(FieldForPointerTest
, WorksForPointerToConst
) {
3503 Matcher
<const AStruct
*> m
= Field(&AStruct::x
, Ge(0));
3506 EXPECT_TRUE(m
.Matches(&a
));
3508 EXPECT_FALSE(m
.Matches(&a
));
3511 // Tests that Field() works when the argument is a pointer to non-const.
3512 TEST(FieldForPointerTest
, WorksForPointerToNonConst
) {
3513 Matcher
<AStruct
*> m
= Field(&AStruct::x
, Ge(0));
3516 EXPECT_TRUE(m
.Matches(&a
));
3518 EXPECT_FALSE(m
.Matches(&a
));
3521 // Tests that Field() works when the argument is a reference to a const pointer.
3522 TEST(FieldForPointerTest
, WorksForReferenceToConstPointer
) {
3523 Matcher
<AStruct
* const&> m
= Field(&AStruct::x
, Ge(0));
3526 EXPECT_TRUE(m
.Matches(&a
));
3528 EXPECT_FALSE(m
.Matches(&a
));
3531 // Tests that Field() does not match the NULL pointer.
3532 TEST(FieldForPointerTest
, DoesNotMatchNull
) {
3533 Matcher
<const AStruct
*> m
= Field(&AStruct::x
, _
);
3534 EXPECT_FALSE(m
.Matches(NULL
));
3537 // Tests that Field(&Foo::field, ...) works when the argument's type
3538 // is a sub-type of const Foo*.
3539 TEST(FieldForPointerTest
, WorksForArgumentOfSubType
) {
3540 // Note that the matcher expects DerivedStruct but we say AStruct
3542 Matcher
<DerivedStruct
*> m
= Field(&AStruct::x
, Ge(0));
3545 EXPECT_TRUE(m
.Matches(&d
));
3547 EXPECT_FALSE(m
.Matches(&d
));
3550 // Tests that Field() can describe itself when used to match a pointer.
3551 TEST(FieldForPointerTest
, CanDescribeSelf
) {
3552 Matcher
<const AStruct
*> m
= Field(&AStruct::x
, Ge(0));
3554 EXPECT_EQ("is an object whose given field is >= 0", Describe(m
));
3555 EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m
));
3558 // Tests that Field() can explain the result of matching a pointer.
3559 TEST(FieldForPointerTest
, CanExplainMatchResult
) {
3560 Matcher
<const AStruct
*> m
= Field(&AStruct::x
, Ge(0));
3564 EXPECT_EQ("", Explain(m
, static_cast<const AStruct
*>(NULL
)));
3565 EXPECT_EQ("which points to an object whose given field is 1" + OfType("int"),
3568 m
= Field(&AStruct::x
, GreaterThan(0));
3569 EXPECT_EQ("which points to an object whose given field is 1" + OfType("int") +
3570 ", which is 1 more than 0", Explain(m
, &a
));
3573 // A user-defined class for testing Property().
3578 // A getter that returns a non-reference.
3579 int n() const { return n_
; }
3581 void set_n(int new_n
) { n_
= new_n
; }
3583 // A getter that returns a reference to const.
3584 const string
& s() const { return s_
; }
3586 void set_s(const string
& new_s
) { s_
= new_s
; }
3588 // A getter that returns a reference to non-const.
3589 double& x() const { return x_
; }
3597 double AClass::x_
= 0.0;
3599 // A derived class for testing Property().
3600 class DerivedClass
: public AClass
{
3602 int k() const { return k_
; }
3607 // Tests that Property(&Foo::property, ...) works when property()
3608 // returns a non-reference.
3609 TEST(PropertyTest
, WorksForNonReferenceProperty
) {
3610 Matcher
<const AClass
&> m
= Property(&AClass::n
, Ge(0));
3614 EXPECT_TRUE(m
.Matches(a
));
3617 EXPECT_FALSE(m
.Matches(a
));
3620 // Tests that Property(&Foo::property, ...) works when property()
3621 // returns a reference to const.
3622 TEST(PropertyTest
, WorksForReferenceToConstProperty
) {
3623 Matcher
<const AClass
&> m
= Property(&AClass::s
, StartsWith("hi"));
3627 EXPECT_TRUE(m
.Matches(a
));
3630 EXPECT_FALSE(m
.Matches(a
));
3633 // Tests that Property(&Foo::property, ...) works when property()
3634 // returns a reference to non-const.
3635 TEST(PropertyTest
, WorksForReferenceToNonConstProperty
) {
3639 Matcher
<const AClass
&> m
= Property(&AClass::x
, Ref(x
));
3640 EXPECT_FALSE(m
.Matches(a
));
3642 m
= Property(&AClass::x
, Not(Ref(x
)));
3643 EXPECT_TRUE(m
.Matches(a
));
3646 // Tests that Property(&Foo::property, ...) works when the argument is
3648 TEST(PropertyTest
, WorksForByValueArgument
) {
3649 Matcher
<AClass
> m
= Property(&AClass::s
, StartsWith("hi"));
3653 EXPECT_TRUE(m
.Matches(a
));
3656 EXPECT_FALSE(m
.Matches(a
));
3659 // Tests that Property(&Foo::property, ...) works when the argument's
3660 // type is a sub-type of Foo.
3661 TEST(PropertyTest
, WorksForArgumentOfSubType
) {
3662 // The matcher expects a DerivedClass, but inside the Property() we
3664 Matcher
<const DerivedClass
&> m
= Property(&AClass::n
, Ge(0));
3668 EXPECT_TRUE(m
.Matches(d
));
3671 EXPECT_FALSE(m
.Matches(d
));
3674 // Tests that Property(&Foo::property, m) works when property()'s type
3675 // and m's argument type are compatible but different.
3676 TEST(PropertyTest
, WorksForCompatibleMatcherType
) {
3677 // n() returns an int but the inner matcher expects a signed char.
3678 Matcher
<const AClass
&> m
= Property(&AClass::n
,
3679 Matcher
<signed char>(Ge(0)));
3682 EXPECT_TRUE(m
.Matches(a
));
3684 EXPECT_FALSE(m
.Matches(a
));
3687 // Tests that Property() can describe itself.
3688 TEST(PropertyTest
, CanDescribeSelf
) {
3689 Matcher
<const AClass
&> m
= Property(&AClass::n
, Ge(0));
3691 EXPECT_EQ("is an object whose given property is >= 0", Describe(m
));
3692 EXPECT_EQ("is an object whose given property isn't >= 0",
3693 DescribeNegation(m
));
3696 // Tests that Property() can explain the match result.
3697 TEST(PropertyTest
, CanExplainMatchResult
) {
3698 Matcher
<const AClass
&> m
= Property(&AClass::n
, Ge(0));
3702 EXPECT_EQ("whose given property is 1" + OfType("int"), Explain(m
, a
));
3704 m
= Property(&AClass::n
, GreaterThan(0));
3706 "whose given property is 1" + OfType("int") + ", which is 1 more than 0",
3710 // Tests that Property() works when the argument is a pointer to const.
3711 TEST(PropertyForPointerTest
, WorksForPointerToConst
) {
3712 Matcher
<const AClass
*> m
= Property(&AClass::n
, Ge(0));
3716 EXPECT_TRUE(m
.Matches(&a
));
3719 EXPECT_FALSE(m
.Matches(&a
));
3722 // Tests that Property() works when the argument is a pointer to non-const.
3723 TEST(PropertyForPointerTest
, WorksForPointerToNonConst
) {
3724 Matcher
<AClass
*> m
= Property(&AClass::s
, StartsWith("hi"));
3728 EXPECT_TRUE(m
.Matches(&a
));
3731 EXPECT_FALSE(m
.Matches(&a
));
3734 // Tests that Property() works when the argument is a reference to a
3736 TEST(PropertyForPointerTest
, WorksForReferenceToConstPointer
) {
3737 Matcher
<AClass
* const&> m
= Property(&AClass::s
, StartsWith("hi"));
3741 EXPECT_TRUE(m
.Matches(&a
));
3744 EXPECT_FALSE(m
.Matches(&a
));
3747 // Tests that Property() does not match the NULL pointer.
3748 TEST(PropertyForPointerTest
, WorksForReferenceToNonConstProperty
) {
3749 Matcher
<const AClass
*> m
= Property(&AClass::x
, _
);
3750 EXPECT_FALSE(m
.Matches(NULL
));
3753 // Tests that Property(&Foo::property, ...) works when the argument's
3754 // type is a sub-type of const Foo*.
3755 TEST(PropertyForPointerTest
, WorksForArgumentOfSubType
) {
3756 // The matcher expects a DerivedClass, but inside the Property() we
3758 Matcher
<const DerivedClass
*> m
= Property(&AClass::n
, Ge(0));
3762 EXPECT_TRUE(m
.Matches(&d
));
3765 EXPECT_FALSE(m
.Matches(&d
));
3768 // Tests that Property() can describe itself when used to match a pointer.
3769 TEST(PropertyForPointerTest
, CanDescribeSelf
) {
3770 Matcher
<const AClass
*> m
= Property(&AClass::n
, Ge(0));
3772 EXPECT_EQ("is an object whose given property is >= 0", Describe(m
));
3773 EXPECT_EQ("is an object whose given property isn't >= 0",
3774 DescribeNegation(m
));
3777 // Tests that Property() can explain the result of matching a pointer.
3778 TEST(PropertyForPointerTest
, CanExplainMatchResult
) {
3779 Matcher
<const AClass
*> m
= Property(&AClass::n
, Ge(0));
3783 EXPECT_EQ("", Explain(m
, static_cast<const AClass
*>(NULL
)));
3785 "which points to an object whose given property is 1" + OfType("int"),
3788 m
= Property(&AClass::n
, GreaterThan(0));
3789 EXPECT_EQ("which points to an object whose given property is 1" +
3790 OfType("int") + ", which is 1 more than 0",
3796 // Tests that ResultOf(f, ...) compiles and works as expected when f is a
3797 // function pointer.
3798 string
IntToStringFunction(int input
) { return input
== 1 ? "foo" : "bar"; }
3800 TEST(ResultOfTest
, WorksForFunctionPointers
) {
3801 Matcher
<int> matcher
= ResultOf(&IntToStringFunction
, Eq(string("foo")));
3803 EXPECT_TRUE(matcher
.Matches(1));
3804 EXPECT_FALSE(matcher
.Matches(2));
3807 // Tests that ResultOf() can describe itself.
3808 TEST(ResultOfTest
, CanDescribeItself
) {
3809 Matcher
<int> matcher
= ResultOf(&IntToStringFunction
, StrEq("foo"));
3811 EXPECT_EQ("is mapped by the given callable to a value that "
3812 "is equal to \"foo\"", Describe(matcher
));
3813 EXPECT_EQ("is mapped by the given callable to a value that "
3814 "isn't equal to \"foo\"", DescribeNegation(matcher
));
3817 // Tests that ResultOf() can explain the match result.
3818 int IntFunction(int input
) { return input
== 42 ? 80 : 90; }
3820 TEST(ResultOfTest
, CanExplainMatchResult
) {
3821 Matcher
<int> matcher
= ResultOf(&IntFunction
, Ge(85));
3822 EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int"),
3823 Explain(matcher
, 36));
3825 matcher
= ResultOf(&IntFunction
, GreaterThan(85));
3826 EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int") +
3827 ", which is 5 more than 85", Explain(matcher
, 36));
3830 // Tests that ResultOf(f, ...) compiles and works as expected when f(x)
3831 // returns a non-reference.
3832 TEST(ResultOfTest
, WorksForNonReferenceResults
) {
3833 Matcher
<int> matcher
= ResultOf(&IntFunction
, Eq(80));
3835 EXPECT_TRUE(matcher
.Matches(42));
3836 EXPECT_FALSE(matcher
.Matches(36));
3839 // Tests that ResultOf(f, ...) compiles and works as expected when f(x)
3840 // returns a reference to non-const.
3841 double& DoubleFunction(double& input
) { return input
; } // NOLINT
3843 Uncopyable
& RefUncopyableFunction(Uncopyable
& obj
) { // NOLINT
3847 TEST(ResultOfTest
, WorksForReferenceToNonConstResults
) {
3850 Matcher
<double&> matcher
= ResultOf(&DoubleFunction
, Ref(x
));
3852 EXPECT_TRUE(matcher
.Matches(x
));
3853 EXPECT_FALSE(matcher
.Matches(x2
));
3855 // Test that ResultOf works with uncopyable objects
3858 Matcher
<Uncopyable
&> matcher2
=
3859 ResultOf(&RefUncopyableFunction
, Ref(obj
));
3861 EXPECT_TRUE(matcher2
.Matches(obj
));
3862 EXPECT_FALSE(matcher2
.Matches(obj2
));
3865 // Tests that ResultOf(f, ...) compiles and works as expected when f(x)
3866 // returns a reference to const.
3867 const string
& StringFunction(const string
& input
) { return input
; }
3869 TEST(ResultOfTest
, WorksForReferenceToConstResults
) {
3872 Matcher
<const string
&> matcher
= ResultOf(&StringFunction
, Ref(s
));
3874 EXPECT_TRUE(matcher
.Matches(s
));
3875 EXPECT_FALSE(matcher
.Matches(s2
));
3878 // Tests that ResultOf(f, m) works when f(x) and m's
3879 // argument types are compatible but different.
3880 TEST(ResultOfTest
, WorksForCompatibleMatcherTypes
) {
3881 // IntFunction() returns int but the inner matcher expects a signed char.
3882 Matcher
<int> matcher
= ResultOf(IntFunction
, Matcher
<signed char>(Ge(85)));
3884 EXPECT_TRUE(matcher
.Matches(36));
3885 EXPECT_FALSE(matcher
.Matches(42));
3888 // Tests that the program aborts when ResultOf is passed
3889 // a NULL function pointer.
3890 TEST(ResultOfDeathTest
, DiesOnNullFunctionPointers
) {
3891 EXPECT_DEATH_IF_SUPPORTED(
3892 ResultOf(static_cast<string(*)(int dummy
)>(NULL
), Eq(string("foo"))),
3893 "NULL function pointer is passed into ResultOf\\(\\)\\.");
3896 // Tests that ResultOf(f, ...) compiles and works as expected when f is a
3897 // function reference.
3898 TEST(ResultOfTest
, WorksForFunctionReferences
) {
3899 Matcher
<int> matcher
= ResultOf(IntToStringFunction
, StrEq("foo"));
3900 EXPECT_TRUE(matcher
.Matches(1));
3901 EXPECT_FALSE(matcher
.Matches(2));
3904 // Tests that ResultOf(f, ...) compiles and works as expected when f is a
3906 struct Functor
: public ::std::unary_function
<int, string
> {
3907 result_type
operator()(argument_type input
) const {
3908 return IntToStringFunction(input
);
3912 TEST(ResultOfTest
, WorksForFunctors
) {
3913 Matcher
<int> matcher
= ResultOf(Functor(), Eq(string("foo")));
3915 EXPECT_TRUE(matcher
.Matches(1));
3916 EXPECT_FALSE(matcher
.Matches(2));
3919 // Tests that ResultOf(f, ...) compiles and works as expected when f is a
3920 // functor with more then one operator() defined. ResultOf() must work
3921 // for each defined operator().
3922 struct PolymorphicFunctor
{
3923 typedef int result_type
;
3924 int operator()(int n
) { return n
; }
3925 int operator()(const char* s
) { return static_cast<int>(strlen(s
)); }
3928 TEST(ResultOfTest
, WorksForPolymorphicFunctors
) {
3929 Matcher
<int> matcher_int
= ResultOf(PolymorphicFunctor(), Ge(5));
3931 EXPECT_TRUE(matcher_int
.Matches(10));
3932 EXPECT_FALSE(matcher_int
.Matches(2));
3934 Matcher
<const char*> matcher_string
= ResultOf(PolymorphicFunctor(), Ge(5));
3936 EXPECT_TRUE(matcher_string
.Matches("long string"));
3937 EXPECT_FALSE(matcher_string
.Matches("shrt"));
3940 const int* ReferencingFunction(const int& n
) { return &n
; }
3942 struct ReferencingFunctor
{
3943 typedef const int* result_type
;
3944 result_type
operator()(const int& n
) { return &n
; }
3947 TEST(ResultOfTest
, WorksForReferencingCallables
) {
3950 Matcher
<const int&> matcher2
= ResultOf(ReferencingFunction
, Eq(&n
));
3951 EXPECT_TRUE(matcher2
.Matches(n
));
3952 EXPECT_FALSE(matcher2
.Matches(n2
));
3954 Matcher
<const int&> matcher3
= ResultOf(ReferencingFunctor(), Eq(&n
));
3955 EXPECT_TRUE(matcher3
.Matches(n
));
3956 EXPECT_FALSE(matcher3
.Matches(n2
));
3959 class DivisibleByImpl
{
3961 explicit DivisibleByImpl(int a_divider
) : divider_(a_divider
) {}
3963 // For testing using ExplainMatchResultTo() with polymorphic matchers.
3964 template <typename T
>
3965 bool MatchAndExplain(const T
& n
, MatchResultListener
* listener
) const {
3966 *listener
<< "which is " << (n
% divider_
) << " modulo "
3968 return (n
% divider_
) == 0;
3971 void DescribeTo(ostream
* os
) const {
3972 *os
<< "is divisible by " << divider_
;
3975 void DescribeNegationTo(ostream
* os
) const {
3976 *os
<< "is not divisible by " << divider_
;
3979 void set_divider(int a_divider
) { divider_
= a_divider
; }
3980 int divider() const { return divider_
; }
3986 PolymorphicMatcher
<DivisibleByImpl
> DivisibleBy(int n
) {
3987 return MakePolymorphicMatcher(DivisibleByImpl(n
));
3990 // Tests that when AllOf() fails, only the first failing matcher is
3991 // asked to explain why.
3992 TEST(ExplainMatchResultTest
, AllOf_False_False
) {
3993 const Matcher
<int> m
= AllOf(DivisibleBy(4), DivisibleBy(3));
3994 EXPECT_EQ("which is 1 modulo 4", Explain(m
, 5));
3997 // Tests that when AllOf() fails, only the first failing matcher is
3998 // asked to explain why.
3999 TEST(ExplainMatchResultTest
, AllOf_False_True
) {
4000 const Matcher
<int> m
= AllOf(DivisibleBy(4), DivisibleBy(3));
4001 EXPECT_EQ("which is 2 modulo 4", Explain(m
, 6));
4004 // Tests that when AllOf() fails, only the first failing matcher is
4005 // asked to explain why.
4006 TEST(ExplainMatchResultTest
, AllOf_True_False
) {
4007 const Matcher
<int> m
= AllOf(Ge(1), DivisibleBy(3));
4008 EXPECT_EQ("which is 2 modulo 3", Explain(m
, 5));
4011 // Tests that when AllOf() succeeds, all matchers are asked to explain
4013 TEST(ExplainMatchResultTest
, AllOf_True_True
) {
4014 const Matcher
<int> m
= AllOf(DivisibleBy(2), DivisibleBy(3));
4015 EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m
, 6));
4018 TEST(ExplainMatchResultTest
, AllOf_True_True_2
) {
4019 const Matcher
<int> m
= AllOf(Ge(2), Le(3));
4020 EXPECT_EQ("", Explain(m
, 2));
4023 TEST(ExplainmatcherResultTest
, MonomorphicMatcher
) {
4024 const Matcher
<int> m
= GreaterThan(5);
4025 EXPECT_EQ("which is 1 more than 5", Explain(m
, 6));
4028 // The following two tests verify that values without a public copy
4029 // ctor can be used as arguments to matchers like Eq(), Ge(), and etc
4030 // with the help of ByRef().
4034 explicit NotCopyable(int a_value
) : value_(a_value
) {}
4036 int value() const { return value_
; }
4038 bool operator==(const NotCopyable
& rhs
) const {
4039 return value() == rhs
.value();
4042 bool operator>=(const NotCopyable
& rhs
) const {
4043 return value() >= rhs
.value();
4048 GTEST_DISALLOW_COPY_AND_ASSIGN_(NotCopyable
);
4051 TEST(ByRefTest
, AllowsNotCopyableConstValueInMatchers
) {
4052 const NotCopyable
const_value1(1);
4053 const Matcher
<const NotCopyable
&> m
= Eq(ByRef(const_value1
));
4055 const NotCopyable
n1(1), n2(2);
4056 EXPECT_TRUE(m
.Matches(n1
));
4057 EXPECT_FALSE(m
.Matches(n2
));
4060 TEST(ByRefTest
, AllowsNotCopyableValueInMatchers
) {
4061 NotCopyable
value2(2);
4062 const Matcher
<NotCopyable
&> m
= Ge(ByRef(value2
));
4064 NotCopyable
n1(1), n2(2);
4065 EXPECT_FALSE(m
.Matches(n1
));
4066 EXPECT_TRUE(m
.Matches(n2
));
4069 TEST(IsEmptyTest
, ImplementsIsEmpty
) {
4070 vector
<int> container
;
4071 EXPECT_THAT(container
, IsEmpty());
4072 container
.push_back(0);
4073 EXPECT_THAT(container
, Not(IsEmpty()));
4074 container
.push_back(1);
4075 EXPECT_THAT(container
, Not(IsEmpty()));
4078 TEST(IsEmptyTest
, WorksWithString
) {
4080 EXPECT_THAT(text
, IsEmpty());
4082 EXPECT_THAT(text
, Not(IsEmpty()));
4083 text
= string("\0", 1);
4084 EXPECT_THAT(text
, Not(IsEmpty()));
4087 TEST(IsEmptyTest
, CanDescribeSelf
) {
4088 Matcher
<vector
<int> > m
= IsEmpty();
4089 EXPECT_EQ("is empty", Describe(m
));
4090 EXPECT_EQ("isn't empty", DescribeNegation(m
));
4093 TEST(IsEmptyTest
, ExplainsResult
) {
4094 Matcher
<vector
<int> > m
= IsEmpty();
4095 vector
<int> container
;
4096 EXPECT_EQ("", Explain(m
, container
));
4097 container
.push_back(0);
4098 EXPECT_EQ("whose size is 1", Explain(m
, container
));
4101 TEST(SizeIsTest
, ImplementsSizeIs
) {
4102 vector
<int> container
;
4103 EXPECT_THAT(container
, SizeIs(0));
4104 EXPECT_THAT(container
, Not(SizeIs(1)));
4105 container
.push_back(0);
4106 EXPECT_THAT(container
, Not(SizeIs(0)));
4107 EXPECT_THAT(container
, SizeIs(1));
4108 container
.push_back(0);
4109 EXPECT_THAT(container
, Not(SizeIs(0)));
4110 EXPECT_THAT(container
, SizeIs(2));
4113 TEST(SizeIsTest
, WorksWithMap
) {
4114 map
<string
, int> container
;
4115 EXPECT_THAT(container
, SizeIs(0));
4116 EXPECT_THAT(container
, Not(SizeIs(1)));
4117 container
.insert(make_pair("foo", 1));
4118 EXPECT_THAT(container
, Not(SizeIs(0)));
4119 EXPECT_THAT(container
, SizeIs(1));
4120 container
.insert(make_pair("bar", 2));
4121 EXPECT_THAT(container
, Not(SizeIs(0)));
4122 EXPECT_THAT(container
, SizeIs(2));
4125 TEST(SizeIsTest
, WorksWithReferences
) {
4126 vector
<int> container
;
4127 Matcher
<const vector
<int>&> m
= SizeIs(1);
4128 EXPECT_THAT(container
, Not(m
));
4129 container
.push_back(0);
4130 EXPECT_THAT(container
, m
);
4133 TEST(SizeIsTest
, CanDescribeSelf
) {
4134 Matcher
<vector
<int> > m
= SizeIs(2);
4135 EXPECT_EQ("size is equal to 2", Describe(m
));
4136 EXPECT_EQ("size isn't equal to 2", DescribeNegation(m
));
4139 TEST(SizeIsTest
, ExplainsResult
) {
4140 Matcher
<vector
<int> > m1
= SizeIs(2);
4141 Matcher
<vector
<int> > m2
= SizeIs(Lt(2u));
4142 Matcher
<vector
<int> > m3
= SizeIs(AnyOf(0, 3));
4143 Matcher
<vector
<int> > m4
= SizeIs(GreaterThan(1));
4144 vector
<int> container
;
4145 EXPECT_EQ("whose size 0 doesn't match", Explain(m1
, container
));
4146 EXPECT_EQ("whose size 0 matches", Explain(m2
, container
));
4147 EXPECT_EQ("whose size 0 matches", Explain(m3
, container
));
4148 EXPECT_EQ("whose size 0 doesn't match, which is 1 less than 1",
4149 Explain(m4
, container
));
4150 container
.push_back(0);
4151 container
.push_back(0);
4152 EXPECT_EQ("whose size 2 matches", Explain(m1
, container
));
4153 EXPECT_EQ("whose size 2 doesn't match", Explain(m2
, container
));
4154 EXPECT_EQ("whose size 2 doesn't match", Explain(m3
, container
));
4155 EXPECT_EQ("whose size 2 matches, which is 1 more than 1",
4156 Explain(m4
, container
));
4159 #if GTEST_HAS_TYPED_TEST
4160 // Tests ContainerEq with different container types, and
4161 // different element types.
4163 template <typename T
>
4164 class ContainerEqTest
: public testing::Test
{};
4166 typedef testing::Types
<
4171 ContainerEqTestTypes
;
4173 TYPED_TEST_CASE(ContainerEqTest
, ContainerEqTestTypes
);
4175 // Tests that the filled container is equal to itself.
4176 TYPED_TEST(ContainerEqTest
, EqualsSelf
) {
4177 static const int vals
[] = {1, 1, 2, 3, 5, 8};
4178 TypeParam
my_set(vals
, vals
+ 6);
4179 const Matcher
<TypeParam
> m
= ContainerEq(my_set
);
4180 EXPECT_TRUE(m
.Matches(my_set
));
4181 EXPECT_EQ("", Explain(m
, my_set
));
4184 // Tests that missing values are reported.
4185 TYPED_TEST(ContainerEqTest
, ValueMissing
) {
4186 static const int vals
[] = {1, 1, 2, 3, 5, 8};
4187 static const int test_vals
[] = {2, 1, 8, 5};
4188 TypeParam
my_set(vals
, vals
+ 6);
4189 TypeParam
test_set(test_vals
, test_vals
+ 4);
4190 const Matcher
<TypeParam
> m
= ContainerEq(my_set
);
4191 EXPECT_FALSE(m
.Matches(test_set
));
4192 EXPECT_EQ("which doesn't have these expected elements: 3",
4193 Explain(m
, test_set
));
4196 // Tests that added values are reported.
4197 TYPED_TEST(ContainerEqTest
, ValueAdded
) {
4198 static const int vals
[] = {1, 1, 2, 3, 5, 8};
4199 static const int test_vals
[] = {1, 2, 3, 5, 8, 46};
4200 TypeParam
my_set(vals
, vals
+ 6);
4201 TypeParam
test_set(test_vals
, test_vals
+ 6);
4202 const Matcher
<const TypeParam
&> m
= ContainerEq(my_set
);
4203 EXPECT_FALSE(m
.Matches(test_set
));
4204 EXPECT_EQ("which has these unexpected elements: 46", Explain(m
, test_set
));
4207 // Tests that added and missing values are reported together.
4208 TYPED_TEST(ContainerEqTest
, ValueAddedAndRemoved
) {
4209 static const int vals
[] = {1, 1, 2, 3, 5, 8};
4210 static const int test_vals
[] = {1, 2, 3, 8, 46};
4211 TypeParam
my_set(vals
, vals
+ 6);
4212 TypeParam
test_set(test_vals
, test_vals
+ 5);
4213 const Matcher
<TypeParam
> m
= ContainerEq(my_set
);
4214 EXPECT_FALSE(m
.Matches(test_set
));
4215 EXPECT_EQ("which has these unexpected elements: 46,\n"
4216 "and doesn't have these expected elements: 5",
4217 Explain(m
, test_set
));
4220 // Tests duplicated value -- expect no explanation.
4221 TYPED_TEST(ContainerEqTest
, DuplicateDifference
) {
4222 static const int vals
[] = {1, 1, 2, 3, 5, 8};
4223 static const int test_vals
[] = {1, 2, 3, 5, 8};
4224 TypeParam
my_set(vals
, vals
+ 6);
4225 TypeParam
test_set(test_vals
, test_vals
+ 5);
4226 const Matcher
<const TypeParam
&> m
= ContainerEq(my_set
);
4227 // Depending on the container, match may be true or false
4228 // But in any case there should be no explanation.
4229 EXPECT_EQ("", Explain(m
, test_set
));
4231 #endif // GTEST_HAS_TYPED_TEST
4233 // Tests that mutliple missing values are reported.
4234 // Using just vector here, so order is predicatble.
4235 TEST(ContainerEqExtraTest
, MultipleValuesMissing
) {
4236 static const int vals
[] = {1, 1, 2, 3, 5, 8};
4237 static const int test_vals
[] = {2, 1, 5};
4238 vector
<int> my_set(vals
, vals
+ 6);
4239 vector
<int> test_set(test_vals
, test_vals
+ 3);
4240 const Matcher
<vector
<int> > m
= ContainerEq(my_set
);
4241 EXPECT_FALSE(m
.Matches(test_set
));
4242 EXPECT_EQ("which doesn't have these expected elements: 3, 8",
4243 Explain(m
, test_set
));
4246 // Tests that added values are reported.
4247 // Using just vector here, so order is predicatble.
4248 TEST(ContainerEqExtraTest
, MultipleValuesAdded
) {
4249 static const int vals
[] = {1, 1, 2, 3, 5, 8};
4250 static const int test_vals
[] = {1, 2, 92, 3, 5, 8, 46};
4251 list
<size_t> my_set(vals
, vals
+ 6);
4252 list
<size_t> test_set(test_vals
, test_vals
+ 7);
4253 const Matcher
<const list
<size_t>&> m
= ContainerEq(my_set
);
4254 EXPECT_FALSE(m
.Matches(test_set
));
4255 EXPECT_EQ("which has these unexpected elements: 92, 46",
4256 Explain(m
, test_set
));
4259 // Tests that added and missing values are reported together.
4260 TEST(ContainerEqExtraTest
, MultipleValuesAddedAndRemoved
) {
4261 static const int vals
[] = {1, 1, 2, 3, 5, 8};
4262 static const int test_vals
[] = {1, 2, 3, 92, 46};
4263 list
<size_t> my_set(vals
, vals
+ 6);
4264 list
<size_t> test_set(test_vals
, test_vals
+ 5);
4265 const Matcher
<const list
<size_t> > m
= ContainerEq(my_set
);
4266 EXPECT_FALSE(m
.Matches(test_set
));
4267 EXPECT_EQ("which has these unexpected elements: 92, 46,\n"
4268 "and doesn't have these expected elements: 5, 8",
4269 Explain(m
, test_set
));
4272 // Tests to see that duplicate elements are detected,
4273 // but (as above) not reported in the explanation.
4274 TEST(ContainerEqExtraTest
, MultiSetOfIntDuplicateDifference
) {
4275 static const int vals
[] = {1, 1, 2, 3, 5, 8};
4276 static const int test_vals
[] = {1, 2, 3, 5, 8};
4277 vector
<int> my_set(vals
, vals
+ 6);
4278 vector
<int> test_set(test_vals
, test_vals
+ 5);
4279 const Matcher
<vector
<int> > m
= ContainerEq(my_set
);
4280 EXPECT_TRUE(m
.Matches(my_set
));
4281 EXPECT_FALSE(m
.Matches(test_set
));
4282 // There is nothing to report when both sets contain all the same values.
4283 EXPECT_EQ("", Explain(m
, test_set
));
4286 // Tests that ContainerEq works for non-trivial associative containers,
4288 TEST(ContainerEqExtraTest
, WorksForMaps
) {
4289 map
<int, std::string
> my_map
;
4293 map
<int, std::string
> test_map
;
4297 const Matcher
<const map
<int, std::string
>&> m
= ContainerEq(my_map
);
4298 EXPECT_TRUE(m
.Matches(my_map
));
4299 EXPECT_FALSE(m
.Matches(test_map
));
4301 EXPECT_EQ("which has these unexpected elements: (0, \"aa\"),\n"
4302 "and doesn't have these expected elements: (0, \"a\")",
4303 Explain(m
, test_map
));
4306 TEST(ContainerEqExtraTest
, WorksForNativeArray
) {
4307 int a1
[] = {1, 2, 3};
4308 int a2
[] = {1, 2, 3};
4309 int b
[] = {1, 2, 4};
4311 EXPECT_THAT(a1
, ContainerEq(a2
));
4312 EXPECT_THAT(a1
, Not(ContainerEq(b
)));
4315 TEST(ContainerEqExtraTest
, WorksForTwoDimensionalNativeArray
) {
4316 const char a1
[][3] = {"hi", "lo"};
4317 const char a2
[][3] = {"hi", "lo"};
4318 const char b
[][3] = {"lo", "hi"};
4320 // Tests using ContainerEq() in the first dimension.
4321 EXPECT_THAT(a1
, ContainerEq(a2
));
4322 EXPECT_THAT(a1
, Not(ContainerEq(b
)));
4324 // Tests using ContainerEq() in the second dimension.
4325 EXPECT_THAT(a1
, ElementsAre(ContainerEq(a2
[0]), ContainerEq(a2
[1])));
4326 EXPECT_THAT(a1
, ElementsAre(Not(ContainerEq(b
[0])), ContainerEq(a2
[1])));
4329 TEST(ContainerEqExtraTest
, WorksForNativeArrayAsTuple
) {
4330 const int a1
[] = {1, 2, 3};
4331 const int a2
[] = {1, 2, 3};
4332 const int b
[] = {1, 2, 3, 4};
4334 const int* const p1
= a1
;
4335 EXPECT_THAT(make_tuple(p1
, 3), ContainerEq(a2
));
4336 EXPECT_THAT(make_tuple(p1
, 3), Not(ContainerEq(b
)));
4338 const int c
[] = {1, 3, 2};
4339 EXPECT_THAT(make_tuple(p1
, 3), Not(ContainerEq(c
)));
4342 TEST(ContainerEqExtraTest
, CopiesNativeArrayParameter
) {
4343 std::string a1
[][3] = {
4344 {"hi", "hello", "ciao"},
4345 {"bye", "see you", "ciao"}
4348 std::string a2
[][3] = {
4349 {"hi", "hello", "ciao"},
4350 {"bye", "see you", "ciao"}
4353 const Matcher
<const std::string(&)[2][3]> m
= ContainerEq(a2
);
4360 TEST(WhenSortedByTest
, WorksForEmptyContainer
) {
4361 const vector
<int> numbers
;
4362 EXPECT_THAT(numbers
, WhenSortedBy(less
<int>(), ElementsAre()));
4363 EXPECT_THAT(numbers
, Not(WhenSortedBy(less
<int>(), ElementsAre(1))));
4366 TEST(WhenSortedByTest
, WorksForNonEmptyContainer
) {
4367 vector
<unsigned> numbers
;
4368 numbers
.push_back(3);
4369 numbers
.push_back(1);
4370 numbers
.push_back(2);
4371 numbers
.push_back(2);
4372 EXPECT_THAT(numbers
, WhenSortedBy(greater
<unsigned>(),
4373 ElementsAre(3, 2, 2, 1)));
4374 EXPECT_THAT(numbers
, Not(WhenSortedBy(greater
<unsigned>(),
4375 ElementsAre(1, 2, 2, 3))));
4378 TEST(WhenSortedByTest
, WorksForNonVectorContainer
) {
4380 words
.push_back("say");
4381 words
.push_back("hello");
4382 words
.push_back("world");
4383 EXPECT_THAT(words
, WhenSortedBy(less
<string
>(),
4384 ElementsAre("hello", "say", "world")));
4385 EXPECT_THAT(words
, Not(WhenSortedBy(less
<string
>(),
4386 ElementsAre("say", "hello", "world"))));
4389 TEST(WhenSortedByTest
, WorksForNativeArray
) {
4390 const int numbers
[] = {1, 3, 2, 4};
4391 const int sorted_numbers
[] = {1, 2, 3, 4};
4392 EXPECT_THAT(numbers
, WhenSortedBy(less
<int>(), ElementsAre(1, 2, 3, 4)));
4393 EXPECT_THAT(numbers
, WhenSortedBy(less
<int>(),
4394 ElementsAreArray(sorted_numbers
)));
4395 EXPECT_THAT(numbers
, Not(WhenSortedBy(less
<int>(), ElementsAre(1, 3, 2, 4))));
4398 TEST(WhenSortedByTest
, CanDescribeSelf
) {
4399 const Matcher
<vector
<int> > m
= WhenSortedBy(less
<int>(), ElementsAre(1, 2));
4400 EXPECT_EQ("(when sorted) has 2 elements where\n"
4401 "element #0 is equal to 1,\n"
4402 "element #1 is equal to 2",
4404 EXPECT_EQ("(when sorted) doesn't have 2 elements, or\n"
4405 "element #0 isn't equal to 1, or\n"
4406 "element #1 isn't equal to 2",
4407 DescribeNegation(m
));
4410 TEST(WhenSortedByTest
, ExplainsMatchResult
) {
4411 const int a
[] = {2, 1};
4412 EXPECT_EQ("which is { 1, 2 } when sorted, whose element #0 doesn't match",
4413 Explain(WhenSortedBy(less
<int>(), ElementsAre(2, 3)), a
));
4414 EXPECT_EQ("which is { 1, 2 } when sorted",
4415 Explain(WhenSortedBy(less
<int>(), ElementsAre(1, 2)), a
));
4418 // WhenSorted() is a simple wrapper on WhenSortedBy(). Hence we don't
4419 // need to test it as exhaustively as we test the latter.
4421 TEST(WhenSortedTest
, WorksForEmptyContainer
) {
4422 const vector
<int> numbers
;
4423 EXPECT_THAT(numbers
, WhenSorted(ElementsAre()));
4424 EXPECT_THAT(numbers
, Not(WhenSorted(ElementsAre(1))));
4427 TEST(WhenSortedTest
, WorksForNonEmptyContainer
) {
4429 words
.push_back("3");
4430 words
.push_back("1");
4431 words
.push_back("2");
4432 words
.push_back("2");
4433 EXPECT_THAT(words
, WhenSorted(ElementsAre("1", "2", "2", "3")));
4434 EXPECT_THAT(words
, Not(WhenSorted(ElementsAre("3", "1", "2", "2"))));
4437 TEST(WhenSortedTest
, WorksForMapTypes
) {
4438 map
<string
, int> word_counts
;
4439 word_counts
["and"] = 1;
4440 word_counts
["the"] = 1;
4441 word_counts
["buffalo"] = 2;
4442 EXPECT_THAT(word_counts
, WhenSorted(ElementsAre(
4443 Pair("and", 1), Pair("buffalo", 2), Pair("the", 1))));
4444 EXPECT_THAT(word_counts
, Not(WhenSorted(ElementsAre(
4445 Pair("and", 1), Pair("the", 1), Pair("buffalo", 2)))));
4448 TEST(WhenSortedTest
, WorksForMultiMapTypes
) {
4449 multimap
<int, int> ifib
;
4450 ifib
.insert(make_pair(8, 6));
4451 ifib
.insert(make_pair(2, 3));
4452 ifib
.insert(make_pair(1, 1));
4453 ifib
.insert(make_pair(3, 4));
4454 ifib
.insert(make_pair(1, 2));
4455 ifib
.insert(make_pair(5, 5));
4456 EXPECT_THAT(ifib
, WhenSorted(ElementsAre(Pair(1, 1),
4462 EXPECT_THAT(ifib
, Not(WhenSorted(ElementsAre(Pair(8, 6),
4470 TEST(WhenSortedTest
, WorksForPolymorphicMatcher
) {
4474 EXPECT_THAT(d
, WhenSorted(ElementsAre(1, 2)));
4475 EXPECT_THAT(d
, Not(WhenSorted(ElementsAre(2, 1))));
4478 TEST(WhenSortedTest
, WorksForVectorConstRefMatcher
) {
4482 Matcher
<const std::vector
<int>&> vector_match
= ElementsAre(1, 2);
4483 EXPECT_THAT(d
, WhenSorted(vector_match
));
4484 Matcher
<const std::vector
<int>&> not_vector_match
= ElementsAre(2, 1);
4485 EXPECT_THAT(d
, Not(WhenSorted(not_vector_match
)));
4488 // Deliberately bare pseudo-container.
4489 // Offers only begin() and end() accessors, yielding InputIterator.
4490 template <typename T
>
4495 typedef ConstIter const_iterator
;
4496 typedef T value_type
;
4498 template <typename InIter
>
4499 Streamlike(InIter first
, InIter last
) : remainder_(first
, last
) {}
4501 const_iterator
begin() const {
4502 return const_iterator(this, remainder_
.begin());
4504 const_iterator
end() const {
4505 return const_iterator(this, remainder_
.end());
4509 class ConstIter
: public std::iterator
<std::input_iterator_tag
,
4513 const value_type
&> {
4515 ConstIter(const Streamlike
* s
,
4516 typename
std::list
<value_type
>::iterator pos
)
4517 : s_(s
), pos_(pos
) {}
4519 const value_type
& operator*() const { return *pos_
; }
4520 const value_type
* operator->() const { return &*pos_
; }
4521 ConstIter
& operator++() {
4522 s_
->remainder_
.erase(pos_
++);
4526 // *iter++ is required to work (see std::istreambuf_iterator).
4527 // (void)iter++ is also required to work.
4528 class PostIncrProxy
{
4530 explicit PostIncrProxy(const value_type
& value
) : value_(value
) {}
4531 value_type
operator*() const { return value_
; }
4535 PostIncrProxy
operator++(int) {
4536 PostIncrProxy
proxy(**this);
4541 friend bool operator==(const ConstIter
& a
, const ConstIter
& b
) {
4542 return a
.s_
== b
.s_
&& a
.pos_
== b
.pos_
;
4544 friend bool operator!=(const ConstIter
& a
, const ConstIter
& b
) {
4549 const Streamlike
* s_
;
4550 typename
std::list
<value_type
>::iterator pos_
;
4553 friend std::ostream
& operator<<(std::ostream
& os
, const Streamlike
& s
) {
4555 typedef typename
std::list
<value_type
>::const_iterator Iter
;
4556 const char* sep
= "";
4557 for (Iter it
= s
.remainder_
.begin(); it
!= s
.remainder_
.end(); ++it
) {
4565 mutable std::list
<value_type
> remainder_
; // modified by iteration
4568 TEST(StreamlikeTest
, Iteration
) {
4569 const int a
[5] = {2, 1, 4, 5, 3};
4570 Streamlike
<int> s(a
, a
+ 5);
4571 Streamlike
<int>::const_iterator it
= s
.begin();
4573 while (it
!= s
.end()) {
4574 SCOPED_TRACE(ip
- a
);
4575 EXPECT_EQ(*ip
++, *it
++);
4579 #if GTEST_HAS_STD_FORWARD_LIST_
4580 TEST(BeginEndDistanceIsTest
, WorksWithForwardList
) {
4581 std::forward_list
<int> container
;
4582 EXPECT_THAT(container
, BeginEndDistanceIs(0));
4583 EXPECT_THAT(container
, Not(BeginEndDistanceIs(1)));
4584 container
.push_front(0);
4585 EXPECT_THAT(container
, Not(BeginEndDistanceIs(0)));
4586 EXPECT_THAT(container
, BeginEndDistanceIs(1));
4587 container
.push_front(0);
4588 EXPECT_THAT(container
, Not(BeginEndDistanceIs(0)));
4589 EXPECT_THAT(container
, BeginEndDistanceIs(2));
4591 #endif // GTEST_HAS_STD_FORWARD_LIST_
4593 TEST(BeginEndDistanceIsTest
, WorksWithNonStdList
) {
4594 const int a
[5] = {1, 2, 3, 4, 5};
4595 Streamlike
<int> s(a
, a
+ 5);
4596 EXPECT_THAT(s
, BeginEndDistanceIs(5));
4599 TEST(BeginEndDistanceIsTest
, CanDescribeSelf
) {
4600 Matcher
<vector
<int> > m
= BeginEndDistanceIs(2);
4601 EXPECT_EQ("distance between begin() and end() is equal to 2", Describe(m
));
4602 EXPECT_EQ("distance between begin() and end() isn't equal to 2",
4603 DescribeNegation(m
));
4606 TEST(BeginEndDistanceIsTest
, ExplainsResult
) {
4607 Matcher
<vector
<int> > m1
= BeginEndDistanceIs(2);
4608 Matcher
<vector
<int> > m2
= BeginEndDistanceIs(Lt(2));
4609 Matcher
<vector
<int> > m3
= BeginEndDistanceIs(AnyOf(0, 3));
4610 Matcher
<vector
<int> > m4
= BeginEndDistanceIs(GreaterThan(1));
4611 vector
<int> container
;
4612 EXPECT_EQ("whose distance between begin() and end() 0 doesn't match",
4613 Explain(m1
, container
));
4614 EXPECT_EQ("whose distance between begin() and end() 0 matches",
4615 Explain(m2
, container
));
4616 EXPECT_EQ("whose distance between begin() and end() 0 matches",
4617 Explain(m3
, container
));
4619 "whose distance between begin() and end() 0 doesn't match, which is 1 "
4621 Explain(m4
, container
));
4622 container
.push_back(0);
4623 container
.push_back(0);
4624 EXPECT_EQ("whose distance between begin() and end() 2 matches",
4625 Explain(m1
, container
));
4626 EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
4627 Explain(m2
, container
));
4628 EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
4629 Explain(m3
, container
));
4631 "whose distance between begin() and end() 2 matches, which is 1 more "
4633 Explain(m4
, container
));
4636 TEST(WhenSortedTest
, WorksForStreamlike
) {
4637 // Streamlike 'container' provides only minimal iterator support.
4638 // Its iterators are tagged with input_iterator_tag.
4639 const int a
[5] = {2, 1, 4, 5, 3};
4640 Streamlike
<int> s(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4641 EXPECT_THAT(s
, WhenSorted(ElementsAre(1, 2, 3, 4, 5)));
4642 EXPECT_THAT(s
, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
4645 TEST(WhenSortedTest
, WorksForVectorConstRefMatcherOnStreamlike
) {
4646 const int a
[] = {2, 1, 4, 5, 3};
4647 Streamlike
<int> s(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4648 Matcher
<const std::vector
<int>&> vector_match
= ElementsAre(1, 2, 3, 4, 5);
4649 EXPECT_THAT(s
, WhenSorted(vector_match
));
4650 EXPECT_THAT(s
, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
4653 // Tests using ElementsAre() and ElementsAreArray() with stream-like
4656 TEST(ElemensAreStreamTest
, WorksForStreamlike
) {
4657 const int a
[5] = {1, 2, 3, 4, 5};
4658 Streamlike
<int> s(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4659 EXPECT_THAT(s
, ElementsAre(1, 2, 3, 4, 5));
4660 EXPECT_THAT(s
, Not(ElementsAre(2, 1, 4, 5, 3)));
4663 TEST(ElemensAreArrayStreamTest
, WorksForStreamlike
) {
4664 const int a
[5] = {1, 2, 3, 4, 5};
4665 Streamlike
<int> s(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4667 vector
<int> expected
;
4668 expected
.push_back(1);
4669 expected
.push_back(2);
4670 expected
.push_back(3);
4671 expected
.push_back(4);
4672 expected
.push_back(5);
4673 EXPECT_THAT(s
, ElementsAreArray(expected
));
4676 EXPECT_THAT(s
, Not(ElementsAreArray(expected
)));
4679 TEST(ElementsAreTest
, WorksWithUncopyable
) {
4681 objs
[0].set_value(-3);
4682 objs
[1].set_value(1);
4683 EXPECT_THAT(objs
, ElementsAre(UncopyableIs(-3), Truly(ValueIsPositive
)));
4686 TEST(ElementsAreTest
, TakesStlContainer
) {
4687 const int actual
[] = {3, 1, 2};
4689 ::std::list
<int> expected
;
4690 expected
.push_back(3);
4691 expected
.push_back(1);
4692 expected
.push_back(2);
4693 EXPECT_THAT(actual
, ElementsAreArray(expected
));
4695 expected
.push_back(4);
4696 EXPECT_THAT(actual
, Not(ElementsAreArray(expected
)));
4699 // Tests for UnorderedElementsAreArray()
4701 TEST(UnorderedElementsAreArrayTest
, SucceedsWhenExpected
) {
4702 const int a
[] = {0, 1, 2, 3, 4};
4703 std::vector
<int> s(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4705 StringMatchResultListener listener
;
4706 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(a
),
4707 s
, &listener
)) << listener
.str();
4708 } while (std::next_permutation(s
.begin(), s
.end()));
4711 TEST(UnorderedElementsAreArrayTest
, VectorBool
) {
4712 const bool a
[] = {0, 1, 0, 1, 1};
4713 const bool b
[] = {1, 0, 1, 1, 0};
4714 std::vector
<bool> expected(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4715 std::vector
<bool> actual(b
, b
+ GTEST_ARRAY_SIZE_(b
));
4716 StringMatchResultListener listener
;
4717 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(expected
),
4718 actual
, &listener
)) << listener
.str();
4721 TEST(UnorderedElementsAreArrayTest
, WorksForStreamlike
) {
4722 // Streamlike 'container' provides only minimal iterator support.
4723 // Its iterators are tagged with input_iterator_tag, and it has no
4724 // size() or empty() methods.
4725 const int a
[5] = {2, 1, 4, 5, 3};
4726 Streamlike
<int> s(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4728 ::std::vector
<int> expected
;
4729 expected
.push_back(1);
4730 expected
.push_back(2);
4731 expected
.push_back(3);
4732 expected
.push_back(4);
4733 expected
.push_back(5);
4734 EXPECT_THAT(s
, UnorderedElementsAreArray(expected
));
4736 expected
.push_back(6);
4737 EXPECT_THAT(s
, Not(UnorderedElementsAreArray(expected
)));
4740 TEST(UnorderedElementsAreArrayTest
, TakesStlContainer
) {
4741 const int actual
[] = {3, 1, 2};
4743 ::std::list
<int> expected
;
4744 expected
.push_back(1);
4745 expected
.push_back(2);
4746 expected
.push_back(3);
4747 EXPECT_THAT(actual
, UnorderedElementsAreArray(expected
));
4749 expected
.push_back(4);
4750 EXPECT_THAT(actual
, Not(UnorderedElementsAreArray(expected
)));
4753 #if GTEST_HAS_STD_INITIALIZER_LIST_
4755 TEST(UnorderedElementsAreArrayTest
, TakesInitializerList
) {
4756 const int a
[5] = {2, 1, 4, 5, 3};
4757 EXPECT_THAT(a
, UnorderedElementsAreArray({1, 2, 3, 4, 5}));
4758 EXPECT_THAT(a
, Not(UnorderedElementsAreArray({1, 2, 3, 4, 6})));
4761 TEST(UnorderedElementsAreArrayTest
, TakesInitializerListOfCStrings
) {
4762 const string a
[5] = {"a", "b", "c", "d", "e"};
4763 EXPECT_THAT(a
, UnorderedElementsAreArray({"a", "b", "c", "d", "e"}));
4764 EXPECT_THAT(a
, Not(UnorderedElementsAreArray({"a", "b", "c", "d", "ef"})));
4767 TEST(UnorderedElementsAreArrayTest
, TakesInitializerListOfSameTypedMatchers
) {
4768 const int a
[5] = {2, 1, 4, 5, 3};
4769 EXPECT_THAT(a
, UnorderedElementsAreArray(
4770 {Eq(1), Eq(2), Eq(3), Eq(4), Eq(5)}));
4771 EXPECT_THAT(a
, Not(UnorderedElementsAreArray(
4772 {Eq(1), Eq(2), Eq(3), Eq(4), Eq(6)})));
4775 TEST(UnorderedElementsAreArrayTest
,
4776 TakesInitializerListOfDifferentTypedMatchers
) {
4777 const int a
[5] = {2, 1, 4, 5, 3};
4778 // The compiler cannot infer the type of the initializer list if its
4779 // elements have different types. We must explicitly specify the
4780 // unified element type in this case.
4781 EXPECT_THAT(a
, UnorderedElementsAreArray
<Matcher
<int> >(
4782 {Eq(1), Ne(-2), Ge(3), Le(4), Eq(5)}));
4783 EXPECT_THAT(a
, Not(UnorderedElementsAreArray
<Matcher
<int> >(
4784 {Eq(1), Ne(-2), Ge(3), Le(4), Eq(6)})));
4787 #endif // GTEST_HAS_STD_INITIALIZER_LIST_
4789 class UnorderedElementsAreTest
: public testing::Test
{
4791 typedef std::vector
<int> IntVec
;
4794 TEST_F(UnorderedElementsAreTest
, WorksWithUncopyable
) {
4796 objs
[0].set_value(-3);
4797 objs
[1].set_value(1);
4799 UnorderedElementsAre(Truly(ValueIsPositive
), UncopyableIs(-3)));
4802 TEST_F(UnorderedElementsAreTest
, SucceedsWhenExpected
) {
4803 const int a
[] = {1, 2, 3};
4804 std::vector
<int> s(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4806 StringMatchResultListener listener
;
4807 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
4808 s
, &listener
)) << listener
.str();
4809 } while (std::next_permutation(s
.begin(), s
.end()));
4812 TEST_F(UnorderedElementsAreTest
, FailsWhenAnElementMatchesNoMatcher
) {
4813 const int a
[] = {1, 2, 3};
4814 std::vector
<int> s(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4815 std::vector
<Matcher
<int> > mv
;
4819 // The element with value '3' matches nothing: fail fast.
4820 StringMatchResultListener listener
;
4821 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAreArray(mv
),
4822 s
, &listener
)) << listener
.str();
4825 TEST_F(UnorderedElementsAreTest
, WorksForStreamlike
) {
4826 // Streamlike 'container' provides only minimal iterator support.
4827 // Its iterators are tagged with input_iterator_tag, and it has no
4828 // size() or empty() methods.
4829 const int a
[5] = {2, 1, 4, 5, 3};
4830 Streamlike
<int> s(a
, a
+ GTEST_ARRAY_SIZE_(a
));
4832 EXPECT_THAT(s
, UnorderedElementsAre(1, 2, 3, 4, 5));
4833 EXPECT_THAT(s
, Not(UnorderedElementsAre(2, 2, 3, 4, 5)));
4836 // One naive implementation of the matcher runs in O(N!) time, which is too
4837 // slow for many real-world inputs. This test shows that our matcher can match
4838 // 100 inputs very quickly (a few milliseconds). An O(100!) is 10^158
4839 // iterations and obviously effectively incomputable.
4840 // [ RUN ] UnorderedElementsAreTest.Performance
4841 // [ OK ] UnorderedElementsAreTest.Performance (4 ms)
4842 TEST_F(UnorderedElementsAreTest
, Performance
) {
4844 std::vector
<Matcher
<int> > mv
;
4845 for (int i
= 0; i
< 100; ++i
) {
4850 StringMatchResultListener listener
;
4851 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv
),
4852 s
, &listener
)) << listener
.str();
4855 // Another variant of 'Performance' with similar expectations.
4856 // [ RUN ] UnorderedElementsAreTest.PerformanceHalfStrict
4857 // [ OK ] UnorderedElementsAreTest.PerformanceHalfStrict (4 ms)
4858 TEST_F(UnorderedElementsAreTest
, PerformanceHalfStrict
) {
4860 std::vector
<Matcher
<int> > mv
;
4861 for (int i
= 0; i
< 100; ++i
) {
4869 StringMatchResultListener listener
;
4870 EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv
),
4871 s
, &listener
)) << listener
.str();
4874 TEST_F(UnorderedElementsAreTest
, FailMessageCountWrong
) {
4877 StringMatchResultListener listener
;
4878 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
4879 v
, &listener
)) << listener
.str();
4880 EXPECT_THAT(listener
.str(), Eq("which has 1 element"));
4883 TEST_F(UnorderedElementsAreTest
, FailMessageCountWrongZero
) {
4885 StringMatchResultListener listener
;
4886 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
4887 v
, &listener
)) << listener
.str();
4888 EXPECT_THAT(listener
.str(), Eq(""));
4891 TEST_F(UnorderedElementsAreTest
, FailMessageUnmatchedMatchers
) {
4895 StringMatchResultListener listener
;
4896 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
4897 v
, &listener
)) << listener
.str();
4900 Eq("where the following matchers don't match any elements:\n"
4901 "matcher #1: is equal to 2"));
4904 TEST_F(UnorderedElementsAreTest
, FailMessageUnmatchedElements
) {
4908 StringMatchResultListener listener
;
4909 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 1),
4910 v
, &listener
)) << listener
.str();
4913 Eq("where the following elements don't match any matchers:\n"
4917 TEST_F(UnorderedElementsAreTest
, FailMessageUnmatchedMatcherAndElement
) {
4921 StringMatchResultListener listener
;
4922 EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
4923 v
, &listener
)) << listener
.str();
4927 " the following matchers don't match any elements:\n"
4928 "matcher #0: is equal to 1\n"
4931 " the following elements don't match any matchers:\n"
4935 // Test helper for formatting element, matcher index pairs in expectations.
4936 static string
EMString(int element
, int matcher
) {
4938 ss
<< "(element #" << element
<< ", matcher #" << matcher
<< ")";
4942 TEST_F(UnorderedElementsAreTest
, FailMessageImperfectMatchOnly
) {
4943 // A situation where all elements and matchers have a match
4944 // associated with them, but the max matching is not perfect.
4945 std::vector
<string
> v
;
4949 StringMatchResultListener listener
;
4950 EXPECT_FALSE(ExplainMatchResult(
4951 UnorderedElementsAre("a", "a", AnyOf("b", "c")), v
, &listener
))
4955 "where no permutation of the elements can satisfy all matchers, "
4956 "and the closest match is 2 of 3 matchers with the "
4959 // We have to be a bit loose here, because there are 4 valid max matches.
4962 AnyOf(prefix
+ "{\n " + EMString(0, 0) +
4963 ",\n " + EMString(1, 2) + "\n}",
4964 prefix
+ "{\n " + EMString(0, 1) +
4965 ",\n " + EMString(1, 2) + "\n}",
4966 prefix
+ "{\n " + EMString(0, 0) +
4967 ",\n " + EMString(2, 2) + "\n}",
4968 prefix
+ "{\n " + EMString(0, 1) +
4969 ",\n " + EMString(2, 2) + "\n}"));
4972 TEST_F(UnorderedElementsAreTest
, Describe
) {
4973 EXPECT_THAT(Describe
<IntVec
>(UnorderedElementsAre()),
4976 Describe
<IntVec
>(UnorderedElementsAre(345)),
4977 Eq("has 1 element and that element is equal to 345"));
4979 Describe
<IntVec
>(UnorderedElementsAre(111, 222, 333)),
4980 Eq("has 3 elements and there exists some permutation "
4981 "of elements such that:\n"
4982 " - element #0 is equal to 111, and\n"
4983 " - element #1 is equal to 222, and\n"
4984 " - element #2 is equal to 333"));
4987 TEST_F(UnorderedElementsAreTest
, DescribeNegation
) {
4988 EXPECT_THAT(DescribeNegation
<IntVec
>(UnorderedElementsAre()),
4991 DescribeNegation
<IntVec
>(UnorderedElementsAre(345)),
4992 Eq("doesn't have 1 element, or has 1 element that isn't equal to 345"));
4994 DescribeNegation
<IntVec
>(UnorderedElementsAre(123, 234, 345)),
4995 Eq("doesn't have 3 elements, or there exists no permutation "
4996 "of elements such that:\n"
4997 " - element #0 is equal to 123, and\n"
4998 " - element #1 is equal to 234, and\n"
4999 " - element #2 is equal to 345"));
5004 // Used as a check on the more complex max flow method used in the
5005 // real testing::internal::FindMaxBipartiteMatching. This method is
5006 // compatible but runs in worst-case factorial time, so we only
5007 // use it in testing for small problem sizes.
5008 template <typename Graph
>
5009 class BacktrackingMaxBPMState
{
5011 // Does not take ownership of 'g'.
5012 explicit BacktrackingMaxBPMState(const Graph
* g
) : graph_(g
) { }
5014 ElementMatcherPairs
Compute() {
5015 if (graph_
->LhsSize() == 0 || graph_
->RhsSize() == 0) {
5016 return best_so_far_
;
5018 lhs_used_
.assign(graph_
->LhsSize(), kUnused
);
5019 rhs_used_
.assign(graph_
->RhsSize(), kUnused
);
5020 for (size_t irhs
= 0; irhs
< graph_
->RhsSize(); ++irhs
) {
5023 if (best_so_far_
.size() == graph_
->RhsSize())
5026 return best_so_far_
;
5030 static const size_t kUnused
= static_cast<size_t>(-1);
5032 void PushMatch(size_t lhs
, size_t rhs
) {
5033 matches_
.push_back(ElementMatcherPair(lhs
, rhs
));
5034 lhs_used_
[lhs
] = rhs
;
5035 rhs_used_
[rhs
] = lhs
;
5036 if (matches_
.size() > best_so_far_
.size()) {
5037 best_so_far_
= matches_
;
5042 const ElementMatcherPair
& back
= matches_
.back();
5043 lhs_used_
[back
.first
] = kUnused
;
5044 rhs_used_
[back
.second
] = kUnused
;
5045 matches_
.pop_back();
5048 bool RecurseInto(size_t irhs
) {
5049 if (rhs_used_
[irhs
] != kUnused
) {
5052 for (size_t ilhs
= 0; ilhs
< graph_
->LhsSize(); ++ilhs
) {
5053 if (lhs_used_
[ilhs
] != kUnused
) {
5056 if (!graph_
->HasEdge(ilhs
, irhs
)) {
5059 PushMatch(ilhs
, irhs
);
5060 if (best_so_far_
.size() == graph_
->RhsSize()) {
5063 for (size_t mi
= irhs
+ 1; mi
< graph_
->RhsSize(); ++mi
) {
5064 if (!RecurseInto(mi
)) return false;
5071 const Graph
* graph_
; // not owned
5072 std::vector
<size_t> lhs_used_
;
5073 std::vector
<size_t> rhs_used_
;
5074 ElementMatcherPairs matches_
;
5075 ElementMatcherPairs best_so_far_
;
5078 template <typename Graph
>
5079 const size_t BacktrackingMaxBPMState
<Graph
>::kUnused
;
5083 // Implement a simple backtracking algorithm to determine if it is possible
5084 // to find one element per matcher, without reusing elements.
5085 template <typename Graph
>
5087 FindBacktrackingMaxBPM(const Graph
& g
) {
5088 return BacktrackingMaxBPMState
<Graph
>(&g
).Compute();
5091 class BacktrackingBPMTest
: public ::testing::Test
{ };
5093 // Tests the MaxBipartiteMatching algorithm with square matrices.
5094 // The single int param is the # of nodes on each of the left and right sides.
5095 class BipartiteTest
: public ::testing::TestWithParam
<int> { };
5097 // Verify all match graphs up to some moderate number of edges.
5098 TEST_P(BipartiteTest
, Exhaustive
) {
5099 int nodes
= GetParam();
5100 MatchMatrix
graph(nodes
, nodes
);
5102 ElementMatcherPairs matches
=
5103 internal::FindMaxBipartiteMatching(graph
);
5104 EXPECT_EQ(FindBacktrackingMaxBPM(graph
).size(), matches
.size())
5105 << "graph: " << graph
.DebugString();
5106 // Check that all elements of matches are in the graph.
5107 // Check that elements of first and second are unique.
5108 std::vector
<bool> seen_element(graph
.LhsSize());
5109 std::vector
<bool> seen_matcher(graph
.RhsSize());
5110 SCOPED_TRACE(PrintToString(matches
));
5111 for (size_t i
= 0; i
< matches
.size(); ++i
) {
5112 size_t ilhs
= matches
[i
].first
;
5113 size_t irhs
= matches
[i
].second
;
5114 EXPECT_TRUE(graph
.HasEdge(ilhs
, irhs
));
5115 EXPECT_FALSE(seen_element
[ilhs
]);
5116 EXPECT_FALSE(seen_matcher
[irhs
]);
5117 seen_element
[ilhs
] = true;
5118 seen_matcher
[irhs
] = true;
5120 } while (graph
.NextGraph());
5123 INSTANTIATE_TEST_CASE_P(AllGraphs
, BipartiteTest
,
5124 ::testing::Range(0, 5));
5126 // Parameterized by a pair interpreted as (LhsSize, RhsSize).
5127 class BipartiteNonSquareTest
5128 : public ::testing::TestWithParam
<std::pair
<size_t, size_t> > {
5131 TEST_F(BipartiteNonSquareTest
, SimpleBacktracking
) {
5139 MatchMatrix
g(4, 3);
5140 static const int kEdges
[][2] = {{0, 2}, {1, 1}, {2, 1}, {3, 0}};
5141 for (size_t i
= 0; i
< GTEST_ARRAY_SIZE_(kEdges
); ++i
) {
5142 g
.SetEdge(kEdges
[i
][0], kEdges
[i
][1], true);
5144 EXPECT_THAT(FindBacktrackingMaxBPM(g
),
5145 ElementsAre(Pair(3, 0),
5146 Pair(AnyOf(1, 2), 1),
5147 Pair(0, 2))) << g
.DebugString();
5150 // Verify a few nonsquare matrices.
5151 TEST_P(BipartiteNonSquareTest
, Exhaustive
) {
5152 size_t nlhs
= GetParam().first
;
5153 size_t nrhs
= GetParam().second
;
5154 MatchMatrix
graph(nlhs
, nrhs
);
5156 EXPECT_EQ(FindBacktrackingMaxBPM(graph
).size(),
5157 internal::FindMaxBipartiteMatching(graph
).size())
5158 << "graph: " << graph
.DebugString()
5159 << "\nbacktracking: "
5160 << PrintToString(FindBacktrackingMaxBPM(graph
))
5162 << PrintToString(internal::FindMaxBipartiteMatching(graph
));
5163 } while (graph
.NextGraph());
5166 INSTANTIATE_TEST_CASE_P(AllGraphs
, BipartiteNonSquareTest
,
5168 std::make_pair(1, 2),
5169 std::make_pair(2, 1),
5170 std::make_pair(3, 2),
5171 std::make_pair(2, 3),
5172 std::make_pair(4, 1),
5173 std::make_pair(1, 4),
5174 std::make_pair(4, 3),
5175 std::make_pair(3, 4)));
5177 class BipartiteRandomTest
5178 : public ::testing::TestWithParam
<std::pair
<int, int> > {
5181 // Verifies a large sample of larger graphs.
5182 TEST_P(BipartiteRandomTest
, LargerNets
) {
5183 int nodes
= GetParam().first
;
5184 int iters
= GetParam().second
;
5185 MatchMatrix
graph(nodes
, nodes
);
5187 testing::internal::Int32 seed
= GTEST_FLAG(random_seed
);
5189 seed
= static_cast<testing::internal::Int32
>(time(NULL
));
5192 for (; iters
> 0; --iters
, ++seed
) {
5193 srand(static_cast<int>(seed
));
5195 EXPECT_EQ(FindBacktrackingMaxBPM(graph
).size(),
5196 internal::FindMaxBipartiteMatching(graph
).size())
5197 << " graph: " << graph
.DebugString()
5198 << "\nTo reproduce the failure, rerun the test with the flag"
5199 " --" << GTEST_FLAG_PREFIX_
<< "random_seed=" << seed
;
5203 // Test argument is a std::pair<int, int> representing (nodes, iters).
5204 INSTANTIATE_TEST_CASE_P(Samples
, BipartiteRandomTest
,
5206 std::make_pair(5, 10000),
5207 std::make_pair(6, 5000),
5208 std::make_pair(7, 2000),
5209 std::make_pair(8, 500),
5210 std::make_pair(9, 100)));
5212 // Tests IsReadableTypeName().
5214 TEST(IsReadableTypeNameTest
, ReturnsTrueForShortNames
) {
5215 EXPECT_TRUE(IsReadableTypeName("int"));
5216 EXPECT_TRUE(IsReadableTypeName("const unsigned char*"));
5217 EXPECT_TRUE(IsReadableTypeName("MyMap<int, void*>"));
5218 EXPECT_TRUE(IsReadableTypeName("void (*)(int, bool)"));
5221 TEST(IsReadableTypeNameTest
, ReturnsTrueForLongNonTemplateNonFunctionNames
) {
5222 EXPECT_TRUE(IsReadableTypeName("my_long_namespace::MyClassName"));
5223 EXPECT_TRUE(IsReadableTypeName("int [5][6][7][8][9][10][11]"));
5224 EXPECT_TRUE(IsReadableTypeName("my_namespace::MyOuterClass::MyInnerClass"));
5227 TEST(IsReadableTypeNameTest
, ReturnsFalseForLongTemplateNames
) {
5229 IsReadableTypeName("basic_string<char, std::char_traits<char> >"));
5230 EXPECT_FALSE(IsReadableTypeName("std::vector<int, std::alloc_traits<int> >"));
5233 TEST(IsReadableTypeNameTest
, ReturnsFalseForLongFunctionTypeNames
) {
5234 EXPECT_FALSE(IsReadableTypeName("void (&)(int, bool, char, float)"));
5237 // Tests JoinAsTuple().
5239 TEST(JoinAsTupleTest
, JoinsEmptyTuple
) {
5240 EXPECT_EQ("", JoinAsTuple(Strings()));
5243 TEST(JoinAsTupleTest
, JoinsOneTuple
) {
5244 const char* fields
[] = {"1"};
5245 EXPECT_EQ("1", JoinAsTuple(Strings(fields
, fields
+ 1)));
5248 TEST(JoinAsTupleTest
, JoinsTwoTuple
) {
5249 const char* fields
[] = {"1", "a"};
5250 EXPECT_EQ("(1, a)", JoinAsTuple(Strings(fields
, fields
+ 2)));
5253 TEST(JoinAsTupleTest
, JoinsTenTuple
) {
5254 const char* fields
[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
5255 EXPECT_EQ("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)",
5256 JoinAsTuple(Strings(fields
, fields
+ 10)));
5259 // Tests FormatMatcherDescription().
5261 TEST(FormatMatcherDescriptionTest
, WorksForEmptyDescription
) {
5262 EXPECT_EQ("is even",
5263 FormatMatcherDescription(false, "IsEven", Strings()));
5264 EXPECT_EQ("not (is even)",
5265 FormatMatcherDescription(true, "IsEven", Strings()));
5267 const char* params
[] = {"5"};
5268 EXPECT_EQ("equals 5",
5269 FormatMatcherDescription(false, "Equals",
5270 Strings(params
, params
+ 1)));
5272 const char* params2
[] = {"5", "8"};
5273 EXPECT_EQ("is in range (5, 8)",
5274 FormatMatcherDescription(false, "IsInRange",
5275 Strings(params2
, params2
+ 2)));
5278 // Tests PolymorphicMatcher::mutable_impl().
5279 TEST(PolymorphicMatcherTest
, CanAccessMutableImpl
) {
5280 PolymorphicMatcher
<DivisibleByImpl
> m(DivisibleByImpl(42));
5281 DivisibleByImpl
& impl
= m
.mutable_impl();
5282 EXPECT_EQ(42, impl
.divider());
5284 impl
.set_divider(0);
5285 EXPECT_EQ(0, m
.mutable_impl().divider());
5288 // Tests PolymorphicMatcher::impl().
5289 TEST(PolymorphicMatcherTest
, CanAccessImpl
) {
5290 const PolymorphicMatcher
<DivisibleByImpl
> m(DivisibleByImpl(42));
5291 const DivisibleByImpl
& impl
= m
.impl();
5292 EXPECT_EQ(42, impl
.divider());
5295 TEST(MatcherTupleTest
, ExplainsMatchFailure
) {
5297 ExplainMatchFailureTupleTo(make_tuple(Matcher
<char>(Eq('a')), GreaterThan(5)),
5298 make_tuple('a', 10), &ss1
);
5299 EXPECT_EQ("", ss1
.str()); // Successful match.
5302 ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher
<char>(Eq('a'))),
5303 make_tuple(2, 'b'), &ss2
);
5304 EXPECT_EQ(" Expected arg #0: is > 5\n"
5305 " Actual: 2, which is 3 less than 5\n"
5306 " Expected arg #1: is equal to 'a' (97, 0x61)\n"
5307 " Actual: 'b' (98, 0x62)\n",
5308 ss2
.str()); // Failed match where both arguments need explanation.
5311 ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher
<char>(Eq('a'))),
5312 make_tuple(2, 'a'), &ss3
);
5313 EXPECT_EQ(" Expected arg #0: is > 5\n"
5314 " Actual: 2, which is 3 less than 5\n",
5315 ss3
.str()); // Failed match where only one argument needs
5321 TEST(EachTest
, ExplainsMatchResultCorrectly
) {
5322 set
<int> a
; // empty
5324 Matcher
<set
<int> > m
= Each(2);
5325 EXPECT_EQ("", Explain(m
, a
));
5327 Matcher
<const int(&)[1]> n
= Each(1); // NOLINT
5329 const int b
[1] = {1};
5330 EXPECT_EQ("", Explain(n
, b
));
5333 EXPECT_EQ("whose element #0 doesn't match", Explain(n
, b
));
5338 m
= Each(GreaterThan(0));
5339 EXPECT_EQ("", Explain(m
, a
));
5341 m
= Each(GreaterThan(10));
5342 EXPECT_EQ("whose element #0 doesn't match, which is 9 less than 10",
5346 TEST(EachTest
, DescribesItselfCorrectly
) {
5347 Matcher
<vector
<int> > m
= Each(1);
5348 EXPECT_EQ("only contains elements that is equal to 1", Describe(m
));
5350 Matcher
<vector
<int> > m2
= Not(m
);
5351 EXPECT_EQ("contains some element that isn't equal to 1", Describe(m2
));
5354 TEST(EachTest
, MatchesVectorWhenAllElementsMatch
) {
5355 vector
<int> some_vector
;
5356 EXPECT_THAT(some_vector
, Each(1));
5357 some_vector
.push_back(3);
5358 EXPECT_THAT(some_vector
, Not(Each(1)));
5359 EXPECT_THAT(some_vector
, Each(3));
5360 some_vector
.push_back(1);
5361 some_vector
.push_back(2);
5362 EXPECT_THAT(some_vector
, Not(Each(3)));
5363 EXPECT_THAT(some_vector
, Each(Lt(3.5)));
5365 vector
<string
> another_vector
;
5366 another_vector
.push_back("fee");
5367 EXPECT_THAT(another_vector
, Each(string("fee")));
5368 another_vector
.push_back("fie");
5369 another_vector
.push_back("foe");
5370 another_vector
.push_back("fum");
5371 EXPECT_THAT(another_vector
, Not(Each(string("fee"))));
5374 TEST(EachTest
, MatchesMapWhenAllElementsMatch
) {
5375 map
<const char*, int> my_map
;
5376 const char* bar
= "a string";
5378 EXPECT_THAT(my_map
, Each(make_pair(bar
, 2)));
5380 map
<string
, int> another_map
;
5381 EXPECT_THAT(another_map
, Each(make_pair(string("fee"), 1)));
5382 another_map
["fee"] = 1;
5383 EXPECT_THAT(another_map
, Each(make_pair(string("fee"), 1)));
5384 another_map
["fie"] = 2;
5385 another_map
["foe"] = 3;
5386 another_map
["fum"] = 4;
5387 EXPECT_THAT(another_map
, Not(Each(make_pair(string("fee"), 1))));
5388 EXPECT_THAT(another_map
, Not(Each(make_pair(string("fum"), 1))));
5389 EXPECT_THAT(another_map
, Each(Pair(_
, Gt(0))));
5392 TEST(EachTest
, AcceptsMatcher
) {
5393 const int a
[] = {1, 2, 3};
5394 EXPECT_THAT(a
, Each(Gt(0)));
5395 EXPECT_THAT(a
, Not(Each(Gt(1))));
5398 TEST(EachTest
, WorksForNativeArrayAsTuple
) {
5399 const int a
[] = {1, 2};
5400 const int* const pointer
= a
;
5401 EXPECT_THAT(make_tuple(pointer
, 2), Each(Gt(0)));
5402 EXPECT_THAT(make_tuple(pointer
, 2), Not(Each(Gt(1))));
5405 // For testing Pointwise().
5406 class IsHalfOfMatcher
{
5408 template <typename T1
, typename T2
>
5409 bool MatchAndExplain(const tuple
<T1
, T2
>& a_pair
,
5410 MatchResultListener
* listener
) const {
5411 if (get
<0>(a_pair
) == get
<1>(a_pair
)/2) {
5412 *listener
<< "where the second is " << get
<1>(a_pair
);
5415 *listener
<< "where the second/2 is " << get
<1>(a_pair
)/2;
5420 void DescribeTo(ostream
* os
) const {
5421 *os
<< "are a pair where the first is half of the second";
5424 void DescribeNegationTo(ostream
* os
) const {
5425 *os
<< "are a pair where the first isn't half of the second";
5429 PolymorphicMatcher
<IsHalfOfMatcher
> IsHalfOf() {
5430 return MakePolymorphicMatcher(IsHalfOfMatcher());
5433 TEST(PointwiseTest
, DescribesSelf
) {
5438 const Matcher
<const vector
<int>&> m
= Pointwise(IsHalfOf(), rhs
);
5439 EXPECT_EQ("contains 3 values, where each value and its corresponding value "
5440 "in { 1, 2, 3 } are a pair where the first is half of the second",
5442 EXPECT_EQ("doesn't contain exactly 3 values, or contains a value x at some "
5443 "index i where x and the i-th value of { 1, 2, 3 } are a pair "
5444 "where the first isn't half of the second",
5445 DescribeNegation(m
));
5448 TEST(PointwiseTest
, MakesCopyOfRhs
) {
5449 list
<signed char> rhs
;
5454 const Matcher
<const int (&)[2]> m
= Pointwise(IsHalfOf(), rhs
);
5455 EXPECT_THAT(lhs
, m
);
5457 // Changing rhs now shouldn't affect m, which made a copy of rhs.
5459 EXPECT_THAT(lhs
, m
);
5462 TEST(PointwiseTest
, WorksForLhsNativeArray
) {
5463 const int lhs
[] = {1, 2, 3};
5468 EXPECT_THAT(lhs
, Pointwise(Lt(), rhs
));
5469 EXPECT_THAT(lhs
, Not(Pointwise(Gt(), rhs
)));
5472 TEST(PointwiseTest
, WorksForRhsNativeArray
) {
5473 const int rhs
[] = {1, 2, 3};
5478 EXPECT_THAT(lhs
, Pointwise(Gt(), rhs
));
5479 EXPECT_THAT(lhs
, Not(Pointwise(Lt(), rhs
)));
5482 #if GTEST_HAS_STD_INITIALIZER_LIST_
5484 TEST(PointwiseTest
, WorksForRhsInitializerList
) {
5485 const vector
<int> lhs
{2, 4, 6};
5486 EXPECT_THAT(lhs
, Pointwise(Gt(), {1, 2, 3}));
5487 EXPECT_THAT(lhs
, Not(Pointwise(Lt(), {3, 3, 7})));
5490 #endif // GTEST_HAS_STD_INITIALIZER_LIST_
5492 TEST(PointwiseTest
, RejectsWrongSize
) {
5493 const double lhs
[2] = {1, 2};
5494 const int rhs
[1] = {0};
5495 EXPECT_THAT(lhs
, Not(Pointwise(Gt(), rhs
)));
5496 EXPECT_EQ("which contains 2 values",
5497 Explain(Pointwise(Gt(), rhs
), lhs
));
5499 const int rhs2
[3] = {0, 1, 2};
5500 EXPECT_THAT(lhs
, Not(Pointwise(Gt(), rhs2
)));
5503 TEST(PointwiseTest
, RejectsWrongContent
) {
5504 const double lhs
[3] = {1, 2, 3};
5505 const int rhs
[3] = {2, 6, 4};
5506 EXPECT_THAT(lhs
, Not(Pointwise(IsHalfOf(), rhs
)));
5507 EXPECT_EQ("where the value pair (2, 6) at index #1 don't match, "
5508 "where the second/2 is 3",
5509 Explain(Pointwise(IsHalfOf(), rhs
), lhs
));
5512 TEST(PointwiseTest
, AcceptsCorrectContent
) {
5513 const double lhs
[3] = {1, 2, 3};
5514 const int rhs
[3] = {2, 4, 6};
5515 EXPECT_THAT(lhs
, Pointwise(IsHalfOf(), rhs
));
5516 EXPECT_EQ("", Explain(Pointwise(IsHalfOf(), rhs
), lhs
));
5519 TEST(PointwiseTest
, AllowsMonomorphicInnerMatcher
) {
5520 const double lhs
[3] = {1, 2, 3};
5521 const int rhs
[3] = {2, 4, 6};
5522 const Matcher
<tuple
<const double&, const int&> > m1
= IsHalfOf();
5523 EXPECT_THAT(lhs
, Pointwise(m1
, rhs
));
5524 EXPECT_EQ("", Explain(Pointwise(m1
, rhs
), lhs
));
5526 // This type works as a tuple<const double&, const int&> can be
5527 // implicitly cast to tuple<double, int>.
5528 const Matcher
<tuple
<double, int> > m2
= IsHalfOf();
5529 EXPECT_THAT(lhs
, Pointwise(m2
, rhs
));
5530 EXPECT_EQ("", Explain(Pointwise(m2
, rhs
), lhs
));
5533 TEST(UnorderedPointwiseTest
, DescribesSelf
) {
5538 const Matcher
<const vector
<int>&> m
= UnorderedPointwise(IsHalfOf(), rhs
);
5540 "has 3 elements and there exists some permutation of elements such "
5542 " - element #0 and 1 are a pair where the first is half of the second, "
5544 " - element #1 and 2 are a pair where the first is half of the second, "
5546 " - element #2 and 3 are a pair where the first is half of the second",
5549 "doesn't have 3 elements, or there exists no permutation of elements "
5551 " - element #0 and 1 are a pair where the first is half of the second, "
5553 " - element #1 and 2 are a pair where the first is half of the second, "
5555 " - element #2 and 3 are a pair where the first is half of the second",
5556 DescribeNegation(m
));
5559 TEST(UnorderedPointwiseTest
, MakesCopyOfRhs
) {
5560 list
<signed char> rhs
;
5565 const Matcher
<const int (&)[2]> m
= UnorderedPointwise(IsHalfOf(), rhs
);
5566 EXPECT_THAT(lhs
, m
);
5568 // Changing rhs now shouldn't affect m, which made a copy of rhs.
5570 EXPECT_THAT(lhs
, m
);
5573 TEST(UnorderedPointwiseTest
, WorksForLhsNativeArray
) {
5574 const int lhs
[] = {1, 2, 3};
5579 EXPECT_THAT(lhs
, UnorderedPointwise(Lt(), rhs
));
5580 EXPECT_THAT(lhs
, Not(UnorderedPointwise(Gt(), rhs
)));
5583 TEST(UnorderedPointwiseTest
, WorksForRhsNativeArray
) {
5584 const int rhs
[] = {1, 2, 3};
5589 EXPECT_THAT(lhs
, UnorderedPointwise(Gt(), rhs
));
5590 EXPECT_THAT(lhs
, Not(UnorderedPointwise(Lt(), rhs
)));
5593 #if GTEST_HAS_STD_INITIALIZER_LIST_
5595 TEST(UnorderedPointwiseTest
, WorksForRhsInitializerList
) {
5596 const vector
<int> lhs
{2, 4, 6};
5597 EXPECT_THAT(lhs
, UnorderedPointwise(Gt(), {5, 1, 3}));
5598 EXPECT_THAT(lhs
, Not(UnorderedPointwise(Lt(), {1, 1, 7})));
5601 #endif // GTEST_HAS_STD_INITIALIZER_LIST_
5603 TEST(UnorderedPointwiseTest
, RejectsWrongSize
) {
5604 const double lhs
[2] = {1, 2};
5605 const int rhs
[1] = {0};
5606 EXPECT_THAT(lhs
, Not(UnorderedPointwise(Gt(), rhs
)));
5607 EXPECT_EQ("which has 2 elements",
5608 Explain(UnorderedPointwise(Gt(), rhs
), lhs
));
5610 const int rhs2
[3] = {0, 1, 2};
5611 EXPECT_THAT(lhs
, Not(UnorderedPointwise(Gt(), rhs2
)));
5614 TEST(UnorderedPointwiseTest
, RejectsWrongContent
) {
5615 const double lhs
[3] = {1, 2, 3};
5616 const int rhs
[3] = {2, 6, 6};
5617 EXPECT_THAT(lhs
, Not(UnorderedPointwise(IsHalfOf(), rhs
)));
5618 EXPECT_EQ("where the following elements don't match any matchers:\n"
5620 Explain(UnorderedPointwise(IsHalfOf(), rhs
), lhs
));
5623 TEST(UnorderedPointwiseTest
, AcceptsCorrectContentInSameOrder
) {
5624 const double lhs
[3] = {1, 2, 3};
5625 const int rhs
[3] = {2, 4, 6};
5626 EXPECT_THAT(lhs
, UnorderedPointwise(IsHalfOf(), rhs
));
5629 TEST(UnorderedPointwiseTest
, AcceptsCorrectContentInDifferentOrder
) {
5630 const double lhs
[3] = {1, 2, 3};
5631 const int rhs
[3] = {6, 4, 2};
5632 EXPECT_THAT(lhs
, UnorderedPointwise(IsHalfOf(), rhs
));
5635 TEST(UnorderedPointwiseTest
, AllowsMonomorphicInnerMatcher
) {
5636 const double lhs
[3] = {1, 2, 3};
5637 const int rhs
[3] = {4, 6, 2};
5638 const Matcher
<tuple
<const double&, const int&> > m1
= IsHalfOf();
5639 EXPECT_THAT(lhs
, UnorderedPointwise(m1
, rhs
));
5641 // This type works as a tuple<const double&, const int&> can be
5642 // implicitly cast to tuple<double, int>.
5643 const Matcher
<tuple
<double, int> > m2
= IsHalfOf();
5644 EXPECT_THAT(lhs
, UnorderedPointwise(m2
, rhs
));
5647 } // namespace gmock_matchers_test
5648 } // namespace testing