uninum 0.1.1

//! Tests for edge cases and special scenarios
//!
//! This module tests various edge cases, boundary conditions,
//! and special scenarios in conversion operations.

use std::convert::TryFrom;

use uninum::Number;

/// Tests boundary conditions and edge cases
#[test]
fn test_boundary_edge_cases() {
    // Test numbers at exact type boundaries
    assert_eq!(Number::try_from("127").unwrap(), Number::from(127u64));
    assert_eq!(Number::try_from("128").unwrap(), Number::from(128u64));
    assert_eq!(Number::try_from("-127").unwrap(), Number::from(-127i64));
    assert_eq!(Number::try_from("-128").unwrap(), Number::from(-128i64));
    assert_eq!(Number::try_from("-129").unwrap(), Number::from(-129i64));

    assert_eq!(Number::try_from("32767").unwrap(), Number::from(32767u64));
    assert_eq!(Number::try_from("32768").unwrap(), Number::from(32768u64));
    assert_eq!(Number::try_from("-32767").unwrap(), Number::from(-32767i64));
    assert_eq!(Number::try_from("-32768").unwrap(), Number::from(-32768i64));
    assert_eq!(Number::try_from("-32769").unwrap(), Number::from(-32769i64));

    assert_eq!(
        Number::try_from("2147483647").unwrap(),
        Number::from(2147483647u64)
    );
    assert_eq!(
        Number::try_from("2147483648").unwrap(),
        Number::from(2147483648u64)
    );
    assert_eq!(
        Number::try_from("-2147483647").unwrap(),
        Number::from(-2147483647i64)
    );
    assert_eq!(
        Number::try_from("-2147483648").unwrap(),
        Number::from(-2147483648i64)
    );
    assert_eq!(
        Number::try_from("-2147483649").unwrap(),
        Number::from(-2147483649i64)
    );
}

/// Tests very large and very small numbers
#[test]
fn test_conversion_extreme_values() {
    // Test maximum values for each type
    assert_eq!(
        Number::try_from("18446744073709551615").unwrap(),
        Number::from(u64::MAX)
    );
    assert_eq!(
        Number::try_from("9223372036854775807").unwrap(),
        Number::from(i64::MAX)
    );
    assert_eq!(
        Number::try_from("-9223372036854775808").unwrap(),
        Number::from(i64::MIN)
    );

    // Test values that exceed u64::MAX
    #[cfg(feature = "decimal")]
    {
        // Should use Decimal for exact representation
        assert!(
            Number::try_from("18446744073709551616")
                .unwrap()
                .try_get_decimal()
                .is_some()
        );
        assert!(
            Number::try_from("99999999999999999999999999999999")
                .unwrap()
                .try_get_f64()
                .is_some()
        ); // Falls back to F64 if too large for Decimal
    }
    #[cfg(not(feature = "decimal"))]
    {
        // Should use F64
        assert!(
            Number::try_from("18446744073709551616")
                .unwrap()
                .try_get_f64()
                .is_some()
        );
        assert!(
            Number::try_from("99999999999999999999999999999999")
                .unwrap()
                .try_get_f64()
                .is_some()
        );
    }

    // Test very small float values
    assert!(Number::try_from("1e-308").is_ok());
    assert!(Number::try_from("1e-323").is_ok()); // Near f64 subnormal range
    assert!(Number::try_from("1e-324").is_ok()); // f64 MIN_POSITIVE is
    // ~4.9e-324
}

/// Tests special float value handling
#[test]
fn test_special_float_values() {
    // Test infinity representations
    let pos_inf = Number::try_from("inf").unwrap();
    assert!(
        pos_inf
            .try_get_f64()
            .is_some_and(|f| f.is_infinite() && f.is_sign_positive())
    );

    let neg_inf = Number::try_from("-inf").unwrap();
    assert!(
        neg_inf
            .try_get_f64()
            .is_some_and(|f| f.is_infinite() && f.is_sign_negative())
    );

    let pos_inf_caps = Number::try_from("INFINITY").unwrap();
    assert!(pos_inf_caps.try_get_f64().is_some_and(|f| f.is_infinite()));

    let neg_inf_caps = Number::try_from("-INFINITY").unwrap();
    assert!(
        neg_inf_caps
            .try_get_f64()
            .is_some_and(|f| f.is_infinite() && f.is_sign_negative())
    );

    // Test NaN representations
    let nan = Number::try_from("NaN").unwrap();
    assert!(nan.try_get_f64().is_some_and(|f| f.is_nan()));

    let nan_lower = Number::try_from("nan").unwrap();
    assert!(nan_lower.try_get_f64().is_some_and(|f| f.is_nan()));

    // Test with type suffixes should fail
    assert!(Number::try_from("inff64").is_err());
    assert!(Number::try_from("nanf64").is_err());
}

