Skip to content

Commit a875765

Browse files
author
Siva Chandra
committed
[libc][obvious] Switch copysign[f|l] and fabs[f|l] to the new test matchers.
1 parent dc7b1e9 commit a875765

File tree

6 files changed

+113
-166
lines changed

6 files changed

+113
-166
lines changed

‎libc/test/src/math/copysign_test.cpp

Lines changed: 23 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -8,56 +8,42 @@
88

99
#include "include/math.h"
1010
#include "src/math/copysign.h"
11-
#include "utils/FPUtil/BitPatterns.h"
12-
#include "utils/FPUtil/FloatOperations.h"
13-
#include "utils/FPUtil/FloatProperties.h"
11+
#include "utils/FPUtil/FPBits.h"
12+
#include "utils/FPUtil/TestHelpers.h"
1413
#include "utils/UnitTest/Test.h"
1514

16-
using __llvm_libc::fputil::valueAsBits;
17-
using __llvm_libc::fputil::valueFromBits;
15+
using FPBits = __llvm_libc::fputil::FPBits<double>;
1816

19-
using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
20-
using Properties = __llvm_libc::fputil::FloatProperties<double>;
17+
static const double zero = FPBits::zero();
18+
static const double negZero = FPBits::negZero();
19+
static const double nan = FPBits::buildNaN(1);
20+
static const double inf = FPBits::inf();
21+
static const double negInf = FPBits::negInf();
2122

2223
TEST(CopySignTest, SpecialNumbers) {
23-
EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
24-
valueAsBits(__llvm_libc::copysign(
25-
valueFromBits(BitPatterns::aQuietNaN), -1.0)));
26-
EXPECT_EQ(BitPatterns::aQuietNaN,
27-
valueAsBits(__llvm_libc::copysign(
28-
valueFromBits(BitPatterns::aNegativeQuietNaN), 1.0)));
29-
30-
EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
31-
valueAsBits(__llvm_libc::copysign(
32-
valueFromBits(BitPatterns::aSignallingNaN), -1.0)));
33-
EXPECT_EQ(BitPatterns::aSignallingNaN,
34-
valueAsBits(__llvm_libc::copysign(
35-
valueFromBits(BitPatterns::aNegativeSignallingNaN), 1.0)));
36-
37-
EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::copysign(
38-
valueFromBits(BitPatterns::inf), -1.0)));
39-
EXPECT_EQ(BitPatterns::inf, valueAsBits(__llvm_libc::copysign(
40-
valueFromBits(BitPatterns::negInf), 1.0)));
41-
42-
EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::copysign(
43-
valueFromBits(BitPatterns::zero), -1.0)));
44-
EXPECT_EQ(BitPatterns::zero, valueAsBits(__llvm_libc::copysign(
45-
valueFromBits(BitPatterns::negZero), 1.0)));
24+
EXPECT_FP_EQ(nan, __llvm_libc::copysign(nan, -1.0));
25+
EXPECT_FP_EQ(nan, __llvm_libc::copysign(nan, 1.0));
26+
27+
EXPECT_FP_EQ(negInf, __llvm_libc::copysign(inf, -1.0));
28+
EXPECT_FP_EQ(inf, __llvm_libc::copysign(negInf, 1.0));
29+
30+
EXPECT_FP_EQ(negZero, __llvm_libc::copysign(zero, -1.0));
31+
EXPECT_FP_EQ(zero, __llvm_libc::copysign(negZero, 1.0));
4632
}
4733

4834
TEST(CopySignTest, InDoubleRange) {
49-
using BitsType = Properties::BitsType;
50-
constexpr BitsType count = 1000000;
51-
constexpr BitsType step = UINT64_MAX / count;
52-
for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
53-
double x = valueFromBits(v);
35+
using UIntType = FPBits::UIntType;
36+
constexpr UIntType count = 10000000;
37+
constexpr UIntType step = UIntType(-1) / count;
38+
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
39+
double x = FPBits(v);
5440
if (isnan(x) || isinf(x) || x == 0)
5541
continue;
5642

5743
double res1 = __llvm_libc::copysign(x, -x);
58-
ASSERT_TRUE(res1 == -x);
44+
ASSERT_FP_EQ(res1, -x);
5945

6046
double res2 = __llvm_libc::copysign(x, x);
61-
ASSERT_TRUE(res2 == x);
47+
ASSERT_FP_EQ(res2, x);
6248
}
6349
}

