uninum 0.1.1

//! Tests for power (exponentiation) operations

use uninum::{Number, num};

/// Tests basic pow operations
#[test]
fn test_basic_pow() {
    // Basic integer powers
    assert_eq!(
        Number::from(2u64).pow(&Number::from(3u64)),
        Number::from(8u64)
    );
    assert_eq!(
        Number::from(10u64).pow(&Number::from(2u64)),
        Number::from(100u64)
    );
    assert_eq!(
        Number::from(-2i64).pow(&Number::from(3u64)),
        Number::from(-8i64)
    );
    assert_eq!(
        Number::from(-2i64).pow(&Number::from(4u64)),
        Number::from(16i64)
    );

    // Power of 0 and 1
    assert_eq!(
        Number::from(42u64).pow(&Number::from(0u64)),
        Number::from(1u64)
    );
    assert_eq!(
        Number::from(42u64).pow(&Number::from(1u64)),
        Number::from(42u64)
    );
    assert_eq!(num!(3.16).pow(&Number::from(0u64)), num!(1.0));

    // 0 to various powers
    assert_eq!(
        Number::from(0u64).pow(&Number::from(0u64)),
        Number::from(1u64)
    ); // 0^0 = 1
    assert_eq!(
        Number::from(0u64).pow(&Number::from(5u64)),
        Number::from(0u64)
    );
    assert_eq!(
        Number::from(0i64).pow(&Number::from(3u64)),
        Number::from(0i64)
    );
}

/// Tests pow overflow handling
#[test]
fn test_pow_overflow() {
    // U64 to U64 overflow
    assert_eq!(
        Number::from(1000u64).pow(&Number::from(3u64)),
        Number::from(1_000_000_000u64)
    );
    assert_eq!(
        Number::from(2u64).pow(&Number::from(32u64)),
        Number::from(4_294_967_296u64)
    );

    // Large base with small exponent
    assert_eq!(
        Number::from(u64::MAX).pow(&Number::from(1u64)),
        Number::from(u64::MAX)
    );
    // Power operations with MAX values may overflow and promote to different types

    // Test with larger bases to ensure mul_ref handles overflow correctly
    let result = Number::from(100u64).pow(&Number::from(5u64));
    if let Some(n) = result.try_get_u64() {
        assert_eq!(n, 10_000_000_000);
    } else if let Some(f) = result.try_get_f64() {
        assert_eq!(f, 10_000_000_000.0);
    } else {
        panic!("Unexpected result type for 100^5");
    }
}

/// Tests pow with float exponents
#[test]
fn test_pow_float_exponents() {
    // Square root
    let result = num!(4.0).pow(&num!(0.5));
    assert_eq!(result, num!(2.0));

    // Cube root
    let result = num!(8.0).pow(&num!(1.0 / 3.0));
    if let Some(f) = result.try_get_f64() {
        assert!((f - 2.0).abs() < 1e-10);
    } else {
        panic!("Expected F64 result for cube root");
    }

    // Fractional powers
    let result = Number::from(4u64).pow(&num!(0.5));
    assert_eq!(result, num!(2.0));

    // Test various number types converting to u64 in pow context
    // U64 that fits in u64
    let base = Number::from(10u64);
    let exp = Number::from(100u64);
    let result = base.pow(&exp);
    assert!(result.try_get_f64().is_some());

    // I64 positive value
    let exp = Number::from(3i64);
    let result = Number::from(2u64).pow(&exp);
    assert_eq!(result, Number::from(8u64));

    // I64 positive value that fits in u64
    let exp = Number::from(4i64);
    let result = Number::from(3u64).pow(&exp);
    assert_eq!(result, Number::from(81u64));

    // Float that is exactly an integer
    let exp = num!(5.0);
    let result = Number::from(2u64).pow(&exp);
    assert_eq!(result, Number::from(32u64));

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

        let exp = Number::from(Decimal::new(3, 0));
        let result = Number::from(4u64).pow(&exp);
        assert_eq!(result, Number::from(64u64));
    }
}

