itsscb/serde
1
0
Fork 0
mirror of https://github.com/serde-rs/serde.git synced 2025-10-02 15:25:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Factor out the remaining json tests into tests/

Browse Source
This commit is contained in:
Erick Tryzelaar 2015-03-05 19:49:17 -08:00
parent 5c06137499
commit 2ee5a416ad
4 changed files with 159 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
serde2/src/json/builder.rs
View File

@ -82,57 +82,3 @@ impl ObjectBuilder {
self self
} }
} }
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use json::value::Value;
use super::{ArrayBuilder, ObjectBuilder};
#[test]
fn test_array_builder() {
let value = ArrayBuilder::new().unwrap();
assert_eq!(value, Value::Array(Vec::new()));
let value = ArrayBuilder::new()
.push(1)
.push(2)
.push(3)
.unwrap();
assert_eq!(value, Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3))));
let value = ArrayBuilder::new()
.push_array(|bld| bld.push(1).push(2).push(3))
.unwrap();
assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3))))));
let value = ArrayBuilder::new()
.push_object(|bld|
bld
.insert("a".to_string(), 1)
.insert("b".to_string(), 2))
.unwrap();
let mut map = BTreeMap::new();
map.insert("a".to_string(), Value::I64(1));
map.insert("b".to_string(), Value::I64(2));
assert_eq!(value, Value::Array(vec!(Value::Object(map))));
}
#[test]
fn test_object_builder() {
let value = ObjectBuilder::new().unwrap();
assert_eq!(value, Value::Object(BTreeMap::new()));
let value = ObjectBuilder::new()
.insert("a".to_string(), 1)
.insert("b".to_string(), 2)
.unwrap();
let mut map = BTreeMap::new();
map.insert("a".to_string(), Value::I64(1));
map.insert("b".to_string(), Value::I64(2));
assert_eq!(value, Value::Object(map));
}
}

221
serde2/src/json/de.rs
View File

