[libc][NFC] Introduce a Location object for consistent failure logging

[gchatelet]

Summary

This is just an implementation detail.

libc/src/__support/CPP/type_traits.h

#endif
       unsigned int, long, unsigned long, long long, unsigned long long, bool>();
 };
 template <typename T>
 inline constexpr bool is_integral_v = is_integral<T>::value;
 
 template <typename T> struct is_enum {
   static constexpr bool value = __is_enum(T);
 };
+template <typename T> inline constexpr bool is_enum_v = is_enum<T>::value;
 
 template <typename T> struct is_pointer : cpp::false_type {};
 template <typename T> struct is_pointer<T *> : cpp::true_type {};
 template <typename T> struct is_pointer<T *const> : cpp::true_type {};
 template <typename T> struct is_pointer<T *volatile> : cpp::true_type {};
 template <typename T> struct is_pointer<T *const volatile> : cpp::true_type {};
 template <typename T> inline constexpr bool is_pointer_v = is_pointer<T>::value;
 

libc/test/UnitTest/LibcDeathTestExecutors.cpp

 
 #include <cassert>
 
 namespace __llvm_libc {
 namespace testing {
 
 bool Test::testProcessKilled(testutils::FunctionCaller *Func, int Signal,
                              const char *LHSStr, const char *RHSStr,
-                             const char *File, unsigned long Line) {
+                             internal::Location Loc) {
   testutils::ProcessStatus Result = testutils::invoke_in_subprocess(Func, 500);
 
   if (const char *error = Result.get_error()) {
     Ctx->markFail();
-    tlog << File << ":" << Line << ": FAILURE\n" << error << '\n';
+    tlog << Loc;
+    tlog << error << '\n';
     return false;
   }
 
   if (Result.timed_out()) {
     Ctx->markFail();
-    tlog << File << ":" << Line << ": FAILURE\n"
-         << "Process timed out after " << 500 << " milliseconds.\n";
+    tlog << Loc;
+    tlog << "Process timed out after " << 500 << " milliseconds.\n";
     return false;
   }
 
   if (Result.exited_normally()) {
     Ctx->markFail();
-    tlog << File << ":" << Line << ": FAILURE\n"
-         << "Expected " << LHSStr
+    tlog << Loc;
+    tlog << "Expected " << LHSStr
          << " to be killed by a signal\nBut it exited normally!\n";
     return false;
   }
 
   int KilledBy = Result.get_fatal_signal();
   assert(KilledBy != 0 && "Not killed by any signal");
   if (Signal == -1 || KilledBy == Signal)
     return true;
 
   using testutils::signal_as_string;
   Ctx->markFail();
-  tlog << File << ":" << Line << ": FAILURE\n"
-       << "              Expected: " << LHSStr << '\n'
+  tlog << Loc;
+  tlog << "              Expected: " << LHSStr << '\n'
        << "To be killed by signal: " << Signal << '\n'
        << "              Which is: " << signal_as_string(Signal) << '\n'
        << "  But it was killed by: " << KilledBy << '\n'
        << "              Which is: " << signal_as_string(KilledBy) << '\n';
   return false;
 }
 
 bool Test::testProcessExits(testutils::FunctionCaller *Func, int ExitCode,
                             const char *LHSStr, const char *RHSStr,
-                            const char *File, unsigned long Line) {
+                            internal::Location Loc) {
   testutils::ProcessStatus Result = testutils::invoke_in_subprocess(Func, 500);
 
   if (const char *error = Result.get_error()) {
     Ctx->markFail();
-    tlog << File << ":" << Line << ": FAILURE\n" << error << '\n';
+    tlog << Loc;
+    tlog << error << '\n';
     return false;
   }
 
   if (Result.timed_out()) {
     Ctx->markFail();
-    tlog << File << ":" << Line << ": FAILURE\n"
-         << "Process timed out after " << 500 << " milliseconds.\n";
+    tlog << Loc;
+    tlog << "Process timed out after " << 500 << " milliseconds.\n";
     return false;
   }
 
   if (!Result.exited_normally()) {
     Ctx->markFail();
-    tlog << File << ":" << Line << ": FAILURE\n"
-         << "Expected " << LHSStr << '\n'
+    tlog << Loc;
+    tlog << "Expected " << LHSStr << '\n'
          << "to exit with exit code " << ExitCode << '\n'
          << "But it exited abnormally!\n";
     return false;
   }
 
   int ActualExit = Result.get_exit_code();
   if (ActualExit == ExitCode)
     return true;
 
   Ctx->markFail();
-  tlog << File << ":" << Line << ": FAILURE\n"
-       << "Expected exit code of: " << LHSStr << '\n'
+  tlog << Loc;
+  tlog << "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

libc/test/UnitTest/LibcTest.h

 // a TRUE or FALSE condition. That is because, C library functions do not
 // return boolean values, but use integral return values to indicate true or
 // false conditions. Hence, it is more appropriate to use the other comparison
 // conditions for such cases.
 enum class TestCond { EQ, NE, LT, LE, GT, GE };
 
 namespace internal {
 
+struct Location {
+  Location(const char *file, int line) : file(file), line(line) {}
+  const char *file;
+  int line;
+};
+
+TestLogger &operator<<(TestLogger &logger, Location Loc);
+
+#define LOC() __llvm_libc::testing::internal::Location(__FILE__, __LINE__)
+
 struct RunContext {
   enum class RunResult : bool { Pass, Fail };
 
   RunResult status() const { return Status; }
 
   void markFail() { Status = RunResult::Fail; }
 
 private:
   RunResult Status = RunResult::Pass;
 };
 
 template <typename ValType>
 bool test(RunContext *Ctx, TestCond Cond, ValType LHS, ValType RHS,
-          const char *LHSStr, const char *RHSStr, const char *File,
-          unsigned long Line);
+          const char *LHSStr, const char *RHSStr, Location Loc);
 
 } // namespace internal
 
 struct MatcherBase {
   virtual ~MatcherBase() {}
   virtual void explainError() { tlog << "unknown error\n"; }
   // Override and return true to skip `explainError` step.
   virtual bool is_silent() const { return false; }
 };
 
 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;
   internal::RunContext *Ctx = nullptr;
 
   void setContext(internal::RunContext *C) { Ctx = C; }
 
 public:
   virtual ~Test() {}
   virtual void SetUp() {}
protected:
   // 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::enable_if_t<cpp::is_integral_v<ValType>, int> = 0>
   bool test(TestCond 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);
+            const char *RHSStr, internal::Location Loc) {
+    return internal::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, Loc);
   }
 
   template <typename ValType,
