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 // Google Mock - a framework for writing C++ mock classes. 31 // 32 // This file tests the built-in cardinalities. 33 34 #include <ostream> 35 36 #include "gmock/gmock.h" 37 #include "gtest/gtest-spi.h" 38 #include "gtest/gtest.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() = default; 56 MOCK_METHOD0(Bar, int()); // NOLINT 57 58 private: 59 MockFoo(const MockFoo&) = delete; 60 MockFoo& operator=(const MockFoo&) = delete; 61 }; 62 63 // Tests that Cardinality objects can be default constructed. 64 TEST(CardinalityTest, IsDefaultConstructable) { Cardinality c; } 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", ss.str()); 123 } 124 125 TEST(AnyNumberTest, HasCorrectBounds) { 126 const Cardinality c = AnyNumber(); 127 EXPECT_EQ(0, c.ConservativeLowerBound()); 128 EXPECT_EQ(INT_MAX, c.ConservativeUpperBound()); 129 } 130 131 // Tests AtLeast(n). 132 133 TEST(AtLeastTest, OnNegativeNumber) { 134 EXPECT_NONFATAL_FAILURE( 135 { // NOLINT 136 AtLeast(-1); 137 }, 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", 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", ss1.str()); 168 169 stringstream ss2; 170 c.DescribeTo(&ss2); 171 EXPECT_PRED_FORMAT2(IsSubstring, "at least twice", ss2.str()); 172 173 stringstream ss3; 174 AtLeast(3).DescribeTo(&ss3); 175 EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times", ss3.str()); 176 } 177 178 TEST(AtLeastTest, HasCorrectBounds) { 179 const Cardinality c = AtLeast(2); 180 EXPECT_EQ(2, c.ConservativeLowerBound()); 181 EXPECT_EQ(INT_MAX, c.ConservativeUpperBound()); 182 } 183 184 // Tests AtMost(n). 185 186 TEST(AtMostTest, OnNegativeNumber) { 187 EXPECT_NONFATAL_FAILURE( 188 { // NOLINT 189 AtMost(-1); 190 }, 191 "The invocation upper bound must be >= 0"); 192 } 193 194 TEST(AtMostTest, OnZero) { 195 const Cardinality c = AtMost(0); 196 EXPECT_TRUE(c.IsSatisfiedByCallCount(0)); 197 EXPECT_TRUE(c.IsSaturatedByCallCount(0)); 198 199 EXPECT_FALSE(c.IsSatisfiedByCallCount(1)); 200 EXPECT_TRUE(c.IsSaturatedByCallCount(1)); 201 202 stringstream ss; 203 c.DescribeTo(&ss); 204 EXPECT_PRED_FORMAT2(IsSubstring, "never called", ss.str()); 205 } 206 207 TEST(AtMostTest, OnPositiveNumber) { 208 const Cardinality c = AtMost(2); 209 EXPECT_TRUE(c.IsSatisfiedByCallCount(0)); 210 EXPECT_FALSE(c.IsSaturatedByCallCount(0)); 211 212 EXPECT_TRUE(c.IsSatisfiedByCallCount(1)); 213 EXPECT_FALSE(c.IsSaturatedByCallCount(1)); 214 215 EXPECT_TRUE(c.IsSatisfiedByCallCount(2)); 216 EXPECT_TRUE(c.IsSaturatedByCallCount(2)); 217 218 stringstream ss1; 219 AtMost(1).DescribeTo(&ss1); 220 EXPECT_PRED_FORMAT2(IsSubstring, "called at most once", ss1.str()); 221 222 stringstream ss2; 223 c.DescribeTo(&ss2); 224 EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice", ss2.str()); 225 226 stringstream ss3; 227 AtMost(3).DescribeTo(&ss3); 228 EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times", ss3.str()); 229 } 230 231 TEST(AtMostTest, HasCorrectBounds) { 232 const Cardinality c = AtMost(2); 233 EXPECT_EQ(0, c.ConservativeLowerBound()); 234 EXPECT_EQ(2, c.ConservativeUpperBound()); 235 } 236 237 // Tests Between(m, n). 238 239 TEST(BetweenTest, OnNegativeStart) { 240 EXPECT_NONFATAL_FAILURE( 241 { // NOLINT 242 Between(-1, 2); 243 }, 244 "The invocation lower bound must be >= 0, but is actually -1"); 245 } 246 247 TEST(BetweenTest, OnNegativeEnd) { 248 EXPECT_NONFATAL_FAILURE( 249 { // NOLINT 250 Between(1, -2); 251 }, 252 "The invocation upper bound must be >= 0, but is actually -2"); 253 } 254 255 TEST(BetweenTest, OnStartBiggerThanEnd) { 256 EXPECT_NONFATAL_FAILURE( 257 { // NOLINT 258 Between(2, 1); 259 }, 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", 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", ss.str()); 293 } 294 295 TEST(BetweenTest, OnSameStartAndEnd) { 296 const Cardinality c = Between(3, 3); 297 298 EXPECT_FALSE(c.IsSatisfiedByCallCount(2)); 299 EXPECT_FALSE(c.IsSaturatedByCallCount(2)); 300 301 EXPECT_TRUE(c.IsSatisfiedByCallCount(3)); 302 EXPECT_TRUE(c.IsSaturatedByCallCount(3)); 303 304 EXPECT_FALSE(c.IsSatisfiedByCallCount(4)); 305 EXPECT_TRUE(c.IsSaturatedByCallCount(4)); 306 307 stringstream ss; 308 c.DescribeTo(&ss); 309 EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times", ss.str()); 310 } 311 312 TEST(BetweenTest, OnDifferentStartAndEnd) { 313 const Cardinality c = Between(3, 5); 314 315 EXPECT_FALSE(c.IsSatisfiedByCallCount(2)); 316 EXPECT_FALSE(c.IsSaturatedByCallCount(2)); 317 318 EXPECT_TRUE(c.IsSatisfiedByCallCount(3)); 319 EXPECT_FALSE(c.IsSaturatedByCallCount(3)); 320 321 EXPECT_TRUE(c.IsSatisfiedByCallCount(5)); 322 EXPECT_TRUE(c.IsSaturatedByCallCount(5)); 323 324 EXPECT_FALSE(c.IsSatisfiedByCallCount(6)); 325 EXPECT_TRUE(c.IsSaturatedByCallCount(6)); 326 327 stringstream ss; 328 c.DescribeTo(&ss); 329 EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times", ss.str()); 330 } 331 332 TEST(BetweenTest, HasCorrectBounds) { 333 const Cardinality c = Between(3, 5); 334 EXPECT_EQ(3, c.ConservativeLowerBound()); 335 EXPECT_EQ(5, c.ConservativeUpperBound()); 336 } 337 338 // Tests Exactly(n). 339 340 TEST(ExactlyTest, OnNegativeNumber) { 341 EXPECT_NONFATAL_FAILURE( 342 { // NOLINT 343 Exactly(-1); 344 }, 345 "The invocation lower bound must be >= 0"); 346 } 347 348 TEST(ExactlyTest, OnZero) { 349 const Cardinality c = Exactly(0); 350 EXPECT_TRUE(c.IsSatisfiedByCallCount(0)); 351 EXPECT_TRUE(c.IsSaturatedByCallCount(0)); 352 353 EXPECT_FALSE(c.IsSatisfiedByCallCount(1)); 354 EXPECT_TRUE(c.IsSaturatedByCallCount(1)); 355 356 stringstream ss; 357 c.DescribeTo(&ss); 358 EXPECT_PRED_FORMAT2(IsSubstring, "never called", ss.str()); 359 } 360 361 TEST(ExactlyTest, OnPositiveNumber) { 362 const Cardinality c = Exactly(2); 363 EXPECT_FALSE(c.IsSatisfiedByCallCount(0)); 364 EXPECT_FALSE(c.IsSaturatedByCallCount(0)); 365 366 EXPECT_TRUE(c.IsSatisfiedByCallCount(2)); 367 EXPECT_TRUE(c.IsSaturatedByCallCount(2)); 368 369 stringstream ss1; 370 Exactly(1).DescribeTo(&ss1); 371 EXPECT_PRED_FORMAT2(IsSubstring, "called once", ss1.str()); 372 373 stringstream ss2; 374 c.DescribeTo(&ss2); 375 EXPECT_PRED_FORMAT2(IsSubstring, "called twice", ss2.str()); 376 377 stringstream ss3; 378 Exactly(3).DescribeTo(&ss3); 379 EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times", ss3.str()); 380 } 381 382 TEST(ExactlyTest, HasCorrectBounds) { 383 const Cardinality c = Exactly(3); 384 EXPECT_EQ(3, c.ConservativeLowerBound()); 385 EXPECT_EQ(3, c.ConservativeUpperBound()); 386 } 387 388 // Tests that a user can make their own cardinality by implementing 389 // CardinalityInterface and calling MakeCardinality(). 390 391 class EvenCardinality : public CardinalityInterface { 392 public: 393 // Returns true if and only if call_count calls will satisfy this 394 // cardinality. 395 bool IsSatisfiedByCallCount(int call_count) const override { 396 return (call_count % 2 == 0); 397 } 398 399 // Returns true if and only if call_count calls will saturate this 400 // cardinality. 401 bool IsSaturatedByCallCount(int /* call_count */) const override { 402 return false; 403 } 404 405 // Describes self to an ostream. 406 void DescribeTo(::std::ostream* ss) const override { 407 *ss << "called even number of times"; 408 } 409 }; 410 411 TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) { 412 const Cardinality c = MakeCardinality(new EvenCardinality); 413 414 EXPECT_TRUE(c.IsSatisfiedByCallCount(2)); 415 EXPECT_FALSE(c.IsSatisfiedByCallCount(3)); 416 417 EXPECT_FALSE(c.IsSaturatedByCallCount(10000)); 418 419 stringstream ss; 420 c.DescribeTo(&ss); 421 EXPECT_EQ("called even number of times", ss.str()); 422 } 423 424 } // Unnamed namespace 425