This is an archive of the discontinued LLVM Phabricator instance.

Differential D85486

[libc][NFC] Add library of floating point test matchers.
ClosedPublic

Authored by sivachandra on Aug 6 2020, 4:14 PM.

Details

Reviewers
abrachet
lntue
Commits
rGdb936e0e9153: [libc][NFC] Add library of floating point test matchers.
Summary

This eliminates UnitTest's dependency on FPUtil and hence prevents
non-math tests from depending indirectly on FPUtil. The patch
essentially moves some of the existing pieces into a library of its own.

Along the way, renamed add_math_unittest to add_fp_unittest.

Diff Detail

Event Timeline

sivachandra created this revision.Aug 6 2020, 4:14 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 6 2020, 4:14 PM
Herald added subscribers: libc-commits, ecnelises, tschuett, mgorny. · View Herald Transcript
sivachandra requested review of this revision.Aug 6 2020, 4:14 PM
Harbormaster completed remote builds in B67393: Diff 283761.Aug 6 2020, 4:20 PM
sivachandra updated this revision to Diff 283763.Aug 6 2020, 4:28 PM

Fix naming style in Test.cpp.

Harbormaster completed remote builds in B67394: Diff 283763.Aug 6 2020, 4:34 PM
lntue accepted this revision.Aug 7 2020, 8:19 AM
This revision is now accepted and ready to land.Aug 7 2020, 8:19 AM
This revision was landed with ongoing or failed builds.Aug 7 2020, 11:34 PM
Closed by commit rGdb936e0e9153: [libc][NFC] Add library of floating point test matchers. (authored by sivachandra). · Explain Why
This revision was automatically updated to reflect the committed changes.
sivachandra added a commit: rGdb936e0e9153: [libc][NFC] Add library of floating point test matchers..
lntue mentioned this in D84725: [libc] Add ULP function to MPFRNumber class to test correctly rounded functions such as SQRT, FMA..Aug 12 2020, 10:44 PM

Revision Contents

PathSize
libc/
test/
src/
math/
83 lines
45 lines
45 lines
45 lines
45 lines
45 lines
45 lines
utils/
FPUtil/
14 lines
92 lines
75 lines
UnitTest/
2 lines
78 lines

Diff 284120

libc/test/src/math/CMakeLists.txt

