[libc][NFC] Move RoundingModeUtils to LibcFPTestHelpers.

[sivachandra]

Rebase.

libc/cmake/modules/LLVMLibCTestRules.cmake

function(create_libc_unittest fq_target_name)
   set_target_properties(${fq_build_target_name}
     PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
   add_dependencies(
     ${fq_build_target_name}
     ${fq_deps_list}
   )
 
-  # LibcUnitTest and libc_test_utils should not depend on anything in LINK_LIBRARIES.
+  # LibcUnitTest should not depend on anything in LINK_LIBRARIES.
   if(NO_LIBC_UNITTEST_TEST_MAIN)
-    list(APPEND link_libraries LibcUnitTest libc_test_utils)
+    list(APPEND link_libraries LibcUnitTest)
   else()
-    list(APPEND link_libraries LibcUnitTest LibcUnitTestMain libc_test_utils)
+    list(APPEND link_libraries LibcUnitTest LibcUnitTestMain)
   endif()
 
   target_link_libraries(${fq_build_target_name} PRIVATE ${link_libraries})
 
   if(NOT LIBC_UNITTEST_NO_RUN_POSTBUILD)
     add_custom_target(
       ${fq_target_name}
       COMMAND $<TARGET_FILE:${fq_build_target_name}>

libc/test/UnitTest/CMakeLists.txt

 target_include_directories(LibcUnitTest PUBLIC ${LIBC_SOURCE_DIR})
 add_dependencies(
   LibcUnitTest
   libc.src.__support.CPP.string
   libc.src.__support.CPP.string_view
   libc.src.__support.CPP.type_traits
   libc.src.__support.OSUtil.osutil
   libc.src.__support.uint128)
-target_link_libraries(LibcUnitTest PUBLIC libc_test_utils)
 
 add_library(
   LibcUnitTestMain
   LibcTestMain.cpp
 )
 
 target_include_directories(LibcUnitTestMain PUBLIC ${LIBC_SOURCE_DIR})
 add_dependencies(LibcUnitTestMain LibcUnitTest)
-target_link_libraries(LibcUnitTestMain PUBLIC LibcUnitTest libc_test_utils)
+target_link_libraries(LibcUnitTestMain PUBLIC LibcUnitTest)
 
 add_header_library(
   string_utils
   HDRS
   StringUtils.h
   DEPENDS
     libc.src.__support.CPP.string
     libc.src.__support.CPP.type_traits
 )
 
 add_library(
   LibcFPTestHelpers
   FPExceptMatcher.cpp
   FPExceptMatcher.h
   FPMatcher.h
+  RoundingModeUtils.cpp
+  RoundingModeUtils.h
 )
 target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
-target_link_libraries(LibcFPTestHelpers LibcUnitTest libc_test_utils)
+target_link_libraries(LibcFPTestHelpers LibcUnitTest)
 add_dependencies(
   LibcFPTestHelpers
   LibcUnitTest
   libc.test.UnitTest.string_utils
   libc.src.__support.FPUtil.fp_bits
   libc.src.__support.FPUtil.fenv_impl
   libc.test.UnitTest.string_utils
 )

libc/test/UnitTest/FPMatcher.h

 //===-- FPMatchers.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_UTILS_UNITTEST_FPMATCHER_H
 #define LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H
 
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
+#include "test/UnitTest/RoundingModeUtils.h"
 #include "test/UnitTest/StringUtils.h"
 #include "test/UnitTest/Test.h"
-#include "utils/testutils/RoundingModeUtils.h"
 
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
 template <typename ValType>
if (math_errhandling & MATH_ERREXCEPT) {                                   \
                     expected_except,                                           \
                 expected_except);                                              \
       __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);                        \
     }                                                                          \
   } while (0)
 
 #define EXPECT_FP_EQ_ALL_ROUNDING(expected, actual)                            \
   do {                                                                         \
-    using namespace __llvm_libc::testutils;                                    \
+    using namespace __llvm_libc::fputil::testing;                              \
     ForceRoundingMode __r1(RoundingMode::Nearest);                             \
     EXPECT_FP_EQ((expected), (actual));                                        \
     ForceRoundingMode __r2(RoundingMode::Upward);                              \
     EXPECT_FP_EQ((expected), (actual));                                        \
     ForceRoundingMode __r3(RoundingMode::Downward);                            \
     EXPECT_FP_EQ((expected), (actual));                                        \
     ForceRoundingMode __r4(RoundingMode::TowardZero);                          \
     EXPECT_FP_EQ((expected), (actual));                                        \
   } while (0)
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H

