flesh/tests/test_lib_decl.rs

mod decl_lib_tests {
    use flesh::ast::{eval, lex, Ctr, SymTable};
    use flesh::stdlib::{dynamic_stdlib, static_stdlib};

    #[test]
    fn test_variable_def_and_lookup() {
        let doc1 = "(def test 'my test var' 1)";
        let doc2 = "test";
        let result = "(1)";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);

        eval(&lex(&doc1.to_string()).unwrap(), &mut syms).unwrap();
        let res = *eval(&lex(&doc2.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(res.to_string(), result);
    }

    #[test]
    fn test_variable_def_and_lookup_list() {
        let doc1 = "(def test 'my test var' (1))";
        let doc2 = "test";
        let result = "((1))";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);

        eval(&lex(&doc1.to_string()).unwrap(), &mut syms).unwrap();
        let res = *eval(&lex(&doc2.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(res.to_string(), result);
    }

    #[test]
    fn test_func_def_and_lookup() {
        let doc1 = "(def test 'my test func' (hello) hello)";
        let doc2 = "(test 1)";
        let result = "1";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);

        eval(&lex(&doc1.to_string()).unwrap(), &mut syms).unwrap();
        let res = *eval(&lex(&doc2.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(res.to_string(), result);
    }

    #[test]
    fn test_variable_def_redef_and_lookup() {
        let doc1 = "(def test 'my test var' 1)";
        let doc2 = "(def test 'my test var' '2')";
        let doc3 = "(test)";
        let result = "('2')";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);

        eval(&lex(&doc1.to_string()).unwrap(), &mut syms).unwrap();
        eval(&lex(&doc2.to_string()).unwrap(), &mut syms).unwrap();
        let res = *eval(&lex(&doc3.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(res.to_string(), result);
    }

    #[test]
    fn test_variable_def_undef_and_lookup_fail() {
        let doc1 = "(def test 'my test var' 1)";
        let doc2 = "(def test)";
        let doc3 = "(test)";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);

        eval(&lex(&doc1.to_string()).unwrap(), &mut syms).unwrap();
        eval(&lex(&doc2.to_string()).unwrap(), &mut syms).unwrap();

        let eval_result = eval(&lex(&doc3.to_string()).unwrap(), &mut syms);
        if let Err(s) = eval_result {
            assert_eq!(
                s.0.first().unwrap().message,
                "(is an undefined symbol)".to_string()
            );
        } else {
            assert!(false);
        }
    }

    #[test]
    fn test_variable_def_redef_via_reference_and_lookup() {
        let doc1 = "(def test 'my test var' 1)";
        let doc2 = "(def ref 'references test' (quote test))";
        let doc3 = "(def ref 'my test var' '2')";
        let test = "(test)";
        let res1 = "(1)";
        let doc4 = "(def (eval ref) 'my test var' '2')";
        let res2 = "('2')";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);

        eval(&lex(&doc1.to_string()).unwrap(), &mut syms).unwrap();
        eval(&lex(&doc2.to_string()).unwrap(), &mut syms).unwrap();
        eval(&lex(&doc3.to_string()).unwrap(), &mut syms).unwrap();
        let r1 = *eval(&lex(&test.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(r1.to_string(), res1);
        eval(&lex(&doc2.to_string()).unwrap(), &mut syms).unwrap();
        eval(&lex(&doc4.to_string()).unwrap(), &mut syms).unwrap();
        let r2 = *eval(&lex(&test.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(r2.to_string(), res2);
    }

    #[test]
    fn test_variable_doc_dynamic() {
        let doc1 = "(def test-doc 'docs for test' 'test tests tests test')";
        let doc2 = "(def test test-doc 'one')";
        let doc3 = "(eq? (and
                           (eq? (get-doc (quote test)) test-doc)
                           (eq? test 'one')))";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);

        eval(&lex(&doc1.to_string()).unwrap(), &mut syms).unwrap();
        eval(&lex(&doc2.to_string()).unwrap(), &mut syms).unwrap();
        if let Ctr::Bool(b) = *eval(&lex(&doc3.to_string()).unwrap(), &mut syms).unwrap() {
            assert!(b);
        } else {
            assert!(false);
        }
    }

    #[test]
    fn test_func_def_no_args() {
        let doc1 = "(def test 'my test func' () 1)";
        let doc2 = "(test)";
        let result = "1";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);

        eval(&lex(&doc1.to_string()).unwrap(), &mut syms).unwrap();
        let res = *eval(&lex(&doc2.to_string()).unwrap(), &mut syms).unwrap();
        assert_eq!(res.to_string(), result);
    }

    #[test]
    fn test_isset_true() {
        let doc1 = "(def test '' 1)";
        let doc2 = "(set? test)";

        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);

        let def_tree = lex(&doc1.to_string()).unwrap();
        let set_tree = lex(&doc2.to_string()).unwrap();
        eval(&def_tree, &mut syms).unwrap();
        if let Ctr::Bool(b) = *eval(&set_tree, &mut syms).unwrap() {
            assert!(b);
        }
    }

    #[test]
    fn test_isset_false() {
        let doc = "(set? test)";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        let set_tree = lex(&doc.to_string()).unwrap();
        if let Ctr::Bool(b) = *eval(&set_tree, &mut syms).unwrap() {
            assert!(!b);
        }
    }

    #[test]
    fn test_env_doesnt_lose_elements() {
        let doc1 = "(def t '' 1)";
        let doc2 = "(env)";
        let doc3 = "t";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        let set_tree = lex(&doc1.to_string()).unwrap();
        let env_tree = lex(&doc2.to_string()).unwrap();
        let tst_tree = lex(&doc3.to_string()).unwrap();
        eval(&set_tree, &mut syms).unwrap();
        eval(&env_tree, &mut syms).unwrap();
        eval(&tst_tree, &mut syms).unwrap();
    }

    #[test]
    fn test_quote() {
        let document = "(quote (add 1 2))";
        let result = "(add 1 2)";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_eval() {
        let document = "
          (let ((stored-tree (quote (add 1 2))))
            (eval stored-tree)))";
        let result = "3";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_eval_basic() {
        let document = "(eval (1 2 3))";
        let result = "(1 2 3)";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            result.to_string(),
        );
    }

    #[test]
    fn test_lambda_str_equivalency_list() {
        let document = "(lambda (x y) (add x y))";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            document.to_string(),
        );
    }

    #[test]
    fn test_lambda_str_equivalency_no_args() {
        let document = "(lambda () (add 1 2))";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        assert_eq!(
            *eval(&lex(&document.to_string()).unwrap(), &mut syms)
                .unwrap()
                .to_string(),
            document.to_string(),
        );
    }

    #[test]
    fn test_lambda_inline_call() {
        let document = "((lambda (x y) (add x y)) 1 2)";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        let it = *eval(
            &lex(&document.to_string()).unwrap(),
            &mut syms).unwrap();
        if let Ctr::Integer(i) = it {
            assert_eq!(i, 3)
        } else {
            panic!()
        }
    }

    #[test]
    fn test_lambda_let_call() {
        let document = "(let ((adder (lambda (x y) (add x y))))
            (adder 1 2))";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
                let it = *eval(
            &lex(&document.to_string()).unwrap(),
            &mut syms).unwrap();
        if let Ctr::Integer(i) = it {
            assert_eq!(i, 3)
        } else {
            panic!()
        }
    }

