tktax_money/

lib.rs

// ---------------- [ File: tktax-money/src/lib.rs ]
#![feature(assert_matches)]
#[macro_use] mod imports; use imports::*;

x!{basic_stats}
x!{dimensionless}
x!{price}
x!{errors}
x!{correlation}
x!{simple_linear_regression}
x!{monetary_amount}
x!{segment_by}
x!{deser}
x!{advanced_stats}

#[cfg(test)]
mod test_monetary_amount_extended {
    use super::MonetaryAmount;
    use super::MonetaryAmountError;
    use super::*;
    use std::str::FromStr;
    use rust_decimal::Decimal;

    fn ma(s: &str) -> MonetaryAmount {
        MonetaryAmount::from_str(s).unwrap()
    }

    // --------------------------
    // 1. Parsing & Edge Cases
    // --------------------------

    #[test]
    fn test_parse_valid() {
        assert_eq!(MonetaryAmount::from_str("0").unwrap(), MonetaryAmount::zero());
        assert_eq!(MonetaryAmount::from_str("123.456").unwrap(), ma("123.456"));
        assert_eq!(MonetaryAmount::from_str("-987.654321").unwrap(), ma("-987.654321"));
    }

    #[test]
    fn test_parse_invalid() {
        // Contains non-numeric chars or multiple decimals, etc.
        let err = MonetaryAmount::from_str("12.34.56").unwrap_err();
        assert_matches!(err, MonetaryAmountParseError::CouldNotParse { .. });

        let err = MonetaryAmount::from_str("abc").unwrap_err();
        assert_matches!(err, MonetaryAmountParseError::CouldNotParse { .. });

        let err = MonetaryAmount::from_str("").unwrap_err();
        assert_matches!(err, MonetaryAmountParseError::CouldNotParse { .. });
    }

    #[test]
    fn test_parse_extreme() {
        // 12 digits before decimal is allowed
        let x = ma("999999999999.9999999999"); // 12 digits before decimal
        assert_eq!(format!("{}", x), " $1000000000000.00");  // Rounds up

        // 13 digits => display panic
        // But from_str is still valid. The panic only triggers *when printing* if >12 digits before decimal.
        let big_str = "1234567890123.45";
        let y = MonetaryAmount::from_str(big_str).unwrap();
        // The next line should panic if displayed:
        // let _ = format!("{}", y);

        // We can check that we store it, but panic if we do try to display:
        // So we won't call format!() here to avoid intentional panic in this test.
        assert_eq!(y, MonetaryAmount::from(Decimal::from_str(big_str).unwrap()));
    }

    #[test]
    fn test_from_f64_valid() {
        let x = MonetaryAmount::from(3.14159_f64);
        // 3.14159 => check truncated or exact?
        assert_eq!(x.to_string().trim(), "$3.14");
    }

    // This scenario might panic if the f64 => Decimal fails.
    // Usually rust_decimal::from_f64(some_large_value) => Option::None if out of range
    // so we might wrap that in a custom panic or error. 
    // For demonstration:
    #[test]
    #[should_panic(expected = "Failed to convert from f64 to Decimal")]
    fn test_from_f64_out_of_range() {
        // Very large f64 can cause Decimal::from_f64 to return None
        let _ = MonetaryAmount::from(1e40_f64); 
    }

    // --------------------------
    // 2. Display & Rounding
    // --------------------------

    // Check that trailing decimals get truncated properly
    #[test]
    fn test_display_rounding() {
        let amt = ma("123.4567");
        // 2 decimal rounding => "123.46"
        // left-justify in 12 spaces => " $123.46     "
        assert_eq!(format!("{}", amt), " $123.46     ");
    }

    #[test]
    fn test_display_zero() {
        let amt = ma("0");
        assert_eq!(format!("{}", amt).trim(), "$0.00");
    }

    // --------------------------
    // 3. Arithmetic Edge Cases
    // --------------------------

    #[test]
    fn test_negative_division() {
        let x = ma("-10");
        let y = ma("5");
        let res = x / y; // = -2
        assert_eq!(res, ma("-2"));
        let res2 = x + y; // -10 + 5 = -5
        assert_eq!(res2, ma("-5"));
    }

    #[test]
    fn test_sqrt_zero() {
        let z = MonetaryAmount::zero();
        let root = z.sqrt();
        assert_eq!(root, MonetaryAmount::zero());
    }

    // Another corner: exponent 0 => x^0=1
    #[test]
    fn test_powu_zero_exponent() {
        let x = ma("9999.99");
        let p = x.powu(0);
        // any non-zero x^0 => 1
        assert_eq!(p, ma("1"));
    }

    #[test]
    fn test_powu_large_exponent() {
        // test behavior for large exponent that might overflow decimal
        // e.g. we expect a panic if it's too big, or success if not
        let x = ma("2");
        // 2^32=4,294,967,296 => might still be ok for 128-bit decimal
        let p = x.powu(32);
        assert_eq!(p, ma("4294967296"));
    }

    // --------------------------
    // 4. Comparison & Hashing
    // --------------------------

    #[test]
    fn test_partial_eq_and_ordering() {
        // Check that different decimal scales are recognized as equal
        let a = ma("10.0");
        let b = ma("10.00");
        assert_eq!(a, b);

        let c = ma("10.0001");
        assert!(c > a);
        assert!(c >= a);
        assert!(a < c);
    }

    #[test]
    fn test_hash_map_usage() {
        // confirm we can use MonetaryAmount as key in a HashMap
        let mut map = std::collections::HashMap::new();
        map.insert(ma("5"), "five");
        map.insert(ma("10.000"), "ten");

        assert_eq!(map.get(&ma("5.0")), Some(&"five"));
        assert_eq!(map.get(&ma("10")), Some(&"ten"));
    }

    // ----------------------------
    // 5. (Optional) Property Tests
    // ----------------------------

    // If you want property-based checks, uncomment and add proptest dev-dependency in Cargo.toml:
    //
    // [dev-dependencies]
    // proptest = "1"
    //
    // Then:
    /*
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn prop_arithmetic_closure(a in -9999i64..9999, b in -9999i64..9999) {
            let ma_a = MonetaryAmount::from(a);
            let ma_b = MonetaryAmount::from(b);

            // Check associativity, commutativity, etc.
            // For example, addition is commutative:
            prop_assert_eq!(ma_a + ma_b, ma_b + ma_a);

            // Multiplying with 0 yields 0:
            prop_assert_eq!(ma_a * MonetaryAmount::zero(), MonetaryAmount::zero());
            prop_assert_eq!(ma_b * MonetaryAmount::zero(), MonetaryAmount::zero());
        }
    }
    */
}