[libc] Wrap unittests in __llvm_libc namespace. NFC

[PaulkaToast]

Summary

Some of our tests were wrapped in __llvm_libc namespace, while other were not. This patch makes them consistent and prevent upcoming test CalleeNamespaceCheck from triggering on things like memcpy_test helper functions.

[MaskRay]

http://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

[abrachet]

If the goal is to not need to explicitly use the __llvm_libc:: prefix in our tests we could change the TEST macro to put the class it makes in __llvm_libc instead of needing to remember to explicitly put our tests in __llvm_libc. Granted it isn't difficult to remember to put new tests in the namespace but I don't think there is any clear advantage to requiring it either.

[sivachandra]

What is the problem if we do not wrap the tests in __llvm_libc namespace?

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 "config/linux/syscall.h"
 #include "utils/UnitTest/Test.h"
 
 #include "utils/CPP/Functional.h"
 
+namespace __llvm_libc {
+
 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.
 
   using __llvm_libc::cpp::function;
 
   function<long(long)> f([](long n) { return __llvm_libc::syscall(n); });
   function<long(long, long)> f1(
TEST(X86_64_SyscallTest, APITest) {
   function<long(long, long, long, long, long, long, long)> f6(
       [](long n, long a1, long a2, long a3, long a4, long a5, long a6) {
         return __llvm_libc::syscall(n, a1, a2, a3, a4, a5, a6);
       });
 
   function<long(long, void *)> notLongType(
       [](long n, void *a1) { return __llvm_libc::syscall(n, a1); });
 }
+
+} // namespace __llvm_libc

libc/test/loader/linux/args_test.cpp

 //===-- Loader test to check args to main ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #undef NDEBUG
 #include "src/assert/assert.h"
 
+namespace __llvm_libc {
+
 static bool my_streq(const char *lhs, const char *rhs) {
   const char *l, *r;
   for (l = lhs, r = rhs; *l != '\0' && *r != '\0'; ++l, ++r)
     if (*l != *r)
       return false;
 
   return *l == '\0' && *r == '\0';
 }
if (my_streq(*envp, "GERMANY=Berlin"))
       found_germany = true;
   }
 
   assert(found_france && found_germany &&
          "Did not find whats expected in envp.");
 
   return 0;
 }
+
+} // namespace __llvm_libc

libc/test/src/assert/assert_test.cpp

 //===-- Unittests for assert ----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #undef NDEBUG
 #include "src/assert/assert.h"
 #include "utils/UnitTest/Test.h"
 
 extern "C" int close(int);
 
+namespace __llvm_libc {
+
 TEST(Assert, Enabled) {
   // -1 matches against any signal, which is necessary for now until
   // __llvm_libc::abort() unblocks SIGABRT. Close standard error for the
   // child process so we don't print the assertion failure message.
   EXPECT_DEATH(
       [] {
         close(2);
         assert(0);
       },
       -1);
 }
 
 #define NDEBUG
 #include "src/assert/assert.h"
 
 TEST(Assert, Disabled) {
   EXPECT_EXITS([] { assert(0); }, 0);
 }
+
+} // namespace __llvm_libc

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 "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 TEST(ErrnoTest, Basic) {
   int test_val = 123;
   llvmlibc_errno = test_val;
   ASSERT_EQ(test_val, llvmlibc_errno);
 }
+
+} // namespace __llvm_libc

libc/test/src/signal/raise_test.cpp

 //===-- Unittests for raise -----------------------------------------------===//
 //
 // 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 "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 TEST(SignalTest, Raise) {
   // SIGCONT is ingored unless stopped, so we can use it to check the return
   // value of raise without needing to block.
   EXPECT_EQ(__llvm_libc::raise(SIGCONT), 0);
 
   // SIGKILL is chosen because other fatal signals could be caught by sanitizers
   // for example and incorrectly report test failure.
   EXPECT_DEATH([] { __llvm_libc::raise(SIGKILL); }, SIGKILL);
 }
+
+} // namespace __llvm_libc

libc/test/src/signal/sigaction_test.cpp

 #include "src/signal/sigaction.h"
 
 #include "utils/UnitTest/ErrnoSetterMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
