From 626172d64c0e67d36c82cfe250d080a5c45b4f9c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Wed, 5 Dec 2018 18:04:51 -0500
Subject: [PATCH 01/11] style: Use cbindgen for a couple more CSS properties.

Differential Revision: https://phabricator.services.mozilla.com/D13886
---
 components/style/cbindgen.toml                |  5 +++
 components/style/properties/gecko.mako.rs     | 41 ++++++-------------
 .../style/properties/longhands/box.mako.rs    |  1 +
 components/style/values/computed/box.rs       |  2 +
 components/style/values/specified/box.rs      |  3 ++
 5 files changed, 23 insertions(+), 29 deletions(-)

diff --git a/components/style/cbindgen.toml b/components/style/cbindgen.toml
index e93d2c35c35..3b5d56f9882 100644
--- a/components/style/cbindgen.toml
+++ b/components/style/cbindgen.toml
@@ -59,5 +59,10 @@ include = [
   "PathCommand",
   "UnicodeRange",
   "UserSelect",
+  "Float",
+  "OverscrollBehavior",
+  "ScrollSnapType",
+  "OverflowClipBox",
+  "Resize",
 ]
 item_types = ["enums", "structs", "typedefs"]
diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index de6a84cccf2..6381bc1f47e 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -1389,8 +1389,14 @@ impl Clone for ${style_struct.gecko_struct_name} {
 
     # Types used with predefined_type()-defined properties that we can auto-generate.
     predefined_types = {
+        "Appearance": impl_simple,
+        "OverscrollBehavior": impl_simple,
+        "OverflowClipBox": impl_simple,
+        "ScrollSnapType": impl_simple,
+        "Float": impl_simple,
         "BreakBetween": impl_simple,
         "BreakWithin": impl_simple,
+        "Resize": impl_simple,
         "Color": impl_color,
         "ColorOrAuto": impl_color,
         "GreaterThanOrEqualToOneNumber": impl_simple,
@@ -3005,20 +3011,18 @@ fn static_assert() {
     }
 </%def>
 
-<% skip_box_longhands= """display -moz-appearance overflow-y vertical-align
+<% skip_box_longhands= """display overflow-y vertical-align
                           animation-name animation-delay animation-duration
                           animation-direction animation-fill-mode animation-play-state
                           animation-iteration-count animation-timing-function
-                          transition-duration transition-delay
+                          clear transition-duration transition-delay
                           transition-timing-function transition-property
                           rotate scroll-snap-points-x scroll-snap-points-y
-                          scroll-snap-type-x scroll-snap-type-y scroll-snap-coordinate
+                          scroll-snap-coordinate
                           perspective-origin -moz-binding will-change
-                          offset-path overscroll-behavior-x overscroll-behavior-y
-                          overflow-clip-box-inline overflow-clip-box-block
-                          perspective-origin -moz-binding will-change
-                          shape-outside contain touch-action translate
-                          scale""" %>
+                          offset-path perspective-origin -moz-binding
+                          will-change shape-outside contain touch-action
+                          translate scale""" %>
 <%self:impl_trait style_struct_name="Box" skip_longhands="${skip_box_longhands}">
     #[inline]
     pub fn set_display(&mut self, v: longhands::display::computed_value::T) {
@@ -3051,11 +3055,6 @@ fn static_assert() {
         self.gecko.mDisplay
     }
 
-    ${impl_simple('_moz_appearance', 'mAppearance')}
-
-    <% float_keyword = Keyword("float", "Left Right None", gecko_enum_prefix="StyleFloat") %>
-    ${impl_keyword('float', 'mFloat', float_keyword)}
-
     <% clear_keyword = Keyword(
         "clear",
         "Left Right None Both",
@@ -3064,9 +3063,6 @@ fn static_assert() {
     ) %>
     ${impl_keyword('clear', 'mBreakType', clear_keyword)}
 
-    <% resize_keyword = Keyword("resize", "None Both Horizontal Vertical") %>
-    ${impl_keyword('resize', 'mResize', resize_keyword)}
-
     <% overflow_x = data.longhands_by_name["overflow-x"] %>
     pub fn set_overflow_y(&mut self, v: longhands::overflow_y::computed_value::T) {
         use crate::properties::longhands::overflow_x::computed_value::T as BaseType;
@@ -3398,19 +3394,6 @@ fn static_assert() {
 
     ${impl_animation_timing_function()}
 
-    <% scroll_snap_type_keyword = Keyword("scroll-snap-type", "None Mandatory Proximity") %>
-    ${impl_keyword('scroll_snap_type_y', 'mScrollSnapTypeY', scroll_snap_type_keyword)}
-    ${impl_keyword('scroll_snap_type_x', 'mScrollSnapTypeX', scroll_snap_type_keyword)}
-
-    <% overscroll_behavior_keyword = Keyword("overscroll-behavior", "Auto Contain None",
-                                             gecko_enum_prefix="StyleOverscrollBehavior") %>
-    ${impl_keyword('overscroll_behavior_x', 'mOverscrollBehaviorX', overscroll_behavior_keyword)}
-    ${impl_keyword('overscroll_behavior_y', 'mOverscrollBehaviorY', overscroll_behavior_keyword)}
-
-    <% overflow_clip_box_keyword = Keyword("overflow-clip-box", "padding-box content-box") %>
-    ${impl_keyword('overflow_clip_box_inline', 'mOverflowClipBoxInline', overflow_clip_box_keyword)}
-    ${impl_keyword('overflow_clip_box_block', 'mOverflowClipBoxBlock', overflow_clip_box_keyword)}
-
     pub fn set_perspective_origin(&mut self, v: longhands::perspective_origin::computed_value::T) {
         self.gecko.mPerspectiveOrigin[0].set(v.horizontal);
         self.gecko.mPerspectiveOrigin[1].set(v.vertical);
diff --git a/components/style/properties/longhands/box.mako.rs b/components/style/properties/longhands/box.mako.rs
index 5a0f893cc63..f0bf6b0bcdb 100644
--- a/components/style/properties/longhands/box.mako.rs
+++ b/components/style/properties/longhands/box.mako.rs
@@ -574,6 +574,7 @@ ${helpers.predefined_type(
     alias="-webkit-appearance:layout.css.webkit-appearance.enabled",
     spec="Nonstandard (https://developer.mozilla.org/en-US/docs/Web/CSS/-moz-appearance)",
     animation_value_type="discrete",
+    gecko_ffi_name="mAppearance",
 )}
 
 ${helpers.predefined_type(
diff --git a/components/style/values/computed/box.rs b/components/style/values/computed/box.rs
index 05d61015765..9ba38f04015 100644
--- a/components/style/values/computed/box.rs
+++ b/components/style/values/computed/box.rs
@@ -39,6 +39,7 @@ pub type Perspective = GenericPerspective<NonNegativeLength>;
 #[derive(
     Clone, Copy, Debug, Eq, Hash, MallocSizeOf, Parse, PartialEq, SpecifiedValueInfo, ToCss,
 )]
+#[repr(u8)]
 /// A computed value for the `float` property.
 pub enum Float {
     Left,
@@ -157,6 +158,7 @@ impl ToComputedValue for SpecifiedClear {
 #[allow(missing_docs)]
 #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
 #[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, Parse, PartialEq, ToCss)]
+#[repr(u8)]
 pub enum Resize {
     None,
     Both,
diff --git a/components/style/values/specified/box.rs b/components/style/values/specified/box.rs
index 78f29ccf6de..84cbe9e879c 100644
--- a/components/style/values/specified/box.rs
+++ b/components/style/values/specified/box.rs
@@ -389,6 +389,7 @@ impl Parse for AnimationName {
     ToComputedValue,
     ToCss,
 )]
+#[repr(u8)]
 pub enum ScrollSnapType {
     None,
     Mandatory,
@@ -409,6 +410,7 @@ pub enum ScrollSnapType {
     ToComputedValue,
     ToCss,
 )]
+#[repr(u8)]
 pub enum OverscrollBehavior {
     Auto,
     Contain,
@@ -429,6 +431,7 @@ pub enum OverscrollBehavior {
     ToComputedValue,
     ToCss,
 )]
+#[repr(u8)]
 pub enum OverflowClipBox {
     PaddingBox,
     ContentBox,

From 3f58e0b069859515844da0565a06a7950af4862f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Tue, 11 Dec 2018 00:11:18 +0000
Subject: [PATCH 02/11] style: Deduplicate a bit the malloc_size_of code for
 hashmaps / hashsets.

This allows to experiment with other hash maps easily rather than
depending on what hashglobe::fake::HashMap dereferences to.

In particular I wrote it while trying to get a build working with hashbrown.

Differential Revision: https://phabricator.services.mozilla.com/D14098
---
 components/malloc_size_of/lib.rs | 241 ++++++++++---------------------
 1 file changed, 74 insertions(+), 167 deletions(-)

diff --git a/components/malloc_size_of/lib.rs b/components/malloc_size_of/lib.rs
index 778082b5f06..ddd7b5f2dad 100644
--- a/components/malloc_size_of/lib.rs
+++ b/components/malloc_size_of/lib.rs
@@ -436,126 +436,89 @@ where
     }
 }
 
-impl<T, S> MallocShallowSizeOf for std::collections::HashSet<T, S>
-where
-    T: Eq + Hash,
-    S: BuildHasher,
-{
-    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        if ops.has_malloc_enclosing_size_of() {
-            // The first value from the iterator gives us an interior pointer.
-            // `ops.malloc_enclosing_size_of()` then gives us the storage size.
-            // This assumes that the `HashSet`'s contents (values and hashes)
-            // are all stored in a single contiguous heap allocation.
-            self.iter()
-                .next()
-                .map_or(0, |t| unsafe { ops.malloc_enclosing_size_of(t) })
-        } else {
-            // An estimate.
-            self.capacity() * (size_of::<T>() + size_of::<usize>())
+macro_rules! malloc_size_of_hash_set {
+    ($ty:ty) => {
+        impl<T, S> MallocShallowSizeOf for $ty
+        where
+            T: Eq + Hash,
+            S: BuildHasher,
+        {
+            fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+                if ops.has_malloc_enclosing_size_of() {
+                    // The first value from the iterator gives us an interior pointer.
+                    // `ops.malloc_enclosing_size_of()` then gives us the storage size.
+                    // This assumes that the `HashSet`'s contents (values and hashes)
+                    // are all stored in a single contiguous heap allocation.
+                    self.iter()
+                        .next()
+                        .map_or(0, |t| unsafe { ops.malloc_enclosing_size_of(t) })
+                } else {
+                    // An estimate.
+                    self.capacity() * (size_of::<T>() + size_of::<usize>())
+                }
+            }
+        }
+
+        impl<T, S> MallocSizeOf for $ty
+        where
+            T: Eq + Hash + MallocSizeOf,
+            S: BuildHasher,
+        {
+            fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+                let mut n = self.shallow_size_of(ops);
+                for t in self.iter() {
+                    n += t.size_of(ops);
+                }
+                n
+            }
         }
     }
 }
 
-impl<T, S> MallocSizeOf for std::collections::HashSet<T, S>
-where
-    T: Eq + Hash + MallocSizeOf,
-    S: BuildHasher,
-{
-    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        let mut n = self.shallow_size_of(ops);
-        for t in self.iter() {
-            n += t.size_of(ops);
-        }
-        n
-    }
-}
+malloc_size_of_hash_set!(std::collections::HashSet<T, S>);
+malloc_size_of_hash_set!(hashglobe::hash_set::HashSet<T, S>);
+malloc_size_of_hash_set!(hashglobe::fake::HashSet<T, S>);
 
-impl<T, S> MallocShallowSizeOf for hashglobe::hash_set::HashSet<T, S>
-where
-    T: Eq + Hash,
-    S: BuildHasher,
-{
-    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        // See the implementation for std::collections::HashSet for details.
-        if ops.has_malloc_enclosing_size_of() {
-            self.iter()
-                .next()
-                .map_or(0, |t| unsafe { ops.malloc_enclosing_size_of(t) })
-        } else {
-            self.capacity() * (size_of::<T>() + size_of::<usize>())
+macro_rules! malloc_size_of_hash_map {
+    ($ty:ty) => {
+        impl<K, V, S> MallocShallowSizeOf for $ty
+        where
+            K: Eq + Hash,
+            S: BuildHasher,
+        {
+            fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+                // See the implementation for std::collections::HashSet for details.
+                if ops.has_malloc_enclosing_size_of() {
+                    self.values()
+                        .next()
+                        .map_or(0, |v| unsafe { ops.malloc_enclosing_size_of(v) })
+                } else {
+                    self.capacity() * (size_of::<V>() + size_of::<K>() + size_of::<usize>())
+                }
+            }
+        }
+
+        impl<K, V, S> MallocSizeOf for $ty
+        where
+            K: Eq + Hash + MallocSizeOf,
+            V: MallocSizeOf,
+            S: BuildHasher,
+        {
+            fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+                let mut n = self.shallow_size_of(ops);
+                for (k, v) in self.iter() {
+                    n += k.size_of(ops);
+                    n += v.size_of(ops);
+                }
+                n
+            }
         }
     }
 }
 
-impl<T, S> MallocSizeOf for hashglobe::hash_set::HashSet<T, S>
-where
-    T: Eq + Hash + MallocSizeOf,
-    S: BuildHasher,
-{
-    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        let mut n = self.shallow_size_of(ops);
-        for t in self.iter() {
-            n += t.size_of(ops);
-        }
-        n
-    }
-}
-
-impl<T, S> MallocShallowSizeOf for hashglobe::fake::HashSet<T, S>
-where
-    T: Eq + Hash,
-    S: BuildHasher,
-{
-    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        use std::ops::Deref;
-        self.deref().shallow_size_of(ops)
-    }
-}
-
-impl<T, S> MallocSizeOf for hashglobe::fake::HashSet<T, S>
-where
-    T: Eq + Hash + MallocSizeOf,
-    S: BuildHasher,
-{
-    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        use std::ops::Deref;
-        self.deref().size_of(ops)
-    }
-}
-
-impl<K, V, S> MallocShallowSizeOf for std::collections::HashMap<K, V, S>
-where
-    K: Eq + Hash,
-    S: BuildHasher,
-{
-    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        // See the implementation for std::collections::HashSet for details.
-        if ops.has_malloc_enclosing_size_of() {
-            self.values()
-                .next()
-                .map_or(0, |v| unsafe { ops.malloc_enclosing_size_of(v) })
-        } else {
-            self.capacity() * (size_of::<V>() + size_of::<K>() + size_of::<usize>())
-        }
-    }
-}
-
-impl<K, V, S> MallocSizeOf for std::collections::HashMap<K, V, S>
-where
-    K: Eq + Hash + MallocSizeOf,
-    V: MallocSizeOf,
-    S: BuildHasher,
-{
-    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        let mut n = self.shallow_size_of(ops);
-        for (k, v) in self.iter() {
-            n += k.size_of(ops);
-            n += v.size_of(ops);
-        }
-        n
-    }
-}
+malloc_size_of_hash_map!(std::collections::HashMap<K, V, S>);
+malloc_size_of_hash_map!(hashglobe::hash_map::HashMap<K, V, S>);
+malloc_size_of_hash_map!(hashglobe::fake::HashMap<K, V, S>);
 
 impl<K, V> MallocShallowSizeOf for std::collections::BTreeMap<K, V>
 where
@@ -587,62 +550,6 @@ where
     }
 }
 
