[libc] Make ErrnoSetterMatcher handle logging floating point values.

[sivachandra]

Summary

Along the way, couple of additional things have been done:

1. Move ErrnoSetterMatcher.h to test/UnitTest as all other matchers live there now.
2. ErrnoSetterMatcher ignores matching errno on GPUs.

[sivachandra]

Rebase

[jhuber6]

Applied locally, here's some errors while building,

In file included from /home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:10:
In file included from /home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/platform_errors.h:15:
In file included from /home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/tables/minimal_platform_errors.h:12:
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/tables/stdc_errors.h:22:16: error: use of undeclared identifier 'EILSEQ'
    MsgMapping(EILSEQ, "Invalid or incomplete multibyte or wide character"),
               ^
In file included from /home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:10:
In file included from /home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/platform_errors.h:15:
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/tables/minimal_platform_errors.h:16:23: error: constexpr variable 'PLATFORM_ERRORS' must be initialized by a constant expression
inline constexpr auto PLATFORM_ERRORS = STDC_ERRORS;
                      ^                 ~~~~~~~~~~~
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/tables/minimal_platform_errors.h:16:41: note: initializer of 'STDC_ERRORS' is unknown
inline constexpr auto PLATFORM_ERRORS = STDC_ERRORS;
                                        ^
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/tables/minimal_platform_errors.h:16:41: note: in call to 'array(STDC_ERRORS)'
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/tables/stdc_errors.h:18:36: note: declared here
inline constexpr const MsgTable<4> STDC_ERRORS = {
                                   ^
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:36:18: error: constexpr variable 'TOTAL_STR_LEN' must be initialized by a constant expression
constexpr size_t TOTAL_STR_LEN = total_str_len(PLATFORM_ERRORS);
                 ^               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/message_mapper.h:35:32: note: initializer of 'PLATFORM_ERRORS' is not a constant expression
  for (size_t i = 0; i < table.size(); ++i) {
                               ^
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:36:34: note: in call to 'total_str_len(PLATFORM_ERRORS)'
constexpr size_t TOTAL_STR_LEN = total_str_len(PLATFORM_ERRORS);
                                 ^
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/tables/minimal_platform_errors.h:16:23: note: declared here
inline constexpr auto PLATFORM_ERRORS = STDC_ERRORS;
                      ^
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:44:18: error: constexpr variable 'ERR_ARRAY_SIZE' must be initialized by a constant expression
constexpr size_t ERR_ARRAY_SIZE = max_key_val(PLATFORM_ERRORS) + 1;
                 ^                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/message_mapper.h:44:32: note: initializer of 'PLATFORM_ERRORS' is not a constant expression
  for (size_t i = 0; i < table.size(); ++i) {
                               ^
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:44:35: note: in call to 'max_key_val(PLATFORM_ERRORS)'
constexpr size_t ERR_ARRAY_SIZE = max_key_val(PLATFORM_ERRORS) + 1;
                                  ^
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/tables/minimal_platform_errors.h:16:23: note: declared here
inline constexpr auto PLATFORM_ERRORS = STDC_ERRORS;
                      ^
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:46:25: error: non-type template argument is not a constant expression
constexpr MessageMapper<ERR_ARRAY_SIZE, TOTAL_STR_LEN>
                        ^~~~~~~~~~~~~~
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:46:25: note: initializer of 'ERR_ARRAY_SIZE' is not a constant expression
/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:44:18: note: declared here
constexpr size_t ERR_ARRAY_SIZE = max_key_val(PLATFORM_ERRORS) + 1;
                 ^
5 errors generated.

[sivachandra]

Add EILSEQ to the list of generic error number macros.

[jhuber6]

New failure due to thread_local

/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:34:1: error: thread-local storage is not supported for the current target
thread_local char error_buffer[ERR_BUFFER_SIZE];
^

[sivachandra]

I think all of those errors have a single root cause that EILSEQ was missing from the list of generic error numbers. I have added it now. Can you give it another try?

[jhuber6]

In D151129#4373075, @sivachandra wrote:

I think all of those errors have a single root cause that EILSEQ was missing from the list of generic error numbers. I have added it now. Can you give it another try?

Yes, I think we just need to make the thread_local error buffer a regular integer on platforms without errno. (Same reason we can't support it in the first place).

[sivachandra]

In D151129#4373077, @jhuber6 wrote:

In D151129#4373075, @sivachandra wrote:

I think all of those errors have a single root cause that EILSEQ was missing from the list of generic error numbers. I have added it now. Can you give it another try?

Yes, I think we just need to make the thread_local error buffer a regular integer on platforms without errno. (Same reason we can't support it in the first place).

Few things:

1. This patch is likely titled incorrectly titled because I uploaded when I wanted to quickly show how we can ignore testing for errno. I totally happy to remove that part (re-title this patch anyway).
2. If you want to consider GPU to be a platform without errno, that is up to you. But, This question goes beyond errno. Is the GPU platform in general a platform without thread local variable support? If yes, we need to say that somewhere and give guidance on how to detect C library function errors.
3. Is the libc project groups and patches the right forum to discuss/decide about GPU errno?

[jhuber6]

In D151129#4373139, @sivachandra wrote:

In D151129#4373077, @jhuber6 wrote:

In D151129#4373075, @sivachandra wrote:

I think all of those errors have a single root cause that EILSEQ was missing from the list of generic error numbers. I have added it now. Can you give it another try?

Yes, I think we just need to make the thread_local error buffer a regular integer on platforms without errno. (Same reason we can't support it in the first place).

Few things:

1. This patch is likely titled incorrectly titled because I uploaded when I wanted to quickly show how we can ignore testing for errno. I totally happy to remove that part (re-title this patch anyway).

Okay, this prevented running the existing tests on the GPU so it should at least be worked around for this to land.

2. If you want to consider GPU to be a platform without errno, that is up to you. But, This question goes beyond errno. Is the GPU platform in general a platform without thread local variable support? If yes, we need to say that somewhere and give guidance on how to detect C library function errors.

That's the simplest solution right now. The GPU does have thread local memory, it comes from the stack. It's very limited but it does exist. The problem is that this stack variable would require each executing kernel on the GPU to initialize the variables. There's basically a few ways to get around this if we really wanted to support it.

1. Preallocate global memory in the GPU loader such that every software thread has a slot.
2. Statically allocate 1024 integers in block-local memory and index out of it.
3. Perform an alloca instruction from the bottom of the stack and initialize it
4. Set up true codegen for the GPU that basically does 3 but automatically. This would require a lot of fun with sections like how TLS is handled on Linux to implement properly.
5. Ignore it completely.
6. Make it a global and have data races

3. Is the libc project groups and patches the right forum to discuss/decide about GPU errno?

I'm not sure, there hasn't exactly been an outcry from the GPU community for errno support. Speaking frankly most users would only *really* care about malloc, free, and `printf. Most everything else can be seen as supplemental.

[sivachandra]

In D151129#4373162, @jhuber6 wrote:

In D151129#4373139, @sivachandra wrote:

In D151129#4373077, @jhuber6 wrote:

In D151129#4373075, @sivachandra wrote:

I think all of those errors have a single root cause that EILSEQ was missing from the list of generic error numbers. I have added it now. Can you give it another try?

Yes, I think we just need to make the thread_local error buffer a regular integer on platforms without errno. (Same reason we can't support it in the first place).

Few things:

1. This patch is likely titled incorrectly titled because I uploaded when I wanted to quickly show how we can ignore testing for errno. I totally happy to remove that part (re-title this patch anyway).

Okay, this prevented running the existing tests on the GPU so it should at least be worked around for this to land.

How is the latest version of this patch?

2. If you want to consider GPU to be a platform without errno, that is up to you. But, This question goes beyond errno. Is the GPU platform in general a platform without thread local variable support? If yes, we need to say that somewhere and give guidance on how to detect C library function errors.

That's the simplest solution right now. The GPU does have thread local memory, it comes from the stack. It's very limited but it does exist. The problem is that this stack variable would require each executing kernel on the GPU to initialize the variables. There's basically a few ways to get around this if we really wanted to support it.

1. Preallocate global memory in the GPU loader such that every software thread has a slot.
2. Statically allocate 1024 integers in block-local memory and index out of it.
3. Perform an alloca instruction from the bottom of the stack and initialize it
4. Set up true codegen for the GPU that basically does 3 but automatically. This would require a lot of fun with sections like how TLS is handled on Linux to implement properly.
5. Ignore it completely.
6. Make it a global and have data races

3. Is the libc project groups and patches the right forum to discuss/decide about GPU errno?

I'm not sure, there hasn't exactly been an outcry from the GPU community for errno support. Speaking frankly most users would only *really* care about malloc, free, and `printf. Most everything else can be seen as supplemental.

I will leave it up to you to drive this discussion in the appropriate forums. Even things like, should there be an errno.h in the GPU libc with relevant error macros exposed? For the current work in the libc around this, I only view them as "workarounds" which will help make progress with making more of the libc available on the GPUs while the fundamental questions are being sorted out.

[jhuber6]

Did you update the patch? It's still got the same error:

/home/jhuber/Documents/llvm/llvm-project/libc/src/__support/StringUtil/error_to_string.cpp:34:1: error: thread-local storage is not supported for the current target
thread_local char error_buffer[ERR_BUFFER_SIZE];
^
1 error generated.

[sivachandra]

Rebase

[jhuber6]

Works now, thanks!

libc/cmake/modules/LLVMLibCTestRules.cmake

message(FATAL_ERROR "'add_libc_unittest' target requires a SRCS list of .cpp "
                         "files.")
   endif()
   if(NOT LIBC_UNITTEST_DEPENDS)
     message(FATAL_ERROR "'add_libc_unittest' target requires a DEPENDS list of "
                         "'add_entrypoint_object' targets.")
   endif()
 
   get_fq_deps_list(fq_deps_list ${LIBC_UNITTEST_DEPENDS})
+  list(APPEND fq_deps_list libc.src.__support.StringUtil.error_to_string
+                           libc.test.UnitTest.ErrnoSetterMatcher)
+  list(REMOVE_DUPLICATES fq_deps_list)
   get_object_files_for_test(
       link_object_files skipped_entrypoints_list ${fq_deps_list})
   if(skipped_entrypoints_list)
     # If a test is OS/target machine independent, it has to be skipped if the
     # OS/target machine combination does not provide any dependent entrypoints.
     # If a test is OS/target machine specific, then such a test will live is a
     # OS/target machine specific directory and will be skipped at the directory
     # level if required.
list(APPEND fq_deps_list
       # We always add the memory functions objects. This is because the
       # compiler's codegen can emit calls to the C memory functions.
       libc.src.string.bcmp
       libc.src.string.bzero
       libc.src.string.memcmp
       libc.src.string.memcpy
       libc.src.string.memmove
       libc.src.string.memset
+      libc.src.__support.StringUtil.error_to_string
   )
   list(REMOVE_DUPLICATES fq_deps_list)
 
   # TODO: Instead of gathering internal object files from entrypoints,
   # collect the object files with public names of entrypoints.
   get_object_files_for_test(
       link_object_files skipped_entrypoints_list ${fq_deps_list})
   if(skipped_entrypoints_list)
PRIVATE
       libc.startup.${LIBC_TARGET_OS}.crt1
       ${link_libraries}
       LibcTest.hermetic
       LibcHermeticTestSupport.hermetic
       # The NVIDIA 'nvlink' linker does not currently support static libraries.
       $<$<NOT:$<BOOL:${LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX}>>:${fq_target_name}.__libc__>)
   add_dependencies(${fq_build_target_name}
                    LibcTest.hermetic
+                   libc.test.UnitTest.ErrnoSetterMatcher
                    ${fq_deps_list})
 
   # Tests on the GPU require an external loader utility to launch the kernel.
   if(TARGET libc.utils.gpu.loader)
     add_dependencies(${fq_build_target_name} libc.utils.gpu.loader)
     get_target_property(gpu_loader_exe libc.utils.gpu.loader "EXECUTABLE")
   endif()
 

libc/include/llvm-libc-macros/generic-error-number-macros.h

 #define EFBIG 27
 #define ENOSPC 28
 #define ESPIPE 29
 #define EROFS 30
 #define EMLINK 31
 #define EPIPE 32
 #define EDOM 33
 #define ERANGE 34
+#define EILSEQ 35
 
 #endif // __LLVM_LIBC_MACROS_GENERIC_ERROR_NUMBER_MACROS_H

libc/test/CMakeLists.txt

 add_custom_target(check-libc)
 add_custom_target(libc-unit-tests)
 add_custom_target(libc-hermetic-tests)
 add_dependencies(check-libc libc-unit-tests libc-hermetic-tests)
 
 add_custom_target(exhaustive-check-libc)
 add_custom_target(libc-long-running-tests)
 
 add_subdirectory(UnitTest)
 
 add_header_library(
   errno_setter_matcher
   HDRS
     ErrnoSetterMatcher.h
   DEPENDS
+    libc.src.__support.common
+    libc.src.__support.FPUtil.fp_bits
+    libc.src.__support.StringUtil.error_to_string
     libc.src.errno.errno
 )
 
 if(LIBC_TARGET_ARCHITECTURE_IS_GPU AND
    (NOT TARGET libc.utils.gpu.loader OR NOT TARGET libc.startup.gpu.crt1))
   message(WARNING "Cannot build libc GPU tests, missing loader implementation")
   return()
 endif()

libc/test/UnitTest/CMakeLists.txt

add_unittest_framework_library(
   HDRS
     ScanfMatcher.h
   DEPENDS
     LibcTest
     libc.src.__support.FPUtil.fp_bits
     libc.src.stdio.scanf_core.core_structs
     libc.test.UnitTest.string_utils
 )
+
+add_header_library(
+  ErrnoSetterMatcher
+  HDRS
+    ErrnoSetterMatcher
+)

libc/test/UnitTest/ErrnoSetterMatcher.h

 //===-- ErrnoSetterMatcher.h ------------------------------------*- 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_TEST_ERRNOSETTERMATCHER_H
 #define LLVM_LIBC_TEST_ERRNOSETTERMATCHER_H
 
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/__support/StringUtil/error_to_string.h"
+#include "src/__support/macros/properties/architectures.h"
 #include "src/errno/libc_errno.h"
 #include "test/UnitTest/Test.h"
 
-#include <string.h>
-
 namespace __llvm_libc {
 namespace testing {
 
 namespace internal {
 
 template <typename T> class ErrnoSetterMatcher : public Matcher<T> {
   T ExpectedReturn;
   T ActualReturn;
   int ExpectedErrno;
   int ActualErrno;
 
+  // Even though this is a errno matcher primarily, it has to cater to platforms
+  // which do not have an errno. This predicate checks if errno matching is to
+  // be skipped.
+  static constexpr bool ignore_errno() {
+#ifdef LIBC_TARGET_ARCH_IS_GPU
+    return true;
+#else
+    return false;
+#endif
+  }
+
 public:
   ErrnoSetterMatcher(T ExpectedReturn, int ExpectedErrno)
       : ExpectedReturn(ExpectedReturn), ExpectedErrno(ExpectedErrno) {}
 
   void explainError() override {
-    if (ActualReturn != ExpectedReturn)
+    if (ActualReturn != ExpectedReturn) {
+      if constexpr (cpp::is_floating_point_v<T>) {
         __llvm_libc::testing::tlog
-          << "Expected return to be " << ExpectedReturn << " but got "
-          << ActualReturn << ".\nExpecte errno to be "
-          << strerror(ExpectedErrno) << " but got " << strerror(ActualErrno)
-          << ".\n";
-    else
+            << "Expected return value to be: "
+            << __llvm_libc::fputil::FPBits<T>(ExpectedReturn).str() << '\n';
         __llvm_libc::testing::tlog
-          << "Correct value " << ExpectedReturn
-          << " was returned\nBut errno was unexpectely set to "
-          << strerror(ActualErrno) << ".\n";
+            << "                    But got: "
+            << __llvm_libc::fputil::FPBits<T>(ActualReturn).str() << '\n';
+      } else {
+        __llvm_libc::testing::tlog << "Expected return value to be "
+                                   << ExpectedReturn << " but got "
+                                   << ActualReturn << ".\n";
+      }
+    }
+
+    if constexpr (!ignore_errno()) {
+      if (ActualErrno != ExpectedErrno) {
+        __llvm_libc::testing::tlog
+            << "Expected errno to be \"" << get_error_string(ExpectedErrno)
+            << "\" but got \"" << get_error_string(ActualErrno) << "\".\n";
+      }
+    }
   }
 
   bool match(T Got) {
     ActualReturn = Got;
     ActualErrno = libc_errno;
     libc_errno = 0;
+    if constexpr (ignore_errno())
+      return Got == ExpectedReturn;
+    else
       return Got == ExpectedReturn && ActualErrno == ExpectedErrno;
   }
 };
 
 } // namespace internal
 
 namespace ErrnoSetterMatcher {
 
 template <typename RetT = int>

libc/test/src/fcntl/creat_test.cpp

 //===-- Unittest for creat ------------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/creat.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcCreatTest, CreatAndOpen) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "testdata/creat.test";
   int fd = __llvm_libc::creat(TEST_FILE, S_IRWXU);
   ASSERT_EQ(libc_errno, 0);
   ASSERT_GT(fd, 0);

libc/test/src/fcntl/openat_test.cpp

 //===-- Unittests for openat ----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/fcntl/openat.h"
 #include "src/unistd/close.h"
 #include "src/unistd/read.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 
 TEST(LlvmLibcUniStd, OpenAndReadTest) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_DIR = "testdata";
   constexpr const char *TEST_FILE = "openat.test";

libc/test/src/sched/affinity_test.cpp

 //===-- Unittests for sched_getaffinity and sched_setaffinity -------------===//
 //
 // 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/__support/OSUtil/syscall.h"
 #include "src/errno/libc_errno.h"
 #include "src/sched/sched_getaffinity.h"
 #include "src/sched/sched_setaffinity.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 
 #include <sched.h>
 #include <sys/syscall.h>
 
 TEST(LlvmLibcSchedAffinityTest, SmokeTest) {
   cpu_set_t mask;
   libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/sched/cpu_count_test.cpp

 //===-- Unittests for __sched_cpu_count -----------------------------------===//
 //
 // 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/__support/OSUtil/syscall.h"
 #include "src/errno/libc_errno.h"
 #include "src/sched/sched_getaffinity.h"
 #include "src/sched/sched_getcpucount.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 
 #include <sched.h>
 #include <sys/syscall.h>
 
 TEST(LlvmLibcSchedCpuCountTest, SmokeTest) {
   cpu_set_t mask;
   libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/signal/kill_test.cpp

 //===-- Unittests for kill -----------------------------------------------===//
 //
 // 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/signal/kill.h"
 
 #include "include/sys/syscall.h"          // For syscall numbers.
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <signal.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 TEST(LlvmLibcKillTest, TargetSelf) {
   pid_t parent_pid = __llvm_libc::syscall_impl(SYS_getpid);

libc/test/src/signal/sigaction_test.cpp

 //===-- Unittests for sigaction -------------------------------------------===//
 //
 // 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/signal/raise.h"
 #include "src/signal/sigaction.h"
 
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 #include <signal.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 

libc/test/src/signal/sigaddset_test.cpp

 //===-- Unittests for sigaddset -------------------------------------------===//
 //
 // 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/signal.h"
 #include "src/signal/sigaddset.h"
 
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 
 // This tests invalid inputs and ensures errno is properly set.
 TEST(LlvmLibcSignalTest, SigaddsetInvalid) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/signal/sigaltstack_test.cpp

 //===-- Unittests for sigaltstack -----------------------------------------===//
 //
 // 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/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/errno/libc_errno.h"
 #include "src/signal/linux/signal_utils.h"
 #include "src/signal/raise.h"
 #include "src/signal/sigaction.h"
 #include "src/signal/sigaltstack.h"
 
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <signal.h>
 #include <stdint.h>
 #include <sys/syscall.h>
 
 constexpr int LOCAL_VAR_SIZE = 512;
 constexpr int ALT_STACK_SIZE = SIGSTKSZ + LOCAL_VAR_SIZE * 2;

libc/test/src/signal/sigdelset_test.cpp

 //===-- Unittests for sigdelset -------------------------------------------===//
 //
 // 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/signal.h"
 #include "src/signal/raise.h"
 #include "src/signal/sigdelset.h"
 #include "src/signal/sigfillset.h"
 #include "src/signal/sigprocmask.h"
 
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 
 TEST(LlvmLibcSigdelset, Invalid) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   // Invalid set.
   EXPECT_THAT(__llvm_libc::sigdelset(nullptr, SIGUSR1), Fails(EINVAL));

libc/test/src/signal/sigfillset_test.cpp

 //===-- Unittests for sigfillset ------------------------------------------===//
 //
 // 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/signal.h"
 #include "src/signal/raise.h"
 #include "src/signal/sigfillset.h"
 #include "src/signal/sigprocmask.h"
 
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 
 TEST(LlvmLibcSigfillset, Invalid) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   EXPECT_THAT(__llvm_libc::sigfillset(nullptr), Fails(EINVAL));
 }
 
 TEST(LlvmLibcSigfillset, BlocksAll) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   sigset_t set;
   EXPECT_THAT(__llvm_libc::sigfillset(&set), Succeeds());
   EXPECT_THAT(__llvm_libc::sigprocmask(SIG_SETMASK, &set, nullptr), Succeeds());
   EXPECT_EXITS([] { __llvm_libc::raise(SIGUSR1); }, 0);
 }

libc/test/src/signal/signal_test.cpp

 //===-- Unittests for signal ----------------------------------------------===//
 //
 // 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/signal.h"
 #include "src/errno/libc_errno.h"
 #include "src/signal/raise.h"
 #include "src/signal/signal.h"
 
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 TEST(LlvmLibcSignal, Invalid) {
   libc_errno = 0;
   __llvm_libc::sighandler_t valid = +[](int) {};

libc/test/src/signal/sigprocmask_test.cpp

 //===-- Unittests for sigprocmask -----------------------------------------===//
 //
 // 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/signal.h"
 #include "src/errno/libc_errno.h"
 #include "src/signal/raise.h"
 #include "src/signal/sigaddset.h"
 #include "src/signal/sigemptyset.h"
 #include "src/signal/sigprocmask.h"
 
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 class LlvmLibcSignalTest : public __llvm_libc::testing::Test {
   sigset_t oldSet;
 
 public:
   void SetUp() override { __llvm_libc::sigprocmask(0, nullptr, &oldSet); }
 

libc/test/src/stdio/remove_test.cpp

 //===-- Unittests for remove ----------------------------------------------===//
 //
 // 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/fcntl/open.h"
 #include "src/stdio/remove.h"
 #include "src/sys/stat/mkdirat.h"
 #include "src/unistd/access.h"
 #include "src/unistd/close.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include "src/errno/libc_errno.h"
 #include <unistd.h>
 
 TEST(LlvmLibcRemoveTest, CreateAndRemoveFile) {
   // The test strategy is to create a file and remove it, and also verify that
   // it was removed.

libc/test/src/stdlib/CMakeLists.txt

 add_custom_target(libc-stdlib-tests)
 
 add_libc_test(
   atof_test
   SUITE
     libc-stdlib-tests
   SRCS
     atof_test.cpp
   DEPENDS
     libc.src.errno.errno
     libc.src.stdlib.atof
+    libc.test.errno_setter_matcher
 )
 
 add_header_library(
   atoi_test_support
   HDRS
     AtoiTest.h
   DEPENDS
     libc.src.errno.errno

libc/test/src/stdlib/atof_test.cpp

 //===-- Unittests for atof ------------------------------------------------===//
 //
 // 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/__support/FPUtil/FPBits.h"
 #include "src/errno/libc_errno.h"
 #include "src/stdlib/atof.h"
 
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <limits.h>
 #include <stddef.h>
 
+using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
+
 // This is just a simple test to make sure that this function works at all. It's
 // functionally identical to strtod so the bulk of the testing is there.
 TEST(LlvmLibcAToFTest, SimpleTest) {
   __llvm_libc::fputil::FPBits<double> expected_fp =
       __llvm_libc::fputil::FPBits<double>(uint64_t(0x405ec00000000000));
 
   libc_errno = 0;
-  double result = __llvm_libc::atof("123");
-
-  __llvm_libc::fputil::FPBits<double> actual_fp =
-      __llvm_libc::fputil::FPBits<double>(result);
-
-  EXPECT_EQ(actual_fp.bits, expected_fp.bits);
-  EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
-  EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
-  EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
-  EXPECT_EQ(libc_errno, 0);
+  EXPECT_THAT(__llvm_libc::atof("123"),
+              Succeeds<double>(static_cast<double>(expected_fp)));
 }
 
 TEST(LlvmLibcAToFTest, FailedParsingTest) {
-  __llvm_libc::fputil::FPBits<double> expected_fp =
-      __llvm_libc::fputil::FPBits<double>(uint64_t(0));
-
   libc_errno = 0;
-  double result = __llvm_libc::atof("???");
-
-  __llvm_libc::fputil::FPBits<double> actual_fp =
-      __llvm_libc::fputil::FPBits<double>(result);
-
-  EXPECT_EQ(actual_fp.bits, expected_fp.bits);
-  EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
-  EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
-  EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
-  EXPECT_EQ(libc_errno, 0);
+  // atof does not flag errors.
+  EXPECT_THAT(__llvm_libc::atof("???"), Succeeds<double>(0.0));
 }

libc/test/src/stdlib/strtod_test.cpp

 //===-- Unittests for strtod ---------------------------------------------===//
 //
 // 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/__support/FPUtil/FPBits.h"
 #include "src/errno/libc_errno.h"
 #include "src/stdlib/strtod.h"
 
-#include "test/UnitTest/FPMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/RoundingModeUtils.h"
 #include "test/UnitTest/Test.h"
 
 #include <limits.h>
 #include <stddef.h>
 
 using __llvm_libc::fputil::testing::ForceRoundingModeTest;
 using __llvm_libc::fputil::testing::RoundingMode;
 
+using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
+using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
+
 class LlvmLibcStrToDTest : public __llvm_libc::testing::Test,
                            ForceRoundingModeTest<RoundingMode::Nearest> {
 public:
   void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
                 const uint64_t expectedRawData, const int expectedErrno = 0) {
     // expectedRawData is the expected double result as a uint64_t, organized
     // according to IEEE754:
     //
void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
     //  This is so that the result can be compared in parts.
     char *str_end = nullptr;
 
     __llvm_libc::fputil::FPBits<double> expected_fp =
         __llvm_libc::fputil::FPBits<double>(expectedRawData);
 
     libc_errno = 0;
     double result = __llvm_libc::strtod(inputString, &str_end);
-
+    if (expectedErrno == 0)
+      EXPECT_THAT(result, Succeeds<double>(static_cast<double>(expected_fp)));
+    else
+      EXPECT_THAT(result, Fails<double>(expectedErrno,
+                                        static_cast<double>(expected_fp)));
     EXPECT_EQ(str_end - inputString, expectedStrLen);
-    EXPECT_FP_EQ(result, static_cast<double>(expected_fp));
-    EXPECT_EQ(libc_errno, expectedErrno);
   }
 };
 
 TEST_F(LlvmLibcStrToDTest, SimpleTest) {
   run_test("123", 3, uint64_t(0x405ec00000000000));
 
   // This should fail on Eisel-Lemire, forcing a fallback to simple decimal
   // conversion.

libc/test/src/sys/mman/linux/madvise_test.cpp

 //===-- Unittests for madvise ---------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/sys/mman/madvise.h"
 #include "src/sys/mman/mmap.h"
 #include "src/sys/mman/munmap.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <sys/mman.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 TEST(LlvmLibcMadviseTest, NoError) {

libc/test/src/sys/mman/linux/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 "src/errno/libc_errno.h"
 #include "src/sys/mman/mmap.h"
 #include "src/sys/mman/munmap.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <sys/mman.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 TEST(LlvmLibcMMapTest, NoError) {

libc/test/src/sys/mman/linux/mprotect_test.cpp

 //===-- Unittests for mprotect --------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/sys/mman/mmap.h"
 #include "src/sys/mman/mprotect.h"
 #include "src/sys/mman/munmap.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <signal.h>
 #include <sys/mman.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 

libc/test/src/sys/mman/linux/posix_madvise_test.cpp

 //===-- Unittests for posix_madvise ---------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/sys/mman/mmap.h"
 #include "src/sys/mman/munmap.h"
 #include "src/sys/mman/posix_madvise.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <sys/mman.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 TEST(LlvmLibcPosixMadviseTest, NoError) {

libc/test/src/sys/random/linux/getrandom_test.cpp

 //===-- Unittests for getrandom -------------------------------------------===//
 //
 // 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/__support/CPP/array.h"
 #include "src/errno/libc_errno.h"
 #include "src/math/fabs.h"
 #include "src/sys/random/getrandom.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcGetRandomTest, InvalidFlag) {
   __llvm_libc::cpp::array<char, 10> buffer;
   libc_errno = 0;
   ASSERT_THAT(__llvm_libc::getrandom(buffer.data(), buffer.size(), -1),
               __llvm_libc::testing::ErrnoSetterMatcher::Fails(EINVAL));
 }

libc/test/src/sys/resource/getrlimit_setrlimit_test.cpp

 //===-- Unittests for getrlimit and setrlimit -----------------------------===//
 //
 // 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/__support/CPP/string_view.h"
 #include "src/errno/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/sys/resource/getrlimit.h"
 #include "src/sys/resource/setrlimit.h"
 #include "src/unistd/close.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <sys/resource.h>
 
 TEST(LlvmLibcResourceLimitsTest, SetNoFileLimit) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 

libc/test/src/sys/select/select_failure_test.cpp

 //===-- Failure unittests for select --------------------------------------===//
 //
 // 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/select/select.h"
 #include "src/unistd/read.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 #include <sys/select.h>
 #include <unistd.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 

libc/test/src/sys/sendfile/sendfile_test.cpp

 //===-- Unittests for sendfile --------------------------------------------===//
 //
 // 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/__support/CPP/string_view.h"
 #include "src/errno/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/sys/sendfile/sendfile.h"
 #include "src/unistd/close.h"
 #include "src/unistd/read.h"
 #include "src/unistd/unlink.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 
 namespace cpp = __llvm_libc::cpp;
 
 TEST(LlvmLibcSendfileTest, CreateAndTransfer) {

libc/test/src/sys/stat/chmod_test.cpp

 //===-- Unittests for chmod -----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/sys/stat/chmod.h"
 #include "src/unistd/close.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 
 TEST(LlvmLibcChmodTest, ChangeAndOpen) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/sys/stat/fchmod_test.cpp

 //===-- Unittests for fchmod ----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/sys/stat/fchmod.h"
 #include "src/unistd/close.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 
 TEST(LlvmLibcChmodTest, ChangeAndOpen) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/sys/stat/fchmodat_test.cpp

 //===-- Unittests for fchmodat --------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/sys/stat/fchmodat.h"
 #include "src/unistd/close.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 
 TEST(LlvmLibcFchmodatTest, ChangeAndOpen) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/sys/stat/fstat_test.cpp

 //===-- Unittests for fstat -----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/sys/stat/fstat.h"
 #include "src/unistd/close.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 
 TEST(LlvmLibcFStatTest, CreatAndReadMode) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/sys/stat/lstat_test.cpp

 //===-- Unittests for lstat -----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/sys/stat/lstat.h"
 #include "src/unistd/close.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 
 TEST(LlvmLibcLStatTest, CreatAndReadMode) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/sys/stat/mkdirat_test.cpp

 //===-- Unittests for mkdirat ---------------------------------------------===//
 //
 // 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/stat/mkdirat.h"
 #include "src/unistd/rmdir.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 
 TEST(LlvmLibcMkdiratTest, CreateAndRemove) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_DIR = "testdata/mkdirat.testdir";
   ASSERT_THAT(__llvm_libc::mkdirat(AT_FDCWD, TEST_DIR, S_IRWXU), Succeeds(0));
   ASSERT_THAT(__llvm_libc::rmdir(TEST_DIR), Succeeds(0));
 }
 
 TEST(LlvmLibcMkdiratTest, BadPath) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   ASSERT_THAT(__llvm_libc::mkdirat(AT_FDCWD, "non-existent-dir/test", S_IRWXU),
               Fails(ENOENT));
 }

libc/test/src/sys/stat/stat_test.cpp

 //===-- Unittests for stat ------------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/sys/stat/stat.h"
 #include "src/unistd/close.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 
 TEST(LlvmLibcStatTest, CreatAndReadMode) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/sys/utsname/uname_test.cpp

 //===-- Unittests for uname -----------------------------------------------===//
 //
 // 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/__support/CPP/string_view.h"
 #include "src/__support/macros/properties/architectures.h"
 #include "src/sys/utsname/uname.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 #include <sys/utsname.h>
 
 TEST(LlvmLibcUnameTest, GetMachineName) {
   struct utsname names;
   ASSERT_GE(__llvm_libc::uname(&names), 0);
 #ifdef LIBC_TARGET_ARCH_IS_X86_64
   ASSERT_STREQ(names.machine, "x86_64");
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
   ASSERT_STREQ(names.machine, "aarch64");
 #endif
 }

libc/test/src/sys/wait/wait4_test.cpp

 //===-- Unittests for wait4 -----------------------------------------------===//
 //
 // 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/wait/wait4.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 #include <sys/wait.h>
 
 // The test here is a simpl test for WNOHANG functionality. For a more
 // involved test, look at fork_test.
 
 TEST(LlvmLibcwait4Test, NoHangTest) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   int status;
   ASSERT_THAT(__llvm_libc::wait4(-1, &status, WNOHANG, nullptr), Fails(ECHILD));
 }

libc/test/src/sys/wait/waitpid_test.cpp

 //===-- Unittests for waitpid ---------------------------------------------===//
 //
 // 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/wait/waitpid.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 #include <sys/wait.h>
 
 // The test here is a simpl test for WNOHANG functionality. For a more
 // involved test, look at fork_test.
 
 TEST(LlvmLibcWaitPidTest, NoHangTest) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   int status;
   ASSERT_THAT(__llvm_libc::waitpid(-1, &status, WNOHANG), Fails(ECHILD));
 }

libc/test/src/termios/termios_test.cpp

 #include "src/termios/cfgetispeed.h"
 #include "src/termios/cfgetospeed.h"
 #include "src/termios/cfsetispeed.h"
 #include "src/termios/cfsetospeed.h"
 #include "src/termios/tcgetattr.h"
 #include "src/termios/tcgetsid.h"
 #include "src/termios/tcsetattr.h"
 #include "src/unistd/close.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <termios.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 // We just list a bunch of smoke tests here as it is not possible to

libc/test/src/time/difftime_test.cpp

 //===-- Unittests for difftime --------------------------------------------===//
 //
 // 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/__support/FPUtil/FPBits.h"
 #include "src/time/difftime.h"
 #include "src/time/time_utils.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 using __llvm_libc::time_utils::TimeConstants;
 
 TEST(LlvmLibcDifftime, SmokeTest) {
   time_t t1_seconds = TimeConstants::SECONDS_PER_HOUR;
   time_t t2_seconds = 0;

libc/test/src/time/gettimeofday_test.cpp

 //===-- Unittests for gettimeofday ----------------------------------------===//
 //
 // 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 <time.h>
 
 #include "src/time/gettimeofday.h"
 #include "src/time/nanosleep.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 namespace cpp = __llvm_libc::cpp;
 
 TEST(LlvmLibcGettimeofday, SmokeTest) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   void *tz = nullptr;
   struct timeval tv;

libc/test/src/time/gmtime_test.cpp

 //===-- Unittests for gmtime ----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/time/gmtime.h"
 #include "src/time/time_utils.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 #include "test/src/time/TmMatcher.h"
 
 #include <limits.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 using __llvm_libc::time_utils::TimeConstants;

libc/test/src/time/mktime_test.cpp

 //===-- Unittests for mktime ----------------------------------------------===//
 //
 // 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/time/mktime.h"
 #include "src/time/time_utils.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 #include "test/src/time/TmHelper.h"
 #include "test/src/time/TmMatcher.h"
 
 #include <limits.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/time/nanosleep_test.cpp

 //===-- Unittests for nanosleep -------------------------------------------===//
 //
 // 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 <time.h>
 
 #include "src/errno/libc_errno.h"
 #include "src/time/nanosleep.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 namespace cpp = __llvm_libc::cpp;
 
 TEST(LlvmLibcNanosleep, SmokeTest) {
   // TODO: When we have the code to read clocks, test that time has passed.
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   libc_errno = 0;
 
   struct timespec tim = {1, 500};
   struct timespec tim2 = {0, 0};
   int ret = __llvm_libc::nanosleep(&tim, &tim2);
   ASSERT_EQ(libc_errno, 0);
   ASSERT_EQ(ret, 0);
 }

libc/test/src/unistd/access_test.cpp

 //===-- Unittests for access ----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/access.h"
 #include "src/unistd/close.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <unistd.h>
 
 TEST(LlvmLibcAccessTest, CreateAndTest) {
   // The test strategy is to repeatedly create a file in different modes and
   // test that it is accessable in those modes but not in others.
   libc_errno = 0;

libc/test/src/unistd/chdir_test.cpp

 //===-- Unittests for chdir -----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/chdir.h"
 #include "src/unistd/close.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 
 TEST(LlvmLibcChdirTest, ChangeAndOpen) {
   // The idea of this test is that we will first open an existing test file
   // without changing the directory to make sure it exists. Next, we change
   // directory and open the same file to make sure that the "chdir" operation

libc/test/src/unistd/dup2_test.cpp

 //===-- Unittests for dup -------------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/dup2.h"
 #include "src/unistd/read.h"
 #include "src/unistd/unlink.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcdupTest, ReadAndWriteViaDup) {
   constexpr int DUPFD = 0xD0;
   libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "testdata/dup2.test";
   int fd = __llvm_libc::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);

libc/test/src/unistd/dup3_test.cpp

 //===-- Unittests for dup3 ------------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/dup3.h"
 #include "src/unistd/read.h"
 #include "src/unistd/unlink.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 // The tests here are exactly the same as those of dup2. We only test the
 // plumbing of the dup3 syscall and not the dup3 functionality itself as it is
 // a simple syscall wrapper. Testing dup3 functionality is beyond the scope of
 // this test.
 
 TEST(LlvmLibcdupTest, ReadAndWriteViaDup) {

libc/test/src/unistd/dup_test.cpp

 //===-- Unittests for dup -------------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/dup.h"
 #include "src/unistd/read.h"
 #include "src/unistd/unlink.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcdupTest, ReadAndWriteViaDup) {
   libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "testdata/dup.test";
   int fd = __llvm_libc::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
   ASSERT_EQ(libc_errno, 0);

libc/test/src/unistd/fchdir_test.cpp

 //===-- Unittests for fchdir ----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/fchdir.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 
 TEST(LlvmLibcChdirTest, ChangeAndOpen) {
   // The idea of this test is that we will first open an existing test file
   // without changing the directory to make sure it exists. Next, we change
   // directory and open the same file to make sure that the "fchdir" operation

libc/test/src/unistd/ftruncate_test.cpp

 //===-- Unittests for ftruncate -------------------------------------------===//
 //
 // 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/__support/CPP/string_view.h"
 #include "src/errno/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/ftruncate.h"
 #include "src/unistd/read.h"
 #include "src/unistd/unlink.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 namespace cpp = __llvm_libc::cpp;
 
 TEST(LlvmLibcFtruncateTest, CreateAndTruncate) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char TEST_FILE[] = "testdata/ftruncate.test";
   constexpr const char WRITE_DATA[] = "hello, ftruncate";

libc/test/src/unistd/isatty_test.cpp

 //===-- Unittests for isatty ----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/isatty.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 TEST(LlvmLibcIsATTYTest, StdInOutTests) {
   // If stdin is connected to a terminal, assume that all of the standard i/o
   // fds are.

libc/test/src/unistd/link_test.cpp

 //===-- Unittests for link ------------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/link.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcLinkTest, CreateAndUnlink) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "testdata/link.test";
   constexpr const char *TEST_FILE_LINK = "testdata/link.test.link";
 
   // The test strategy is as follows:

libc/test/src/unistd/linkat_test.cpp

 //===-- Unittests for linkat ----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/linkat.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcLinkatTest, CreateAndUnlink) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_DIR = "testdata";
   constexpr const char *TEST_FILE = "linkat.test";
   constexpr const char *TEST_FILE_PATH = "testdata/linkat.test";
   constexpr const char *TEST_FILE_LINK = "linkat.test.link";

libc/test/src/unistd/lseek_test.cpp

 //===-- Unittests for lseek -----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/lseek.h"
 #include "src/unistd/read.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <unistd.h>
 
 TEST(LlvmLibcUniStd, LseekTest) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "testdata/lseek.test";
   int fd = __llvm_libc::open(TEST_FILE, O_RDONLY);

libc/test/src/unistd/pread_pwrite_test.cpp

 //===-- Unittests for pread and pwrite ------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/fsync.h"
 #include "src/unistd/pread.h"
 #include "src/unistd/pwrite.h"
 #include "src/unistd/unlink.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcUniStd, PWriteAndPReadBackTest) {
   // The strategy here is that we first create a file and write to it. Next,
   // we open that file again and write at an offset. Finally, we open the
   // file again and pread at an offset and make sure that only expected data
   // is being read back. This also confirms that pwrite happened successfully.
   constexpr const char HELLO[] = "hello";

libc/test/src/unistd/read_write_test.cpp

 //===-- Unittests for read and write --------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/fsync.h"
 #include "src/unistd/read.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcUniStd, WriteAndReadBackTest) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "__unistd_read_write.test";
   int write_fd = __llvm_libc::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
   ASSERT_EQ(libc_errno, 0);
   ASSERT_GT(write_fd, 0);

libc/test/src/unistd/readlink_test.cpp

 //===-- Unittests for readlink --------------------------------------------===//
 //
 // 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/__support/CPP/string_view.h"
 #include "src/errno/libc_errno.h"
 #include "src/unistd/readlink.h"
 #include "src/unistd/symlink.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 namespace cpp = __llvm_libc::cpp;
 
 TEST(LlvmLibcReadlinkTest, CreateAndUnlink) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char LINK_VAL[] = "readlink_test_value";
   constexpr const char LINK[] = "testdata/readlink.test.link";

libc/test/src/unistd/readlinkat_test.cpp

 //===-- Unittests for readlinkat ------------------------------------------===//
 //
 // 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/__support/CPP/string_view.h"
 #include "src/errno/libc_errno.h"
 #include "src/unistd/readlinkat.h"
 #include "src/unistd/symlink.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 
 namespace cpp = __llvm_libc::cpp;
 
 TEST(LlvmLibcReadlinkatTest, CreateAndUnlink) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;

libc/test/src/unistd/rmdir_test.cpp

 //===-- Unittests for rmdir -----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/sys/stat/mkdir.h"
 #include "src/unistd/rmdir.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 
 TEST(LlvmLibcRmdirTest, CreateAndRemove) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_DIR = "testdata/rmdir.testdir";
   ASSERT_THAT(__llvm_libc::mkdir(TEST_DIR, S_IRWXU), Succeeds(0));
   ASSERT_THAT(__llvm_libc::rmdir(TEST_DIR), Succeeds(0));
 }
 
 TEST(LlvmLibcRmdirTest, RemoveNonExistentDir) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   ASSERT_THAT(__llvm_libc::rmdir("testdata/non-existent-dir"), Fails(ENOENT));
 }

libc/test/src/unistd/symlink_test.cpp

 //===-- Unittests for symlink ---------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/symlink.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcSymlinkTest, CreateAndUnlink) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE_BASE = "symlink.test";
   constexpr const char *TEST_FILE = "testdata/symlink.test";
   constexpr const char *TEST_FILE_LINK = "testdata/symlink.test.symlink";
 

libc/test/src/unistd/symlinkat_test.cpp

 //===-- Unittests for symlinkat -------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/symlinkat.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcSymlinkatTest, CreateAndUnlink) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_DIR = "testdata";
   constexpr const char *TEST_FILE = "symlinkat.test";
   constexpr const char *TEST_FILE_PATH = "testdata/symlinkat.test";
   constexpr const char *TEST_FILE_LINK = "symlinkat.test.link";

libc/test/src/unistd/syscall_test.cpp

 //===-- Unittests for 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/errno/libc_errno.h"
 #include "src/unistd/syscall.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 #include <unistd.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 

libc/test/src/unistd/truncate_test.cpp

 //===-- Unittests for truncate --------------------------------------------===//
 //
 // 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/__support/CPP/string_view.h"
 #include "src/errno/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/read.h"
 #include "src/unistd/truncate.h"
 #include "src/unistd/unlink.h"
 #include "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 namespace cpp = __llvm_libc::cpp;
 
 TEST(LlvmLibcTruncateTest, CreateAndTruncate) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char TEST_FILE[] = "testdata/truncate.test";
   constexpr const char WRITE_DATA[] = "hello, truncate";

libc/test/src/unistd/unlink_test.cpp

 //===-- Unittests for unlink ----------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "src/unistd/unlink.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcUnlinkTest, CreateAndUnlink) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "testdata/unlink.test";
   int write_fd = __llvm_libc::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
   ASSERT_EQ(libc_errno, 0);
   ASSERT_GT(write_fd, 0);
   ASSERT_THAT(__llvm_libc::close(write_fd), Succeeds(0));
   ASSERT_THAT(__llvm_libc::unlink(TEST_FILE), Succeeds(0));
 }
 
 TEST(LlvmLibcUnlinkTest, UnlinkNonExistentFile) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   ASSERT_THAT(__llvm_libc::unlink("testdata/non-existent-file"), Fails(ENOENT));
 }

libc/test/src/unistd/unlinkat_test.cpp

 //===-- Unittests for unlinkat --------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/fcntl/openat.h"
 #include "src/unistd/close.h"
 #include "src/unistd/unlinkat.h"
-#include "test/ErrnoSetterMatcher.h"
+#include "test/UnitTest/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcUnlinkatTest, CreateAndDeleteTest) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_DIR = "testdata";
   constexpr const char *TEST_FILE = "openat.test";
   int dir_fd = __llvm_libc::open(TEST_DIR, O_DIRECTORY);
   ASSERT_EQ(libc_errno, 0);