300 lines
9.1 KiB
Rust
300 lines
9.1 KiB
Rust
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 'my test var' 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 'my test func' (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 '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).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 'my test var' 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);
|
|
}
|
|
}
|
|
|
|
#[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).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_isset_true() {
|
|
let doc1 = "(def test '' 1)";
|
|
let doc2 = "(set? test)";
|
|
let mut syms = SymTable::new();
|
|
static_stdlib(&mut syms).unwrap();
|
|
dynamic_stdlib(&mut syms).unwrap();
|
|
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).unwrap();
|
|
dynamic_stdlib(&mut syms).unwrap();
|
|
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).unwrap();
|
|
dynamic_stdlib(&mut syms).unwrap();
|
|
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).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_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).unwrap();
|
|
dynamic_stdlib(&mut syms).unwrap();
|
|
assert_eq!(
|
|
*eval(&lex(&document.to_string()).unwrap(), &mut syms)
|
|
.unwrap()
|
|
.to_string(),
|
|
result.to_string(),
|
|
);
|
|
}
|
|
}
|