libc/test/UnitTest/RoundingModeUtils.h

 //===-- RoundingModeUtils.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_UTILS_TESTUTILS_ROUNDINGMODEUTILS_H
 #define LLVM_LIBC_UTILS_TESTUTILS_ROUNDINGMODEUTILS_H
 
 #include <stdint.h>
 
 namespace __llvm_libc {
-namespace testutils {
+namespace fputil {
+namespace testing {
 
 enum class RoundingMode : uint8_t { Upward, Downward, TowardZero, Nearest };
 
 struct ForceRoundingMode {
   ForceRoundingMode(RoundingMode);
   ~ForceRoundingMode();
 
   int old_rounding_mode;
   int rounding_mode;
 };
 
 template <RoundingMode R> struct ForceRoundingModeTest : ForceRoundingMode {
   ForceRoundingModeTest() : ForceRoundingMode(R) {}
 };
 
-} // namespace testutils
+} // namespace testing
+} // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_TESTUTILS_ROUNDINGMODEUTILS_H

libc/test/UnitTest/RoundingModeUtils.cpp

 //===-- RoundingModeUtils.cpp ---------------------------------------------===//
 //
 // 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 "RoundingModeUtils.h"
 
 #include <fenv.h>
 
 namespace __llvm_libc {
-namespace testutils {
+namespace fputil {
+namespace testing {
 
 int get_fe_rounding(RoundingMode mode) {
   switch (mode) {
   case RoundingMode::Upward:
     return FE_UPWARD;
     break;
   case RoundingMode::Downward:
     return FE_DOWNWARD;
if (old_rounding_mode != rounding_mode)
     fesetround(rounding_mode);
 }
 
 ForceRoundingMode::~ForceRoundingMode() {
   if (old_rounding_mode != rounding_mode)
     fesetround(old_rounding_mode);
 }
 
-} // namespace testutils
+} // namespace testing
+} // namespace fputil
 } // namespace __llvm_libc

libc/test/src/math/differential_testing/CMakeLists.txt

if(DIFF_COMPILE_OPTIONS)
     target_compile_options(
       ${fq_target_name}
       PRIVATE ${DIFF_COMPILE_OPTIONS}
     )
   endif()
 
   target_link_libraries(
       ${fq_target_name}
-      PRIVATE ${link_object_files} libc_test_utils libc_diff_test_utils)
+      PRIVATE ${link_object_files} libc_diff_test_utils)
 
   set_target_properties(${fq_target_name}
     PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
   
   if(DIFF_CXX_STANDARD)
     set_target_properties(
       ${fq_target_name}
       PROPERTIES

libc/test/src/stdio/CMakeLists.txt

DEPENDS
     libc.src.stdio.fopencookie
     libc.src.stdio.fread
     libc.src.stdio.fseek
     libc.src.stdio.fwrite
   LINK_LIBRARIES
     LibcMemoryHelpers
 )
 
-add_libc_unittest(
+add_fp_unittest(
   sprintf_test
   SUITE
     libc_stdio_unittests
   SRCS
     sprintf_test.cpp
   DEPENDS
     libc.src.stdio.sprintf
     libc.src.__support.FPUtil.fp_bits

libc/test/src/stdio/sprintf_test.cpp

 //===-- Unittests for sprintf ---------------------------------------------===//
 //
 // 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/sprintf.h"
 
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PlatformDefs.h"
+#include "test/UnitTest/RoundingModeUtils.h"
 #include "test/UnitTest/Test.h"
-#include "utils/testutils/RoundingModeUtils.h"
 
 // #include <stdio.h>
 // namespace __llvm_libc {
 // using ::sprintf;
 // }
 
 class LlvmLibcSPrintfTest : public __llvm_libc::testing::Test {
 protected:
written = __llvm_libc::sprintf(buff, "%04hho %#.5llo %-6.3zo", 256 + 077,
                                  01000000000000ll, size_t(2));
   EXPECT_EQ(written, 26);
   ASSERT_STREQ(buff, "0077 01000000000000 002   ");
 }
 
 #ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT
 
 TEST_F(LlvmLibcSPrintfTest, FloatHexExpConv) {
-  __llvm_libc::testutils::ForceRoundingMode r(
-      __llvm_libc::testutils::RoundingMode::Nearest);
+  __llvm_libc::fputil::testing::ForceRoundingMode r(
+      __llvm_libc::fputil::testing::RoundingMode::Nearest);
   double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
   double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
 
   written = __llvm_libc::sprintf(buff, "%a", 1.0);
   ASSERT_STREQ_LEN(written, buff, "0x1p+0");
 
   written = __llvm_libc::sprintf(buff, "%A", -1.0);
   ASSERT_STREQ_LEN(written, buff, "-0X1P+0");
#elif defined(LONG_DOUBLE_IS_DOUBLE)
   ASSERT_STREQ_LEN(written, buff, "inf");
 #else // 128 bit long double
   ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
 #endif
 
   // Rounding Mode Tests.
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Nearest);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Nearest);
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
     ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
     ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
     ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Upward);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Upward);
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
     ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
     ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Downward);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Downward);
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
     ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.1a", -0x1.04p0);
     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", -0x1.14p0);
     ASSERT_STREQ_LEN(written, buff, "-0x1.2p+0");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::TowardZero);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::TowardZero);
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.08p0);
     ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.18p0);
     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
 
     written = __llvm_libc::sprintf(buff, "%.1a", 0x1.04p0);
