[libc][NFC] Move RoundingModeUtils to LibcFPTestHelpers.

[sivachandra]

Rebase.

libc/test/UnitTest/CMakeLists.txt

DEPENDS
     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)
 add_dependencies(
   LibcFPTestHelpers
   LibcUnitTest
   libc.test.UnitTest.string_utils
   libc.src.__support.FPUtil.fp_bits

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/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/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

 if(CMAKE_HOST_UNIX)
   set(EFFile ExecuteFunctionUnix.cpp)
 endif()
 
 add_library(
   libc_test_utils
   ${EFFile}
   ExecuteFunction.h
-  RoundingModeUtils.cpp
 )

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

deps = [
         "//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",

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

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/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 = [
         "ExecuteFunctionUnix.cpp",
-        "RoundingModeUtils.cpp",
     ],
     hdrs = [
         "ExecuteFunction.h",
-        "RoundingModeUtils.h",
     ],
     deps = [
         "//libc:libc_root",
         "//llvm:Support",
     ],
 )