Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gmock-cardinalities_test.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file gmock-cardinalities_test.cc
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 // Author: wan@google.com (Zhanyong Wan)
31 
32 // Google Mock - a framework for writing C++ mock classes.
33 //
34 // This file tests the built-in cardinalities.
35 
36 #include "gmock/gmock.h"
37 #include "gtest/gtest.h"
38 #include "gtest/gtest-spi.h"
39 
40 namespace {
41 
42 using std::stringstream;
43 using testing::AnyNumber;
44 using testing::AtLeast;
45 using testing::AtMost;
46 using testing::Between;
49 using testing::Exactly;
52 
53 class MockFoo {
54  public:
55  MockFoo() {}
56  MOCK_METHOD0(Bar, int()); // NOLINT
57 
58  private:
60 };
61 
62 // Tests that Cardinality objects can be default constructed.
63 TEST(CardinalityTest, IsDefaultConstructable) {
64  Cardinality c;
65 }
66 
67 // Tests that Cardinality objects are copyable.
68 TEST(CardinalityTest, IsCopyable) {
69  // Tests the copy constructor.
70  Cardinality c = Exactly(1);
71  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
72  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
73  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
74 
75  // Tests the assignment operator.
76  c = Exactly(2);
77  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
78  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
79  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
80 }
81 
82 TEST(CardinalityTest, IsOverSaturatedByCallCountWorks) {
83  const Cardinality c = AtMost(5);
84  EXPECT_FALSE(c.IsOverSaturatedByCallCount(4));
85  EXPECT_FALSE(c.IsOverSaturatedByCallCount(5));
86  EXPECT_TRUE(c.IsOverSaturatedByCallCount(6));
87 }
88 
89 // Tests that Cardinality::DescribeActualCallCountTo() creates the
90 // correct description.
91 TEST(CardinalityTest, CanDescribeActualCallCount) {
92  stringstream ss0;
93  Cardinality::DescribeActualCallCountTo(0, &ss0);
94  EXPECT_EQ("never called", ss0.str());
95 
96  stringstream ss1;
97  Cardinality::DescribeActualCallCountTo(1, &ss1);
98  EXPECT_EQ("called once", ss1.str());
99 
100  stringstream ss2;
101  Cardinality::DescribeActualCallCountTo(2, &ss2);
102  EXPECT_EQ("called twice", ss2.str());
103 
104  stringstream ss3;
105  Cardinality::DescribeActualCallCountTo(3, &ss3);
106  EXPECT_EQ("called 3 times", ss3.str());
107 }
108 
109 // Tests AnyNumber()
110 TEST(AnyNumber, Works) {
111  const Cardinality c = AnyNumber();
112  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
113  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
114 
115  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
116  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
117 
118  EXPECT_TRUE(c.IsSatisfiedByCallCount(9));
119  EXPECT_FALSE(c.IsSaturatedByCallCount(9));
120 
121  stringstream ss;
122  c.DescribeTo(&ss);
123  EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times",
124  ss.str());
125 }
126 
127 TEST(AnyNumberTest, HasCorrectBounds) {
128  const Cardinality c = AnyNumber();
129  EXPECT_EQ(0, c.ConservativeLowerBound());
130  EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
131 }
132 
133 // Tests AtLeast(n).
134 
135 TEST(AtLeastTest, OnNegativeNumber) {
136  EXPECT_NONFATAL_FAILURE({ // NOLINT
137  AtLeast(-1);
138  }, "The invocation lower bound must be >= 0");
139 }
140 
141 TEST(AtLeastTest, OnZero) {
142  const Cardinality c = AtLeast(0);
143  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
144  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
145 
146  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
147  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
148 
149  stringstream ss;
150  c.DescribeTo(&ss);
151  EXPECT_PRED_FORMAT2(IsSubstring, "any number of times",
152  ss.str());
153 }
154 
155 TEST(AtLeastTest, OnPositiveNumber) {
156  const Cardinality c = AtLeast(2);
157  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
158  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
159 
160  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
161  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
162 
163  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
164  EXPECT_FALSE(c.IsSaturatedByCallCount(2));
165 
166  stringstream ss1;
167  AtLeast(1).DescribeTo(&ss1);
168  EXPECT_PRED_FORMAT2(IsSubstring, "at least once",
169  ss1.str());
170 
171  stringstream ss2;
172  c.DescribeTo(&ss2);
173  EXPECT_PRED_FORMAT2(IsSubstring, "at least twice",
174  ss2.str());
175 
176  stringstream ss3;
177  AtLeast(3).DescribeTo(&ss3);
178  EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times",
179  ss3.str());
180 }
181 
182 TEST(AtLeastTest, HasCorrectBounds) {
183  const Cardinality c = AtLeast(2);
184  EXPECT_EQ(2, c.ConservativeLowerBound());
185  EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
186 }
187 
188 // Tests AtMost(n).
189 
190 TEST(AtMostTest, OnNegativeNumber) {
191  EXPECT_NONFATAL_FAILURE({ // NOLINT
192  AtMost(-1);
193  }, "The invocation upper bound must be >= 0");
194 }
195 
196 TEST(AtMostTest, OnZero) {
197  const Cardinality c = AtMost(0);
198  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
199  EXPECT_TRUE(c.IsSaturatedByCallCount(0));
200 
201  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
202  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
203 
204  stringstream ss;
205  c.DescribeTo(&ss);
206  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
207  ss.str());
208 }
209 
210 TEST(AtMostTest, OnPositiveNumber) {
211  const Cardinality c = AtMost(2);
212  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
213  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
214 
215  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
216  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
217 
218  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
219  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
220 
221  stringstream ss1;
222  AtMost(1).DescribeTo(&ss1);
223  EXPECT_PRED_FORMAT2(IsSubstring, "called at most once",
224  ss1.str());
225 
226  stringstream ss2;
227  c.DescribeTo(&ss2);
228  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
229  ss2.str());
230 
231  stringstream ss3;
232  AtMost(3).DescribeTo(&ss3);
233  EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times",
234  ss3.str());
235 }
236 
237 TEST(AtMostTest, HasCorrectBounds) {
238  const Cardinality c = AtMost(2);
239  EXPECT_EQ(0, c.ConservativeLowerBound());
240  EXPECT_EQ(2, c.ConservativeUpperBound());
241 }
242 
243 // Tests Between(m, n).
244 
245 TEST(BetweenTest, OnNegativeStart) {
246  EXPECT_NONFATAL_FAILURE({ // NOLINT
247  Between(-1, 2);
248  }, "The invocation lower bound must be >= 0, but is actually -1");
249 }
250 
251 TEST(BetweenTest, OnNegativeEnd) {
252  EXPECT_NONFATAL_FAILURE({ // NOLINT
253  Between(1, -2);
254  }, "The invocation upper bound must be >= 0, but is actually -2");
255 }
256 
257 TEST(BetweenTest, OnStartBiggerThanEnd) {
258  EXPECT_NONFATAL_FAILURE({ // NOLINT
259  Between(2, 1);
260  }, "The invocation upper bound (1) must be >= "
261  "the invocation lower bound (2)");
262 }
263 
264 TEST(BetweenTest, OnZeroStartAndZeroEnd) {
265  const Cardinality c = Between(0, 0);
266 
267  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
268  EXPECT_TRUE(c.IsSaturatedByCallCount(0));
269 
270  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
271  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
272 
273  stringstream ss;
274  c.DescribeTo(&ss);
275  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
276  ss.str());
277 }
278 
279 TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
280  const Cardinality c = Between(0, 2);
281 
282  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
283  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
284 
285  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
286  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
287 
288  EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
289  EXPECT_TRUE(c.IsSaturatedByCallCount(4));
290 
291  stringstream ss;
292  c.DescribeTo(&ss);
293  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
294  ss.str());
295 }
296 
297 TEST(BetweenTest, OnSameStartAndEnd) {
298  const Cardinality c = Between(3, 3);
299 
300  EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
301  EXPECT_FALSE(c.IsSaturatedByCallCount(2));
302 
303  EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
304  EXPECT_TRUE(c.IsSaturatedByCallCount(3));
305 
306  EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
307  EXPECT_TRUE(c.IsSaturatedByCallCount(4));
308 
309  stringstream ss;
310  c.DescribeTo(&ss);
311  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
312  ss.str());
313 }
314 
315 TEST(BetweenTest, OnDifferentStartAndEnd) {
316  const Cardinality c = Between(3, 5);
317 
318  EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
319  EXPECT_FALSE(c.IsSaturatedByCallCount(2));
320 
321  EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
322  EXPECT_FALSE(c.IsSaturatedByCallCount(3));
323 
324  EXPECT_TRUE(c.IsSatisfiedByCallCount(5));
325  EXPECT_TRUE(c.IsSaturatedByCallCount(5));
326 
327  EXPECT_FALSE(c.IsSatisfiedByCallCount(6));
328  EXPECT_TRUE(c.IsSaturatedByCallCount(6));
329 
330  stringstream ss;
331  c.DescribeTo(&ss);
332  EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times",
333  ss.str());
334 }
335 
336 TEST(BetweenTest, HasCorrectBounds) {
337  const Cardinality c = Between(3, 5);
338  EXPECT_EQ(3, c.ConservativeLowerBound());
339  EXPECT_EQ(5, c.ConservativeUpperBound());
340 }
341 
342 // Tests Exactly(n).
343 
344 TEST(ExactlyTest, OnNegativeNumber) {
345  EXPECT_NONFATAL_FAILURE({ // NOLINT
346  Exactly(-1);
347  }, "The invocation lower bound must be >= 0");
348 }
349 
350 TEST(ExactlyTest, OnZero) {
351  const Cardinality c = Exactly(0);
352  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
353  EXPECT_TRUE(c.IsSaturatedByCallCount(0));
354 
355  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
356  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
357 
358  stringstream ss;
359  c.DescribeTo(&ss);
360  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
361  ss.str());
362 }
363 
364 TEST(ExactlyTest, OnPositiveNumber) {
365  const Cardinality c = Exactly(2);
366  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
367  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
368 
369  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
370  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
371 
372  stringstream ss1;
373  Exactly(1).DescribeTo(&ss1);
374  EXPECT_PRED_FORMAT2(IsSubstring, "called once",
375  ss1.str());
376 
377  stringstream ss2;
378  c.DescribeTo(&ss2);
379  EXPECT_PRED_FORMAT2(IsSubstring, "called twice",
380  ss2.str());
381 
382  stringstream ss3;
383  Exactly(3).DescribeTo(&ss3);
384  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
385  ss3.str());
386 }
387 
388 TEST(ExactlyTest, HasCorrectBounds) {
389  const Cardinality c = Exactly(3);
390  EXPECT_EQ(3, c.ConservativeLowerBound());
391  EXPECT_EQ(3, c.ConservativeUpperBound());
392 }
393 
394 // Tests that a user can make his own cardinality by implementing
395 // CardinalityInterface and calling MakeCardinality().
396 
397 class EvenCardinality : public CardinalityInterface {
398  public:
399  // Returns true iff call_count calls will satisfy this cardinality.
400  virtual bool IsSatisfiedByCallCount(int call_count) const {
401  return (call_count % 2 == 0);
402  }
403 
404  // Returns true iff call_count calls will saturate this cardinality.
405  virtual bool IsSaturatedByCallCount(int /* call_count */) const {
406  return false;
407  }
408 
409  // Describes self to an ostream.
410  virtual void DescribeTo(::std::ostream* ss) const {
411  *ss << "called even number of times";
412  }
413 };
414 
415 TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {
416  const Cardinality c = MakeCardinality(new EvenCardinality);
417 
418  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
419  EXPECT_FALSE(c.IsSatisfiedByCallCount(3));
420 
421  EXPECT_FALSE(c.IsSaturatedByCallCount(10000));
422 
423  stringstream ss;
424  c.DescribeTo(&ss);
425  EXPECT_EQ("called even number of times", ss.str());
426 }
427 
428 } // Unnamed namespace