From fa52cd63631954b558f144de8508cd8d2463c0e8 Mon Sep 17 00:00:00 2001 From: misterg Date: Thu, 18 Apr 2019 10:05:29 -0400 Subject: Googletest export Expose more information in SuiteApiResolver diagnostic output PiperOrigin-RevId: 244179347 --- googlemock/test/gmock_doctor_nc.cc | 294 +++++++++++++++++++++++++++++++++++++ 1 file changed, 294 insertions(+) create mode 100644 googlemock/test/gmock_doctor_nc.cc (limited to 'googlemock/test/gmock_doctor_nc.cc') diff --git a/googlemock/test/gmock_doctor_nc.cc b/googlemock/test/gmock_doctor_nc.cc new file mode 100644 index 00000000..e20f4dc9 --- /dev/null +++ b/googlemock/test/gmock_doctor_nc.cc @@ -0,0 +1,294 @@ +// 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.h" + +bool Overloaded(int n) { return n > 0; } +bool Overloaded(double x) { return x > 0; } + +class Foo { + public: + virtual ~Foo() {} + virtual int IntFunc(bool* p) = 0; + virtual void VoidFunc(int n) = 0; + virtual int& GetIntRef() = 0; + virtual Foo* GetPointer() = 0; + virtual int Do(void (*fp)()) = 0; +}; + +class MockFoo : public Foo { + public: + MOCK_METHOD1(IntFunc, int(bool* p)); + MOCK_METHOD1(VoidFunc, void(int n)); + MOCK_METHOD0(GetIntRef, int&()); + MOCK_METHOD0(GetPointer, Foo*()); + MOCK_METHOD1(Do, int(void (*fp)())); +}; + +class Bar { + public: + virtual ~Bar() {} + int Overloaded() { return 1; } + virtual void Overloaded(int n) {} +}; + +#if defined(TEST_MOP) + +using ::testing::_; +using ::testing::Return; + +// Tests that Google Mock Doctor can diagnose the Mock Object Pointer +// disease. +void Test() { + MockFoo foo; + ON_CALL(&foo, IntFunc(_)).WillByDefault(Return(0)); + EXPECT_CALL(&foo, VoidFunc(_)); +} + +#elif defined(TEST_NRS1) + +using ::testing::_; +using ::testing::SetArgPointee; + +// Tests that Google Mock Doctor can diagnose the Need to Return +// Something disease. +void Test() { + MockFoo foo; + EXPECT_CALL(foo, IntFunc(_)) + .WillOnce(SetArgPointee<0>(true)); +} + +#elif defined(TEST_NRS2) + +using ::testing::_; +using ::testing::Return; + +// Tests that Google Mock Doctor can diagnose the Need to Return +// Something disease. +void Test() { + MockFoo foo; + EXPECT_CALL(foo, IntFunc(_)) + .WillOnce(Return()); +} + +#elif defined(TEST_NRS3) + +using ::testing::_; +using ::testing::InvokeArgument; + +// Tests that Google Mock Doctor can diagnose the Need to Return +// Something disease. +void Test() { + MockFoo foo; + EXPECT_CALL(foo, Do(_)) + .WillOnce(InvokeArgument<0>()); +} + +#elif defined(TEST_IBRA) + +// Tests that Google Mock Doctor can diagnose the Incomplete +// By-Reference Argument Type disease. + +class Incomplete; + +class MockBar { + public: + MOCK_METHOD1(ByRefFunc, void(const Incomplete&)); +}; + +void Test() { + MockBar bar; +} + +#elif defined(TEST_OFM) + +// Tests that Google Mock Doctor can diagnose the Overloaded Function +// Matcher disease. +void Test() { + using ::testing::Matcher; + using ::testing::Truly; + + Matcher m = Truly(Overloaded); +} + +#elif defined(TEST_NO_NUS_FOR_NON_GMOCK_SYMBOL) + +// Tests that Google Mock Doctor doesn't report the Need to Use Symbol +// disease when the undeclared symbol is not from Google Mock. +void Test() { + MockFoo foo; + EXPECT_CALL(foo, IntFunc(NonGMockMatcher())); +} + +#elif defined(TEST_NUS_VARIABLE) + +// Tests that Google Mock Doctor can diagnose the Need to Use Symbol +// disease when the undeclared symbol is a variable. +void Test() { + MockFoo foo; + EXPECT_CALL(foo, IntFunc(_)); +} + +#elif defined(TEST_NUS_FUNCTION) + +// Tests that Google Mock Doctor can diagnose the Need to Use Symbol +// disease when the undeclared symbol is a function. +void Test() { + MockFoo foo; + EXPECT_CALL(foo, IntFunc(NULL)) + .Times(AtLeast(1)); +} + +#elif defined(TEST_NUS_FUNCTION_TEMPLATE) + +// Tests that Google Mock Doctor can diagnose the Need to Use Symbol +// disease when the undeclared symbol is a function template with no +// explicit template argument. +void Test() { + MockFoo foo; + EXPECT_CALL(foo, IntFunc(NULL)) + .WillOnce(Return(1)); +} + +#elif defined(TEST_NUS_FUNCTION_TEMPLATE_WITH_TYPE_ARG) + +// Tests that Google Mock Doctor can diagnose the Need to Use Symbol +// disease when the undeclared symbol is a function template with an +// explicit template type argument. +void Test() { + MockFoo foo; + EXPECT_CALL(foo, IntFunc(A())); +} + +#elif defined(TEST_NUS_FUNCTION_TEMPLATE_WITH_NONTYPE_ARG) + +// Tests that Google Mock Doctor can diagnose the Need to Use Symbol +// disease when the undeclared symbol is a function template with an +// explicit template non-type argument. +using ::testing::_; + +void Test() { + MockFoo foo; + int n; + EXPECT_CALL(foo, VoidFunc(_)).WillOnce(SaveArg<0>(&n)); +} + +#elif defined(TEST_NUS_CLASS) + +// Tests that Google Mock Doctor can diagnose the Need to Use Symbol +// disease when the undeclared symbol is a class. +void Test() { + MockFoo foo; + Sequence s; + Mock::VerifyAndClear(&foo); +} + +#elif defined(TEST_NRR) + +using ::testing::Return; + +// Tests that Google Mock Doctor can diagnose the Need to Return +// Reference disease (using Return() when ReturnRef() should be used). +void Test() { + int n = 0; + MockFoo foo; + EXPECT_CALL(foo, GetIntRef()) + .WillOnce(Return(n)); +} + +#elif defined(TEST_MULTI_OCCURRENCES_OF_SAME_DISEASE) + +// Tests that Google Mock Doctor can diagnose multiple occurrences of +// the same disease in the same code. + +class Incomplete; +class Incomplete2; + +class MockBar { + public: + MOCK_METHOD1(ByRefFunc, void(const Incomplete&)); + MOCK_METHOD1(ByRefFunc, void(const Incomplete2&)); +}; + +MockBar bar; + +#elif defined(TEST_NRNULL) + +using ::testing::Return; + +// Tests that gMock Doctor can diagnose the Need to use ReturnNull +// disease (using Return(NULL) when ReturnNull() should be used). +void Test() { + MockFoo foo; + EXPECT_CALL(foo, GetPointer()) + .WillOnce(Return(NULL)); +} + +#elif defined(TEST_WPP) + +using ::testing::_; +using ::testing::Return; + +// Tests that gMock doctor can diagnose the Wrong Parenthesis Position +// disease. +void Test() { + MockFoo foo; + + ON_CALL(foo, IntFunc(_).WillByDefault(Return(0))); + EXPECT_CALL(foo, VoidFunc(_).Times(1)); + EXPECT_CALL(foo, VoidFunc(_).WillOnce(Return())); +} + +#elif defined(TEST_TTB) + +template +class Stack { + public: + typedef unsigned int SomeType; +}; + +// Tests that gMock doctor can diagnose the Type in Template Base +// disease. +template +class MockStack : public Stack { + public: + // typedef typename Stack::SomeType SomeType; would fix the errors. + + // Uses a type from Stack as the mock function's return type. + MOCK_METHOD0_T(IsEmpty, SomeType()); + + // Uses a type from Stack as the sole parameter of the mock function. + MOCK_CONST_METHOD1_T(IsOK1, bool(SomeType)); + + // Uses a type from Stack as one of the parameters of the mock function. + MOCK_CONST_METHOD3_T(IsOK2, bool(int, int, SomeType)); +}; + +#endif -- cgit v1.2.3