[libc][NFC] Add template tests for a bunch of math functions.
Namely, template tests have been added for the following functions:
ceil, copysign, fabs, fmax, fmin, floor, trunc, round.
GitOrigin-RevId: 80e166f81abd33d15ced8d6ab66cb4193e75b51e
diff --git a/test/src/math/CMakeLists.txt b/test/src/math/CMakeLists.txt
index 07d57b0..3ffcc97 100644
--- a/test/src/math/CMakeLists.txt
+++ b/test/src/math/CMakeLists.txt
@@ -82,6 +82,8 @@
libc_math_unittests
SRCS
fabs_test.cpp
+ HDRS
+ FAbsTest.h
DEPENDS
libc.include.math
libc.src.math.fabs
@@ -95,6 +97,8 @@
libc_math_unittests
SRCS
fabsf_test.cpp
+ HDRS
+ FAbsTest.h
DEPENDS
libc.include.math
libc.src.math.fabsf
@@ -108,6 +112,8 @@
libc_math_unittests
SRCS
fabsl_test.cpp
+ HDRS
+ FAbsTest.h
DEPENDS
libc.include.math
libc.src.math.fabsl
@@ -121,6 +127,8 @@
libc_math_unittests
SRCS
trunc_test.cpp
+ HDRS
+ TruncTest.h
DEPENDS
libc.include.math
libc.src.math.trunc
@@ -134,6 +142,8 @@
libc_math_unittests
SRCS
truncf_test.cpp
+ HDRS
+ TruncTest.h
DEPENDS
libc.include.math
libc.src.math.truncf
@@ -147,6 +157,8 @@
libc_math_unittests
SRCS
truncl_test.cpp
+ HDRS
+ TruncTest.h
DEPENDS
libc.include.math
libc.src.math.truncl
@@ -160,6 +172,8 @@
libc_math_unittests
SRCS
ceil_test.cpp
+ HDRS
+ CeilTest.h
DEPENDS
libc.include.math
libc.src.math.ceil
@@ -173,6 +187,8 @@
libc_math_unittests
SRCS
ceilf_test.cpp
+ HDRS
+ CeilTest.h
DEPENDS
libc.include.math
libc.src.math.ceilf
@@ -186,6 +202,8 @@
libc_math_unittests
SRCS
ceill_test.cpp
+ HDRS
+ CeilTest.h
DEPENDS
libc.include.math
libc.src.math.ceill
@@ -199,6 +217,8 @@
libc_math_unittests
SRCS
floor_test.cpp
+ HDRS
+ FloorTest.h
DEPENDS
libc.include.math
libc.src.math.floor
@@ -212,6 +232,8 @@
libc_math_unittests
SRCS
floorf_test.cpp
+ HDRS
+ FloorTest.h
DEPENDS
libc.include.math
libc.src.math.floorf
@@ -225,6 +247,8 @@
libc_math_unittests
SRCS
floorl_test.cpp
+ HDRS
+ FloorTest.h
DEPENDS
libc.include.math
libc.src.math.floorl
@@ -238,6 +262,8 @@
libc_math_unittests
SRCS
round_test.cpp
+ HDRS
+ RoundTest.h
DEPENDS
libc.include.math
libc.src.math.round
@@ -251,6 +277,8 @@
libc_math_unittests
SRCS
roundf_test.cpp
+ HDRS
+ RoundTest.h
DEPENDS
libc.include.math
libc.src.math.roundf
@@ -264,6 +292,8 @@
libc_math_unittests
SRCS
roundl_test.cpp
+ HDRS
+ RoundTest.h
DEPENDS
libc.include.math
libc.src.math.roundl
@@ -559,6 +589,8 @@
libc_math_unittests
SRCS
copysign_test.cpp
+ HDRS
+ CopySignTest.h
DEPENDS
libc.include.math
libc.src.math.copysign
@@ -571,6 +603,8 @@
libc_math_unittests
SRCS
copysignf_test.cpp
+ HDRS
+ CopySignTest.h
DEPENDS
libc.include.math
libc.src.math.copysignf
@@ -583,6 +617,8 @@
libc_math_unittests
SRCS
copysignl_test.cpp
+ HDRS
+ CopySignTest.h
DEPENDS
libc.include.math
libc.src.math.copysignl
@@ -832,6 +868,8 @@
libc_math_unittests
SRCS
fminf_test.cpp
+ HDRS
+ FMinTest.h
DEPENDS
libc.include.math
libc.src.math.fminf
@@ -844,6 +882,8 @@
libc_math_unittests
SRCS
fmin_test.cpp
+ HDRS
+ FMinTest.h
DEPENDS
libc.include.math
libc.src.math.fmin
@@ -856,6 +896,8 @@
libc_math_unittests
SRCS
fminl_test.cpp
+ HDRS
+ FMinTest.h
DEPENDS
libc.include.math
libc.src.math.fminl
@@ -868,6 +910,8 @@
libc_math_unittests
SRCS
fmaxf_test.cpp
+ HDRS
+ FMaxTest.h
DEPENDS
libc.include.math
libc.src.math.fmaxf
@@ -880,6 +924,8 @@
libc_math_unittests
SRCS
fmax_test.cpp
+ HDRS
+ FMaxTest.h
DEPENDS
libc.include.math
libc.src.math.fmax
@@ -892,6 +938,8 @@
libc_math_unittests
SRCS
fmaxl_test.cpp
+ HDRS
+ FMaxTest.h
DEPENDS
libc.include.math
libc.src.math.fmaxl
diff --git a/test/src/math/CeilTest.h b/test/src/math/CeilTest.h
new file mode 100644
index 0000000..b956616
--- /dev/null
+++ b/test/src/math/CeilTest.h
@@ -0,0 +1,84 @@
+//===-- Utility class to test ceil[f|l] -------------------------*- 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 "utils/FPUtil/TestHelpers.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+#include <math.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+template <typename T> class CeilTest : public __llvm_libc::testing::Test {
+
+ DECLARE_SPECIAL_CONSTANTS(T)
+
+public:
+ typedef T (*CeilFunc)(T);
+
+ void testSpecialNumbers(CeilFunc func) {
+ EXPECT_FP_EQ(zero, func(zero));
+ EXPECT_FP_EQ(negZero, func(negZero));
+
+ EXPECT_FP_EQ(inf, func(inf));
+ EXPECT_FP_EQ(negInf, func(negInf));
+
+ EXPECT_FP_EQ(aNaN, func(aNaN));
+ }
+
+ void testRoundedNumbers(CeilFunc func) {
+ EXPECT_FP_EQ(T(1.0), func(T(1.0)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
+ EXPECT_FP_EQ(T(10.0), func(T(10.0)));
+ EXPECT_FP_EQ(T(-10.0), func(T(-10.0)));
+ EXPECT_FP_EQ(T(1234.0), func(T(1234.0)));
+ EXPECT_FP_EQ(T(-1234.0), func(T(-1234.0)));
+ }
+
+ void testFractions(CeilFunc func) {
+ EXPECT_FP_EQ(T(1.0), func(T(0.5)));
+ EXPECT_FP_EQ(T(-0.0), func(T(-0.5)));
+ EXPECT_FP_EQ(T(1.0), func(T(0.115)));
+ EXPECT_FP_EQ(T(-0.0), func(T(-0.115)));
+ EXPECT_FP_EQ(T(1.0), func(T(0.715)));
+ EXPECT_FP_EQ(T(-0.0), func(T(-0.715)));
+ EXPECT_FP_EQ(T(2.0), func(T(1.3)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.3)));
+ EXPECT_FP_EQ(T(2.0), func(T(1.5)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.5)));
+ EXPECT_FP_EQ(T(2.0), func(T(1.75)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.75)));
+ EXPECT_FP_EQ(T(11.0), func(T(10.32)));
+ EXPECT_FP_EQ(T(-10.0), func(T(-10.32)));
+ EXPECT_FP_EQ(T(11.0), func(T(10.65)));
+ EXPECT_FP_EQ(T(-10.0), func(T(-10.65)));
+ EXPECT_FP_EQ(T(1235.0), func(T(1234.38)));
+ EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
+ EXPECT_FP_EQ(T(1235.0), func(T(1234.96)));
+ EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96)));
+ }
+
+ void testRange(CeilFunc func) {
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ T x = T(FPBits(v));
+ if (isnan(x) || isinf(x))
+ continue;
+
+ ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, func(x), 0.0);
+ }
+ }
+};
+
+#define LIST_CEIL_TESTS(T, func) \
+ using LlvmLibcCeilTest = CeilTest<T>; \
+ TEST_F(LlvmLibcCeilTest, SpecialNumbers) { testSpecialNumbers(&func); } \
+ TEST_F(LlvmLibcCeilTest, RoundedNubmers) { testRoundedNumbers(&func); } \
+ TEST_F(LlvmLibcCeilTest, Fractions) { testFractions(&func); } \
+ TEST_F(LlvmLibcCeilTest, Range) { testRange(&func); }
diff --git a/test/src/math/CopySignTest.h b/test/src/math/CopySignTest.h
new file mode 100644
index 0000000..acc6a0e
--- /dev/null
+++ b/test/src/math/CopySignTest.h
@@ -0,0 +1,55 @@
+//===-- Utility class to test copysign[f|l] ---------------------*- 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 "utils/FPUtil/TestHelpers.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+#include <math.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+template <typename T> class CopySignTest : public __llvm_libc::testing::Test {
+
+ DECLARE_SPECIAL_CONSTANTS(T)
+
+public:
+ typedef T (*CopySignFunc)(T, T);
+
+ void testSpecialNumbers(CopySignFunc func) {
+ EXPECT_FP_EQ(aNaN, func(aNaN, -1.0));
+ EXPECT_FP_EQ(aNaN, func(aNaN, 1.0));
+
+ EXPECT_FP_EQ(negInf, func(inf, -1.0));
+ EXPECT_FP_EQ(inf, func(negInf, 1.0));
+
+ EXPECT_FP_EQ(negZero, func(zero, -1.0));
+ EXPECT_FP_EQ(zero, func(negZero, 1.0));
+ }
+
+ void testRange(CopySignFunc func) {
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ T x = T(FPBits(v));
+ if (isnan(x) || isinf(x))
+ continue;
+
+ double res1 = func(x, -x);
+ ASSERT_FP_EQ(res1, -x);
+
+ double res2 = func(x, x);
+ ASSERT_FP_EQ(res2, x);
+ }
+ }
+};
+
+#define LIST_COPYSIGN_TESTS(T, func) \
+ using LlvmLibcCopySignTest = CopySignTest<T>; \
+ TEST_F(LlvmLibcCopySignTest, SpecialNumbers) { testSpecialNumbers(&func); } \
+ TEST_F(LlvmLibcCopySignTest, Range) { testRange(&func); }
diff --git a/test/src/math/FAbsTest.h b/test/src/math/FAbsTest.h
new file mode 100644
index 0000000..32217b0
--- /dev/null
+++ b/test/src/math/FAbsTest.h
@@ -0,0 +1,49 @@
+//===-- Utility class to test fabs[f|l] -------------------------*- 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 "utils/FPUtil/TestHelpers.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+#include <math.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+template <typename T> class FAbsTest : public __llvm_libc::testing::Test {
+
+ DECLARE_SPECIAL_CONSTANTS(T)
+
+public:
+ typedef T (*FabsFunc)(T);
+
+ void testSpecialNumbers(FabsFunc func) {
+ EXPECT_FP_EQ(aNaN, func(aNaN));
+
+ EXPECT_FP_EQ(inf, func(inf));
+ EXPECT_FP_EQ(inf, func(negInf));
+
+ EXPECT_FP_EQ(zero, func(zero));
+ EXPECT_FP_EQ(zero, func(negZero));
+ }
+
+ void testRange(FabsFunc func) {
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ T x = T(FPBits(v));
+ if (isnan(x) || isinf(x))
+ continue;
+ ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, func(x), 0.0);
+ }
+ }
+};
+
+#define LIST_FABS_TESTS(T, func) \
+ using LlvmLibcFAbsTest = FAbsTest<T>; \
+ TEST_F(LlvmLibcFAbsTest, SpecialNumbers) { testSpecialNumbers(&func); } \
+ TEST_F(LlvmLibcFAbsTest, Range) { testRange(&func); }
diff --git a/test/src/math/FMaxTest.h b/test/src/math/FMaxTest.h
new file mode 100644
index 0000000..c74d21f
--- /dev/null
+++ b/test/src/math/FMaxTest.h
@@ -0,0 +1,85 @@
+//===-- Utility class to test fmin[f|l] -------------------------*- 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 "utils/FPUtil/TestHelpers.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+#include <math.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+template <typename T> class FMaxTest : public __llvm_libc::testing::Test {
+
+ DECLARE_SPECIAL_CONSTANTS(T)
+
+public:
+ typedef T (*FMaxFunc)(T, T);
+
+ void testNaN(FMaxFunc func) {
+ EXPECT_FP_EQ(inf, func(aNaN, inf));
+ EXPECT_FP_EQ(negInf, func(negInf, aNaN));
+ EXPECT_FP_EQ(0.0, func(aNaN, 0.0));
+ EXPECT_FP_EQ(-0.0, func(-0.0, aNaN));
+ EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345)));
+ EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN));
+ EXPECT_FP_EQ(aNaN, func(aNaN, aNaN));
+ }
+
+ void testInfArg(FMaxFunc func) {
+ EXPECT_FP_EQ(inf, func(negInf, inf));
+ EXPECT_FP_EQ(inf, func(inf, 0.0));
+ EXPECT_FP_EQ(inf, func(-0.0, inf));
+ EXPECT_FP_EQ(inf, func(inf, T(1.2345)));
+ EXPECT_FP_EQ(inf, func(T(-1.2345), inf));
+ }
+
+ void testNegInfArg(FMaxFunc func) {
+ EXPECT_FP_EQ(inf, func(inf, negInf));
+ EXPECT_FP_EQ(0.0, func(negInf, 0.0));
+ EXPECT_FP_EQ(-0.0, func(-0.0, negInf));
+ EXPECT_FP_EQ(T(-1.2345), func(negInf, T(-1.2345)));
+ EXPECT_FP_EQ(T(1.2345), func(T(1.2345), negInf));
+ }
+
+ void testBothZero(FMaxFunc func) {
+ EXPECT_FP_EQ(0.0, func(0.0, 0.0));
+ EXPECT_FP_EQ(0.0, func(-0.0, 0.0));
+ EXPECT_FP_EQ(0.0, func(0.0, -0.0));
+ EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
+ }
+
+ void testRange(FMaxFunc func) {
+ constexpr UIntType count = 10000001;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
+ ++i, v += step, w -= step) {
+ T x = T(FPBits(v)), y = T(FPBits(w));
+ if (isnan(x) || isinf(x))
+ continue;
+ if (isnan(y) || isinf(y))
+ continue;
+ if ((x == 0) && (y == 0))
+ continue;
+
+ if (x > y) {
+ EXPECT_FP_EQ(x, func(x, y));
+ } else {
+ EXPECT_FP_EQ(y, func(x, y));
+ }
+ }
+ }
+};
+
+#define LIST_FMAX_TESTS(T, func) \
+ using LlvmLibcFMaxTest = FMaxTest<T>; \
+ TEST_F(LlvmLibcFMaxTest, NaN) { testNaN(&func); } \
+ TEST_F(LlvmLibcFMaxTest, InfArg) { testInfArg(&func); } \
+ TEST_F(LlvmLibcFMaxTest, NegInfArg) { testNegInfArg(&func); } \
+ TEST_F(LlvmLibcFMaxTest, BothZero) { testBothZero(&func); } \
+ TEST_F(LlvmLibcFMaxTest, Range) { testRange(&func); }
diff --git a/test/src/math/FMinTest.h b/test/src/math/FMinTest.h
new file mode 100644
index 0000000..9cc49c3
--- /dev/null
+++ b/test/src/math/FMinTest.h
@@ -0,0 +1,85 @@
+//===-- Utility class to test fmin[f|l] -------------------------*- 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 "utils/FPUtil/TestHelpers.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+#include <math.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+template <typename T> class FMinTest : public __llvm_libc::testing::Test {
+
+ DECLARE_SPECIAL_CONSTANTS(T)
+
+public:
+ typedef T (*FMinFunc)(T, T);
+
+ void testNaN(FMinFunc func) {
+ EXPECT_FP_EQ(inf, func(aNaN, inf));
+ EXPECT_FP_EQ(negInf, func(negInf, aNaN));
+ EXPECT_FP_EQ(0.0, func(aNaN, 0.0));
+ EXPECT_FP_EQ(-0.0, func(-0.0, aNaN));
+ EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345)));
+ EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN));
+ EXPECT_FP_EQ(aNaN, func(aNaN, aNaN));
+ }
+
+ void testInfArg(FMinFunc func) {
+ EXPECT_FP_EQ(negInf, func(negInf, inf));
+ EXPECT_FP_EQ(0.0, func(inf, 0.0));
+ EXPECT_FP_EQ(-0.0, func(-0.0, inf));
+ EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345)));
+ EXPECT_FP_EQ(T(-1.2345), func(T(-1.2345), inf));
+ }
+
+ void testNegInfArg(FMinFunc func) {
+ EXPECT_FP_EQ(negInf, func(inf, negInf));
+ EXPECT_FP_EQ(negInf, func(negInf, 0.0));
+ EXPECT_FP_EQ(negInf, func(-0.0, negInf));
+ EXPECT_FP_EQ(negInf, func(negInf, T(-1.2345)));
+ EXPECT_FP_EQ(negInf, func(T(1.2345), negInf));
+ }
+
+ void testBothZero(FMinFunc func) {
+ EXPECT_FP_EQ(0.0, func(0.0, 0.0));
+ EXPECT_FP_EQ(-0.0, func(-0.0, 0.0));
+ EXPECT_FP_EQ(-0.0, func(0.0, -0.0));
+ EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
+ }
+
+ void testRange(FMinFunc func) {
+ constexpr UIntType count = 10000001;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
+ ++i, v += step, w -= step) {
+ T x = T(FPBits(v)), y = T(FPBits(w));
+ if (isnan(x) || isinf(x))
+ continue;
+ if (isnan(y) || isinf(y))
+ continue;
+ if ((x == 0) && (y == 0))
+ continue;
+
+ if (x > y) {
+ EXPECT_FP_EQ(y, func(x, y));
+ } else {
+ EXPECT_FP_EQ(x, func(x, y));
+ }
+ }
+ }
+};
+
+#define LIST_FMIN_TESTS(T, func) \
+ using LlvmLibcFMinTest = FMinTest<T>; \
+ TEST_F(LlvmLibcFMinTest, NaN) { testNaN(&func); } \
+ TEST_F(LlvmLibcFMinTest, InfArg) { testInfArg(&func); } \
+ TEST_F(LlvmLibcFMinTest, NegInfArg) { testNegInfArg(&func); } \
+ TEST_F(LlvmLibcFMinTest, BothZero) { testBothZero(&func); } \
+ TEST_F(LlvmLibcFMinTest, Range) { testRange(&func); }
diff --git a/test/src/math/FloorTest.h b/test/src/math/FloorTest.h
new file mode 100644
index 0000000..8d59344
--- /dev/null
+++ b/test/src/math/FloorTest.h
@@ -0,0 +1,84 @@
+//===-- Utility class to test floor[f|l] ------------------------*- 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 "utils/FPUtil/TestHelpers.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+#include <math.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+template <typename T> class FloorTest : public __llvm_libc::testing::Test {
+
+ DECLARE_SPECIAL_CONSTANTS(T)
+
+public:
+ typedef T (*FloorFunc)(T);
+
+ void testSpecialNumbers(FloorFunc func) {
+ EXPECT_FP_EQ(zero, func(zero));
+ EXPECT_FP_EQ(negZero, func(negZero));
+
+ EXPECT_FP_EQ(inf, func(inf));
+ EXPECT_FP_EQ(negInf, func(negInf));
+
+ EXPECT_FP_EQ(aNaN, func(aNaN));
+ }
+
+ void testRoundedNumbers(FloorFunc func) {
+ EXPECT_FP_EQ(T(1.0), func(T(1.0)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
+ EXPECT_FP_EQ(T(10.0), func(T(10.0)));
+ EXPECT_FP_EQ(T(-10.0), func(T(-10.0)));
+ EXPECT_FP_EQ(T(1234.0), func(T(1234.0)));
+ EXPECT_FP_EQ(T(-1234.0), func(T(-1234.0)));
+ }
+
+ void testFractions(FloorFunc func) {
+ EXPECT_FP_EQ(T(0.0), func(T(0.5)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-0.5)));
+ EXPECT_FP_EQ(T(0.0), func(T(0.115)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-0.115)));
+ EXPECT_FP_EQ(T(0.0), func(T(0.715)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-0.715)));
+ EXPECT_FP_EQ(T(1.0), func(T(1.3)));
+ EXPECT_FP_EQ(T(-2.0), func(T(-1.3)));
+ EXPECT_FP_EQ(T(1.0), func(T(1.5)));
+ EXPECT_FP_EQ(T(-2.0), func(T(-1.5)));
+ EXPECT_FP_EQ(T(1.0), func(T(1.75)));
+ EXPECT_FP_EQ(T(-2.0), func(T(-1.75)));
+ EXPECT_FP_EQ(T(10.0), func(T(10.32)));
+ EXPECT_FP_EQ(T(-11.0), func(T(-10.32)));
+ EXPECT_FP_EQ(T(10.0), func(T(10.65)));
+ EXPECT_FP_EQ(T(-11.0), func(T(-10.65)));
+ EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
+ EXPECT_FP_EQ(T(-1235.0), func(T(-1234.38)));
+ EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
+ EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
+ }
+
+ void testRange(FloorFunc func) {
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ T x = T(FPBits(v));
+ if (isnan(x) || isinf(x))
+ continue;
+
+ ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, func(x), 0.0);
+ }
+ }
+};
+
+#define LIST_FLOOR_TESTS(T, func) \
+ using LlvmLibcFloorTest = FloorTest<T>; \
+ TEST_F(LlvmLibcFloorTest, SpecialNumbers) { testSpecialNumbers(&func); } \
+ TEST_F(LlvmLibcFloorTest, RoundedNubmers) { testRoundedNumbers(&func); } \
+ TEST_F(LlvmLibcFloorTest, Fractions) { testFractions(&func); } \
+ TEST_F(LlvmLibcFloorTest, Range) { testRange(&func); }
diff --git a/test/src/math/RoundTest.h b/test/src/math/RoundTest.h
new file mode 100644
index 0000000..11e9008
--- /dev/null
+++ b/test/src/math/RoundTest.h
@@ -0,0 +1,84 @@
+//===-- Utility class to test round[f|l] ------------------------*- 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 "utils/FPUtil/TestHelpers.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+#include <math.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+template <typename T> class RoundTest : public __llvm_libc::testing::Test {
+
+ DECLARE_SPECIAL_CONSTANTS(T)
+
+public:
+ typedef T (*RoundFunc)(T);
+
+ void testSpecialNumbers(RoundFunc func) {
+ EXPECT_FP_EQ(zero, func(zero));
+ EXPECT_FP_EQ(negZero, func(negZero));
+
+ EXPECT_FP_EQ(inf, func(inf));
+ EXPECT_FP_EQ(negInf, func(negInf));
+
+ EXPECT_FP_EQ(aNaN, func(aNaN));
+ }
+
+ void testRoundedNumbers(RoundFunc func) {
+ EXPECT_FP_EQ(T(1.0), func(T(1.0)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
+ EXPECT_FP_EQ(T(10.0), func(T(10.0)));
+ EXPECT_FP_EQ(T(-10.0), func(T(-10.0)));
+ EXPECT_FP_EQ(T(1234.0), func(T(1234.0)));
+ EXPECT_FP_EQ(T(-1234.0), func(T(-1234.0)));
+ }
+
+ void testFractions(RoundFunc func) {
+ EXPECT_FP_EQ(T(1.0), func(T(0.5)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-0.5)));
+ EXPECT_FP_EQ(T(0.0), func(T(0.115)));
+ EXPECT_FP_EQ(T(-0.0), func(T(-0.115)));
+ EXPECT_FP_EQ(T(1.0), func(T(0.715)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-0.715)));
+ EXPECT_FP_EQ(T(1.0), func(T(1.3)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.3)));
+ EXPECT_FP_EQ(T(2.0), func(T(1.5)));
+ EXPECT_FP_EQ(T(-2.0), func(T(-1.5)));
+ EXPECT_FP_EQ(T(2.0), func(T(1.75)));
+ EXPECT_FP_EQ(T(-2.0), func(T(-1.75)));
+ EXPECT_FP_EQ(T(10.0), func(T(10.32)));
+ EXPECT_FP_EQ(T(-10.0), func(T(-10.32)));
+ EXPECT_FP_EQ(T(11.0), func(T(10.65)));
+ EXPECT_FP_EQ(T(-11.0), func(T(-10.65)));
+ EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
+ EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
+ EXPECT_FP_EQ(T(1235.0), func(T(1234.96)));
+ EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
+ }
+
+ void testRange(RoundFunc func) {
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ T x = T(FPBits(v));
+ if (isnan(x) || isinf(x))
+ continue;
+
+ ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, func(x), 0.0);
+ }
+ }
+};
+
+#define LIST_ROUND_TESTS(T, func) \
+ using LlvmLibcRoundTest = RoundTest<T>; \
+ TEST_F(LlvmLibcRoundTest, SpecialNumbers) { testSpecialNumbers(&func); } \
+ TEST_F(LlvmLibcRoundTest, RoundedNubmers) { testRoundedNumbers(&func); } \
+ TEST_F(LlvmLibcRoundTest, Fractions) { testFractions(&func); } \
+ TEST_F(LlvmLibcRoundTest, Range) { testRange(&func); }
diff --git a/test/src/math/TruncTest.h b/test/src/math/TruncTest.h
new file mode 100644
index 0000000..5b015e9
--- /dev/null
+++ b/test/src/math/TruncTest.h
@@ -0,0 +1,84 @@
+//===-- Utility class to test trunc[f|l] ------------------------*- 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 "utils/FPUtil/TestHelpers.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+#include <math.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+template <typename T> class TruncTest : public __llvm_libc::testing::Test {
+
+ DECLARE_SPECIAL_CONSTANTS(T)
+
+public:
+ typedef T (*TruncFunc)(T);
+
+ void testSpecialNumbers(TruncFunc func) {
+ EXPECT_FP_EQ(zero, func(zero));
+ EXPECT_FP_EQ(negZero, func(negZero));
+
+ EXPECT_FP_EQ(inf, func(inf));
+ EXPECT_FP_EQ(negInf, func(negInf));
+
+ EXPECT_FP_EQ(aNaN, func(aNaN));
+ }
+
+ void testRoundedNumbers(TruncFunc func) {
+ EXPECT_FP_EQ(T(1.0), func(T(1.0)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
+ EXPECT_FP_EQ(T(10.0), func(T(10.0)));
+ EXPECT_FP_EQ(T(-10.0), func(T(-10.0)));
+ EXPECT_FP_EQ(T(1234.0), func(T(1234.0)));
+ EXPECT_FP_EQ(T(-1234.0), func(T(-1234.0)));
+ }
+
+ void testFractions(TruncFunc func) {
+ EXPECT_FP_EQ(T(0.0), func(T(0.5)));
+ EXPECT_FP_EQ(T(-0.0), func(T(-0.5)));
+ EXPECT_FP_EQ(T(0.0), func(T(0.115)));
+ EXPECT_FP_EQ(T(-0.0), func(T(-0.115)));
+ EXPECT_FP_EQ(T(0.0), func(T(0.715)));
+ EXPECT_FP_EQ(T(-0.0), func(T(-0.715)));
+ EXPECT_FP_EQ(T(1.0), func(T(1.3)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.3)));
+ EXPECT_FP_EQ(T(1.0), func(T(1.5)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.5)));
+ EXPECT_FP_EQ(T(1.0), func(T(1.75)));
+ EXPECT_FP_EQ(T(-1.0), func(T(-1.75)));
+ EXPECT_FP_EQ(T(10.0), func(T(10.32)));
+ EXPECT_FP_EQ(T(-10.0), func(T(-10.32)));
+ EXPECT_FP_EQ(T(10.0), func(T(10.65)));
+ EXPECT_FP_EQ(T(-10.0), func(T(-10.65)));
+ EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
+ EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
+ EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
+ EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96)));
+ }
+
+ void testRange(TruncFunc func) {
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ T x = T(FPBits(v));
+ if (isnan(x) || isinf(x))
+ continue;
+
+ ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, func(x), 0.0);
+ }
+ }
+};
+
+#define LIST_TRUNC_TESTS(T, func) \
+ using LlvmLibcTruncTest = TruncTest<T>; \
+ TEST_F(LlvmLibcTruncTest, SpecialNumbers) { testSpecialNumbers(&func); } \
+ TEST_F(LlvmLibcTruncTest, RoundedNubmers) { testRoundedNumbers(&func); } \
+ TEST_F(LlvmLibcTruncTest, Fractions) { testFractions(&func); } \
+ TEST_F(LlvmLibcTruncTest, Range) { testRange(&func); }
diff --git a/test/src/math/ceil_test.cpp b/test/src/math/ceil_test.cpp
index 2fd5c43..2a592e3 100644
--- a/test/src/math/ceil_test.cpp
+++ b/test/src/math/ceil_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "CeilTest.h"
+
#include "src/math/ceil.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-DECLARE_SPECIAL_CONSTANTS(double)
-
-TEST(LlvmLibcCeilTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::ceil(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::ceil(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::ceil(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::ceil(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::ceil(aNaN));
-}
-
-TEST(LlvmLibcCeilTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0, __llvm_libc::ceil(1.0));
- EXPECT_FP_EQ(-1.0, __llvm_libc::ceil(-1.0));
- EXPECT_FP_EQ(10.0, __llvm_libc::ceil(10.0));
- EXPECT_FP_EQ(-10.0, __llvm_libc::ceil(-10.0));
- EXPECT_FP_EQ(1234.0, __llvm_libc::ceil(1234.0));
- EXPECT_FP_EQ(-1234.0, __llvm_libc::ceil(-1234.0));
-}
-
-TEST(LlvmLibcCeilTest, Fractions) {
- EXPECT_FP_EQ(1.0, __llvm_libc::ceil(0.5));
- EXPECT_FP_EQ(-0.0, __llvm_libc::ceil(-0.5));
- EXPECT_FP_EQ(1.0, __llvm_libc::ceil(0.115));
- EXPECT_FP_EQ(-0.0, __llvm_libc::ceil(-0.115));
- EXPECT_FP_EQ(1.0, __llvm_libc::ceil(0.715));
- EXPECT_FP_EQ(-0.0, __llvm_libc::ceil(-0.715));
- EXPECT_FP_EQ(2.0, __llvm_libc::ceil(1.3));
- EXPECT_FP_EQ(-1.0, __llvm_libc::ceil(-1.3));
- EXPECT_FP_EQ(2.0, __llvm_libc::ceil(1.5));
- EXPECT_FP_EQ(-1.0, __llvm_libc::ceil(-1.5));
- EXPECT_FP_EQ(2.0, __llvm_libc::ceil(1.75));
- EXPECT_FP_EQ(-1.0, __llvm_libc::ceil(-1.75));
- EXPECT_FP_EQ(11.0, __llvm_libc::ceil(10.32));
- EXPECT_FP_EQ(-10.0, __llvm_libc::ceil(-10.32));
- EXPECT_FP_EQ(11.0, __llvm_libc::ceil(10.65));
- EXPECT_FP_EQ(-10.0, __llvm_libc::ceil(-10.65));
- EXPECT_FP_EQ(1235.0, __llvm_libc::ceil(1234.38));
- EXPECT_FP_EQ(-1234.0, __llvm_libc::ceil(-1234.38));
- EXPECT_FP_EQ(1235.0, __llvm_libc::ceil(1234.96));
- EXPECT_FP_EQ(-1234.0, __llvm_libc::ceil(-1234.96));
-}
-
-TEST(LlvmLibcCeilTest, InDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceil(x), 0.0);
- }
-}
+LIST_CEIL_TESTS(double, __llvm_libc::ceil)
diff --git a/test/src/math/ceilf_test.cpp b/test/src/math/ceilf_test.cpp
index dc20970..cfa8cb2 100644
--- a/test/src/math/ceilf_test.cpp
+++ b/test/src/math/ceilf_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "CeilTest.h"
+
#include "src/math/ceilf.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-DECLARE_SPECIAL_CONSTANTS(float)
-
-TEST(LlvmLibcCeilfTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::ceilf(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::ceilf(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::ceilf(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::ceilf(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::ceilf(aNaN));
-}
-
-TEST(LlvmLibcCeilfTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(1.0f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::ceilf(-1.0f));
- EXPECT_FP_EQ(10.0f, __llvm_libc::ceilf(10.0f));
- EXPECT_FP_EQ(-10.0f, __llvm_libc::ceilf(-10.0f));
- EXPECT_FP_EQ(1234.0f, __llvm_libc::ceilf(1234.0f));
- EXPECT_FP_EQ(-1234.0f, __llvm_libc::ceilf(-1234.0f));
-}
-
-TEST(LlvmLibcCeilfTest, Fractions) {
- EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(0.5f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::ceilf(-0.5f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(0.115f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::ceilf(-0.115f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(0.715f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::ceilf(-0.715f));
- EXPECT_FP_EQ(2.0f, __llvm_libc::ceilf(1.3f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::ceilf(-1.3f));
- EXPECT_FP_EQ(2.0f, __llvm_libc::ceilf(1.5f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::ceilf(-1.5f));
- EXPECT_FP_EQ(2.0f, __llvm_libc::ceilf(1.75f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::ceilf(-1.75f));
- EXPECT_FP_EQ(11.0f, __llvm_libc::ceilf(10.32f));
- EXPECT_FP_EQ(-10.0f, __llvm_libc::ceilf(-10.32f));
- EXPECT_FP_EQ(11.0f, __llvm_libc::ceilf(10.65f));
- EXPECT_FP_EQ(-10.0f, __llvm_libc::ceilf(-10.65f));
- EXPECT_FP_EQ(1235.0f, __llvm_libc::ceilf(1234.38f));
- EXPECT_FP_EQ(-1234.0f, __llvm_libc::ceilf(-1234.38f));
- EXPECT_FP_EQ(1235.0f, __llvm_libc::ceilf(1234.96f));
- EXPECT_FP_EQ(-1234.0f, __llvm_libc::ceilf(-1234.96f));
-}
-
-TEST(LlvmLibcCeilfTest, InFloatRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 1000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- float x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceilf(x), 0.0);
- }
-}
+LIST_CEIL_TESTS(float, __llvm_libc::ceilf)
diff --git a/test/src/math/ceill_test.cpp b/test/src/math/ceill_test.cpp
index 96d2c58..6fe3046 100644
--- a/test/src/math/ceill_test.cpp
+++ b/test/src/math/ceill_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "CeilTest.h"
+
#include "src/math/ceill.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<long double>;
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-DECLARE_SPECIAL_CONSTANTS(long double)
-
-TEST(LlvmLibcCeillTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::ceill(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::ceill(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::ceill(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::ceill(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::ceill(aNaN));
-}
-
-TEST(LlvmLibcCeillTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(1.0l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.0l));
- EXPECT_FP_EQ(10.0l, __llvm_libc::ceill(10.0l));
- EXPECT_FP_EQ(-10.0l, __llvm_libc::ceill(-10.0l));
- EXPECT_FP_EQ(1234.0l, __llvm_libc::ceill(1234.0l));
- EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.0l));
-}
-
-TEST(LlvmLibcCeillTest, Fractions) {
- EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(0.5l));
- EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.5l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(0.115l));
- EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.115l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(0.715l));
- EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.715l));
- EXPECT_FP_EQ(2.0l, __llvm_libc::ceill(1.3l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.3l));
- EXPECT_FP_EQ(2.0l, __llvm_libc::ceill(1.5l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.5l));
- EXPECT_FP_EQ(2.0l, __llvm_libc::ceill(1.75l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.75l));
- EXPECT_FP_EQ(11.0l, __llvm_libc::ceill(10.32l));
- EXPECT_FP_EQ(-10.0l, __llvm_libc::ceill(-10.32l));
- EXPECT_FP_EQ(11.0l, __llvm_libc::ceill(10.65l));
- EXPECT_FP_EQ(-10.0l, __llvm_libc::ceill(-10.65l));
- EXPECT_FP_EQ(1235.0l, __llvm_libc::ceill(1234.38l));
- EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.38l));
- EXPECT_FP_EQ(1235.0l, __llvm_libc::ceill(1234.96l));
- EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.96l));
-}
-
-TEST(LlvmLibcCeillTest, InLongDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- long double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceill(x), 0.0);
- }
-}
+LIST_CEIL_TESTS(long double, __llvm_libc::ceill)
diff --git a/test/src/math/copysign_test.cpp b/test/src/math/copysign_test.cpp
index b7ee517..37bfa0d 100644
--- a/test/src/math/copysign_test.cpp
+++ b/test/src/math/copysign_test.cpp
@@ -6,40 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "CopySignTest.h"
+
#include "src/math/copysign.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
-
-DECLARE_SPECIAL_CONSTANTS(double)
-
-TEST(LlvmLibcCopySignTest, SpecialNumbers) {
- EXPECT_FP_EQ(aNaN, __llvm_libc::copysign(aNaN, -1.0));
- EXPECT_FP_EQ(aNaN, __llvm_libc::copysign(aNaN, 1.0));
-
- EXPECT_FP_EQ(negInf, __llvm_libc::copysign(inf, -1.0));
- EXPECT_FP_EQ(inf, __llvm_libc::copysign(negInf, 1.0));
-
- EXPECT_FP_EQ(negZero, __llvm_libc::copysign(zero, -1.0));
- EXPECT_FP_EQ(zero, __llvm_libc::copysign(negZero, 1.0));
-}
-
-TEST(LlvmLibcCopySignTest, InDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = FPBits(v);
- if (isnan(x) || isinf(x) || x == 0)
- continue;
-
- double res1 = __llvm_libc::copysign(x, -x);
- ASSERT_FP_EQ(res1, -x);
-
- double res2 = __llvm_libc::copysign(x, x);
- ASSERT_FP_EQ(res2, x);
- }
-}
+LIST_COPYSIGN_TESTS(double, __llvm_libc::copysign)
diff --git a/test/src/math/copysignf_test.cpp b/test/src/math/copysignf_test.cpp
index 6ad29a6..fec283c 100644
--- a/test/src/math/copysignf_test.cpp
+++ b/test/src/math/copysignf_test.cpp
@@ -6,40 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "CopySignTest.h"
+
#include "src/math/copysignf.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
-
-DECLARE_SPECIAL_CONSTANTS(float)
-
-TEST(LlvmLibcCopySinfTest, SpecialNumbers) {
- EXPECT_FP_EQ(aNaN, __llvm_libc::copysignf(aNaN, -1.0));
- EXPECT_FP_EQ(aNaN, __llvm_libc::copysignf(aNaN, 1.0));
-
- EXPECT_FP_EQ(negInf, __llvm_libc::copysignf(inf, -1.0));
- EXPECT_FP_EQ(inf, __llvm_libc::copysignf(negInf, 1.0));
-
- EXPECT_FP_EQ(negZero, __llvm_libc::copysignf(zero, -1.0));
- EXPECT_FP_EQ(zero, __llvm_libc::copysignf(negZero, 1.0));
-}
-
-TEST(LlvmLibcCopySinfTest, InFloatRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 1000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- float x = FPBits(v);
- if (isnan(x) || isinf(x) || x == 0)
- continue;
-
- float res1 = __llvm_libc::copysignf(x, -x);
- ASSERT_FP_EQ(res1, -x);
-
- float res2 = __llvm_libc::copysignf(x, x);
- ASSERT_FP_EQ(res2, x);
- }
-}
+LIST_COPYSIGN_TESTS(float, __llvm_libc::copysignf)
diff --git a/test/src/math/copysignl_test.cpp b/test/src/math/copysignl_test.cpp
index 89deff6..d1de911 100644
--- a/test/src/math/copysignl_test.cpp
+++ b/test/src/math/copysignl_test.cpp
@@ -6,40 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "CopySignTest.h"
+
#include "src/math/copysignl.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<long double>;
-
-DECLARE_SPECIAL_CONSTANTS(long double)
-
-TEST(LlvmLibcCopySinlTest, SpecialNumbers) {
- EXPECT_FP_EQ(aNaN, __llvm_libc::copysignl(aNaN, -1.0));
- EXPECT_FP_EQ(aNaN, __llvm_libc::copysignl(aNaN, 1.0));
-
- EXPECT_FP_EQ(negInf, __llvm_libc::copysignl(inf, -1.0));
- EXPECT_FP_EQ(inf, __llvm_libc::copysignl(negInf, 1.0));
-
- EXPECT_FP_EQ(negZero, __llvm_libc::copysignl(zero, -1.0));
- EXPECT_FP_EQ(zero, __llvm_libc::copysignl(negZero, 1.0));
-}
-
-TEST(LlvmLibcCopySinlTest, InLongDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- long double x = FPBits(v);
- if (isnan(x) || isinf(x) || x == 0)
- continue;
-
- long double res1 = __llvm_libc::copysignl(x, -x);
- ASSERT_FP_EQ(res1, -x);
-
- long double res2 = __llvm_libc::copysignl(x, x);
- ASSERT_FP_EQ(res2, x);
- }
-}
+LIST_COPYSIGN_TESTS(long double, __llvm_libc::copysignl)
diff --git a/test/src/math/fabs_test.cpp b/test/src/math/fabs_test.cpp
index 0e7390b..2bf0ddd 100644
--- a/test/src/math/fabs_test.cpp
+++ b/test/src/math/fabs_test.cpp
@@ -6,37 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "FAbsTest.h"
+
#include "src/math/fabs.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
-
-DECLARE_SPECIAL_CONSTANTS(double)
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-TEST(LlvmLibcFabsTest, SpecialNumbers) {
- EXPECT_FP_EQ(aNaN, __llvm_libc::fabs(aNaN));
-
- EXPECT_FP_EQ(inf, __llvm_libc::fabs(inf));
- EXPECT_FP_EQ(inf, __llvm_libc::fabs(negInf));
-
- EXPECT_FP_EQ(zero, __llvm_libc::fabs(zero));
- EXPECT_FP_EQ(zero, __llvm_libc::fabs(negZero));
-}
-
-TEST(LlvmLibcFabsTest, InDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
- ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, __llvm_libc::fabs(x), 0.0);
- }
-}
+LIST_FABS_TESTS(double, __llvm_libc::fabs)
diff --git a/test/src/math/fabsf_test.cpp b/test/src/math/fabsf_test.cpp
index 9a67ade..6374a10 100644
--- a/test/src/math/fabsf_test.cpp
+++ b/test/src/math/fabsf_test.cpp
@@ -6,37 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "FAbsTest.h"
+
#include "src/math/fabsf.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
-
-DECLARE_SPECIAL_CONSTANTS(float)
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-TEST(LlvmLibcFabsfTest, SpecialNumbers) {
- EXPECT_FP_EQ(aNaN, __llvm_libc::fabsf(aNaN));
-
- EXPECT_FP_EQ(inf, __llvm_libc::fabsf(inf));
- EXPECT_FP_EQ(inf, __llvm_libc::fabsf(negInf));
-
- EXPECT_FP_EQ(zero, __llvm_libc::fabsf(zero));
- EXPECT_FP_EQ(zero, __llvm_libc::fabsf(negZero));
-}
-
-TEST(LlvmLibcFabsfTest, InFloatRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 1000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- float x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
- ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, __llvm_libc::fabsf(x), 0.0);
- }
-}
+LIST_FABS_TESTS(float, __llvm_libc::fabsf)
diff --git a/test/src/math/fabsl_test.cpp b/test/src/math/fabsl_test.cpp
index b51cf92..ff13202 100644
--- a/test/src/math/fabsl_test.cpp
+++ b/test/src/math/fabsl_test.cpp
@@ -6,37 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "FAbsTest.h"
+
#include "src/math/fabsl.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<long double>;
-
-DECLARE_SPECIAL_CONSTANTS(long double)
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-TEST(LlvmLibcFabslTest, SpecialNumbers) {
- EXPECT_FP_EQ(aNaN, __llvm_libc::fabsl(aNaN));
-
- EXPECT_FP_EQ(inf, __llvm_libc::fabsl(inf));
- EXPECT_FP_EQ(inf, __llvm_libc::fabsl(negInf));
-
- EXPECT_FP_EQ(zero, __llvm_libc::fabsl(zero));
- EXPECT_FP_EQ(zero, __llvm_libc::fabsl(negZero));
-}
-
-TEST(LlvmLibcFabslTest, InLongDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- long double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
- ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, __llvm_libc::fabsl(x), 0.0);
- }
-}
+LIST_FABS_TESTS(long double, __llvm_libc::fabsl)
diff --git a/test/src/math/floor_test.cpp b/test/src/math/floor_test.cpp
index cd3b170..e68ed3e 100644
--- a/test/src/math/floor_test.cpp
+++ b/test/src/math/floor_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "FloorTest.h"
+
#include "src/math/floor.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
-
-DECLARE_SPECIAL_CONSTANTS(double)
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-TEST(LlvmLibcFloorTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::floor(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::floor(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::floor(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::floor(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::floor(aNaN));
-}
-
-TEST(LlvmLibcFloorTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0, __llvm_libc::floor(1.0));
- EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-1.0));
- EXPECT_FP_EQ(10.0, __llvm_libc::floor(10.0));
- EXPECT_FP_EQ(-10.0, __llvm_libc::floor(-10.0));
- EXPECT_FP_EQ(1234.0, __llvm_libc::floor(1234.0));
- EXPECT_FP_EQ(-1234.0, __llvm_libc::floor(-1234.0));
-}
-
-TEST(LlvmLibcFloorTest, Fractions) {
- EXPECT_FP_EQ(0.0, __llvm_libc::floor(0.5));
- EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-0.5));
- EXPECT_FP_EQ(0.0, __llvm_libc::floor(0.115));
- EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-0.115));
- EXPECT_FP_EQ(0.0, __llvm_libc::floor(0.715));
- EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-0.715));
- EXPECT_FP_EQ(1.0, __llvm_libc::floor(1.3));
- EXPECT_FP_EQ(-2.0, __llvm_libc::floor(-1.3));
- EXPECT_FP_EQ(1.0, __llvm_libc::floor(1.5));
- EXPECT_FP_EQ(-2.0, __llvm_libc::floor(-1.5));
- EXPECT_FP_EQ(1.0, __llvm_libc::floor(1.75));
- EXPECT_FP_EQ(-2.0, __llvm_libc::floor(-1.75));
- EXPECT_FP_EQ(10.0, __llvm_libc::floor(10.32));
- EXPECT_FP_EQ(-11.0, __llvm_libc::floor(-10.32));
- EXPECT_FP_EQ(10.0, __llvm_libc::floor(10.65));
- EXPECT_FP_EQ(-11.0, __llvm_libc::floor(-10.65));
- EXPECT_FP_EQ(1234.0, __llvm_libc::floor(1234.38));
- EXPECT_FP_EQ(-1235.0, __llvm_libc::floor(-1234.38));
- EXPECT_FP_EQ(1234.0, __llvm_libc::floor(1234.96));
- EXPECT_FP_EQ(-1235.0, __llvm_libc::floor(-1234.96));
-}
-
-TEST(LlvmLibcFloorTest, InDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floor(x), 0.0);
- }
-}
+LIST_FLOOR_TESTS(double, __llvm_libc::floor)
diff --git a/test/src/math/floorf_test.cpp b/test/src/math/floorf_test.cpp
index 9ca71d4..f0538f7 100644
--- a/test/src/math/floorf_test.cpp
+++ b/test/src/math/floorf_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "FloorTest.h"
+
#include "src/math/floorf.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
-
-DECLARE_SPECIAL_CONSTANTS(float)
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-TEST(LlvmLibcFloorfTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::floorf(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::floorf(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::floorf(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::floorf(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::floorf(aNaN));
-}
-
-TEST(LlvmLibcFloorfTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0f, __llvm_libc::floorf(1.0f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-1.0f));
- EXPECT_FP_EQ(10.0f, __llvm_libc::floorf(10.0f));
- EXPECT_FP_EQ(-10.0f, __llvm_libc::floorf(-10.0f));
- EXPECT_FP_EQ(1234.0f, __llvm_libc::floorf(1234.0f));
- EXPECT_FP_EQ(-1234.0f, __llvm_libc::floorf(-1234.0f));
-}
-
-TEST(LlvmLibcFloorfTest, Fractions) {
- EXPECT_FP_EQ(0.0f, __llvm_libc::floorf(0.5f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-0.5f));
- EXPECT_FP_EQ(0.0f, __llvm_libc::floorf(0.115f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-0.115f));
- EXPECT_FP_EQ(0.0f, __llvm_libc::floorf(0.715f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-0.715f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::floorf(1.3f));
- EXPECT_FP_EQ(-2.0f, __llvm_libc::floorf(-1.3f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::floorf(1.5f));
- EXPECT_FP_EQ(-2.0f, __llvm_libc::floorf(-1.5f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::floorf(1.75f));
- EXPECT_FP_EQ(-2.0f, __llvm_libc::floorf(-1.75f));
- EXPECT_FP_EQ(10.0f, __llvm_libc::floorf(10.32f));
- EXPECT_FP_EQ(-11.0f, __llvm_libc::floorf(-10.32f));
- EXPECT_FP_EQ(10.0f, __llvm_libc::floorf(10.65f));
- EXPECT_FP_EQ(-11.0f, __llvm_libc::floorf(-10.65f));
- EXPECT_FP_EQ(1234.0f, __llvm_libc::floorf(1234.38f));
- EXPECT_FP_EQ(-1235.0f, __llvm_libc::floorf(-1234.38f));
- EXPECT_FP_EQ(1234.0f, __llvm_libc::floorf(1234.96f));
- EXPECT_FP_EQ(-1235.0f, __llvm_libc::floorf(-1234.96f));
-}
-
-TEST(LlvmLibcFloorfTest, InFloatRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 1000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- float x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floorf(x), 0.0);
- }
-}
+LIST_FLOOR_TESTS(float, __llvm_libc::floorf)
diff --git a/test/src/math/floorl_test.cpp b/test/src/math/floorl_test.cpp
index 6bf9353..1b244fd 100644
--- a/test/src/math/floorl_test.cpp
+++ b/test/src/math/floorl_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "FloorTest.h"
+
#include "src/math/floorl.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<long double>;
-
-DECLARE_SPECIAL_CONSTANTS(long double)
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-TEST(LlvmLibcFloorlTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::floorl(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::floorl(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::floorl(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::floorl(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::floorl(aNaN));
-}
-
-TEST(LlvmLibcFloorlTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0l, __llvm_libc::floorl(1.0l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-1.0l));
- EXPECT_FP_EQ(10.0l, __llvm_libc::floorl(10.0l));
- EXPECT_FP_EQ(-10.0l, __llvm_libc::floorl(-10.0l));
- EXPECT_FP_EQ(1234.0l, __llvm_libc::floorl(1234.0l));
- EXPECT_FP_EQ(-1234.0l, __llvm_libc::floorl(-1234.0l));
-}
-
-TEST(LlvmLibcFloorlTest, Fractions) {
- EXPECT_FP_EQ(0.0l, __llvm_libc::floorl(0.5l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-0.5l));
- EXPECT_FP_EQ(0.0l, __llvm_libc::floorl(0.115l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-0.115l));
- EXPECT_FP_EQ(0.0l, __llvm_libc::floorl(0.715l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-0.715l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::floorl(1.3l));
- EXPECT_FP_EQ(-2.0l, __llvm_libc::floorl(-1.3l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::floorl(1.5l));
- EXPECT_FP_EQ(-2.0l, __llvm_libc::floorl(-1.5l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::floorl(1.75l));
- EXPECT_FP_EQ(-2.0l, __llvm_libc::floorl(-1.75l));
- EXPECT_FP_EQ(10.0l, __llvm_libc::floorl(10.32l));
- EXPECT_FP_EQ(-11.0l, __llvm_libc::floorl(-10.32l));
- EXPECT_FP_EQ(10.0l, __llvm_libc::floorl(10.65l));
- EXPECT_FP_EQ(-11.0l, __llvm_libc::floorl(-10.65l));
- EXPECT_FP_EQ(1234.0l, __llvm_libc::floorl(1234.38l));
- EXPECT_FP_EQ(-1235.0l, __llvm_libc::floorl(-1234.38l));
- EXPECT_FP_EQ(1234.0l, __llvm_libc::floorl(1234.96l));
- EXPECT_FP_EQ(-1235.0l, __llvm_libc::floorl(-1234.96l));
-}
-
-TEST(LlvmLibcFloorlTest, InLongDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- long double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floorl(x), 0.0);
- }
-}
+LIST_FLOOR_TESTS(long double, __llvm_libc::floorl)
diff --git a/test/src/math/fmax_test.cpp b/test/src/math/fmax_test.cpp
index 843f073..9c81c09 100644
--- a/test/src/math/fmax_test.cpp
+++ b/test/src/math/fmax_test.cpp
@@ -6,67 +6,8 @@
//
//===---------------------------------------------------------------------===//
+#include "FMaxTest.h"
+
#include "src/math/fmax.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
-
-DECLARE_SPECIAL_CONSTANTS(double)
-
-TEST(LlvmLibcFmaxTest, NaNArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmax(aNaN, inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fmax(negInf, aNaN));
- EXPECT_FP_EQ(0.0, __llvm_libc::fmax(aNaN, 0.0));
- EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, aNaN));
- EXPECT_FP_EQ(-1.2345, __llvm_libc::fmax(aNaN, -1.2345));
- EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, aNaN));
- EXPECT_FP_EQ(aNaN, __llvm_libc::fmax(aNaN, aNaN));
-}
-
-TEST(LlvmLibcFmaxTest, InfArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmax(negInf, inf));
- EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, 0.0));
- EXPECT_FP_EQ(inf, __llvm_libc::fmax(-0.0, inf));
- EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, 1.2345));
- EXPECT_FP_EQ(inf, __llvm_libc::fmax(-1.2345, inf));
-}
-
-TEST(LlvmLibcFmaxTest, NegInfArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, negInf));
- EXPECT_FP_EQ(0.0, __llvm_libc::fmax(negInf, 0.0));
- EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, negInf));
- EXPECT_FP_EQ(-1.2345, __llvm_libc::fmax(negInf, -1.2345));
- EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, negInf));
-}
-
-TEST(LlvmLibcFmaxTest, BothZero) {
- EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, 0.0));
- EXPECT_FP_EQ(0.0, __llvm_libc::fmax(-0.0, 0.0));
- EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, -0.0));
- EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, -0.0));
-}
-
-TEST(LlvmLibcFmaxTest, InDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000001;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
- ++i, v += step, w -= step) {
- double x = FPBits(v), y = FPBits(w);
- if (isnan(x) || isinf(x))
- continue;
- if (isnan(y) || isinf(y))
- continue;
- if ((x == 0) && (y == 0))
- continue;
-
- if (x > y) {
- EXPECT_FP_EQ(x, __llvm_libc::fmax(x, y));
- } else {
- EXPECT_FP_EQ(y, __llvm_libc::fmax(x, y));
- }
- }
-}
+LIST_FMAX_TESTS(double, __llvm_libc::fmax)
diff --git a/test/src/math/fmaxf_test.cpp b/test/src/math/fmaxf_test.cpp
index 70d9e70..cf337d4 100644
--- a/test/src/math/fmaxf_test.cpp
+++ b/test/src/math/fmaxf_test.cpp
@@ -4,69 +4,10 @@
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
-//===---------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+
+#include "FMaxTest.h"
#include "src/math/fmaxf.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
-
-DECLARE_SPECIAL_CONSTANTS(float)
-
-TEST(LlvmLibcFmaxfTest, NaNArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(aNaN, inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fmaxf(negInf, aNaN));
- EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(aNaN, 0.0f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, aNaN));
- EXPECT_FP_EQ(-1.2345f, __llvm_libc::fmaxf(aNaN, -1.2345f));
- EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, aNaN));
- EXPECT_FP_EQ(aNaN, __llvm_libc::fmaxf(aNaN, aNaN));
-}
-
-TEST(LlvmLibcFmaxfTest, InfArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(negInf, inf));
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, 0.0f));
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-0.0f, inf));
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, 1.2345f));
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-1.2345f, inf));
-}
-
-TEST(LlvmLibcFmaxfTest, NegInfArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, negInf));
- EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(negInf, 0.0f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, negInf));
- EXPECT_FP_EQ(-1.2345f, __llvm_libc::fmaxf(negInf, -1.2345f));
- EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, negInf));
-}
-
-TEST(LlvmLibcFmaxfTest, BothZero) {
- EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, 0.0f));
- EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(-0.0f, 0.0f));
- EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, -0.0f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, -0.0f));
-}
-
-TEST(LlvmLibcFmaxfTest, InFloatRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000001;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
- ++i, v += step, w -= step) {
- float x = FPBits(v), y = FPBits(w);
- if (isnan(x) || isinf(x))
- continue;
- if (isnan(y) || isinf(y))
- continue;
- if ((x == 0) && (y == 0))
- continue;
-
- if (x > y) {
- ASSERT_FP_EQ(x, __llvm_libc::fmaxf(x, y));
- } else {
- ASSERT_FP_EQ(y, __llvm_libc::fmaxf(x, y));
- }
- }
-}
+LIST_FMAX_TESTS(float, __llvm_libc::fmaxf)
diff --git a/test/src/math/fmaxl_test.cpp b/test/src/math/fmaxl_test.cpp
index 8a17c19..636bc42 100644
--- a/test/src/math/fmaxl_test.cpp
+++ b/test/src/math/fmaxl_test.cpp
@@ -4,69 +4,10 @@
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
-//===---------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+
+#include "FMaxTest.h"
#include "src/math/fmaxl.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<long double>;
-
-DECLARE_SPECIAL_CONSTANTS(long double)
-
-TEST(LlvmLibcFmaxlTest, NaNArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(aNaN, inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fmaxl(negInf, aNaN));
- EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(aNaN, 0.0L));
- EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, aNaN));
- EXPECT_FP_EQ(-1.2345L, __llvm_libc::fmaxl(aNaN, -1.2345L));
- EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, aNaN));
- EXPECT_FP_EQ(aNaN, __llvm_libc::fmaxl(aNaN, aNaN));
-}
-
-TEST(LlvmLibcFmaxlTest, InfArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(negInf, inf));
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, 0.0L));
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-0.0L, inf));
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, 1.2345L));
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-1.2345L, inf));
-}
-
-TEST(LlvmLibcFmaxlTest, NegInfArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, negInf));
- EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(negInf, 0.0L));
- EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, negInf));
- EXPECT_FP_EQ(-1.2345L, __llvm_libc::fmaxl(negInf, -1.2345L));
- EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, negInf));
-}
-
-TEST(LlvmLibcFmaxlTest, BothZero) {
- EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, 0.0L));
- EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(-0.0L, 0.0L));
- EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, -0.0L));
- EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, -0.0L));
-}
-
-TEST(LlvmLibcFmaxlTest, InLongDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000001;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
- ++i, v += step, w -= step) {
- long double x = FPBits(v), y = FPBits(w);
- if (isnan(x) || isinf(x))
- continue;
- if (isnan(y) || isinf(y))
- continue;
- if ((x == 0) && (y == 0))
- continue;
-
- if (x > y) {
- ASSERT_FP_EQ(x, __llvm_libc::fmaxl(x, y));
- } else {
- ASSERT_FP_EQ(y, __llvm_libc::fmaxl(x, y));
- }
- }
-}
+LIST_FMAX_TESTS(long double, __llvm_libc::fmaxl)
diff --git a/test/src/math/fmin_test.cpp b/test/src/math/fmin_test.cpp
index ef80d49..3515f97 100644
--- a/test/src/math/fmin_test.cpp
+++ b/test/src/math/fmin_test.cpp
@@ -6,67 +6,8 @@
//
//===---------------------------------------------------------------------===//
+#include "FMinTest.h"
+
#include "src/math/fmin.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
-
-DECLARE_SPECIAL_CONSTANTS(double)
-
-TEST(LlvmLibcFminTest, NaNArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fmin(aNaN, inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, aNaN));
- EXPECT_FP_EQ(0.0, __llvm_libc::fmin(aNaN, 0.0));
- EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, aNaN));
- EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(aNaN, -1.2345));
- EXPECT_FP_EQ(1.2345, __llvm_libc::fmin(1.2345, aNaN));
- EXPECT_FP_EQ(aNaN, __llvm_libc::fmin(aNaN, aNaN));
-}
-
-TEST(LlvmLibcFminTest, InfArg) {
- EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, inf));
- EXPECT_FP_EQ(0.0, __llvm_libc::fmin(inf, 0.0));
- EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, inf));
- EXPECT_FP_EQ(1.2345, __llvm_libc::fmin(inf, 1.2345));
- EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(-1.2345, inf));
-}
-
-TEST(LlvmLibcFminTest, NegInfArg) {
- EXPECT_FP_EQ(negInf, __llvm_libc::fmin(inf, negInf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, 0.0));
- EXPECT_FP_EQ(negInf, __llvm_libc::fmin(-0.0, negInf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, -1.2345));
- EXPECT_FP_EQ(negInf, __llvm_libc::fmin(1.2345, negInf));
-}
-
-TEST(LlvmLibcFminTest, BothZero) {
- EXPECT_FP_EQ(0.0, __llvm_libc::fmin(0.0, 0.0));
- EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, 0.0));
- EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(0.0, -0.0));
- EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, -0.0));
-}
-
-TEST(LlvmLibcFminTest, InFloatRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
- ++i, v += step, w -= step) {
- double x = FPBits(v), y = FPBits(w);
- if (isnan(x) || isinf(x))
- continue;
- if (isnan(y) || isinf(y))
- continue;
- if ((x == 0) && (y == 0))
- continue;
-
- if (x < y) {
- ASSERT_FP_EQ(x, __llvm_libc::fmin(x, y));
- } else {
- ASSERT_FP_EQ(y, __llvm_libc::fmin(x, y));
- }
- }
-}
+LIST_FMIN_TESTS(double, __llvm_libc::fmin)
diff --git a/test/src/math/fminf_test.cpp b/test/src/math/fminf_test.cpp
index 25daf6c..1a76247 100644
--- a/test/src/math/fminf_test.cpp
+++ b/test/src/math/fminf_test.cpp
@@ -1,72 +1,13 @@
-//===-- Unittests for fminf ----------------------------------------------===//
+//===-- Unittests for fminf -----------------------------------------------===//
//
// 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 "FMinTest.h"
#include "src/math/fminf.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
-
-DECLARE_SPECIAL_CONSTANTS(float)
-
-TEST(LlvmLibcFminfTest, NaNArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fminf(aNaN, inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, aNaN));
- EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(aNaN, 0.0f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, aNaN));
- EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(aNaN, -1.2345f));
- EXPECT_FP_EQ(1.2345f, __llvm_libc::fminf(1.2345f, aNaN));
- EXPECT_FP_EQ(aNaN, __llvm_libc::fminf(aNaN, aNaN));
-}
-
-TEST(LlvmLibcFminfTest, InfArg) {
- EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, inf));
- EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(inf, 0.0f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, inf));
- EXPECT_FP_EQ(1.2345f, __llvm_libc::fminf(inf, 1.2345f));
- EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(-1.2345f, inf));
-}
-
-TEST(LlvmLibcFminfTest, NegInfArg) {
- EXPECT_FP_EQ(negInf, __llvm_libc::fminf(inf, negInf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, 0.0f));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminf(-0.0f, negInf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, -1.2345f));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminf(1.2345f, negInf));
-}
-
-TEST(LlvmLibcFminfTest, BothZero) {
- EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(0.0f, 0.0f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, 0.0f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(0.0f, -0.0f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, -0.0f));
-}
-
-TEST(LlvmLibcFminfTest, InFloatRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
- ++i, v += step, w -= step) {
- float x = FPBits(v), y = FPBits(w);
- if (isnan(x) || isinf(x))
- continue;
- if (isnan(y) || isinf(y))
- continue;
- if ((x == 0) && (y == 0))
- continue;
-
- if (x < y) {
- ASSERT_FP_EQ(x, __llvm_libc::fminf(x, y));
- } else {
- ASSERT_FP_EQ(y, __llvm_libc::fminf(x, y));
- }
- }
-}
+LIST_FMIN_TESTS(float, __llvm_libc::fminf)
diff --git a/test/src/math/fminl_test.cpp b/test/src/math/fminl_test.cpp
index a618110..ce8b705 100644
--- a/test/src/math/fminl_test.cpp
+++ b/test/src/math/fminl_test.cpp
@@ -1,72 +1,13 @@
-//===-- Unittests for fmin -----------------------------------------------===//
+//===-- Unittests for fminl -----------------------------------------------===//
//
// 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 "FMinTest.h"
#include "src/math/fminl.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<long double>;
-
-DECLARE_SPECIAL_CONSTANTS(long double)
-
-TEST(LlvmLibcFminlTest, NaNArg) {
- EXPECT_FP_EQ(inf, __llvm_libc::fminl(aNaN, inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, aNaN));
- EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(aNaN, 0.0L));
- EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, aNaN));
- EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(aNaN, -1.2345L));
- EXPECT_FP_EQ(1.2345L, __llvm_libc::fminl(1.2345L, aNaN));
- EXPECT_FP_EQ(aNaN, __llvm_libc::fminl(aNaN, aNaN));
-}
-
-TEST(LlvmLibcFminlTest, InfArg) {
- EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, inf));
- EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(inf, 0.0L));
- EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, inf));
- EXPECT_FP_EQ(1.2345L, __llvm_libc::fminl(inf, 1.2345L));
- EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(-1.2345L, inf));
-}
-
-TEST(LlvmLibcFminlTest, NegInfArg) {
- EXPECT_FP_EQ(negInf, __llvm_libc::fminl(inf, negInf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, 0.0L));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminl(-0.0L, negInf));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, -1.2345L));
- EXPECT_FP_EQ(negInf, __llvm_libc::fminl(1.2345L, negInf));
-}
-
-TEST(LlvmLibcFminlTest, BothZero) {
- EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(0.0L, 0.0L));
- EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, 0.0L));
- EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(0.0L, -0.0L));
- EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, -0.0L));
-}
-
-TEST(LlvmLibcFminlTest, InLongDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
- ++i, v += step, w -= step) {
- long double x = FPBits(v), y = FPBits(w);
- if (isnan(x) || isinf(x))
- continue;
- if (isnan(y) || isinf(y))
- continue;
- if ((x == 0) && (y == 0))
- continue;
-
- if (x < y) {
- ASSERT_FP_EQ(x, __llvm_libc::fminl(x, y));
- } else {
- ASSERT_FP_EQ(y, __llvm_libc::fminl(x, y));
- }
- }
-}
+LIST_FMIN_TESTS(long double, __llvm_libc::fminl)
diff --git a/test/src/math/round_test.cpp b/test/src/math/round_test.cpp
index 1662514..87ce079 100644
--- a/test/src/math/round_test.cpp
+++ b/test/src/math/round_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "RoundTest.h"
+
#include "src/math/round.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-DECLARE_SPECIAL_CONSTANTS(double)
-
-TEST(LlvmLibcRoundTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::round(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::round(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::round(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::round(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::round(aNaN));
-}
-
-TEST(LlvmLibcRoundTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0, __llvm_libc::round(1.0));
- EXPECT_FP_EQ(-1.0, __llvm_libc::round(-1.0));
- EXPECT_FP_EQ(10.0, __llvm_libc::round(10.0));
- EXPECT_FP_EQ(-10.0, __llvm_libc::round(-10.0));
- EXPECT_FP_EQ(1234.0, __llvm_libc::round(1234.0));
- EXPECT_FP_EQ(-1234.0, __llvm_libc::round(-1234.0));
-}
-
-TEST(LlvmLibcRoundTest, Fractions) {
- EXPECT_FP_EQ(1.0, __llvm_libc::round(0.5));
- EXPECT_FP_EQ(-1.0, __llvm_libc::round(-0.5));
- EXPECT_FP_EQ(0.0, __llvm_libc::round(0.115));
- EXPECT_FP_EQ(-0.0, __llvm_libc::round(-0.115));
- EXPECT_FP_EQ(1.0, __llvm_libc::round(0.715));
- EXPECT_FP_EQ(-1.0, __llvm_libc::round(-0.715));
- EXPECT_FP_EQ(1.0, __llvm_libc::round(1.3));
- EXPECT_FP_EQ(-1.0, __llvm_libc::round(-1.3));
- EXPECT_FP_EQ(2.0, __llvm_libc::round(1.5));
- EXPECT_FP_EQ(-2.0, __llvm_libc::round(-1.5));
- EXPECT_FP_EQ(2.0, __llvm_libc::round(1.75));
- EXPECT_FP_EQ(-2.0, __llvm_libc::round(-1.75));
- EXPECT_FP_EQ(10.0, __llvm_libc::round(10.32));
- EXPECT_FP_EQ(-10.0, __llvm_libc::round(-10.32));
- EXPECT_FP_EQ(11.0, __llvm_libc::round(10.65));
- EXPECT_FP_EQ(-11.0, __llvm_libc::round(-10.65));
- EXPECT_FP_EQ(1234.0, __llvm_libc::round(1234.38));
- EXPECT_FP_EQ(-1234.0, __llvm_libc::round(-1234.38));
- EXPECT_FP_EQ(1235.0, __llvm_libc::round(1234.96));
- EXPECT_FP_EQ(-1235.0, __llvm_libc::round(-1234.96));
-}
-
-TEST(LlvmLibcRoundTest, InDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::round(x), 0.0);
- }
-}
+LIST_ROUND_TESTS(double, __llvm_libc::round)
diff --git a/test/src/math/roundf_test.cpp b/test/src/math/roundf_test.cpp
index 8a71072..0a182dd 100644
--- a/test/src/math/roundf_test.cpp
+++ b/test/src/math/roundf_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "RoundTest.h"
+
#include "src/math/roundf.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-DECLARE_SPECIAL_CONSTANTS(float)
-
-TEST(LlvmLibcRoundfTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::roundf(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::roundf(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::roundf(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::roundf(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::roundf(aNaN));
-}
-
-TEST(LlvmLibcRoundfTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(1.0f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-1.0f));
- EXPECT_FP_EQ(10.0f, __llvm_libc::roundf(10.0f));
- EXPECT_FP_EQ(-10.0f, __llvm_libc::roundf(-10.0f));
- EXPECT_FP_EQ(1234.0f, __llvm_libc::roundf(1234.0f));
- EXPECT_FP_EQ(-1234.0f, __llvm_libc::roundf(-1234.0f));
-}
-
-TEST(LlvmLibcRoundfTest, Fractions) {
- EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(0.5f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-0.5f));
- EXPECT_FP_EQ(0.0f, __llvm_libc::roundf(0.115f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::roundf(-0.115f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(0.715f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-0.715f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(1.3f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-1.3f));
- EXPECT_FP_EQ(2.0f, __llvm_libc::roundf(1.5f));
- EXPECT_FP_EQ(-2.0f, __llvm_libc::roundf(-1.5f));
- EXPECT_FP_EQ(2.0f, __llvm_libc::roundf(1.75f));
- EXPECT_FP_EQ(-2.0f, __llvm_libc::roundf(-1.75f));
- EXPECT_FP_EQ(10.0f, __llvm_libc::roundf(10.32f));
- EXPECT_FP_EQ(-10.0f, __llvm_libc::roundf(-10.32f));
- EXPECT_FP_EQ(11.0f, __llvm_libc::roundf(10.65f));
- EXPECT_FP_EQ(-11.0f, __llvm_libc::roundf(-10.65f));
- EXPECT_FP_EQ(1234.0f, __llvm_libc::roundf(1234.38f));
- EXPECT_FP_EQ(-1234.0f, __llvm_libc::roundf(-1234.38f));
- EXPECT_FP_EQ(1235.0f, __llvm_libc::roundf(1234.96f));
- EXPECT_FP_EQ(-1235.0f, __llvm_libc::roundf(-1234.96f));
-}
-
-TEST(LlvmLibcRoundfTest, InFloatRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 1000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- float x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::roundf(x), 0.0);
- }
-}
+LIST_ROUND_TESTS(float, __llvm_libc::roundf)
diff --git a/test/src/math/roundl_test.cpp b/test/src/math/roundl_test.cpp
index 83764ec..32cf724 100644
--- a/test/src/math/roundl_test.cpp
+++ b/test/src/math/roundl_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "RoundTest.h"
+
#include "src/math/roundl.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<long double>;
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-DECLARE_SPECIAL_CONSTANTS(long double)
-
-TEST(LlvmLibcRoundlTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::roundl(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::roundl(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::roundl(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::roundl(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::roundl(aNaN));
-}
-
-TEST(LlvmLibcRoundlTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(1.0l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-1.0l));
- EXPECT_FP_EQ(10.0l, __llvm_libc::roundl(10.0l));
- EXPECT_FP_EQ(-10.0l, __llvm_libc::roundl(-10.0l));
- EXPECT_FP_EQ(1234.0l, __llvm_libc::roundl(1234.0l));
- EXPECT_FP_EQ(-1234.0l, __llvm_libc::roundl(-1234.0l));
-}
-
-TEST(LlvmLibcRoundlTest, Fractions) {
- EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(0.5l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-0.5l));
- EXPECT_FP_EQ(0.0l, __llvm_libc::roundl(0.115l));
- EXPECT_FP_EQ(-0.0l, __llvm_libc::roundl(-0.115l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(0.715l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-0.715l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(1.3l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-1.3l));
- EXPECT_FP_EQ(2.0l, __llvm_libc::roundl(1.5l));
- EXPECT_FP_EQ(-2.0l, __llvm_libc::roundl(-1.5l));
- EXPECT_FP_EQ(2.0l, __llvm_libc::roundl(1.75l));
- EXPECT_FP_EQ(-2.0l, __llvm_libc::roundl(-1.75l));
- EXPECT_FP_EQ(10.0l, __llvm_libc::roundl(10.32l));
- EXPECT_FP_EQ(-10.0l, __llvm_libc::roundl(-10.32l));
- EXPECT_FP_EQ(11.0l, __llvm_libc::roundl(10.65l));
- EXPECT_FP_EQ(-11.0l, __llvm_libc::roundl(-10.65l));
- EXPECT_FP_EQ(1234.0l, __llvm_libc::roundl(1234.38l));
- EXPECT_FP_EQ(-1234.0l, __llvm_libc::roundl(-1234.38l));
- EXPECT_FP_EQ(1235.0l, __llvm_libc::roundl(1234.96l));
- EXPECT_FP_EQ(-1235.0l, __llvm_libc::roundl(-1234.96l));
-}
-
-TEST(LlvmLibcRoundlTest, InLongDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- long double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::roundl(x), 0.0);
- }
-}
+LIST_ROUND_TESTS(long double, __llvm_libc::roundl)
diff --git a/test/src/math/trunc_test.cpp b/test/src/math/trunc_test.cpp
index ee74485..f0a808d 100644
--- a/test/src/math/trunc_test.cpp
+++ b/test/src/math/trunc_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "TruncTest.h"
+
#include "src/math/trunc.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<double>;
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-DECLARE_SPECIAL_CONSTANTS(double)
-
-TEST(LlvmLibcTruncTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::trunc(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::trunc(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::trunc(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::trunc(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::trunc(aNaN));
-}
-
-TEST(LlvmLibcTruncTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0, __llvm_libc::trunc(1.0));
- EXPECT_FP_EQ(-1.0, __llvm_libc::trunc(-1.0));
- EXPECT_FP_EQ(10.0, __llvm_libc::trunc(10.0));
- EXPECT_FP_EQ(-10.0, __llvm_libc::trunc(-10.0));
- EXPECT_FP_EQ(1234.0, __llvm_libc::trunc(1234.0));
- EXPECT_FP_EQ(-1234.0, __llvm_libc::trunc(-1234.0));
-}
-
-TEST(LlvmLibcTruncTest, Fractions) {
- EXPECT_FP_EQ(0.0, __llvm_libc::trunc(0.5));
- EXPECT_FP_EQ(-0.0, __llvm_libc::trunc(-0.5));
- EXPECT_FP_EQ(0.0, __llvm_libc::trunc(0.115));
- EXPECT_FP_EQ(-0.0, __llvm_libc::trunc(-0.115));
- EXPECT_FP_EQ(0.0, __llvm_libc::trunc(0.715));
- EXPECT_FP_EQ(-0.0, __llvm_libc::trunc(-0.715));
- EXPECT_FP_EQ(1.0, __llvm_libc::trunc(1.3));
- EXPECT_FP_EQ(-1.0, __llvm_libc::trunc(-1.3));
- EXPECT_FP_EQ(1.0, __llvm_libc::trunc(1.5));
- EXPECT_FP_EQ(-1.0, __llvm_libc::trunc(-1.5));
- EXPECT_FP_EQ(1.0, __llvm_libc::trunc(1.75));
- EXPECT_FP_EQ(-1.0, __llvm_libc::trunc(-1.75));
- EXPECT_FP_EQ(10.0, __llvm_libc::trunc(10.32));
- EXPECT_FP_EQ(-10.0, __llvm_libc::trunc(-10.32));
- EXPECT_FP_EQ(10.0, __llvm_libc::trunc(10.65));
- EXPECT_FP_EQ(-10.0, __llvm_libc::trunc(-10.65));
- EXPECT_FP_EQ(1234.0, __llvm_libc::trunc(1234.38));
- EXPECT_FP_EQ(-1234.0, __llvm_libc::trunc(-1234.38));
- EXPECT_FP_EQ(1234.0, __llvm_libc::trunc(1234.96));
- EXPECT_FP_EQ(-1234.0, __llvm_libc::trunc(-1234.96));
-}
-
-TEST(LlvmLibcTruncTest, InDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::trunc(x), 0.0);
- }
-}
+LIST_TRUNC_TESTS(double, __llvm_libc::trunc)
diff --git a/test/src/math/truncf_test.cpp b/test/src/math/truncf_test.cpp
index 00f3d46..cbd672c 100644
--- a/test/src/math/truncf_test.cpp
+++ b/test/src/math/truncf_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "TruncTest.h"
+
#include "src/math/truncf.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<float>;
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-DECLARE_SPECIAL_CONSTANTS(float)
-
-TEST(LlvmLibcTruncfTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::truncf(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::truncf(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::truncf(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::truncf(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::truncf(aNaN));
-}
-
-TEST(LlvmLibcTruncfTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0f, __llvm_libc::truncf(1.0f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::truncf(-1.0f));
- EXPECT_FP_EQ(10.0f, __llvm_libc::truncf(10.0f));
- EXPECT_FP_EQ(-10.0f, __llvm_libc::truncf(-10.0f));
- EXPECT_FP_EQ(1234.0f, __llvm_libc::truncf(1234.0f));
- EXPECT_FP_EQ(-1234.0f, __llvm_libc::truncf(-1234.0f));
-}
-
-TEST(LlvmLibcTruncfTest, Fractions) {
- EXPECT_FP_EQ(0.0f, __llvm_libc::truncf(0.5f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::truncf(-0.5f));
- EXPECT_FP_EQ(0.0f, __llvm_libc::truncf(0.115f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::truncf(-0.115f));
- EXPECT_FP_EQ(0.0f, __llvm_libc::truncf(0.715f));
- EXPECT_FP_EQ(-0.0f, __llvm_libc::truncf(-0.715f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::truncf(1.3f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::truncf(-1.3f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::truncf(1.5f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::truncf(-1.5f));
- EXPECT_FP_EQ(1.0f, __llvm_libc::truncf(1.75f));
- EXPECT_FP_EQ(-1.0f, __llvm_libc::truncf(-1.75f));
- EXPECT_FP_EQ(10.0f, __llvm_libc::truncf(10.32f));
- EXPECT_FP_EQ(-10.0f, __llvm_libc::truncf(-10.32f));
- EXPECT_FP_EQ(10.0f, __llvm_libc::truncf(10.65f));
- EXPECT_FP_EQ(-10.0f, __llvm_libc::truncf(-10.65f));
- EXPECT_FP_EQ(1234.0f, __llvm_libc::truncf(1234.38f));
- EXPECT_FP_EQ(-1234.0f, __llvm_libc::truncf(-1234.38f));
- EXPECT_FP_EQ(1234.0f, __llvm_libc::truncf(1234.96f));
- EXPECT_FP_EQ(-1234.0f, __llvm_libc::truncf(-1234.96f));
-}
-
-TEST(LlvmLibcTruncfTest, InFloatRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 1000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- float x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::truncf(x), 0.0);
- }
-}
+LIST_TRUNC_TESTS(float, __llvm_libc::truncf)
diff --git a/test/src/math/truncl_test.cpp b/test/src/math/truncl_test.cpp
index e50e7a3..0cf9ab8 100644
--- a/test/src/math/truncl_test.cpp
+++ b/test/src/math/truncl_test.cpp
@@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//
+#include "TruncTest.h"
+
#include "src/math/truncl.h"
-#include "utils/FPUtil/FPBits.h"
-#include "utils/FPUtil/TestHelpers.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/UnitTest/Test.h"
-#include <math.h>
-using FPBits = __llvm_libc::fputil::FPBits<long double>;
-
-namespace mpfr = __llvm_libc::testing::mpfr;
-
-DECLARE_SPECIAL_CONSTANTS(long double)
-
-TEST(LlvmLibcTrunclTest, SpecialNumbers) {
- EXPECT_FP_EQ(zero, __llvm_libc::truncl(zero));
- EXPECT_FP_EQ(negZero, __llvm_libc::truncl(negZero));
-
- EXPECT_FP_EQ(inf, __llvm_libc::truncl(inf));
- EXPECT_FP_EQ(negInf, __llvm_libc::truncl(negInf));
-
- EXPECT_FP_EQ(aNaN, __llvm_libc::truncl(aNaN));
-}
-
-TEST(LlvmLibcTrunclTest, RoundedNumbers) {
- EXPECT_FP_EQ(1.0l, __llvm_libc::truncl(1.0l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::truncl(-1.0l));
- EXPECT_FP_EQ(10.0l, __llvm_libc::truncl(10.0l));
- EXPECT_FP_EQ(-10.0l, __llvm_libc::truncl(-10.0l));
- EXPECT_FP_EQ(1234.0l, __llvm_libc::truncl(1234.0l));
- EXPECT_FP_EQ(-1234.0l, __llvm_libc::truncl(-1234.0l));
-}
-
-TEST(LlvmLibcTrunclTest, Fractions) {
- EXPECT_FP_EQ(0.0l, __llvm_libc::truncl(0.5l));
- EXPECT_FP_EQ(-0.0l, __llvm_libc::truncl(-0.5l));
- EXPECT_FP_EQ(0.0l, __llvm_libc::truncl(0.115l));
- EXPECT_FP_EQ(-0.0l, __llvm_libc::truncl(-0.115l));
- EXPECT_FP_EQ(0.0l, __llvm_libc::truncl(0.715l));
- EXPECT_FP_EQ(-0.0l, __llvm_libc::truncl(-0.715l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::truncl(1.3l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::truncl(-1.3l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::truncl(1.5l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::truncl(-1.5l));
- EXPECT_FP_EQ(1.0l, __llvm_libc::truncl(1.75l));
- EXPECT_FP_EQ(-1.0l, __llvm_libc::truncl(-1.75l));
- EXPECT_FP_EQ(10.0l, __llvm_libc::truncl(10.32l));
- EXPECT_FP_EQ(-10.0l, __llvm_libc::truncl(-10.32l));
- EXPECT_FP_EQ(10.0l, __llvm_libc::truncl(10.65l));
- EXPECT_FP_EQ(-10.0l, __llvm_libc::truncl(-10.65l));
- EXPECT_FP_EQ(1234.0l, __llvm_libc::truncl(1234.38l));
- EXPECT_FP_EQ(-1234.0l, __llvm_libc::truncl(-1234.38l));
- EXPECT_FP_EQ(1234.0l, __llvm_libc::truncl(1234.96l));
- EXPECT_FP_EQ(-1234.0l, __llvm_libc::truncl(-1234.96l));
-}
-
-TEST(LlvmLibcTrunclTest, InLongDoubleRange) {
- using UIntType = FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
- long double x = FPBits(v);
- if (isnan(x) || isinf(x))
- continue;
-
- ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::truncl(x), 0.0);
- }
-}
+LIST_TRUNC_TESTS(long double, __llvm_libc::truncl)
diff --git a/utils/FPUtil/TestHelpers.h b/utils/FPUtil/TestHelpers.h
index c55f226..6ad6d3f 100644
--- a/utils/FPUtil/TestHelpers.h
+++ b/utils/FPUtil/TestHelpers.h
@@ -66,11 +66,13 @@
} // namespace __llvm_libc
#define DECLARE_SPECIAL_CONSTANTS(T) \
- static const T zero = __llvm_libc::fputil::FPBits<T>::zero(); \
- static const T negZero = __llvm_libc::fputil::FPBits<T>::negZero(); \
- static const T aNaN = __llvm_libc::fputil::FPBits<T>::buildNaN(1); \
- static const T inf = __llvm_libc::fputil::FPBits<T>::inf(); \
- static const T negInf = __llvm_libc::fputil::FPBits<T>::negInf();
+ using FPBits = __llvm_libc::fputil::FPBits<T>; \
+ using UIntType = typename FPBits::UIntType; \
+ const T zero = FPBits::zero(); \
+ const T negZero = FPBits::negZero(); \
+ const T aNaN = FPBits::buildNaN(1); \
+ const T inf = FPBits::inf(); \
+ const T negInf = FPBits::negInf();
#define EXPECT_FP_EQ(expected, actual) \
EXPECT_THAT( \