-            cpp::enable_if_t<cpp::is_enum<ValType>::value, int> = 0>
+            cpp::enable_if_t<cpp::is_enum_v<ValType>, int> = 0>
   bool test(TestCond Cond, ValType LHS, ValType RHS, const char *LHSStr,
-            const char *RHSStr, const char *File, unsigned long Line) {
+            const char *RHSStr, internal::Location Loc) {
     return internal::test(Ctx, Cond, (long long)LHS, (long long)RHS, LHSStr,
-                          RHSStr, File, Line);
+                          RHSStr, Loc);
   }
 
   template <typename ValType,
             cpp::enable_if_t<cpp::is_pointer_v<ValType>, ValType> = nullptr>
   bool test(TestCond Cond, ValType LHS, ValType RHS, const char *LHSStr,
-            const char *RHSStr, const char *File, unsigned long Line) {
+            const char *RHSStr, internal::Location Loc) {
     return internal::test(Ctx, Cond, (unsigned long long)LHS,
-                          (unsigned long long)RHS, LHSStr, RHSStr, File, Line);
+                          (unsigned long long)RHS, LHSStr, RHSStr, Loc);
   }
 
   template <
       typename ValType,
       cpp::enable_if_t<cpp::is_same_v<ValType, __llvm_libc::cpp::string_view>,
                        int> = 0>
   bool test(TestCond 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);
+            const char *RHSStr, internal::Location Loc) {
+    return internal::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, Loc);
   }
 
   template <typename ValType,
             cpp::enable_if_t<cpp::is_same_v<ValType, __llvm_libc::cpp::string>,
                              int> = 0>
   bool test(TestCond 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);
+            const char *RHSStr, internal::Location Loc) {
+    return internal::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, Loc);
   }
 
   bool testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
-                 const char *RHSStr, const char *File, unsigned long Line);
+                 const char *RHSStr, internal::Location Loc);
 
   bool testStrNe(const char *LHS, const char *RHS, const char *LHSStr,
-                 const char *RHSStr, const char *File, unsigned long Line);
+                 const char *RHSStr, internal::Location Loc);
 
   bool testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
