picojson 0.2.3

A resource-constrained JSON parser for embedded systems.
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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

// Comprehensive tests for configurable number handling
// These tests demonstrate the various compilation configurations

use picojson::{Event, NumberResult, PullParser, SliceParser};

#[test]
#[cfg(feature = "int32")]
fn test_int32_overflow() {
    let input = r#"{"value": 9999999999}"#; // Larger than i32::MAX (2,147,483,647)
    let mut scratch = [0u8; 1024];
    let mut parser = SliceParser::with_buffer(input, &mut scratch);

    assert!(matches!(parser.next_event(), Ok(Event::StartObject)));
    assert!(matches!(parser.next_event(), Ok(Event::Key(_))));

    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "9999999999");
            assert!(matches!(num.parsed(), NumberResult::IntegerOverflow));
            assert_eq!(num.as_int(), None); // Too large for i32
        }
        other => panic!("Expected Number, got: {:?}", other),
    }
}

#[test]
#[cfg(feature = "int64")]
fn test_int64_handles_large_numbers() {
    let input = r#"{"value": 9999999999}"#; // Within i64 range
    let mut scratch = [0u8; 1024];
    let mut parser = SliceParser::with_buffer(input, &mut scratch);

    assert!(matches!(parser.next_event(), Ok(Event::StartObject)));
    assert!(matches!(parser.next_event(), Ok(Event::Key(_))));

    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "9999999999");
            assert!(matches!(num.parsed(), NumberResult::Integer(9999999999)));
            assert_eq!(num.as_int(), Some(9999999999));
        }
        other => panic!("Expected Number, got: {:?}", other),
    }
}

#[test]
#[cfg(all(not(feature = "float"), feature = "float-error"))]
fn test_float_error_behavior() {
    let input = r#"{"value": 3.14}"#;
    let mut scratch = [0u8; 1024];
    let mut parser = SliceParser::with_buffer(input, &mut scratch);

    // Should parse normally until we hit the float
    assert!(matches!(parser.next_event(), Ok(Event::StartObject)));
    assert!(matches!(parser.next_event(), Ok(Event::Key(_))));

    // Float should cause an error
    match parser.next_event() {
        Err(picojson::ParseError::FloatNotAllowed) => {
            // Expected behavior - test passes
        }
        other => panic!("Expected FloatNotAllowed error, got: {:?}", other),
    }
}

#[test]
#[cfg(all(not(feature = "float"), feature = "float-truncate", feature = "int32"))]
fn test_float_truncate_to_i32() {
    let input = r#"[1.7, 2.9, 3.1]"#;
    let mut scratch = [0u8; 1024];
    let mut parser = SliceParser::with_buffer(input, &mut scratch);

    assert!(matches!(parser.next_event(), Ok(Event::StartArray)));

    // 1.7 -> 1
    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "1.7");
            assert!(matches!(num.parsed(), NumberResult::FloatTruncated(1)));
            assert_eq!(num.as_int(), Some(1));
        }
        other => panic!("Expected truncated Number(1), got: {:?}", other),
    }

    // 2.9 -> 2
    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "2.9");
            assert!(matches!(num.parsed(), NumberResult::FloatTruncated(2)));
            assert_eq!(num.as_int(), Some(2));
        }
        other => panic!("Expected truncated Number(2), got: {:?}", other),
    }

    // 3.1 -> 3
    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "3.1");
            assert!(matches!(num.parsed(), NumberResult::FloatTruncated(3)));
            assert_eq!(num.as_int(), Some(3));
        }
        other => panic!("Expected truncated Number(3), got: {:?}", other),
    }

    assert!(matches!(parser.next_event(), Ok(Event::EndArray)));
}

#[test]
#[cfg(all(
    not(feature = "float"),
    feature = "float-truncate",
    not(feature = "int32")
))]
fn test_float_truncate_to_integer() {
    let input = r#"[1.7, 2.9, 3.1]"#;
    let mut scratch = [0u8; 1024];
    let mut parser = SliceParser::with_buffer(input, &mut scratch);

    assert!(matches!(parser.next_event(), Ok(Event::StartArray)));

    // Should truncate to integer
    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "1.7");
            assert!(matches!(num.parsed(), NumberResult::FloatTruncated(1)));
        }
        other => panic!("Expected truncated Number, got: {:?}", other),
    }
}

