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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

#[cfg(test)]
mod tests {
    use crate::decode::decode;
    use crate::error::DecodeErrorKind;
    use crate::value::Value;

    // null/bool/int
    #[test]
    fn decode_null() {
        let bytes = vec![0x00];
        assert_eq!(decode(&bytes).unwrap(), Value::Null);
    }

    #[test]
    fn decode_bool() {
        assert_eq!(decode(&[0x01]).unwrap(), Value::Bool(false));
        assert_eq!(decode(&[0x02]).unwrap(), Value::Bool(true));
    }

    #[test]
    fn decode_int() {
        // Int 1 -> 0x10 0x01
        assert_eq!(decode(&[0x10, 0x01]), Ok(Value::Int(1)));
    }

    // strings and bytes
    #[test]
    fn decode_string() {
        // 'hi'
        let bytes = vec![0x20, 0x02, b'h', b'i'];

        assert_eq!(decode(&bytes), Ok(Value::String("hi".into())));
    }

    #[test]
    fn decode_bytes() {
        let bytes = vec![0x21, 0x02, 0xaa, 0xbb];
        assert_eq!(decode(&bytes), Ok(Value::Bytes(vec![0xaa, 0xbb])));
    }

    // list decoding
    #[test]
    fn decode_list() {
        // [1, 2]
        let bytes = vec![0x30, 0x02, 0x10, 0x01, 0x10, 0x02];

        assert_eq!(
            decode(&bytes),
            Ok(Value::List(vec![Value::Int(1), Value::Int(2)]))
        );
    }

    // map decoding
    #[test]
    fn decode_map() {
        // { 'a': 1 }
        let bytes = vec![
            0x40, 0x01, // map with 1 entry
            0x20, 0x01, b'a', // key: 'a'
            0x10, 0x01, // value: 1
        ];

        let mut map = std::collections::BTreeMap::new();
        map.insert("a".into(), Value::Int(1));

        assert_eq!(decode(&bytes), Ok(Value::Map(map)));
    }

    // nested structures
    #[test]
    fn decode_nested() {
        // { "x": [true, null] }
        let bytes = vec![
            0x40, 0x01, // map with 1 entry
            0x20, 0x01, b'x', // key: 'x
            0x30, 0x02, // list with 2 items
            0x02, // true
            0x00, // null
        ];

        let mut map = std::collections::BTreeMap::new();
        map.insert(
            "x".into(),
            Value::List(vec![Value::Bool(true), Value::Null]),
        );

        assert_eq!(decode(&bytes), Ok(Value::Map(map)));
    }

    // safety tests v2.1 strict
    #[test]
    fn decode_truncated_string() {
        let bytes = vec![0x20, 0x05, b'h']; // length 5, but only 1 byte provided

        let err = decode(&bytes).unwrap_err();
        assert_eq!(err.kind, DecodeErrorKind::UnexpectedEOF);
        assert_eq!(err.offset, 2);
    }

    #[test]
    fn decode_invalid_tag() {
        let bytes = vec![0xFF]; // invalid tag

        let err = decode(&bytes).unwrap_err();
        assert_eq!(err.kind, DecodeErrorKind::InvalidTag(0xFF));
        assert_eq!(err.offset, 1);
    }

    #[test]
    fn decode_trailing_bytes() {
        let bytes = vec![0x00, 0x00];

        let err = decode(&bytes).unwrap_err();
        assert_eq!(err.kind, DecodeErrorKind::TrailingBytes);
        assert_eq!(err.offset, 1);
    }
}