Changeset View
Changeset View
Standalone View
Standalone View
google/googletest/dist/googlemock/test/gmock-nice-strict_test.cc
- This file was added.
Property | Old Value | New Value |
---|---|---|
svn:eol-style | null | native \ No newline at end of property |
svn:keywords | null | FreeBSD=%H \ No newline at end of property |
svn:mime-type | null | text/plain \ No newline at end of property |
// Copyright 2008, Google Inc. | |||||
// All rights reserved. | |||||
// | |||||
// Redistribution and use in source and binary forms, with or without | |||||
// modification, are permitted provided that the following conditions are | |||||
// met: | |||||
// | |||||
// * Redistributions of source code must retain the above copyright | |||||
// notice, this list of conditions and the following disclaimer. | |||||
// * Redistributions in binary form must reproduce the above | |||||
// copyright notice, this list of conditions and the following disclaimer | |||||
// in the documentation and/or other materials provided with the | |||||
// distribution. | |||||
// * Neither the name of Google Inc. nor the names of its | |||||
// contributors may be used to endorse or promote products derived from | |||||
// this software without specific prior written permission. | |||||
// | |||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||||
#include "gmock/gmock-generated-nice-strict.h" | |||||
#include <string> | |||||
#include <utility> | |||||
#include "gmock/gmock.h" | |||||
#include "gtest/gtest-spi.h" | |||||
#include "gtest/gtest.h" | |||||
// This must not be defined inside the ::testing namespace, or it will | |||||
// clash with ::testing::Mock. | |||||
class Mock { | |||||
public: | |||||
Mock() {} | |||||
MOCK_METHOD0(DoThis, void()); | |||||
private: | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock); | |||||
}; | |||||
namespace testing { | |||||
namespace gmock_nice_strict_test { | |||||
using testing::GMOCK_FLAG(verbose); | |||||
using testing::HasSubstr; | |||||
using testing::NaggyMock; | |||||
using testing::NiceMock; | |||||
using testing::StrictMock; | |||||
#if GTEST_HAS_STREAM_REDIRECTION | |||||
using testing::internal::CaptureStdout; | |||||
using testing::internal::GetCapturedStdout; | |||||
#endif | |||||
// Class without default constructor. | |||||
class NotDefaultConstructible { | |||||
public: | |||||
explicit NotDefaultConstructible(int) {} | |||||
}; | |||||
// Defines some mock classes needed by the tests. | |||||
class Foo { | |||||
public: | |||||
virtual ~Foo() {} | |||||
virtual void DoThis() = 0; | |||||
virtual int DoThat(bool flag) = 0; | |||||
}; | |||||
class MockFoo : public Foo { | |||||
public: | |||||
MockFoo() {} | |||||
void Delete() { delete this; } | |||||
MOCK_METHOD0(DoThis, void()); | |||||
MOCK_METHOD1(DoThat, int(bool flag)); | |||||
MOCK_METHOD0(ReturnNonDefaultConstructible, NotDefaultConstructible()); | |||||
private: | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo); | |||||
}; | |||||
class MockBar { | |||||
public: | |||||
explicit MockBar(const std::string& s) : str_(s) {} | |||||
MockBar(char a1, char a2, std::string a3, std::string a4, int a5, int a6, | |||||
const std::string& a7, const std::string& a8, bool a9, bool a10) { | |||||
str_ = std::string() + a1 + a2 + a3 + a4 + static_cast<char>(a5) + | |||||
static_cast<char>(a6) + a7 + a8 + (a9 ? 'T' : 'F') + (a10 ? 'T' : 'F'); | |||||
} | |||||
virtual ~MockBar() {} | |||||
const std::string& str() const { return str_; } | |||||
MOCK_METHOD0(This, int()); | |||||
MOCK_METHOD2(That, std::string(int, bool)); | |||||
private: | |||||
std::string str_; | |||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar); | |||||
}; | |||||
#if GTEST_GTEST_LANG_CXX11 | |||||
class MockBaz { | |||||
public: | |||||
class MoveOnly { | |||||
MoveOnly() = default; | |||||
MoveOnly(const MoveOnly&) = delete; | |||||
operator=(const MoveOnly&) = delete; | |||||
MoveOnly(MoveOnly&&) = default; | |||||
operator=(MoveOnly&&) = default; | |||||
}; | |||||
MockBaz(MoveOnly) {} | |||||
} | |||||
#endif // GTEST_GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_ | |||||
#if GTEST_HAS_STREAM_REDIRECTION | |||||
// Tests that a raw mock generates warnings for uninteresting calls. | |||||
TEST(RawMockTest, WarningForUninterestingCall) { | |||||
const std::string saved_flag = GMOCK_FLAG(verbose); | |||||
GMOCK_FLAG(verbose) = "warning"; | |||||
MockFoo raw_foo; | |||||
CaptureStdout(); | |||||
raw_foo.DoThis(); | |||||
raw_foo.DoThat(true); | |||||
EXPECT_THAT(GetCapturedStdout(), | |||||
HasSubstr("Uninteresting mock function call")); | |||||
GMOCK_FLAG(verbose) = saved_flag; | |||||
} | |||||
// Tests that a raw mock generates warnings for uninteresting calls | |||||
// that delete the mock object. | |||||
TEST(RawMockTest, WarningForUninterestingCallAfterDeath) { | |||||
const std::string saved_flag = GMOCK_FLAG(verbose); | |||||
GMOCK_FLAG(verbose) = "warning"; | |||||
MockFoo* const raw_foo = new MockFoo; | |||||
ON_CALL(*raw_foo, DoThis()) | |||||
.WillByDefault(Invoke(raw_foo, &MockFoo::Delete)); | |||||
CaptureStdout(); | |||||
raw_foo->DoThis(); | |||||
EXPECT_THAT(GetCapturedStdout(), | |||||
HasSubstr("Uninteresting mock function call")); | |||||
GMOCK_FLAG(verbose) = saved_flag; | |||||
} | |||||
// Tests that a raw mock generates informational logs for | |||||
// uninteresting calls. | |||||
TEST(RawMockTest, InfoForUninterestingCall) { | |||||
MockFoo raw_foo; | |||||
const std::string saved_flag = GMOCK_FLAG(verbose); | |||||
GMOCK_FLAG(verbose) = "info"; | |||||
CaptureStdout(); | |||||
raw_foo.DoThis(); | |||||
EXPECT_THAT(GetCapturedStdout(), | |||||
HasSubstr("Uninteresting mock function call")); | |||||
GMOCK_FLAG(verbose) = saved_flag; | |||||
} | |||||
// Tests that a nice mock generates no warning for uninteresting calls. | |||||
TEST(NiceMockTest, NoWarningForUninterestingCall) { | |||||
NiceMock<MockFoo> nice_foo; | |||||
CaptureStdout(); | |||||
nice_foo.DoThis(); | |||||
nice_foo.DoThat(true); | |||||
EXPECT_EQ("", GetCapturedStdout()); | |||||
} | |||||
// Tests that a nice mock generates no warning for uninteresting calls | |||||
// that delete the mock object. | |||||
TEST(NiceMockTest, NoWarningForUninterestingCallAfterDeath) { | |||||
NiceMock<MockFoo>* const nice_foo = new NiceMock<MockFoo>; | |||||
ON_CALL(*nice_foo, DoThis()) | |||||
.WillByDefault(Invoke(nice_foo, &MockFoo::Delete)); | |||||
CaptureStdout(); | |||||
nice_foo->DoThis(); | |||||
EXPECT_EQ("", GetCapturedStdout()); | |||||
} | |||||
// Tests that a nice mock generates informational logs for | |||||
// uninteresting calls. | |||||
TEST(NiceMockTest, InfoForUninterestingCall) { | |||||
NiceMock<MockFoo> nice_foo; | |||||
const std::string saved_flag = GMOCK_FLAG(verbose); | |||||
GMOCK_FLAG(verbose) = "info"; | |||||
CaptureStdout(); | |||||
nice_foo.DoThis(); | |||||
EXPECT_THAT(GetCapturedStdout(), | |||||
HasSubstr("Uninteresting mock function call")); | |||||
GMOCK_FLAG(verbose) = saved_flag; | |||||
} | |||||
#endif // GTEST_HAS_STREAM_REDIRECTION | |||||
// Tests that a nice mock allows expected calls. | |||||
TEST(NiceMockTest, AllowsExpectedCall) { | |||||
NiceMock<MockFoo> nice_foo; | |||||
EXPECT_CALL(nice_foo, DoThis()); | |||||
nice_foo.DoThis(); | |||||
} | |||||
// Tests that an unexpected call on a nice mock which returns a | |||||
// not-default-constructible type throws an exception and the exception contains | |||||
// the method's name. | |||||
TEST(NiceMockTest, ThrowsExceptionForUnknownReturnTypes) { | |||||
NiceMock<MockFoo> nice_foo; | |||||
#if GTEST_HAS_EXCEPTIONS | |||||
try { | |||||
nice_foo.ReturnNonDefaultConstructible(); | |||||
FAIL(); | |||||
} catch (const std::runtime_error& ex) { | |||||
EXPECT_THAT(ex.what(), HasSubstr("ReturnNonDefaultConstructible")); | |||||
} | |||||
#else | |||||
EXPECT_DEATH_IF_SUPPORTED({ nice_foo.ReturnNonDefaultConstructible(); }, ""); | |||||
#endif | |||||
} | |||||
// Tests that an unexpected call on a nice mock fails. | |||||
TEST(NiceMockTest, UnexpectedCallFails) { | |||||
NiceMock<MockFoo> nice_foo; | |||||
EXPECT_CALL(nice_foo, DoThis()).Times(0); | |||||
EXPECT_NONFATAL_FAILURE(nice_foo.DoThis(), "called more times than expected"); | |||||
} | |||||
// Tests that NiceMock works with a mock class that has a non-default | |||||
// constructor. | |||||
TEST(NiceMockTest, NonDefaultConstructor) { | |||||
NiceMock<MockBar> nice_bar("hi"); | |||||
EXPECT_EQ("hi", nice_bar.str()); | |||||
nice_bar.This(); | |||||
nice_bar.That(5, true); | |||||
} | |||||
// Tests that NiceMock works with a mock class that has a 10-ary | |||||
// non-default constructor. | |||||
TEST(NiceMockTest, NonDefaultConstructor10) { | |||||
NiceMock<MockBar> nice_bar('a', 'b', "c", "d", 'e', 'f', | |||||
"g", "h", true, false); | |||||
EXPECT_EQ("abcdefghTF", nice_bar.str()); | |||||
nice_bar.This(); | |||||
nice_bar.That(5, true); | |||||
} | |||||
TEST(NiceMockTest, AllowLeak) { | |||||
NiceMock<MockFoo>* leaked = new NiceMock<MockFoo>; | |||||
Mock::AllowLeak(leaked); | |||||
EXPECT_CALL(*leaked, DoThis()); | |||||
leaked->DoThis(); | |||||
} | |||||
#if GTEST_GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_ | |||||
TEST(NiceMockTest, MoveOnlyConstructor) { | |||||
NiceMock<MockBaz> nice_baz(MockBaz::MoveOnly()); | |||||
} | |||||
#endif // GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_ | |||||
#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE | |||||
// Tests that NiceMock<Mock> compiles where Mock is a user-defined | |||||
// class (as opposed to ::testing::Mock). We had to work around an | |||||
// MSVC 8.0 bug that caused the symbol Mock used in the definition of | |||||
// NiceMock to be looked up in the wrong context, and this test | |||||
// ensures that our fix works. | |||||
// | |||||
// We have to skip this test on Symbian and Windows Mobile, as it | |||||
// causes the program to crash there, for reasons unclear to us yet. | |||||
TEST(NiceMockTest, AcceptsClassNamedMock) { | |||||
NiceMock< ::Mock> nice; | |||||
EXPECT_CALL(nice, DoThis()); | |||||
nice.DoThis(); | |||||
} | |||||
#endif // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE | |||||
#if GTEST_HAS_STREAM_REDIRECTION | |||||
// Tests that a naggy mock generates warnings for uninteresting calls. | |||||
TEST(NaggyMockTest, WarningForUninterestingCall) { | |||||
const std::string saved_flag = GMOCK_FLAG(verbose); | |||||
GMOCK_FLAG(verbose) = "warning"; | |||||
NaggyMock<MockFoo> naggy_foo; | |||||
CaptureStdout(); | |||||
naggy_foo.DoThis(); | |||||
naggy_foo.DoThat(true); | |||||
EXPECT_THAT(GetCapturedStdout(), | |||||
HasSubstr("Uninteresting mock function call")); | |||||
GMOCK_FLAG(verbose) = saved_flag; | |||||
} | |||||
// Tests that a naggy mock generates a warning for an uninteresting call | |||||
// that deletes the mock object. | |||||
TEST(NaggyMockTest, WarningForUninterestingCallAfterDeath) { | |||||
const std::string saved_flag = GMOCK_FLAG(verbose); | |||||
GMOCK_FLAG(verbose) = "warning"; | |||||
NaggyMock<MockFoo>* const naggy_foo = new NaggyMock<MockFoo>; | |||||
ON_CALL(*naggy_foo, DoThis()) | |||||
.WillByDefault(Invoke(naggy_foo, &MockFoo::Delete)); | |||||
CaptureStdout(); | |||||
naggy_foo->DoThis(); | |||||
EXPECT_THAT(GetCapturedStdout(), | |||||
HasSubstr("Uninteresting mock function call")); | |||||
GMOCK_FLAG(verbose) = saved_flag; | |||||
} | |||||
#endif // GTEST_HAS_STREAM_REDIRECTION | |||||
// Tests that a naggy mock allows expected calls. | |||||
TEST(NaggyMockTest, AllowsExpectedCall) { | |||||
NaggyMock<MockFoo> naggy_foo; | |||||
EXPECT_CALL(naggy_foo, DoThis()); | |||||
naggy_foo.DoThis(); | |||||
} | |||||
// Tests that an unexpected call on a naggy mock fails. | |||||
TEST(NaggyMockTest, UnexpectedCallFails) { | |||||
NaggyMock<MockFoo> naggy_foo; | |||||
EXPECT_CALL(naggy_foo, DoThis()).Times(0); | |||||
EXPECT_NONFATAL_FAILURE(naggy_foo.DoThis(), | |||||
"called more times than expected"); | |||||
} | |||||
// Tests that NaggyMock works with a mock class that has a non-default | |||||
// constructor. | |||||
TEST(NaggyMockTest, NonDefaultConstructor) { | |||||
NaggyMock<MockBar> naggy_bar("hi"); | |||||
EXPECT_EQ("hi", naggy_bar.str()); | |||||
naggy_bar.This(); | |||||
naggy_bar.That(5, true); | |||||
} | |||||
// Tests that NaggyMock works with a mock class that has a 10-ary | |||||
// non-default constructor. | |||||
TEST(NaggyMockTest, NonDefaultConstructor10) { | |||||
NaggyMock<MockBar> naggy_bar('0', '1', "2", "3", '4', '5', | |||||
"6", "7", true, false); | |||||
EXPECT_EQ("01234567TF", naggy_bar.str()); | |||||
naggy_bar.This(); | |||||
naggy_bar.That(5, true); | |||||
} | |||||
TEST(NaggyMockTest, AllowLeak) { | |||||
NaggyMock<MockFoo>* leaked = new NaggyMock<MockFoo>; | |||||
Mock::AllowLeak(leaked); | |||||
EXPECT_CALL(*leaked, DoThis()); | |||||
leaked->DoThis(); | |||||
} | |||||
#if GTEST_GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_ | |||||
TEST(NaggyMockTest, MoveOnlyConstructor) { | |||||
NaggyMock<MockBaz> naggy_baz(MockBaz::MoveOnly()); | |||||
} | |||||
#endif // GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_ | |||||
#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE | |||||
// Tests that NaggyMock<Mock> compiles where Mock is a user-defined | |||||
// class (as opposed to ::testing::Mock). We had to work around an | |||||
// MSVC 8.0 bug that caused the symbol Mock used in the definition of | |||||
// NaggyMock to be looked up in the wrong context, and this test | |||||
// ensures that our fix works. | |||||
// | |||||
// We have to skip this test on Symbian and Windows Mobile, as it | |||||
// causes the program to crash there, for reasons unclear to us yet. | |||||
TEST(NaggyMockTest, AcceptsClassNamedMock) { | |||||
NaggyMock< ::Mock> naggy; | |||||
EXPECT_CALL(naggy, DoThis()); | |||||
naggy.DoThis(); | |||||
} | |||||
#endif // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE | |||||
// Tests that a strict mock allows expected calls. | |||||
TEST(StrictMockTest, AllowsExpectedCall) { | |||||
StrictMock<MockFoo> strict_foo; | |||||
EXPECT_CALL(strict_foo, DoThis()); | |||||
strict_foo.DoThis(); | |||||
} | |||||
// Tests that an unexpected call on a strict mock fails. | |||||
TEST(StrictMockTest, UnexpectedCallFails) { | |||||
StrictMock<MockFoo> strict_foo; | |||||
EXPECT_CALL(strict_foo, DoThis()).Times(0); | |||||
EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(), | |||||
"called more times than expected"); | |||||
} | |||||
// Tests that an uninteresting call on a strict mock fails. | |||||
TEST(StrictMockTest, UninterestingCallFails) { | |||||
StrictMock<MockFoo> strict_foo; | |||||
EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(), | |||||
"Uninteresting mock function call"); | |||||
} | |||||
// Tests that an uninteresting call on a strict mock fails, even if | |||||
// the call deletes the mock object. | |||||
TEST(StrictMockTest, UninterestingCallFailsAfterDeath) { | |||||
StrictMock<MockFoo>* const strict_foo = new StrictMock<MockFoo>; | |||||
ON_CALL(*strict_foo, DoThis()) | |||||
.WillByDefault(Invoke(strict_foo, &MockFoo::Delete)); | |||||
EXPECT_NONFATAL_FAILURE(strict_foo->DoThis(), | |||||
"Uninteresting mock function call"); | |||||
} | |||||
// Tests that StrictMock works with a mock class that has a | |||||
// non-default constructor. | |||||
TEST(StrictMockTest, NonDefaultConstructor) { | |||||
StrictMock<MockBar> strict_bar("hi"); | |||||
EXPECT_EQ("hi", strict_bar.str()); | |||||
EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true), | |||||
"Uninteresting mock function call"); | |||||
} | |||||
// Tests that StrictMock works with a mock class that has a 10-ary | |||||
// non-default constructor. | |||||
TEST(StrictMockTest, NonDefaultConstructor10) { | |||||
StrictMock<MockBar> strict_bar('a', 'b', "c", "d", 'e', 'f', | |||||
"g", "h", true, false); | |||||
EXPECT_EQ("abcdefghTF", strict_bar.str()); | |||||
EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true), | |||||
"Uninteresting mock function call"); | |||||
} | |||||
TEST(StrictMockTest, AllowLeak) { | |||||
StrictMock<MockFoo>* leaked = new StrictMock<MockFoo>; | |||||
Mock::AllowLeak(leaked); | |||||
EXPECT_CALL(*leaked, DoThis()); | |||||
leaked->DoThis(); | |||||
} | |||||
#if GTEST_GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_ | |||||
TEST(StrictMockTest, MoveOnlyConstructor) { | |||||
StrictMock<MockBaz> strict_baz(MockBaz::MoveOnly()); | |||||
} | |||||
#endif // GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_ | |||||
#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE | |||||
// Tests that StrictMock<Mock> compiles where Mock is a user-defined | |||||
// class (as opposed to ::testing::Mock). We had to work around an | |||||
// MSVC 8.0 bug that caused the symbol Mock used in the definition of | |||||
// StrictMock to be looked up in the wrong context, and this test | |||||
// ensures that our fix works. | |||||
// | |||||
// We have to skip this test on Symbian and Windows Mobile, as it | |||||
// causes the program to crash there, for reasons unclear to us yet. | |||||
TEST(StrictMockTest, AcceptsClassNamedMock) { | |||||
StrictMock< ::Mock> strict; | |||||
EXPECT_CALL(strict, DoThis()); | |||||
strict.DoThis(); | |||||
} | |||||
#endif // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE | |||||
} // namespace gmock_nice_strict_test | |||||
} // namespace testing |