flesh/tests/test_vars.rs

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

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

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();

        if let Ok(tree) = lex(&doc1.to_string()) {
            let eval_result = *eval(&tree, &mut syms).unwrap();
            if let Ctr::None = eval_result {
                // pass
            } else {
                eprintln!("bad: {eval_result}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc1");
            assert!(false);
        }

        if let Ok(tree) = lex(&doc2.to_string()) {
            println!("tree: {tree}");
            let eval_result = *eval(&tree, &mut syms).unwrap();
            if let Ctr::Seg(ref i) = eval_result {
                assert_eq!(i.to_string(), result);
            } else {
                eprintln!("bad: {eval_result}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc2");
            assert!(false);
        }
    }

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

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();

        if let Ok(tree) = lex(&doc1.to_string()) {
            let eval_result = *eval(&tree, &mut syms).unwrap();
            if let Ctr::None = eval_result {
                // pass
            } else {
                eprintln!("bad: {eval_result}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc1");
            assert!(false);
        }

        if let Ok(tree) = lex(&doc2.to_string()) {
            let eval_result = *eval(&tree, &mut syms).unwrap();
            if let Ctr::String(ref i) = eval_result {
                assert_eq!(i.to_string(), result);
            } else {
                eprintln!("bad: {eval_result}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc2");
            assert!(false);
        }
    }

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

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();

        if let Ok(tree) = lex(&doc1.to_string()) {
            let eval_result = *eval(&tree, &mut syms).unwrap();
            if let Ctr::None = eval_result {
                // pass
            } else {
                eprintln!("bad: {eval_result}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc1");
            assert!(false);
        }

        if let Ok(tree) = lex(&doc2.to_string()) {
            println!("tree: {tree}");
            let eval_result = *eval(&tree, &mut syms).unwrap();
            if let Ctr::None = eval_result {
                // pass
            } else {
                eprintln!("bad: {eval_result}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc2");
            assert!(false);
        }

        if let Ok(tree) = lex(&doc3.to_string()) {
            println!("tree: {tree}");
            let eval_result = *eval(&tree, &mut syms).unwrap();
            if let Ctr::Seg(ref i) = eval_result {
                assert_eq!(i.to_string(), result);
            } else {
                eprintln!("bad: {eval_result}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc3");
            assert!(false);
        }
    }

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

        let mut syms = SymTable::new();
        static_stdlib(&mut syms).unwrap();
        dynamic_stdlib(&mut syms).unwrap();

        if let Ok(tree) = lex(&doc1.to_string()) {
            let eval_result = *eval(&tree, &mut syms).unwrap();
            if let Ctr::None = eval_result {
                // pass
            } else {
                eprintln!("bad: {eval_result}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc1");
            assert!(false);
        }

        if let Ok(tree) = lex(&doc2.to_string()) {
            println!("tree: {tree}");
            let eval_result = *eval(&tree, &mut syms).unwrap();
            if let Ctr::None = eval_result {
                // pass
            } else {
                eprintln!("bad: {eval_result}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc2");
            assert!(false);
        }

        if let Ok(tree) = lex(&doc3.to_string()) {
            println!("tree: {tree}");
            let eval_result = eval(&tree, &mut syms);
            if let Err(s) = eval_result {
                assert_eq!(
                    s.to_string(),
                    "error in call to test: undefined symbol: test".to_string()
                );
            } else {
                let res = eval_result.unwrap();
                eprintln!("shouldn't have suceeded: {res}");
                assert!(false);
            }
        } else {
            eprintln!("couldn't lex doc3");
            assert!(false);
        }
    }
}