-                 const char *RHSStr, const char *File, unsigned long Line);
+                 const char *RHSStr, internal::Location Loc);
 
   bool testProcessExits(testutils::FunctionCaller *Func, int ExitCode,
                         const char *LHSStr, const char *RHSStr,
-                        const char *File, unsigned long Line);
+                        internal::Location Loc);
 
   bool testProcessKilled(testutils::FunctionCaller *Func, int Signal,
                          const char *LHSStr, const char *RHSStr,
-                         const char *File, unsigned long Line);
+                         internal::Location Loc);
 
   template <typename Func> testutils::FunctionCaller *createCallable(Func f) {
     struct Callable : public testutils::FunctionCaller {
       Func f;
       Callable(Func f) : f(f) {}
       void operator()() override { f(); }
     };
 
public:                                                                      \
     void Run() override;                                                       \
     const char *getName() const override { return #SuiteClass "." #TestName; } \
   };                                                                           \
   SuiteClass##_##TestName SuiteClass##_##TestName##_Instance;                  \
   void SuiteClass##_##TestName::Run()
 
 #define EXPECT_EQ(LHS, RHS)                                                    \
   this->test(__llvm_libc::testing::TestCond::EQ, (LHS), (RHS), #LHS, #RHS,     \
-             __FILE__, __LINE__)
+             LOC())
 #define ASSERT_EQ(LHS, RHS)                                                    \
   if (!EXPECT_EQ(LHS, RHS))                                                    \
   return
 
 #define EXPECT_NE(LHS, RHS)                                                    \
   this->test(__llvm_libc::testing::TestCond::NE, (LHS), (RHS), #LHS, #RHS,     \
-             __FILE__, __LINE__)
+             LOC())
 #define ASSERT_NE(LHS, RHS)                                                    \
   if (!EXPECT_NE(LHS, RHS))                                                    \
   return
 
 #define EXPECT_LT(LHS, RHS)                                                    \
   this->test(__llvm_libc::testing::TestCond::LT, (LHS), (RHS), #LHS, #RHS,     \
-             __FILE__, __LINE__)
+             LOC())
 #define ASSERT_LT(LHS, RHS)                                                    \
   if (!EXPECT_LT(LHS, RHS))                                                    \
   return
 
 #define EXPECT_LE(LHS, RHS)                                                    \
   this->test(__llvm_libc::testing::TestCond::LE, (LHS), (RHS), #LHS, #RHS,     \
-             __FILE__, __LINE__)
+             LOC())
 #define ASSERT_LE(LHS, RHS)                                                    \
   if (!EXPECT_LE(LHS, RHS))                                                    \
   return
 
 #define EXPECT_GT(LHS, RHS)                                                    \
   this->test(__llvm_libc::testing::TestCond::GT, (LHS), (RHS), #LHS, #RHS,     \
-             __FILE__, __LINE__)
+             LOC())
 #define ASSERT_GT(LHS, RHS)                                                    \
   if (!EXPECT_GT(LHS, RHS))                                                    \
   return
 
 #define EXPECT_GE(LHS, RHS)                                                    \
   this->test(__llvm_libc::testing::TestCond::GE, (LHS), (RHS), #LHS, #RHS,     \
-             __FILE__, __LINE__)
+             LOC())
 #define ASSERT_GE(LHS, RHS)                                                    \
   if (!EXPECT_GE(LHS, RHS))                                                    \
   return
 
