[libc] Replace the use of gtest with a new light weight unittest framework.

[sivachandra]

Summary

Header files included wrongly using <...> are now included using the
internal path names as the new unittest framework allows us to do so.

[abrachet]

libc/src/sys/mman/munmap.h

12

While we are here, the other comments end with a period so this one should too.

libc/test/src/string/strcat_test.cpp

21

Shouldn't we keep this as just ASSERT_EQ, the streq doesn't make much sense because these should be the same pointers. I think right now ASSERT_EQ with char* will not work but see my other comments.

libc/utils/UnitTest/Test.cpp

43

Maybe a using llvm_libc::testing::Test; and shorten these to Test::Cond_EQ?

48

What about llvm::withColor(llvm::errs(), llvm::raw_ostream::RED); Even if you don't like the color, all of these should be printing to stderr.

133

What if addTest added to a vector that way we can easily change the order the tests are executed for like in --gtest_shuffle

151

for (Test *T = Start; T; T = T->Next, ++TestCount)

And then the

Test *T = Start;
 if (T == nullptr)
   return 0;

can be removed along with the ++TestCount right below this comment.

175

What about !!FailCount?

178–184

You can create

template <typename T>
bool Test::test(...) {
   return ::test(...);
}

and then instantiate each of these

template Test::test<int>(RunContext &, ...);

But see previous comment I think we can do this differently.

libc/utils/UnitTest/Test.h

56–59

We can make this template call ::test(...) just here. But also It would be worth it to have enable_if specialization for std::is_pointer to call ::test<const void*>, and std::is_integral to call ::test<int64_t> and one for unsigned integrals to call use uint64_t so that we only need to have a couple instantiated in Test.cpp.

103–106

What do you think about making the ASSERT_*'s into if (!EXPECT_*) return?

[sivachandra]

Address comments.

libc/test/src/string/strcat_test.cpp

21

I have added a new ASSERT_PTREQ macro to test pointer equality. I previously had a specialization of ASSERT_EQ for void *. But, I think something like a PTREQ it is more useful as it can be used to compare any kind of pointer.

libc/utils/UnitTest/Test.cpp

43

Its affecting only this function so I have left it as is.

48

Streaming to llvm::errs() instead of llvm::outs().

133

Yeah, I did consider that. But, that means we will have a global non-POD which is usually not considered as a good practice. We can always reconsider this in case we want features like --gtest-shuffle.

175

Personally, I do not like the implicit nature of such a construct.

178–184

I do not think a declaration of a function specialization instantiates it. Am I misunderstanding something?

libc/utils/UnitTest/Test.h

56–59

This a very good suggestion to enable_if. But, I do not want to include <type_traits> here so I have now implemented an equivalent and used it to incorporate your suggestion. The benefit of using it is that the use of unsupported types leads to a compile-error which is more descriptive than a link-error (which was the case earlier.)

About calling ::test, since ::test is template function, we will have to define it in the header. We will then have to include some headers which we want to avoid.
About filtering signed integers to int64_t comparison etc., I want to avoid such implicit conversions so I have kept it as is.
About using std::is_pointer, I have added new EXPECT_PTREQ and friends. These macros cast the pointers to unsigned long long and do the comparison.

103–106

This is yet another good suggestion. Done now.

[abrachet]

libc/utils/UnitTest/Test.cpp

15

This include is unnecessary I think.

149

This one is still to outs

156

ditto

159

ditto

165

ditto

178–184

It instantiates if you write like template function<params_to_instantiate>(...);. Its used more often with class templates but it works with function templates as well. In llvm, I have seen it here.

libc/utils/UnitTest/Test.h

24

It looks like libcxx does remove_cv before these specializations. Which confuses me because

template <typename T> void f(T) {}
template <> void f<char>(char) {}
int main() {
  const volatile char c = 'c';
  f(c); // calls f<char>
}

But I figured I would mention it.

56–59

About calling ::test, since ::test is template function, we will have to define it in the header. We will then have to include some headers which we want to avoid.

Thats no different than what we have now we have the declaration of Test::test and it's definition in the cpp file. Just putting template <typename ValType> bool ::test(...); in the header file and then making Test::test call ::test makes it inline-able but more importantly its a little easier to follow I think.

About using std::is_pointer, I have added new EXPECT_PTREQ and friends. These macros cast the pointers to unsigned long long and do the comparison.

