3party/googletest
0
0
Fork 0
mirror of https://github.com/google/googletest.git synced 2024-12-27 10:11:03 +08:00
Code Issues Projects Releases Wiki Activity

Simplifies the definition of NativeArray. Works around a VC bug in StrictMock & NiceMock.

Browse Source
This commit is contained in:
zhanyong.wan 2009-09-16 17:38:08 +00:00
parent f5e1ce5b92
commit 4bd79e4f25
6 changed files with 117 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
include/gmock/gmock-generated-nice-strict.h
View File

@ -70,42 +70,49 @@ class NiceMock : public MockClass {
// We don't factor out the constructor body to a common method, as
// we have to avoid a possible clash with members of MockClass.
NiceMock() {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
// C++ doesn't (yet) allow inheritance of constructors, so we have
// to define it for each arity.
template <typename A1>
explicit NiceMock(const A1& a1) : MockClass(a1) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2>
NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3>
NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4>
NiceMock(const A1& a1, const A2& a2, const A3& a3,
const A4& a4) : MockClass(a1, a2, a3, a4) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5>
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6>
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
@ -113,7 +120,8 @@ class NiceMock : public MockClass {
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
a6, a7) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
@ -121,7 +129,8 @@ class NiceMock : public MockClass {
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
a2, a3, a4, a5, a6, a7, a8) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
@ -129,7 +138,8 @@ class NiceMock : public MockClass {
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8,
const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
@ -137,11 +147,13 @@ class NiceMock : public MockClass {
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
virtual ~NiceMock() {
Mock::UnregisterCallReaction(internal::implicit_cast<MockClass*>(this));
::testing::Mock::UnregisterCallReaction(
internal::implicit_cast<MockClass*>(this));
}
};
@ -151,40 +163,47 @@ class StrictMock : public MockClass {
// We don't factor out the constructor body to a common method, as
// we have to avoid a possible clash with members of MockClass.
StrictMock() {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1>
explicit StrictMock(const A1& a1) : MockClass(a1) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2>
StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3>
StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4>
StrictMock(const A1& a1, const A2& a2, const A3& a3,
const A4& a4) : MockClass(a1, a2, a3, a4) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5>
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6>
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
@ -192,7 +211,8 @@ class StrictMock : public MockClass {
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
a6, a7) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
@ -200,7 +220,8 @@ class StrictMock : public MockClass {
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
a2, a3, a4, a5, a6, a7, a8) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
@ -208,7 +229,8 @@ class StrictMock : public MockClass {
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8,
const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
@ -216,11 +238,13 @@ class StrictMock : public MockClass {
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
virtual ~StrictMock() {
Mock::UnregisterCallReaction(internal::implicit_cast<MockClass*>(this));
::testing::Mock::UnregisterCallReaction(
internal::implicit_cast<MockClass*>(this));
}
};

24
include/gmock/gmock-generated-nice-strict.h.pump
View File

@ -73,14 +73,16 @@ class NiceMock : public MockClass {
// We don't factor out the constructor body to a common method, as
// we have to avoid a possible clash with members of MockClass.
NiceMock() {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
// C++ doesn't (yet) allow inheritance of constructors, so we have
// to define it for each arity.
template <typename A1>
explicit NiceMock(const A1& a1) : MockClass(a1) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
$range i 2..n
@ -88,13 +90,15 @@ $for i [[
$range j 1..i
template <$for j, [[typename A$j]]>
NiceMock($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
Mock::AllowUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::AllowUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
]]
virtual ~NiceMock() {
Mock::UnregisterCallReaction(internal::implicit_cast<MockClass*>(this));
::testing::Mock::UnregisterCallReaction(
internal::implicit_cast<MockClass*>(this));
}
};
@ -104,25 +108,29 @@ class StrictMock : public MockClass {
// We don't factor out the constructor body to a common method, as
// we have to avoid a possible clash with members of MockClass.
StrictMock() {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
template <typename A1>
explicit StrictMock(const A1& a1) : MockClass(a1) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
$for i [[
$range j 1..i
template <$for j, [[typename A$j]]>
StrictMock($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
Mock::FailUninterestingCalls(internal::implicit_cast<MockClass*>(this));
::testing::Mock::FailUninterestingCalls(
internal::implicit_cast<MockClass*>(this));
}
]]
virtual ~StrictMock() {
Mock::UnregisterCallReaction(internal::implicit_cast<MockClass*>(this));
::testing::Mock::UnregisterCallReaction(
internal::implicit_cast<MockClass*>(this));
}
};

28
include/gmock/internal/gmock-internal-utils.h
View File

@ -581,21 +581,9 @@ class NativeArray {
typedef Element value_type;
typedef const Element* const_iterator;
// Constructs from a native array passed by reference.
template <size_t N>
NativeArray(const Element (&array)[N], RelationToSource relation) {
Init(array, N, relation);
}
// Constructs from a native array passed by a pointer and a size.
// For generality we don't artificially restrict the types of the
// pointer and the size.
template <typename Pointer, typename Size>
NativeArray(const ::std::tr1::tuple<Pointer, Size>& array,
RelationToSource relation) {
Init(internal::GetRawPointer(::std::tr1::get<0>(array)),
::std::tr1::get<1>(array),
relation);
// Constructs from a native array.
NativeArray(const Element* array, size_t count, RelationToSource relation) {
Init(array, count, relation);
}
// Copy constructor.
@ -691,10 +679,10 @@ class StlContainerView<Element[N]> {
static const_reference ConstReference(const Element (&array)[N]) {
// Ensures that Element is not a const type.
testing::StaticAssertTypeEq<Element, RawElement>();
return type(array, kReference);
return type(array, N, kReference);
}
static type Copy(const Element (&array)[N]) {
return type(array, kCopy);
return type(array, N, kCopy);
}
};
@ -710,10 +698,12 @@ class StlContainerView< ::std::tr1::tuple<ElementPointer, Size> > {
static const_reference ConstReference(
const ::std::tr1::tuple<ElementPointer, Size>& array) {
return type(array, kReference);
using ::std::tr1::get;
return type(get<0>(array), get<1>(array), kReference);
}
static type Copy(const ::std::tr1::tuple<ElementPointer, Size>& array) {
return type(array, kCopy);
using ::std::tr1::get;
return type(get<0>(array), get<1>(array), kCopy);
}
};

37
test/gmock-internal-utils_test.cc
View File

@ -815,34 +815,19 @@ TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
// Tests NativeArray.
TEST(NativeArrayTest, ConstructorFromArrayReferenceWorks) {
TEST(NativeArrayTest, ConstructorFromArrayWorks) {
const int a[3] = { 0, 1, 2 };
NativeArray<int> na(a, kReference);
NativeArray<int> na(a, 3, kReference);
EXPECT_EQ(3, na.size());
EXPECT_EQ(a, na.begin());
}
TEST(NativeArrayTest, ConstructorFromTupleWorks) {
int a[3] = { 0, 1, 2 };
int* const p = a;
// Tests with a plain pointer.
NativeArray<int> na(make_tuple(p, 3U), kReference);
EXPECT_EQ(a, na.begin());
const linked_ptr<char> b(new char);
*b = 'a';
// Tests with a smart pointer.
NativeArray<char> nb(make_tuple(b, 1), kCopy);
EXPECT_NE(b.get(), nb.begin());
EXPECT_EQ('a', nb.begin()[0]);
}
TEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) {
typedef int Array[2];
Array* a = new Array[1];
(*a)[0] = 0;
(*a)[1] = 1;
NativeArray<int> na(*a, kCopy);
NativeArray<int> na(*a, 2, kCopy);
EXPECT_NE(*a, na.begin());
delete[] a;
EXPECT_EQ(0, na.begin()[0]);
@ -861,8 +846,8 @@ TEST(NativeArrayTest, TypeMembersAreCorrect) {
}
TEST(NativeArrayTest, MethodsWork) {
const int a[] = { 0, 1, 2 };
NativeArray<int> na(a, kCopy);
const int a[3] = { 0, 1, 2 };
NativeArray<int> na(a, 3, kCopy);
ASSERT_EQ(3, na.size());
EXPECT_EQ(3, na.end() - na.begin());
@ -877,18 +862,18 @@ TEST(NativeArrayTest, MethodsWork) {
EXPECT_THAT(na, Eq(na));
NativeArray<int> na2(a, kReference);
NativeArray<int> na2(a, 3, kReference);
EXPECT_THAT(na, Eq(na2));
const int b1[] = { 0, 1, 1 };
const int b2[] = { 0, 1, 2, 3 };
EXPECT_THAT(na, Not(Eq(NativeArray<int>(b1, kReference))));
EXPECT_THAT(na, Not(Eq(NativeArray<int>(b2, kCopy))));
const int b1[3] = { 0, 1, 1 };
const int b2[4] = { 0, 1, 2, 3 };
EXPECT_THAT(na, Not(Eq(NativeArray<int>(b1, 3, kReference))));
EXPECT_THAT(na, Not(Eq(NativeArray<int>(b2, 4, kCopy))));
}
TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
const char a[2][3] = { "hi", "lo" };
NativeArray<char[3]> na(a, kReference);
NativeArray<char[3]> na(a, 2, kReference);
ASSERT_EQ(2, na.size());
EXPECT_EQ(a, na.begin());
}

29
test/gmock-nice-strict_test.cc
View File

@ -36,6 +36,13 @@
#include <gtest/gtest.h>
#include <gtest/gtest-spi.h>
// This must not be defined inside the ::testing namespace, or it will
// clash with ::testing::Mock.
class Mock {
public:
MOCK_METHOD0(DoThis, void());
};
namespace testing {
namespace gmock_nice_strict_test {
@ -166,6 +173,17 @@ TEST(NiceMockTest, NonDefaultConstructor10) {
nice_bar.That(5, true);
}
// Tests that NiceMock<Mock> compiles where Mock is a user-defined
// class (as opposed to ::testing::Mock). We had to workaround 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.
TEST(NiceMockTest, AcceptsClassNamedMock) {
NiceMock< ::Mock> nice;
EXPECT_CALL(nice, DoThis());
nice.DoThis();
}
// Tests that a strict mock allows expected calls.
TEST(StrictMockTest, AllowsExpectedCall) {
StrictMock<MockFoo> strict_foo;
@ -224,5 +242,16 @@ TEST(StrictMockTest, NonDefaultConstructor10) {
"Uninteresting mock function call");
}
// Tests that StrictMock<Mock> compiles where Mock is a user-defined
// class (as opposed to ::testing::Mock). We had to workaround 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.
TEST(StrictMockTest, AcceptsClassNamedMock) {
StrictMock< ::Mock> nice;
EXPECT_CALL(nice, DoThis());
nice.DoThis();
}
} // namespace gmock_nice_strict_test
} // namespace testing

8
test/gmock-printers_test.cc
View File

@ -790,14 +790,14 @@ TEST(PrintStlContainerTest, NestedContainer) {
}
TEST(PrintStlContainerTest, OneDimensionalNativeArray) {
const int a[] = { 1, 2, 3 };
NativeArray<int> b(a, kReference);
const int a[3] = { 1, 2, 3 };
NativeArray<int> b(a, 3, kReference);
EXPECT_EQ("{ 1, 2, 3 }", Print(b));
}
TEST(PrintStlContainerTest, TwoDimensionalNativeArray) {
const int a[][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
NativeArray<int[3]> b(a, kReference);
const int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
NativeArray<int[3]> b(a, 2, kReference);
EXPECT_EQ("{ { 1, 2, 3 }, { 4, 5, 6 } }", Print(b));
}