-impl<K, V, S> MallocShallowSizeOf for hashglobe::hash_map::HashMap<K, V, S>
-where
-    K: Eq + Hash,
-    S: BuildHasher,
-{
-    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        // See the implementation for std::collections::HashSet for details.
-        if ops.has_malloc_enclosing_size_of() {
-            self.values()
-                .next()
-                .map_or(0, |v| unsafe { ops.malloc_enclosing_size_of(v) })
-        } else {
-            self.capacity() * (size_of::<V>() + size_of::<K>() + size_of::<usize>())
-        }
-    }
-}
-
-impl<K, V, S> MallocSizeOf for hashglobe::hash_map::HashMap<K, V, S>
-where
-    K: Eq + Hash + MallocSizeOf,
-    V: MallocSizeOf,
-    S: BuildHasher,
-{
-    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        let mut n = self.shallow_size_of(ops);
-        for (k, v) in self.iter() {
-            n += k.size_of(ops);
-            n += v.size_of(ops);
-        }
-        n
-    }
-}
-
-impl<K, V, S> MallocShallowSizeOf for hashglobe::fake::HashMap<K, V, S>
-where
-    K: Eq + Hash,
-    S: BuildHasher,
-{
-    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        use std::ops::Deref;
-        self.deref().shallow_size_of(ops)
-    }
-}
-
-impl<K, V, S> MallocSizeOf for hashglobe::fake::HashMap<K, V, S>
-where
-    K: Eq + Hash + MallocSizeOf,
-    V: MallocSizeOf,
-    S: BuildHasher,
-{
-    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
-        use std::ops::Deref;
-        self.deref().size_of(ops)
-    }
-}
-
 // PhantomData is always 0.
 impl<T> MallocSizeOf for std::marker::PhantomData<T> {
     fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {

From 901c055519198872460352fc43ff997f7e1dac12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Tue, 11 Dec 2018 01:50:32 +0100
Subject: [PATCH 03/11] style: Move overflow to use cbindgen.

It's one of the most annoying / hacky mako bits we have.

Differential Revision: https://phabricator.services.mozilla.com/D14084
---
 components/style/cbindgen.toml                |  1 +
 components/style/properties/data.py           |  1 +
 components/style/properties/gecko.mako.rs     | 25 ++-------------
 .../style/properties/longhands/box.mako.rs    | 32 ++++++++-----------
 components/style/values/computed/box.rs       |  2 +-
 components/style/values/computed/mod.rs       |  2 +-
 components/style/values/specified/box.rs      | 25 +++++++++++++++
 components/style/values/specified/mod.rs      |  2 +-
 8 files changed, 46 insertions(+), 44 deletions(-)

diff --git a/components/style/cbindgen.toml b/components/style/cbindgen.toml
index 3b5d56f9882..6005126fb27 100644
--- a/components/style/cbindgen.toml
+++ b/components/style/cbindgen.toml
@@ -64,5 +64,6 @@ include = [
   "ScrollSnapType",
   "OverflowClipBox",
   "Resize",
+  "Overflow",
 ]
 item_types = ["enums", "structs", "typedefs"]
diff --git a/components/style/properties/data.py b/components/style/properties/data.py
index 52d8cf8ec03..8faaa163823 100644
--- a/components/style/properties/data.py
+++ b/components/style/properties/data.py
@@ -325,6 +325,7 @@ class Longhand(object):
                 "NonNegativeNumber",
                 "Opacity",
                 "OutlineStyle",
+                "Overflow",
                 "OverflowClipBox",
                 "OverflowWrap",
                 "OverscrollBehavior",
diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index 6381bc1f47e..5f96b42c10a 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -1394,6 +1394,7 @@ impl Clone for ${style_struct.gecko_struct_name} {
         "OverflowClipBox": impl_simple,
         "ScrollSnapType": impl_simple,
         "Float": impl_simple,
+        "Overflow": impl_simple,
         "BreakBetween": impl_simple,
         "BreakWithin": impl_simple,
         "Resize": impl_simple,
@@ -3011,7 +3012,7 @@ fn static_assert() {
     }
 </%def>
 
-<% skip_box_longhands= """display overflow-y vertical-align
+<% skip_box_longhands= """display vertical-align
                           animation-name animation-delay animation-duration
                           animation-direction animation-fill-mode animation-play-state
                           animation-iteration-count animation-timing-function
@@ -3063,28 +3064,6 @@ fn static_assert() {
     ) %>
     ${impl_keyword('clear', 'mBreakType', clear_keyword)}
 
-    <% overflow_x = data.longhands_by_name["overflow-x"] %>
-    pub fn set_overflow_y(&mut self, v: longhands::overflow_y::computed_value::T) {
-        use crate::properties::longhands::overflow_x::computed_value::T as BaseType;
-        // FIXME(bholley): Align binary representations and ditch |match| for cast + static_asserts
-        self.gecko.mOverflowY = match v {
-            % for value in overflow_x.keyword.values_for('gecko'):
-                BaseType::${to_camel_case(value)} => structs::${overflow_x.keyword.gecko_constant(value)} as u8,
-            % endfor
-        };
-    }
-    ${impl_simple_copy('overflow_y', 'mOverflowY')}
-    pub fn clone_overflow_y(&self) -> longhands::overflow_y::computed_value::T {
-        use crate::properties::longhands::overflow_x::computed_value::T as BaseType;
-        // FIXME(bholley): Align binary representations and ditch |match| for cast + static_asserts
-        match self.gecko.mOverflowY as u32 {
-            % for value in overflow_x.keyword.values_for('gecko'):
-            structs::${overflow_x.keyword.gecko_constant(value)} => BaseType::${to_camel_case(value)},
-            % endfor
-            x => panic!("Found unexpected value in style struct for overflow_y property: {}", x),
-        }
-    }
-
     pub fn set_vertical_align(&mut self, v: longhands::vertical_align::computed_value::T) {
         use crate::values::generics::box_::VerticalAlign;
         let value = match v {
diff --git a/components/style/properties/longhands/box.mako.rs b/components/style/properties/longhands/box.mako.rs
index f0bf6b0bcdb..1e0629861e4 100644
--- a/components/style/properties/longhands/box.mako.rs
+++ b/components/style/properties/longhands/box.mako.rs
@@ -100,34 +100,30 @@ ${helpers.single_keyword("-servo-overflow-clip-box", "padding-box content-box",
     )}
 % endfor
 
-<%
-    overflow_custom_consts = { "-moz-hidden-unscrollable": "CLIP" }
-%>
-
 // FIXME(pcwalton, #2742): Implement scrolling for `scroll` and `auto`.
 //
 // We allow it to apply to placeholders for UA sheets, which set it !important.
-${helpers.single_keyword(
+${helpers.predefined_type(
     "overflow-x",
-    "visible hidden scroll auto",
+    "Overflow",
+    "computed::Overflow::Visible",
     animation_value_type="discrete",
-    extra_gecko_values="-moz-hidden-unscrollable",
-    custom_consts=overflow_custom_consts,
-    gecko_constant_prefix="NS_STYLE_OVERFLOW",
     flags="APPLIES_TO_PLACEHOLDER",
     spec="https://drafts.csswg.org/css-overflow/#propdef-overflow-x",
+    needs_context=False,
     servo_restyle_damage = "reflow",
 )}
 
-// FIXME(pcwalton, #2742): Implement scrolling for `scroll` and `auto`.
-//
-// We allow it to apply to placeholders for UA sheets, which set it !important.
-<%helpers:longhand name="overflow-y" animation_value_type="discrete"
-                   flags="APPLIES_TO_PLACEHOLDER",
-                   spec="https://drafts.csswg.org/css-overflow/#propdef-overflow-y"
-                   servo_restyle_damage = "reflow">
-    pub use super::overflow_x::{SpecifiedValue, parse, get_initial_value, computed_value};
-</%helpers:longhand>
+${helpers.predefined_type(
+    "overflow-y",
+    "Overflow",
+    "computed::Overflow::Visible",
+    animation_value_type="discrete",
+    flags="APPLIES_TO_PLACEHOLDER",
+    spec="https://drafts.csswg.org/css-overflow/#propdef-overflow-y",
+    needs_context=False,
+    servo_restyle_damage = "reflow",
+)}
 
 <% transition_extra_prefixes = "moz:layout.css.prefixes.transitions webkit" %>
 
diff --git a/components/style/values/computed/box.rs b/components/style/values/computed/box.rs
index 9ba38f04015..32ac16fb574 100644
--- a/components/style/values/computed/box.rs
+++ b/components/style/values/computed/box.rs
@@ -13,7 +13,7 @@ use crate::values::specified::box_ as specified;
 
 pub use crate::values::specified::box_::{AnimationName, Appearance, BreakBetween, BreakWithin};
 pub use crate::values::specified::box_::{Clear as SpecifiedClear, Float as SpecifiedFloat};
-pub use crate::values::specified::box_::{Contain, Display, OverflowClipBox};
+pub use crate::values::specified::box_::{Contain, Display, Overflow, OverflowClipBox};
 pub use crate::values::specified::box_::{OverscrollBehavior, ScrollSnapType};
 pub use crate::values::specified::box_::{TouchAction, TransitionProperty, WillChange};
 
diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs
index d05d42e0102..8e135b52caa 100644
--- a/components/style/values/computed/mod.rs
+++ b/components/style/values/computed/mod.rs
@@ -43,7 +43,7 @@ pub use self::border::{BorderImageRepeat, BorderImageSideWidth};
 pub use self::border::{BorderImageSlice, BorderImageWidth};
 pub use self::box_::{AnimationIterationCount, AnimationName, Contain};
 pub use self::box_::{Appearance, BreakBetween, BreakWithin, Clear, Float};
-pub use self::box_::{Display, TransitionProperty};
+pub use self::box_::{Display, TransitionProperty, Overflow};
 pub use self::box_::{OverflowClipBox, OverscrollBehavior, Perspective, Resize};
 pub use self::box_::{ScrollSnapType, TouchAction, VerticalAlign, WillChange};
 pub use self::color::{Color, ColorPropertyValue, RGBAColor};
diff --git a/components/style/values/specified/box.rs b/components/style/values/specified/box.rs
index 84cbe9e879c..54030ba7139 100644
--- a/components/style/values/specified/box.rs
+++ b/components/style/values/specified/box.rs
@@ -1363,3 +1363,28 @@ pub enum BreakWithin {
     Auto,
     Avoid,
 }
+
+/// The value for the `overflow-x` / `overflow-y` properties.
+#[allow(missing_docs)]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Eq,
+    Hash,
+    MallocSizeOf,
+    Parse,
+    PartialEq,
+    SpecifiedValueInfo,
+    ToCss,
+    ToComputedValue,
+)]
+#[repr(u8)]
+pub enum Overflow {
+    Visible,
+    Hidden,
+    Scroll,
+    Auto,
+    #[cfg(feature = "gecko")]
+    MozHiddenUnscrollable,
+}
diff --git a/components/style/values/specified/mod.rs b/components/style/values/specified/mod.rs
index c185dce80d0..3b8278c3287 100644
--- a/components/style/values/specified/mod.rs
+++ b/components/style/values/specified/mod.rs
@@ -36,7 +36,7 @@ pub use self::border::{BorderCornerRadius, BorderImageSlice, BorderImageWidth};
 pub use self::border::{BorderImageRepeat, BorderImageSideWidth};
 pub use self::border::{BorderRadius, BorderSideWidth, BorderSpacing, BorderStyle};
 pub use self::box_::{AnimationIterationCount, AnimationName, Contain, Display};
-pub use self::box_::{Appearance, BreakBetween, BreakWithin, Clear, Float};
+pub use self::box_::{Appearance, BreakBetween, BreakWithin, Clear, Float, Overflow};
 pub use self::box_::{OverflowClipBox, OverscrollBehavior, Perspective, Resize};
 pub use self::box_::{ScrollSnapType, TouchAction, TransitionProperty, VerticalAlign, WillChange};
 pub use self::color::{Color, ColorPropertyValue, RGBAColor};

From a519d9ecc3ba4193147529d923b09946d4c843fd Mon Sep 17 00:00:00 2001
From: Boris Zbarsky <bzbarsky@mit.edu>
Date: Mon, 10 Dec 2018 22:24:49 +0000
Subject: [PATCH 04/11] style: Add support for 's' flag on attribute selectors.

We could keep using ParsedCaseSensitivity::CaseSensitive as a temporary stand-in
for "case-sensitive or maybe not depending on what HTML says" until we check the
attribute list, but it seems better to make that explicit.

Differential Revision: https://phabricator.services.mozilla.com/D14093
---
 components/selectors/attr.rs   | 12 ++++-
 components/selectors/parser.rs | 86 +++++++++++++++++++++++++---------
 2 files changed, 73 insertions(+), 25 deletions(-)

diff --git a/components/selectors/attr.rs b/components/selectors/attr.rs
index 38612f57b64..35e678946f9 100644
--- a/components/selectors/attr.rs
+++ b/components/selectors/attr.rs
@@ -134,8 +134,13 @@ pub static SELECTOR_WHITESPACE: &'static [char] = &[' ', '\t', '\n', '\r', '\x0C
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum ParsedCaseSensitivity {
-    CaseSensitive,
+    // 's' was specified.
+    ExplicitCaseSensitive,
+    // 'i' was specified.
     AsciiCaseInsensitive,
+    // No flags were specified and HTML says this is a case-sensitive attribute.
+    CaseSensitive,
+    // No flags were specified and HTML says this is a case-insensitive attribute.
     AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument,
 }
 
@@ -150,7 +155,10 @@ impl ParsedCaseSensitivity {
             ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {
                 CaseSensitivity::CaseSensitive
             },
-            ParsedCaseSensitivity::CaseSensitive => CaseSensitivity::CaseSensitive,
+            ParsedCaseSensitivity::CaseSensitive |
+            ParsedCaseSensitivity::ExplicitCaseSensitive => {
+                CaseSensitivity::CaseSensitive
+            },
             ParsedCaseSensitivity::AsciiCaseInsensitive => CaseSensitivity::AsciiCaseInsensitive,
         }
     }
diff --git a/components/selectors/parser.rs b/components/selectors/parser.rs
index e8e98dbe38e..01dcfdd99d1 100644
--- a/components/selectors/parser.rs
+++ b/components/selectors/parser.rs
@@ -1223,6 +1223,7 @@ impl<Impl: SelectorImpl> ToCss for Component<Impl> {
                     ParsedCaseSensitivity::CaseSensitive |
                     ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {},
                     ParsedCaseSensitivity::AsciiCaseInsensitive => dest.write_str(" i")?,
+                    ParsedCaseSensitivity::ExplicitCaseSensitive => dest.write_str(" s")?,
                 }
                 dest.write_char(']')
             },
@@ -1301,6 +1302,7 @@ impl<Impl: SelectorImpl> ToCss for AttrSelectorWithOptionalNamespace<Impl> {
                     ParsedCaseSensitivity::CaseSensitive |
                     ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {},
                     ParsedCaseSensitivity::AsciiCaseInsensitive => dest.write_str(" i")?,
+                    ParsedCaseSensitivity::ExplicitCaseSensitive => dest.write_str(" i")?,
                 }
             },
         }
@@ -1711,24 +1713,15 @@ where
         AttrSelectorOperator::Suffix => value.is_empty(),
     };
 
