302 lines
11 KiB
Rust
302 lines
11 KiB
Rust
mod func_tests {
|
|
use relish::ast::lex;
|
|
use relish::ast::{Args, Ctr, Seg, Symbol, ValueType};
|
|
use relish::ast::{SymTable, Type, UserFn};
|
|
use std::rc::Rc;
|
|
|
|
#[test]
|
|
fn decl_and_call_internal_func() {
|
|
let mut syms = SymTable::new();
|
|
let test_internal_func: Symbol = Symbol {
|
|
name: String::from("test_func_in"),
|
|
conditional_branches: false,
|
|
args: Args::Strict(vec![Type::Bool]),
|
|
value: ValueType::Internal(Rc::new(
|
|
|a: &Seg, _: &mut SymTable| -> Result<Ctr, String> {
|
|
let inner = a;
|
|
let mut is_bool = false;
|
|
if let Ctr::Bool(_) = *inner.car {
|
|
is_bool = true;
|
|
}
|
|
Ok(Ctr::Bool(is_bool))
|
|
},
|
|
)),
|
|
};
|
|
let args = Seg::from(Box::new(Ctr::Bool(true)), Box::new(Ctr::None));
|
|
|
|
syms.insert(String::from("test_func_in"), test_internal_func);
|
|
|
|
if let Ok(ret) = syms.call_symbol(&"test_func_in".to_string(), &args, true) {
|
|
match *ret {
|
|
Ctr::Bool(b) => assert!(b),
|
|
_ => {
|
|
print!("invalid return from func!");
|
|
assert!(false);
|
|
}
|
|
}
|
|
} else {
|
|
print!("call to function failed!");
|
|
assert!(false);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn decl_and_call_external_func_singlet() {
|
|
let mut syms = SymTable::new();
|
|
match lex(&"input".to_string()) {
|
|
Err(e) => panic!("{}", e),
|
|
Ok(finner) => {
|
|
let test_external_func: Symbol = Symbol {
|
|
name: String::from("echo"),
|
|
conditional_branches: false,
|
|
args: Args::Lazy(1),
|
|
value: ValueType::FuncForm(UserFn {
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: finner,
|
|
}),
|
|
};
|
|
|
|
let args = Seg::from(
|
|
Box::new(Ctr::String("test".to_string())),
|
|
Box::new(Ctr::None),
|
|
);
|
|
|
|
syms.insert(String::from("test_func_in"), test_external_func);
|
|
|
|
match syms.call_symbol(&"test_func_in".to_string(), &args, true) {
|
|
Ok(ret) => match *ret {
|
|
Ctr::String(b) => assert!(b == "test"),
|
|
_ => {
|
|
print!("Invalid return from func. Got {:?}\n", ret);
|
|
assert!(false);
|
|
}
|
|
},
|
|
Err(e) => {
|
|
print!("Call to function failed: {}\n", e);
|
|
assert!(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn decl_and_call_external_func_multi_body() {
|
|
let mut syms = SymTable::new();
|
|
match lex(&"(input input)".to_string()) {
|
|
Err(e) => panic!("{}", e),
|
|
Ok(finner) => {
|
|
let test_external_func: Symbol = Symbol {
|
|
name: String::from("echo_2"),
|
|
conditional_branches: false,
|
|
args: Args::Lazy(1),
|
|
value: ValueType::FuncForm(UserFn {
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: finner,
|
|
}),
|
|
};
|
|
|
|
let args = Seg::from(
|
|
Box::new(Ctr::String("test".to_string())),
|
|
Box::new(Ctr::None),
|
|
);
|
|
|
|
syms.insert(String::from("echo_2"), test_external_func);
|
|
|
|
match syms.call_symbol(&"echo_2".to_string(), &args, true) {
|
|
Ok(ret) => assert_eq!(ret.to_string(), "'test'"),
|
|
Err(e) => {
|
|
print!("Call to function failed: {}\n", e);
|
|
assert!(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn decl_and_call_func_with_nested_call() {
|
|
let mut syms = SymTable::new();
|
|
let inner_func: Symbol = Symbol {
|
|
name: String::from("test_inner"),
|
|
conditional_branches: false,
|
|
args: Args::Strict(vec![Type::Bool]),
|
|
value: ValueType::Internal(Rc::new(
|
|
|a: &Seg, _: &mut SymTable| -> Result<Ctr, String> {
|
|
let inner = a;
|
|
if let Ctr::Bool(b) = *inner.car {
|
|
if b {
|
|
Ok(Ctr::String("test".to_string()))
|
|
} else {
|
|
Ok(Ctr::None)
|
|
}
|
|
} else {
|
|
Err("not a bool".to_string())
|
|
}
|
|
},
|
|
)),
|
|
};
|
|
|
|
match lex(&"((test_inner true))".to_string()) {
|
|
Err(e) => panic!("{}", e),
|
|
Ok(finner) => {
|
|
let outer_func: Symbol = Symbol {
|
|
name: String::from("test_outer"),
|
|
conditional_branches: false,
|
|
args: Args::Lazy(1),
|
|
value: ValueType::FuncForm(UserFn {
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: finner,
|
|
}),
|
|
};
|
|
|
|
let args = Seg::from(Box::new(Ctr::Bool(true)), Box::new(Ctr::None));
|
|
|
|
syms.insert(String::from("test_inner"), inner_func);
|
|
syms.insert(String::from("test_outer"), outer_func);
|
|
|
|
match syms.call_symbol(&"test_outer".to_string(), &args, true) {
|
|
Ok(ret) => match *ret {
|
|
Ctr::String(b) => assert!(b == "test"),
|
|
_ => {
|
|
print!("Invalid return from func. Got {:?}\n", ret);
|
|
assert!(false);
|
|
}
|
|
},
|
|
Err(e) => {
|
|
print!("Call to function failed: {}\n", e);
|
|
assert!(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn arg_type_mismatch() {
|
|
let mut syms = SymTable::new();
|
|
let test_internal_func: Symbol = Symbol {
|
|
name: String::from("test_func_in"),
|
|
conditional_branches: false,
|
|
args: Args::Strict(vec![Type::Bool]),
|
|
value: ValueType::Internal(Rc::new(
|
|
|a: &Seg, _: &mut SymTable| -> Result<Ctr, String> {
|
|
let inner = a;
|
|
let mut is_bool = false;
|
|
if let Ctr::Bool(_) = *inner.car {
|
|
is_bool = true;
|
|
}
|
|
Ok(Ctr::Bool(is_bool))
|
|
},
|
|
)),
|
|
};
|
|
let args = Seg::from(Box::new(Ctr::Integer(1)), Box::new(Ctr::None));
|
|
|
|
syms.insert(String::from("test_func_in"), test_internal_func);
|
|
|
|
if let Err(s) = syms.call_symbol(&"test_func_in".to_string(), &args, true) {
|
|
assert_eq!(s, "failure to call test_func_in: arg 1 expected to be bool");
|
|
} else {
|
|
print!("call to function succeeded (shouldnt have)");
|
|
assert!(false);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn too_many_args() {
|
|
let mut syms = SymTable::new();
|
|
match lex(&"(input)".to_string()) {
|
|
Err(e) => panic!("{}", e),
|
|
Ok(finner) => {
|
|
let test_external_func: Symbol = Symbol {
|
|
name: String::from("echo"),
|
|
conditional_branches: false,
|
|
args: Args::Lazy(1),
|
|
value: ValueType::FuncForm(UserFn {
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: finner,
|
|
}),
|
|
};
|
|
|
|
let args = Seg::from(
|
|
Box::new(Ctr::String("test".to_string())),
|
|
Box::new(Ctr::Seg(Seg::from_mono(Box::new(Ctr::Integer(1))))),
|
|
);
|
|
|
|
syms.insert(String::from("test_func_in"), test_external_func);
|
|
|
|
if let Err(s) = syms.call_symbol(&"test_func_in".to_string(), &args, true) {
|
|
assert_eq!(s, "failure to call echo: expected 1 args. Got 2.");
|
|
} else {
|
|
print!("call to function succeeded (shouldnt have)");
|
|
assert!(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn too_few_args() {
|
|
let mut syms = SymTable::new();
|
|
match lex(&"(input)".to_string()) {
|
|
Err(e) => panic!("{}", e),
|
|
Ok(finner) => {
|
|
let test_external_func: Symbol = Symbol {
|
|
name: String::from("echo"),
|
|
conditional_branches: false,
|
|
args: Args::Lazy(1),
|
|
value: ValueType::FuncForm(UserFn {
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: finner,
|
|
}),
|
|
};
|
|
|
|
let args = Seg::new();
|
|
syms.insert(String::from("test_func_in"), test_external_func);
|
|
|
|
if let Err(s) = syms.call_symbol(&"test_func_in".to_string(), &args, true) {
|
|
assert_eq!(s, "failure to call echo: expected 1 args. Got 0.");
|
|
} else {
|
|
print!("call to function succeeded (shouldnt have)");
|
|
assert!(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn arg_cant_eval() {
|
|
let mut syms = SymTable::new();
|
|
let test_internal_func: Symbol = Symbol {
|
|
name: String::from("test_func_in"),
|
|
conditional_branches: false,
|
|
args: Args::Strict(vec![Type::Bool]),
|
|
value: ValueType::Internal(Rc::new(
|
|
|a: &Seg, _: &mut SymTable| -> Result<Ctr, String> {
|
|
let inner = a;
|
|
let mut is_bool = false;
|
|
if let Ctr::Bool(_) = *inner.car {
|
|
is_bool = true;
|
|
}
|
|
Ok(Ctr::Bool(is_bool))
|
|
},
|
|
)),
|
|
};
|
|
let args = Seg::from(
|
|
Box::new(Ctr::Symbol("undefined-symbol".to_string())),
|
|
Box::new(Ctr::None),
|
|
);
|
|
|
|
syms.insert(String::from("test_func_in"), test_internal_func);
|
|
|
|
if let Err(s) = syms.call_symbol(&"test_func_in".to_string(), &args, true) {
|
|
assert_eq!(
|
|
s,
|
|
"error in call to undefined-symbol: undefined symbol: undefined-symbol"
|
|
);
|
|
} else {
|
|
print!("call to function succeeded (shouldnt have)");
|
|
assert!(false);
|
|
}
|
|
}
|
|
}
|