[libc] Move all tests to a top level `test` directory.

[sivachandra]

Summary

A toplevel target, check-libc has also been added.

[sivachandra]

This change is implementing the proposal I made in http://lists.llvm.org/pipermail/libc-dev/2019-December/000030.html

[sivachandra]

Thanks for the review. I have now pushed this change.

libc/CMakeLists.txt

 set(LIBC_TARGET_MACHINE ${CMAKE_SYSTEM_PROCESSOR})
 
 include(CMakeParseArguments)
 include(LLVMLibCRules)
 
 add_subdirectory(src)
 add_subdirectory(config)
 add_subdirectory(include)
-add_subdirectory(lib)
 add_subdirectory(utils)
+
+# The lib and test directories are added at the very end as tests
+# and libraries potentially draw from the components present in all
+# of the other directories.
+add_subdirectory(lib)
+add_subdirectory(test)

libc/config/linux/x86_64/CMakeLists.txt

-add_custom_target(libc_linux_x86_64_unittests)
-
-add_libc_unittest(
-  libc_linux_x86_64_syscall_unittest
-  SUITE libc_linux_x86_64_unittests
-  SRCS syscall_test.cpp
-  DEPENDS
-   syscall_impl_h
-   support_common_h
-)

libc/docs/source_layout.rst

 LLVM-libc Source Tree Layout
 ============================
 
 At the top-level, LLVM-libc source tree is organized in to the following
 directories::
 
    + libc
         - cmake
         - docs
         - include
         - lib
         - loader
         - src
+        - test
         + utils
             - build_scripts
             - testing
         - www
 
 Each of these directories is explained in detail below.
 
 The ``cmake`` directory

 1. There is a toplevel CMakeLists.txt file.
 2. For every public header file provided by llvm-libc, there exists a
    corresponding directory in the ``src`` directory. The name of the directory
    is same as the base name of the header file. For example, the directory
    corresponding to the public ``math.h`` header file is named ``math``. The
    implementation standard document explains more about the *header*
    directories.
 
+The ``test`` directory
+----------------------
+
+This directory contains tests for the various components of llvm-libc. The
+directory structure within this directory mirrors the directory structure of the
+toplevel ``libc`` directory itself. A test for, say the ``mmap`` function, lives
+in the directory ``test/src/sys/mman/`` as implementation of ``mmap`` lives in
+``src/sys/mman``.
+
 The ``www`` directory
 ---------------------
 
 The ``www`` directory contains the HTML content of libc.llvm.org
 
 The ``utils/build_scripts`` directory
 -------------------------------------
 
 This directory contains scripts which support the build system, tooling etc.
 
 The ``utils/testing`` directory
 -------------------------------
 
 This directory contains testing infrastructure.

libc/src/errno/CMakeLists.txt

 add_entrypoint_object(
   __errno_location
   SRCS
     errno_location.cpp
   HDRS
     llvmlibc_errno.h
 )
-
-add_custom_target(libc_errno_unittests)
-
-add_libc_unittest(
-  errno_test
-  SUITE
-    libc_errno_unittests
-  SRCS
-    errno_test.cpp
-  DEPENDS
-    __errno_location
-)

libc/src/string/CMakeLists.txt

-add_custom_target(libc_string_unittests)
-
 add_subdirectory(strcpy)
 add_subdirectory(strcat)

libc/src/string/strcat/CMakeLists.txt

 add_entrypoint_object(
   strcat
   SRCS
     strcat.cpp
   HDRS
     strcat.h
   DEPENDS
     strcpy
     string_h
 )
-
-add_libc_unittest(
-  strcat_test
-  SUITE
-    libc_string_unittests
-  SRCS
-    strcat_test.cpp
-  DEPENDS
-    strcat
-    strcpy
-)

libc/src/string/strcpy/CMakeLists.txt

 add_entrypoint_object(
   strcpy
   SRCS
     strcpy.cpp
   HDRS
     strcpy.h
   DEPENDS
     string_h
 )