‎libc/test/src/math/copysignf_test.cpp

Lines changed: 24 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,4 @@
1-
//===-- Unittests for copysignf
2-
//--------------------------------------------===//
1+
//===-- Unittests for copysignf -------------------------------------------===//
32
//
43
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
54
// See https://llvm.org/LICENSE.txt for license information.
@@ -9,57 +8,42 @@
98

109
#include "include/math.h"
1110
#include "src/math/copysignf.h"
12-
#include "utils/FPUtil/BitPatterns.h"
13-
#include "utils/FPUtil/FloatOperations.h"
14-
#include "utils/FPUtil/FloatProperties.h"
11+
#include "utils/FPUtil/FPBits.h"
12+
#include "utils/FPUtil/TestHelpers.h"
1513
#include "utils/UnitTest/Test.h"
1614

17-
using __llvm_libc::fputil::valueAsBits;
18-
using __llvm_libc::fputil::valueFromBits;
15+
using FPBits = __llvm_libc::fputil::FPBits<float>;
1916

20-
using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
21-
using Properties = __llvm_libc::fputil::FloatProperties<float>;
17+
static const float zero = FPBits::zero();
18+
static const float negZero = FPBits::negZero();
19+
static const float nan = FPBits::buildNaN(1);
20+
static const float inf = FPBits::inf();
21+
static const float negInf = FPBits::negInf();
2222

23-
TEST(CopySignFTest, SpecialNumbers) {
24-
EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
25-
valueAsBits(__llvm_libc::copysignf(
26-
valueFromBits(BitPatterns::aQuietNaN), -1.0f)));
27-
EXPECT_EQ(BitPatterns::aQuietNaN,
28-
valueAsBits(__llvm_libc::copysignf(
29-
valueFromBits(BitPatterns::aNegativeQuietNaN), 1.0f)));
23+
TEST(CopySinfTest, SpecialNumbers) {
24+
EXPECT_FP_EQ(nan, __llvm_libc::copysignf(nan, -1.0));
25+
EXPECT_FP_EQ(nan, __llvm_libc::copysignf(nan, 1.0));
3026

31-
EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
32-
valueAsBits(__llvm_libc::copysignf(
33-
valueFromBits(BitPatterns::aSignallingNaN), -1.0f)));
34-
EXPECT_EQ(BitPatterns::aSignallingNaN,
35-
valueAsBits(__llvm_libc::copysignf(
36-
valueFromBits(BitPatterns::aNegativeSignallingNaN), 1.0f)));
27+
EXPECT_FP_EQ(negInf, __llvm_libc::copysignf(inf, -1.0));
28+
EXPECT_FP_EQ(inf, __llvm_libc::copysignf(negInf, 1.0));
3729

38-
EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::copysignf(
39-
valueFromBits(BitPatterns::inf), -1.0f)));
40-
EXPECT_EQ(BitPatterns::inf, valueAsBits(__llvm_libc::copysignf(
41-
valueFromBits(BitPatterns::negInf), 1.0f)));
42-
43-
EXPECT_EQ(BitPatterns::negZero,
44-
valueAsBits(__llvm_libc::copysignf(valueFromBits(BitPatterns::zero),
45-
-1.0f)));
46-
EXPECT_EQ(BitPatterns::zero, valueAsBits(__llvm_libc::copysignf(
47-
valueFromBits(BitPatterns::negZero), 1.0f)));
30+
EXPECT_FP_EQ(negZero, __llvm_libc::copysignf(zero, -1.0));
31+
EXPECT_FP_EQ(zero, __llvm_libc::copysignf(negZero, 1.0));
4832
}
4933

