[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

19

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

19

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

14

This include is unnecessary I think.

148

This one is still to outs

155

ditto

158

ditto

164

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

23

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

148

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

33–36

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

[phosek]

LGTM

libc/utils/UnitTest/Test.cpp

119

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.

150

This could also be a switch.

libc/utils/UnitTest/Test.h

96

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

33–36

No harm to keep them I guess :)

libc/utils/UnitTest/Test.h

96

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());
-  ASSERT_EQ(dest, result);
-  ASSERT_EQ(std::string(dest), abc);
-  ASSERT_EQ(std::string(dest).size(), abc.size());
+  char *result = __llvm_libc::strcat(dest, abc);
+  ASSERT_PTREQ(dest, result);
+  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());
-  ASSERT_EQ(dest, result);
-  ASSERT_EQ(std::string(dest), std::string("xyz") + abc);
-  ASSERT_EQ(std::string(dest).size(), abc.size() + 3);
+  char *result = __llvm_libc::strcat(dest, abc);
+  ASSERT_PTREQ(dest, result);
+  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());
-  ASSERT_EQ(dest, result);
-  ASSERT_EQ(std::string(dest), abc);
-  ASSERT_EQ(std::string(dest).size(), abc.size());
+  char *result = __llvm_libc::strcpy(dest, abc);
+  ASSERT_PTREQ(dest, result);
+  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());
-  ASSERT_EQ(dest + 3, result);
-  ASSERT_EQ(std::string(dest), std::string("xyz") + abc);
-  ASSERT_EQ(std::string(dest).size(), abc.size() + 3);
+  char *result = __llvm_libc::strcpy(dest + 3, abc);
+  ASSERT_PTREQ(dest + 3, result);
+  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);
+  EXPECT_PTRNE(addr, MAP_FAILED);
 
   int *array = reinterpret_cast<int *>(addr);
   // Reading from the memory should not crash the test.
   // Since we used the MAP_ANONYMOUS flag, the contents of the newly
   // allocated memory should be initialized to zero.
   EXPECT_EQ(array[0], 0);
 
   int ret_val = __llvm_libc::munmap(addr, alloc_size);
   EXPECT_EQ(0, ret_val);
   EXPECT_EQ(0, llvmlibc_errno);
 }
 
 TEST(MMapTest, Error_InvalidSize) {
   llvmlibc_errno = 0;
   void *addr = __llvm_libc::mmap(nullptr, 0, PROT_READ,
                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   EXPECT_EQ(EINVAL, llvmlibc_errno);
-  EXPECT_EQ(addr, MAP_FAILED);
+  EXPECT_PTREQ(addr, MAP_FAILED);
 
   llvmlibc_errno = 0;
   int ret_val = __llvm_libc::munmap(0, 0);
   EXPECT_EQ(-1, ret_val);
   EXPECT_EQ(EINVAL, llvmlibc_errno);
 }

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;
+};
+
+class RunContext;
+
+// 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:
+  // 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 Condition {
+    Cond_None,
+    Cond_EQ,
+    Cond_NE,
+    Cond_LT,
+    Cond_LE,
+    Cond_GT,
+    Cond_GE,
+  };
+
+  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, Condition Cond, ValType LHS, ValType RHS,
+                   const char *LHSStr, const char *RHSStr, const char *File,
+                   unsigned long 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, 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, 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, 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, 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, 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, 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
+
+#define EXPECT_PTREQ(LHS, RHS)                                                 \
+  llvm_libc::testing::Test::test(Ctx, Cond_EQ, (unsigned long long)(LHS),      \
+                                 (unsigned long long)(RHS), #LHS, #RHS,        \
+                                 __FILE__, __LINE__)
+#define ASSERT_PTREQ(LHS, RHS)                                                 \
+  if (!EXPECT_PTREQ(LHS, RHS))                                                 \
+  return
+
+#define EXPECT_PTRNE(LHS, RHS)                                                 \
+  llvm_libc::testing::Test::test(Ctx, Cond_NE, (unsigned long long)(LHS),      \
+                                 (unsigned long long)(RHS), #LHS, #RHS,        \
+                                 __FILE__, __LINE__)
+#define ASSERT_PTRNE(LHS, RHS)                                                 \
+  if (!EXPECT_PTRNE(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"
+
+#include <string>
+
+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 testing
+} // namespace llvm_libc
+
+template <typename ValType>
+static bool test(llvm_libc::testing::RunContext &Ctx,
+                 llvm_libc::testing::Test::Condition Cond, ValType LHS,
+                 ValType RHS, const char *LHSStr, const char *RHSStr,
+                 const char *File, unsigned long Line) {
+  if (Cond == llvm_libc::testing::Test::Cond_EQ) {
+    if (LHS == RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::errs() << 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 == llvm_libc::testing::Test::Cond_NE) {
+    if (LHS != RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::errs() << 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 == llvm_libc::testing::Test::Cond_LT) {
+    if (LHS < RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::errs() << 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 == llvm_libc::testing::Test::Cond_LE) {
+    if (LHS <= RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::errs() << 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 == llvm_libc::testing::Test::Cond_GT) {
+    if (LHS > RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::errs() << 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 == llvm_libc::testing::Test::Cond_GE) {
+    if (LHS >= RHS)
+      return true;
+
+    Ctx.markFail();
+    llvm::errs() << 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::errs() << "Unexpected test condition.\n";
+  return false;
+}
+
+namespace llvm_libc {
+namespace testing {
+
+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::errs() << "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, Test::Condition Cond, char LHS,
+                         char RHS, const char *LHSStr, const char *RHSStr,
+                         const char *File, unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
+}
+
+template <>
+bool Test::test<short, 0>(RunContext &Ctx, Test::Condition Cond, short LHS,
+                          short RHS, const char *LHSStr, const char *RHSStr,
+                          const char *File, unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
+}
+
+template <>
+bool Test::test<int, 0>(RunContext &Ctx, Test::Condition Cond, int LHS, int RHS,
+                        const char *LHSStr, const char *RHSStr,
+                        const char *File, unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
+}
+
+template <>
+bool Test::test<long, 0>(RunContext &Ctx, Test::Condition Cond, long LHS,
+                         long RHS, const char *LHSStr, const char *RHSStr,
+                         const char *File, unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
+}
+
+template <>
+bool Test::test<long long, 0>(RunContext &Ctx, Test::Condition Cond,
+                              long long LHS, long long RHS, const char *LHSStr,
+                              const char *RHSStr, const char *File,
+                              unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
+}
+
+template <>
+bool Test::test<unsigned char, 0>(RunContext &Ctx, Test::Condition Cond,
+                                  unsigned char LHS, unsigned char RHS,
+                                  const char *LHSStr, const char *RHSStr,
+                                  const char *File, unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
+}
+
+template <>
+bool Test::test<unsigned short, 0>(RunContext &Ctx, Test::Condition Cond,
+                                   unsigned short LHS, unsigned short RHS,
+                                   const char *LHSStr, const char *RHSStr,
+                                   const char *File, unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
+}
+
+template <>
+bool Test::test<unsigned int, 0>(RunContext &Ctx, Test::Condition Cond,
+                                 unsigned int LHS, unsigned int RHS,
+                                 const char *LHSStr, const char *RHSStr,
+                                 const char *File, unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
+}
+
+template <>
+bool Test::test<unsigned long, 0>(RunContext &Ctx, Test::Condition Cond,
+                                  unsigned long LHS, unsigned long RHS,
+                                  const char *LHSStr, const char *RHSStr,
+                                  const char *File, unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
+}
+
+template <>
+bool Test::test<unsigned long long, 0>(RunContext &Ctx, Test::Condition Cond,
+                                       unsigned long long LHS,
+                                       unsigned long long RHS,
+                                       const char *LHSStr, const char *RHSStr,
+                                       const char *File, unsigned long Line) {
+  return ::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, 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 ::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 ::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(); }