calc_rational 3.1.0

use super::{
    BigInt, BigUint, Cache, Evaluator,
    LangErr::MissingTerm,
    O::{Empty, Eval, Store},
    Sign, Vec, vec,
};
#[cfg(feature = "rand")]
use super::{BufRead, LangErr, LendingIterator as _};
#[cfg(feature = "std")]
use super::{E, EvalIter};
#[cfg(not(feature = "rand"))]
use super::{
    LangErr::{
        DivByZero, ExpDivByZero, ExpIsNotIntOrOneHalf, InvalidAbs, InvalidDec, InvalidPar,
        InvalidQuit, InvalidRound, InvalidStore, ModIsNotInt, ModZero, NotEnoughPrevResults,
        NotNonNegIntFact, SqrtDoesNotExist, TrailingSyms,
    },
    O::Exit,
    Ratio,
};
#[cfg(not(feature = "rand"))]
use alloc::{borrow::ToOwned as _, string::ToString as _};
#[cfg(not(feature = "rand"))]
use num_traits::Pow as _;
#[cfg(feature = "rand")]
use num_traits::ToPrimitive as _;
#[cfg(feature = "rand")]
use std::io::{self, Error, Read};
#[expect(clippy::too_many_lines, reason = "a lot to test")]
#[cfg(not(feature = "rand"))]
#[test]
fn empty() {
    // Empty expressions without a previous result return nothing.
    assert_eq!(
        Evaluator::new(b"\n", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Ok(Empty(&None))
    );
    assert_eq!(
        Evaluator::new(
            b"  \t  \t \n",
            &mut Cache::new(),
            &mut Some(Ratio::from_integer(BigInt::from_biguint(
                Sign::Minus,
                BigUint::new(vec![12])
            ))),
            &mut Vec::new()
        )
        .evaluate()
        .map(|a| a.to_string()),
        Ok("> -12".to_owned())
    );
    assert_eq!(
        Evaluator::new(
            b"\t\n",
            &mut Cache::new(),
            &mut Some(Ratio::new(
                BigInt::from_biguint(Sign::Minus, BigUint::new(vec![4])),
                BigInt::from_biguint(Sign::Plus, BigUint::new(vec![6]))
            )),
            &mut Vec::new()
        )
        .evaluate()
        .map(|a| a.to_string()),
        Ok("> -0.666666667".to_owned())
    );
    assert_eq!(
        Evaluator::new(
            b"\t\n",
            &mut Cache::new(),
            &mut Some(Ratio::new(
                BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])),
                BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4_230_196_224, 6]))
            )),
            &mut Vec::new()
        )
        .evaluate()
        .map(|a| a.to_string()),
        Ok("> 0.000000000".to_owned())
    );
    assert_eq!(
        Evaluator::new(
            b"\t\n",
            &mut Cache::new(),
            &mut Some(Ratio::new(
                BigInt::from_biguint(Sign::Plus, BigUint::new(vec![17])),
                BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4_230_196_224, 6]))
            )),
            &mut Vec::new()
        )
        .evaluate()
        .map(|a| a.to_string()),
        Ok("> 0.000000001".to_owned())
    );
    assert_eq!(
        Evaluator::new(
            b"\t\n",
            &mut Cache::new(),
            &mut Some(Ratio::new(
                BigInt::from_biguint(Sign::Plus, BigUint::new(vec![3])),
                BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]))
            )),
            &mut Vec::new()
        )
        .evaluate()
        .map(|a| a.to_string()),
        Ok("> 0.3".to_owned())
    );
    assert_eq!(
        Evaluator::new(
            b"\t\n",
            &mut Cache::new(),
            &mut Some(Ratio::new(
                BigInt::from_biguint(Sign::Minus, BigUint::new(vec![203])),
                BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]))
            )),
            &mut Vec::new()
        )
        .evaluate()
        .map(|a| a.to_string()),
        Ok("> -20.3".to_owned())
    );
    assert_eq!(
        Evaluator::new(
            &[0u8; 0],
            &mut Cache::new(),
            &mut Some(Ratio::new(
                BigInt::from_biguint(Sign::Minus, BigUint::new(vec![203])),
                BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]))
            )),
            &mut Vec::new()
        )
        .evaluate()
        .map(|a| a.to_string()),
        Ok("> -20.3".to_owned())
    );
}
#[expect(clippy::unreachable, reason = "want to crash when there is a bug")]
#[cfg(not(feature = "rand"))]
#[test]
fn number_literal() {
    // Normal 0 is fine.
    assert_eq!(
        Evaluator::new(b"0", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::NoSign,
            BigUint::new(Vec::new())
        ))))
    );
    // Leading 0s and trailing 0s are fine.
    assert_eq!(
        Evaluator::new(b"0000.00000", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::NoSign,
            BigUint::new(Vec::new())
        ))))
    );
    // Parsing stops at first non-(digit/period).
    assert_eq!(
        Evaluator::new(b"1 0", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    let int = b"3397450981271938475135134759823759835414";
    let frac = b"913759810573549872354897210539127530981570";
    let left = Ratio::from_integer(
        BigInt::parse_bytes(int, 10).unwrap_or_else(|| unreachable!("bug in BigInt::parse_bytes")),
    );
    let right = Ratio::new(
        BigInt::parse_bytes(frac, 10).unwrap_or_else(|| unreachable!("bug in BigInt::parse_bytes")),
        BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]).pow(frac.len() + 1)),
    );
    let mut vec = Vec::new();
    vec.extend_from_slice(int);
    vec.push(b'.');
    vec.push(b'0');
    vec.extend_from_slice(frac);
    // Test a number whose integer and fraction portions are larger than u128::MAX.
    assert_eq!(
        Evaluator::new(
            vec.as_slice(),
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_rational(),
        Ok(Some(left + right))
    );
    // Leading 0s and trailing 0s for a non-zero value are fine.
    assert_eq!(
        Evaluator::new(
            b"000000014.0000000000000",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_rational(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![14])
        ))))
    );
    // A sequence of digits followed immediately by a decimal point but no digits after is invalid.
    assert_eq!(
        Evaluator::new(b"1.", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Err(InvalidDec(2))
    );
    // A sequence of digits followed immediately by a decimal point but no digits after is invalid.
    // This just shows that spaces are not ignored in number literals.
    assert_eq!(
        Evaluator::new(b"1. 2", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Err(InvalidDec(2))
    );
    // Non-whitespace starting the input is valid but produces no value.
    // This also shows that an invalid byte sequence does not produce an error here.
    assert_eq!(
        Evaluator::new(b"a1", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Ok(None)
    );
    // A space starting the input is valid but produces no value.
    assert_eq!(
        Evaluator::new(b" 1", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Ok(None)
    );
    // A tab starting the input is valid but produces no value.
    assert_eq!(
        Evaluator::new(b"\t1", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Ok(None)
    );
    // Negative literals don't exist, so this should succeed but produce nothing.
    assert_eq!(
        Evaluator::new(b"-1", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Ok(None)
    );
    // '/' is division and not part of a number literal so only the "numerator" is parsed.
    assert_eq!(
        Evaluator::new(b"1/2", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    // A sequence of digits followed by invalid bytes is valid and produces a number equal to the digits before the invalid bytes.
    assert_eq!(
        Evaluator::new(b"130alj", &mut Cache::new(), &mut None, &mut Vec::new()).get_rational(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![130])
        ))))
    );
}
#[cfg(not(feature = "rand"))]
#[test]
fn par() {
    // Missing closing ')'
    assert_eq!(
        Evaluator::new(b"(1", &mut Cache::new(), &mut None, &mut Vec::new()).get_par(),
        Err(InvalidPar(2))
    );
    assert_eq!(
        Evaluator::new(b"((1\t + 2)", &mut Cache::new(), &mut None, &mut Vec::new()).get_par(),
        Err(InvalidPar(9))
    );
    assert_eq!(
        Evaluator::new(b"(  0 \t )", &mut Cache::new(), &mut None, &mut Vec::new()).get_par(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::NoSign,
            BigUint::new(Vec::new())
        ))))
    );
    assert_eq!(
        Evaluator::new(b"( - \t 5 )", &mut Cache::new(), &mut None, &mut Vec::new()).get_par(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![5])
        ))))
    );
    assert_eq!(
        Evaluator::new(
            b"( ( 2 -\t  5) * 9 )",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_par(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![27])
        ))))
    );
}
#[expect(clippy::too_many_lines, reason = "a lot to test")]
#[expect(
    clippy::indexing_slicing,
    clippy::unwrap_used,
    reason = "comments justify correctness"
)]
#[cfg(not(feature = "rand"))]
#[test]
fn recall_expression() {
    // If the input does not start with '@', then it's valid but produces nothing.
    assert_eq!(
        Evaluator::new(b"1", &mut Cache::new(), &mut None, &mut Vec::new()).get_recall(),
        Ok(None)
    );
    assert_eq!(
        Evaluator::new(b"a", &mut Cache::new(), &mut None, &mut Vec::new()).get_recall(),
        Ok(None)
    );
    assert_eq!(
        Evaluator::new(b" @", &mut Cache::new(), &mut None, &mut Vec::new()).get_recall(),
        Ok(None)
    );
    assert_eq!(
        Evaluator::new(b"\t@", &mut Cache::new(), &mut None, &mut Vec::new()).get_recall(),
        Ok(None)
    );
    // Invalid recall expression since there are no previous results.
    assert_eq!(
        Evaluator::new(b"@", &mut Cache::new(), &mut None, &mut Vec::new()).get_recall(),
        Err(NotEnoughPrevResults(0))
    );
    // Invalid recall expression since there are no previous results.
    assert_eq!(
        Evaluator::new(b"@4", &mut Cache::new(), &mut None, &mut Vec::new()).get_recall(),
        Err(NotEnoughPrevResults(0))
    );
    // Invalid recall expression since there are no previous results.
    // The input violates our grammar, but this error happens before that.
    assert_eq!(
        Evaluator::new(b"@0", &mut Cache::new(), &mut None, &mut Vec::new()).get_recall(),
        Err(NotEnoughPrevResults(0))
    );
    // Successfully extract previous expression.
    let mut prev = None;
    let mut cache = Cache::new();
    // Quick check that `Ok` is returned.
    _ = Evaluator::new(b"1\n", &mut cache, &mut prev, &mut Vec::new())
        .evaluate()
        .unwrap();
    // Quick check that `Ok` is returned.
    _ = Evaluator::new(b"   s   \r\n", &mut cache, &mut prev, &mut Vec::new())
        .evaluate()
        .unwrap();
    assert_eq!(
        Evaluator::new(b"@", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    // Invalid characters are ignored at this stage.
    assert_eq!(
        Evaluator::new(b"@&", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    // 0 is not a valid stored value only 1-8 are.
    assert_eq!(
        Evaluator::new(b"@0", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    // 9 is not a valid stored value only 1-8 are.
    assert_eq!(
        Evaluator::new(b"@9", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    // Spaces are not cleaned; otherwise this would error since we only have 1 stored value.
    assert_eq!(
        Evaluator::new(b"@ 2", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    // Tabs are not cleaned; otherwise this would error since we only have 1 stored value.
    assert_eq!(
        Evaluator::new(b"@\t2", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    // One digits are looked at so this is not @<ten>.
    assert_eq!(
        Evaluator::new(b"@10", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    // Invalid recall expression since there is only one stored result.
    assert_eq!(
        Evaluator::new(b"@2", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Err(NotEnoughPrevResults(1))
    );
    // Quick check that `Ok` is returned.
    _ = Evaluator::new(b"2\r\n", &mut cache, &mut prev, &mut Vec::new())
        .evaluate()
        .unwrap();
    // Quick check that `Ok` is returned.
    _ = Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
        .evaluate()
        .unwrap();
    // Stored values correct.
    assert_eq!(
        Evaluator::new(b"@", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![2])
        ))))
    );
    assert_eq!(
        Evaluator::new(b"@2", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        ))))
    );
    // Invalid recall expression since there are only three stored results.
    assert_eq!(
        Evaluator::new(b"@3", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Err(NotEnoughPrevResults(2))
    );
    let mut v = vec![0, b'\n'];
    for i in b'3'..=b'8' {
        // `v.len() > 0`.
        v[0] = i;
        _ = Evaluator::new(v.as_slice(), &mut cache, &mut prev, &mut Vec::new())
            .evaluate()
            .unwrap();
        _ = Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
            .evaluate()
            .unwrap();
    }
    v[0] = b'@';
    for i in b'1'..=b'8' {
        // `v.len() > 1`.
        v[1] = i;
        // Cache is filled up correctly storing all previous values.
        assert_eq!(
            Evaluator::new(v.as_slice(), &mut cache, &mut prev, &mut Vec::new()).get_recall(),
            Ok(Some(Ratio::from_integer(BigInt::from_biguint(
                Sign::Plus,
                BigUint::new(vec![u32::from(b'9' - i)])
            ))))
        );
    }
    // Only parses the first @ since the second @ is not a digit between 1 and 8.
    assert_eq!(
        Evaluator::new(b"@@", &mut cache, &mut prev, &mut Vec::new()).get_recall(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![8])
        ))))
    );
    // Quick check that `Ok` is returned.
    _ = Evaluator::new(b"9\r\n", &mut cache, &mut prev, &mut Vec::new())
        .evaluate()
        .unwrap();
    // Quick check that `Ok` is returned.
    _ = Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
        .evaluate()
        .unwrap();
    // Oldest value is overwritten; all others remain.
    for i in b'1'..=b'8' {
        // `v.len() > 1`.
        v[1] = i;
        assert_eq!(
            Evaluator::new(v.as_slice(), &mut cache, &mut prev, &mut Vec::new()).get_recall(),
            Ok(Some(Ratio::from_integer(BigInt::from_biguint(
                Sign::Plus,
                BigUint::new(vec![u32::from((b'9' + 1) - i)])
            ))))
        );
    }
}
#[cfg(not(feature = "rand"))]
#[test]
fn abs() {
    // Missing closing '|'
    assert_eq!(
        Evaluator::new(b"|1", &mut Cache::new(), &mut None, &mut Vec::new()).get_abs(),
        Err(InvalidAbs(2))
    );
    assert_eq!(
        Evaluator::new(b"||1 + 2|", &mut Cache::new(), &mut None, &mut Vec::new()).get_abs(),
        Err(InvalidAbs(8))
    );
    assert_eq!(
        Evaluator::new(
            b"|  0\t \t |",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_abs(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::NoSign,
            BigUint::new(Vec::new())
        ))))
    );
    assert_eq!(
        Evaluator::new(b"| -  5 |", &mut Cache::new(), &mut None, &mut Vec::new()).get_abs(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![5])
        ))))
    );
    assert_eq!(
        Evaluator::new(
            b"| \t| 2 -  5| * 9 |",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_abs(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![27])
        ))))
    );
    // If the input does not start with '|', then it's valid but produces nothing.
    assert_eq!(
        Evaluator::new(b" \t|9|", &mut Cache::new(), &mut None, &mut Vec::new()).get_abs(),
        Ok(None)
    );
}
#[cfg(not(feature = "rand"))]
#[test]
fn round() {
    // Missing ',<digit>)'
    assert_eq!(
        Evaluator::new(b"round(1", &mut Cache::new(), &mut None, &mut Vec::new()).get_round(),
        Err(InvalidRound(7))
    );
    assert_eq!(
        Evaluator::new(b"round(1,", &mut Cache::new(), &mut None, &mut Vec::new()).get_round(),
        Err(InvalidRound(8))
    );
    assert_eq!(
        Evaluator::new(b"round(1,2", &mut Cache::new(), &mut None, &mut Vec::new()).get_round(),
        Err(InvalidRound(9))
    );
    assert_eq!(
        Evaluator::new(
            b"round(1,10)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_round(),
        Err(InvalidRound(9))
    );
    assert_eq!(
        Evaluator::new(b"round(1,a)", &mut Cache::new(), &mut None, &mut Vec::new()).get_round(),
        Err(InvalidRound(8))
    );
    assert_eq!(
        Evaluator::new(
            b"round(2, 7)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_round(),
        Ok(Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![2])
        ))))
    );
    assert_eq!(
        Evaluator::new(
            b"round(2.677, 1)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_round(),
        Ok(Some(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![27])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]))
        )))
    );
}
#[expect(clippy::too_many_lines, reason = "a lot to test")]
#[cfg(feature = "rand")]
#[test]
fn rand() {
    assert_eq!(
        Evaluator::new(
            b"rand(1",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng()
        )
        .get_rand(),
        Err(LangErr::InvalidRand(6))
    );
    assert_eq!(
        Evaluator::new(
            b"rand(1,2",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng()
        )
        .get_rand(),
        Err(LangErr::InvalidRand(8))
    );
    assert_eq!(
        Evaluator::new(
            b"rand(1/2,3/4)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng(),
        )
        .get_rand(),
        Err(LangErr::RandNoInts(13))
    );
    assert_eq!(
        Evaluator::new(
            b"rand(-100000000000000000000000,-1000000000000000000000)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng(),
        )
        .get_rand(),
        Err(LangErr::RandNoInts(55))
    );
    assert_eq!(
        Evaluator::new(
            b"rand(2/3,1/3)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng(),
        )
        .get_rand(),
        Err(LangErr::RandInvalidArgs(13))
    );
    // If the input does not start with 'rand(', then it's invalid since get_rand must only be called as the last terminal expression which means whitespace must be consumed already.
    assert_eq!(
        Evaluator::new(
            b" rand(2/3,2)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng(),
        )
        .get_rand(),
        Err(MissingTerm(0))
    );
    assert!(
        Evaluator::new(
            b"rand(2, 7)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng()
        )
        .get_rand()
        .is_ok_and(|r| {
            let int = r.numer();
            int >= &BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2]))
                && *int <= BigInt::from_biguint(Sign::Plus, BigUint::new(vec![7]))
        })
    );
    assert!(
        Evaluator::new(
            b"rand()",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng()
        )
        .get_rand()
        .is_ok_and(|r| {
            let int = r.numer();
            int >= &BigInt::from(i64::MIN) && *int <= BigInt::from(i64::MAX)
        })
    );
    for _ in 0..100u8 {
        assert!(
            Evaluator::new(
                b"rand(2, 2)",
                &mut Cache::new(),
                &mut None,
                &mut Vec::new(),
                &mut rand::rng()
            )
            .get_rand()
            .is_ok_and(|r| *r.numer() == BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])))
        );
    }
}
#[expect(
    clippy::indexing_slicing,
    clippy::unwrap_used,
    reason = "comment justifies correctness"
)]
#[cfg(feature = "rand")]
#[test]
#[ignore = "slow"]
fn rand_uni() {
    const COUNT: u32 = 999_999;
    #[expect(
        clippy::integer_division,
        clippy::integer_division_remainder_used,
        reason = "correct"
    )]
    const LOWER: u32 = COUNT * 33 / 100;
    #[expect(
        clippy::integer_division,
        clippy::integer_division_remainder_used,
        reason = "correct"
    )]
    const UPPER: u32 = COUNT * 101 / 300;
    // Test rand on an interval that is not a power of 2 in size.
    // This causes rand to adjust the interval to enforce uniformity.
    let mut vals = [0u32; 3];
    let mut vec = Vec::new();
    let mut cache = Cache::new();
    let mut none = None;
    for _ in 1..COUNT {
        // We want to `panic` if `rand` does not work correctly.
        vals[usize::try_from(
            Evaluator::new(
                b"rand(-1, 1)",
                &mut cache,
                &mut none,
                &mut vec,
                &mut rand::rng(),
            )
            .get_rand()
            .unwrap()
            .numer()
            .to_i32()
            .unwrap()
                + 1i32,
        )
        .unwrap()] += 1;
    }
    // Test that the distribution is within 1% of what is expected.
    assert_eq!(
        vals.into_iter().try_fold(false, |_, r| {
            if (LOWER..=UPPER).contains(&r) {
                Ok(true)
            } else {
                Err(false)
            }
        }),
        Ok(true)
    );
}
#[allow(
    clippy::allow_attributes,
    reason = "unwrap_used only fires when rand is not enabled"
)]
#[allow(clippy::unwrap_used, reason = "comments justify correctness")]
#[test]
fn term() {
    #[cfg(not(feature = "rand"))]
    assert_eq!(
        Evaluator::new(b"0000.00000", &mut Cache::new(), &mut None, &mut Vec::new()).get_term(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::NoSign,
            BigUint::new(Vec::new())
        )))
    );
    #[cfg(not(feature = "rand"))]
    assert_eq!(
        Evaluator::new(b"(4)", &mut Cache::new(), &mut None, &mut Vec::new()).get_term(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![4])
        )))
    );
    #[cfg(not(feature = "rand"))]
    assert_eq!(
        Evaluator::new(
            b"round(-2/3,2)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_term(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Minus, BigUint::new(vec![67])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![100]))
        ))
    );
    #[cfg(feature = "rand")]
    drop(
        Evaluator::new(
            b"rand()",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng(),
        )
        .get_term()
        .unwrap(),
    );
    #[cfg(feature = "rand")]
    drop(
        Evaluator::new(
            b"rand(-13/93, 833)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new(),
            &mut rand::rng(),
        )
        .get_term()
        .unwrap(),
    );
    #[cfg(not(feature = "rand"))]
    assert_eq!(
        Evaluator::new(b"rand()", &mut Cache::new(), &mut None, &mut Vec::new()).get_term(),
        Err(MissingTerm(0))
    );
    #[cfg(not(feature = "rand"))]
    assert_eq!(
        Evaluator::new(b"|4|", &mut Cache::new(), &mut None, &mut Vec::new()).get_term(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![4])
        )))
    );
    // Terminal expressions do no clean up before or after.
    #[cfg(not(feature = "rand"))]
    assert_eq!(
        Evaluator::new(b" 2", &mut Cache::new(), &mut None, &mut Vec::new()).get_term(),
        Err(MissingTerm(0))
    );
    #[cfg(not(feature = "rand"))]
    let mut prev = None;
    #[cfg(not(feature = "rand"))]
    let mut cache = Cache::new();
    #[cfg(not(feature = "rand"))]
    {
        // Quick check that `Ok` is returned.
        _ = Evaluator::new(b"1\n", &mut cache, &mut prev, &mut Vec::new())
            .evaluate()
            .unwrap();
        // Quick check that `Ok` is returned.
        _ = Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
            .evaluate()
            .unwrap();
    }
    #[cfg(not(feature = "rand"))]
    assert_eq!(
        Evaluator::new(b"@", &mut cache, &mut prev, &mut Vec::new()).get_term(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
}
#[expect(clippy::unwrap_used, reason = "comments justify correctness")]
#[cfg(not(feature = "rand"))]
#[test]
fn factorial() {
    // Negative integer is not allowed.
    assert_eq!(
        Evaluator::new(b"(-1)!", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Err(NotNonNegIntFact(5))
    );
    // Non-integer is not allowed.
    assert_eq!(
        Evaluator::new(b"2.5!", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Err(NotNonNegIntFact(4))
    );
    // factorials always become terminal expressions eventually.
    assert_eq!(
        Evaluator::new(b"7", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![7])
        )))
    );
    assert_eq!(
        Evaluator::new(b"(7)", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![7])
        )))
    );
    assert_eq!(
        Evaluator::new(b"|7|", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![7])
        )))
    );
    let mut prev = None;
    let mut cache = Cache::new();
    // Quick check that `Ok` is returned.
    _ = Evaluator::new(b"3\n", &mut cache, &mut prev, &mut Vec::new())
        .evaluate()
        .unwrap();
    // Quick check that `Ok` is returned.
    _ = Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
        .evaluate()
        .unwrap();
    assert_eq!(
        Evaluator::new(b"@!", &mut cache, &mut prev, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![6])
        )))
    );
    assert_eq!(
        Evaluator::new(b"@", &mut cache, &mut prev, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![3])
        )))
    );
    // 0! = 1.
    assert_eq!(
        Evaluator::new(b"0.0!", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    // 1! = 1.
    assert_eq!(
        Evaluator::new(b"1!", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    // 4! = 24, and whitespace is not consumed.
    assert_eq!(
        Evaluator::new(b"4! \t", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![24])
        )))
    );
    // Factorials can be chained.
    assert_eq!(
        Evaluator::new(b"3!! ", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![720])
        )))
    );
    // only factorial is consumed.
    assert_eq!(
        Evaluator::new(b"2!+3", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![2])
        )))
    );
    // Error since leading/trailing whitespace is not consumed by factorial or higher precedence expressions.
    assert_eq!(
        Evaluator::new(b" 2!", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Err(MissingTerm(0))
    );
    assert_eq!(
        Evaluator::new(b"\t2!", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Err(MissingTerm(0))
    );
    // Error since negation is not consumed by factorial or higher precedence expressions.
    assert_eq!(
        Evaluator::new(b"-2!", &mut Cache::new(), &mut None, &mut Vec::new()).get_fact(),
        Err(MissingTerm(0))
    );
}
#[expect(
    clippy::cognitive_complexity,
    clippy::too_many_lines,
    reason = "a lot to test"
)]
#[cfg(not(feature = "rand"))]
#[test]
fn exp() {
    // 1 can be raised to anything and return 1.
    // Also white space is ignored between operator.
    assert_eq!(
        Evaluator::new(b"1  ^\t  0", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"1^0.5", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"1^(-1/2)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"1.0^(-2)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    // 0 can be raised to any non-negative value and will always return 0 unless raised to 0 which will return 1.
    assert_eq!(
        Evaluator::new(b"0^0", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"0^1", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::NoSign,
            BigUint::new(vec![0])
        )))
    );
    assert_eq!(
        Evaluator::new(b"0^0.5", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::NoSign,
            BigUint::new(vec![0])
        )))
    );
    // Anything else can only be raised to integers.
    assert_eq!(
        Evaluator::new(b"4^0", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"4^1", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![4])
        )))
    );
    assert_eq!(
        Evaluator::new(b"4^(-2)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![16]))
        ))
    );
    assert_eq!(
        Evaluator::new(b"(-4)^0", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"(-4)^1", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![4])
        )))
    );
    assert_eq!(
        Evaluator::new(b"(-4)^2", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![16])
        )))
    );
    assert_eq!(
        Evaluator::new(b"(-4)^(-2)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![16]))
        ))
    );
    assert_eq!(
        Evaluator::new(b"(-4)^(-3)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Minus, BigUint::new(vec![1])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![64]))
        ))
    );
    assert_eq!(
        Evaluator::new(b"(2/3)^0", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"(2/3)^(2)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![9]))
        ))
    );
    assert_eq!(
        Evaluator::new(b"(2/3)^(-3)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![27])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![8]))
        ))
    );
    assert_eq!(
        Evaluator::new(b"(-2/3)^0", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"(-2/3)^(2)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![9]))
        ))
    );
    assert_eq!(
        Evaluator::new(b"(-2/3)^(3)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Minus, BigUint::new(vec![8])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![27]))
        ))
    );
    assert_eq!(
        Evaluator::new(
            b"(-2/3)^(-2)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![9])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4]))
        ))
    );
    assert_eq!(
        Evaluator::new(
            b"(-2/3)^(-3)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Minus, BigUint::new(vec![27])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![8]))
        ))
    );
    assert_eq!(
        Evaluator::new(
            b"(4/9)^(-1/2)",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_exps(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![3])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2]))
        ))
    );
    // Error since 0 cannot be raised to a negative power.
    assert_eq!(
        Evaluator::new(b"0^(-1)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Err(ExpDivByZero(6))
    );
    // Error since anything other than 0 or 1 cannot be raised to a non-integer power or (+/-) 1/2.
    assert_eq!(
        Evaluator::new(b"2^(1/3)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Err(ExpIsNotIntOrOneHalf(7))
    );
    // When exponent is (+/-) 1/2, base has to be the square of a rational number.
    assert_eq!(
        Evaluator::new(b"2^(1/2)", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Err(SqrtDoesNotExist(7))
    );
    // exps always become factorials eventually.
    assert_eq!(
        Evaluator::new(b"3!", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![6])
        )))
    );
    // exponentiation has lower precedence than factorials.
    assert_eq!(
        Evaluator::new(b"2^3!", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![64])
        )))
    );
    assert_eq!(
        Evaluator::new(b"3!^2", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![36])
        )))
    );
    // Error since leading/trailing whitespace is not consumed by exponentiation or higher precedence expressions.
    assert_eq!(
        Evaluator::new(b" 2^2", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Err(MissingTerm(0))
    );
    assert_eq!(
        Evaluator::new(b"\t2^2", &mut Cache::new(), &mut None, &mut Vec::new()).get_exps(),
        Err(MissingTerm(0))
    );
}
#[cfg(not(feature = "rand"))]
#[test]
fn neg() {
    assert_eq!(
        Evaluator::new(b"-1", &mut Cache::new(), &mut None, &mut Vec::new()).get_neg(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"- \t  -  1", &mut Cache::new(), &mut None, &mut Vec::new()).get_neg(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"-0", &mut Cache::new(), &mut None, &mut Vec::new()).get_neg(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::NoSign,
            BigUint::new(Vec::new())
        )))
    );
    // negation has lower precedence than exponentiation.
    assert_eq!(
        Evaluator::new(b"-2^2", &mut Cache::new(), &mut None, &mut Vec::new()).get_neg(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![4])
        )))
    );
    // negation always becomes exponentiation eventually.
    assert_eq!(
        Evaluator::new(b"2.0^2.0", &mut Cache::new(), &mut None, &mut Vec::new()).get_neg(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![4])
        )))
    );
    // Error since leading/trailing whitespace is not consumed by exponentiation or higher precedence expressions.
    assert_eq!(
        Evaluator::new(b" -2", &mut Cache::new(), &mut None, &mut Vec::new()).get_neg(),
        Err(MissingTerm(0))
    );
    assert_eq!(
        Evaluator::new(b"\t-2", &mut Cache::new(), &mut None, &mut Vec::new()).get_neg(),
        Err(MissingTerm(0))
    );
}
#[expect(
    clippy::cognitive_complexity,
    clippy::too_many_lines,
    reason = "a lot to test"
)]
#[cfg(not(feature = "rand"))]
#[test]
fn mult() {
    assert_eq!(
        Evaluator::new(b"2  *   3", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![6])
        )))
    );
    assert_eq!(
        Evaluator::new(
            b"-2  * \t  3",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![6])
        )))
    );
    assert_eq!(
        Evaluator::new(
            b"2\t  *   -3.0",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![6])
        )))
    );
    assert_eq!(
        Evaluator::new(b"-2.5*-3.5", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![35])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4]))
        ))
    );
    assert_eq!(
        Evaluator::new(b"4.0\t /  6", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![3]))
        ))
    );
    assert_eq!(
        Evaluator::new(b"6/3", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![2])
        )))
    );
    assert_eq!(
        Evaluator::new(b"-6/3", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![2])
        )))
    );
    assert_eq!(
        Evaluator::new(b"6/-3", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![2])
        )))
    );
    assert_eq!(
        Evaluator::new(
            b"-  6 /\t -  3",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![2])
        )))
    );
    // Number literals are not strictly equivalent to "ratios" as "ratios" don't exist (i.e., 2/3 is not the ratio of 2 to 3 but is the rational number two divided by the rational number 3).
    assert!(
        Evaluator::new(b"1/1.5", &mut Cache::new(), &mut None, &mut Vec::new())
            .get_mults()
            .is_ok_and(|r| {
                Evaluator::new(b"1/3/2", &mut Cache::new(), &mut None, &mut Vec::new())
                    .get_mults()
                    .is_ok_and(|r2| r != r2)
            })
    );
    assert!(
        Evaluator::new(b"1/1.5", &mut Cache::new(), &mut None, &mut Vec::new())
            .get_mults()
            .is_ok_and(|r| {
                Evaluator::new(b"1/(3/2)", &mut Cache::new(), &mut None, &mut Vec::new())
                    .get_mults()
                    .is_ok_and(|r2| r == r2)
            })
    );
    // multiplication always becomes negation eventually.
    assert_eq!(
        Evaluator::new(b"-2.0", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![2])
        )))
    );
    // Error since leading/trailing whitespace is not consumed by multiplication or higher precedence expressions.
    assert_eq!(
        Evaluator::new(b" 2*2", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Err(MissingTerm(0))
    );
    assert_eq!(
        Evaluator::new(b"\t2/2", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Err(MissingTerm(0))
    );
    assert_eq!(
        Evaluator::new(
            b"4.0\t mod  6",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![4])
        ),))
    );
    assert_eq!(
        Evaluator::new(b"5 mod 3", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![2])
        )))
    );
    assert_eq!(
        Evaluator::new(b"-5 mod 3", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"5 mod -3", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![2])
        )))
    );
    assert_eq!(
        Evaluator::new(
            b"-5   mod\t -3",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    // Cannot divide by 0.
    assert_eq!(
        Evaluator::new(b"2/0", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Err(DivByZero(3))
    );
    assert_eq!(
        Evaluator::new(b"2 mod 0", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Err(ModZero(7))
    );
    // Right and left operands of mod must be integers.
    assert_eq!(
        Evaluator::new(b"3.2 mod 1", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Err(ModIsNotInt(4))
    );
    assert_eq!(
        Evaluator::new(b"3 mod 3.2", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Err(ModIsNotInt(9))
    );
    // multiplication has lower precedence than exponentiation.
    assert_eq!(
        Evaluator::new(b"2*2^2", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![8])
        )))
    );
    assert_eq!(
        Evaluator::new(b"8/2^2", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![2])
        )))
    );
    assert_eq!(
        Evaluator::new(b"8 mod 3^2", &mut Cache::new(), &mut None, &mut Vec::new()).get_mults(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![8])
        )))
    );
}
#[expect(clippy::too_many_lines, reason = "a lot to test")]
#[cfg(not(feature = "rand"))]
#[test]
fn add() {
    assert_eq!(
        Evaluator::new(b"2  +   3", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![5])
        )))
    );
    assert_eq!(
        Evaluator::new(b"-2  +   3", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(
            b"2  +  \t -3.0",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![1])
        )))
    );
    assert_eq!(
        Evaluator::new(b"-2.5+-3.5", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![6])
        )))
    );
    assert_eq!(
        Evaluator::new(b"4.0\t -  6", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![2])
        )))
    );
    assert_eq!(
        Evaluator::new(b"6-3", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![3])
        )))
    );
    assert_eq!(
        Evaluator::new(b"-6-3", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![9])
        )))
    );
    assert_eq!(
        Evaluator::new(b"6--3", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![9])
        )))
    );
    assert_eq!(
        Evaluator::new(
            b"-  6 -\t -  3",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![3])
        )))
    );
    // addition always becomes multiplication eventually.
    assert_eq!(
        Evaluator::new(b"2 * 8", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![16])
        )))
    );
    assert_eq!(
        Evaluator::new(b"8 /\t 2", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![4])
        )))
    );
    // Error since leading/trailing whitespace is not consumed by addition or higher precedence expressions.
    assert_eq!(
        Evaluator::new(b" 2+2", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Err(MissingTerm(0))
    );
    assert_eq!(
        Evaluator::new(b" 2-2", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Err(MissingTerm(0))
    );
    // addition has lower precedence than multiplication.
    assert_eq!(
        Evaluator::new(b"2+2*2", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![6])
        )))
    );
    assert_eq!(
        Evaluator::new(b"2+2/2", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![3])
        )))
    );
    assert_eq!(
        Evaluator::new(b"2-2*2", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Minus,
            BigUint::new(vec![2])
        )))
    );
    assert_eq!(
        Evaluator::new(b"2-2/2", &mut Cache::new(), &mut None, &mut Vec::new()).get_adds(),
        Ok(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))
    );
}
#[cfg(not(feature = "rand"))]
#[test]
fn exit() {
    assert_eq!(
        Evaluator::new(b"  q    \n", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Ok(Exit)
    );
    assert_eq!(
        Evaluator::new(
            b"  q    \r\n",
            &mut Cache::new(),
            &mut None,
            &mut Vec::new()
        )
        .evaluate(),
        Ok(Exit)
    );
    assert_eq!(
        Evaluator::new(b"q\n", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Ok(Exit)
    );
    assert_eq!(
        Evaluator::new(b"q\r\n", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Ok(Exit)
    );
    assert_eq!(
        Evaluator::new(b"\rq\n", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Err(MissingTerm(0))
    );
    assert_eq!(
        Evaluator::new(b"\tq\n", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Ok(Exit)
    );
    assert_eq!(
        Evaluator::new(b"q\n\n", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Err(InvalidQuit)
    );
    assert_eq!(
        Evaluator::new(b"\nq\n", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Err(MissingTerm(0))
    );
    assert_eq!(
        Evaluator::new(b"q", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Ok(Exit)
    );
}
#[expect(clippy::unwrap_used, reason = "comment justifies correctness")]
#[cfg(not(feature = "rand"))]
#[test]
fn store() {
    let mut prev = None;
    let mut cache = Cache::new();
    // Quick check that `Ok` is returned.
    _ = Evaluator::new(b"1\n", &mut cache, &mut prev, &mut Vec::new())
        .evaluate()
        .unwrap();
    assert!(cache.is_empty());
    assert_eq!(
        Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new()).evaluate(),
        Ok(Store(&Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![1])
        )))))
    );
    assert_eq!(cache.len(), 1);
    assert_eq!(
        Evaluator::new(b"s2\n", &mut Cache::new(), &mut None, &mut Vec::new()).evaluate(),
        Err(InvalidStore)
    );
}
#[expect(clippy::too_many_lines, reason = "a lot to test")]
#[cfg(not(feature = "rand"))]
#[test]
fn eval() {
    use core::str::FromStr as _;
    let mut prev = None;
    let mut cache = Cache::new();
    let mut exp = Vec::new();
    assert_eq!(
        Evaluator::new(b"1+2\n", &mut cache, &mut prev, &mut exp).evaluate(),
        Ok(Eval(&Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![3])
        ))))
    );
    assert_eq!(
        Evaluator::new(b"\t  s  \n", &mut cache, &mut prev, &mut exp).evaluate(),
        Ok(Store(&Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![3])
        )))))
    );
    assert_eq!(
        Evaluator::new(b"-1/2+2*@\n", &mut cache, &mut prev, &mut exp).evaluate(),
        Ok(Eval(&Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![11])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2]))
        )))
    );
    assert_eq!(
        Evaluator::new(b"s\n", &mut cache, &mut prev, &mut exp).evaluate(),
        Ok(Store(&Some(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![11])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2]))
        ))))
    );
    assert_eq!(
        Evaluator::new(b"@^@2!\r\n", &mut cache, &mut prev, &mut exp).evaluate(),
        Ok(Eval(&Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1_771_561])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![64]))
        )))
    );
    assert_eq!(
        Evaluator::new(b"s\n", &mut cache, &mut prev, &mut exp).evaluate(),
        Ok(Store(&Some(Ratio::new(
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1_771_561])),
            BigInt::from_biguint(Sign::Plus, BigUint::new(vec![64]))
        ))))
    );
    // Verified with Wolfram Alpha.
    assert!(
            Evaluator::new(
                b" \t 1 + (2 * |(7.98\t - 12/7)|) / 4!^@3!^|1-3|\t  \n",
                &mut cache,
                &mut prev,
                &mut exp
            )
            .evaluate().is_ok_and(|r| {
                Ratio::from_str("2841328814244153299237884950647090899374680152474331/2841328814244153299237884950647090899374680152473600").is_ok_and(|r2| {
                    r == Eval(&r2)
                })
            })
        );
    assert_eq!(
        Evaluator::new(
            b" \t round(19/6,0)!\t  \r\n",
            &mut cache,
            &mut prev,
            &mut exp
        )
        .evaluate(),
        Ok(Eval(&Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![6])
        ))))
    );
    assert_eq!(
        Evaluator::new(
            b" \t 2^round(19/6,0)!\t  \r\n",
            &mut cache,
            &mut prev,
            &mut exp
        )
        .evaluate(),
        Ok(Eval(&Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![64])
        ))))
    );
    assert_eq!(
        Evaluator::new(b"round(19/6,0)^2\t\n", &mut cache, &mut prev, &mut exp).evaluate(),
        Ok(Eval(&Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![9])
        ))))
    );
    // Invalid UTF-8 does not cause a panic!.
    assert_eq!(
        Evaluator::new(&[255, 255, 255, b'\n'], &mut cache, &mut prev, &mut exp).evaluate(),
        Err(MissingTerm(0))
    );
    assert_eq!(
        Evaluator::new(&[b'2', 255, b'\n'], &mut cache, &mut prev, &mut exp).evaluate(),
        Err(TrailingSyms(1))
    );
    // Exactly one newline is required.
    assert_eq!(
        Evaluator::new(b"2\n\n", &mut cache, &mut prev, &mut exp).evaluate(),
        Err(TrailingSyms(1))
    );
    assert_eq!(
        prev,
        Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![9])
        )))
    );
    assert_eq!(
        Evaluator::new(b"\n", &mut cache, &mut prev.clone(), &mut exp).evaluate(),
        Ok(Empty(&Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![9])
        )))))
    );
    assert_eq!(
        prev,
        Some(Ratio::from_integer(BigInt::from_biguint(
            Sign::Plus,
            BigUint::new(vec![9])
        )))
    );
    assert_eq!(
        Evaluator::new(b"\r\n", &mut cache, &mut prev.clone(), &mut exp).evaluate(),
        Ok(Empty(&prev))
    );
    assert_eq!(
        Evaluator::new(&[0u8; 0], &mut cache, &mut prev.clone(), &mut exp).evaluate(),
        Ok(Empty(&prev))
    );
}
#[cfg(feature = "rand")]
#[test]
fn eval_iter() {
    struct Reader<'a> {
        data: &'a [u8],
        err: bool,
    }
    impl<'a> Reader<'a> {
        fn new(data: &'a [u8]) -> Self {
            Self { data, err: true }
        }
    }
    impl Read for Reader<'_> {
        #[expect(clippy::indexing_slicing, reason = "comment justifies correctness")]
        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
            if self.err {
                self.err = false;
                Err(Error::other(""))
            } else {
                let len = usize::min(buf.len(), self.data.len());
                // `len <= buf.len()` and `len <= `self.data.len()`.
                buf[..len].copy_from_slice(&self.data[..len]);
                Ok(len)
            }
        }
    }
    impl BufRead for Reader<'_> {
        fn fill_buf(&mut self) -> io::Result<&[u8]> {
            if self.err {
                self.err = false;
                Err(Error::other(""))
            } else {
                Ok(self.data)
            }
        }
        #[expect(clippy::indexing_slicing, reason = "comment justifies correctness")]
        fn consume(&mut self, amount: usize) {
            // This is just a test, so calling code passing in an invalid `amount` is fine.
            self.data = &self.data[amount..];
        }
    }
    let mut iter = EvalIter::new(Reader::new(
        b"1+2\n4\n\nq\n5\ns\nrand() + rand(-139/@, 2984/134)\nab",
    ));
    assert!(
        iter.lend_next()
            .is_some_and(|res| res.map_or_else(|e| matches!(e, E::Error(_)), |_| false))
    );
    assert!(iter.lend_next().is_some_and(|res| {
        res.is_ok_and(|e| matches!(e, Eval(r) if r.numer().to_i32() == Some(3i32)))
    }));
    assert!(iter.lend_next().is_some_and(|res| {
        res.is_ok_and(|e| matches!(e, Eval(r) if r.numer().to_i32() == Some(4i32)))
    }));
    assert!(iter.lend_next().is_some_and(|res| {
            res.is_ok_and(
                |e| matches!(e, Empty(r) if r.as_ref().is_some_and(|val| val.numer().to_i32() == Some(4i32))),
            )
        }));
    assert!(iter.lend_next().is_none());
    assert!(iter.lend_next().is_some_and(|res| {
        res.is_ok_and(|e| matches!(e, Eval(r) if r.numer().to_i32() == Some(5i32)))
    }));
    assert!(iter.lend_next().is_some_and(|res| {
            res.is_ok_and(
                |e| matches!(e, Store(r) if r.as_ref().is_some_and(|val| val.numer().to_i32() == Some(5i32))),
            )
        }));
    assert!(
        iter.lend_next()
            .is_some_and(|res| res.is_ok_and(|e| matches!(e, Eval(r) if r.is_integer())))
    );
    assert!(iter.lend_next().is_some_and(|res| {
        res.is_err_and(|err| matches!(err, E::LangErr(ref e) if matches!(*e, MissingTerm(_))))
    }));
    assert!(iter.lend_next().is_none());
    assert!(iter.lend_next().is_none());
    assert!(iter.lend_next().is_none());
}
#[ignore = "only to silence lint"]
#[cfg(feature = "std")]
#[test]
fn silence_dead_pub_in_binary_when_only_std() {
    drop(E::LangErr(MissingTerm(0)));
    drop(EvalIter::new(b""));
}