bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

libserialize: Prefer into_string() to to_string() wherever possible

Browse source 
Except for the example code!
This commit is contained in:
Barosl Lee 2014-12-08 18:16:09 +09:00
parent c32286d1b1
commit 7176dd1c90
1 changed files with 85 additions and 85 deletions
Download patch file Download diff file Expand all files Collapse all files

170
src/libserialize/json.rs
View file

@ -1947,7 +1947,7 @@ macro_rules! expect(
($e:expr, Null) => ({ ($e:expr, Null) => ({
match $e { match $e {
Json::Null => Ok(()), Json::Null => Ok(()),
other => Err(ExpectedError("Null".to_string(), other => Err(ExpectedError("Null".into_string(),
format!("{}", other))) format!("{}", other)))
} }
}); });
@ -1968,20 +1968,20 @@ macro_rules! read_primitive {
match self.pop() { match self.pop() {
Json::I64(f) => match num::cast(f) { Json::I64(f) => match num::cast(f) {
Some(f) => Ok(f), Some(f) => Ok(f),
None => Err(ExpectedError("Number".to_string(), format!("{}", f))), None => Err(ExpectedError("Number".into_string(), format!("{}", f))),
}, },
Json::U64(f) => match num::cast(f) { Json::U64(f) => match num::cast(f) {
Some(f) => Ok(f), Some(f) => Ok(f),
None => Err(ExpectedError("Number".to_string(), format!("{}", f))), None => Err(ExpectedError("Number".into_string(), format!("{}", f))),
}, },
Json::F64(f) => Err(ExpectedError("Integer".to_string(), format!("{}", f))), Json::F64(f) => Err(ExpectedError("Integer".into_string(), format!("{}", f))),
// re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc) // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
// is going to have a string here, as per JSON spec. // is going to have a string here, as per JSON spec.
Json::String(s) => match std::str::from_str(s.as_slice()) { Json::String(s) => match std::str::from_str(s.as_slice()) {
Some(f) => Ok(f), Some(f) => Ok(f),
None => Err(ExpectedError("Number".to_string(), s)), None => Err(ExpectedError("Number".into_string(), s)),
}, },
value => Err(ExpectedError("Number".to_string(), format!("{}", value))), value => Err(ExpectedError("Number".into_string(), format!("{}", value))),
} }
} }
} }
@ -2017,11 +2017,11 @@ impl ::Decoder<DecoderError> for Decoder {
// is going to have a string here, as per JSON spec. // is going to have a string here, as per JSON spec.
match std::str::from_str(s.as_slice()) { match std::str::from_str(s.as_slice()) {
Some(f) => Ok(f), Some(f) => Ok(f),
None => Err(ExpectedError("Number".to_string(), s)), None => Err(ExpectedError("Number".into_string(), s)),
} }
}, },
Json::Null => Ok(f64::NAN), Json::Null => Ok(f64::NAN),
value => Err(ExpectedError("Number".to_string(), format!("{}", value))) value => Err(ExpectedError("Number".into_string(), format!("{}", value)))
} }
} }
@ -2040,7 +2040,7 @@ impl ::Decoder<DecoderError> for Decoder {
_ => () _ => ()
} }
} }
Err(ExpectedError("single character string".to_string(), format!("{}", s))) Err(ExpectedError("single character string".into_string(), format!("{}", s)))
} }
fn read_str(&mut self) -> DecodeResult<string::String> { fn read_str(&mut self) -> DecodeResult<string::String> {
@ -2063,32 +2063,32 @@ impl ::Decoder<DecoderError> for Decoder {
let name = match self.pop() { let name = match self.pop() {
Json::String(s) => s, Json::String(s) => s,
Json::Object(mut o) => { Json::Object(mut o) => {
let n = match o.remove(&"variant".to_string()) { let n = match o.remove(&"variant".into_string()) {
Some(Json::String(s)) => s, Some(Json::String(s)) => s,
Some(val) => { Some(val) => {
return Err(ExpectedError("String".to_string(), format!("{}", val))) return Err(ExpectedError("String".into_string(), format!("{}", val)))
} }
None => { None => {
return Err(MissingFieldError("variant".to_string())) return Err(MissingFieldError("variant".into_string()))
} }
}; };
match o.remove(&"fields".to_string()) { match o.remove(&"fields".into_string()) {
Some(Json::Array(l)) => { Some(Json::Array(l)) => {
for field in l.into_iter().rev() { for field in l.into_iter().rev() {
self.stack.push(field); self.stack.push(field);
} }
}, },
Some(val) => { Some(val) => {
return Err(ExpectedError("Array".to_string(), format!("{}", val))) return Err(ExpectedError("Array".into_string(), format!("{}", val)))
} }
None => { None => {
return Err(MissingFieldError("fields".to_string())) return Err(MissingFieldError("fields".into_string()))
} }
} }
n n
} }
json => { json => {
return Err(ExpectedError("String or Object".to_string(), format!("{}", json))) return Err(ExpectedError("String or Object".into_string(), format!("{}", json)))
} }
}; };
let idx = match names.iter() let idx = match names.iter()
@ -2437,9 +2437,9 @@ mod tests {
#[test] #[test]
fn test_decode_option_malformed() { fn test_decode_option_malformed() {
check_err::<OptionData>("{ \"opt\": [] }", check_err::<OptionData>("{ \"opt\": [] }",
ExpectedError("Number".to_string(), "[]".to_string())); ExpectedError("Number".into_string(), "[]".into_string()));
check_err::<OptionData>("{ \"opt\": false }", check_err::<OptionData>("{ \"opt\": false }",
ExpectedError("Number".to_string(), "false".to_string())); ExpectedError("Number".into_string(), "false".into_string()));
} }
#[deriving(PartialEq, Encodable, Decodable, Show)] #[deriving(PartialEq, Encodable, Decodable, Show)]
@ -2525,11 +2525,11 @@ mod tests {
#[test] #[test]
fn test_write_str() { fn test_write_str() {
assert_eq!(String("".to_string()).to_string(), "\"\""); assert_eq!(String("".into_string()).to_string(), "\"\"");
assert_eq!(String("".to_string()).to_pretty_str(), "\"\""); assert_eq!(String("".into_string()).to_pretty_str(), "\"\"");
assert_eq!(String("homura".to_string()).to_string(), "\"homura\""); assert_eq!(String("homura".into_string()).to_string(), "\"homura\"");
assert_eq!(String("madoka".to_string()).to_pretty_str(), "\"madoka\""); assert_eq!(String("madoka".into_string()).to_pretty_str(), "\"madoka\"");
} }
#[test] #[test]
@ -2558,7 +2558,7 @@ mod tests {
let long_test_array = Array(vec![ let long_test_array = Array(vec![
Boolean(false), Boolean(false),
Null, Null,
Array(vec![String("foo\nbar".to_string()), F64(3.5)])]); Array(vec![String("foo\nbar".into_string()), F64(3.5)])]);
assert_eq!(long_test_array.to_string(), assert_eq!(long_test_array.to_string(),
"[false,null,[\"foo\\nbar\",3.5]]"); "[false,null,[\"foo\\nbar\",3.5]]");
@ -2583,12 +2583,12 @@ mod tests {
assert_eq!( assert_eq!(
mk_object(&[ mk_object(&[
("a".to_string(), Boolean(true)) ("a".into_string(), Boolean(true))
]).to_string(), ]).to_string(),
"{\"a\":true}" "{\"a\":true}"
); );
assert_eq!( assert_eq!(
mk_object(&[("a".to_string(), Boolean(true))]).to_pretty_str(), mk_object(&[("a".into_string(), Boolean(true))]).to_pretty_str(),
"\ "\
{\n \ {\n \
\"a\": true\n\ \"a\": true\n\
@ -2596,9 +2596,9 @@ mod tests {
); );
let complex_obj = mk_object(&[ let complex_obj = mk_object(&[
("b".to_string(), Array(vec![ ("b".into_string(), Array(vec![
mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]), mk_object(&[("c".into_string(), String("\x0c\r".into_string()))]),
mk_object(&[("d".to_string(), String("".to_string()))]) mk_object(&[("d".into_string(), String("".into_string()))])
])) ]))
]); ]);
@ -2627,10 +2627,10 @@ mod tests {
); );
let a = mk_object(&[ let a = mk_object(&[
("a".to_string(), Boolean(true)), ("a".into_string(), Boolean(true)),
("b".to_string(), Array(vec![ ("b".into_string(), Array(vec![
mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]), mk_object(&[("c".into_string(), String("\x0c\r".into_string()))]),
mk_object(&[("d".to_string(), String("".to_string()))]) mk_object(&[("d".into_string(), String("".into_string()))])
])) ]))
]); ]);
@ -2667,7 +2667,7 @@ mod tests {
"\"Dog\"" "\"Dog\""
); );
let animal = Frog("Henry".to_string(), 349); let animal = Frog("Henry".into_string(), 349);
assert_eq!( assert_eq!(
with_str_writer(|writer| { with_str_writer(|writer| {
let mut encoder = Encoder::new(writer); let mut encoder = Encoder::new(writer);
@ -2692,14 +2692,14 @@ mod tests {
#[test] #[test]
fn test_write_some() { fn test_write_some() {
let value = Some("jodhpurs".to_string()); let value = Some("jodhpurs".into_string());
let s = with_str_writer(|writer| { let s = with_str_writer(|writer| {
let mut encoder = Encoder::new(writer); let mut encoder = Encoder::new(writer);
value.encode(&mut encoder).unwrap(); value.encode(&mut encoder).unwrap();
}); });
assert_eq!(s, "\"jodhpurs\""); assert_eq!(s, "\"jodhpurs\"");
let value = Some("jodhpurs".to_string()); let value = Some("jodhpurs".into_string());
let s = with_str_writer(|writer| { let s = with_str_writer(|writer| {
let mut encoder = PrettyEncoder::new(writer); let mut encoder = PrettyEncoder::new(writer);
value.encode(&mut encoder).unwrap(); value.encode(&mut encoder).unwrap();
@ -2834,16 +2834,16 @@ mod tests {
assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2))); assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2)));
assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5))); assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
assert_eq!(from_str("\"\""), Ok(String("".to_string()))); assert_eq!(from_str("\"\""), Ok(String("".into_string())));
assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string()))); assert_eq!(from_str("\"foo\""), Ok(String("foo".into_string())));
assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string()))); assert_eq!(from_str("\"\\\"\""), Ok(String("\"".into_string())));
assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string()))); assert_eq!(from_str("\"\\b\""), Ok(String("\x08".into_string())));
assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string()))); assert_eq!(from_str("\"\\n\""), Ok(String("\n".into_string())));
assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string()))); assert_eq!(from_str("\"\\r\""), Ok(String("\r".into_string())));
assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string()))); assert_eq!(from_str("\"\\t\""), Ok(String("\t".into_string())));
assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string()))); assert_eq!(from_str(" \"foo\" "), Ok(String("foo".into_string())));
assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u12ab".to_string()))); assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u12ab".into_string())));
assert_eq!(from_str("\"\\uAB12\""), Ok(String("\uAB12".to_string()))); assert_eq!(from_str("\"\\uAB12\""), Ok(String("\uAB12".into_string())));
} }
#[test] #[test]
@ -2909,7 +2909,7 @@ mod tests {
assert_eq!(t, (1u, 2, 3)) assert_eq!(t, (1u, 2, 3))
let t: (uint, string::String) = super::decode("[1, \"two\"]").unwrap(); let t: (uint, string::String) = super::decode("[1, \"two\"]").unwrap();
assert_eq!(t, (1u, "two".to_string())); assert_eq!(t, (1u, "two".into_string()));
} }
#[test] #[test]
@ -2939,22 +2939,22 @@ mod tests {
assert_eq!(from_str("{}").unwrap(), mk_object(&[])); assert_eq!(from_str("{}").unwrap(), mk_object(&[]));
assert_eq!(from_str("{\"a\": 3}").unwrap(), assert_eq!(from_str("{\"a\": 3}").unwrap(),
mk_object(&[("a".to_string(), U64(3))])); mk_object(&[("a".into_string(), U64(3))]));
assert_eq!(from_str( assert_eq!(from_str(
"{ \"a\": null, \"b\" : true }").unwrap(), "{ \"a\": null, \"b\" : true }").unwrap(),
mk_object(&[ mk_object(&[
("a".to_string(), Null), ("a".into_string(), Null),
("b".to_string(), Boolean(true))])); ("b".into_string(), Boolean(true))]));
assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(), assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
mk_object(&[ mk_object(&[
("a".to_string(), Null), ("a".into_string(), Null),
("b".to_string(), Boolean(true))])); ("b".into_string(), Boolean(true))]));
assert_eq!(from_str( assert_eq!(from_str(
"{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(), "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
mk_object(&[ mk_object(&[
("a".to_string(), F64(1.0)), ("a".into_string(), F64(1.0)),
("b".to_string(), Array(vec![Boolean(true)])) ("b".into_string(), Array(vec![Boolean(true)]))
])); ]));
assert_eq!(from_str( assert_eq!(from_str(
"{\ "{\
@ -2966,12 +2966,12 @@ mod tests {
]\ ]\
}").unwrap(), }").unwrap(),
mk_object(&[ mk_object(&[
("a".to_string(), F64(1.0)), ("a".into_string(), F64(1.0)),
("b".to_string(), Array(vec![ ("b".into_string(), Array(vec![
Boolean(true), Boolean(true),
String("foo\nbar".to_string()), String("foo\nbar".into_string()),
mk_object(&[ mk_object(&[
("c".to_string(), mk_object(&[("d".to_string(), Null)])) ("c".into_string(), mk_object(&[("d".into_string(), Null)]))
]) ])
])) ]))
])); ]));
@ -2990,7 +2990,7 @@ mod tests {
v, v,
Outer { Outer {
inner: vec![ inner: vec![
Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] } Inner { a: (), b: 2, c: vec!["abc".into_string(), "xyz".into_string()] }
] ]
} }
); );
@ -3016,7 +3016,7 @@ mod tests {
assert_eq!(value, None); assert_eq!(value, None);
let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap(); let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
assert_eq!(value, Some("jodhpurs".to_string())); assert_eq!(value, Some("jodhpurs".into_string()));
} }
#[test] #[test]
@ -3026,7 +3026,7 @@ mod tests {
let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"; let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
let value: Animal = super::decode(s).unwrap(); let value: Animal = super::decode(s).unwrap();
assert_eq!(value, Frog("Henry".to_string(), 349)); assert_eq!(value, Frog("Henry".into_string(), 349));
} }
#[test] #[test]
@ -3035,8 +3035,8 @@ mod tests {
\"fields\":[\"Henry\", 349]}}"; \"fields\":[\"Henry\", 349]}}";
let mut map: TreeMap<string::String, Animal> = super::decode(s).unwrap(); let mut map: TreeMap<string::String, Animal> = super::decode(s).unwrap();
assert_eq!(map.remove(&"a".to_string()), Some(Dog)); assert_eq!(map.remove(&"a".into_string()), Some(Dog));
assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349))); assert_eq!(map.remove(&"b".into_string()), Some(Frog("Henry".into_string(), 349)));
} }
#[test] #[test]
@ -3076,30 +3076,30 @@ mod tests {
} }
#[test] #[test]
fn test_decode_errors_struct() { fn test_decode_errors_struct() {
check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string())); check_err::<DecodeStruct>("[]", ExpectedError("Object".into_string(), "[]".into_string()));
check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}", check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
ExpectedError("Number".to_string(), "true".to_string())); ExpectedError("Number".into_string(), "true".into_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}", check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
ExpectedError("Boolean".to_string(), "[]".to_string())); ExpectedError("Boolean".into_string(), "[]".into_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}", check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
ExpectedError("String".to_string(), "{}".to_string())); ExpectedError("String".into_string(), "{}".into_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}", check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
ExpectedError("Array".to_string(), "null".to_string())); ExpectedError("Array".into_string(), "null".into_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}", check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
MissingFieldError("w".to_string())); MissingFieldError("w".into_string()));
} }
#[test] #[test]
fn test_decode_errors_enum() { fn test_decode_errors_enum() {
check_err::<DecodeEnum>("{}", check_err::<DecodeEnum>("{}",
MissingFieldError("variant".to_string())); MissingFieldError("variant".into_string()));
check_err::<DecodeEnum>("{\"variant\": 1}", check_err::<DecodeEnum>("{\"variant\": 1}",
ExpectedError("String".to_string(), "1".to_string())); ExpectedError("String".into_string(), "1".into_string()));
check_err::<DecodeEnum>("{\"variant\": \"A\"}", check_err::<DecodeEnum>("{\"variant\": \"A\"}",
MissingFieldError("fields".to_string())); MissingFieldError("fields".into_string()));
check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}", check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
ExpectedError("Array".to_string(), "null".to_string())); ExpectedError("Array".into_string(), "null".into_string()));
check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}", check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
UnknownVariantError("C".to_string())); UnknownVariantError("C".into_string()));
} }
#[test] #[test]
@ -3384,7 +3384,7 @@ mod tests {
}; };
let mut decoder = Decoder::new(json_obj); let mut decoder = Decoder::new(json_obj);
let result: Result<HashMap<uint, bool>, DecoderError> = Decodable::decode(&mut decoder); let result: Result<HashMap<uint, bool>, DecoderError> = Decodable::decode(&mut decoder);
assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string()))); assert_eq!(result, Err(ExpectedError("Number".into_string(), "a".into_string())));
} }
fn assert_stream_equal(src: &str, fn assert_stream_equal(src: &str,
@ -3411,7 +3411,7 @@ mod tests {
r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#, r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
vec![ vec![
(ObjectStart, vec![]), (ObjectStart, vec![]),
(StringValue("bar".to_string()), vec![Key("foo")]), (StringValue("bar".into_string()), vec![Key("foo")]),
(ArrayStart, vec![Key("array")]), (ArrayStart, vec![Key("array")]),
(U64Value(0), vec![Key("array"), Index(0)]), (U64Value(0), vec![Key("array"), Index(0)]),
(U64Value(1), vec![Key("array"), Index(1)]), (U64Value(1), vec![Key("array"), Index(1)]),
@ -3502,7 +3502,7 @@ mod tests {
(F64Value(1.0), vec![Key("a")]), (F64Value(1.0), vec![Key("a")]),
(ArrayStart, vec![Key("b")]), (ArrayStart, vec![Key("b")]),
(BooleanValue(true), vec![Key("b"), Index(0)]), (BooleanValue(true), vec![Key("b"), Index(0)]),
(StringValue("foo\nbar".to_string()), vec![Key("b"), Index(1)]), (StringValue("foo\nbar".into_string()), vec![Key("b"), Index(1)]),
(ObjectStart, vec![Key("b"), Index(2)]), (ObjectStart, vec![Key("b"), Index(2)]),
(ObjectStart, vec![Key("b"), Index(2), Key("c")]), (ObjectStart, vec![Key("b"), Index(2), Key("c")]),
(NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]), (NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]),
@ -3635,7 +3635,7 @@ mod tests {
assert!(stack.last_is_index()); assert!(stack.last_is_index());
assert!(stack.get(0) == Index(1)); assert!(stack.get(0) == Index(1));
stack.push_key("foo".to_string()); stack.push_key("foo".into_string());
assert!(stack.len() == 2); assert!(stack.len() == 2);
assert!(stack.is_equal_to(&[Index(1), Key("foo")])); assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
@ -3647,7 +3647,7 @@ mod tests {
assert!(stack.get(0) == Index(1)); assert!(stack.get(0) == Index(1));
assert!(stack.get(1) == Key("foo")); assert!(stack.get(1) == Key("foo"));
stack.push_key("bar".to_string()); stack.push_key("bar".into_string());
assert!(stack.len() == 3); assert!(stack.len() == 3);
assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")])); assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")]));
@ -3684,8 +3684,8 @@ mod tests {
let array3 = Array(vec!(U64(1), U64(2), U64(3))); let array3 = Array(vec!(U64(1), U64(2), U64(3)));
let object = { let object = {
let mut tree_map = TreeMap::new(); let mut tree_map = TreeMap::new();
tree_map.insert("a".to_string(), U64(1)); tree_map.insert("a".into_string(), U64(1));
tree_map.insert("b".to_string(), U64(2)); tree_map.insert("b".into_string(), U64(2));
Object(tree_map) Object(tree_map)
}; };
@ -3717,12 +3717,12 @@ mod tests {
assert_eq!((vec![1u, 2]).to_json(), array2); assert_eq!((vec![1u, 2]).to_json(), array2);
assert_eq!(vec!(1u, 2, 3).to_json(), array3); assert_eq!(vec!(1u, 2, 3).to_json(), array3);
let mut tree_map = TreeMap::new(); let mut tree_map = TreeMap::new();
tree_map.insert("a".to_string(), 1u); tree_map.insert("a".into_string(), 1u);
tree_map.insert("b".to_string(), 2); tree_map.insert("b".into_string(), 2);
assert_eq!(tree_map.to_json(), object); assert_eq!(tree_map.to_json(), object);
let mut hash_map = HashMap::new(); let mut hash_map = HashMap::new();
hash_map.insert("a".to_string(), 1u); hash_map.insert("a".into_string(), 1u);
hash_map.insert("b".to_string(), 2); hash_map.insert("b".into_string(), 2);
assert_eq!(hash_map.to_json(), object); assert_eq!(hash_map.to_json(), object);
assert_eq!(Some(15i).to_json(), I64(15)); assert_eq!(Some(15i).to_json(), I64(15));
assert_eq!(Some(15u).to_json(), U64(15)); assert_eq!(Some(15u).to_json(), U64(15));
@ -3765,7 +3765,7 @@ mod tests {
} }
fn big_json() -> string::String { fn big_json() -> string::String {
let mut src = "[\n".to_string(); let mut src = "[\n".into_string();
for _ in range(0i, 500) { for _ in range(0i, 500) {
src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \ src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
[1,2,3]},"#); [1,2,3]},"#);