    #[test]
    fn test_lambda_var_bound_call() {
        let document = "(let (())
            (def adder 'my adder' (lambda (x y) (add x y)))
            (adder 1 2))";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        let it = *eval(
            &lex(&document.to_string()).unwrap(),
            &mut syms).unwrap();
        if let Ctr::Integer(i) = it {
            assert_eq!(i, 3)
        } else {
            panic!()
        }
    }

    #[test]
    fn test_lambda_arg_call() {
        let document = "(let (())
            (def appl '' (func item) (func item))
            (def adder 'my adder' (lambda (x) (add x 1)))
            (appl adder 2))";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        let it = *eval(
            &lex(&document.to_string()).unwrap(),
            &mut syms).unwrap();
        if let Ctr::Integer(i) = it {
            assert_eq!(i, 3)
        } else {
            println!("bad result: {}", it);
            panic!()
        }
    }

    #[test]
    fn test_setget_doc_string() {
        let highly_inadvisable = "(set-doc (q help) 'help')";
        let document = "(get-doc (q help))";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        let _ = *eval(
            &lex(&highly_inadvisable.to_string()).unwrap(),
            &mut syms).unwrap();
        let it = *eval(
            &lex(&document.to_string()).unwrap(),
            &mut syms).unwrap();
        if let Ctr::String(i) = it {
            assert_eq!(i, "help".to_string())
        } else {
            panic!()
        }
    }

    #[test]
    fn test_eval_quote() {
        let doc = "(eval (quote (add 1 1)))";
        let mut syms = SymTable::new();
        static_stdlib(&mut syms);
        dynamic_stdlib(&mut syms, None);
        assert_eq!(
            *eval(&lex(&doc.to_string()).unwrap(), &mut syms).unwrap().to_string(),
            2.to_string()
        )
    }
}