50-
TEST(CopySignFTest, InDoubleRange) {
51-
using BitsType = Properties::BitsType;
52-
constexpr BitsType count = 1000000;
53-
constexpr BitsType step = UINT32_MAX / count;
54-
for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
55-
float x = valueFromBits(v);
34+
TEST(CopySinfTest, InFloatRange) {
35+
using UIntType = FPBits::UIntType;
36+
constexpr UIntType count = 1000000;
37+
constexpr UIntType step = UIntType(-1) / count;
38+
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
39+
float x = FPBits(v);
5640
if (isnan(x) || isinf(x) || x == 0)
5741
continue;
5842

5943
float res1 = __llvm_libc::copysignf(x, -x);
60-
ASSERT_TRUE(res1 == -x);
44+
ASSERT_FP_EQ(res1, -x);
6145

6246
float res2 = __llvm_libc::copysignf(x, x);
63-
ASSERT_TRUE(res2 == x);
47+
ASSERT_FP_EQ(res2, x);
6448
}
6549
}

‎libc/test/src/math/copysignl_test.cpp

Lines changed: 18 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,4 @@
1-
//===-- Unittests for copysignl
2-
//--------------------------------------------===//
1+
//===-- Unittests for copysignl -------------------------------------------===//
32
//
43
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
54
// See https://llvm.org/LICENSE.txt for license information.
@@ -10,26 +9,29 @@
109
#include "include/math.h"
1110
#include "src/math/copysignl.h"
1211
#include "utils/FPUtil/FPBits.h"
12+
#include "utils/FPUtil/TestHelpers.h"
1313
#include "utils/UnitTest/Test.h"
1414

1515
using FPBits = __llvm_libc::fputil::FPBits<long double>;
1616

