strata-rs 0.4.1

Deterministic binary data format with canonical encoding
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

#[cfg(test)]
mod tests {
    use crate::lexer::*;

    #[test]
    fn lex_identifiers_and_keywords() {
        let mut lexer = Lexer::new("foo null true false bar");

        assert_eq!(
            lexer.next_token().unwrap().kind,
            TokenKind::Ident("foo".into())
        );
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::Null);
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::True);
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::False);
        assert_eq!(
            lexer.next_token().unwrap().kind,
            TokenKind::Ident("bar".into())
        );
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::EOF);
    }

    #[test]
    fn lex_integers() {
        let mut lexer = Lexer::new("0 42 -7 -0");

        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::Int(0));
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::Int(42));
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::Int(-7));
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::Int(0));
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::EOF);
    }

    #[test]
    fn lex_bytes_literal() {
        let mut lexer = Lexer::new("0xDEADBEEF");

        assert_eq!(
            lexer.next_token().unwrap().kind,
            TokenKind::Bytes(vec![0xDE, 0xAD, 0xBE, 0xEF])
        );
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::EOF);
    }

    #[test]
    fn lex_string_with_escapes() {
        let mut lexer = Lexer::new(r#""hello\n\"world\"""#);

        assert_eq!(
            lexer.next_token().unwrap().kind,
            TokenKind::String("hello\n\"world\"".into())
        );
        assert_eq!(lexer.next_token().unwrap().kind, TokenKind::EOF);
    }

    #[test]
    fn lex_mixed_input() {
        let mut lexer = Lexer::new(
            r#"
            user {
                id: 42,
                active: true,
                hash: 0xFF00
            }
        "#,
        );

        use TokenKind::*;

        let expected = [
            Ident("user".into()),
            LBrace,
            Ident("id".to_string()),
            Colon,
            Int(42),
            Comma,
            Ident("active".to_string()),
            Colon,
            True,
            Comma,
            Ident("hash".to_string()),
            Colon,
            Bytes(vec![0xFF, 0x00]),
            RBrace,
        ];

        for exp in expected {
            let tok = lexer.next_token().unwrap();
            assert_eq!(tok.kind, exp);
        }

        assert_eq!(lexer.next_token().unwrap().kind, EOF);
    }
}