From cde1c511c573088d66a2ebf28c3a29f3acda9490 Mon Sep 17 00:00:00 2001
From: Anthony Ramine <n.oxyde@gmail.com>
Date: Wed, 19 Aug 2015 11:11:04 +0200
Subject: [PATCH] Fix <noscript> tests

Use the expectations' fields script-on and script-off to run the tests with
their scripting flag set appropriately.
---
 data/test/ignore      |  8 --------
 tests/tree_builder.rs | 46 +++++++++++++++++++++++++++++++++++--------
 2 files changed, 38 insertions(+), 16 deletions(-)

diff --git a/data/test/ignore b/data/test/ignore
index 5f84915c..4a2c95a6 100644
--- a/data/test/ignore
+++ b/data/test/ignore
@@ -13,13 +13,7 @@ tb: ruby.dat-20
 tb: ruby.dat-3
 tb: ruby.dat-5
 tb: ruby.dat-7
-tb: tests16.dat-181
-tb: tests16.dat-183
-tb: tests16.dat-185
 tb: tests16.dat-194
-tb: tests16.dat-84
-tb: tests16.dat-86
-tb: tests16.dat-88
 tb: tests19.dat-10
 tb: tests19.dat-11
 tb: tests19.dat-18
@@ -29,8 +23,6 @@ tb: tests19.dat-8
 tb: tests19.dat-9
 tb: tests2.dat-44
 tb: tests26.dat-9
-tb: tests5.dat-16
-tb: webkit02.dat-2
 tb: foreign-fragment.dat-0
 tb: foreign-fragment.dat-1
 tb: foreign-fragment.dat-18
diff --git a/tests/tree_builder.rs b/tests/tree_builder.rs
index 22a17145..3596ceda 100644
--- a/tests/tree_builder.rs
+++ b/tests/tree_builder.rs
@@ -30,7 +30,7 @@ use std::collections::{HashSet, HashMap};
 #[cfg(feature = "unstable")] use test::{TestDesc, TestDescAndFn, DynTestName, DynTestFn};
 #[cfg(feature = "unstable")] use test::ShouldPanic::No;
 
-use html5ever::{parse, parse_fragment, one_input};
+use html5ever::{ParseOpts, parse, parse_fragment, one_input};
 use html5ever::rcdom::{Comment, Document, Doctype, Element, Handle, RcDom};
 use html5ever::rcdom::{Template, Text};
 
@@ -161,19 +161,49 @@ fn make_test(
         idx: usize,
         fields: HashMap<String, String>) {
 
+    let scripting_flags = &[false, true];
+    let scripting_flags = if fields.contains_key("script-off") {
+        &scripting_flags[0..1]
+    } else if fields.contains_key("script-on") {
+        &scripting_flags[1..2]
+    } else {
+        &scripting_flags[0..2]
+    };
+    let name = format!("tb: {}-{}", filename, idx);
+    for scripting_enabled in scripting_flags {
+        let test = make_test_desc_with_scripting_flag(
+            ignores, &name, &fields, *scripting_enabled);
+        tests.push(test);
+    }
+}
+
+#[cfg(feature = "unstable")]
+fn make_test_desc_with_scripting_flag(
+        ignores: &HashSet<String>,
+        name: &str,
+        fields: &HashMap<String, String>,
+        scripting_enabled: bool)
+        -> TestDescAndFn {
     let get_field = |key| {
         let field = fields.get(key).expect("missing field");
         field.trim_right_matches('\n').to_string()
     };
 
-    let data = get_field("data");
     let expected = get_field("document");
     let context = fields.get("document-fragment")
                         .map(|field| Atom::from_slice(field.trim_right_matches('\n')));
-    let name = format!("tb: {}-{}", filename, idx);
-    let ignore = ignores.contains(&name);
+    let data = get_field("data");
+    let ignore = ignores.contains(name);
+    let mut name = name.to_owned();
+    if scripting_enabled {
+        name.push_str(" (scripting enabled)");
+    } else {
+        name.push_str(" (scripting disabled)");
+    };
+    let mut opts: ParseOpts = Default::default();
+    opts.tree_builder.scripting_enabled = scripting_enabled;
 
-    tests.push(TestDescAndFn {
+    TestDescAndFn {
         desc: TestDesc {
             name: DynTestName(name),
             ignore: ignore,
@@ -185,7 +215,7 @@ fn make_test(
             let mut result = String::new();
             match context {
                 None => {
-                    let dom: RcDom = parse(one_input(data.clone()), Default::default());
+                    let dom: RcDom = parse(one_input(data.clone()), opts);
                     for child in dom.document.borrow().children.iter() {
                         serialize(&mut result, 1, child.clone());
                     }
@@ -193,7 +223,7 @@ fn make_test(
                 Some(ref context) => {
                     let dom: RcDom = parse_fragment(one_input(data.clone()),
                                                     context.clone(),
-                                                    Default::default());
+                                                    opts);
                     // fragment case: serialize children of the html element
                     // rather than children of the document
                     let doc = dom.document.borrow();
@@ -211,7 +241,7 @@ fn make_test(
                     data, result, expected);
             }
         })),
-    });
+    }
 }
 
 #[cfg(feature = "unstable")]