#[test]
#[cfg(all(not(feature = "float"), feature = "float-truncate"))]
fn test_float_truncate_scientific_notation() {
    let input = r#"{"value": 1.5e2}"#; // Scientific notation should error in truncate mode
    let mut scratch = [0u8; 1024];
    let mut parser = SliceParser::with_buffer(input, &mut scratch);

    assert!(matches!(parser.next_event(), Ok(Event::StartObject)));
    assert!(matches!(parser.next_event(), Ok(Event::Key(_))));

    // Scientific notation should cause InvalidNumber error to avoid float math
    match parser.next_event() {
        Err(picojson::ParseError::InvalidNumber) => {
            // Expected behavior - test passes
        }
        other => panic!(
            "Expected InvalidNumber error for scientific notation, got: {:?}",
            other
        ),
    }
}

#[test]
#[cfg(all(
    not(feature = "float"),
    feature = "int64",
    not(any(
        feature = "float-error",
        feature = "float-skip",
        feature = "float-truncate"
    ))
))]
fn test_default_float_disabled_behavior() {
    let input = r#"{"value": 3.14}"#;
    let mut scratch = [0u8; 1024];
    let mut parser = SliceParser::with_buffer(input, &mut scratch);

    assert!(matches!(parser.next_event(), Ok(Event::StartObject)));
    assert!(matches!(parser.next_event(), Ok(Event::Key(_))));

    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "3.14");
            assert!(matches!(num.parsed(), NumberResult::FloatDisabled));
            assert_eq!(num.as_int(), None);

            // Raw string should still be available for manual parsing
            assert_eq!(num.as_str(), "3.14");
            let manual_parse: Result<f64, _> = num.parse();
            assert!(manual_parse.is_ok());
        }
        other => panic!("Expected Number with FloatDisabled, got: {:?}", other),
    }
}

#[test]
#[cfg(feature = "int32")]
fn test_mixed_numbers_with_i32() {
    let input = r#"{"small": 42, "large": 999999999999}"#; // large > i32::MAX
    let mut scratch = [0u8; 1024];
    let mut parser = SliceParser::with_buffer(input, &mut scratch);

    assert!(matches!(parser.next_event(), Ok(Event::StartObject)));
    assert!(matches!(parser.next_event(), Ok(Event::Key(_))));

    // Small number should parse fine
    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "42");
            assert!(matches!(num.parsed(), NumberResult::Integer(42)));
            assert_eq!(num.as_int(), Some(42));
        }
        other => panic!("Expected Number(42), got: {:?}", other),
    }

    assert!(matches!(parser.next_event(), Ok(Event::Key(_))));

    // Large number should overflow
    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "999999999999");
            assert!(matches!(num.parsed(), NumberResult::IntegerOverflow));
            assert_eq!(num.as_int(), None);

            // But raw string is still available
            assert_eq!(num.as_str(), "999999999999");
        }
        other => panic!("Expected Number with overflow, got: {:?}", other),
    }
}

// This test ensures the library compiles and works with the most restrictive embedded configuration
#[test]
#[cfg(all(feature = "int32", not(feature = "float"), feature = "float-error"))]
fn test_embedded_friendly_config() {
    // This configuration uses:
    // - i32 integers (no 64-bit math)
    // - No float support
    // - Error on floats (fail fast)

    let input = r#"{"sensor": 42, "status": 1}"#;
    let mut scratch = [0u8; 256]; // Small buffer for embedded
    let mut parser = SliceParser::with_buffer(input, &mut scratch);

    // Should parse integers normally
    assert!(matches!(parser.next_event(), Ok(Event::StartObject)));
    assert!(matches!(parser.next_event(), Ok(Event::Key(_))));

    match parser.next_event() {
        Ok(Event::Number(num)) => {
            assert_eq!(num.as_str(), "42");
            assert!(matches!(num.parsed(), NumberResult::Integer(42i32)));
            assert_eq!(num.as_int(), Some(42i32));
        }
        other => panic!("Expected Number(42), got: {:?}", other),
    }

    assert!(matches!(parser.next_event(), Ok(Event::Key(_))));
    assert!(matches!(parser.next_event(), Ok(Event::Number(_))));
    assert!(matches!(parser.next_event(), Ok(Event::EndObject)));
}