17-
TEST(CopysignlTest, SpecialNumbers) {
18-
EXPECT_TRUE(FPBits::negZero() ==
19-
__llvm_libc::copysignl(FPBits::zero(), -1.0l));
20-
EXPECT_TRUE(FPBits::zero() ==
21-
__llvm_libc::copysignl(FPBits::negZero(), 1.0l));
17+
static const long double zero = FPBits::zero();
18+
static const long double negZero = FPBits::negZero();
19+
static const long double nan = FPBits::buildNaN(1);
20+
static const long double inf = FPBits::inf();
21+
static const long double negInf = FPBits::negInf();
2222

23-
EXPECT_TRUE(FPBits::negZero() ==
24-
__llvm_libc::copysignl(FPBits::zero(), -1.0l));
25-
EXPECT_TRUE(FPBits::zero() ==
26-
__llvm_libc::copysignl(FPBits::negZero(), 1.0l));
23+
TEST(CopySinlTest, SpecialNumbers) {
24+
EXPECT_FP_EQ(nan, __llvm_libc::copysignl(nan, -1.0));
25+
EXPECT_FP_EQ(nan, __llvm_libc::copysignl(nan, 1.0));
2726

28-
EXPECT_TRUE(
29-
FPBits(__llvm_libc::copysignl(FPBits::buildNaN(1), -1.0l)).isNaN());
27+
EXPECT_FP_EQ(negInf, __llvm_libc::copysignl(inf, -1.0));
28+
EXPECT_FP_EQ(inf, __llvm_libc::copysignl(negInf, 1.0));
29+
30+
EXPECT_FP_EQ(negZero, __llvm_libc::copysignl(zero, -1.0));
31+
EXPECT_FP_EQ(zero, __llvm_libc::copysignl(negZero, 1.0));
3032
}
3133

32-
TEST(CopysignlTest, InDoubleRange) {
34+
TEST(CopySinlTest, InLongDoubleRange) {
3335
using UIntType = FPBits::UIntType;
3436
constexpr UIntType count = 10000000;
3537
constexpr UIntType step = UIntType(-1) / count;
@@ -39,9 +41,9 @@ TEST(CopysignlTest, InDoubleRange) {
3941
continue;
4042

4143
long double res1 = __llvm_libc::copysignl(x, -x);
42-
ASSERT_TRUE(res1 == -x);
44+
ASSERT_FP_EQ(res1, -x);
4345

4446
long double res2 = __llvm_libc::copysignl(x, x);
45-
ASSERT_TRUE(res2 == x);
47+
ASSERT_FP_EQ(res2, x);
4648
}
4749
}

‎libc/test/src/math/fabs_test.cpp

Lines changed: 18 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -8,17 +8,18 @@
88

99
#include "include/math.h"
1010
#include "src/math/fabs.h"
11-
#include "utils/FPUtil/BitPatterns.h"
12-
#include "utils/FPUtil/FloatOperations.h"
13-
#include "utils/FPUtil/FloatProperties.h"
11+
#include "utils/FPUtil/FPBits.h"
12+
#include "utils/FPUtil/TestHelpers.h"
1413
#include "utils/MPFRWrapper/MPFRUtils.h"
1514
#include "utils/UnitTest/Test.h"
1615

17-
using __llvm_libc::fputil::valueAsBits;
18-
using __llvm_libc::fputil::valueFromBits;
16+
using FPBits = __llvm_libc::fputil::FPBits<double>;
1917

20-
using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
21-
using Properties = __llvm_libc::fputil::FloatProperties<double>;
18+
static const double zero = FPBits::zero();
19+
static const double negZero = FPBits::negZero();
20+
static const double nan = FPBits::buildNaN(1);
21+
static const double inf = FPBits::inf();
22+
static const double negInf = FPBits::negInf();
2223

2324
namespace mpfr = __llvm_libc::testing::mpfr;
2425

@@ -27,36 +28,21 @@ static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
2728
0};
2829

2930
TEST(FabsTest, SpecialNumbers) {
30-
EXPECT_EQ(
31-
BitPatterns::aQuietNaN,
32-
valueAsBits(__llvm_libc::fabs(valueFromBits(BitPatterns::aQuietNaN))));
33-
EXPECT_EQ(BitPatterns::aQuietNaN, valueAsBits(__llvm_libc::fabs(valueFromBits(
34-
BitPatterns::aNegativeQuietNaN))));
31+
EXPECT_FP_EQ(nan, __llvm_libc::fabs(nan));
3532

36-
EXPECT_EQ(BitPatterns::aSignallingNaN,
37-
valueAsBits(
38-
__llvm_libc::fabs(valueFromBits(BitPatterns::aSignallingNaN))));
39-
EXPECT_EQ(BitPatterns::aSignallingNaN,
40-
valueAsBits(__llvm_libc::fabs(
41-
valueFromBits(BitPatterns::aNegativeSignallingNaN))));
33+
EXPECT_FP_EQ(inf, __llvm_libc::fabs(inf));
34+
EXPECT_FP_EQ(inf, __llvm_libc::fabs(negInf));
4235

43-
EXPECT_EQ(BitPatterns::inf,
44-
valueAsBits(__llvm_libc::fabs(valueFromBits(BitPatterns::inf))));
45-
EXPECT_EQ(BitPatterns::inf,
46-
valueAsBits(__llvm_libc::fabs(valueFromBits(BitPatterns::negInf))));
47-
48-
EXPECT_EQ(BitPatterns::zero,
49-
valueAsBits(__llvm_libc::fabs(valueFromBits(BitPatterns::zero))));
50-
EXPECT_EQ(BitPatterns::zero, valueAsBits(__llvm_libc::fabs(
51-
valueFromBits(BitPatterns::negZero))));
36+
EXPECT_FP_EQ(zero, __llvm_libc::fabs(zero));
37+
EXPECT_FP_EQ(zero, __llvm_libc::fabs(negZero));
5238
}
5339

5440
TEST(FabsTest, InDoubleRange) {
55-
using BitsType = Properties::BitsType;
56-
constexpr BitsType count = 1000000;
57-
constexpr BitsType step = UINT64_MAX / count;
58-
for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
59-
double x = valueFromBits(v);
41+
using UIntType = FPBits::UIntType;
42+
constexpr UIntType count = 10000000;
43+
constexpr UIntType step = UIntType(-1) / count;
44+
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
45+
double x = FPBits(v);
6046
if (isnan(x) || isinf(x))
6147
continue;
6248
ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, __llvm_libc::fabs(x), tolerance);

‎libc/test/src/math/fabsf_test.cpp

Lines changed: 18 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -8,57 +8,41 @@
88

99
#include "include/math.h"
1010
#include "src/math/fabsf.h"
11-
#include "utils/FPUtil/BitPatterns.h"
12-
#include "utils/FPUtil/FloatOperations.h"
13-
#include "utils/FPUtil/FloatProperties.h"
11+
#include "utils/FPUtil/FPBits.h"
12+
#include "utils/FPUtil/TestHelpers.h"
1413
#include "utils/MPFRWrapper/MPFRUtils.h"
1514
#include "utils/UnitTest/Test.h"
1615

17-
using __llvm_libc::fputil::valueAsBits;
18-
using __llvm_libc::fputil::valueFromBits;
16+
using FPBits = __llvm_libc::fputil::FPBits<float>;
1917

20-
using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
21-
using Properties = __llvm_libc::fputil::FloatProperties<float>;
18+
static const float zero = FPBits::zero();
19+
static const float negZero = FPBits::negZero();
20+
static const float nan = FPBits::buildNaN(1);
21+
static const float inf = FPBits::inf();
22+
static const float negInf = FPBits::negInf();
2223

2324
namespace mpfr = __llvm_libc::testing::mpfr;
2425

2526
// Zero tolerance; As in, exact match with MPFR result.
2627
static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
2728
0};
2829