I think it is important that we make a IsPointerType specialization so we can just use EXPECT_EQ and be consistent with gtest. This will confuse people later I'm pretty sure. Also if we do the above suggestion this will be easy to make this specialization call ::test<unsigned long long>.

[abrachet]

I just checked quickly and it looks like gtest actually prints to stdout which surprised me, I always figured it was to stderr. Do you think we should go back to stdout?

[sivachandra]

Address another round of comments.

[sivachandra]

In D72743#1825799, @abrachet wrote:

I just checked quickly and it looks like gtest actually prints to stdout which surprised me, I always figured it was to stderr. Do you think we should go back to stdout?

TBF, I do not have any opinion here. For me, a message from a test run is all useful. So, its hard for me to see why something should be logged to stderr and something else to stdout. I have now put everything back to stdout because I actually think there could be tools out there which are probably only looking at stdout.

libc/utils/UnitTest/Test.cpp

149

The others were really an error message, so may be stderr was more appropriate. These are purely informational and hence I left them with stdout.

178–184

Ah, I never used this before. I have modified as you have suggested now.

libc/utils/UnitTest/Test.h

56–59

I don't have any opinion about this. I had previously thought I should limit the re-implementation of std types. But heck, we have already come this far so I have implemented everything as you have suggested.

[abrachet]

libc/test/config/linux/x86_64/syscall_test.cpp

12

Should we get rid of this include too? Maybe just assign to function pointer? Or we could implement std::is_same?

libc/test/src/string/strcat_test.cpp

35

I guess we don't really need these STREQ anymore.

[phosek]

LGTM

libc/utils/UnitTest/Test.cpp

118

Have you considered using a switch instead so that the compiler statically checks that you've handled all conditions? I'd expect it to also be more efficient.

149

This could also be a switch.

libc/utils/UnitTest/Test.h

95