#endif
   written = __llvm_libc::sprintf(buff, "%12.3a %-12.3A", 0.1, 256.0);
   ASSERT_STREQ_LEN(written, buff, "  0x1.99ap-4 0X1.000P+8  ");
 
   written = __llvm_libc::sprintf(buff, "%+-#12.3a % 012.3a", 0.1256, 1256.0);
   ASSERT_STREQ_LEN(written, buff, "+0x1.014p-3   0x1.3a0p+10");
 }
 
 TEST_F(LlvmLibcSPrintfTest, FloatDecimalConv) {
-  __llvm_libc::testutils::ForceRoundingMode r(
-      __llvm_libc::testutils::RoundingMode::Nearest);
+  __llvm_libc::fputil::testing::ForceRoundingMode r(
+      __llvm_libc::fputil::testing::RoundingMode::Nearest);
   double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
   double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
 
   written = __llvm_libc::sprintf(buff, "%f", 1.0);
   ASSERT_STREQ_LEN(written, buff, "1.000000");
 
   written = __llvm_libc::sprintf(buff, "%F", -1.0);
   ASSERT_STREQ_LEN(written, buff, "-1.000000");
*/
   #else // 128 bit long double
     ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
   #endif
   */
 
   // Rounding Mode Tests.
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Nearest);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Nearest);
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.8");
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.2");
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.125);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.1f", -1.375);
     ASSERT_STREQ_LEN(written, buff, "-1.4");
 
     written = __llvm_libc::sprintf(buff, "%.1f", -1.875);
     ASSERT_STREQ_LEN(written, buff, "-1.9");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Upward);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Upward);
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.8");
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.3");
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.125);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.1f", -1.375);
     ASSERT_STREQ_LEN(written, buff, "-1.3");
 
     written = __llvm_libc::sprintf(buff, "%.1f", -1.875);
     ASSERT_STREQ_LEN(written, buff, "-1.8");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Downward);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Downward);
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.7");
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.2");
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.125);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.1f", -1.375);
     ASSERT_STREQ_LEN(written, buff, "-1.4");
 
     written = __llvm_libc::sprintf(buff, "%.1f", -1.875);
     ASSERT_STREQ_LEN(written, buff, "-1.9");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::TowardZero);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::TowardZero);
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.7");
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.2");
 
     written = __llvm_libc::sprintf(buff, "%.1f", 1.125);
