150 lines
4.4 KiB
Rust
150 lines
4.4 KiB
Rust
mod eval_tests {
|
|
use relish::ast::{eval, lex, SYM_TABLE};
|
|
use relish::ast::{Args, Symbol, Ctr, Seg, ValueType, UserFn};
|
|
|
|
// TODO: write generalized testing routine on top of list of inputs
|
|
|
|
#[test]
|
|
fn eval_singlet() {
|
|
let test_doc = "(1)".to_string();
|
|
match lex(&test_doc) {
|
|
Err(e) => {
|
|
println!("Lexing error: {}\n", e);
|
|
assert!(false)
|
|
}
|
|
|
|
Ok(ref initial_ast) => match eval(initial_ast, true, true) {
|
|
Err(e) => {
|
|
println!("Evaluation error: {}\n", e);
|
|
assert!(false)
|
|
}
|
|
|
|
Ok(reduced) => {
|
|
assert_eq!(reduced.to_string(), test_doc)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_embedded_lists_no_funcs() {
|
|
let test_doc = "(1 (1 2 3 4 5) 5)".to_string();
|
|
|
|
match lex(&test_doc) {
|
|
Err(e) => {
|
|
println!("Lexing error: {}\n", e);
|
|
assert!(false)
|
|
}
|
|
|
|
Ok(initial_ast) => match eval(&initial_ast, true, true) {
|
|
Err(e) => {
|
|
println!("Evaluation error: {}\n", e);
|
|
assert!(false)
|
|
}
|
|
|
|
Ok(reduced) => {
|
|
assert_eq!(reduced.to_string(), test_doc)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_function_call() {
|
|
let test_doc = "('one' (echo 'unwrap_me'))".to_string();
|
|
let output = "('one' 'unwrap_me')";
|
|
|
|
{ // we want the write lock to expire before eval
|
|
let mut table_handle = SYM_TABLE.write().unwrap();
|
|
let test_external_func: Symbol = Symbol {
|
|
name: String::from("echo"),
|
|
args: Args::Lazy(1),
|
|
has_undefined_symbols: false,
|
|
value: ValueType::FuncForm( UserFn {
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: Box::new(Seg::from(
|
|
Box::new(Ctr::Seg(Seg::from(
|
|
Box::from(Ctr::Symbol("input".to_string())),
|
|
Box::from(Ctr::None)))),
|
|
Box::new(Ctr::None),
|
|
)),
|
|
}),
|
|
};
|
|
|
|
table_handle.insert(String::from("echo"), test_external_func);
|
|
}
|
|
match lex(&test_doc) {
|
|
Err(e) => {
|
|
println!("Lexing error: {}\n", e);
|
|
assert!(false)
|
|
}
|
|
|
|
Ok(initial_ast) => match eval(&initial_ast, true, true) {
|
|
Err(e) => {
|
|
println!("Evaluation error: {}\n", e);
|
|
assert!(false)
|
|
}
|
|
|
|
Ok(reduced) => {
|
|
assert_eq!(reduced.to_string(), output)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_embedded_func_calls() {
|
|
let test_doc = "('one' (echo (echo 'unwrap_me')))".to_string();
|
|
let output = "('one' 'unwrap_me')";
|
|
|
|
{
|
|
let mut table_handle = SYM_TABLE.write().unwrap();
|
|
let test_external_func: Symbol = Symbol{
|
|
name: String::from("echo"),
|
|
args: Args::Lazy(1),
|
|
has_undefined_symbols: false,
|
|
value: ValueType::FuncForm( UserFn {
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: Box::new(Seg::from(
|
|
Box::new(Ctr::Seg(Seg::from(
|
|
Box::from(Ctr::Symbol("input".to_string())),
|
|
Box::from(Ctr::None)))),
|
|
Box::new(Ctr::None),
|
|
)),
|
|
}),
|
|
};
|
|
|
|
table_handle.insert(String::from("echo"), test_external_func);
|
|
}
|
|
match lex(&test_doc) {
|
|
Err(e) => {
|
|
println!("Lexing error: {}\n", e);
|
|
assert!(false)
|
|
}
|
|
|
|
Ok(initial_ast) => match eval(&initial_ast, true, true) {
|
|
Err(e) => {
|
|
println!("Evaluation error: {}\n", e);
|
|
assert!(false)
|
|
}
|
|
|
|
Ok(reduced) => {
|
|
assert_eq!(reduced.to_string(), output)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
/*
|
|
#[test]
|
|
fn eval_bad_vars() {
|
|
}
|
|
|
|
#[test]
|
|
fn eval_bad_func() {
|
|
}
|
|
|
|
#[test]
|
|
fn eval_verify_all_elems_cloned() {
|
|
}*/
|
|
}
|