-
-add_libc_unittest(
-  strcpy_test
-  SUITE
-    libc_string_unittests
-  SRCS
-    strcpy_test.cpp
-  DEPENDS
-    strcpy
-)

libc/src/sys/mman/CMakeLists.txt

add_entrypoint_object(
   HDRS
     munmap.h
   DEPENDS
     sys_mman_h
     sys_syscall_h
     syscall_impl_h
     __errno_location
 )
-
-add_custom_target(libc_sys_mman_unittests)
-
-add_libc_unittest(
-  mmap_test
-  SUITE
-    libc_sys_mman_unittests
-  SRCS
-    mmap_test.cpp
-  DEPENDS
-    mmap
-    munmap
-    __errno_location
-)

libc/test/CMakeLists.txt

+add_custom_target(check_libc)
+
+add_subdirectory(config)
+add_subdirectory(src)

libc/test/config/CMakeLists.txt

+add_subdirectory(linux)

libc/test/config/linux/CMakeLists.txt

+add_custom_target(libc_linux_tests)
+add_dependencies(check_libc libc_linux_tests)
+
+add_subdirectory(x86_64)

libc/test/config/linux/x86_64/CMakeLists.txt

+add_custom_target(libc_linux_x86_64_tests)
+add_dependencies(libc_linux_tests libc_linux_x86_64_tests)
+
+add_libc_unittest(
+  libc_linux_x86_64_syscall_unittest
+  SUITE libc_linux_x86_64_tests
+  SRCS syscall_test.cpp
+  DEPENDS
+   syscall_impl_h
+   support_common_h
+)

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

 //===------------------ Unittests for x86_64 syscalls ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/unistd/syscall.h"
 
 #include "gtest/gtest.h"
 
 #include <functional>
 
 TEST(X86_64_SyscallTest, APITest) {
   // We only do a signature test here. Actual functionality tests are
   // done by the unit tests of the syscall wrappers like mmap.
 
   std::function<long(long)> f([](long n) { return __llvm_libc::syscall(n); });
   std::function<long(long, long)> f1(
       [](long n, long a1) { return __llvm_libc::syscall(n, a1); });
   std::function<long(long, long, long)> f2(
       [](long n, long a1, long a2) { return __llvm_libc::syscall(n, a1, a2); });
   std::function<long(long, long, long, long)> f3(
       [](long n, long a1, long a2, long a3) {
         return __llvm_libc::syscall(n, a1, a2, a3);
       });
   std::function<long(long, long, long, long, long)> f4(
       [](long n, long a1, long a2, long a3, long a4) {
         return __llvm_libc::syscall(n, a1, a2, a3, a4);
       });
   std::function<long(long, long, long, long, long, long)> f5(
       [](long n, long a1, long a2, long a3, long a4, long a5) {
         return __llvm_libc::syscall(n, a1, a2, a3, a4, a5);
       });
   std::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);
       });
 }

libc/test/src/CMakeLists.txt

+add_subdirectory(errno)
+add_subdirectory(string)
+add_subdirectory(sys)

libc/test/src/errno/CMakeLists.txt

-add_entrypoint_object(
-  __errno_location
-  SRCS
-    errno_location.cpp
-  HDRS
-    llvmlibc_errno.h
-)
-
 add_custom_target(libc_errno_unittests)
+add_dependencies(check_libc libc_errno_unittests)
 
 add_libc_unittest(
   errno_test
   SUITE
     libc_errno_unittests
   SRCS
     errno_test.cpp
   DEPENDS
     __errno_location
 )

libc/test/src/errno/errno_test.cpp

 //===---------------------- Unittests for errno --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/errno/llvmlibc_errno.h"
 
 #include "gtest/gtest.h"
 
 TEST(ErrnoTest, Basic) {
   int test_val = 123;
   llvmlibc_errno = test_val;
   ASSERT_EQ(test_val, llvmlibc_errno);
 }

libc/test/src/string/CMakeLists.txt

