--- /dev/null
+// 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<int> 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<bool*>()));
+}
+
+#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 <typename T>
+class Stack {
+ public:
+ typedef unsigned int SomeType;
+};
+
+// Tests that gMock doctor can diagnose the Type in Template Base
+// disease.
+template <typename T>
+class MockStack : public Stack<T> {
+ public:
+ // typedef typename Stack<T>::SomeType SomeType; would fix the errors.
+
+ // Uses a type from Stack<T> as the mock function's return type.
+ MOCK_METHOD0_T(IsEmpty, SomeType());
+
+ // Uses a type from Stack<T> as the sole parameter of the mock function.
+ MOCK_CONST_METHOD1_T(IsOK1, bool(SomeType));
+
+ // Uses a type from Stack<T> as one of the parameters of the mock function.
+ MOCK_CONST_METHOD3_T(IsOK2, bool(int, int, SomeType));
+};
+
+#endif
--- /dev/null
+#!/usr/bin/env python
+#
+# 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.
+
+"""Tests for gmock_doctor.py."""
+
+import os
+import sys
+
+IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
+if not IS_LINUX:
+ sys.stderr.write(
+ 'WARNING: Negative compilation tests are not supported on this platform')
+ sys.exit(0)
+
+# Suppresses the 'Import not at the top of the file' lint complaint.
+# pylint: disable-msg=C6204
+import google3.third_party.googletest.googlemock.scripts.gmock_doctor
+gmock_doctor = google3.third_party.googletest.googlemock.scripts.gmock_doctor
+from google3.testing.pybase import fake_target_util
+from google3.testing.pybase import googletest
+# pylint: enable-msg=C6204
+
+
+def GetCompilerCommand():
+ """Returns the command used for compiling gmock_doctor_nc.cc."""
+
+ # Parses the fake output generated by the cc_fake_binary rule.
+ target = fake_target_util.ParseFakeTargetFile(
+ 'google3/third_party/googletest/googlemock/test/gmock_doctor_nc')
+
+ # Looks up the command for making the desired target.
+ command = target.CommandMap()['gmock_doctor_nc.o']
+
+ # Looks up where Makefile is.
+ makefile_dir = target.MakefileDir()
+
+ # Changes the current directory to where Makefile is - the
+ # compilation must be done there.
+ os.chdir(makefile_dir)
+
+ return command
+
+
+def CompileSection(section_name):
+ """Compiles the given section in gmock_doctor_nc.cc.
+
+ The error messages from the compiler will be printed on stdout such that
+ they can be easily piped to the Google Mock Doctor.
+
+ Args:
+ section_name: Name of the section in gmock_doctor_nc.cc that should
+ be compiled.
+ """
+
+ command = GetCompilerCommand()
+ (_, compiler_errors) = googletest.GetCommandStderr(
+ command + ' -DTEST_' + section_name,
+ env = {'TEST_TMPDIR': os.environ['TEST_TMPDIR']})
+ print compiler_errors
+
+
+class GMockDoctorTest(googletest.TestCase):
+ def setUp(self):
+ self.command = GetCompilerCommand()
+
+ def CheckDiagnoses(self, test_name, diseases):
+ """Checks the diagnoses for the given compiler output.
+
+ Args:
+ test_name: Name of the section in gmock_doctor_nc.cc that should
+ be compiled.
+
+ diseases: A list of disease short names that Google Mock Doctor
+ should diagnose.
+ """
+
+ _, compiler_errors = googletest.GetCommandStderr(
+ self.command + ' -DTEST_' + test_name,
+ env = {'TEST_TMPDIR': os.environ['TEST_TMPDIR']})
+
+ self.CheckDiagnosesForOutput(compiler_errors, diseases)
+
+ def CheckDiagnosesForOutput(self, compiler_errors, diseases):
+ """Checks the diagnoses for the given test.
+
+ Args:
+ compiler_errors: The compiler diagnostics to check for diseases.
+
+ diseases: A list of disease short names that Google Mock Doctor
+ should diagnose.
+ """
+
+ diagnoses = gmock_doctor.Diagnose(compiler_errors)
+ num_diseases = len(diseases)
+ num_diagnoses = len(diagnoses)
+
+ for i in range(min(num_diseases, num_diagnoses)):
+ self.assert_(('[' + diseases[i] + ' ') in diagnoses[i],
+ ('Compiler error message:\n\n'
+ '%sgmock_doctor.py\'s diagnoses:\n%s\n\n'
+ 'Failed to diagnose the %s disease.')
+ % (compiler_errors, diagnoses[i], diseases[i]))
+
+ self.assertEquals(num_diseases, num_diagnoses,
+ ('%d diseases, but %d diagnoses, where the '
+ 'compiler errors are:\n%s\n'
+ 'and where the diseases are:\n%s\n'
+ 'and where the diagnoses are:\n%s\n')
+ % (num_diseases, num_diagnoses, compiler_errors,
+ str(diseases), str(diagnoses)))
+
+ def testMOP(self):
+ self.CheckDiagnoses('MOP', 2 * ['MOP'])
+
+ def testNRS1(self):
+ self.CheckDiagnoses('NRS1', ['NRS'])
+
+ def testNRS2(self):
+ self.CheckDiagnoses('NRS2', ['NRS'])
+
+ def testNRS3(self):
+ self.CheckDiagnoses('NRS3', ['NRS'])
+
+ def testIBRA(self):
+ self.CheckDiagnoses('IBRA', ['IBRA'])
+
+ def testOFM(self):
+ self.CheckDiagnoses('OFM', ['OFM'])
+
+ def testNoNUSForNonGMockSymbol(self):
+ self.CheckDiagnoses('NO_NUS_FOR_NON_GMOCK_SYMBOL', [])
+
+ def testNUSVariable(self):
+ self.CheckDiagnoses('NUS_VARIABLE', ['NUS'])
+
+ def testNUSFunction(self):
+ self.CheckDiagnoses('NUS_FUNCTION', ['NUS'])
+
+ def testNUSFunctionTemplate(self):
+ self.CheckDiagnoses('NUS_FUNCTION_TEMPLATE', ['NUS'])
+
+ def testNUSFunctionTemplateWithTypeArg(self):
+ self.CheckDiagnoses('NUS_FUNCTION_TEMPLATE_WITH_TYPE_ARG', ['NUS'])
+
+ def testNUSFunctionTemplateWithNontypeArg(self):
+ self.CheckDiagnoses('NUS_FUNCTION_TEMPLATE_WITH_NONTYPE_ARG', ['NUS'])
+
+ def testNUSClass(self):
+ self.CheckDiagnoses('NUS_CLASS', 2 * ['NUS'])
+
+ def testNRR(self):
+ self.CheckDiagnoses('NRR', ['NRR'])
+
+ def testMultipleOccurrences(self):
+ self.CheckDiagnoses('MULTI_OCCURRENCES_OF_SAME_DISEASE', 2 * ['IBRA'])
+
+ def testNRNULL(self):
+ self.CheckDiagnoses('NRNULL', ['NRNULL'])
+
+ def testWPP(self):
+ self.CheckDiagnoses('WPP', 3 * ['WPP'])
+
+ def testTTB(self):
+ self.CheckDiagnoses('TTB', 3 * ['TTB'])
+
+ def testUnderstandsCharaterPositionsInGcc(self):
+ # We cannot guarantee that the system compiler will output character
+ # positions so we inject the compiler output.
+ compiler_errors = (
+ 'In file included from /usr/include/gmock/gmock.h:58:0,\n'
+ ' from foo.cpp:4:\n'
+ '/usr/include/gmock/gmock-actions.h: In member function'
+ " 'testing::internal::ReturnAction<R>::operator testing::Action<Func>()"
+ ' const [with F = const std::complex<double>&(unsigned int),'
+ " R = std::complex<double>]':\n"
+ 'foo.cpp:116:28: instantiated from here\n'
+ '/usr/include/gmock/gmock-actions.h:449:5: error:'
+ " creating array with negative size ('-0x00000000000000001')")
+ self.CheckDiagnosesForOutput(compiler_errors, ['NRR'])
+
+ def testUnderstandsLeftAndRightSingleQuotes(self):
+ # We cannot guarantee that the system compiler will output single quote
+ # characters so we inject the compiler output.
+ compiler_errors = (
+ 'In file included from /usr/include/gmock/gmock.h:58,\n'
+ ' from foo.cpp:4:\n'
+ '/usr/include/gmock/gmock-actions.h: In member function'
+ ' \xe2\x80\x98testing::internal::ReturnAction<R>::operator'
+ ' testing::Action<Func>() const'
+ ' [with F = const std::complex<double>&(unsigned int),'
+ ' R = std::complex<double>]\xe2\x80\x99:\n'
+ 'foo.cpp:116: instantiated from here\n'
+ '/usr/include/gmock/gmock-actions.h:449: error:'
+ ' creating array with negative size'
+ ' (\xe2\x80\x98-0x00000000000000001\xe2\x80\x99)')
+ self.CheckDiagnosesForOutput(compiler_errors, ['NRR'])
+
+
+if __name__ == '__main__':
+ if len(sys.argv) == 1:
+ googletest.main()
+ else:
+ # To make it easy for a user to see Google Mock Doctor in action,
+ # we compile the given section in gmock_doctor_nc.cc and direct
+ # the error messages to stdout, when the test is run with a
+ # section name on the command line. Then the user can pipe the
+ # output to Google Mock Doctor and see what the diagnoses are
+ # like. For example, to demo how Google Mock Doctor diagnoses the
+ # NRN disease:
+ #
+ # $ blaze build third_party/googletest/googlemock/test:gmock_doctor_test
+ # $ blaze-bin/third_party/googletest/googlemock/test/gmock_doctor_test NRN | \
+ # third_party/googletest/googlemock/scripts/gmock_doctor.py
+ CompileSection(sys.argv[1])
return internal::MakeAndRegisterTestInfo(
test_suite_name, test_name, type_param, value_param,
internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
- internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(),
- internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(),
+ internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line),
+ internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line),
new FactoryImpl{std::move(factory)});
}
using Test =
typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type;
- static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite() {
+ static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
+ int line_num) {
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearDownSuiteFuncType test_suite_fp =
GTEST_CHECK_(!test_case_fp || !test_suite_fp)
<< "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
- "make sure there is only one present ";
+ "make sure there is only one present at "
+ << filename << ":" << line_num;
return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
}
- static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite() {
+ static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
+ int line_num) {
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
SetUpTearDownSuiteFuncType test_suite_fp =
GTEST_CHECK_(!test_case_fp || !test_suite_fp)
<< "Test can not provide both TearDownTestSuite and TearDownTestCase,"
- " please make sure there is only one present ";
+ " please make sure there is only one present at"
+ << filename << ":" << line_num;
return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
}
GetTypeName<Type>().c_str(),
nullptr, // No value parameter.
code_location, GetTypeId<FixtureClass>(),
- SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite(),
- SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite(),
+ SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite(
+ code_location.file.c_str(), code_location.line),
+ SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite(
+ code_location.file.c_str(), code_location.line),
new TestFactoryImpl<TestClass>);
// Next, recurses (at compile time) with the tail of the type list.
#test_suite_name, #test_name, nullptr, nullptr, \
::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
::testing::internal::SuiteApiResolver< \
- parent_class>::GetSetUpCaseOrSuite(), \
+ parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__), \
::testing::internal::SuiteApiResolver< \
- parent_class>::GetTearDownCaseOrSuite(), \
+ parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__), \
new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_( \
test_suite_name, test_name)>); \
void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
nullptr, // No type parameter.
PrintToString(*param_it).c_str(), code_location_,
GetTestSuiteTypeId(),
- SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(),
- SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(),
+ SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
+ SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
test_info->test_meta_factory->CreateTestFactory(*param_it));
} // for param_it
} // for gen_it
projects / googletest.git / commitdiff