add_libc_testsuite(libc_math_unittests) add_libc_testsuite(libc_math_unittests)
function(add_math_unittest name) function(add_fp_unittest name)
cmake_parse_arguments( cmake_parse_arguments(
"MATH_UNITTEST" "MATH_UNITTEST"
"NEED_MPFR" # No optional arguments "NEED_MPFR" # No optional arguments
"" # Single value arguments "" # Single value arguments
"" # Multi-value arguments "" # Multi-value arguments
${ARGN} ${ARGN}
) )
if(MATH_UNITTEST_NEED_MPFR) if(MATH_UNITTEST_NEED_MPFR)
if(NOT LIBC_TESTS_CAN_USE_MPFR) if(NOT LIBC_TESTS_CAN_USE_MPFR)
message("WARNING: Math test ${name} will be skipped as MPFR library is not available.") message("WARNING: Math test ${name} will be skipped as MPFR library is not available.")
return() return()
endif() endif()
endif() endif()
add_libc_unittest(${name} ${MATH_UNITTEST_UNPARSED_ARGUMENTS}) add_libc_unittest(${name} ${MATH_UNITTEST_UNPARSED_ARGUMENTS})
if(MATH_UNITTEST_NEED_MPFR)
get_fq_target_name(${name} fq_target_name) get_fq_target_name(${name} fq_target_name)
target_link_libraries(${fq_target_name} PRIVATE LibcFPTestHelpers)
if(MATH_UNITTEST_NEED_MPFR)
target_link_libraries(${fq_target_name} PRIVATE libcMPFRWrapper -lmpfr -lgmp) target_link_libraries(${fq_target_name} PRIVATE libcMPFRWrapper -lmpfr -lgmp)
endif() endif()
endfunction(add_math_unittest) endfunction(add_fp_unittest)
add_math_unittest( add_fp_unittest(
cosf_test cosf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
cosf_test.cpp cosf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.src.math.cosf libc.src.math.cosf
libc.utils.CPP.standalone_cpp libc.utils.CPP.standalone_cpp
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
sinf_test sinf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sinf_test.cpp sinf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.src.math.sinf libc.src.math.sinf
libc.utils.CPP.standalone_cpp libc.utils.CPP.standalone_cpp
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
sincosf_test sincosf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sincosf_test.cpp sincosf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.src.math.sincosf libc.src.math.sincosf
libc.utils.CPP.standalone_cpp libc.utils.CPP.standalone_cpp
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
fabs_test fabs_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fabs_test.cpp fabs_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fabs libc.src.math.fabs
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
fabsf_test fabsf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fabsf_test.cpp fabsf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fabsf libc.src.math.fabsf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
fabsl_test fabsl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fabsl_test.cpp fabsl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fabsl libc.src.math.fabsl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
trunc_test trunc_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
trunc_test.cpp trunc_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.trunc libc.src.math.trunc
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
truncf_test truncf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
truncf_test.cpp truncf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.truncf libc.src.math.truncf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
truncl_test truncl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
truncl_test.cpp truncl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.truncl libc.src.math.truncl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
ceil_test ceil_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ceil_test.cpp ceil_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ceil libc.src.math.ceil
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
ceilf_test ceilf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ceilf_test.cpp ceilf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ceilf libc.src.math.ceilf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
ceill_test ceill_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ceill_test.cpp ceill_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ceill libc.src.math.ceill
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
floor_test floor_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
floor_test.cpp floor_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.floor libc.src.math.floor
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
floorf_test floorf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
floorf_test.cpp floorf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.floorf libc.src.math.floorf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
floorl_test floorl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
floorl_test.cpp floorl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.floorl libc.src.math.floorl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
round_test round_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
round_test.cpp round_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.round libc.src.math.round
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
roundf_test roundf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
roundf_test.cpp roundf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.roundf libc.src.math.roundf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
roundl_test roundl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
roundl_test.cpp roundl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.roundl libc.src.math.roundl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
expf_test expf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
expf_test.cpp expf_test.cpp
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.math.expf libc.src.math.expf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
exp2f_test exp2f_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
exp2f_test.cpp exp2f_test.cpp
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.math.exp2f libc.src.math.exp2f
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
copysign_test copysign_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
copysign_test.cpp copysign_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.copysign libc.src.math.copysign
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
copysignf_test copysignf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
copysignf_test.cpp copysignf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.copysignf libc.src.math.copysignf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
copysignl_test copysignl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
copysignl_test.cpp copysignl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.copysignl libc.src.math.copysignl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
frexp_test frexp_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
frexp_test.cpp frexp_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.frexp libc.src.math.frexp
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
frexpf_test frexpf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
frexpf_test.cpp frexpf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.frexpf libc.src.math.frexpf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
frexpl_test frexpl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
frexpl_test.cpp frexpl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.frexpl libc.src.math.frexpl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
logb_test logb_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
logb_test.cpp logb_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.logb libc.src.math.logb
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
logbf_test logbf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
logbf_test.cpp logbf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.logbf libc.src.math.logbf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
logbl_test logbl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
logbl_test.cpp logbl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.logbl libc.src.math.logbl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
modf_test modf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
modf_test.cpp modf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.modf libc.src.math.modf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
modff_test modff_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
modff_test.cpp modff_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.modff libc.src.math.modff
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
modfl_test modfl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
modfl_test.cpp modfl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.modfl libc.src.math.modfl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
fminf_test fminf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fminf_test.cpp fminf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fminf libc.src.math.fminf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
fmin_test fmin_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fmin_test.cpp fmin_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fmin libc.src.math.fmin
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
fminl_test fminl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fminl_test.cpp fminl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fminl libc.src.math.fminl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
fmaxf_test fmaxf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fmaxf_test.cpp fmaxf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fmaxf libc.src.math.fmaxf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
fmax_test fmax_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fmax_test.cpp fmax_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fmax libc.src.math.fmax
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_fp_unittest(
fmaxl_test fmaxl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fmaxl_test.cpp fmaxl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fmaxl libc.src.math.fmaxl
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )

libc/test/src/math/fmax_test.cpp

//===-- Unittests for fmax -----------------------------------------------===// //===-- Unittests for fmax -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#include "include/math.h" #include "include/math.h"
#include "src/math/fmax.h" #include "src/math/fmax.h"
#include "utils/FPUtil/FPBits.h" #include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using FPBits = __llvm_libc::fputil::FPBits<double>; using FPBits = __llvm_libc::fputil::FPBits<double>;
double nan = FPBits::buildNaN(1); double nan = FPBits::buildNaN(1);
double inf = FPBits::inf(); double inf = FPBits::inf();
double negInf = FPBits::negInf(); double negInf = FPBits::negInf();
TEST(FmaxTest, NaNArg) { TEST(FmaxTest, NaNArg) {
EXPECT_EQ(inf, __llvm_libc::fmax(nan, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmax(nan, inf));
EXPECT_EQ(negInf, __llvm_libc::fmax(negInf, nan)); EXPECT_FP_EQ(negInf, __llvm_libc::fmax(negInf, nan));
EXPECT_EQ(0.0, __llvm_libc::fmax(nan, 0.0)); EXPECT_FP_EQ(0.0, __llvm_libc::fmax(nan, 0.0));
EXPECT_EQ(-0.0, __llvm_libc::fmax(-0.0, nan)); EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, nan));
EXPECT_EQ(-1.2345, __llvm_libc::fmax(nan, -1.2345)); EXPECT_FP_EQ(-1.2345, __llvm_libc::fmax(nan, -1.2345));
EXPECT_EQ(1.2345, __llvm_libc::fmax(1.2345, nan)); EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, nan));
EXPECT_NE(isnan(__llvm_libc::fmax(nan, nan)), 0); EXPECT_NE(isnan(__llvm_libc::fmax(nan, nan)), 0);
} }
TEST(FmaxTest, InfArg) { TEST(FmaxTest, InfArg) {
EXPECT_EQ(inf, __llvm_libc::fmax(negInf, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmax(negInf, inf));
EXPECT_EQ(inf, __llvm_libc::fmax(inf, 0.0)); EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, 0.0));
EXPECT_EQ(inf, __llvm_libc::fmax(-0.0, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmax(-0.0, inf));
EXPECT_EQ(inf, __llvm_libc::fmax(inf, 1.2345)); EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, 1.2345));
EXPECT_EQ(inf, __llvm_libc::fmax(-1.2345, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmax(-1.2345, inf));
} }
TEST(FmaxTest, NegInfArg) { TEST(FmaxTest, NegInfArg) {
EXPECT_EQ(inf, __llvm_libc::fmax(inf, negInf)); EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, negInf));
EXPECT_EQ(0.0, __llvm_libc::fmax(negInf, 0.0)); EXPECT_FP_EQ(0.0, __llvm_libc::fmax(negInf, 0.0));
EXPECT_EQ(-0.0, __llvm_libc::fmax(-0.0, negInf)); EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, negInf));
EXPECT_EQ(-1.2345, __llvm_libc::fmax(negInf, -1.2345)); EXPECT_FP_EQ(-1.2345, __llvm_libc::fmax(negInf, -1.2345));
EXPECT_EQ(1.2345, __llvm_libc::fmax(1.2345, negInf)); EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, negInf));
} }
TEST(FmaxTest, BothZero) { TEST(FmaxTest, BothZero) {
EXPECT_EQ(0.0, __llvm_libc::fmax(0.0, 0.0)); EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, 0.0));
EXPECT_EQ(0.0, __llvm_libc::fmax(-0.0, 0.0)); EXPECT_FP_EQ(0.0, __llvm_libc::fmax(-0.0, 0.0));
EXPECT_EQ(0.0, __llvm_libc::fmax(0.0, -0.0)); EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, -0.0));
EXPECT_EQ(-0.0, __llvm_libc::fmax(-0.0, -0.0)); EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, -0.0));
} }
TEST(FmaxTest, InDoubleRange) { TEST(FmaxTest, InDoubleRange) {
using UIntType = FPBits::UIntType; using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000001; constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) { ++i, v += step, w -= step) {
double x = FPBits(v), y = FPBits(w); double x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
if (x > y) { if (x > y) {
ASSERT_EQ(x, __llvm_libc::fmax(x, y)); EXPECT_FP_EQ(x, __llvm_libc::fmax(x, y));
} else { } else {
ASSERT_EQ(y, __llvm_libc::fmax(x, y)); EXPECT_FP_EQ(y, __llvm_libc::fmax(x, y));
} }
} }
} }

