185 lines · c
1//===-- Utility class to test different flavors of float add ----*- 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-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_ADDTEST_H10#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_ADDTEST_H11 12#include "hdr/errno_macros.h"13#include "hdr/fenv_macros.h"14#include "src/__support/macros/properties/os.h"15#include "test/UnitTest/FEnvSafeTest.h"16#include "test/UnitTest/FPMatcher.h"17#include "test/UnitTest/Test.h"18 19using LIBC_NAMESPACE::Sign;20 21template <typename OutType, typename InType>22class AddTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {23 24 DECLARE_SPECIAL_CONSTANTS(OutType)25 26 struct InConstants {27 DECLARE_SPECIAL_CONSTANTS(InType)28 };29 30 using InFPBits = typename InConstants::FPBits;31 using InStorageType = typename InConstants::StorageType;32 33 InConstants in;34 35public:36 using AddFunc = OutType (*)(InType, InType);37 38 void test_special_numbers(AddFunc func) {39 EXPECT_FP_IS_NAN(func(in.aNaN, in.aNaN));40 EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(in.sNaN, in.sNaN), FE_INVALID);41 42 InType qnan_42 = InFPBits::quiet_nan(Sign::POS, 0x42).get_val();43 EXPECT_FP_IS_NAN(func(qnan_42, in.zero));44 EXPECT_FP_IS_NAN(func(in.zero, qnan_42));45 46 EXPECT_FP_EQ(inf, func(in.inf, in.zero));47 EXPECT_FP_EQ(neg_inf, func(in.neg_inf, in.zero));48 EXPECT_FP_EQ(inf, func(in.inf, in.neg_zero));49 EXPECT_FP_EQ(neg_inf, func(in.neg_inf, in.neg_zero));50 EXPECT_FP_EQ(inf, func(in.zero, in.inf));51 EXPECT_FP_EQ(inf, func(in.neg_zero, in.inf));52 EXPECT_FP_EQ(neg_inf, func(in.zero, in.neg_inf));53 EXPECT_FP_EQ(neg_inf, func(in.neg_zero, in.neg_inf));54 }55 56 void test_invalid_operations(AddFunc func) {57 EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(in.inf, in.neg_inf), FE_INVALID);58 EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(in.neg_inf, in.inf), FE_INVALID);59 }60 61 void test_range_errors(AddFunc func) {62#ifndef LIBC_TARGET_OS_IS_WINDOWS63 using namespace LIBC_NAMESPACE::fputil::testing;64 65 if (LIBC_NAMESPACE::fputil::get_fp_type<OutType>() ==66 LIBC_NAMESPACE::fputil::get_fp_type<InType>())67 return;68 69 if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {70 EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(in.max_normal, in.max_normal),71 FE_OVERFLOW | FE_INEXACT);72 EXPECT_MATH_ERRNO(ERANGE);73 EXPECT_FP_EQ_WITH_EXCEPTION(-inf,74 func(in.neg_max_normal, in.neg_max_normal),75 FE_OVERFLOW | FE_INEXACT);76 EXPECT_MATH_ERRNO(ERANGE);77 78 EXPECT_FP_EQ_WITH_EXCEPTION(zero, func(in.min_denormal, in.min_denormal),79 FE_UNDERFLOW | FE_INEXACT);80 EXPECT_MATH_ERRNO(ERANGE);81 EXPECT_FP_EQ_WITH_EXCEPTION(82 neg_zero, func(in.neg_min_denormal, in.neg_min_denormal),83 FE_UNDERFLOW | FE_INEXACT);84 EXPECT_MATH_ERRNO(ERANGE);85 }86 87 if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {88 EXPECT_FP_EQ_WITH_EXCEPTION(max_normal,89 func(in.max_normal, in.max_normal),90 FE_OVERFLOW | FE_INEXACT);91 EXPECT_FP_EQ_WITH_EXCEPTION(neg_max_normal,92 func(in.neg_max_normal, in.neg_max_normal),93 FE_OVERFLOW | FE_INEXACT);94 95 EXPECT_FP_EQ_WITH_EXCEPTION(zero, func(in.min_denormal, in.min_denormal),96 FE_UNDERFLOW | FE_INEXACT);97 EXPECT_MATH_ERRNO(ERANGE);98 EXPECT_FP_EQ_WITH_EXCEPTION(99 neg_zero, func(in.neg_min_denormal, in.neg_min_denormal),100 FE_UNDERFLOW | FE_INEXACT);101 EXPECT_MATH_ERRNO(ERANGE);102 }103 104 if (ForceRoundingMode r(RoundingMode::Downward); r.success) {105 EXPECT_FP_EQ_WITH_EXCEPTION(max_normal,106 func(in.max_normal, in.max_normal),107 FE_OVERFLOW | FE_INEXACT);108 EXPECT_FP_EQ_WITH_EXCEPTION(-inf,109 func(in.neg_max_normal, in.neg_max_normal),110 FE_OVERFLOW | FE_INEXACT);111 EXPECT_MATH_ERRNO(ERANGE);112 113 EXPECT_FP_EQ_WITH_EXCEPTION(zero, func(in.min_denormal, in.min_denormal),114 FE_UNDERFLOW | FE_INEXACT);115 EXPECT_MATH_ERRNO(ERANGE);116 EXPECT_FP_EQ_WITH_EXCEPTION(117 neg_min_denormal, func(in.neg_min_denormal, in.neg_min_denormal),118 FE_UNDERFLOW | FE_INEXACT);119 EXPECT_MATH_ERRNO(ERANGE);120 }121 122 if (ForceRoundingMode r(RoundingMode::Upward); r.success) {123 EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(in.max_normal, in.max_normal),124 FE_OVERFLOW | FE_INEXACT);125 EXPECT_MATH_ERRNO(ERANGE);126 EXPECT_FP_EQ_WITH_EXCEPTION(neg_max_normal,127 func(in.neg_max_normal, in.neg_max_normal),128 FE_OVERFLOW | FE_INEXACT);129 130 EXPECT_FP_EQ_WITH_EXCEPTION(min_denormal,131 func(in.min_denormal, in.min_denormal),132 FE_UNDERFLOW | FE_INEXACT);133 EXPECT_MATH_ERRNO(ERANGE);134 EXPECT_FP_EQ_WITH_EXCEPTION(135 neg_zero, func(in.neg_min_denormal, in.neg_min_denormal),136 FE_UNDERFLOW | FE_INEXACT);137 EXPECT_MATH_ERRNO(ERANGE);138 }139#endif140 }141 142 void test_inexact_results(AddFunc func) {143 func(InType(1.0), in.min_denormal);144 EXPECT_FP_EXCEPTION(FE_INEXACT);145 }146 147 void test_mixed_normality(AddFunc func) {148 if (LIBC_NAMESPACE::fputil::get_fp_type<OutType>() !=149 LIBC_NAMESPACE::fputil::get_fp_type<InType>())150 return;151 152 EXPECT_FP_EQ(FPBits::create_value(Sign::POS, 2U, 0b1U).get_val(),153 func(InFPBits::create_value(Sign::POS, 2U, 0U).get_val(),154 InFPBits::create_value(Sign::POS, 0U, 0b10U).get_val()));155 }156};157 158#define LIST_ADD_TESTS(OutType, InType, func) \159 using LlvmLibcAddTest = AddTest<OutType, InType>; \160 TEST_F(LlvmLibcAddTest, SpecialNumbers) { test_special_numbers(&func); } \161 TEST_F(LlvmLibcAddTest, InvalidOperations) { \162 test_invalid_operations(&func); \163 } \164 TEST_F(LlvmLibcAddTest, RangeErrors) { test_range_errors(&func); } \165 TEST_F(LlvmLibcAddTest, InexactResults) { test_inexact_results(&func); } \166 TEST_F(LlvmLibcAddTest, MixedNormality) { test_mixed_normality(&func); }167 168#define LIST_ADD_SAME_TYPE_TESTS(suffix, OutType, InType, func) \169 using LlvmLibcAddTest##suffix = AddTest<OutType, InType>; \170 TEST_F(LlvmLibcAddTest##suffix, SpecialNumbers) { \171 test_special_numbers(&func); \172 } \173 TEST_F(LlvmLibcAddTest##suffix, InvalidOperations) { \174 test_invalid_operations(&func); \175 } \176 TEST_F(LlvmLibcAddTest##suffix, RangeErrors) { test_range_errors(&func); } \177 TEST_F(LlvmLibcAddTest##suffix, InexactResults) { \178 test_inexact_results(&func); \179 } \180 TEST_F(LlvmLibcAddTest##suffix, MixedNormality) { \181 test_mixed_normality(&func); \182 }183 184#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_ADDTEST_H185