-    let mut case_sensitivity = parse_attribute_flags(input)?;
+    let attribute_flags = parse_attribute_flags(input)?;
 
     let value = value.as_ref().into();
     let local_name_lower;
     let local_name_is_ascii_lowercase;
+    let case_sensitivity;
     {
         let local_name_lower_cow = to_ascii_lowercase(&local_name);
-        if let ParsedCaseSensitivity::CaseSensitive = case_sensitivity {
-            if namespace.is_none() && include!(concat!(
-                env!("OUT_DIR"),
-                "/ascii_case_insensitive_html_attributes.rs"
-            ))
-            .contains(&*local_name_lower_cow)
-            {
-                case_sensitivity =
-                    ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument
-            }
-        }
+        case_sensitivity = attribute_flags.to_case_sensitivity(local_name_lower_cow.as_ref(), namespace.is_some());
         local_name_lower = local_name_lower_cow.as_ref().into();
         local_name_is_ascii_lowercase = matches!(local_name_lower_cow, Cow::Borrowed(..));
     }
@@ -1758,20 +1751,67 @@ where
     }
 }
 
+/// An attribute selector can have 's' or 'i' as flags, or no flags at all.
+enum AttributeFlags {
+    // Matching should be case-sensitive ('s' flag).
+    CaseSensitive,
+    // Matching should be case-insensitive ('i' flag).
+    AsciiCaseInsensitive,
+    // No flags.  Matching behavior depends on the name of the attribute.
+    CaseSensitivityDependsOnName
+}
+
+impl AttributeFlags {
+    fn to_case_sensitivity(
+        self,
+        local_name: &str,
+        have_namespace: bool,
+    ) -> ParsedCaseSensitivity {
+        match self {
+            AttributeFlags::CaseSensitive =>
+                ParsedCaseSensitivity::ExplicitCaseSensitive,
+            AttributeFlags::AsciiCaseInsensitive =>
+                ParsedCaseSensitivity::AsciiCaseInsensitive,
+            AttributeFlags::CaseSensitivityDependsOnName => {
+                if !have_namespace && include!(concat!(
+                    env!("OUT_DIR"),
+                    "/ascii_case_insensitive_html_attributes.rs"
+                ))
+                    .contains(local_name)
+                {
+                    ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument
+                } else {
+                    ParsedCaseSensitivity::CaseSensitive
+                }
+            }
+        }
+    }
+}
+
 fn parse_attribute_flags<'i, 't>(
     input: &mut CssParser<'i, 't>,
-) -> Result<ParsedCaseSensitivity, BasicParseError<'i>> {
+) -> Result<AttributeFlags, BasicParseError<'i>> {
     let location = input.current_source_location();
