* `Boolean`: equivalent to rust's `bool`
* `Number`: equivalent to rust's `f64`
* `String`: equivalent to rust's `String`
-* `List`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the same
+* `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the same
array
* `Object`: equivalent to rust's `Treemap<String, json::Json>`
* `Null`
F64(f64),
String(string::String),
Boolean(bool),
- List(JsonList),
+ Array(JsonArray),
Object(JsonObject),
Null,
}
-pub type JsonList = Vec<Json>;
+pub type JsonArray = Vec<Json>;
pub type JsonObject = TreeMap<string::String, Json>;
/// The errors that can arise while parsing a JSON stream.
InvalidSyntax,
InvalidNumber,
EOFWhileParsingObject,
- EOFWhileParsingList,
+ EOFWhileParsingArray,
EOFWhileParsingValue,
EOFWhileParsingString,
KeyMustBeAString,
InvalidSyntax => "invalid syntax",
InvalidNumber => "invalid number",
EOFWhileParsingObject => "EOF While parsing object",
- EOFWhileParsingList => "EOF While parsing list",
+ EOFWhileParsingArray => "EOF While parsing array",
EOFWhileParsingValue => "EOF While parsing value",
EOFWhileParsingString => "EOF While parsing string",
KeyMustBeAString => "key must be a string",
F64(v) => v.encode(e),
String(ref v) => v.encode(e),
Boolean(v) => v.encode(e),
- List(ref v) => v.encode(e),
+ Array(ref v) => v.encode(e),
Object(ref v) => v.encode(e),
Null => e.emit_nil(),
}
}
}
- /// Returns true if the Json value is a List. Returns false otherwise.
- pub fn is_list<'a>(&'a self) -> bool {
- self.as_list().is_some()
+ /// Returns true if the Json value is a Array. Returns false otherwise.
+ pub fn is_array<'a>(&'a self) -> bool {
+ self.as_array().is_some()
}
- /// If the Json value is a List, returns the associated vector.
+ /// If the Json value is a Array, returns the associated vector.
/// Returns None otherwise.
- pub fn as_list<'a>(&'a self) -> Option<&'a JsonList> {
+ pub fn as_array<'a>(&'a self) -> Option<&'a JsonArray> {
match self {
- &List(ref list) => Some(&*list),
+ &Array(ref array) => Some(&*array),
_ => None
}
}
impl ops::Index<uint, Json> for Json {
fn index<'a>(&'a self, idx: &uint) -> &'a Json {
match self {
- &List(ref v) => v.index(idx),
- _ => panic!("can only index Json with uint if it is a list")
+ &Array(ref v) => v.index(idx),
+ _ => panic!("can only index Json with uint if it is an array")
}
}
}
pub enum JsonEvent {
ObjectStart,
ObjectEnd,
- ListStart,
- ListEnd,
+ ArrayStart,
+ ArrayEnd,
BooleanValue(bool),
I64Value(i64),
U64Value(u64),
#[deriving(PartialEq, Show)]
enum ParserState {
- // Parse a value in a list, true means first element.
+ // Parse a value in a array, true means first element.
ParseArray(bool),
- // Parse ',' or ']' after an element in a list.
- ParseListComma,
+ // Parse ',' or ']' after an element in a array.
+ ParseArrayComma,
// Parse a key:value in an object, true means first element.
ParseObject(bool),
// Parse ',' or ']' after an element in an object.
fn parse(&mut self) -> JsonEvent {
loop {
// The only paths where the loop can spin a new iteration
- // are in the cases ParseListComma and ParseObjectComma if ','
+ // are in the cases ParseArrayComma and ParseObjectComma if ','
// is parsed. In these cases the state is set to (respectively)
// ParseArray(false) and ParseObject(false), which always return,
// so there is no risk of getting stuck in an infinite loop.
return self.parse_start();
}
ParseArray(first) => {
- return self.parse_list(first);
+ return self.parse_array(first);
}
- ParseListComma => {
- match self.parse_list_comma_or_end() {
+ ParseArrayComma => {
+ match self.parse_array_comma_or_end() {
Some(evt) => { return evt; }
None => {}
}
let val = self.parse_value();
self.state = match val {
Error(_) => { ParseFinished }
- ListStart => { ParseArray(true) }
+ ArrayStart => { ParseArray(true) }
ObjectStart => { ParseObject(true) }
_ => { ParseBeforeFinish }
};
return val;
}
- fn parse_list(&mut self, first: bool) -> JsonEvent {
+ fn parse_array(&mut self, first: bool) -> JsonEvent {
if self.ch_is(']') {
if !first {
return self.error_event(InvalidSyntax);
self.state = ParseBeforeFinish;
} else {
self.state = if self.stack.last_is_index() {
- ParseListComma
+ ParseArrayComma
} else {
ParseObjectComma
}
}
self.bump();
- return ListEnd;
+ return ArrayEnd;
}
if first {
self.stack.push_index(0);
self.state = match val {
Error(_) => { ParseFinished }
- ListStart => { ParseArray(true) }
+ ArrayStart => { ParseArray(true) }
ObjectStart => { ParseObject(true) }
- _ => { ParseListComma }
+ _ => { ParseArrayComma }
};
return val;
}
- fn parse_list_comma_or_end(&mut self) -> Option<JsonEvent> {
+ fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> {
if self.ch_is(',') {
self.stack.bump_index();
self.state = ParseArray(false);
self.state = ParseBeforeFinish;
} else {
self.state = if self.stack.last_is_index() {
- ParseListComma
+ ParseArrayComma
} else {
ParseObjectComma
}
}
self.bump();
- return Some(ListEnd);
+ return Some(ArrayEnd);
} else if self.eof() {
- return Some(self.error_event(EOFWhileParsingList));
+ return Some(self.error_event(EOFWhileParsingArray));
} else {
return Some(self.error_event(InvalidSyntax));
}
self.state = ParseBeforeFinish;
} else {
self.state = if self.stack.last_is_index() {
- ParseListComma
+ ParseArrayComma
} else {
ParseObjectComma
}
self.state = match val {
Error(_) => { ParseFinished }
- ListStart => { ParseArray(true) }
+ ArrayStart => { ParseArray(true) }
ObjectStart => { ParseObject(true) }
_ => { ParseObjectComma }
};
self.state = ParseBeforeFinish;
} else {
self.state = if self.stack.last_is_index() {
- ParseListComma
+ ParseArrayComma
} else {
ParseObjectComma
}
},
'[' => {
self.bump();
- ListStart
+ ArrayStart
}
'{' => {
self.bump();
Ok(String(temp))
}
Some(Error(e)) => { Err(e) }
- Some(ListStart) => { self.build_list() }
+ Some(ArrayStart) => { self.build_array() }
Some(ObjectStart) => { self.build_object() }
Some(ObjectEnd) => { self.parser.error(InvalidSyntax) }
- Some(ListEnd) => { self.parser.error(InvalidSyntax) }
+ Some(ArrayEnd) => { self.parser.error(InvalidSyntax) }
None => { self.parser.error(EOFWhileParsingValue) }
}
}
- fn build_list(&mut self) -> Result<Json, BuilderError> {
+ fn build_array(&mut self) -> Result<Json, BuilderError> {
self.bump();
let mut values = Vec::new();
loop {
- if self.token == Some(ListEnd) {
- return Ok(List(values.into_iter().collect()));
+ if self.token == Some(ArrayEnd) {
+ return Ok(Array(values.into_iter().collect()));
}
match self.build_value() {
Ok(v) => values.push(v),
}
};
match o.remove(&"fields".to_string()) {
- Some(List(l)) => {
+ Some(Array(l)) => {
for field in l.into_iter().rev() {
self.stack.push(field);
}
},
Some(val) => {
- return Err(ExpectedError("List".to_string(), format!("{}", val)))
+ return Err(ExpectedError("Array".to_string(), format!("{}", val)))
}
None => {
return Err(MissingFieldError("fields".to_string()))
fn read_seq<T>(&mut self, f: |&mut Decoder, uint| -> DecodeResult<T>) -> DecodeResult<T> {
debug!("read_seq()");
- let list = try!(expect!(self.pop(), List));
- let len = list.len();
- for v in list.into_iter().rev() {
+ let array = try!(expect!(self.pop(), Array));
+ let len = array.len();
+ for v in array.into_iter().rev() {
self.stack.push(v);
}
f(self, len)
#[allow(non_snake_case)]
fn to_json(&self) -> Json {
match *self {
- ($(ref $tyvar),*,) => List(vec![$($tyvar.to_json()),*])
+ ($(ref $tyvar),*,) => Array(vec![$($tyvar.to_json()),*])
}
}
}
tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
impl<A: ToJson> ToJson for [A] {
- fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
+ fn to_json(&self) -> Json { Array(self.iter().map(|elt| elt.to_json()).collect()) }
}
impl<A: ToJson> ToJson for Vec<A> {
- fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
+ fn to_json(&self) -> Json { Array(self.iter().map(|elt| elt.to_json()).collect()) }
}
impl<A: ToJson> ToJson for TreeMap<string::String, A> {
use self::DecodeEnum::*;
use self::test::Bencher;
use {Encodable, Decodable};
- use super::{List, Encoder, Decoder, Error, Boolean, I64, U64, F64, String, Null,
+ use super::{Array, Encoder, Decoder, Error, Boolean, I64, U64, F64, String, Null,
PrettyEncoder, Object, Json, from_str, ParseError, ExpectedError,
MissingFieldError, UnknownVariantError, DecodeResult, DecoderError,
JsonEvent, Parser, StackElement,
- ObjectStart, ObjectEnd, ListStart, ListEnd, BooleanValue, U64Value,
+ ObjectStart, ObjectEnd, ArrayStart, ArrayEnd, BooleanValue, U64Value,
F64Value, StringValue, NullValue, SyntaxError, Key, Index, Stack,
- InvalidSyntax, InvalidNumber, EOFWhileParsingObject, EOFWhileParsingList,
+ InvalidSyntax, InvalidNumber, EOFWhileParsingObject, EOFWhileParsingArray,
EOFWhileParsingValue, EOFWhileParsingString, KeyMustBeAString, ExpectedColon,
TrailingCharacters, TrailingComma};
use std::{i64, u64, f32, f64, io};
}
#[test]
- fn test_write_list() {
- assert_eq!(List(vec![]).to_string().into_string(), "[]".to_string());
- assert_eq!(List(vec![]).to_pretty_str().into_string(), "[]".to_string());
+ fn test_write_array() {
+ assert_eq!(Array(vec![]).to_string().into_string(), "[]".to_string());
+ assert_eq!(Array(vec![]).to_pretty_str().into_string(), "[]".to_string());
- assert_eq!(List(vec![Boolean(true)]).to_string().into_string(), "[true]".to_string());
+ assert_eq!(Array(vec![Boolean(true)]).to_string().into_string(), "[true]".to_string());
assert_eq!(
- List(vec![Boolean(true)]).to_pretty_str().into_string(),
+ Array(vec![Boolean(true)]).to_pretty_str().into_string(),
"\
[\n \
true\n\
]".to_string()
);
- let long_test_list = List(vec![
+ let long_test_array = Array(vec![
Boolean(false),
Null,
- List(vec![String("foo\nbar".to_string()), F64(3.5)])]);
+ Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
- assert_eq!(long_test_list.to_string().into_string(),
+ assert_eq!(long_test_array.to_string().into_string(),
"[false,null,[\"foo\\nbar\",3.5]]".to_string());
assert_eq!(
- long_test_list.to_pretty_str().into_string(),
+ long_test_array.to_pretty_str().into_string(),
"\
[\n \
false,\n \
);
let complex_obj = mk_object(&[
- ("b".to_string(), List(vec![
+ ("b".to_string(), Array(vec![
mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
mk_object(&[("d".to_string(), String("".to_string()))])
]))
let a = mk_object(&[
("a".to_string(), Boolean(true)),
- ("b".to_string(), List(vec![
+ ("b".to_string(), Array(vec![
mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
mk_object(&[("d".to_string(), String("".to_string()))])
]))
}
#[test]
- fn test_read_list() {
+ fn test_read_array() {
assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
- assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingList, 1, 3)));
+ assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(from_str("[]"), Ok(List(vec![])));
- assert_eq!(from_str("[ ]"), Ok(List(vec![])));
- assert_eq!(from_str("[true]"), Ok(List(vec![Boolean(true)])));
- assert_eq!(from_str("[ false ]"), Ok(List(vec![Boolean(false)])));
- assert_eq!(from_str("[null]"), Ok(List(vec![Null])));
+ assert_eq!(from_str("[]"), Ok(Array(vec![])));
+ assert_eq!(from_str("[ ]"), Ok(Array(vec![])));
+ assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)])));
+ assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
+ assert_eq!(from_str("[null]"), Ok(Array(vec![Null])));
assert_eq!(from_str("[3, 1]"),
- Ok(List(vec![U64(3), U64(1)])));
+ Ok(Array(vec![U64(3), U64(1)])));
assert_eq!(from_str("\n[3, 2]\n"),
- Ok(List(vec![U64(3), U64(2)])));
+ Ok(Array(vec![U64(3), U64(2)])));
assert_eq!(from_str("[2, [4, 1]]"),
- Ok(List(vec![U64(2), List(vec![U64(4), U64(1)])])));
+ Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
}
#[test]
- fn test_decode_list() {
+ fn test_decode_array() {
let v: Vec<()> = super::decode("[]").unwrap();
assert_eq!(v, vec![]);
"{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
mk_object(&[
("a".to_string(), F64(1.0)),
- ("b".to_string(), List(vec![Boolean(true)]))
+ ("b".to_string(), Array(vec![Boolean(true)]))
]));
assert_eq!(from_str(
"{\
}").unwrap(),
mk_object(&[
("a".to_string(), F64(1.0)),
- ("b".to_string(), List(vec![
+ ("b".to_string(), Array(vec![
Boolean(true),
String("foo\nbar".to_string()),
mk_object(&[
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
ExpectedError("String".to_string(), "{}".to_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
- ExpectedError("List".to_string(), "null".to_string()));
+ ExpectedError("Array".to_string(), "null".to_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
MissingFieldError("w".to_string()));
}
check_err::<DecodeEnum>("{\"variant\": \"A\"}",
MissingFieldError("fields".to_string()));
check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
- ExpectedError("List".to_string(), "null".to_string()));
+ ExpectedError("Array".to_string(), "null".to_string()));
check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
UnknownVariantError("C".to_string()));
}
#[test]
fn test_index(){
let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
- let ref list = json_value["animals"];
- assert_eq!(list[0].as_string().unwrap(), "dog");
- assert_eq!(list[1].as_string().unwrap(), "cat");
- assert_eq!(list[2].as_string().unwrap(), "mouse");
+ let ref array = json_value["animals"];
+ assert_eq!(array[0].as_string().unwrap(), "dog");
+ assert_eq!(array[1].as_string().unwrap(), "cat");
+ assert_eq!(array[2].as_string().unwrap(), "mouse");
}
#[test]
}
#[test]
- fn test_is_list(){
+ fn test_is_array(){
let json_value = from_str("[1, 2, 3]").unwrap();
- assert!(json_value.is_list());
+ assert!(json_value.is_array());
}
#[test]
- fn test_as_list(){
+ fn test_as_array(){
let json_value = from_str("[1, 2, 3]").unwrap();
- let json_list = json_value.as_list();
+ let json_array = json_value.as_array();
let expected_length = 3;
- assert!(json_list.is_some() && json_list.unwrap().len() == expected_length);
+ assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
}
#[test]
tree.insert("hello".into_string(), String("guten tag".into_string()));
tree.insert("goodbye".into_string(), String("sayonara".into_string()));
- let json = List(
+ let json = Array(
// The following layout below should look a lot like
// the pretty-printed JSON (indent * x)
vec!
String("greetings".into_string()), // 1x
Object(tree), // 1x + 2x + 2x + 1x
) // 0x
- // End JSON list (7 lines)
+ // End JSON array (7 lines)
);
// Helper function for counting indents
vec![
(ObjectStart, vec![]),
(StringValue("bar".to_string()), vec![Key("foo")]),
- (ListStart, vec![Key("array")]),
+ (ArrayStart, vec![Key("array")]),
(U64Value(0), vec![Key("array"), Index(0)]),
(U64Value(1), vec![Key("array"), Index(1)]),
(U64Value(2), vec![Key("array"), Index(2)]),
(U64Value(3), vec![Key("array"), Index(3)]),
(U64Value(4), vec![Key("array"), Index(4)]),
(U64Value(5), vec![Key("array"), Index(5)]),
- (ListEnd, vec![Key("array")]),
- (ListStart, vec![Key("idents")]),
+ (ArrayEnd, vec![Key("array")]),
+ (ArrayStart, vec![Key("idents")]),
(NullValue, vec![Key("idents"), Index(0)]),
(BooleanValue(true), vec![Key("idents"), Index(1)]),
(BooleanValue(false), vec![Key("idents"), Index(2)]),
- (ListEnd, vec![Key("idents")]),
+ (ArrayEnd, vec![Key("idents")]),
(ObjectEnd, vec![]),
]
);
vec![
(ObjectStart, vec![]),
(F64Value(1.0), vec![Key("a")]),
- (ListStart, vec![Key("b")]),
+ (ArrayStart, vec![Key("b")]),
(BooleanValue(true),vec![Key("b"), Index(0)]),
- (ListEnd, vec![Key("b")]),
+ (ArrayEnd, vec![Key("b")]),
(ObjectEnd, vec![]),
]
);
vec![
(ObjectStart, vec![]),
(F64Value(1.0), vec![Key("a")]),
- (ListStart, vec![Key("b")]),
+ (ArrayStart, vec![Key("b")]),
(BooleanValue(true), vec![Key("b"), Index(0)]),
(StringValue("foo\nbar".to_string()), vec![Key("b"), Index(1)]),
(ObjectStart, vec![Key("b"), Index(2)]),
(NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]),
(ObjectEnd, vec![Key("b"), Index(2), Key("c")]),
(ObjectEnd, vec![Key("b"), Index(2)]),
- (ListEnd, vec![Key("b")]),
+ (ArrayEnd, vec![Key("b")]),
(ObjectEnd, vec![]),
]
);
}
#[test]
#[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
- fn test_read_list_streaming() {
+ fn test_read_array_streaming() {
assert_stream_equal(
"[]",
vec![
- (ListStart, vec![]),
- (ListEnd, vec![]),
+ (ArrayStart, vec![]),
+ (ArrayEnd, vec![]),
]
);
assert_stream_equal(
"[ ]",
vec![
- (ListStart, vec![]),
- (ListEnd, vec![]),
+ (ArrayStart, vec![]),
+ (ArrayEnd, vec![]),
]
);
assert_stream_equal(
"[true]",
vec![
- (ListStart, vec![]),
+ (ArrayStart, vec![]),
(BooleanValue(true), vec![Index(0)]),
- (ListEnd, vec![]),
+ (ArrayEnd, vec![]),
]
);
assert_stream_equal(
"[ false ]",
vec![
- (ListStart, vec![]),
+ (ArrayStart, vec![]),
(BooleanValue(false), vec![Index(0)]),
- (ListEnd, vec![]),
+ (ArrayEnd, vec![]),
]
);
assert_stream_equal(
"[null]",
vec![
- (ListStart, vec![]),
+ (ArrayStart, vec![]),
(NullValue, vec![Index(0)]),
- (ListEnd, vec![]),
+ (ArrayEnd, vec![]),
]
);
assert_stream_equal(
"[3, 1]",
vec![
- (ListStart, vec![]),
+ (ArrayStart, vec![]),
(U64Value(3), vec![Index(0)]),
(U64Value(1), vec![Index(1)]),
- (ListEnd, vec![]),
+ (ArrayEnd, vec![]),
]
);
assert_stream_equal(
"\n[3, 2]\n",
vec![
- (ListStart, vec![]),
+ (ArrayStart, vec![]),
(U64Value(3), vec![Index(0)]),
(U64Value(2), vec![Index(1)]),
- (ListEnd, vec![]),
+ (ArrayEnd, vec![]),
]
);
assert_stream_equal(
"[2, [4, 1]]",
vec![
- (ListStart, vec![]),
+ (ArrayStart, vec![]),
(U64Value(2), vec![Index(0)]),
- (ListStart, vec![Index(1)]),
+ (ArrayStart, vec![Index(1)]),
(U64Value(4), vec![Index(1), Index(0)]),
(U64Value(1), vec![Index(1), Index(1)]),
- (ListEnd, vec![Index(1)]),
- (ListEnd, vec![]),
+ (ArrayEnd, vec![Index(1)]),
+ (ArrayEnd, vec![]),
]
);
assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2)));
assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
- assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingList, 1, 3)));
+ assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
use std::collections::{HashMap,TreeMap};
use super::ToJson;
- let list2 = List(vec!(U64(1), U64(2)));
- let list3 = List(vec!(U64(1), U64(2), U64(3)));
+ let array2 = Array(vec!(U64(1), U64(2)));
+ let array3 = Array(vec!(U64(1), U64(2), U64(3)));
let object = {
let mut tree_map = TreeMap::new();
tree_map.insert("a".to_string(), U64(1));
Object(tree_map)
};
- assert_eq!(list2.to_json(), list2);
+ assert_eq!(array2.to_json(), array2);
assert_eq!(object.to_json(), object);
assert_eq!(3_i.to_json(), I64(3));
assert_eq!(4_i8.to_json(), I64(4));
assert_eq!(false.to_json(), Boolean(false));
assert_eq!("abc".to_json(), String("abc".into_string()));
assert_eq!("abc".into_string().to_json(), String("abc".into_string()));
- assert_eq!((1u, 2u).to_json(), list2);
- assert_eq!((1u, 2u, 3u).to_json(), list3);
- assert_eq!([1u, 2].to_json(), list2);
- assert_eq!((&[1u, 2, 3]).to_json(), list3);
- assert_eq!((vec![1u, 2]).to_json(), list2);
- assert_eq!(vec!(1u, 2, 3).to_json(), list3);
+ assert_eq!((1u, 2u).to_json(), array2);
+ assert_eq!((1u, 2u, 3u).to_json(), array3);
+ assert_eq!([1u, 2].to_json(), array2);
+ assert_eq!((&[1u, 2, 3]).to_json(), array3);
+ assert_eq!((vec![1u, 2]).to_json(), array2);
+ assert_eq!(vec!(1u, 2, 3).to_json(), array3);
let mut tree_map = TreeMap::new();
tree_map.insert("a".to_string(), 1u);
tree_map.insert("b".to_string(), 2);
projects / rust.git / commitdiff