1 //===-- Utility class to test different flavors of nexttoward ---*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLVM_LIBC_TEST_SRC_MATH_NEXTTOWARDTEST_H 10 #define LLVM_LIBC_TEST_SRC_MATH_NEXTTOWARDTEST_H 11 12 #include "src/__support/CPP/bit.h" 13 #include "src/__support/FPUtil/FEnvImpl.h" 14 #include "src/__support/FPUtil/FPBits.h" 15 #include "test/UnitTest/FEnvSafeTest.h" 16 #include "test/UnitTest/FPMatcher.h" 17 #include "test/UnitTest/Test.h" 18 19 #include "hdr/fenv_macros.h" 20 21 using LIBC_NAMESPACE::Sign; 22 23 // TODO: Strengthen errno,exception checks and remove these assert macros 24 // after new matchers/test fixtures are added 25 #define ASSERT_FP_EQ_WITH_EXCEPTION(result, expected, expected_exception) \ 26 ASSERT_FP_EQ(result, expected); \ 27 ASSERT_FP_EXCEPTION(expected_exception); \ 28 LIBC_NAMESPACE::fputil::clear_except(FE_ALL_EXCEPT) 29 30 #define ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected) \ 31 ASSERT_FP_EQ_WITH_EXCEPTION(result, expected, FE_INEXACT | FE_UNDERFLOW) 32 33 #define ASSERT_FP_EQ_WITH_OVERFLOW(result, expected) \ 34 ASSERT_FP_EQ_WITH_EXCEPTION(result, expected, FE_INEXACT | FE_OVERFLOW) 35 36 template <typename T> 37 class NextTowardTestTemplate : public LIBC_NAMESPACE::testing::FEnvSafeTest { 38 using FPBits = LIBC_NAMESPACE::fputil::FPBits<T>; 39 using ToFPBits = LIBC_NAMESPACE::fputil::FPBits<long double>; 40 using StorageType = typename FPBits::StorageType; 41 42 const T inf = FPBits::inf(Sign::POS).get_val(); 43 const T neg_inf = FPBits::inf(Sign::NEG).get_val(); 44 const T zero = FPBits::zero(Sign::POS).get_val(); 45 const T neg_zero = FPBits::zero(Sign::NEG).get_val(); 46 const T nan = FPBits::quiet_nan().get_val(); 47 48 const long double to_inf = ToFPBits::inf(Sign::POS).get_val(); 49 const long double to_neg_inf = ToFPBits::inf(Sign::NEG).get_val(); 50 const long double to_zero = ToFPBits::zero().get_val(); 51 const long double to_neg_zero = ToFPBits::zero(Sign::NEG).get_val(); 52 const long double to_nan = ToFPBits::quiet_nan().get_val(); 53 54 static constexpr StorageType min_subnormal = 55 FPBits::min_subnormal().uintval(); 56 static constexpr StorageType max_subnormal = 57 FPBits::max_subnormal().uintval(); 58 static constexpr StorageType min_normal = FPBits::min_normal().uintval(); 59 static constexpr StorageType max_normal = FPBits::max_normal().uintval(); 60 61 public: 62 typedef T (*NextTowardFunc)(T, long double); 63 testNaN(NextTowardFunc func)64 void testNaN(NextTowardFunc func) { 65 ASSERT_FP_EQ(func(nan, 0), nan); 66 ASSERT_FP_EQ(func(0, to_nan), nan); 67 } 68 testBoundaries(NextTowardFunc func)69 void testBoundaries(NextTowardFunc func) { 70 ASSERT_FP_EQ(func(zero, to_neg_zero), neg_zero); 71 ASSERT_FP_EQ(func(neg_zero, to_zero), zero); 72 73 // 'from' is zero|neg_zero. 74 T x = zero; 75 T result = func(x, 1); 76 StorageType expected_bits = 1; 77 T expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 78 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 79 80 result = func(x, -1); 81 expected_bits = FPBits::SIGN_MASK + 1; 82 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 83 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 84 85 x = neg_zero; 86 result = func(x, 1); 87 expected_bits = 1; 88 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 89 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 90 91 result = func(x, -1); 92 expected_bits = FPBits::SIGN_MASK + 1; 93 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 94 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 95 96 // 'from' is max subnormal value. 97 x = LIBC_NAMESPACE::cpp::bit_cast<T>(max_subnormal); 98 result = func(x, 1); 99 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(min_normal); 100 ASSERT_FP_EQ(result, expected); 101 102 result = func(x, 0); 103 expected_bits = max_subnormal - 1; 104 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 105 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 106 107 x = -x; 108 109 result = func(x, -1); 110 expected_bits = FPBits::SIGN_MASK + min_normal; 111 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 112 ASSERT_FP_EQ(result, expected); 113 114 result = func(x, 0); 115 expected_bits = FPBits::SIGN_MASK + max_subnormal - 1; 116 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 117 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 118 119 // 'from' is min subnormal value. 120 x = LIBC_NAMESPACE::cpp::bit_cast<T>(min_subnormal); 121 result = func(x, 1); 122 expected_bits = min_subnormal + 1; 123 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 124 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 125 ASSERT_FP_EQ_WITH_UNDERFLOW(func(x, 0), 0); 126 127 x = -x; 128 result = func(x, -1); 129 expected_bits = FPBits::SIGN_MASK + min_subnormal + 1; 130 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 131 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 132 ASSERT_FP_EQ_WITH_UNDERFLOW(func(x, 0), T(-0.0)); 133 134 // 'from' is min normal. 135 x = LIBC_NAMESPACE::cpp::bit_cast<T>(min_normal); 136 result = func(x, 0); 137 expected_bits = max_subnormal; 138 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 139 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 140 141 result = func(x, to_inf); 142 expected_bits = min_normal + 1; 143 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 144 ASSERT_FP_EQ(result, expected); 145 146 x = -x; 147 result = func(x, 0); 148 expected_bits = FPBits::SIGN_MASK + max_subnormal; 149 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 150 ASSERT_FP_EQ_WITH_UNDERFLOW(result, expected); 151 152 result = func(x, to_neg_inf); 153 expected_bits = FPBits::SIGN_MASK + min_normal + 1; 154 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 155 ASSERT_FP_EQ(result, expected); 156 157 // 'from' is max normal 158 x = LIBC_NAMESPACE::cpp::bit_cast<T>(max_normal); 159 result = func(x, 0); 160 expected_bits = max_normal - 1; 161 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 162 ASSERT_FP_EQ(result, expected); 163 ASSERT_FP_EQ_WITH_OVERFLOW(func(x, to_inf), inf); 164 165 x = -x; 166 result = func(x, 0); 167 expected_bits = FPBits::SIGN_MASK + max_normal - 1; 168 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 169 ASSERT_FP_EQ(result, expected); 170 ASSERT_FP_EQ_WITH_OVERFLOW(func(x, to_neg_inf), neg_inf); 171 172 // 'from' is infinity. 173 x = inf; 174 result = func(x, 0); 175 expected_bits = max_normal; 176 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 177 ASSERT_FP_EQ(result, expected); 178 ASSERT_FP_EQ(func(x, to_inf), inf); 179 180 x = neg_inf; 181 result = func(x, 0); 182 expected_bits = FPBits::SIGN_MASK + max_normal; 183 expected = LIBC_NAMESPACE::cpp::bit_cast<T>(expected_bits); 184 ASSERT_FP_EQ(result, expected); 185 ASSERT_FP_EQ(func(x, to_neg_inf), neg_inf); 186 187 // 'from' is a power of 2. 188 x = T(32.0); 189 result = func(x, 0); 190 FPBits x_bits = FPBits(x); 191 FPBits result_bits = FPBits(result); 192 ASSERT_EQ(result_bits.get_biased_exponent(), 193 uint16_t(x_bits.get_biased_exponent() - 1)); 194 ASSERT_EQ(result_bits.get_mantissa(), FPBits::FRACTION_MASK); 195 196 result = func(x, 33.0); 197 result_bits = FPBits(result); 198 ASSERT_EQ(result_bits.get_biased_exponent(), x_bits.get_biased_exponent()); 199 ASSERT_EQ(result_bits.get_mantissa(), 200 static_cast<StorageType>(x_bits.get_mantissa() + StorageType(1))); 201 202 x = -x; 203 204 result = func(x, 0); 205 result_bits = FPBits(result); 206 ASSERT_EQ(result_bits.get_biased_exponent(), 207 uint16_t(x_bits.get_biased_exponent() - 1)); 208 ASSERT_EQ(result_bits.get_mantissa(), FPBits::FRACTION_MASK); 209 210 result = func(x, -33.0); 211 result_bits = FPBits(result); 212 ASSERT_EQ(result_bits.get_biased_exponent(), x_bits.get_biased_exponent()); 213 ASSERT_EQ(result_bits.get_mantissa(), 214 static_cast<StorageType>(x_bits.get_mantissa() + StorageType(1))); 215 } 216 }; 217 218 #define LIST_NEXTTOWARD_TESTS(T, func) \ 219 using LlvmLibcNextTowardTest = NextTowardTestTemplate<T>; \ 220 TEST_F(LlvmLibcNextTowardTest, TestNaN) { testNaN(&func); } \ 221 TEST_F(LlvmLibcNextTowardTest, TestBoundaries) { testBoundaries(&func); } 222 223 #endif // LLVM_LIBC_TEST_SRC_MATH_NEXTTOWARDTEST_H 224