ut/gtest/googlemock/test/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;
  47 using testing::Cardinality;
  48 using testing::CardinalityInterface;
  49 using testing::Exactly;
  50 using testing::IsSubstring;
  51 using testing::MakeCardinality;
  52
  53 class MockFoo {
  54  public:
  55   MockFoo() {}
  56   MOCK_METHOD0(Bar, int());  // NOLINT
  57
  58  private:
  59   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
  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