1 #[macro_use]
2 extern crate json;
3
4 use json::{ parse, JsonValue, JsonError, Null };
5
6 #[test]
is_as_string()7 fn is_as_string() {
8 let string = JsonValue::from("foo");
9
10 assert!(string.is_string());
11 assert_eq!(string.as_str().unwrap(), "foo");
12 }
13
14 #[test]
is_as_number()15 fn is_as_number() {
16 let number = JsonValue::from(42);
17
18 assert!(number.is_number());
19 assert_eq!(number.as_f64().unwrap(), 42.0f64);
20 assert_eq!(number.as_f32().unwrap(), 42.0f32);
21 assert_eq!(number.as_u64().unwrap(), 42u64);
22 assert_eq!(number.as_u32().unwrap(), 42u32);
23 assert_eq!(number.as_u16().unwrap(), 42u16);
24 assert_eq!(number.as_u8().unwrap(), 42u8);
25 assert_eq!(number.as_usize().unwrap(), 42usize);
26 assert_eq!(number.as_i64().unwrap(), 42i64);
27 assert_eq!(number.as_i32().unwrap(), 42i32);
28 assert_eq!(number.as_i16().unwrap(), 42i16);
29 assert_eq!(number.as_i8().unwrap(), 42i8);
30 assert_eq!(number.as_isize().unwrap(), 42isize);
31
32 let number = JsonValue::from(-1);
33
34 assert_eq!(number.as_u64(), None);
35 assert_eq!(number.as_u32(), None);
36 assert_eq!(number.as_u16(), None);
37 assert_eq!(number.as_u8(), None);
38 assert_eq!(number.as_usize(), None);
39 assert_eq!(number.as_i64(), Some(-1));
40 assert_eq!(number.as_i32(), Some(-1));
41 assert_eq!(number.as_i16(), Some(-1));
42 assert_eq!(number.as_i8(), Some(-1));
43 assert_eq!(number.as_isize(), Some(-1));
44
45 let number = JsonValue::from(40_000);
46
47 assert_eq!(number.as_u8(), None);
48 assert_eq!(number.as_u16(), Some(40_000));
49 assert_eq!(number.as_i8(), None);
50 assert_eq!(number.as_i16(), None);
51 assert_eq!(number.as_i32(), Some(40_000));
52
53 let number = JsonValue::from(-5.5);
54 assert_eq!(number.as_i8(), None);
55 assert_eq!(number.as_i16(), None);
56 assert_eq!(number.as_i32(), None);
57 assert_eq!(number.as_u8(), None);
58 assert_eq!(number.as_u16(), None);
59 assert_eq!(number.as_u32(), None);
60 }
61
62 #[test]
as_fixed_point()63 fn as_fixed_point() {
64 let number = JsonValue::from(3.14);
65
66 assert_eq!(number.as_fixed_point_u64(4).unwrap(), 31400_u64);
67 assert_eq!(number.as_fixed_point_u64(2).unwrap(), 314_u64);
68 assert_eq!(number.as_fixed_point_u64(0).unwrap(), 3_u64);
69
70 assert_eq!(number.as_fixed_point_i64(4).unwrap(), 31400_i64);
71 assert_eq!(number.as_fixed_point_i64(2).unwrap(), 314_i64);
72 assert_eq!(number.as_fixed_point_i64(0).unwrap(), 3_i64);
73
74 let number = JsonValue::from(-3.14);
75
76 assert_eq!(number.as_fixed_point_u64(4), None);
77 assert_eq!(number.as_fixed_point_u64(2), None);
78 assert_eq!(number.as_fixed_point_u64(0), None);
79
80 assert_eq!(number.as_fixed_point_i64(4).unwrap(), -31400_i64);
81 assert_eq!(number.as_fixed_point_i64(2).unwrap(), -314_i64);
82 assert_eq!(number.as_fixed_point_i64(0).unwrap(), -3_i64);
83 }
84
85 #[test]
is_as_boolean()86 fn is_as_boolean() {
87 let boolean = JsonValue::Boolean(true);
88
89 assert!(boolean.is_boolean());
90 assert_eq!(boolean.as_bool().unwrap(), true);
91 }
92
93 #[test]
is_true()94 fn is_true() {
95 let boolean = JsonValue::Boolean(true);
96
97 assert_eq!(boolean, true);
98 }
99
100 #[test]
is_false()101 fn is_false() {
102 let boolean = JsonValue::Boolean(false);
103
104 assert_eq!(boolean, false);
105 }
106
107 #[test]
is_null()108 fn is_null() {
109 let null = JsonValue::Null;
110
111 assert!(null.is_null());
112 }
113
114 #[test]
is_empty()115 fn is_empty() {
116 assert!(Null.is_empty());
117 assert!(json::from(0).is_empty());
118 assert!(json::from("").is_empty());
119 assert!(json::from(false).is_empty());
120 assert!(array![].is_empty());
121 assert!(object!{}.is_empty());
122
123 assert!(!json::from(1).is_empty());
124 assert!(!json::from("foo").is_empty());
125 assert!(!json::from(true).is_empty());
126 assert!(!array![0].is_empty());
127 assert!(!object!{ foo: false }.is_empty());
128 }
129
130 #[test]
array_len()131 fn array_len() {
132 let data = array![0, 1, 2, 3];
133
134 assert_eq!(data.len(), 4);
135 }
136
137 #[test]
array_contains()138 fn array_contains() {
139 let data = array![true, null, 3.14, "foo"];
140
141 assert!(data.contains(true));
142 assert!(data.contains(Null));
143 assert!(data.contains(3.14));
144 assert!(data.contains("foo"));
145
146 assert!(!data.contains(false));
147 assert!(!data.contains(42));
148 assert!(!data.contains("bar"));
149 }
150
151 #[test]
array_push()152 fn array_push() {
153 let mut data = array![1, 2];
154
155 data.push(3).unwrap();
156
157 assert_eq!(data, array![1, 2, 3]);
158 }
159
160 #[test]
array_pop()161 fn array_pop() {
162 let mut data = array![1, 2, 3];
163
164 assert_eq!(data.pop(), 3);
165 assert_eq!(data, array![1, 2]);
166 }
167
168 #[test]
array_remove()169 fn array_remove() {
170 let mut data = array![1, 2, 3];
171
172 assert_eq!(data.array_remove(1), 2);
173 assert_eq!(data, array![1, 3]);
174 // Test with index out of bounds
175 assert_eq!(data.array_remove(2), JsonValue::Null);
176 }
177
178 #[test]
array_members()179 fn array_members() {
180 let data = array![1, "foo"];
181
182 for member in data.members() {
183 assert!(!member.is_null());
184 }
185
186 let mut members = data.members();
187
188 assert_eq!(members.next().unwrap(), 1);
189 assert_eq!(members.next().unwrap(), "foo");
190 assert!(members.next().is_none());
191 }
192
193 #[test]
array_members_rev()194 fn array_members_rev() {
195 let data = array![1, "foo"];
196
197 for member in data.members() {
198 assert!(!member.is_null());
199 }
200
201 let mut members = data.members().rev();
202
203 assert_eq!(members.next().unwrap(), "foo");
204 assert_eq!(members.next().unwrap(), 1);
205 assert!(members.next().is_none());
206 }
207
208 #[test]
array_members_mut()209 fn array_members_mut() {
210 let mut data = array![null, null];
211
212 for member in data.members_mut() {
213 assert!(member.is_null());
214 *member = 100.into();
215 }
216
217 assert_eq!(data, array![100, 100]);
218 }
219
220 #[test]
array_members_mut_rev()221 fn array_members_mut_rev() {
222 let mut data = array![null, null];
223 let mut item = 100;
224
225 for member in data.members_mut().rev() {
226 assert!(member.is_null());
227 *member = item.into();
228 item += 1;
229 }
230
231 assert_eq!(data, array![item - 1, item - 2]);
232 }
233
234 #[test]
object_len()235 fn object_len() {
236 let data = object!{
237 a: true,
238 b: false
239 };
240
241 assert_eq!(data.len(), 2);
242 }
243
244 #[test]
object_remove()245 fn object_remove() {
246 let mut data = object!{
247 foo: "bar",
248 answer: 42
249 };
250
251 assert_eq!(data.remove("foo"), "bar");
252 assert_eq!(data, object!{ answer: 42 });
253 }
254
255 #[test]
object_entries()256 fn object_entries() {
257 let data = object!{
258 a: 1,
259 b: "foo"
260 };
261
262 for (_, value) in data.entries() {
263 assert!(!value.is_null());
264 }
265
266 let mut entries = data.entries();
267
268 let (key, value) = entries.next().unwrap();
269 assert_eq!(key, "a");
270 assert_eq!(value, 1);
271
272 let (key, value) = entries.next().unwrap();
273 assert_eq!(key, "b");
274 assert_eq!(value, "foo");
275
276 assert!(entries.next().is_none());
277 }
278
279 #[test]
object_entries_rev()280 fn object_entries_rev() {
281 let data = object!{
282 a: 1,
283 b: "foo"
284 };
285
286 for (_, value) in data.entries().rev() {
287 assert!(!value.is_null());
288 }
289
290 let mut entries = data.entries().rev();
291
292 let (key, value) = entries.next().unwrap();
293 assert_eq!(key, "b");
294 assert_eq!(value, "foo");
295
296 let (key, value) = entries.next().unwrap();
297 assert_eq!(key, "a");
298 assert_eq!(value, 1);
299
300 assert!(entries.next().is_none());
301 }
302
303 #[test]
object_entries_mut()304 fn object_entries_mut() {
305 let mut data = object!{
306 a: null,
307 b: null
308 };
309
310 for (_, value) in data.entries_mut() {
311 assert!(value.is_null());
312 *value = 100.into();
313 }
314
315 assert_eq!(data, object!{
316 a: 100,
317 b: 100
318 });
319 }
320
321 #[test]
object_entries_mut_rev()322 fn object_entries_mut_rev() {
323 let mut data = object!{
324 a: null,
325 b: null
326 };
327 let mut item = 100;
328
329 for (_, value) in data.entries_mut().rev() {
330 assert!(value.is_null());
331 *value = item.into();
332 item += 1;
333 }
334
335 assert_eq!(data, object!{
336 a: item - 1,
337 b: item - 2
338 });
339 }
340
341 #[test]
object_dump_minified()342 fn object_dump_minified() {
343 let object = object!{
344 name: "Maciej",
345 age: 30
346 };
347
348 assert_eq!(object.dump(), "{\"name\":\"Maciej\",\"age\":30}");
349 }
350
351 #[test]
object_dump_pretty()352 fn object_dump_pretty() {
353 let object = object!{
354 name: "Urlich",
355 age: 50,
356 parents: {
357 mother: "Helga",
358 father: "Brutus"
359 },
360 cars: [ "Golf", "Mercedes", "Porsche" ]
361 };
362
363 assert_eq!(object.pretty(2),
364 "{\n \"name\": \"Urlich\",\n \"age\": 50,\n \"parents\": {\n \"mother\": \"Helga\",\n \"father\": \"Brutus\"\n },\n \"cars\": [\n \"Golf\",\n \"Mercedes\",\n \"Porsche\"\n ]\n}");
365 }
366
367 #[test]
null_len()368 fn null_len() {
369 let data = json::Null;
370
371 assert_eq!(data.len(), 0);
372 }
373
374 #[test]
index_by_str()375 fn index_by_str() {
376 let data = object!{
377 foo: "bar"
378 };
379
380 assert_eq!(data["foo"], "bar");
381 }
382
383 #[test]
index_by_string()384 fn index_by_string() {
385 let data = object!{
386 "foo": "bar"
387 };
388
389 assert_eq!(data["foo".to_string()], "bar");
390 }
391
392 #[test]
index_by_string_ref()393 fn index_by_string_ref() {
394 let data = object!{
395 foo: "bar"
396 };
397
398 let key = "foo".to_string();
399 let ref key_ref = key;
400
401 assert_eq!(data[key_ref], "bar");
402 }
403
404 #[test]
index_mut_by_str()405 fn index_mut_by_str() {
406 let mut data = object!{
407 foo: null
408 };
409
410 data["foo"] = "bar".into();
411
412 assert_eq!(data["foo"], "bar");
413 }
414
415 #[test]
index_mut_by_string()416 fn index_mut_by_string() {
417 let mut data = object!{
418 foo: null
419 };
420
421 data["foo".to_string()] = "bar".into();
422
423 assert_eq!(data["foo"], "bar");
424 }
425
426 #[test]
index_mut_by_string_ref()427 fn index_mut_by_string_ref() {
428 let mut data = object!{
429 foo: null
430 };
431
432 let key = "foo".to_string();
433 let ref key_ref = key;
434
435 data[key_ref] = "bar".into();
436
437 assert_eq!(data["foo"], "bar");
438 }
439
440 #[test]
object_index_by_str()441 fn object_index_by_str() {
442 let val = object!{
443 foo: "bar"
444 };
445 if let JsonValue::Object(data) = val {
446 assert_eq!(data["foo"], "bar");
447 }
448 }
449
450 #[test]
object_index_by_string()451 fn object_index_by_string() {
452 let val = object!{
453 foo: "bar"
454 };
455
456 if let JsonValue::Object(data) = val {
457 assert_eq!(data["foo".to_string()], "bar");
458 }
459 }
460
461 #[test]
object_index_by_string_ref()462 fn object_index_by_string_ref() {
463 let val = object!{
464 foo: "bar"
465 };
466
467 let key = "foo".to_string();
468 let ref key_ref = key;
469
470 if let JsonValue::Object(data) = val {
471 assert_eq!(data[key_ref], "bar");
472 }
473 }
474
475 #[test]
object_index_mut_by_str()476 fn object_index_mut_by_str() {
477 let val = object!{
478 foo: null
479 };
480
481 if let JsonValue::Object(mut data) = val {
482 data["foo"] = "bar".into();
483
484 assert_eq!(data["foo"], "bar");
485 }
486 }
487
488 #[test]
object_index_mut_by_string()489 fn object_index_mut_by_string() {
490 let val = object!{
491 foo: null
492 };
493
494 if let JsonValue::Object(mut data) = val {
495 data["foo".to_string()] = "bar".into();
496
497 assert_eq!(data["foo"], "bar");
498 }
499 }
500
501 #[test]
object_index_mut_by_string_ref()502 fn object_index_mut_by_string_ref() {
503 let val = object!{
504 foo: null
505 };
506
507 let key = "foo".to_string();
508 let ref key_ref = key;
509
510 if let JsonValue::Object(mut data) = val {
511 data[key_ref] = "bar".into();
512
513 assert_eq!(data["foo"], "bar");
514 }
515 }
516
517 #[test]
fmt_string()518 fn fmt_string() {
519 let data: JsonValue = "foobar".into();
520
521 assert_eq!(format!("{}", data), "foobar");
522 assert_eq!(format!("{:#}", data), r#""foobar""#);
523 }
524
525 #[test]
fmt_number()526 fn fmt_number() {
527 let data: JsonValue = 42.into();
528
529 assert_eq!(format!("{}", data), "42");
530 assert_eq!(format!("{:#}", data), "42");
531 }
532
533 #[test]
fmt_boolean()534 fn fmt_boolean() {
535 let data: JsonValue = true.into();
536
537 assert_eq!(format!("{}", data), "true");
538 assert_eq!(format!("{:#}", data), "true");
539 }
540
541 #[test]
fmt_null()542 fn fmt_null() {
543 let data = Null;
544
545 assert_eq!(format!("{}", data), "null");
546 assert_eq!(format!("{:#}", data), "null");
547 }
548
549 #[test]
fmt_array()550 fn fmt_array() {
551 let data = array![1, true, "three"];
552
553 assert_eq!(format!("{}", data), r#"[1,true,"three"]"#);
554 assert_eq!(format!("{:#}", data), "[\n 1,\n true,\n \"three\"\n]");
555 }
556
557 #[test]
fmt_object()558 fn fmt_object() {
559 let data = object!{
560 foo: "bar",
561 answer: 42
562 };
563
564 assert_eq!(format!("{}", data), r#"{"foo":"bar","answer":42}"#);
565 assert_eq!(format!("{:#}", data), "{\n \"foo\": \"bar\",\n \"answer\": 42\n}");
566 }
567
568 #[test]
error_unexpected_character()569 fn error_unexpected_character() {
570 let err = parse("\n\nnulX\n").unwrap_err();
571
572 assert_eq!(err, JsonError::UnexpectedCharacter {
573 ch: 'X',
574 line: 3,
575 column: 4,
576 });
577
578 assert_eq!(format!("{}", err), "Unexpected character: X at (3:4)");
579 }
580
581 #[test]
error_unexpected_unicode_character()582 fn error_unexpected_unicode_character() {
583 let err = parse("\n\nnul��\n").unwrap_err();
584
585 assert_eq!(err, JsonError::UnexpectedCharacter {
586 ch: '��',
587 line: 3,
588 column: 4,
589 });
590
591 assert_eq!(format!("{}", err), "Unexpected character: �� at (3:4)");
592 }
593
594 #[test]
error_unexpected_token()595 fn error_unexpected_token() {
596 let err = parse("\n [\n null,\n ] \n").unwrap_err();
597
598 assert_eq!(err, JsonError::UnexpectedCharacter {
599 ch: ']',
600 line: 4,
601 column: 3,
602 });
603
604 assert_eq!(format!("{}", err), "Unexpected character: ] at (4:3)");
605 }
606
607 #[test]
writer_generator()608 fn writer_generator() {
609 let data = object!{
610 foo: ["bar", 100, true]
611 };
612
613 let mut buf = Vec::new();
614
615 data.write(&mut buf).expect("Can't fail with a Vec");
616
617 assert_eq!(String::from_utf8(buf).unwrap(), r#"{"foo":["bar",100,true]}"#);
618 }
619
620 #[test]
pretty_writer_generator()621 fn pretty_writer_generator() {
622 let data = object!{
623 foo: ["bar", 100, true]
624 };
625
626 let mut buf = Vec::new();
627
628 data.write_pretty(&mut buf, 4).expect("Can't fail with a Vec");
629
630 assert_eq!(String::from_utf8(buf).unwrap(), "{\n \"foo\": [\n \"bar\",\n 100,\n true\n ]\n}");
631 }
632
633 #[test]
equality()634 fn equality() {
635 let left = object!{
636 foo: ["bar", 100, true]
637 };
638
639 let left_copy = object!{
640 foo: ["bar", 100, true]
641 };
642
643 let left_string = object!{
644 foo: [JsonValue::String("bar".to_string()), 100, true]
645 };
646
647 let left_short = object!{
648 foo: [JsonValue::Short(unsafe { json::short::Short::from_slice("bar") }), 100, true]
649 };
650
651 let change_bool = object!{
652 foo: ["bar", 100, false]
653 };
654
655 let change_string = object!{
656 foo: [JsonValue::String("sna".to_string()), 100, true]
657 };
658
659 let change_short = object!{
660 foo: [JsonValue::Short(unsafe { json::short::Short::from_slice("sna") }), 100, true]
661 };
662
663 assert_eq!(left, left_copy);
664 assert_eq!(left, left_string);
665 assert_eq!(left, left_short);
666 assert_ne!(left, change_bool);
667 assert_ne!(left, change_string);
668 assert_ne!(left, change_short);
669 }
670