+namespace __llvm_libc {
+
 TEST(Sigaction, Invalid) {
   // -1 is a much larger signal that NSIG, so this should fail.
   EXPECT_THAT(__llvm_libc::sigaction(-1, nullptr, nullptr), Fails(EINVAL));
 }
 
 // SIGKILL cannot have its action changed, but it can be examined.
 TEST(Sigaction, Sigkill) {
   struct __sigaction action;

 TEST(Sigaction, Ignore) {
   struct __sigaction action;
   EXPECT_THAT(__llvm_libc::sigaction(SIGUSR1, nullptr, &action), Succeeds());
   action.sa_handler = SIG_IGN;
   EXPECT_THAT(__llvm_libc::sigaction(SIGUSR1, &action, nullptr), Succeeds());
 
   EXPECT_EXITS([] { __llvm_libc::raise(SIGUSR1); }, 0);
 }
+
+} // namespace __llvm_libc

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/errno.h"
 #include "include/signal.h"
 #include "src/signal/sigaddset.h"
 
 #include "utils/UnitTest/ErrnoSetterMatcher.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 // This tests invalid inputs and ensures errno is properly set.
 TEST(SignalTest, SigaddsetInvalid) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   EXPECT_THAT(__llvm_libc::sigaddset(nullptr, SIGSEGV), Fails(EINVAL));
 
   sigset_t sigset;
   EXPECT_THAT(__llvm_libc::sigaddset(&sigset, -1), Fails(EINVAL));
 
   // This doesn't use NSIG because __llvm_libc::sigaddset error checking is
   // against sizeof(sigset_t) not NSIG.
   constexpr int bitsInSigsetT = 8 * sizeof(sigset_t);
 
   EXPECT_THAT(__llvm_libc::sigaddset(&sigset, bitsInSigsetT + 1),
               Fails(EINVAL));
   EXPECT_THAT(__llvm_libc::sigaddset(&sigset, 0), Fails(EINVAL));
   EXPECT_THAT(__llvm_libc::sigaddset(&sigset, bitsInSigsetT), Succeeds());
 }
+
+} // namespace __llvm_libc

libc/test/src/signal/sigdelset_test.cpp

 #include "src/signal/raise.h"
 #include "src/signal/sigdelset.h"
 #include "src/signal/sigfillset.h"
 #include "src/signal/sigprocmask.h"
 
 #include "utils/UnitTest/ErrnoSetterMatcher.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 TEST(Sigdelset, Invalid) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   // Invalid set.
   EXPECT_THAT(__llvm_libc::sigdelset(nullptr, SIGUSR1), Fails(EINVAL));
 
   sigset_t set;
   // Valid set, invalid signum.
   EXPECT_THAT(__llvm_libc::sigdelset(&set, -1), Fails(EINVAL));
 }
 
 TEST(Sigdelset, UnblockOne) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   sigset_t set;
   EXPECT_THAT(__llvm_libc::sigfillset(&set), Succeeds());
   EXPECT_THAT(__llvm_libc::sigdelset(&set, SIGUSR1), Succeeds());
   EXPECT_THAT(__llvm_libc::sigprocmask(SIG_SETMASK, &set, nullptr), Succeeds());
   EXPECT_DEATH([] { __llvm_libc::raise(SIGUSR1); }, SIGUSR1);
 }
+
+} // namespace __llvm_libc

libc/test/src/signal/sigfillset_test.cpp

 #include "include/signal.h"
 #include "src/signal/raise.h"
 #include "src/signal/sigfillset.h"
 #include "src/signal/sigprocmask.h"
 
 #include "utils/UnitTest/ErrnoSetterMatcher.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 TEST(Sigfillset, Invalid) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   EXPECT_THAT(__llvm_libc::sigfillset(nullptr), Fails(EINVAL));
 }
 
 TEST(Sigfillset, 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);
 }
+
+} // namespace __llvm_libc

libc/test/src/signal/signal_test.cpp

 #include "src/signal/signal.h"
 
 #include "utils/UnitTest/ErrnoSetterMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
+namespace __llvm_libc {
+
 TEST(Signal, Invalid) {
   llvmlibc_errno = 0;
   __llvm_libc::sighandler_t valid = +[](int) {};
   EXPECT_THAT((void *)__llvm_libc::signal(0, valid),
               Fails(EINVAL, (void *)SIG_ERR));
   EXPECT_THAT((void *)__llvm_libc::signal(65, valid),
               Fails(EINVAL, (void *)SIG_ERR));
 }
 
 static int sum;
 TEST(Signal, Basic) {
   // In case test get run multiple times.
   sum = 0;
   ASSERT_NE(__llvm_libc::signal(SIGUSR1, +[](int) { sum++; }),
             SIG_ERR);
   ASSERT_THAT(__llvm_libc::raise(SIGUSR1), Succeeds());
   EXPECT_EQ(sum, 1);
   for (int i = 0; i < 10; i++)
     ASSERT_THAT(__llvm_libc::raise(SIGUSR1), Succeeds());
   EXPECT_EQ(sum, 11);
 }
+
+} // namespace __llvm_libc

