mirror of
https://github.com/pezkuwichain/serde.git
synced 2026-04-23 04:48:01 +00:00
Erick Tryzelaar
816 lines
23 KiB
Rust
816 lines
23 KiB
Rust
use std::char;
|
|
use std::fmt;
|
|
use std::num;
|
|
use std::str::ScalarValue;
|
|
use std::str;
|
|
|
|
use de;
|
|
use de::Deserializer;
|
|
|
|
#[deriving(Clone, PartialEq, Eq)]
|
|
pub enum ErrorCode {
|
|
EOFWhileParsingList,
|
|
EOFWhileParsingObject,
|
|
EOFWhileParsingString,
|
|
EOFWhileParsingValue,
|
|
ExpectedColon,
|
|
InvalidEscape,
|
|
InvalidNumber,
|
|
InvalidSyntax(SyntaxExpectation),
|
|
InvalidUnicodeCodePoint,
|
|
KeyMustBeAString,
|
|
LoneLeadingSurrogateInHexEscape,
|
|
MissingField(&'static str),
|
|
NotFourDigit,
|
|
NotUtf8,
|
|
TrailingCharacters,
|
|
UnexpectedEndOfHexEscape,
|
|
UnknownVariant,
|
|
UnrecognizedHex,
|
|
}
|
|
|
|
/// The failed expectation of InvalidSyntax
|
|
#[deriving(Clone, PartialEq, Eq, Show)]
|
|
pub enum SyntaxExpectation {
|
|
ListCommaOrEnd,
|
|
ObjectCommaOrEnd,
|
|
SomeValue,
|
|
SomeIdent,
|
|
EnumMapStart,
|
|
EnumVariantString,
|
|
EnumToken,
|
|
EnumEndToken,
|
|
EnumEnd,
|
|
}
|
|
|
|
impl fmt::Show for ErrorCode {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match *self {
|
|
EOFWhileParsingList => "EOF While parsing list".fmt(f),
|
|
EOFWhileParsingObject => "EOF While parsing object".fmt(f),
|
|
EOFWhileParsingString => "EOF While parsing string".fmt(f),
|
|
EOFWhileParsingValue => "EOF While parsing value".fmt(f),
|
|
ExpectedColon => "expected `:`".fmt(f),
|
|
InvalidEscape => "invalid escape".fmt(f),
|
|
InvalidNumber => "invalid number".fmt(f),
|
|
InvalidSyntax(expect) => {
|
|
write!(f, "invalid syntax, expected: {}", expect)
|
|
}
|
|
InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f),
|
|
KeyMustBeAString => "key must be a string".fmt(f),
|
|
LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f),
|
|
MissingField(field) => {
|
|
write!(f, "missing field \"{}\"", field)
|
|
}
|
|
NotFourDigit => "invalid \\u escape (not four digits)".fmt(f),
|
|
NotUtf8 => "contents not utf-8".fmt(f),
|
|
TrailingCharacters => "trailing characters".fmt(f),
|
|
UnexpectedEndOfHexEscape => "unexpected end of hex escape".fmt(f),
|
|
UnknownVariant => "unknown variant".fmt(f),
|
|
UnrecognizedHex => "invalid \\u escape (unrecognized hex)".fmt(f),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[deriving(PartialEq, Eq, Show)]
|
|
pub enum Error {
|
|
SyntaxError(ErrorCode, uint, uint),
|
|
}
|
|
|
|
pub struct Parser<Iter> {
|
|
rdr: Iter,
|
|
ch: Option<char>,
|
|
line: uint,
|
|
col: uint,
|
|
}
|
|
|
|
impl<
|
|
Iter: Iterator<char>,
|
|
> Parser<Iter> {
|
|
/// Creates the JSON parser.
|
|
pub fn new(rdr: Iter) -> Parser<Iter> {
|
|
let mut p = Parser {
|
|
rdr: rdr,
|
|
ch: Some('\x00'),
|
|
line: 1,
|
|
col: 0,
|
|
};
|
|
p.bump();
|
|
return p;
|
|
}
|
|
|
|
pub fn end(&mut self) -> Result<(), Error> {
|
|
if self.eof() {
|
|
Ok(())
|
|
} else {
|
|
Err(self.error(TrailingCharacters))
|
|
}
|
|
}
|
|
|
|
fn eof(&self) -> bool { self.ch.is_none() }
|
|
|
|
fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
|
|
|
|
fn bump(&mut self) {
|
|
self.ch = self.rdr.next();
|
|
|
|
if self.ch_is('\n') {
|
|
self.line += 1;
|
|
self.col = 1;
|
|
} else {
|
|
self.col += 1;
|
|
}
|
|
}
|
|
|
|
fn next_char(&mut self) -> Option<char> {
|
|
self.bump();
|
|
self.ch
|
|
}
|
|
|
|
fn ch_is(&self, c: char) -> bool {
|
|
self.ch == Some(c)
|
|
}
|
|
|
|
fn parse_whitespace(&mut self) {
|
|
while self.ch_is(' ') ||
|
|
self.ch_is('\n') ||
|
|
self.ch_is('\t') ||
|
|
self.ch_is('\r') { self.bump(); }
|
|
}
|
|
|
|
fn error(&mut self, reason: ErrorCode) -> Error {
|
|
//self.state_stack.clear();
|
|
SyntaxError(reason, self.line, self.col)
|
|
}
|
|
|
|
fn parse_value<
|
|
R,
|
|
V: de::Visitor<Parser<Iter>, R, Error>,
|
|
>(&mut self, visitor: &mut V) -> Result<R, Error> {
|
|
self.parse_whitespace();
|
|
|
|
if self.eof() {
|
|
return Err(self.error(EOFWhileParsingValue));
|
|
}
|
|
|
|
match self.ch_or_null() {
|
|
'n' => {
|
|
try!(self.parse_ident("ull"));
|
|
visitor.visit_null(self)
|
|
}
|
|
't' => {
|
|
try!(self.parse_ident("rue"));
|
|
visitor.visit_bool(self, true)
|
|
}
|
|
'f' => {
|
|
try!(self.parse_ident("alse"));
|
|
visitor.visit_bool(self, false)
|
|
}
|
|
'0' ... '9' | '-' => self.parse_number(visitor),
|
|
'"' => {
|
|
let s = try!(self.parse_string());
|
|
visitor.visit_string(self, s)
|
|
}
|
|
'[' => {
|
|
self.bump();
|
|
visitor.visit_seq(self, SeqVisitor { first: true })
|
|
}
|
|
'{' => {
|
|
self.bump();
|
|
visitor.visit_map(self, MapVisitor { first: true })
|
|
}
|
|
_ => {
|
|
Err(self.error(InvalidSyntax(SomeValue)))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_ident(&mut self, ident: &str) -> Result<(), Error> {
|
|
if ident.chars().all(|c| Some(c) == self.next_char()) {
|
|
self.bump();
|
|
Ok(())
|
|
} else {
|
|
Err(self.error(InvalidSyntax(SomeIdent)))
|
|
}
|
|
}
|
|
|
|
fn parse_number<
|
|
R,
|
|
V: de::Visitor<Parser<Iter>, R, Error>,
|
|
>(&mut self, visitor: &mut V) -> Result<R, Error> {
|
|
let mut neg = 1;
|
|
|
|
if self.ch_is('-') {
|
|
self.bump();
|
|
neg = -1;
|
|
}
|
|
|
|
let res = try!(self.parse_integer());
|
|
|
|
if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
|
|
let neg = neg as f64;
|
|
let mut res = res as f64;
|
|
|
|
if self.ch_is('.') {
|
|
res = try!(self.parse_decimal(res));
|
|
}
|
|
|
|
if self.ch_is('e') || self.ch_is('E') {
|
|
res = try!(self.parse_exponent(res));
|
|
}
|
|
|
|
visitor.visit_f64(self, neg * res)
|
|
} else {
|
|
visitor.visit_i64(self, neg * res)
|
|
}
|
|
}
|
|
|
|
fn parse_integer(&mut self) -> Result<i64, Error> {
|
|
let mut res = 0;
|
|
|
|
match self.ch_or_null() {
|
|
'0' => {
|
|
self.bump();
|
|
|
|
// There can be only one leading '0'.
|
|
match self.ch_or_null() {
|
|
'0' ... '9' => {
|
|
return Err(self.error(InvalidNumber));
|
|
}
|
|
_ => ()
|
|
}
|
|
},
|
|
'1' ... '9' => {
|
|
while !self.eof() {
|
|
match self.ch_or_null() {
|
|
c @ '0' ... '9' => {
|
|
res *= 10;
|
|
res += (c as i64) - ('0' as i64);
|
|
self.bump();
|
|
}
|
|
_ => break,
|
|
}
|
|
}
|
|
}
|
|
_ => {
|
|
return Err(self.error(InvalidNumber));
|
|
}
|
|
}
|
|
|
|
Ok(res)
|
|
}
|
|
|
|
fn parse_decimal(&mut self, res: f64) -> Result<f64, Error> {
|
|
self.bump();
|
|
|
|
// Make sure a digit follows the decimal place.
|
|
match self.ch_or_null() {
|
|
'0' ... '9' => (),
|
|
_ => {
|
|
return Err(self.error(InvalidNumber));
|
|
}
|
|
}
|
|
|
|
let mut res = res;
|
|
let mut dec = 1.0;
|
|
while !self.eof() {
|
|
match self.ch_or_null() {
|
|
c @ '0' ... '9' => {
|
|
dec /= 10.0;
|
|
res += (((c as int) - ('0' as int)) as f64) * dec;
|
|
self.bump();
|
|
}
|
|
_ => break,
|
|
}
|
|
}
|
|
|
|
Ok(res)
|
|
}
|
|
|
|
fn parse_exponent(&mut self, mut res: f64) -> Result<f64, Error> {
|
|
self.bump();
|
|
|
|
let mut exp = 0u;
|
|
let mut neg_exp = false;
|
|
|
|
if self.ch_is('+') {
|
|
self.bump();
|
|
} else if self.ch_is('-') {
|
|
self.bump();
|
|
neg_exp = true;
|
|
}
|
|
|
|
// Make sure a digit follows the exponent place.
|
|
match self.ch_or_null() {
|
|
'0' ... '9' => (),
|
|
_ => {
|
|
return Err(self.error(InvalidNumber));
|
|
}
|
|
}
|
|
while !self.eof() {
|
|
match self.ch_or_null() {
|
|
c @ '0' ... '9' => {
|
|
exp *= 10;
|
|
exp += (c as uint) - ('0' as uint);
|
|
|
|
self.bump();
|
|
}
|
|
_ => break
|
|
}
|
|
}
|
|
|
|
let exp: f64 = num::pow(10u as f64, exp);
|
|
if neg_exp {
|
|
res /= exp;
|
|
} else {
|
|
res *= exp;
|
|
}
|
|
|
|
Ok(res)
|
|
}
|
|
|
|
fn decode_hex_escape(&mut self) -> Result<u16, Error> {
|
|
let mut i = 0u;
|
|
let mut n = 0u16;
|
|
while i < 4u && !self.eof() {
|
|
self.bump();
|
|
n = match self.ch_or_null() {
|
|
c @ '0' ... '9' => n * 16_u16 + ((c as u16) - ('0' as u16)),
|
|
'a' | 'A' => n * 16_u16 + 10_u16,
|
|
'b' | 'B' => n * 16_u16 + 11_u16,
|
|
'c' | 'C' => n * 16_u16 + 12_u16,
|
|
'd' | 'D' => n * 16_u16 + 13_u16,
|
|
'e' | 'E' => n * 16_u16 + 14_u16,
|
|
'f' | 'F' => n * 16_u16 + 15_u16,
|
|
_ => {
|
|
return Err(self.error(InvalidEscape));
|
|
}
|
|
};
|
|
|
|
i += 1u;
|
|
}
|
|
|
|
// Error out if we didn't parse 4 digits.
|
|
if i != 4u {
|
|
return Err(self.error(InvalidEscape));
|
|
}
|
|
|
|
Ok(n)
|
|
}
|
|
|
|
fn parse_string(&mut self) -> Result<String, Error> {
|
|
let mut escape = false;
|
|
let mut res = String::new();
|
|
|
|
loop {
|
|
self.bump();
|
|
if self.eof() {
|
|
return Err(self.error(EOFWhileParsingString));
|
|
}
|
|
|
|
if escape {
|
|
match self.ch_or_null() {
|
|
'"' => res.push('"'),
|
|
'\\' => res.push('\\'),
|
|
'/' => res.push('/'),
|
|
'b' => res.push('\x08'),
|
|
'f' => res.push('\x0c'),
|
|
'n' => res.push('\n'),
|
|
'r' => res.push('\r'),
|
|
't' => res.push('\t'),
|
|
'u' => match try!(self.decode_hex_escape()) {
|
|
0xDC00 ... 0xDFFF => {
|
|
return Err(self.error(LoneLeadingSurrogateInHexEscape));
|
|
}
|
|
|
|
// Non-BMP characters are encoded as a sequence of
|
|
// two hex escapes, representing UTF-16 surrogates.
|
|
n1 @ 0xD800 ... 0xDBFF => {
|
|
let c1 = self.next_char();
|
|
let c2 = self.next_char();
|
|
match (c1, c2) {
|
|
(Some('\\'), Some('u')) => (),
|
|
_ => {
|
|
return Err(self.error(UnexpectedEndOfHexEscape));
|
|
}
|
|
}
|
|
|
|
let buf = [n1, try!(self.decode_hex_escape())];
|
|
match str::utf16_items(buf.as_slice()).next() {
|
|
Some(ScalarValue(c)) => res.push(c),
|
|
_ => {
|
|
return Err(self.error(LoneLeadingSurrogateInHexEscape));
|
|
}
|
|
}
|
|
}
|
|
|
|
n => match char::from_u32(n as u32) {
|
|
Some(c) => res.push(c),
|
|
None => {
|
|
return Err(self.error(InvalidUnicodeCodePoint));
|
|
}
|
|
},
|
|
},
|
|
_ => {
|
|
return Err(self.error(InvalidEscape));
|
|
}
|
|
}
|
|
escape = false;
|
|
} else if self.ch_is('\\') {
|
|
escape = true;
|
|
} else {
|
|
match self.ch {
|
|
Some('"') => {
|
|
self.bump();
|
|
return Ok(res);
|
|
},
|
|
Some(c) => res.push(c),
|
|
None => unreachable!()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<Iter: Iterator<char>> Deserializer<Error> for Parser<Iter> {
|
|
#[inline]
|
|
fn visit<
|
|
R,
|
|
V: de::Visitor<Parser<Iter>, R, Error>,
|
|
>(&mut self, visitor: &mut V) -> Result<R, Error> {
|
|
self.parse_value(visitor)
|
|
}
|
|
|
|
fn syntax_error(&mut self) -> Error {
|
|
SyntaxError(InvalidSyntax(SomeValue), self.line, self.col)
|
|
}
|
|
|
|
fn end_of_stream_error(&mut self) -> Error {
|
|
SyntaxError(EOFWhileParsingValue, self.line, self.col)
|
|
}
|
|
}
|
|
|
|
struct SeqVisitor {
|
|
first: bool,
|
|
}
|
|
|
|
impl<Iter: Iterator<char>> de::SeqVisitor<Parser<Iter>, Error> for SeqVisitor {
|
|
fn visit<
|
|
T: de::Deserialize<Parser<Iter>, Error>,
|
|
>(&mut self, d: &mut Parser<Iter>) -> Result<Option<T>, Error> {
|
|
d.parse_whitespace();
|
|
|
|
if d.ch_is(']') {
|
|
d.bump();
|
|
return Ok(None);
|
|
}
|
|
|
|
if self.first {
|
|
self.first = false;
|
|
} else {
|
|
if d.ch_is(',') {
|
|
d.bump();
|
|
} else if d.eof() {
|
|
return Err(d.error(EOFWhileParsingList));
|
|
} else {
|
|
return Err(d.error(InvalidSyntax(ListCommaOrEnd)));
|
|
}
|
|
}
|
|
|
|
let value = try!(de::Deserialize::deserialize(d));
|
|
Ok(Some(value))
|
|
}
|
|
|
|
fn end(&mut self, d: &mut Parser<Iter>) -> Result<(), Error> {
|
|
if d.ch_is(']') {
|
|
d.bump();
|
|
Ok(())
|
|
} else if d.eof() {
|
|
Err(d.error(EOFWhileParsingList))
|
|
} else {
|
|
Err(d.error(TrailingCharacters))
|
|
}
|
|
}
|
|
}
|
|
|
|
struct MapVisitor {
|
|
first: bool,
|
|
}
|
|
|
|
impl<Iter: Iterator<char>> de::MapVisitor<Parser<Iter>, Error> for MapVisitor {
|
|
fn visit<
|
|
K: de::Deserialize<Parser<Iter>, Error>,
|
|
V: de::Deserialize<Parser<Iter>, Error>,
|
|
>(&mut self, d: &mut Parser<Iter>) -> Result<Option<(K, V)>, Error> {
|
|
d.parse_whitespace();
|
|
|
|
if d.ch_is('}') {
|
|
d.bump();
|
|
return Ok(None);
|
|
}
|
|
|
|
if self.first {
|
|
self.first = false;
|
|
} else {
|
|
if d.ch_is(',') {
|
|
d.bump();
|
|
d.parse_whitespace();
|
|
} else if d.eof() {
|
|
return Err(d.error(EOFWhileParsingObject));
|
|
} else {
|
|
return Err(d.error(InvalidSyntax(ObjectCommaOrEnd)));
|
|
}
|
|
}
|
|
|
|
if d.eof() {
|
|
return Err(d.error(EOFWhileParsingValue));
|
|
}
|
|
|
|
if !d.ch_is('"') {
|
|
return Err(d.error(KeyMustBeAString));
|
|
}
|
|
|
|
let key = try!(de::Deserialize::deserialize(d));
|
|
|
|
d.parse_whitespace();
|
|
|
|
if d.ch_is(':') {
|
|
d.bump();
|
|
} else if d.eof() {
|
|
return Err(d.error(EOFWhileParsingObject));
|
|
} else {
|
|
return Err(d.error(ExpectedColon));
|
|
}
|
|
|
|
d.parse_whitespace();
|
|
|
|
let value = try!(de::Deserialize::deserialize(d));
|
|
|
|
Ok(Some((key, value)))
|
|
}
|
|
|
|
fn end(&mut self, d: &mut Parser<Iter>) -> Result<(), Error> {
|
|
if d.ch_is(']') {
|
|
d.bump();
|
|
Ok(())
|
|
} else if d.eof() {
|
|
Err(d.error(EOFWhileParsingList))
|
|
} else {
|
|
Err(d.error(TrailingCharacters))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Decodes a json value from an `Iterator<Char>`.
|
|
pub fn from_iter<
|
|
Iter: Iterator<char>,
|
|
T: de::Deserialize<Parser<Iter>, Error>
|
|
>(iter: Iter) -> Result<T, Error> {
|
|
let mut parser = Parser::new(iter);
|
|
let value = try!(de::Deserialize::deserialize(&mut parser));
|
|
|
|
// Make sure the whole stream has been consumed.
|
|
try!(parser.end());
|
|
Ok(value)
|
|
}
|
|
|
|
/// Decodes a json value from a string
|
|
pub fn from_str<
|
|
'a,
|
|
T: de::Deserialize<Parser<str::Chars<'a>>, Error>
|
|
>(s: &'a str) -> Result<T, Error> {
|
|
from_iter(s.chars())
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::str;
|
|
use std::fmt::Show;
|
|
use std::collections::TreeMap;
|
|
|
|
use de::Deserialize;
|
|
use super::{Parser, Error, from_str};
|
|
use super::{
|
|
ListCommaOrEnd,
|
|
ObjectCommaOrEnd,
|
|
SomeIdent,
|
|
SomeValue,
|
|
};
|
|
use super::{
|
|
EOFWhileParsingList,
|
|
EOFWhileParsingObject,
|
|
EOFWhileParsingString,
|
|
EOFWhileParsingValue,
|
|
ExpectedColon,
|
|
InvalidNumber,
|
|
InvalidSyntax,
|
|
KeyMustBeAString,
|
|
TrailingCharacters,
|
|
};
|
|
use super::SyntaxError;
|
|
|
|
macro_rules! treemap {
|
|
($($k:expr => $v:expr),*) => ({
|
|
let mut _m = TreeMap::new();
|
|
$(_m.insert($k, $v);)*
|
|
_m
|
|
})
|
|
}
|
|
|
|
fn test_parse_ok<
|
|
'a,
|
|
T: PartialEq + Show + Deserialize<Parser<str::Chars<'a>>, Error>,
|
|
>(errors: Vec<(&'a str, T)>) {
|
|
for (s, value) in errors.into_iter() {
|
|
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: PartialEq + Show + Deserialize<Parser<str::Chars<'a>>, Error>
|
|
>(errors: Vec<(&'a str, Error)>) {
|
|
for (s, err) in errors.into_iter() {
|
|
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", SyntaxError(InvalidSyntax(SomeIdent), 1, 2)),
|
|
("truz", SyntaxError(InvalidSyntax(SomeIdent), 1, 4)),
|
|
("f", SyntaxError(InvalidSyntax(SomeIdent), 1, 2)),
|
|
("faz", SyntaxError(InvalidSyntax(SomeIdent), 1, 3)),
|
|
("truea", SyntaxError(TrailingCharacters, 1, 5)),
|
|
("falsea", SyntaxError(TrailingCharacters, 1, 6)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("true", true),
|
|
("false", false),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_numbers() {
|
|
test_parse_err::<f64>(vec![
|
|
("+", SyntaxError(InvalidSyntax(SomeValue), 1, 1)),
|
|
(".", SyntaxError(InvalidSyntax(SomeValue), 1, 1)),
|
|
("-", SyntaxError(InvalidNumber, 1, 2)),
|
|
("00", SyntaxError(InvalidNumber, 1, 2)),
|
|
("1.", SyntaxError(InvalidNumber, 1, 3)),
|
|
("1e", SyntaxError(InvalidNumber, 1, 3)),
|
|
("1e+", SyntaxError(InvalidNumber, 1, 4)),
|
|
("1a", SyntaxError(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![
|
|
("\"", SyntaxError(EOFWhileParsingString, 1, 2)),
|
|
("\"lol", SyntaxError(EOFWhileParsingString, 1, 5)),
|
|
("\"lol\"a", SyntaxError(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\"", "\u12ab".to_string()),
|
|
("\"\\uAB12\"", "\uAB12".to_string()),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_list() {
|
|
test_parse_err::<Vec<f64>>(vec![
|
|
("[", SyntaxError(EOFWhileParsingValue, 1, 2)),
|
|
("[ ", SyntaxError(EOFWhileParsingValue, 1, 3)),
|
|
("[1", SyntaxError(EOFWhileParsingList, 1, 3)),
|
|
("[1,", SyntaxError(EOFWhileParsingValue, 1, 4)),
|
|
("[1,]", SyntaxError(InvalidSyntax(SomeValue), 1, 4)),
|
|
("[1 2]", SyntaxError(InvalidSyntax(ListCommaOrEnd), 1, 4)),
|
|
("[]a", SyntaxError(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![3i, 1]),
|
|
("[ 3 , 1 ]", vec![3i, 1]),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[[3], [1, 2]]", vec![vec![3i], vec![1, 2]]),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[]", ()),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[1]", (1u,)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[1, 2]", (1u, 2u)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("[1, 2, 3]", (1u, 2u, 3u)),
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_object() {
|
|
test_parse_err::<TreeMap<String, int>>(vec![
|
|
("{", SyntaxError(EOFWhileParsingValue, 1, 2)),
|
|
("{ ", SyntaxError(EOFWhileParsingValue, 1, 3)),
|
|
("{1", SyntaxError(KeyMustBeAString, 1, 2)),
|
|
("{ \"a\"", SyntaxError(EOFWhileParsingObject, 1, 6)),
|
|
("{\"a\"", SyntaxError(EOFWhileParsingObject, 1, 5)),
|
|
("{\"a\" ", SyntaxError(EOFWhileParsingObject, 1, 6)),
|
|
("{\"a\" 1", SyntaxError(ExpectedColon, 1, 6)),
|
|
("{\"a\":", SyntaxError(EOFWhileParsingValue, 1, 6)),
|
|
("{\"a\":1", SyntaxError(EOFWhileParsingObject, 1, 7)),
|
|
("{\"a\":1 1", SyntaxError(InvalidSyntax(ObjectCommaOrEnd), 1, 8)),
|
|
("{\"a\":1,", SyntaxError(EOFWhileParsingValue, 1, 8)),
|
|
("{}a", SyntaxError(TrailingCharacters, 1, 3)),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
("{}", treemap!()),
|
|
("{ }", treemap!()),
|
|
(
|
|
"{\"a\":3}",
|
|
treemap!("a".to_string() => 3i)
|
|
),
|
|
(
|
|
"{ \"a\" : 3 }",
|
|
treemap!("a".to_string() => 3i)
|
|
),
|
|
(
|
|
"{\"a\":3,\"b\":4}",
|
|
treemap!("a".to_string() => 3i, "b".to_string() => 4)
|
|
),
|
|
(
|
|
"{ \"a\" : 3 , \"b\" : 4 }",
|
|
treemap!("a".to_string() => 3i, "b".to_string() => 4),
|
|
),
|
|
]);
|
|
|
|
test_parse_ok(vec![
|
|
(
|
|
"{\"a\": {\"b\": 3, \"c\": 4}}",
|
|
treemap!("a".to_string() => treemap!("b".to_string() => 3i, "c".to_string() => 4i)),
|
|
),
|
|
]);
|
|
}
|
|
}
|