libc/test/src/math/fmaxf_test.cpp

//===-- Unittests for fmaxf -----------------------------------------------===// //===-- Unittests for fmaxf -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#include "include/math.h" #include "include/math.h"
#include "src/math/fmaxf.h" #include "src/math/fmaxf.h"
#include "utils/FPUtil/FPBits.h" #include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
float nan = FPBits::buildNaN(1); float nan = FPBits::buildNaN(1);
float inf = FPBits::inf(); float inf = FPBits::inf();
float negInf = FPBits::negInf(); float negInf = FPBits::negInf();
TEST(FmaxfTest, NaNArg) { TEST(FmaxfTest, NaNArg) {
EXPECT_EQ(inf, __llvm_libc::fmaxf(nan, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(nan, inf));
EXPECT_EQ(negInf, __llvm_libc::fmaxf(negInf, nan)); EXPECT_FP_EQ(negInf, __llvm_libc::fmaxf(negInf, nan));
EXPECT_EQ(0.0f, __llvm_libc::fmaxf(nan, 0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(nan, 0.0f));
EXPECT_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, nan)); EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, nan));
EXPECT_EQ(-1.2345f, __llvm_libc::fmaxf(nan, -1.2345f)); EXPECT_FP_EQ(-1.2345f, __llvm_libc::fmaxf(nan, -1.2345f));
EXPECT_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, nan)); EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, nan));
EXPECT_NE(isnan(__llvm_libc::fmaxf(nan, nan)), 0); EXPECT_NE(isnan(__llvm_libc::fmaxf(nan, nan)), 0);
} }
TEST(FmaxfTest, InfArg) { TEST(FmaxfTest, InfArg) {
EXPECT_EQ(inf, __llvm_libc::fmaxf(negInf, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(negInf, inf));
EXPECT_EQ(inf, __llvm_libc::fmaxf(inf, 0.0f)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, 0.0f));
EXPECT_EQ(inf, __llvm_libc::fmaxf(-0.0f, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-0.0f, inf));
EXPECT_EQ(inf, __llvm_libc::fmaxf(inf, 1.2345f)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, 1.2345f));
EXPECT_EQ(inf, __llvm_libc::fmaxf(-1.2345f, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-1.2345f, inf));
} }
TEST(FmaxfTest, NegInfArg) { TEST(FmaxfTest, NegInfArg) {
EXPECT_EQ(inf, __llvm_libc::fmaxf(inf, negInf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, negInf));
EXPECT_EQ(0.0f, __llvm_libc::fmaxf(negInf, 0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(negInf, 0.0f));
EXPECT_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, negInf)); EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, negInf));
EXPECT_EQ(-1.2345f, __llvm_libc::fmaxf(negInf, -1.2345f)); EXPECT_FP_EQ(-1.2345f, __llvm_libc::fmaxf(negInf, -1.2345f));
EXPECT_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, negInf)); EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, negInf));
} }
TEST(FmaxfTest, BothZero) { TEST(FmaxfTest, BothZero) {
EXPECT_EQ(0.0f, __llvm_libc::fmaxf(0.0f, 0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, 0.0f));
EXPECT_EQ(0.0f, __llvm_libc::fmaxf(-0.0f, 0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(-0.0f, 0.0f));
EXPECT_EQ(0.0f, __llvm_libc::fmaxf(0.0f, -0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, -0.0f));
EXPECT_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, -0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, -0.0f));
} }
TEST(FmaxfTest, InFloatRange) { TEST(FmaxfTest, InFloatRange) {
using UIntType = FPBits::UIntType; using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000001; constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) { ++i, v += step, w -= step) {
float x = FPBits(v), y = FPBits(w); float x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
if (x > y) { if (x > y) {
ASSERT_EQ(x, __llvm_libc::fmaxf(x, y)); ASSERT_FP_EQ(x, __llvm_libc::fmaxf(x, y));
} else { } else {
ASSERT_EQ(y, __llvm_libc::fmaxf(x, y)); ASSERT_FP_EQ(y, __llvm_libc::fmaxf(x, y));
} }
} }
} }

libc/test/src/math/fmaxl_test.cpp

