Skip to content

Commit 18d61bf

Browse files
orlpUrgau
orlp
authored and
Urgau
committed
Skip next_up/down tests entirely on x87.
1 parent fbe215a commit 18d61bf

File tree

2 files changed

+114
-112
lines changed

2 files changed

+114
-112
lines changed

‎library/std/src/f32/tests.rs

+55-53
Original file line numberDiff line numberDiff line change
@@ -299,79 +299,81 @@ fn test_is_sign_negative() {
299299
assert!((-f32::NAN).is_sign_negative());
300300
}
301301

302+
macro_rules! assert_f32_biteq {
303+
($left : expr, $right : expr) => {
304+
let l: &f32 = &$left;
305+
let r: &f32 = &$right;
306+
let lb = l.to_bits();
307+
let rb = r.to_bits();
308+
assert_eq!(lb, rb, "float {} ({:#x}) is not equal to {} ({:#x})", *l, lb, *r, rb);
309+
}
310+
}
311+
312+
// Ignore test on x87 floating point, these platforms do not guarantee NaN
313+
// payloads are preserved and flush denormals to zero, failing the tests.
314+
#[cfg(not(target_arch = "x86"))]
302315
#[test]
303316
fn test_next_up() {
304317
let tiny = f32::from_bits(1);
305318
let tiny_up = f32::from_bits(2);
306319
let max_down = f32::from_bits(0x7f7f_fffe);
307320
let largest_subnormal = f32::from_bits(0x007f_ffff);
308321
let smallest_normal = f32::from_bits(0x0080_0000);
322+
assert_f32_biteq!(f32::NEG_INFINITY.next_up(), f32::MIN);
323+
assert_f32_biteq!(f32::MIN.next_up(), -max_down);
324+
assert_f32_biteq!((-1.0 - f32::EPSILON).next_up(), -1.0);
325+
assert_f32_biteq!((-smallest_normal).next_up(), -largest_subnormal);
326+
assert_f32_biteq!((-tiny_up).next_up(), -tiny);
327+
assert_f32_biteq!((-tiny).next_up(), -0.0f32);
328+
assert_f32_biteq!((-0.0f32).next_up(), tiny);
329+
assert_f32_biteq!(0.0f32.next_up(), tiny);
330+
assert_f32_biteq!(tiny.next_up(), tiny_up);
331+
assert_f32_biteq!(largest_subnormal.next_up(), smallest_normal);
332+
assert_f32_biteq!(1.0f32.next_up(), 1.0 + f32::EPSILON);
333+
assert_f32_biteq!(f32::MAX.next_up(), f32::INFINITY);
334+
assert_f32_biteq!(f32::INFINITY.next_up(), f32::INFINITY);
309335

310336
// Check that NaNs roundtrip.
311-
// Ignore test on x87 floating point, the code is still correct but these
312-
// platforms do not guarantee NaN payloads are preserved, which caused these
313-
// tests to fail.
314-
#[cfg(not(all(target_arch = "x86", not(target_feature = "fxsr"))))]
315-
{
316-
let nan0 = f32::NAN;
317-
let nan1 = f32::from_bits(f32::NAN.to_bits() ^ 0x002a_aaaa);
318-
let nan2 = f32::from_bits(f32::NAN.to_bits() ^ 0x0055_5555);
319-
assert_eq!(nan0.next_up().to_bits(), nan0.to_bits());
320-
assert_eq!(nan1.next_up().to_bits(), nan1.to_bits());
321-
assert_eq!(nan2.next_up().to_bits(), nan2.to_bits());
322-
}
323-
324-
assert_eq!(f32::NEG_INFINITY.next_up(), f32::MIN);
325-
assert_eq!(f32::MIN.next_up(), -max_down);
326-
assert_eq!((-1.0 - f32::EPSILON).next_up(), -1.0);
327-
assert_eq!((-smallest_normal).next_up(), -largest_subnormal);
328-
assert_eq!((-tiny_up).next_up(), -tiny);
329-
assert_eq!((-tiny).next_up().to_bits(), (-0.0f32).to_bits());
330-
assert_eq!((-0.0f32).next_up(), tiny);
331-
assert_eq!(0.0f32.next_up(), tiny);
332-
assert_eq!(tiny.next_up(), tiny_up);
333-
assert_eq!(largest_subnormal.next_up(), smallest_normal);
334-
assert_eq!(1.0f32.next_up(), 1.0 + f32::EPSILON);
335-
assert_eq!(f32::MAX.next_up(), f32::INFINITY);
336-
assert_eq!(f32::INFINITY.next_up(), f32::INFINITY);
337+
let nan0 = f32::NAN;
338+
let nan1 = f32::from_bits(f32::NAN.to_bits() ^ 0x002a_aaaa);
339+
let nan2 = f32::from_bits(f32::NAN.to_bits() ^ 0x0055_5555);
340+
assert_f32_biteq!(nan0.next_up(), nan0);
341+
assert_f32_biteq!(nan1.next_up(), nan1);
342+
assert_f32_biteq!(nan2.next_up(), nan2);
337343
}
338344

