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// Author: wan@google.com (Zhanyong Wan) 31 32#include "gmock/gmock-generated-nice-strict.h" 33 34#include <string> 35#include "gmock/gmock.h" 36#include "gtest/gtest.h" 37#include "gtest/gtest-spi.h" 38 39// This must not be defined inside the ::testing namespace, or it will 40// clash with ::testing::Mock. 41class Mock { 42 public: 43 Mock() {} 44 45 MOCK_METHOD0(DoThis, void()); 46 47 private: 48 GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock); 49}; 50 51namespace testing { 52namespace gmock_nice_strict_test { 53 54using testing::internal::string; 55using testing::GMOCK_FLAG(verbose); 56using testing::HasSubstr; 57using testing::NiceMock; 58using testing::StrictMock; 59 60#if GTEST_HAS_STREAM_REDIRECTION 61using testing::internal::CaptureStdout; 62using testing::internal::GetCapturedStdout; 63#endif 64 65// Defines some mock classes needed by the tests. 66 67class Foo { 68 public: 69 virtual ~Foo() {} 70 71 virtual void DoThis() = 0; 72 virtual int DoThat(bool flag) = 0; 73}; 74 75class MockFoo : public Foo { 76 public: 77 MockFoo() {} 78 void Delete() { delete this; } 79 80 MOCK_METHOD0(DoThis, void()); 81 MOCK_METHOD1(DoThat, int(bool flag)); 82 83 private: 84 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo); 85}; 86 87class MockBar { 88 public: 89 explicit MockBar(const string& s) : str_(s) {} 90 91 MockBar(char a1, char a2, string a3, string a4, int a5, int a6, 92 const string& a7, const string& a8, bool a9, bool a10) { 93 str_ = string() + a1 + a2 + a3 + a4 + static_cast<char>(a5) + 94 static_cast<char>(a6) + a7 + a8 + (a9 ? 'T' : 'F') + (a10 ? 'T' : 'F'); 95 } 96 97 virtual ~MockBar() {} 98 99 const string& str() const { return str_; } 100 101 MOCK_METHOD0(This, int()); 102 MOCK_METHOD2(That, string(int, bool)); 103 104 private: 105 string str_; 106 107 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar); 108}; 109 110#if GTEST_HAS_STREAM_REDIRECTION 111 112// Tests that a nice mock generates no warning for uninteresting calls. 113TEST(NiceMockTest, NoWarningForUninterestingCall) { 114 NiceMock<MockFoo> nice_foo; 115 116 CaptureStdout(); 117 nice_foo.DoThis(); 118 nice_foo.DoThat(true); 119 EXPECT_STREQ("", GetCapturedStdout().c_str()); 120} 121 122// Tests that a nice mock generates no warning for uninteresting calls 123// that delete the mock object. 124TEST(NiceMockTest, NoWarningForUninterestingCallAfterDeath) { 125 NiceMock<MockFoo>* const nice_foo = new NiceMock<MockFoo>; 126 127 ON_CALL(*nice_foo, DoThis()) 128 .WillByDefault(Invoke(nice_foo, &MockFoo::Delete)); 129 130 CaptureStdout(); 131 nice_foo->DoThis(); 132 EXPECT_STREQ("", GetCapturedStdout().c_str()); 133} 134 135// Tests that a nice mock generates informational logs for 136// uninteresting calls. 137TEST(NiceMockTest, InfoForUninterestingCall) { 138 NiceMock<MockFoo> nice_foo; 139 140 const string saved_flag = GMOCK_FLAG(verbose); 141 GMOCK_FLAG(verbose) = "info"; 142 CaptureStdout(); 143 nice_foo.DoThis(); 144 EXPECT_THAT(GetCapturedStdout(), 145 HasSubstr("Uninteresting mock function call")); 146 147 CaptureStdout(); 148 nice_foo.DoThat(true); 149 EXPECT_THAT(GetCapturedStdout(), 150 HasSubstr("Uninteresting mock function call")); 151 GMOCK_FLAG(verbose) = saved_flag; 152} 153 154#endif // GTEST_HAS_STREAM_REDIRECTION 155 156// Tests that a nice mock allows expected calls. 157TEST(NiceMockTest, AllowsExpectedCall) { 158 NiceMock<MockFoo> nice_foo; 159 160 EXPECT_CALL(nice_foo, DoThis()); 161 nice_foo.DoThis(); 162} 163 164// Tests that an unexpected call on a nice mock fails. 165TEST(NiceMockTest, UnexpectedCallFails) { 166 NiceMock<MockFoo> nice_foo; 167 168 EXPECT_CALL(nice_foo, DoThis()).Times(0); 169 EXPECT_NONFATAL_FAILURE(nice_foo.DoThis(), "called more times than expected"); 170} 171 172// Tests that NiceMock works with a mock class that has a non-default 173// constructor. 174TEST(NiceMockTest, NonDefaultConstructor) { 175 NiceMock<MockBar> nice_bar("hi"); 176 EXPECT_EQ("hi", nice_bar.str()); 177 178 nice_bar.This(); 179 nice_bar.That(5, true); 180} 181 182// Tests that NiceMock works with a mock class that has a 10-ary 183// non-default constructor. 184TEST(NiceMockTest, NonDefaultConstructor10) { 185 NiceMock<MockBar> nice_bar('a', 'b', "c", "d", 'e', 'f', 186 "g", "h", true, false); 187 EXPECT_EQ("abcdefghTF", nice_bar.str()); 188 189 nice_bar.This(); 190 nice_bar.That(5, true); 191} 192 193#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE 194// Tests that NiceMock<Mock> compiles where Mock is a user-defined 195// class (as opposed to ::testing::Mock). We had to workaround an 196// MSVC 8.0 bug that caused the symbol Mock used in the definition of 197// NiceMock to be looked up in the wrong context, and this test 198// ensures that our fix works. 199// 200// We have to skip this test on Symbian and Windows Mobile, as it 201// causes the program to crash there, for reasons unclear to us yet. 202TEST(NiceMockTest, AcceptsClassNamedMock) { 203 NiceMock< ::Mock> nice; 204 EXPECT_CALL(nice, DoThis()); 205 nice.DoThis(); 206} 207#endif // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE 208 209// Tests that a strict mock allows expected calls. 210TEST(StrictMockTest, AllowsExpectedCall) { 211 StrictMock<MockFoo> strict_foo; 212 213 EXPECT_CALL(strict_foo, DoThis()); 214 strict_foo.DoThis(); 215} 216 217// Tests that an unexpected call on a strict mock fails. 218TEST(StrictMockTest, UnexpectedCallFails) { 219 StrictMock<MockFoo> strict_foo; 220 221 EXPECT_CALL(strict_foo, DoThis()).Times(0); 222 EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(), 223 "called more times than expected"); 224} 225 226// Tests that an uninteresting call on a strict mock fails. 227TEST(StrictMockTest, UninterestingCallFails) { 228 StrictMock<MockFoo> strict_foo; 229 230 EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(), 231 "Uninteresting mock function call"); 232} 233 234// Tests that an uninteresting call on a strict mock fails, even if 235// the call deletes the mock object. 236TEST(StrictMockTest, UninterestingCallFailsAfterDeath) { 237 StrictMock<MockFoo>* const strict_foo = new StrictMock<MockFoo>; 238 239 ON_CALL(*strict_foo, DoThis()) 240 .WillByDefault(Invoke(strict_foo, &MockFoo::Delete)); 241 242 EXPECT_NONFATAL_FAILURE(strict_foo->DoThis(), 243 "Uninteresting mock function call"); 244} 245 246// Tests that StrictMock works with a mock class that has a 247// non-default constructor. 248TEST(StrictMockTest, NonDefaultConstructor) { 249 StrictMock<MockBar> strict_bar("hi"); 250 EXPECT_EQ("hi", strict_bar.str()); 251 252 EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true), 253 "Uninteresting mock function call"); 254} 255 256// Tests that StrictMock works with a mock class that has a 10-ary 257// non-default constructor. 258TEST(StrictMockTest, NonDefaultConstructor10) { 259 StrictMock<MockBar> strict_bar('a', 'b', "c", "d", 'e', 'f', 260 "g", "h", true, false); 261 EXPECT_EQ("abcdefghTF", strict_bar.str()); 262 263 EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true), 264 "Uninteresting mock function call"); 265} 266 267#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE 268// Tests that StrictMock<Mock> compiles where Mock is a user-defined 269// class (as opposed to ::testing::Mock). We had to workaround an 270// MSVC 8.0 bug that caused the symbol Mock used in the definition of 271// StrictMock to be looked up in the wrong context, and this test 272// ensures that our fix works. 273// 274// We have to skip this test on Symbian and Windows Mobile, as it 275// causes the program to crash there, for reasons unclear to us yet. 276TEST(StrictMockTest, AcceptsClassNamedMock) { 277 StrictMock< ::Mock> strict; 278 EXPECT_CALL(strict, DoThis()); 279 strict.DoThis(); 280} 281#endif // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE 282 283} // namespace gmock_nice_strict_test 284} // namespace testing 285