//===-- Unittests for fmaxl -----------------------------------------------===// //===-- Unittests for fmaxl -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#include "include/math.h" #include "include/math.h"
#include "src/math/fmaxl.h" #include "src/math/fmaxl.h"
#include "utils/FPUtil/FPBits.h" #include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using FPBits = __llvm_libc::fputil::FPBits<long double>; using FPBits = __llvm_libc::fputil::FPBits<long double>;
long double nan = FPBits::buildNaN(1); long double nan = FPBits::buildNaN(1);
long double inf = FPBits::inf(); long double inf = FPBits::inf();
long double negInf = FPBits::negInf(); long double negInf = FPBits::negInf();
TEST(FmaxlTest, NaNArg) { TEST(FmaxlTest, NaNArg) {
EXPECT_EQ(inf, __llvm_libc::fmaxl(nan, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(nan, inf));
EXPECT_EQ(negInf, __llvm_libc::fmaxl(negInf, nan)); EXPECT_FP_EQ(negInf, __llvm_libc::fmaxl(negInf, nan));
EXPECT_EQ(0.0L, __llvm_libc::fmaxl(nan, 0.0L)); EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(nan, 0.0L));
EXPECT_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, nan)); EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, nan));
EXPECT_EQ(-1.2345L, __llvm_libc::fmaxl(nan, -1.2345L)); EXPECT_FP_EQ(-1.2345L, __llvm_libc::fmaxl(nan, -1.2345L));
EXPECT_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, nan)); EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, nan));
EXPECT_NE(isnan(__llvm_libc::fmaxl(nan, nan)), 0); EXPECT_NE(isnan(__llvm_libc::fmaxl(nan, nan)), 0);
} }
TEST(FmaxlTest, InfArg) { TEST(FmaxlTest, InfArg) {
EXPECT_EQ(inf, __llvm_libc::fmaxl(negInf, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(negInf, inf));
EXPECT_EQ(inf, __llvm_libc::fmaxl(inf, 0.0L)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, 0.0L));
EXPECT_EQ(inf, __llvm_libc::fmaxl(-0.0L, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-0.0L, inf));
EXPECT_EQ(inf, __llvm_libc::fmaxl(inf, 1.2345L)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, 1.2345L));
EXPECT_EQ(inf, __llvm_libc::fmaxl(-1.2345L, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-1.2345L, inf));
} }
TEST(FmaxlTest, NegInfArg) { TEST(FmaxlTest, NegInfArg) {
EXPECT_EQ(inf, __llvm_libc::fmaxl(inf, negInf)); EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, negInf));
EXPECT_EQ(0.0L, __llvm_libc::fmaxl(negInf, 0.0L)); EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(negInf, 0.0L));
EXPECT_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, negInf)); EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, negInf));
EXPECT_EQ(-1.2345L, __llvm_libc::fmaxl(negInf, -1.2345L)); EXPECT_FP_EQ(-1.2345L, __llvm_libc::fmaxl(negInf, -1.2345L));
EXPECT_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, negInf)); EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, negInf));
} }
TEST(FmaxlTest, BothZero) { TEST(FmaxlTest, BothZero) {
EXPECT_EQ(0.0L, __llvm_libc::fmaxl(0.0L, 0.0L)); EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, 0.0L));
EXPECT_EQ(0.0L, __llvm_libc::fmaxl(-0.0L, 0.0L)); EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(-0.0L, 0.0L));
EXPECT_EQ(0.0L, __llvm_libc::fmaxl(0.0L, -0.0L)); EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, -0.0L));
EXPECT_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, -0.0L)); EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, -0.0L));
} }
TEST(FmaxlTest, InLongDoubleRange) { TEST(FmaxlTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType; using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000001; constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) { ++i, v += step, w -= step) {
long double x = FPBits(v), y = FPBits(w); long double x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
if (x > y) { if (x > y) {
ASSERT_EQ(x, __llvm_libc::fmaxl(x, y)); ASSERT_FP_EQ(x, __llvm_libc::fmaxl(x, y));
} else { } else {
ASSERT_EQ(y, __llvm_libc::fmaxl(x, y)); ASSERT_FP_EQ(y, __llvm_libc::fmaxl(x, y));
} }
} }
} }

libc/test/src/math/fmin_test.cpp

//===-- Unittests for fmin -----------------------------------------------===// //===-- Unittests for fmin -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#include "include/math.h" #include "include/math.h"
#include "src/math/fmin.h" #include "src/math/fmin.h"
#include "utils/FPUtil/FPBits.h" #include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using FPBits = __llvm_libc::fputil::FPBits<double>; using FPBits = __llvm_libc::fputil::FPBits<double>;
double nan = static_cast<double>(FPBits::buildNaN(1)); double nan = static_cast<double>(FPBits::buildNaN(1));
double inf = static_cast<double>(FPBits::inf()); double inf = static_cast<double>(FPBits::inf());
double negInf = static_cast<double>(FPBits::negInf()); double negInf = static_cast<double>(FPBits::negInf());
TEST(FminTest, NaNArg) { TEST(FminTest, NaNArg) {
EXPECT_EQ(inf, __llvm_libc::fmin(nan, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fmin(nan, inf));
EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, nan)); EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, nan));
EXPECT_EQ(0.0, __llvm_libc::fmin(nan, 0.0)); EXPECT_FP_EQ(0.0, __llvm_libc::fmin(nan, 0.0));
EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, nan)); EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, nan));
EXPECT_EQ(-1.2345, __llvm_libc::fmin(nan, -1.2345)); EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(nan, -1.2345));
EXPECT_EQ(1.2345, __llvm_libc::fmin(1.2345, nan)); EXPECT_FP_EQ(1.2345, __llvm_libc::fmin(1.2345, nan));
EXPECT_NE(isnan(__llvm_libc::fmin(nan, nan)), 0); EXPECT_NE(isnan(__llvm_libc::fmin(nan, nan)), 0);
} }
TEST(FminTest, InfArg) { TEST(FminTest, InfArg) {
EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, inf)); EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, inf));
EXPECT_EQ(0.0, __llvm_libc::fmin(inf, 0.0)); EXPECT_FP_EQ(0.0, __llvm_libc::fmin(inf, 0.0));
EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, inf)); EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, inf));
EXPECT_EQ(1.2345, __llvm_libc::fmin(inf, 1.2345)); EXPECT_FP_EQ(1.2345, __llvm_libc::fmin(inf, 1.2345));
EXPECT_EQ(-1.2345, __llvm_libc::fmin(-1.2345, inf)); EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(-1.2345, inf));
} }
TEST(FminTest, NegInfArg) { TEST(FminTest, NegInfArg) {
EXPECT_EQ(negInf, __llvm_libc::fmin(inf, negInf)); EXPECT_FP_EQ(negInf, __llvm_libc::fmin(inf, negInf));
EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, 0.0)); EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, 0.0));
EXPECT_EQ(negInf, __llvm_libc::fmin(-0.0, negInf)); EXPECT_FP_EQ(negInf, __llvm_libc::fmin(-0.0, negInf));
EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, -1.2345)); EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, -1.2345));
EXPECT_EQ(negInf, __llvm_libc::fmin(1.2345, negInf)); EXPECT_FP_EQ(negInf, __llvm_libc::fmin(1.2345, negInf));
} }
TEST(FminTest, BothZero) { TEST(FminTest, BothZero) {
EXPECT_EQ(0.0, __llvm_libc::fmin(0.0, 0.0)); EXPECT_FP_EQ(0.0, __llvm_libc::fmin(0.0, 0.0));
EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, 0.0)); EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, 0.0));
EXPECT_EQ(-0.0, __llvm_libc::fmin(0.0, -0.0)); EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(0.0, -0.0));
EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, -0.0)); EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, -0.0));
} }
TEST(FminTest, InFloatRange) { TEST(FminTest, InFloatRange) {
using UIntType = FPBits::UIntType; using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000; constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) { ++i, v += step, w -= step) {
double x = FPBits(v), y = FPBits(w); double x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
if (x < y) { if (x < y) {
ASSERT_EQ(x, __llvm_libc::fmin(x, y)); ASSERT_FP_EQ(x, __llvm_libc::fmin(x, y));
} else { } else {
ASSERT_EQ(y, __llvm_libc::fmin(x, y)); ASSERT_FP_EQ(y, __llvm_libc::fmin(x, y));
} }
} }
} }

