1// Copyright 2008, 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// Tests Google Mock's output in various scenarios. This ensures that 32// Google Mock's messages are readable and useful. 33 34#include "gmock/gmock.h" 35 36#include <stdio.h> 37#include <string> 38 39#include "gtest/gtest.h" 40 41// Silence C4100 (unreferenced formal parameter) 42#ifdef _MSC_VER 43# pragma warning(push) 44# pragma warning(disable:4100) 45#endif 46 47using testing::_; 48using testing::AnyNumber; 49using testing::Ge; 50using testing::InSequence; 51using testing::NaggyMock; 52using testing::Ref; 53using testing::Return; 54using testing::Sequence; 55using testing::Value; 56 57class MockFoo { 58 public: 59 MockFoo() {} 60 61 MOCK_METHOD3(Bar, char(const std::string& s, int i, double x)); 62 MOCK_METHOD2(Bar2, bool(int x, int y)); 63 MOCK_METHOD2(Bar3, void(int x, int y)); 64 65 private: 66 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo); 67}; 68 69class GMockOutputTest : public testing::Test { 70 protected: 71 NaggyMock<MockFoo> foo_; 72}; 73 74TEST_F(GMockOutputTest, ExpectedCall) { 75 testing::GMOCK_FLAG(verbose) = "info"; 76 77 EXPECT_CALL(foo_, Bar2(0, _)); 78 foo_.Bar2(0, 0); // Expected call 79 80 testing::GMOCK_FLAG(verbose) = "warning"; 81} 82 83TEST_F(GMockOutputTest, ExpectedCallToVoidFunction) { 84 testing::GMOCK_FLAG(verbose) = "info"; 85 86 EXPECT_CALL(foo_, Bar3(0, _)); 87 foo_.Bar3(0, 0); // Expected call 88 89 testing::GMOCK_FLAG(verbose) = "warning"; 90} 91 92TEST_F(GMockOutputTest, ExplicitActionsRunOut) { 93 EXPECT_CALL(foo_, Bar2(_, _)) 94 .Times(2) 95 .WillOnce(Return(false)); 96 foo_.Bar2(2, 2); 97 foo_.Bar2(1, 1); // Explicit actions in EXPECT_CALL run out. 98} 99 100TEST_F(GMockOutputTest, UnexpectedCall) { 101 EXPECT_CALL(foo_, Bar2(0, _)); 102 103 foo_.Bar2(1, 0); // Unexpected call 104 foo_.Bar2(0, 0); // Expected call 105} 106 107TEST_F(GMockOutputTest, UnexpectedCallToVoidFunction) { 108 EXPECT_CALL(foo_, Bar3(0, _)); 109 110 foo_.Bar3(1, 0); // Unexpected call 111 foo_.Bar3(0, 0); // Expected call 112} 113 114TEST_F(GMockOutputTest, ExcessiveCall) { 115 EXPECT_CALL(foo_, Bar2(0, _)); 116 117 foo_.Bar2(0, 0); // Expected call 118 foo_.Bar2(0, 1); // Excessive call 119} 120 121TEST_F(GMockOutputTest, ExcessiveCallToVoidFunction) { 122 EXPECT_CALL(foo_, Bar3(0, _)); 123 124 foo_.Bar3(0, 0); // Expected call 125 foo_.Bar3(0, 1); // Excessive call 126} 127 128TEST_F(GMockOutputTest, UninterestingCall) { 129 foo_.Bar2(0, 1); // Uninteresting call 130} 131 132TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) { 133 foo_.Bar3(0, 1); // Uninteresting call 134} 135 136TEST_F(GMockOutputTest, RetiredExpectation) { 137 EXPECT_CALL(foo_, Bar2(_, _)) 138 .RetiresOnSaturation(); 139 EXPECT_CALL(foo_, Bar2(0, 0)); 140 141 foo_.Bar2(1, 1); 142 foo_.Bar2(1, 1); // Matches a retired expectation 143 foo_.Bar2(0, 0); 144} 145 146TEST_F(GMockOutputTest, UnsatisfiedPrerequisite) { 147 { 148 InSequence s; 149 EXPECT_CALL(foo_, Bar(_, 0, _)); 150 EXPECT_CALL(foo_, Bar2(0, 0)); 151 EXPECT_CALL(foo_, Bar2(1, _)); 152 } 153 154 foo_.Bar2(1, 0); // Has one immediate unsatisfied pre-requisite 155 foo_.Bar("Hi", 0, 0); 156 foo_.Bar2(0, 0); 157 foo_.Bar2(1, 0); 158} 159 160TEST_F(GMockOutputTest, UnsatisfiedPrerequisites) { 161 Sequence s1, s2; 162 163 EXPECT_CALL(foo_, Bar(_, 0, _)) 164 .InSequence(s1); 165 EXPECT_CALL(foo_, Bar2(0, 0)) 166 .InSequence(s2); 167 EXPECT_CALL(foo_, Bar2(1, _)) 168 .InSequence(s1, s2); 169 170 foo_.Bar2(1, 0); // Has two immediate unsatisfied pre-requisites 171 foo_.Bar("Hi", 0, 0); 172 foo_.Bar2(0, 0); 173 foo_.Bar2(1, 0); 174} 175 176TEST_F(GMockOutputTest, UnsatisfiedWith) { 177 EXPECT_CALL(foo_, Bar2(_, _)).With(Ge()); 178} 179 180TEST_F(GMockOutputTest, UnsatisfiedExpectation) { 181 EXPECT_CALL(foo_, Bar(_, _, _)); 182 EXPECT_CALL(foo_, Bar2(0, _)) 183 .Times(2); 184 185 foo_.Bar2(0, 1); 186} 187 188TEST_F(GMockOutputTest, MismatchArguments) { 189 const std::string s = "Hi"; 190 EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0))); 191 192 foo_.Bar("Ho", 0, -0.1); // Mismatch arguments 193 foo_.Bar(s, 0, 0); 194} 195 196TEST_F(GMockOutputTest, MismatchWith) { 197 EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1))) 198 .With(Ge()); 199 200 foo_.Bar2(2, 3); // Mismatch With() 201 foo_.Bar2(2, 1); 202} 203 204TEST_F(GMockOutputTest, MismatchArgumentsAndWith) { 205 EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1))) 206 .With(Ge()); 207 208 foo_.Bar2(1, 3); // Mismatch arguments and mismatch With() 209 foo_.Bar2(2, 1); 210} 211 212TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) { 213 ON_CALL(foo_, Bar2(_, _)) 214 .WillByDefault(Return(true)); // Default action #1 215 ON_CALL(foo_, Bar2(1, _)) 216 .WillByDefault(Return(false)); // Default action #2 217 218 EXPECT_CALL(foo_, Bar2(2, 2)); 219 foo_.Bar2(1, 0); // Unexpected call, takes default action #2. 220 foo_.Bar2(0, 0); // Unexpected call, takes default action #1. 221 foo_.Bar2(2, 2); // Expected call. 222} 223 224TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) { 225 ON_CALL(foo_, Bar2(_, _)) 226 .WillByDefault(Return(true)); // Default action #1 227 ON_CALL(foo_, Bar2(1, _)) 228 .WillByDefault(Return(false)); // Default action #2 229 230 EXPECT_CALL(foo_, Bar2(2, 2)); 231 EXPECT_CALL(foo_, Bar2(1, 1)); 232 233 foo_.Bar2(2, 2); // Expected call. 234 foo_.Bar2(2, 2); // Excessive call, takes default action #1. 235 foo_.Bar2(1, 1); // Expected call. 236 foo_.Bar2(1, 1); // Excessive call, takes default action #2. 237} 238 239TEST_F(GMockOutputTest, UninterestingCallWithDefaultAction) { 240 ON_CALL(foo_, Bar2(_, _)) 241 .WillByDefault(Return(true)); // Default action #1 242 ON_CALL(foo_, Bar2(1, _)) 243 .WillByDefault(Return(false)); // Default action #2 244 245 foo_.Bar2(2, 2); // Uninteresting call, takes default action #1. 246 foo_.Bar2(1, 1); // Uninteresting call, takes default action #2. 247} 248 249TEST_F(GMockOutputTest, ExplicitActionsRunOutWithDefaultAction) { 250 ON_CALL(foo_, Bar2(_, _)) 251 .WillByDefault(Return(true)); // Default action #1 252 253 EXPECT_CALL(foo_, Bar2(_, _)) 254 .Times(2) 255 .WillOnce(Return(false)); 256 foo_.Bar2(2, 2); 257 foo_.Bar2(1, 1); // Explicit actions in EXPECT_CALL run out. 258} 259 260TEST_F(GMockOutputTest, CatchesLeakedMocks) { 261 MockFoo* foo1 = new MockFoo; 262 MockFoo* foo2 = new MockFoo; 263 264 // Invokes ON_CALL on foo1. 265 ON_CALL(*foo1, Bar(_, _, _)).WillByDefault(Return('a')); 266 267 // Invokes EXPECT_CALL on foo2. 268 EXPECT_CALL(*foo2, Bar2(_, _)); 269 EXPECT_CALL(*foo2, Bar2(1, _)); 270 EXPECT_CALL(*foo2, Bar3(_, _)).Times(AnyNumber()); 271 foo2->Bar2(2, 1); 272 foo2->Bar2(1, 1); 273 274 // Both foo1 and foo2 are deliberately leaked. 275} 276 277MATCHER_P2(IsPair, first, second, "") { 278 return Value(arg.first, first) && Value(arg.second, second); 279} 280 281TEST_F(GMockOutputTest, PrintsMatcher) { 282 const testing::Matcher<int> m1 = Ge(48); 283 EXPECT_THAT((std::pair<int, bool>(42, true)), IsPair(m1, true)); 284} 285 286void TestCatchesLeakedMocksInAdHocTests() { 287 MockFoo* foo = new MockFoo; 288 289 // Invokes EXPECT_CALL on foo. 290 EXPECT_CALL(*foo, Bar2(_, _)); 291 foo->Bar2(2, 1); 292 293 // foo is deliberately leaked. 294} 295 296int main(int argc, char **argv) { 297 testing::InitGoogleMock(&argc, argv); 298 // Ensures that the tests pass no matter what value of 299 // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies. 300 testing::GMOCK_FLAG(catch_leaked_mocks) = true; 301 testing::GMOCK_FLAG(verbose) = "warning"; 302 303 TestCatchesLeakedMocksInAdHocTests(); 304 return RUN_ALL_TESTS(); 305} 306 307#ifdef _MSC_VER 308# pragma warning(pop) 309#endif 310