library/core/tests/num/dec2flt/mod.rs

   1 #![allow(overflowing_literals)]
   2
   3 mod parse;
   4 mod rawfp;
   5
   6 // Take a float literal, turn it into a string in various ways (that are all trusted
   7 // to be correct) and see if those strings are parsed back to the value of the literal.
   8 // Requires a *polymorphic literal*, i.e., one that can serve as f64 as well as f32.
   9 macro_rules! test_literal {
  10     ($x: expr) => {{
  11         let x32: f32 = $x;
  12         let x64: f64 = $x;
  13         let inputs = &[stringify!($x).into(), format!("{:?}", x64), format!("{:e}", x64)];
  14         for input in inputs {
  15             assert_eq!(input.parse(), Ok(x64));
  16             assert_eq!(input.parse(), Ok(x32));
  17             let neg_input = &format!("-{}", input);
  18             assert_eq!(neg_input.parse(), Ok(-x64));
  19             assert_eq!(neg_input.parse(), Ok(-x32));
  20         }
  21     }};
  22 }
  23
  24 #[test]
  25 fn ordinary() {
  26     test_literal!(1.0);
  27     test_literal!(3e-5);
  28     test_literal!(0.1);
  29     test_literal!(12345.);
  30     test_literal!(0.9999999);
  31
  32     if cfg!(miri) {
  33         // Miri is too slow
  34         return;
  35     }
  36
  37     test_literal!(2.2250738585072014e-308);
  38 }
  39
  40 #[test]
  41 fn special_code_paths() {
  42     test_literal!(36893488147419103229.0); // 2^65 - 3, triggers half-to-even with even significand
  43     test_literal!(101e-33); // Triggers the tricky underflow case in AlgorithmM (for f32)
  44     test_literal!(1e23); // Triggers AlgorithmR
  45     test_literal!(2075e23); // Triggers another path through AlgorithmR
  46     test_literal!(8713e-23); // ... and yet another.
  47 }
  48
  49 #[test]
  50 fn large() {
  51     test_literal!(1e300);
  52     test_literal!(123456789.34567e250);
  53     test_literal!(943794359898089732078308743689303290943794359843568973207830874368930329.);
  54 }
  55
  56 #[test]
  57 #[cfg_attr(miri, ignore)] // Miri is too slow
  58 fn subnormals() {
  59     test_literal!(5e-324);
  60     test_literal!(91e-324);
  61     test_literal!(1e-322);
  62     test_literal!(13245643e-320);
  63     test_literal!(2.22507385851e-308);
  64     test_literal!(2.1e-308);
  65     test_literal!(4.9406564584124654e-324);
  66 }
  67
  68 #[test]
  69 #[cfg_attr(miri, ignore)] // Miri is too slow
  70 fn infinity() {
  71     test_literal!(1e400);
  72     test_literal!(1e309);
  73     test_literal!(2e308);
  74     test_literal!(1.7976931348624e308);
  75 }
  76
  77 #[test]
  78 fn zero() {
  79     test_literal!(0.0);
  80     test_literal!(1e-325);
  81
  82     if cfg!(miri) {
  83         // Miri is too slow
  84         return;
  85     }
  86
  87     test_literal!(1e-326);
  88     test_literal!(1e-500);
  89 }
  90
  91 #[test]
  92 fn fast_path_correct() {
  93     // This number triggers the fast path and is handled incorrectly when compiling on
  94     // x86 without SSE2 (i.e., using the x87 FPU stack).
  95     test_literal!(1.448997445238699);
  96 }
  97
  98 #[test]
  99 fn lonely_dot() {
 100     assert!(".".parse::<f32>().is_err());
 101     assert!(".".parse::<f64>().is_err());
 102 }
 103
 104 #[test]
 105 fn exponentiated_dot() {
 106     assert!(".e0".parse::<f32>().is_err());
 107     assert!(".e0".parse::<f64>().is_err());
 108 }
 109
 110 #[test]
 111 fn lonely_sign() {
 112     assert!("+".parse::<f32>().is_err());
 113     assert!("-".parse::<f64>().is_err());
 114 }
 115
 116 #[test]
 117 fn whitespace() {
 118     assert!(" 1.0".parse::<f32>().is_err());
 119     assert!("1.0 ".parse::<f64>().is_err());
 120 }
 121
 122 #[test]
 123 fn nan() {
 124     assert!("NaN".parse::<f32>().unwrap().is_nan());
 125     assert!("NaN".parse::<f64>().unwrap().is_nan());
 126 }
 127
 128 #[test]
 129 fn inf() {
 130     assert_eq!("inf".parse(), Ok(f64::INFINITY));
 131     assert_eq!("-inf".parse(), Ok(f64::NEG_INFINITY));
 132     assert_eq!("inf".parse(), Ok(f32::INFINITY));
 133     assert_eq!("-inf".parse(), Ok(f32::NEG_INFINITY));
 134 }
 135
 136 #[test]
 137 fn massive_exponent() {
 138     let max = i64::MAX;
 139     assert_eq!(format!("1e{}000", max).parse(), Ok(f64::INFINITY));
 140     assert_eq!(format!("1e-{}000", max).parse(), Ok(0.0));
 141     assert_eq!(format!("1e{}000", max).parse(), Ok(f64::INFINITY));
 142 }
 143
 144 #[test]
 145 fn borderline_overflow() {
 146     let mut s = "0.".to_string();
 147     for _ in 0..375 {
 148         s.push('3');
 149     }
 150     // At the time of this writing, this returns Err(..), but this is a bug that should be fixed.
 151     // It makes no sense to enshrine that in a test, the important part is that it doesn't panic.
 152     let _ = s.parse::<f64>();
 153 }