[libc][NFC] Make test macros callable from helper methods of test classes.

[sivachandra]

Summary

This is acheived by making the RunContext a state variable of the test
classes.

[sivachandra]

This helps us setup math tests for float, double and long double flavors of a functions without a lot of duplicated logic. See the tests of remquo, remquof and remquol for examples. In contrast, I used this change to set up tests for ilogb, ilogbf and ilogbl without any duplicated logic: https://reviews.llvm.org/D90806.

libc/utils/UnitTest/Test.h

enum TestCondition {
   Cond_LE,
   Cond_GT,
   Cond_GE,
 };
 
 namespace internal {
 
 template <typename ValType>
-bool test(RunContext &Ctx, TestCondition Cond, ValType LHS, ValType RHS,
+bool test(RunContext *Ctx, TestCondition Cond, ValType LHS, ValType RHS,
           const char *LHSStr, const char *RHSStr, const char *File,
           unsigned long Line);
 
 } // namespace internal
 
 struct MatcherBase {
   virtual ~MatcherBase() {}
   virtual void explainError(testutils::StreamWrapper &OS) {
     OS << "unknown error\n";
   }
 };
 
 template <typename T> struct Matcher : public MatcherBase { bool match(T &t); };
 
 // NOTE: One should not create instances and call methods on them directly. One
 // should use the macros TEST or TEST_F to write test cases.
 class Test {
 private:
   Test *Next = nullptr;
+  RunContext *Ctx = nullptr;
+
+  void setContext(RunContext *C) { Ctx = C; }
 
 public:
   virtual ~Test() {}
   virtual void SetUp() {}
   virtual void TearDown() {}
 
   static int runTests();
 
 protected:
   static void addTest(Test *T);
 
   // We make use of a template function, with |LHS| and |RHS| as explicit
   // parameters, for enhanced type checking. Other gtest like unittest
   // frameworks have a similar function which takes a boolean argument
   // instead of the explicit |LHS| and |RHS| arguments. This boolean argument
   // is the result of the |Cond| operation on |LHS| and |RHS|. Though not bad,
   // |Cond| on mismatched |LHS| and |RHS| types can potentially succeed because
   // of type promotion.
   template <typename ValType,
             cpp::EnableIfType<cpp::IsIntegral<ValType>::Value, int> = 0>
-  static bool test(RunContext &Ctx, TestCondition Cond, ValType LHS,
-                   ValType RHS, const char *LHSStr, const char *RHSStr,
-                   const char *File, unsigned long Line) {
+  bool test(TestCondition Cond, ValType LHS, ValType RHS, const char *LHSStr,
+            const char *RHSStr, const char *File, unsigned long Line) {
     return internal::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
   }
 
   template <
       typename ValType,
       cpp::EnableIfType<cpp::IsPointerType<ValType>::Value, ValType> = nullptr>
-  static bool test(RunContext &Ctx, TestCondition Cond, ValType LHS,
-                   ValType RHS, const char *LHSStr, const char *RHSStr,
-                   const char *File, unsigned long Line) {
+  bool test(TestCondition Cond, ValType LHS, ValType RHS, const char *LHSStr,
+            const char *RHSStr, const char *File, unsigned long Line) {
     return internal::test(Ctx, Cond, (unsigned long long)LHS,
                           (unsigned long long)RHS, LHSStr, RHSStr, File, Line);
   }
 
-  static bool testStrEq(RunContext &Ctx, const char *LHS, const char *RHS,
-                        const char *LHSStr, const char *RHSStr,
-                        const char *File, unsigned long Line);
+  bool testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
+                 const char *RHSStr, const char *File, unsigned long Line);
 
-  static bool testStrNe(RunContext &Ctx, const char *LHS, const char *RHS,
-                        const char *LHSStr, const char *RHSStr,
-                        const char *File, unsigned long Line);
+  bool testStrNe(const char *LHS, const char *RHS, const char *LHSStr,
+                 const char *RHSStr, const char *File, unsigned long Line);
 
-  static bool testMatch(RunContext &Ctx, bool MatchResult, MatcherBase &Matcher,
+  bool testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
+                 const char *RHSStr, const char *File, unsigned long Line);
+
+  bool testProcessExits(testutils::FunctionCaller *Func, int ExitCode,
                         const char *LHSStr, const char *RHSStr,
                         const char *File, unsigned long Line);
 
-  static bool testProcessExits(RunContext &Ctx, testutils::FunctionCaller *Func,
-                               int ExitCode, const char *LHSStr,
-                               const char *RHSStr, const char *File,
-                               unsigned long Line);
-
-  static bool testProcessKilled(RunContext &Ctx,
-                                testutils::FunctionCaller *Func, int Signal,
-                                const char *LHSStr, const char *RHSStr,
-                                const char *File, unsigned long Line);
+  bool testProcessKilled(testutils::FunctionCaller *Func, int Signal,
 
   template <typename Func> testutils::FunctionCaller *createCallable(Func f) {
     struct Callable : public testutils::FunctionCaller {
       Func f;
       Callable(Func f) : f(f) {}
       void operator()() override { f(); }
     };
 
     return new Callable(f);
   }
 
 private:
-  virtual void Run(RunContext &Ctx) = 0;
+  virtual void Run() = 0;
   virtual const char *getName() const = 0;
 
   static Test *Start;
   static Test *End;
 };
 
 } // namespace testing
 } // namespace __llvm_libc
 
 #define TEST(SuiteName, TestName)                                              \
   class SuiteName##_##TestName : public __llvm_libc::testing::Test {           \
   public:                                                                      \
     SuiteName##_##TestName() { addTest(this); }                                \
-    void Run(__llvm_libc::testing::RunContext &) override;                     \
+    void Run() override;                                                       \
     const char *getName() const override { return #SuiteName "." #TestName; }  \
   };                                                                           \
   SuiteName##_##TestName SuiteName##_##TestName##_Instance;                    \
-  void SuiteName##_##TestName::Run(__llvm_libc::testing::RunContext &Ctx)
+  void SuiteName##_##TestName::Run()
 
 #define TEST_F(SuiteClass, TestName)                                           \
   class SuiteClass##_##TestName : public SuiteClass {                          \
   public:                                                                      \
     SuiteClass##_##TestName() { addTest(this); }                               \
-    void Run(__llvm_libc::testing::RunContext &) override;                     \
+    void Run() override;                                                       \
     const char *getName() const override { return #SuiteClass "." #TestName; } \
   };                                                                           \
   SuiteClass##_##TestName SuiteClass##_##TestName##_Instance;                  \
-  void SuiteClass##_##TestName::Run(__llvm_libc::testing::RunContext &Ctx)
+  void SuiteClass##_##TestName::Run()
 
 #define EXPECT_EQ(LHS, RHS)                                                    \
-  __llvm_libc::testing::Test::test(Ctx, __llvm_libc::testing::Cond_EQ, (LHS),  \
-                                   (RHS), #LHS, #RHS, __FILE__, __LINE__)
+  this->test(__llvm_libc::testing::Cond_EQ, (LHS), (RHS), #LHS, #RHS,          \
+             __FILE__, __LINE__)
 #define ASSERT_EQ(LHS, RHS)                                                    \
   if (!EXPECT_EQ(LHS, RHS))                                                    \
   return
 
 #define EXPECT_NE(LHS, RHS)                                                    \
-  __llvm_libc::testing::Test::test(Ctx, __llvm_libc::testing::Cond_NE, (LHS),  \
-                                   (RHS), #LHS, #RHS, __FILE__, __LINE__)
+  this->test(__llvm_libc::testing::Cond_NE, (LHS), (RHS), #LHS, #RHS,          \
+             __FILE__, __LINE__)
 #define ASSERT_NE(LHS, RHS)                                                    \
   if (!EXPECT_NE(LHS, RHS))                                                    \
   return
 
 #define EXPECT_LT(LHS, RHS)                                                    \
-  __llvm_libc::testing::Test::test(Ctx, __llvm_libc::testing::Cond_LT, (LHS),  \
-                                   (RHS), #LHS, #RHS, __FILE__, __LINE__)
+  this->test(__llvm_libc::testing::Cond_LT, (LHS), (RHS), #LHS, #RHS,          \
+             __FILE__, __LINE__)
 #define ASSERT_LT(LHS, RHS)                                                    \
   if (!EXPECT_LT(LHS, RHS))                                                    \
   return
 
 #define EXPECT_LE(LHS, RHS)                                                    \
-  __llvm_libc::testing::Test::test(Ctx, __llvm_libc::testing::Cond_LE, (LHS),  \
-                                   (RHS), #LHS, #RHS, __FILE__, __LINE__)
+  this->test(__llvm_libc::testing::Cond_LE, (LHS), (RHS), #LHS, #RHS,          \
+             __FILE__, __LINE__)
 #define ASSERT_LE(LHS, RHS)                                                    \
   if (!EXPECT_LE(LHS, RHS))                                                    \
   return
 
 #define EXPECT_GT(LHS, RHS)                                                    \
-  __llvm_libc::testing::Test::test(Ctx, __llvm_libc::testing::Cond_GT, (LHS),  \
-                                   (RHS), #LHS, #RHS, __FILE__, __LINE__)
+  this->test(__llvm_libc::testing::Cond_GT, (LHS), (RHS), #LHS, #RHS,          \
+             __FILE__, __LINE__)
 #define ASSERT_GT(LHS, RHS)                                                    \
   if (!EXPECT_GT(LHS, RHS))                                                    \
   return
 
 #define EXPECT_GE(LHS, RHS)                                                    \
-  __llvm_libc::testing::Test::test(Ctx, __llvm_libc::testing::Cond_GE, (LHS),  \
-                                   (RHS), #LHS, #RHS, __FILE__, __LINE__)
+  this->test(__llvm_libc::testing::Cond_GE, (LHS), (RHS), #LHS, #RHS,          \
+             __FILE__, __LINE__)
 #define ASSERT_GE(LHS, RHS)                                                    \
   if (!EXPECT_GE(LHS, RHS))                                                    \
   return
 
 #define EXPECT_STREQ(LHS, RHS)                                                 \
-  __llvm_libc::testing::Test::testStrEq(Ctx, (LHS), (RHS), #LHS, #RHS,         \
-                                        __FILE__, __LINE__)
+  this->testStrEq((LHS), (RHS), #LHS, #RHS, __FILE__, __LINE__)
 #define ASSERT_STREQ(LHS, RHS)                                                 \
   if (!EXPECT_STREQ(LHS, RHS))                                                 \
   return
 
 #define EXPECT_STRNE(LHS, RHS)                                                 \
-  __llvm_libc::testing::Test::testStrNe(Ctx, (LHS), (RHS), #LHS, #RHS,         \
-                                        __FILE__, __LINE__)
+  this->testStrNe((LHS), (RHS), #LHS, #RHS, __FILE__, __LINE__)
 #define ASSERT_STRNE(LHS, RHS)                                                 \
   if (!EXPECT_STRNE(LHS, RHS))                                                 \
   return
 
 #define EXPECT_TRUE(VAL) EXPECT_EQ((VAL), true)
 
 #define ASSERT_TRUE(VAL)                                                       \
   if (!EXPECT_TRUE(VAL))                                                       \
   return
 
 #define EXPECT_FALSE(VAL) EXPECT_EQ((VAL), false)
 
 #define ASSERT_FALSE(VAL)                                                      \
   if (!EXPECT_FALSE(VAL))                                                      \
   return
 
 #define EXPECT_EXITS(FUNC, EXIT)                                               \
-  __llvm_libc::testing::Test::testProcessExits(                                \
-      Ctx, __llvm_libc::testing::Test::createCallable(FUNC), EXIT, #FUNC,      \
-      #EXIT, __FILE__, __LINE__)
+  this->testProcessExits(__llvm_libc::testing::Test::createCallable(FUNC),     \
+                         EXIT, #FUNC, #EXIT, __FILE__, __LINE__)
 
 #define ASSERT_EXITS(FUNC, EXIT)                                               \
   if (!EXPECT_EXITS(FUNC, EXIT))                                               \
   return
 
 #define EXPECT_DEATH(FUNC, SIG)                                                \
-  __llvm_libc::testing::Test::testProcessKilled(                               \
-      Ctx, __llvm_libc::testing::Test::createCallable(FUNC), SIG, #FUNC, #SIG, \
-      __FILE__, __LINE__)
+  this->testProcessKilled(__llvm_libc::testing::Test::createCallable(FUNC),    \
+                          SIG, #FUNC, #SIG, __FILE__, __LINE__)
 
 #define ASSERT_DEATH(FUNC, EXIT)                                               \
   if (!EXPECT_DEATH(FUNC, EXIT))                                               \
   return
 
 #define __CAT1(a, b) a##b
 #define __CAT(a, b) __CAT1(a, b)
 #define UNIQUE_VAR(prefix) __CAT(prefix, __LINE__)
 
 #define EXPECT_THAT(MATCH, MATCHER)                                            \
   do {                                                                         \
     auto UNIQUE_VAR(__matcher) = (MATCHER);                                    \
-    __llvm_libc::testing::Test::testMatch(                                     \
-        Ctx, UNIQUE_VAR(__matcher).match((MATCH)), UNIQUE_VAR(__matcher),      \
-        #MATCH, #MATCHER, __FILE__, __LINE__);                                 \
+    this->testMatch(UNIQUE_VAR(__matcher).match((MATCH)),                      \
+                    UNIQUE_VAR(__matcher), #MATCH, #MATCHER, __FILE__,         \
+                    __LINE__);                                                 \
   } while (0)
 
 #define ASSERT_THAT(MATCH, MATCHER)                                            \
   do {                                                                         \
     auto UNIQUE_VAR(__matcher) = (MATCHER);                                    \
-    if (!__llvm_libc::testing::Test::testMatch(                                \
-            Ctx, UNIQUE_VAR(__matcher).match((MATCH)), UNIQUE_VAR(__matcher),  \
-            #MATCH, #MATCHER, __FILE__, __LINE__))                             \
+    if (!this->testMatch(UNIQUE_VAR(__matcher).match((MATCH)),                 \
+                         UNIQUE_VAR(__matcher), #MATCH, #MATCHER, __FILE__,    \
+                         __LINE__))                                            \
       return;                                                                  \
   } while (0)
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_H

libc/utils/UnitTest/Test.cpp

void explainDifference(ValType LHS, ValType RHS, const char *LHSStr,
   llvm::outs() << File << ":" << Line << ": FAILURE\n"
                << Offset << "Expected: " << LHSStr << '\n'
                << Offset << "Which is: " << describeValue(LHS) << '\n'
                << "To be " << OpString << ": " << RHSStr << '\n'
                << Offset << "Which is: " << describeValue(RHS) << '\n';
 }
 
 template <typename ValType>
-bool test(RunContext &Ctx, TestCondition Cond, ValType LHS, ValType RHS,
+bool test(RunContext *Ctx, TestCondition Cond, ValType LHS, ValType RHS,
           const char *LHSStr, const char *RHSStr, const char *File,
           unsigned long Line) {
   auto ExplainDifference = [=](llvm::StringRef OpString) {
     explainDifference(LHS, RHS, LHSStr, RHSStr, File, Line, OpString);
   };
 
   switch (Cond) {
   case Cond_EQ:
     if (LHS == RHS)
       return true;
 
-    Ctx.markFail();
+    Ctx->markFail();
     ExplainDifference("equal to");
     return false;
   case Cond_NE:
     if (LHS != RHS)
       return true;
 
-    Ctx.markFail();
+    Ctx->markFail();
     ExplainDifference("not equal to");
     return false;
   case Cond_LT:
     if (LHS < RHS)
       return true;
 
-    Ctx.markFail();
+    Ctx->markFail();
     ExplainDifference("less than");
     return false;
   case Cond_LE:
     if (LHS <= RHS)
       return true;
 
-    Ctx.markFail();
+    Ctx->markFail();
     ExplainDifference("less than or equal to");
     return false;
   case Cond_GT:
     if (LHS > RHS)
       return true;
 
-    Ctx.markFail();
+    Ctx->markFail();
     ExplainDifference("greater than");
     return false;
   case Cond_GE:
     if (LHS >= RHS)
       return true;
 
-    Ctx.markFail();
+    Ctx->markFail();
     ExplainDifference("greater than or equal to");
     return false;
   default:
-    Ctx.markFail();
+    Ctx->markFail();
     llvm::outs() << "Unexpected test condition.\n";
     return false;
   }
 }
 
 } // namespace internal
 
 Test *Test::Start = nullptr;
int Test::runTests() {
   for (Test *T = Start; T != nullptr; T = T->Next, ++TestCount) {
     const char *TestName = T->getName();
     constexpr auto GREEN = llvm::raw_ostream::GREEN;
     constexpr auto RED = llvm::raw_ostream::RED;
     constexpr auto RESET = llvm::raw_ostream::RESET;
     llvm::outs() << GREEN << "[ RUN      ] " << RESET << TestName << '\n';
     RunContext Ctx;
     T->SetUp();
-    T->Run(Ctx);
+    T->setContext(&Ctx);
+    T->Run();
     T->TearDown();
     auto Result = Ctx.status();
     switch (Result) {
     case RunContext::Result_Fail:
       llvm::outs() << RED << "[  FAILED  ] " << RESET << TestName << '\n';
       ++FailCount;
       break;
     case RunContext::Result_Pass:
       llvm::outs() << GREEN << "[       OK ] " << RESET << TestName << '\n';
       break;
     }
   }
 
   llvm::outs() << "Ran " << TestCount << " tests. "
                << " PASS: " << TestCount - FailCount << ' '
                << " FAIL: " << FailCount << '\n';
 
   return FailCount > 0 ? 1 : 0;
 }
 
-template bool Test::test<char, 0>(RunContext &Ctx, TestCondition Cond, char LHS,
-                                  char RHS, const char *LHSStr,
-                                  const char *RHSStr, const char *File,
-                                  unsigned long Line);
-
-template bool Test::test<short, 0>(RunContext &Ctx, TestCondition Cond,
-                                   short LHS, short RHS, const char *LHSStr,
-                                   const char *RHSStr, const char *File,
-                                   unsigned long Line);
+template bool Test::test<char, 0>(TestCondition Cond, char LHS, char RHS,
+                                  const char *LHSStr, const char *RHSStr,
+                                  const char *File, unsigned long Line);
 
-template bool Test::test<int, 0>(RunContext &Ctx, TestCondition Cond, int LHS,
-                                 int RHS, const char *LHSStr,
-                                 const char *RHSStr, const char *File,
-                                 unsigned long Line);
+template bool Test::test<short, 0>(TestCondition Cond, short LHS, short RHS,
+                                   const char *LHSStr, const char *RHSStr,
+                                   const char *File, unsigned long Line);
 
-template bool Test::test<long, 0>(RunContext &Ctx, TestCondition Cond, long LHS,
-                                  long RHS, const char *LHSStr,
-                                  const char *RHSStr, const char *File,
-                                  unsigned long Line);
+template bool Test::test<int, 0>(TestCondition Cond, int LHS, int RHS,
+                                 const char *LHSStr, const char *RHSStr,
+                                 const char *File, unsigned long Line);
 
-template bool Test::test<long long, 0>(RunContext &Ctx, TestCondition Cond,
-                                       long long LHS, long long RHS,
-                                       const char *LHSStr, const char *RHSStr,
-                                       const char *File, unsigned long Line);
+template bool Test::test<long, 0>(TestCondition Cond, long LHS, long RHS,
 
-template bool Test::test<unsigned char, 0>(RunContext &Ctx, TestCondition Cond,
+template bool Test::test<long long, 0>(TestCondition Cond, long long LHS,
+                                       long long RHS, const char *LHSStr,
+                                       const char *RHSStr, const char *File,
+                                       unsigned long Line);
+
+template bool Test::test<unsigned char, 0>(TestCondition Cond,
                                            unsigned char LHS, unsigned char RHS,
                                            const char *LHSStr,
                                            const char *RHSStr, const char *File,
                                            unsigned long Line);
 
 template bool
-Test::test<unsigned short, 0>(RunContext &Ctx, TestCondition Cond,
-                              unsigned short LHS, unsigned short RHS,
-                              const char *LHSStr, const char *RHSStr,
-                              const char *File, unsigned long Line);
+Test::test<unsigned short, 0>(TestCondition Cond, unsigned short LHS,
+                              unsigned short RHS, const char *LHSStr,
+                              const char *RHSStr, const char *File,
+                              unsigned long Line);
 
-template bool Test::test<unsigned int, 0>(RunContext &Ctx, TestCondition Cond,
-                                          unsigned int LHS, unsigned int RHS,
-                                          const char *LHSStr,
+template bool Test::test<unsigned int, 0>(TestCondition Cond, unsigned int LHS,
+                                          unsigned int RHS, const char *LHSStr,
                                           const char *RHSStr, const char *File,
                                           unsigned long Line);
 
-template bool Test::test<unsigned long, 0>(RunContext &Ctx, TestCondition Cond,
+template bool Test::test<unsigned long, 0>(TestCondition Cond,
                                            unsigned long LHS, unsigned long RHS,
                                            const char *LHSStr,
                                            const char *RHSStr, const char *File,
                                            unsigned long Line);
 
-template bool Test::test<bool, 0>(RunContext &Ctx, TestCondition Cond, bool LHS,
-                                  bool RHS, const char *LHSStr,
+template bool Test::test<bool, 0>(TestCondition Cond, bool LHS, bool RHS,
+                                  const char *LHSStr, const char *RHSStr,
+                                  const char *File, unsigned long Line);
+
+template bool
+Test::test<unsigned long long, 0>(TestCondition Cond, unsigned long long LHS,
+                                  unsigned long long RHS, const char *LHSStr,
                                   const char *RHSStr, const char *File,
                                   unsigned long Line);
 
-template bool Test::test<unsigned long long, 0>(
-    RunContext &Ctx, TestCondition Cond, unsigned long long LHS,
-    unsigned long long RHS, const char *LHSStr, const char *RHSStr,
-    const char *File, unsigned long Line);
-
-template bool Test::test<__uint128_t, 0>(RunContext &Ctx, TestCondition Cond,
-                                         __uint128_t LHS, __uint128_t RHS,
-                                         const char *LHSStr, const char *RHSStr,
-                                         const char *File, unsigned long Line);
+template bool Test::test<__uint128_t, 0>(TestCondition Cond, __uint128_t LHS,
+                                         __uint128_t RHS, const char *LHSStr,
+                                         const char *RHSStr, const char *File,
+                                         unsigned long Line);
 
-bool Test::testStrEq(RunContext &Ctx, const char *LHS, const char *RHS,
-                     const char *LHSStr, const char *RHSStr, const char *File,
-                     unsigned long Line) {
+bool Test::testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
+                     const char *RHSStr, const char *File, unsigned long Line) {
   return internal::test(Ctx, Cond_EQ, llvm::StringRef(LHS),
                         llvm::StringRef(RHS), LHSStr, RHSStr, File, Line);
 }
 
-bool Test::testStrNe(RunContext &Ctx, const char *LHS, const char *RHS,
-                     const char *LHSStr, const char *RHSStr, const char *File,
-                     unsigned long Line) {
+bool Test::testStrNe(const char *LHS, const char *RHS, const char *LHSStr,
+                     const char *RHSStr, const char *File, unsigned long Line) {
   return internal::test(Ctx, Cond_NE, llvm::StringRef(LHS),
                         llvm::StringRef(RHS), LHSStr, RHSStr, File, Line);
 }
 
-bool Test::testMatch(RunContext &Ctx, bool MatchResult, MatcherBase &Matcher,
-                     const char *LHSStr, const char *RHSStr, const char *File,
-                     unsigned long Line) {
+bool Test::testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
+                     const char *RHSStr, const char *File, unsigned long Line) {
   if (MatchResult)
     return true;
 
-  Ctx.markFail();
+  Ctx->markFail();
   llvm::outs() << File << ":" << Line << ": FAILURE\n"
                << "Failed to match " << LHSStr << " against " << RHSStr
                << ".\n";
   testutils::StreamWrapper OutsWrapper = testutils::outs();
   Matcher.explainError(OutsWrapper);
   return false;
 }
 
-bool Test::testProcessKilled(RunContext &Ctx, testutils::FunctionCaller *Func,
-                             int Signal, const char *LHSStr, const char *RHSStr,
+bool Test::testProcessKilled(testutils::FunctionCaller *Func, int Signal,
+                             const char *LHSStr, const char *RHSStr,
                              const char *File, unsigned long Line) {
   testutils::ProcessStatus Result = testutils::invokeInSubprocess(Func, 500);
 
   if (const char *error = Result.getError()) {
-    Ctx.markFail();
+    Ctx->markFail();
     llvm::outs() << File << ":" << Line << ": FAILURE\n" << error << '\n';
     return false;
   }
 
   if (Result.timedOut()) {
-    Ctx.markFail();
+    Ctx->markFail();
     llvm::outs() << File << ":" << Line << ": FAILURE\n"
                  << "Process timed out after " << 500 << " milliseconds.\n";
     return false;
   }
 
   if (Result.exitedNormally()) {
-    Ctx.markFail();
+    Ctx->markFail();
     llvm::outs() << File << ":" << Line << ": FAILURE\n"
                  << "Expected " << LHSStr
                  << " to be killed by a signal\nBut it exited normally!\n";
     return false;
   }
 
   int KilledBy = Result.getFatalSignal();
   assert(KilledBy != 0 && "Not killed by any signal");
   if (Signal == -1 || KilledBy == Signal)
     return true;
 
   using testutils::signalAsString;
-  Ctx.markFail();
+  Ctx->markFail();
   llvm::outs() << File << ":" << Line << ": FAILURE\n"
                << "              Expected: " << LHSStr << '\n'
                << "To be killed by signal: " << Signal << '\n'
                << "              Which is: " << signalAsString(Signal) << '\n'
                << "  But it was killed by: " << KilledBy << '\n'
                << "              Which is: " << signalAsString(KilledBy)
                << '\n';
   return false;
 }
 
-bool Test::testProcessExits(RunContext &Ctx, testutils::FunctionCaller *Func,
-                            int ExitCode, const char *LHSStr,
-                            const char *RHSStr, const char *File,
-                            unsigned long Line) {
+bool Test::testProcessExits(testutils::FunctionCaller *Func, int ExitCode,
+                            const char *LHSStr, const char *RHSStr,
+                            const char *File, unsigned long Line) {
   testutils::ProcessStatus Result = testutils::invokeInSubprocess(Func, 500);
 
   if (const char *error = Result.getError()) {
-    Ctx.markFail();
+    Ctx->markFail();
     llvm::outs() << File << ":" << Line << ": FAILURE\n" << error << '\n';
     return false;
   }
 
   if (Result.timedOut()) {
-    Ctx.markFail();
+    Ctx->markFail();
     llvm::outs() << File << ":" << Line << ": FAILURE\n"
                  << "Process timed out after " << 500 << " milliseconds.\n";
     return false;
   }
 
   if (!Result.exitedNormally()) {
-    Ctx.markFail();
+    Ctx->markFail();
     llvm::outs() << File << ":" << Line << ": FAILURE\n"
                  << "Expected " << LHSStr << '\n'
                  << "to exit with exit code " << ExitCode << '\n'
                  << "But it exited abnormally!\n";
     return false;
   }
 
   int ActualExit = Result.getExitCode();
   if (ActualExit == ExitCode)
     return true;
 
-  Ctx.markFail();
+  Ctx->markFail();
   llvm::outs() << File << ":" << Line << ": FAILURE\n"
                << "Expected exit code of: " << LHSStr << '\n'
                << "             Which is: " << ActualExit << '\n'
                << "       To be equal to: " << RHSStr << '\n'
                << "             Which is: " << ExitCode << '\n';
   return false;
 }
 
 } // namespace testing
 } // namespace __llvm_libc
 
 int main() { return __llvm_libc::testing::Test::runTests(); }