libc/test/src/signal/sigprocmask_test.cpp

 #include "src/signal/raise.h"
 #include "src/signal/sigaddset.h"
 #include "src/signal/sigemptyset.h"
 #include "src/signal/sigprocmask.h"
 
 #include "utils/UnitTest/ErrnoSetterMatcher.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 class SignalTest : public __llvm_libc::testing::Test {
   sigset_t oldSet;
 
 public:
   void SetUp() override { __llvm_libc::sigprocmask(0, nullptr, &oldSet); }
 
   void TearDown() override {
     __llvm_libc::sigprocmask(SIG_SETMASK, &oldSet, nullptr);
TEST_F(SignalTest, BlockUnblock) {
   sigset_t sigset;
   EXPECT_EQ(__llvm_libc::sigemptyset(&sigset), 0);
   EXPECT_EQ(__llvm_libc::sigprocmask(SIG_SETMASK, &sigset, nullptr), 0);
   EXPECT_DEATH([] { __llvm_libc::raise(SIGUSR1); }, SIGUSR1);
   EXPECT_EQ(__llvm_libc::sigaddset(&sigset, SIGUSR1), 0);
   EXPECT_EQ(__llvm_libc::sigprocmask(SIG_SETMASK, &sigset, nullptr), 0);
   EXPECT_EXITS([] { __llvm_libc::raise(SIGUSR1); }, 0);
 }
+
+} // namespace __llvm_libc

libc/test/src/stdio/fwrite_test.cpp

 //===-- Unittests for fwrite ----------------------------------------------===//
 //
 // 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/stdio/FILE.h"
 #include "src/stdio/fwrite.h"
 #include "utils/CPP/Array.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 TEST(Stdio, FWriteBasic) {
   struct StrcpyFile : __llvm_libc::FILE {
     char *buf;
   } f;
   char array[6];
   f.buf = array;
   f.write = +[](__llvm_libc::FILE *file, const char *ptr, size_t size) {
     StrcpyFile *strcpyFile = static_cast<StrcpyFile *>(file);
     for (size_t i = 0; i < size; ++i)
       strcpyFile->buf[i] = ptr[i];
     return size;
   };
   EXPECT_EQ(fwrite("hello", 1, 6, &f), 6UL);
   EXPECT_STREQ(array, "hello");
 }
+
+} // namespace __llvm_libc

libc/test/src/stdlib/_Exit_test.cpp

 //===-- Unittests for _Exit -----------------------------------------------===//
 //
 // 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/stdlib.h"
 #include "src/stdlib/_Exit.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 TEST(Stdlib, _Exit) {
   EXPECT_EXITS([] { __llvm_libc::_Exit(1); }, 1);
   EXPECT_EXITS([] { __llvm_libc::_Exit(65); }, 65);
 }
+
+} // namespace __llvm_libc

libc/test/src/stdlib/abort_test.cpp

 //===-- Unittests for abort -----------------------------------------------===//
 //
 // 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 "include/stdlib.h"
 #include "src/stdlib/abort.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 TEST(Stdlib, abort) {
   // -1 matches against any signal, which is necessary for now until
   // __llvm_libc::abort() unblocks SIGABRT.
   EXPECT_DEATH([] { __llvm_libc::abort(); }, -1);
 }
+
+} // namespace __llvm_libc

libc/test/src/string/memcpy_test.cpp

 #include "utils/UnitTest/Test.h"
 #include "src/string/memcpy.h"
 
 using __llvm_libc::cpp::Array;
 using __llvm_libc::cpp::ArrayRef;
 using __llvm_libc::cpp::MutableArrayRef;
 using Data = Array<char, 2048>;
 
+namespace __llvm_libc {
+
 static const ArrayRef<char> kNumbers("0123456789", 10);
 static const ArrayRef<char> kDeadcode("DEADC0DE", 8);
 
 // Returns a Data object filled with a repetition of `filler`.
 Data getData(ArrayRef<char> filler) {
   Data out;
   for (size_t i = 0; i < out.size(); ++i)
     out[i] = filler[i % filler.size()];
for (size_t align = 0; align < 64; ++align) {
         ASSERT_EQ(buffer[i], dirty[i]);
     }
   }
 }
 
 // FIXME: Add tests with reads and writes on the boundary of a read/write
 // protected page to check we're not reading nor writing prior/past the allowed
 // regions.