libc/test/src/math/fminf_test.cpp

//===-- Unittests for fminf ----------------------------------------------===// //===-- Unittests for fminf ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#include "include/math.h" #include "include/math.h"
#include "src/math/fminf.h" #include "src/math/fminf.h"
#include "utils/FPUtil/FPBits.h" #include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
float nan = static_cast<float>(FPBits::buildNaN(1)); float nan = static_cast<float>(FPBits::buildNaN(1));
float inf = static_cast<float>(FPBits::inf()); float inf = static_cast<float>(FPBits::inf());
float negInf = static_cast<float>(FPBits::negInf()); float negInf = static_cast<float>(FPBits::negInf());
TEST(FminfTest, NaNArg) { TEST(FminfTest, NaNArg) {
EXPECT_EQ(inf, __llvm_libc::fminf(nan, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fminf(nan, inf));
EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, nan)); EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, nan));
EXPECT_EQ(0.0f, __llvm_libc::fminf(nan, 0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(nan, 0.0f));
EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, nan)); EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, nan));
EXPECT_EQ(-1.2345f, __llvm_libc::fminf(nan, -1.2345f)); EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(nan, -1.2345f));
EXPECT_EQ(1.2345f, __llvm_libc::fminf(1.2345f, nan)); EXPECT_FP_EQ(1.2345f, __llvm_libc::fminf(1.2345f, nan));
EXPECT_NE(isnan(__llvm_libc::fminf(nan, nan)), 0); EXPECT_NE(isnan(__llvm_libc::fminf(nan, nan)), 0);
} }
TEST(FminfTest, InfArg) { TEST(FminfTest, InfArg) {
EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, inf)); EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, inf));
EXPECT_EQ(0.0f, __llvm_libc::fminf(inf, 0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(inf, 0.0f));
EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, inf)); EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, inf));
EXPECT_EQ(1.2345f, __llvm_libc::fminf(inf, 1.2345f)); EXPECT_FP_EQ(1.2345f, __llvm_libc::fminf(inf, 1.2345f));
EXPECT_EQ(-1.2345f, __llvm_libc::fminf(-1.2345f, inf)); EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(-1.2345f, inf));
} }
TEST(FminfTest, NegInfArg) { TEST(FminfTest, NegInfArg) {
EXPECT_EQ(negInf, __llvm_libc::fminf(inf, negInf)); EXPECT_FP_EQ(negInf, __llvm_libc::fminf(inf, negInf));
EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, 0.0f)); EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, 0.0f));
EXPECT_EQ(negInf, __llvm_libc::fminf(-0.0f, negInf)); EXPECT_FP_EQ(negInf, __llvm_libc::fminf(-0.0f, negInf));
EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, -1.2345f)); EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, -1.2345f));
EXPECT_EQ(negInf, __llvm_libc::fminf(1.2345f, negInf)); EXPECT_FP_EQ(negInf, __llvm_libc::fminf(1.2345f, negInf));
} }
TEST(FminfTest, BothZero) { TEST(FminfTest, BothZero) {
EXPECT_EQ(0.0f, __llvm_libc::fminf(0.0f, 0.0f)); EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(0.0f, 0.0f));
EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, 0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, 0.0f));
EXPECT_EQ(-0.0f, __llvm_libc::fminf(0.0f, -0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(0.0f, -0.0f));
EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, -0.0f)); EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, -0.0f));
} }
TEST(FminfTest, InFloatRange) { TEST(FminfTest, InFloatRange) {
using UIntType = FPBits::UIntType; using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000; constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) { ++i, v += step, w -= step) {
float x = FPBits(v), y = FPBits(w); float x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
if (x < y) { if (x < y) {
ASSERT_EQ(x, __llvm_libc::fminf(x, y)); ASSERT_FP_EQ(x, __llvm_libc::fminf(x, y));
} else { } else {
ASSERT_EQ(y, __llvm_libc::fminf(x, y)); ASSERT_FP_EQ(y, __llvm_libc::fminf(x, y));
} }
} }
} }

libc/test/src/math/fminl_test.cpp

