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 47 using testing::_; 48 using testing::AnyNumber; 49 using testing::Ge; 50 using testing::InSequence; 51 using testing::NaggyMock; 52 using testing::Ref; 53 using testing::Return; 54 using testing::Sequence; 55 using testing::Value; 56 57 class 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 69 class GMockOutputTest : public testing::Test { 70 protected: 71 NaggyMock<MockFoo> foo_; 72 }; 73 74 TEST_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 83 TEST_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 92 TEST_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 100 TEST_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 107 TEST_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 114 TEST_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 121 TEST_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 128 TEST_F(GMockOutputTest, UninterestingCall) { 129 foo_.Bar2(0, 1); // Uninteresting call 130 } 131 132 TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) { 133 foo_.Bar3(0, 1); // Uninteresting call 134 } 135 136 TEST_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 146 TEST_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 160 TEST_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 176 TEST_F(GMockOutputTest, UnsatisfiedWith) { 177 EXPECT_CALL(foo_, Bar2(_, _)).With(Ge()); 178 } 179 180 TEST_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 188 TEST_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 196 TEST_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 204 TEST_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 212 TEST_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 224 TEST_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 239 TEST_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 249 TEST_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 260 TEST_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 277 MATCHER_P2(IsPair, first, second, "") { 278 return Value(arg.first, first) && Value(arg.second, second); 279 } 280 281 TEST_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 286 void 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 296 int 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