1278 lines
33 KiB
Rust
1278 lines
33 KiB
Rust
use std::collections::BTreeMap;
|
|
use std::fmt::Debug;
|
|
use std::marker::PhantomData;
|
|
|
|
use serde::de;
|
|
use serde::ser;
|
|
|
|
use serde_json::{
|
|
self,
|
|
Value,
|
|
from_str,
|
|
from_value,
|
|
to_value,
|
|
};
|
|
|
|
use serde_json::error::{Error, ErrorCode};
|
|
|
|
macro_rules! treemap {
|
|
($($k:expr => $v:expr),*) => ({
|
|
let mut _m = BTreeMap::new();
|
|
$(_m.insert($k, $v);)*
|
|
_m
|
|
})
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
enum Animal {
|
|
Dog,
|
|
Frog(String, Vec<isize>),
|
|
Cat { age: usize, name: String },
|
|
AntHive(Vec<String>),
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
struct Inner {
|
|
a: (),
|
|
b: usize,
|
|
c: Vec<String>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
struct Outer {
|
|
inner: Vec<Inner>,
|
|
}
|
|
|
|
fn test_encode_ok<T>(errors: &[(T, &str)])
|
|
where T: PartialEq + Debug + ser::Serialize,
|
|
{
|
|
for &(ref value, out) in errors {
|
|
let out = out.to_string();
|
|
|
|
let s = serde_json::to_string(value).unwrap();
|
|
assert_eq!(s, out);
|
|
|
|
let v = to_value(&value);
|
|
let s = serde_json::to_string(&v).unwrap();
|
|
assert_eq!(s, out);
|
|
}
|
|
}
|
|
|
|
fn test_pretty_encode_ok<T>(errors: &[(T, &str)])
|
|
where T: PartialEq + Debug + ser::Serialize,
|
|
{
|
|
for &(ref value, out) in errors {
|
|
let out = out.to_string();
|
|
|
|
let s = serde_json::to_string_pretty(value).unwrap();
|
|
assert_eq!(s, out);
|
|
|
|
let v = to_value(&value);
|
|
let s = serde_json::to_string_pretty(&v).unwrap();
|
|
assert_eq!(s, out);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_null() {
|
|
let tests = &[
|
|
((), "null"),
|
|
];
|
|
test_encode_ok(tests);
|
|
test_pretty_encode_ok(tests);
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_i64() {
|
|
let tests = &[
|
|
(3i64, "3"),
|
|
(-2i64, "-2"),
|
|
(-1234i64, "-1234"),
|
|
];
|
|
test_encode_ok(tests);
|
|
test_pretty_encode_ok(tests);
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_f64() {
|
|
let tests = &[
|
|
(3.0, "3.0"),
|
|
(3.1, "3.1"),
|
|
(-1.5, "-1.5"),
|
|
(0.5, "0.5"),
|
|
];
|
|
test_encode_ok(tests);
|
|
test_pretty_encode_ok(tests);
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_str() {
|
|
let tests = &[
|
|
("", "\"\""),
|
|
("foo", "\"foo\""),
|
|
];
|
|
test_encode_ok(tests);
|
|
test_pretty_encode_ok(tests);
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_bool() {
|
|
let tests = &[
|
|
(true, "true"),
|
|
(false, "false"),
|
|
];
|
|
test_encode_ok(tests);
|
|
test_pretty_encode_ok(tests);
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_list() {
|
|
test_encode_ok(&[
|
|
(vec![], "[]"),
|
|
(vec![true], "[true]"),
|
|
(vec![true, false], "[true,false]"),
|
|
]);
|
|
|
|
test_encode_ok(&[
|
|
(vec![vec![], vec![], vec![]], "[[],[],[]]"),
|
|
(vec![vec![1, 2, 3], vec![], vec![]], "[[1,2,3],[],[]]"),
|
|
(vec![vec![], vec![1, 2, 3], vec![]], "[[],[1,2,3],[]]"),
|
|
(vec![vec![], vec![], vec![1, 2, 3]], "[[],[],[1,2,3]]"),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(
|
|
vec![vec![], vec![], vec![]],
|
|
concat!(
|
|
"[\n",
|
|
" [],\n",
|
|
" [],\n",
|
|
" []\n",
|
|
"]"
|
|
),
|
|
),
|
|
(
|
|
vec![vec![1, 2, 3], vec![], vec![]],
|
|
concat!(
|
|
"[\n",
|
|
" [\n",
|
|
" 1,\n",
|
|
" 2,\n",
|
|
" 3\n",
|
|
" ],\n",
|
|
" [],\n",
|
|
" []\n",
|
|
"]"
|
|
),
|
|
),
|
|
(
|
|
vec![vec![], vec![1, 2, 3], vec![]],
|
|
concat!(
|
|
"[\n",
|
|
" [],\n",
|
|
" [\n",
|
|
" 1,\n",
|
|
" 2,\n",
|
|
" 3\n",
|
|
" ],\n",
|
|
" []\n",
|
|
"]"
|
|
),
|
|
),
|
|
(
|
|
vec![vec![], vec![], vec![1, 2, 3]],
|
|
concat!(
|
|
"[\n",
|
|
" [],\n",
|
|
" [],\n",
|
|
" [\n",
|
|
" 1,\n",
|
|
" 2,\n",
|
|
" 3\n",
|
|
" ]\n",
|
|
"]"
|
|
),
|
|
),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(vec![], "[]"),
|
|
(
|
|
vec![true],
|
|
concat!(
|
|
"[\n",
|
|
" true\n",
|
|
"]"
|
|
),
|
|
),
|
|
(
|
|
vec![true, false],
|
|
concat!(
|
|
"[\n",
|
|
" true,\n",
|
|
" false\n",
|
|
"]"
|
|
),
|
|
),
|
|
]);
|
|
|
|
let long_test_list = Value::Array(vec![
|
|
Value::Bool(false),
|
|
Value::Null,
|
|
Value::Array(vec![Value::String("foo\nbar".to_string()), Value::F64(3.5)])]);
|
|
|
|
test_encode_ok(&[
|
|
(
|
|
long_test_list.clone(),
|
|
"[false,null,[\"foo\\nbar\",3.5]]",
|
|
),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(
|
|
long_test_list,
|
|
concat!(
|
|
"[\n",
|
|
" false,\n",
|
|
" null,\n",
|
|
" [\n",
|
|
" \"foo\\nbar\",\n",
|
|
" 3.5\n",
|
|
" ]\n",
|
|
"]"
|
|
),
|
|
)
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_object() {
|
|
test_encode_ok(&[
|
|
(treemap!(), "{}"),
|
|
(treemap!("a".to_string() => true), "{\"a\":true}"),
|
|
(
|
|
treemap!(
|
|
"a".to_string() => true,
|
|
"b".to_string() => false
|
|
),
|
|
"{\"a\":true,\"b\":false}"),
|
|
]);
|
|
|
|
test_encode_ok(&[
|
|
(
|
|
treemap![
|
|
"a".to_string() => treemap![],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
"{\"a\":{},\"b\":{},\"c\":{}}",
|
|
),
|
|
(
|
|
treemap![
|
|
"a".to_string() => treemap![
|
|
"a".to_string() => treemap!["a" => vec![1,2,3]],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
"{\"a\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"b\":{},\"c\":{}}",
|
|
),
|
|
(
|
|
treemap![
|
|
"a".to_string() => treemap![],
|
|
"b".to_string() => treemap![
|
|
"a".to_string() => treemap!["a" => vec![1,2,3]],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
"{\"a\":{},\"b\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"c\":{}}",
|
|
),
|
|
(
|
|
treemap![
|
|
"a".to_string() => treemap![],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![
|
|
"a".to_string() => treemap!["a" => vec![1,2,3]],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
]
|
|
],
|
|
"{\"a\":{},\"b\":{},\"c\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}}}",
|
|
),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(
|
|
treemap![
|
|
"a".to_string() => treemap![],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
concat!(
|
|
"{\n",
|
|
" \"a\": {},\n",
|
|
" \"b\": {},\n",
|
|
" \"c\": {}\n",
|
|
"}",
|
|
),
|
|
),
|
|
(
|
|
treemap![
|
|
"a".to_string() => treemap![
|
|
"a".to_string() => treemap!["a" => vec![1,2,3]],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
concat!(
|
|
"{\n",
|
|
" \"a\": {\n",
|
|
" \"a\": {\n",
|
|
" \"a\": [\n",
|
|
" 1,\n",
|
|
" 2,\n",
|
|
" 3\n",
|
|
" ]\n",
|
|
" },\n",
|
|
" \"b\": {},\n",
|
|
" \"c\": {}\n",
|
|
" },\n",
|
|
" \"b\": {},\n",
|
|
" \"c\": {}\n",
|
|
"}"
|
|
),
|
|
),
|
|
(
|
|
treemap![
|
|
"a".to_string() => treemap![],
|
|
"b".to_string() => treemap![
|
|
"a".to_string() => treemap!["a" => vec![1,2,3]],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
"c".to_string() => treemap![]
|
|
],
|
|
concat!(
|
|
"{\n",
|
|
" \"a\": {},\n",
|
|
" \"b\": {\n",
|
|
" \"a\": {\n",
|
|
" \"a\": [\n",
|
|
" 1,\n",
|
|
" 2,\n",
|
|
" 3\n",
|
|
" ]\n",
|
|
" },\n",
|
|
" \"b\": {},\n",
|
|
" \"c\": {}\n",
|
|
" },\n",
|
|
" \"c\": {}\n",
|
|
"}"
|
|
),
|
|
),
|
|
(
|
|
treemap![
|
|
"a".to_string() => treemap![],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![
|
|
"a".to_string() => treemap!["a" => vec![1,2,3]],
|
|
"b".to_string() => treemap![],
|
|
"c".to_string() => treemap![]
|
|
]
|
|
],
|
|
concat!(
|
|
"{\n",
|
|
" \"a\": {},\n",
|
|
" \"b\": {},\n",
|
|
" \"c\": {\n",
|
|
" \"a\": {\n",
|
|
" \"a\": [\n",
|
|
" 1,\n",
|
|
" 2,\n",
|
|
" 3\n",
|
|
" ]\n",
|
|
" },\n",
|
|
" \"b\": {},\n",
|
|
" \"c\": {}\n",
|
|
" }\n",
|
|
"}"
|
|
),
|
|
),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(treemap!(), "{}"),
|
|
(
|
|
treemap!("a".to_string() => true),
|
|
concat!(
|
|
"{\n",
|
|
" \"a\": true\n",
|
|
"}"
|
|
),
|
|
),
|
|
(
|
|
treemap!(
|
|
"a".to_string() => true,
|
|
"b".to_string() => false
|
|
),
|
|
concat!(
|
|
"{\n",
|
|
" \"a\": true,\n",
|
|
" \"b\": false\n",
|
|
"}"
|
|
),
|
|
),
|
|
]);
|
|
|
|
let complex_obj = Value::Object(treemap!(
|
|
"b".to_string() => Value::Array(vec![
|
|
Value::Object(treemap!("c".to_string() => Value::String("\x0c\r".to_string()))),
|
|
Value::Object(treemap!("d".to_string() => Value::String("".to_string())))
|
|
])
|
|
));
|
|
|
|
test_encode_ok(&[
|
|
(
|
|
complex_obj.clone(),
|
|
"{\
|
|
\"b\":[\
|
|
{\"c\":\"\\f\\r\"},\
|
|
{\"d\":\"\"}\
|
|
]\
|
|
}"
|
|
),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(
|
|
complex_obj.clone(),
|
|
concat!(
|
|
"{\n",
|
|
" \"b\": [\n",
|
|
" {\n",
|
|
" \"c\": \"\\f\\r\"\n",
|
|
" },\n",
|
|
" {\n",
|
|
" \"d\": \"\"\n",
|
|
" }\n",
|
|
" ]\n",
|
|
"}"
|
|
),
|
|
)
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_tuple() {
|
|
test_encode_ok(&[
|
|
(
|
|
(5,),
|
|
"[5]",
|
|
),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(
|
|
(5,),
|
|
concat!(
|
|
"[\n",
|
|
" 5\n",
|
|
"]"
|
|
),
|
|
),
|
|
]);
|
|
|
|
test_encode_ok(&[
|
|
(
|
|
(5, (6, "abc")),
|
|
"[5,[6,\"abc\"]]",
|
|
),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(
|
|
(5, (6, "abc")),
|
|
concat!(
|
|
"[\n",
|
|
" 5,\n",
|
|
" [\n",
|
|
" 6,\n",
|
|
" \"abc\"\n",
|
|
" ]\n",
|
|
"]"
|
|
),
|
|
),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_enum() {
|
|
test_encode_ok(&[
|
|
(
|
|
Animal::Dog,
|
|
"{\"Dog\":[]}",
|
|
),
|
|
(
|
|
Animal::Frog("Henry".to_string(), vec![]),
|
|
"{\"Frog\":[\"Henry\",[]]}",
|
|
),
|
|
(
|
|
Animal::Frog("Henry".to_string(), vec![349]),
|
|
"{\"Frog\":[\"Henry\",[349]]}",
|
|
),
|
|
(
|
|
Animal::Frog("Henry".to_string(), vec![349, 102]),
|
|
"{\"Frog\":[\"Henry\",[349,102]]}",
|
|
),
|
|
(
|
|
Animal::Cat { age: 5, name: "Kate".to_string() },
|
|
"{\"Cat\":{\"age\":5,\"name\":\"Kate\"}}"
|
|
),
|
|
(
|
|
Animal::AntHive(vec!["Bob".to_string(), "Stuart".to_string()]),
|
|
"{\"AntHive\":[\"Bob\",\"Stuart\"]}",
|
|
),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(
|
|
Animal::Dog,
|
|
concat!(
|
|
"{\n",
|
|
" \"Dog\": []\n",
|
|
"}"
|
|
),
|
|
),
|
|
(
|
|
Animal::Frog("Henry".to_string(), vec![]),
|
|
concat!(
|
|
"{\n",
|
|
" \"Frog\": [\n",
|
|
" \"Henry\",\n",
|
|
" []\n",
|
|
" ]\n",
|
|
"}"
|
|
),
|
|
),
|
|
(
|
|
Animal::Frog("Henry".to_string(), vec![349]),
|
|
concat!(
|
|
"{\n",
|
|
" \"Frog\": [\n",
|
|
" \"Henry\",\n",
|
|
" [\n",
|
|
" 349\n",
|
|
" ]\n",
|
|
" ]\n",
|
|
"}"
|
|
),
|
|
),
|
|
(
|
|
Animal::Frog("Henry".to_string(), vec![349, 102]),
|
|
concat!(
|
|
"{\n",
|
|
" \"Frog\": [\n",
|
|
" \"Henry\",\n",
|
|
" [\n",
|
|
" 349,\n",
|
|
" 102\n",
|
|
" ]\n",
|
|
" ]\n",
|
|
"}"
|
|
),
|
|
),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_write_option() {
|
|
test_encode_ok(&[
|
|
(None, "null"),
|
|
(Some("jodhpurs"), "\"jodhpurs\""),
|
|
]);
|
|
|
|
test_encode_ok(&[
|
|
(None, "null"),
|
|
(Some(vec!["foo", "bar"]), "[\"foo\",\"bar\"]"),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(None, "null"),
|
|
(Some("jodhpurs"), "\"jodhpurs\""),
|
|
]);
|
|
|
|
test_pretty_encode_ok(&[
|
|
(None, "null"),
|
|
(
|
|
Some(vec!["foo", "bar"]),
|
|
concat!(
|
|
"[\n",
|
|
" \"foo\",\n",
|
|
" \"bar\"\n",
|
|
"]"
|
|
),
|
|
),
|
|
]);
|
|
}
|
|
|
|
fn test_parse_ok<T>(errors: Vec<(&'static str, T)>)
|
|
where T: Clone + Debug + PartialEq + ser::Serialize + de::Deserialize,
|
|
{
|
|
for (s, value) in errors {
|
|
let v: T = from_str(s).unwrap();
|
|
assert_eq!(v, value.clone());
|
|
|
|
// Make sure we can deserialize into a `Value`.
|
|
let json_value: Value = from_str(s).unwrap();
|
|
assert_eq!(json_value, to_value(&value));
|
|
|
|
// Make sure we can deserialize from a `Value`.
|
|
let v: T = from_value(json_value.clone()).unwrap();
|
|
assert_eq!(v, value);
|
|
|
|
// Make sure we can round trip back to `Value`.
|
|
let json_value2: Value = from_value(json_value.clone()).unwrap();
|
|
assert_eq!(json_value2, json_value);
|
|
}
|
|
}
|
|
|
|
// FIXME (#5527): these could be merged once UFCS is finished.
|
|
fn test_parse_err<T>(errors: Vec<(&'static str, Error)>)
|
|
where T: Debug + PartialEq + de::Deserialize,
|
|
{
|
|
for (s, err) in errors {
|
|
match (err, from_str::<T>(s).unwrap_err()) {
|
|
(
|
|
Error::SyntaxError(expected_code, expected_line, expected_col),
|
|
Error::SyntaxError(actual_code, actual_line, actual_col),
|
|
) => {
|
|
assert_eq!(
|
|
(expected_code, expected_line, expected_col),
|
|
(actual_code, actual_line, actual_col)
|
|
)
|
|
}
|
|
(expected_err, actual_err) => {
|
|
panic!("unexpected errors {} != {}", expected_err, actual_err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_null() {
|
|
test_parse_err::<()>(vec![
|
|
("n", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 1)),
|
|
("nul", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 3)),
|
|
("nulla", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 5)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("null", ()),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_bool() {
|
|
test_parse_err::<bool>(vec![
|
|
("t", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 1)),
|
|
("truz", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 4)),
|
|
("f", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 1)),
|
|
("faz", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 3)),
|
|
("truea", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 5)),
|
|
("falsea", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 6)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("true", true),
|
|
(" true ", true),
|
|
("false", false),
|
|
(" false ", false),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_number_errors() {
|
|
test_parse_err::<f64>(vec![
|
|
("+", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 1)),
|
|
(".", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 1)),
|
|
("-", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 1)),
|
|
("00", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
|
|
("1.", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
|
|
("1e", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
|
|
("1e+", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 3)),
|
|
("1a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 2)),
|
|
("777777777777777777777777777", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 20)),
|
|
("1e777777777777777777777777777", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 22)),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_i64() {
|
|
test_parse_ok(vec![
|
|
("-2", -2),
|
|
("-1234", -1234),
|
|
(" -1234 ", -1234),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_u64() {
|
|
test_parse_ok(vec![
|
|
("3", 3u64),
|
|
("1234", 1234),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_f64() {
|
|
test_parse_ok(vec![
|
|
("3.0", 3.0f64),
|
|
("3.1", 3.1),
|
|
("-1.2", -1.2),
|
|
("0.4", 0.4),
|
|
("0.4e5", 0.4e5),
|
|
("0.4e15", 0.4e15),
|
|
("0.4e-01", 0.4e-01),
|
|
(" 0.4e-01 ", 0.4e-01),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_string() {
|
|
test_parse_err::<String>(vec![
|
|
("\"", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 1)),
|
|
("\"lol", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 4)),
|
|
("\"lol\"a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 6)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("\"\"", "".to_string()),
|
|
("\"foo\"", "foo".to_string()),
|
|
(" \"foo\" ", "foo".to_string()),
|
|
("\"\\\"\"", "\"".to_string()),
|
|
("\"\\b\"", "\x08".to_string()),
|
|
("\"\\n\"", "\n".to_string()),
|
|
("\"\\r\"", "\r".to_string()),
|
|
("\"\\t\"", "\t".to_string()),
|
|
("\"\\u12ab\"", "\u{12ab}".to_string()),
|
|
("\"\\uAB12\"", "\u{AB12}".to_string()),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_list() {
|
|
test_parse_err::<Vec<f64>>(vec![
|
|
("[", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 1)),
|
|
("[ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
|
|
("[1", Error::SyntaxError(ErrorCode::EOFWhileParsingList, 1, 2)),
|
|
("[1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
|
|
("[1,]", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 4)),
|
|
("[1 2]", Error::SyntaxError(ErrorCode::ExpectedListCommaOrEnd, 1, 4)),
|
|
("[]a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 3)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[]", vec![]),
|
|
("[ ]", vec![]),
|
|
("[null]", vec![()]),
|
|
(" [ null ] ", vec![()]),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[true]", vec![true]),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[3,1]", vec![3u64, 1]),
|
|
(" [ 3 , 1 ] ", vec![3, 1]),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[[3], [1, 2]]", vec![vec![3u64], vec![1, 2]]),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[1]", (1u64,)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[1, 2]", (1u64, 2u64)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[1, 2, 3]", (1u64, 2u64, 3u64)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[1, [2, 3]]", (1u64, (2u64, 3u64))),
|
|
]);
|
|
|
|
let v: () = from_str("[]").unwrap();
|
|
assert_eq!(v, ());
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_object() {
|
|
test_parse_err::<BTreeMap<String, u32>>(vec![
|
|
("{", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 1)),
|
|
("{ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
|
|
("{1", Error::SyntaxError(ErrorCode::KeyMustBeAString, 1, 2)),
|
|
("{ \"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 5)),
|
|
("{\"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 4)),
|
|
("{\"a\" ", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 5)),
|
|
("{\"a\" 1", Error::SyntaxError(ErrorCode::ExpectedColon, 1, 6)),
|
|
("{\"a\":", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 5)),
|
|
("{\"a\":1", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 6)),
|
|
("{\"a\":1 1", Error::SyntaxError(ErrorCode::ExpectedObjectCommaOrEnd, 1, 8)),
|
|
("{\"a\":1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 7)),
|
|
("{}a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 3)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("{}", treemap!()),
|
|
("{ }", treemap!()),
|
|
(
|
|
"{\"a\":3}",
|
|
treemap!("a".to_string() => 3u64)
|
|
),
|
|
(
|
|
"{ \"a\" : 3 }",
|
|
treemap!("a".to_string() => 3)
|
|
),
|
|
(
|
|
"{\"a\":3,\"b\":4}",
|
|
treemap!("a".to_string() => 3, "b".to_string() => 4)
|
|
),
|
|
(
|
|
" { \"a\" : 3 , \"b\" : 4 } ",
|
|
treemap!("a".to_string() => 3, "b".to_string() => 4),
|
|
),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
(
|
|
"{\"a\": {\"b\": 3, \"c\": 4}}",
|
|
treemap!(
|
|
"a".to_string() => treemap!(
|
|
"b".to_string() => 3u64,
|
|
"c".to_string() => 4
|
|
)
|
|
),
|
|
),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_struct() {
|
|
test_parse_err::<Outer>(vec![
|
|
("5", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 1)),
|
|
("\"hello\"", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 7)),
|
|
("{\"inner\": true}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 15)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
(
|
|
"{
|
|
\"inner\": []
|
|
}",
|
|
Outer {
|
|
inner: vec![]
|
|
},
|
|
),
|
|
(
|
|
"{
|
|
\"inner\": [
|
|
{ \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
|
|
]
|
|
}",
|
|
Outer {
|
|
inner: vec![
|
|
Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
|
|
]
|
|
},
|
|
),
|
|
]);
|
|
|
|
let v: Outer = from_str("{}").unwrap();
|
|
|
|
assert_eq!(
|
|
v,
|
|
Outer {
|
|
inner: vec![],
|
|
}
|
|
);
|
|
|
|
let v: Outer = from_str(
|
|
"[
|
|
[
|
|
[ null, 2, [\"abc\", \"xyz\"] ]
|
|
]
|
|
]").unwrap();
|
|
|
|
assert_eq!(
|
|
v,
|
|
Outer {
|
|
inner: vec![
|
|
Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
|
|
],
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_option() {
|
|
test_parse_ok(vec![
|
|
("null", None::<String>),
|
|
("\"jodhpurs\"", Some("jodhpurs".to_string())),
|
|
]);
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
struct Foo {
|
|
x: Option<isize>,
|
|
}
|
|
|
|
let value: Foo = from_str("{}").unwrap();
|
|
assert_eq!(value, Foo { x: None });
|
|
|
|
test_parse_ok(vec![
|
|
("{\"x\": null}", Foo { x: None }),
|
|
("{\"x\": 5}", Foo { x: Some(5) }),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_enum_errors() {
|
|
test_parse_err::<Animal>(vec![
|
|
("{}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 2)),
|
|
("{\"Dog\":", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 7)),
|
|
("{\"Dog\":}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 8)),
|
|
("{\"unknown\":[]}", Error::SyntaxError(ErrorCode::UnknownField("unknown".to_string()), 1, 11)),
|
|
("{\"Dog\":{}}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 9)),
|
|
("{\"Frog\":{}}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 10)),
|
|
("{\"Cat\":[]}", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 9)),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_enum() {
|
|
test_parse_ok(vec![
|
|
("{\"Dog\":[]}", Animal::Dog),
|
|
(" { \"Dog\" : [ ] } ", Animal::Dog),
|
|
(
|
|
"{\"Frog\":[\"Henry\",[]]}",
|
|
Animal::Frog("Henry".to_string(), vec![]),
|
|
),
|
|
(
|
|
" { \"Frog\": [ \"Henry\" , [ 349, 102 ] ] } ",
|
|
Animal::Frog("Henry".to_string(), vec![349, 102]),
|
|
),
|
|
(
|
|
"{\"Cat\": {\"age\": 5, \"name\": \"Kate\"}}",
|
|
Animal::Cat { age: 5, name: "Kate".to_string() },
|
|
),
|
|
(
|
|
" { \"Cat\" : { \"age\" : 5 , \"name\" : \"Kate\" } } ",
|
|
Animal::Cat { age: 5, name: "Kate".to_string() },
|
|
),
|
|
(
|
|
" { \"AntHive\" : [\"Bob\", \"Stuart\"] } ",
|
|
Animal::AntHive(vec!["Bob".to_string(), "Stuart".to_string()]),
|
|
),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
(
|
|
concat!(
|
|
"{",
|
|
" \"a\": {\"Dog\": []},",
|
|
" \"b\": {\"Frog\":[\"Henry\", []]}",
|
|
"}"
|
|
),
|
|
treemap!(
|
|
"a".to_string() => Animal::Dog,
|
|
"b".to_string() => Animal::Frog("Henry".to_string(), vec![])
|
|
)
|
|
),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_trailing_whitespace() {
|
|
test_parse_ok(vec![
|
|
("[1, 2] ", vec![1u64, 2]),
|
|
("[1, 2]\n", vec![1, 2]),
|
|
("[1, 2]\t", vec![1, 2]),
|
|
("[1, 2]\t \n", vec![1, 2]),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_multiline_errors() {
|
|
test_parse_err::<BTreeMap<String, String>>(vec![
|
|
("{\n \"foo\":\n \"bar\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 3, 6)),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_missing_field() {
|
|
#[derive(Debug, PartialEq, Deserialize)]
|
|
struct Foo {
|
|
x: Option<u32>,
|
|
}
|
|
|
|
let value: Foo = from_str("{}").unwrap();
|
|
assert_eq!(value, Foo { x: None });
|
|
|
|
let value: Foo = from_str("{\"x\": 5}").unwrap();
|
|
assert_eq!(value, Foo { x: Some(5) });
|
|
|
|
let value: Foo = from_value(Value::Object(treemap!())).unwrap();
|
|
assert_eq!(value, Foo { x: None });
|
|
|
|
let value: Foo = from_value(Value::Object(treemap!(
|
|
"x".to_string() => Value::I64(5)
|
|
))).unwrap();
|
|
assert_eq!(value, Foo { x: Some(5) });
|
|
}
|
|
|
|
#[test]
|
|
fn test_missing_renamed_field() {
|
|
#[derive(Debug, PartialEq, Deserialize)]
|
|
struct Foo {
|
|
#[serde(rename="y")]
|
|
x: Option<u32>,
|
|
}
|
|
|
|
let value: Foo = from_str("{}").unwrap();
|
|
assert_eq!(value, Foo { x: None });
|
|
|
|
let value: Foo = from_str("{\"y\": 5}").unwrap();
|
|
assert_eq!(value, Foo { x: Some(5) });
|
|
|
|
let value: Foo = from_value(Value::Object(treemap!())).unwrap();
|
|
assert_eq!(value, Foo { x: None });
|
|
|
|
let value: Foo = from_value(Value::Object(treemap!(
|
|
"y".to_string() => Value::I64(5)
|
|
))).unwrap();
|
|
assert_eq!(value, Foo { x: Some(5) });
|
|
}
|
|
|
|
#[test]
|
|
fn test_missing_fmt_renamed_field() {
|
|
#[derive(Debug, PartialEq, Deserialize)]
|
|
struct Foo {
|
|
#[serde(rename(json="y"))]
|
|
x: Option<u32>,
|
|
}
|
|
|
|
let value: Foo = from_str("{}").unwrap();
|
|
assert_eq!(value, Foo { x: None });
|
|
|
|
let value: Foo = from_str("{\"y\": 5}").unwrap();
|
|
assert_eq!(value, Foo { x: Some(5) });
|
|
|
|
let value: Foo = from_value(Value::Object(treemap!())).unwrap();
|
|
assert_eq!(value, Foo { x: None });
|
|
|
|
let value : Foo = from_value(Value::Object(treemap!(
|
|
"y".to_string() => Value::I64(5)
|
|
))).unwrap();
|
|
assert_eq!(value, Foo { x: Some(5) });
|
|
}
|
|
|
|
#[test]
|
|
fn test_find_path() {
|
|
let obj: Value = serde_json::from_str(r#"{"x": {"a": 1}, "y": 2}"#).unwrap();
|
|
|
|
assert!(obj.find_path(&["x", "a"]).unwrap() == &Value::U64(1));
|
|
assert!(obj.find_path(&["y"]).unwrap() == &Value::U64(2));
|
|
assert!(obj.find_path(&["z"]).is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_lookup() {
|
|
let obj: Value = serde_json::from_str(r#"{"x": {"a": 1}, "y": 2}"#).unwrap();
|
|
|
|
assert!(obj.lookup("x.a").unwrap() == &Value::U64(1));
|
|
assert!(obj.lookup("y").unwrap() == &Value::U64(2));
|
|
assert!(obj.lookup("z").is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_serialize_seq_with_no_len() {
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
struct MyVec<T>(Vec<T>);
|
|
|
|
impl<T> ser::Serialize for MyVec<T>
|
|
where T: ser::Serialize,
|
|
{
|
|
#[inline]
|
|
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
|
|
where S: ser::Serializer,
|
|
{
|
|
serializer.visit_seq(ser::impls::SeqIteratorVisitor::new(self.0.iter(), None))
|
|
}
|
|
}
|
|
|
|
struct Visitor<T> {
|
|
marker: PhantomData<MyVec<T>>,
|
|
}
|
|
|
|
impl<T> de::Visitor for Visitor<T>
|
|
where T: de::Deserialize,
|
|
{
|
|
type Value = MyVec<T>;
|
|
|
|
#[inline]
|
|
fn visit_unit<E>(&mut self) -> Result<MyVec<T>, E>
|
|
where E: de::Error,
|
|
{
|
|
Ok(MyVec(Vec::new()))
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_seq<V>(&mut self, mut visitor: V) -> Result<MyVec<T>, V::Error>
|
|
where V: de::SeqVisitor,
|
|
{
|
|
let mut values = Vec::new();
|
|
|
|
while let Some(value) = try!(visitor.visit()) {
|
|
values.push(value);
|
|
}
|
|
|
|
try!(visitor.end());
|
|
|
|
Ok(MyVec(values))
|
|
}
|
|
}
|
|
|
|
impl<T> de::Deserialize for MyVec<T>
|
|
where T: de::Deserialize,
|
|
{
|
|
fn deserialize<D>(deserializer: &mut D) -> Result<MyVec<T>, D::Error>
|
|
where D: de::Deserializer,
|
|
{
|
|
deserializer.visit_map(Visitor { marker: PhantomData })
|
|
}
|
|
}
|
|
|
|
let mut vec = Vec::new();
|
|
vec.push(MyVec(Vec::new()));
|
|
vec.push(MyVec(Vec::new()));
|
|
let vec: MyVec<MyVec<u32>> = MyVec(vec);
|
|
|
|
test_encode_ok(&[
|
|
(
|
|
vec.clone(),
|
|
"[[],[]]",
|
|
),
|
|
]);
|
|
|
|
let s = serde_json::to_string_pretty(&vec).unwrap();
|
|
assert_eq!(
|
|
s,
|
|
concat!(
|
|
"[\n",
|
|
" [\n",
|
|
" ],\n",
|
|
" [\n",
|
|
" ]\n",
|
|
"]"
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_serialize_map_with_no_len() {
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
struct Map<K, V>(BTreeMap<K, V>);
|
|
|
|
impl<K, V> ser::Serialize for Map<K, V>
|
|
where K: ser::Serialize + Ord,
|
|
V: ser::Serialize,
|
|
{
|
|
#[inline]
|
|
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
|
|
where S: ser::Serializer,
|
|
{
|
|
serializer.visit_map(ser::impls::MapIteratorVisitor::new(self.0.iter(), None))
|
|
}
|
|
}
|
|
|
|
struct Visitor<K, V> {
|
|
marker: PhantomData<Map<K, V>>,
|
|
}
|
|
|
|
impl<K, V> de::Visitor for Visitor<K, V>
|
|
where K: de::Deserialize + Eq + Ord,
|
|
V: de::Deserialize,
|
|
{
|
|
type Value = Map<K, V>;
|
|
|
|
#[inline]
|
|
fn visit_unit<E>(&mut self) -> Result<Map<K, V>, E>
|
|
where E: de::Error,
|
|
{
|
|
Ok(Map(BTreeMap::new()))
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_map<Visitor>(&mut self, mut visitor: Visitor) -> Result<Map<K, V>, Visitor::Error>
|
|
where Visitor: de::MapVisitor,
|
|
{
|
|
let mut values = BTreeMap::new();
|
|
|
|
while let Some((key, value)) = try!(visitor.visit()) {
|
|
values.insert(key, value);
|
|
}
|
|
|
|
try!(visitor.end());
|
|
|
|
Ok(Map(values))
|
|
}
|
|
}
|
|
|
|
impl<K, V> de::Deserialize for Map<K, V>
|
|
where K: de::Deserialize + Eq + Ord,
|
|
V: de::Deserialize,
|
|
{
|
|
fn deserialize<D>(deserializer: &mut D) -> Result<Map<K, V>, D::Error>
|
|
where D: de::Deserializer,
|
|
{
|
|
deserializer.visit_map(Visitor { marker: PhantomData })
|
|
}
|
|
}
|
|
|
|
let mut map = BTreeMap::new();
|
|
map.insert("a", Map(BTreeMap::new()));
|
|
map.insert("b", Map(BTreeMap::new()));
|
|
let map: Map<_, Map<u32, u32>> = Map(map);
|
|
|
|
test_encode_ok(&[
|
|
(
|
|
map.clone(),
|
|
"{\"a\":{},\"b\":{}}",
|
|
),
|
|
]);
|
|
|
|
let s = serde_json::to_string_pretty(&map).unwrap();
|
|
assert_eq!(
|
|
s,
|
|
concat!(
|
|
"{\n",
|
|
" \"a\": {\n",
|
|
" },\n",
|
|
" \"b\": {\n",
|
|
" }\n",
|
|
"}"
|
|
)
|
|
);
|
|
}
|