345+
// Ignore test on x87 floating point, these platforms do not guarantee NaN
346+
// payloads are preserved and flush denormals to zero, failing the tests.
347+
#[cfg(not(target_arch = "x86"))]
339348
#[test]
340349
fn test_next_down() {
341350
let tiny = f32::from_bits(1);
342351
let tiny_up = f32::from_bits(2);
343352
let max_down = f32::from_bits(0x7f7f_fffe);
344353
let largest_subnormal = f32::from_bits(0x007f_ffff);
345354
let smallest_normal = f32::from_bits(0x0080_0000);
355+
assert_f32_biteq!(f32::NEG_INFINITY.next_down(), f32::NEG_INFINITY);
356+
assert_f32_biteq!(f32::MIN.next_down(), f32::NEG_INFINITY);
357+
assert_f32_biteq!((-max_down).next_down(), f32::MIN);
358+
assert_f32_biteq!((-1.0f32).next_down(), -1.0 - f32::EPSILON);
359+
assert_f32_biteq!((-largest_subnormal).next_down(), -smallest_normal);
360+
assert_f32_biteq!((-tiny).next_down(), -tiny_up);
361+
assert_f32_biteq!((-0.0f32).next_down(), -tiny);
362+
assert_f32_biteq!((0.0f32).next_down(), -tiny);
363+
assert_f32_biteq!(tiny.next_down(), 0.0f32);
364+
assert_f32_biteq!(tiny_up.next_down(), tiny);
365+
assert_f32_biteq!(smallest_normal.next_down(), largest_subnormal);
366+
assert_f32_biteq!((1.0 + f32::EPSILON).next_down(), 1.0f32);
367+
assert_f32_biteq!(f32::MAX.next_down(), max_down);
368+
assert_f32_biteq!(f32::INFINITY.next_down(), f32::MAX);
346369

347370
// Check that NaNs roundtrip.
348-
// Ignore test on x87 floating point, the code is still correct but these
349-
// platforms do not guarantee NaN payloads are preserved, which caused these
350-
// tests to fail.
351-
#[cfg(not(all(target_arch = "x86", not(target_feature = "fxsr"))))]
352-
{
353-
let nan0 = f32::NAN;
354-
let nan1 = f32::from_bits(f32::NAN.to_bits() ^ 0x002a_aaaa);
355-
let nan2 = f32::from_bits(f32::NAN.to_bits() ^ 0x0055_5555);
356-
assert_eq!(nan0.next_down().to_bits(), nan0.to_bits());
357-
assert_eq!(nan1.next_down().to_bits(), nan1.to_bits());
358-
assert_eq!(nan2.next_down().to_bits(), nan2.to_bits());
359-
}
360-
361-
assert_eq!(f32::NEG_INFINITY.next_down(), f32::NEG_INFINITY);
362-
assert_eq!(f32::MIN.next_down(), f32::NEG_INFINITY);
363-
assert_eq!((-max_down).next_down(), f32::MIN);
364-
assert_eq!((-1.0f32).next_down(), -1.0 - f32::EPSILON);
365-
assert_eq!((-largest_subnormal).next_down(), -smallest_normal);
366-
assert_eq!((-tiny).next_down(), -tiny_up);
367-
assert_eq!((-0.0f32).next_down(), -tiny);
368-
assert_eq!((0.0f32).next_down(), -tiny);
369-
assert_eq!(tiny.next_down().to_bits(), 0.0f32.to_bits());
370-
assert_eq!(tiny_up.next_down(), tiny);
371-
assert_eq!(smallest_normal.next_down(), largest_subnormal);
372-
assert_eq!((1.0 + f32::EPSILON).next_down(), 1.0f32);
373-
assert_eq!(f32::MAX.next_down(), max_down);
374-
assert_eq!(f32::INFINITY.next_down(), f32::MAX);
371+
let nan0 = f32::NAN;
372+
let nan1 = f32::from_bits(f32::NAN.to_bits() ^ 0x002a_aaaa);
373+
let nan2 = f32::from_bits(f32::NAN.to_bits() ^ 0x0055_5555);
374+
assert_f32_biteq!(nan0.next_down(), nan0);
375+
assert_f32_biteq!(nan1.next_down(), nan1);
376+
assert_f32_biteq!(nan2.next_down(), nan2);
375377
}
376378