-#define EXPECT_STREQ(LHS, RHS)                                                 \
-  this->testStrEq((LHS), (RHS), #LHS, #RHS, __FILE__, __LINE__)
+#define EXPECT_STREQ(LHS, RHS) this->testStrEq((LHS), (RHS), #LHS, #RHS, LOC())
 #define ASSERT_STREQ(LHS, RHS)                                                 \
   if (!EXPECT_STREQ(LHS, RHS))                                                 \
   return
 
-#define EXPECT_STRNE(LHS, RHS)                                                 \
-  this->testStrNe((LHS), (RHS), #LHS, #RHS, __FILE__, __LINE__)
+#define EXPECT_STRNE(LHS, RHS) this->testStrNe((LHS), (RHS), #LHS, #RHS, LOC())
 #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
 
 #ifdef ENABLE_SUBPROCESS_TESTS
 
 #define EXPECT_EXITS(FUNC, EXIT)                                               \
   this->testProcessExits(__llvm_libc::testing::Test::createCallable(FUNC),     \
-                         EXIT, #FUNC, #EXIT, __FILE__, __LINE__)
+                         EXIT, #FUNC, #EXIT, LOC())
 
 #define ASSERT_EXITS(FUNC, EXIT)                                               \
   if (!EXPECT_EXITS(FUNC, EXIT))                                               \
   return
 
 #define EXPECT_DEATH(FUNC, SIG)                                                \
   this->testProcessKilled(__llvm_libc::testing::Test::createCallable(FUNC),    \
-                          SIG, #FUNC, #SIG, __FILE__, __LINE__)
+                          SIG, #FUNC, #SIG, LOC())
 
 #define ASSERT_DEATH(FUNC, EXIT)                                               \
   if (!EXPECT_DEATH(FUNC, EXIT))                                               \
   return
 
 #endif // ENABLE_SUBPROCESS_TESTS
 
 #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)                                            \
   [&]() -> bool {                                                              \
     auto UNIQUE_VAR(__matcher) = (MATCHER);                                    \
     return this->testMatch(UNIQUE_VAR(__matcher).match((MATCH)),               \
-                           UNIQUE_VAR(__matcher), #MATCH, #MATCHER, __FILE__,  \
-                           __LINE__);                                          \
+                           UNIQUE_VAR(__matcher), #MATCH, #MATCHER, LOC());    \
   }()
 
 #define ASSERT_THAT(MATCH, MATCHER)                                            \
   do {                                                                         \
     if (!EXPECT_THAT(MATCH, MATCHER))                                          \
       return;                                                                  \
   } while (0)
 
 #define WITH_SIGNAL(X) X
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_LIBCTEST_H

libc/test/UnitTest/LibcTest.cpp

 #define CLOCKS_PER_SEC 1
 #endif
 
 namespace __llvm_libc {
 namespace testing {
 
 namespace internal {
 
+TestLogger &operator<<(TestLogger &logger, Location Loc) {
+  return logger << Loc.file << ":" << Loc.line << ": FAILURE\n";
+}
+
 // When the value is UInt128, __uint128_t or wider, show its hexadecimal digits.
 template <typename T>
 cpp::enable_if_t<cpp::is_integral_v<T> && cpp::is_unsigned_v<T> &&
                      (sizeof(T) > sizeof(uint64_t)),
                  cpp::string>
 describeValue(T Value) {
   static_assert(sizeof(T) % 8 == 0, "Unsupported size of UInt");
   char buf[IntegerToString::hex_bufsize<T>()];
describeValue(ValType Value) {
   return cpp::to_string(Value);
 }
 
 cpp::string_view describeValue(const cpp::string &Value) { return Value; }
 cpp::string_view describeValue(cpp::string_view Value) { return Value; }
 
 template <typename ValType>
 bool test(RunContext *Ctx, TestCond Cond, ValType LHS, ValType RHS,
-          const char *LHSStr, const char *RHSStr, const char *File,
-          unsigned long Line) {
+          const char *LHSStr, const char *RHSStr, Location Loc) {
   auto ExplainDifference = [=, &Ctx](bool Cond,
                                      cpp::string_view OpString) -> bool {
     if (Cond)
       return true;
     Ctx->markFail();
     size_t OffsetLength = OpString.size() > 2 ? OpString.size() - 2 : 0;
     cpp::string Offset(OffsetLength, ' ');
-    tlog << File << ":" << Line << ": FAILURE\n"
-         << Offset << "Expected: " << LHSStr << '\n'
+    tlog << Loc;
+    tlog << Offset << "Expected: " << LHSStr << '\n'
          << Offset << "Which is: " << describeValue(LHS) << '\n'
          << "To be " << OpString << ": " << RHSStr << '\n'
          << Offset << "Which is: " << describeValue(RHS) << '\n';
     return false;
   };
 
   switch (Cond) {
   case TestCond::EQ:
#endif
   }
 
   return FailCount > 0 || TestCount == 0 ? 1 : 0;
 }
 
 namespace internal {
 
 template bool test<char>(RunContext *Ctx, TestCond Cond, char LHS, char RHS,
-                         const char *LHSStr, const char *RHSStr,
-                         const char *File, unsigned long Line);
+                         const char *LHSStr, const char *RHSStr, Location Loc);
 
 template bool test<short>(RunContext *Ctx, TestCond Cond, short LHS, short RHS,
-                          const char *LHSStr, const char *RHSStr,
-                          const char *File, unsigned long Line);
+                          const char *LHSStr, const char *RHSStr, Location Loc);
 
 template bool test<int>(RunContext *Ctx, TestCond Cond, int LHS, int RHS,
-                        const char *LHSStr, const char *RHSStr,
-                        const char *File, unsigned long Line);
+                        const char *LHSStr, const char *RHSStr, Location Loc);
 
 template bool test<long>(RunContext *Ctx, TestCond Cond, long LHS, long RHS,
-                         const char *LHSStr, const char *RHSStr,
-                         const char *File, unsigned long Line);
+                         const char *LHSStr, const char *RHSStr, Location Loc);
 
 template bool test<long long>(RunContext *Ctx, TestCond Cond, long long LHS,
                               long long RHS, const char *LHSStr,
-                              const char *RHSStr, const char *File,
-                              unsigned long Line);
+                              const char *RHSStr, Location Loc);
 
 template bool test<unsigned char>(RunContext *Ctx, TestCond Cond,
                                   unsigned char LHS, unsigned char RHS,
                                   const char *LHSStr, const char *RHSStr,
-                                  const char *File, unsigned long Line);
+                                  Location Loc);
 
 template bool test<unsigned short>(RunContext *Ctx, TestCond Cond,
                                    unsigned short LHS, unsigned short RHS,
                                    const char *LHSStr, const char *RHSStr,
-                                   const char *File, unsigned long Line);
+                                   Location Loc);
 
 template bool test<unsigned int>(RunContext *Ctx, TestCond Cond,
                                  unsigned int LHS, unsigned int RHS,
                                  const char *LHSStr, const char *RHSStr,
-                                 const char *File, unsigned long Line);
+                                 Location Loc);
 
 template bool test<unsigned long>(RunContext *Ctx, TestCond Cond,
                                   unsigned long LHS, unsigned long RHS,
                                   const char *LHSStr, const char *RHSStr,
-                                  const char *File, unsigned long Line);
+                                  Location Loc);
 
 template bool test<bool>(RunContext *Ctx, TestCond Cond, bool LHS, bool RHS,
-                         const char *LHSStr, const char *RHSStr,
-                         const char *File, unsigned long Line);
+                         const char *LHSStr, const char *RHSStr, Location Loc);
 
 template bool test<unsigned long long>(RunContext *Ctx, TestCond Cond,
                                        unsigned long long LHS,
                                        unsigned long long RHS,
                                        const char *LHSStr, const char *RHSStr,
-                                       const char *File, unsigned long Line);
+                                       Location Loc);
 
 // We cannot just use a single UInt128 specialization as that resolves to only
 // one type, UInt<128> or __uint128_t. We want both overloads as we want to
 // be able to unittest UInt<128> on platforms where UInt128 resolves to
 // UInt128.
 #ifdef __SIZEOF_INT128__
 // When builtin __uint128_t type is available, include its specialization
 // also.
 template bool test<__uint128_t>(RunContext *Ctx, TestCond Cond, __uint128_t LHS,
                                 __uint128_t RHS, const char *LHSStr,
-                                const char *RHSStr, const char *File,
-                                unsigned long Line);
+                                const char *RHSStr, Location Loc);
 #endif
 
