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 iff call_count calls will satisfy this cardinality.
399  virtual bool IsSatisfiedByCallCount(int call_count) const {
400    return (call_count % 2 == 0);
401  }
402
403  // Returns true iff call_count calls will saturate this cardinality.
404  virtual bool IsSaturatedByCallCount(int /* call_count */) const {
405    return false;
406  }
407
408  // Describes self to an ostream.
409  virtual void DescribeTo(::std::ostream* ss) const {
410    *ss << "called even number of times";
411  }
412};
413
414TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {
415  const Cardinality c = MakeCardinality(new EvenCardinality);
416
417  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
418  EXPECT_FALSE(c.IsSatisfiedByCallCount(3));
419
420  EXPECT_FALSE(c.IsSaturatedByCallCount(10000));
421
422  stringstream ss;
423  c.DescribeTo(&ss);
424  EXPECT_EQ("called even number of times", ss.str());
425}
426
427}  // Unnamed namespace
428