1 #![allow(rustc::internal)]
2 
3 use json::DecoderError::*;
4 use json::ErrorCode::*;
5 use json::Json::*;
6 use json::JsonEvent::*;
7 use json::ParserError::*;
8 use json::{
9     from_str, DecodeResult, Decoder, DecoderError, Encoder, EncoderError, Json, JsonEvent, Parser,
10     StackElement,
11 };
12 use rustc_macros::{Decodable, Encodable};
13 use rustc_serialize::json;
14 use rustc_serialize::{Decodable, Encodable};
15 
16 use std::collections::BTreeMap;
17 use std::io::prelude::*;
18 use std::string;
19 use Animal::*;
20 
21 #[derive(Decodable, Eq, PartialEq, Debug)]
22 struct OptionData {
23     opt: Option<usize>,
24 }
25 
26 #[test]
test_decode_option_none()27 fn test_decode_option_none() {
28     let s = "{}";
29     let obj: OptionData = json::decode(s).unwrap();
30     assert_eq!(obj, OptionData { opt: None });
31 }
32 
33 #[test]
test_decode_option_some()34 fn test_decode_option_some() {
35     let s = "{ \"opt\": 10 }";
36     let obj: OptionData = json::decode(s).unwrap();
37     assert_eq!(obj, OptionData { opt: Some(10) });
38 }
39 
40 #[test]
test_decode_option_malformed()41 fn test_decode_option_malformed() {
42     check_err::<OptionData>(
43         "{ \"opt\": [] }",
44         ExpectedError("Number".to_string(), "[]".to_string()),
45     );
46     check_err::<OptionData>(
47         "{ \"opt\": false }",
48         ExpectedError("Number".to_string(), "false".to_string()),
49     );
50 }
51 
52 #[derive(PartialEq, Encodable, Decodable, Debug)]
53 enum Animal {
54     Dog,
55     Frog(string::String, isize),
56 }
57 
58 #[derive(PartialEq, Encodable, Decodable, Debug)]
59 struct Inner {
60     a: (),
61     b: usize,
62     c: Vec<string::String>,
63 }
64 
65 #[derive(PartialEq, Encodable, Decodable, Debug)]
66 struct Outer {
67     inner: Vec<Inner>,
68 }
69 
mk_object(items: &[(string::String, Json)]) -> Json70 fn mk_object(items: &[(string::String, Json)]) -> Json {
71     let mut d = BTreeMap::new();
72 
73     for item in items {
74         match *item {
75             (ref key, ref value) => {
76                 d.insert((*key).clone(), (*value).clone());
77             }
78         }
79     }
80 
81     Object(d)
82 }
83 
84 #[test]
test_from_str_trait()85 fn test_from_str_trait() {
86     let s = "null";
87     assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
88 }
89 
90 #[test]
test_write_null()91 fn test_write_null() {
92     assert_eq!(Null.to_string(), "null");
93     assert_eq!(Null.pretty().to_string(), "null");
94 }
95 
96 #[test]
test_write_i64()97 fn test_write_i64() {
98     assert_eq!(U64(0).to_string(), "0");
99     assert_eq!(U64(0).pretty().to_string(), "0");
100 
101     assert_eq!(U64(1234).to_string(), "1234");
102     assert_eq!(U64(1234).pretty().to_string(), "1234");
103 
104     assert_eq!(I64(-5678).to_string(), "-5678");
105     assert_eq!(I64(-5678).pretty().to_string(), "-5678");
106 
107     assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
108     assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
109 }
110 
111 #[test]
test_write_f64()112 fn test_write_f64() {
113     assert_eq!(F64(3.0).to_string(), "3.0");
114     assert_eq!(F64(3.0).pretty().to_string(), "3.0");
115 
116     assert_eq!(F64(3.1).to_string(), "3.1");
117     assert_eq!(F64(3.1).pretty().to_string(), "3.1");
118 
119     assert_eq!(F64(-1.5).to_string(), "-1.5");
120     assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
121 
122     assert_eq!(F64(0.5).to_string(), "0.5");
123     assert_eq!(F64(0.5).pretty().to_string(), "0.5");
124 
125     assert_eq!(F64(f64::NAN).to_string(), "null");
126     assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
127 
128     assert_eq!(F64(f64::INFINITY).to_string(), "null");
129     assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
130 
131     assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
132     assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
133 }
134 
135 #[test]
test_write_str()136 fn test_write_str() {
137     assert_eq!(String("".to_string()).to_string(), "\"\"");
138     assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
139 
140     assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
141     assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
142 }
143 
144 #[test]
test_write_bool()145 fn test_write_bool() {
146     assert_eq!(Boolean(true).to_string(), "true");
147     assert_eq!(Boolean(true).pretty().to_string(), "true");
148 
149     assert_eq!(Boolean(false).to_string(), "false");
150     assert_eq!(Boolean(false).pretty().to_string(), "false");
151 }
152 
153 #[test]
test_write_array()154 fn test_write_array() {
155     assert_eq!(Array(vec![]).to_string(), "[]");
156     assert_eq!(Array(vec![]).pretty().to_string(), "[]");
157 
158     assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
159     assert_eq!(
160         Array(vec![Boolean(true)]).pretty().to_string(),
161         "\
162         [\n  \
163             true\n\
164         ]"
165     );
166 
167     let long_test_array =
168         Array(vec![Boolean(false), Null, Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
169 
170     assert_eq!(long_test_array.to_string(), "[false,null,[\"foo\\nbar\",3.5]]");
171     assert_eq!(
172         long_test_array.pretty().to_string(),
173         "\
174         [\n  \
175             false,\n  \
176             null,\n  \
177             [\n    \
178                 \"foo\\nbar\",\n    \
179                 3.5\n  \
180             ]\n\
181         ]"
182     );
183 }
184 
185 #[test]
test_write_object()186 fn test_write_object() {
187     assert_eq!(mk_object(&[]).to_string(), "{}");
188     assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
189 
190     assert_eq!(mk_object(&[("a".to_string(), Boolean(true))]).to_string(), "{\"a\":true}");
191     assert_eq!(
192         mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
193         "\
194         {\n  \
195             \"a\": true\n\
196         }"
197     );
198 
199     let complex_obj = mk_object(&[(
200         "b".to_string(),
201         Array(vec![
202             mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
203             mk_object(&[("d".to_string(), String("".to_string()))]),
204         ]),
205     )]);
206 
207     assert_eq!(
208         complex_obj.to_string(),
209         "{\
210             \"b\":[\
211                 {\"c\":\"\\f\\r\"},\
212                 {\"d\":\"\"}\
213             ]\
214         }"
215     );
216     assert_eq!(
217         complex_obj.pretty().to_string(),
218         "\
219         {\n  \
220             \"b\": [\n    \
221                 {\n      \
222                     \"c\": \"\\f\\r\"\n    \
223                 },\n    \
224                 {\n      \
225                     \"d\": \"\"\n    \
226                 }\n  \
227             ]\n\
228         }"
229     );
230 
231     let a = mk_object(&[
232         ("a".to_string(), Boolean(true)),
233         (
234             "b".to_string(),
235             Array(vec![
236                 mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
237                 mk_object(&[("d".to_string(), String("".to_string()))]),
238             ]),
239         ),
240     ]);
241 
242     // We can't compare the strings directly because the object fields be
243     // printed in a different order.
244     assert_eq!(a.clone(), a.to_string().parse().unwrap());
245     assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
246 }
247 
248 #[test]
test_write_enum()249 fn test_write_enum() {
250     let animal = Dog;
251     assert_eq!(json::as_json(&animal).to_string(), "\"Dog\"");
252     assert_eq!(json::as_pretty_json(&animal).to_string(), "\"Dog\"");
253 
254     let animal = Frog("Henry".to_string(), 349);
255     assert_eq!(
256         json::as_json(&animal).to_string(),
257         "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
258     );
259     assert_eq!(
260         json::as_pretty_json(&animal).to_string(),
261         "{\n  \
262            \"variant\": \"Frog\",\n  \
263            \"fields\": [\n    \
264              \"Henry\",\n    \
265              349\n  \
266            ]\n\
267          }"
268     );
269 }
270 
271 macro_rules! check_encoder_for_simple {
272     ($value:expr, $expected:expr) => {{
273         let s = json::as_json(&$value).to_string();
274         assert_eq!(s, $expected);
275 
276         let s = json::as_pretty_json(&$value).to_string();
277         assert_eq!(s, $expected);
278     }};
279 }
280 
281 #[test]
test_write_some()282 fn test_write_some() {
283     check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
284 }
285 
286 #[test]
test_write_none()287 fn test_write_none() {
288     check_encoder_for_simple!(None::<string::String>, "null");
289 }
290 
291 #[test]
test_write_char()292 fn test_write_char() {
293     check_encoder_for_simple!('a', "\"a\"");
294     check_encoder_for_simple!('\t', "\"\\t\"");
295     check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
296     check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
297     check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
298     check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
299     check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
300     check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
301 }
302 
303 #[test]
test_trailing_characters()304 fn test_trailing_characters() {
305     assert_eq!(from_str("nulla"), Err(SyntaxError(TrailingCharacters, 1, 5)));
306     assert_eq!(from_str("truea"), Err(SyntaxError(TrailingCharacters, 1, 5)));
307     assert_eq!(from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
308     assert_eq!(from_str("1a"), Err(SyntaxError(TrailingCharacters, 1, 2)));
309     assert_eq!(from_str("[]a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
310     assert_eq!(from_str("{}a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
311 }
312 
313 #[test]
test_read_identifiers()314 fn test_read_identifiers() {
315     assert_eq!(from_str("n"), Err(SyntaxError(InvalidSyntax, 1, 2)));
316     assert_eq!(from_str("nul"), Err(SyntaxError(InvalidSyntax, 1, 4)));
317     assert_eq!(from_str("t"), Err(SyntaxError(InvalidSyntax, 1, 2)));
318     assert_eq!(from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
319     assert_eq!(from_str("f"), Err(SyntaxError(InvalidSyntax, 1, 2)));
320     assert_eq!(from_str("faz"), Err(SyntaxError(InvalidSyntax, 1, 3)));
321 
322     assert_eq!(from_str("null"), Ok(Null));
323     assert_eq!(from_str("true"), Ok(Boolean(true)));
324     assert_eq!(from_str("false"), Ok(Boolean(false)));
325     assert_eq!(from_str(" null "), Ok(Null));
326     assert_eq!(from_str(" true "), Ok(Boolean(true)));
327     assert_eq!(from_str(" false "), Ok(Boolean(false)));
328 }
329 
330 #[test]
test_decode_identifiers()331 fn test_decode_identifiers() {
332     let v: () = json::decode("null").unwrap();
333     assert_eq!(v, ());
334 
335     let v: bool = json::decode("true").unwrap();
336     assert_eq!(v, true);
337 
338     let v: bool = json::decode("false").unwrap();
339     assert_eq!(v, false);
340 }
341 
342 #[test]
test_read_number()343 fn test_read_number() {
344     assert_eq!(from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1)));
345     assert_eq!(from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1)));
346     assert_eq!(from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
347     assert_eq!(from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2)));
348     assert_eq!(from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2)));
349     assert_eq!(from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3)));
350     assert_eq!(from_str("1e"), Err(SyntaxError(InvalidNumber, 1, 3)));
351     assert_eq!(from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
352 
353     assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
354     assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
355 
356     assert_eq!(from_str("3"), Ok(U64(3)));
357     assert_eq!(from_str("3.1"), Ok(F64(3.1)));
358     assert_eq!(from_str("-1.2"), Ok(F64(-1.2)));
359     assert_eq!(from_str("0.4"), Ok(F64(0.4)));
360     assert_eq!(from_str("0.4e5"), Ok(F64(0.4e5)));
361     assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15)));
362     assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01)));
363     assert_eq!(from_str(" 3 "), Ok(U64(3)));
364 
365     assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
366     assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
367     assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX)));
368 }
369 
370 #[test]
test_decode_numbers()371 fn test_decode_numbers() {
372     let v: f64 = json::decode("3").unwrap();
373     assert_eq!(v, 3.0);
374 
375     let v: f64 = json::decode("3.1").unwrap();
376     assert_eq!(v, 3.1);
377 
378     let v: f64 = json::decode("-1.2").unwrap();
379     assert_eq!(v, -1.2);
380 
381     let v: f64 = json::decode("0.4").unwrap();
382     assert_eq!(v, 0.4);
383 
384     let v: f64 = json::decode("0.4e5").unwrap();
385     assert_eq!(v, 0.4e5);
386 
387     let v: f64 = json::decode("0.4e15").unwrap();
388     assert_eq!(v, 0.4e15);
389 
390     let v: f64 = json::decode("0.4e-01").unwrap();
391     assert_eq!(v, 0.4e-01);
392 
393     let v: u64 = json::decode("0").unwrap();
394     assert_eq!(v, 0);
395 
396     let v: u64 = json::decode("18446744073709551615").unwrap();
397     assert_eq!(v, u64::MAX);
398 
399     let v: i64 = json::decode("-9223372036854775808").unwrap();
400     assert_eq!(v, i64::MIN);
401 
402     let v: i64 = json::decode("9223372036854775807").unwrap();
403     assert_eq!(v, i64::MAX);
404 
405     let res: DecodeResult<i64> = json::decode("765.25");
406     assert_eq!(res, Err(ExpectedError("Integer".to_string(), "765.25".to_string())));
407 }
408 
409 #[test]
test_read_str()410 fn test_read_str() {
411     assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2)));
412     assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
413 
414     assert_eq!(from_str("\"\""), Ok(String("".to_string())));
415     assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string())));
416     assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string())));
417     assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string())));
418     assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string())));
419     assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string())));
420     assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string())));
421     assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string())));
422     assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
423     assert_eq!(from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
424 }
425 
426 #[test]
test_decode_str()427 fn test_decode_str() {
428     let s = [
429         ("\"\"", ""),
430         ("\"foo\"", "foo"),
431         ("\"\\\"\"", "\""),
432         ("\"\\b\"", "\x08"),
433         ("\"\\n\"", "\n"),
434         ("\"\\r\"", "\r"),
435         ("\"\\t\"", "\t"),
436         ("\"\\u12ab\"", "\u{12ab}"),
437         ("\"\\uAB12\"", "\u{AB12}"),
438     ];
439 
440     for &(i, o) in &s {
441         let v: string::String = json::decode(i).unwrap();
442         assert_eq!(v, o);
443     }
444 }
445 
446 #[test]
test_read_array()447 fn test_read_array() {
448     assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
449     assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
450     assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
451     assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
452     assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
453 
454     assert_eq!(from_str("[]"), Ok(Array(vec![])));
455     assert_eq!(from_str("[ ]"), Ok(Array(vec![])));
456     assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)])));
457     assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
458     assert_eq!(from_str("[null]"), Ok(Array(vec![Null])));
459     assert_eq!(from_str("[3, 1]"), Ok(Array(vec![U64(3), U64(1)])));
460     assert_eq!(from_str("\n[3, 2]\n"), Ok(Array(vec![U64(3), U64(2)])));
461     assert_eq!(from_str("[2, [4, 1]]"), Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
462 }
463 
464 #[test]
test_decode_array()465 fn test_decode_array() {
466     let v: Vec<()> = json::decode("[]").unwrap();
467     assert_eq!(v, []);
468 
469     let v: Vec<()> = json::decode("[null]").unwrap();
470     assert_eq!(v, [()]);
471 
472     let v: Vec<bool> = json::decode("[true]").unwrap();
473     assert_eq!(v, [true]);
474 
475     let v: Vec<isize> = json::decode("[3, 1]").unwrap();
476     assert_eq!(v, [3, 1]);
477 
478     let v: Vec<Vec<usize>> = json::decode("[[3], [1, 2]]").unwrap();
479     assert_eq!(v, [vec![3], vec![1, 2]]);
480 }
481 
482 #[test]
test_decode_tuple()483 fn test_decode_tuple() {
484     let t: (usize, usize, usize) = json::decode("[1, 2, 3]").unwrap();
485     assert_eq!(t, (1, 2, 3));
486 
487     let t: (usize, string::String) = json::decode("[1, \"two\"]").unwrap();
488     assert_eq!(t, (1, "two".to_string()));
489 }
490 
491 #[test]
test_decode_tuple_malformed_types()492 fn test_decode_tuple_malformed_types() {
493     assert!(json::decode::<(usize, string::String)>("[1, 2]").is_err());
494 }
495 
496 #[test]
test_decode_tuple_malformed_length()497 fn test_decode_tuple_malformed_length() {
498     assert!(json::decode::<(usize, usize)>("[1, 2, 3]").is_err());
499 }
500 
501 #[test]
test_read_object()502 fn test_read_object() {
503     assert_eq!(from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
504     assert_eq!(from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
505     assert_eq!(from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2)));
506     assert_eq!(from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
507     assert_eq!(from_str("{\"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
508     assert_eq!(from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
509 
510     assert_eq!(from_str("{\"a\" 1"), Err(SyntaxError(ExpectedColon, 1, 6)));
511     assert_eq!(from_str("{\"a\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6)));
512     assert_eq!(from_str("{\"a\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
513     assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8)));
514     assert_eq!(from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
515 
516     assert_eq!(from_str("{}").unwrap(), mk_object(&[]));
517     assert_eq!(from_str("{\"a\": 3}").unwrap(), mk_object(&[("a".to_string(), U64(3))]));
518 
519     assert_eq!(
520         from_str("{ \"a\": null, \"b\" : true }").unwrap(),
521         mk_object(&[("a".to_string(), Null), ("b".to_string(), Boolean(true))])
522     );
523     assert_eq!(
524         from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
525         mk_object(&[("a".to_string(), Null), ("b".to_string(), Boolean(true))])
526     );
527     assert_eq!(
528         from_str("{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
529         mk_object(&[("a".to_string(), F64(1.0)), ("b".to_string(), Array(vec![Boolean(true)]))])
530     );
531     assert_eq!(
532         from_str(
533             "{\
534                         \"a\": 1.0, \
535                         \"b\": [\
536                             true,\
537                             \"foo\\nbar\", \
538                             { \"c\": {\"d\": null} } \
539                         ]\
540                     }"
541         )
542         .unwrap(),
543         mk_object(&[
544             ("a".to_string(), F64(1.0)),
545             (
546                 "b".to_string(),
547                 Array(vec![
548                     Boolean(true),
549                     String("foo\nbar".to_string()),
550                     mk_object(&[("c".to_string(), mk_object(&[("d".to_string(), Null)]))])
551                 ])
552             )
553         ])
554     );
555 }
556 
557 #[test]
test_decode_struct()558 fn test_decode_struct() {
559     let s = "{
560         \"inner\": [
561             { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
562         ]
563     }";
564 
565     let v: Outer = json::decode(s).unwrap();
566     assert_eq!(
567         v,
568         Outer { inner: vec![Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }] }
569     );
570 }
571 
572 #[derive(Decodable)]
573 struct FloatStruct {
574     f: f64,
575     a: Vec<f64>,
576 }
577 #[test]
test_decode_struct_with_nan()578 fn test_decode_struct_with_nan() {
579     let s = "{\"f\":null,\"a\":[null,123]}";
580     let obj: FloatStruct = json::decode(s).unwrap();
581     assert!(obj.f.is_nan());
582     assert!(obj.a[0].is_nan());
583     assert_eq!(obj.a[1], 123f64);
584 }
585 
586 #[test]
test_decode_option()587 fn test_decode_option() {
588     let value: Option<string::String> = json::decode("null").unwrap();
589     assert_eq!(value, None);
590 
591     let value: Option<string::String> = json::decode("\"jodhpurs\"").unwrap();
592     assert_eq!(value, Some("jodhpurs".to_string()));
593 }
594 
595 #[test]
test_decode_enum()596 fn test_decode_enum() {
597     let value: Animal = json::decode("\"Dog\"").unwrap();
598     assert_eq!(value, Dog);
599 
600     let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
601     let value: Animal = json::decode(s).unwrap();
602     assert_eq!(value, Frog("Henry".to_string(), 349));
603 }
604 
605 #[test]
test_decode_map()606 fn test_decode_map() {
607     let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
608               \"fields\":[\"Henry\", 349]}}";
609     let mut map: BTreeMap<string::String, Animal> = json::decode(s).unwrap();
610 
611     assert_eq!(map.remove(&"a".to_string()), Some(Dog));
612     assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
613 }
614 
615 #[test]
test_multiline_errors()616 fn test_multiline_errors() {
617     assert_eq!(from_str("{\n  \"foo\":\n \"bar\""), Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
618 }
619 
620 #[derive(Decodable)]
621 #[allow(dead_code)]
622 struct DecodeStruct {
623     x: f64,
624     y: bool,
625     z: string::String,
626     w: Vec<DecodeStruct>,
627 }
628 #[derive(Decodable)]
629 enum DecodeEnum {
630     A(f64),
631     B(string::String),
632 }
check_err<T: Decodable<Decoder>>(to_parse: &'static str, expected: DecoderError)633 fn check_err<T: Decodable<Decoder>>(to_parse: &'static str, expected: DecoderError) {
634     let res: DecodeResult<T> = match from_str(to_parse) {
635         Err(e) => Err(ParseError(e)),
636         Ok(json) => Decodable::decode(&mut Decoder::new(json)),
637     };
638     match res {
639         Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`", to_parse, expected),
640         Err(ParseError(e)) => panic!("`{:?}` is not valid json: {:?}", to_parse, e),
641         Err(e) => {
642             assert_eq!(e, expected);
643         }
644     }
645 }
646 #[test]
test_decode_errors_struct()647 fn test_decode_errors_struct() {
648     check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
649     check_err::<DecodeStruct>(
650         "{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
651         ExpectedError("Number".to_string(), "true".to_string()),
652     );
653     check_err::<DecodeStruct>(
654         "{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
655         ExpectedError("Boolean".to_string(), "[]".to_string()),
656     );
657     check_err::<DecodeStruct>(
658         "{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
659         ExpectedError("String".to_string(), "{}".to_string()),
660     );
661     check_err::<DecodeStruct>(
662         "{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
663         ExpectedError("Array".to_string(), "null".to_string()),
664     );
665     check_err::<DecodeStruct>(
666         "{\"x\": 1, \"y\": true, \"z\": \"\"}",
667         MissingFieldError("w".to_string()),
668     );
669 }
670 #[test]
test_decode_errors_enum()671 fn test_decode_errors_enum() {
672     check_err::<DecodeEnum>("{}", MissingFieldError("variant".to_string()));
673     check_err::<DecodeEnum>(
674         "{\"variant\": 1}",
675         ExpectedError("String".to_string(), "1".to_string()),
676     );
677     check_err::<DecodeEnum>("{\"variant\": \"A\"}", MissingFieldError("fields".to_string()));
678     check_err::<DecodeEnum>(
679         "{\"variant\": \"A\", \"fields\": null}",
680         ExpectedError("Array".to_string(), "null".to_string()),
681     );
682     check_err::<DecodeEnum>(
683         "{\"variant\": \"C\", \"fields\": []}",
684         UnknownVariantError("C".to_string()),
685     );
686 }
687 
688 #[test]
test_find()689 fn test_find() {
690     let json_value = from_str("{\"dog\" : \"cat\"}").unwrap();
691     let found_str = json_value.find("dog");
692     assert!(found_str.unwrap().as_string().unwrap() == "cat");
693 }
694 
695 #[test]
test_find_path()696 fn test_find_path() {
697     let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
698     let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
699     assert!(found_str.unwrap().as_string().unwrap() == "cheese");
700 }
701 
702 #[test]
test_search()703 fn test_search() {
704     let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
705     let found_str = json_value.search("mouse").and_then(|j| j.as_string());
706     assert!(found_str.unwrap() == "cheese");
707 }
708 
709 #[test]
test_index()710 fn test_index() {
711     let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
712     let ref array = json_value["animals"];
713     assert_eq!(array[0].as_string().unwrap(), "dog");
714     assert_eq!(array[1].as_string().unwrap(), "cat");
715     assert_eq!(array[2].as_string().unwrap(), "mouse");
716 }
717 
718 #[test]
test_is_object()719 fn test_is_object() {
720     let json_value = from_str("{}").unwrap();
721     assert!(json_value.is_object());
722 }
723 
724 #[test]
test_as_object()725 fn test_as_object() {
726     let json_value = from_str("{}").unwrap();
727     let json_object = json_value.as_object();
728     assert!(json_object.is_some());
729 }
730 
731 #[test]
test_is_array()732 fn test_is_array() {
733     let json_value = from_str("[1, 2, 3]").unwrap();
734     assert!(json_value.is_array());
735 }
736 
737 #[test]
test_as_array()738 fn test_as_array() {
739     let json_value = from_str("[1, 2, 3]").unwrap();
740     let json_array = json_value.as_array();
741     let expected_length = 3;
742     assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
743 }
744 
745 #[test]
test_is_string()746 fn test_is_string() {
747     let json_value = from_str("\"dog\"").unwrap();
748     assert!(json_value.is_string());
749 }
750 
751 #[test]
test_as_string()752 fn test_as_string() {
753     let json_value = from_str("\"dog\"").unwrap();
754     let json_str = json_value.as_string();
755     let expected_str = "dog";
756     assert_eq!(json_str, Some(expected_str));
757 }
758 
759 #[test]
test_is_number()760 fn test_is_number() {
761     let json_value = from_str("12").unwrap();
762     assert!(json_value.is_number());
763 }
764 
765 #[test]
test_is_i64()766 fn test_is_i64() {
767     let json_value = from_str("-12").unwrap();
768     assert!(json_value.is_i64());
769 
770     let json_value = from_str("12").unwrap();
771     assert!(!json_value.is_i64());
772 
773     let json_value = from_str("12.0").unwrap();
774     assert!(!json_value.is_i64());
775 }
776 
777 #[test]
test_is_u64()778 fn test_is_u64() {
779     let json_value = from_str("12").unwrap();
780     assert!(json_value.is_u64());
781 
782     let json_value = from_str("-12").unwrap();
783     assert!(!json_value.is_u64());
784 
785     let json_value = from_str("12.0").unwrap();
786     assert!(!json_value.is_u64());
787 }
788 
789 #[test]
test_is_f64()790 fn test_is_f64() {
791     let json_value = from_str("12").unwrap();
792     assert!(!json_value.is_f64());
793 
794     let json_value = from_str("-12").unwrap();
795     assert!(!json_value.is_f64());
796 
797     let json_value = from_str("12.0").unwrap();
798     assert!(json_value.is_f64());
799 
800     let json_value = from_str("-12.0").unwrap();
801     assert!(json_value.is_f64());
802 }
803 
804 #[test]
test_as_i64()805 fn test_as_i64() {
806     let json_value = from_str("-12").unwrap();
807     let json_num = json_value.as_i64();
808     assert_eq!(json_num, Some(-12));
809 }
810 
811 #[test]
test_as_u64()812 fn test_as_u64() {
813     let json_value = from_str("12").unwrap();
814     let json_num = json_value.as_u64();
815     assert_eq!(json_num, Some(12));
816 }
817 
818 #[test]
test_as_f64()819 fn test_as_f64() {
820     let json_value = from_str("12.0").unwrap();
821     let json_num = json_value.as_f64();
822     assert_eq!(json_num, Some(12f64));
823 }
824 
825 #[test]
test_is_boolean()826 fn test_is_boolean() {
827     let json_value = from_str("false").unwrap();
828     assert!(json_value.is_boolean());
829 }
830 
831 #[test]
test_as_boolean()832 fn test_as_boolean() {
833     let json_value = from_str("false").unwrap();
834     let json_bool = json_value.as_boolean();
835     let expected_bool = false;
836     assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
837 }
838 
839 #[test]
test_is_null()840 fn test_is_null() {
841     let json_value = from_str("null").unwrap();
842     assert!(json_value.is_null());
843 }
844 
845 #[test]
test_as_null()846 fn test_as_null() {
847     let json_value = from_str("null").unwrap();
848     let json_null = json_value.as_null();
849     let expected_null = ();
850     assert!(json_null.is_some() && json_null.unwrap() == expected_null);
851 }
852 
853 #[test]
test_encode_hashmap_with_numeric_key()854 fn test_encode_hashmap_with_numeric_key() {
855     use std::collections::HashMap;
856     use std::str::from_utf8;
857     let mut hm: HashMap<usize, bool> = HashMap::new();
858     hm.insert(1, true);
859     let mut mem_buf = Vec::new();
860     write!(&mut mem_buf, "{}", json::as_pretty_json(&hm)).unwrap();
861     let json_str = from_utf8(&mem_buf[..]).unwrap();
862     match from_str(json_str) {
863         Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
864         _ => {} // it parsed and we are good to go
865     }
866 }
867 
868 #[test]
test_prettyencode_hashmap_with_numeric_key()869 fn test_prettyencode_hashmap_with_numeric_key() {
870     use std::collections::HashMap;
871     use std::str::from_utf8;
872     let mut hm: HashMap<usize, bool> = HashMap::new();
873     hm.insert(1, true);
874     let mut mem_buf = Vec::new();
875     write!(&mut mem_buf, "{}", json::as_pretty_json(&hm)).unwrap();
876     let json_str = from_utf8(&mem_buf[..]).unwrap();
877     match from_str(json_str) {
878         Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
879         _ => {} // it parsed and we are good to go
880     }
881 }
882 
883 #[test]
test_prettyencoder_indent_level_param()884 fn test_prettyencoder_indent_level_param() {
885     use std::collections::BTreeMap;
886     use std::str::from_utf8;
887 
888     let mut tree = BTreeMap::new();
889 
890     tree.insert("hello".to_string(), String("guten tag".to_string()));
891     tree.insert("goodbye".to_string(), String("sayonara".to_string()));
892 
893     let json = Array(
894         // The following layout below should look a lot like
895         // the pretty-printed JSON (indent * x)
896         vec![
897             // 0x
898             String("greetings".to_string()), // 1x
899             Object(tree),                    // 1x + 2x + 2x + 1x
900         ], // 0x
901            // End JSON array (7 lines)
902     );
903 
904     // Helper function for counting indents
905     fn indents(source: &str) -> usize {
906         let trimmed = source.trim_start_matches(' ');
907         source.len() - trimmed.len()
908     }
909 
910     // Test up to 4 spaces of indents (more?)
911     for i in 0..4 {
912         let mut writer = Vec::new();
913         write!(&mut writer, "{}", json::as_pretty_json(&json).indent(i)).unwrap();
914 
915         let printed = from_utf8(&writer[..]).unwrap();
916 
917         // Check for indents at each line
918         let lines: Vec<&str> = printed.lines().collect();
919         assert_eq!(lines.len(), 7); // JSON should be 7 lines
920 
921         assert_eq!(indents(lines[0]), 0 * i); // [
922         assert_eq!(indents(lines[1]), 1 * i); //   "greetings",
923         assert_eq!(indents(lines[2]), 1 * i); //   {
924         assert_eq!(indents(lines[3]), 2 * i); //     "hello": "guten tag",
925         assert_eq!(indents(lines[4]), 2 * i); //     "goodbye": "sayonara"
926         assert_eq!(indents(lines[5]), 1 * i); //   },
927         assert_eq!(indents(lines[6]), 0 * i); // ]
928 
929         // Finally, test that the pretty-printed JSON is valid
930         from_str(printed).ok().expect("Pretty-printed JSON is invalid!");
931     }
932 }
933 
934 #[test]
test_hashmap_with_enum_key()935 fn test_hashmap_with_enum_key() {
936     use std::collections::HashMap;
937     #[derive(Encodable, Eq, Hash, PartialEq, Decodable, Debug)]
938     enum Enum {
939         Foo,
940         #[allow(dead_code)]
941         Bar,
942     }
943     let mut map = HashMap::new();
944     map.insert(Enum::Foo, 0);
945     let result = json::encode(&map).unwrap();
946     assert_eq!(&result[..], r#"{"Foo":0}"#);
947     let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
948     assert_eq!(map, decoded);
949 }
950 
951 #[test]
test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key()952 fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
953     use std::collections::HashMap;
954     let json_str = "{\"1\":true}";
955     let json_obj = match from_str(json_str) {
956         Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
957         Ok(o) => o,
958     };
959     let mut decoder = Decoder::new(json_obj);
960     let _hm: HashMap<usize, bool> = Decodable::decode(&mut decoder).unwrap();
961 }
962 
963 #[test]
test_hashmap_with_numeric_key_will_error_with_string_keys()964 fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
965     use std::collections::HashMap;
966     let json_str = "{\"a\":true}";
967     let json_obj = match from_str(json_str) {
968         Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
969         Ok(o) => o,
970     };
971     let mut decoder = Decoder::new(json_obj);
972     let result: Result<HashMap<usize, bool>, DecoderError> = Decodable::decode(&mut decoder);
973     assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
974 }
975 
assert_stream_equal(src: &str, expected: Vec<(JsonEvent, Vec<StackElement<'_>>)>)976 fn assert_stream_equal(src: &str, expected: Vec<(JsonEvent, Vec<StackElement<'_>>)>) {
977     let mut parser = Parser::new(src.chars());
978     let mut i = 0;
979     loop {
980         let evt = match parser.next() {
981             Some(e) => e,
982             None => {
983                 break;
984             }
985         };
986         let (ref expected_evt, ref expected_stack) = expected[i];
987         if !parser.stack().is_equal_to(expected_stack) {
988             panic!("Parser stack is not equal to {:?}", expected_stack);
989         }
990         assert_eq!(&evt, expected_evt);
991         i += 1;
992     }
993 }
994 #[test]
test_streaming_parser()995 fn test_streaming_parser() {
996     assert_stream_equal(
997         r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
998         vec![
999             (ObjectStart, vec![]),
1000             (StringValue("bar".to_string()), vec![StackElement::Key("foo")]),
1001             (ArrayStart, vec![StackElement::Key("array")]),
1002             (U64Value(0), vec![StackElement::Key("array"), StackElement::Index(0)]),
1003             (U64Value(1), vec![StackElement::Key("array"), StackElement::Index(1)]),
1004             (U64Value(2), vec![StackElement::Key("array"), StackElement::Index(2)]),
1005             (U64Value(3), vec![StackElement::Key("array"), StackElement::Index(3)]),
1006             (U64Value(4), vec![StackElement::Key("array"), StackElement::Index(4)]),
1007             (U64Value(5), vec![StackElement::Key("array"), StackElement::Index(5)]),
1008             (ArrayEnd, vec![StackElement::Key("array")]),
1009             (ArrayStart, vec![StackElement::Key("idents")]),
1010             (NullValue, vec![StackElement::Key("idents"), StackElement::Index(0)]),
1011             (BooleanValue(true), vec![StackElement::Key("idents"), StackElement::Index(1)]),
1012             (BooleanValue(false), vec![StackElement::Key("idents"), StackElement::Index(2)]),
1013             (ArrayEnd, vec![StackElement::Key("idents")]),
1014             (ObjectEnd, vec![]),
1015         ],
1016     );
1017 }
last_event(src: &str) -> JsonEvent1018 fn last_event(src: &str) -> JsonEvent {
1019     let mut parser = Parser::new(src.chars());
1020     let mut evt = NullValue;
1021     loop {
1022         evt = match parser.next() {
1023             Some(e) => e,
1024             None => return evt,
1025         }
1026     }
1027 }
1028 
1029 #[test]
test_read_object_streaming()1030 fn test_read_object_streaming() {
1031     assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
1032     assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2)));
1033     assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
1034     assert_eq!(last_event("{\"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
1035     assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
1036 
1037     assert_eq!(last_event("{\"a\" 1"), Error(SyntaxError(ExpectedColon, 1, 6)));
1038     assert_eq!(last_event("{\"a\":"), Error(SyntaxError(EOFWhileParsingValue, 1, 6)));
1039     assert_eq!(last_event("{\"a\":1"), Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
1040     assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax, 1, 8)));
1041     assert_eq!(last_event("{\"a\":1,"), Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
1042     assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
1043 
1044     assert_stream_equal("{}", vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]);
1045     assert_stream_equal(
1046         "{\"a\": 3}",
1047         vec![
1048             (ObjectStart, vec![]),
1049             (U64Value(3), vec![StackElement::Key("a")]),
1050             (ObjectEnd, vec![]),
1051         ],
1052     );
1053     assert_stream_equal(
1054         "{ \"a\": null, \"b\" : true }",
1055         vec![
1056             (ObjectStart, vec![]),
1057             (NullValue, vec![StackElement::Key("a")]),
1058             (BooleanValue(true), vec![StackElement::Key("b")]),
1059             (ObjectEnd, vec![]),
1060         ],
1061     );
1062     assert_stream_equal(
1063         "{\"a\" : 1.0 ,\"b\": [ true ]}",
1064         vec![
1065             (ObjectStart, vec![]),
1066             (F64Value(1.0), vec![StackElement::Key("a")]),
1067             (ArrayStart, vec![StackElement::Key("b")]),
1068             (BooleanValue(true), vec![StackElement::Key("b"), StackElement::Index(0)]),
1069             (ArrayEnd, vec![StackElement::Key("b")]),
1070             (ObjectEnd, vec![]),
1071         ],
1072     );
1073     assert_stream_equal(
1074         r#"{
1075             "a": 1.0,
1076             "b": [
1077                 true,
1078                 "foo\nbar",
1079                 { "c": {"d": null} }
1080             ]
1081         }"#,
1082         vec![
1083             (ObjectStart, vec![]),
1084             (F64Value(1.0), vec![StackElement::Key("a")]),
1085             (ArrayStart, vec![StackElement::Key("b")]),
1086             (BooleanValue(true), vec![StackElement::Key("b"), StackElement::Index(0)]),
1087             (
1088                 StringValue("foo\nbar".to_string()),
1089                 vec![StackElement::Key("b"), StackElement::Index(1)],
1090             ),
1091             (ObjectStart, vec![StackElement::Key("b"), StackElement::Index(2)]),
1092             (
1093                 ObjectStart,
1094                 vec![StackElement::Key("b"), StackElement::Index(2), StackElement::Key("c")],
1095             ),
1096             (
1097                 NullValue,
1098                 vec![
1099                     StackElement::Key("b"),
1100                     StackElement::Index(2),
1101                     StackElement::Key("c"),
1102                     StackElement::Key("d"),
1103                 ],
1104             ),
1105             (
1106                 ObjectEnd,
1107                 vec![StackElement::Key("b"), StackElement::Index(2), StackElement::Key("c")],
1108             ),
1109             (ObjectEnd, vec![StackElement::Key("b"), StackElement::Index(2)]),
1110             (ArrayEnd, vec![StackElement::Key("b")]),
1111             (ObjectEnd, vec![]),
1112         ],
1113     );
1114 }
1115 #[test]
test_read_array_streaming()1116 fn test_read_array_streaming() {
1117     assert_stream_equal("[]", vec![(ArrayStart, vec![]), (ArrayEnd, vec![])]);
1118     assert_stream_equal("[ ]", vec![(ArrayStart, vec![]), (ArrayEnd, vec![])]);
1119     assert_stream_equal(
1120         "[true]",
1121         vec![
1122             (ArrayStart, vec![]),
1123             (BooleanValue(true), vec![StackElement::Index(0)]),
1124             (ArrayEnd, vec![]),
1125         ],
1126     );
1127     assert_stream_equal(
1128         "[ false ]",
1129         vec![
1130             (ArrayStart, vec![]),
1131             (BooleanValue(false), vec![StackElement::Index(0)]),
1132             (ArrayEnd, vec![]),
1133         ],
1134     );
1135     assert_stream_equal(
1136         "[null]",
1137         vec![(ArrayStart, vec![]), (NullValue, vec![StackElement::Index(0)]), (ArrayEnd, vec![])],
1138     );
1139     assert_stream_equal(
1140         "[3, 1]",
1141         vec![
1142             (ArrayStart, vec![]),
1143             (U64Value(3), vec![StackElement::Index(0)]),
1144             (U64Value(1), vec![StackElement::Index(1)]),
1145             (ArrayEnd, vec![]),
1146         ],
1147     );
1148     assert_stream_equal(
1149         "\n[3, 2]\n",
1150         vec![
1151             (ArrayStart, vec![]),
1152             (U64Value(3), vec![StackElement::Index(0)]),
1153             (U64Value(2), vec![StackElement::Index(1)]),
1154             (ArrayEnd, vec![]),
1155         ],
1156     );
1157     assert_stream_equal(
1158         "[2, [4, 1]]",
1159         vec![
1160             (ArrayStart, vec![]),
1161             (U64Value(2), vec![StackElement::Index(0)]),
1162             (ArrayStart, vec![StackElement::Index(1)]),
1163             (U64Value(4), vec![StackElement::Index(1), StackElement::Index(0)]),
1164             (U64Value(1), vec![StackElement::Index(1), StackElement::Index(1)]),
1165             (ArrayEnd, vec![StackElement::Index(1)]),
1166             (ArrayEnd, vec![]),
1167         ],
1168     );
1169 
1170     assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2)));
1171 
1172     assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
1173     assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
1174     assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
1175     assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
1176     assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
1177 }
1178 #[test]
test_trailing_characters_streaming()1179 fn test_trailing_characters_streaming() {
1180     assert_eq!(last_event("nulla"), Error(SyntaxError(TrailingCharacters, 1, 5)));
1181     assert_eq!(last_event("truea"), Error(SyntaxError(TrailingCharacters, 1, 5)));
1182     assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
1183     assert_eq!(last_event("1a"), Error(SyntaxError(TrailingCharacters, 1, 2)));
1184     assert_eq!(last_event("[]a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
1185     assert_eq!(last_event("{}a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
1186 }
1187 #[test]
test_read_identifiers_streaming()1188 fn test_read_identifiers_streaming() {
1189     assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
1190     assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
1191     assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
1192 
1193     assert_eq!(last_event("n"), Error(SyntaxError(InvalidSyntax, 1, 2)));
1194     assert_eq!(last_event("nul"), Error(SyntaxError(InvalidSyntax, 1, 4)));
1195     assert_eq!(last_event("t"), Error(SyntaxError(InvalidSyntax, 1, 2)));
1196     assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
1197     assert_eq!(last_event("f"), Error(SyntaxError(InvalidSyntax, 1, 2)));
1198     assert_eq!(last_event("faz"), Error(SyntaxError(InvalidSyntax, 1, 3)));
1199 }
1200 
1201 #[test]
test_to_json()1202 fn test_to_json() {
1203     use json::ToJson;
1204     use std::collections::{BTreeMap, HashMap};
1205 
1206     let array2 = Array(vec![U64(1), U64(2)]);
1207     let array3 = Array(vec![U64(1), U64(2), U64(3)]);
1208     let object = {
1209         let mut tree_map = BTreeMap::new();
1210         tree_map.insert("a".to_string(), U64(1));
1211         tree_map.insert("b".to_string(), U64(2));
1212         Object(tree_map)
1213     };
1214 
1215     assert_eq!(array2.to_json(), array2);
1216     assert_eq!(object.to_json(), object);
1217     assert_eq!(3_isize.to_json(), I64(3));
1218     assert_eq!(4_i8.to_json(), I64(4));
1219     assert_eq!(5_i16.to_json(), I64(5));
1220     assert_eq!(6_i32.to_json(), I64(6));
1221     assert_eq!(7_i64.to_json(), I64(7));
1222     assert_eq!(8_usize.to_json(), U64(8));
1223     assert_eq!(9_u8.to_json(), U64(9));
1224     assert_eq!(10_u16.to_json(), U64(10));
1225     assert_eq!(11_u32.to_json(), U64(11));
1226     assert_eq!(12_u64.to_json(), U64(12));
1227     assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
1228     assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
1229     assert_eq!(().to_json(), Null);
1230     assert_eq!(f32::INFINITY.to_json(), Null);
1231     assert_eq!(f64::NAN.to_json(), Null);
1232     assert_eq!(true.to_json(), Boolean(true));
1233     assert_eq!(false.to_json(), Boolean(false));
1234     assert_eq!("abc".to_json(), String("abc".to_string()));
1235     assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
1236     assert_eq!((1_usize, 2_usize).to_json(), array2);
1237     assert_eq!((1_usize, 2_usize, 3_usize).to_json(), array3);
1238     assert_eq!([1_usize, 2_usize].to_json(), array2);
1239     assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3);
1240     assert_eq!((vec![1_usize, 2_usize]).to_json(), array2);
1241     assert_eq!(vec![1_usize, 2_usize, 3_usize].to_json(), array3);
1242     let mut tree_map = BTreeMap::new();
1243     tree_map.insert("a".to_string(), 1 as usize);
1244     tree_map.insert("b".to_string(), 2);
1245     assert_eq!(tree_map.to_json(), object);
1246     let mut hash_map = HashMap::new();
1247     hash_map.insert("a".to_string(), 1 as usize);
1248     hash_map.insert("b".to_string(), 2);
1249     assert_eq!(hash_map.to_json(), object);
1250     assert_eq!(Some(15).to_json(), I64(15));
1251     assert_eq!(Some(15 as usize).to_json(), U64(15));
1252     assert_eq!(None::<isize>.to_json(), Null);
1253 }
1254 
1255 #[test]
test_encode_hashmap_with_arbitrary_key()1256 fn test_encode_hashmap_with_arbitrary_key() {
1257     use std::collections::HashMap;
1258     #[derive(PartialEq, Eq, Hash, Encodable)]
1259     struct ArbitraryType(usize);
1260     let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
1261     hm.insert(ArbitraryType(1), true);
1262     let mut mem_buf = string::String::new();
1263     let mut encoder = Encoder::new(&mut mem_buf);
1264     let result = hm.encode(&mut encoder);
1265     match result.unwrap_err() {
1266         EncoderError::BadHashmapKey => (),
1267         _ => panic!("expected bad hash map key"),
1268     }
1269 }
1270