-template bool test<__llvm_libc::cpp::UInt<128>>(
-    RunContext *Ctx, TestCond Cond, __llvm_libc::cpp::UInt<128> LHS,
-    __llvm_libc::cpp::UInt<128> RHS, const char *LHSStr, const char *RHSStr,
-    const char *File, unsigned long Line);
-
-template bool test<__llvm_libc::cpp::UInt<192>>(
-    RunContext *Ctx, TestCond Cond, __llvm_libc::cpp::UInt<192> LHS,
-    __llvm_libc::cpp::UInt<192> RHS, const char *LHSStr, const char *RHSStr,
-    const char *File, unsigned long Line);
-
-template bool test<__llvm_libc::cpp::UInt<256>>(
-    RunContext *Ctx, TestCond Cond, __llvm_libc::cpp::UInt<256> LHS,
-    __llvm_libc::cpp::UInt<256> RHS, const char *LHSStr, const char *RHSStr,
-    const char *File, unsigned long Line);
-
-template bool test<__llvm_libc::cpp::UInt<320>>(
-    RunContext *Ctx, TestCond Cond, __llvm_libc::cpp::UInt<320> LHS,
-    __llvm_libc::cpp::UInt<320> RHS, const char *LHSStr, const char *RHSStr,
-    const char *File, unsigned long Line);
+template bool test<__llvm_libc::cpp::UInt<128>>(RunContext *Ctx, TestCond Cond,
+                                                __llvm_libc::cpp::UInt<128> LHS,
+                                                __llvm_libc::cpp::UInt<128> RHS,
+                                                const char *LHSStr,
+                                                const char *RHSStr,
+                                                Location Loc);
+
+template bool test<__llvm_libc::cpp::UInt<192>>(RunContext *Ctx, TestCond Cond,
+                                                __llvm_libc::cpp::UInt<192> LHS,
+                                                __llvm_libc::cpp::UInt<192> RHS,
+                                                const char *LHSStr,
+                                                const char *RHSStr,
+                                                Location Loc);
+
+template bool test<__llvm_libc::cpp::UInt<256>>(RunContext *Ctx, TestCond Cond,
+                                                __llvm_libc::cpp::UInt<256> LHS,
+                                                __llvm_libc::cpp::UInt<256> RHS,
+                                                const char *LHSStr,
+                                                const char *RHSStr,
+                                                Location Loc);
+
+template bool test<__llvm_libc::cpp::UInt<320>>(RunContext *Ctx, TestCond Cond,
+                                                __llvm_libc::cpp::UInt<320> LHS,
+                                                __llvm_libc::cpp::UInt<320> RHS,
+                                                const char *LHSStr,
+                                                const char *RHSStr,
+                                                Location Loc);
 
 template bool test<__llvm_libc::cpp::string_view>(
     RunContext *Ctx, TestCond Cond, __llvm_libc::cpp::string_view LHS,
     __llvm_libc::cpp::string_view RHS, const char *LHSStr, const char *RHSStr,
-    const char *File, unsigned long Line);
+    Location Loc);
 