//===-- Unittests for fmin -----------------------------------------------===// //===-- Unittests for fmin -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#include "include/math.h" #include "include/math.h"
#include "src/math/fminl.h" #include "src/math/fminl.h"
#include "utils/FPUtil/FPBits.h" #include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using FPBits = __llvm_libc::fputil::FPBits<long double>; using FPBits = __llvm_libc::fputil::FPBits<long double>;
long double nan = static_cast<long double>(FPBits::buildNaN(1)); long double nan = static_cast<long double>(FPBits::buildNaN(1));
long double inf = static_cast<long double>(FPBits::inf()); long double inf = static_cast<long double>(FPBits::inf());
long double negInf = static_cast<long double>(FPBits::negInf()); long double negInf = static_cast<long double>(FPBits::negInf());
TEST(FminlTest, NaNArg) { TEST(FminlTest, NaNArg) {
EXPECT_EQ(inf, __llvm_libc::fminl(nan, inf)); EXPECT_FP_EQ(inf, __llvm_libc::fminl(nan, inf));
EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, nan)); EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, nan));
EXPECT_EQ(0.0L, __llvm_libc::fminl(nan, 0.0L)); EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(nan, 0.0L));
EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, nan)); EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, nan));
EXPECT_EQ(-1.2345L, __llvm_libc::fminl(nan, -1.2345L)); EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(nan, -1.2345L));
EXPECT_EQ(1.2345L, __llvm_libc::fminl(1.2345L, nan)); EXPECT_FP_EQ(1.2345L, __llvm_libc::fminl(1.2345L, nan));
EXPECT_NE(isnan(__llvm_libc::fminl(nan, nan)), 0); EXPECT_NE(isnan(__llvm_libc::fminl(nan, nan)), 0);
} }
TEST(FminlTest, InfArg) { TEST(FminlTest, InfArg) {
EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, inf)); EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, inf));
EXPECT_EQ(0.0L, __llvm_libc::fminl(inf, 0.0L)); EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(inf, 0.0L));
EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, inf)); EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, inf));
EXPECT_EQ(1.2345L, __llvm_libc::fminl(inf, 1.2345L)); EXPECT_FP_EQ(1.2345L, __llvm_libc::fminl(inf, 1.2345L));
EXPECT_EQ(-1.2345L, __llvm_libc::fminl(-1.2345L, inf)); EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(-1.2345L, inf));
} }
TEST(FminlTest, NegInfArg) { TEST(FminlTest, NegInfArg) {
EXPECT_EQ(negInf, __llvm_libc::fminl(inf, negInf)); EXPECT_FP_EQ(negInf, __llvm_libc::fminl(inf, negInf));
EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, 0.0L)); EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, 0.0L));
EXPECT_EQ(negInf, __llvm_libc::fminl(-0.0L, negInf)); EXPECT_FP_EQ(negInf, __llvm_libc::fminl(-0.0L, negInf));
EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, -1.2345L)); EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, -1.2345L));
EXPECT_EQ(negInf, __llvm_libc::fminl(1.2345L, negInf)); EXPECT_FP_EQ(negInf, __llvm_libc::fminl(1.2345L, negInf));
} }
TEST(FminlTest, BothZero) { TEST(FminlTest, BothZero) {
EXPECT_EQ(0.0L, __llvm_libc::fminl(0.0L, 0.0L)); EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(0.0L, 0.0L));
EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, 0.0L)); EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, 0.0L));
EXPECT_EQ(-0.0L, __llvm_libc::fminl(0.0L, -0.0L)); EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(0.0L, -0.0L));
EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, -0.0L)); EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, -0.0L));
} }
TEST(FminlTest, InLongDoubleRange) { TEST(FminlTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType; using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000; constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) { ++i, v += step, w -= step) {
long double x = FPBits(v), y = FPBits(w); long double x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
if (x < y) { if (x < y) {
ASSERT_EQ(x, __llvm_libc::fminl(x, y)); ASSERT_FP_EQ(x, __llvm_libc::fminl(x, y));
} else { } else {
ASSERT_EQ(y, __llvm_libc::fminl(x, y)); ASSERT_FP_EQ(y, __llvm_libc::fminl(x, y));
} }
} }
} }

libc/utils/FPUtil/CMakeLists.txt

Show All 14 Lines HDRS
FloatProperties.h FloatProperties.h
FPBits.h FPBits.h
BasicOperations.h BasicOperations.h
ManipulationFunctions.h ManipulationFunctions.h
NearestIntegerOperations.h NearestIntegerOperations.h
DEPENDS DEPENDS
libc.utils.CPP.standalone_cpp libc.utils.CPP.standalone_cpp
) )
add_llvm_library(
LibcFPTestHelpers
TestHelpers.cpp
TestHelpers.h
)
target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
target_link_libraries(LibcFPTestHelpers LibcUnitTest LLVMSupport)
add_dependencies(
LibcFPTestHelpers
LibcUnitTest
libc.utils.CPP.standalone_cpp
libc.utils.FPUtil.fputil
)

libc/utils/FPUtil/TestHelpers.h

  • This file was added.
//===-- TestMatchers.h ------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_TEST_HELPERS_H
#define LLVM_LIBC_UTILS_FPUTIL_TEST_HELPERS_H
#include "FPBits.h"
#include "utils/UnitTest/Test.h"
namespace __llvm_libc {
namespace fputil {
namespace testing {
template <typename ValType>
cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, void>
describeValue(const char *label, ValType value,
testutils::StreamWrapper &stream);
template <typename T, __llvm_libc::testing::TestCondition Condition>
class FPMatcher : public __llvm_libc::testing::Matcher<T> {
static_assert(__llvm_libc::cpp::IsFloatingPointType<T>::Value,
"FPMatcher can only be used with floating point values.");
static_assert(Condition == __llvm_libc::testing::Cond_EQ ||
Condition == __llvm_libc::testing::Cond_NE,
"Unsupported FPMathcer test condition.");
T expected;
T actual;
public:
FPMatcher(T expectedValue) : expected(expectedValue) {}
bool match(T actualValue) {
actual = actualValue;
fputil::FPBits<T> actualBits(actual), expectedBits(expected);
if (Condition == __llvm_libc::testing::Cond_EQ)
return (actualBits.isNaN() && expectedBits.isNaN()) ||
(actualBits.bitsAsUInt() == expectedBits.bitsAsUInt());
// If condition == Cond_NE.
if (actualBits.isNaN())
return !expectedBits.isNaN();
return expectedBits.isNaN() ||
(actualBits.bitsAsUInt() != expectedBits.bitsAsUInt());
}
void explainError(testutils::StreamWrapper &stream) override {
describeValue("Expected floating point value: ", expected, stream);
describeValue(" Actual floating point value: ", actual, stream);
}
};
template <__llvm_libc::testing::TestCondition C, typename T>
FPMatcher<T, C> getMatcher(T expectedValue) {
return FPMatcher<T, C>(expectedValue);
}
} // namespace testing
} // namespace fputil
} // namespace __llvm_libc
#define EXPECT_FP_EQ(expected, actual) \
EXPECT_THAT( \
actual, \
__llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_EQ>( \
expected))
#define ASSERT_FP_EQ(expected, actual) \
ASSERT_THAT( \
actual, \
__llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_EQ>( \
expected))
#define EXPECT_FP_NE(expected, actual) \
EXPECT_THAT( \
actual, \
__llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_NE>( \
expected))
#define ASSERT_FP_NE(expected, actual) \
ASSERT_THAT( \
actual, \
__llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_NE>( \
expected))
#endif // LLVM_LIBC_UTILS_FPUTIL_TEST_HELPERS_H

libc/utils/FPUtil/TestHelpers.cpp

  • This file was added.