*/
   written = __llvm_libc::sprintf(buff, "%12.3f %-12.3f", 0.1, 256.0);
   ASSERT_STREQ_LEN(written, buff, "       0.100 256.000     ");
 
   written = __llvm_libc::sprintf(buff, "%+-#12.3f % 012.3f", 0.1256, 1256.0);
   ASSERT_STREQ_LEN(written, buff, "+0.126        0001256.000");
 }
 
 TEST_F(LlvmLibcSPrintfTest, FloatExponentConv) {
-  __llvm_libc::testutils::ForceRoundingMode r(
-      __llvm_libc::testutils::RoundingMode::Nearest);
+  __llvm_libc::fputil::testing::ForceRoundingMode r(
+      __llvm_libc::fputil::testing::RoundingMode::Nearest);
   double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
   double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
 
   written = __llvm_libc::sprintf(buff, "%e", 1.0);
   ASSERT_STREQ_LEN(written, buff, "1.000000e+00");
 
   written = __llvm_libc::sprintf(buff, "%E", -1.0);
   ASSERT_STREQ_LEN(written, buff, "-1.000000E+00");
*/
   #else // 128 bit long double
     ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
   #endif
   */
 
   // Rounding Mode Tests.
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Nearest);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Nearest);
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.8e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.2e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.125);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.1e", -1.375);
     ASSERT_STREQ_LEN(written, buff, "-1.4e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", -1.875);
     ASSERT_STREQ_LEN(written, buff, "-1.9e+00");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Upward);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Upward);
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.8e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.3e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.125);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.1e", -1.375);
     ASSERT_STREQ_LEN(written, buff, "-1.3e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", -1.875);
     ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Downward);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Downward);
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.7e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.2e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.125);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.1e", -1.375);
     ASSERT_STREQ_LEN(written, buff, "-1.4e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", -1.875);
     ASSERT_STREQ_LEN(written, buff, "-1.9e+00");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::TowardZero);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::TowardZero);
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.7e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.2e+00");
 
     written = __llvm_libc::sprintf(buff, "%.1e", 1.125);
*/
   written = __llvm_libc::sprintf(buff, "%12.3e %-12.3e", 0.1, 256.0);
   ASSERT_STREQ_LEN(written, buff, "   1.000e-01 2.560e+02   ");
 
   written = __llvm_libc::sprintf(buff, "%+-#12.3e % 012.3e", 0.1256, 1256.0);
   ASSERT_STREQ_LEN(written, buff, "+1.256e-01    001.256e+03");
 }
 
 TEST_F(LlvmLibcSPrintfTest, FloatAutoConv) {
-  __llvm_libc::testutils::ForceRoundingMode r(
-      __llvm_libc::testutils::RoundingMode::Nearest);
+  __llvm_libc::fputil::testing::ForceRoundingMode r(
+      __llvm_libc::fputil::testing::RoundingMode::Nearest);
   double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
   double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
 
   written = __llvm_libc::sprintf(buff, "%g", 1.0);
   ASSERT_STREQ_LEN(written, buff, "1");
 
   written = __llvm_libc::sprintf(buff, "%G", -1.0);
   ASSERT_STREQ_LEN(written, buff, "-1");
*/
   #else // 128 bit long double
     ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
   #endif
   */
 
   // Rounding Mode Tests.
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Nearest);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Nearest);
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.8");
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.2");
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.125);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.2g", -1.375);
     ASSERT_STREQ_LEN(written, buff, "-1.4");
 
     written = __llvm_libc::sprintf(buff, "%.2g", -1.875);
     ASSERT_STREQ_LEN(written, buff, "-1.9");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Upward);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Upward);
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.8");
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.3");
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.125);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.2g", -1.375);
     ASSERT_STREQ_LEN(written, buff, "-1.3");
 
     written = __llvm_libc::sprintf(buff, "%.2g", -1.875);
     ASSERT_STREQ_LEN(written, buff, "-1.8");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::Downward);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::Downward);
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.7");
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.2");
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.125);
// Rounding Mode Tests.
     written = __llvm_libc::sprintf(buff, "%.2g", -1.375);
     ASSERT_STREQ_LEN(written, buff, "-1.4");
 
     written = __llvm_libc::sprintf(buff, "%.2g", -1.875);
     ASSERT_STREQ_LEN(written, buff, "-1.9");
   }
 
   {
-    __llvm_libc::testutils::ForceRoundingMode r(
-        __llvm_libc::testutils::RoundingMode::TowardZero);
+    __llvm_libc::fputil::testing::ForceRoundingMode r(
+        __llvm_libc::fputil::testing::RoundingMode::TowardZero);
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.75);
     ASSERT_STREQ_LEN(written, buff, "1.7");
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.25);
     ASSERT_STREQ_LEN(written, buff, "1.2");
 
     written = __llvm_libc::sprintf(buff, "%.2g", 1.125);

