fosk 0.1.3

In-memory SQL-like query engine and lightweight data store for testing and prototyping.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::parser::{ast::Literal, ParseError, QueryParser};

pub struct NullParser;

impl NullParser {
    pub fn is_null(parser: &QueryParser) -> bool {
        parser.comparers.null.compare(parser)
    }

    pub fn parse(parser: &mut QueryParser) -> Result<Literal, ParseError> {
        if parser.comparers.null.compare(parser) {
            parser.jump(parser.comparers.null.length);
            return Ok(Literal::Null)
        }

        Err(ParseError::new("Invalid boolean", parser.position, parser))
    }
}

#[cfg(test)]
pub mod tests {
    use crate::parser::{ast::{NullParser, Literal}, QueryParser};

    #[test]
    pub fn test_null_parser() {
        let text = "null";

        let mut parser = QueryParser::new(text);

        let result = NullParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                Literal::Null => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_null_parser_upper() {
        let text = "NULL";

        let mut parser = QueryParser::new(text);

        let result = NullParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                Literal::Null => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_null_parser_null_space_delimiter() {
        let text = "null ";

        let mut parser = QueryParser::new(text);

        let result = NullParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                Literal::Null => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_null_parser_null_comma_delimiter() {
        let text = "null,";

        let mut parser = QueryParser::new(text);

        let result = NullParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                Literal::Null => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_null_parser_null_break_line() {
        let text = "null\r\n";

        let mut parser = QueryParser::new(text);

        let result = NullParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                Literal::Null => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_null_parser_null_wrong() {
        let text = "nulle";

        let mut parser = QueryParser::new(text);

        let result = NullParser::parse(&mut parser);

        match result {
            Ok(_) => panic!(),
            Err(err) => {
                assert_eq!(err.text, "n");
                assert_eq!(err.start, 0);
                assert_eq!(err.end, 0);
            },
        }
    }

    #[test]
    pub fn test_null_parser_null_wrong_2() {
        let text = "null#";

        let mut parser = QueryParser::new(text);

        let result = NullParser::parse(&mut parser);

        match result {
            Ok(_) => panic!(),
            Err(err) => {
                assert_eq!(err.text, "n");
                assert_eq!(err.start, 0);
                assert_eq!(err.end, 0);
            },
        }
    }
}