//===-- TestMatchers.cpp ----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "TestHelpers.h"
#include "FPBits.h"
#include "llvm/ADT/StringExtras.h"
#include <string>
namespace __llvm_libc {
namespace fputil {
namespace testing {
// Return the first N hex digits of an integer as a string in upper case.
template <typename T>
cpp::EnableIfType<cpp::IsIntegral<T>::Value, std::string>
uintToHex(T X, size_t Length = sizeof(T) * 2) {
std::string s(Length, '0');
for (auto it = s.rbegin(), end = s.rend(); it != end; ++it, X >>= 4) {
unsigned char Mod = static_cast<unsigned char>(X) & 15;
*it = llvm::hexdigit(Mod, true);
}
return s;
}
template <typename ValType>
cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, void>
describeValue(const char *label, ValType value,
testutils::StreamWrapper &stream) {
stream << label;
FPBits<ValType> bits(value);
if (bits.isNaN()) {
stream << "(NaN)";
} else if (bits.isInf()) {
if (bits.sign)
stream << "(-Infinity)";
else
stream << "(+Infinity)";
} else {
constexpr int exponentWidthInHex =
(fputil::ExponentWidth<ValType>::value - 1) / 4 + 1;
constexpr int mantissaWidthInHex =
(fputil::MantissaWidth<ValType>::value - 1) / 4 + 1;
stream << "Sign: " << (bits.sign ? '1' : '0') << ", "
<< "Exponent: 0x"
<< uintToHex<uint16_t>(bits.exponent, exponentWidthInHex) << ", "
<< "Mantissa: 0x"
<< uintToHex<typename fputil::FPBits<ValType>::UIntType>(
bits.mantissa, mantissaWidthInHex);
}
stream << '\n';
}
template void describeValue<float>(const char *, float,
testutils::StreamWrapper &);
template void describeValue<double>(const char *, double,
testutils::StreamWrapper &);
template void describeValue<long double>(const char *, long double,
testutils::StreamWrapper &);
} // namespace testing
} // namespace fputil
} // namespace __llvm_libc

libc/utils/UnitTest/Test.h

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesprotected:
// We make use of a template function, with |LHS| and |RHS| as explicit // We make use of a template function, with |LHS| and |RHS| as explicit
// parameters, for enhanced type checking. Other gtest like unittest // parameters, for enhanced type checking. Other gtest like unittest
// frameworks have a similar function which takes a boolean argument // frameworks have a similar function which takes a boolean argument
// instead of the explicit |LHS| and |RHS| arguments. This boolean argument // instead of the explicit |LHS| and |RHS| arguments. This boolean argument
// is the result of the |Cond| operation on |LHS| and |RHS|. Though not bad, // is the result of the |Cond| operation on |LHS| and |RHS|. Though not bad,
// |Cond| on mismatched |LHS| and |RHS| types can potentially succeed because // |Cond| on mismatched |LHS| and |RHS| types can potentially succeed because
// of type promotion. // of type promotion.
template <typename ValType, template <typename ValType,
cpp::EnableIfType<cpp::IsArithmetic<ValType>::Value, int> = 0> cpp::EnableIfType<cpp::IsIntegral<ValType>::Value, int> = 0>
static bool test(RunContext &Ctx, TestCondition Cond, ValType LHS, static bool test(RunContext &Ctx, TestCondition Cond, ValType LHS,
ValType RHS, const char *LHSStr, const char *RHSStr, ValType RHS, const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line) { const char *File, unsigned long Line) {
return internal::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line); return internal::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
} }
template < template <
typename ValType, typename ValType,
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

libc/utils/UnitTest/Test.cpp