/// Tests pow with negative exponents
#[test]
fn test_pow_negative_exponents() {
    // Integer base with negative exponent
    assert_eq!(Number::from(2u64).pow(&Number::from(-3i64)), num!(0.125));
    assert_eq!(Number::from(10u64).pow(&Number::from(-2i64)), num!(0.01));

    // Float base with negative exponent
    assert_eq!(num!(4.0).pow(&Number::from(-1i64)), num!(0.25));
    assert_eq!(num!(2.0).pow(&Number::from(-3i64)), num!(0.125));

    // Test various number types converting to i64 in pow context
    // I64 negative value that fits in i64
    let exp = Number::from(-2i64);
    let result = Number::from(4u64).pow(&exp);
    assert_eq!(result, num!(0.0625));

    // Float that is exactly a negative integer
    let exp = num!(-3.0);
    let result = Number::from(2u64).pow(&exp);
    assert_eq!(result, num!(0.125));

    // Test with U64 base and various negative exponents
    let base = Number::from(10u64);
    assert_eq!(base.clone().pow(&Number::from(-1i64)), num!(0.1));
    assert_eq!(base.pow(&Number::from(-3i64)), num!(0.001));

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

        let exp = Number::from(Decimal::new(-2, 0));
        let result = Number::from(5u64).pow(&exp);
        assert_eq!(result, num!(0.04));
    }
}

/// Tests pow special cases
#[test]
fn test_pow_special_cases() {
    // 0 to negative power = infinity
    assert_eq!(
        Number::from(0u64).pow(&Number::from(-1i64)),
        num!(f64::INFINITY)
    );
    assert_eq!(num!(0.0).pow(&Number::from(-2i64)), num!(f64::INFINITY));

    // -0 to odd negative power = -infinity
    assert_eq!(
        num!(-0.0).pow(&Number::from(-3i64)),
        num!(f64::NEG_INFINITY)
    );

    // Negative base with non-integer exponent = NaN
    let result = Number::from(-4i64).pow(&num!(0.5));
    assert!(result.is_nan());

    let result = num!(-2.0).pow(&num!(1.5));
    assert!(result.is_nan());

    // Test is_positive check in zero power handling
    // Zero to positive power
    assert_eq!(
        Number::from(0u64).pow(&Number::from(1u64)),
        Number::from(0u64)
    );
    assert_eq!(
        Number::from(0u64).pow(&Number::from(100u64)),
        Number::from(0u64)
    );
    assert_eq!(num!(0.0).pow(&Number::from(5u64)), num!(0.0));

    // Zero to zero (special case)
    assert_eq!(
        Number::from(0u64).pow(&Number::from(0u64)),
        Number::from(1u64)
    );
    assert_eq!(num!(0.0).pow(&Number::from(0u64)), num!(1.0));

    // Zero to negative (should be infinity)
    assert_eq!(
        Number::from(0u64).pow(&Number::from(-1i64)),
        num!(f64::INFINITY)
    );
    assert_eq!(num!(0.0).pow(&Number::from(-5i64)), num!(f64::INFINITY));
}

