Skip to content

Commit 33d8a4e

Browse files
committed
Rearrange tests to be in the same order as implementation
I was having trouble figuring out which functions had tests and which didn't. This commit is just moving tests around and does not change anything.
1 parent b0746ff commit 33d8a4e

File tree

2 files changed

+345
-345
lines changed

2 files changed

+345
-345
lines changed

src/libstd/num/f32.rs

Lines changed: 173 additions & 173 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
1+
// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
22
// file at the top-level directory of this distribution and at
33
// http://rust-lang.org/COPYRIGHT.
44
//
@@ -468,6 +468,11 @@ mod tests {
468468
use num::*;
469469
use num::FpCategory as Fp;
470470

471+
#[test]
472+
fn test_num_f32() {
473+
test_num(10f32, 2f32);
474+
}
475+
471476
#[test]
472477
fn test_min_nan() {
473478
assert_eq!(NAN.min(2.0), 2.0);
@@ -481,8 +486,49 @@ mod tests {
481486
}
482487

483488
#[test]
484-
fn test_num_f32() {
485-
test_num(10f32, 2f32);
489+
fn test_is_normal() {
490+
let nan: f32 = Float::nan();
491+
let inf: f32 = Float::infinity();
492+
let neg_inf: f32 = Float::neg_infinity();
493+
let zero: f32 = Float::zero();
494+
let neg_zero: f32 = Float::neg_zero();
495+
assert!(!nan.is_normal());
496+
assert!(!inf.is_normal());
497+
assert!(!neg_inf.is_normal());
498+
assert!(!zero.is_normal());
499+
assert!(!neg_zero.is_normal());
500+
assert!(1f32.is_normal());
501+
assert!(1e-37f32.is_normal());
502+
assert!(!1e-38f32.is_normal());
503+
}
504+
505+
#[test]
506+
fn test_classify() {
507+
let nan: f32 = Float::nan();
508+
let inf: f32 = Float::infinity();
509+
let neg_inf: f32 = Float::neg_infinity();
510+
let zero: f32 = Float::zero();
511+
let neg_zero: f32 = Float::neg_zero();
512+
assert_eq!(nan.classify(), Fp::Nan);
513+
assert_eq!(inf.classify(), Fp::Infinite);
514+
assert_eq!(neg_inf.classify(), Fp::Infinite);
515+
assert_eq!(zero.classify(), Fp::Zero);
516+
assert_eq!(neg_zero.classify(), Fp::Zero);
517+
assert_eq!(1f32.classify(), Fp::Normal);
518+
assert_eq!(1e-37f32.classify(), Fp::Normal);
519+
assert_eq!(1e-38f32.classify(), Fp::Subnormal);
520+
}
521+
522+
#[test]
523+
fn test_integer_decode() {
524+
assert_eq!(3.14159265359f32.integer_decode(), (13176795, -22, 1));
525+
assert_eq!((-8573.5918555f32).integer_decode(), (8779358, -10, -1));
526+
assert_eq!(2f32.powf(100.0).integer_decode(), (8388608, 77, 1));
527+
assert_eq!(0f32.integer_decode(), (0, -150, 1));
528+
assert_eq!((-0f32).integer_decode(), (0, -150, -1));
529+
assert_eq!(INFINITY.integer_decode(), (8388608, 105, 1));
530+
assert_eq!(NEG_INFINITY.integer_decode(), (8388608, 105, -1));
531+
assert_eq!(NAN.integer_decode(), (12582912, 105, 1));
486532
}
487533

488534
#[test]
@@ -555,6 +601,65 @@ mod tests {
555601
assert_approx_eq!((-1.7f32).fract(), -0.7f32);
556602
}
557603

604+
#[test]
605+
pub fn test_abs() {
606+
assert_eq!(INFINITY.abs(), INFINITY);
607+
assert_eq!(1f32.abs(), 1f32);
608+
assert_eq!(0f32.abs(), 0f32);
609+
assert_eq!((-0f32).abs(), 0f32);
610+
assert_eq!((-1f32).abs(), 1f32);
611+
assert_eq!(NEG_INFINITY.abs(), INFINITY);
612+
assert_eq!((1f32/NEG_INFINITY).abs(), 0f32);
613+
assert!(NAN.abs().is_nan());
614+
}
615+
616+
#[test]
617+
fn test_signum() {
618+
assert_eq!(INFINITY.signum(), 1f32);
619+
assert_eq!(1f32.signum(), 1f32);
620+
assert_eq!(0f32.signum(), 1f32);
621+
assert_eq!((-0f32).signum(), -1f32);
622+
assert_eq!((-1f32).signum(), -1f32);
623+
assert_eq!(NEG_INFINITY.signum(), -1f32);
624+
assert_eq!((1f32/NEG_INFINITY).signum(), -1f32);
625+
assert!(NAN.signum().is_nan());
626+
}
627+
628+
#[test]
629+
fn test_is_positive() {
630+
assert!(INFINITY.is_positive());
631+
assert!(1f32.is_positive());
632+
assert!(0f32.is_positive());
633+
assert!(!(-0f32).is_positive());
634+
assert!(!(-1f32).is_positive());
635+
assert!(!NEG_INFINITY.is_positive());
636+
assert!(!(1f32/NEG_INFINITY).is_positive());
637+
assert!(!NAN.is_positive());
638+
}
639+
640+
#[test]
641+
fn test_is_negative() {
642+
assert!(!INFINITY.is_negative());
643+
assert!(!1f32.is_negative());
644+
assert!(!0f32.is_negative());
645+
assert!((-0f32).is_negative());
646+
assert!((-1f32).is_negative());
647+
assert!(NEG_INFINITY.is_negative());
648+
assert!((1f32/NEG_INFINITY).is_negative());
649+
assert!(!NAN.is_negative());
650+
}
651+
652+
#[test]
653+
fn test_sqrt_domain() {
654+
assert!(NAN.sqrt().is_nan());
655+
assert!(NEG_INFINITY.sqrt().is_nan());
656+
assert!((-1.0f32).sqrt().is_nan());
657+
assert_eq!((-0.0f32).sqrt(), -0.0);
658+
assert_eq!(0.0f32.sqrt(), 0.0);
659+
assert_eq!(1.0f32.sqrt(), 1.0);
660+
assert_eq!(INFINITY.sqrt(), INFINITY);
661+
}
662+
558663
#[test]
559664
fn test_exp() {
560665
assert_eq!(1.0, 0.0f32.exp());
@@ -582,6 +687,71 @@ mod tests {
582687
assert!(nan.exp2().is_nan());
583688
}
584689

690+
#[test]
691+
fn test_ldexp() {
692+
// We have to use from_str until base-2 exponents
693+
// are supported in floating-point literals
694+
let f1: f32 = FromStrRadix::from_str_radix("1p-123", 16).unwrap();
695+
let f2: f32 = FromStrRadix::from_str_radix("1p-111", 16).unwrap();
696+
assert_eq!(Float::ldexp(1f32, -123), f1);
697+
assert_eq!(Float::ldexp(1f32, -111), f2);
698+
699+
assert_eq!(Float::ldexp(0f32, -123), 0f32);
700+
assert_eq!(Float::ldexp(-0f32, -123), -0f32);
701+
702+
let inf: f32 = Float::infinity();
703+
let neg_inf: f32 = Float::neg_infinity();
704+
let nan: f32 = Float::nan();
705+
assert_eq!(Float::ldexp(inf, -123), inf);
706+
assert_eq!(Float::ldexp(neg_inf, -123), neg_inf);
707+
assert!(Float::ldexp(nan, -123).is_nan());
708+
}
709+
710+
#[test]
711+
fn test_frexp() {
712+
// We have to use from_str until base-2 exponents
713+
// are supported in floating-point literals
714+
let f1: f32 = FromStrRadix::from_str_radix("1p-123", 16).unwrap();
715+
let f2: f32 = FromStrRadix::from_str_radix("1p-111", 16).unwrap();
716+
let (x1, exp1) = f1.frexp();
717+
let (x2, exp2) = f2.frexp();
718+
assert_eq!((x1, exp1), (0.5f32, -122));
719+
assert_eq!((x2, exp2), (0.5f32, -110));
720+
assert_eq!(Float::ldexp(x1, exp1), f1);
721+
assert_eq!(Float::ldexp(x2, exp2), f2);
722+
723+
assert_eq!(0f32.frexp(), (0f32, 0));
724+
assert_eq!((-0f32).frexp(), (-0f32, 0));
725+
}
726+
727+
#[test] #[cfg_attr(windows, ignore)] // FIXME #8755
728+
fn test_frexp_nowin() {
729+
let inf: f32 = Float::infinity();
730+
let neg_inf: f32 = Float::neg_infinity();
731+
let nan: f32 = Float::nan();
732+
assert_eq!(match inf.frexp() { (x, _) => x }, inf);
733+
assert_eq!(match neg_inf.frexp() { (x, _) => x }, neg_inf);
734+
assert!(match nan.frexp() { (x, _) => x.is_nan() })
735+
}
736+
737+
#[test]
738+
fn test_abs_sub() {
739+
assert_eq!((-1f32).abs_sub(1f32), 0f32);
740+
assert_eq!(1f32.abs_sub(1f32), 0f32);
741+
assert_eq!(1f32.abs_sub(0f32), 1f32);
742+
assert_eq!(1f32.abs_sub(-1f32), 2f32);
743+
assert_eq!(NEG_INFINITY.abs_sub(0f32), 0f32);
744+
assert_eq!(INFINITY.abs_sub(1f32), INFINITY);
745+
assert_eq!(0f32.abs_sub(NEG_INFINITY), INFINITY);
746+
assert_eq!(0f32.abs_sub(INFINITY), 0f32);
747+
}
748+
749+
#[test]
750+
fn test_abs_sub_nowin() {
751+
assert!(NAN.abs_sub(-1f32).is_nan());
752+
assert!(1f32.abs_sub(NAN).is_nan());
753+
}
754+
585755
#[test]
586756
fn test_asinh() {
587757
assert_eq!(0.0f32.asinh(), 0.0f32);
@@ -674,174 +844,4 @@ mod tests {
674844
assert_approx_eq!(ln_2, 2f32.ln());
675845
assert_approx_eq!(ln_10, 10f32.ln());
676846
}
677-
678-
#[test]
679-
pub fn test_abs() {
680-
assert_eq!(INFINITY.abs(), INFINITY);
681-
assert_eq!(1f32.abs(), 1f32);
682-
assert_eq!(0f32.abs(), 0f32);
683-
assert_eq!((-0f32).abs(), 0f32);
684-
assert_eq!((-1f32).abs(), 1f32);
685-
assert_eq!(NEG_INFINITY.abs(), INFINITY);
686-
assert_eq!((1f32/NEG_INFINITY).abs(), 0f32);
687-
assert!(NAN.abs().is_nan());
688-
}
689-
690-
#[test]
691-
fn test_abs_sub() {
692-
assert_eq!((-1f32).abs_sub(1f32), 0f32);
693-
assert_eq!(1f32.abs_sub(1f32), 0f32);
694-
assert_eq!(1f32.abs_sub(0f32), 1f32);
695-
assert_eq!(1f32.abs_sub(-1f32), 2f32);
696-
assert_eq!(NEG_INFINITY.abs_sub(0f32), 0f32);
697-
assert_eq!(INFINITY.abs_sub(1f32), INFINITY);
698-
assert_eq!(0f32.abs_sub(NEG_INFINITY), INFINITY);
699-
assert_eq!(0f32.abs_sub(INFINITY), 0f32);
700-
}
701-
702-
#[test]
703-
fn test_abs_sub_nowin() {
704-
assert!(NAN.abs_sub(-1f32).is_nan());
705-
assert!(1f32.abs_sub(NAN).is_nan());
706-
}
707-
708-
#[test]
709-
fn test_signum() {
710-
assert_eq!(INFINITY.signum(), 1f32);
711-
assert_eq!(1f32.signum(), 1f32);
712-
assert_eq!(0f32.signum(), 1f32);
713-
assert_eq!((-0f32).signum(), -1f32);
714-
assert_eq!((-1f32).signum(), -1f32);
715-
assert_eq!(NEG_INFINITY.signum(), -1f32);
716-
assert_eq!((1f32/NEG_INFINITY).signum(), -1f32);
717-
assert!(NAN.signum().is_nan());
718-
}
719-
720-
#[test]
721-
fn test_is_positive() {
722-
assert!(INFINITY.is_positive());
723-
assert!(1f32.is_positive());
724-
assert!(0f32.is_positive());
725-
assert!(!(-0f32).is_positive());
726-
assert!(!(-1f32).is_positive());
727-
assert!(!NEG_INFINITY.is_positive());
728-
assert!(!(1f32/NEG_INFINITY).is_positive());
729-
assert!(!NAN.is_positive());
730-
}
731-
732-
#[test]
733-
fn test_is_negative() {
734-
assert!(!INFINITY.is_negative());
735-
assert!(!1f32.is_negative());
736-
assert!(!0f32.is_negative());
737-
assert!((-0f32).is_negative());
738-
assert!((-1f32).is_negative());
739-
assert!(NEG_INFINITY.is_negative());
740-
assert!((1f32/NEG_INFINITY).is_negative());
741-
assert!(!NAN.is_negative());
742-
}
743-
744-
#[test]
745-
fn test_is_normal() {
746-
let nan: f32 = Float::nan();
747-
let inf: f32 = Float::infinity();
748-
let neg_inf: f32 = Float::neg_infinity();
749-
let zero: f32 = Float::zero();
750-
let neg_zero: f32 = Float::neg_zero();
751-
assert!(!nan.is_normal());
752-
assert!(!inf.is_normal());
753-
assert!(!neg_inf.is_normal());
754-
assert!(!zero.is_normal());
755-
assert!(!neg_zero.is_normal());
756-
assert!(1f32.is_normal());
757-
assert!(1e-37f32.is_normal());
758-
assert!(!1e-38f32.is_normal());
759-
}
760-
761-
#[test]
762-
fn test_classify() {
763-
let nan: f32 = Float::nan();
764-
let inf: f32 = Float::infinity();
765-
let neg_inf: f32 = Float::neg_infinity();
766-
let zero: f32 = Float::zero();
767-
let neg_zero: f32 = Float::neg_zero();
768-
assert_eq!(nan.classify(), Fp::Nan);
769-
assert_eq!(inf.classify(), Fp::Infinite);
770-
assert_eq!(neg_inf.classify(), Fp::Infinite);
771-
assert_eq!(zero.classify(), Fp::Zero);
772-
assert_eq!(neg_zero.classify(), Fp::Zero);
773-
assert_eq!(1f32.classify(), Fp::Normal);
774-
assert_eq!(1e-37f32.classify(), Fp::Normal);
775-
assert_eq!(1e-38f32.classify(), Fp::Subnormal);
776-
}
777-
778-
#[test]
779-
fn test_ldexp() {
780-
// We have to use from_str until base-2 exponents
781-
// are supported in floating-point literals
782-
let f1: f32 = FromStrRadix::from_str_radix("1p-123", 16).unwrap();
783-
let f2: f32 = FromStrRadix::from_str_radix("1p-111", 16).unwrap();
784-
assert_eq!(Float::ldexp(1f32, -123), f1);
785-
assert_eq!(Float::ldexp(1f32, -111), f2);
786-
787-
assert_eq!(Float::ldexp(0f32, -123), 0f32);
788-
assert_eq!(Float::ldexp(-0f32, -123), -0f32);
789-
790-
let inf: f32 = Float::infinity();
791-
let neg_inf: f32 = Float::neg_infinity();
792-
let nan: f32 = Float::nan();
793-
assert_eq!(Float::ldexp(inf, -123), inf);
794-
assert_eq!(Float::ldexp(neg_inf, -123), neg_inf);
795-
assert!(Float::ldexp(nan, -123).is_nan());
796-
}
797-
798-
#[test]
799-
fn test_frexp() {
800-
// We have to use from_str until base-2 exponents
801-
// are supported in floating-point literals
802-
let f1: f32 = FromStrRadix::from_str_radix("1p-123", 16).unwrap();
803-
let f2: f32 = FromStrRadix::from_str_radix("1p-111", 16).unwrap();
804-
let (x1, exp1) = f1.frexp();
805-
let (x2, exp2) = f2.frexp();
806-
assert_eq!((x1, exp1), (0.5f32, -122));
807-
assert_eq!((x2, exp2), (0.5f32, -110));
808-
assert_eq!(Float::ldexp(x1, exp1), f1);
809-
assert_eq!(Float::ldexp(x2, exp2), f2);
810-
811-
assert_eq!(0f32.frexp(), (0f32, 0));
812-
assert_eq!((-0f32).frexp(), (-0f32, 0));
813-
}
814-
815-
#[test] #[cfg_attr(windows, ignore)] // FIXME #8755
816-
fn test_frexp_nowin() {
817-
let inf: f32 = Float::infinity();
818-
let neg_inf: f32 = Float::neg_infinity();
819-
let nan: f32 = Float::nan();
820-
assert_eq!(match inf.frexp() { (x, _) => x }, inf);
821-
assert_eq!(match neg_inf.frexp() { (x, _) => x }, neg_inf);
822-
assert!(match nan.frexp() { (x, _) => x.is_nan() })
823-
}
824-
825-
#[test]
826-
fn test_integer_decode() {
827-
assert_eq!(3.14159265359f32.integer_decode(), (13176795, -22, 1));
828-
assert_eq!((-8573.5918555f32).integer_decode(), (8779358, -10, -1));
829-
assert_eq!(2f32.powf(100.0).integer_decode(), (8388608, 77, 1));
830-
assert_eq!(0f32.integer_decode(), (0, -150, 1));
831-
assert_eq!((-0f32).integer_decode(), (0, -150, -1));
832-
assert_eq!(INFINITY.integer_decode(), (8388608, 105, 1));
833-
assert_eq!(NEG_INFINITY.integer_decode(), (8388608, 105, -1));
834-
assert_eq!(NAN.integer_decode(), (12582912, 105, 1));
835-
}
836-
837-
#[test]
838-
fn test_sqrt_domain() {
839-
assert!(NAN.sqrt().is_nan());
840-
assert!(NEG_INFINITY.sqrt().is_nan());
841-
assert!((-1.0f32).sqrt().is_nan());
842-
assert_eq!((-0.0f32).sqrt(), -0.0);
843-
assert_eq!(0.0f32.sqrt(), 0.0);
844-
assert_eq!(1.0f32.sqrt(), 1.0);
845-
assert_eq!(INFINITY.sqrt(), INFINITY);
846-
}
847847
}

0 commit comments

Comments
 (0)