34#include "gmock/gmock.h"
35#include "gtest/gtest-spi.h"
36#include "gtest/gtest.h"
40using std::stringstream;
41using testing::AnyNumber;
42using testing::AtLeast;
44using testing::Between;
45using testing::Cardinality;
46using testing::CardinalityInterface;
47using testing::Exactly;
48using testing::IsSubstring;
49using testing::MakeCardinality;
54 MOCK_METHOD0(Bar,
int());
57 MockFoo(
const MockFoo&) =
delete;
58 MockFoo& operator=(
const MockFoo&) =
delete;
62TEST(CardinalityTest, IsDefaultConstructable) { Cardinality c; }
65TEST(CardinalityTest, IsCopyable) {
67 Cardinality c = Exactly(1);
68 EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
69 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
70 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
74 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
75 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
76 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
79TEST(CardinalityTest, IsOverSaturatedByCallCountWorks) {
80 const Cardinality c = AtMost(5);
81 EXPECT_FALSE(c.IsOverSaturatedByCallCount(4));
82 EXPECT_FALSE(c.IsOverSaturatedByCallCount(5));
83 EXPECT_TRUE(c.IsOverSaturatedByCallCount(6));
88TEST(CardinalityTest, CanDescribeActualCallCount) {
90 Cardinality::DescribeActualCallCountTo(0, &ss0);
91 EXPECT_EQ(
"never called", ss0.str());
94 Cardinality::DescribeActualCallCountTo(1, &ss1);
95 EXPECT_EQ(
"called once", ss1.str());
98 Cardinality::DescribeActualCallCountTo(2, &ss2);
99 EXPECT_EQ(
"called twice", ss2.str());
102 Cardinality::DescribeActualCallCountTo(3, &ss3);
103 EXPECT_EQ(
"called 3 times", ss3.str());
107TEST(AnyNumber, Works) {
108 const Cardinality c = AnyNumber();
109 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
110 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
112 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
113 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
115 EXPECT_TRUE(c.IsSatisfiedByCallCount(9));
116 EXPECT_FALSE(c.IsSaturatedByCallCount(9));
120 EXPECT_PRED_FORMAT2(IsSubstring,
"called any number of times", ss.str());
123TEST(AnyNumberTest, HasCorrectBounds) {
124 const Cardinality c = AnyNumber();
125 EXPECT_EQ(0, c.ConservativeLowerBound());
126 EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
131TEST(AtLeastTest, OnNegativeNumber) {
132 EXPECT_NONFATAL_FAILURE(
136 "The invocation lower bound must be >= 0");
139TEST(AtLeastTest, OnZero) {
140 const Cardinality c = AtLeast(0);
141 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
142 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
144 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
145 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
149 EXPECT_PRED_FORMAT2(IsSubstring,
"any number of times", ss.str());
152TEST(AtLeastTest, OnPositiveNumber) {
153 const Cardinality c = AtLeast(2);
154 EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
155 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
157 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
158 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
160 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
161 EXPECT_FALSE(c.IsSaturatedByCallCount(2));
164 AtLeast(1).DescribeTo(&ss1);
165 EXPECT_PRED_FORMAT2(IsSubstring,
"at least once", ss1.str());
169 EXPECT_PRED_FORMAT2(IsSubstring,
"at least twice", ss2.str());
172 AtLeast(3).DescribeTo(&ss3);
173 EXPECT_PRED_FORMAT2(IsSubstring,
"at least 3 times", ss3.str());
176TEST(AtLeastTest, HasCorrectBounds) {
177 const Cardinality c = AtLeast(2);
178 EXPECT_EQ(2, c.ConservativeLowerBound());
179 EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
184TEST(AtMostTest, OnNegativeNumber) {
185 EXPECT_NONFATAL_FAILURE(
189 "The invocation upper bound must be >= 0");
192TEST(AtMostTest, OnZero) {
193 const Cardinality c = AtMost(0);
194 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
195 EXPECT_TRUE(c.IsSaturatedByCallCount(0));
197 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
198 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
202 EXPECT_PRED_FORMAT2(IsSubstring,
"never called", ss.str());
205TEST(AtMostTest, OnPositiveNumber) {
206 const Cardinality c = AtMost(2);
207 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
208 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
210 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
211 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
213 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
214 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
217 AtMost(1).DescribeTo(&ss1);
218 EXPECT_PRED_FORMAT2(IsSubstring,
"called at most once", ss1.str());
222 EXPECT_PRED_FORMAT2(IsSubstring,
"called at most twice", ss2.str());
225 AtMost(3).DescribeTo(&ss3);
226 EXPECT_PRED_FORMAT2(IsSubstring,
"called at most 3 times", ss3.str());
229TEST(AtMostTest, HasCorrectBounds) {
230 const Cardinality c = AtMost(2);
231 EXPECT_EQ(0, c.ConservativeLowerBound());
232 EXPECT_EQ(2, c.ConservativeUpperBound());
237TEST(BetweenTest, OnNegativeStart) {
238 EXPECT_NONFATAL_FAILURE(
242 "The invocation lower bound must be >= 0, but is actually -1");
245TEST(BetweenTest, OnNegativeEnd) {
246 EXPECT_NONFATAL_FAILURE(
250 "The invocation upper bound must be >= 0, but is actually -2");
253TEST(BetweenTest, OnStartBiggerThanEnd) {
254 EXPECT_NONFATAL_FAILURE(
258 "The invocation upper bound (1) must be >= "
259 "the invocation lower bound (2)");
262TEST(BetweenTest, OnZeroStartAndZeroEnd) {
263 const Cardinality c = Between(0, 0);
265 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
266 EXPECT_TRUE(c.IsSaturatedByCallCount(0));
268 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
269 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
273 EXPECT_PRED_FORMAT2(IsSubstring,
"never called", ss.str());
276TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
277 const Cardinality c = Between(0, 2);
279 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
280 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
282 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
283 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
285 EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
286 EXPECT_TRUE(c.IsSaturatedByCallCount(4));
290 EXPECT_PRED_FORMAT2(IsSubstring,
"called at most twice", ss.str());
293TEST(BetweenTest, OnSameStartAndEnd) {
294 const Cardinality c = Between(3, 3);
296 EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
297 EXPECT_FALSE(c.IsSaturatedByCallCount(2));
299 EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
300 EXPECT_TRUE(c.IsSaturatedByCallCount(3));
302 EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
303 EXPECT_TRUE(c.IsSaturatedByCallCount(4));
307 EXPECT_PRED_FORMAT2(IsSubstring,
"called 3 times", ss.str());
310TEST(BetweenTest, OnDifferentStartAndEnd) {
311 const Cardinality c = Between(3, 5);
313 EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
314 EXPECT_FALSE(c.IsSaturatedByCallCount(2));
316 EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
317 EXPECT_FALSE(c.IsSaturatedByCallCount(3));
319 EXPECT_TRUE(c.IsSatisfiedByCallCount(5));
320 EXPECT_TRUE(c.IsSaturatedByCallCount(5));
322 EXPECT_FALSE(c.IsSatisfiedByCallCount(6));
323 EXPECT_TRUE(c.IsSaturatedByCallCount(6));
327 EXPECT_PRED_FORMAT2(IsSubstring,
"called between 3 and 5 times", ss.str());
330TEST(BetweenTest, HasCorrectBounds) {
331 const Cardinality c = Between(3, 5);
332 EXPECT_EQ(3, c.ConservativeLowerBound());
333 EXPECT_EQ(5, c.ConservativeUpperBound());
338TEST(ExactlyTest, OnNegativeNumber) {
339 EXPECT_NONFATAL_FAILURE(
343 "The invocation lower bound must be >= 0");
346TEST(ExactlyTest, OnZero) {
347 const Cardinality c = Exactly(0);
348 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
349 EXPECT_TRUE(c.IsSaturatedByCallCount(0));
351 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
352 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
356 EXPECT_PRED_FORMAT2(IsSubstring,
"never called", ss.str());
359TEST(ExactlyTest, OnPositiveNumber) {
360 const Cardinality c = Exactly(2);
361 EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
362 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
364 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
365 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
368 Exactly(1).DescribeTo(&ss1);
369 EXPECT_PRED_FORMAT2(IsSubstring,
"called once", ss1.str());
373 EXPECT_PRED_FORMAT2(IsSubstring,
"called twice", ss2.str());
376 Exactly(3).DescribeTo(&ss3);
377 EXPECT_PRED_FORMAT2(IsSubstring,
"called 3 times", ss3.str());
380TEST(ExactlyTest, HasCorrectBounds) {
381 const Cardinality c = Exactly(3);
382 EXPECT_EQ(3, c.ConservativeLowerBound());
383 EXPECT_EQ(3, c.ConservativeUpperBound());
389class EvenCardinality :
public CardinalityInterface {
393 bool IsSatisfiedByCallCount(
int call_count)
const override {
394 return (call_count % 2 == 0);
399 bool IsSaturatedByCallCount(
int )
const override {
404 void DescribeTo(::std::ostream* ss)
const override {
405 *ss <<
"called even number of times";
409TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {
410 const Cardinality c = MakeCardinality(
new EvenCardinality);
412 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
413 EXPECT_FALSE(c.IsSatisfiedByCallCount(3));
415 EXPECT_FALSE(c.IsSaturatedByCallCount(10000));
419 EXPECT_EQ(
"called even number of times", ss.str());