[libc] Move FPExceptMatcher out of TestHelpers.h

[sivachandra]

Summary

TestHelpers.h pulls few pieces from LLVM libc's unittest framework
which aren't available on platforms like Fuchsia which use their own
unittest framework. So, by moving FPExceptMatcher to a different file
we can exclude LLVM libc specific pieces in a cleaner way.

In a later pass, it might make more sense to rename TestHelpers.h also
to FPMatcher.h. That way, we can make macros like EXPECT_FP_EQ to be
equivalent to EXPECT_EQ on platforms like Fuchsia.

[michaelrj]

LGTM

libc/test/src/fenv/enabled_exceptions_test.cpp

 //===-- Unittests for feraiseexcept with exceptions enabled ---------------===//
 //
 // 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/fenv/feclearexcept.h"
 #include "src/fenv/feraiseexcept.h"
 #include "src/fenv/fetestexcept.h"
 
 #include "utils/FPUtil/FEnvUtils.h"
-#include "utils/FPUtil/TestHelpers.h"
+#include "utils/FPUtil/FPExceptMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 #include <signal.h>
 
 // This test enables an exception and verifies that raising that exception
 // triggers SIGFPE.
 TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {

libc/test/src/fenv/feholdexcept_test.cpp

 //===-- Unittests for feholdexcept with exceptions enabled ----------------===//
 //
 // 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/fenv/feholdexcept.h"
 
 #include "utils/FPUtil/FEnvUtils.h"
-#include "utils/FPUtil/TestHelpers.h"
+#include "utils/FPUtil/FPExceptMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcFEnvTest, RaiseAndCrash) {
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 

libc/utils/FPUtil/CMakeLists.txt

DEPENDS
     libc.include.errno
     libc.include.fenv
     libc.src.__support.common
     libc.utils.CPP.standalone_cpp
 )
 
 add_library(
   LibcFPTestHelpers
+    FPExceptMatcher.cpp
+    FPExceptMatcher.h
     TestHelpers.cpp
     TestHelpers.h
 )
 target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
 target_link_libraries(LibcFPTestHelpers LibcUnitTest)
 add_dependencies(
   LibcFPTestHelpers
   LibcUnitTest
   libc.utils.CPP.standalone_cpp
   libc.utils.FPUtil.fputil
 )

libc/utils/FPUtil/FPExceptMatcher.h

+//===-- FPExceptMatcher.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_FPUTIL_FP_EXCEPT_MATCHER_H
+#define LLVM_LIBC_UTILS_FPUTIL_FP_EXCEPT_MATCHER_H
+
+#ifndef LLVM_LIBC_TEST_USE_FUCHSIA
+
+#include "utils/UnitTest/Test.h"
+
+namespace __llvm_libc {
+namespace fputil {
+namespace testing {
+
+// TODO: Make the matcher match specific exceptions instead of just identifying
+// that an exception was raised.
+class FPExceptMatcher : public __llvm_libc::testing::Matcher<bool> {
+  bool exceptionRaised;
+
+public:
+  class FunctionCaller {
+  public:
+    virtual ~FunctionCaller(){};
+    virtual void call() = 0;
+  };
+
+  template <typename Func> static FunctionCaller *getFunctionCaller(Func func) {
+    struct Callable : public FunctionCaller {
+      Func f;
+      explicit Callable(Func theFunc) : f(theFunc) {}
+      void call() override { f(); }
+    };
+
+    return new Callable(func);
+  }
+
+  // Takes ownership of func.
+  explicit FPExceptMatcher(FunctionCaller *func);
+
+  bool match(bool unused) { return exceptionRaised; }
+
+  void explainError(testutils::StreamWrapper &stream) override {
+    stream << "A floating point exception should have been raised but it "
+           << "wasn't\n";
+  }
+};
+
+} // namespace testing
+} // namespace fputil
+} // namespace __llvm_libc
+
+#define ASSERT_RAISES_FP_EXCEPT(func)                                          \
+  ASSERT_THAT(                                                                 \
+      true,                                                                    \
+      __llvm_libc::fputil::testing::FPExceptMatcher(                           \
+          __llvm_libc::fputil::testing::FPExceptMatcher::getFunctionCaller(    \
+              func)))
+#else
+#define ASSERT_RAISES_FP_EXCEPT(func) ASSERT_DEATH(func, WITH_SIGNAL(SIGFPE))
+#endif // LLVM_LIBC_TEST_USE_FUCHSIA
+
+#endif // LLVM_LIBC_UTILS_FPUTIL_FP_EXCEPT_MATCHER_H

libc/utils/FPUtil/FPExceptMatcher.cpp

