diff --git a/include/gmock/gmock-generated-nice-strict.h b/include/gmock/gmock-generated-nice-strict.h index f961d796..fc9a81b5 100644 --- a/include/gmock/gmock-generated-nice-strict.h +++ b/include/gmock/gmock-generated-nice-strict.h @@ -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(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } // C++ doesn't (yet) allow inheritance of constructors, so we have // to define it for each arity. template explicit NiceMock(const A1& a1) : MockClass(a1) { - Mock::AllowUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } template NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { - Mock::AllowUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } template NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { - Mock::AllowUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } template NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4) : MockClass(a1, a2, a3, a4) { - Mock::AllowUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } template 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(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } template 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(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } template (this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } template (this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } template (this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } template (this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } virtual ~NiceMock() { - Mock::UnregisterCallReaction(internal::implicit_cast(this)); + ::testing::Mock::UnregisterCallReaction( + internal::implicit_cast(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(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template explicit StrictMock(const A1& a1) : MockClass(a1) { - Mock::FailUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) { - Mock::FailUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) { - Mock::FailUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4) : MockClass(a1, a2, a3, a4) { - Mock::FailUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template 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(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template 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(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template (this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template (this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template (this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template (this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } virtual ~StrictMock() { - Mock::UnregisterCallReaction(internal::implicit_cast(this)); + ::testing::Mock::UnregisterCallReaction( + internal::implicit_cast(this)); } }; diff --git a/include/gmock/gmock-generated-nice-strict.h.pump b/include/gmock/gmock-generated-nice-strict.h.pump index 580e79f0..b265c2e4 100644 --- a/include/gmock/gmock-generated-nice-strict.h.pump +++ b/include/gmock/gmock-generated-nice-strict.h.pump @@ -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(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } // C++ doesn't (yet) allow inheritance of constructors, so we have // to define it for each arity. template explicit NiceMock(const A1& a1) : MockClass(a1) { - Mock::AllowUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(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(this)); + ::testing::Mock::AllowUninterestingCalls( + internal::implicit_cast(this)); } ]] virtual ~NiceMock() { - Mock::UnregisterCallReaction(internal::implicit_cast(this)); + ::testing::Mock::UnregisterCallReaction( + internal::implicit_cast(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(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } template explicit StrictMock(const A1& a1) : MockClass(a1) { - Mock::FailUninterestingCalls(internal::implicit_cast(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(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(this)); + ::testing::Mock::FailUninterestingCalls( + internal::implicit_cast(this)); } ]] virtual ~StrictMock() { - Mock::UnregisterCallReaction(internal::implicit_cast(this)); + ::testing::Mock::UnregisterCallReaction( + internal::implicit_cast(this)); } }; diff --git a/include/gmock/internal/gmock-internal-utils.h b/include/gmock/internal/gmock-internal-utils.h index ee6aa1e2..39e70b3f 100644 --- a/include/gmock/internal/gmock-internal-utils.h +++ b/include/gmock/internal/gmock-internal-utils.h @@ -581,21 +581,9 @@ class NativeArray { typedef Element value_type; typedef const Element* const_iterator; - // Constructs from a native array passed by reference. - template - 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 - NativeArray(const ::std::tr1::tuple& 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 { static const_reference ConstReference(const Element (&array)[N]) { // Ensures that Element is not a const type. testing::StaticAssertTypeEq(); - 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 > { static const_reference ConstReference( const ::std::tr1::tuple& 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& array) { - return type(array, kCopy); + using ::std::tr1::get; + return type(get<0>(array), get<1>(array), kCopy); } }; diff --git a/test/gmock-internal-utils_test.cc b/test/gmock-internal-utils_test.cc index 4867e119..d3a16ad3 100644 --- a/test/gmock-internal-utils_test.cc +++ b/test/gmock-internal-utils_test.cc @@ -815,34 +815,19 @@ TEST(CopyArrayTest, WorksForTwoDimensionalArrays) { // Tests NativeArray. -TEST(NativeArrayTest, ConstructorFromArrayReferenceWorks) { +TEST(NativeArrayTest, ConstructorFromArrayWorks) { const int a[3] = { 0, 1, 2 }; - NativeArray na(a, kReference); + NativeArray 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 na(make_tuple(p, 3U), kReference); - EXPECT_EQ(a, na.begin()); - - const linked_ptr b(new char); - *b = 'a'; - // Tests with a smart pointer. - NativeArray 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 na(*a, kCopy); + NativeArray 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 na(a, kCopy); + const int a[3] = { 0, 1, 2 }; + NativeArray 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 na2(a, kReference); + NativeArray 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(b1, kReference)))); - EXPECT_THAT(na, Not(Eq(NativeArray(b2, kCopy)))); + const int b1[3] = { 0, 1, 1 }; + const int b2[4] = { 0, 1, 2, 3 }; + EXPECT_THAT(na, Not(Eq(NativeArray(b1, 3, kReference)))); + EXPECT_THAT(na, Not(Eq(NativeArray(b2, 4, kCopy)))); } TEST(NativeArrayTest, WorksForTwoDimensionalArray) { const char a[2][3] = { "hi", "lo" }; - NativeArray na(a, kReference); + NativeArray na(a, 2, kReference); ASSERT_EQ(2, na.size()); EXPECT_EQ(a, na.begin()); } diff --git a/test/gmock-nice-strict_test.cc b/test/gmock-nice-strict_test.cc index 955961c5..15984a55 100644 --- a/test/gmock-nice-strict_test.cc +++ b/test/gmock-nice-strict_test.cc @@ -36,6 +36,13 @@ #include #include +// 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 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 strict_foo; @@ -224,5 +242,16 @@ TEST(StrictMockTest, NonDefaultConstructor10) { "Uninteresting mock function call"); } +// Tests that StrictMock 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 diff --git a/test/gmock-printers_test.cc b/test/gmock-printers_test.cc index af2e83c0..0eb8e094 100644 --- a/test/gmock-printers_test.cc +++ b/test/gmock-printers_test.cc @@ -790,14 +790,14 @@ TEST(PrintStlContainerTest, NestedContainer) { } TEST(PrintStlContainerTest, OneDimensionalNativeArray) { - const int a[] = { 1, 2, 3 }; - NativeArray b(a, kReference); + const int a[3] = { 1, 2, 3 }; + NativeArray 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 b(a, kReference); + const int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } }; + NativeArray b(a, 2, kReference); EXPECT_EQ("{ { 1, 2, 3 }, { 4, 5, 6 } }", Print(b)); }