uninum 0.1.1

//! Comprehensive Rounding Function Tests
//!
//! This module contains well-organized tests for all rounding strategies:
//! - Basic integer and float rounding (0 decimal places)
//! - Decimal precision rounding (non-zero decimal places)
//! - Special values (NaN, infinity, zero)
//! - Type preservation and consistency
//! - All 7 rounding strategies with comprehensive coverage

use uninum::{Number, RoundingStrategy, num};

// =============================================================================
// Basic Strategy Tests - 0 Decimal Places
// =============================================================================

#[test]
fn test_midpoint_nearest_even_basic() {
    // Integer types should return unchanged
    assert_eq!(
        Number::from(42_u64),
        Number::from(42_u64).round(0, RoundingStrategy::MidpointNearestEven)
    );
    assert_eq!(
        Number::from(-42_i64),
        Number::from(-42_i64).round(0, RoundingStrategy::MidpointNearestEven)
    );

    // True midpoints (x.5) - round to even
    assert_eq!(
        num!(0.0f64),
        num!(0.5f64).round(0, RoundingStrategy::MidpointNearestEven)
    ); // 0.5 -> 0 (even)
    assert_eq!(
        num!(2.0f64),
        num!(1.5f64).round(0, RoundingStrategy::MidpointNearestEven)
    ); // 1.5 -> 2 (even)
    assert_eq!(
        num!(2.0f64),
        num!(2.5f64).round(0, RoundingStrategy::MidpointNearestEven)
    ); // 2.5 -> 2 (even)
    assert_eq!(
        num!(4.0f64),
        num!(3.5f64).round(0, RoundingStrategy::MidpointNearestEven)
    ); // 3.5 -> 4 (even)

    // Negative midpoints
    assert_eq!(
        num!(-0.0f64),
        num!(-0.5f64).round(0, RoundingStrategy::MidpointNearestEven)
    ); // -0.5 -> 0 (even)
    assert_eq!(
        num!(-2.0f64),
        num!(-1.5f64).round(0, RoundingStrategy::MidpointNearestEven)
    ); // -1.5 -> -2 (even)
    assert_eq!(
        num!(-2.0f64),
        num!(-2.5f64).round(0, RoundingStrategy::MidpointNearestEven)
    ); // -2.5 -> -2 (even)

    // Non-midpoints
    assert_eq!(
        num!(3.0f64),
        num!(3.16f64).round(0, RoundingStrategy::MidpointNearestEven)
    );
    assert_eq!(
        num!(4.0f64),
        num!(3.86f64).round(0, RoundingStrategy::MidpointNearestEven)
    );
    assert_eq!(
        num!(-3.0f64),
        num!(-3.16f64).round(0, RoundingStrategy::MidpointNearestEven)
    );
}

