crisp 0.1.3

A small, expressive Lisp-inspired programming language.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use crate::structure::helpers::*;
use crisp::parsing::{CrispParser, Rule, ast::validation::validate_fn};
use pest::Parser;
use proptest::{prelude::ProptestConfig, proptest};

proptest! {
    #![proptest_config(ProptestConfig::with_cases(10000))]
    #[test]
    fn named(ret_type in gen_return_type(), name in gen_ident(), params in gen_params(), body in gen_body()) {
        let source = format!("(fn:{} {} {} {})", ret_type, name, params, body);
        let mut pairs = CrispParser::parse(Rule::list, &source).unwrap();
        let pair = pairs.next().unwrap();
        assert!(validate_fn(&pair, "test"));
    }
    #[test]
    fn named_missing_body(ret_type in gen_return_type(), name in gen_ident(), params in gen_params()) {
        let source = format!("(fn:{} {} {})", ret_type, name, params);
        let mut pairs = CrispParser::parse(Rule::list, &source).unwrap();
        let pair = pairs.next().unwrap();
        assert!(!validate_fn(&pair, "test"));
    }
    #[test]
    fn named_missing_params(ret_type in gen_return_type(), name in gen_ident(), body in gen_body()) {
        let source = format!("(fn:{} {} {})", ret_type, name, body);
        let mut pairs =CrispParser::parse(Rule::list, &source).unwrap();
        let pair = pairs.next().unwrap();
        assert!(!validate_fn(&pair, "test"));
    }
    #[test]
    fn named_extra_body_parts(ret_type in gen_return_type(), name in gen_ident(), params in gen_params(), body in gen_body()) {
        let source = format!("(fn:{} {} {} {} {})", ret_type, name, params, body, body);
        let mut pairs = CrispParser::parse(Rule::list, &source).unwrap();
        let pair = pairs.next().unwrap();
        assert!(!validate_fn(&pair, "test"));
    }
    #[test]
    fn anonymous(ret_type in gen_return_type(), params in gen_params(), body in gen_body()) {
        let source = format!("(fn:{} {} {})", ret_type, params, body);
        let mut pairs = CrispParser::parse(Rule::list, &source).unwrap();
        let pair = pairs.next().unwrap();
        assert!(validate_fn(&pair, "test"));
    }
    #[test]
    fn anonymous_missing_body(ret_type in gen_return_type(), params in gen_params()) {
        let source = format!("(fn:{} {})", ret_type, params);
        let mut pairs = CrispParser::parse(Rule::list, &source).unwrap();
        let pair = pairs.next().unwrap();
        assert!(!validate_fn(&pair, "test"));
    }
    #[test]
    fn anonymous_missing_params(ret_type in gen_return_type(), body in gen_body()) {
        let source = format!("(fn:{} {})", ret_type, body);
        let mut pairs =CrispParser::parse(Rule::list, &source).unwrap();
        let pair = pairs.next().unwrap();
        assert!(!validate_fn(&pair, "test"));
    }
    #[test]
    fn anonymous_extra_body_parts(ret_type in gen_return_type(), params in gen_params(), body in gen_body()) {
        let source = format!("(fn:{} {} {} {})", ret_type, params, body, body);
        let mut pairs = CrispParser::parse(Rule::list, &source).unwrap();
        let pair = pairs.next().unwrap();
        assert!(!validate_fn(&pair, "test"));
    }
    #[test]
    fn named_bad_params(
        ret_type in gen_return_type(),
        name in gen_ident(),
        bad_params in gen_bad_params(),
        body in gen_body(),
    ) {
        let source =
            format!("(fn:{} {} {} {})",
                ret_type,
                name,
                bad_params,
                body,
            );
        let mut pairs =
            CrispParser::parse(Rule::list, &source).unwrap();
        let pair = pairs.next().unwrap();
        assert!(!validate_fn(&pair, "test"));
    }
}