@ -628,224 +628,3 @@ pub fn from_str<'a, T>(s: &'a str) -> Result<T, Error>
{ {
from_iter(s.bytes()) from_iter(s.bytes())
} }
#[cfg(test)]
mod tests {
use std::fmt::Debug;
use std::collections::BTreeMap;
use de::Deserialize;
use super::from_str;
use super::super::error::{Error, ErrorCode};
macro_rules! treemap {
($($k:expr => $v:expr),*) => ({
let mut _m = BTreeMap::new();
$(_m.insert($k, $v);)*
_m
})
}
fn test_parse_ok<'a, T>(errors: Vec<(&'a str, T)>)
where T: PartialEq + Debug + Deserialize,
{
for (s, value) in errors {
let v: Result<T, Error> = from_str(s);
assert_eq!(v, Ok(value));
/*
let v: Json = from_iter(s.chars()).unwrap();
assert_eq!(v, value.to_json());
*/
}
}
fn test_parse_err<'a, T>(errors: Vec<(&'a str, Error)>)
where T: PartialEq + Debug + Deserialize
{
for (s, err) in errors {
let v: Result<T, Error> = from_str(s);
assert_eq!(v, Err(err));
}
}
#[test]
fn test_parse_null() {
test_parse_ok(vec![
("null", ()),
]);
}
#[test]
fn test_parse_bool() {
test_parse_err::<bool>(vec![
("t", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 2)),
("truz", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 4)),
("f", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 2)),
("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),
("false", false),
]);
}
#[test]
fn test_parse_numbers() {
test_parse_err::<f64>(vec![
("+", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 1)),
(".", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 1)),
("-", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
("00", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
("1.", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 3)),
("1e", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 3)),
("1e+", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 4)),
("1a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 2)),
]);
test_parse_ok(vec![
("3", 3i64),
("-2", -2),
("-1234", -1234),
]);
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),
]);
}
#[test]
fn test_parse_string() {
test_parse_err::<String>(vec![
("\"", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 2)),
("\"lol", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 5)),
("\"lol\"a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 6)),
]);
test_parse_ok(vec![
("\"\"", "".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, 2)),
("[ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
("[1", Error::SyntaxError(ErrorCode::EOFWhileParsingList, 1, 3)),
("[1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 4)),
("[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![3, 1]),
("[ 3 , 1 ]", vec![3, 1]),
]);
test_parse_ok(vec![
("[[3], [1, 2]]", vec![vec![3], vec![1, 2]]),
]);
test_parse_ok(vec![
("[]", ()),
]);
test_parse_ok(vec![
("[1]", (1,)),
]);
test_parse_ok(vec![
("[1, 2]", (1, 2)),
]);
test_parse_ok(vec![
("[1, 2, 3]", (1, 2, 3)),
]);
}
#[test]
fn test_parse_object() {
test_parse_err::<BTreeMap<String, i32>>(vec![
("{", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
("{ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
("{1", Error::SyntaxError(ErrorCode::KeyMustBeAString, 1, 2)),
("{ \"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 6)),
("{\"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 5)),
("{\"a\" ", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 6)),
("{\"a\" 1", Error::SyntaxError(ErrorCode::ExpectedColon, 1, 6)),
("{\"a\":", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 6)),
("{\"a\":1", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 7)),
("{\"a\":1 1", Error::SyntaxError(ErrorCode::ExpectedObjectCommaOrEnd, 1, 8)),
("{\"a\":1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 8)),
("{}a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 3)),
]);
test_parse_ok(vec![
("{}", treemap!()),
("{ }", treemap!()),
(
"{\"a\":3}",
treemap!("a".to_string() => 3)
),
(
"{ \"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() => 3, "c".to_string() => 4)),
),
]);
}
#[test]
fn test_parse_trailing_whitespace() {
test_parse_ok(vec![
("[1, 2] ", vec![1, 2]),
("[1, 2]\n", vec![1, 2]),
("[1, 2]\t", vec![1, 2]),
("[1, 2]\t \n", vec![1, 2]),
]);
}
}

203
serde2/tests/test_json.rs
View File

@ -5,7 +5,6 @@ extern crate test;
extern crate serde2; extern crate serde2;
use std::fmt::Debug; use std::fmt::Debug;
use std::string;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use serde2::de; use serde2::de;
@ -13,35 +12,17 @@ use serde2::ser;
use serde2::json::{ use serde2::json::{
self, self,
Error,
Value, Value,
from_str, from_str,
from_value, from_value,
to_value, to_value,
}; };
use serde2::json::error::Error::{ use serde2::json::error::{Error, ErrorCode};
SyntaxError,
};
use serde2::json::error::ErrorCode::{
EOFWhileParsingList,
EOFWhileParsingObject,
EOFWhileParsingString,
EOFWhileParsingValue,
ExpectedColon,
ExpectedListCommaOrEnd,
ExpectedObjectCommaOrEnd,
ExpectedSomeIdent,
ExpectedSomeValue,
InvalidNumber,
KeyMustBeAString,
TrailingCharacters,
};
macro_rules! treemap { macro_rules! treemap {
($($k:expr => $v:expr),*) => ({ ($($k:expr => $v:expr),*) => ({
let mut _m = ::std::collections::BTreeMap::new(); let mut _m = BTreeMap::new();
$(_m.insert($k, $v);)* $(_m.insert($k, $v);)*
_m _m
}) })
@ -63,7 +44,7 @@ enum Animal {
struct Inner { struct Inner {
a: (), a: (),
b: usize, b: usize,
c: Vec<string::String>, c: Vec<String>,
} }
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
@ -456,16 +437,6 @@ fn test_write_option() {
*/ */
} }
// FIXME (#5527): these could be merged once UFCS is finished.
fn test_parse_err<'a, T>(errors: &[(&'a str, Error)])
where T: Debug + de::Deserialize,
{
for &(s, ref err) in errors {
let v: Result<T, Error> = from_str(s);
assert_eq!(v.unwrap_err(), *err);
}
}
fn test_parse_ok<'a, T>(errors: &[(&'a str, T)]) fn test_parse_ok<'a, T>(errors: &[(&'a str, T)])
where T: PartialEq + Debug + ser::Serialize + de::Deserialize, where T: PartialEq + Debug + ser::Serialize + de::Deserialize,
{ {
@ -487,12 +458,22 @@ fn test_parse_ok<'a, T>(errors: &[(&'a str, T)])
} }
} }
// FIXME (#5527): these could be merged once UFCS is finished.
fn test_parse_err<'a, T>(errors: &[(&'a str, Error)])
where T: Debug + de::Deserialize,
{
for &(s, ref err) in errors {
let v: Result<T, Error> = from_str(s);
assert_eq!(v.unwrap_err(), *err);
}
}
#[test] #[test]
fn test_parse_null() { fn test_parse_null() {
test_parse_err::<()>(&[ test_parse_err::<()>(&[
("n", SyntaxError(ExpectedSomeIdent, 1, 2)), ("n", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 2)),
("nul", SyntaxError(ExpectedSomeIdent, 1, 4)), ("nul", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 4)),
("nulla", SyntaxError(TrailingCharacters, 1, 5)), ("nulla", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 5)),
]); ]);
test_parse_ok(&[ test_parse_ok(&[
@ -503,31 +484,33 @@ fn test_parse_null() {
#[test] #[test]
fn test_parse_bool() { fn test_parse_bool() {
test_parse_err::<bool>(&[ test_parse_err::<bool>(&[
("t", SyntaxError(ExpectedSomeIdent, 1, 2)), ("t", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 2)),
("truz", SyntaxError(ExpectedSomeIdent, 1, 4)), ("truz", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 4)),
("f", SyntaxError(ExpectedSomeIdent, 1, 2)), ("f", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 2)),
("faz", SyntaxError(ExpectedSomeIdent, 1, 3)), ("faz", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 3)),
("truea", SyntaxError(TrailingCharacters, 1, 5)), ("truea", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 5)),
("falsea", SyntaxError(TrailingCharacters, 1, 6)), ("falsea", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 6)),
]); ]);
test_parse_ok(&[ test_parse_ok(&[
("true", true), ("true", true),
(" true ", true),
("false", false), ("false", false),
(" false ", false),
]); ]);
} }
#[test] #[test]
fn test_parse_number_errors() { fn test_parse_number_errors() {
test_parse_err::<f64>(&[ test_parse_err::<f64>(&[
("+", SyntaxError(ExpectedSomeValue, 1, 1)), ("+", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 1)),
(".", SyntaxError(ExpectedSomeValue, 1, 1)), (".", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 1)),
("-", SyntaxError(InvalidNumber, 1, 2)), ("-", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
("00", SyntaxError(InvalidNumber, 1, 2)), ("00", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
("1.", SyntaxError(InvalidNumber, 1, 3)), ("1.", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 3)),
("1e", SyntaxError(InvalidNumber, 1, 3)), ("1e", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 3)),
("1e+", SyntaxError(InvalidNumber, 1, 4)), ("1e+", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 4)),
("1a", SyntaxError(TrailingCharacters, 1, 2)), ("1a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 2)),
]); ]);
} }
@ -537,6 +520,7 @@ fn test_parse_i64() {
("3", 3), ("3", 3),
("-2", -2), ("-2", -2),
("-1234", -1234), ("-1234", -1234),
(" -1234 ", -1234),
]); ]);
} }
@ -550,15 +534,16 @@ fn test_parse_f64() {
("0.4e5", 0.4e5), ("0.4e5", 0.4e5),
("0.4e15", 0.4e15), ("0.4e15", 0.4e15),
("0.4e-01", 0.4e-01), ("0.4e-01", 0.4e-01),
(" 0.4e-01 ", 0.4e-01),
]); ]);
} }
#[test] #[test]
fn test_parse_string() { fn test_parse_string() {
test_parse_err::<string::String>(&[ test_parse_err::<String>(&[
("\"", SyntaxError(EOFWhileParsingString, 1, 2)), ("\"", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 2)),
("\"lol", SyntaxError(EOFWhileParsingString, 1, 5)), ("\"lol", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 5)),
("\"lol\"a", SyntaxError(TrailingCharacters, 1, 6)), ("\"lol\"a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 6)),
]); ]);
test_parse_ok(&[ test_parse_ok(&[
@ -578,58 +563,70 @@ fn test_parse_string() {
#[test] #[test]
fn test_parse_list() { fn test_parse_list() {
test_parse_err::<Vec<f64>>(&[ test_parse_err::<Vec<f64>>(&[
("[", SyntaxError(EOFWhileParsingValue, 1, 2)), ("[", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
("[ ", SyntaxError(EOFWhileParsingValue, 1, 3)), ("[ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
("[1", SyntaxError(EOFWhileParsingList, 1, 3)), ("[1", Error::SyntaxError(ErrorCode::EOFWhileParsingList, 1, 3)),
("[1,", SyntaxError(EOFWhileParsingValue, 1, 4)), ("[1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 4)),
("[1,]", SyntaxError(ExpectedSomeValue, 1, 4)), ("[1,]", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 4)),
("[1 2]", SyntaxError(ExpectedListCommaOrEnd, 1, 4)), ("[1 2]", Error::SyntaxError(ErrorCode::ExpectedListCommaOrEnd, 1, 4)),
("[]a", SyntaxError(TrailingCharacters, 1, 3)), ("[]a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 3)),
]); ]);
test_parse_ok(&[ test_parse_ok(&[
("[]", vec!()), ("[]", vec![]),
("[ ]", vec!()), ("[ ]", vec![]),
("[null]", vec!(())), ("[null]", vec![()]),
(" [ null ] ", vec!(())), (" [ null ] ", vec![()]),
]); ]);
test_parse_ok(&[ test_parse_ok(&[
("[true]", vec!(true)), ("[true]", vec![true]),
]); ]);
test_parse_ok(&[ test_parse_ok(&[
("[3,1]", vec!(3, 1)), ("[3,1]", vec![3, 1]),
(" [ 3 , 1 ] ", vec!(3, 1)), (" [ 3 , 1 ] ", vec![3, 1]),
]); ]);
test_parse_ok(&[ test_parse_ok(&[
("[[3], [1, 2]]", vec!(vec!(3), vec!(1, 2))), ("[[3], [1, 2]]", vec![vec![3], vec![1, 2]]),
]); ]);
let v: () = from_str("[]").unwrap(); test_parse_ok(&[
assert_eq!(v, ()); ("[1]", (1,)),
]);
test_parse_ok(&[
("[1, 2]", (1, 2)),
]);
test_parse_ok(&[ test_parse_ok(&[
("[1, 2, 3]", (1, 2, 3)), ("[1, 2, 3]", (1, 2, 3)),
]); ]);
test_parse_ok(&[
("[1, [2, 3]]", (1, (2, 3))),
]);
let v: () = from_str("[]").unwrap();
assert_eq!(v, ());
} }
#[test] #[test]
fn test_parse_object() { fn test_parse_object() {
test_parse_err::<BTreeMap<string::String, isize>>(&[ test_parse_err::<BTreeMap<String, u32>>(&[
("{", SyntaxError(EOFWhileParsingValue, 1, 2)), ("{", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
("{ ", SyntaxError(EOFWhileParsingValue, 1, 3)), ("{ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
("{1", SyntaxError(KeyMustBeAString, 1, 2)), ("{1", Error::SyntaxError(ErrorCode::KeyMustBeAString, 1, 2)),
("{ \"a\"", SyntaxError(EOFWhileParsingObject, 1, 6)), ("{ \"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 6)),
("{\"a\"", SyntaxError(EOFWhileParsingObject, 1, 5)), ("{\"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 5)),
("{\"a\" ", SyntaxError(EOFWhileParsingObject, 1, 6)), ("{\"a\" ", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 6)),
("{\"a\" 1", SyntaxError(ExpectedColon, 1, 6)), ("{\"a\" 1", Error::SyntaxError(ErrorCode::ExpectedColon, 1, 6)),
("{\"a\":", SyntaxError(EOFWhileParsingValue, 1, 6)), ("{\"a\":", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 6)),
("{\"a\":1", SyntaxError(EOFWhileParsingObject, 1, 7)), ("{\"a\":1", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 7)),
("{\"a\":1 1", SyntaxError(ExpectedObjectCommaOrEnd, 1, 8)), ("{\"a\":1 1", Error::SyntaxError(ErrorCode::ExpectedObjectCommaOrEnd, 1, 8)),
("{\"a\":1,", SyntaxError(EOFWhileParsingValue, 1, 8)), ("{\"a\":1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 8)),
("{}a", SyntaxError(TrailingCharacters, 1, 3)), ("{}a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 3)),
]); ]);
test_parse_ok(&[ test_parse_ok(&[
@ -716,18 +713,18 @@ fn test_parse_option() {
fn test_parse_enum() { fn test_parse_enum() {
/* /*
test_parse_err::<Animal>(&[ test_parse_err::<Animal>(&[
("{", SyntaxError(EOFWhileParsingString, 1, 2)), ("{", Error::SyntaxError(EOFWhileParsingString, 1, 2)),
("{ ", SyntaxError(EOFWhileParsingString, 1, 3)), ("{ ", Error::SyntaxError(EOFWhileParsingString, 1, 3)),
("{1", SyntaxError(KeyMustBeAString, 1, 2)), ("{1", Error::SyntaxError(KeyMustBeAString, 1, 2)),
("{ \"a\"", SyntaxError(EOFWhileParsingObject, 1, 6)), ("{ \"a\"", Error::SyntaxError(EOFWhileParsingObject, 1, 6)),
("{\"a\"", SyntaxError(EOFWhileParsingObject, 1, 5)), ("{\"a\"", Error::SyntaxError(EOFWhileParsingObject, 1, 5)),
("{\"a\" ", SyntaxError(EOFWhileParsingObject, 1, 6)), ("{\"a\" ", Error::SyntaxError(EOFWhileParsingObject, 1, 6)),
("{\"a\" 1", SyntaxError(ExpectedColon, 1, 6)), ("{\"a\" 1", Error::SyntaxError(ExpectedColon, 1, 6)),
("{\"a\":", SyntaxError(EOFWhileParsingValue, 1, 6)), ("{\"a\":", Error::SyntaxError(EOFWhileParsingValue, 1, 6)),
("{\"a\":1", SyntaxError(EOFWhileParsingObject, 1, 7)), ("{\"a\":1", Error::SyntaxError(EOFWhileParsingObject, 1, 7)),
("{\"a\":1 1", SyntaxError(ExpectedObjectCommaOrEnd, 1, 8)), ("{\"a\":1 1", Error::SyntaxError(ExpectedObjectCommaOrEnd, 1, 8)),
("{\"a\":1,", SyntaxError(EOFWhileParsingValue, 1, 8)), ("{\"a\":1,", Error::SyntaxError(EOFWhileParsingValue, 1, 8)),
("{}a", SyntaxError(TrailingCharacters, 1, 3)), ("{}a", Error::SyntaxError(TrailingCharacters, 1, 3)),
]); ]);
*/ */
@ -770,12 +767,22 @@ fn test_parse_enum() {
*/ */
} }
#[test]
fn test_parse_trailing_whitespace() {
test_parse_ok(&[
("[1, 2] ", vec![1, 2]),
("[1, 2]\n", vec![1, 2]),
("[1, 2]\t", vec![1, 2]),
("[1, 2]\t \n", vec![1, 2]),
]);
}
/* /*
#[test] #[test]
fn test_multiline_errors() { fn test_multiline_errors() {
test_parse_err::<BTreeMap<string::String, string::String>>(&[ test_parse_err::<BTreeMap<String, String>>(&[
("{\n \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3us, 8us)), ("{\n \"foo\":\n \"bar\"", Error::SyntaxError(EOFWhileParsingObject, 3us, 8us)),
]); ]);
} }
@ -869,7 +876,7 @@ fn test_is_object() {
#[test] #[test]
fn test_as_object() { fn test_as_object() {
let json_value: Value = from_str("{}").unwrap(); let json_value: Value = from_str("{}").unwrap();
let map = BTreeMap::<string::String, Value>::new(); let map = BTreeMap::<String, Value>::new();
let json_object = json_value.as_object(); let json_object = json_value.as_object();
assert_eq!(json_object, Some(&map)); assert_eq!(json_object, Some(&map));
} }

54
serde2/tests/test_json_builder.rs Normal file
View File

@ -0,0 +1,54 @@
#![feature(test)]
extern crate serde2;
use std::collections::BTreeMap;
use serde2::json::value::Value;
use serde2::json::builder::{ArrayBuilder, ObjectBuilder};
#[test]
fn test_array_builder() {
let value = ArrayBuilder::new().unwrap();
assert_eq!(value, Value::Array(Vec::new()));
let value = ArrayBuilder::new()
.push(1)
.push(2)
.push(3)
.unwrap();
assert_eq!(value, Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3))));
let value = ArrayBuilder::new()
.push_array(|bld| bld.push(1).push(2).push(3))
.unwrap();
assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3))))));
let value = ArrayBuilder::new()
.push_object(|bld|
bld
.insert("a".to_string(), 1)
.insert("b".to_string(), 2))
.unwrap();
let mut map = BTreeMap::new();
map.insert("a".to_string(), Value::I64(1));
map.insert("b".to_string(), Value::I64(2));
assert_eq!(value, Value::Array(vec!(Value::Object(map))));
}
#[test]
fn test_object_builder() {
let value = ObjectBuilder::new().unwrap();
assert_eq!(value, Value::Object(BTreeMap::new()));
let value = ObjectBuilder::new()
.insert("a".to_string(), 1)
.insert("b".to_string(), 2)
.unwrap();
let mut map = BTreeMap::new();
map.insert("a".to_string(), Value::I64(1));
map.insert("b".to_string(), Value::I64(2));
assert_eq!(value, Value::Object(map));
}