Googletest export

googlemock/test/gmock_doctor_nc.cc

+// 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

googlemock/test/gmock_doctor_test.py

+#!/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])

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<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)});
 }
 

googletest/include/gtest/internal/gtest-internal.h

@@ -506,7 +506,8 @@ struct SuiteApiResolver : T {
   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 =
@@ -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<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.
@@ -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<GTEST_TEST_CLASS_NAME_(    \
               test_suite_name, test_name)>);                                  \
   void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()

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<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