390 lines
13 KiB
Rust
390 lines
13 KiB
Rust
mod func_tests {
|
|
use std::rc::Rc;
|
|
use std::cell::RefCell;
|
|
use relish::ast::{Ast, Type, Ctr, new_ast};
|
|
use relish::ast::VTable;
|
|
use relish::ast::{Function, Operation, FTable, Args, func_declare, func_call, ExternalOperation};
|
|
|
|
#[test]
|
|
fn decl_and_call_internal_func() {
|
|
let test_internal_func: Function = Function{
|
|
name: String::from("test_func_in"),
|
|
loose_syms: false,
|
|
eval_lazy: false,
|
|
args: Args::Strict(vec![Type::Bool]),
|
|
function: Operation::Internal(
|
|
|a: Ast, _b: Rc<RefCell<VTable>>, _c: Rc<RefCell<FTable>>| -> Ctr {
|
|
let inner = a.borrow();
|
|
let mut is_bool = false;
|
|
if let Ctr::Bool(_) = &inner.car {
|
|
is_bool = true;
|
|
}
|
|
|
|
Ctr::Bool(is_bool)
|
|
}
|
|
)
|
|
};
|
|
let ft = Rc::new(RefCell::new(FTable::new()));
|
|
let vt = Rc::new(RefCell::new(VTable::new()));
|
|
let args = new_ast(Ctr::Bool(true), Ctr::None);
|
|
if let Some(s) = func_declare(ft.clone(),
|
|
Rc::new(RefCell::new(test_internal_func))) {
|
|
print!("Error declaring internal func: {}", s);
|
|
assert!(false);
|
|
}
|
|
|
|
let func: Rc<RefCell<Function>>;
|
|
if let Some(f) = ft.borrow().get(&"test_func_in".to_string()) {
|
|
func = f.clone();
|
|
} else {
|
|
print!("failed to retrieve function!");
|
|
assert!(false);
|
|
return;
|
|
}
|
|
|
|
if let Ok(ret) = func_call(func, args, vt, ft) {
|
|
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 test_external_func: Function = Function{
|
|
name: String::from("echo"),
|
|
loose_syms: false,
|
|
eval_lazy: false,
|
|
args: Args::Lazy(1),
|
|
function: Operation::External(
|
|
ExternalOperation{
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: new_ast(Ctr::Symbol("input".to_string()), Ctr::None)
|
|
}
|
|
)
|
|
};
|
|
let ft = Rc::new(RefCell::new(FTable::new()));
|
|
let vt = Rc::new(RefCell::new(VTable::new()));
|
|
let args = new_ast(Ctr::String("test".to_string()), Ctr::None);
|
|
if let Some(s) = func_declare(ft.clone(),
|
|
Rc::new(RefCell::new(test_external_func))) {
|
|
print!("Error declaring external func: {}", s);
|
|
assert!(false);
|
|
}
|
|
|
|
let func: Rc<RefCell<Function>>;
|
|
if let Some(f) = ft.borrow().get(&"echo".to_string()) {
|
|
func = f.clone();
|
|
} else {
|
|
print!("failed to retrieve function!");
|
|
assert!(false);
|
|
return;
|
|
}
|
|
|
|
match func_call(func, args, vt, ft) {
|
|
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_dual_ret() {
|
|
let test_external_func: Function = Function{
|
|
name: String::from("echox2"),
|
|
loose_syms: false,
|
|
eval_lazy: false,
|
|
args: Args::Lazy(1),
|
|
function: Operation::External(
|
|
ExternalOperation{
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: new_ast(Ctr::Seg(new_ast(Ctr::Symbol("input".to_string()),
|
|
Ctr::Seg(new_ast(Ctr::Symbol("input".to_string()), Ctr::None)))),
|
|
Ctr::None)
|
|
}
|
|
)
|
|
};
|
|
let ft = Rc::new(RefCell::new(FTable::new()));
|
|
let vt = Rc::new(RefCell::new(VTable::new()));
|
|
let args = new_ast(Ctr::String("test".to_string()), Ctr::None);
|
|
if let Some(s) = func_declare(ft.clone(),
|
|
Rc::new(RefCell::new(test_external_func))) {
|
|
print!("Error declaring external func: {}", s);
|
|
assert!(false);
|
|
}
|
|
|
|
let func: Rc<RefCell<Function>>;
|
|
if let Some(f) = ft.borrow().get(&"echox2".to_string()) {
|
|
func = f.clone();
|
|
} else {
|
|
print!("failed to retrieve function!");
|
|
assert!(false);
|
|
return;
|
|
}
|
|
|
|
match func_call(func, args, vt, ft) {
|
|
Ok(ret) => {
|
|
match ret {
|
|
Ctr::Seg(b) => {
|
|
match b.borrow().clone().car {
|
|
Ctr::String(s) => assert!(s == "test"),
|
|
_ => {
|
|
print!("first elem wrong. expected \"test\", got: {:?}\n", b.borrow().car);
|
|
assert!(false);
|
|
}
|
|
}
|
|
|
|
match b.borrow().clone().cdr {
|
|
Ctr::Seg(b2) => {
|
|
match b2.borrow().clone().car {
|
|
Ctr::String(s) => assert!(s == "test"),
|
|
_ => {
|
|
print!("second elem wrong. expected \"test\", got: {:?}\n", b2.borrow().car);
|
|
assert!(false)
|
|
}
|
|
}
|
|
|
|
match b2.borrow().cdr {
|
|
Ctr::None => (),
|
|
_ => {
|
|
print!("there should not be a third element\n");
|
|
assert!(false)
|
|
}
|
|
}
|
|
},
|
|
_ => {
|
|
print!("first elem cdr should be a list. got: {:?}\n", b.borrow().cdr)
|
|
}
|
|
}
|
|
},
|
|
_ => {
|
|
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_func_with_nested_call() {
|
|
let inner_func: Function = Function{
|
|
name: String::from("test_inner"),
|
|
loose_syms: false,
|
|
eval_lazy: false,
|
|
args: Args::Strict(vec![Type::Bool]),
|
|
function: Operation::Internal(
|
|
|a: Ast, _b: Rc<RefCell<VTable>>, _c: Rc<RefCell<FTable>>| -> Ctr {
|
|
let inner = a.borrow();
|
|
if let Ctr::Bool(b) = &inner.car {
|
|
if *b {
|
|
Ctr::String("test".to_string())
|
|
} else {
|
|
Ctr::None
|
|
}
|
|
} else {
|
|
Ctr::None
|
|
}
|
|
}
|
|
)
|
|
};
|
|
|
|
let outer_func: Function = Function{
|
|
name: String::from("test_outer"),
|
|
loose_syms: false,
|
|
eval_lazy: false,
|
|
args: Args::Lazy(1),
|
|
function: Operation::External(
|
|
ExternalOperation{
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: new_ast(Ctr::Symbol("test_inner".to_string()),
|
|
Ctr::Seg(new_ast(Ctr::Symbol("input".to_string()),
|
|
Ctr::None)))
|
|
}
|
|
)
|
|
};
|
|
|
|
let ft = Rc::new(RefCell::new(FTable::new()));
|
|
let vt = Rc::new(RefCell::new(VTable::new()));
|
|
let args = new_ast(Ctr::Bool(true), Ctr::None);
|
|
|
|
if let Some(s) = func_declare(ft.clone(),
|
|
Rc::new(RefCell::new(inner_func))) {
|
|
print!("Error declaring inner func: {}", s);
|
|
assert!(false);
|
|
}
|
|
if let Some(s) = func_declare(ft.clone(),
|
|
Rc::new(RefCell::new(outer_func))) {
|
|
print!("Error declaring outer func: {}", s);
|
|
assert!(false);
|
|
}
|
|
|
|
let func: Rc<RefCell<Function>>;
|
|
if let Some(f) = ft.borrow().get(&"test_outer".to_string()) {
|
|
func = f.clone();
|
|
} else {
|
|
print!("failed to retrieve function!");
|
|
assert!(false);
|
|
return;
|
|
}
|
|
|
|
match func_call(func, args, vt, ft) {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* This test removed because it would make more sense to test this functionality in eval tests
|
|
* this function tested the evaluation of a complex argument ast that could be reduced in eval
|
|
|
|
#[test]
|
|
fn decl_and_call_func_eval_arg() {
|
|
let is_true_func: Function = Function{
|
|
name: String::from("is_true?"),
|
|
loose_syms: false,
|
|
eval_lazy: false,
|
|
args: Args::Strict(vec![Type::Bool]),
|
|
function: Operation::Internal(
|
|
|a: Ast, _b: Rc<RefCell<VTable>>, _c: Rc<RefCell<FTable>>| -> Ctr {
|
|
let inner = a.borrow();
|
|
if let Ctr::Bool(b) = &inner.car {
|
|
if *b {
|
|
Ctr::String("test".to_string())
|
|
} else {
|
|
Ctr::None
|
|
}
|
|
} else {
|
|
Ctr::None
|
|
}
|
|
}
|
|
)
|
|
};
|
|
|
|
let echo_func: Function = Function{
|
|
name: String::from("echo"),
|
|
loose_syms: false,
|
|
eval_lazy: false,
|
|
args: Args::Lazy(1),
|
|
function: Operation::External(
|
|
ExternalOperation{
|
|
arg_syms: vec!["input".to_string()],
|
|
ast: new_ast(Ctr::Symbol("input".to_string()), Ctr::None)
|
|
}
|
|
)
|
|
};
|
|
|
|
let ft = Rc::new(RefCell::new(FTable::new()));
|
|
let vt = Rc::new(RefCell::new(VTable::new()));
|
|
let args = new_ast(
|
|
Ctr::Seg(new_ast(
|
|
Ctr::Symbol("is_true?".to_string()),
|
|
Ctr::Seg(new_ast(
|
|
Ctr::Bool(true),
|
|
Ctr::None)))),
|
|
Ctr::None);
|
|
|
|
if let Some(s) = func_declare(ft.clone(),
|
|
Rc::new(RefCell::new(is_true_func))) {
|
|
print!("Error declaring inner func: {}", s);
|
|
assert!(false);
|
|
}
|
|
if let Some(s) = func_declare(ft.clone(),
|
|
Rc::new(RefCell::new(echo_func))) {
|
|
print!("Error declaring outer func: {}", s);
|
|
assert!(false);
|
|
}
|
|
|
|
let func: Rc<RefCell<Function>>;
|
|
if let Some(f) = ft.borrow().get(&"echo".to_string()) {
|
|
func = f.clone();
|
|
} else {
|
|
print!("failed to retrieve function!");
|
|
assert!(false);
|
|
return;
|
|
}
|
|
|
|
match func_call(func, args, vt, ft) {
|
|
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 eval_lazy_func_call() {
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn sym_loose_func_call() {
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn too_many_args() {
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn not_enough_args() {
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn bad_eval_arg() {
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn bad_eval_fn_body() {
|
|
|
|
}
|
|
}
|
|
|
|
/* TESTING TODO:
|
|
* - Test functions that eval_lazy
|
|
* - Test functions that sym_loose
|
|
*/
|