bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

std: change fail_unless to assert_eq in json.rs

Browse source
This commit is contained in:
Erick Tryzelaar 2013-03-26 17:23:00 -07:00
parent 89fc95885f
commit 6cf99fa54a
1 changed files with 128 additions and 133 deletions
Download patch file Download diff file Expand all files Collapse all files

261
src/libstd/json.rs
View file

@ -1214,45 +1214,47 @@ mod tests {
#[test] #[test]
fn test_write_null() { fn test_write_null() {
fail_unless!(to_str(&Null) == ~"null"); assert_eq!(to_str(&Null), ~"null");
} }
#[test] #[test]
fn test_write_number() { fn test_write_number() {
fail_unless!(to_str(&Number(3f)) == ~"3"); assert_eq!(to_str(&Number(3f)), ~"3");
fail_unless!(to_str(&Number(3.1f)) == ~"3.1"); assert_eq!(to_str(&Number(3.1f)), ~"3.1");
fail_unless!(to_str(&Number(-1.5f)) == ~"-1.5"); assert_eq!(to_str(&Number(-1.5f)), ~"-1.5");
fail_unless!(to_str(&Number(0.5f)) == ~"0.5"); assert_eq!(to_str(&Number(0.5f)), ~"0.5");
} }
#[test] #[test]
fn test_write_str() { fn test_write_str() {
fail_unless!(to_str(&String(~"")) == ~"\"\""); assert_eq!(to_str(&String(~"")), ~"\"\"");
fail_unless!(to_str(&String(~"foo")) == ~"\"foo\""); assert_eq!(to_str(&String(~"foo")), ~"\"foo\"");
} }
#[test] #[test]
fn test_write_bool() { fn test_write_bool() {
fail_unless!(to_str(&Boolean(true)) == ~"true"); assert_eq!(to_str(&Boolean(true)), ~"true");
fail_unless!(to_str(&Boolean(false)) == ~"false"); assert_eq!(to_str(&Boolean(false)), ~"false");
} }
#[test] #[test]
fn test_write_list() { fn test_write_list() {
fail_unless!(to_str(&List(~[])) == ~"[]"); assert_eq!(to_str(&List(~[])), ~"[]");
fail_unless!(to_str(&List(~[Boolean(true)])) == ~"[true]"); assert_eq!(to_str(&List(~[Boolean(true)])), ~"[true]");
fail_unless!(to_str(&List(~[ assert_eq!(to_str(&List(~[
Boolean(false), Boolean(false),
Null, Null,
List(~[String(~"foo\nbar"), Number(3.5f)]) List(~[String(~"foo\nbar"), Number(3.5f)])
])) == ~"[false,null,[\"foo\\nbar\",3.5]]"); ])), ~"[false,null,[\"foo\\nbar\",3.5]]");
} }
#[test] #[test]
fn test_write_object() { fn test_write_object() {
fail_unless!(to_str(&mk_object(~[])) == ~"{}"); assert_eq!(to_str(&mk_object(~[])), ~"{}");
fail_unless!(to_str(&mk_object(~[(~"a", Boolean(true))])) assert_eq!(
== ~"{\"a\":true}"); to_str(&mk_object(~[(~"a", Boolean(true))])),
~"{\"a\":true}"
);
let a = mk_object(~[ let a = mk_object(~[
(~"a", Boolean(true)), (~"a", Boolean(true)),
(~"b", List(~[ (~"b", List(~[
@ -1262,248 +1264,241 @@ mod tests {
]); ]);
// We can't compare the strings directly because the object fields be // We can't compare the strings directly because the object fields be
// printed in a different order. // printed in a different order.
let b = result::unwrap(from_str(to_str(&a))); let b = from_str(to_str(&a)).unwrap();
fail_unless!(a == b); assert_eq!(a, b);
} }
#[test] #[test]
fn test_write_enum () { fn test_write_enum () {
let bw = @io::BytesWriter(); let s = do io::with_str_writer |wr| {
let bww : @io::Writer = (bw as @io::Writer); let encoder = &Encoder(wr) as &serialize::Encoder;
let encoder = (@Encoder(bww) as @serialize::Encoder); do encoder.emit_enum(~"animal") {
do encoder.emit_enum(~"animal") { do encoder.emit_enum_variant(~"frog",37,1242) {
do encoder.emit_enum_variant (~"frog",37,1242) { // name of frog:
// name of frog: do encoder.emit_enum_variant_arg(0) {
do encoder.emit_enum_variant_arg (0) { encoder.emit_owned_str(~"Henry")
encoder.emit_owned_str(~"Henry") }
} // mass of frog in grams:
// mass of frog in grams: do encoder.emit_enum_variant_arg(1) {
do encoder.emit_enum_variant_arg (1) { encoder.emit_int(349);
encoder.emit_int(349); }
} }
} }
} };
assert_eq!(str::from_bytes(bw.bytes), ~"[\"frog\",[\"Henry\",349]]"); assert_eq!(s, ~"[\"frog\",[\"Henry\",349]]");
} }
#[test] #[test]
fn test_write_some () { fn test_write_some() {
let bw = @io::BytesWriter(); let value = Some(~"jodhpurs");
let bww : @io::Writer = (bw as @io::Writer); let s = do io::with_str_writer |wr| {
let encoder = (@Encoder(bww) as @serialize::Encoder); let encoder = Encoder(wr);
do encoder.emit_enum(~"Option") { value.encode(&encoder);
do encoder.emit_enum_variant (~"Some",37,1242) { };
do encoder.emit_enum_variant_arg (0) { assert_eq!(s, ~"\"jodhpurs\"");
encoder.emit_owned_str(~"jodhpurs")
}
}
}
assert_eq!(str::from_bytes(bw.bytes), ~"\"jodhpurs\"");
} }
#[test] #[test]
fn test_write_none () { fn test_write_none() {
let bw = @io::BytesWriter(); let value: Option<~str> = None;
let bww : @io::Writer = (bw as @io::Writer); let s = do io::with_str_writer |wr| {
let encoder = (@Encoder(bww) as @serialize::Encoder); let encoder = Encoder(wr);
do encoder.emit_enum(~"Option") { value.encode(&encoder);
do encoder.emit_enum_variant (~"None",37,1242) { };
} assert_eq!(s, ~"null");
}
assert_eq!(str::from_bytes(bw.bytes), ~"null");
} }
#[test] #[test]
fn test_trailing_characters() { fn test_trailing_characters() {
fail_unless!(from_str(~"nulla") == assert_eq!(from_str(~"nulla"),
Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"}));
fail_unless!(from_str(~"truea") == assert_eq!(from_str(~"truea"),
Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"}));
fail_unless!(from_str(~"falsea") == assert_eq!(from_str(~"falsea"),
Err(Error {line: 1u, col: 6u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 6u, msg: @~"trailing characters"}));
fail_unless!(from_str(~"1a") == assert_eq!(from_str(~"1a"),
Err(Error {line: 1u, col: 2u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 2u, msg: @~"trailing characters"}));
fail_unless!(from_str(~"[]a") == assert_eq!(from_str(~"[]a"),
Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"}));
fail_unless!(from_str(~"{}a") == assert_eq!(from_str(~"{}a"),
Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"}));
} }
#[test] #[test]
fn test_read_identifiers() { fn test_read_identifiers() {
fail_unless!(from_str(~"n") == assert_eq!(from_str(~"n"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}));
fail_unless!(from_str(~"nul") == assert_eq!(from_str(~"nul"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}));
fail_unless!(from_str(~"t") == assert_eq!(from_str(~"t"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}));
fail_unless!(from_str(~"truz") == assert_eq!(from_str(~"truz"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}));
fail_unless!(from_str(~"f") == assert_eq!(from_str(~"f"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}));
fail_unless!(from_str(~"faz") == assert_eq!(from_str(~"faz"),
Err(Error {line: 1u, col: 3u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 3u, msg: @~"invalid syntax"}));
fail_unless!(from_str(~"null") == Ok(Null)); assert_eq!(from_str(~"null"), Ok(Null));
fail_unless!(from_str(~"true") == Ok(Boolean(true))); assert_eq!(from_str(~"true"), Ok(Boolean(true)));
fail_unless!(from_str(~"false") == Ok(Boolean(false))); assert_eq!(from_str(~"false"), Ok(Boolean(false)));
fail_unless!(from_str(~" null ") == Ok(Null)); assert_eq!(from_str(~" null "), Ok(Null));
fail_unless!(from_str(~" true ") == Ok(Boolean(true))); assert_eq!(from_str(~" true "), Ok(Boolean(true)));
fail_unless!(from_str(~" false ") == Ok(Boolean(false))); assert_eq!(from_str(~" false "), Ok(Boolean(false)));
} }
#[test] #[test]
fn test_read_number() { fn test_read_number() {
fail_unless!(from_str(~"+") == assert_eq!(from_str(~"+"),
Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"}));
fail_unless!(from_str(~".") == assert_eq!(from_str(~"."),
Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"}));
fail_unless!(from_str(~"-") == assert_eq!(from_str(~"-"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid number"}));
fail_unless!(from_str(~"00") == assert_eq!(from_str(~"00"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid number"}));
fail_unless!(from_str(~"1.") == assert_eq!(from_str(~"1."),
Err(Error {line: 1u, col: 3u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 3u, msg: @~"invalid number"}));
fail_unless!(from_str(~"1e") == assert_eq!(from_str(~"1e"),
Err(Error {line: 1u, col: 3u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 3u, msg: @~"invalid number"}));
fail_unless!(from_str(~"1e+") == assert_eq!(from_str(~"1e+"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 4u, msg: @~"invalid number"}));
fail_unless!(from_str(~"3") == Ok(Number(3f))); assert_eq!(from_str(~"3"), Ok(Number(3f)));
fail_unless!(from_str(~"3.1") == Ok(Number(3.1f))); assert_eq!(from_str(~"3.1"), Ok(Number(3.1f)));
fail_unless!(from_str(~"-1.2") == Ok(Number(-1.2f))); assert_eq!(from_str(~"-1.2"), Ok(Number(-1.2f)));
fail_unless!(from_str(~"0.4") == Ok(Number(0.4f))); assert_eq!(from_str(~"0.4"), Ok(Number(0.4f)));
fail_unless!(from_str(~"0.4e5") == Ok(Number(0.4e5f))); assert_eq!(from_str(~"0.4e5"), Ok(Number(0.4e5f)));
fail_unless!(from_str(~"0.4e+15") == Ok(Number(0.4e15f))); assert_eq!(from_str(~"0.4e+15"), Ok(Number(0.4e15f)));
fail_unless!(from_str(~"0.4e-01") == Ok(Number(0.4e-01f))); assert_eq!(from_str(~"0.4e-01"), Ok(Number(0.4e-01f)));
fail_unless!(from_str(~" 3 ") == Ok(Number(3f))); assert_eq!(from_str(~" 3 "), Ok(Number(3f)));
} }
#[test] #[test]
fn test_read_str() { fn test_read_str() {
fail_unless!(from_str(~"\"") == assert_eq!(from_str(~"\""),
Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing string" Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing string"
})); }));
fail_unless!(from_str(~"\"lol") == assert_eq!(from_str(~"\"lol"),
Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing string" Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing string"
})); }));
fail_unless!(from_str(~"\"\"") == Ok(String(~""))); assert_eq!(from_str(~"\"\""), Ok(String(~"")));
fail_unless!(from_str(~"\"foo\"") == Ok(String(~"foo"))); assert_eq!(from_str(~"\"foo\""), Ok(String(~"foo")));
fail_unless!(from_str(~"\"\\\"\"") == Ok(String(~"\""))); assert_eq!(from_str(~"\"\\\"\""), Ok(String(~"\"")));
fail_unless!(from_str(~"\"\\b\"") == Ok(String(~"\x08"))); assert_eq!(from_str(~"\"\\b\""), Ok(String(~"\x08")));
fail_unless!(from_str(~"\"\\n\"") == Ok(String(~"\n"))); assert_eq!(from_str(~"\"\\n\""), Ok(String(~"\n")));
fail_unless!(from_str(~"\"\\r\"") == Ok(String(~"\r"))); assert_eq!(from_str(~"\"\\r\""), Ok(String(~"\r")));
fail_unless!(from_str(~"\"\\t\"") == Ok(String(~"\t"))); assert_eq!(from_str(~"\"\\t\""), Ok(String(~"\t")));
fail_unless!(from_str(~" \"foo\" ") == Ok(String(~"foo"))); assert_eq!(from_str(~" \"foo\" "), Ok(String(~"foo")));
} }
#[test] #[test]
fn test_unicode_hex_escapes_in_str() { fn test_unicode_hex_escapes_in_str() {
fail_unless!(from_str(~"\"\\u12ab\"") == Ok(String(~"\u12ab"))); assert_eq!(from_str(~"\"\\u12ab\""), Ok(String(~"\u12ab")));
fail_unless!(from_str(~"\"\\uAB12\"") == Ok(String(~"\uAB12"))); assert_eq!(from_str(~"\"\\uAB12\""), Ok(String(~"\uAB12")));
} }
#[test] #[test]
fn test_read_list() { fn test_read_list() {
fail_unless!(from_str(~"[") == assert_eq!(from_str(~"["),
Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing value"})); Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing value"}));
fail_unless!(from_str(~"[1") == assert_eq!(from_str(~"[1"),
Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing list"})); Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing list"}));
fail_unless!(from_str(~"[1,") == assert_eq!(from_str(~"[1,"),
Err(Error {line: 1u, col: 4u, msg: @~"EOF while parsing value"})); Err(Error {line: 1u, col: 4u, msg: @~"EOF while parsing value"}));
fail_unless!(from_str(~"[1,]") == assert_eq!(from_str(~"[1,]"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}));
fail_unless!(from_str(~"[6 7]") == assert_eq!(from_str(~"[6 7]"),
Err(Error {line: 1u, col: 4u, msg: @~"expected `,` or `]`"})); Err(Error {line: 1u, col: 4u, msg: @~"expected `,` or `]`"}));
fail_unless!(from_str(~"[]") == Ok(List(~[]))); assert_eq!(from_str(~"[]"), Ok(List(~[])));
fail_unless!(from_str(~"[ ]") == Ok(List(~[]))); assert_eq!(from_str(~"[ ]"), Ok(List(~[])));
fail_unless!(from_str(~"[true]") == Ok(List(~[Boolean(true)]))); assert_eq!(from_str(~"[true]"), Ok(List(~[Boolean(true)])));
fail_unless!(from_str(~"[ false ]") == Ok(List(~[Boolean(false)]))); assert_eq!(from_str(~"[ false ]"), Ok(List(~[Boolean(false)])));
fail_unless!(from_str(~"[null]") == Ok(List(~[Null]))); assert_eq!(from_str(~"[null]"), Ok(List(~[Null])));
fail_unless!(from_str(~"[3, 1]") == assert_eq!(from_str(~"[3, 1]"),
Ok(List(~[Number(3f), Number(1f)]))); Ok(List(~[Number(3f), Number(1f)])));
fail_unless!(from_str(~"\n[3, 2]\n") == assert_eq!(from_str(~"\n[3, 2]\n"),
Ok(List(~[Number(3f), Number(2f)]))); Ok(List(~[Number(3f), Number(2f)])));
fail_unless!(from_str(~"[2, [4, 1]]") == assert_eq!(from_str(~"[2, [4, 1]]"),
Ok(List(~[Number(2f), List(~[Number(4f), Number(1f)])]))); Ok(List(~[Number(2f), List(~[Number(4f), Number(1f)])])));
} }
#[test] #[test]
fn test_read_object() { fn test_read_object() {
fail_unless!(from_str(~"{") == assert_eq!(from_str(~"{"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 2u, col: 2u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
fail_unless!(from_str(~"{ ") == assert_eq!(from_str(~"{ "),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 3u, col: 3u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
fail_unless!(from_str(~"{1") == assert_eq!(from_str(~"{1"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 2u, col: 2u,
msg: @~"key must be a string"})); msg: @~"key must be a string"}));
fail_unless!(from_str(~"{ \"a\"") == assert_eq!(from_str(~"{ \"a\""),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 6u, col: 6u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
fail_unless!(from_str(~"{\"a\"") == assert_eq!(from_str(~"{\"a\""),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 5u, col: 5u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
fail_unless!(from_str(~"{\"a\" ") == assert_eq!(from_str(~"{\"a\" "),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 6u, col: 6u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
fail_unless!(from_str(~"{\"a\" 1") == assert_eq!(from_str(~"{\"a\" 1"),
Err(Error {line: 1u, col: 6u, msg: @~"expected `:`"})); Err(Error {line: 1u, col: 6u, msg: @~"expected `:`"}));
fail_unless!(from_str(~"{\"a\":") == assert_eq!(from_str(~"{\"a\":"),
Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing value"})); Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing value"}));
fail_unless!(from_str(~"{\"a\":1") == assert_eq!(from_str(~"{\"a\":1"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 7u, col: 7u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
fail_unless!(from_str(~"{\"a\":1 1") == assert_eq!(from_str(~"{\"a\":1 1"),
Err(Error {line: 1u, col: 8u, msg: @~"expected `,` or `}`"})); Err(Error {line: 1u, col: 8u, msg: @~"expected `,` or `}`"}));
fail_unless!(from_str(~"{\"a\":1,") == assert_eq!(from_str(~"{\"a\":1,"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 8u, col: 8u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
fail_unless!(result::unwrap(from_str(~"{}")) == mk_object(~[])); assert_eq!(result::unwrap(from_str(~"{}")), mk_object(~[]));
fail_unless!(result::unwrap(from_str(~"{\"a\": 3}")) == assert_eq!(result::unwrap(from_str(~"{\"a\": 3}")),
mk_object(~[(~"a", Number(3.0f))])); mk_object(~[(~"a", Number(3.0f))]));
fail_unless!(result::unwrap(from_str( assert_eq!(result::unwrap(from_str(
~"{ \"a\": null, \"b\" : true }")) == ~"{ \"a\": null, \"b\" : true }")),
mk_object(~[ mk_object(~[
(~"a", Null), (~"a", Null),
(~"b", Boolean(true))])); (~"b", Boolean(true))]));
fail_unless!(result::unwrap( assert_eq!(result::unwrap(
from_str(~"\n{ \"a\": null, \"b\" : true }\n")) == from_str(~"\n{ \"a\": null, \"b\" : true }\n")),
mk_object(~[ mk_object(~[
(~"a", Null), (~"a", Null),
(~"b", Boolean(true))])); (~"b", Boolean(true))]));
fail_unless!(result::unwrap(from_str( assert_eq!(result::unwrap(from_str(
~"{\"a\" : 1.0 ,\"b\": [ true ]}")) == ~"{\"a\" : 1.0 ,\"b\": [ true ]}")),
mk_object(~[ mk_object(~[
(~"a", Number(1.0)), (~"a", Number(1.0)),
(~"b", List(~[Boolean(true)])) (~"b", List(~[Boolean(true)]))
])); ]));
fail_unless!(result::unwrap(from_str( assert_eq!(result::unwrap(from_str(
~"{" + ~"{" +
~"\"a\": 1.0, " + ~"\"a\": 1.0, " +
~"\"b\": [" + ~"\"b\": [" +
@ -1511,7 +1506,7 @@ mod tests {
~"\"foo\\nbar\", " + ~"\"foo\\nbar\", " +
~"{ \"c\": {\"d\": null} } " + ~"{ \"c\": {\"d\": null} } " +
~"]" + ~"]" +
~"}")) == ~"}")),
mk_object(~[ mk_object(~[
(~"a", Number(1.0f)), (~"a", Number(1.0f)),
(~"b", List(~[ (~"b", List(~[
@ -1526,7 +1521,7 @@ mod tests {
#[test] #[test]
fn test_multiline_errors() { fn test_multiline_errors() {
fail_unless!(from_str(~"{\n \"foo\":\n \"bar\"") == assert_eq!(from_str(~"{\n \"foo\":\n \"bar\""),
Err(Error { Err(Error {
line: 3u, line: 3u,
col: 8u, col: 8u,