29-
namespace mpfr = __llvm_libc::testing::mpfr;
3030
TEST(FabsfTest, SpecialNumbers) {
31-
EXPECT_EQ(
32-
BitPatterns::aQuietNaN,
33-
valueAsBits(__llvm_libc::fabsf(valueFromBits(BitPatterns::aQuietNaN))));
34-
EXPECT_EQ(BitPatterns::aQuietNaN,
35-
valueAsBits(__llvm_libc::fabsf(
36-
valueFromBits(BitPatterns::aNegativeQuietNaN))));
37-
38-
EXPECT_EQ(BitPatterns::aSignallingNaN,
39-
valueAsBits(__llvm_libc::fabsf(
40-
valueFromBits(BitPatterns::aSignallingNaN))));
41-
EXPECT_EQ(BitPatterns::aSignallingNaN,
42-
valueAsBits(__llvm_libc::fabsf(
43-
valueFromBits(BitPatterns::aNegativeSignallingNaN))));
31+
EXPECT_FP_EQ(nan, __llvm_libc::fabsf(nan));
4432

45-
EXPECT_EQ(BitPatterns::inf,
46-
valueAsBits(__llvm_libc::fabsf(valueFromBits(BitPatterns::inf))));
47-
EXPECT_EQ(BitPatterns::inf, valueAsBits(__llvm_libc::fabsf(
48-
valueFromBits(BitPatterns::negInf))));
33+
EXPECT_FP_EQ(inf, __llvm_libc::fabsf(inf));
34+
EXPECT_FP_EQ(inf, __llvm_libc::fabsf(negInf));
4935

50-
EXPECT_EQ(BitPatterns::zero,
51-
valueAsBits(__llvm_libc::fabsf(valueFromBits(BitPatterns::zero))));
52-
EXPECT_EQ(BitPatterns::zero, valueAsBits(__llvm_libc::fabsf(
53-
valueFromBits(BitPatterns::negZero))));
36+
EXPECT_FP_EQ(zero, __llvm_libc::fabsf(zero));
37+
EXPECT_FP_EQ(zero, __llvm_libc::fabsf(negZero));
5438
}
5539

5640
TEST(FabsfTest, InFloatRange) {
57-
using BitsType = Properties::BitsType;
58-
constexpr BitsType count = 1000000;
59-
constexpr BitsType step = UINT32_MAX / count;
60-
for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
61-
double x = valueFromBits(v);
41+
using UIntType = FPBits::UIntType;
42+
constexpr UIntType count = 1000000;
43+
constexpr UIntType step = UIntType(-1) / count;
44+
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
45+
float x = FPBits(v);
6246
if (isnan(x) || isinf(x))
6347
continue;
6448
ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, __llvm_libc::fabsf(x),

0 commit comments

Comments
 (0)