-template bool test<__llvm_libc::cpp::string>(
-    RunContext *Ctx, TestCond Cond, __llvm_libc::cpp::string LHS,
-    __llvm_libc::cpp::string RHS, const char *LHSStr, const char *RHSStr,
-    const char *File, unsigned long Line);
+template bool test<__llvm_libc::cpp::string>(RunContext *Ctx, TestCond Cond,
+                                             __llvm_libc::cpp::string LHS,
+                                             __llvm_libc::cpp::string RHS,
+                                             const char *LHSStr,
+                                             const char *RHSStr, Location Loc);
 
 } // namespace internal
 
 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, TestCond::EQ,
-                        LHS ? cpp::string_view(LHS) : cpp::string_view(),
-                        RHS ? cpp::string_view(RHS) : cpp::string_view(),
-                        LHSStr, RHSStr, File, Line);
+                     const char *RHSStr, internal::Location Loc) {
+  return internal::test(
+      Ctx, TestCond::EQ, LHS ? cpp::string_view(LHS) : cpp::string_view(),
+      RHS ? cpp::string_view(RHS) : cpp::string_view(), LHSStr, RHSStr, Loc);
 }
 
 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, TestCond::NE,
-                        LHS ? cpp::string_view(LHS) : cpp::string_view(),
-                        RHS ? cpp::string_view(RHS) : cpp::string_view(),
-                        LHSStr, RHSStr, File, Line);
+                     const char *RHSStr, internal::Location Loc) {
+  return internal::test(
+      Ctx, TestCond::NE, LHS ? cpp::string_view(LHS) : cpp::string_view(),
+      RHS ? cpp::string_view(RHS) : cpp::string_view(), LHSStr, RHSStr, Loc);
 }
 
 bool Test::testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
-                     const char *RHSStr, const char *File, unsigned long Line) {
+                     const char *RHSStr, internal::Location Loc) {
   if (MatchResult)
     return true;
 
   Ctx->markFail();
   if (!Matcher.is_silent()) {
-    tlog << File << ":" << Line << ": FAILURE\n"
-         << "Failed to match " << LHSStr << " against " << RHSStr << ".\n";
+    tlog << Loc;
+    tlog << "Failed to match " << LHSStr << " against " << RHSStr << ".\n";
     Matcher.explainError();
   }
   return false;
 }
 
 } // namespace testing
 } // namespace __llvm_libc