// Adapted from https://github.com/Alexhuszagh/rust-lexical.

use crate::lexical::float::ExtendedFloat;
use crate::lexical::num::Float;
use crate::lexical::rounding::*;

// MASKS

#[test]
fn lower_n_mask_test() {
    assert_eq!(lower_n_mask(0u64), 0b0);
    assert_eq!(lower_n_mask(1u64), 0b1);
    assert_eq!(lower_n_mask(2u64), 0b11);
    assert_eq!(lower_n_mask(10u64), 0b1111111111);
    assert_eq!(lower_n_mask(32u64), 0b11111111111111111111111111111111);
}

#[test]
fn lower_n_halfway_test() {
    assert_eq!(lower_n_halfway(0u64), 0b0);
    assert_eq!(lower_n_halfway(1u64), 0b1);
    assert_eq!(lower_n_halfway(2u64), 0b10);
    assert_eq!(lower_n_halfway(10u64), 0b1000000000);
    assert_eq!(lower_n_halfway(32u64), 0b10000000000000000000000000000000);
}

#[test]
fn nth_bit_test() {
    assert_eq!(nth_bit(0u64), 0b1);
    assert_eq!(nth_bit(1u64), 0b10);
    assert_eq!(nth_bit(2u64), 0b100);
    assert_eq!(nth_bit(10u64), 0b10000000000);
    assert_eq!(nth_bit(31u64), 0b10000000000000000000000000000000);
}

#[test]
fn internal_n_mask_test() {
    assert_eq!(internal_n_mask(1u64, 0u64), 0b0);
    assert_eq!(internal_n_mask(1u64, 1u64), 0b1);
    assert_eq!(internal_n_mask(2u64, 1u64), 0b10);
    assert_eq!(internal_n_mask(4u64, 2u64), 0b1100);
    assert_eq!(internal_n_mask(10u64, 2u64), 0b1100000000);
    assert_eq!(internal_n_mask(10u64, 4u64), 0b1111000000);
    assert_eq!(
        internal_n_mask(32u64, 4u64),
        0b11110000000000000000000000000000
    );
}

// NEAREST ROUNDING

#[test]
fn round_nearest_test() {
    // Check exactly halfway (b'1100000')
    let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };
    let (above, halfway) = round_nearest(&mut fp, 6);
    assert!(!above);
    assert!(halfway);
    assert_eq!(fp.mant, 1);

    // Check above halfway (b'1100001')
    let mut fp = ExtendedFloat { mant: 0x61, exp: 0 };
    let (above, halfway) = round_nearest(&mut fp, 6);
    assert!(above);
    assert!(!halfway);
    assert_eq!(fp.mant, 1);

    // Check below halfway (b'1011111')
    let mut fp = ExtendedFloat { mant: 0x5F, exp: 0 };
    let (above, halfway) = round_nearest(&mut fp, 6);
    assert!(!above);
    assert!(!halfway);
    assert_eq!(fp.mant, 1);
}

// DIRECTED ROUNDING

#[test]
fn round_downward_test() {
    // b0000000
    let mut fp = ExtendedFloat { mant: 0x00, exp: 0 };
    round_downward(&mut fp, 6);
    assert_eq!(fp.mant, 0);

    // b1000000
    let mut fp = ExtendedFloat { mant: 0x40, exp: 0 };
    round_downward(&mut fp, 6);
    assert_eq!(fp.mant, 1);

    // b1100000
    let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };
    round_downward(&mut fp, 6);
    assert_eq!(fp.mant, 1);

    // b1110000
    let mut fp = ExtendedFloat { mant: 0x70, exp: 0 };
    round_downward(&mut fp, 6);
    assert_eq!(fp.mant, 1);
}

#[test]
fn round_nearest_tie_even_test() {
    // Check round-up, halfway
    let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };
    round_nearest_tie_even(&mut fp, 6);
    assert_eq!(fp.mant, 2);

    // Check round-down, halfway
    let mut fp = ExtendedFloat { mant: 0x20, exp: 0 };
    round_nearest_tie_even(&mut fp, 6);
    assert_eq!(fp.mant, 0);

    // Check round-up, above halfway
    let mut fp = ExtendedFloat { mant: 0x61, exp: 0 };
    round_nearest_tie_even(&mut fp, 6);
    assert_eq!(fp.mant, 2);

    let mut fp = ExtendedFloat { mant: 0x21, exp: 0 };
    round_nearest_tie_even(&mut fp, 6);
    assert_eq!(fp.mant, 1);

    // Check round-down, below halfway
    let mut fp = ExtendedFloat { mant: 0x5F, exp: 0 };
    round_nearest_tie_even(&mut fp, 6);
    assert_eq!(fp.mant, 1);

    let mut fp = ExtendedFloat { mant: 0x1F, exp: 0 };
    round_nearest_tie_even(&mut fp, 6);
    assert_eq!(fp.mant, 0);
}

// HIGH-LEVEL