+//===-- FPExceptMatchers.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 "FPExceptMatcher.h"
+
+#include <fenv.h>
+#include <memory>
+#include <setjmp.h>
+#include <signal.h>
+
+namespace __llvm_libc {
+namespace fputil {
+namespace testing {
+
+#if defined(_WIN32)
+#define sigjmp_buf jmp_buf
+#define sigsetjmp(buf, save) setjmp(buf)
+#define siglongjmp(buf, val) longjmp(buf, val)
+#endif
+
+static thread_local sigjmp_buf jumpBuffer;
+static thread_local bool caughtExcept;
+
+static void sigfpeHandler(int sig) {
+  caughtExcept = true;
+  siglongjmp(jumpBuffer, -1);
+}
+
+FPExceptMatcher::FPExceptMatcher(FunctionCaller *func) {
+  auto oldSIGFPEHandler = signal(SIGFPE, &sigfpeHandler);
+  std::unique_ptr<FunctionCaller> funcUP(func);
+
+  caughtExcept = false;
+  fenv_t oldEnv;
+  fegetenv(&oldEnv);
+  if (sigsetjmp(jumpBuffer, 1) == 0)
+    funcUP->call();
+  // We restore the previous floating point environment after
+  // the call to the function which can potentially raise SIGFPE.
+  fesetenv(&oldEnv);
+  signal(SIGFPE, oldSIGFPEHandler);
+  exceptionRaised = caughtExcept;
+}
+
+} // namespace testing
+} // namespace fputil
+} // namespace __llvm_libc

libc/utils/FPUtil/TestHelpers.h

public:
   }
 };
 
 template <__llvm_libc::testing::TestCondition C, typename T>
 FPMatcher<T, C> getMatcher(T expectedValue) {
   return FPMatcher<T, C>(expectedValue);
 }
 
-// TODO: Make the matcher match specific exceptions instead of just identifying
-// that an exception was raised.
-class FPExceptMatcher : public __llvm_libc::testing::Matcher<bool> {
-  bool exceptionRaised;
-
-public:
-  class FunctionCaller {
-  public:
-    virtual ~FunctionCaller(){};
-    virtual void call() = 0;
-  };
-
-  template <typename Func> static FunctionCaller *getFunctionCaller(Func func) {
-    struct Callable : public FunctionCaller {
-      Func f;
-      explicit Callable(Func theFunc) : f(theFunc) {}
-      void call() override { f(); }
-    };
-
-    return new Callable(func);
-  }
-
-  // Takes ownership of func.
-  explicit FPExceptMatcher(FunctionCaller *func);
-
-  bool match(bool unused) { return exceptionRaised; }
-
-  void explainError(testutils::StreamWrapper &stream) override {
-    stream << "A floating point exception should have been raised but it "
-           << "wasn't\n";
-  }
-};
-
 } // namespace testing
 } // namespace fputil
 } // namespace __llvm_libc
 
 #define DECLARE_SPECIAL_CONSTANTS(T)                                           \
   using FPBits = __llvm_libc::fputil::FPBits<T>;                               \
   using UIntType = typename FPBits::UIntType;                                  \
   const T zero = T(FPBits::zero());                                            \
EXPECT_THAT(                                                                 \
           expected))
 
 #define ASSERT_FP_NE(expected, actual)                                         \
   ASSERT_THAT(                                                                 \
       actual,                                                                  \
       __llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_NE>( \
           expected))
 
-#ifdef LLVM_LIBC_TEST_USE_FUCHSIA
-#define ASSERT_RAISES_FP_EXCEPT(func) ASSERT_DEATH(func, WITH_SIGNAL(SIGFPE))
-#else
-#define ASSERT_RAISES_FP_EXCEPT(func)                                          \
-  ASSERT_THAT(                                                                 \
-      true,                                                                    \
-      __llvm_libc::fputil::testing::FPExceptMatcher(                           \
-          __llvm_libc::fputil::testing::FPExceptMatcher::getFunctionCaller(    \
-              func)))
-#endif // LLVM_LIBC_TEST_USE_FUCHSIA
-
 #endif // LLVM_LIBC_UTILS_FPUTIL_TEST_HELPERS_H

libc/utils/FPUtil/TestHelpers.cpp

 //===-- TestMatchers.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 "TestHelpers.h"
 
 #include "FPBits.h"
 
-#include <fenv.h>
-#include <memory>
-#include <setjmp.h>
-#include <signal.h>
 #include <string>
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
 // Return the first N hex digits of an integer as a string in upper case.
 template <typename T>

 
 template void describeValue<float>(const char *, float,
                                    testutils::StreamWrapper &);
 template void describeValue<double>(const char *, double,
                                     testutils::StreamWrapper &);
 template void describeValue<long double>(const char *, long double,
                                          testutils::StreamWrapper &);
 
-#if defined(_WIN32)
-#define sigjmp_buf jmp_buf
-#define sigsetjmp(buf, save) setjmp(buf)
-#define siglongjmp(buf, val) longjmp(buf, val)
-#endif
-
-static thread_local sigjmp_buf jumpBuffer;
-static thread_local bool caughtExcept;
-
-static void sigfpeHandler(int sig) {
-  caughtExcept = true;
-  siglongjmp(jumpBuffer, -1);
-}
-
-FPExceptMatcher::FPExceptMatcher(FunctionCaller *func) {
-  auto oldSIGFPEHandler = signal(SIGFPE, &sigfpeHandler);
-  std::unique_ptr<FunctionCaller> funcUP(func);
-
-  caughtExcept = false;
-  fenv_t oldEnv;
-  fegetenv(&oldEnv);
-  if (sigsetjmp(jumpBuffer, 1) == 0)
-    funcUP->call();
-  // We restore the previous floating point environment after
-  // the call to the function which can potentially raise SIGFPE.
-  fesetenv(&oldEnv);
-  signal(SIGFPE, oldSIGFPEHandler);
-  exceptionRaised = caughtExcept;
-}
-
 } // namespace testing
 } // namespace fputil
 } // namespace __llvm_libc