dangerous 0.10.0

Safely and explicitly parse untrusted / dangerous data
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

#[macro_use]
mod common;

use common::*;

///////////////////////////////////////////////////////////////////////////////
// Test debug

#[test]
fn test_bytes_input_debug() {
    read_all_ok!(b"hello", |r| {
        assert_eq!(
            format!("{:?}", r),
            "Reader { input: Bytes { bound: Start, value: [68 65 6c 6c 6f] } }"
        );
        r.consume(b"hello")
    });
}

#[test]
fn test_bytes_input_pretty_debug() {
    read_all_ok!(b"hello", |r| {
        assert_eq!(
            format!("{:#?}\n", r),
            indoc! {r#"
                Reader {
                    input: Bytes {
                        bound: Start,
                        value: "hello",
                    },
                }
            "#}
        );
        r.consume(b"hello")
    });
}

///////////////////////////////////////////////////////////////////////////////
// Reader::consume (u8)

#[test]
fn test_consume_u8_exact_same() {
    read_all_ok!(b"1", |r| { r.consume(b'1') });
}

#[test]
fn test_consume_u8_same_len_different_value() {
    assert_eq!(
        read_all_err!(b"1", |r| { r.consume(b'2') }).to_retry_requirement(),
        None
    );
}

#[test]
fn test_consume_u8_different_len_and_value() {
    assert_eq!(
        read_all_err!(b"", |r| { r.consume(b'1') }).to_retry_requirement(),
        RetryRequirement::new(1)
    );
}

///////////////////////////////////////////////////////////////////////////////
// Reader::consume_opt (u8)

#[test]
fn test_consume_opt_u8_true() {
    assert!(read_all_ok!(b"1", |r| { Ok(r.consume_opt(b'1')) }));
}

#[test]
fn test_consume_opt_u8_false() {
    assert!(!read_all_ok!(b"1", |r| {
        let v = r.consume_opt(b'2');
        r.skip(1)?;
        Ok(v)
    }));
}

///////////////////////////////////////////////////////////////////////////////
// Reader::peek_u8

#[test]
fn test_peek_u8() {
    assert_eq!(
        read_all_ok!(b"hello", |r| {
            let v = r.peek_u8()? == b'h';
            r.skip(5)?;
            Ok(v)
        }),
        true
    );
}

///////////////////////////////////////////////////////////////////////////////
// Reader::peek_u8_opt

#[test]
fn test_peek_u8_opt() {
    assert_eq!(
        read_all_ok!(b"hello", |r| {
            let v = r.peek_u8_opt().map_or(false, |v| v == b'h');
            r.skip(5)?;
            Ok(v)
        }),
        true
    );
}

///////////////////////////////////////////////////////////////////////////////
// Reader::skip_str_while

#[test]
fn test_skip_str_while() {
    read_all_ok!(b"hello!", |r| {
        r.skip_str_while(|c| c.is_ascii_alphabetic())?;
        r.skip(1)?;
        Ok(())
    })
}

///////////////////////////////////////////////////////////////////////////////
// Reader::take_str_while

#[test]
fn test_take_str_while() {
    assert_eq!(
        read_all_ok!(b"hello!", |r| {
            let v = r.take_str_while(|c| c.is_ascii_alphabetic())?;
            r.skip(1)?;
            Ok(v)
        }),
        "hello"[..]
    );
}

#[test]
fn test_take_str_while_utf8_retry() {
    // Length 1
    assert_eq!(
        read_all_ok!(&[0b0111_1111], |r| r.take_str_while(|_| true)),
        input!(core::str::from_utf8(&[0b0111_1111]).unwrap())
    );
    // Length 2
    let err = read_all_err!(&[0b1101_1111], |r| r.take_str_while(|_| true));
    assert_eq!(err.to_retry_requirement(), RetryRequirement::new(1));
    // Length 3
    let err = read_all_err!(&[0b1110_1111], |r| r.take_str_while(|_| true));
    assert_eq!(err.to_retry_requirement(), RetryRequirement::new(2));
    // Invalid
    let err = read_all_err!(&[0b1111_0111], |r| r.take_str_while(|_| true));
    assert_eq!(err.to_retry_requirement(), None);
}

///////////////////////////////////////////////////////////////////////////////
// Reader::try_skip_str_while

#[test]
fn test_try_skip_str_while() {
    read_all_ok!(b"hello!", |r| {
        r.try_skip_str_while(|c| Ok(c.is_ascii_alphabetic()))?;
        r.skip(1)?;
        Ok(())
    })
}

///////////////////////////////////////////////////////////////////////////////
// Reader::try_take_str_while

#[test]
fn test_try_take_str_while() {
    assert_eq!(
        read_all_ok!(b"hello!", |r| {
            let v = r.try_take_str_while(|c| Ok(c.is_ascii_alphabetic()))?;
            r.skip(1)?;
            Ok(v)
        }),
        "hello"[..]
    );
}