Skip to content

Commit 6a79b27

Browse files
tgross35tgross35
committed
float: Use a shared assert_biteq! macro for tests
Clean up the separate `assert_f{16,32,64,128}` macros with a single `assert_biteq!` macro that works for all float widths.
1 parent 45f256d commit 6a79b27

File tree

5 files changed

+163
-176
lines changed

5 files changed

+163
-176
lines changed

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

Lines changed: 33 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -39,17 +39,6 @@ const NAN_MASK1: u128 = 0x0000aaaaaaaaaaaaaaaaaaaaaaaaaaaa;
3939
/// Second pattern over the mantissa
4040
const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
4141

42-
/// Compare by representation
43-
#[allow(unused_macros)]
44-
macro_rules! assert_f128_biteq {
45-
($a:expr, $b:expr) => {
46-
let (l, r): (&f128, &f128) = (&$a, &$b);
47-
let lb = l.to_bits();
48-
let rb = r.to_bits();
49-
assert_eq!(lb, rb, "float {l:?} is not bitequal to {r:?}.\na: {lb:#034x}\nb: {rb:#034x}");
50-
};
51-
}
52-
5342
#[test]
5443
fn test_num_f128() {
5544
// FIXME(f16_f128): replace with a `test_num` call once the required `fmodl`/`fmodf128`
@@ -401,27 +390,27 @@ fn test_next_up() {
401390
let max_down = f128::from_bits(MAX_DOWN_BITS);
402391
let largest_subnormal = f128::from_bits(LARGEST_SUBNORMAL_BITS);
403392
let smallest_normal = f128::from_bits(SMALLEST_NORMAL_BITS);
404-
assert_f128_biteq!(f128::NEG_INFINITY.next_up(), f128::MIN);
405-
assert_f128_biteq!(f128::MIN.next_up(), -max_down);
406-
assert_f128_biteq!((-1.0 - f128::EPSILON).next_up(), -1.0);
407-
assert_f128_biteq!((-smallest_normal).next_up(), -largest_subnormal);
408-
assert_f128_biteq!((-tiny_up).next_up(), -tiny);
409-
assert_f128_biteq!((-tiny).next_up(), -0.0f128);
410-
assert_f128_biteq!((-0.0f128).next_up(), tiny);
411-
assert_f128_biteq!(0.0f128.next_up(), tiny);
412-
assert_f128_biteq!(tiny.next_up(), tiny_up);
413-
assert_f128_biteq!(largest_subnormal.next_up(), smallest_normal);
414-
assert_f128_biteq!(1.0f128.next_up(), 1.0 + f128::EPSILON);
415-
assert_f128_biteq!(f128::MAX.next_up(), f128::INFINITY);
416-
assert_f128_biteq!(f128::INFINITY.next_up(), f128::INFINITY);
393+
assert_biteq!(f128::NEG_INFINITY.next_up(), f128::MIN);
394+
assert_biteq!(f128::MIN.next_up(), -max_down);
395+
assert_biteq!((-1.0 - f128::EPSILON).next_up(), -1.0f128);
396+
assert_biteq!((-smallest_normal).next_up(), -largest_subnormal);
397+
assert_biteq!((-tiny_up).next_up(), -tiny);
398+
assert_biteq!((-tiny).next_up(), -0.0f128);
399+
assert_biteq!((-0.0f128).next_up(), tiny);
400+
assert_biteq!(0.0f128.next_up(), tiny);
401+
assert_biteq!(tiny.next_up(), tiny_up);
402+
assert_biteq!(largest_subnormal.next_up(), smallest_normal);
403+
assert_biteq!(1.0f128.next_up(), 1.0 + f128::EPSILON);
404+
assert_biteq!(f128::MAX.next_up(), f128::INFINITY);
405+
assert_biteq!(f128::INFINITY.next_up(), f128::INFINITY);
417406

418407
// Check that NaNs roundtrip.
419408
let nan0 = f128::NAN;
420409
let nan1 = f128::from_bits(f128::NAN.to_bits() ^ 0x002a_aaaa);
421410
let nan2 = f128::from_bits(f128::NAN.to_bits() ^ 0x0055_5555);
422-
assert_f128_biteq!(nan0.next_up(), nan0);
423-
assert_f128_biteq!(nan1.next_up(), nan1);
424-
assert_f128_biteq!(nan2.next_up(), nan2);
411+
assert_biteq!(nan0.next_up(), nan0);
412+
assert_biteq!(nan1.next_up(), nan1);
413+
assert_biteq!(nan2.next_up(), nan2);
425414
}
426415

427416
#[test]
@@ -431,28 +420,28 @@ fn test_next_down() {
431420
let max_down = f128::from_bits(MAX_DOWN_BITS);
432421
let largest_subnormal = f128::from_bits(LARGEST_SUBNORMAL_BITS);
433422
let smallest_normal = f128::from_bits(SMALLEST_NORMAL_BITS);
434-
assert_f128_biteq!(f128::NEG_INFINITY.next_down(), f128::NEG_INFINITY);
435-
assert_f128_biteq!(f128::MIN.next_down(), f128::NEG_INFINITY);
436-
assert_f128_biteq!((-max_down).next_down(), f128::MIN);
437-
assert_f128_biteq!((-1.0f128).next_down(), -1.0 - f128::EPSILON);
438-
assert_f128_biteq!((-largest_subnormal).next_down(), -smallest_normal);
439-
assert_f128_biteq!((-tiny).next_down(), -tiny_up);
440-
assert_f128_biteq!((-0.0f128).next_down(), -tiny);
441-
assert_f128_biteq!((0.0f128).next_down(), -tiny);
442-
assert_f128_biteq!(tiny.next_down(), 0.0f128);
443-
assert_f128_biteq!(tiny_up.next_down(), tiny);
444-
assert_f128_biteq!(smallest_normal.next_down(), largest_subnormal);
445-
assert_f128_biteq!((1.0 + f128::EPSILON).next_down(), 1.0f128);
446-
assert_f128_biteq!(f128::MAX.next_down(), max_down);
447-
assert_f128_biteq!(f128::INFINITY.next_down(), f128::MAX);
423+
assert_biteq!(f128::NEG_INFINITY.next_down(), f128::NEG_INFINITY);
424+
assert_biteq!(f128::MIN.next_down(), f128::NEG_INFINITY);
425+
assert_biteq!((-max_down).next_down(), f128::MIN);
426+
assert_biteq!((-1.0f128).next_down(), -1.0 - f128::EPSILON);
427+
assert_biteq!((-largest_subnormal).next_down(), -smallest_normal);
428+
assert_biteq!((-tiny).next_down(), -tiny_up);
429+
assert_biteq!((-0.0f128).next_down(), -tiny);
430+
assert_biteq!((0.0f128).next_down(), -tiny);
431+
assert_biteq!(tiny.next_down(), 0.0f128);
432+
assert_biteq!(tiny_up.next_down(), tiny);
433+
assert_biteq!(smallest_normal.next_down(), largest_subnormal);
434+
assert_biteq!((1.0 + f128::EPSILON).next_down(), 1.0f128);
435+
assert_biteq!(f128::MAX.next_down(), max_down);
436+
assert_biteq!(f128::INFINITY.next_down(), f128::MAX);
448437

449438
// Check that NaNs roundtrip.
450439
let nan0 = f128::NAN;
451440
let nan1 = f128::from_bits(f128::NAN.to_bits() ^ 0x002a_aaaa);
452441
let nan2 = f128::from_bits(f128::NAN.to_bits() ^ 0x0055_5555);
453-
assert_f128_biteq!(nan0.next_down(), nan0);
454-
assert_f128_biteq!(nan1.next_down(), nan1);
455-
assert_f128_biteq!(nan2.next_down(), nan2);
442+
assert_biteq!(nan0.next_down(), nan0);
443+
assert_biteq!(nan1.next_down(), nan1);
444+
assert_biteq!(nan2.next_down(), nan2);
456445
}
457446

458447
#[test]

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

Lines changed: 33 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -41,17 +41,6 @@ const NAN_MASK1: u16 = 0x02aa;
4141
/// Second pattern over the mantissa
4242
const NAN_MASK2: u16 = 0x0155;
4343

44-
/// Compare by representation
45-
#[allow(unused_macros)]
46-
macro_rules! assert_f16_biteq {
47-
($a:expr, $b:expr) => {
48-
let (l, r): (&f16, &f16) = (&$a, &$b);
49-
let lb = l.to_bits();
50-
let rb = r.to_bits();
51-
assert_eq!(lb, rb, "float {l:?} ({lb:#04x}) is not bitequal to {r:?} ({rb:#04x})");
52-
};
53-
}
54-
5544
#[test]
5645
fn test_num_f16() {
5746
super::test_num(10f16, 2f16);
@@ -387,27 +376,27 @@ fn test_next_up() {
387376
let max_down = f16::from_bits(MAX_DOWN_BITS);
388377
let largest_subnormal = f16::from_bits(LARGEST_SUBNORMAL_BITS);
389378
let smallest_normal = f16::from_bits(SMALLEST_NORMAL_BITS);
390-
assert_f16_biteq!(f16::NEG_INFINITY.next_up(), f16::MIN);
391-
assert_f16_biteq!(f16::MIN.next_up(), -max_down);
392-
assert_f16_biteq!((-1.0 - f16::EPSILON).next_up(), -1.0);
393-
assert_f16_biteq!((-smallest_normal).next_up(), -largest_subnormal);
394-
assert_f16_biteq!((-tiny_up).next_up(), -tiny);
395-
assert_f16_biteq!((-tiny).next_up(), -0.0f16);
396-
assert_f16_biteq!((-0.0f16).next_up(), tiny);
397-
assert_f16_biteq!(0.0f16.next_up(), tiny);
398-
assert_f16_biteq!(tiny.next_up(), tiny_up);
399-
assert_f16_biteq!(largest_subnormal.next_up(), smallest_normal);
400-
assert_f16_biteq!(1.0f16.next_up(), 1.0 + f16::EPSILON);
401-
assert_f16_biteq!(f16::MAX.next_up(), f16::INFINITY);
402-
assert_f16_biteq!(f16::INFINITY.next_up(), f16::INFINITY);
379+
assert_biteq!(f16::NEG_INFINITY.next_up(), f16::MIN);
380+
assert_biteq!(f16::MIN.next_up(), -max_down);
381+
assert_biteq!((-1.0 - f16::EPSILON).next_up(), -1.0f16);
382+
assert_biteq!((-smallest_normal).next_up(), -largest_subnormal);
383+
assert_biteq!((-tiny_up).next_up(), -tiny);
384+
assert_biteq!((-tiny).next_up(), -0.0f16);
385+
assert_biteq!((-0.0f16).next_up(), tiny);
386+
assert_biteq!(0.0f16.next_up(), tiny);
387+
assert_biteq!(tiny.next_up(), tiny_up);
388+
assert_biteq!(largest_subnormal.next_up(), smallest_normal);
389+
assert_biteq!(1.0f16.next_up(), 1.0 + f16::EPSILON);
390+
assert_biteq!(f16::MAX.next_up(), f16::INFINITY);
391+
assert_biteq!(f16::INFINITY.next_up(), f16::INFINITY);
403392

404393
// Check that NaNs roundtrip.
405394
let nan0 = f16::NAN;
406395
let nan1 = f16::from_bits(f16::NAN.to_bits() ^ NAN_MASK1);
407396
let nan2 = f16::from_bits(f16::NAN.to_bits() ^ NAN_MASK2);
408-
assert_f16_biteq!(nan0.next_up(), nan0);
409-
assert_f16_biteq!(nan1.next_up(), nan1);
410-
assert_f16_biteq!(nan2.next_up(), nan2);
397+
assert_biteq!(nan0.next_up(), nan0);
398+
assert_biteq!(nan1.next_up(), nan1);
399+
assert_biteq!(nan2.next_up(), nan2);
411400
}
412401

413402
#[test]
@@ -417,28 +406,28 @@ fn test_next_down() {
417406
let max_down = f16::from_bits(MAX_DOWN_BITS);
418407
let largest_subnormal = f16::from_bits(LARGEST_SUBNORMAL_BITS);
419408
let smallest_normal = f16::from_bits(SMALLEST_NORMAL_BITS);
420-
assert_f16_biteq!(f16::NEG_INFINITY.next_down(), f16::NEG_INFINITY);
421-
assert_f16_biteq!(f16::MIN.next_down(), f16::NEG_INFINITY);
422-
assert_f16_biteq!((-max_down).next_down(), f16::MIN);
423-
assert_f16_biteq!((-1.0f16).next_down(), -1.0 - f16::EPSILON);
424-
assert_f16_biteq!((-largest_subnormal).next_down(), -smallest_normal);
425-
assert_f16_biteq!((-tiny).next_down(), -tiny_up);
426-
assert_f16_biteq!((-0.0f16).next_down(), -tiny);
427-
assert_f16_biteq!((0.0f16).next_down(), -tiny);
428-
assert_f16_biteq!(tiny.next_down(), 0.0f16);
429-
assert_f16_biteq!(tiny_up.next_down(), tiny);
430-
assert_f16_biteq!(smallest_normal.next_down(), largest_subnormal);
431-
assert_f16_biteq!((1.0 + f16::EPSILON).next_down(), 1.0f16);
432-
assert_f16_biteq!(f16::MAX.next_down(), max_down);
433-
assert_f16_biteq!(f16::INFINITY.next_down(), f16::MAX);
409+
assert_biteq!(f16::NEG_INFINITY.next_down(), f16::NEG_INFINITY);
410+
assert_biteq!(f16::MIN.next_down(), f16::NEG_INFINITY);
411+
assert_biteq!((-max_down).next_down(), f16::MIN);
412+
assert_biteq!((-1.0f16).next_down(), -1.0 - f16::EPSILON);
413+
assert_biteq!((-largest_subnormal).next_down(), -smallest_normal);
414+
assert_biteq!((-tiny).next_down(), -tiny_up);
415+
assert_biteq!((-0.0f16).next_down(), -tiny);
416+
assert_biteq!((0.0f16).next_down(), -tiny);
417+
assert_biteq!(tiny.next_down(), 0.0f16);
418+
assert_biteq!(tiny_up.next_down(), tiny);
419+
assert_biteq!(smallest_normal.next_down(), largest_subnormal);
420+
assert_biteq!((1.0 + f16::EPSILON).next_down(), 1.0f16);
421+
assert_biteq!(f16::MAX.next_down(), max_down);
422+
assert_biteq!(f16::INFINITY.next_down(), f16::MAX);
434423

435424
// Check that NaNs roundtrip.
436425
let nan0 = f16::NAN;
437426
let nan1 = f16::from_bits(f16::NAN.to_bits() ^ NAN_MASK1);
438427
let nan2 = f16::from_bits(f16::NAN.to_bits() ^ NAN_MASK2);
439-
assert_f16_biteq!(nan0.next_down(), nan0);
440-
assert_f16_biteq!(nan1.next_down(), nan1);
441-
assert_f16_biteq!(nan2.next_down(), nan2);
428+
assert_biteq!(nan0.next_down(), nan0);
429+
assert_biteq!(nan1.next_down(), nan1);
430+
assert_biteq!(nan2.next_down(), nan2);
442431
}
443432

444433
#[test]

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

Lines changed: 33 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -23,17 +23,6 @@ const NAN_MASK1: u32 = 0x002a_aaaa;
2323
/// Second pattern over the mantissa
2424
const NAN_MASK2: u32 = 0x0055_5555;
2525

26-
#[allow(unused_macros)]
27-
macro_rules! assert_f32_biteq {
28-
($left : expr, $right : expr) => {
29-
let l: &f32 = &$left;
30-
let r: &f32 = &$right;
31-
let lb = l.to_bits();
32-
let rb = r.to_bits();
33-
assert_eq!(lb, rb, "float {l} ({lb:#010x}) is not bitequal to {r} ({rb:#010x})");
34-
};
35-
}
36-
3726
#[test]
3827
fn test_num_f32() {
3928
super::test_num(10f32, 2f32);
@@ -356,27 +345,27 @@ fn test_next_up() {
356345
let max_down = f32::from_bits(MAX_DOWN_BITS);
357346
let largest_subnormal = f32::from_bits(LARGEST_SUBNORMAL_BITS);
358347
let smallest_normal = f32::from_bits(SMALLEST_NORMAL_BITS);
359-
assert_f32_biteq!(f32::NEG_INFINITY.next_up(), f32::MIN);
360-
assert_f32_biteq!(f32::MIN.next_up(), -max_down);
361-
assert_f32_biteq!((-1.0 - f32::EPSILON).next_up(), -1.0);
362-
assert_f32_biteq!((-smallest_normal).next_up(), -largest_subnormal);
363-
assert_f32_biteq!((-tiny_up).next_up(), -tiny);
364-
assert_f32_biteq!((-tiny).next_up(), -0.0f32);
365-
assert_f32_biteq!((-0.0f32).next_up(), tiny);
366-
assert_f32_biteq!(0.0f32.next_up(), tiny);
367-
assert_f32_biteq!(tiny.next_up(), tiny_up);
368-
assert_f32_biteq!(largest_subnormal.next_up(), smallest_normal);
369-
assert_f32_biteq!(1.0f32.next_up(), 1.0 + f32::EPSILON);
370-
assert_f32_biteq!(f32::MAX.next_up(), f32::INFINITY);
371-
assert_f32_biteq!(f32::INFINITY.next_up(), f32::INFINITY);
348+
assert_biteq!(f32::NEG_INFINITY.next_up(), f32::MIN);
349+
assert_biteq!(f32::MIN.next_up(), -max_down);
350+
assert_biteq!((-1.0f32 - f32::EPSILON).next_up(), -1.0f32);
351+
assert_biteq!((-smallest_normal).next_up(), -largest_subnormal);
352+
assert_biteq!((-tiny_up).next_up(), -tiny);
353+
assert_biteq!((-tiny).next_up(), -0.0f32);
354+
assert_biteq!((-0.0f32).next_up(), tiny);
355+
assert_biteq!(0.0f32.next_up(), tiny);
356+
assert_biteq!(tiny.next_up(), tiny_up);
357+
assert_biteq!(largest_subnormal.next_up(), smallest_normal);
358+
assert_biteq!(1.0f32.next_up(), 1.0 + f32::EPSILON);
359+
assert_biteq!(f32::MAX.next_up(), f32::INFINITY);
360+
assert_biteq!(f32::INFINITY.next_up(), f32::INFINITY);
372361

373362
// Check that NaNs roundtrip.
374363
let nan0 = f32::NAN;
375364
let nan1 = f32::from_bits(f32::NAN.to_bits() ^ NAN_MASK1);
376365
let nan2 = f32::from_bits(f32::NAN.to_bits() ^ NAN_MASK2);
377-
assert_f32_biteq!(nan0.next_up(), nan0);
378-
assert_f32_biteq!(nan1.next_up(), nan1);
379-
assert_f32_biteq!(nan2.next_up(), nan2);
366+
assert_biteq!(nan0.next_up(), nan0);
367+
assert_biteq!(nan1.next_up(), nan1);
368+
assert_biteq!(nan2.next_up(), nan2);
380369
}
381370

382371
#[test]
@@ -386,28 +375,28 @@ fn test_next_down() {
386375
let max_down = f32::from_bits(MAX_DOWN_BITS);
387376
let largest_subnormal = f32::from_bits(LARGEST_SUBNORMAL_BITS);
388377
let smallest_normal = f32::from_bits(SMALLEST_NORMAL_BITS);
389-
assert_f32_biteq!(f32::NEG_INFINITY.next_down(), f32::NEG_INFINITY);
390-
assert_f32_biteq!(f32::MIN.next_down(), f32::NEG_INFINITY);
391-
assert_f32_biteq!((-max_down).next_down(), f32::MIN);
392-
assert_f32_biteq!((-1.0f32).next_down(), -1.0 - f32::EPSILON);
393-
assert_f32_biteq!((-largest_subnormal).next_down(), -smallest_normal);
394-
assert_f32_biteq!((-tiny).next_down(), -tiny_up);
395-
assert_f32_biteq!((-0.0f32).next_down(), -tiny);
396-
assert_f32_biteq!((0.0f32).next_down(), -tiny);
397-
assert_f32_biteq!(tiny.next_down(), 0.0f32);
398-
assert_f32_biteq!(tiny_up.next_down(), tiny);
399-
assert_f32_biteq!(smallest_normal.next_down(), largest_subnormal);
400-
assert_f32_biteq!((1.0 + f32::EPSILON).next_down(), 1.0f32);
401-
assert_f32_biteq!(f32::MAX.next_down(), max_down);
402-
assert_f32_biteq!(f32::INFINITY.next_down(), f32::MAX);
378+
assert_biteq!(f32::NEG_INFINITY.next_down(), f32::NEG_INFINITY);
379+
assert_biteq!(f32::MIN.next_down(), f32::NEG_INFINITY);
380+
assert_biteq!((-max_down).next_down(), f32::MIN);
381+
assert_biteq!((-1.0f32).next_down(), -1.0 - f32::EPSILON);
382+
assert_biteq!((-largest_subnormal).next_down(), -smallest_normal);
383+
assert_biteq!((-tiny).next_down(), -tiny_up);
384+
assert_biteq!((-0.0f32).next_down(), -tiny);
385+
assert_biteq!((0.0f32).next_down(), -tiny);
386+
assert_biteq!(tiny.next_down(), 0.0f32);
387+
assert_biteq!(tiny_up.next_down(), tiny);
388+
assert_biteq!(smallest_normal.next_down(), largest_subnormal);
389+
assert_biteq!((1.0 + f32::EPSILON).next_down(), 1.0f32);
390+
assert_biteq!(f32::MAX.next_down(), max_down);
391+
assert_biteq!(f32::INFINITY.next_down(), f32::MAX);
403392

404393
// Check that NaNs roundtrip.
405394
let nan0 = f32::NAN;
406395
let nan1 = f32::from_bits(f32::NAN.to_bits() ^ NAN_MASK1);
407396
let nan2 = f32::from_bits(f32::NAN.to_bits() ^ NAN_MASK2);
408-
assert_f32_biteq!(nan0.next_down(), nan0);
409-
assert_f32_biteq!(nan1.next_down(), nan1);
410-
assert_f32_biteq!(nan2.next_down(), nan2);
397+
assert_biteq!(nan0.next_down(), nan0);
398+
assert_biteq!(nan1.next_down(), nan1);
399+
assert_biteq!(nan2.next_down(), nan2);
411400
}
412401

413402
// FIXME(#140515): mingw has an incorrect fma https://sourceforge.net/p/mingw-w64/bugs/848/

0 commit comments

Comments
 (0)