flesh/tests/test_eval.rs

mod func_tests {
    use std::rc::Rc;
    use std::cell::RefCell;
    use relish::ast::{Ctr, Function, Operation, ExternalOperation};
    use relish::ast::{new_ast, lex, eval, VTable, FTable, ast_to_string};
    use relish::ast::{func_declare, Args};

    // TODO: write generalized testing routine on top of list of inputs

    #[test]
    fn eval_singlet() {
        let test_doc = "(1)".to_string();
        let ft = Rc::new(RefCell::new(FTable::new()));
        let vt = Rc::new(RefCell::new(VTable::new()));

        match lex(test_doc.clone()) {
            Err(e) => {
                println!("Lexing error: {}\n", e);
                assert!(false)
            },

            Ok(initial_ast) => {
                match eval(initial_ast.clone(), vt.clone(), ft.clone(), false) {
                    Err(e) => {
                        println!("Evaluation error: {}\n", e);
                        assert!(false)
                    },

                    Ok(reduced) => {
                        if let Ctr::Seg(reduced_ast) = reduced {
                            assert_eq!(ast_to_string(reduced_ast), test_doc)
                        }
                    }
                }
            }
        }
    }

    #[test]
    fn eval_embedded_lists_no_funcs() {
        let test_doc = "(1 (1 2 3 4 5) 5)".to_string();
        let ft = Rc::new(RefCell::new(FTable::new()));
        let vt = Rc::new(RefCell::new(VTable::new()));

        match lex(test_doc.clone()) {
            Err(e) => {
                println!("Lexing error: {}\n", e);
                assert!(false)
            },

            Ok(initial_ast) => {
                match eval(initial_ast.clone(), vt.clone(), ft.clone(), false) {
                    Err(e) => {
                        println!("Evaluation error: {}\n", e);
                        assert!(false)
                    },

                    Ok(reduced) => {
                        if let Ctr::Seg(reduced_ast) = reduced {
                            assert_eq!(ast_to_string(reduced_ast), test_doc)
                        }
                    }
                }
            }
        }
    }

    #[test]
    fn eval_function_call() {
        let test_doc = "('one' (echo 'unwrap_me'))".to_string();
        let output = "('one' 'unwrap_me')";
        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::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()));
        if let Some(s) = func_declare(ft.clone(),
                                      Rc::new(RefCell::new(test_external_func))) {
            print!("Error declaring external func: {}", s);
            assert!(false);
        }

        match lex(test_doc) {
            Err(e) => {
                println!("Lexing error: {}\n", e);
                assert!(false)
            },

            Ok(initial_ast) => {
                match eval(initial_ast.clone(), vt.clone(), ft.clone(), false) {
                    Err(e) => {
                        println!("Evaluation error: {}\n", e);
                        assert!(false)
                    },

                    Ok(reduced) => {
                        if let Ctr::Seg(reduced_ast) = reduced {
                            let out_doc = ast_to_string(reduced_ast);
                            if out_doc != output {
                                print!("Erroneous output: {}\n", out_doc);
                                assert!(false)
                            }
                        }
                    }
                }
            }
        }
    }

    /*
    #[test]
    fn eval_embedded_func_calls() {
        let test_doc = "1".to_string();
        let ft = Rc::new(RefCell::new(FTable::new()));
        let vt = Rc::new(RefCell::new(VTable::new()));

        match lex(test_doc) {
            Err(e) => {
                println!("Lexing error: {}\n", e);
                assert!(false)
            },

            Ok(initial_ast) => {
                match eval(initial_ast.clone(), vt.clone(), ft.clone(), false) {
                    Err(e) => {
                        println!("Evaluation error: {}\n", e);
                        assert!(false)
                    },

                    Ok(reduced_ast) => {
                        // write tests here
                    }
                }
            }
        }
    }

    #[test]
    fn eval_bad_vars() {
        let test_doc = "1".to_string();
        let ft = Rc::new(RefCell::new(FTable::new()));
        let vt = Rc::new(RefCell::new(VTable::new()));

        match lex(test_doc) {
            Err(e) => {
                println!("Lexing error: {}\n", e);
                assert!(false)
            },

            Ok(initial_ast) => {
                match eval(initial_ast.clone(), vt.clone(), ft.clone(), false) {
                    Err(e) => {
                        println!("Evaluation error: {}\n", e);
                        assert!(false)
                    },

                    Ok(reduced_ast) => {
                        // write tests here
                    }
                }
            }
        }
    }

    #[test]
    fn eval_bad_func() {
        let test_doc = "1".to_string();
        let ft = Rc::new(RefCell::new(FTable::new()));
        let vt = Rc::new(RefCell::new(VTable::new()));

        match lex(test_doc) {
            Err(e) => {
                println!("Lexing error: {}\n", e);
                assert!(false)
            },

            Ok(initial_ast) => {
                match eval(initial_ast.clone(), vt.clone(), ft.clone(), false) {
                    Err(e) => {
                        println!("Evaluation error: {}\n", e);
                        assert!(false)
                    },

                    Ok(reduced_ast) => {
                        // write tests here
                    }
                }
            }
        }
    }

    #[test]
    fn eval_verify_all_elems_cloned() {
        let test_doc = "1".to_string();
        let ft = Rc::new(RefCell::new(FTable::new()));
        let vt = Rc::new(RefCell::new(VTable::new()));

        match lex(test_doc) {
            Err(e) => {
                println!("Lexing error: {}\n", e);
                assert!(false)
            },

            Ok(initial_ast) => {
                match eval(initial_ast.clone(), vt.clone(), ft.clone(), false) {
                    Err(e) => {
                        println!("Evaluation error: {}\n", e);
                        assert!(false)
                    },

                    Ok(reduced_ast) => {
                        // write tests here
                    }
                }
            }
        }
    }*/
}