-    match input.next() {
-        Err(_) => {
-            // Selectors spec says language-defined, but HTML says sensitive.
-            Ok(ParsedCaseSensitivity::CaseSensitive)
-        },
-        Ok(&Token::Ident(ref value)) if value.eq_ignore_ascii_case("i") => {
-            Ok(ParsedCaseSensitivity::AsciiCaseInsensitive)
-        },
-        Ok(t) => Err(location.new_basic_unexpected_token_error(t.clone())),
-    }
+    let token = match input.next() {
+        Ok(t) => t,
+        Err(..) => {
+            // Selectors spec says language-defined; HTML says it depends on the
+            // exact attribute name.
+            return Ok(AttributeFlags::CaseSensitivityDependsOnName);
+        }
+    };
+
+    let ident = match *token {
+        Token::Ident(ref i) => i,
+        ref other => return Err(location.new_basic_unexpected_token_error(other.clone())),
+    };
+
+    Ok(match_ignore_ascii_case! {
+        ident,
+        "i" => AttributeFlags::AsciiCaseInsensitive,
+        "s" => AttributeFlags::CaseSensitive,
+        _ => return Err(location.new_basic_unexpected_token_error(token.clone())),
+    })
 }
 
 /// Level 3: Parse **one** simple_selector.  (Though we might insert a second

From 7f5a9e0f4589e49369ca1abaac562fdcc69faa36 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Thu, 13 Dec 2018 02:17:53 +0000
Subject: [PATCH 05/11] style: Handle nested slots correctly in slotted
 matching and invalidation.

The patch and test should be pretty much self-descriptive.

Differential Revision: https://phabricator.services.mozilla.com/D14063
---
 components/selectors/matching.rs              | 26 ++++++++++++++--
 components/selectors/tree.rs                  |  5 ++-
 .../style/invalidation/element/invalidator.rs | 31 ++++++++++++-------
 3 files changed, 45 insertions(+), 17 deletions(-)

diff --git a/components/selectors/matching.rs b/components/selectors/matching.rs
index d8d083d7b28..8a9a2790f52 100644
--- a/components/selectors/matching.rs
+++ b/components/selectors/matching.rs
@@ -410,6 +410,7 @@ fn next_element_for_combinator<E>(
     element: &E,
     combinator: Combinator,
     selector: &SelectorIter<E::Impl>,
+    context: &MatchingContext<E::Impl>,
 ) -> Option<E>
 where
     E: Element,
@@ -449,12 +450,21 @@ where
             element.containing_shadow_host()
         },
         Combinator::SlotAssignment => {
+            debug_assert!(
+                context.current_host.is_some(),
+                "Should not be trying to match slotted rules in a non-shadow-tree context"
+            );
             debug_assert!(
                 element
                     .assigned_slot()
                     .map_or(true, |s| s.is_html_slot_element())
             );
-            element.assigned_slot()
+            let scope = context.current_host?;
+            let mut current_slot = element.assigned_slot()?;
+            while current_slot.containing_shadow_host().unwrap().opaque() != scope {
+                current_slot = current_slot.assigned_slot()?;
+            }
+            Some(current_slot)
         },
         Combinator::PseudoElement => element.pseudo_element_originating_element(),
     }
@@ -511,7 +521,12 @@ where
         Combinator::PseudoElement => SelectorMatchingResult::NotMatchedGlobally,
     };
 
-    let mut next_element = next_element_for_combinator(element, combinator, &selector_iter);
+    let mut next_element = next_element_for_combinator(
+        element,
+        combinator,
+        &selector_iter,
+        &context,
+    );
 
     // Stop matching :visited as soon as we find a link, or a combinator for
     // something that isn't an ancestor.
@@ -575,7 +590,12 @@ where
             visited_handling = VisitedHandlingMode::AllLinksUnvisited;
         }
 
-        next_element = next_element_for_combinator(&element, combinator, &selector_iter);
+        next_element = next_element_for_combinator(
+            &element,
+            combinator,
+            &selector_iter,
+            &context,
+        );
     }
 }
 
diff --git a/components/selectors/tree.rs b/components/selectors/tree.rs
index 9e606ab9124..6d8c5fcd25f 100644
--- a/components/selectors/tree.rs
+++ b/components/selectors/tree.rs
@@ -11,9 +11,8 @@ use crate::parser::SelectorImpl;
 use std::fmt::Debug;
 use std::ptr::NonNull;
 
-/// Opaque representation of an Element, for identity comparisons. We use
-/// NonZeroPtrMut to get the NonZero optimization.
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+/// Opaque representation of an Element, for identity comparisons.
+#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
 pub struct OpaqueElement(NonNull<()>);
 
 unsafe impl Send for OpaqueElement {}
diff --git a/components/style/invalidation/element/invalidator.rs b/components/style/invalidation/element/invalidator.rs
index fdcdff1b69f..4640c7c0442 100644
--- a/components/style/invalidation/element/invalidator.rs
+++ b/components/style/invalidation/element/invalidator.rs
@@ -471,25 +471,34 @@ where
             return false;
         }
 