libc/test/src/stdlib/CMakeLists.txt

SUITE
     libc_stdlib_unittests
   SRCS
     atoll_test.cpp
   DEPENDS
     .atoi_test_support
     libc.src.stdlib.atoll
 )
 
-add_libc_unittest(
+add_fp_unittest(
   strtod_test
   SUITE
     libc_stdlib_unittests
   SRCS
     strtod_test.cpp
   DEPENDS
     libc.src.errno.errno
     libc.src.stdlib.strtod
 )
 
-add_libc_unittest(
+add_fp_unittest(
   strtof_test
   SUITE
     libc_stdlib_unittests
   SRCS
     strtof_test.cpp
   DEPENDS
     libc.src.errno.errno
     libc.src.stdlib.strtof

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/RoundingModeUtils.h"
 #include "test/UnitTest/Test.h"
-#include "utils/testutils/RoundingModeUtils.h"
 
 #include <limits.h>
 #include <stddef.h>
 
-using __llvm_libc::testutils::ForceRoundingModeTest;
-using __llvm_libc::testutils::RoundingMode;
+using __llvm_libc::fputil::testing::ForceRoundingModeTest;
+using __llvm_libc::fputil::testing::RoundingMode;
 
 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,
     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);
 
-    __llvm_libc::fputil::FPBits<double> actual_fp =
-        __llvm_libc::fputil::FPBits<double>(result);
-
     EXPECT_EQ(str_end - inputString, expectedStrLen);
-
-    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_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

libc/test/src/stdlib/strtof_test.cpp

 //===-- Unittests for strtof ---------------------------------------------===//
 //
 // 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/strtof.h"
 
+#include "test/UnitTest/FPMatcher.h"
+#include "test/UnitTest/RoundingModeUtils.h"
 #include "test/UnitTest/Test.h"
-#include "utils/testutils/RoundingModeUtils.h"
 
 #include <limits.h>
 #include <stddef.h>
 
-using __llvm_libc::testutils::ForceRoundingModeTest;
-using __llvm_libc::testutils::RoundingMode;
+using __llvm_libc::fputil::testing::ForceRoundingModeTest;
+using __llvm_libc::fputil::testing::RoundingMode;
 
 class LlvmLibcStrToFTest : public __llvm_libc::testing::Test,
                            ForceRoundingModeTest<RoundingMode::Nearest> {
 public:
   void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
                 const uint32_t expectedRawData, const int expectedErrno = 0) {
     // expectedRawData is the expected float result as a uint32_t, organized
     // according to IEEE754:
void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
     char *str_end = nullptr;
 
     __llvm_libc::fputil::FPBits<float> expected_fp =
         __llvm_libc::fputil::FPBits<float>(expectedRawData);
 
     libc_errno = 0;
     float result = __llvm_libc::strtof(inputString, &str_end);
 
-    __llvm_libc::fputil::FPBits<float> actual_fp =
-        __llvm_libc::fputil::FPBits<float>(result);
-
     EXPECT_EQ(str_end - inputString, expectedStrLen);
-
-    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_FP_EQ(result, static_cast<float>(expected_fp));
     EXPECT_EQ(libc_errno, expectedErrno);
   }
 };
 
 // This is the set of tests that I have working (verified correct when compared
 // to system libc). This is here so I don't break more things when I try to fix
 // them.
 

libc/utils/CMakeLists.txt

 if(LLVM_INCLUDE_TESTS)
   add_subdirectory(MPFRWrapper)
-  add_subdirectory(testutils)
 endif()
 if(LIBC_TARGET_ARCHITECTURE_IS_GPU)
   add_subdirectory(gpu)
 endif()

libc/utils/MPFRWrapper/CMakeLists.txt

 if(LIBC_TESTS_CAN_USE_MPFR)
   add_library(libcMPFRWrapper
     MPFRUtils.cpp
     MPFRUtils.h
   )
   add_compile_options(
     -O3
   )
   add_dependencies(
     libcMPFRWrapper 
     libc.src.__support.CPP.string_view 
     libc.src.__support.CPP.type_traits 
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.platform_defs
     LibcUnitTest
-    libc_test_utils
   )
   if(EXISTS ${LLVM_LIBC_MPFR_INSTALL_PATH})
     target_include_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/include)
     target_link_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/lib)
   endif()