#[test]
fn test_midpoint_away_from_zero_basic() {
    // Integer types should return unchanged
    assert_eq!(
        Number::from(42_u64),
        Number::from(42_u64).round(0, RoundingStrategy::MidpointAwayFromZero)
    );
    assert_eq!(
        Number::from(-42_i64),
        Number::from(-42_i64).round(0, RoundingStrategy::MidpointAwayFromZero)
    );

    // True midpoints (x.5) - round away from zero
    assert_eq!(
        num!(1.0f64),
        num!(0.5f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // 0.5 -> 1
    assert_eq!(
        num!(2.0f64),
        num!(1.5f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // 1.5 -> 2
    assert_eq!(
        num!(3.0f64),
        num!(2.5f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // 2.5 -> 3
    assert_eq!(
        num!(4.0f64),
        num!(3.5f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // 3.5 -> 4

    // Negative midpoints - away from zero means toward negative infinity
    assert_eq!(
        num!(-1.0f64),
        num!(-0.5f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // -0.5 -> -1
    assert_eq!(
        num!(-2.0f64),
        num!(-1.5f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // -1.5 -> -2
    assert_eq!(
        num!(-3.0f64),
        num!(-2.5f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // -2.5 -> -3

    // Non-midpoints
    assert_eq!(
        num!(3.0f64),
        num!(3.2f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    );
    assert_eq!(
        num!(4.0f64),
        num!(3.7f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    );
    assert_eq!(
        num!(-3.0f64),
        num!(-3.2f64).round(0, RoundingStrategy::MidpointAwayFromZero)
    );
}

#[test]
fn test_midpoint_toward_zero_basic() {
    // True midpoints (x.5) - round toward zero
    assert_eq!(
        num!(0.0f64),
        num!(0.5f64).round(0, RoundingStrategy::MidpointTowardZero)
    ); // 0.5 -> 0
    assert_eq!(
        num!(1.0f64),
        num!(1.5f64).round(0, RoundingStrategy::MidpointTowardZero)
    ); // 1.5 -> 1
    assert_eq!(
        num!(2.0f64),
        num!(2.5f64).round(0, RoundingStrategy::MidpointTowardZero)
    ); // 2.5 -> 2

    // Negative midpoints - toward zero means toward positive
    assert_eq!(
        num!(-0.0f64),
        num!(-0.5f64).round(0, RoundingStrategy::MidpointTowardZero)
    ); // -0.5 -> 0
    assert_eq!(
        num!(-1.0f64),
        num!(-1.5f64).round(0, RoundingStrategy::MidpointTowardZero)
    ); // -1.5 -> -1
    assert_eq!(
        num!(-2.0f64),
        num!(-2.5f64).round(0, RoundingStrategy::MidpointTowardZero)
    ); // -2.5 -> -2

    // Non-midpoints round normally (not affected by TowardZero rule)
    assert_eq!(
        num!(4.0f64),
        num!(3.7f64).round(0, RoundingStrategy::MidpointTowardZero)
    );
    assert_eq!(
        num!(-4.0f64),
        num!(-3.7f64).round(0, RoundingStrategy::MidpointTowardZero)
    );
}

#[test]
fn test_to_zero_basic() {
    // Truncation toward zero
    assert_eq!(
        num!(3.0f64),
        num!(3.16f64).round(0, RoundingStrategy::ToZero)
    );
    assert_eq!(
        num!(3.0f64),
        num!(3.99f64).round(0, RoundingStrategy::ToZero)
    );
    assert_eq!(
        num!(-3.0f64),
        num!(-3.16f64).round(0, RoundingStrategy::ToZero)
    );
    assert_eq!(
        num!(-3.0f64),
        num!(-3.99f64).round(0, RoundingStrategy::ToZero)
    );

    // Midpoints truncate toward zero
    assert_eq!(
        num!(0.0f64),
        num!(0.5f64).round(0, RoundingStrategy::ToZero)
    );
    assert_eq!(
        num!(1.0f64),
        num!(1.5f64).round(0, RoundingStrategy::ToZero)
    );
    assert_eq!(
        num!(-0.0f64),
        num!(-0.5f64).round(0, RoundingStrategy::ToZero)
    );
    assert_eq!(
        num!(-1.0f64),
        num!(-1.5f64).round(0, RoundingStrategy::ToZero)
    );

    // Integer types unchanged
    assert_eq!(
        Number::from(42_u64),
        Number::from(42_u64).round(0, RoundingStrategy::ToZero)
    );
    assert_eq!(
        Number::from(-42_i64),
        Number::from(-42_i64).round(0, RoundingStrategy::ToZero)
    );
}

#[test]
fn test_away_from_zero_basic() {
    // Always round away from zero
    assert_eq!(
        num!(4.0f64),
        num!(3.01f64).round(0, RoundingStrategy::AwayFromZero)
    );
    assert_eq!(
        num!(4.0f64),
        num!(3.99f64).round(0, RoundingStrategy::AwayFromZero)
    );
    assert_eq!(
        num!(-4.0f64),
        num!(-3.01f64).round(0, RoundingStrategy::AwayFromZero)
    );
    assert_eq!(
        num!(-4.0f64),
        num!(-3.99f64).round(0, RoundingStrategy::AwayFromZero)
    );

    // Midpoints round away from zero
    assert_eq!(
        num!(1.0f64),
        num!(0.5f64).round(0, RoundingStrategy::AwayFromZero)
    );
    assert_eq!(
        num!(2.0f64),
        num!(1.5f64).round(0, RoundingStrategy::AwayFromZero)
    );
    assert_eq!(
        num!(-1.0f64),
        num!(-0.5f64).round(0, RoundingStrategy::AwayFromZero)
    );
    assert_eq!(
        num!(-2.0f64),
        num!(-1.5f64).round(0, RoundingStrategy::AwayFromZero)
    );

    // Integer types unchanged
    assert_eq!(
        Number::from(42_u64),
        Number::from(42_u64).round(0, RoundingStrategy::AwayFromZero)
    );
    assert_eq!(
        Number::from(-42_i64),
        Number::from(-42_i64).round(0, RoundingStrategy::AwayFromZero)
    );
}

#[test]
fn test_floor_basic() {
    // Floor always rounds toward negative infinity
    assert_eq!(
        num!(3.0f64),
        num!(3.16f64).round(0, RoundingStrategy::Floor)
    );
    assert_eq!(
        num!(3.0f64),
        num!(3.99f64).round(0, RoundingStrategy::Floor)
    );
    assert_eq!(
        num!(-4.0f64),
        num!(-3.16f64).round(0, RoundingStrategy::Floor)
    );
    assert_eq!(
        num!(-4.0f64),
        num!(-3.01f64).round(0, RoundingStrategy::Floor)
    );

    // Midpoints floor toward negative infinity
    assert_eq!(num!(0.0f64), num!(0.5f64).round(0, RoundingStrategy::Floor));
    assert_eq!(num!(1.0f64), num!(1.5f64).round(0, RoundingStrategy::Floor));
    assert_eq!(
        num!(-1.0f64),
        num!(-0.5f64).round(0, RoundingStrategy::Floor)
    );
    assert_eq!(
        num!(-2.0f64),
        num!(-1.5f64).round(0, RoundingStrategy::Floor)
    );

    // Integer types unchanged
    assert_eq!(
        Number::from(42_u64),
        Number::from(42_u64).round(0, RoundingStrategy::Floor)
    );
    assert_eq!(
        Number::from(-42_i64),
        Number::from(-42_i64).round(0, RoundingStrategy::Floor)
    );
}

#[test]
fn test_ceil_basic() {
    // Ceil always rounds toward positive infinity
    assert_eq!(num!(4.0f64), num!(3.01f64).round(0, RoundingStrategy::Ceil));
    assert_eq!(num!(4.0f64), num!(3.99f64).round(0, RoundingStrategy::Ceil));
    assert_eq!(
        num!(-3.0f64),
        num!(-3.99f64).round(0, RoundingStrategy::Ceil)
    );
    assert_eq!(
        num!(-3.0f64),
        num!(-3.01f64).round(0, RoundingStrategy::Ceil)
    );

    // Midpoints ceil toward positive infinity
    assert_eq!(num!(1.0f64), num!(0.5f64).round(0, RoundingStrategy::Ceil));
    assert_eq!(num!(2.0f64), num!(1.5f64).round(0, RoundingStrategy::Ceil));
    assert_eq!(
        num!(-0.0f64),
        num!(-0.5f64).round(0, RoundingStrategy::Ceil)
    );
    assert_eq!(
        num!(-1.0f64),
        num!(-1.5f64).round(0, RoundingStrategy::Ceil)
    );

    // Integer types unchanged
    assert_eq!(
        Number::from(42_u64),
        Number::from(42_u64).round(0, RoundingStrategy::Ceil)
    );
    assert_eq!(
        Number::from(-42_i64),
        Number::from(-42_i64).round(0, RoundingStrategy::Ceil)
    );
}

// =============================================================================
// Decimal Precision Tests - Non-Zero Decimal Places
// =============================================================================

#[test]
fn test_decimal_precision_midpoint_nearest_even() {
    // Test with 2 decimal places - banker's rounding
    assert_eq!(
        num!(1.12f64),
        num!(1.125f64).round(2, RoundingStrategy::MidpointNearestEven)
    ); // 1.125 -> 1.12 (even)
    assert_eq!(
        num!(1.14f64),
        num!(1.135f64).round(2, RoundingStrategy::MidpointNearestEven)
    ); // 1.135 -> 1.14 (even)
    assert_eq!(
        num!(1.12f64),
        num!(1.115f64).round(2, RoundingStrategy::MidpointNearestEven)
    ); // 1.115 -> 1.12 (even)

    // Test with 1 decimal place
    assert_eq!(
        num!(1.2f64),
        num!(1.25f64).round(1, RoundingStrategy::MidpointNearestEven)
    ); // 1.25 -> 1.2 (even)
    assert_eq!(
        num!(1.4f64),
        num!(1.35f64).round(1, RoundingStrategy::MidpointNearestEven)
    ); // 1.35 -> 1.4 (even)

    // Negative values
    assert_eq!(
        num!(-1.12f64),
        num!(-1.125f64).round(2, RoundingStrategy::MidpointNearestEven)
    );
    assert_eq!(
        num!(-1.14f64),
        num!(-1.135f64).round(2, RoundingStrategy::MidpointNearestEven)
    );
}

#[test]
fn test_decimal_precision_midpoint_away_from_zero() {
    // Test with 2 decimal places - round away from zero
    assert_eq!(
        num!(1.13f64),
        num!(1.125f64).round(2, RoundingStrategy::MidpointAwayFromZero)
    ); // 1.125 -> 1.13
    assert_eq!(
        num!(1.14f64),
        num!(1.135f64).round(2, RoundingStrategy::MidpointAwayFromZero)
    ); // 1.135 -> 1.14

    // Test with 1 decimal place
    assert_eq!(
        num!(1.3f64),
        num!(1.25f64).round(1, RoundingStrategy::MidpointAwayFromZero)
    ); // 1.25 -> 1.3
    assert_eq!(
        num!(1.4f64),
        num!(1.35f64).round(1, RoundingStrategy::MidpointAwayFromZero)
    ); // 1.35 -> 1.4

    // Negative values - away from zero means more negative
    assert_eq!(
        num!(-1.13f64),
        num!(-1.125f64).round(2, RoundingStrategy::MidpointAwayFromZero)
    );
    assert_eq!(
        num!(-1.14f64),
        num!(-1.135f64).round(2, RoundingStrategy::MidpointAwayFromZero)
    );
}

#[test]
fn test_decimal_precision_other_strategies() {
    let test_val = num!(1.125f64);

    // Test all strategies with 2 decimal places
    assert_eq!(
        num!(1.12f64),
        test_val.round(2, RoundingStrategy::MidpointTowardZero)
    );
    assert_eq!(num!(1.12f64), test_val.round(2, RoundingStrategy::ToZero));
    assert_eq!(
        num!(1.13f64),
        test_val.round(2, RoundingStrategy::AwayFromZero)
    );
    assert_eq!(num!(1.12f64), test_val.round(2, RoundingStrategy::Floor));
    assert_eq!(num!(1.13f64), test_val.round(2, RoundingStrategy::Ceil));
}

// =============================================================================
// Special Values Tests
// =============================================================================

#[test]
fn test_special_float_values() {
    // Test all strategies with special float values
    let strategies = [
        RoundingStrategy::MidpointNearestEven,
        RoundingStrategy::MidpointAwayFromZero,
        RoundingStrategy::MidpointTowardZero,
        RoundingStrategy::ToZero,
        RoundingStrategy::AwayFromZero,
        RoundingStrategy::Floor,
        RoundingStrategy::Ceil,
    ];

    for strategy in strategies {
        // NaN should remain NaN
        assert!(num!(f64::NAN).round(0, strategy).is_nan());
        assert!(num!(f64::NAN).round(2, strategy).is_nan());

        // Infinity should remain infinity
        assert_eq!(num!(f64::INFINITY), num!(f64::INFINITY).round(0, strategy));
        assert_eq!(
            num!(f64::NEG_INFINITY),
            num!(f64::NEG_INFINITY).round(0, strategy)
        );
        assert_eq!(num!(f64::INFINITY), num!(f64::INFINITY).round(2, strategy));
        assert_eq!(
            num!(f64::NEG_INFINITY),
            num!(f64::NEG_INFINITY).round(2, strategy)
        );

        // Zero should remain zero
        assert_eq!(num!(0.0f64), num!(0.0f64).round(0, strategy));
        assert_eq!(num!(-0.0f64), num!(-0.0f64).round(0, strategy));
        assert_eq!(num!(0.0f64), num!(0.0f64).round(2, strategy));
    }
}

#[test]
fn test_type_preservation() {
    // Test that integer types are preserved for 0 decimal places
    let u32_val = Number::from(42_u64);
    let i32_val = Number::from(-42_i64);
    let u64_val = Number::from(1000_u64);
    let i64_val = Number::from(-1000_i64);

    let strategies = [
        RoundingStrategy::MidpointNearestEven,
        RoundingStrategy::MidpointAwayFromZero,
        RoundingStrategy::MidpointTowardZero,
        RoundingStrategy::ToZero,
        RoundingStrategy::AwayFromZero,
        RoundingStrategy::Floor,
        RoundingStrategy::Ceil,
    ];

    for strategy in strategies {
        assert_eq!(u32_val, u32_val.round(0, strategy));
        assert_eq!(i32_val, i32_val.round(0, strategy));
        assert_eq!(u64_val, u64_val.round(0, strategy));
        assert_eq!(i64_val, i64_val.round(0, strategy));
    }

    // Test that F64 type is preserved
    let f64_val = num!(3.16f64);
    for strategy in strategies {
        if f64_val.round(0, strategy).try_get_f64().is_some() {
            // Type preserved
        } else {
            panic!("F64 type not preserved for strategy {strategy:?}");
        }
    }
}

#[test]
fn test_integer_rounding_with_fractional_places_promotes_to_f64() {
    let unsigned = Number::from(42_u64);
    let rounded_unsigned = unsigned.round(2, RoundingStrategy::MidpointNearestEven);
    assert!(rounded_unsigned.try_get_f64().is_some());
    assert_eq!(rounded_unsigned.try_get_f64().unwrap(), 42.0);

    let signed = Number::from(-7_i64);
    let rounded_signed = signed.round(3, RoundingStrategy::Floor);
    assert!(rounded_signed.try_get_f64().is_some());
    assert_eq!(rounded_signed.try_get_f64().unwrap(), -7.0);
}

// =============================================================================
// Decimal Type Tests (feature-gated)
// =============================================================================

#[cfg(feature = "decimal")]
#[test]
fn test_decimal_type_comprehensive() {
    use rust_decimal::Decimal;

    // Test non-midpoint value 1.25 (rust_decimal treats this as closer to 1 than 2)
    let decimal_125 = Number::from(Decimal::new(125, 2)); // 1.25
    assert_eq!(
        Number::from(Decimal::new(1, 0)),
        decimal_125.round(0, RoundingStrategy::MidpointNearestEven)
    );
    assert_eq!(
        Number::from(Decimal::new(1, 0)),
        decimal_125.round(0, RoundingStrategy::MidpointAwayFromZero)
    );
    assert_eq!(
        Number::from(Decimal::new(1, 0)),
        decimal_125.round(0, RoundingStrategy::MidpointTowardZero)
    );
    assert_eq!(
        Number::from(Decimal::new(1, 0)),
        decimal_125.round(0, RoundingStrategy::ToZero)
    );
    assert_eq!(
        Number::from(Decimal::new(2, 0)),
        decimal_125.round(0, RoundingStrategy::AwayFromZero)
    );
    assert_eq!(
        Number::from(Decimal::new(1, 0)),
        decimal_125.round(0, RoundingStrategy::Floor)
    );
    assert_eq!(
        Number::from(Decimal::new(2, 0)),
        decimal_125.round(0, RoundingStrategy::Ceil)
    );

    // Test true midpoint value 1.5
    let decimal_15 = Number::from(Decimal::new(15, 1)); // 1.5
    assert_eq!(
        Number::from(Decimal::new(2, 0)),
        decimal_15.round(0, RoundingStrategy::MidpointNearestEven)
    ); // 1.5 -> 2 (even)
    assert_eq!(
        Number::from(Decimal::new(2, 0)),
        decimal_15.round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // 1.5 -> 2
    assert_eq!(
        Number::from(Decimal::new(1, 0)),
        decimal_15.round(0, RoundingStrategy::MidpointTowardZero)
    ); // 1.5 -> 1
    assert_eq!(
        Number::from(Decimal::new(1, 0)),
        decimal_15.round(0, RoundingStrategy::ToZero)
    ); // 1.5 -> 1
    assert_eq!(
        Number::from(Decimal::new(2, 0)),
        decimal_15.round(0, RoundingStrategy::AwayFromZero)
    ); // 1.5 -> 2
    assert_eq!(
        Number::from(Decimal::new(1, 0)),
        decimal_15.round(0, RoundingStrategy::Floor)
    ); // 1.5 -> 1
    assert_eq!(
        Number::from(Decimal::new(2, 0)),
        decimal_15.round(0, RoundingStrategy::Ceil)
    ); // 1.5 -> 2

    // Test true midpoint value 2.5 (should round to 2 for MidpointNearestEven)
    let decimal_25 = Number::from(Decimal::new(25, 1)); // 2.5
    assert_eq!(
        Number::from(Decimal::new(2, 0)),
        decimal_25.round(0, RoundingStrategy::MidpointNearestEven)
    ); // 2.5 -> 2 (even)
    assert_eq!(
        Number::from(Decimal::new(3, 0)),
        decimal_25.round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // 2.5 -> 3

    // Test negative values
    let neg_decimal_15 = Number::from(Decimal::new(-15, 1)); // -1.5
    assert_eq!(
        Number::from(Decimal::new(-2, 0)),
        neg_decimal_15.round(0, RoundingStrategy::MidpointNearestEven)
    ); // -1.5 -> -2 (even)
    assert_eq!(
        Number::from(Decimal::new(-2, 0)),
        neg_decimal_15.round(0, RoundingStrategy::MidpointAwayFromZero)
    ); // -1.5 -> -2 (away from zero)
    assert_eq!(
        Number::from(Decimal::new(-1, 0)),
        neg_decimal_15.round(0, RoundingStrategy::MidpointTowardZero)
    ); // -1.5 -> -1 (toward zero)
    assert_eq!(
        Number::from(Decimal::new(-2, 0)),
        neg_decimal_15.round(0, RoundingStrategy::Floor)
    ); // -1.5 -> -2 (floor)
    assert_eq!(
        Number::from(Decimal::new(-1, 0)),
        neg_decimal_15.round(0, RoundingStrategy::Ceil)
    ); // -1.5 -> -1 (ceil)

    // Test decimal precision
    let decimal_1125 = Number::from(Decimal::new(1125, 3)); // 1.125
    assert_eq!(
        Number::from(Decimal::new(112, 2)),
        decimal_1125.round(2, RoundingStrategy::MidpointNearestEven)
    ); // 1.125 -> 1.12 (even)
    assert_eq!(
        Number::from(Decimal::new(113, 2)),
        decimal_1125.round(2, RoundingStrategy::MidpointAwayFromZero)
    ); // 1.125 -> 1.13
}

// =============================================================================
// Consistency and Edge Case Tests
// =============================================================================

#[test]
fn test_consistency_across_types() {
    // Test that equivalent values across different types produce consistent results
    let f64_val = num!(3.5f64);
    let strategies = [
        RoundingStrategy::MidpointNearestEven,
        RoundingStrategy::MidpointAwayFromZero,
        RoundingStrategy::Floor,
        RoundingStrategy::Ceil,
    ];

    for strategy in strategies {
        let f64_result = f64_val.round(0, strategy);

        // Extract the numeric value for comparison
        if let Some(f64_wrapper) = f64_result.try_get_f64() {
            let val = f64_wrapper;
            // 3.5 should round to 4 for all strategies except floor
            match strategy {
                RoundingStrategy::Floor => assert_eq!(val, 3.0),
                _ => assert_eq!(val, 4.0),
            }
        }
    }
}

#[test]
fn test_boundary_cases() {
    // Test values very close to midpoints
    assert_eq!(
        num!(1.0f64),
        num!(1.4999999f64).round(0, RoundingStrategy::MidpointNearestEven)
    );
    assert_eq!(
        num!(2.0f64),
        num!(1.5000001f64).round(0, RoundingStrategy::MidpointNearestEven)
    );

    // Test very small values
    assert_eq!(
        num!(0.0f64),
        num!(0.0001f64).round(0, RoundingStrategy::Floor)
    );
    assert_eq!(
        num!(1.0f64),
        num!(0.0001f64).round(0, RoundingStrategy::Ceil)
    );

    // Test very large values
    assert_eq!(
        num!(1000000.0f64),
        num!(1000000.1f64).round(0, RoundingStrategy::Floor)
    );
    assert_eq!(
        num!(1000001.0f64),
        num!(1000000.1f64).round(0, RoundingStrategy::Ceil)
    );
}

#[test]
fn test_zero_decimal_places_edge_cases() {
    // Ensure 0 decimal places works correctly for all strategies
    let test_values = [
        0.1, 0.5, 0.9, 1.1, 1.5, 1.9, -0.1, -0.5, -0.9, -1.1, -1.5, -1.9,
    ];

    for val in test_values {
        let num_val = num!(val);

        // All strategies should return valid results for 0 decimal places
        let _ = num_val.round(0, RoundingStrategy::MidpointNearestEven);
        let _ = num_val.round(0, RoundingStrategy::MidpointAwayFromZero);
        let _ = num_val.round(0, RoundingStrategy::MidpointTowardZero);
        let _ = num_val.round(0, RoundingStrategy::ToZero);
        let _ = num_val.round(0, RoundingStrategy::AwayFromZero);
        let _ = num_val.round(0, RoundingStrategy::Floor);
        let _ = num_val.round(0, RoundingStrategy::Ceil);
    }
}