[WIP][RGT] Rotten Green Test checking for LLVM and Clang unittests

[probinson]

Summary

This is an enhancement of the 'googletest' support code, to report
test assertions (EXPECT_* and ASSERT_* macros) that are not executed.
An un-executed assertion looks like it tests something, and passes (so
is "green") but actually does nothing (so is "rotten").

Due to the number of false positives (for example, all DISABLED tests
will be reported as rotten), running the unittests under lit will
*not* report rotten tests; however, running a unittest program
manually (not under lit) will report these by default.

The RGT support has been tried on Linux using both Clang and GCC as
build compilers, and on Windows with MSVC. MachO has not been tried.

The intent is to clean up more of the false positives before seeking
to commit the RGT support. Some of this work has been done already.

This is a Work-In-Progress, not ready for final review, but it seems
mature enough to present to the community in its current form.

clang/test/Unit/lit.cfg.py

 # test_source_root: The root path where tests are located.
 # test_exec_root: The root path where tests should be run.
 config.test_exec_root = os.path.join(config.clang_obj_root, 'unittests')
 config.test_source_root = config.test_exec_root
 
 # testFormat: The test format to use to interpret tests.
 config.test_format = lit.formats.GoogleTest(config.llvm_build_mode, 'Tests')
 
+# Tell gtest not to report un-executed tests.
+config.environment['GTEST_REPORT_ROTTEN'] = '0'
+
 # Propagate the temp directory. Windows requires this because it uses \Windows\
 # if none of these are present.
 if 'TMP' in os.environ:
     config.environment['TMP'] = os.environ['TMP']
 if 'TEMP' in os.environ:
     config.environment['TEMP'] = os.environ['TEMP']
 
 # Propagate path to symbolizer for ASan/MSan.

clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp

 #include "llvm/Testing/Support/SupportHelpers.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace ast_matchers {
 using internal::DynTypedMatcher;
 
 #if GTEST_HAS_DEATH_TEST
+// RGT-FIXME: The RGT infraststructure does not play nicely with ASSERT_DEATH
+// when the statement lexically contains an EXPECT.
+#undef GTEST_RGT_DECLARE
+#define GTEST_RGT_DECLARE
 TEST(HasNameDeathTest, DiesOnEmptyName) {
   ASSERT_DEBUG_DEATH({
     DeclarationMatcher HasEmptyName = recordDecl(hasName(""));
     EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
   }, "");
 }
 
 TEST(HasNameDeathTest, DiesOnEmptyPattern) {
   ASSERT_DEBUG_DEATH({
       DeclarationMatcher HasEmptyName = recordDecl(matchesName(""));
       EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
     }, "");
 }