377379
#[test]

‎library/std/src/f64/tests.rs

+59-59
Original file line numberDiff line numberDiff line change
@@ -289,79 +289,79 @@ fn test_is_sign_negative() {
289289
assert!((-f64::NAN).is_sign_negative());
290290
}
291291

292+
macro_rules! assert_f64_biteq {
293+
($left : expr, $right : expr) => {
294+
let l: &f64 = &$left;
295+
let r: &f64 = &$right;
296+
let lb = l.to_bits();
297+
let rb = r.to_bits();
298+
assert_eq!(lb, rb, "float {} ({:#x}) is not equal to {} ({:#x})", *l, lb, *r, rb);
299+
}
300+
}
301+
302+
// Ignore test on x87 floating point, these platforms do not guarantee NaN
303+
// payloads are preserved and flush denormals to zero, failing the tests.
304+
#[cfg(not(target_arch = "x86"))]
292305
#[test]
293306
fn test_next_up() {
294307
let tiny = f64::from_bits(1);
295308
let tiny_up = f64::from_bits(2);
296309
let max_down = f64::from_bits(0x7fef_ffff_ffff_fffe);
297310
let largest_subnormal = f64::from_bits(0x000f_ffff_ffff_ffff);
298311
let smallest_normal = f64::from_bits(0x0010_0000_0000_0000);
299-
300-
// Check that NaNs roundtrip.
301-
// Ignore test on x87 floating point, the code is still correct but these
302-
// platforms do not guarantee NaN payloads are preserved, which caused these
303-
// tests to fail.
304-
#[cfg(not(all(target_arch = "x86", not(target_feature = "fxsr"))))]
305-
{
306-
let nan0 = f64::NAN;
307-
let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa);
308-
let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555);
309-
assert_eq!(nan0.next_up().to_bits(), nan0.to_bits());
310-
assert_eq!(nan1.next_up().to_bits(), nan1.to_bits());
311-
assert_eq!(nan2.next_up().to_bits(), nan2.to_bits());
312-
}
313-
314-
assert_eq!(f64::NEG_INFINITY.next_up(), f64::MIN);
315-
assert_eq!(f64::MIN.next_up(), -max_down);
316-
assert_eq!((-1.0 - f64::EPSILON).next_up(), -1.0);
317-
assert_eq!((-smallest_normal).next_up(), -largest_subnormal);
318-
assert_eq!((-tiny_up).next_up(), -tiny);
319-
assert_eq!((-tiny).next_up().to_bits(), (-0.0f64).to_bits());
320-
assert_eq!((-0.0f64).next_up(), tiny);
321-
assert_eq!(0.0f64.next_up(), tiny);
322-
assert_eq!(tiny.next_up(), tiny_up);
323-
assert_eq!(largest_subnormal.next_up(), smallest_normal);
324-
assert_eq!(1.0f64.next_up(), 1.0 + f64::EPSILON);
325-
assert_eq!(f64::MAX.next_up(), f64::INFINITY);
326-
assert_eq!(f64::INFINITY.next_up(), f64::INFINITY);
327-
}
328-
312+
assert_f64_biteq!(f64::NEG_INFINITY.next_up(), f64::MIN);
313+
assert_f64_biteq!(f64::MIN.next_up(), -max_down);
314+
assert_f64_biteq!((-1.0 - f64::EPSILON).next_up(), -1.0);
315+
assert_f64_biteq!((-smallest_normal).next_up(), -largest_subnormal);
316+
assert_f64_biteq!((-tiny_up).next_up(), -tiny);
317+
assert_f64_biteq!((-tiny).next_up(), -0.0f64);
318+
assert_f64_biteq!((-0.0f64).next_up(), tiny);
319+
assert_f64_biteq!(0.0f64.next_up(), tiny);
320+
assert_f64_biteq!(tiny.next_up(), tiny_up);
321+
assert_f64_biteq!(largest_subnormal.next_up(), smallest_normal);
322+
assert_f64_biteq!(1.0f64.next_up(), 1.0 + f64::EPSILON);
323+
assert_f64_biteq!(f64::MAX.next_up(), f64::INFINITY);
324+
assert_f64_biteq!(f64::INFINITY.next_up(), f64::INFINITY);
325+
326+
let nan0 = f64::NAN;
327+
let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa);
328+
let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555);
329+
assert_f64_biteq!(nan0.next_up(), nan0);
330+
assert_f64_biteq!(nan1.next_up(), nan1);
331+
assert_f64_biteq!(nan2.next_up(), nan2);
332+
}
333+
334+
// Ignore test on x87 floating point, these platforms do not guarantee NaN
335+
// payloads are preserved and flush denormals to zero, failing the tests.
336+
#[cfg(not(target_arch = "x86"))]
329337
#[test]
330338
fn test_next_down() {
331339
let tiny = f64::from_bits(1);
332340
let tiny_up = f64::from_bits(2);
333341
let max_down = f64::from_bits(0x7fef_ffff_ffff_fffe);
334342
let largest_subnormal = f64::from_bits(0x000f_ffff_ffff_ffff);
335343
let smallest_normal = f64::from_bits(0x0010_0000_0000_0000);
336-
337-
// Check that NaNs roundtrip.
338-
// Ignore test on x87 floating point, the code is still correct but these
339-
// platforms do not guarantee NaN payloads are preserved, which caused these
340-
// tests to fail.
341-
#[cfg(not(all(target_arch = "x86", not(target_feature = "fxsr"))))]
342-
{
343-
let nan0 = f64::NAN;
344-
let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa);
345-
let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555);
346-
assert_eq!(nan0.next_down().to_bits(), nan0.to_bits());
347-
assert_eq!(nan1.next_down().to_bits(), nan1.to_bits());
348-
assert_eq!(nan2.next_down().to_bits(), nan2.to_bits());
349-
}
350-
351-
assert_eq!(f64::NEG_INFINITY.next_down(), f64::NEG_INFINITY);
352-
assert_eq!(f64::MIN.next_down(), f64::NEG_INFINITY);
353-
assert_eq!((-max_down).next_down(), f64::MIN);
354-
assert_eq!((-1.0f64).next_down(), -1.0 - f64::EPSILON);
355-
assert_eq!((-largest_subnormal).next_down(), -smallest_normal);
356-
assert_eq!((-tiny).next_down(), -tiny_up);
357-
assert_eq!((-0.0f64).next_down(), -tiny);
358-
assert_eq!((0.0f64).next_down(), -tiny);
359-
assert_eq!(tiny.next_down().to_bits(), 0.0f64.to_bits());
360-
assert_eq!(tiny_up.next_down(), tiny);
361-
assert_eq!(smallest_normal.next_down(), largest_subnormal);
362-
assert_eq!((1.0 + f64::EPSILON).next_down(), 1.0f64);
363-
assert_eq!(f64::MAX.next_down(), max_down);
364-
assert_eq!(f64::INFINITY.next_down(), f64::MAX);
344+
assert_f64_biteq!(f64::NEG_INFINITY.next_down(), f64::NEG_INFINITY);
345+
assert_f64_biteq!(f64::MIN.next_down(), f64::NEG_INFINITY);
346+
assert_f64_biteq!((-max_down).next_down(), f64::MIN);
347+
assert_f64_biteq!((-1.0f64).next_down(), -1.0 - f64::EPSILON);
348+
assert_f64_biteq!((-largest_subnormal).next_down(), -smallest_normal);
349+
assert_f64_biteq!((-tiny).next_down(), -tiny_up);
350+
assert_f64_biteq!((-0.0f64).next_down(), -tiny);
351+
assert_f64_biteq!((0.0f64).next_down(), -tiny);
352+
assert_f64_biteq!(tiny.next_down(), 0.0f64);
353+
assert_f64_biteq!(tiny_up.next_down(), tiny);
354+
assert_f64_biteq!(smallest_normal.next_down(), largest_subnormal);
355+
assert_f64_biteq!((1.0 + f64::EPSILON).next_down(), 1.0f64);
356+
assert_f64_biteq!(f64::MAX.next_down(), max_down);
357+
assert_f64_biteq!(f64::INFINITY.next_down(), f64::MAX);
358+
359+
let nan0 = f64::NAN;
360+
let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa);
361+
let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555);
362+
assert_f64_biteq!(nan0.next_down(), nan0);
363+
assert_f64_biteq!(nan1.next_down(), nan1);
364+
assert_f64_biteq!(nan2.next_down(), nan2);
365365
}
366366

367367
#[test]

0 commit comments

Comments
 (0)