-  target_link_libraries(libcMPFRWrapper LibcFPTestHelpers LibcUnitTest mpfr gmp libc_test_utils)
+  target_link_libraries(libcMPFRWrapper LibcFPTestHelpers LibcUnitTest mpfr gmp)
 elseif(NOT LIBC_TARGET_ARCHITECTURE_IS_GPU)
   message(WARNING "Math tests using MPFR will be skipped.")
 endif()

libc/utils/MPFRWrapper/MPFRUtils.h

 //===-- MPFRUtils.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_UTILS_TESTUTILS_MPFRUTILS_H
 #define LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H
 
 #include "src/__support/CPP/type_traits.h"
+#include "test/UnitTest/RoundingModeUtils.h"
 #include "test/UnitTest/Test.h"
-#include "utils/testutils/RoundingModeUtils.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
 
 enum class Operation : int {
enum class Operation : int {
   // Operations which take three floating point nubmers of the same type as
   // input and produce a single floating point number of the same type as
   // output.
   BeginTernaryOperationsSingleOuput,
   Fma,
   EndTernaryOperationsSingleOutput,
 };
 
-using __llvm_libc::testutils::ForceRoundingMode;
-using __llvm_libc::testutils::RoundingMode;
+using __llvm_libc::fputil::testing::ForceRoundingMode;
+using __llvm_libc::fputil::testing::RoundingMode;
 
 template <typename T> struct BinaryInput {
   static_assert(
       __llvm_libc::cpp::is_floating_point_v<T>,
       "Template parameter of BinaryInput must be a floating point type.");
 
   using Type = T;
   T x, y;

libc/utils/testutils/CMakeLists.txt

-add_library(
-  libc_test_utils
-  RoundingModeUtils.cpp
-)

utils/bazel/llvm-project-overlay/libc/test/UnitTest/BUILD.bazel

deps = [
         "//libc:__support_cpp_bit",
         "//libc:__support_cpp_bitset",
         "//libc:__support_cpp_span",
         "//libc:__support_cpp_string",
         "//libc:__support_cpp_string_view",
         "//libc:__support_cpp_type_traits",
         "//libc:__support_uint128",
         "//libc:libc_root",
-        "//libc/utils/testutils:libc_test_utils",
         "//llvm:Support",
     ],
 )
 
 cc_library(
     name = "fp_test_helpers",
     srcs = [
         "FPExceptMatcher.cpp",
+        "RoundingModeUtils.cpp",
     ],
     hdrs = [
         "FPExceptMatcher.h",
         "FPMatcher.h",
+        "RoundingModeUtils.h",
     ],
     deps = [
         ":LibcUnitTest",
         ":string_utils",
         "//libc:__support_cpp_bit",
         "//libc:__support_cpp_bitset",
         "//libc:__support_cpp_span",
         "//libc:__support_cpp_type_traits",
         "//libc:__support_fputil_fenv_impl",
         "//libc:__support_fputil_fp_bits",
         "//libc:libc_root",
-        "//libc/utils/testutils:libc_test_utils",
     ],
 )
 
 cc_library(
     name = "memory_matcher",
     srcs = [
         "MemoryMatcher.cpp",
     ],

utils/bazel/llvm-project-overlay/libc/test/src/stdio/BUILD.bazel

libc_test(
     libc_function_deps = [
     ],
     deps = [
       "//libc:printf_parser",
       "//libc:printf_core_structs",
       "//libc:__support_cpp_string_view",
       "//libc:__support_cpp_bit",
       "//libc:__support_arg_list",
-      "//libc/utils/testutils:libc_test_utils",
       "//libc/test/UnitTest:printf_matcher",
     ],
 )
 
 libc_test(
     name = "printf_string_writer_test",
     srcs = ["printf_core/string_writer_test.cpp"],
     libc_function_deps = [
libc_test(
     name = "sprintf_test",
     srcs = ["sprintf_test.cpp"],
     libc_function_deps = [
         "//libc:sprintf",
     ],
     deps = [
       "//libc:__support_fputil_fp_bits",
       "//libc:__support_fputil_platform_defs",
-      "//libc/utils/testutils:libc_test_utils",
+      "//libc/test/UnitTest:fp_test_helpers",
     ],
 )
 
 libc_test(
     name = "snprintf_test",
     srcs = ["snprintf_test.cpp"],
     libc_function_deps = [
         "//libc:snprintf",
     ],
 )

utils/bazel/llvm-project-overlay/libc/test/src/stdlib/BUILD.bazel

 libc_test(
     name = "strtof_test",
     srcs = ["strtof_test.cpp"],
     libc_function_deps = [
         "//libc:strtof",
     ],
     deps = [
         "//libc:__support_fputil_fp_bits",
-        "//libc/utils/testutils:libc_test_utils",
+        "//libc/test/UnitTest:fp_test_helpers",
     ],
 )
 
 libc_test(
     name = "strtod_test",
     srcs = ["strtod_test.cpp"],
     libc_function_deps = [
         "//libc:strtod",
     ],
     deps = [
         "//libc:__support_fputil_fp_bits",
-        "//libc/utils/testutils:libc_test_utils",
+        "//libc/test/UnitTest:fp_test_helpers",
     ],
 )
 
 libc_test(
     name = "strtold_test",
     srcs = ["strtold_test.cpp"],
     libc_function_deps = [
         "//libc:strtold",
     ],
     deps = [
         "//libc:__support_fputil_fp_bits",
         "//libc:__support_uint128",
     ],
 )

utils/bazel/llvm-project-overlay/libc/utils/MPFRWrapper/BUILD.bazel

deps = [
         "//libc:__support_cpp_string_view",
         "//libc:__support_cpp_type_traits",
         "//libc:__support_fputil_fp_bits",
         "//libc:__support_fputil_platform_defs",
         "//libc:libc_root",
         "//libc/test/UnitTest:LibcUnitTest",
         "//libc/test/UnitTest:fp_test_helpers",
         "//libc/utils/MPFRWrapper:mpfr_impl",
-        "//libc/utils/testutils:libc_test_utils",
     ],
 )

utils/bazel/llvm-project-overlay/libc/utils/testutils/BUILD.bazel

-# This file is licensed 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
-
-package(default_visibility = ["//visibility:public"])
-
-licenses(["notice"])
-
-cc_library(
-    name = "libc_test_utils",
-    srcs = [
-        "RoundingModeUtils.cpp",
-    ],
-    hdrs = [
-        "RoundingModeUtils.h",
-    ],
-    deps = [
-        "//libc:libc_root",
-        "//llvm:Support",
-    ],
-)