[libc] Make fenv and math tests preserve fenv_t state #89658
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This adds a new test fixture class FEnvSafeTest (usable as a base class for other fixtures) that ensures each test doesn't perturb the `fenv_t` state that the next test will start with. It also provides types and methods tests can use to explicitly wrap code under test either to check that it doesn't perturb the state or to save and restore the state around particular test code. All the fenv and math tests are updated to use this so that none can affect another. Expectations that code under test and/or tests themselves don't perturb state can be added later.
|
✅ With the latest revision this PR passed the C/C++ code formatter. |
|
@llvm/pr-subscribers-libc Author: Roland McGrath (frobtech) Changes
Patch is 71.47 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/89658.diff 81 Files Affected:
diff --git a/libc/test/UnitTest/CMakeLists.txt b/libc/test/UnitTest/CMakeLists.txt
index 9113eca388e05b..302af3044ca3d6 100644
--- a/libc/test/UnitTest/CMakeLists.txt
+++ b/libc/test/UnitTest/CMakeLists.txt
@@ -111,8 +111,10 @@ add_header_library(
add_unittest_framework_library(
LibcFPTestHelpers
SRCS
+ FEnvSafeTest.cpp
RoundingModeUtils.cpp
HDRS
+ FEnvSafeTest.h
FPMatcher.h
RoundingModeUtils.h
DEPENDS
diff --git a/libc/test/UnitTest/FEnvSafeTest.cpp b/libc/test/UnitTest/FEnvSafeTest.cpp
new file mode 100644
index 00000000000000..43aebc3f36e7b3
--- /dev/null
+++ b/libc/test/UnitTest/FEnvSafeTest.cpp
@@ -0,0 +1,84 @@
+//===-- FEnvSafeTest.cpp ---------------------------------------*- 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
+//
+//===---------------------------------------------------------------------===//
+
+#include "FEnvSafeTest.h"
+
+#include "src/__support/FPUtil/FEnvImpl.h"
+#include "src/__support/macros/properties/architectures.h"
+
+namespace LIBC_NAMESPACE::testing {
+
+void FEnvSafeTest::PreserveFEnv::check() {
+ fenv_t after;
+ test.get_fenv(after);
+ test.expect_fenv_eq(before, after);
+}
+
+void FEnvSafeTest::TearDown() {
+ if (!should_be_unchanged) {
+ restore_fenv();
+ }
+}
+
+void FEnvSafeTest::get_fenv(fenv_t &fenv) {
+ ASSERT_EQ(LIBC_NAMESPACE::fputil::get_env(&fenv), 0);
+}
+
+void FEnvSafeTest::set_fenv(const fenv_t &fenv) {
+ ASSERT_EQ(LIBC_NAMESPACE::fputil::set_env(&fenv), 0);
+}
+
+void FEnvSafeTest::expect_fenv_eq(const fenv_t &before_fenv,
+ const fenv_t &after_fenv) {
+#if defined(LIBC_TARGET_ARCH_IS_AARCH64)
+ using LIBC_NAMESPACE::fputil::FEnv::FPState;
+ const FPState &before_state = reinterpret_cast<const FPState &>(before_fenv);
+ const FPState &after_state = reinterpret_cast<const FPState &>(after_fenv);
+
+ EXPECT_EQ(before_state.ControlWord, after_state.ControlWord);
+ EXPECT_EQ(before_state.StatusWord, after_state.StatusWord);
+
+#elif defined(LIBC_TARGET_ARCH_IS_X86) && !defined(__APPLE__)
+ using LIBC_NAMESPACE::fputil::internal::FPState;
+ const FPState &before_state = reinterpret_cast<const FPState &>(before_fenv);
+ const FPState &after_state = reinterpret_cast<const FPState &>(after_fenv);
+
+#if defined(_WIN32)
+ EXPECT_EQ(before_state.control_word, after_state.control_word);
+ EXPECT_EQ(before_state.status_word, after_state.status_word);
+#elif defined(__APPLE__)
+ EXPECT_EQ(before_state.control_word, after_state.control_word);
+ EXPECT_EQ(before_state.status_word, after_state.status_word);
+ EXPECT_EQ(before_state.mxcsr, after_state.mxcsr);
+#else
+ EXPECT_EQ(before_state.x87_status.control_word,
+ after_state.x87_status.control_word);
+ EXPECT_EQ(before_state.x87_status.status_word,
+ after_state.x87_status.status_word);
+ EXPECT_EQ(before_state.mxcsr, after_state.mxcsr);
+#endif
+
+#elif defined(LIBC_TARGET_ARCH_IS_ARM) && defined(__ARM_FP)
+ using LIBC_NAMESPACE::fputil::FEnv;
+ const FEnv &before_state = reinterpret_cast<const FEnv &>(before_fenv);
+ const FEnv &after_state = reinterpret_cast<const FEnv &>(after_fenv);
+
+ EXPECT_EQ(before_state.fpscr, after_state.fpscr);
+
+#elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
+ const uint32_t &before_fcsr = reinterpret_cast<const uint32_t &>(before_fenv);
+ const uint32_t &after_fcsr = reinterpret_cast<const uint32_t &>(after_fenv);
+ EXPECT_EQ(before_fcsr, after_fcsr);
+
+#else
+ // No arch-specific `fenv_t` support, so nothing to compare.
+
+#endif
+}
+
+} // namespace LIBC_NAMESPACE::testing
diff --git a/libc/test/UnitTest/FEnvSafeTest.h b/libc/test/UnitTest/FEnvSafeTest.h
new file mode 100644
index 00000000000000..d5a8bb7ee667ce
--- /dev/null
+++ b/libc/test/UnitTest/FEnvSafeTest.h
@@ -0,0 +1,101 @@
+//===-- FEnvSafeTest.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_TEST_UNITTEST_FPENVSAFE_H
+#define LLVM_LIBC_TEST_UNITTEST_FPENVSAFE_H
+
+#include "hdr/types/fenv_t.h"
+#include "src/__support/CPP/utility.h"
+#include "test/UnitTest/Test.h"
+
+namespace LIBC_NAMESPACE::testing {
+
+// This provides a test fixture (or base class for other test fixtures) that
+// asserts that each test does not leave the FPU state represented by `fenv_t`
+// (aka `FPState`) perturbed from its initial state.
+class FEnvSafeTest : public Test {
+public:
+ void TearDown() override;
+
+protected:
+ // This is an RAII type where `PreserveFEnv preserve{this};` will sample the
+ // `fenv_t` state and restore it when `preserve` goes out of scope.
+ class PreserveFEnv {
+ fenv_t before;
+ FEnvSafeTest &test;
+
+ public:
+ explicit PreserveFEnv(FEnvSafeTest *self) : test{*self} {
+ test.get_fenv(before);
+ }
+
+ // Cause test expectation failures if the current state doesn't match what
+ // was captured in the constructor.
+ void check();
+
+ // Restore the state captured in the constructor.
+ void restore() { test.set_fenv(before); }
+
+ ~PreserveFEnv() { restore(); }
+ };
+
+ // This is an RAII type where `CheckFEnv check{this};` will sample the
+ // `fenv_t` state and require it be the same when `check` goes out of scope.
+ struct CheckFEnv : public PreserveFEnv {
+ using PreserveFEnv::PreserveFEnv;
+
+ ~CheckFEnv() { check(); }
+ };
+
+ // This calls callable() and returns its value, but has EXPECT_* failures if
+ // the `fenv_t` state is not preserved by the call.
+ template <typename T> decltype(auto) check_fenv_preserved(T &&callable) {
+ CheckFEnv check{this};
+ return cpp::forward<T>(callable)();
+ }
+
+ // This calls callable() and returns its value, but saves and restores the
+ // `fenv_t` state around the call.
+ template <typename T>
+ auto with_fenv_preserved(T &&callable)
+ -> decltype(cpp::forward<decltype(callable)>(callable)()) {
+ PreserveFEnv preserve{this};
+ return cpp::forward<T>(callable)();
+ }
+
+ // A test can call these to indicate it will or won't change `fenv_t` state.
+ void will_change_fenv() { should_be_unchanged = false; }
+ void will_not_change_fenv() { should_be_unchanged = true; }
+
+ // This explicitly resets back to the "before" state captured in SetUp().
+ // TearDown() always does this, but should_be_unchanged controls whether
+ // it also causes test failures if a test fails to restore it.
+ void restore_fenv() { check.restore(); }
+
+private:
+ void get_fenv(fenv_t &fenv);
+ void set_fenv(const fenv_t &fenv);
+ void expect_fenv_eq(const fenv_t &before_fenv, const fenv_t &after_fenv);
+
+ CheckFEnv check{this};
+
+ // TODO: Many tests fail if this is true. It needs to be figured out whether
+ // the state should be preserved by each library function under test, and
+ // separately whether each test itself should preserve the state. It
+ // probably isn't important that tests be explicitly written to preserve the
+ // state, as the fixture can (and does) reset it--the next test can rely on
+ // getting "normal" ambient state initially. For library functions that
+ // should preserve the state, that should be checked after each call, not
+ // just after the whole test. So they can use check_fenv_preserved or
+ // with_fenv_preserved as appropriate.
+ bool should_be_unchanged = false;
+};
+
+} // namespace LIBC_NAMESPACE::testing
+
+#endif // LLVM_LIBC_TEST_UNITTEST_FPENVSAFE_H
diff --git a/libc/test/src/fenv/CMakeLists.txt b/libc/test/src/fenv/CMakeLists.txt
index f277b65e2d42be..b776f9a0706e86 100644
--- a/libc/test/src/fenv/CMakeLists.txt
+++ b/libc/test/src/fenv/CMakeLists.txt
@@ -9,6 +9,8 @@ add_libc_unittest(
DEPENDS
libc.src.fenv.fegetround
libc.src.fenv.fesetround
+ LINK_LIBRARIES
+ LibcFPTestHelpers
)
add_libc_unittest(
@@ -23,6 +25,8 @@ add_libc_unittest(
libc.src.fenv.fesetexcept
libc.src.fenv.fetestexcept
libc.src.__support.FPUtil.fenv_impl
+ LINK_LIBRARIES
+ LibcFPTestHelpers
)
add_libc_unittest(
@@ -37,6 +41,8 @@ add_libc_unittest(
libc.src.fenv.fesetenv
libc.src.fenv.fesetround
libc.src.__support.FPUtil.fenv_impl
+ LINK_LIBRARIES
+ LibcFPTestHelpers
)
add_libc_unittest(
@@ -50,6 +56,8 @@ add_libc_unittest(
libc.src.fenv.fesetexceptflag
libc.src.fenv.fetestexceptflag
libc.src.__support.FPUtil.fenv_impl
+ LINK_LIBRARIES
+ LibcFPTestHelpers
)
add_libc_unittest(
@@ -62,6 +70,8 @@ add_libc_unittest(
libc.include.signal
libc.src.fenv.feupdateenv
libc.src.__support.FPUtil.fenv_impl
+ LINK_LIBRARIES
+ LibcFPTestHelpers
)
add_libc_unittest(
@@ -73,6 +83,8 @@ add_libc_unittest(
DEPENDS
libc.src.fenv.feclearexcept
libc.src.__support.FPUtil.fenv_impl
+ LINK_LIBRARIES
+ LibcFPTestHelpers
)
add_libc_unittest(
@@ -85,6 +97,8 @@ add_libc_unittest(
libc.src.fenv.fedisableexcept
libc.src.fenv.feenableexcept
libc.src.fenv.fegetexcept
+ LINK_LIBRARIES
+ LibcFPTestHelpers
)
if (NOT (LLVM_USE_SANITIZER OR (${LIBC_TARGET_OS} STREQUAL "windows")
@@ -109,6 +123,7 @@ if (NOT (LLVM_USE_SANITIZER OR (${LIBC_TARGET_OS} STREQUAL "windows")
libc.src.__support.FPUtil.fenv_impl
LINK_LIBRARIES
LibcFPExceptionHelpers
+ LibcFPTestHelpers
)
add_fp_unittest(
@@ -124,5 +139,6 @@ if (NOT (LLVM_USE_SANITIZER OR (${LIBC_TARGET_OS} STREQUAL "windows")
libc.src.__support.FPUtil.fenv_impl
LINK_LIBRARIES
LibcFPExceptionHelpers
+ LibcFPTestHelpers
)
endif()
diff --git a/libc/test/src/fenv/enabled_exceptions_test.cpp b/libc/test/src/fenv/enabled_exceptions_test.cpp
index 53440b704ca761..7d26eab5695bce 100644
--- a/libc/test/src/fenv/enabled_exceptions_test.cpp
+++ b/libc/test/src/fenv/enabled_exceptions_test.cpp
@@ -12,15 +12,20 @@
#include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/macros/properties/architectures.h"
+#include "test/UnitTest/FEnvSafeTest.h"
#include "test/UnitTest/FPExceptMatcher.h"
#include "test/UnitTest/Test.h"
#include "hdr/fenv_macros.h"
#include <signal.h>
+#include "excepts.h"
+
+using LlvmLibcExceptionStatusTest = LIBC_NAMESPACE::testing::FEnvSafeTest;
+
// This test enables an exception and verifies that raising that exception
// triggers SIGFPE.
-TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
+TEST_F(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
#if defined(LIBC_TARGET_ARCH_IS_ANY_ARM) || \
defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
// Few Arm HW implementations do not trap exceptions. We skip this test
@@ -41,16 +46,7 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
// that exception handler, so such a testing can be done after we have
// longjmp implemented.
- int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
- FE_UNDERFLOW};
-
- // We '|' the individual exception flags instead of using FE_ALL_EXCEPT
- // as it can include non-standard extensions. Note that we should be able
- // to compile this file with headers from other libcs as well.
- constexpr int ALL_EXCEPTS =
- FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW;
-
- for (int e : excepts) {
+ for (int e : EXCEPTS) {
LIBC_NAMESPACE::fputil::disable_except(FE_ALL_EXCEPT);
LIBC_NAMESPACE::fputil::enable_except(e);
ASSERT_EQ(LIBC_NAMESPACE::feclearexcept(FE_ALL_EXCEPT), 0);
diff --git a/libc/test/src/fenv/exception_flags_test.cpp b/libc/test/src/fenv/exception_flags_test.cpp
index 9d2be6426a6d0b..2f4332df861fec 100644
--- a/libc/test/src/fenv/exception_flags_test.cpp
+++ b/libc/test/src/fenv/exception_flags_test.cpp
@@ -12,18 +12,20 @@
#include "src/fenv/fetestexceptflag.h"
#include "src/__support/FPUtil/FEnvImpl.h"
+#include "test/UnitTest/FEnvSafeTest.h"
#include "test/UnitTest/Test.h"
-TEST(LlvmLibcFenvTest, GetSetTestExceptFlag) {
+#include "excepts.h"
+
+using LlvmLibcFEnvTest = LIBC_NAMESPACE::testing::FEnvSafeTest;
+
+TEST_F(LlvmLibcFEnvTest, GetSetTestExceptFlag) {
// We will disable all exceptions to prevent invocation of the exception
// handler.
LIBC_NAMESPACE::fputil::disable_except(FE_ALL_EXCEPT);
LIBC_NAMESPACE::fputil::clear_except(FE_ALL_EXCEPT);
- int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
- FE_UNDERFLOW};
-
- for (int e : excepts) {
+ for (int e : EXCEPTS) {
// The overall idea is to raise an except and save the exception flags.
// Next, clear the flags and then set the saved exception flags. This
// should set the flag corresponding to the previously raised exception.
diff --git a/libc/test/src/fenv/exception_status_test.cpp b/libc/test/src/fenv/exception_status_test.cpp
index a7000020b1a3c8..fdf9421457866e 100644
--- a/libc/test/src/fenv/exception_status_test.cpp
+++ b/libc/test/src/fenv/exception_status_test.cpp
@@ -13,24 +13,23 @@
#include "src/fenv/fetestexcept.h"
#include "src/__support/FPUtil/FEnvImpl.h"
+#include "test/UnitTest/FEnvSafeTest.h"
#include "test/UnitTest/Test.h"
#include "hdr/fenv_macros.h"
-TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
+#include "excepts.h"
+
+using LlvmLibcExceptionStatusTest = LIBC_NAMESPACE::testing::FEnvSafeTest;
+
+TEST_F(LlvmLibcExceptionStatusTest, RaiseAndTest) {
// This test raises a set of exceptions and checks that the exception
// status flags are updated. The intention is really not to invoke the
// exception handler. Hence, we will disable all exceptions at the
// beginning.
LIBC_NAMESPACE::fputil::disable_except(FE_ALL_EXCEPT);
- int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
- FE_UNDERFLOW};
-
- constexpr int ALL_EXCEPTS =
- FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW;
-
- for (int e : excepts) {
+ for (int e : EXCEPTS) {
int r = LIBC_NAMESPACE::feraiseexcept(e);
ASSERT_EQ(r, 0);
int s = LIBC_NAMESPACE::fetestexcept(e);
@@ -47,8 +46,8 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
ASSERT_EQ(s, e);
}
- for (int e1 : excepts) {
- for (int e2 : excepts) {
+ for (int e1 : EXCEPTS) {
+ for (int e2 : EXCEPTS) {
int e = e1 | e2;
int r = LIBC_NAMESPACE::feraiseexcept(e);
ASSERT_EQ(r, 0);
@@ -67,9 +66,9 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
}
}
- for (int e1 : excepts) {
- for (int e2 : excepts) {
- for (int e3 : excepts) {
+ for (int e1 : EXCEPTS) {
+ for (int e2 : EXCEPTS) {
+ for (int e3 : EXCEPTS) {
int e = e1 | e2 | e3;
int r = LIBC_NAMESPACE::feraiseexcept(e);
ASSERT_EQ(r, 0);
@@ -89,10 +88,10 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
}
}
- for (int e1 : excepts) {
- for (int e2 : excepts) {
- for (int e3 : excepts) {
- for (int e4 : excepts) {
+ for (int e1 : EXCEPTS) {
+ for (int e2 : EXCEPTS) {
+ for (int e3 : EXCEPTS) {
+ for (int e4 : EXCEPTS) {
int e = e1 | e2 | e3 | e4;
int r = LIBC_NAMESPACE::feraiseexcept(e);
ASSERT_EQ(r, 0);
@@ -113,11 +112,11 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
}
}
- for (int e1 : excepts) {
- for (int e2 : excepts) {
- for (int e3 : excepts) {
- for (int e4 : excepts) {
- for (int e5 : excepts) {
+ for (int e1 : EXCEPTS) {
+ for (int e2 : EXCEPTS) {
+ for (int e3 : EXCEPTS) {
+ for (int e4 : EXCEPTS) {
+ for (int e5 : EXCEPTS) {
int e = e1 | e2 | e3 | e4 | e5;
int r = LIBC_NAMESPACE::feraiseexcept(e);
ASSERT_EQ(r, 0);
diff --git a/libc/test/src/fenv/excepts.h b/libc/test/src/fenv/excepts.h
new file mode 100644
index 00000000000000..e9517d319a9b79
--- /dev/null
+++ b/libc/test/src/fenv/excepts.h
@@ -0,0 +1,24 @@
+//===-- List of all FE_* constants for tests -----------------------------===//
+//
+// 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_TEST_SRC_FENV_EXCEPTS_H
+#define LLVM_LIBC_TEST_SRC_FENV_EXCEPTS_H
+
+#include "hdr/fenv_macros.h"
+
+constexpr int EXCEPTS[] = {
+ FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW, FE_UNDERFLOW,
+};
+
+// We '|' the individual exception flags instead of using FE_ALL_EXCEPT
+// as it can include non-standard extensions. Note that we should be able
+// to compile this file with headers from other libcs as well.
+constexpr int ALL_EXCEPTS =
+ FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW;
+
+#endif // LLVM_LIBC_TEST_SRC_FENV_EXCEPTS_H
diff --git a/libc/test/src/fenv/feclearexcept_test.cpp b/libc/test/src/fenv/feclearexcept_test.cpp
index bb42d9070358ef..52adda46adf2f0 100644
--- a/libc/test/src/fenv/feclearexcept_test.cpp
+++ b/libc/test/src/fenv/feclearexcept_test.cpp
@@ -9,27 +9,30 @@
#include "src/fenv/feclearexcept.h"
#include "src/__support/FPUtil/FEnvImpl.h"
+#include "test/UnitTest/FEnvSafeTest.h"
#include "test/UnitTest/Test.h"
#include "hdr/fenv_macros.h"
#include <stdint.h>
-TEST(LlvmLibcFEnvTest, ClearTest) {
- uint16_t excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
- FE_UNDERFLOW};
+#include "excepts.h"
+
+using LlvmLibcFEnvTest = LIBC_NAMESPACE::testing::FEnvSafeTest;
+
+TEST_F(LlvmLibcFEnvTest, ClearTest) {
LIBC_NAMESPACE::fputil::disable_except(FE_ALL_EXCEPT);
LIBC_NAMESPACE::fputil::clear_except(FE_ALL_EXCEPT);
- for (uint16_t e : excepts)
+ for (int e : EXCEPTS)
ASSERT_EQ(LIBC_NAMESPACE::fputil::test_except(e), 0);
LIBC_NAMESPACE::fputil::raise_except(FE_ALL_EXCEPT);
- for (uint16_t e1 : excepts) {
- for (uint16_t e2 : excepts) {
- for (uint16_t e3 : excepts) {
- for (uint16_t e4 : excepts) {
- for (uint16_t e5 : excepts) {
+ for (int e1 : EXCEPTS) {
+ for (int e2 : EXCEPTS) {
+ for (int e3 : EXCEPTS) {
+ for (int e4 : EXCEPTS) {
+ for (int e5 : EXCEPTS) {
// We clear one exception and test to verify that it was cleared.
LIBC_NAMESPACE::feclearexcept(e1 | e2 | e3 | e4 | e5);
ASSERT_EQ(
diff --git a/libc/test/src/fenv/feenableexcept_test.cpp b/libc/test/src/fenv/feenableexcept_test.cpp
index aeb4f955fd69b6..232e2a1c8316c6 100644
--- a/libc/test/src/fenv/feenableexcept_test.cpp
+++ b/libc/test/src/fenv/feenableexcept_test.cpp
@@ -11,11 +11,16 @@
#include "src/fenv/feenableexcept.h"
#include "src/fenv/fegetexcept.h"
+#include "test/UnitTest/FEnvSafeTest.h"
#include "test/UnitTest/Test.h"
#include "hdr/fenv_macros.h"
-TEST(LlvmLibcFEnvTest, EnableTest) {
+#include "excepts.h"
+
+using LlvmLibcFEnvTest = LIBC_NAMESPACE::testing::FEnvSafeTest;
+
+TEST_F(LlvmLibcFEnvTest, EnableTest) {
#if defined(LIBC_TARGET_ARCH_IS_ANY_ARM) || \
defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
// Few Arm HW implementations do not trap exceptions. We skip this test
diff --git a/libc/test/src/fenv/feholdexcept_test.cpp b/libc/test/src/fenv/feholdexcept_test.cpp
index 0689d89ab233a3..f3e05d4a5b6c0d 100644
--- a/libc/test/src/fenv/feholdexcept_test.cpp
+++ b/libc/test/src/fenv/feholdexcept_test.cpp
@@ -11,10 +11,15 @@
#include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/macros/properties/architectures.h"
+#include "test/UnitTest/FEnvSafeTest.h"
#include "test/UnitTest/FPExceptMatcher.h"
#include "test/UnitTest/Test.h"
-TEST(LlvmLibcFEnvTest, RaiseAndCrash) {
+#include "excepts.h"
+
+using LlvmLibcFEnvTest = LIBC_NAMESPACE::testing::FEnvSafeTest;
+
+TEST_F(LlvmLibcFEnvTest, RaiseAndCrash) {
#if defined(LIBC_TARGET_ARCH_IS_ANY_ARM) || \
defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
// Few Arm HW implementations do not trap exceptions. We skip this test
diff --gi...
[truncated]
|
|
Mind updating the PR description? Not sure what happened there. |
frobtech
changed the title
michaelrj-google
added a commit
to michaelrj-google/llvm-project
that referenced
this pull request
Apr 23, 2024
The PR llvm#89658 updated up the fenv tests work, this patch updates the bazel to match.
Flandini
added a commit
to Flandini/llvm-project
that referenced
this pull request
Apr 30, 2024
…in atan* tests Moving towards llvm#89658 style matchers and test fixtures instead of macros
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This adds a new test fixture class FEnvSafeTest (usable as a base
class for other fixtures) that ensures each test doesn't perturb
the
fenv_tstate that the next test will start with. It alsoprovides types and methods tests can use to explicitly wrap code
under test either to check that it doesn't perturb the state or
to save and restore the state around particular test code.
All the fenv and math tests are updated to use this so that none
can affect another. Expectations that code under test and/or
tests themselves don't perturb state can be added later.