mod math_lib_tests {
    use relish::ast::{eval, lex, SymTable};
    use relish::stdlib::{dynamic_stdlib, static_stdlib};

    #[test]
    fn test_add_chain() {
        let document = "(add 1 2 3 4)";
        let result = "10";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_add_chain_mixed() {
        let document = "(add 1 2.2 3 4)";
        let result = "10.2";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_mul_chain() {
        let document = "(mul 1 2 3 4)";
        let result = "24";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_sub_chain() {
        let document = "(sub 1 2.2 3 4)";
        let result = "-8.2";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_div() {
        let document = "(div 10 5)";
        let result = "2";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_float_to_int() {
        let document = "(int 10.5)";
        let result = "10";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_string_to_int() {
        let document = "(int '10')";
        let result = "10";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_int_to_float() {
        let document = "(float 10)";
        let result = "10";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_string_to_float() {
        let document = "(float '10.3')";
        let result = "10.3";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_ii_exp() {
        let document = "(exp 7 20)";
        let result = 7i128.pow(20);

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_if_exp() {
        let document = "(exp 1 10.2)";
        let result = f64::powf(1f64, 10.2);

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_fi_exp() {
        let document = "(exp 1.2 5)";
        let result = f64::powf(1.2, 5f64);

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            format!("{:.5}", result),
        );
    }

    #[test]
    fn test_ff_exp() {
        let document = "(exp 1.3 1.5)";
        let result = f64::powf(1.3, 1.5);

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_ii_mod() {
        let document = "(def test '' (mod 7 3))";
        let check1 = "(car test)";
        let result1 = "2";
        let check2 = "(cdr test)";
        let result2 = "1";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        let _ = *eval(&lex(&document.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&check1.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result1.to_string(),
        );
        assert_eq!(
            *eval(&lex(&check2.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result2.to_string(),
        );
    }

    #[test]
    fn test_if_mod() {
        let document = "(def test '' (mod 7 3.3))";
        let check1 = "(car test)";
        let result1 = "2";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        let _ = *eval(&lex(&document.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&check1.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result1.to_string(),
        );
    }

    #[test]
    fn test_fi_mod() {
        let document = "(def test '' (mod 7.2 2))";
        let check1 = "(car test)";
        let result1 = "3";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        let _ = *eval(&lex(&document.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&check1.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result1.to_string(),
        );
    }

    #[test]
    fn test_ff_mod() {
        let document = "(def test '' (mod 7.2 3.3))";
        let check1 = "(car test)";
        let result1 = "2";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        let _ = *eval(&lex(&document.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&check1.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result1.to_string(),
        );
    }

    #[test]
    fn test_ii_gt_t() {
        let document = "(gt? 4 3)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_ii_gt_f() {
        let document = "(gt? 2 3)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_if_gt_t() {
        let document = "(gt? 4 3.1)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_if_gt_f() {
        let document = "(gt? 3 3.1)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_fi_gt_t() {
        let document = "(gt? 4.1 4)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_fi_gt_f() {
        let document = "(gt? 2.1 3)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_ff_gt_t() {
        let document = "(gt? 3.2 3.1)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_ff_gt_f() {
        let document = "(gt? 3.1 3.2)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_ii_lt_f() {
        let document = "(lt? 4 3)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_ii_lt_t() {
        let document = "(lt? 2 3)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_if_lt_f() {
        let document = "(lt? 4 3.1)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_if_lt_t() {
        let document = "(lt? 3 3.1)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_fi_lt_f() {
        let document = "(lt? 4.1 4)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_fi_lt_t() {
        let document = "(lt? 2.1 3)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_ff_lt_f() {
        let document = "(lt? 3.2 3.1)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_ff_lt_ft() {
        let document = "(lt? 3.1 3.2)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_lte() {
        let document = "(lte? 3.2 3.1)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_lte_e() {
        let document = "(lte? 3.2 3.2)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_gte() {
        let document = "(gte? 3.1 3.2)";
        let result = false;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_gte_e() {
        let document = "(gte? 3.1 3.1)";
        let result = true;

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }
}