pub fn micro_denom_to_denom(micro_denom: u128) -> f64 {
    ((micro_denom as f64) / 1000000f64) as f64
}

pub fn denom_to_micro_denom_f64(denom: f64) -> u128 {
    (denom * 1000000f64) as u128
}

pub fn denom_to_micro_denom_u128(denom: u128) -> u128 {
    denom * 1000000u128
}

#[cfg(test)]
mod tests {
    use crate::util::{denom_to_micro_denom_f64, denom_to_micro_denom_u128, micro_denom_to_denom};

    #[test]
    fn overflow_percentage_maths_test() {
        let juno_max_denom_f64: f64 = 185562268f64;
        let juno_max_denom_u128: u128 = 185562268;
        let juno_max_micro_denom_from_f64: u128 = denom_to_micro_denom_f64(juno_max_denom_f64);
        let juno_max_micro_denom_from_u128: u128 = denom_to_micro_denom_u128(juno_max_denom_u128);
        assert_eq!(
            juno_max_micro_denom_from_f64, juno_max_micro_denom_from_u128,
            "Lossless conversion for JUNO"
        );
        let max_u128: u128 = u128::MAX;
        let max_f64 = f64::MAX;
        assert_eq!((((max_u128 / 1000000) as f64) < max_f64), true);
        assert_eq!(((max_u128 / 1000000) < max_f64 as u128), true);
    }
    #[test]
    fn values() {
        let zero_u128: u128 = 0;
        let zero_f64: f64 = 0f64;

        assert_eq!(micro_denom_to_denom(zero_u128), 0f64);
        assert_eq!(denom_to_micro_denom_f64(zero_f64), 0u128);

        let normal_micro_denom_u128: u128 = 10000000;
        let normal_denom_u128: u128 = 10000000 / 1000000;
        let normal_denom_f64: f64 = 10000000f64 / 1000000f64;

        assert_eq!(
            micro_denom_to_denom(normal_micro_denom_u128),
            normal_denom_f64
        );
        assert_eq!(
            denom_to_micro_denom_f64(normal_denom_f64),
            normal_micro_denom_u128
        );
        assert_eq!(
            denom_to_micro_denom_u128(normal_denom_u128),
            normal_micro_denom_u128
        );

        let decimal_micro_denom_u128: u128 = 201234567;
        let decimal_denom_f64: f64 = 201234567f64 / 1000000f64;

        assert_eq!(
            micro_denom_to_denom(decimal_micro_denom_u128),
            decimal_denom_f64
        );
        assert_eq!(
            denom_to_micro_denom_f64(decimal_denom_f64),
            decimal_micro_denom_u128
        );

        let max_micro_denom_u128: u128 = u128::MAX;
        let max_denom_f64: f64 = (u128::MAX as f64) / 1000000f64;

        assert_eq!(micro_denom_to_denom(max_micro_denom_u128), max_denom_f64);
        assert_eq!(
            denom_to_micro_denom_f64(max_denom_f64),
            max_micro_denom_u128
        );

        let juno_max_denom_u128: u128 = 185562268;
        let juno_max_denom_f64: f64 = 185562268f64;
        let juno_max_micro_denom: u128 = juno_max_denom_u128 * 1000000;

        assert_eq!(
            micro_denom_to_denom(juno_max_micro_denom),
            juno_max_denom_f64
        );
        assert_eq!(
            denom_to_micro_denom_f64(juno_max_denom_f64),
            juno_max_micro_denom
        );
        assert_eq!(
            denom_to_micro_denom_u128(juno_max_denom_u128),
            juno_max_micro_denom
        );
    }
}
