From 80e166f81abd33d15ced8d6ab66cb4193e75b51e Mon Sep 17 00:00:00 2001 From: Siva Chandra Reddy Date: Wed, 14 Apr 2021 20:32:50 +0000 Subject: [PATCH] [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. --- libc/test/src/math/CMakeLists.txt | 48 +++++++++++++++ libc/test/src/math/CeilTest.h | 84 ++++++++++++++++++++++++++ libc/test/src/math/CopySignTest.h | 55 +++++++++++++++++ libc/test/src/math/FAbsTest.h | 49 +++++++++++++++ libc/test/src/math/FMaxTest.h | 85 +++++++++++++++++++++++++++ libc/test/src/math/FMinTest.h | 85 +++++++++++++++++++++++++++ libc/test/src/math/FloorTest.h | 84 ++++++++++++++++++++++++++ libc/test/src/math/RoundTest.h | 84 ++++++++++++++++++++++++++ libc/test/src/math/TruncTest.h | 84 ++++++++++++++++++++++++++ libc/test/src/math/ceil_test.cpp | 68 +-------------------- libc/test/src/math/ceilf_test.cpp | 68 +-------------------- libc/test/src/math/ceill_test.cpp | 68 +-------------------- libc/test/src/math/copysign_test.cpp | 38 +----------- libc/test/src/math/copysignf_test.cpp | 38 +----------- libc/test/src/math/copysignl_test.cpp | 38 +----------- libc/test/src/math/fabs_test.cpp | 35 +---------- libc/test/src/math/fabsf_test.cpp | 35 +---------- libc/test/src/math/fabsl_test.cpp | 35 +---------- libc/test/src/math/floor_test.cpp | 68 +-------------------- libc/test/src/math/floorf_test.cpp | 68 +-------------------- libc/test/src/math/floorl_test.cpp | 68 +-------------------- libc/test/src/math/fmax_test.cpp | 65 +------------------- libc/test/src/math/fmaxf_test.cpp | 67 ++------------------- libc/test/src/math/fmaxl_test.cpp | 67 ++------------------- libc/test/src/math/fmin_test.cpp | 65 +------------------- libc/test/src/math/fminf_test.cpp | 69 ++-------------------- libc/test/src/math/fminl_test.cpp | 69 ++-------------------- libc/test/src/math/round_test.cpp | 68 +-------------------- libc/test/src/math/roundf_test.cpp | 68 +-------------------- libc/test/src/math/roundl_test.cpp | 68 +-------------------- libc/test/src/math/trunc_test.cpp | 68 +-------------------- libc/test/src/math/truncf_test.cpp | 68 +-------------------- libc/test/src/math/truncl_test.cpp | 68 +-------------------- libc/utils/FPUtil/TestHelpers.h | 12 ++-- 34 files changed, 743 insertions(+), 1364 deletions(-) create mode 100644 libc/test/src/math/CeilTest.h create mode 100644 libc/test/src/math/CopySignTest.h create mode 100644 libc/test/src/math/FAbsTest.h create mode 100644 libc/test/src/math/FMaxTest.h create mode 100644 libc/test/src/math/FMinTest.h create mode 100644 libc/test/src/math/FloorTest.h create mode 100644 libc/test/src/math/RoundTest.h create mode 100644 libc/test/src/math/TruncTest.h diff --git a/libc/test/src/math/CMakeLists.txt b/libc/test/src/math/CMakeLists.txt index 07d57b06a87e..3ffcc976c7a2 100644 --- a/libc/test/src/math/CMakeLists.txt +++ b/libc/test/src/math/CMakeLists.txt @@ -82,6 +82,8 @@ add_fp_unittest( libc_math_unittests SRCS fabs_test.cpp + HDRS + FAbsTest.h DEPENDS libc.include.math libc.src.math.fabs @@ -95,6 +97,8 @@ add_fp_unittest( libc_math_unittests SRCS fabsf_test.cpp + HDRS + FAbsTest.h DEPENDS libc.include.math libc.src.math.fabsf @@ -108,6 +112,8 @@ add_fp_unittest( libc_math_unittests SRCS fabsl_test.cpp + HDRS + FAbsTest.h DEPENDS libc.include.math libc.src.math.fabsl @@ -121,6 +127,8 @@ add_fp_unittest( libc_math_unittests SRCS trunc_test.cpp + HDRS + TruncTest.h DEPENDS libc.include.math libc.src.math.trunc @@ -134,6 +142,8 @@ add_fp_unittest( libc_math_unittests SRCS truncf_test.cpp + HDRS + TruncTest.h DEPENDS libc.include.math libc.src.math.truncf @@ -147,6 +157,8 @@ add_fp_unittest( libc_math_unittests SRCS truncl_test.cpp + HDRS + TruncTest.h DEPENDS libc.include.math libc.src.math.truncl @@ -160,6 +172,8 @@ add_fp_unittest( libc_math_unittests SRCS ceil_test.cpp + HDRS + CeilTest.h DEPENDS libc.include.math libc.src.math.ceil @@ -173,6 +187,8 @@ add_fp_unittest( libc_math_unittests SRCS ceilf_test.cpp + HDRS + CeilTest.h DEPENDS libc.include.math libc.src.math.ceilf @@ -186,6 +202,8 @@ add_fp_unittest( libc_math_unittests SRCS ceill_test.cpp + HDRS + CeilTest.h DEPENDS libc.include.math libc.src.math.ceill @@ -199,6 +217,8 @@ add_fp_unittest( libc_math_unittests SRCS floor_test.cpp + HDRS + FloorTest.h DEPENDS libc.include.math libc.src.math.floor @@ -212,6 +232,8 @@ add_fp_unittest( libc_math_unittests SRCS floorf_test.cpp + HDRS + FloorTest.h DEPENDS libc.include.math libc.src.math.floorf @@ -225,6 +247,8 @@ add_fp_unittest( libc_math_unittests SRCS floorl_test.cpp + HDRS + FloorTest.h DEPENDS libc.include.math libc.src.math.floorl @@ -238,6 +262,8 @@ add_fp_unittest( libc_math_unittests SRCS round_test.cpp + HDRS + RoundTest.h DEPENDS libc.include.math libc.src.math.round @@ -251,6 +277,8 @@ add_fp_unittest( libc_math_unittests SRCS roundf_test.cpp + HDRS + RoundTest.h DEPENDS libc.include.math libc.src.math.roundf @@ -264,6 +292,8 @@ add_fp_unittest( libc_math_unittests SRCS roundl_test.cpp + HDRS + RoundTest.h DEPENDS libc.include.math libc.src.math.roundl @@ -559,6 +589,8 @@ add_fp_unittest( libc_math_unittests SRCS copysign_test.cpp + HDRS + CopySignTest.h DEPENDS libc.include.math libc.src.math.copysign @@ -571,6 +603,8 @@ add_fp_unittest( libc_math_unittests SRCS copysignf_test.cpp + HDRS + CopySignTest.h DEPENDS libc.include.math libc.src.math.copysignf @@ -583,6 +617,8 @@ add_fp_unittest( libc_math_unittests SRCS copysignl_test.cpp + HDRS + CopySignTest.h DEPENDS libc.include.math libc.src.math.copysignl @@ -832,6 +868,8 @@ add_fp_unittest( libc_math_unittests SRCS fminf_test.cpp + HDRS + FMinTest.h DEPENDS libc.include.math libc.src.math.fminf @@ -844,6 +882,8 @@ add_fp_unittest( libc_math_unittests SRCS fmin_test.cpp + HDRS + FMinTest.h DEPENDS libc.include.math libc.src.math.fmin @@ -856,6 +896,8 @@ add_fp_unittest( libc_math_unittests SRCS fminl_test.cpp + HDRS + FMinTest.h DEPENDS libc.include.math libc.src.math.fminl @@ -868,6 +910,8 @@ add_fp_unittest( libc_math_unittests SRCS fmaxf_test.cpp + HDRS + FMaxTest.h DEPENDS libc.include.math libc.src.math.fmaxf @@ -880,6 +924,8 @@ add_fp_unittest( libc_math_unittests SRCS fmax_test.cpp + HDRS + FMaxTest.h DEPENDS libc.include.math libc.src.math.fmax @@ -892,6 +938,8 @@ add_fp_unittest( libc_math_unittests SRCS fmaxl_test.cpp + HDRS + FMaxTest.h DEPENDS libc.include.math libc.src.math.fmaxl diff --git a/libc/test/src/math/CeilTest.h b/libc/test/src/math/CeilTest.h new file mode 100644 index 000000000000..b956616fbf66 --- /dev/null +++ b/libc/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 + +namespace mpfr = __llvm_libc::testing::mpfr; + +template 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; \ + 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/libc/test/src/math/CopySignTest.h b/libc/test/src/math/CopySignTest.h new file mode 100644 index 000000000000..acc6a0e1f51b --- /dev/null +++ b/libc/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 + +namespace mpfr = __llvm_libc::testing::mpfr; + +template 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; \ + TEST_F(LlvmLibcCopySignTest, SpecialNumbers) { testSpecialNumbers(&func); } \ + TEST_F(LlvmLibcCopySignTest, Range) { testRange(&func); } diff --git a/libc/test/src/math/FAbsTest.h b/libc/test/src/math/FAbsTest.h new file mode 100644 index 000000000000..32217b0fe6b3 --- /dev/null +++ b/libc/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 + +namespace mpfr = __llvm_libc::testing::mpfr; + +template 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; \ + TEST_F(LlvmLibcFAbsTest, SpecialNumbers) { testSpecialNumbers(&func); } \ + TEST_F(LlvmLibcFAbsTest, Range) { testRange(&func); } diff --git a/libc/test/src/math/FMaxTest.h b/libc/test/src/math/FMaxTest.h new file mode 100644 index 000000000000..c74d21f46092 --- /dev/null +++ b/libc/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 + +namespace mpfr = __llvm_libc::testing::mpfr; + +template 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; \ + 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/libc/test/src/math/FMinTest.h b/libc/test/src/math/FMinTest.h new file mode 100644 index 000000000000..9cc49c35f6db --- /dev/null +++ b/libc/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 + +namespace mpfr = __llvm_libc::testing::mpfr; + +template 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; \ + 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/libc/test/src/math/FloorTest.h b/libc/test/src/math/FloorTest.h new file mode 100644 index 000000000000..8d59344c64fc --- /dev/null +++ b/libc/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 + +namespace mpfr = __llvm_libc::testing::mpfr; + +template 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; \ + 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/libc/test/src/math/RoundTest.h b/libc/test/src/math/RoundTest.h new file mode 100644 index 000000000000..11e900808f2d --- /dev/null +++ b/libc/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 + +namespace mpfr = __llvm_libc::testing::mpfr; + +template 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; \ + 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/libc/test/src/math/TruncTest.h b/libc/test/src/math/TruncTest.h new file mode 100644 index 000000000000..5b015e98852e --- /dev/null +++ b/libc/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 + +namespace mpfr = __llvm_libc::testing::mpfr; + +template 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; \ + 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/libc/test/src/math/ceil_test.cpp b/libc/test/src/math/ceil_test.cpp index 2fd5c439f229..2a592e3ee85b 100644 --- a/libc/test/src/math/ceil_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/ceilf_test.cpp b/libc/test/src/math/ceilf_test.cpp index dc20970d03f1..cfa8cb2c5aa6 100644 --- a/libc/test/src/math/ceilf_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/ceill_test.cpp b/libc/test/src/math/ceill_test.cpp index 96d2c583e436..6fe30465edc8 100644 --- a/libc/test/src/math/ceill_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/copysign_test.cpp b/libc/test/src/math/copysign_test.cpp index b7ee5178a7fa..37bfa0d90c37 100644 --- a/libc/test/src/math/copysign_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/copysignf_test.cpp b/libc/test/src/math/copysignf_test.cpp index 6ad29a68b206..fec283ccd0c7 100644 --- a/libc/test/src/math/copysignf_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/copysignl_test.cpp b/libc/test/src/math/copysignl_test.cpp index 89deff6d5732..d1de911196b6 100644 --- a/libc/test/src/math/copysignl_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/fabs_test.cpp b/libc/test/src/math/fabs_test.cpp index 0e7390bf16d4..2bf0ddda44ad 100644 --- a/libc/test/src/math/fabs_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/fabsf_test.cpp b/libc/test/src/math/fabsf_test.cpp index 9a67adee2b96..6374a1018f1d 100644 --- a/libc/test/src/math/fabsf_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/fabsl_test.cpp b/libc/test/src/math/fabsl_test.cpp index b51cf92249e4..ff1320225452 100644 --- a/libc/test/src/math/fabsl_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/floor_test.cpp b/libc/test/src/math/floor_test.cpp index cd3b170943a1..e68ed3ecbb60 100644 --- a/libc/test/src/math/floor_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/floorf_test.cpp b/libc/test/src/math/floorf_test.cpp index 9ca71d457d8b..f0538f7b97b2 100644 --- a/libc/test/src/math/floorf_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/floorl_test.cpp b/libc/test/src/math/floorl_test.cpp index 6bf935335ee1..1b244fd62a11 100644 --- a/libc/test/src/math/floorl_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/fmax_test.cpp b/libc/test/src/math/fmax_test.cpp index 843f073dbf02..9c81c09414f0 100644 --- a/libc/test/src/math/fmax_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/fmaxf_test.cpp b/libc/test/src/math/fmaxf_test.cpp index 70d9e70e5441..cf337d4f07e0 100644 --- a/libc/test/src/math/fmaxf_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/fmaxl_test.cpp b/libc/test/src/math/fmaxl_test.cpp index 8a17c1926744..636bc4208cae 100644 --- a/libc/test/src/math/fmaxl_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/fmin_test.cpp b/libc/test/src/math/fmin_test.cpp index ef80d49c11af..3515f97faca3 100644 --- a/libc/test/src/math/fmin_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/fminf_test.cpp b/libc/test/src/math/fminf_test.cpp index 25daf6cc55ce..1a762478af61 100644 --- a/libc/test/src/math/fminf_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/fminl_test.cpp b/libc/test/src/math/fminl_test.cpp index a618110eb739..ce8b705b0385 100644 --- a/libc/test/src/math/fminl_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/round_test.cpp b/libc/test/src/math/round_test.cpp index 1662514178bf..87ce079e89af 100644 --- a/libc/test/src/math/round_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/roundf_test.cpp b/libc/test/src/math/roundf_test.cpp index 8a71072c80a8..0a182dd02dee 100644 --- a/libc/test/src/math/roundf_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/roundl_test.cpp b/libc/test/src/math/roundl_test.cpp index 83764eca94c1..32cf724fb7c4 100644 --- a/libc/test/src/math/roundl_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/trunc_test.cpp b/libc/test/src/math/trunc_test.cpp index ee74485c083a..f0a808dcb236 100644 --- a/libc/test/src/math/trunc_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/truncf_test.cpp b/libc/test/src/math/truncf_test.cpp index 00f3d4601ae3..cbd672cfe2e2 100644 --- a/libc/test/src/math/truncf_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/test/src/math/truncl_test.cpp b/libc/test/src/math/truncl_test.cpp index e50e7a3aebcd..0cf9ab8cd557 100644 --- a/libc/test/src/math/truncl_test.cpp +++ b/libc/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 -using FPBits = __llvm_libc::fputil::FPBits; - -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/libc/utils/FPUtil/TestHelpers.h b/libc/utils/FPUtil/TestHelpers.h index c55f226cd9d7..6ad6d3f13af9 100644 --- a/libc/utils/FPUtil/TestHelpers.h +++ b/libc/utils/FPUtil/TestHelpers.h @@ -66,11 +66,13 @@ FPMatcher getMatcher(T expectedValue) { } // namespace __llvm_libc #define DECLARE_SPECIAL_CONSTANTS(T) \ - static const T zero = __llvm_libc::fputil::FPBits::zero(); \ - static const T negZero = __llvm_libc::fputil::FPBits::negZero(); \ - static const T aNaN = __llvm_libc::fputil::FPBits::buildNaN(1); \ - static const T inf = __llvm_libc::fputil::FPBits::inf(); \ - static const T negInf = __llvm_libc::fputil::FPBits::negInf(); + using FPBits = __llvm_libc::fputil::FPBits; \ + 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( \