/// Tests pow with special float values
#[test]
fn test_pow_special_floats() {
    let inf = num!(f64::INFINITY);
    let neg_inf = num!(f64::NEG_INFINITY);
    let nan = num!(f64::NAN);

    // Infinity^positive = Infinity
    assert_eq!(inf.clone().pow(&Number::from(2u64)), num!(f64::INFINITY));
    assert_eq!(inf.clone().pow(&num!(0.5)), num!(f64::INFINITY));

    // Infinity^negative = 0
    assert_eq!(inf.clone().pow(&Number::from(-1i64)), num!(0.0));
    assert_eq!(inf.clone().pow(&num!(-0.5)), num!(0.0));

    // (-Infinity)^even = Infinity
    assert_eq!(
        neg_inf.clone().pow(&Number::from(2u64)),
        num!(f64::INFINITY)
    );

    // (-Infinity)^odd = -Infinity
    assert_eq!(
        neg_inf.clone().pow(&Number::from(3u64)),
        num!(f64::NEG_INFINITY)
    );

    // NaN propagation
    assert!(nan.clone().pow(&Number::from(2u64)).is_nan());
    assert!(Number::from(2u64).pow(&nan.clone()).is_nan());

    // Special: x^0 = 1 (even for NaN and Infinity)
    assert_eq!(inf.clone().pow(&Number::from(0u64)), num!(1.0));
    assert_eq!(nan.clone().pow(&Number::from(0u64)), num!(1.0));

    // Special: 1^x = 1 (even for NaN and Infinity)
    assert_eq!(num!(1.0).pow(&inf), num!(1.0));
    assert_eq!(num!(1.0).pow(&nan), num!(1.0));

    // Test NaN exponent special cases
    let nan_exp = num!(f64::NAN);

    // 1^NaN = 1 (special case)
    assert_eq!(Number::from(1u64).pow(&nan_exp.clone()), Number::from(1u64));
    assert_eq!(num!(1.0).pow(&nan_exp.clone()), num!(1.0));
    assert_eq!(Number::from(1i64).pow(&nan_exp.clone()), Number::from(1i64));

    // x^NaN = NaN for x != 1
    assert!(Number::from(2u64).pow(&nan_exp.clone()).is_nan());
    assert!(num!(0.5).pow(&nan_exp.clone()).is_nan());
    assert!(Number::from(0u64).pow(&nan_exp.clone()).is_nan());
    assert!(Number::from(-1i64).pow(&nan_exp.clone()).is_nan());

    // Edge case: 1.0 exactly
    let almost_one = num!(1.0000000000000002);
    assert!(almost_one.pow(&nan_exp).is_nan());

    // Test cached constants usage
    // get_cached_f64_nan()
    let nan_result = Number::from(0u64).pow(&num!(f64::NAN));
    assert!(nan_result.is_nan());

    // get_cached_f64_infinity()
    let inf_result = Number::from(0u64).pow(&Number::from(-2i64));
    assert_eq!(inf_result, num!(f64::INFINITY));

    // get_cached_f64_neg_infinity() for -0^-odd
    let neg_inf_result = num!(-0.0).pow(&Number::from(-3i64));
    assert_eq!(neg_inf_result, num!(f64::NEG_INFINITY));

    // get_cached_u64_one() in reciprocal
    let recip_result = Number::from(4u64).pow(&Number::from(-1i64));
    assert_eq!(recip_result, num!(0.25));
}

/// Tests pow_by_squaring algorithm edge cases
#[test]
fn test_pow_by_squaring_edge_cases() {
    // Test with power of 2 exponents (exercises the bit manipulation)
    assert_eq!(
        Number::from(3u64).pow(&Number::from(4u64)),
        Number::from(81u64)
    ); // 3^4 = 81
    assert_eq!(
        Number::from(2u64).pow(&Number::from(16u64)),
        Number::from(65536u64)
    ); // 2^16
    assert_eq!(
        Number::from(5u64).pow(&Number::from(8u64)),
        Number::from(390625u64)
    ); // 5^8

    // Test with odd exponents (exercises the exp & 1 check)
    assert_eq!(
        Number::from(2u64).pow(&Number::from(5u64)),
        Number::from(32u64)
    ); // 2^5 = 32
    assert_eq!(
        Number::from(3u64).pow(&Number::from(7u64)),
        Number::from(2187u64)
    ); // 3^7 = 2187

    // Test that exercises all branches of the squaring algorithm
    assert_eq!(
        Number::from(3u64).pow(&Number::from(13u64)),
        Number::from(1594323u64)
    ); // 3^13
}

/// Tests pow with mixed number types
#[test]
fn test_pow_mixed_types() {
    // Mixed integer types (avoiding duplicate U64(2)^3 test)
    assert_eq!(
        Number::from(10u64).pow(&Number::from(2i64)),
        Number::from(100u64)
    );
    assert_eq!(
        Number::from(-3i64).pow(&Number::from(2u64)),
        Number::from(9i64)
    );

    // Float base with different exponent types
    assert_eq!(num!(10.0).pow(&Number::from(-2i64)), num!(0.01));

    // U64 and I64 exponents
    assert_eq!(
        Number::from(3u64).pow(&Number::from(3u64)),
        Number::from(27u64)
    );
    assert_eq!(
        Number::from(4u64).pow(&Number::from(2i64)),
        Number::from(16u64)
    );
}