+#undef GTEST_RGT_DECLARE
+#define GTEST_RGT_DECLARE GTEST_RGT_DECLARE_
 #endif
 
 TEST(ConstructVariadic, MismatchedTypes_Regression) {
   EXPECT_TRUE(
       matches("const int a = 0;", internal::DynTypedMatcher::constructVariadic(
                                       internal::DynTypedMatcher::VO_AnyOf,
                                       ASTNodeKind::getFromNodeKind<QualType>(),
                                       {isConstQualified(), arrayType()})

clang/unittests/Tooling/Syntax/MutationsTest.cpp

if (!Output) {
       ADD_FAILURE() << "could not apply replacements: "
                     << llvm::toString(Output.takeError());
       return;
     }
 
     EXPECT_EQ(Expected, *Output) << "input is:\n" << Input;
   };
 
+// GCC seems to have issues here.
+#undef GTEST_RGT_DECLARE
+#define GTEST_RGT_DECLARE
   // Removes the selected statement. Input should have exactly one selected
   // range and it should correspond to a single statement.
   Transformation RemoveStatement = [this](const llvm::Annotations &Input,
                                           TranslationUnit *Root) {
     auto *S = cast<syntax::Statement>(nodeByRange(Input.range(), Root));
     ASSERT_TRUE(S->canModify()) << "cannot remove a statement";
     syntax::removeStatement(*Arena, S);
     EXPECT_TRUE(S->isDetached());
     EXPECT_FALSE(S->isOriginal())
         << "node removed from tree cannot be marked as original";
   };
+#undef GTEST_RGT_DECLARE
+#define GTEST_RGT_DECLARE GTEST_RGT_DECLARE_
 };
 
 INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, MutationTest,
                         ::testing::ValuesIn(allTestClangConfigs()), );
 
 TEST_P(MutationTest, RemoveStatement_InCompound) {
   CheckTransformation(RemoveStatement, "void test() { [[100+100;]] test(); }",
                       "void test() {  test(); }");

llvm/test/Unit/lit.cfg.py

 # test_source_root: The root path where tests are located.
 # test_exec_root: The root path where tests should be run.
 config.test_exec_root = os.path.join(config.llvm_obj_root, 'unittests')
 config.test_source_root = config.test_exec_root
 
 # testFormat: The test format to use to interpret tests.
 config.test_format = lit.formats.GoogleTest(config.llvm_build_mode, 'Tests')
 
+# Tell gtest not to report un-executed tests.
+config.environment['GTEST_REPORT_ROTTEN'] = '0'
+
 # Propagate the temp directory. Windows requires this because it uses \Windows\
 # if none of these are present.
 if 'TMP' in os.environ:
     config.environment['TMP'] = os.environ['TMP']
 if 'TEMP' in os.environ:
     config.environment['TEMP'] = os.environ['TEMP']
 
 # Propagate HOME as it can be used to override incorrect homedir in passwd

llvm/unittests/Support/ProgramTest.cpp

TEST_F(ProgramEnvTest, CreateProcessLongPath) {
   std::string MyAbsExe =
       sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
   std::string MyExe;
   if (!StringRef(MyAbsExe).startswith("\\\\?\\"))
     MyExe.append("\\\\?\\");
   MyExe.append(MyAbsExe);
 
   StringRef ArgV[] = {MyExe,
-                      "--gtest_filter=ProgramEnvTest.CreateProcessLongPath"};
+                      "--gtest_filter=ProgramEnvTest.CreateProcessLongPath",
+                      "--gtest_report_rotten=0"};
 
   // Add LLVM_PROGRAM_TEST_LONG_PATH to the environment of the child.
   addEnvVar("LLVM_PROGRAM_TEST_LONG_PATH=1");
 
   // Redirect stdout to a long path.
   SmallString<128> TestDirectory;
   ASSERT_NO_ERROR(
     fs::createUniqueDirectory("program-redirect-test", TestDirectory));
if (getenv("LLVM_PROGRAM_TEST_CHILD")) {
     exit(1);
   }
 
   std::string my_exe =
       sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
   StringRef argv[] = {
       my_exe,
       "--gtest_filter=ProgramEnvTest.CreateProcessTrailingSlash",
+      "--gtest_report_rotten=0",
       "-program-test-string-arg1",
       "has\\\\ trailing\\",
       "-program-test-string-arg2",
       "has\\\\ trailing\\"};
 
   // Add LLVM_PROGRAM_TEST_CHILD to the environment of the child.
   addEnvVar("LLVM_PROGRAM_TEST_CHILD=1");
 
TEST_F(ProgramEnvTest, TestExecuteNoWait) {
   if (getenv("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT")) {
     sleep_for(/*seconds*/ 1);
     exit(0);
   }
 
   std::string Executable =
       sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
   StringRef argv[] = {Executable,
-                      "--gtest_filter=ProgramEnvTest.TestExecuteNoWait"};
+                      "--gtest_filter=ProgramEnvTest.TestExecuteNoWait",
+                      "--gtest_report_rotten=0"};
 
   // Add LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT to the environment of the child.
   addEnvVar("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT=1");
 
   std::string Error;
   bool ExecutionFailed;
   ProcessInfo PI1 = ExecuteNoWait(Executable, argv, getEnviron(), {}, 0, &Error,
                                   &ExecutionFailed);
TEST_F(ProgramEnvTest, TestExecuteAndWaitTimeout) {
 
   if (getenv("LLVM_PROGRAM_TEST_TIMEOUT")) {
     sleep_for(/*seconds*/ 10);
     exit(0);
   }
 
   std::string Executable =
       sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
-  StringRef argv[] = {
-      Executable, "--gtest_filter=ProgramEnvTest.TestExecuteAndWaitTimeout"};
+  StringRef argv[] = {Executable,
+                      "--gtest_filter=ProgramEnvTest.TestExecuteAndWaitTimeout",
+                      "--gtest_report_rotten=0"};
 
   // Add LLVM_PROGRAM_TEST_TIMEOUT to the environment of the child.
  addEnvVar("LLVM_PROGRAM_TEST_TIMEOUT=1");
 
   std::string Error;
   bool ExecutionFailed;
   int RetCode =
       ExecuteAndWait(Executable, argv, getEnviron(), {}, /*secondsToWait=*/1, 0,
TEST_F(ProgramEnvTest, TestExecuteAndWaitStatistics) {
   using namespace llvm::sys;
 
   if (getenv("LLVM_PROGRAM_TEST_STATISTICS"))
     exit(0);
 
   std::string Executable =
       sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
   StringRef argv[] = {
-      Executable, "--gtest_filter=ProgramEnvTest.TestExecuteAndWaitStatistics"};
+      Executable,
+      "--gtest_filter=ProgramEnvTest.TestExecuteAndWaitStatistics",
+      "--gtest_report_rotten=0"};
 
   // Add LLVM_PROGRAM_TEST_STATISTICS to the environment of the child.
   addEnvVar("LLVM_PROGRAM_TEST_STATISTICS=1");
 
   std::string Error;
   bool ExecutionFailed;
   Optional<ProcessStatistics> ProcStat;
   int RetCode = ExecuteAndWait(Executable, argv, getEnviron(), {}, 0, 0, &Error,

llvm/utils/unittest/googletest/include/gtest/gtest.h

 // non-zero code otherwise.
 GTEST_DECLARE_bool_(throw_on_failure);
 
 // When this flag is set with a "host:port" string, on supported
 // platforms test results are streamed to the specified port on
 // the specified host machine.
 GTEST_DECLARE_string_(stream_result_to);
 
+// This flag controls whether we print location info for each
+// un-executed test.
+GTEST_DECLARE_bool_(report_rotten);
+
+// When this flag is set with a filename, report all test assertion
+// locations to that file.  For debugging RGT.
+GTEST_DECLARE_string_(report_all_assertions_to);
+
 // The upper limit for valid stack trace depths.
 const int kMaxStackTraceDepth = 100;
 
 namespace internal {
 
 class AssertHelper;
 class DefaultGlobalTestPartResultReporter;
 class ExecDeathTest;

llvm/utils/unittest/googletest/include/gtest/gtest_pred_impl.h

 //
 // Implements a family of generic predicate assertion macros.
 
 #ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
 #define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
 
 // Makes sure this header is not included before gtest.h.
 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
 # error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
 #endif  // GTEST_INCLUDE_GTEST_GTEST_H_
 
 // This header implements a family of generic predicate assertion
 // macros:
 //
 //   ASSERT_PRED_FORMAT1(pred_format, v1)
 //   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
 //   ...

 //
 // For now we only support predicates whose arity is at most 5.
 // Please email [e-mail] if you need
 // support for higher arities.
 
 // GTEST_ASSERT_ is the basic statement to which all of the assertions
 // in this file reduce.  Don't use this in your code.
 
 #define GTEST_ASSERT_(expression, on_failure) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
   if (const ::testing::AssertionResult gtest_ar = (expression)) \
-    ; \
+    { GTEST_RGT_DECLARE }                                      \
   else \
     on_failure(gtest_ar.failure_message())
 
 
 // Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
 // this in your code.
 template <typename Pred,
           typename T1>
 AssertionResult AssertPred1Helper(const char* pred_text,
                                   const char* e1,
                                   Pred pred,
                                   const T1& v1) {
   if (pred(v1)) return AssertionSuccess();
 
   return AssertionFailure() << pred_text << "("
                             << e1 << ") evaluates to false, where"
                             << "\n" << e1 << " evaluates to " << v1;
 }
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
 // Don't use this in your code.
 #define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
   GTEST_ASSERT_(pred_format(#v1, v1), \

 
 
 
 // Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
 // this in your code.
 template <typename Pred,
           typename T1,
           typename T2>
 AssertionResult AssertPred2Helper(const char* pred_text,
                                   const char* e1,
                                   const char* e2,
                                   Pred pred,
                                   const T1& v1,
                                   const T2& v2) {
   if (pred(v1, v2)) return AssertionSuccess();
 
   return AssertionFailure() << pred_text << "("
                             << e1 << ", "
                             << e2 << ") evaluates to false, where"
                             << "\n" << e1 << " evaluates to " << v1
                             << "\n" << e2 << " evaluates to " << v2;
 }
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
 // Don't use this in your code.

 
 
 // Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
 // this in your code.
 template <typename Pred,
           typename T1,
           typename T2,
           typename T3>
 AssertionResult AssertPred3Helper(const char* pred_text,
                                   const char* e1,
                                   const char* e2,
                                   const char* e3,
                                   Pred pred,
                                   const T1& v1,
                                   const T2& v2,
                                   const T3& v3) {
   if (pred(v1, v2, v3)) return AssertionSuccess();
 
   return AssertionFailure() << pred_text << "("
                             << e1 << ", "
                             << e2 << ", "
                             << e3 << ") evaluates to false, where"
                             << "\n" << e1 << " evaluates to " << v1
                             << "\n" << e2 << " evaluates to " << v2
                             << "\n" << e3 << " evaluates to " << v3;
 }
 

 
 // Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
 // this in your code.
 template <typename Pred,
           typename T1,
           typename T2,
           typename T3,
           typename T4>
 AssertionResult AssertPred4Helper(const char* pred_text,
                                   const char* e1,
                                   const char* e2,
                                   const char* e3,
                                   const char* e4,
                                   Pred pred,
                                   const T1& v1,
                                   const T2& v2,
                                   const T3& v3,
                                   const T4& v4) {
   if (pred(v1, v2, v3, v4)) return AssertionSuccess();
 
   return AssertionFailure() << pred_text << "("
                             << e1 << ", "
                             << e2 << ", "
                             << e3 << ", "
                             << e4 << ") evaluates to false, where"
                             << "\n" << e1 << " evaluates to " << v1
                             << "\n" << e2 << " evaluates to " << v2
                             << "\n" << e3 << " evaluates to " << v3
                             << "\n" << e4 << " evaluates to " << v4;

 // Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
 // this in your code.
 template <typename Pred,
           typename T1,
           typename T2,
           typename T3,
           typename T4,
           typename T5>
 AssertionResult AssertPred5Helper(const char* pred_text,
                                   const char* e1,
                                   const char* e2,
                                   const char* e3,
                                   const char* e4,
                                   const char* e5,
                                   Pred pred,
                                   const T1& v1,
                                   const T2& v2,
                                   const T3& v3,
                                   const T4& v4,
                                   const T5& v5) {
   if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
 
   return AssertionFailure() << pred_text << "("
                             << e1 << ", "
                             << e2 << ", "
                             << e3 << ", "
                             << e4 << ", "
                             << e5 << ") evaluates to false, where"
                             << "\n" << e1 << " evaluates to " << v1
                             << "\n" << e2 << " evaluates to " << v2
                             << "\n" << e3 << " evaluates to " << v3

llvm/utils/unittest/googletest/include/gtest/internal/gtest-internal.h

 //
 // This header file declares functions and macros used internally by
 // Google Test.  They are subject to change without notice.
 
 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
 
 #include "gtest/internal/gtest-port.h"
+#include "gtest/internal/rgt.h"
 
 #if GTEST_OS_LINUX
 # include <stdlib.h>
 # include <sys/types.h>
 # include <sys/wait.h>
 # include <unistd.h>
 #endif  // GTEST_OS_LINUX
 
if (::testing::internal::AlwaysTrue()) { \
     GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
       fail("Expected: " #statement " throws an exception.\n" \
            "  Actual: it doesn't.")
 
 
 // Implements Boolean test assertions such as EXPECT_TRUE. expression can be
 // either a boolean expression or an AssertionResult. text is a textual
 // represenation of expression as it was passed into the EXPECT_TRUE.
+#if 0
 #define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
   if (const ::testing::AssertionResult gtest_ar_ = \
       ::testing::AssertionResult(expression)) \
     ; \
   else \
     fail(::testing::internal::GetBoolAssertionFailureMessage(\
              gtest_ar_, text, #actual, #expected).c_str())
+#else
+#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar_ = \
+      ::testing::AssertionResult(expression)) \
+    { GTEST_RGT_DECLARE } \
+  else \
+    fail(::testing::internal::GetBoolAssertionFailureMessage(\
+             gtest_ar_, text, #actual, #expected).c_str())
+#endif
 
 #define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
   if (::testing::internal::AlwaysTrue()) { \
     ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
     if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
       goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \

llvm/utils/unittest/googletest/include/gtest/internal/rgt.h

+//===- gtest/include/internal/rgt.h - Rotten Green Test helper --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines macros and classes for detecting Rotten Green Tests
+// in the LLVM unittests.
+//
+//===----------------------------------------------------------------------===//
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_RGT_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_RGT_H_
+
+// A Rotten Green Test is one that looks like it is testing some useful
+// assertion about code behavior, but in fact the assertion is never
+// executed.  This file supports instrumenting LLVM unittests to detect
+// EXPECT_* and ASSERT_* calls that are not executed, indicating that
+// they are Rotten Green Tests.
+//
+// Inspired by "Rotten Green Tests", Delplanque et al., ICSE 2019
+// DOI 10.1109/ICSE.2019.00062
+//
+// The implementation depends on having static data allocated and initialized
+// at compile time, in order to identify each test assertion.  Execution of
+// the assertion will record that test as having been executed.  On program
+// exit, we scan the array of static data and report those that have not
+// been executed.
+//
+// We allocate the static data into a custom section that has a name that is
+// a legal C identifier.  This will cause the linker to define symbols for
+// the start and end of the section, if those symbols are referenced.  This
+// allows us to allocate static data piecemeal in the source, and still have
+// effectively a single array of all such data at runtime.
+//
+// This tactic is known to work in GNU linkers and LLD.
+
+// Due to a quirk of data allocation for items in inline functions, gcc
+// won't let us put local static data in a custom section.  We use a hack
+// to imitate runtime initialization of globals; we can't rely on normal
+// initialization of static locals because that requires control to pass
+// over the definition of the static local, which defeats the purpose.
+
+// For MSVC, allocatic static data to a custom section apparently doesn't
+// keep it from being optimized away, and there is no equivalent of the
+// "used" attribute. So we use a gcc-like hack, but instead of .init_array
+// being run automatically on startup, we have to run it manually.
+
+#if defined(__GNUC__) && !defined(__clang__)
+#define GTEST_RGT_RUNTIME_INIT_ARRAY_ 1
+#elif defined(_WIN32)
+#define GTEST_RGT_RUNTIME_INIT_MANUAL_ 1
+#endif
+#define GTEST_RGT_RUNTIME_INIT_ \
+    (GTEST_RGT_RUNTIME_INIT_ARRAY_ || GTEST_RGT_RUNTIME_INIT_MANUAL_)
+
+
+// In cases where a test is known and expected to fail, the client may
+// disable checking for the failing test by doing
+//     #undef  GTEST_RGT_DECLARE
+//     #define GTEST_RGT_DECLARE
+// before the test, and re-enabling it afterward with
+//     #undef  GTEST_RGT_DECLARE
+//     #define GTEST_RGT_DECLARE GTEST_RGT_DECLARE_
+// afterward.
+#define GTEST_RGT_DECLARE GTEST_RGT_DECLARE_
+
+namespace testing {
+namespace internal {
+
+// The data to record per test-assertion site.
+struct RGT_item {
+  const char *file;
+  unsigned line;
+  bool executed;
+};
+
+#if GTEST_RGT_RUNTIME_INIT_
+// Record the existence of a test point, when we can't arrange for that
+// purely with static initialization.
+void RGT_record(RGT_item *item);
+
+#if GTEST_RGT_RUNTIME_INIT_MANUAL_
+// Run all the initializations.
+void RGT_init_manual();
+
+// Provide a global pointer so we can fake-use all the items.
+void *RGT_fake_use = nullptr;
+#endif
+#endif // GTEST_RGT_RUNTIME_INIT_
+
+// Pass nullptr to get the first rotten item; pass the previous return value
+// to get the next item.  Returns nullptr when there are no more.
+// TODO: Is there a reasonable way to achieve this with a range while still
+// hiding the inconvenient platform differences?
+RGT_item *RGT_get_next_rotten_item(RGT_item *item);
+
+// Get the total number of test assertions.
+int RGT_get_item_count();
+
+// For debugging: Report the locations of all test assertions to the
+// specified file.
+void RGT_report_all_assertions_to(std::string &filename);
+} // end namespace internal
+} // end namespace testing
+
+#if GTEST_RGT_RUNTIME_INIT_
+
+// Conjure up a function to do startup-time initialization, given that
+// we can't arrange for static initialization.
+
+#if GTEST_RGT_RUNTIME_INIT_ARRAY_
+
+#define GTEST_RGT_RECORD_ITEM_(ITEM)            \
+  struct __rgt_recorder { \
+    static void record() { testing::internal::RGT_record(&ITEM); }      \
+  }; \
+  __asm__( \
+  ".pushsection .init_array" "\n" \
+  ".quad %c0" "\n" \
+  ".popsection" "\n" \
+  : : "i"(__rgt_recorder::record));
+
+#else
+
+// Windows doesn't automatically provide start/end symbol names, so we roll
+// our own with start/end entries.  The sorting is determined by suffixes on
+// the section name, so we need to paste the base name with another string to
+// get correct sorting.  Extra fun macro indirection required.
+
+#define GTEST_RGT_SECTION_NAME_WITH_SUFFIX_(SUFFIX) GTEST_RGT_SECTION_NAME_2(RGT, SUFFIX)
+#define GTEST_RGT_SECTION_NAME_2(NAME, SUFFIX) GTEST_RGT_SECTION_NAME_3(NAME, SUFFIX)
+#define GTEST_RGT_SECTION_NAME_3(NAME, SUFFIX) GTEST_RGT_SECTION_NAME_4(NAME ## SUFFIX)
+#define GTEST_RGT_SECTION_NAME_4(NAME) #NAME
+
+#define GTEST_RGT_SECTION_NAME_ GTEST_RGT_SECTION_NAME_WITH_SUFFIX_($d)
+
+// MSVC requires the section to be declared before being used, but simply
+// using a global #pragma seems not to work (despite the documentation).
+// And because MSVC has no equivalent of attribute(used) we need to fake
+// up a pointer escaping so it will look used.
+
+typedef void(*RGT_recorder)(void);
+
+#define GTEST_RGT_RECORD_ITEM_(ITEM) \
+  struct __rgt_recorder { \
+    static void record() { testing::internal::RGT_record(&ITEM); }      \
+  }; \
+  __pragma(section(GTEST_RGT_SECTION_NAME_,read,write)) \
+  __declspec(allocate(GTEST_RGT_SECTION_NAME_)) \
+  static RGT_recorder __rgt_record_item = __rgt_recorder::record; \
+  testing::internal::RGT_fake_use = (void*)&__rgt_record_item;
+
+#endif // GTEST_RGT_RUNTIME_INIT_ARRAY_
+
+#define GTEST_RGT_DECLARE_ \
+  static testing::internal::RGT_item \
+      GTEST_RGT_item_ { __FILE__, __LINE__, false }; \
+  GTEST_RGT_item_.executed = true; \
+  GTEST_RGT_RECORD_ITEM_(GTEST_RGT_item_)
+
+#else
+
+// The "normal" case, allocate local static data to a custom section
+// which we can then iterate over at program end.
+// Note, the non-Windows case requires this be a legal C identifier.
+
+#define GTEST_RGT_SECTION_NAME_ RGT
+
+// Now define how to decorate the data declarations.
+#define GTEST_RGT_SECTION_ATTR_3(NAME) __attribute__((section(#NAME),used))
+#define GTEST_RGT_SECTION_ATTR_2(NAME) GTEST_RGT_SECTION_ATTR_3(NAME)
+#define GTEST_RGT_SECTION_ATTR GTEST_RGT_SECTION_ATTR_2(GTEST_RGT_SECTION_NAME_)
+
+
+// Macro to declare one test assertion's data item and initialize it.
+
+#define GTEST_RGT_DECLARE_ \
+  GTEST_RGT_SECTION_ATTR static testing::internal::RGT_item    \
+      GTEST_RGT_item_ { __FILE__, __LINE__, false }; \
+  GTEST_RGT_item_.executed = true;
+
+#endif // GTEST_RGT_RUNTIME_INIT_
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_RGT_H_

llvm/utils/unittest/googletest/src/gtest-all.cc

 // Sometimes it's desirable to build Google Test by compiling a single file.
 // This file serves this purpose.
 
 // This line ensures that gtest.h can be compiled on its own, even
 // when it's fused.
 #include "gtest/gtest.h"
 
 // The following lines pull in the real gtest *.cc files.
 #include "src/gtest.cc"
 #include "src/gtest-death-test.cc"
 #include "src/gtest-filepath.cc"
 #include "src/gtest-port.cc"
 #include "src/gtest-printers.cc"
 #include "src/gtest-test-part.cc"
 #include "src/gtest-typed-test.cc"
+#include "src/rgt.cc"

llvm/utils/unittest/googletest/src/gtest-internal-inl.h

 
 #ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_
 #define GTEST_SRC_GTEST_INTERNAL_INL_H_
 
 // GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is
 // part of Google Test's implementation; otherwise it's undefined.
 #if !GTEST_IMPLEMENTATION_
 // If this file is included from the user's code, just say no.
 # error "gtest-internal-inl.h is part of Google Test's internal implementation."
 # error "It must not be included except by Google Test itself."
 #endif  // GTEST_IMPLEMENTATION_
 
 #ifndef _WIN32_WCE
 # include <errno.h>
 #endif  // !_WIN32_WCE
 #include <stddef.h>
 #include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
 #include <string.h>  // For memmove.

 const char kCatchExceptionsFlag[] = "catch_exceptions";
 const char kColorFlag[] = "color";
 const char kFilterFlag[] = "filter";
 const char kListTestsFlag[] = "list_tests";
 const char kOutputFlag[] = "output";
 const char kPrintTimeFlag[] = "print_time";
 const char kRandomSeedFlag[] = "random_seed";
 const char kRepeatFlag[] = "repeat";
+const char kRGTReportLocation[] = "report_rotten";
+const char kRGTReportAllTo[] = "report_all_assertions_to";
 const char kShuffleFlag[] = "shuffle";
 const char kStackTraceDepthFlag[] = "stack_trace_depth";
 const char kStreamResultToFlag[] = "stream_result_to";
 const char kThrowOnFailureFlag[] = "throw_on_failure";
 const char kFlagfileFlag[] = "flagfile";
 
 // A valid random seed must be in [1, kMaxRandomSeed].
 const int kMaxRandomSeed = 99999;

llvm/utils/unittest/googletest/src/gtest.cc

 
 #if GTEST_USE_OWN_FLAGFILE_FLAG_
 GTEST_DEFINE_string_(
     flagfile,
     internal::StringFromGTestEnv("flagfile", ""),
     "This flag specifies the flagfile to read command-line flags from.");
 #endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
 
+GTEST_DEFINE_bool_(
+    report_rotten,
+    internal::BoolFromGTestEnv("report_rotten", true),
+    "When this flag is specified, the source locations of un-executed "
+    "test assertions will be reported.");
+
+GTEST_DEFINE_string_(
+    report_all_assertions_to,
+    internal::StringFromGTestEnv("report_all_assertions_to", ""),
+    "This flag specifies the file on which to report the source locations "
+    "of all test assertions.");
+
 namespace internal {
 
 // Generates a random number from [0, range), using a Linear
 // Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
 // than kMaxRange.
 UInt32 Random::Generate(UInt32 range) {
   // These constants are the same as are used in glibc's rand(3).
   state_ = (1103515245U*state_ + 12345U) % kMaxRange;
ColoredPrintf(COLOR_YELLOW,
                   num_disabled == 1 ? "TEST" : "TESTS");
   }
   // Ensure that Google Test output is printed before, e.g., heapchecker output.
   fflush(stdout);
 }
 
 // End PrettyUnitTestResultPrinter
 
+// This class implements the TestEventListener interface.
+//
+// Class RGTListener is not copyable.
+class RGTListener : public EmptyTestEventListener {
+ public:
+  RGTListener() {}
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
+};
+
+void RGTListener::OnEnvironmentsSetUpStart(const UnitTest& unit_test) {
+#if GTEST_RGT_RUNTIME_INIT_MANUAL_
+  internal::RGT_init_manual();
+#endif
+}
+void RGTListener::OnEnvironmentsTearDownStart(const UnitTest& unit_test) {
+  // Possibly report all assertion locations.
+  internal::RGT_report_all_assertions_to(GTEST_FLAG(report_all_assertions_to));
+
+  // Report any un-executed test assertions.
+  int rotten_count = 0;
+  // FIXME: Is there a way to do this with a range?
+  internal::RGT_item *item = nullptr;
+  while ((item = internal::RGT_get_next_rotten_item(item))) {
+    // Exclude gtest.cc and gtest-port.cc, which contain assertions in
+    // methods that are rarely used and so show up as rotten.
+    if (String::EndsWithCaseInsensitive(item->file, "gtest.cc") ||
+        String::EndsWithCaseInsensitive(item->file, "gtest-port.cc"))
+      continue;
+    if (GTEST_FLAG(report_rotten)) {
+      ColoredPrintf(COLOR_RED, "Rotten Test Detected");
+      printf(" at %s:%u\n", item->file, item->line);
+    }
+    ++rotten_count;
+  }
+
+  // FIXME: If basically all tests have good reason for un-executed tests,
+  // this should also be under the flag.
+  std::string message = "You have " +
+      FormatCountableNoun(rotten_count, "rotten test assertion",
+                          "rotten test assertions") + " out of " +
+      FormatCountableNoun(internal::RGT_get_item_count(),
+                          "total assertion", "total assertions") + "\n";
+  // Optionally force the test to fail for rotten assertions.
+  if (rotten_count) {
+    if (GTEST_FLAG(report_rotten))
+      internal::ReportFailureInUnknownLocation(TestPartResult::kNonFatalFailure,
+                                               message);
+    else
+      ColoredPrintf(COLOR_YELLOW, message.c_str());
+  } else {
+    ColoredPrintf(COLOR_GREEN, message.c_str());
+  }
+}
+
+// End RGTListener
+
 // class TestEventRepeater
 //
 // This class forwards events to other event listeners.
 class TestEventRepeater : public TestEventListener {
  public:
   TestEventRepeater() : forwarding_enabled_(true) {}
   virtual ~TestEventRepeater();
   void Append(TestEventListener *listener);
void UnitTestImpl::PostFlagParsingInit() {
   if (!post_flag_parse_init_performed_) {
     post_flag_parse_init_performed_ = true;
 
 #if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
     // Register to send notifications about key process state changes.
     listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
 #endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
 
+    // Register the RGT listener.
+    listeners()->Append(new RGTListener);
+
 #if GTEST_HAS_DEATH_TEST
     InitDeathTestSubprocessControlInfo();
     SuppressTestEventsIfInSubprocess();
 #endif  // GTEST_HAS_DEATH_TEST
 
     // Registers parameterized tests. This makes parameterized tests
     // available to the UnitTest reflection API without running
     // RUN_ALL_TESTS.
if (ch == '@') {
       color = COLOR_YELLOW;
     } else {
       --str;
     }
   }
 }
 
 static const char kColorEncodedHelpMessage[] =
 "This program contains tests written using " GTEST_NAME_ ". You can use the\n"
 "following command line flags to control its behavior:\n"
 "\n"
 "Test Selection:\n"
 "  @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n"
 "      List the names of all tests instead of running them. The name of\n"
 "      TEST(Foo, Bar) is \"Foo.Bar\".\n"
 "  @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS"
     "[@G-@YNEGATIVE_PATTERNS]@D\n"
 "      Run only the tests whose name matches one of the positive patterns but\n"
 "      none of the negative patterns. '?' matches any single character; '*'\n"
 "      matches any substring; ':' separates two patterns.\n"
 "  @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n"
 "      Run all disabled tests too.\n"
 "\n"
 "Test Execution:\n"
 "  @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n"
 "      Run the tests repeatedly; use a negative count to repeat forever.\n"
 "  @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n"
 "      Randomize tests' orders on every iteration.\n"
 "  @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n"
 "      Random number seed to use for shuffling test orders (between 1 and\n"
 "      99999, or 0 to use a seed based on the current time).\n"
 "\n"
 "Test Output:\n"
 "  @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
 "      Enable/disable colored output. The default is @Gauto@D.\n"
 "  -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n"
 "      Don't print the elapsed time of each test.\n"
 "  @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G"
     GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n"
 "      Generate an XML report in the given directory or with the given file\n"
 "      name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n"
 #if GTEST_CAN_STREAM_RESULTS_
 "  @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n"
 "      Stream test results to the given server.\n"
 #endif  // GTEST_CAN_STREAM_RESULTS_
+"  @G--" GTEST_FLAG_PREFIX_ "report_rotten@D\n"
+"      Report source location of un-executed test assertions.\n"
 "\n"
 "Assertion Behavior:\n"
 #if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
 "  @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
 "      Set the default death test style.\n"
 #endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
 "  @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n"
 "      Turn assertion failures into debugger break-points.\n"
 "  @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n"
 "      Turn assertion failures into C++ exceptions.\n"
 "  @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n"
 "      Do not report exceptions as test failures. Instead, allow them\n"
 "      to crash the program or throw a pop-up (on Windows).\n"
 "\n"
 "Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set "
     "the corresponding\n"
 "environment variable of a flag (all letters in upper-case). For example, to\n"
 "disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_
     "color=no@D or set\n"
 "the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n"
 "\n"
 "For more information, please read the " GTEST_NAME_ " documentation at\n"
 "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n"
 "(not one in your own code or tests), please report it to\n"
 "@G<" GTEST_DEV_EMAIL_ ">@D.\n";
 
 bool ParseGoogleTestFlag(const char* const arg) {
   return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
                        &GTEST_FLAG(also_run_disabled_tests)) ||
       ParseBoolFlag(arg, kBreakOnFailureFlag,
                     &GTEST_FLAG(break_on_failure)) ||
       ParseBoolFlag(arg, kCatchExceptionsFlag,
                     &GTEST_FLAG(catch_exceptions)) ||
       ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
       ParseStringFlag(arg, kDeathTestStyleFlag,
                       &GTEST_FLAG(death_test_style)) ||
       ParseBoolFlag(arg, kDeathTestUseFork,
                     &GTEST_FLAG(death_test_use_fork)) ||
       ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
       ParseStringFlag(arg, kInternalRunDeathTestFlag,
                       &GTEST_FLAG(internal_run_death_test)) ||
       ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
       ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
       ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
       ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
       ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
+      ParseBoolFlag(arg, kRGTReportLocation,
+                    &GTEST_FLAG(report_rotten)) ||
+      ParseStringFlag(arg, kRGTReportAllTo,
+                      &GTEST_FLAG(report_all_assertions_to)) ||
       ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
       ParseInt32Flag(arg, kStackTraceDepthFlag,
                      &GTEST_FLAG(stack_trace_depth)) ||
       ParseStringFlag(arg, kStreamResultToFlag,
                       &GTEST_FLAG(stream_result_to)) ||
       ParseBoolFlag(arg, kThrowOnFailureFlag,
                     &GTEST_FLAG(throw_on_failure));
 }

llvm/utils/unittest/googletest/src/rgt.cc

+//===- rgt.cc - Rotten Green Test support ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Support for the Rotten Green Test extension to LLVM's copy of the
+// googletest framework.
+
+#include "gtest/internal/rgt.h"
+#include <algorithm>
+#include <cassert>
+#include <map>
+#include <vector>
+
+// When we can't get pure static initialization of the array of items
+// describing test points, they get registered on startup and we keep
+// pointers to the data in this vector.
+
+#if GTEST_RGT_RUNTIME_INIT_
+
+namespace {
+
+using item_vector = std::vector<testing::internal::RGT_item *>;
+class RegisteredItems {
+  static item_vector *items;
+public:
+  RegisteredItems() = default;
+  item_vector *getItems() {
+    if (!items)
+      items = new item_vector;
+    return items;
+  }
+  int size() { return getItems()->size(); }
+  bool empty() { return getItems()->empty(); }
+  auto begin() { return getItems()->begin(); }
+  auto end() { return getItems()->end(); }
+  void push_back(testing::internal::RGT_item *item) {
+    getItems()->push_back(item);
+  }
+};
+
+RegisteredItems registered_items;
+item_vector *RegisteredItems::items = nullptr;
+
+} // end anonymous namespace
+
+void testing::internal::RGT_record(testing::internal::RGT_item *item) {
+  registered_items.push_back(item);
+}
+
+#if GTEST_RGT_RUNTIME_INIT_MANUAL_
+// On Windows we have to allocate our own placeholder start/stop data items.
+// The linker will sort these into the right order relative to real data.
+// Because the section concatenation might be padded, we'll have to skip over
+// any items with a null file pointer, so make the first item look like it's
+// padding.
+
+#define START_SECTION_NAME GTEST_RGT_SECTION_NAME_WITH_SUFFIX_($a)
+#define STOP_SECTION_NAME GTEST_RGT_SECTION_NAME_WITH_SUFFIX_($z)
+
+#pragma section (START_SECTION_NAME,read,write)
+__declspec(allocate(START_SECTION_NAME))
+RGT_recorder RGT_manual_init_start = (RGT_recorder)1;
+
+#pragma section (STOP_SECTION_NAME,read,write)
+__declspec(allocate(STOP_SECTION_NAME))
+RGT_recorder RGT_manual_init_stop = (RGT_recorder)1;
+
+void testing::internal::RGT_init_manual() {
+  const RGT_recorder *F = &RGT_manual_init_start;
+  int call_count = 0;
+  int null_count = 0;
+  for (++F; F < &RGT_manual_init_stop; ++F) {
+    if (*F) {
+      ++call_count;
+      (*F)();
+    } else {
+      ++null_count;
+    }
+  }
+  printf("RGT_init_manual: %d called, %d null\n", call_count, null_count);
+}
+
+#endif // GTEST_RGT_RUNTIME_INIT_MANUAL_
+#endif // GTEST_RGT_RUNTIME_INIT_
+
+// In order to deduplicate information due to template instantiations,
+// we combine all raw reports for the same source location.  Then for
+// nicer reporting, we generate a vector such that all reports for a
+// given file are sorted by line number.
+//
+// The runtime initialization tactic can result in the same item being
+// registered multiple times; the deduplication automatically handles
+// that as well.
+
+namespace testing {
+namespace internal {
+
+bool operator<(const RGT_item &a, const RGT_item &b) {
+  assert(a.file == b.file);
+  return a.line < b.line;
+}
+
+} // end namespace internal
+} // end namespace testing
+
+#if !GTEST_RGT_RUNTIME_INIT_
+// Non-Windows linkers provide __start_<section> and __stop_<section> symbols.
+// Declare these outside of all namespaces.
+#define GEN_NAME2(prefix, section) prefix ## section
+#define GEN_NAME(prefix, section) GEN_NAME2(prefix, section)
+#define START_NAME GEN_NAME(__start_, GTEST_RGT_SECTION_NAME_)
+#define STOP_NAME GEN_NAME(__stop_, GTEST_RGT_SECTION_NAME_)
+
+// extern "C" vars can't have qualified type names; we only care about
+// the addresses, we'll do appropriate casts later.
+extern "C" int START_NAME;
+extern "C" int STOP_NAME;
+#endif // !GTEST_RGT_RUNTIME_INIT_
+
+namespace {
+
+std::vector<testing::internal::RGT_item> RGT_collated_data;
+
+void collate_data() {
+  if (!RGT_collated_data.empty())
+    return;
+
+  // Collect raw data into a map with filename as the key; the value is
+  // another map with line number as the key and "executed" as the value.
+  // This collection deduplicates entries, and markes a line as executed
+  // if any of the (possibly duplicate) entries was marked executed.
+  // We sort the data by filename, because we run in various environments
+  // and sorting the output makes the data easier to compare.
+  struct test_info_compare {
+    bool operator()(const char *lhs, const char *rhs) const {
+      return strcmp(lhs, rhs) < 0;
+    }
+  };
+  using file_info = std::map<unsigned, bool>;
+  using test_info = std::map<const char*, file_info, test_info_compare>;
+
+  test_info test_map;
+  testing::internal::RGT_item *item;
+#if GTEST_RGT_RUNTIME_INIT_
+  item_vector::iterator I = registered_items.begin();
+  item_vector::iterator E = registered_items.end();
+#define GET_ITEM item = *I
+#else
+  testing::internal::RGT_item *I = (testing::internal::RGT_item *)&START_NAME;
+  testing::internal::RGT_item *E = (testing::internal::RGT_item *)&STOP_NAME;
+#define GET_ITEM item = I
+#endif
+
+  // This assumes all pointers to the same filename string are equal.
+  for (; I != E; ++I) {
+    GET_ITEM;
+    file_info &fileinfo = test_map[item->file];
+    bool &was_executed = fileinfo[item->line];
+    if (item->executed)
+      was_executed = true;
+  }
+
+
+  // Serialize the collated data into a vector where the data for a given
+  // file is all in adjacent entries, and sorted by line.
+  for (auto &M : test_map) {
+    const char *file = M.first;
+    // As we're adding elements to the vector, we can't preserve iterators.
+    std::size_t file_start = RGT_collated_data.size();
+    for (auto &I : M.second)
+      RGT_collated_data.push_back({file, I.first, I.second});
+    std::sort(RGT_collated_data.begin() + file_start, RGT_collated_data.end());
+  }
+}
+
+} // end anonymous namespace
+
+int testing::internal::RGT_get_item_count() {
+  collate_data();
+  return RGT_collated_data.size();
+}
+
+// Iterator-like function to find un-executed test points.
+
+testing::internal::RGT_item *
+testing::internal::RGT_get_next_rotten_item(testing::internal::RGT_item *item) {
+  collate_data();
+
+  if (item)
+    ++item;
+  else
+    item = &*RGT_collated_data.begin();
+  for (; item != &*RGT_collated_data.end(); ++item) {
+    if (!item->executed)
+      return item;
+  }
+
+  return nullptr;
+}
+
+// Report source location of all identified assertions.  For debugging.
+// We emit one per line to simplify diffing.
+
+void testing::internal::RGT_report_all_assertions_to(std::string &filename) {
+  if (filename.empty())
+    return;
+
+  // Following is based on UnitTestOptions::GetAbsolutePathToOutputFile()
+  // which has a note regarding certain Windows paths not working.
+  internal::FilePath log_path(filename);
+  if (!log_path.IsAbsolutePath()) {
+    log_path = internal::FilePath::ConcatPaths(
+        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(filename));
+  }
+
+  if (log_path.IsDirectory()) {
+    fprintf(stderr, "Specified log file is a directory \"%s\"\n",
+            filename.c_str());
+    return;
+  }
+  FILE* logfile = posix::FOpen(log_path.c_str(), "w");
+  if (!logfile) {
+    fprintf(stderr, "Unable to open log file \"%s\"\n", log_path.c_str());
+    return;
+  }
+
+  collate_data();
+  for (auto &item : RGT_collated_data)
+    fprintf(logfile, "%s::%u\n", item.file, item.line);
+  posix::FClose(logfile);
+}