35#include "gmock/gmock.h"
36#include "gtest/gtest.h"
37#include "gtest/gtest-spi.h"
41using std::stringstream;
42using testing::AnyNumber;
43using testing::AtLeast;
45using testing::Between;
46using testing::Cardinality;
47using testing::CardinalityInterface;
48using testing::Exactly;
49using testing::IsSubstring;
50using testing::MakeCardinality;
55 MOCK_METHOD0(Bar,
int());
58 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
62TEST(CardinalityTest, IsDefaultConstructable) {
67TEST(CardinalityTest, IsCopyable) {
69 Cardinality c = Exactly(1);
70 EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
71 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
72 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
76 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
77 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
78 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
81TEST(CardinalityTest, IsOverSaturatedByCallCountWorks) {
82 const Cardinality c = AtMost(5);
83 EXPECT_FALSE(c.IsOverSaturatedByCallCount(4));
84 EXPECT_FALSE(c.IsOverSaturatedByCallCount(5));
85 EXPECT_TRUE(c.IsOverSaturatedByCallCount(6));
90TEST(CardinalityTest, CanDescribeActualCallCount) {
92 Cardinality::DescribeActualCallCountTo(0, &ss0);
93 EXPECT_EQ(
"never called", ss0.str());
96 Cardinality::DescribeActualCallCountTo(1, &ss1);
97 EXPECT_EQ(
"called once", ss1.str());
100 Cardinality::DescribeActualCallCountTo(2, &ss2);
101 EXPECT_EQ(
"called twice", ss2.str());
104 Cardinality::DescribeActualCallCountTo(3, &ss3);
105 EXPECT_EQ(
"called 3 times", ss3.str());
109TEST(AnyNumber, Works) {
110 const Cardinality c = AnyNumber();
111 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
112 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
114 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
115 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
117 EXPECT_TRUE(c.IsSatisfiedByCallCount(9));
118 EXPECT_FALSE(c.IsSaturatedByCallCount(9));
122 EXPECT_PRED_FORMAT2(IsSubstring,
"called any number of times",
126TEST(AnyNumberTest, HasCorrectBounds) {
127 const Cardinality c = AnyNumber();
128 EXPECT_EQ(0, c.ConservativeLowerBound());
129 EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
134TEST(AtLeastTest, OnNegativeNumber) {
135 EXPECT_NONFATAL_FAILURE({
137 },
"The invocation lower bound must be >= 0");
140TEST(AtLeastTest, OnZero) {
141 const Cardinality c = AtLeast(0);
142 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
143 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
145 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
146 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
150 EXPECT_PRED_FORMAT2(IsSubstring,
"any number of times",
154TEST(AtLeastTest, OnPositiveNumber) {
155 const Cardinality c = AtLeast(2);
156 EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
157 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
159 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
160 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
162 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
163 EXPECT_FALSE(c.IsSaturatedByCallCount(2));
166 AtLeast(1).DescribeTo(&ss1);
167 EXPECT_PRED_FORMAT2(IsSubstring,
"at least once",
172 EXPECT_PRED_FORMAT2(IsSubstring,
"at least twice",
176 AtLeast(3).DescribeTo(&ss3);
177 EXPECT_PRED_FORMAT2(IsSubstring,
"at least 3 times",
181TEST(AtLeastTest, HasCorrectBounds) {
182 const Cardinality c = AtLeast(2);
183 EXPECT_EQ(2, c.ConservativeLowerBound());
184 EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
189TEST(AtMostTest, OnNegativeNumber) {
190 EXPECT_NONFATAL_FAILURE({
192 },
"The invocation upper bound must be >= 0");
195TEST(AtMostTest, OnZero) {
196 const Cardinality c = AtMost(0);
197 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
198 EXPECT_TRUE(c.IsSaturatedByCallCount(0));
200 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
201 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
205 EXPECT_PRED_FORMAT2(IsSubstring,
"never called",
209TEST(AtMostTest, OnPositiveNumber) {
210 const Cardinality c = AtMost(2);
211 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
212 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
214 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
215 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
217 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
218 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
221 AtMost(1).DescribeTo(&ss1);
222 EXPECT_PRED_FORMAT2(IsSubstring,
"called at most once",
227 EXPECT_PRED_FORMAT2(IsSubstring,
"called at most twice",
231 AtMost(3).DescribeTo(&ss3);
232 EXPECT_PRED_FORMAT2(IsSubstring,
"called at most 3 times",
236TEST(AtMostTest, HasCorrectBounds) {
237 const Cardinality c = AtMost(2);
238 EXPECT_EQ(0, c.ConservativeLowerBound());
239 EXPECT_EQ(2, c.ConservativeUpperBound());
244TEST(BetweenTest, OnNegativeStart) {
245 EXPECT_NONFATAL_FAILURE({
247 },
"The invocation lower bound must be >= 0, but is actually -1");
250TEST(BetweenTest, OnNegativeEnd) {
251 EXPECT_NONFATAL_FAILURE({
253 },
"The invocation upper bound must be >= 0, but is actually -2");
256TEST(BetweenTest, OnStartBiggerThanEnd) {
257 EXPECT_NONFATAL_FAILURE({
259 },
"The invocation upper bound (1) must be >= "
260 "the invocation lower bound (2)");
263TEST(BetweenTest, OnZeroStartAndZeroEnd) {
264 const Cardinality c = Between(0, 0);
266 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
267 EXPECT_TRUE(c.IsSaturatedByCallCount(0));
269 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
270 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
274 EXPECT_PRED_FORMAT2(IsSubstring,
"never called",
278TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
279 const Cardinality c = Between(0, 2);
281 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
282 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
284 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
285 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
287 EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
288 EXPECT_TRUE(c.IsSaturatedByCallCount(4));
292 EXPECT_PRED_FORMAT2(IsSubstring,
"called at most twice",
296TEST(BetweenTest, OnSameStartAndEnd) {
297 const Cardinality c = Between(3, 3);
299 EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
300 EXPECT_FALSE(c.IsSaturatedByCallCount(2));
302 EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
303 EXPECT_TRUE(c.IsSaturatedByCallCount(3));
305 EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
306 EXPECT_TRUE(c.IsSaturatedByCallCount(4));
310 EXPECT_PRED_FORMAT2(IsSubstring,
"called 3 times",
314TEST(BetweenTest, OnDifferentStartAndEnd) {
315 const Cardinality c = Between(3, 5);
317 EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
318 EXPECT_FALSE(c.IsSaturatedByCallCount(2));
320 EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
321 EXPECT_FALSE(c.IsSaturatedByCallCount(3));
323 EXPECT_TRUE(c.IsSatisfiedByCallCount(5));
324 EXPECT_TRUE(c.IsSaturatedByCallCount(5));
326 EXPECT_FALSE(c.IsSatisfiedByCallCount(6));
327 EXPECT_TRUE(c.IsSaturatedByCallCount(6));
331 EXPECT_PRED_FORMAT2(IsSubstring,
"called between 3 and 5 times",
335TEST(BetweenTest, HasCorrectBounds) {
336 const Cardinality c = Between(3, 5);
337 EXPECT_EQ(3, c.ConservativeLowerBound());
338 EXPECT_EQ(5, c.ConservativeUpperBound());
343TEST(ExactlyTest, OnNegativeNumber) {
344 EXPECT_NONFATAL_FAILURE({
346 },
"The invocation lower bound must be >= 0");
349TEST(ExactlyTest, OnZero) {
350 const Cardinality c = Exactly(0);
351 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
352 EXPECT_TRUE(c.IsSaturatedByCallCount(0));
354 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
355 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
359 EXPECT_PRED_FORMAT2(IsSubstring,
"never called",
363TEST(ExactlyTest, OnPositiveNumber) {
364 const Cardinality c = Exactly(2);
365 EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
366 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
368 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
369 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
372 Exactly(1).DescribeTo(&ss1);
373 EXPECT_PRED_FORMAT2(IsSubstring,
"called once",
378 EXPECT_PRED_FORMAT2(IsSubstring,
"called twice",
382 Exactly(3).DescribeTo(&ss3);
383 EXPECT_PRED_FORMAT2(IsSubstring,
"called 3 times",
387TEST(ExactlyTest, HasCorrectBounds) {
388 const Cardinality c = Exactly(3);
389 EXPECT_EQ(3, c.ConservativeLowerBound());
390 EXPECT_EQ(3, c.ConservativeUpperBound());
396class EvenCardinality :
public CardinalityInterface {
400 bool IsSatisfiedByCallCount(
int call_count)
const override {
401 return (call_count % 2 == 0);
406 bool IsSaturatedByCallCount(
int )
const override {
411 void DescribeTo(::std::ostream* ss)
const override {
412 *ss <<
"called even number of times";
416TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {
417 const Cardinality c = MakeCardinality(
new EvenCardinality);
419 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
420 EXPECT_FALSE(c.IsSatisfiedByCallCount(3));
422 EXPECT_FALSE(c.IsSaturatedByCallCount(10000));
426 EXPECT_EQ(
"called even number of times", ss.str());