[libc] Run all unit tests, irrespective of whether they belong to a test suite.

[sivachandra]

Summary

Previously, only those unit tests which belonged to a suite were run as
part of libc-unit-tests. It meant that unit tests not part of any suite
were not being tested. This change makes all unit tests run as part of
libc-unit-tests. The convenience function to add a libc unit test suite
has been removed and add_custom_target is used in its place. One of the
bit-rotting test has along been fixed. Math exhaustive and differential
tests are skipped under full build.

[michaelrj]

libc/test/src/math/CMakeLists.txt

1575

is there a better way to do this so that these tests can still be built under fullbuild, even if they aren't part of the default set?

[sivachandra]

libc/test/src/math/CMakeLists.txt

1575

The exhaustive tests (use MPFR) and differential tests (compare against the system libc) are built against the system libc/system libraries. So, we cannot build them cleanly in the full build mode wherein we assume no system libraries are available.

[michaelrj]

LGTM

libc/test/src/math/CMakeLists.txt

1575

That makes sense.

[sivachandra]

Add a few explicit casts which are required on a few bots.

libc/cmake/modules/LLVMLibCTestRules.cmake

function(create_libc_unittest fq_target_name)
   endif()
 
   if(LIBC_UNITTEST_SUITE)
     add_dependencies(
       ${LIBC_UNITTEST_SUITE}
       ${fq_target_name}
     )
   endif()