/// Tests pow chain operations
#[test]
fn test_pow_chains() {
    // (2^3)^2 = 8^2 = 64
    let result = Number::from(2u64)
        .pow(&Number::from(3u64))
        .pow(&Number::from(2u64));
    assert_eq!(result, Number::from(64u64));

    // Chain that causes overflow
    let result = Number::from(2u64)
        .pow(&Number::from(8u64))
        .pow(&Number::from(2u64));
    // 2^8 = 256, and 256^2 = 65536 which is still within U64 range
    assert_eq!(result, Number::from(65536u64));
}

/// Tests edge cases with very small/large values
#[test]
fn test_pow_extreme_values() {
    // Very small base with large exponent
    let result = num!(0.1).pow(&Number::from(100u64));
    if let Some(f) = result.try_get_f64() {
        assert!(f < 1e-50);
    } else {
        #[cfg(feature = "decimal")]
        {
            if result.try_get_decimal().is_none() {
                panic!("Expected F64 or Decimal result");
            }
        }
        #[cfg(not(feature = "decimal"))]
        {
            panic!("Expected F64 result");
        }
    }

    // Small float with large exponent
    let result = num!(0.9).pow(&Number::from(1000u64));
    if let Some(f) = result.try_get_f64() {
        assert!(f < 1e-10);
    } else {
        #[cfg(feature = "decimal")]
        {
            if result.try_get_decimal().is_none() {
                panic!("Expected F64 or Decimal result");
            }
        }
        #[cfg(not(feature = "decimal"))]
        {
            panic!("Expected F64 result");
        }
    }

    // Base close to 1 with large exponent - should be approximately e
    let result = num!(1.0001).pow(&Number::from(10000u64));
    if let Some(f) = result.try_get_f64() {
        assert!((f - std::f64::consts::E).abs() < 0.1);
    } else {
        #[cfg(feature = "decimal")]
        {
            if result.try_get_decimal().is_none() {
                panic!("Expected F64 or Decimal result");
            }
        }
        #[cfg(not(feature = "decimal"))]
        {
            panic!("Expected F64 result");
        }
    }

    // Subnormal numbers
    let subnormal = num!(f64::MIN_POSITIVE / 2.0);
    let result = subnormal.pow(&Number::from(2u64));
    assert!(result.try_get_f64().is_some());

    // Test with very large exponents
    // Large exponent that overflows everything
    let result = Number::from(2u64).pow(&Number::from(1000u64));
    assert!(result.try_get_f64().is_some());

    // Moderately large exponent
    let result = Number::from(10u64).pow(&Number::from(100u64));
    assert!(result.try_get_f64().is_some());

    // Base > 1 with large exponent
    let result = num!(1.1).pow(&Number::from(10000u64));
    assert!(result.try_get_f64().is_some());

    // Base < 1 with large exponent (should approach 0)
    let result = num!(0.9).pow(&Number::from(10000u64));
    #[cfg(feature = "decimal")]
    assert!(result.try_get_f64().is_some() || result.try_get_decimal().is_some());
    #[cfg(not(feature = "decimal"))]
    assert!(result.try_get_f64().is_some());
}

/// Tests negative zero edge cases
#[test]
fn test_pow_negative_zero() {
    let neg_zero = num!(-0.0);
    let pos_zero = num!(0.0);

    // -0^even = +0
    let result = neg_zero.clone().pow(&Number::from(2u64));
    if let Some(f) = result.try_get_f64() {
        assert_eq!(f, 0.0);
        // pow implementation may not preserve sign for 0^n results
    }

    // -0^odd = -0
    let result = neg_zero.clone().pow(&Number::from(3u64));
    if let Some(f) = result.try_get_f64() {
        assert_eq!(f, 0.0);
    }

    // -0^-odd = -infinity
    let result = neg_zero.clone().pow(&Number::from(-3i64));
    assert_eq!(result, num!(f64::NEG_INFINITY));

    // -0^-even = +infinity
    let result = neg_zero.pow(&Number::from(-2i64));
    assert_eq!(result, num!(f64::INFINITY));

    // +0^negative = +infinity
    let result = pos_zero.pow(&Number::from(-5i64));
    assert_eq!(result, num!(f64::INFINITY));
}

