[libc] Specify rounding mode for strto[f|d] tests

[abrachet]

Summary

The specified rounding mode will be used and restored to what it was before the test ran.

Additionally, it moves ForceRoundingMode and RoundingMode out of MPFRUtils to be used in more places.

[lntue]

libc/utils/testutils/RoundingModeUtils.h

29

typo?

[abrachet]

Fix typo

[abrachet]

libc/utils/testutils/RoundingModeUtils.h

29

Yes. Thanks

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/stdlib/strtod.h"
 
 #include "utils/UnitTest/Test.h"
+#include "utils/testutils/RoundingModeUtils.h"
 
 #include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
-class LlvmLibcStrToDTest : public __llvm_libc::testing::Test {
+using __llvm_libc::testutils::ForceRoundingModeTest;
+using __llvm_libc::testutils::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:
     //
     // +-- 1 Sign Bit                        +-- 52 Mantissa bits
     // |                                     |

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/stdlib/strtof.h"
 
 #include "utils/UnitTest/Test.h"
+#include "utils/testutils/RoundingModeUtils.h"
 
 #include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
-class LlvmLibcStrToFTest : public __llvm_libc::testing::Test {
+using __llvm_libc::testutils::ForceRoundingModeTest;
+using __llvm_libc::testutils::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:
     //
     // +-- 1 Sign Bit      +-- 23 Mantissa bits
     // |                   |

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.fputil 
     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)
+  target_link_libraries(libcMPFRWrapper LibcFPTestHelpers LibcUnitTest mpfr gmp libc_test_utils)
 else()
   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/TypeTraits.h"
 #include "utils/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,
 };
 
-enum class RoundingMode : uint8_t { Upward, Downward, TowardZero, Nearest };
-
-int get_fe_rounding(RoundingMode mode);
-
-struct ForceRoundingMode {
-  ForceRoundingMode(RoundingMode);
-  ~ForceRoundingMode();
-
-  int old_rounding_mode;
-  int rounding_mode;
-};
+using __llvm_libc::testutils::ForceRoundingMode;
+using __llvm_libc::testutils::RoundingMode;
 
 template <typename T> struct BinaryInput {
   static_assert(
       __llvm_libc::cpp::IsFloatingPointType<T>::Value,
       "Template parameter of BinaryInput must be a floating point type.");
 
   using Type = T;
   T x, y;

libc/utils/MPFRWrapper/MPFRUtils.cpp

case RoundingMode::TowardZero:
     return MPFR_RNDZ;
     break;
   case RoundingMode::Nearest:
     return MPFR_RNDN;
     break;
   }
 }
 
-int get_fe_rounding(RoundingMode mode) {
-  switch (mode) {
-  case RoundingMode::Upward:
-    return FE_UPWARD;
-    break;
-  case RoundingMode::Downward:
-    return FE_DOWNWARD;
-    break;
-  case RoundingMode::TowardZero:
-    return FE_TOWARDZERO;
-    break;
-  case RoundingMode::Nearest:
-    return FE_TONEAREST;
-    break;
-  }
-}
-
-ForceRoundingMode::ForceRoundingMode(RoundingMode mode) {
-  old_rounding_mode = fegetround();
-  rounding_mode = get_fe_rounding(mode);
-  if (old_rounding_mode != rounding_mode)
-    fesetround(rounding_mode);
-}
-
-ForceRoundingMode::~ForceRoundingMode() {
-  if (old_rounding_mode != rounding_mode)
-    fesetround(old_rounding_mode);
-}
-
 class MPFRNumber {
   unsigned int mpfr_precision;
   mpfr_rnd_t mpfr_rounding;
 
   mpfr_t value;
 
 public:
   MPFRNumber() : mpfr_precision(256), mpfr_rounding(MPFR_RNDN) {

libc/utils/testutils/CMakeLists.txt

add_library(
   StreamWrapper.cpp
   StreamWrapper.h
   ${EFFile}
   ExecuteFunction.h
   ${FDReaderFile}
   FDReader.h
   Timer.h
   Timer.cpp
+  RoundingModeUtils.cpp
 )

libc/utils/testutils/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 {
+
+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 __llvm_libc
+
+#endif // LLVM_LIBC_UTILS_TESTUTILS_ROUNDINGMODEUTILS_H

libc/utils/testutils/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 {
+
+int get_fe_rounding(RoundingMode mode) {
+  switch (mode) {
+  case RoundingMode::Upward:
+    return FE_UPWARD;
+    break;
+  case RoundingMode::Downward:
+    return FE_DOWNWARD;
+    break;
+  case RoundingMode::TowardZero:
+    return FE_TOWARDZERO;
+    break;
+  case RoundingMode::Nearest:
+    return FE_TONEAREST;
+    break;
+  }
+}
+
+ForceRoundingMode::ForceRoundingMode(RoundingMode mode) {
+  old_rounding_mode = fegetround();
+  rounding_mode = get_fe_rounding(mode);
+  if (old_rounding_mode != rounding_mode)
+    fesetround(rounding_mode);
+}
+
+ForceRoundingMode::~ForceRoundingMode() {
+  if (old_rounding_mode != rounding_mode)
+    fesetround(old_rounding_mode);
+}
+
+} // namespace testutils
+} // namespace __llvm_libc