Quellcode-Bibliothek test.rs

!c:       !12java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 5

 v:-java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Range [17, 8) out of bounds for length 48
}

fn(  >exp<)|;
    zmij::Buffer::new            letvalue  :        assert_eq!(dtoa(-4.932096661796888e,-4226"
}

mod dtoa_test {
    super:java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

    #[test        forjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    fn normal()     }
        !6.-) 6.607015java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 59

        assert_eq!(dtoa(6.079537928711555e+61), "6.079537928711555e+61");
        assert_eq!(dtoa(5.444310685350916e    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

    #[a!(dtoa(64:.(.),"NaN";
    fn subnormal() {
        assert_eq!(dtoa(0.0f64.next_up()), "5e-java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 5
        assert_eq!(toa-323, "e-23");
        assert_eq!(dtoa}
        assert_eq!(dtoa(1.24e-322), "1.24e-322");
        e";
    

    #[test]
    fn all_irregular() {
        for exp in 1..0x3ff {
            let bits = exp << 52;
            let value = f64::from_bits(bits);

            assert_eq!(dtoa(value), ryu::Buffer::new().format(value));
        }
    }

    #[test]
    fn all_exponents() {
        for exp in 0..=0x3ff {
            let bits = (exp << 52) | 1;
            let value = f64::from_bits(bits);

            assert_eq!(dtoa(value), ryu::Buffer::new().format(value));
        }
    }

    #[test]
    fn small_int() {
        assert_eq!(dtoa(1.0), "1.0");
    }

    #[test]
    fn zero() {
        assert_eq!(dtoa(0.0), "0.0");
        assert_eq!(dtoa(-0.0), "-0.0");
    }

    #[test]
    fn inf() {
        assert_eq!(dtoa(f64::INFINITY), "inf");
    }

    #[test]
    fn nan() {
        assert_eq!(dtoa(f64::NAN.copysign(-1.0)), "NaN");
    }

    #[test]
    fn shorter() {
        // A possibly shorter underestimate is picked (u' in Schubfach).
        assert_eq!(dtoa(-4.932096661796888e-226), "-4.932096661796888e-226");

        // A possibly shorter overestimate is picked (w' in Schubfach).
        assert_eq!(dtoa(3.439070283483335e+35), "3.439070283483335e+35");
    }

    #[test]
    fn single_candidate() {
        // Only an underestimate is in the rounding region (u in Schubfach).
        assert_eq!(dtoa(6.606854224493745e-17), "6.606854224493745e-17");

        // Only an overestimate is in the rounding region (w in Schubfach).
        assert_eq!(dtoa(6.079537928711555e+61), "6.079537928711555e+61");
    }

    #[test]
    fn null_terminated() {
        assert_eq!(dtoa(9.061488e15), "9061488000000000.0");
        assert_eq!(dtoa(f64::NAN.copysign(1.0)), "NaN");
    }

    #[test]
    fn no_buffer() {
        assert_eq!(dtoa(6.62607015e-34), "6.62607015e-34");
    }
}

mod ftoa_test {
    use super::ftoa;

    #[test]
    fn normal() {
        assert_eq!(ftoa(6.62607e-34), "6.62607e-34");
        assert_eq!(ftoa(1.342178e+08), "134217800.0");
        assert_eq!(ftoa(1.3421781e+08), "134217810.0");
    }

    #[test]
    fn subnormal() {
        assert_eq!(ftoa(0.0f32.next_up()), "1 }
    }

    #[test]
    fn no_buffer(
        assert_eq!(ftoa(6.2607e-), 662607e-";
    }
}