#[test]
fn round_to_float_test() {
    // Denormal
    let mut fp = ExtendedFloat {
        mant: 1 << 63,
        exp: f64::DENORMAL_EXPONENT - 15,
    };
    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 1 << 48);
    assert_eq!(fp.exp, f64::DENORMAL_EXPONENT);

    // Halfway, round-down (b'1000000000000000000000000000000000000000000000000000010000000000')
    let mut fp = ExtendedFloat {
        mant: 0x8000000000000400,
        exp: -63,
    };
    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 1 << 52);
    assert_eq!(fp.exp, -52);

    // Halfway, round-up (b'1000000000000000000000000000000000000000000000000000110000000000')
    let mut fp = ExtendedFloat {
        mant: 0x8000000000000C00,
        exp: -63,
    };
    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, (1 << 52) + 2);
    assert_eq!(fp.exp, -52);

    // Above halfway
    let mut fp = ExtendedFloat {
        mant: 0x8000000000000401,
        exp: -63,
    };
    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, (1 << 52) + 1);
    assert_eq!(fp.exp, -52);

    let mut fp = ExtendedFloat {
        mant: 0x8000000000000C01,
        exp: -63,
    };
    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, (1 << 52) + 2);
    assert_eq!(fp.exp, -52);

    // Below halfway
    let mut fp = ExtendedFloat {
        mant: 0x80000000000003FF,
        exp: -63,
    };
    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 1 << 52);
    assert_eq!(fp.exp, -52);

    let mut fp = ExtendedFloat {
        mant: 0x8000000000000BFF,
        exp: -63,
    };
    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, (1 << 52) + 1);
    assert_eq!(fp.exp, -52);
}

#[test]
fn avoid_overflow_test() {
    // Avoid overflow, fails by 1
    let mut fp = ExtendedFloat {
        mant: 0xFFFFFFFFFFFF,
        exp: f64::MAX_EXPONENT + 5,
    };
    avoid_overflow::<f64>(&mut fp);
    assert_eq!(fp.mant, 0xFFFFFFFFFFFF);
    assert_eq!(fp.exp, f64::MAX_EXPONENT + 5);

    // Avoid overflow, succeeds
    let mut fp = ExtendedFloat {
        mant: 0xFFFFFFFFFFFF,
        exp: f64::MAX_EXPONENT + 4,
    };
    avoid_overflow::<f64>(&mut fp);
    assert_eq!(fp.mant, 0x1FFFFFFFFFFFE0);
    assert_eq!(fp.exp, f64::MAX_EXPONENT - 1);
}

#[test]
fn round_to_native_test() {
    // Overflow
    let mut fp = ExtendedFloat {
        mant: 0xFFFFFFFFFFFF,
        exp: f64::MAX_EXPONENT + 4,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 0x1FFFFFFFFFFFE0);
    assert_eq!(fp.exp, f64::MAX_EXPONENT - 1);

    // Need denormal
    let mut fp = ExtendedFloat {
        mant: 1,
        exp: f64::DENORMAL_EXPONENT + 48,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 1 << 48);
    assert_eq!(fp.exp, f64::DENORMAL_EXPONENT);

    // Halfway, round-down (b'10000000000000000000000000000000000000000000000000000100000')
    let mut fp = ExtendedFloat {
        mant: 0x400000000000020,
        exp: -58,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 1 << 52);
    assert_eq!(fp.exp, -52);

    // Halfway, round-up (b'10000000000000000000000000000000000000000000000000001100000')
    let mut fp = ExtendedFloat {
        mant: 0x400000000000060,
        exp: -58,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, (1 << 52) + 2);
    assert_eq!(fp.exp, -52);

    // Above halfway
    let mut fp = ExtendedFloat {
        mant: 0x400000000000021,
        exp: -58,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, (1 << 52) + 1);
    assert_eq!(fp.exp, -52);

    let mut fp = ExtendedFloat {
        mant: 0x400000000000061,
        exp: -58,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, (1 << 52) + 2);
    assert_eq!(fp.exp, -52);

    // Below halfway
    let mut fp = ExtendedFloat {
        mant: 0x40000000000001F,
        exp: -58,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 1 << 52);
    assert_eq!(fp.exp, -52);

    let mut fp = ExtendedFloat {
        mant: 0x40000000000005F,
        exp: -58,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, (1 << 52) + 1);
    assert_eq!(fp.exp, -52);

    // Underflow
    // Adapted from failures in strtod.
    let mut fp = ExtendedFloat {
        exp: -1139,
        mant: 18446744073709550712,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 0);
    assert_eq!(fp.exp, 0);

    let mut fp = ExtendedFloat {
        exp: -1139,
        mant: 18446744073709551460,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 0);
    assert_eq!(fp.exp, 0);

    let mut fp = ExtendedFloat {
        exp: -1138,
        mant: 9223372036854776103,
    };
    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
    assert_eq!(fp.mant, 1);
    assert_eq!(fp.exp, -1074);
}