Auto merge of #382 - est31:xml5ever_serde_json, r=jdm

Move xml5ever tests from rustc-serialize to serde_json

Part of #378

Author: bors-servo

xml5ever/Cargo.toml

@@ -26,7 +26,7 @@ mac = "0.1"
 markup5ever = {version = "0.8", path = "../markup5ever" }
 
 [dev-dependencies]
-rustc-serialize = "0.3.15"
+serde_json = "1.0"
 rustc-test = "0.3"
 criterion = "0.2"
 

xml5ever/tests/tokenizer.rs

@@ -8,15 +8,15 @@
 // except according to those terms.
 
 extern crate markup5ever;
-extern crate rustc_serialize;
+extern crate serde_json;
 extern crate rustc_test as test;
 #[macro_use]
 extern crate xml5ever;
 
-use rustc_serialize::json::Json;
+use serde_json::{Value, Map};
 use std::borrow::Cow::Borrowed;
-use std::collections::BTreeMap;
 use std::env;
+use std::io::Read;
 use std::ffi::OsStr;
 use std::mem::replace;
 use std::path::Path;
@@ -151,65 +151,65 @@ trait JsonExt: Sized {
     fn get_tendril(&self) -> StrTendril;
     fn get_nullable_tendril(&self) -> Option<StrTendril>;
     fn get_bool(&self) -> bool;
-    fn get_obj<'t>(&'t self) -> &'t BTreeMap<String, Self>;
+    fn get_obj<'t>(&'t self) -> &'t Map<String, Self>;
     fn get_list<'t>(&'t self) -> &'t Vec<Self>;
     fn find<'t>(&'t self, key: &str) -> &'t Self;
 }
 
-impl JsonExt for Json {
+impl JsonExt for Value {
     fn get_str(&self) -> String {
         match *self {
-            Json::String(ref s) => s.to_string(),
-            _ => panic!("Json::get_str: not a String"),
+            Value::String(ref s) => s.to_string(),
+            _ => panic!("Value::get_str: not a String"),
         }
     }
 
     fn get_tendril(&self) -> StrTendril {
         match *self {
-            Json::String(ref s) => s.to_tendril(),
-            _ => panic!("Json::get_tendril: not a String"),
+            Value::String(ref s) => s.to_tendril(),
+            _ => panic!("Value::get_tendril: not a String"),
         }
     }
 
     fn get_nullable_tendril(&self) -> Option<StrTendril> {
         match *self {
-            Json::Null => None,
-            Json::String(ref s) => Some(s.to_tendril()),
-            _ => panic!("Json::get_nullable_tendril: not a String"),
+            Value::Null => None,
+            Value::String(ref s) => Some(s.to_tendril()),
+            _ => panic!("Value::get_nullable_tendril: not a String"),
         }
     }
 
     fn get_bool(&self) -> bool {
         match *self {
-            Json::Boolean(b) => b,
-            _ => panic!("Json::get_bool: not a Boolean"),
+            Value::Bool(b) => b,
+            _ => panic!("Value::get_bool: not a Boolean"),
         }
     }
 
-    fn get_obj<'t>(&'t self) -> &'t BTreeMap<String, Json> {
+    fn get_obj<'t>(&'t self) -> &'t Map<String, Value> {
         match *self {
-            Json::Object(ref m) => &*m,
-            _ => panic!("Json::get_obj: not an Object"),
+            Value::Object(ref m) => &*m,
+            _ => panic!("Value::get_obj: not an Object"),
         }
     }
 
-    fn get_list<'t>(&'t self) -> &'t Vec<Json> {
+    fn get_list<'t>(&'t self) -> &'t Vec<Value> {
         match *self {
-            Json::Array(ref m) => m,
-            _ => panic!("Json::get_list: not an Array"),
+            Value::Array(ref m) => m,
+            _ => panic!("Value::get_list: not an Array"),
         }
     }
 
-    fn find<'t>(&'t self, key: &str) -> &'t Json {
+    fn find<'t>(&'t self, key: &str) -> &'t Value {
         self.get_obj().get(&key.to_string()).unwrap()
     }
 }
 
 // Parse a JSON object (other than "ParseError") to a token.
-fn json_to_token(js: &Json) -> Token {
+fn json_to_token(js: &Value) -> Token {
     let parts = js.as_array().unwrap();
     // Collect refs here so we don't have to use "ref" in all the patterns below.
-    let args: Vec<&Json> = parts[1..].iter().collect();
+    let args: Vec<&Value> = parts[1..].iter().collect();
     match &*parts[0].get_str() {
         "StartTag" => TagToken(Tag {
             kind: StartTag,
@@ -271,13 +271,13 @@ fn json_to_token(js: &Json) -> Token {
 }
 
 // Parse the "output" field of the test case into a vector of tokens.
-fn json_to_tokens(js: &Json, exact_errors: bool) -> Vec<Token> {
+fn json_to_tokens(js: &Value, exact_errors: bool) -> Vec<Token> {
     // Use a TokenLogger so that we combine character tokens separated
     // by an ignored error.
     let mut sink = TokenLogger::new(exact_errors);
     for tok in js.as_array().unwrap().iter() {
         match *tok {
-            Json::String(ref s) if &s[..] == "ParseError" => {
+            Value::String(ref s) if &s[..] == "ParseError" => {
                 sink.process_token(ParseError(Borrowed("")))
             },
             _ => sink.process_token(json_to_token(tok)),
@@ -286,7 +286,7 @@ fn json_to_tokens(js: &Json, exact_errors: bool) -> Vec<Token> {
     sink.get_tokens()
 }
 
-fn mk_xml_test(desc: String, input: String, expect: Json, opts: XmlTokenizerOpts) -> TestDescAndFn {
+fn mk_xml_test(desc: String, input: String, expect: Value, opts: XmlTokenizerOpts) -> TestDescAndFn {
     TestDescAndFn {
         desc: TestDesc::new(DynTestName(desc)),
         testfn: DynTestFn(Box::new(move || {
@@ -310,13 +310,13 @@ fn mk_xml_test(desc: String, input: String, expect: Json, opts: XmlTokenizerOpts
     }
 }
 
-fn mk_xml_tests(tests: &mut Vec<TestDescAndFn>, filename: &str, js: &Json) {
-    let input = js.find("input").unwrap().as_string().unwrap();
-    let expect = js.find("output").unwrap().clone();
+fn mk_xml_tests(tests: &mut Vec<TestDescAndFn>, filename: &str, js: &Value) {
+    let input: &str = &js.find("input").get_str();
+    let expect = js.find("output");
     let desc = format!(
         "tok: {}: {}",
         filename,
-        js.find("description").unwrap().as_string().unwrap()
+        js.find("description").get_str()
     );
 
     // Some tests want to start in a state other than Data.
@@ -360,10 +360,12 @@ fn tests(src_dir: &Path) -> Vec<TestDescAndFn> {
         "tokenizer",
         OsStr::new("test"),
         |path, mut file| {
-            let js = Json::from_reader(&mut file).ok().expect("json parse error");
+            let mut s = String::new();
+            file.read_to_string(&mut s).ok().expect("file reading error");
+            let js: Value = serde_json::from_str(&s).ok().expect("json parse error");
 
             match js["tests"] {
-                Json::Array(ref lst) => {
+                Value::Array(ref lst) => {
                     for test in lst.iter() {
                         mk_xml_tests(
                             &mut tests,

xml5ever/tests/tree_builder.rs

@@ -7,7 +7,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-extern crate rustc_serialize;
 extern crate rustc_test as test;
 #[macro_use]
 extern crate xml5ever;