+
+} // namespace __llvm_libc

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

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

libc/test/src/string/strlen_test.cpp

 //===-- Unittests for strlen ----------------------------------------------===//
 //
 // 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/string/strlen.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 TEST(StrLenTest, EmptyString) {
   const char *empty = "";
 
   size_t result = __llvm_libc::strlen(empty);
   ASSERT_EQ((size_t)0, result);
 }
 
 TEST(StrLenTest, AnyString) {
   const char *any = "Hello World!";
 
   size_t result = __llvm_libc::strlen(any);
   ASSERT_EQ((size_t)12, result);
 }
+
+} // namespace __llvm_libc

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

 #include "src/sys/mman/mmap.h"
 #include "src/sys/mman/munmap.h"
 #include "utils/UnitTest/ErrnoSetterMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
+namespace __llvm_libc {
+
 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);
 
   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);
   EXPECT_THAT(__llvm_libc::munmap(addr, alloc_size), Succeeds());
 }
 
 TEST(MMapTest, Error_InvalidSize) {
   llvmlibc_errno = 0;
   void *addr = __llvm_libc::mmap(nullptr, 0, PROT_READ,
                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   EXPECT_THAT(addr, Fails(EINVAL, MAP_FAILED));
 
   EXPECT_THAT(__llvm_libc::munmap(0, 0), Fails(EINVAL));
 }
+
+} // namespace __llvm_libc

libc/test/src/threads/mtx_test.cpp

 //===-- Unittests for mtx_t -----------------------------------------------===//
 //
 // 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/threads.h"
 #include "src/threads/mtx_init.h"
 #include "src/threads/mtx_lock.h"
 #include "src/threads/mtx_unlock.h"
 #include "src/threads/thrd_create.h"
 #include "src/threads/thrd_join.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 constexpr int START = 0;
 constexpr int MAX = 10000;
 
 mtx_t mutex;
 static int shared_int = START;
 
 int counter(void *arg) {
   int last_count = START;
while (true) {
     if (current_step_value)
       break;
   }
 
   int retval = 123;
   __llvm_libc::thrd_join(&thread, &retval);
   ASSERT_EQ(retval, 0);
 }
+
+} // namespace __llvm_libc

libc/test/src/threads/thrd_test.cpp

 //===-- Unittests for thrd_t ----------------------------------------------===//
 //
 // 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/threads.h"
 #include "src/threads/thrd_create.h"
 #include "src/threads/thrd_join.h"
 #include "utils/UnitTest/Test.h"
 
+namespace __llvm_libc {
+
 static constexpr int thread_count = 1000;
 static int counter = 0;
 static int thread_func(void *) {
   ++counter;
   return 0;
 }
 
 TEST(ThreadTest, CreateAndJoin) {
TEST(ThreadTest, SpawnAndJoin) {
 
   for (int i = 0; i < thread_count; ++i) {
     int retval = thread_count + 1; // Start with a retval we dont expect.
     ASSERT_EQ(__llvm_libc::thrd_join(&thread_list[i], &retval),
               (int)thrd_success);
     ASSERT_EQ(retval, i);
   }
 }
+
+} // namespace __llvm_libc

libc/test/src/unistd/write_test.cpp

 //===-- Unittests for 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 "include/errno.h"
 #include "src/unistd/write.h"
 #include "utils/UnitTest/ErrnoSetterMatcher.h"
 #include "utils/UnitTest/Test.h"
 #include "utils/testutils/FDReader.h"
 
+namespace __llvm_libc {
+
 TEST(UniStd, WriteBasic) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *hello = "hello";
   __llvm_libc::testutils::FDReader reader;
   EXPECT_THAT(__llvm_libc::write(reader.getWriteFD(), hello, 5), Succeeds(5));
   EXPECT_TRUE(reader.matchWritten(hello));
 }
 
 TEST(UniStd, WriteFails) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 
   EXPECT_THAT(__llvm_libc::write(-1, "", 1), Fails(EBADF));
   EXPECT_THAT(__llvm_libc::write(1, reinterpret_cast<const void *>(-1), 1),
               Fails(EFAULT));
 }
+
+} // namespace __llvm_libc