/// Tests zero handling in various forms
#[test]
fn test_zero_variants() {
    // Different zero representations
    assert_eq!(Number::try_from("0").unwrap(), Number::from(0u64));
    assert_eq!(Number::try_from("-0").unwrap(), Number::from(0i64));
    assert_eq!(Number::try_from("+0").unwrap(), Number::from(0u64));
    assert_eq!(Number::try_from("00").unwrap(), Number::from(0u64));
    assert_eq!(Number::try_from("000000").unwrap(), Number::from(0u64));

    // Float zeros
    #[cfg(feature = "decimal")]
    {
        assert!(Number::try_from("0.0").unwrap().try_get_decimal().is_some());
        assert!(
            Number::try_from("-0.0")
                .unwrap()
                .try_get_decimal()
                .is_some()
        );
        assert!(
            Number::try_from("+0.0")
                .unwrap()
                .try_get_decimal()
                .is_some()
        );
        assert!(
            Number::try_from("00.00")
                .unwrap()
                .try_get_decimal()
                .is_some()
        );
    }
    #[cfg(not(feature = "decimal"))]
    {
        assert!(Number::try_from("0.0").unwrap().try_get_f64().is_some());
        assert!(Number::try_from("-0.0").unwrap().try_get_f64().is_some());
        assert!(Number::try_from("+0.0").unwrap().try_get_f64().is_some());
        assert!(Number::try_from("00.00").unwrap().try_get_f64().is_some());
    }

    // Scientific notation zeros
    assert_eq!(Number::try_from("0e10").unwrap(), Number::from(0u64));
    assert_eq!(Number::try_from("0E+5").unwrap(), Number::from(0u64));

    // Scientific notation always uses F64 (not Decimal) even with decimal feature
    assert!(Number::try_from("0.0e-5").unwrap().try_get_f64().is_some());

    // Prefix zeros
    assert_eq!(Number::try_from("0x0").unwrap(), Number::from(0u64));
    assert_eq!(Number::try_from("0o0").unwrap(), Number::from(0u64));
    assert_eq!(Number::try_from("0b0").unwrap(), Number::from(0u64));
}

/// Tests precision edge cases
#[test]
fn test_precision_edge_cases() {
    // Test numbers at f64 precision boundary (53-bit mantissa)
    let exact_f64_max = 9007199254740992u64; // 2^53
    assert_eq!(Number::from(exact_f64_max), Number::from(exact_f64_max));

    let beyond_f64_precision = 9007199254740993u64; // 2^53 + 1
    assert_eq!(
        Number::from(beyond_f64_precision),
        Number::from(beyond_f64_precision)
    );

    // Test very precise decimal representations
    #[cfg(feature = "decimal")]
    {
        // Arc import removed as it's no longer needed

        use rust_decimal::Decimal;

        // Create a very precise decimal
        let precise_decimal = Number::from(Decimal::new(123456789012345, 15));
        assert_eq!(
            precise_decimal,
            Number::from(Decimal::new(123456789012345, 15))
        );
    }
}

/// Tests underscore handling edge cases
#[test]
fn test_underscore_edge_cases() {
    // Valid underscore placements
    assert_eq!(
        Number::try_from("1_000_000").unwrap(),
        Number::from(1_000_000u64)
    );
    assert_eq!(
        Number::try_from("0x1_a_2_b").unwrap(),
        Number::from(0x1a2bu64)
    );
    assert_eq!(
        Number::try_from("0b1010_1010").unwrap(),
        Number::from(0b10101010u64)
    );
    assert_eq!(Number::try_from("0o7_5_5").unwrap(), Number::from(0o755u64));

    // Underscores in different numeric bases
    assert_eq!(
        Number::try_from("0xff_ee_dd").unwrap(),
        Number::from(0xffeedd_u64)
    );
    assert_eq!(
        Number::try_from("0o1_2_3_4").unwrap(),
        Number::from(0o1234u64)
    );
    assert_eq!(
        Number::try_from("0b1111_0000_1010_0101").unwrap(),
        Number::from(0b1111000010100101u64)
    );

    // Underscores with type suffixes
    assert!(Number::try_from("1_000u32").is_err());
    assert!(Number::try_from("0xff_00u32").is_err());

    // Underscores in float literals
    #[cfg(feature = "decimal")]
    assert!(
        Number::try_from("1_234.567_8")
            .unwrap()
            .try_get_decimal()
            .is_some()
    );
    #[cfg(not(feature = "decimal"))]
    assert!(
        Number::try_from("1_234.567_8")
            .unwrap()
            .try_get_f64()
            .is_some()
    );
}