//===-- Implementation of the base class for libc unittests ---------------===// //===-- Implementation of the base class for libc unittests ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "Test.h" #include "Test.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/testutils/ExecuteFunction.h" #include "utils/testutils/ExecuteFunction.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace testing { namespace testing {
Show All 9 Linespublic:
void markFail() { Status = Result_Fail; } void markFail() { Status = Result_Fail; }
private: private:
RunResult Status = Result_Pass; RunResult Status = Result_Pass;
}; };
namespace internal { namespace internal {
// Display the first N hexadecimal digits of an integer in upper case. // When the value is of integral type, just display it as normal.
template <typename T>
cpp::EnableIfType<cpp::IsIntegral<T>::Value, std::string>
uintToHex(T X, size_t Length = sizeof(T) * 2) {
std::string s(Length, '0');
for (auto it = s.rbegin(), end = s.rend(); it != end; ++it, X >>= 4) {
unsigned char Mod = static_cast<unsigned char>(X) & 15;
*it = llvm::hexdigit(Mod, true);
}
return s;
}
// When the value is not floating-point type, just display it as normal.
template <typename ValType> template <typename ValType>
cpp::EnableIfType<!cpp::IsFloatingPointType<ValType>::Value, std::string> cpp::EnableIfType<cpp::IsIntegral<ValType>::Value, std::string>
describeValue(ValType Value) { describeValue(ValType Value) {
return std::to_string(Value); return std::to_string(Value);
} }
template <> std::string describeValue<llvm::StringRef>(llvm::StringRef Value) { std::string describeValue(llvm::StringRef Value) { return std::string(Value); }
return std::string(Value);
}
// When the value is __uint128_t, also show its hexadecimal digits. // When the value is __uint128_t, also show its hexadecimal digits.
// Using template to force exact match, prevent ambiguous promotion. // Using template to force exact match, prevent ambiguous promotion.
template <> std::string describeValue<__uint128_t>(__uint128_t Value) { template <> std::string describeValue<__uint128_t>(__uint128_t Value) {
return "0x" + uintToHex(Value); std::string S(sizeof(__uint128_t) * 2, '0');
}
// When the value is a floating point type, also show its sign | exponent |
// mantissa.
template <typename ValType>
cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, std::string>
describeValue(ValType Value) {
fputil::FPBits<ValType> Bits(Value);
if (Bits.isNaN()) { for (auto I = S.rbegin(), End = S.rend(); I != End; ++I, Value >>= 4) {
return "(NaN)"; unsigned char Mod = static_cast<unsigned char>(Value) & 15;
} else if (Bits.isInf()) { *I = llvm::hexdigit(Mod, true);
return Bits.sign ? "(-Infinity)" : "(+Infinity)";
} else {
constexpr int ExponentWidthInHex =
(fputil::ExponentWidth<ValType>::value - 1) / 4 + 1;
constexpr int MantissaWidthInHex =
(fputil::MantissaWidth<ValType>::value - 1) / 4 + 1;
return std::string("Sign: ") + (Bits.sign ? '1' : '0') + ", Exponent: 0x" +
uintToHex<uint16_t>(Bits.exponent, ExponentWidthInHex) +
", Mantissa: 0x" +
uintToHex<typename fputil::FPBits<ValType>::UIntType>(
Bits.mantissa, MantissaWidthInHex);
} }
return "0x" + S;
} }
template <typename ValType> template <typename ValType>
void explainDifference(ValType LHS, ValType RHS, const char *LHSStr, void explainDifference(ValType LHS, ValType RHS, const char *LHSStr,
const char *RHSStr, const char *File, unsigned long Line, const char *RHSStr, const char *File, unsigned long Line,
llvm::StringRef OpString) { llvm::StringRef OpString) {
size_t OffsetLength = OpString.size() > 2 ? OpString.size() - 2 : 0; size_t OffsetLength = OpString.size() > 2 ? OpString.size() - 2 : 0;
std::string Offset(OffsetLength, ' '); std::string Offset(OffsetLength, ' ');
llvm::outs() << File << ":" << Line << ": FAILURE\n" llvm::outs() << File << ":" << Line << ": FAILURE\n"
<< Offset << "Expected: " << LHSStr << '\n' << Offset << "Expected: " << LHSStr << '\n'
<< Offset << "Which is: " << describeValue(LHS) << '\n' << Offset << "Which is: " << describeValue(LHS) << '\n'
<< "To be " << OpString << ": " << RHSStr << '\n' << "To be " << OpString << ": " << RHSStr << '\n'
<< Offset << "Which is: " << describeValue(RHS) << '\n'; << Offset << "Which is: " << describeValue(RHS) << '\n';
} }
template <typename ValType> template <typename ValType>
cpp::EnableIfType<!cpp::IsFloatingPointType<ValType>::Value, bool>
testEQ(ValType LHS, ValType RHS) {
return LHS == RHS;
}
// For floating points, we consider all NaNs are equal, and +0.0 is not equal to
// -0.0.
template <typename ValType>
cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, bool>
testEQ(ValType LHS, ValType RHS) {
fputil::FPBits<ValType> LHSBits(LHS), RHSBits(RHS);
return (LHSBits.isNaN() && RHSBits.isNaN()) ||
(LHSBits.bitsAsUInt() == RHSBits.bitsAsUInt());
}
template <typename ValType>
bool test(RunContext &Ctx, TestCondition Cond, ValType LHS, ValType RHS, bool test(RunContext &Ctx, TestCondition Cond, ValType LHS, ValType RHS,
const char *LHSStr, const char *RHSStr, const char *File, const char *LHSStr, const char *RHSStr, const char *File,
unsigned long Line) { unsigned long Line) {
auto ExplainDifference = [=](llvm::StringRef OpString) { auto ExplainDifference = [=](llvm::StringRef OpString) {
explainDifference(LHS, RHS, LHSStr, RHSStr, File, Line, OpString); explainDifference(LHS, RHS, LHSStr, RHSStr, File, Line, OpString);
}; };
switch (Cond) { switch (Cond) {
case Cond_EQ: case Cond_EQ:
if (testEQ(LHS, RHS)) if (LHS == RHS)
return true; return true;
Ctx.markFail(); Ctx.markFail();
ExplainDifference("equal to"); ExplainDifference("equal to");
return false; return false;
case Cond_NE: case Cond_NE:
if (!testEQ(LHS, RHS)) if (LHS != RHS)
return true; return true;
Ctx.markFail(); Ctx.markFail();
ExplainDifference("not equal to"); ExplainDifference("not equal to");
return false; return false;
case Cond_LT: case Cond_LT:
if (LHS < RHS) if (LHS < RHS)
return true; return true;
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Linestemplate bool Test::test<unsigned long long, 0>(
RunContext &Ctx, TestCondition Cond, unsigned long long LHS, RunContext &Ctx, TestCondition Cond, unsigned long long LHS,
unsigned long long RHS, const char *LHSStr, const char *RHSStr, unsigned long long RHS, const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line); const char *File, unsigned long Line);
template bool Test::test<__uint128_t, 0>(RunContext &Ctx, TestCondition Cond, template bool Test::test<__uint128_t, 0>(RunContext &Ctx, TestCondition Cond,
__uint128_t LHS, __uint128_t RHS, __uint128_t LHS, __uint128_t RHS,
const char *LHSStr, const char *RHSStr, const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line); const char *File, unsigned long Line);
/*
template bool Test::test<float, 0>(RunContext &Ctx, TestCondition Cond, template bool Test::test<float, 0>(RunContext &Ctx, TestCondition Cond,
float LHS, float RHS, const char *LHSStr, float LHS, float RHS, const char *LHSStr,
const char *RHSStr, const char *File, const char *RHSStr, const char *File,
unsigned long Line); unsigned long Line);
template bool Test::test<double, 0>(RunContext &Ctx, TestCondition Cond, template bool Test::test<double, 0>(RunContext &Ctx, TestCondition Cond,
double LHS, double RHS, const char *LHSStr, double LHS, double RHS, const char *LHSStr,
const char *RHSStr, const char *File, const char *RHSStr, const char *File,
unsigned long Line); unsigned long Line);
template bool Test::test<long double, 0>(RunContext &Ctx, TestCondition Cond, template bool Test::test<long double, 0>(RunContext &Ctx, TestCondition Cond,
long double LHS, long double RHS, long double LHS, long double RHS,
const char *LHSStr, const char *RHSStr, const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line); const char *File, unsigned long Line);
*/
bool Test::testStrEq(RunContext &Ctx, const char *LHS, const char *RHS, bool Test::testStrEq(RunContext &Ctx, const char *LHS, const char *RHS,
const char *LHSStr, const char *RHSStr, const char *File, const char *LHSStr, const char *RHSStr, const char *File,
unsigned long Line) { unsigned long Line) {
return internal::test(Ctx, Cond_EQ, llvm::StringRef(LHS), return internal::test(Ctx, Cond_EQ, llvm::StringRef(LHS),
llvm::StringRef(RHS), LHSStr, RHSStr, File, Line); llvm::StringRef(RHS), LHSStr, RHSStr, File, Line);
} }
bool Test::testStrNe(RunContext &Ctx, const char *LHS, const char *RHS, bool Test::testStrNe(RunContext &Ctx, const char *LHS, const char *RHS,
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines