38#pragma warning(disable : 4244)
39#pragma warning(disable : 4100)
42#include "test/gmock-matchers_test.h"
45namespace gmock_matchers_test {
48TEST(AddressTest, NonConst) {
50 const Matcher<int> m = Address(Eq(&n));
52 EXPECT_TRUE(m.Matches(n));
56 EXPECT_FALSE(m.Matches(other));
60 EXPECT_TRUE(m.Matches(n_ref));
63TEST(AddressTest, Const) {
65 const Matcher<int> m = Address(Eq(&n));
67 EXPECT_TRUE(m.Matches(n));
71 EXPECT_FALSE(m.Matches(other));
74TEST(AddressTest, MatcherDoesntCopy) {
75 std::unique_ptr<int> n(
new int(1));
76 const Matcher<std::unique_ptr<int>> m = Address(Eq(&n));
78 EXPECT_TRUE(m.Matches(n));
81TEST(AddressTest, Describe) {
82 Matcher<int> matcher = Address(_);
83 EXPECT_EQ(
"has address that is anything", Describe(matcher));
84 EXPECT_EQ(
"does not have address that is anything",
85 DescribeNegation(matcher));
94 explicit NotCopyable(
int a_value) : value_(a_value) {}
96 int value()
const {
return value_; }
98 bool operator==(
const NotCopyable& rhs)
const {
99 return value() == rhs.value();
102 bool operator>=(
const NotCopyable& rhs)
const {
103 return value() >= rhs.value();
109 NotCopyable(
const NotCopyable&) =
delete;
110 NotCopyable& operator=(
const NotCopyable&) =
delete;
113TEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) {
114 const NotCopyable const_value1(1);
115 const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1));
117 const NotCopyable n1(1), n2(2);
118 EXPECT_TRUE(m.Matches(n1));
119 EXPECT_FALSE(m.Matches(n2));
122TEST(ByRefTest, AllowsNotCopyableValueInMatchers) {
123 NotCopyable value2(2);
124 const Matcher<NotCopyable&> m = Ge(ByRef(value2));
126 NotCopyable n1(1), n2(2);
127 EXPECT_FALSE(m.Matches(n1));
128 EXPECT_TRUE(m.Matches(n2));
131TEST(IsEmptyTest, ImplementsIsEmpty) {
132 vector<int> container;
133 EXPECT_THAT(container, IsEmpty());
134 container.push_back(0);
135 EXPECT_THAT(container, Not(IsEmpty()));
136 container.push_back(1);
137 EXPECT_THAT(container, Not(IsEmpty()));
140TEST(IsEmptyTest, WorksWithString) {
142 EXPECT_THAT(text, IsEmpty());
144 EXPECT_THAT(text, Not(IsEmpty()));
145 text = std::string(
"\0", 1);
146 EXPECT_THAT(text, Not(IsEmpty()));
149TEST(IsEmptyTest, CanDescribeSelf) {
150 Matcher<vector<int>> m = IsEmpty();
151 EXPECT_EQ(
"is empty", Describe(m));
152 EXPECT_EQ(
"isn't empty", DescribeNegation(m));
155TEST(IsEmptyTest, ExplainsResult) {
156 Matcher<vector<int>> m = IsEmpty();
157 vector<int> container;
158 EXPECT_EQ(
"", Explain(m, container));
159 container.push_back(0);
160 EXPECT_EQ(
"whose size is 1", Explain(m, container));
163TEST(IsEmptyTest, WorksWithMoveOnly) {
164 ContainerHelper helper;
165 EXPECT_CALL(helper, Call(IsEmpty()));
169TEST(IsTrueTest, IsTrueIsFalse) {
170 EXPECT_THAT(
true, IsTrue());
171 EXPECT_THAT(
false, IsFalse());
172 EXPECT_THAT(
true, Not(IsFalse()));
173 EXPECT_THAT(
false, Not(IsTrue()));
174 EXPECT_THAT(0, Not(IsTrue()));
175 EXPECT_THAT(0, IsFalse());
176 EXPECT_THAT(
nullptr, Not(IsTrue()));
177 EXPECT_THAT(
nullptr, IsFalse());
178 EXPECT_THAT(-1, IsTrue());
179 EXPECT_THAT(-1, Not(IsFalse()));
180 EXPECT_THAT(1, IsTrue());
181 EXPECT_THAT(1, Not(IsFalse()));
182 EXPECT_THAT(2, IsTrue());
183 EXPECT_THAT(2, Not(IsFalse()));
185 EXPECT_THAT(a, IsTrue());
186 EXPECT_THAT(a, Not(IsFalse()));
187 EXPECT_THAT(&a, IsTrue());
188 EXPECT_THAT(&a, Not(IsFalse()));
189 EXPECT_THAT(
false, Not(IsTrue()));
190 EXPECT_THAT(
true, Not(IsFalse()));
191 EXPECT_THAT(std::true_type(), IsTrue());
192 EXPECT_THAT(std::true_type(), Not(IsFalse()));
193 EXPECT_THAT(std::false_type(), IsFalse());
194 EXPECT_THAT(std::false_type(), Not(IsTrue()));
195 EXPECT_THAT(
nullptr, Not(IsTrue()));
196 EXPECT_THAT(
nullptr, IsFalse());
197 std::unique_ptr<int> null_unique;
198 std::unique_ptr<int> nonnull_unique(
new int(0));
199 EXPECT_THAT(null_unique, Not(IsTrue()));
200 EXPECT_THAT(null_unique, IsFalse());
201 EXPECT_THAT(nonnull_unique, IsTrue());
202 EXPECT_THAT(nonnull_unique, Not(IsFalse()));
205#if GTEST_HAS_TYPED_TEST
213 ContainerEqTestTypes;
215TYPED_TEST_SUITE(ContainerEqTest, ContainerEqTestTypes);
218TYPED_TEST(ContainerEqTest, EqualsSelf) {
219 static const int vals[] = {1, 1, 2, 3, 5, 8};
220 TypeParam my_set(vals, vals + 6);
221 const Matcher<TypeParam> m = ContainerEq(my_set);
222 EXPECT_TRUE(m.Matches(my_set));
223 EXPECT_EQ(
"", Explain(m, my_set));
227TYPED_TEST(ContainerEqTest, ValueMissing) {
228 static const int vals[] = {1, 1, 2, 3, 5, 8};
229 static const int test_vals[] = {2, 1, 8, 5};
230 TypeParam my_set(vals, vals + 6);
231 TypeParam test_set(test_vals, test_vals + 4);
232 const Matcher<TypeParam> m = ContainerEq(my_set);
233 EXPECT_FALSE(m.Matches(test_set));
234 EXPECT_EQ(
"which doesn't have these expected elements: 3",
235 Explain(m, test_set));
239TYPED_TEST(ContainerEqTest, ValueAdded) {
240 static const int vals[] = {1, 1, 2, 3, 5, 8};
241 static const int test_vals[] = {1, 2, 3, 5, 8, 46};
242 TypeParam my_set(vals, vals + 6);
243 TypeParam test_set(test_vals, test_vals + 6);
244 const Matcher<const TypeParam&> m = ContainerEq(my_set);
245 EXPECT_FALSE(m.Matches(test_set));
246 EXPECT_EQ(
"which has these unexpected elements: 46", Explain(m, test_set));
250TYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) {
251 static const int vals[] = {1, 1, 2, 3, 5, 8};
252 static const int test_vals[] = {1, 2, 3, 8, 46};
253 TypeParam my_set(vals, vals + 6);
254 TypeParam test_set(test_vals, test_vals + 5);
255 const Matcher<TypeParam> m = ContainerEq(my_set);
256 EXPECT_FALSE(m.Matches(test_set));
258 "which has these unexpected elements: 46,\n"
259 "and doesn't have these expected elements: 5",
260 Explain(m, test_set));
264TYPED_TEST(ContainerEqTest, DuplicateDifference) {
265 static const int vals[] = {1, 1, 2, 3, 5, 8};
266 static const int test_vals[] = {1, 2, 3, 5, 8};
267 TypeParam my_set(vals, vals + 6);
268 TypeParam test_set(test_vals, test_vals + 5);
269 const Matcher<const TypeParam&> m = ContainerEq(my_set);
272 EXPECT_EQ(
"", Explain(m, test_set));
278TEST(ContainerEqExtraTest, MultipleValuesMissing) {
279 static const int vals[] = {1, 1, 2, 3, 5, 8};
280 static const int test_vals[] = {2, 1, 5};
281 vector<int> my_set(vals, vals + 6);
282 vector<int> test_set(test_vals, test_vals + 3);
283 const Matcher<vector<int>> m = ContainerEq(my_set);
284 EXPECT_FALSE(m.Matches(test_set));
285 EXPECT_EQ(
"which doesn't have these expected elements: 3, 8",
286 Explain(m, test_set));
291TEST(ContainerEqExtraTest, MultipleValuesAdded) {
292 static const int vals[] = {1, 1, 2, 3, 5, 8};
293 static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46};
294 list<size_t> my_set(vals, vals + 6);
295 list<size_t> test_set(test_vals, test_vals + 7);
296 const Matcher<const list<size_t>&> m = ContainerEq(my_set);
297 EXPECT_FALSE(m.Matches(test_set));
298 EXPECT_EQ(
"which has these unexpected elements: 92, 46",
299 Explain(m, test_set));
303TEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) {
304 static const int vals[] = {1, 1, 2, 3, 5, 8};
305 static const int test_vals[] = {1, 2, 3, 92, 46};
306 list<size_t> my_set(vals, vals + 6);
307 list<size_t> test_set(test_vals, test_vals + 5);
308 const Matcher<const list<size_t>> m = ContainerEq(my_set);
309 EXPECT_FALSE(m.Matches(test_set));
311 "which has these unexpected elements: 92, 46,\n"
312 "and doesn't have these expected elements: 5, 8",
313 Explain(m, test_set));
318TEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) {
319 static const int vals[] = {1, 1, 2, 3, 5, 8};
320 static const int test_vals[] = {1, 2, 3, 5, 8};
321 vector<int> my_set(vals, vals + 6);
322 vector<int> test_set(test_vals, test_vals + 5);
323 const Matcher<vector<int>> m = ContainerEq(my_set);
324 EXPECT_TRUE(m.Matches(my_set));
325 EXPECT_FALSE(m.Matches(test_set));
327 EXPECT_EQ(
"", Explain(m, test_set));
332TEST(ContainerEqExtraTest, WorksForMaps) {
333 map<int, std::string> my_map;
337 map<int, std::string> test_map;
341 const Matcher<const map<int, std::string>&> m = ContainerEq(my_map);
342 EXPECT_TRUE(m.Matches(my_map));
343 EXPECT_FALSE(m.Matches(test_map));
346 "which has these unexpected elements: (0, \"aa\"),\n"
347 "and doesn't have these expected elements: (0, \"a\")",
348 Explain(m, test_map));
351TEST(ContainerEqExtraTest, WorksForNativeArray) {
352 int a1[] = {1, 2, 3};
353 int a2[] = {1, 2, 3};
356 EXPECT_THAT(a1, ContainerEq(a2));
357 EXPECT_THAT(a1, Not(ContainerEq(b)));
360TEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) {
361 const char a1[][3] = {
"hi",
"lo"};
362 const char a2[][3] = {
"hi",
"lo"};
363 const char b[][3] = {
"lo",
"hi"};
366 EXPECT_THAT(a1, ContainerEq(a2));
367 EXPECT_THAT(a1, Not(ContainerEq(b)));
370 EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1])));
371 EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1])));
374TEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) {
375 const int a1[] = {1, 2, 3};
376 const int a2[] = {1, 2, 3};
377 const int b[] = {1, 2, 3, 4};
379 const int*
const p1 = a1;
380 EXPECT_THAT(std::make_tuple(p1, 3), ContainerEq(a2));
381 EXPECT_THAT(std::make_tuple(p1, 3), Not(ContainerEq(b)));
383 const int c[] = {1, 3, 2};
384 EXPECT_THAT(std::make_tuple(p1, 3), Not(ContainerEq(c)));
387TEST(ContainerEqExtraTest, CopiesNativeArrayParameter) {
388 std::string a1[][3] = {{
"hi",
"hello",
"ciao"}, {
"bye",
"see you",
"ciao"}};
390 std::string a2[][3] = {{
"hi",
"hello",
"ciao"}, {
"bye",
"see you",
"ciao"}};
392 const Matcher<
const std::string(&)[2][3]> m = ContainerEq(a2);
405template <
typename Graph>
406class BacktrackingMaxBPMState {
409 explicit BacktrackingMaxBPMState(
const Graph* g) : graph_(g) {}
411 ElementMatcherPairs Compute() {
412 if (graph_->LhsSize() == 0 || graph_->RhsSize() == 0) {
415 lhs_used_.assign(graph_->LhsSize(), kUnused);
416 rhs_used_.assign(graph_->RhsSize(), kUnused);
417 for (
size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
420 if (best_so_far_.size() == graph_->RhsSize())
break;
426 static const size_t kUnused =
static_cast<size_t>(-1);
428 void PushMatch(
size_t lhs,
size_t rhs) {
429 matches_.push_back(ElementMatcherPair(lhs, rhs));
430 lhs_used_[lhs] = rhs;
431 rhs_used_[rhs] = lhs;
432 if (matches_.size() > best_so_far_.size()) {
433 best_so_far_ = matches_;
438 const ElementMatcherPair& back = matches_.back();
439 lhs_used_[back.first] = kUnused;
440 rhs_used_[back.second] = kUnused;
444 bool RecurseInto(
size_t irhs) {
445 if (rhs_used_[irhs] != kUnused) {
448 for (
size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
449 if (lhs_used_[ilhs] != kUnused) {
452 if (!graph_->HasEdge(ilhs, irhs)) {
455 PushMatch(ilhs, irhs);
456 if (best_so_far_.size() == graph_->RhsSize()) {
459 for (
size_t mi = irhs + 1; mi < graph_->RhsSize(); ++mi) {
460 if (!RecurseInto(mi))
return false;
468 std::vector<size_t> lhs_used_;
469 std::vector<size_t> rhs_used_;
470 ElementMatcherPairs matches_;
471 ElementMatcherPairs best_so_far_;
474template <
typename Graph>
475const size_t BacktrackingMaxBPMState<Graph>::kUnused;
481template <
typename Graph>
482ElementMatcherPairs FindBacktrackingMaxBPM(
const Graph& g) {
483 return BacktrackingMaxBPMState<Graph>(&g).Compute();
493TEST_P(BipartiteTest, Exhaustive) {
494 size_t nodes = GetParam();
495 MatchMatrix graph(nodes, nodes);
497 ElementMatcherPairs matches = internal::FindMaxBipartiteMatching(graph);
498 EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), matches.size())
499 <<
"graph: " << graph.DebugString();
502 std::vector<bool> seen_element(graph.LhsSize());
503 std::vector<bool> seen_matcher(graph.RhsSize());
504 SCOPED_TRACE(PrintToString(matches));
505 for (
size_t i = 0; i < matches.size(); ++i) {
506 size_t ilhs = matches[i].first;
507 size_t irhs = matches[i].second;
508 EXPECT_TRUE(graph.HasEdge(ilhs, irhs));
509 EXPECT_FALSE(seen_element[ilhs]);
510 EXPECT_FALSE(seen_matcher[irhs]);
511 seen_element[ilhs] =
true;
512 seen_matcher[irhs] =
true;
514 }
while (graph.NextGraph());
517INSTANTIATE_TEST_SUITE_P(AllGraphs, BipartiteTest,
518 ::testing::Range(
size_t{0},
size_t{5}));
521class BipartiteNonSquareTest
524TEST_F(BipartiteNonSquareTest, SimpleBacktracking) {
533 constexpr std::array<std::array<size_t, 2>, 4> kEdges = {
534 {{{0, 2}}, {{1, 1}}, {{2, 1}}, {{3, 0}}}};
535 for (
size_t i = 0; i < kEdges.size(); ++i) {
536 g.SetEdge(kEdges[i][0], kEdges[i][1],
true);
538 EXPECT_THAT(FindBacktrackingMaxBPM(g),
539 ElementsAre(Pair(3, 0), Pair(AnyOf(1, 2), 1), Pair(0, 2)))
544TEST_P(BipartiteNonSquareTest, Exhaustive) {
545 size_t nlhs = GetParam().first;
546 size_t nrhs = GetParam().second;
547 MatchMatrix graph(nlhs, nrhs);
549 EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
550 internal::FindMaxBipartiteMatching(graph).size())
551 <<
"graph: " << graph.DebugString()
552 <<
"\nbacktracking: " << PrintToString(FindBacktrackingMaxBPM(graph))
554 << PrintToString(internal::FindMaxBipartiteMatching(graph));
555 }
while (graph.NextGraph());
558INSTANTIATE_TEST_SUITE_P(
559 AllGraphs, BipartiteNonSquareTest,
560 testing::Values(std::make_pair(1, 2), std::make_pair(2, 1),
561 std::make_pair(3, 2), std::make_pair(2, 3),
562 std::make_pair(4, 1), std::make_pair(1, 4),
563 std::make_pair(4, 3), std::make_pair(3, 4)));
565class BipartiteRandomTest
569TEST_P(BipartiteRandomTest, LargerNets) {
570 int nodes = GetParam().first;
571 int iters = GetParam().second;
572 MatchMatrix graph(
static_cast<size_t>(nodes),
static_cast<size_t>(nodes));
574 auto seed =
static_cast<uint32_t
>(GTEST_FLAG_GET(random_seed));
576 seed =
static_cast<uint32_t
>(time(
nullptr));
579 for (; iters > 0; --iters, ++seed) {
580 srand(
static_cast<unsigned int>(seed));
582 EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
583 internal::FindMaxBipartiteMatching(graph).size())
584 <<
" graph: " << graph.DebugString()
585 <<
"\nTo reproduce the failure, rerun the test with the flag"
587 << GTEST_FLAG_PREFIX_ <<
"random_seed=" << seed;
592INSTANTIATE_TEST_SUITE_P(Samples, BipartiteRandomTest,
593 testing::Values(std::make_pair(5, 10000),
594 std::make_pair(6, 5000),
595 std::make_pair(7, 2000),
596 std::make_pair(8, 500),
597 std::make_pair(9, 100)));
601TEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) {
602 EXPECT_TRUE(IsReadableTypeName(
"int"));
603 EXPECT_TRUE(IsReadableTypeName(
"const unsigned char*"));
604 EXPECT_TRUE(IsReadableTypeName(
"MyMap<int, void*>"));
605 EXPECT_TRUE(IsReadableTypeName(
"void (*)(int, bool)"));
608TEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctionNames) {
609 EXPECT_TRUE(IsReadableTypeName(
"my_long_namespace::MyClassName"));
610 EXPECT_TRUE(IsReadableTypeName(
"int [5][6][7][8][9][10][11]"));
611 EXPECT_TRUE(IsReadableTypeName(
"my_namespace::MyOuterClass::MyInnerClass"));
614TEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) {
616 IsReadableTypeName(
"basic_string<char, std::char_traits<char> >"));
617 EXPECT_FALSE(IsReadableTypeName(
"std::vector<int, std::alloc_traits<int> >"));
620TEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) {
621 EXPECT_FALSE(IsReadableTypeName(
"void (&)(int, bool, char, float)"));
626TEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) {
628 FormatMatcherDescription(
false,
"IsEven", {}, Strings()));
629 EXPECT_EQ(
"not (is even)",
630 FormatMatcherDescription(
true,
"IsEven", {}, Strings()));
632 EXPECT_EQ(
"equals (a: 5)",
633 FormatMatcherDescription(
false,
"Equals", {
"a"}, {
"5"}));
636 "is in range (a: 5, b: 8)",
637 FormatMatcherDescription(
false,
"IsInRange", {
"a",
"b"}, {
"5",
"8"}));
640INSTANTIATE_GTEST_MATCHER_TEST_P(MatcherTupleTest);
642TEST_P(MatcherTupleTestP, ExplainsMatchFailure) {
644 ExplainMatchFailureTupleTo(
645 std::make_tuple(Matcher<char>(Eq(
'a')), GreaterThan(5)),
646 std::make_tuple(
'a', 10), &ss1);
647 EXPECT_EQ(
"", ss1.str());
650 ExplainMatchFailureTupleTo(
651 std::make_tuple(GreaterThan(5), Matcher<char>(Eq(
'a'))),
652 std::make_tuple(2,
'b'), &ss2);
654 " Expected arg #0: is > 5\n"
655 " Actual: 2, which is 3 less than 5\n"
656 " Expected arg #1: is equal to 'a' (97, 0x61)\n"
657 " Actual: 'b' (98, 0x62)\n",
661 ExplainMatchFailureTupleTo(
662 std::make_tuple(GreaterThan(5), Matcher<char>(Eq(
'a'))),
663 std::make_tuple(2,
'a'), &ss3);
665 " Expected arg #0: is > 5\n"
666 " Actual: 2, which is 3 less than 5\n",
674class SampleOptional {
676 using value_type = T;
677 explicit SampleOptional(T value)
678 : value_(std::move(value)), has_value_(true) {}
679 SampleOptional() : value_(), has_value_(false) {}
680 operator bool()
const {
return has_value_; }
681 const T& operator*()
const {
return value_; }
688TEST(OptionalTest, DescribesSelf) {
689 const Matcher<SampleOptional<int>> m = Optional(Eq(1));
690 EXPECT_EQ(
"value is equal to 1", Describe(m));
693TEST(OptionalTest, ExplainsSelf) {
694 const Matcher<SampleOptional<int>> m = Optional(Eq(1));
695 EXPECT_EQ(
"whose value 1 matches", Explain(m, SampleOptional<int>(1)));
696 EXPECT_EQ(
"whose value 2 doesn't match", Explain(m, SampleOptional<int>(2)));
699TEST(OptionalTest, MatchesNonEmptyOptional) {
700 const Matcher<SampleOptional<int>> m1 = Optional(1);
701 const Matcher<SampleOptional<int>> m2 = Optional(Eq(2));
702 const Matcher<SampleOptional<int>> m3 = Optional(Lt(3));
703 SampleOptional<int> opt(1);
704 EXPECT_TRUE(m1.Matches(opt));
705 EXPECT_FALSE(m2.Matches(opt));
706 EXPECT_TRUE(m3.Matches(opt));
709TEST(OptionalTest, DoesNotMatchNullopt) {
710 const Matcher<SampleOptional<int>> m = Optional(1);
711 SampleOptional<int> empty;
712 EXPECT_FALSE(m.Matches(empty));
715TEST(OptionalTest, WorksWithMoveOnly) {
716 Matcher<SampleOptional<std::unique_ptr<int>>> m = Optional(Eq(
nullptr));
717 EXPECT_TRUE(m.Matches(SampleOptional<std::unique_ptr<int>>(
nullptr)));
720class SampleVariantIntString {
722 SampleVariantIntString(
int i) : i_(i), has_int_(true) {}
723 SampleVariantIntString(
const std::string& s) : s_(s), has_int_(false) {}
725 template <
typename T>
726 friend bool holds_alternative(
const SampleVariantIntString& value) {
727 return value.has_int_ == std::is_same<T, int>::value;
730 template <
typename T>
731 friend const T& get(
const SampleVariantIntString& value) {
732 return value.get_impl(
static_cast<T*
>(
nullptr));
736 const int& get_impl(
int*)
const {
return i_; }
737 const std::string& get_impl(std::string*)
const {
return s_; }
744TEST(VariantTest, DescribesSelf) {
745 const Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
746 EXPECT_THAT(Describe(m), ContainsRegex(
"is a variant<> with value of type "
747 "'.*' and the value is equal to 1"));
750TEST(VariantTest, ExplainsSelf) {
751 const Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
752 EXPECT_THAT(Explain(m, SampleVariantIntString(1)),
753 ContainsRegex(
"whose value 1"));
754 EXPECT_THAT(Explain(m, SampleVariantIntString(
"A")),
755 HasSubstr(
"whose value is not of type '"));
756 EXPECT_THAT(Explain(m, SampleVariantIntString(2)),
757 "whose value 2 doesn't match");
760TEST(VariantTest, FullMatch) {
761 Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
762 EXPECT_TRUE(m.Matches(SampleVariantIntString(1)));
764 m = VariantWith<std::string>(Eq(
"1"));
765 EXPECT_TRUE(m.Matches(SampleVariantIntString(
"1")));
768TEST(VariantTest, TypeDoesNotMatch) {
769 Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
770 EXPECT_FALSE(m.Matches(SampleVariantIntString(
"1")));
772 m = VariantWith<std::string>(Eq(
"1"));
773 EXPECT_FALSE(m.Matches(SampleVariantIntString(1)));
776TEST(VariantTest, InnerDoesNotMatch) {
777 Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
778 EXPECT_FALSE(m.Matches(SampleVariantIntString(2)));
780 m = VariantWith<std::string>(Eq(
"1"));
781 EXPECT_FALSE(m.Matches(SampleVariantIntString(
"2")));
786 explicit SampleAnyType(
int i) : index_(0), i_(i) {}
787 explicit SampleAnyType(
const std::string& s) : index_(1), s_(s) {}
789 template <
typename T>
790 friend const T* any_cast(
const SampleAnyType* any) {
791 return any->get_impl(
static_cast<T*
>(
nullptr));
799 const int* get_impl(
int*)
const {
return index_ == 0 ? &i_ :
nullptr; }
800 const std::string* get_impl(std::string*)
const {
801 return index_ == 1 ? &s_ :
nullptr;
805TEST(AnyWithTest, FullMatch) {
806 Matcher<SampleAnyType> m = AnyWith<int>(Eq(1));
807 EXPECT_TRUE(m.Matches(SampleAnyType(1)));
810TEST(AnyWithTest, TestBadCastType) {
811 Matcher<SampleAnyType> m = AnyWith<std::string>(Eq(
"fail"));
812 EXPECT_FALSE(m.Matches(SampleAnyType(1)));
815TEST(AnyWithTest, TestUseInContainers) {
816 std::vector<SampleAnyType> a;
821 a, ElementsAreArray({AnyWith<int>(1), AnyWith<int>(2), AnyWith<int>(3)}));
823 std::vector<SampleAnyType> b;
824 b.emplace_back(
"hello");
825 b.emplace_back(
"merhaba");
826 b.emplace_back(
"salut");
827 EXPECT_THAT(b, ElementsAreArray({AnyWith<std::string>(
"hello"),
828 AnyWith<std::string>(
"merhaba"),
829 AnyWith<std::string>(
"salut")}));
831TEST(AnyWithTest, TestCompare) {
832 EXPECT_THAT(SampleAnyType(1), AnyWith<int>(Gt(0)));
835TEST(AnyWithTest, DescribesSelf) {
836 const Matcher<const SampleAnyType&> m = AnyWith<int>(Eq(1));
837 EXPECT_THAT(Describe(m), ContainsRegex(
"is an 'any' type with value of type "
838 "'.*' and the value is equal to 1"));
841TEST(AnyWithTest, ExplainsSelf) {
842 const Matcher<const SampleAnyType&> m = AnyWith<int>(Eq(1));
844 EXPECT_THAT(Explain(m, SampleAnyType(1)), ContainsRegex(
"whose value 1"));
845 EXPECT_THAT(Explain(m, SampleAnyType(
"A")),
846 HasSubstr(
"whose value is not of type '"));
847 EXPECT_THAT(Explain(m, SampleAnyType(2)),
"whose value 2 doesn't match");
852TEST(ArgsTest, AcceptsZeroTemplateArg) {
853 const std::tuple<int, bool> t(5,
true);
854 EXPECT_THAT(t, Args<>(Eq(std::tuple<>())));
855 EXPECT_THAT(t, Not(Args<>(Ne(std::tuple<>()))));
858TEST(ArgsTest, AcceptsOneTemplateArg) {
859 const std::tuple<int, bool> t(5,
true);
860 EXPECT_THAT(t, Args<0>(Eq(std::make_tuple(5))));
861 EXPECT_THAT(t, Args<1>(Eq(std::make_tuple(
true))));
862 EXPECT_THAT(t, Not(Args<1>(Eq(std::make_tuple(
false)))));
865TEST(ArgsTest, AcceptsTwoTemplateArgs) {
866 const std::tuple<short, int, long> t(4, 5, 6L);
868 EXPECT_THAT(t, (Args<0, 1>(Lt())));
869 EXPECT_THAT(t, (Args<1, 2>(Lt())));
870 EXPECT_THAT(t, Not(Args<0, 2>(Gt())));
873TEST(ArgsTest, AcceptsRepeatedTemplateArgs) {
874 const std::tuple<short, int, long> t(4, 5, 6L);
875 EXPECT_THAT(t, (Args<0, 0>(Eq())));
876 EXPECT_THAT(t, Not(Args<1, 1>(Ne())));
879TEST(ArgsTest, AcceptsDecreasingTemplateArgs) {
880 const std::tuple<short, int, long> t(4, 5, 6L);
881 EXPECT_THAT(t, (Args<2, 0>(Gt())));
882 EXPECT_THAT(t, Not(Args<2, 1>(Lt())));
885MATCHER(SumIsZero,
"") {
886 return std::get<0>(arg) + std::get<1>(arg) + std::get<2>(arg) == 0;
889TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) {
890 EXPECT_THAT(std::make_tuple(-1, 2), (Args<0, 0, 1>(SumIsZero())));
891 EXPECT_THAT(std::make_tuple(1, 2), Not(Args<0, 0, 1>(SumIsZero())));
894TEST(ArgsTest, CanBeNested) {
895 const std::tuple<short, int, long, int> t(4, 5, 6L, 6);
896 EXPECT_THAT(t, (Args<1, 2, 3>(Args<1, 2>(Eq()))));
897 EXPECT_THAT(t, (Args<0, 1, 3>(Args<0, 2>(Lt()))));
900TEST(ArgsTest, CanMatchTupleByValue) {
901 typedef std::tuple<char, int, int> Tuple3;
902 const Matcher<Tuple3> m = Args<1, 2>(Lt());
903 EXPECT_TRUE(m.Matches(Tuple3(
'a', 1, 2)));
904 EXPECT_FALSE(m.Matches(Tuple3(
'b', 2, 2)));
907TEST(ArgsTest, CanMatchTupleByReference) {
908 typedef std::tuple<char, char, int> Tuple3;
909 const Matcher<const Tuple3&> m = Args<0, 1>(Lt());
910 EXPECT_TRUE(m.Matches(Tuple3(
'a',
'b', 2)));
911 EXPECT_FALSE(m.Matches(Tuple3(
'b',
'b', 2)));
915MATCHER_P(PrintsAs, str,
"") {
return testing::PrintToString(arg) == str; }
917TEST(ArgsTest, AcceptsTenTemplateArgs) {
918 EXPECT_THAT(std::make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
919 (Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
920 PrintsAs(
"(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
921 EXPECT_THAT(std::make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
922 Not(Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
923 PrintsAs(
"(0, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
926TEST(ArgsTest, DescirbesSelfCorrectly) {
927 const Matcher<std::tuple<int, bool, char>> m = Args<2, 0>(Lt());
929 "are a tuple whose fields (#2, #0) are a pair where "
930 "the first < the second",
934TEST(ArgsTest, DescirbesNestedArgsCorrectly) {
935 const Matcher<const std::tuple<int, bool, char, int>&> m =
936 Args<0, 2, 3>(Args<2, 0>(Lt()));
938 "are a tuple whose fields (#0, #2, #3) are a tuple "
939 "whose fields (#2, #0) are a pair where the first < the second",
943TEST(ArgsTest, DescribesNegationCorrectly) {
944 const Matcher<std::tuple<int, char>> m = Args<1, 0>(Gt());
946 "are a tuple whose fields (#1, #0) aren't a pair "
947 "where the first > the second",
948 DescribeNegation(m));
951TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) {
952 const Matcher<std::tuple<bool, int, int>> m = Args<1, 2>(Eq());
953 EXPECT_EQ(
"whose fields (#1, #2) are (42, 42)",
954 Explain(m, std::make_tuple(
false, 42, 42)));
955 EXPECT_EQ(
"whose fields (#1, #2) are (42, 43)",
956 Explain(m, std::make_tuple(
false, 42, 43)));
960class LessThanMatcher :
public MatcherInterface<std::tuple<char, int>> {
962 void DescribeTo(::std::ostream* )
const override {}
964 bool MatchAndExplain(std::tuple<char, int> value,
965 MatchResultListener* listener)
const override {
966 const int diff = std::get<0>(value) - std::get<1>(value);
968 *listener <<
"where the first value is " << diff
969 <<
" more than the second";
975Matcher<std::tuple<char, int>> LessThan() {
976 return MakeMatcher(
new LessThanMatcher);
979TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) {
980 const Matcher<std::tuple<char, int, int>> m = Args<0, 2>(LessThan());
982 "whose fields (#0, #2) are ('a' (97, 0x61), 42), "
983 "where the first value is 55 more than the second",
984 Explain(m, std::make_tuple(
'a', 42, 42)));
985 EXPECT_EQ(
"whose fields (#0, #2) are ('\\0', 43)",
986 Explain(m, std::make_tuple(
'\0', 42, 43)));
993MATCHER(IsEven,
"") {
return (arg % 2) == 0; }
995TEST(MatcherMacroTest, Works) {
996 const Matcher<int> m = IsEven();
997 EXPECT_TRUE(m.Matches(6));
998 EXPECT_FALSE(m.Matches(7));
1000 EXPECT_EQ(
"is even", Describe(m));
1001 EXPECT_EQ(
"not (is even)", DescribeNegation(m));
1002 EXPECT_EQ(
"", Explain(m, 6));
1003 EXPECT_EQ(
"", Explain(m, 7));
1007MATCHER(IsEven2, negation ?
"is odd" :
"is even") {
1008 if ((arg % 2) == 0) {
1011 *result_listener <<
"OK";
1014 *result_listener <<
"% 2 == " << (arg % 2);
1021MATCHER_P2(EqSumOf, x, y,
1022 std::string(negation ?
"doesn't equal" :
"equals") +
" the sum of " +
1023 PrintToString(x) +
" and " + PrintToString(y)) {
1024 if (arg == (x + y)) {
1025 *result_listener <<
"OK";
1030 if (result_listener->stream() !=
nullptr) {
1031 *result_listener->stream() <<
"diff == " << (x + y - arg);
1039TEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) {
1040 const Matcher<int> m1 = IsEven2();
1041 EXPECT_EQ(
"is even", Describe(m1));
1042 EXPECT_EQ(
"is odd", DescribeNegation(m1));
1044 const Matcher<int> m2 = EqSumOf(5, 9);
1045 EXPECT_EQ(
"equals the sum of 5 and 9", Describe(m2));
1046 EXPECT_EQ(
"doesn't equal the sum of 5 and 9", DescribeNegation(m2));
1050TEST(MatcherMacroTest, CanExplainMatchResult) {
1051 const Matcher<int> m1 = IsEven2();
1052 EXPECT_EQ(
"OK", Explain(m1, 4));
1053 EXPECT_EQ(
"% 2 == 1", Explain(m1, 5));
1055 const Matcher<int> m2 = EqSumOf(1, 2);
1056 EXPECT_EQ(
"OK", Explain(m2, 3));
1057 EXPECT_EQ(
"diff == -1", Explain(m2, 4));
1063MATCHER(IsEmptyString,
"") {
1064 StaticAssertTypeEq<::std::string, arg_type>();
1068MATCHER(IsEmptyStringByRef,
"") {
1069 StaticAssertTypeEq<const ::std::string&, arg_type>();
1073TEST(MatcherMacroTest, CanReferenceArgType) {
1074 const Matcher<::std::string> m1 = IsEmptyString();
1075 EXPECT_TRUE(m1.Matches(
""));
1077 const Matcher<const ::std::string&> m2 = IsEmptyStringByRef();
1078 EXPECT_TRUE(m2.Matches(
""));
1083namespace matcher_test {
1084MATCHER(IsOdd,
"") {
return (arg % 2) != 0; }
1087TEST(MatcherMacroTest, WorksInNamespace) {
1088 Matcher<int> m = matcher_test::IsOdd();
1089 EXPECT_FALSE(m.Matches(4));
1090 EXPECT_TRUE(m.Matches(5));
1094MATCHER(IsPositiveOdd,
"") {
1095 return Value(arg, matcher_test::IsOdd()) && arg > 0;
1098TEST(MatcherMacroTest, CanBeComposedUsingValue) {
1099 EXPECT_THAT(3, IsPositiveOdd());
1100 EXPECT_THAT(4, Not(IsPositiveOdd()));
1101 EXPECT_THAT(-1, Not(IsPositiveOdd()));
1106MATCHER_P(IsGreaterThan32And, n,
"") {
return arg > 32 && arg > n; }
1108TEST(MatcherPMacroTest, Works) {
1109 const Matcher<int> m = IsGreaterThan32And(5);
1110 EXPECT_TRUE(m.Matches(36));
1111 EXPECT_FALSE(m.Matches(5));
1113 EXPECT_EQ(
"is greater than 32 and (n: 5)", Describe(m));
1114 EXPECT_EQ(
"not (is greater than 32 and (n: 5))", DescribeNegation(m));
1115 EXPECT_EQ(
"", Explain(m, 36));
1116 EXPECT_EQ(
"", Explain(m, 5));
1120MATCHER_P(_is_Greater_Than32and_, n,
"") {
return arg > 32 && arg > n; }
1122TEST(MatcherPMacroTest, GeneratesCorrectDescription) {
1123 const Matcher<int> m = _is_Greater_Than32and_(5);
1125 EXPECT_EQ(
"is greater than 32 and (n: 5)", Describe(m));
1126 EXPECT_EQ(
"not (is greater than 32 and (n: 5))", DescribeNegation(m));
1127 EXPECT_EQ(
"", Explain(m, 36));
1128 EXPECT_EQ(
"", Explain(m, 5));
1134class UncopyableFoo {
1136 explicit UncopyableFoo(
char value) : value_(value) { (void)value_; }
1138 UncopyableFoo(
const UncopyableFoo&) =
delete;
1139 void operator=(
const UncopyableFoo&) =
delete;
1145MATCHER_P(ReferencesUncopyable, variable,
"") {
return &arg == &variable; }
1147TEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) {
1148 UncopyableFoo foo1(
'1'), foo2(
'2');
1149 const Matcher<const UncopyableFoo&> m =
1150 ReferencesUncopyable<const UncopyableFoo&>(foo1);
1152 EXPECT_TRUE(m.Matches(foo1));
1153 EXPECT_FALSE(m.Matches(foo2));
1159 EXPECT_EQ(
"references uncopyable (variable: 1-byte object <31>)",
1166MATCHER_P3(ParamTypesAreIntLongAndChar, foo, bar, baz,
"") {
1167 StaticAssertTypeEq<int, foo_type>();
1168 StaticAssertTypeEq<long, bar_type>();
1169 StaticAssertTypeEq<char, baz_type>();
1173TEST(MatcherPnMacroTest, CanReferenceParamTypes) {
1174 EXPECT_THAT(0, ParamTypesAreIntLongAndChar(10, 20L,
'a'));
1180MATCHER_P2(ReferencesAnyOf, variable1, variable2,
"") {
1181 return &arg == &variable1 || &arg == &variable2;
1184TEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferences) {
1185 UncopyableFoo foo1(
'1'), foo2(
'2'), foo3(
'3');
1186 const Matcher<const UncopyableFoo&> const_m =
1187 ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
1189 EXPECT_TRUE(const_m.Matches(foo1));
1190 EXPECT_TRUE(const_m.Matches(foo2));
1191 EXPECT_FALSE(const_m.Matches(foo3));
1193 const Matcher<UncopyableFoo&> m =
1194 ReferencesAnyOf<UncopyableFoo&, UncopyableFoo&>(foo1, foo2);
1196 EXPECT_TRUE(m.Matches(foo1));
1197 EXPECT_TRUE(m.Matches(foo2));
1198 EXPECT_FALSE(m.Matches(foo3));
1201TEST(MatcherPnMacroTest,
1202 GeneratesCorretDescriptionWhenExplicitlyInstantiatedWithReferences) {
1203 UncopyableFoo foo1(
'1'), foo2(
'2');
1204 const Matcher<const UncopyableFoo&> m =
1205 ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
1212 "references any of (variable1: 1-byte object <31>, variable2: 1-byte "
1219MATCHER_P2(IsNotInClosedRange, low, hi,
"") {
return arg < low || arg > hi; }
1221TEST(MatcherPnMacroTest, Works) {
1222 const Matcher<const long&> m = IsNotInClosedRange(10, 20);
1223 EXPECT_TRUE(m.Matches(36L));
1224 EXPECT_FALSE(m.Matches(15L));
1226 EXPECT_EQ(
"is not in closed range (low: 10, hi: 20)", Describe(m));
1227 EXPECT_EQ(
"not (is not in closed range (low: 10, hi: 20))",
1228 DescribeNegation(m));
1229 EXPECT_EQ(
"", Explain(m, 36L));
1230 EXPECT_EQ(
"", Explain(m, 15L));
1236MATCHER(EqualsSumOf,
"") {
return arg == 0; }
1237MATCHER_P(EqualsSumOf, a,
"") {
return arg == a; }
1238MATCHER_P2(EqualsSumOf, a, b,
"") {
return arg == a + b; }
1239MATCHER_P3(EqualsSumOf, a, b, c,
"") {
return arg == a + b + c; }
1240MATCHER_P4(EqualsSumOf, a, b, c, d,
"") {
return arg == a + b + c + d; }
1241MATCHER_P5(EqualsSumOf, a, b, c, d, e,
"") {
return arg == a + b + c + d + e; }
1242MATCHER_P6(EqualsSumOf, a, b, c, d, e, f,
"") {
1243 return arg == a + b + c + d + e + f;
1245MATCHER_P7(EqualsSumOf, a, b, c, d, e, f, g,
"") {
1246 return arg == a + b + c + d + e + f + g;
1248MATCHER_P8(EqualsSumOf, a, b, c, d, e, f, g, h,
"") {
1249 return arg == a + b + c + d + e + f + g + h;
1251MATCHER_P9(EqualsSumOf, a, b, c, d, e, f, g, h, i,
"") {
1252 return arg == a + b + c + d + e + f + g + h + i;
1254MATCHER_P10(EqualsSumOf, a, b, c, d, e, f, g, h, i, j,
"") {
1255 return arg == a + b + c + d + e + f + g + h + i + j;
1258TEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) {
1259 EXPECT_THAT(0, EqualsSumOf());
1260 EXPECT_THAT(1, EqualsSumOf(1));
1261 EXPECT_THAT(12, EqualsSumOf(10, 2));
1262 EXPECT_THAT(123, EqualsSumOf(100, 20, 3));
1263 EXPECT_THAT(1234, EqualsSumOf(1000, 200, 30, 4));
1264 EXPECT_THAT(12345, EqualsSumOf(10000, 2000, 300, 40, 5));
1265 EXPECT_THAT(
"abcdef",
1266 EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
"e",
'f'));
1267 EXPECT_THAT(
"abcdefg",
1268 EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
"e",
'f',
'g'));
1269 EXPECT_THAT(
"abcdefgh", EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
"e",
1271 EXPECT_THAT(
"abcdefghi", EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
"e",
1272 'f',
'g',
"h",
'i'));
1273 EXPECT_THAT(
"abcdefghij",
1274 EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
"e",
'f',
'g',
"h",
1275 'i', ::std::string(
"j")));
1277 EXPECT_THAT(1, Not(EqualsSumOf()));
1278 EXPECT_THAT(-1, Not(EqualsSumOf(1)));
1279 EXPECT_THAT(-12, Not(EqualsSumOf(10, 2)));
1280 EXPECT_THAT(-123, Not(EqualsSumOf(100, 20, 3)));
1281 EXPECT_THAT(-1234, Not(EqualsSumOf(1000, 200, 30, 4)));
1282 EXPECT_THAT(-12345, Not(EqualsSumOf(10000, 2000, 300, 40, 5)));
1283 EXPECT_THAT(
"abcdef ",
1284 Not(EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
"e",
'f')));
1285 EXPECT_THAT(
"abcdefg ", Not(EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
1287 EXPECT_THAT(
"abcdefgh ", Not(EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
1288 "e",
'f',
'g',
"h")));
1289 EXPECT_THAT(
"abcdefghi ", Not(EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
1290 "e",
'f',
'g',
"h",
'i')));
1291 EXPECT_THAT(
"abcdefghij ",
1292 Not(EqualsSumOf(::std::string(
"a"),
'b',
'c',
"d",
"e",
'f',
'g',
1293 "h",
'i', ::std::string(
"j"))));
1298TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) {
1299 EXPECT_THAT(123, EqualsSumOf(100L, 20,
static_cast<char>(3)));
1300 EXPECT_THAT(
"abcd", EqualsSumOf(::std::string(
"a"),
"b",
'c',
"d"));
1302 EXPECT_THAT(124, Not(EqualsSumOf(100L, 20,
static_cast<char>(3))));
1303 EXPECT_THAT(
"abcde", Not(EqualsSumOf(::std::string(
"a"),
"b",
'c',
"d")));
1308MATCHER_P2(EqConcat, prefix, suffix,
"") {
1310 std::string prefix_str(prefix);
1311 char suffix_char =
static_cast<char>(suffix);
1312 return arg == prefix_str + suffix_char;
1315TEST(MatcherPnMacroTest, SimpleTypePromotion) {
1316 Matcher<std::string> no_promo = EqConcat(std::string(
"foo"),
't');
1317 Matcher<const std::string&> promo = EqConcat(
"foo",
static_cast<int>(
't'));
1318 EXPECT_FALSE(no_promo.Matches(
"fool"));
1319 EXPECT_FALSE(promo.Matches(
"fool"));
1320 EXPECT_TRUE(no_promo.Matches(
"foot"));
1321 EXPECT_TRUE(promo.Matches(
"foot"));
1326TEST(MatcherPnMacroTest, TypesAreCorrect) {
1328 EqualsSumOfMatcher a0 = EqualsSumOf();
1331 EqualsSumOfMatcherP<int> a1 = EqualsSumOf(1);
1335 EqualsSumOfMatcherP2<int, char> a2 = EqualsSumOf(1,
'2');
1336 EqualsSumOfMatcherP3<int, int, char> a3 = EqualsSumOf(1, 2,
'3');
1337 EqualsSumOfMatcherP4<int, int, int, char> a4 = EqualsSumOf(1, 2, 3,
'4');
1338 EqualsSumOfMatcherP5<int, int, int, int, char> a5 =
1339 EqualsSumOf(1, 2, 3, 4,
'5');
1340 EqualsSumOfMatcherP6<int, int, int, int, int, char> a6 =
1341 EqualsSumOf(1, 2, 3, 4, 5,
'6');
1342 EqualsSumOfMatcherP7<int, int, int, int, int, int, char> a7 =
1343 EqualsSumOf(1, 2, 3, 4, 5, 6,
'7');
1344 EqualsSumOfMatcherP8<int, int, int, int, int, int, int, char> a8 =
1345 EqualsSumOf(1, 2, 3, 4, 5, 6, 7,
'8');
1346 EqualsSumOfMatcherP9<int, int, int, int, int, int, int, int, char> a9 =
1347 EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8,
'9');
1348 EqualsSumOfMatcherP10<int, int, int, int, int, int, int, int, int, char> a10 =
1349 EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, 9,
'0');
1369MATCHER_P3(TwoOf, m1, m2, m3,
"") {
1370 const int count =
static_cast<int>(Value(arg, m1)) +
1371 static_cast<int>(Value(arg, m2)) +
1372 static_cast<int>(Value(arg, m3));
1376TEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) {
1377 EXPECT_THAT(42, TwoOf(Gt(0), Lt(50), Eq(10)));
1378 EXPECT_THAT(0, Not(TwoOf(Gt(-1), Lt(1), Eq(0))));
1383INSTANTIATE_GTEST_MATCHER_TEST_P(ContainsTimes);
1385TEST(ContainsTimes, ListMatchesWhenElementQuantityMatches) {
1386 list<int> some_list;
1387 some_list.push_back(3);
1388 some_list.push_back(1);
1389 some_list.push_back(2);
1390 some_list.push_back(3);
1391 EXPECT_THAT(some_list, Contains(3).Times(2));
1392 EXPECT_THAT(some_list, Contains(2).Times(1));
1393 EXPECT_THAT(some_list, Contains(Ge(2)).Times(3));
1394 EXPECT_THAT(some_list, Contains(Ge(2)).Times(Gt(2)));
1395 EXPECT_THAT(some_list, Contains(4).Times(0));
1396 EXPECT_THAT(some_list, Contains(_).Times(4));
1397 EXPECT_THAT(some_list, Not(Contains(5).Times(1)));
1398 EXPECT_THAT(some_list, Contains(5).Times(_));
1399 EXPECT_THAT(some_list, Not(Contains(3).Times(1)));
1400 EXPECT_THAT(some_list, Contains(3).Times(Not(1)));
1401 EXPECT_THAT(list<int>{}, Not(Contains(_)));
1404TEST_P(ContainsTimesP, ExplainsMatchResultCorrectly) {
1405 const int a[2] = {1, 2};
1406 Matcher<
const int(&)[2]> m = Contains(2).Times(3);
1408 "whose element #1 matches but whose match quantity of 1 does not match",
1411 m = Contains(3).Times(0);
1412 EXPECT_EQ(
"has no element that matches and whose match quantity of 0 matches",
1415 m = Contains(3).Times(4);
1417 "has no element that matches and whose match quantity of 0 does not "
1421 m = Contains(2).Times(4);
1423 "whose element #1 matches but whose match quantity of 1 does not "
1427 m = Contains(GreaterThan(0)).Times(2);
1428 EXPECT_EQ(
"whose elements (0, 1) match and whose match quantity of 2 matches",
1431 m = Contains(GreaterThan(10)).Times(Gt(1));
1433 "has no element that matches and whose match quantity of 0 does not "
1437 m = Contains(GreaterThan(0)).Times(GreaterThan<size_t>(5));
1439 "whose elements (0, 1) match but whose match quantity of 2 does not "
1440 "match, which is 3 less than 5",
1444TEST(ContainsTimes, DescribesItselfCorrectly) {
1445 Matcher<vector<int>> m = Contains(1).Times(2);
1446 EXPECT_EQ(
"quantity of elements that match is equal to 1 is equal to 2",
1449 Matcher<vector<int>> m2 = Not(m);
1450 EXPECT_EQ(
"quantity of elements that match is equal to 1 isn't equal to 2",
1456TEST(AllOfArrayTest, BasicForms) {
1458 std::vector<int> v0{};
1459 std::vector<int> v1{1};
1460 std::vector<int> v2{2, 3};
1461 std::vector<int> v3{4, 4, 4};
1462 EXPECT_THAT(0, AllOfArray(v0.begin(), v0.end()));
1463 EXPECT_THAT(1, AllOfArray(v1.begin(), v1.end()));
1464 EXPECT_THAT(2, Not(AllOfArray(v1.begin(), v1.end())));
1465 EXPECT_THAT(3, Not(AllOfArray(v2.begin(), v2.end())));
1466 EXPECT_THAT(4, AllOfArray(v3.begin(), v3.end()));
1468 int ar[6] = {1, 2, 3, 4, 4, 4};
1469 EXPECT_THAT(0, AllOfArray(ar, 0));
1470 EXPECT_THAT(1, AllOfArray(ar, 1));
1471 EXPECT_THAT(2, Not(AllOfArray(ar, 1)));
1472 EXPECT_THAT(3, Not(AllOfArray(ar + 1, 3)));
1473 EXPECT_THAT(4, AllOfArray(ar + 3, 3));
1477 int ar2[2] = {2, 3};
1478 int ar3[3] = {4, 4, 4};
1480 EXPECT_THAT(1, AllOfArray(ar1));
1481 EXPECT_THAT(2, Not(AllOfArray(ar1)));
1482 EXPECT_THAT(3, Not(AllOfArray(ar2)));
1483 EXPECT_THAT(4, AllOfArray(ar3));
1485 EXPECT_THAT(0, AllOfArray(v0));
1486 EXPECT_THAT(1, AllOfArray(v1));
1487 EXPECT_THAT(2, Not(AllOfArray(v1)));
1488 EXPECT_THAT(3, Not(AllOfArray(v2)));
1489 EXPECT_THAT(4, AllOfArray(v3));
1491 EXPECT_THAT(0, AllOfArray<int>({}));
1492 EXPECT_THAT(1, AllOfArray({1}));
1493 EXPECT_THAT(2, Not(AllOfArray({1})));
1494 EXPECT_THAT(3, Not(AllOfArray({2, 3})));
1495 EXPECT_THAT(4, AllOfArray({4, 4, 4}));
1498TEST(AllOfArrayTest, Matchers) {
1500 std::vector<Matcher<int>> matchers{Ge(1), Lt(2)};
1501 EXPECT_THAT(0, Not(AllOfArray(matchers)));
1502 EXPECT_THAT(1, AllOfArray(matchers));
1503 EXPECT_THAT(2, Not(AllOfArray(matchers)));
1505 EXPECT_THAT(0, Not(AllOfArray({Ge(0), Ge(1)})));
1506 EXPECT_THAT(1, AllOfArray({Ge(0), Ge(1)}));
1509INSTANTIATE_GTEST_MATCHER_TEST_P(AnyOfArrayTest);
1511TEST(AnyOfArrayTest, BasicForms) {
1513 std::vector<int> v0{};
1514 std::vector<int> v1{1};
1515 std::vector<int> v2{2, 3};
1516 EXPECT_THAT(0, Not(AnyOfArray(v0.begin(), v0.end())));
1517 EXPECT_THAT(1, AnyOfArray(v1.begin(), v1.end()));
1518 EXPECT_THAT(2, Not(AnyOfArray(v1.begin(), v1.end())));
1519 EXPECT_THAT(3, AnyOfArray(v2.begin(), v2.end()));
1520 EXPECT_THAT(4, Not(AnyOfArray(v2.begin(), v2.end())));
1522 int ar[3] = {1, 2, 3};
1523 EXPECT_THAT(0, Not(AnyOfArray(ar, 0)));
1524 EXPECT_THAT(1, AnyOfArray(ar, 1));
1525 EXPECT_THAT(2, Not(AnyOfArray(ar, 1)));
1526 EXPECT_THAT(3, AnyOfArray(ar + 1, 2));
1527 EXPECT_THAT(4, Not(AnyOfArray(ar + 1, 2)));
1531 int ar2[2] = {2, 3};
1533 EXPECT_THAT(1, AnyOfArray(ar1));
1534 EXPECT_THAT(2, Not(AnyOfArray(ar1)));
1535 EXPECT_THAT(3, AnyOfArray(ar2));
1536 EXPECT_THAT(4, Not(AnyOfArray(ar2)));
1538 EXPECT_THAT(0, Not(AnyOfArray(v0)));
1539 EXPECT_THAT(1, AnyOfArray(v1));
1540 EXPECT_THAT(2, Not(AnyOfArray(v1)));
1541 EXPECT_THAT(3, AnyOfArray(v2));
1542 EXPECT_THAT(4, Not(AnyOfArray(v2)));
1544 EXPECT_THAT(0, Not(AnyOfArray<int>({})));
1545 EXPECT_THAT(1, AnyOfArray({1}));
1546 EXPECT_THAT(2, Not(AnyOfArray({1})));
1547 EXPECT_THAT(3, AnyOfArray({2, 3}));
1548 EXPECT_THAT(4, Not(AnyOfArray({2, 3})));
1551TEST(AnyOfArrayTest, Matchers) {
1554 std::vector<Matcher<int>> matchers{Lt(1), Ge(2)};
1555 EXPECT_THAT(0, AnyOfArray(matchers));
1556 EXPECT_THAT(1, Not(AnyOfArray(matchers)));
1557 EXPECT_THAT(2, AnyOfArray(matchers));
1559 EXPECT_THAT(0, AnyOfArray({Lt(0), Lt(1)}));
1560 EXPECT_THAT(1, Not(AllOfArray({Lt(0), Lt(1)})));
1563TEST_P(AnyOfArrayTestP, ExplainsMatchResultCorrectly) {
1566 const std::vector<int> v0{};
1567 const std::vector<int> v1{1};
1568 const std::vector<int> v2{2, 3};
1569 const Matcher<int> m0 = AnyOfArray(v0);
1570 const Matcher<int> m1 = AnyOfArray(v1);
1571 const Matcher<int> m2 = AnyOfArray(v2);
1572 EXPECT_EQ(
"", Explain(m0, 0));
1573 EXPECT_EQ(
"", Explain(m1, 1));
1574 EXPECT_EQ(
"", Explain(m1, 2));
1575 EXPECT_EQ(
"", Explain(m2, 3));
1576 EXPECT_EQ(
"", Explain(m2, 4));
1577 EXPECT_EQ(
"()", Describe(m0));
1578 EXPECT_EQ(
"(is equal to 1)", Describe(m1));
1579 EXPECT_EQ(
"(is equal to 2) or (is equal to 3)", Describe(m2));
1580 EXPECT_EQ(
"()", DescribeNegation(m0));
1581 EXPECT_EQ(
"(isn't equal to 1)", DescribeNegation(m1));
1582 EXPECT_EQ(
"(isn't equal to 2) and (isn't equal to 3)", DescribeNegation(m2));
1584 const Matcher<int> g1 = AnyOfArray({GreaterThan(1)});
1585 const Matcher<int> g2 = AnyOfArray({GreaterThan(1), GreaterThan(2)});
1587 EXPECT_EQ(
"which is 1 less than 1", Explain(g1, 0));
1588 EXPECT_EQ(
"which is the same as 1", Explain(g1, 1));
1589 EXPECT_EQ(
"which is 1 more than 1", Explain(g1, 2));
1590 EXPECT_EQ(
"which is 1 less than 1, and which is 2 less than 2",
1592 EXPECT_EQ(
"which is the same as 1, and which is 1 less than 2",
1594 EXPECT_EQ(
"which is 1 more than 1",
1598MATCHER(IsNotNull,
"") {
return arg !=
nullptr; }
1602TEST(MatcherMacroTest, WorksOnMoveOnlyType) {
1603 std::unique_ptr<int> p(
new int(3));
1604 EXPECT_THAT(p, IsNotNull());
1605 EXPECT_THAT(std::unique_ptr<int>(), Not(IsNotNull()));
1608MATCHER_P(UniquePointee, pointee,
"") {
return *arg == pointee; }
1612TEST(MatcherPMacroTest, WorksOnMoveOnlyType) {
1613 std::unique_ptr<int> p(
new int(3));
1614 EXPECT_THAT(p, UniquePointee(3));
1615 EXPECT_THAT(p, Not(UniquePointee(2)));
1618#if GTEST_HAS_EXCEPTIONS
1624TEST(ThrowsTest, Examples) {
1626 std::function<
void()>([]() {
throw std::runtime_error(
"message"); }),
1627 Throws<std::runtime_error>());
1630 std::function<
void()>([]() {
throw std::runtime_error(
"message"); }),
1631 ThrowsMessage<std::runtime_error>(HasSubstr(
"message")));
1634TEST(ThrowsTest, PrintsExceptionWhat) {
1636 std::function<
void()>([]() {
throw std::runtime_error(
"ABC123XYZ"); }),
1637 ThrowsMessage<std::runtime_error>(HasSubstr(
"ABC123XYZ")));
1640TEST(ThrowsTest, DoesNotGenerateDuplicateCatchClauseWarning) {
1641 EXPECT_THAT(std::function<
void()>([]() {
throw std::exception(); }),
1642 Throws<std::exception>());
1645TEST(ThrowsTest, CallableExecutedExactlyOnce) {
1648 EXPECT_THAT(std::function<
void()>([&a]() {
1655 EXPECT_THAT(std::function<
void()>([&a]() {
1657 throw std::runtime_error(
"message");
1659 Throws<std::runtime_error>());
1662 EXPECT_THAT(std::function<
void()>([&a]() {
1664 throw std::runtime_error(
"message");
1666 ThrowsMessage<std::runtime_error>(HasSubstr(
"message")));
1669 EXPECT_THAT(std::function<
void()>([&a]() {
1671 throw std::runtime_error(
"message");
1673 Throws<std::runtime_error>(
1674 Property(&std::runtime_error::what, HasSubstr(
"message"))));
1678TEST(ThrowsTest, Describe) {
1679 Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
1680 std::stringstream ss;
1681 matcher.DescribeTo(&ss);
1682 auto explanation = ss.str();
1683 EXPECT_THAT(explanation, HasSubstr(
"std::runtime_error"));
1686TEST(ThrowsTest, Success) {
1687 Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
1688 StringMatchResultListener listener;
1689 EXPECT_TRUE(matcher.MatchAndExplain(
1690 []() { throw std::runtime_error(
"error message"); }, &listener));
1691 EXPECT_THAT(listener.str(), HasSubstr(
"std::runtime_error"));
1694TEST(ThrowsTest, FailWrongType) {
1695 Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
1696 StringMatchResultListener listener;
1697 EXPECT_FALSE(matcher.MatchAndExplain(
1698 []() { throw std::logic_error(
"error message"); }, &listener));
1699 EXPECT_THAT(listener.str(), HasSubstr(
"std::logic_error"));
1700 EXPECT_THAT(listener.str(), HasSubstr(
"\"error message\""));
1703TEST(ThrowsTest, FailWrongTypeNonStd) {
1704 Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
1705 StringMatchResultListener listener;
1706 EXPECT_FALSE(matcher.MatchAndExplain([]() { throw 10; }, &listener));
1707 EXPECT_THAT(listener.str(),
1708 HasSubstr(
"throws an exception of an unknown type"));
1711TEST(ThrowsTest, FailNoThrow) {
1712 Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
1713 StringMatchResultListener listener;
1714 EXPECT_FALSE(matcher.MatchAndExplain([]() { (void)0; }, &listener));
1715 EXPECT_THAT(listener.str(), HasSubstr(
"does not throw any exception"));
1718class ThrowsPredicateTest
1719 :
public TestWithParam<Matcher<std::function<void()>>> {};
1721TEST_P(ThrowsPredicateTest, Describe) {
1722 Matcher<std::function<void()>> matcher = GetParam();
1723 std::stringstream ss;
1724 matcher.DescribeTo(&ss);
1725 auto explanation = ss.str();
1726 EXPECT_THAT(explanation, HasSubstr(
"std::runtime_error"));
1727 EXPECT_THAT(explanation, HasSubstr(
"error message"));
1730TEST_P(ThrowsPredicateTest, Success) {
1731 Matcher<std::function<void()>> matcher = GetParam();
1732 StringMatchResultListener listener;
1733 EXPECT_TRUE(matcher.MatchAndExplain(
1734 []() { throw std::runtime_error(
"error message"); }, &listener));
1735 EXPECT_THAT(listener.str(), HasSubstr(
"std::runtime_error"));
1738TEST_P(ThrowsPredicateTest, FailWrongType) {
1739 Matcher<std::function<void()>> matcher = GetParam();
1740 StringMatchResultListener listener;
1741 EXPECT_FALSE(matcher.MatchAndExplain(
1742 []() { throw std::logic_error(
"error message"); }, &listener));
1743 EXPECT_THAT(listener.str(), HasSubstr(
"std::logic_error"));
1744 EXPECT_THAT(listener.str(), HasSubstr(
"\"error message\""));
1747TEST_P(ThrowsPredicateTest, FailWrongTypeNonStd) {
1748 Matcher<std::function<void()>> matcher = GetParam();
1749 StringMatchResultListener listener;
1750 EXPECT_FALSE(matcher.MatchAndExplain([]() { throw 10; }, &listener));
1751 EXPECT_THAT(listener.str(),
1752 HasSubstr(
"throws an exception of an unknown type"));
1755TEST_P(ThrowsPredicateTest, FailNoThrow) {
1756 Matcher<std::function<void()>> matcher = GetParam();
1757 StringMatchResultListener listener;
1758 EXPECT_FALSE(matcher.MatchAndExplain([]() {}, &listener));
1759 EXPECT_THAT(listener.str(), HasSubstr(
"does not throw any exception"));
1762INSTANTIATE_TEST_SUITE_P(
1763 AllMessagePredicates, ThrowsPredicateTest,
1764 Values(Matcher<std::function<
void()>>(
1765 ThrowsMessage<std::runtime_error>(HasSubstr(
"error message")))));
1768TEST(ThrowsPredicateCompilesTest, ExceptionMatcherAcceptsBroadType) {
1770 Matcher<std::function<void()>> matcher =
1771 ThrowsMessage<std::runtime_error>(HasSubstr(
"error message"));
1773 matcher.Matches([]() { throw std::runtime_error(
"error message"); }));
1775 matcher.Matches([]() { throw std::runtime_error(
"wrong message"); }));
1779 Matcher<uint64_t> inner = Eq(10);
1780 Matcher<std::function<void()>> matcher = Throws<uint32_t>(inner);
1781 EXPECT_TRUE(matcher.Matches([]() { throw(uint32_t) 10; }));
1782 EXPECT_FALSE(matcher.Matches([]() { throw(uint32_t) 11; }));
1788TEST(ThrowsPredicateCompilesTest, MessageMatcherAcceptsNonMatcher) {
1789 Matcher<std::function<void()>> matcher =
1790 ThrowsMessage<std::runtime_error>(
"error message");
1792 matcher.Matches([]() { throw std::runtime_error(
"error message"); }));
1793 EXPECT_FALSE(matcher.Matches(
1794 []() { throw std::runtime_error(
"wrong error message"); }));
Definition gtest-type-util.h:156