Skip to content

Commit 5a98752

Browse files
samueltardieusamueltardieu
authored
Rollup merge of rust-lang#143738 - rocurley:float_tests_refactor_2, r=tgross35
Move several float tests to floats/mod.rs This PR moves several tests to `floats/mod.rs`, as discussed in rust-lang#141726. The tests moved are: - `test_num_f*` - `test_infinity` - `test_neg_infinity` - `test_zero` - `test_neg_zero` - `test_one` - `test_is_nan` - `test_is_infinite` - `test_is_finite` - `test_is_normal` - `test_classify` Each test is its own commit, so it may be easiest to review each commit individually. r? tgross35
2 parents a3b442a + 79769f2 commit 5a98752

File tree

6 files changed

+268
-615
lines changed

6 files changed

+268
-615
lines changed

‎library/coretests/tests/floats/f128.rs

Lines changed: 0 additions & 153 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,7 @@
11
// FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
22
#![cfg(target_has_reliable_f128)]
33

4-
use core::ops::{Add, Div, Mul, Sub};
54
use std::f128::consts;
6-
use std::num::FpCategory as Fp;
75

86
use super::{assert_approx_eq, assert_biteq};
97

@@ -38,160 +36,9 @@ const NAN_MASK1: u128 = 0x0000aaaaaaaaaaaaaaaaaaaaaaaaaaaa;
3836
/// Second pattern over the mantissa
3937
const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
4038

41-
#[test]
42-
fn test_num_f128() {
43-
// FIXME(f16_f128): replace with a `test_num` call once the required `fmodl`/`fmodf128`
44-
// function is available on all platforms.
45-
let ten = 10f128;
46-
let two = 2f128;
47-
assert_biteq!(ten.add(two), ten + two);
48-
assert_biteq!(ten.sub(two), ten - two);
49-
assert_biteq!(ten.mul(two), ten * two);
50-
assert_biteq!(ten.div(two), ten / two);
51-
#[cfg(any(miri, target_has_reliable_f128_math))]
52-
assert_biteq!(core::ops::Rem::rem(ten, two), ten % two);
53-
}
54-
5539
// FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
5640
// the intrinsics.
5741