/// Negative zero with float exponent that is an integer
#[test]
fn test_pow_negative_zero_with_float_integer_exponent() {
    let neg_zero = num!(-0.0);
    let result = neg_zero.pow(&num!(3.0));
    assert!(matches!(result.try_get_f64(), Some(v) if v == 0.0 && v.is_sign_negative()));
}

/// Tests more special float cases
#[test]
fn test_pow_more_special_floats() {
    // Test denormal/subnormal handling
    let denormal = num!(f64::MIN_POSITIVE / 10.0);
    let result = denormal.clone().pow(&Number::from(1u64));
    assert_eq!(result, denormal);

    // Test with MAX values
    let max_f64 = num!(f64::MAX);
    let result = max_f64.pow(&Number::from(0u64));
    assert_eq!(result, num!(1.0));

    // Test base close to zero with fractional exponent
    let result = num!(0.0001).pow(&num!(0.5));
    if let Some(f) = result.try_get_f64() {
        assert!((f - 0.01).abs() < 1e-10);
    } else {
        panic!("Expected F64 result");
    }
}

/// Tests interaction with integer division/truncation
#[test]
fn test_pow_integer_behavior() {
    // Test that integer^integer returns integer when possible
    assert!(
        Number::from(2u64)
            .pow(&Number::from(10u64))
            .try_get_u64()
            .is_some()
    );
    assert!(
        Number::from(-3i64)
            .pow(&Number::from(5u64))
            .try_get_i64()
            .is_some()
    );

    // Test promotion behavior with mixed signs
    let result = Number::from(-10i64).pow(&Number::from(3u64));
    assert_eq!(result, Number::from(-1000i64));

    // Test very large integer results stay as integers until overflow
    let result = Number::from(2u64).pow(&Number::from(63u64));
    // This may overflow; accept integer or float (and decimal when enabled)
    #[cfg(feature = "decimal")]
    assert!(
        result.try_get_u64().is_some()
            || result.try_get_f64().is_some()
            || result.try_get_decimal().is_some()
    );
    #[cfg(not(feature = "decimal"))]
    assert!(result.try_get_u64().is_some() || result.try_get_f64().is_some());
}