Why not bool as a return value`?

[sivachandra]

I modified to use switch statements as suggested before submitting.

libc/test/config/linux/x86_64/syscall_test.cpp

12

Yes, it should go. I have kept it for now as I have a different plan for things like these. Will write about them in detail soon.

libc/test/src/string/strcat_test.cpp

35

No harm to keep them I guess :)

libc/utils/UnitTest/Test.h

95

The main function can then just return the result of runTests. I don't think bool return value disallows it, but I don't like the implicit nature of such conversions.

libc/cmake/modules/LLVMLibCRules.cmake

add_executable(
     ${target_name}
     EXCLUDE_FROM_ALL
     ${LIBC_UNITTEST_SRCS}
     ${LIBC_UNITTEST_HDRS}
   )
   target_include_directories(
     ${target_name}
     PRIVATE
-      ${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include
-      ${LLVM_MAIN_SRC_DIR}/utils/unittest/googlemock/include
       ${LIBC_SOURCE_DIR}
       ${LIBC_BUILD_DIR}
+      ${LIBC_BUILD_DIR}/include
   )
 
   if(library_deps)
     target_link_libraries(${target_name} PRIVATE ${library_deps})
   endif()
 
   set_target_properties(${target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
   add_dependencies(
     ${target_name}
     ${LIBC_UNITTEST_DEPENDS}
     gtest
   )
 
-  target_link_libraries(${target_name} PRIVATE gtest_main gtest)
+  target_link_libraries(${target_name} PRIVATE LibcUnitTest LLVMSupport)
 
   add_custom_command(
     TARGET ${target_name}
     POST_BUILD
     COMMAND $<TARGET_FILE:${target_name}>
   )
   if(LIBC_UNITTEST_SUITE)
     add_dependencies(

libc/src/string/strcat.h

 //===----------------- Implementation header for strcat -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STRING_STRCAT_H
 #define LLVM_LIBC_SRC_STRING_STRCAT_H
 
-#include <string.h>
+#include "include/string.h"
 
 namespace __llvm_libc {
 
 char *strcat(char *dest, const char *src);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_STRCAT_H

libc/src/string/strcpy.h

 //===----------------- Implementation header for strcpy -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STRING_STRCPY_H
 #define LLVM_LIBC_SRC_STRING_STRCPY_H
 
-#include <string.h>
+#include "include/string.h"
 
 namespace __llvm_libc {
 
 char *strcpy(char *dest, const char *src);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_STRCPY_H

libc/src/sys/mman/mmap.h

 //===-------------- Implementation header for mmap function ------ *-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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SYS_MMAN_MMAP_H
 #define LLVM_LIBC_SRC_SYS_MMAN_MMAP_H
 
-#include <sys/mman.h> // For size_t and off_t
+#include "include/sys/mman.h" // For size_t and off_t
 
 namespace __llvm_libc {
 
 void *mmap(void *addr, size_t size, int prot, int flags, int fd, off_t offset);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SYS_MMAN_MMAP_H

libc/src/sys/mman/mmap.cpp

 //===-------------- Implementation of the POSIX mmap function -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/sys/mman/mmap.h"
+#include "include/sys/syscall.h" // For syscall numbers.
 #include "src/__support/common.h"
 #include "src/errno/llvmlibc_errno.h"
-
 #include "src/unistd/syscall.h" // For internal syscall function.
 
-#include <sys/syscall.h> // For syscall numbers.
-
 namespace __llvm_libc {
 
 // This function is currently linux only. It has to be refactored suitably if
 // mmap is to be supported on non-linux operating systems also.
 void *LLVM_LIBC_ENTRYPOINT(mmap)(void *addr, size_t size, int prot, int flags,
                                  int fd, off_t offset) {
   // A lot of POSIX standard prescribed validation of the parameters is not
   // done in this function as modern linux versions do it in the syscall.

libc/src/sys/mman/munmap.h

 //===-------------- Implementation header for mumap function ----- *-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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SYS_MMAN_MUNMAP_H
 #define LLVM_LIBC_SRC_SYS_MMAN_MUNMAP_H
 
-#include <sys/mman.h> // For size_t
+#include "include/sys/mman.h" // For size_t.
 
 namespace __llvm_libc {
 
 int munmap(void *addr, size_t size);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SYS_MMAN_MUNMAP_H

libc/src/sys/mman/munmap.cpp

 //===------------- Implementation of the POSIX munmap function ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/sys/mman/munmap.h"
+#include "include/sys/syscall.h" // For syscall numbers.
 #include "src/__support/common.h"
 #include "src/errno/llvmlibc_errno.h"
-
 #include "src/unistd/syscall.h" // For internal syscall function.
 
-#include <sys/syscall.h> // For syscall numbers.
-
 namespace __llvm_libc {
 
 // This function is currently linux only. It has to be refactored suitably if
 // mmap is to be supported on non-linux operating systems also.
 int LLVM_LIBC_ENTRYPOINT(munmap)(void *addr, size_t size) {
   long ret_val =
       __llvm_libc::syscall(SYS_munmap, reinterpret_cast<long>(addr), size);
 

libc/test/config/linux/x86_64/syscall_test.cpp

 //===------------------ Unittests for x86_64 syscalls ---------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/unistd/syscall.h"
-
-#include "gtest/gtest.h"
+#include "utils/UnitTest/Test.h"
 
 #include <functional>
 
 TEST(X86_64_SyscallTest, APITest) {
   // We only do a signature test here. Actual functionality tests are
   // done by the unit tests of the syscall wrappers like mmap.
 
   std::function<long(long)> f([](long n) { return __llvm_libc::syscall(n); });
   std::function<long(long, long)> f1(
       [](long n, long a1) { return __llvm_libc::syscall(n, a1); });

libc/test/src/errno/errno_test.cpp

 //===---------------------- Unittests for errno --------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/errno/llvmlibc_errno.h"
-
-#include "gtest/gtest.h"
+#include "utils/UnitTest/Test.h"
 
 TEST(ErrnoTest, Basic) {
   int test_val = 123;
   llvmlibc_errno = test_val;
   ASSERT_EQ(test_val, llvmlibc_errno);
 }

libc/test/src/string/strcat_test.cpp

 //===---------------------- Unittests for strcat --------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include <string>
-
 #include "src/string/strcat.h"
-#include "gtest/gtest.h"
+#include "utils/UnitTest/Test.h"
 
 TEST(StrCatTest, EmptyDest) {
-  std::string abc = "abc";
+  const char *abc = "abc";
   char dest[4];
 
   dest[0] = '\0';
 
-  char *result = __llvm_libc::strcat(dest, abc.c_str());
+  char *result = __llvm_libc::strcat(dest, abc);
   ASSERT_EQ(dest, result);
-  ASSERT_EQ(std::string(dest), abc);
-  ASSERT_EQ(std::string(dest).size(), abc.size());
+  ASSERT_STREQ(dest, result);
+  ASSERT_STREQ(dest, abc);
 }
 
 TEST(StrCatTest, NonEmptyDest) {
-  std::string abc = "abc";
+  const char *abc = "abc";
   char dest[7];
 
   dest[0] = 'x';
   dest[1] = 'y';
   dest[2] = 'z';
   dest[3] = '\0';
 
-  char *result = __llvm_libc::strcat(dest, abc.c_str());
+  char *result = __llvm_libc::strcat(dest, abc);
   ASSERT_EQ(dest, result);
-  ASSERT_EQ(std::string(dest), std::string("xyz") + abc);
-  ASSERT_EQ(std::string(dest).size(), abc.size() + 3);
+  ASSERT_STREQ(dest, result);
+  ASSERT_STREQ(dest, "xyzabc");
 }

libc/test/src/string/strcpy_test.cpp

 //===----------------------- Unittests for strcpy -------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include <string>
-
 #include "src/string/strcpy.h"
-#include "gtest/gtest.h"
+#include "utils/UnitTest/Test.h"
 
 TEST(StrCpyTest, EmptyDest) {
-  std::string abc = "abc";
+  const char *abc = "abc";
   char dest[4];
 
-  char *result = __llvm_libc::strcpy(dest, abc.c_str());
+  char *result = __llvm_libc::strcpy(dest, abc);
   ASSERT_EQ(dest, result);
-  ASSERT_EQ(std::string(dest), abc);
-  ASSERT_EQ(std::string(dest).size(), abc.size());
+  ASSERT_STREQ(dest, result);
+  ASSERT_STREQ(dest, abc);
 }
 
 TEST(StrCpyTest, OffsetDest) {
-  std::string abc = "abc";
+  const char *abc = "abc";
   char dest[7];
 
   dest[0] = 'x';
   dest[1] = 'y';
   dest[2] = 'z';
 
-  char *result = __llvm_libc::strcpy(dest + 3, abc.c_str());
+  char *result = __llvm_libc::strcpy(dest + 3, abc);
   ASSERT_EQ(dest + 3, result);
-  ASSERT_EQ(std::string(dest), std::string("xyz") + abc);
-  ASSERT_EQ(std::string(dest).size(), abc.size() + 3);
+  ASSERT_STREQ(dest + 3, result);
+  ASSERT_STREQ(dest, "xyzabc");
 }

libc/test/src/sys/mman/CMakeLists.txt

 add_libc_testsuite(libc_sys_mman_unittests)
 
 add_libc_unittest(
   mmap_test
   SUITE
     libc_sys_mman_unittests
   SRCS
     mmap_test.cpp
   DEPENDS
+    errno_h
+    sys_mman_h
     mmap
     munmap
     __errno_location
 )

libc/test/src/sys/mman/mmap_test.cpp

 //===------------------ Unittests for mmap and munmap ---------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+#include "include/errno.h"
+#include "include/sys/mman.h"
 #include "src/errno/llvmlibc_errno.h"
 #include "src/sys/mman/mmap.h"
 #include "src/sys/mman/munmap.h"
-
-#include "gtest/gtest.h"
-
-#include "errno.h"
-#include "sys/mman.h"
+#include "utils/UnitTest/Test.h"
 
 TEST(MMapTest, NoError) {
   size_t alloc_size = 128;
   llvmlibc_errno = 0;
   void *addr = __llvm_libc::mmap(nullptr, alloc_size, PROT_READ,
                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   EXPECT_EQ(0, llvmlibc_errno);
   EXPECT_NE(addr, MAP_FAILED);

libc/utils/CMakeLists.txt

 add_subdirectory(HdrGen)
+add_subdirectory(UnitTest)

libc/utils/UnitTest/CMakeLists.txt

+add_llvm_library(
+  LibcUnitTest
+  Test.cpp
+  Test.h
+)

libc/utils/UnitTest/Test.h

+//===------------------ Base class for libc unittests -----------*- 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 should stricly not include any other file. Not even standard
+// library headers.
+
+namespace llvm_libc {
+namespace testing {
+
+// We define our own EnableIf and IsIntegerType traits because we do not want to
+// include even the standard header <type_traits>.
+template <bool B, typename T> struct EnableIf;
+template <typename T> struct EnableIf<true, T> { typedef T Type; };
+
+template <bool B, typename T>
+using EnableIfType = typename EnableIf<B, T>::Type;
+
+template <typename Type> struct IsIntegerType {
+  static const bool Value = false;
+};
+
+template <> struct IsIntegerType<char> { static const bool Value = true; };
+template <> struct IsIntegerType<unsigned char> {
+  static const bool Value = true;
+};
+
+template <> struct IsIntegerType<short> { static const bool Value = true; };
+template <> struct IsIntegerType<unsigned short> {
+  static const bool Value = true;
+};
+
+template <> struct IsIntegerType<int> { static const bool Value = true; };
+template <> struct IsIntegerType<unsigned int> {
+  static const bool Value = true;
+};
+
+template <> struct IsIntegerType<long> { static const bool Value = true; };
+template <> struct IsIntegerType<unsigned long> {
+  static const bool Value = true;
+};
+
+template <> struct IsIntegerType<long long> { static const bool Value = true; };
+template <> struct IsIntegerType<unsigned long long> {
+  static const bool Value = true;
+};
+
+template <typename T> struct IsPointerType;
+
+template <typename T> struct IsPointerType<T *> {
+  static const bool Value = true;
+};
+
+class RunContext;
+
+// Only the following conditions are supported. Notice that we do not have
+// a TRUE or FALSE condition. That is because, C library funtions do not
+// return, but use integral return values to indicate true or false
+// conditions. Hence, it is more appropriate to use the other comparison
+// condtions for such cases.
+enum TestCondition {
+  Cond_None,
+  Cond_EQ,
+  Cond_NE,
+  Cond_LT,
+  Cond_LE,
+  Cond_GT,
+  Cond_GE,
+};
+
+namespace internal {
+
+template <typename ValType>
+bool test(RunContext &Ctx, TestCondition Cond, ValType LHS, ValType RHS,
+          const char *LHSStr, const char *RHSStr, const char *File,
+          unsigned long Line);
+
+} // namespace internal
+
+// 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;
+
+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 test unittest
+  // frameworks have a similar functions 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,
+  // mismatched |LHS| and |RHS| types can potentially succeed because of type
+  // promotion.
+  template <typename ValType,
+            EnableIfType<IsIntegerType<ValType>::Value, ValType> = 0>
+  static bool test(RunContext &Ctx, 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,
+            EnableIfType<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) {
+    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);
+
+  static bool testStrNe(RunContext &Ctx, const char *LHS, const char *RHS,
+                        const char *LHSStr, const char *RHSStr,
+                        const char *File, unsigned long Line);
+
+private:
+  virtual void Run(RunContext &Ctx) = 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;                       \
+    const char *getName() const override { return #SuiteName "." #TestName; }  \
+  };                                                                           \
+  SuiteName##_##TestName SuiteName##_##TestName##_Instance;                    \
+  void SuiteName##_##TestName::Run(llvm_libc::testing::RunContext &Ctx)
+
+#define TEST_F(SuiteClass, TestName)                                           \
+  class SuiteClass##_##TestName : public SuiteClass {                          \
+  public:                                                                      \
+    SuiteClass##_##TestName() { addTest(this); }                               \
+    void Run(llvm_libc::testing::RunContext &) override;                       \
+    const char *getName() const override { return #SuiteClass "." #TestName; } \
+  };                                                                           \
+  SuiteClass##_##TestName SuiteClass##_##TestName##_Instance;                  \
+  void SuiteClass##_##TestName::Run(llvm_libc::testing::RunContext &Ctx)
+
+#define EXPECT_EQ(LHS, RHS)                                                    \
+  llvm_libc::testing::Test::test(Ctx, 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__)
+#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__)
+#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__)
+#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__)
+#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__)
+#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__)
+#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__)
+#define ASSERT_STRNE(LHS, RHS)                                                 \
+  if (!EXPECT_STRNE(LHS, RHS))                                                 \
+  return

libc/utils/UnitTest/Test.cpp

+//===--------- Implementation of the base class for libc unittests --------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Test.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm_libc {
+namespace testing {
+
+// This need not be a class as all it has is a single read-write state variable.
+// But, we make it class as then its implementation can be hidden from the
+// header file.
+class RunContext {
+public:
+  enum RunResult { Result_Pass = 1, Result_Fail = 2 };
+
+  RunResult status() const { return Status; }
+
+  void markFail() { Status = Result_Fail; }
+
+private:
+  RunResult Status = Result_Pass;
+};
+
+namespace internal {
+
+template <typename ValType>
+bool test(RunContext &Ctx, TestCondition Cond, ValType LHS, ValType RHS,
+          const char *LHSStr, const char *RHSStr, const char *File,
+          unsigned long Line) {
+  if (Cond == Cond_EQ) {
+    if (LHS == RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::outs() << File << ":" << Line << ": FAILURE\n"
+                 << "      Expected: " << LHSStr << '\n'
+                 << "      Which is: " << LHS << '\n'
+                 << "To be equal to: " << RHSStr << '\n'
+                 << "      Which is: " << RHS << '\n';
+
+    return false;
+  }
+
+  if (Cond == Cond_NE) {
+    if (LHS != RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::outs() << File << ":" << Line << ": FAILURE\n"
+                 << "          Expected: " << LHSStr << '\n'
+                 << "          Which is: " << LHS << '\n'
+                 << "To be not equal to: " << RHSStr << '\n'
+                 << "          Which is: " << RHS << '\n';
+    return false;
+  }
+
+  if (Cond == Cond_LT) {
+    if (LHS < RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::outs() << File << ":" << Line << ": FAILURE\n"
+                 << "       Expected: " << LHSStr << '\n'
+                 << "       Which is: " << LHS << '\n'
+                 << "To be less than: " << RHSStr << '\n'
+                 << "       Which is: " << RHS << '\n';
+    return false;
+  }
+
+  if (Cond == Cond_LE) {
+    if (LHS <= RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::outs() << File << ":" << Line << ": FAILURE\n"
+                 << "                   Expected: " << LHSStr << '\n'
+                 << "                   Which is: " << LHS << '\n'
+                 << "To be less than or equal to: " << RHSStr << '\n'
+                 << "                   Which is: " << RHS << '\n';
+    return false;
+  }
+
+  if (Cond == Cond_GT) {
+    if (LHS > RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::outs() << File << ":" << Line << ": FAILURE\n"
+                 << "          Expected: " << LHSStr << '\n'
+                 << "          Which is: " << LHS << '\n'
+                 << "To be greater than: " << RHSStr << '\n'
+                 << "          Which is: " << RHS << '\n';
+    return false;
+  }
+
+  if (Cond == Cond_GE) {
+    if (LHS >= RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::outs() << File << ":" << Line << ": FAILURE\n"
+                 << "                      Expected: " << LHSStr << '\n'
+                 << "                      Which is: " << LHS << '\n'
+                 << "To be greater than or equal to: " << RHSStr << '\n'
+                 << "                      Which is: " << RHS << '\n';
+    return false;
+  }
+
+  Ctx.markFail();
+  llvm::outs() << "Unexpected test condition.\n";
+  return false;
+}
+
+} // namespace internal
+
+Test *Test::Start = nullptr;
+Test *Test::End = nullptr;
+
+void Test::addTest(Test *T) {
+  if (End == nullptr) {
+    Start = T;
+    End = T;
+    return;
+  }
+
+  End->Next = T;
+  End = T;
+}
+
+int Test::runTests() {
+  int TestCount = 0;
+  int FailCount = 0;
+  for (Test *T = Start; T != nullptr; T = T->Next, ++TestCount) {
+    const char *TestName = T->getName();
+    llvm::outs() << "[ RUN      ] " << TestName << '\n';
+    RunContext Ctx;
+    T->SetUp();
+    T->Run(Ctx);
+    T->TearDown();
+    auto Result = Ctx.status();
+    if (Result == RunContext::Result_Fail) {
+      llvm::outs() << "[  FAILED  ] " << TestName << '\n';
+      ++FailCount;
+    } else if (Result == RunContext::Result_Pass) {
+      llvm::outs() << "[       OK ] " << TestName << '\n';
+    } else {
+      llvm::outs() << "Unexpected result after running " << TestName << '\n';
+    }
+  }
+
+  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<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<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<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<unsigned char, 0>(RunContext &Ctx, 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);
+
+template bool Test::test<unsigned int, 0>(RunContext &Ctx, 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,
+                                           unsigned long LHS, unsigned 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);
+
+bool Test::testStrEq(RunContext &Ctx, 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) {
+  return internal::test(Ctx, Cond_NE, llvm::StringRef(LHS),
+                        llvm::StringRef(RHS), LHSStr, RHSStr, File, Line);
+}
+
+} // namespace testing
+} // namespace llvm_libc
+
+int main() { return llvm_libc::testing::Test::runTests(); }