+        let slot = self.element;
+        self.invalidate_slotted_elements_in_slot(slot, invalidations)
+    }
+
+    fn invalidate_slotted_elements_in_slot(
+        &mut self,
+        slot: E,
+        invalidations: &[Invalidation<'b>],
+    ) -> bool {
         let mut any = false;
 
         let mut sibling_invalidations = InvalidationVector::new();
-        let element = self.element;
-        for node in element.slotted_nodes() {
+        for node in slot.slotted_nodes() {
             let element = match node.as_element() {
                 Some(e) => e,
                 None => continue,
             };
 
-            any |= self.invalidate_child(
-                element,
-                invalidations,
-                &mut sibling_invalidations,
-                DescendantInvalidationKind::Slotted,
-            );
-
-            // FIXME(emilio): Need to handle nested slotted nodes if `element`
-            // is itself a <slot>.
+            if element.is_html_slot_element() {
+                any |= self.invalidate_slotted_elements_in_slot(element, invalidations);
+            } else {
+                any |= self.invalidate_child(
+                    element,
+                    invalidations,
+                    &mut sibling_invalidations,
+                    DescendantInvalidationKind::Slotted,
+                );
+            }
 
             debug_assert!(
                 sibling_invalidations.is_empty(),

From 3d78025e10164722d0460b1861e008fb56ba4570 Mon Sep 17 00:00:00 2001
From: Boris Zbarsky <bzbarsky@mit.edu>
Date: Thu, 13 Dec 2018 23:25:08 +0000
Subject: [PATCH 06/11] style: Fix serialization of explicitly case-sensitive
 attr selectors with a namespace.

Differential Revision: https://phabricator.services.mozilla.com/D14493
---
 components/selectors/parser.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/selectors/parser.rs b/components/selectors/parser.rs
index 01dcfdd99d1..d88d6f38aa5 100644
--- a/components/selectors/parser.rs
+++ b/components/selectors/parser.rs
@@ -1302,7 +1302,7 @@ impl<Impl: SelectorImpl> ToCss for AttrSelectorWithOptionalNamespace<Impl> {
                     ParsedCaseSensitivity::CaseSensitive |
                     ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {},
                     ParsedCaseSensitivity::AsciiCaseInsensitive => dest.write_str(" i")?,
-                    ParsedCaseSensitivity::ExplicitCaseSensitive => dest.write_str(" i")?,
+                    ParsedCaseSensitivity::ExplicitCaseSensitive => dest.write_str(" s")?,
                 }
             },
         }

From ee6bf986757b564b10a570410c36ae2c5e2257e0 Mon Sep 17 00:00:00 2001
From: Daniel Holbert <dholbert@cs.stanford.edu>
Date: Fri, 14 Dec 2018 21:24:17 +0000
Subject: [PATCH 07/11] style: Include the 'unsafe' keyword in serializations
 of css-align properties.

Previously we'd omit it since it was merely an explicit way of requesting the
default behavior.  But the spec has changed such that it's not necessarily
equivalent to the default anymore:
https://drafts.csswg.org/css-align/#overflow-values

(Technically the behaviors are probably still equivalent in our implementation,
pending bug 1451380, but we don't have to publicize that via our
serialization.)

Differential Revision: https://phabricator.services.mozilla.com/D14599
---
 components/style/values/specified/align.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/components/style/values/specified/align.rs b/components/style/values/specified/align.rs
index 4cf68c9b4c6..befeaa2ee6f 100644
--- a/components/style/values/specified/align.rs
+++ b/components/style/values/specified/align.rs
@@ -92,8 +92,7 @@ impl ToCss for AlignFlags {
                 dest.write_char(' ')?;
             },
             AlignFlags::SAFE => dest.write_str("safe ")?,
-            // Don't serialize "unsafe", since it's the default.
-            AlignFlags::UNSAFE => {},
+            AlignFlags::UNSAFE => dest.write_str("unsafe ")?,
             _ => {
                 debug_assert_eq!(extra_flags, AlignFlags::empty());
             },

From 27322abeda5c3b533c1051be1004db1ac3ac1cf2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 3 Dec 2018 08:08:34 -0500
Subject: [PATCH 08/11] style: Minor build fixup after the Servo
 crossbeam_channel update.

---
 components/style/animation.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/style/animation.rs b/components/style/animation.rs
index c10663e99f7..6fac559a777 100644
--- a/components/style/animation.rs
+++ b/components/style/animation.rs
@@ -25,6 +25,7 @@ use crate::values::computed::TimingFunction;
 use crate::values::generics::box_::AnimationIterationCount;
 use crate::values::generics::easing::{StepPosition, TimingFunction as GenericTimingFunction};
 use crate::Atom;
+#[cfg(feature = "servo")]
 use crossbeam_channel::Sender;
 use servo_arc::Arc;
 use std::fmt;

From 28719f24558c1da86343a866883c08305c289412 Mon Sep 17 00:00:00 2001
From: Olli Pettay <Olli.Pettay@helsinki.fi>
Date: Thu, 6 Dec 2018 15:58:40 +0200
Subject: [PATCH 09/11] Move FragmentOrElement::mAttrs to Element.

Bug: 1512256
Reviewed-by: ehsan
---
 components/style/gecko/wrapper.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/style/gecko/wrapper.rs b/components/style/gecko/wrapper.rs
index 9373f0bb2fa..ca991b412d6 100644
--- a/components/style/gecko/wrapper.rs
+++ b/components/style/gecko/wrapper.rs
@@ -581,7 +581,7 @@ impl<'le> GeckoElement<'le> {
     #[inline(always)]
     fn attrs(&self) -> &[structs::AttrArray_InternalAttr] {
         unsafe {
-            let attrs = match self.0._base.mAttrs.mImpl.mPtr.as_ref() {
+            let attrs = match self.0.mAttrs.mImpl.mPtr.as_ref() {
                 Some(attrs) => attrs,
                 None => return &[],
             };

From 273705d7fbe1618258c238d733ac24b6f3370809 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Sat, 15 Dec 2018 03:50:09 +0100
Subject: [PATCH 10/11] style: Fix tidy issues.

---
 components/malloc_size_of/lib.rs        |  4 ++--
 components/selectors/attr.rs            |  3 +--
 components/selectors/matching.rs        | 15 +++------------
 components/selectors/parser.rs          | 23 +++++++++--------------
 components/selectors/tree.rs            |  2 +-
 components/style/values/computed/mod.rs |  2 +-
 6 files changed, 17 insertions(+), 32 deletions(-)

diff --git a/components/malloc_size_of/lib.rs b/components/malloc_size_of/lib.rs
index ddd7b5f2dad..fe988e78f6c 100644
--- a/components/malloc_size_of/lib.rs
+++ b/components/malloc_size_of/lib.rs
@@ -472,7 +472,7 @@ macro_rules! malloc_size_of_hash_set {
                 n
             }
         }
-    }
+    };
 }
 
 malloc_size_of_hash_set!(std::collections::HashSet<T, S>);
@@ -513,7 +513,7 @@ macro_rules! malloc_size_of_hash_map {
                 n
             }
         }
-    }
+    };
 }
 
 malloc_size_of_hash_map!(std::collections::HashMap<K, V, S>);
diff --git a/components/selectors/attr.rs b/components/selectors/attr.rs
index 35e678946f9..36d31e11345 100644
--- a/components/selectors/attr.rs
+++ b/components/selectors/attr.rs
@@ -155,8 +155,7 @@ impl ParsedCaseSensitivity {
             ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {
                 CaseSensitivity::CaseSensitive
             },
-            ParsedCaseSensitivity::CaseSensitive |
-            ParsedCaseSensitivity::ExplicitCaseSensitive => {
+            ParsedCaseSensitivity::CaseSensitive | ParsedCaseSensitivity::ExplicitCaseSensitive => {
                 CaseSensitivity::CaseSensitive
             },
             ParsedCaseSensitivity::AsciiCaseInsensitive => CaseSensitivity::AsciiCaseInsensitive,
diff --git a/components/selectors/matching.rs b/components/selectors/matching.rs
index 8a9a2790f52..7c509e8e673 100644
--- a/components/selectors/matching.rs
+++ b/components/selectors/matching.rs
@@ -521,12 +521,8 @@ where
         Combinator::PseudoElement => SelectorMatchingResult::NotMatchedGlobally,
     };
 
-    let mut next_element = next_element_for_combinator(
-        element,
-        combinator,
-        &selector_iter,
-        &context,
-    );
+    let mut next_element =
+        next_element_for_combinator(element, combinator, &selector_iter, &context);
 
     // Stop matching :visited as soon as we find a link, or a combinator for
     // something that isn't an ancestor.
@@ -590,12 +586,7 @@ where
             visited_handling = VisitedHandlingMode::AllLinksUnvisited;
         }
 
-        next_element = next_element_for_combinator(
-            &element,
-            combinator,
-            &selector_iter,
-            &context,
-        );
+        next_element = next_element_for_combinator(&element, combinator, &selector_iter, &context);
     }
 }
 
diff --git a/components/selectors/parser.rs b/components/selectors/parser.rs
index d88d6f38aa5..4dda76d3200 100644
--- a/components/selectors/parser.rs
+++ b/components/selectors/parser.rs
@@ -1721,7 +1721,8 @@ where
     let case_sensitivity;
     {
         let local_name_lower_cow = to_ascii_lowercase(&local_name);
-        case_sensitivity = attribute_flags.to_case_sensitivity(local_name_lower_cow.as_ref(), namespace.is_some());
+        case_sensitivity =
+            attribute_flags.to_case_sensitivity(local_name_lower_cow.as_ref(), namespace.is_some());
         local_name_lower = local_name_lower_cow.as_ref().into();
         local_name_is_ascii_lowercase = matches!(local_name_lower_cow, Cow::Borrowed(..));
     }
@@ -1758,32 +1759,26 @@ enum AttributeFlags {
     // Matching should be case-insensitive ('i' flag).
     AsciiCaseInsensitive,
     // No flags.  Matching behavior depends on the name of the attribute.
-    CaseSensitivityDependsOnName
+    CaseSensitivityDependsOnName,
 }
 
 impl AttributeFlags {
-    fn to_case_sensitivity(
-        self,
-        local_name: &str,
-        have_namespace: bool,
-    ) -> ParsedCaseSensitivity {
+    fn to_case_sensitivity(self, local_name: &str, have_namespace: bool) -> ParsedCaseSensitivity {
         match self {
-            AttributeFlags::CaseSensitive =>
-                ParsedCaseSensitivity::ExplicitCaseSensitive,
-            AttributeFlags::AsciiCaseInsensitive =>
-                ParsedCaseSensitivity::AsciiCaseInsensitive,
+            AttributeFlags::CaseSensitive => ParsedCaseSensitivity::ExplicitCaseSensitive,
+            AttributeFlags::AsciiCaseInsensitive => ParsedCaseSensitivity::AsciiCaseInsensitive,
             AttributeFlags::CaseSensitivityDependsOnName => {
                 if !have_namespace && include!(concat!(
                     env!("OUT_DIR"),
                     "/ascii_case_insensitive_html_attributes.rs"
                 ))
-                    .contains(local_name)
+                .contains(local_name)
                 {
                     ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument
                 } else {
                     ParsedCaseSensitivity::CaseSensitive
                 }
-            }
+            },
         }
     }
 }