+  add_dependencies(libc-unit-tests ${fq_target_name})
 endfunction(create_libc_unittest)
 
 # Internal function, used by `add_libc_unittest`.
 function(expand_flags_for_libc_unittest target_name flags)
   cmake_parse_arguments(
     "EXPAND_FLAGS"
     "IGNORE_MARKER" # No Optional arguments
     "" # No Single-value arguments
expand_flags_for_libc_unittest(
     ${fq_target_name}
     "${flags}"
     DEPENDS ${fq_deps_list} IGNORE_MARKER
     FLAGS ${flags} IGNORE_MARKER
     ${ADD_TO_EXPAND_UNPARSED_ARGUMENTS}
   )
 endfunction(add_libc_unittest)
 
-function(add_libc_testsuite suite_name)
-  add_custom_target(${suite_name})
-  add_dependencies(libc-unit-tests ${suite_name})
-endfunction(add_libc_testsuite)
-
 function(add_libc_exhaustive_testsuite suite_name)
   add_custom_target(${suite_name})
   add_dependencies(exhaustive-check-libc ${suite_name})
 endfunction(add_libc_exhaustive_testsuite)
 
 function(add_libc_long_running_testsuite suite_name)
   add_custom_target(${suite_name})
   add_dependencies(libc-long-running-tests ${suite_name})

libc/test/src/__support/CMakeLists.txt

-add_libc_testsuite(libc_support_unittests)
+add_custom_target(libc_support_unittests)
 
 add_libc_unittest(
   blockstore_test
   SUITE
     libc_support_unittests
   SRCS
     blockstore_test.cpp
   DEPENDS

libc/test/src/__support/CPP/CMakeLists.txt

-add_libc_testsuite(libc_cpp_utils_unittests)
+add_custom_target(libc_cpp_utils_unittests)
 
 add_libc_unittest(
   bitset_test
   SUITE
     libc_cpp_utils_unittests
   SRCS
     bitset_test.cpp
   DEPENDS

libc/test/src/__support/FPUtil/CMakeLists.txt

-add_libc_testsuite(libc_fputil_unittests)
+add_custom_target(libc_fputil_unittests)
 
 add_fp_unittest(
   dyadic_float_test
   NEED_MPFR
   SUITE
     libc_fputil_unittests
   SRCS
     dyadic_float_test.cpp
   DEPENDS
     libc.src.__support.FPUtil.dyadic_float
 )

libc/test/src/__support/OSUtil/CMakeLists.txt

-add_libc_testsuite(libc_osutil_tests)
+add_custom_target(libc_osutil_tests)
 
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
   add_subdirectory(${LIBC_TARGET_OS})
 endif()

libc/test/src/assert/CMakeLists.txt

-add_libc_testsuite(libc_assert_unittests)
+add_custom_target(libc_assert_unittests)
 
 add_libc_unittest(
   assert_test
   SUITE
     libc_assert_unittests
   SRCS
     assert_test.cpp
   DEPENDS
     libc.src.assert.__assert_fail
     # These are necessary for now because dependencies are not properly added.
     libc.src.signal.raise
     libc.src.stdlib._Exit
     libc.src.stdlib.abort
 )

libc/test/src/ctype/CMakeLists.txt

-add_libc_testsuite(libc_ctype_unittests)
+add_custom_target(libc_ctype_unittests)
 
 add_libc_unittest(
   isalnum_test
   SUITE
     libc_ctype_unittests
   SRCS
     isalnum_test.cpp
   DEPENDS

libc/test/src/dirent/CMakeLists.txt

 add_subdirectory(testdata)
-add_libc_testsuite(libc_dirent_unittests)
+add_custom_target(libc_dirent_unittests)
 
 add_libc_unittest(
   dirent_test
   SUITE
     libc_dirent_unittests
   SRCS
     dirent_test.cpp
   DEPENDS
     libc.src.__support.CPP.string_view
     libc.src.dirent.closedir
     libc.src.dirent.dirfd
     libc.src.dirent.opendir
     libc.src.dirent.readdir
     libc.src.errno.errno
 )
 

libc/test/src/errno/CMakeLists.txt

 if(NOT LLVM_LIBC_FULL_BUILD)
   return()
 endif()
 
-add_libc_testsuite(libc_errno_unittests)
+add_custom_target(libc_errno_unittests)
 
 add_libc_unittest(
   errno_test
   SUITE
     libc_errno_unittests
   SRCS
     errno_test.cpp
   DEPENDS
     libc.src.errno.errno
 )

libc/test/src/fcntl/CMakeLists.txt

-add_libc_testsuite(libc_fcntl_unittests)
+add_custom_target(libc_fcntl_unittests)
 
 add_subdirectory(testdata)
 
 add_libc_unittest(
   creat_test
   SUITE
     libc_fcntl_unittests
   SRCS

libc/test/src/fenv/CMakeLists.txt

-add_libc_testsuite(libc_fenv_unittests)
+add_custom_target(libc_fenv_unittests)
 
 add_libc_unittest(
   rounding_mode_test
   SUITE
     libc_fenv_unittests
   SRCS
     rounding_mode_test.cpp
   DEPENDS

libc/test/src/inttypes/CMakeLists.txt

-add_libc_testsuite(libc_inttypes_unittests)
+add_custom_target(libc_inttypes_unittests)
 
 add_libc_unittest(
   strtoimax_test
   SUITE
     libc_inttypes_unittests
   SRCS
     strtoimax_test.cpp
   DEPENDS

libc/test/src/math/CMakeLists.txt

-add_libc_testsuite(libc_math_unittests)
+add_custom_target(libc_math_unittests)
 
 add_library(
   libc_math_test_utils
   RandUtils.cpp
   RandUtils.h
 )
 
 add_fp_unittest(
add_fp_unittest(
   DEPENDS
     libc.include.math
     libc.src.math.scalbnl
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.normal_float
 )
 
 add_subdirectory(generic)
+
+if(NOT LLVM_LIBC_FULL_BUILD)
   add_subdirectory(exhaustive)
   add_subdirectory(differential_testing)
+endif()

libc/test/src/network/CMakeLists.txt

-add_libc_testsuite(libc_network_unittests)
+add_custom_target(libc_network_unittests)
 
 add_libc_unittest(
   htonl
   SUITE
     libc_network_unittests
   SRCS
     htonl_test.cpp
   CXX_STANDARD

libc/test/src/pthread/CMakeLists.txt

-add_libc_testsuite(libc_pthread_unittests)
+add_custom_target(libc_pthread_unittests)
 
 add_libc_unittest(
   pthread_attr_test
   SUITE
     libc_pthread_unittests
   SRCS
     pthread_attr_test.cpp
   DEPENDS

libc/test/src/sched/CMakeLists.txt

-add_libc_testsuite(libc_sched_unittests)
+add_custom_target(libc_sched_unittests)
 
 add_libc_unittest(
   affinity_test
   SUITE
     libc_sched_unittests
   SRCS
     affinity_test.cpp
   DEPENDS

libc/test/src/setjmp/CMakeLists.txt

-add_libc_testsuite(libc_setjmp_unittests)
+add_custom_target(libc_setjmp_unittests)
 
 # Skip setjmp tests under sanitizers
 if(LLVM_USE_SANITIZER)
   return()
 endif()
 
 add_libc_unittest(
   setjmp_test

libc/test/src/signal/CMakeLists.txt

-add_libc_testsuite(libc_signal_unittests)
+add_custom_target(libc_signal_unittests)
 
 add_libc_unittest(
   raise_test
   SUITE
     libc_signal_unittests
   SRCS
     raise_test.cpp
   DEPENDS

libc/test/src/spawn/CMakeLists.txt

-add_libc_testsuite(libc_spawn_unittests)
+add_custom_target(libc_spawn_unittests)
 
 add_libc_unittest(
   posix_spawn_file_actions_test
   SUITE
     libc_spawn_unittests
   SRCS
     posix_spawn_file_actions_test.cpp
   DEPENDS

libc/test/src/stdio/CMakeLists.txt

-add_libc_testsuite(libc_stdio_unittests)
+add_custom_target(libc_stdio_unittests)
 
 add_libc_unittest(
   fileop_test
   SUITE
     libc_stdio_unittests
   SRCS
     fileop_test.cpp
   DEPENDS

libc/test/src/stdlib/CMakeLists.txt

-add_libc_testsuite(libc_stdlib_unittests)
+add_custom_target(libc_stdlib_unittests)
 
 add_libc_unittest(
   atof_test
   SUITE
     libc_stdlib_unittests
   SRCS
     atof_test.cpp
   DEPENDS

libc/test/src/string/CMakeLists.txt

-add_libc_testsuite(libc_string_unittests)
+add_custom_target(libc_string_unittests)
 
 add_subdirectory(memory_utils)
 
 add_libc_unittest(
   bcopy_test
   SUITE
     libc_string_unittests
   SRCS

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

-add_libc_testsuite(libc_sys_mman_unittests)
+add_custom_target(libc_sys_mman_unittests)
 
 add_libc_unittest(
   mmap_test
   SUITE
     libc_sys_mman_unittests
   SRCS
     mmap_test.cpp
   DEPENDS

libc/test/src/sys/random/linux/CMakeLists.txt

-add_libc_testsuite(libc_sys_random_unittests)
+add_custom_target(libc_sys_random_unittests)
 
 add_libc_unittest(
   getrandom_test
   SUITE
     libc_sys_random_unittests
   SRCS
     getrandom_test.cpp
   DEPENDS
     libc.include.math
     libc.include.sys_random
     libc.src.errno.errno
     libc.src.math.fabs
     libc.src.sys.random.getrandom
     libc.test.errno_setter_matcher
 )

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

-add_libc_testsuite(libc_sys_resource_unittests)
+add_custom_target(libc_sys_resource_unittests)
 
 add_subdirectory(testdata)
 
 add_libc_unittest(
   getrlimit_setrlimit_test
   SUITE
     libc_sys_resource_unittests
   SRCS

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

-add_libc_testsuite(libc_sys_select_unittests)
+add_custom_target(libc_sys_select_unittests)
 
 add_libc_unittest(
   select_ui_test
   NO_RUN_POSTBUILD
   SUITE
     libc_sys_select_unittests
   SRCS
     select_ui_test.cpp

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

-add_libc_testsuite(libc_sys_sendfile_unittests)
+add_custom_target(libc_sys_sendfile_unittests)
 
 add_subdirectory(testdata)
 
 add_libc_unittest(
   sendfile_test
   SUITE
     libc_sys_sendfile_unittests
   SRCS

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

-add_libc_testsuite(libc_sys_stat_unittests)
+add_custom_target(libc_sys_stat_unittests)
 
 add_subdirectory(testdata)
 
 add_libc_unittest(
   chmod_test
   SUITE
     libc_sys_stat_unittests
   SRCS

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

-add_libc_testsuite(libc_sys_utsname_unittests)
+add_custom_target(libc_sys_utsname_unittests)
 
 add_libc_unittest(
   uname_test
   SUITE
     libc_sys_utsname_unittests
   SRCS
     uname_test.cpp
   DEPENDS
     libc.include.errno
     libc.include.sys_utsname
     libc.src.__support.common
     libc.src.sys.utsname.uname
     libc.test.errno_setter_matcher
 )

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

-add_libc_testsuite(libc_sys_wait_unittests)
+add_custom_target(libc_sys_wait_unittests)
 
 add_libc_unittest(
   waitpid_test
   SUITE
     libc_sys_stat_unittests
   SRCS
     waitpid_test.cpp
   DEPENDS

libc/test/src/termios/CMakeLists.txt

-add_libc_testsuite(libc_termios_unittests)
+add_custom_target(libc_termios_unittests)
 
 add_libc_unittest(
   termios_test
   SUITE
     libc_termios_unittests
   SRCS
     termios_test.cpp
   DEPENDS

libc/test/src/time/CMakeLists.txt

-add_libc_testsuite(libc_time_unittests)
+add_custom_target(libc_time_unittests)
 
 add_libc_unittest(
   asctime
   SUITE
     libc_time_unittests
   SRCS
     asctime_test.cpp
   HDRS

libc/test/src/unistd/CMakeLists.txt

-add_libc_testsuite(libc_unistd_unittests)
+add_custom_target(libc_unistd_unittests)
 
 add_subdirectory(testdata)
 
 add_libc_unittest(
   access_test
   SUITE
     libc_unistd_unittests
   SRCS

libc/test/src/wchar/CMakeLists.txt

-add_libc_testsuite(libc_wchar_unittests)
+add_custom_target(libc_wchar_unittests)
 
 add_libc_unittest(
   btowc_test
   SUITE
     libc_wchar_unittests
   SRCS
     btowc_test.cpp
   DEPENDS

libc/test/utils/FPUtil/x86_long_double_test.cpp

 //===-- Unittests for x86 long double -------------------------------------===//
 //
 // 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 "test/UnitTest/Test.h"
 
 #include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
-TEST(X86LongDoubleTest, is_nan) {
+TEST(LlvmLibcX86LongDoubleTest, is_nan) {
   // In the nan checks below, we use the macro isnan from math.h to ensure that
   // a number is actually a NaN. The isnan macro resolves to the compiler
   // builtin function. Hence, matching LLVM-libc's notion of NaN with the
   // isnan result ensures that LLVM-libc's behavior matches the compiler's
   // behavior.
 
   FPBits bits(0.0l);
-  bits.exponent = FPBits::MAX_EXPONENT;
+  bits.set_unbiased_exponent(FPBits::MAX_EXPONENT);
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent has the max value and the implicit bit is 0,
     // then the number is a NaN for all values of mantissa.
-    bits.mantissa = i;
+    bits.set_mantissa(i);
     long double nan = bits;
-    ASSERT_NE(isnan(nan), 0);
+    ASSERT_NE(static_cast<int>(isnan(nan)), 0);
     ASSERT_TRUE(bits.is_nan());
   }
 
-  bits.implicitBit = 1;
+  bits.set_implicit_bit(1);
   for (unsigned int i = 1; i < 1000000; ++i) {
     // If exponent has the max value and the implicit bit is 1,
     // then the number is a NaN for all non-zero values of mantissa.
     // Note the initial value of |i| of 1 to avoid a zero mantissa.
-    bits.mantissa = i;
+    bits.set_mantissa(i);
     long double nan = bits;
-    ASSERT_NE(isnan(nan), 0);
+    ASSERT_NE(static_cast<int>(isnan(nan)), 0);
     ASSERT_TRUE(bits.is_nan());
   }
 
-  bits.exponent = 1;
-  bits.implicitBit = 0;
+  bits.set_unbiased_exponent(1);
+  bits.set_implicit_bit(0);
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent is non-zero and also not max, and the implicit bit is 0,
     // then the number is a NaN for all values of mantissa.
-    bits.mantissa = i;
+    bits.set_mantissa(i);
     long double nan = bits;
-    ASSERT_NE(isnan(nan), 0);
+    ASSERT_NE(static_cast<int>(isnan(nan)), 0);
     ASSERT_TRUE(bits.is_nan());
   }
 
-  bits.exponent = 1;
-  bits.implicitBit = 1;
+  bits.set_unbiased_exponent(1);
+  bits.set_implicit_bit(1);
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent is non-zero and also not max, and the implicit bit is 1,
     // then the number is normal value for all values of mantissa.
-    bits.mantissa = i;
+    bits.set_mantissa(i);
     long double valid = bits;
-    ASSERT_EQ(isnan(valid), 0);
+    ASSERT_EQ(static_cast<int>(isnan(valid)), 0);
     ASSERT_FALSE(bits.is_nan());
   }
 
-  bits.exponent = 0;
-  bits.implicitBit = 1;
+  bits.set_unbiased_exponent(0);
+  bits.set_implicit_bit(1);
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent is zero, then the number is a valid but denormal value.
-    bits.mantissa = i;
+    bits.set_mantissa(i);
     long double valid = bits;
-    ASSERT_EQ(isnan(valid), 0);
+    ASSERT_EQ(static_cast<int>(isnan(valid)), 0);
     ASSERT_FALSE(bits.is_nan());
   }
 
-  bits.exponent = 0;
-  bits.implicitBit = 0;
+  bits.set_unbiased_exponent(0);
+  bits.set_implicit_bit(0);
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent is zero, then the number is a valid but denormal value.
-    bits.mantissa = i;
+    bits.set_mantissa(i);
     long double valid = bits;
-    ASSERT_EQ(isnan(valid), 0);
+    ASSERT_EQ(static_cast<int>(isnan(valid)), 0);
     ASSERT_FALSE(bits.is_nan());
   }
 }

libc/test/utils/UnitTest/CMakeLists.txt

-add_libc_testsuite(libc_unittest_tests)
+add_custom_target(libc_unittest_tests)
 
 add_libc_unittest(
   testfilter_test
   SUITE
     libc_unittest_tests
   SRCS
     testfilter_test.cpp
   DEPENDS
     # TODO(michaelrj): Remove this dependancy. It's only here because all unit 
     # tests must have at least one dependancy.
     libc.src.__support.CPP.bit 
 )