1// Copyright 2007, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8// * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14// * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30
31// Google Mock - a framework for writing C++ mock classes.
32//
33// This file tests the built-in cardinalities.
34
35#include "gmock/gmock.h"
36#include "gtest/gtest.h"
37#include "gtest/gtest-spi.h"
38
39namespace {
40
41using std::stringstream;
42using testing::AnyNumber;
43using testing::AtLeast;
44using testing::AtMost;
45using testing::Between;
46using testing::Cardinality;
47using testing::CardinalityInterface;
48using testing::Exactly;
49using testing::IsSubstring;
50using testing::MakeCardinality;
51
52class MockFoo {
53 public:
54 MockFoo() {}
55 MOCK_METHOD0(Bar, int()); // NOLINT
56
57 private:
58 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
59};
60
61// Tests that Cardinality objects can be default constructed.
62TEST(CardinalityTest, IsDefaultConstructable) {
63 Cardinality c;
64}
65
66// Tests that Cardinality objects are copyable.
67TEST(CardinalityTest, IsCopyable) {
68 // Tests the copy constructor.
69 Cardinality c = Exactly(1);
70 EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
71 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
72 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
73
74 // Tests the assignment operator.
75 c = Exactly(2);
76 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
77 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
78 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
79}
80
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));
86}
87
88// Tests that Cardinality::DescribeActualCallCountTo() creates the
89// correct description.
90TEST(CardinalityTest, CanDescribeActualCallCount) {
91 stringstream ss0;
92 Cardinality::DescribeActualCallCountTo(0, &ss0);
93 EXPECT_EQ("never called", ss0.str());
94
95 stringstream ss1;
96 Cardinality::DescribeActualCallCountTo(1, &ss1);
97 EXPECT_EQ("called once", ss1.str());
98
99 stringstream ss2;
100 Cardinality::DescribeActualCallCountTo(2, &ss2);
101 EXPECT_EQ("called twice", ss2.str());
102
103 stringstream ss3;
104 Cardinality::DescribeActualCallCountTo(3, &ss3);
105 EXPECT_EQ("called 3 times", ss3.str());
106}
107
108// Tests AnyNumber()
109TEST(AnyNumber, Works) {
110 const Cardinality c = AnyNumber();
111 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
112 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
113
114 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
115 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
116
117 EXPECT_TRUE(c.IsSatisfiedByCallCount(9));
118 EXPECT_FALSE(c.IsSaturatedByCallCount(9));
119
120 stringstream ss;
121 c.DescribeTo(&ss);
122 EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times",
123 ss.str());
124}
125
126TEST(AnyNumberTest, HasCorrectBounds) {
127 const Cardinality c = AnyNumber();
128 EXPECT_EQ(0, c.ConservativeLowerBound());
129 EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
130}
131
132// Tests AtLeast(n).
133
134TEST(AtLeastTest, OnNegativeNumber) {
135 EXPECT_NONFATAL_FAILURE({ // NOLINT
136 AtLeast(-1);
137 }, "The invocation lower bound must be >= 0");
138}
139
140TEST(AtLeastTest, OnZero) {
141 const Cardinality c = AtLeast(0);
142 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
143 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
144
145 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
146 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
147
148 stringstream ss;
149 c.DescribeTo(&ss);
150 EXPECT_PRED_FORMAT2(IsSubstring, "any number of times",
151 ss.str());
152}
153
154TEST(AtLeastTest, OnPositiveNumber) {
155 const Cardinality c = AtLeast(2);
156 EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
157 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
158
159 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
160 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
161
162 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
163 EXPECT_FALSE(c.IsSaturatedByCallCount(2));
164
165 stringstream ss1;
166 AtLeast(1).DescribeTo(&ss1);
167 EXPECT_PRED_FORMAT2(IsSubstring, "at least once",
168 ss1.str());
169
170 stringstream ss2;
171 c.DescribeTo(&ss2);
172 EXPECT_PRED_FORMAT2(IsSubstring, "at least twice",
173 ss2.str());
174
175 stringstream ss3;
176 AtLeast(3).DescribeTo(&ss3);
177 EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times",
178 ss3.str());
179}
180
181TEST(AtLeastTest, HasCorrectBounds) {
182 const Cardinality c = AtLeast(2);
183 EXPECT_EQ(2, c.ConservativeLowerBound());
184 EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
185}
186
187// Tests AtMost(n).
188
189TEST(AtMostTest, OnNegativeNumber) {
190 EXPECT_NONFATAL_FAILURE({ // NOLINT
191 AtMost(-1);
192 }, "The invocation upper bound must be >= 0");
193}
194
195TEST(AtMostTest, OnZero) {
196 const Cardinality c = AtMost(0);
197 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
198 EXPECT_TRUE(c.IsSaturatedByCallCount(0));
199
200 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
201 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
202
203 stringstream ss;
204 c.DescribeTo(&ss);
205 EXPECT_PRED_FORMAT2(IsSubstring, "never called",
206 ss.str());
207}
208
209TEST(AtMostTest, OnPositiveNumber) {
210 const Cardinality c = AtMost(2);
211 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
212 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
213
214 EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
215 EXPECT_FALSE(c.IsSaturatedByCallCount(1));
216
217 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
218 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
219
220 stringstream ss1;
221 AtMost(1).DescribeTo(&ss1);
222 EXPECT_PRED_FORMAT2(IsSubstring, "called at most once",
223 ss1.str());
224
225 stringstream ss2;
226 c.DescribeTo(&ss2);
227 EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
228 ss2.str());
229
230 stringstream ss3;
231 AtMost(3).DescribeTo(&ss3);
232 EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times",
233 ss3.str());
234}
235
236TEST(AtMostTest, HasCorrectBounds) {
237 const Cardinality c = AtMost(2);
238 EXPECT_EQ(0, c.ConservativeLowerBound());
239 EXPECT_EQ(2, c.ConservativeUpperBound());
240}
241
242// Tests Between(m, n).
243
244TEST(BetweenTest, OnNegativeStart) {
245 EXPECT_NONFATAL_FAILURE({ // NOLINT
246 Between(-1, 2);
247 }, "The invocation lower bound must be >= 0, but is actually -1");
248}
249
250TEST(BetweenTest, OnNegativeEnd) {
251 EXPECT_NONFATAL_FAILURE({ // NOLINT
252 Between(1, -2);
253 }, "The invocation upper bound must be >= 0, but is actually -2");
254}
255
256TEST(BetweenTest, OnStartBiggerThanEnd) {
257 EXPECT_NONFATAL_FAILURE({ // NOLINT
258 Between(2, 1);
259 }, "The invocation upper bound (1) must be >= "
260 "the invocation lower bound (2)");
261}
262
263TEST(BetweenTest, OnZeroStartAndZeroEnd) {
264 const Cardinality c = Between(0, 0);
265
266 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
267 EXPECT_TRUE(c.IsSaturatedByCallCount(0));
268
269 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
270 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
271
272 stringstream ss;
273 c.DescribeTo(&ss);
274 EXPECT_PRED_FORMAT2(IsSubstring, "never called",
275 ss.str());
276}
277
278TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
279 const Cardinality c = Between(0, 2);
280
281 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
282 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
283
284 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
285 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
286
287 EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
288 EXPECT_TRUE(c.IsSaturatedByCallCount(4));
289
290 stringstream ss;
291 c.DescribeTo(&ss);
292 EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
293 ss.str());
294}
295
296TEST(BetweenTest, OnSameStartAndEnd) {
297 const Cardinality c = Between(3, 3);
298
299 EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
300 EXPECT_FALSE(c.IsSaturatedByCallCount(2));
301
302 EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
303 EXPECT_TRUE(c.IsSaturatedByCallCount(3));
304
305 EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
306 EXPECT_TRUE(c.IsSaturatedByCallCount(4));
307
308 stringstream ss;
309 c.DescribeTo(&ss);
310 EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
311 ss.str());
312}
313
314TEST(BetweenTest, OnDifferentStartAndEnd) {
315 const Cardinality c = Between(3, 5);
316
317 EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
318 EXPECT_FALSE(c.IsSaturatedByCallCount(2));
319
320 EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
321 EXPECT_FALSE(c.IsSaturatedByCallCount(3));
322
323 EXPECT_TRUE(c.IsSatisfiedByCallCount(5));
324 EXPECT_TRUE(c.IsSaturatedByCallCount(5));
325
326 EXPECT_FALSE(c.IsSatisfiedByCallCount(6));
327 EXPECT_TRUE(c.IsSaturatedByCallCount(6));
328
329 stringstream ss;
330 c.DescribeTo(&ss);
331 EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times",
332 ss.str());
333}
334
335TEST(BetweenTest, HasCorrectBounds) {
336 const Cardinality c = Between(3, 5);
337 EXPECT_EQ(3, c.ConservativeLowerBound());
338 EXPECT_EQ(5, c.ConservativeUpperBound());
339}
340
341// Tests Exactly(n).
342
343TEST(ExactlyTest, OnNegativeNumber) {
344 EXPECT_NONFATAL_FAILURE({ // NOLINT
345 Exactly(-1);
346 }, "The invocation lower bound must be >= 0");
347}
348
349TEST(ExactlyTest, OnZero) {
350 const Cardinality c = Exactly(0);
351 EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
352 EXPECT_TRUE(c.IsSaturatedByCallCount(0));
353
354 EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
355 EXPECT_TRUE(c.IsSaturatedByCallCount(1));
356
357 stringstream ss;
358 c.DescribeTo(&ss);
359 EXPECT_PRED_FORMAT2(IsSubstring, "never called",
360 ss.str());
361}
362
363TEST(ExactlyTest, OnPositiveNumber) {
364 const Cardinality c = Exactly(2);
365 EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
366 EXPECT_FALSE(c.IsSaturatedByCallCount(0));
367
368 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
369 EXPECT_TRUE(c.IsSaturatedByCallCount(2));
370
371 stringstream ss1;
372 Exactly(1).DescribeTo(&ss1);
373 EXPECT_PRED_FORMAT2(IsSubstring, "called once",
374 ss1.str());
375
376 stringstream ss2;
377 c.DescribeTo(&ss2);
378 EXPECT_PRED_FORMAT2(IsSubstring, "called twice",
379 ss2.str());
380
381 stringstream ss3;
382 Exactly(3).DescribeTo(&ss3);
383 EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
384 ss3.str());
385}
386
387TEST(ExactlyTest, HasCorrectBounds) {
388 const Cardinality c = Exactly(3);
389 EXPECT_EQ(3, c.ConservativeLowerBound());
390 EXPECT_EQ(3, c.ConservativeUpperBound());
391}
392
393// Tests that a user can make their own cardinality by implementing
394// CardinalityInterface and calling MakeCardinality().
395
396class EvenCardinality : public CardinalityInterface {
397 public:
398 // Returns true if and only if call_count calls will satisfy this
399 // cardinality.
400 bool IsSatisfiedByCallCount(int call_count) const override {
401 return (call_count % 2 == 0);
402 }
403
404 // Returns true if and only if call_count calls will saturate this
405 // cardinality.
406 bool IsSaturatedByCallCount(int /* call_count */) const override {
407 return false;
408 }
409
410 // Describes self to an ostream.
411 void DescribeTo(::std::ostream* ss) const override {
412 *ss << "called even number of times";
413 }
414};
415
416TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {
417 const Cardinality c = MakeCardinality(new EvenCardinality);
418
419 EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
420 EXPECT_FALSE(c.IsSatisfiedByCallCount(3));
421
422 EXPECT_FALSE(c.IsSaturatedByCallCount(10000));
423
424 stringstream ss;
425 c.DescribeTo(&ss);
426 EXPECT_EQ("called even number of times", ss.str());
427}
428
429} // Unnamed namespace
430