+add_custom_target(libc_string_unittests)
+add_dependencies(check_libc libc_string_unittests)
+
+add_libc_unittest(
+  strcat_test
+  SUITE
+    libc_string_unittests
+  SRCS
+    strcat_test.cpp
+  DEPENDS
+    strcat
+    strcpy
+)
+
+add_libc_unittest(
+  strcpy_test
+  SUITE
+    libc_string_unittests
+  SRCS
+    strcpy_test.cpp
+  DEPENDS
+    strcpy
+)

libc/test/src/string/strcat_test.cpp

 //===---------------------- Unittests for strcat --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <string>
 
 #include "src/string/strcat/strcat.h"
 #include "gtest/gtest.h"
 
 TEST(StrCatTest, EmptyDest) {
   std::string abc = "abc";
   char dest[4];
 
   dest[0] = '\0';
 
   char *result = __llvm_libc::strcat(dest, abc.c_str());
   ASSERT_EQ(dest, result);
   ASSERT_EQ(std::string(dest), abc);
   ASSERT_EQ(std::string(dest).size(), abc.size());
 }
 
 TEST(StrCatTest, NonEmptyDest) {
   std::string abc = "abc";
   char dest[7];
 
   dest[0] = 'x';
   dest[1] = 'y';
   dest[2] = 'z';
   dest[3] = '\0';
 
   char *result = __llvm_libc::strcat(dest, abc.c_str());
   ASSERT_EQ(dest, result);
   ASSERT_EQ(std::string(dest), std::string("xyz") + abc);
   ASSERT_EQ(std::string(dest).size(), abc.size() + 3);
 }

libc/test/src/string/strcpy_test.cpp

 //===----------------------- Unittests for strcpy -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <string>
 
 #include "src/string/strcpy/strcpy.h"
 #include "gtest/gtest.h"
 
 TEST(StrCpyTest, EmptyDest) {
   std::string abc = "abc";
   char dest[4];
 
   char *result = __llvm_libc::strcpy(dest, abc.c_str());
   ASSERT_EQ(dest, result);
   ASSERT_EQ(std::string(dest), abc);
   ASSERT_EQ(std::string(dest).size(), abc.size());
 }
 
 TEST(StrCpyTest, OffsetDest) {
   std::string abc = "abc";
   char dest[7];
 
   dest[0] = 'x';
   dest[1] = 'y';
   dest[2] = 'z';
 
   char *result = __llvm_libc::strcpy(dest + 3, abc.c_str());
   ASSERT_EQ(dest + 3, result);
   ASSERT_EQ(std::string(dest), std::string("xyz") + abc);
   ASSERT_EQ(std::string(dest).size(), abc.size() + 3);
 }

libc/test/src/sys/CMakeLists.txt

+add_subdirectory(mman)

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

+add_custom_target(libc_sys_mman_unittests)
+add_dependencies(check_libc libc_sys_mman_unittests)
+
+add_libc_unittest(
+  mmap_test
+  SUITE
+    libc_sys_mman_unittests
+  SRCS
+    mmap_test.cpp
+  DEPENDS
+    mmap
+    munmap
+    __errno_location
+)

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

 //===------------------ Unittests for mmap and munmap ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/errno/llvmlibc_errno.h"
 #include "src/sys/mman/mmap.h"
 #include "src/sys/mman/munmap.h"
 
 #include "gtest/gtest.h"
 
 #include "errno.h"
 #include "sys/mman.h"
 
 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);
 
   int ret_val = __llvm_libc::munmap(addr, alloc_size);
   EXPECT_EQ(0, ret_val);
   EXPECT_EQ(0, llvmlibc_errno);
 }
 
 TEST(MMapTest, Error_InvalidSize) {
   llvmlibc_errno = 0;
   void *addr = __llvm_libc::mmap(nullptr, 0, PROT_READ,
                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   EXPECT_EQ(EINVAL, llvmlibc_errno);
   EXPECT_EQ(addr, MAP_FAILED);
 
   llvmlibc_errno = 0;
   int ret_val = __llvm_libc::munmap(0, 0);
   EXPECT_EQ(-1, ret_val);
   EXPECT_EQ(EINVAL, llvmlibc_errno);
 }