From fa52cd63631954b558f144de8508cd8d2463c0e8 Mon Sep 17 00:00:00 2001 From: misterg Date: Thu, 18 Apr 2019 10:05:29 -0400 Subject: [PATCH] Googletest export Expose more information in SuiteApiResolver diagnostic output PiperOrigin-RevId: 244179347 --- googlemock/test/gmock_doctor_nc.cc | 294 ++++++++++++++++++ googlemock/test/gmock_doctor_test.py | 242 ++++++++++++++ googletest/include/gtest/gtest.h | 4 +- .../include/gtest/internal/gtest-internal.h | 22 +- .../include/gtest/internal/gtest-param-util.h | 4 +- 5 files changed, 554 insertions(+), 12 deletions(-) create mode 100644 googlemock/test/gmock_doctor_nc.cc create mode 100755 googlemock/test/gmock_doctor_test.py 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 diff --git a/googlemock/test/gmock_doctor_test.py b/googlemock/test/gmock_doctor_test.py new file mode 100755 index 00000000..24a2ec43 --- /dev/null +++ b/googlemock/test/gmock_doctor_test.py @@ -0,0 +1,242 @@ +#!/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::operator testing::Action()" + ' const [with F = const std::complex&(unsigned int),' + " R = std::complex]':\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::operator' + ' testing::Action() const' + ' [with F = const std::complex&(unsigned int),' + ' R = std::complex]\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]) diff --git a/googletest/include/gtest/gtest.h b/googletest/include/gtest/gtest.h index cedef931..76f4098b 100644 --- a/googletest/include/gtest/gtest.h +++ b/googletest/include/gtest/gtest.h @@ -2427,8 +2427,8 @@ TestInfo* RegisterTest(const char* test_suite_name, const char* test_name, return internal::MakeAndRegisterTestInfo( test_suite_name, test_name, type_param, value_param, internal::CodeLocation(file, line), internal::GetTypeId(), - internal::SuiteApiResolver::GetSetUpCaseOrSuite(), - internal::SuiteApiResolver::GetTearDownCaseOrSuite(), + internal::SuiteApiResolver::GetSetUpCaseOrSuite(file, line), + internal::SuiteApiResolver::GetTearDownCaseOrSuite(file, line), new FactoryImpl{std::move(factory)}); } diff --git a/googletest/include/gtest/internal/gtest-internal.h b/googletest/include/gtest/internal/gtest-internal.h index 49887170..27326608 100644 --- a/googletest/include/gtest/internal/gtest-internal.h +++ b/googletest/include/gtest/internal/gtest-internal.h @@ -506,7 +506,8 @@ struct SuiteApiResolver : T { using Test = typename std::conditional::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 = @@ -514,12 +515,14 @@ struct SuiteApiResolver : T { 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 = @@ -527,7 +530,8 @@ struct SuiteApiResolver : T { 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; } @@ -706,8 +710,10 @@ class TypeParameterizedTest { GetTypeName().c_str(), nullptr, // No value parameter. code_location, GetTypeId(), - SuiteApiResolver::GetSetUpCaseOrSuite(), - SuiteApiResolver::GetTearDownCaseOrSuite(), + SuiteApiResolver::GetSetUpCaseOrSuite( + code_location.file.c_str(), code_location.line), + SuiteApiResolver::GetTearDownCaseOrSuite( + code_location.file.c_str(), code_location.line), new TestFactoryImpl); // Next, recurses (at compile time) with the tail of the type list. @@ -1412,9 +1418,9 @@ constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; } #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); \ void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody() diff --git a/googletest/include/gtest/internal/gtest-param-util.h b/googletest/include/gtest/internal/gtest-param-util.h index 3ed7d22e..e900b3ff 100644 --- a/googletest/include/gtest/internal/gtest-param-util.h +++ b/googletest/include/gtest/internal/gtest-param-util.h @@ -571,8 +571,8 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase { nullptr, // No type parameter. PrintToString(*param_it).c_str(), code_location_, GetTestSuiteTypeId(), - SuiteApiResolver::GetSetUpCaseOrSuite(), - SuiteApiResolver::GetTearDownCaseOrSuite(), + SuiteApiResolver::GetSetUpCaseOrSuite(file, line), + SuiteApiResolver::GetTearDownCaseOrSuite(file, line), test_info->test_meta_factory->CreateTestFactory(*param_it)); } // for param_it } // for gen_it