@@ -1798,7 +1793,7 @@ fn parse_attribute_flags<'i, 't>(
             // Selectors spec says language-defined; HTML says it depends on the
             // exact attribute name.
             return Ok(AttributeFlags::CaseSensitivityDependsOnName);
-        }
+        },
     };
 
     let ident = match *token {
diff --git a/components/selectors/tree.rs b/components/selectors/tree.rs
index 6d8c5fcd25f..badfca86ed6 100644
--- a/components/selectors/tree.rs
+++ b/components/selectors/tree.rs
@@ -12,7 +12,7 @@ use std::fmt::Debug;
 use std::ptr::NonNull;
 
 /// Opaque representation of an Element, for identity comparisons.
-#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub struct OpaqueElement(NonNull<()>);
 
 unsafe impl Send for OpaqueElement {}
diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs
index 8e135b52caa..93ee3e73cc1 100644
--- a/components/style/values/computed/mod.rs
+++ b/components/style/values/computed/mod.rs
@@ -43,7 +43,7 @@ pub use self::border::{BorderImageRepeat, BorderImageSideWidth};
 pub use self::border::{BorderImageSlice, BorderImageWidth};
 pub use self::box_::{AnimationIterationCount, AnimationName, Contain};
 pub use self::box_::{Appearance, BreakBetween, BreakWithin, Clear, Float};
-pub use self::box_::{Display, TransitionProperty, Overflow};
+pub use self::box_::{Display, Overflow, TransitionProperty};
 pub use self::box_::{OverflowClipBox, OverscrollBehavior, Perspective, Resize};
 pub use self::box_::{ScrollSnapType, TouchAction, VerticalAlign, WillChange};
 pub use self::color::{Color, ColorPropertyValue, RGBAColor};

From 0d9f4659b826931bf800d1bc1808b7badb10d66d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Sat, 15 Dec 2018 16:51:27 +0100
Subject: [PATCH 11/11] Update test expectations.

---
 .../attribute-case/cssom.html.ini             |   97 --
 .../attribute-case/semantics.html.ini         | 1333 -----------------
 .../attribute-case/syntax.html.ini            |  433 ------
 3 files changed, 1863 deletions(-)
 delete mode 100644 tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/cssom.html.ini
 delete mode 100644 tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/semantics.html.ini
 delete mode 100644 tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/syntax.html.ini

diff --git a/tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/cssom.html.ini b/tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/cssom.html.ini
deleted file mode 100644
index 63cd6bde7aa..00000000000
--- a/tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/cssom.html.ini
+++ /dev/null
@@ -1,97 +0,0 @@
-[cssom.html]
-  [[foo="bar" s\] getting CSSStyleRule#selectorText]
-    expected: FAIL
-
-  [[foo="bar" /**/ s\] setting CSSStyleRule#selectorText]
-    expected: FAIL
-
-  [[foo="bar" s\] getting CSSStyleRule#selectorText in @media]
-    expected: FAIL
-
-  [[foo="bar" s\] getting CSSRule#cssText]
-    expected: FAIL
-
-  [[foo="bar" /**/ s\] getting CSSStyleRule#selectorText in @media]
-    expected: FAIL
-
-  [[foo="bar" s\] insertRule in @media]
-    expected: FAIL
-
-  [[foo="bar"/**/s\] insertRule in @media]
-    expected: FAIL
-
-  [[foo="bar"/**/s\] getting CSSStyleRule#selectorText]
-    expected: FAIL
-
-  [[foo="bar"/**/s\] getting CSSRule#cssText]
-    expected: FAIL
-
-  [[foo="bar" /**/ s\] setting CSSStyleRule#selectorText in @media]
-    expected: FAIL
-
-  [[foo="bar"/**/s\] setting CSSStyleRule#selectorText]
-    expected: FAIL
-
-  [[foo="bar" /**/ s\] getting CSSStyleRule#selectorText]
-    expected: FAIL
-
-  [[foo="bar" /**/ s\] getting CSSRule#cssText]
-    expected: FAIL
-
-  [[foo="bar" s\] setting CSSStyleRule#selectorText in @media]
-    expected: FAIL
-
-  [[foo="bar" s\] setting CSSStyleRule#selectorText]
-    expected: FAIL
-
-  [[foo="bar" s\] insertRule]
-    expected: FAIL
-
-  [[foo="bar" /**/ s\] getting CSSRule#cssText in @media]
-    expected: FAIL
-
-  [[foo="bar" /**/ s\] insertRule]
-    expected: FAIL
-
-  [[foo="bar"/**/s\] getting CSSRule#cssText in @media]
-    expected: FAIL
-
-  [[foo="bar" s\] getting CSSRule#cssText in @media]
-    expected: FAIL
-
-  [[foo="bar"/**/s\] insertRule]
-    expected: FAIL
-
-  [[foo="bar" /**/ s\] insertRule in @media]
-    expected: FAIL
-
-  [[foo="bar"/**/s\] getting CSSStyleRule#selectorText in @media]
-    expected: FAIL
-
-  [[foo="bar"/**/s\] setting CSSStyleRule#selectorText in @media]
-    expected: FAIL
-
-  [[*|foo="bar" s\] getting CSSStyleRule#selectorText]
-    expected: FAIL
-
-  [[*|foo="bar" s\] getting CSSRule#cssText in @media]
-    expected: FAIL
-
-  [[*|foo="bar" s\] insertRule in @media]
-    expected: FAIL
-
-  [[*|foo="bar" s\] getting CSSRule#cssText]
-    expected: FAIL
-
-  [[*|foo="bar" s\] insertRule]
-    expected: FAIL
-
-  [[*|foo="bar" s\] getting CSSStyleRule#selectorText in @media]
-    expected: FAIL
-
-  [[*|foo="bar" s\] setting CSSStyleRule#selectorText]
-    expected: FAIL
-
-  [[*|foo="bar" s\] setting CSSStyleRule#selectorText in @media]
-    expected: FAIL
-
diff --git a/tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/semantics.html.ini b/tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/semantics.html.ini
deleted file mode 100644
index b46375f354a..00000000000
--- a/tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/semantics.html.ini
+++ /dev/null
@@ -1,1333 +0,0 @@
-[semantics.html]
-  [[foo|='ä' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="xab"> in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="Ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="Ä"> in XML]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="bar" {c}foo="x"> in XML]
-    expected: FAIL
-
-  [[foo=' ' s\] /* tab in attribute */ <div foo="\t"> in standards mode]
-    expected: FAIL
-
-  [[foo^='Ä' s\] /* COMBINING in selector */ <div foo="Ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="Ä"> in standards mode]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="X A B"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> in standards mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="a-b"> in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="a"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] <div foo="ä"> in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="İ"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="X A B"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo^='Ä' s\] /* COMBINING in selector */ <div foo="Ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="ä"> in quirks mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="A-B"> in standards mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="İ"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="bar" {a}foo="x" {b}foo="x" {c}foo="x"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="I"> in quirks mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="ı"> in standards mode]
-    expected: FAIL
-
-  [@namespace x 'A'; [x|foo='' s\] <div {a}foo=""> in XML]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="ı"> in quirks mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="ı"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="i"> in standards mode]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="X A B"> in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div FOO="bar"> in standards mode]
-    expected: FAIL
-
-  [[foo*='ä' s\] /* COMBINING in attribute */ <div foo="ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo^='Ä' s\] /* COMBINING in selector */ <div foo="Ä"> in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="A"> in XML]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar'\] <div foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="BAR"> in XML]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo|='ä' s\] /* COMBINING in attribute */ <div foo="Ä"> in XML]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar' s\] <div foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="X A B"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo*='ä' s\] /* COMBINING in attribute */ <div foo="ä"> in XML]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="a-b"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="I"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="ı"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="xa"> with querySelector in standards mode]
-    expected: FAIL
-
-  [@namespace x 'http://www.w3.org/XML/1998/namespace'; [x|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> in standards mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="bar" {c}foo="x"> in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="a"> in XML]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='BAR' s\] <div foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="LEFT"> in standards mode]
-    expected: FAIL
-
-  [[foo=' ' s\] /* tab in attribute */ <div foo="\t"> with querySelector in XML]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="left"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="BAR" {a}foo="x" {b}foo="x" {c}foo="x"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo=' ' s\] /* tab in attribute */ <div foo="\t"> in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="Ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="i"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="BAR" {a}foo="x" {b}foo="x" {c}foo="x"> in standards mode]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="X A B"> in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] <div foo="ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='bar'\] <div foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo|='ä' s\] /* COMBINING in attribute */ <div foo="Ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="i"> in quirks mode]
-    expected: FAIL
-
-  [[foo='' s\] <div foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="BAR" {a}foo="x" {b}foo="x" {c}foo="x"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar' s\] <div foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo$='Ä' s\] /* COMBINING in selector */ <div foo="ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="Ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] <div foo="Ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo*='ä' s\] /* COMBINING in attribute */ <div foo="ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="I"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="İ"> in standards mode]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="Ä"> in quirks mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='BAR'\] <div foo="bar"> in standards mode]
-    expected: FAIL
-
-  [[foo='\x00' s\] /* \\0 in selector */ <div foo=""> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='BAR'\] <div foo="bar"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar'\] <div foo="BAR"> in XML]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="x a b"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [[foo='BAR'\][foo='bar' s\] <div foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div baz="BAR"> in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="A"> in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="Ä"> in XML]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="x a b"> in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] <div foo="ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='BAR' s\] <div foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [[foo='\t' s\] /* tab in selector */ <div foo=" "> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> with querySelector in XML]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="left"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='' s\] <div foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="xa"> in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div baz="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[foo='BAR'\][foo='bar' s\] <div foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[align='left' s\] <div align="LEFT"> in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="A"> in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="ä"> in XML]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="x a b"> in quirks mode]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="left"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar' s\] <div foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in both */ <div foo="ä"> in XML]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> in standards mode]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="İ"> in XML]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="i"> in standards mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="A-B"> in quirks mode]
-    expected: FAIL
-
-  [@namespace x 'http://www.w3.org/XML/1998/namespace'; [x|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> in quirks mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="a"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="I"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='BAR'\] <div foo="bar"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="bar"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar' s\] <div foo="BAR"> in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in both */ <div foo="ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='BAR'\] <div foo="bar"> in quirks mode]
-    expected: FAIL
-
-  [[foo='bar'\][foo='BAR' s\] <div foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="I"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] <div foo="Ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo^='Ä' s\] /* COMBINING in selector */ <div foo="Ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="Ä"> in XML]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="bar" {c}foo="x"> with querySelector in XML]
-    expected: FAIL
-
-  [[align='left' s\] <div align="left"> in standards mode]
-    expected: FAIL
-
-  [[foo='' s\] <div foo=""> in XML]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="I"> in XML]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> in standards mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="XAB"> in XML]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="BAR" {c}foo="x"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="XAB"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="x" {a}foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="i"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="İ"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="I"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='BAR'\] <div foo="bar"> in XML]
-    expected: FAIL
-
-  [[foo='' s\] <div foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="ı"> in standards mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="A-B"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='BAR'\] <div foo="bar"> with querySelector in XML]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="AB"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="xa"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="XA"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="Ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="ab"> in XML]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="ab"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='bar'\][foo='BAR' s\] <div foo="BAR"> in XML]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="xab"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="xab"> in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="BAR" {a}foo="x" {b}foo="x" {c}foo="x"> in XML]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="I"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar'\] <div foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo=' ' s\] /* tab in attribute */ <div foo="\t"> in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='\t' s\] /* tab in selector */ <div foo=" "> in quirks mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="A-B"> in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar' s\] <div foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='BAR'\][foo='bar' s\] <div foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] <div foo="ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] <div foo="ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> in XML]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo*='ä' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="ä"> in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="x" {a}foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="A"> in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] <div foo="Ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in both */ <div foo="ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="XA"> in quirks mode]
-    expected: FAIL
-
-  [@namespace x 'http://www.w3.org/XML/1998/namespace'; [x|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> in standards mode]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="X A B"> in XML]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="X A B"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="i"> in quirks mode]
-    expected: FAIL
-
-  [[foo='\x00' s\] /* \\0 in selector */ <div foo=""> in XML]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="ı"> with querySelector in XML]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="XA"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="İ"> in standards mode]
-    expected: FAIL
-
-  [[align='left' s\] <div align="left"> in XML]
-    expected: FAIL
-
-  [[foo='' s\] <div foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[|foo='bar' s\] <div foo="x" {a}foo="BAR"> in XML]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="bar" {a}foo="x" {b}foo="x" {c}foo="x"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo~='ä' s\] /* COMBINING in selector */ <div foo="ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="A"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='bar'\] <div foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo|='ä' s\] /* COMBINING in attribute */ <div foo="Ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='BAR'\][foo='bar' s\] <div foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in both */ <div foo="ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='\x00' s\] /* \\0 in selector */ <div foo=""> with querySelector in XML]
-    expected: FAIL
-
-  [@namespace x 'A'; [x|foo='' s\] <div {a}foo=""> in quirks mode]
-    expected: FAIL
-
-  [[foo='bar'\][foo='BAR' s\] <div foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo=' ' s\] /* tab in attribute */ <div foo="\t"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="x" {a}foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="I"> in XML]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="X A B"> in XML]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> in XML]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="i"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="a"> in quirks mode]
-    expected: FAIL
-
-  [[foo|='ä' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo=' ' s\] /* tab in attribute */ <div foo="\t"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="BAR" {c}foo="x"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='BAR'\][foo='bar' s\] <div foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[foo='\x00' s\] /* \\0 in selector */ <div foo=""> in quirks mode]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="Ä"> in standards mode]
-    expected: FAIL
-
-  [@namespace x 'A'; [x|foo='' s\] <div {a}foo=""> in standards mode]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='' s\] <div foo=""> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo|='ä' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar'\] <div foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="XAB"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="Ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="xa"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo*='ä' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="ä"> in XML]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="ab"> in quirks mode]
-    expected: FAIL
-
-  [@namespace x 'a'; [x|foo='' s\] <div {A}foo=""> in standards mode]
-    expected: FAIL
-
-  [[foo='bar'\][foo='BAR' s\] <div foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="Ä"> in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="bar" {c}foo="x"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='\t' s\] /* tab in selector */ <div foo=" "> in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo^='Ä' s\] /* COMBINING in selector */ <div foo="Ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='' s\] <div foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="İ"> with querySelector in XML]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="a-b"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [@namespace x 'http://www.w3.org/XML/1998/namespace'; [x|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> in quirks mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="a-b"> in XML]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="xab"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo$='Ä' s\] /* COMBINING in selector */ <div foo="ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='' s\] <div foo=""> in standards mode]
-    expected: FAIL
-
-  [[align='left' s\] <div align="left"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="bar"> in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="A"> in quirks mode]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="XAB"> in standards mode]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='bar'\] <div foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo$='Ä' s\] /* COMBINING in selector */ <div foo="ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="BAR" {c}foo="x"> in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="bar"> in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="A"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="X A B"> in standards mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="İ"> in quirks mode]
-    expected: FAIL
-
-  [[foo~='ä' s\] /* COMBINING in selector */ <div foo="ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="Ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="İ"> in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="left"> in XML]
-    expected: FAIL
-
-  [[foo='' s\] <div foo=""> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="i"> with querySelector in XML]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="AB"> in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="a"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="bar" {a}foo="x" {b}foo="x" {c}foo="x"> in standards mode]
-    expected: FAIL
-
-  [[|foo='bar' s\] <div foo="x" {a}foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="ı"> in XML]
-    expected: FAIL
-
-  [[|foo='bar' s\] <div foo="x" {a}foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [[align='left' s\] <div align="LEFT"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="bar"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="x a b"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar'\][foo='BAR' s\] <div foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="left"> in quirks mode]
-    expected: FAIL
-
-  [[foo='' s\] /* \\0 in attribute */ <div foo="\x00"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="a"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="ä"> in standards mode]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="xa"> in quirks mode]
-    expected: FAIL
-
-  [[align='left' s\] <div align="left"> in quirks mode]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="İ"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='bar'\][foo='BAR' s\] <div foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="i"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='BAR' s\] <div foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="ı"> in quirks mode]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="LEFT"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[align='left' s\] <div align="LEFT"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo~='ä' s\] /* COMBINING in selector */ <div foo="ä"> in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="bar"> in standards mode]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="X A B"> with querySelector in XML]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="LEFT"> in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="bar"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="i"> in XML]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="XAB"> in quirks mode]
-    expected: FAIL
-
-  [[foo='' s\] <div foo=""> in quirks mode]
-    expected: FAIL
-
-  [[|foo='bar' s\] <div foo="x" {a}foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] <div foo="Ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="Ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="ı"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='' s\] /* \\0 in attribute */ <div foo="\x00"> in XML]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="İ"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="Ä"> in quirks mode]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="AB"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='BAR' s\] <div foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="x" {a}foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="AB"> in quirks mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="a-b"> in quirks mode]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> in standards mode]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='BAR' s\] <div foo="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div FOO="bar"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='bar'\] <div foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="a-b"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="A"> with querySelector in XML]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="x a b"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='BAR'\][foo='bar' s\] <div foo="BAR"> in XML]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="ab"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='' s\] /* \\0 in attribute */ <div foo="\x00"> in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="A"> with querySelector in standards mode]
-    expected: FAIL
-
-  [@namespace x 'http://www.w3.org/XML/1998/namespace'; [x|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> in XML]
-    expected: FAIL
-
-  [[foo$='Ä' s\] /* COMBINING in selector */ <div foo="ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in attribute */ <div foo="Ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo*='ä' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo~='ä' s\] /* COMBINING in selector */ <div foo="ä"> in quirks mode]
-    expected: FAIL
-
-  [[align='left' s\] <div align="LEFT"> in XML]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="ab"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="XAB"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="I"> in standards mode]
-    expected: FAIL
-
-  [[foo='' s\] <div foo="BAR"> in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="Ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div FOO="bar"> in XML]
-    expected: FAIL
-
-  [[align='left' s\] <div align="LEFT"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="a"> in standards mode]
-    expected: FAIL
-
-  [[align='left' s\] <div align="LEFT"> in quirks mode]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="I"> in quirks mode]
-    expected: FAIL
-
-  [[foo='' s\] /* \\0 in attribute */ <div foo="\x00"> in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="x" {a}foo="BAR"> in XML]
-    expected: FAIL
-
-  [[foo='\t' s\] /* tab in selector */ <div foo=" "> with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> in XML]
-    expected: FAIL
-
-  [[foo='' s\] <div foo=""> with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="bar" {a}foo="x" {b}foo="x" {c}foo="x"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="x" {a}foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="Ä"> in XML]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="A-B"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="BAR" {c}foo="x"> in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="a"> with querySelector in XML]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="left"> in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="ä"> in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div baz="BAR"> in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div baz="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[align='left' s\] <div align="left"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in both */ <div foo="ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="XA"> in XML]
-    expected: FAIL
-
-  [[foo='' s\] /* \\0 in attribute */ <div foo="\x00"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="a"> in XML]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="x a b"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo$='Ä' s\] /* COMBINING in selector */ <div foo="ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] <div foo="Ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="LEFT"> in quirks mode]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="ı"> in XML]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="ab"> in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="bar" {a}foo="x" {b}foo="x" {c}foo="x"> in quirks mode]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="ı"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="i"> in XML]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="x a b"> in standards mode]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="x a b"> in XML]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar'\] <div foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="A"> in standards mode]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="AB"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='\t' s\] /* tab in selector */ <div foo=" "> in standards mode]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="x a b"> in standards mode]
-    expected: FAIL
-
-  [[lang|='a' s\] <div lang="A-B"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="a"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div baz="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] <div foo="Ä"> in XML]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="BAR" {c}foo="x"> in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div baz="BAR"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo~='ä' s\] /* COMBINING in selector */ <div foo="ä"> with querySelector in XML]
-    expected: FAIL
-
-  [[id^='a' s\] <div id="AB"> in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in both */ <div foo="Ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='BAR' s\] <div foo="BAR"> in XML]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="bar" {c}foo="x"> in quirks mode]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="x a b"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='\t' s\] /* tab in selector */ <div foo=" "> with querySelector in XML]
-    expected: FAIL
-
-  [[class~='a' s\] <div class="X A B"> with querySelector in XML]
-    expected: FAIL
-
-  [@namespace x 'a'; [x|foo='' s\] <div {A}foo=""> in XML]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='i' s\] <div foo="İ"> in XML]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="xab"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo$='Ä' s\] /* COMBINING in selector */ <div foo="ä"> in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="A"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='Ä' s\] <div foo="ä"> in quirks mode]
-    expected: FAIL
-
-  [[foo='a' s\] /* COMBINING in attribute */ <div foo="Ä"> in XML]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='bar'\] <div foo="BAR"> in XML]
-    expected: FAIL
-
-  [[align='left' s\] <div align="left"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='\x00' s\] /* \\0 in selector */ <div foo=""> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo^='Ä' s\] /* COMBINING in selector */ <div foo="Ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="BAR" {a}foo="x" {b}foo="x" {c}foo="x"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='BAR' s\][foo='bar'\] <div foo="BAR"> in quirks mode]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="LEFT"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="x a b"> with querySelector in XML]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="XA"> in standards mode]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="ä"> in standards mode]
-    expected: FAIL
-
-  [[foo~='ä' s\] /* COMBINING in selector */ <div foo="ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="Ä"> in standards mode]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="Ä"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar' s\] <div foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [[foo='' s\] /* \\0 in attribute */ <div foo="\x00"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="x a b"> in quirks mode]
-    expected: FAIL
-
-  [[foo='I' s\] <div foo="ı"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div FOO="bar"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="XA"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='\x00' s\] /* \\0 in selector */ <div foo=""> in standards mode]
-    expected: FAIL
-
-  [[foo='ı' s\] <div foo="i"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="A"> with querySelector in standards mode]
-    expected: FAIL
-
-  [@namespace x 'a'; [x|foo='' s\] <div {A}foo=""> in quirks mode]
-    expected: FAIL
-
-  [[|foo='bar' s\] <div foo="x" {a}foo="BAR"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='İ' s\] <div foo="I"> in standards mode]
-    expected: FAIL
-
-  [[foo='A' s\] /* COMBINING in attribute */ <div foo="ä"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[align='LEFT' s\] <div align="LEFT"> with querySelector in XML]
-    expected: FAIL
-
-  [[*|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="A"> with querySelector in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\] <div FOO="bar"> with querySelector in XML]
-    expected: FAIL
-
-  [[foo='ä' s\] /* COMBINING in selector */ <div foo="a"> in quirks mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in selector */ <div foo="a"> in standards mode]
-    expected: FAIL
-
-  [[id$='A' s\] <div id="xa"> in standards mode]
-    expected: FAIL
-
-  [[foo='Ä' s\] /* COMBINING in both */ <div foo="ä"> in quirks mode]
-    expected: FAIL
-
-  [[lang*='A' s\] <div lang="xab"> in standards mode]
-    expected: FAIL
-
-  [[foo='bar' s\][foo='bar'\] <div foo="BAR"> in standards mode]
-    expected: FAIL
-
-  [@namespace x 'http://www.w3.org/XML/1998/namespace'; [x|lang='A' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> in XML]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="bar" {c}foo="x"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[|foo='bar' s\] <div foo="x" {a}foo="BAR"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[class~='A' s\] <div class="X A B"> in quirks mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="BAR" {a}foo="x" {b}foo="x" {c}foo="x"> in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="x" {a}foo="x" {b}foo="BAR" {c}foo="x"> with querySelector in quirks mode]
-    expected: FAIL
-
-  [[*|lang='a' s\] <div {http://www.w3.org/XML/1998/namespace}lang="a"> in quirks mode]
-    expected: FAIL
-
-  [[*|foo='bar' s\] <div foo="bar" {a}foo="x" {b}foo="x" {c}foo="x"> in XML]
-    expected: FAIL
-
-  [[foo='bar' s\] <div FOO="bar"> in quirks mode]
-    expected: FAIL
-
diff --git a/tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/syntax.html.ini b/tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/syntax.html.ini
deleted file mode 100644
index a768d0e86d4..00000000000
--- a/tests/wpt/metadata/css/selectors/attribute-selectors/attribute-case/syntax.html.ini
+++ /dev/null
@@ -1,433 +0,0 @@
-[syntax.html]
-  [[baz='quux' s \] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux' \\s\] in XML]
-    expected: FAIL
-
-  [[baz='quux' s\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' \\73\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz$='quux' s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux's\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz=quux s\] in quirks mode]
-    expected: FAIL
-
-  [[baz*='quux' s\] in XML]
-    expected: FAIL
-
-  [[baz="quux" s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' s \] in XML]
-    expected: FAIL
-
-  [[baz='quux's \] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz*='quux' s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz|='quux' s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux' \\s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' \\73\] in standards mode]
-    expected: FAIL
-
-  [[baz='quux' /**/ s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux' /**/ s\] in XML]
-    expected: FAIL
-
-  [[baz='quux' s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz~='quux' s\] in XML]
-    expected: FAIL
-
-  [[baz='quux'/**/s/**/\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux'/**/s/**/\] in XML]
-    expected: FAIL
-
-  [[baz=quux s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux' \\53\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' \\73\] in XML]
-    expected: FAIL
-
-  [[baz$='quux' s\] in standards mode]
-    expected: FAIL
-
-  [[baz~='quux' s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz~='quux' s\] in standards mode]
-    expected: FAIL
-
-  [[baz='quux' S\] in standards mode]
-    expected: FAIL
-
-  [[baz='quux' s\] in XML]
-    expected: FAIL
-
-  [[baz='quux'\ns\n\] /* \\n */ in standards mode]
-    expected: FAIL
-
-  [[baz='quux's \] in quirks mode]
-    expected: FAIL
-
-  [[baz="quux" s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|baz='quux' s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux's \] in standards mode]
-    expected: FAIL
-
-  [[baz|='quux' s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux's \] with querySelector in XML]
-    expected: FAIL
-
-  [[baz=quux/**/s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux'\ts\t\] /* \\t */ with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz=quux s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz$='quux' s\] in quirks mode]
-    expected: FAIL
-
-  [[baz*='quux' s\] in standards mode]
-    expected: FAIL
-
-  [[*|baz='quux' s\] in standards mode]
-    expected: FAIL
-
-  [[baz='quux's \] in XML]
-    expected: FAIL
-
-  [[baz^='quux' s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux'/**/s/**/\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux'\ts\t\] /* \\t */ in XML]
-    expected: FAIL
-
-  [[*|baz='quux' s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz="quux" s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz*='quux' s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz|='quux' s\] in XML]
-    expected: FAIL
-
-  [[baz='quux' \\s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz^='quux' s\] in quirks mode]
-    expected: FAIL
-
-  [[|baz='quux' s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux' s\] in standards mode]
-    expected: FAIL
-
-  [[baz='quux' /**/ s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux' s \] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[|baz='quux' s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[|baz='quux' s\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' \\53\] in quirks mode]
-    expected: FAIL
-
-  [[baz$='quux' s\] in XML]
-    expected: FAIL
-
-  [[baz='quux' /**/ s\] in quirks mode]
-    expected: FAIL
-
-  [[baz=quux s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz=quux s\] in XML]
-    expected: FAIL
-
-  [[baz='quux' s /**/ \] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux' \\s\] in standards mode]
-    expected: FAIL
-
-  [[baz|='quux' s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux' S\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux's\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux'\ns\n\] /* \\n */ with querySelector in XML]
-    expected: FAIL
-
-  [[baz=quux/**/s\] in XML]
-    expected: FAIL
-
-  [[baz='quux' s \] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' s /**/ \] in quirks mode]
-    expected: FAIL
-
-  [[baz="quux" s\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux'\rs\r\] /* \\r */ with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' s /**/ \] in XML]
-    expected: FAIL
-
-  [[baz='quux'/**/s/**/\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' s \] in standards mode]
-    expected: FAIL
-
-  [[baz='quux's\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux'\ts\t\] /* \\t */ in standards mode]
-    expected: FAIL
-
-  [[baz^='quux' s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux' \\73\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz|='quux' s\] in standards mode]
-    expected: FAIL
-
-  [[baz='quux'\ts\t\] /* \\t */ with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' \\53\] in standards mode]
-    expected: FAIL
-
-  [[baz=quux/**/s\] in standards mode]
-    expected: FAIL
-
-  [[baz$='quux' s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' /**/ s\] in standards mode]
-    expected: FAIL
-
-  [[baz|='quux' s\] in quirks mode]
-    expected: FAIL
-
-  [[baz~='quux' s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz^='quux' s\] in XML]
-    expected: FAIL
-
-  [[baz='quux's\] in XML]
-    expected: FAIL
-
-  [[baz=quux s\] in standards mode]
-    expected: FAIL
-
-  [[baz="quux" s\] in XML]
-    expected: FAIL
-
-  [[baz='quux'/**/s/**/\] in standards mode]
-    expected: FAIL
-
-  [[baz='quux' \\s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|baz='quux' s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux'\rs\r\] /* \\r */ with querySelector in standards mode]
-    expected: FAIL
-
-  [[*|baz='quux' s\] in XML]
-    expected: FAIL
-
-  [[|baz='quux' s\] in XML]
-    expected: FAIL
-
-  [[baz='quux' \\s\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' S\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz=quux/**/s\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux's\] in standards mode]
-    expected: FAIL
-
-  [[baz*='quux' s\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' s \] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz*='quux' s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux' s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux' \\53\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux' \\53\] in XML]
-    expected: FAIL
-
-  [[baz='quux'\ns\n\] /* \\n */ in quirks mode]
-    expected: FAIL
-
-  [[baz='quux'\ts\t\] /* \\t */ in quirks mode]
-    expected: FAIL
-
-  [[baz^='quux' s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz=quux/**/s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux'\ts\t\] /* \\t */ with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux'\ns\n\] /* \\n */ in XML]
-    expected: FAIL
-
-  [[baz='quux'\ns\n\] /* \\n */ with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' s /**/ \] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux's \] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz^='quux' s\] in standards mode]
-    expected: FAIL
-
-  [[baz~='quux' s\] in quirks mode]
-    expected: FAIL
-
-  [[*|baz='quux' s\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' S\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz~='quux' s\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz$='quux' s\] with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux'\rs\r\] /* \\r */ in quirks mode]
-    expected: FAIL
-
-  [[baz="quux" s\] in standards mode]
-    expected: FAIL
-
-  [[baz='quux' \\73\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz=quux/**/s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' s /**/ \] in standards mode]
-    expected: FAIL
-
-  [[baz='quux's\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux'\rs\r\] /* \\r */ in standards mode]
-    expected: FAIL
-
-  [[baz='quux' s /**/ \] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux'\rs\r\] /* \\r */ in XML]
-    expected: FAIL
-
-  [[baz='quux'/**/s/**/\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux'\ns\n\] /* \\n */ with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux'\rs\r\] /* \\r */ with querySelector in XML]
-    expected: FAIL
-
-  [[baz='quux' S\] with querySelector in standards mode]
-    expected: FAIL
-
-  [[baz='quux' \\73\] in quirks mode]
-    expected: FAIL
-
-  [[baz='quux' S\] in XML]
-    expected: FAIL
-
-  [[baz='quux' \\53\] with querySelector in XML]
-    expected: FAIL
-
-  [[|baz='quux' s\] with querySelector in quirks mode]
-    expected: FAIL
-
-  [[|baz='quux' s\] in standards mode]
-    expected: FAIL
-
-  [[baz='quux' /**/ s\] with querySelector in quirks mode]
-    expected: FAIL
-