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 39 namespace { 40 41 using std::stringstream; 42 using testing::AnyNumber; 43 using testing::AtLeast; 44 using testing::AtMost; 45 using testing::Between; 46 using testing::Cardinality; 47 using testing::CardinalityInterface; 48 using testing::Exactly; 49 using testing::IsSubstring; 50 using testing::MakeCardinality; 51 52 class 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. 62 TEST(CardinalityTest, IsDefaultConstructable) { 63 Cardinality c; 64 } 65 66 // Tests that Cardinality objects are copyable. 67 TEST(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 81 TEST(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. 90 TEST(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() 109 TEST(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 126 TEST(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 134 TEST(AtLeastTest, OnNegativeNumber) { 135 EXPECT_NONFATAL_FAILURE({ // NOLINT 136 AtLeast(-1); 137 }, "The invocation lower bound must be >= 0"); 138 } 139 140 TEST(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 154 TEST(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 181 TEST(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 189 TEST(AtMostTest, OnNegativeNumber) { 190 EXPECT_NONFATAL_FAILURE({ // NOLINT 191 AtMost(-1); 192 }, "The invocation upper bound must be >= 0"); 193 } 194 195 TEST(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 209 TEST(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 236 TEST(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 244 TEST(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 250 TEST(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 256 TEST(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 263 TEST(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 278 TEST(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 296 TEST(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 314 TEST(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 335 TEST(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 343 TEST(ExactlyTest, OnNegativeNumber) { 344 EXPECT_NONFATAL_FAILURE({ // NOLINT 345 Exactly(-1); 346 }, "The invocation lower bound must be >= 0"); 347 } 348 349 TEST(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 363 TEST(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 387 TEST(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 396 class 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 414 TEST(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