58-
#[test]
59-
fn test_infinity() {
60-
let inf: f128 = f128::INFINITY;
61-
assert!(inf.is_infinite());
62-
assert!(!inf.is_finite());
63-
assert!(inf.is_sign_positive());
64-
assert!(!inf.is_sign_negative());
65-
assert!(!inf.is_nan());
66-
assert!(!inf.is_normal());
67-
assert_eq!(Fp::Infinite, inf.classify());
68-
}
69-
70-
#[test]
71-
fn test_neg_infinity() {
72-
let neg_inf: f128 = f128::NEG_INFINITY;
73-
assert!(neg_inf.is_infinite());
74-
assert!(!neg_inf.is_finite());
75-
assert!(!neg_inf.is_sign_positive());
76-
assert!(neg_inf.is_sign_negative());
77-
assert!(!neg_inf.is_nan());
78-
assert!(!neg_inf.is_normal());
79-
assert_eq!(Fp::Infinite, neg_inf.classify());
80-
}
81-
82-
#[test]
83-
fn test_zero() {
84-
let zero: f128 = 0.0f128;
85-
assert_biteq!(0.0, zero);
86-
assert!(!zero.is_infinite());
87-
assert!(zero.is_finite());
88-
assert!(zero.is_sign_positive());
89-
assert!(!zero.is_sign_negative());
90-
assert!(!zero.is_nan());
91-
assert!(!zero.is_normal());
92-
assert_eq!(Fp::Zero, zero.classify());
93-
}
94-
95-
#[test]
96-
fn test_neg_zero() {
97-
let neg_zero: f128 = -0.0;
98-
assert_eq!(0.0, neg_zero);
99-
assert_biteq!(-0.0, neg_zero);
100-
assert!(!neg_zero.is_infinite());
101-
assert!(neg_zero.is_finite());
102-
assert!(!neg_zero.is_sign_positive());
103-
assert!(neg_zero.is_sign_negative());
104-
assert!(!neg_zero.is_nan());
105-
assert!(!neg_zero.is_normal());
106-
assert_eq!(Fp::Zero, neg_zero.classify());
107-
}
108-
109-
#[test]
110-
fn test_one() {
111-
let one: f128 = 1.0f128;
112-
assert_biteq!(1.0, one);
113-
assert!(!one.is_infinite());
114-
assert!(one.is_finite());
115-
assert!(one.is_sign_positive());
116-
assert!(!one.is_sign_negative());
117-
assert!(!one.is_nan());
118-
assert!(one.is_normal());
119-
assert_eq!(Fp::Normal, one.classify());
120-
}
121-
122-
#[test]
123-
fn test_is_nan() {
124-
let nan: f128 = f128::NAN;
125-
let inf: f128 = f128::INFINITY;
126-
let neg_inf: f128 = f128::NEG_INFINITY;
127-
assert!(nan.is_nan());
128-
assert!(!0.0f128.is_nan());
129-
assert!(!5.3f128.is_nan());
130-
assert!(!(-10.732f128).is_nan());
131-
assert!(!inf.is_nan());
132-
assert!(!neg_inf.is_nan());
133-
}
134-
135-
#[test]
136-
fn test_is_infinite() {
137-
let nan: f128 = f128::NAN;
138-
let inf: f128 = f128::INFINITY;
139-
let neg_inf: f128 = f128::NEG_INFINITY;
140-
assert!(!nan.is_infinite());
141-
assert!(inf.is_infinite());
142-
assert!(neg_inf.is_infinite());
143-
assert!(!0.0f128.is_infinite());
144-
assert!(!42.8f128.is_infinite());
145-
assert!(!(-109.2f128).is_infinite());
146-
}
147-
148-
#[test]
149-
fn test_is_finite() {
150-
let nan: f128 = f128::NAN;
151-
let inf: f128 = f128::INFINITY;
152-
let neg_inf: f128 = f128::NEG_INFINITY;
153-
assert!(!nan.is_finite());
154-
assert!(!inf.is_finite());
155-
assert!(!neg_inf.is_finite());
156-
assert!(0.0f128.is_finite());
157-
assert!(42.8f128.is_finite());
158-
assert!((-109.2f128).is_finite());
159-
}
160-
161-
#[test]
162-
fn test_is_normal() {
163-
let nan: f128 = f128::NAN;
164-
let inf: f128 = f128::INFINITY;
165-
let neg_inf: f128 = f128::NEG_INFINITY;
166-
let zero: f128 = 0.0f128;
167-
let neg_zero: f128 = -0.0;
168-
assert!(!nan.is_normal());
169-
assert!(!inf.is_normal());
170-
assert!(!neg_inf.is_normal());
171-
assert!(!zero.is_normal());
172-
assert!(!neg_zero.is_normal());
173-
assert!(1f128.is_normal());
174-
assert!(1e-4931f128.is_normal());
175-
assert!(!1e-4932f128.is_normal());
176-
}
177-
178-
#[test]
179-
fn test_classify() {
180-
let nan: f128 = f128::NAN;
181-
let inf: f128 = f128::INFINITY;
182-
let neg_inf: f128 = f128::NEG_INFINITY;
183-
let zero: f128 = 0.0f128;
184-
let neg_zero: f128 = -0.0;
185-
assert_eq!(nan.classify(), Fp::Nan);
186-
assert_eq!(inf.classify(), Fp::Infinite);
187-
assert_eq!(neg_inf.classify(), Fp::Infinite);
188-
assert_eq!(zero.classify(), Fp::Zero);
189-
assert_eq!(neg_zero.classify(), Fp::Zero);
190-
assert_eq!(1f128.classify(), Fp::Normal);
191-
assert_eq!(1e-4931f128.classify(), Fp::Normal);
192-
assert_eq!(1e-4932f128.classify(), Fp::Subnormal);
193-
}
194-
19542
#[test]
19643
#[cfg(any(miri, target_has_reliable_f128_math))]
19744
fn test_abs() {

‎library/coretests/tests/floats/f16.rs

Lines changed: 0 additions & 143 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,6 @@
22
#![cfg(target_has_reliable_f16)]
33

44
use std::f16::consts;
5-
use std::num::FpCategory as Fp;
65

76
use super::{assert_approx_eq, assert_biteq};
87

@@ -43,151 +42,9 @@ const NAN_MASK1: u16 = 0x02aa;
4342
/// Second pattern over the mantissa
4443
const NAN_MASK2: u16 = 0x0155;
4544

46-
#[test]
47-
fn test_num_f16() {
48-
super::test_num(10f16, 2f16);
49-
}
50-
5145
// FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
5246
// the intrinsics.
5347

54-
#[test]
55-
fn test_infinity() {
56-
let inf: f16 = f16::INFINITY;
57-
assert!(inf.is_infinite());
58-
assert!(!inf.is_finite());
59-
assert!(inf.is_sign_positive());
60-
assert!(!inf.is_sign_negative());
61-
assert!(!inf.is_nan());
62-
assert!(!inf.is_normal());
63-
assert_eq!(Fp::Infinite, inf.classify());
64-
}
65-
66-
#[test]
67-
fn test_neg_infinity() {
68-
let neg_inf: f16 = f16::NEG_INFINITY;
69-
assert!(neg_inf.is_infinite());
70-
assert!(!neg_inf.is_finite());
71-
assert!(!neg_inf.is_sign_positive());
72-
assert!(neg_inf.is_sign_negative());
73-
assert!(!neg_inf.is_nan());
74-
assert!(!neg_inf.is_normal());
75-
assert_eq!(Fp::Infinite, neg_inf.classify());
76-
}
77-
78-
#[test]
79-
fn test_zero() {
80-
let zero: f16 = 0.0f16;
81-
assert_biteq!(0.0, zero);
82-
assert!(!zero.is_infinite());
83-
assert!(zero.is_finite());
84-
assert!(zero.is_sign_positive());
85-
assert!(!zero.is_sign_negative());
86-
assert!(!zero.is_nan());
87-
assert!(!zero.is_normal());
88-
assert_eq!(Fp::Zero, zero.classify());
89-
}
90-
91-
#[test]
92-
fn test_neg_zero() {
93-
let neg_zero: f16 = -0.0;
94-
assert_eq!(0.0, neg_zero);
95-
assert_biteq!(-0.0, neg_zero);
96-
assert!(!neg_zero.is_infinite());
97-
assert!(neg_zero.is_finite());
98-
assert!(!neg_zero.is_sign_positive());
99-
assert!(neg_zero.is_sign_negative());
100-
assert!(!neg_zero.is_nan());
101-
assert!(!neg_zero.is_normal());
102-
assert_eq!(Fp::Zero, neg_zero.classify());
103-
}
104-
105-
#[test]
106-
fn test_one() {
107-
let one: f16 = 1.0f16;
108-
assert_biteq!(1.0, one);
109-
assert!(!one.is_infinite());
110-
assert!(one.is_finite());
111-
assert!(one.is_sign_positive());
112-
assert!(!one.is_sign_negative());
113-
assert!(!one.is_nan());
114-
assert!(one.is_normal());
115-
assert_eq!(Fp::Normal, one.classify());
116-
}
117-
118-
#[test]
119-
fn test_is_nan() {
120-
let nan: f16 = f16::NAN;
121-
let inf: f16 = f16::INFINITY;
122-
let neg_inf: f16 = f16::NEG_INFINITY;
123-
assert!(nan.is_nan());
124-
assert!(!0.0f16.is_nan());
125-
assert!(!5.3f16.is_nan());
126-
assert!(!(-10.732f16).is_nan());
127-
assert!(!inf.is_nan());
128-
assert!(!neg_inf.is_nan());
129-
}
130-
131-
#[test]
132-
fn test_is_infinite() {
133-
let nan: f16 = f16::NAN;
134-
let inf: f16 = f16::INFINITY;
135-
let neg_inf: f16 = f16::NEG_INFINITY;
136-
assert!(!nan.is_infinite());
137-
assert!(inf.is_infinite());
138-
assert!(neg_inf.is_infinite());
139-
assert!(!0.0f16.is_infinite());
140-
assert!(!42.8f16.is_infinite());
141-
assert!(!(-109.2f16).is_infinite());
142-
}
143-
144-
#[test]
145-
fn test_is_finite() {
146-
let nan: f16 = f16::NAN;
147-
let inf: f16 = f16::INFINITY;
148-
let neg_inf: f16 = f16::NEG_INFINITY;
149-
assert!(!nan.is_finite());
150-
assert!(!inf.is_finite());
151-
assert!(!neg_inf.is_finite());
152-
assert!(0.0f16.is_finite());
153-
assert!(42.8f16.is_finite());
154-
assert!((-109.2f16).is_finite());
155-
}
156-
157-
#[test]
158-
fn test_is_normal() {
159-
let nan: f16 = f16::NAN;
160-
let inf: f16 = f16::INFINITY;
161-
let neg_inf: f16 = f16::NEG_INFINITY;
162-
let zero: f16 = 0.0f16;
163-
let neg_zero: f16 = -0.0;
164-
assert!(!nan.is_normal());
165-
assert!(!inf.is_normal());
166-
assert!(!neg_inf.is_normal());
167-
assert!(!zero.is_normal());
168-
assert!(!neg_zero.is_normal());
169-
assert!(1f16.is_normal());
170-
assert!(1e-4f16.is_normal());
171-
assert!(!1e-5f16.is_normal());
172-
}
173-
174-
#[test]
175-
fn test_classify() {
176-
let nan: f16 = f16::NAN;
177-
let inf: f16 = f16::INFINITY;
178-
let neg_inf: f16 = f16::NEG_INFINITY;
179-
let zero: f16 = 0.0f16;
180-
let neg_zero: f16 = -0.0;
181-
assert_eq!(nan.classify(), Fp::Nan);
182-
assert_eq!(inf.classify(), Fp::Infinite);
183-
assert_eq!(neg_inf.classify(), Fp::Infinite);
184-
assert_eq!(zero.classify(), Fp::Zero);
185-
assert_eq!(neg_zero.classify(), Fp::Zero);
186-
assert_eq!(1f16.classify(), Fp::Normal);
187-
assert_eq!(1e-4f16.classify(), Fp::Normal);
188-
assert_eq!(1e-5f16.classify(), Fp::Subnormal);
189-
}
190-
19148
#[test]
19249
#[cfg(any(miri, target_has_reliable_f16_math))]
19350
fn test_abs() {

0 commit comments

Comments
 (0)