/// Tests edge cases for negative bases
#[test]
fn test_pow_negative_base_edge_cases() {
    // Negative integer base with even exponent
    assert_eq!(
        Number::from(-5i64).pow(&Number::from(2u64)),
        Number::from(25i64)
    );
    assert_eq!(
        Number::from(-5i64).pow(&Number::from(4u64)),
        Number::from(625i64)
    );

    // Positive i64 exponent should use integer path
    assert_eq!(
        Number::from(3i64).pow(&Number::from(2i64)),
        Number::from(9i64)
    );

    // Negative float base with integer exponent
    assert_eq!(num!(-2.5).pow(&Number::from(2u64)), num!(6.25));
    assert_eq!(num!(-2.5).pow(&Number::from(3u64)), num!(-15.625));

    // Negative base with fractional exponent close to integer
    let result = num!(-8.0).pow(&num!(0.9999999999));
    assert!(result.is_nan());

    // Negative base with very small fractional part
    let result = num!(-1.0).pow(&num!(2.0 + 0.00001));
    assert!(result.is_nan());

    // Test the fract() != 0.0 check for negative bases
    // Negative base with exact integer float exponent (should work)
    assert_eq!(num!(-2.0).pow(&num!(3.0)), num!(-8.0));
    assert_eq!(num!(-2.0).pow(&num!(4.0)), num!(16.0));

    // Negative base with fractional exponent (should be NaN)
    assert!(num!(-2.0).pow(&num!(3.1)).is_nan());
    assert!(num!(-2.0).pow(&num!(3.5)).is_nan());
    assert!(num!(-2.0).pow(&num!(3.999999)).is_nan());

    // Edge case: very small fractional part
    assert!(num!(-2.0).pow(&num!(3.0000001)).is_nan());

    // Integer negative base with float exponent
    assert!(Number::from(-4i64).pow(&num!(0.5)).is_nan());
    assert!(Number::from(-4i64).pow(&num!(1.5)).is_nan());

    // But integer exponent stored as float should work
    assert_eq!(Number::from(-4i64).pow(&num!(2.0)), Number::from(16i64));
}

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

    let two = Number::from(Decimal::new(2, 0));
    let three = Number::from(3u64);

    // Decimal base with integer exponent
    let result = two.pow(&three);
    assert!(result.try_get_decimal().is_some());
    if let Some(d) = result.try_get_decimal() {
        assert_eq!(d.to_string(), "8");
    }

    // Decimal with decimal point
    let base = Number::from(Decimal::new(15, 1)); // 1.5
    let exp = Number::from(2u64);
    let result = base.pow(&exp);
    assert!(result.try_get_decimal().is_some());
    if let Some(d) = result.try_get_decimal() {
        assert_eq!(d.to_string(), "2.25");
    }

    // Decimal 0^0
    let zero = Number::from(Decimal::ZERO);
    let result = zero.pow(&Number::from(0u64));
    assert!(result.try_get_decimal().is_some());
    if let Some(d) = result.try_get_decimal() {
        assert_eq!(**d, Decimal::from(1));
    }

    // Integer-like decimal exponent should follow integer path
    let dec_exp = Number::from(Decimal::new(3, 0));
    let result = Number::from(-2i64).pow(&dec_exp);
    assert_eq!(result, Number::from(-8i64));

    // Decimal to negative power
    let two = Number::from(Decimal::new(2, 0));
    let result = two.pow(&Number::from(-2i64));
    if let Some(_d) = result.try_get_decimal() {
        // Any decimal result is acceptable
    } else if let Some(f) = result.try_get_f64() {
        assert_eq!(f, 0.25);
    } else {
        panic!("Unexpected result type");
    }

    // Decimal with float exponent
    let four = Number::from(Decimal::new(4, 0));
    let result = four.pow(&num!(0.5));
    if let Some(_d) = result.try_get_decimal() {
        // Any decimal result is acceptable
    } else if let Some(f) = result.try_get_f64() {
        assert_eq!(f, 2.0);
    } else {
        panic!("Unexpected result type");
    }

    // Large decimal value
    let large = Number::from(Decimal::new(999999999, 0));
    let result = large.pow(&Number::from(1u64));
    assert!(result.try_get_decimal().is_some());

    // Decimal negative base with integer exponent
    let neg = Number::from(Decimal::new(-5, 0));
    let result = neg.pow(&Number::from(3u64));
    if let Some(d) = result.try_get_decimal() {
        assert_eq!(d.to_string(), "-125");
    }

    // Test decimal-specific edge cases

    // Very small decimal to power
    let small = Number::from(Decimal::new(1, 10)); // 0.0000000001
    let result = small.pow(&Number::from(2u64));
    assert!(result.try_get_decimal().is_some());

    // Decimal with maximum precision
    let precise = Number::from(Decimal::from_str_exact("1.234567890123456789012345678").unwrap());
    let result = precise.pow(&Number::from(1u64));
    assert!(result.try_get_decimal().is_some());

    // Negative decimal to even/odd powers
    let neg_dec = Number::from(Decimal::new(-25, 1)); // -2.5
    let even_result = neg_dec.clone().pow(&Number::from(2u64));
    let odd_result = neg_dec.pow(&Number::from(3u64));

    if let Some(d) = even_result.try_get_decimal() {
        assert!(d.is_sign_positive());
    }
    if let Some(d) = odd_result.try_get_decimal() {
        assert!(d.is_sign_negative());
    }

    // Decimal NaN behavior (Decimal doesn't have NaN, but test the path)
    let dec_base = Number::from(Decimal::new(2, 0));
    let nan_exp = num!(f64::NAN);
    assert!(dec_base.pow(&nan_exp).is_nan());

    // Decimal infinity behavior
    let zero_dec = Number::from(Decimal::ZERO);
    let result = zero_dec.pow(&Number::from(-1i64));
    assert_eq!(result, num!(f64::INFINITY));

    // Very large decimal that might overflow
    let max_dec = Number::from(Decimal::MAX);
    let result = max_dec.pow(&Number::from(2u64));
    // Should gracefully convert to F64
    assert!(result.try_get_f64().is_some());

    // Decimal with fractional float exponent
    let dec = Number::from(Decimal::new(4, 0));
    let result = dec.pow(&num!(0.5));
    assert_eq!(result, num!(2.0));
}

