gdritter repos datalog / master src / lib.rs
master

Tree @master (Download .tar.gz)

lib.rs @master — raw · history · blame 

 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
84
85
86
87
88
89
90
91
92
93
94
95
96
mod ast;
pub mod grammar;

#[cfg(test)]
mod tests {
    use ::grammar::*;
    use ::ast::*;

    fn test_parse(input: &str, expected: TopLevel) {
        match parse_TopLevel(input) {
            Ok(actual) =>
                assert!(expected == actual,
                        "expected = {:?}, actual = {:?}",
                        expected, actual),
            Err(msg) => panic!("Unable to parse {:?}: {:?}",
                               input, msg),
        }
    }

    #[test]
    fn empty_tuple_decl() {
        test_parse(
            "table foo().",
            TopLevel::TableDecl(Clause {
                name: "foo".to_string(),
                data: ClauseData::TupleClause(vec![])
            }));
    }

    #[test]
    fn empty_record_decl() {
        test_parse(
            "table foo{}.",
            TopLevel::TableDecl(Clause {
                name: "foo".to_string(),
                data: ClauseData::RecordClause(vec![])
            }));
    }

    #[test]
    fn tuple_parent_decl() {
        test_parse(
            "table parent(atom, atom).",
            TopLevel::TableDecl(Clause {
                name: "parent".to_string(),
                data: ClauseData::TupleClause(vec![
                    Type::AtomType,
                    Type::AtomType,
                ])
            }));
    }

    #[test]
    fn record_parent_decl() {
        test_parse(
            "table parent { parent: atom, child: atom }.",
            TopLevel::TableDecl(Clause {
                name: "parent".to_string(),
                data: ClauseData::RecordClause(vec![
                    Field { name: "parent".to_string(),
                            value: Type::AtomType },
                    Field { name: "child".to_string(),
                            value: Type::AtomType },
                ])
            }));
    }

    #[test]
    fn insert_tuple_row() {
        test_parse(
            "insert parent (foo, bar).",
            TopLevel::RowDecl(Clause {
                name: "parent".to_string(),
                data: ClauseData::TupleClause(vec![
                    Expr::Atom("foo".to_string()),
                    Expr::Atom("bar".to_string()),
                ])
            }));
    }

    #[test]
    fn insert_record_row() {
        test_parse(
            "insert parent { parent: foo, child: bar }.",
            TopLevel::RowDecl(Clause {
                name: "parent".to_string(),
                data: ClauseData::RecordClause(vec![
                    Field { name: "parent".to_string(),
                            value: Expr::Atom("foo".to_string())},
                    Field { name: "child".to_string(),
                            value: Expr::Atom("bar".to_string())},
                ])
            }));
    }

}