/// Tests whitespace handling
#[test]
fn test_whitespace_handling() {
    // Leading and trailing whitespace should be trimmed
    assert_eq!(Number::try_from("   42   ").unwrap(), Number::from(42u64));
    assert_eq!(Number::try_from("\t\n42\r\n").unwrap(), Number::from(42u64));
    assert_eq!(
        Number::try_from(" \t 42 \r \n ").unwrap(),
        Number::from(42u64)
    );

    // Various whitespace characters
    assert_eq!(Number::try_from(" 42").unwrap(), Number::from(42u64));
    assert_eq!(Number::try_from("42 ").unwrap(), Number::from(42u64));
    assert_eq!(Number::try_from("\t42").unwrap(), Number::from(42u64));
    assert_eq!(Number::try_from("42\n").unwrap(), Number::from(42u64));
    assert_eq!(Number::try_from("\r42").unwrap(), Number::from(42u64));

    // Mixed whitespace
    assert_eq!(
        Number::try_from(" \t\r\n42\r\n\t ").unwrap(),
        Number::from(42u64)
    );

    // Negative numbers with whitespace
    assert_eq!(Number::try_from("  -42  ").unwrap(), Number::from(-42i64));
    assert_eq!(Number::try_from("\t-42\n").unwrap(), Number::from(-42i64));

    // Float numbers with whitespace
    #[cfg(feature = "decimal")]
    assert!(
        Number::try_from("  3.16  ")
            .unwrap()
            .try_get_decimal()
            .is_some()
    );
    #[cfg(not(feature = "decimal"))]
    assert!(
        Number::try_from("  3.16  ")
            .unwrap()
            .try_get_f64()
            .is_some()
    );
}

/// Tests sign handling edge cases
#[test]
fn test_sign_handling() {
    // Explicit positive signs
    assert_eq!(Number::try_from("+42").unwrap(), Number::from(42u64));
    assert_eq!(Number::try_from("+0").unwrap(), Number::from(0u64));
    assert_eq!(Number::try_from("+255").unwrap(), Number::from(255u64));

    // Positive signs with different bases
    assert_eq!(Number::try_from("+0xff").unwrap(), Number::from(255u64));
    assert_eq!(Number::try_from("+0o77").unwrap(), Number::from(63u64));
    assert_eq!(Number::try_from("+0b1010").unwrap(), Number::from(10u64));

    // Positive signs with floats
    #[cfg(feature = "decimal")]
    assert!(
        Number::try_from("+3.16")
            .unwrap()
            .try_get_decimal()
            .is_some()
    );
    #[cfg(not(feature = "decimal"))]
    assert!(Number::try_from("+3.16").unwrap().try_get_f64().is_some());

    // Positive signs with scientific notation
    assert_eq!(Number::try_from("+1e2").unwrap(), Number::from(100u64));
    #[cfg(feature = "decimal")]
    assert!(
        Number::try_from("+1.5e-2")
            .unwrap()
            .try_get_decimal()
            .is_some()
    );
    #[cfg(not(feature = "decimal"))]
    assert!(Number::try_from("+1.5e-2").unwrap().try_get_f64().is_some());

    // Positive signs with type suffixes should fail
    assert!(Number::try_from("+42u32").is_err());
    assert!(Number::try_from("+42i64").is_err());
}