/// Tests try_get_i64() positive path coverage
#[test]
fn test_pow_positive_i64_exponent() {
    // Test positive I64 exponent path (line 106-111 in pow.rs)
    // When try_get_i64() returns Some(positive_value), it should fall through
    assert_eq!(
        Number::from(3u64).pow(&Number::from(4i64)),
        Number::from(81u64)
    );
    assert_eq!(
        Number::from(-2i64).pow(&Number::from(5i64)),
        Number::from(-32i64)
    );
    assert_eq!(num!(2.0).pow(&Number::from(3i64)), num!(8.0));

    // Test I64 that fits in I64 range
    assert_eq!(
        Number::from(5u64).pow(&Number::from(3i64)),
        Number::from(125u64)
    );
    assert_eq!(
        Number::from(-3i64).pow(&Number::from(2i64)),
        Number::from(9i64)
    );

    // Test edge cases with I64::MAX
    assert_eq!(
        Number::from(1u64).pow(&Number::from(i64::MAX)),
        Number::from(1u64)
    );
    // Test large negative exponent (but not I64::MIN to avoid overflow)
    let result = Number::from(2u64).pow(&Number::from(-1000i64));
    // 2^-1000 is extremely small, check that it's a valid F64
    if let Some(f) = result.try_get_f64() {
        assert!(f < 1e-300 && f > 0.0);
    } else {
        panic!("Expected F64 result for large negative exponent");
    }
}

/// Tests overflow scenarios in mul_ref during squaring
#[test]
fn test_pow_mul_ref_overflow_scenarios() {
    // Test specific scenarios that exercise mul_ref in pow_by_squaring
    // These test the transition points between number types

    // U64 -> U64 transition during intermediate calculations
    let result = Number::from(65536u64).pow(&Number::from(2u64)); // 2^32
    assert_eq!(result, Number::from(4294967296u64));

    // Test case where intermediate squaring overflows but final doesn't
    let result = Number::from(256u64).pow(&Number::from(2u64)); // 256^2 = 65536
    assert_eq!(result, Number::from(65536u64));

    // Force multiple overflows during squaring algorithm
    let result = Number::from(1024u64).pow(&Number::from(3u64)); // Forces overflow in intermediate steps
    assert_eq!(result, Number::from(1073741824u64));

    // Test negative base overflow
    let result = Number::from(-32768i64).pow(&Number::from(2u64));
    let expected = 32768.0 * 32768.0;
    if let Some(n) = result.try_get_i64() {
        assert_eq!(n, expected as i64);
    } else if let Some(f) = result.try_get_f64() {
        assert_eq!(f, expected);
    } else {
        #[cfg(feature = "decimal")]
        {
            if result.try_get_decimal().is_none() {
                panic!("Unexpected result type: {result:?}");
            }
        }
        #[cfg(not(feature = "decimal"))]
        {
            panic!("Unexpected result type: {result:?}");
        }
    }
}

/// Tests for reciprocal path (1/x) via negative exponents
#[test]
fn test_pow_reciprocal_path() {
    // Test reciprocal of integer
    assert_eq!(Number::from(4u64).pow(&Number::from(-1i64)), num!(0.25));
    assert_eq!(Number::from(100u64).pow(&Number::from(-1i64)), num!(0.01));

    // Test reciprocal squared
    assert_eq!(Number::from(10u64).pow(&Number::from(-2i64)), num!(0.01));
    assert_eq!(Number::from(5u64).pow(&Number::from(-2i64)), num!(0.04));

    // Test large negative exponents
    let result = Number::from(2u64).pow(&Number::from(-10i64));
    assert_eq!(result, num!(1.0 / 1024.0));

    // Test reciprocal of reciprocal
    let recip = Number::from(4u64).pow(&Number::from(-1i64));
    let double_recip = recip.pow(&Number::from(-1i64));
    assert_eq!(double_recip, num!(4.0));
}