/// Tests complex scientific notation edge cases
#[test]
fn test_complex_scientific_notation() {
    // Very large exponents
    assert!(Number::try_from("1e100").is_ok());
    assert!(Number::try_from("1e308").is_ok()); // Near f64::MAX exponent

    // Very small exponents
    assert!(Number::try_from("1e-100").is_ok());
    assert!(Number::try_from("1e-308").is_ok()); // Near f64::MIN_POSITIVE exponent

    // Complex mantissa with scientific notation
    #[cfg(feature = "decimal")]
    {
        assert!(
            Number::try_from("123.456e-10")
                .unwrap()
                .try_get_decimal()
                .is_some()
        );
        assert!(
            Number::try_from("999.999e+20")
                .unwrap()
                .try_get_decimal()
                .is_some()
        );
    }
    #[cfg(not(feature = "decimal"))]
    {
        assert!(
            Number::try_from("123.456e-10")
                .unwrap()
                .try_get_f64()
                .is_some()
        );
        assert!(
            Number::try_from("999.999e+20")
                .unwrap()
                .try_get_f64()
                .is_some()
        );
    }

    // Scientific notation that resolves to integers
    assert_eq!(Number::try_from("1.0e2").unwrap(), Number::from(100u64));
    assert_eq!(Number::try_from("1.2e1").unwrap(), Number::from(12u64));
    assert_eq!(Number::try_from("5.0e0").unwrap(), Number::from(5u64));

    // Scientific notation with underscores
    assert_eq!(
        Number::try_from("1_000e3").unwrap(),
        Number::from(1_000_000u64)
    );
    #[cfg(feature = "decimal")]
    assert!(
        Number::try_from("1.234_5e-2")
            .unwrap()
            .try_get_decimal()
            .is_some()
    );
    #[cfg(not(feature = "decimal"))]
    assert!(
        Number::try_from("1.234_5e-2")
            .unwrap()
            .try_get_f64()
            .is_some()
    );
}

/// Tests case sensitivity and variations
#[test]
fn test_case_sensitivity() {
    // Hexadecimal case variations (should work)
    assert_eq!(Number::try_from("0xff").unwrap(), Number::from(255u64));
    assert_eq!(Number::try_from("0xFF").unwrap(), Number::from(255u64));
    assert_eq!(Number::try_from("0xaA").unwrap(), Number::from(170u64));
    assert_eq!(Number::try_from("0XFF").unwrap(), Number::from(255u64));

    // Octal and binary case variations (should work)
    assert_eq!(Number::try_from("0o77").unwrap(), Number::from(63u64));
    assert_eq!(Number::try_from("0O77").unwrap(), Number::from(63u64));
    assert_eq!(Number::try_from("0b1010").unwrap(), Number::from(10u64));
    assert_eq!(Number::try_from("0B1010").unwrap(), Number::from(10u64));

    // Scientific notation case variations (should work)
    assert_eq!(Number::try_from("1e2").unwrap(), Number::from(100u64));
    assert_eq!(Number::try_from("1E2").unwrap(), Number::from(100u64));

    // Special float values case variations (should work)
    assert!(
        Number::try_from("inf")
            .unwrap()
            .try_get_f64()
            .is_some_and(|f| f.is_infinite())
    );
    assert!(
        Number::try_from("INF")
            .unwrap()
            .try_get_f64()
            .is_some_and(|f| f.is_infinite())
    );
    assert!(
        Number::try_from("Inf")
            .unwrap()
            .try_get_f64()
            .is_some_and(|f| f.is_infinite())
    );
    assert!(
        Number::try_from("infinity")
            .unwrap()
            .try_get_f64()
            .is_some_and(|f| f.is_infinite())
    );
    assert!(
        Number::try_from("INFINITY")
            .unwrap()
            .try_get_f64()
            .is_some_and(|f| f.is_infinite())
    );

    assert!(
        Number::try_from("nan")
            .unwrap()
            .try_get_f64()
            .is_some_and(|f| f.is_nan())
    );
    assert!(
        Number::try_from("NaN")
            .unwrap()
            .try_get_f64()
            .is_some_and(|f| f.is_nan())
    );
    assert!(
        Number::try_from("NAN")
            .unwrap()
            .try_get_f64()
            .is_some_and(|f| f.is_nan())
    );

    // Type suffixes are case sensitive (should fail)
    assert!(Number::try_from("42U64").is_err());
    assert!(Number::try_from("42I64").is_err());
    assert!(Number::try_from("3.16F64").is_err());
}

/// Tests for memory safety and no panics with extreme inputs
#[test]
fn test_no_panic_extreme_inputs() {
    // These should not panic, regardless of the result
    let _result = Number::try_from("1".repeat(10000).as_str());
    let _result = Number::try_from("0.".repeat(1000).as_str());
    let _result = Number::try_from(format!("1e{}", "9".repeat(100)).as_str());
    let _result = Number::try_from(format!("1e-{}", "9".repeat(100)).as_str());

    // Invalid but potentially problematic inputs
    let _result = Number::try_from("x".repeat(10000).as_str());
    let _result = Number::try_from(format!("0x{}", "g".repeat(1000)).as_str());
    let _result = Number::try_from(format!("{}_", "1".repeat(1000)).as_str());
}