Auto merge of #25674 - pshaughn:selection, r=jdm

Selection DOM interface (but not actual UI selections)

This is work towards #7492.

I put new tests in the mozilla-specific directory rather than the main tree because I'm not sure how upstreamable they are; I'd like opinions on that point.

This adds a new exposed interface, which I understand from tests/mozilla/interfaces.html is something requiring specific approval from someone allowed to give that approval.

Things that aren't done here:
- The spec doesn't describe what selection/script-and-style-elements.html wants, and what it wants seems to require some sort of layout query.
- Actual UI interactions are not present at all; selection.rs has a few TODOs saying which methods I believe the eventual UI code should call for what actions, but there are a lot of fine points here that I don't know about.
- I haven't touched Node; you can ask if a node's in the Selection's Range the same way you'd ask about any other Range, but there's not a faster path just for selection layout.

components/atoms/static_atoms.txt

@@ -109,6 +109,7 @@ seeked
 seeking
 select
 selectend
+selectionchange
 selectstart
 serif
 signalingstatechange

components/script/dom/document.rs

@@ -79,6 +79,7 @@ use crate::dom::pagetransitionevent::PageTransitionEvent;
 use crate::dom::processinginstruction::ProcessingInstruction;
 use crate::dom::promise::Promise;
 use crate::dom::range::Range;
+use crate::dom::selection::Selection;
 use crate::dom::servoparser::ServoParser;
 use crate::dom::shadowroot::ShadowRoot;
 use crate::dom::storageevent::StorageEvent;
@@ -400,6 +401,8 @@ pub struct Document {
     /// https://html.spec.whatwg.org/multipage/#concept-document-csp-list
     #[ignore_malloc_size_of = "Defined in rust-content-security-policy"]
     csp_list: DomRefCell<Option<CspList>>,
+    /// https://w3c.github.io/slection-api/#dfn-selection
+    selection: MutNullableDom<Selection>,
 }
 
 #[derive(JSTraceable, MallocSizeOf)]
@@ -2909,6 +2912,7 @@ impl Document {
             media_controls: DomRefCell::new(HashMap::new()),
             dirty_webgl_contexts: DomRefCell::new(HashMap::new()),
             csp_list: DomRefCell::new(None),
+            selection: MutNullableDom::new(None),
         }
     }
 
@@ -4618,6 +4622,11 @@ impl DocumentMethods for Document {
         // TODO: https://github.com/servo/servo/issues/21936
         Node::replace_all(None, self.upcast::<Node>());
 
+        // Specs and tests are in a state of flux about whether
+        // we want to clear the selection when we remove the contents;
+        // WPT selection/Document-open.html wants us to not clear it
+        // as of Feb 1 2020
+
         // Step 12
         if self.is_fully_active() {
             let mut new_url = entry_responsible_document.url();
@@ -4790,6 +4799,15 @@ impl DocumentMethods for Document {
             None => Err(Error::InvalidAccess),
         }
     }
+
+    // https://w3c.github.io/selection-api/#dom-document-getselection
+    fn GetSelection(&self) -> Option<DomRoot<Selection>> {
+        if self.has_browsing_context {
+            Some(self.selection.or_init(|| Selection::new(self)))
+        } else {
+            None
+        }
+    }
 }
 
 fn update_with_current_time_ms(marker: &Cell<u64>) {

components/script/dom/macros.rs

@@ -488,6 +488,8 @@ macro_rules! global_event_handlers(
         event_handler!(seeked, GetOnseeked, SetOnseeked);
         event_handler!(seeking, GetOnseeking, SetOnseeking);
         event_handler!(select, GetOnselect, SetOnselect);
+        event_handler!(selectionchange, GetOnselectionchange, SetOnselectionchange);
+        event_handler!(selectstart, GetOnselectstart, SetOnselectstart);
         event_handler!(show, GetOnshow, SetOnshow);
         event_handler!(stalled, GetOnstalled, SetOnstalled);
         event_handler!(submit, GetOnsubmit, SetOnsubmit);

components/script/dom/mod.rs

@@ -477,6 +477,7 @@ pub mod rtcpeerconnectioniceevent;
 pub mod rtcsessiondescription;
 pub mod rtctrackevent;
 pub mod screen;
+pub mod selection;
 pub mod serviceworker;
 pub mod serviceworkercontainer;
 pub mod serviceworkerglobalscope;

components/script/dom/range.rs

@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+use crate::dom::bindings::cell::DomRefCell;
 use crate::dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods;
 use crate::dom::bindings::codegen::Bindings::NodeBinding::NodeConstants;
 use crate::dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
@@ -24,6 +25,7 @@ use crate::dom::documentfragment::DocumentFragment;
 use crate::dom::element::Element;
 use crate::dom::htmlscriptelement::HTMLScriptElement;
 use crate::dom::node::{Node, ShadowIncluding, UnbindContext};
+use crate::dom::selection::Selection;
 use crate::dom::text::Text;
 use crate::dom::window::Window;
 use dom_struct::dom_struct;
@@ -37,6 +39,16 @@ pub struct Range {
     reflector_: Reflector,
     start: BoundaryPoint,
     end: BoundaryPoint,
+    // A range that belongs to a Selection needs to know about it
+    // so selectionchange can fire when the range changes.
+    // A range shouldn't belong to more than one Selection at a time,
+    // but from the spec as of Feb 1 2020 I can't rule out a corner case like:
+    // * Select a range R in document A, from node X to Y
+    // * Insert everything from X to Y into document B
+    // * Set B's selection's range to R
+    // which leaves R technically, and observably, associated with A even though
+    // it will fail the same-root-node check on many of A's selection's methods.
+    associated_selections: DomRefCell<Vec<Dom<Selection>>>,
 }
 
 impl Range {
@@ -50,6 +62,7 @@ impl Range {
             reflector_: Reflector::new(),
             start: BoundaryPoint::new(start_container, start_offset),
             end: BoundaryPoint::new(end_container, end_offset),
+            associated_selections: DomRefCell::new(vec![]),
         }
     }
 
@@ -163,6 +176,9 @@ impl Range {
 
     // https://dom.spec.whatwg.org/#concept-range-bp-set
     fn set_start(&self, node: &Node, offset: u32) {
+        if &self.start.node != node || self.start.offset.get() != offset {
+            self.report_change();
+        }
         if &self.start.node != node {
             if self.start.node == self.end.node {
                 node.ranges().push(WeakRef::new(&self));
@@ -178,6 +194,9 @@ impl Range {
 
     // https://dom.spec.whatwg.org/#concept-range-bp-set
     fn set_end(&self, node: &Node, offset: u32) {
+        if &self.end.node != node || self.end.offset.get() != offset {
+            self.report_change();
+        }
         if &self.end.node != node {
             if self.end.node == self.start.node {
                 node.ranges().push(WeakRef::new(&self));
@@ -228,6 +247,26 @@ impl Range {
         // Step 6.
         Ok(Ordering::Equal)
     }
+
+    pub fn associate_selection(&self, selection: &Selection) {
+        let mut selections = self.associated_selections.borrow_mut();
+        if !selections.iter().any(|s| &**s == selection) {
+            selections.push(Dom::from_ref(selection));
+        }
+    }
+
+    pub fn disassociate_selection(&self, selection: &Selection) {
+        self.associated_selections
+            .borrow_mut()
+            .retain(|s| &**s != selection);
+    }
+
+    fn report_change(&self) {
+        self.associated_selections
+            .borrow()
+            .iter()
+            .for_each(|s| s.queue_selectionchange_task());
+    }
 }
 
 impl RangeMethods for Range {
@@ -821,6 +860,9 @@ impl RangeMethods for Range {
         // Step 3.
         if start_node == end_node {
             if let Some(text) = start_node.downcast::<CharacterData>() {
+                if end_offset > start_offset {
+                    self.report_change();
+                }
                 return text.ReplaceData(start_offset, end_offset - start_offset, DOMString::new());
             }
         }
@@ -1142,9 +1184,11 @@ impl WeakRangeVec {
                     entry.remove();
                 }
                 if &range.start.node == child {
+                    range.report_change();
                     range.start.set(context.parent, offset);
                 }
                 if &range.end.node == child {
+                    range.report_change();
                     range.end.set(context.parent, offset);
                 }
             });
@@ -1169,9 +1213,11 @@ impl WeakRangeVec {
                     entry.remove();
                 }
                 if &range.start.node == node {
+                    range.report_change();
                     range.start.set(sibling, range.StartOffset() + length);
                 }
                 if &range.end.node == node {
+                    range.report_change();
                     range.end.set(sibling, range.EndOffset() + length);
                 }
             });
@@ -1212,9 +1258,11 @@ impl WeakRangeVec {
                 }
 
                 if move_start {
+                    range.report_change();
                     range.start.set(child, new_offset);
                 }
                 if move_end {
+                    range.report_change();
                     range.end.set(child, new_offset);
                 }
             });
@@ -1273,9 +1321,11 @@ impl WeakRangeVec {
                 }
 
                 if move_start {
+                    range.report_change();
                     range.start.set(sibling, start_offset - offset);
                 }
                 if move_end {
+                    range.report_change();
                     range.end.set(sibling, end_offset - offset);
                 }
             });
@@ -1289,9 +1339,11 @@ impl WeakRangeVec {
             (*self.cell.get()).update(|entry| {
                 let range = entry.root().unwrap();
                 if &range.start.node == node && offset == range.StartOffset() {
+                    range.report_change();
                     range.start.set_offset(offset + 1);
                 }
                 if &range.end.node == node && offset == range.EndOffset() {
+                    range.report_change();
                     range.end.set_offset(offset + 1);
                 }
             });
@@ -1304,10 +1356,12 @@ impl WeakRangeVec {
                 let range = entry.root().unwrap();
                 let start_offset = range.StartOffset();
                 if &range.start.node == node && start_offset > offset {
+                    range.report_change();
                     range.start.set_offset(f(start_offset));
                 }
                 let end_offset = range.EndOffset();
                 if &range.end.node == node && end_offset > offset {
+                    range.report_change();
                     range.end.set_offset(f(end_offset));
                 }
             });

components/script/dom/selection.rs

@@ -0,0 +1,515 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use crate::dom::bindings::codegen::Bindings::NodeBinding::{GetRootNodeOptions, NodeMethods};
+use crate::dom::bindings::codegen::Bindings::RangeBinding::RangeMethods;
+use crate::dom::bindings::codegen::Bindings::SelectionBinding::{SelectionMethods, Wrap};
+use crate::dom::bindings::error::{Error, ErrorResult, Fallible};
+use crate::dom::bindings::inheritance::Castable;
+use crate::dom::bindings::refcounted::Trusted;
+use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
+use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
+use crate::dom::bindings::str::DOMString;
+use crate::dom::document::Document;
+use crate::dom::eventtarget::EventTarget;
+use crate::dom::node::{window_from_node, Node};
+use crate::dom::range::Range;
+use crate::task_source::TaskSource;
+use dom_struct::dom_struct;
+use std::cell::Cell;
+
+#[derive(Clone, Copy, JSTraceable, MallocSizeOf)]
+enum Direction {
+    Forwards,
+    Backwards,
+    Directionless,
+}
+
+#[dom_struct]
+pub struct Selection {
+    reflector_: Reflector,
+    document: Dom<Document>,
+    range: MutNullableDom<Range>,
+    direction: Cell<Direction>,
+    task_queued: Cell<bool>,
+}
+
+impl Selection {
+    fn new_inherited(document: &Document) -> Selection {
+        Selection {
+            reflector_: Reflector::new(),
+            document: Dom::from_ref(document),
+            range: MutNullableDom::new(None),
+            direction: Cell::new(Direction::Directionless),
+            task_queued: Cell::new(false),
+        }
+    }
+
+    pub fn new(document: &Document) -> DomRoot<Selection> {
+        reflect_dom_object(
+            Box::new(Selection::new_inherited(document)),
+            &*document.global(),
+            Wrap,
+        )
+    }
+
+    fn set_range(&self, range: &Range) {
+        // If we are setting to literally the same Range object
+        // (not just the same positions), then there's nothing changing
+        // and no task to queue.
+        if let Some(existing) = self.range.get() {
+            if &*existing == range {
+                return;
+            }
+        }
+        self.range.set(Some(range));
+        range.associate_selection(self);
+        self.queue_selectionchange_task();
+    }
+
+    fn clear_range(&self) {
+        // If we already don't have a a Range object, then there's
+        // nothing changing and no task to queue.
+        if let Some(range) = self.range.get() {
+            range.disassociate_selection(self);
+            self.range.set(None);
+            self.queue_selectionchange_task();
+        }
+    }
+
+    pub fn queue_selectionchange_task(&self) {
+        if self.task_queued.get() {
+            // Spec doesn't specify not to queue multiple tasks,
+            // but it's much easier to code range operations if
+            // change notifications within a method are idempotent.
+            return;
+        }
+        let this = Trusted::new(self);
+        let window = window_from_node(&*self.document);
+        window
+            .task_manager()
+            .user_interaction_task_source() // w3c/selection-api#117
+            .queue(
+                task!(selectionchange_task_steps: move || {
+                    let this = this.root();
+                    this.task_queued.set(false);
+                    this.document.upcast::<EventTarget>().fire_event(atom!("selectionchange"));
+                }),
+                window.upcast(),
+            )
+            .expect("Couldn't queue selectionchange task!");
+        self.task_queued.set(true);
+    }
+
+    fn is_same_root(&self, node: &Node) -> bool {
+        &*node.GetRootNode(&GetRootNodeOptions::empty()) == self.document.upcast::<Node>()
+    }
+}
+
+impl SelectionMethods for Selection {
+    // https://w3c.github.io/selection-api/#dom-selection-anchornode
+    fn GetAnchorNode(&self) -> Option<DomRoot<Node>> {
+        if let Some(range) = self.range.get() {
+            match self.direction.get() {
+                Direction::Forwards => Some(range.StartContainer()),
+                _ => Some(range.EndContainer()),
+            }
+        } else {
+            None
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-anchoroffset
+    fn AnchorOffset(&self) -> u32 {
+        if let Some(range) = self.range.get() {
+            match self.direction.get() {
+                Direction::Forwards => range.StartOffset(),
+                _ => range.EndOffset(),
+            }
+        } else {
+            0
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-focusnode
+    fn GetFocusNode(&self) -> Option<DomRoot<Node>> {
+        if let Some(range) = self.range.get() {
+            match self.direction.get() {
+                Direction::Forwards => Some(range.EndContainer()),
+                _ => Some(range.StartContainer()),
+            }
+        } else {
+            None
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-focusoffset
+    fn FocusOffset(&self) -> u32 {
+        if let Some(range) = self.range.get() {
+            match self.direction.get() {
+                Direction::Forwards => range.EndOffset(),
+                _ => range.StartOffset(),
+            }
+        } else {
+            0
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-iscollapsed
+    fn IsCollapsed(&self) -> bool {
+        if let Some(range) = self.range.get() {
+            range.Collapsed()
+        } else {
+            true
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-rangecount
+    fn RangeCount(&self) -> u32 {
+        if self.range.get().is_some() {
+            1
+        } else {
+            0
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-type
+    fn Type(&self) -> DOMString {
+        if let Some(range) = self.range.get() {
+            if range.Collapsed() {
+                DOMString::from("Caret")
+            } else {
+                DOMString::from("Range")
+            }
+        } else {
+            DOMString::from("None")
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-getrangeat
+    fn GetRangeAt(&self, index: u32) -> Fallible<DomRoot<Range>> {
+        if index != 0 {
+            Err(Error::IndexSize)
+        } else if let Some(range) = self.range.get() {
+            Ok(DomRoot::from_ref(&range))
+        } else {
+            Err(Error::IndexSize)
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-addrange
+    fn AddRange(&self, range: &Range) {
+        // Step 1
+        if !self.is_same_root(&*range.StartContainer()) {
+            return;
+        }
+
+        // Step 2
+        if self.RangeCount() != 0 {
+            return;
+        }
+
+        // Step 3
+        self.set_range(range);
+        // Are we supposed to set Direction here? w3c/selection-api#116
+        self.direction.set(Direction::Forwards);
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-removerange
+    fn RemoveRange(&self, range: &Range) -> ErrorResult {
+        if let Some(own_range) = self.range.get() {
+            if &*own_range == range {
+                self.clear_range();
+                return Ok(());
+            }
+        }
+        Err(Error::NotFound)
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-removeallranges
+    fn RemoveAllRanges(&self) {
+        self.clear_range();
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-empty
+    // TODO: When implementing actual selection UI, this may be the correct
+    // method to call as the abandon-selection action
+    fn Empty(&self) {
+        self.clear_range();
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-collapse
+    fn Collapse(&self, node: Option<&Node>, offset: u32) -> ErrorResult {
+        if let Some(node) = node {
+            if node.is_doctype() {
+                // w3c/selection-api#118
+                return Err(Error::InvalidNodeType);
+            }
+            if offset > node.len() {
+                // Step 2
+                return Err(Error::IndexSize);
+            }
+
+            if !self.is_same_root(node) {
+                // Step 3
+                return Ok(());
+            }
+
+            // Steps 4-5
+            let range = Range::new(&self.document, node, offset, node, offset);
+
+            // Step 6
+            self.set_range(&range);
+            // Are we supposed to set Direction here? w3c/selection-api#116
+            //
+            self.direction.set(Direction::Forwards);
+        } else {
+            // Step 1
+            self.clear_range();
+        }
+        Ok(())
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-setposition
+    // TODO: When implementing actual selection UI, this may be the correct
+    // method to call as the start-of-selection action, after a
+    // selectstart event has fired and not been cancelled.
+    fn SetPosition(&self, node: Option<&Node>, offset: u32) -> ErrorResult {
+        self.Collapse(node, offset)
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-collapsetostart
+    fn CollapseToStart(&self) -> ErrorResult {
+        if let Some(range) = self.range.get() {
+            self.Collapse(Some(&*range.StartContainer()), range.StartOffset())
+        } else {
+            Err(Error::InvalidState)
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-collapsetoend
+    fn CollapseToEnd(&self) -> ErrorResult {
+        if let Some(range) = self.range.get() {
+            self.Collapse(Some(&*range.EndContainer()), range.EndOffset())
+        } else {
+            Err(Error::InvalidState)
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-extend
+    // TODO: When implementing actual selection UI, this may be the correct
+    // method to call as the continue-selection action
+    fn Extend(&self, node: &Node, offset: u32) -> ErrorResult {
+        if !self.is_same_root(node) {
+            // Step 1
+            return Ok(());
+        }
+        if let Some(range) = self.range.get() {
+            if node.is_doctype() {
+                // w3c/selection-api#118
+                return Err(Error::InvalidNodeType);
+            }
+
+            if offset > node.len() {
+                // As with is_doctype, not explicit in selection spec steps here
+                // but implied by which exceptions are thrown in WPT tests
+                return Err(Error::IndexSize);
+            }
+
+            // Step 4
+            if !self.is_same_root(&*range.StartContainer()) {
+                // Step 5, and its following 8 and 9
+                self.set_range(&*Range::new(&self.document, node, offset, node, offset));
+                self.direction.set(Direction::Forwards);
+            } else {
+                let old_anchor_node = &*self.GetAnchorNode().unwrap(); // has range, therefore has anchor node
+                let old_anchor_offset = self.AnchorOffset();
+                let is_old_anchor_before_or_equal = {
+                    if old_anchor_node == node {
+                        old_anchor_offset <= offset
+                    } else {
+                        old_anchor_node.is_before(node)
+                    }
+                };
+                if is_old_anchor_before_or_equal {
+                    // Step 6, and its following 8 and 9
+                    self.set_range(&*Range::new(
+                        &self.document,
+                        old_anchor_node,
+                        old_anchor_offset,
+                        node,
+                        offset,
+                    ));
+                    self.direction.set(Direction::Forwards);
+                } else {
+                    // Step 7, and its following 8 and 9
+                    self.set_range(&*Range::new(
+                        &self.document,
+                        node,
+                        offset,
+                        old_anchor_node,
+                        old_anchor_offset,
+                    ));
+                    self.direction.set(Direction::Backwards);
+                }
+            };
+        } else {
+            // Step 2
+            return Err(Error::InvalidState);
+        }
+        return Ok(());
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-setbaseandextent
+    fn SetBaseAndExtent(
+        &self,
+        anchor_node: &Node,
+        anchor_offset: u32,
+        focus_node: &Node,
+        focus_offset: u32,
+    ) -> ErrorResult {
+        // Step 1
+        if anchor_node.is_doctype() || focus_node.is_doctype() {
+            // w3c/selection-api#118
+            return Err(Error::InvalidNodeType);
+        }
+
+        if anchor_offset > anchor_node.len() || focus_offset > focus_node.len() {
+            return Err(Error::IndexSize);
+        }
+
+        // Step 2
+        if !self.is_same_root(anchor_node) || !self.is_same_root(focus_node) {
+            return Ok(());
+        }
+
+        // Steps 5-7
+        let is_focus_before_anchor = {
+            if anchor_node == focus_node {
+                focus_offset < anchor_offset
+            } else {
+                focus_node.is_before(anchor_node)
+            }
+        };
+        if is_focus_before_anchor {
+            self.set_range(&*Range::new(
+                &self.document,
+                focus_node,
+                focus_offset,
+                anchor_node,
+                anchor_offset,
+            ));
+            self.direction.set(Direction::Backwards);
+        } else {
+            self.set_range(&*Range::new(
+                &self.document,
+                anchor_node,
+                anchor_offset,
+                focus_node,
+                focus_offset,
+            ));
+            self.direction.set(Direction::Forwards);
+        }
+        Ok(())
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-selectallchildren
+    fn SelectAllChildren(&self, node: &Node) -> ErrorResult {
+        if node.is_doctype() {
+            // w3c/selection-api#118
+            return Err(Error::InvalidNodeType);
+        }
+        if !self.is_same_root(node) {
+            return Ok(());
+        }
+
+        // Spec wording just says node length here, but WPT specifically
+        // wants number of children (the main difference is that it's 0
+        // for cdata).
+        self.set_range(&*Range::new(
+            &self.document,
+            node,
+            0,
+            node,
+            node.children_count(),
+        ));
+
+        self.direction.set(Direction::Forwards);
+        Ok(())
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-deletecontents
+    fn DeleteFromDocument(&self) -> ErrorResult {
+        if let Some(range) = self.range.get() {
+            // Since the range is changing, it should trigger a
+            // selectionchange event as it would if if mutated any other way
+            return range.DeleteContents();
+        }
+        return Ok(());
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-containsnode
+    fn ContainsNode(&self, node: &Node, allow_partial_containment: bool) -> bool {
+        // TODO: Spec requires a "visually equivalent to" check, which is
+        // probably up to a layout query. This is therefore not a full implementation.
+        if !self.is_same_root(node) {
+            return false;
+        }
+        if let Some(range) = self.range.get() {
+            let start_node = &*range.StartContainer();
+            if !self.is_same_root(start_node) {
+                // node can't be contained in a range with a different root
+                return false;
+            }
+            if allow_partial_containment {
+                // Spec seems to be incorrect here, w3c/selection-api#116
+                if node.is_before(start_node) {
+                    return false;
+                }
+                let end_node = &*range.EndContainer();
+                if end_node.is_before(node) {
+                    return false;
+                }
+                if node == start_node {
+                    return range.StartOffset() < node.len();
+                }
+                if node == end_node {
+                    return range.EndOffset() > 0;
+                }
+                return true;
+            } else {
+                if node.is_before(start_node) {
+                    return false;
+                }
+                let end_node = &*range.EndContainer();
+                if end_node.is_before(node) {
+                    return false;
+                }
+                if node == start_node {
+                    return range.StartOffset() == 0;
+                }
+                if node == end_node {
+                    return range.EndOffset() == node.len();
+                }
+                return true;
+            }
+        } else {
+            // No range
+            return false;
+        }
+    }
+
+    // https://w3c.github.io/selection-api/#dom-selection-stringifier
+    fn Stringifier(&self) -> DOMString {
+        // The spec as of Jan 31 2020 just says
+        // "See W3C bug 10583." for this method.
+        // Stringifying the range seems at least approximately right
+        // and passes the non-style-dependent case in the WPT tests.
+        if let Some(range) = self.range.get() {
+            range.Stringifier()
+        } else {
+            DOMString::from("")
+        }
+    }
+}

components/script/dom/webidls/Document.webidl

@@ -214,6 +214,12 @@ partial interface Document {
 
 Document includes DocumentOrShadowRoot;
 
+// https://w3c.github.io/selection-api/#dom-document
+partial interface Document {
+  Selection? getSelection();
+};
+
+
 // Servo internal API.
 partial interface Document {
   [Throws]

components/script/dom/webidls/EventHandler.webidl

@@ -95,6 +95,12 @@ partial interface mixin GlobalEventHandlers {
            attribute EventHandler ontransitionend;
 };
 
+// https://w3c.github.io/selection-api/#extensions-to-globaleventhandlers-interface
+partial interface mixin GlobalEventHandlers {
+          attribute EventHandler onselectstart;
+          attribute EventHandler onselectionchange;
+};
+
 // https://html.spec.whatwg.org/multipage/#windoweventhandlers
 [Exposed=Window]
 interface mixin WindowEventHandlers {

components/script/dom/webidls/Selection.webidl

@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://w3c.github.io/selection-api/#selection-interface
+[Exposed=Window]
+interface Selection {
+readonly attribute Node? anchorNode;
+  readonly attribute unsigned long anchorOffset;
+  readonly attribute Node? focusNode;
+  readonly attribute unsigned long focusOffset;
+  readonly attribute boolean isCollapsed;
+  readonly attribute unsigned long rangeCount;
+  readonly attribute DOMString type;
+  [Throws] Range getRangeAt(unsigned long index);
+  void addRange(Range range);
+  [Throws] void removeRange(Range range);
+  void removeAllRanges();
+  void empty();
+  [Throws] void collapse(Node? node, optional unsigned long offset = 0);
+  [Throws] void setPosition(Node? node, optional unsigned long offset = 0);
+  [Throws] void collapseToStart();
+  [Throws] void collapseToEnd();
+  [Throws] void extend(Node node, optional unsigned long offset = 0);
+  [Throws]
+  void setBaseAndExtent(Node anchorNode, unsigned long anchorOffset, Node focusNode, unsigned long focusOffset);
+  [Throws] void selectAllChildren(Node node);
+  [CEReactions, Throws]
+  void deleteFromDocument();
+  boolean containsNode(Node node, optional boolean allowPartialContainment = false);
+  stringifier DOMString ();
+};

components/script/dom/webidls/Window.webidl

@@ -175,6 +175,12 @@ partial interface Window {
    readonly attribute unsigned long runningAnimationCount;
 };
 
+// https://w3c.github.io/selection-api/#dom-document
+partial interface Window {
+   Selection? getSelection();
+};
+
+
 dictionary WindowPostMessageOptions : PostMessageOptions {
    USVString targetOrigin = "/";
 };

components/script/dom/window.rs

@@ -47,6 +47,7 @@ use crate::dom::node::{document_from_node, from_untrusted_node_address, Node, No
 use crate::dom::performance::Performance;
 use crate::dom::promise::Promise;
 use crate::dom::screen::Screen;
+use crate::dom::selection::Selection;
 use crate::dom::storage::Storage;
 use crate::dom::testrunner::TestRunner;
 use crate::dom::webglrenderingcontext::WebGLCommandSender;
@@ -1322,6 +1323,11 @@ impl WindowMethods for Window {
     fn Origin(&self) -> USVString {
         USVString(self.origin().immutable().ascii_serialization())
     }
+
+    // https://w3c.github.io/selection-api/#dom-window-getselection
+    fn GetSelection(&self) -> Option<DomRoot<Selection>> {
+        self.document.get().and_then(|d| d.GetSelection())
+    }
 }
 
 impl Window {

tests/wpt/include.ini

@@ -155,6 +155,8 @@ skip: true
       skip: true
 [resource-timing]
   skip: false
+[selection]
+  skip: false
 [subresource-integrity]
   skip: false
 [touch-events]

tests/wpt/metadata/custom-elements/reactions/Selection.html.ini

@@ -1,5 +0,0 @@
-[Selection.html]
-  type: testharness
-  [deleteFromDocument on Selection must enqueue a disconnected reaction]
-    expected: FAIL
-

tests/wpt/metadata/dom/ranges/Range-mutations-appendChild.html.ini

@@ -1,107 +0,0 @@
-[Range-mutations-appendChild.html]
-  type: testharness
-  [testDiv.appendChild(testDiv.lastChild), with selected range collapsed at (testDiv.lastChild, 0)]
-    expected: FAIL
-
-  [testDiv.appendChild(testDiv.lastChild), with selected range on testDiv.lastChild from 0 to 1]
-    expected: FAIL
-
-  [testDiv.appendChild(testDiv.lastChild), with selected range collapsed at (testDiv.lastChild, 1)]
-    expected: FAIL
-
-  [testDiv.appendChild(testDiv.lastChild), with selected range on testDiv from testDiv.childNodes.length - 2 to testDiv.childNodes.length]
-    expected: FAIL
-
-  [testDiv.appendChild(testDiv.lastChild), with selected range on testDiv from testDiv.childNodes.length - 2 to testDiv.childNodes.length - 1]
-    expected: FAIL
-
-  [testDiv.appendChild(testDiv.lastChild), with selected range on testDiv from testDiv.childNodes.length - 1 to testDiv.childNodes.length]
-    expected: FAIL
-
-  [testDiv.appendChild(testDiv.lastChild), with selected range collapsed at (testDiv, testDiv.childNodes.length - 1)]
-    expected: FAIL
-
-  [testDiv.appendChild(testDiv.lastChild), with selected range collapsed at (testDiv, testDiv.childNodes.length)]
-    expected: FAIL
-
-  [detachedDiv.appendChild(detachedDiv.lastChild), with selected range collapsed at (detachedDiv.lastChild, 0)]
-    expected: FAIL
-
-  [detachedDiv.appendChild(detachedDiv.lastChild), with selected range on detachedDiv.lastChild from 0 to 1]
-    expected: FAIL
-
-  [detachedDiv.appendChild(detachedDiv.lastChild), with selected range collapsed at (detachedDiv.lastChild, 1)]
-    expected: FAIL
-
-  [detachedDiv.appendChild(detachedDiv.lastChild), with selected range on detachedDiv from detachedDiv.childNodes.length - 2 to detachedDiv.childNodes.length]
-    expected: FAIL
-
-  [detachedDiv.appendChild(detachedDiv.lastChild), with selected range on detachedDiv from detachedDiv.childNodes.length - 2 to detachedDiv.childNodes.length - 1]
-    expected: FAIL
-
-  [detachedDiv.appendChild(detachedDiv.lastChild), with selected range on detachedDiv from detachedDiv.childNodes.length - 1 to detachedDiv.childNodes.length]
-    expected: FAIL
-
-  [detachedDiv.appendChild(detachedDiv.lastChild), with selected range collapsed at (detachedDiv, detachedDiv.childNodes.length - 1)]
-    expected: FAIL
-
-  [detachedDiv.appendChild(detachedDiv.lastChild), with selected range collapsed at (detachedDiv, detachedDiv.childNodes.length)]
-    expected: FAIL
-
-  [paras[0\].appendChild(paras[1\]), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].appendChild(paras[1\]), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].appendChild(paras[1\]), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].appendChild(paras[1\]), with selected range on testDiv from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].appendChild(paras[1\]), with selected range on testDiv from 0 to 2]
-    expected: FAIL
-
-  [paras[0\].appendChild(paras[1\]), with selected range collapsed at (testDiv, 1)]
-    expected: FAIL
-
-  [paras[0\].appendChild(paras[1\]), with selected range on testDiv from 1 to 2]
-    expected: FAIL
-
-  [foreignDoc.appendChild(detachedComment), with selected range on foreignDoc from foreignDoc.childNodes.length - 1 to foreignDoc.childNodes.length]
-    expected: FAIL
-
-  [foreignDoc.appendChild(detachedComment), with selected range collapsed at (foreignDoc, foreignDoc.childNodes.length - 1)]
-    expected: FAIL
-
-  [foreignDoc.appendChild(detachedComment), with selected range collapsed at (foreignDoc, foreignDoc.childNodes.length)]
-    expected: FAIL
-
-  [foreignDoc.appendChild(detachedComment), with selected range on detachedComment from 0 to 5]
-    expected: FAIL
-
-  [paras[0\].appendChild(xmlTextNode), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].appendChild(xmlTextNode), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].appendChild(xmlTextNode), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].appendChild(paras[0\]), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].appendChild(testDiv), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].appendChild(document), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].appendChild(foreignDoc), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].appendChild(document.doctype), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-

tests/wpt/metadata/dom/ranges/Range-mutations-appendData.html.ini

@@ -1,578 +0,0 @@
-[Range-mutations-appendData.html]
-  type: testharness
-  [paras[0\].firstChild.appendData("foo"), with selected range on paras[0\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range collapsed at (paras[0\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range collapsed at (paras[0\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range on paras[0\].firstChild from 0 to paras[0\].firstChild.length]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range on paras[0\].firstChild from 1 to paras[0\].firstChild.length]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range collapsed at (paras[0\].firstChild, paras[0\].firstChild.length)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range on paras[0\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range collapsed at (paras[0\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range collapsed at (paras[0\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range on paras[0\].firstChild from 0 to paras[0\].firstChild.length]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range on paras[0\].firstChild from 1 to paras[0\].firstChild.length]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range collapsed at (paras[0\].firstChild, paras[0\].firstChild.length)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData("foo"), with selected range on paras[1\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData("foo"), with selected range collapsed at (paras[1\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData("foo"), with selected range collapsed at (paras[1\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData("foo"), with selected range on paras[1\].firstChild from 0 to paras[1\].firstChild.length]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData("foo"), with selected range on paras[1\].firstChild from 1 to paras[1\].firstChild.length]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData("foo"), with selected range collapsed at (paras[1\].firstChild, paras[1\].firstChild.length)]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData("foo"), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData(""), with selected range on paras[1\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData(""), with selected range collapsed at (paras[1\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData(""), with selected range collapsed at (paras[1\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData(""), with selected range on paras[1\].firstChild from 0 to paras[1\].firstChild.length]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData(""), with selected range on paras[1\].firstChild from 1 to paras[1\].firstChild.length]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData(""), with selected range collapsed at (paras[1\].firstChild, paras[1\].firstChild.length)]
-    expected: FAIL
-
-  [paras[1\].firstChild.appendData(""), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.appendData("foo"), with selected range on foreignTextNode from 0 to 1]
-    expected: FAIL
-
-  [foreignTextNode.appendData("foo"), with selected range collapsed at (foreignTextNode, 0)]
-    expected: FAIL
-
-  [foreignTextNode.appendData("foo"), with selected range collapsed at (foreignTextNode, 1)]
-    expected: FAIL
-
-  [foreignTextNode.appendData("foo"), with selected range on foreignTextNode from 0 to foreignTextNode.length]
-    expected: FAIL
-
-  [foreignTextNode.appendData("foo"), with selected range on foreignTextNode from 1 to foreignTextNode.length]
-    expected: FAIL
-
-  [foreignTextNode.appendData("foo"), with selected range collapsed at (foreignTextNode, foreignTextNode.length)]
-    expected: FAIL
-
-  [foreignTextNode.appendData("foo"), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.appendData(""), with selected range on foreignTextNode from 0 to 1]
-    expected: FAIL
-
-  [foreignTextNode.appendData(""), with selected range collapsed at (foreignTextNode, 0)]
-    expected: FAIL
-
-  [foreignTextNode.appendData(""), with selected range collapsed at (foreignTextNode, 1)]
-    expected: FAIL
-
-  [foreignTextNode.appendData(""), with selected range on foreignTextNode from 0 to foreignTextNode.length]
-    expected: FAIL
-
-  [foreignTextNode.appendData(""), with selected range on foreignTextNode from 1 to foreignTextNode.length]
-    expected: FAIL
-
-  [foreignTextNode.appendData(""), with selected range collapsed at (foreignTextNode, foreignTextNode.length)]
-    expected: FAIL
-
-  [foreignTextNode.appendData(""), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.appendData("foo"), with selected range on xmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [xmlTextNode.appendData("foo"), with selected range collapsed at (xmlTextNode, 0)]
-    expected: FAIL
-
-  [xmlTextNode.appendData("foo"), with selected range collapsed at (xmlTextNode, 1)]
-    expected: FAIL
-
-  [xmlTextNode.appendData("foo"), with selected range on xmlTextNode from 0 to xmlTextNode.length]
-    expected: FAIL
-
-  [xmlTextNode.appendData("foo"), with selected range on xmlTextNode from 1 to xmlTextNode.length]
-    expected: FAIL
-
-  [xmlTextNode.appendData("foo"), with selected range collapsed at (xmlTextNode, xmlTextNode.length)]
-    expected: FAIL
-
-  [xmlTextNode.appendData("foo"), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.appendData(""), with selected range on xmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [xmlTextNode.appendData(""), with selected range collapsed at (xmlTextNode, 0)]
-    expected: FAIL
-
-  [xmlTextNode.appendData(""), with selected range collapsed at (xmlTextNode, 1)]
-    expected: FAIL
-
-  [xmlTextNode.appendData(""), with selected range on xmlTextNode from 0 to xmlTextNode.length]
-    expected: FAIL
-
-  [xmlTextNode.appendData(""), with selected range on xmlTextNode from 1 to xmlTextNode.length]
-    expected: FAIL
-
-  [xmlTextNode.appendData(""), with selected range collapsed at (xmlTextNode, xmlTextNode.length)]
-    expected: FAIL
-
-  [xmlTextNode.appendData(""), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.appendData("foo"), with selected range on detachedTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedTextNode.appendData("foo"), with selected range collapsed at (detachedTextNode, 0)]
-    expected: FAIL
-
-  [detachedTextNode.appendData("foo"), with selected range collapsed at (detachedTextNode, 1)]
-    expected: FAIL
-
-  [detachedTextNode.appendData("foo"), with selected range on detachedTextNode from 0 to detachedTextNode.length]
-    expected: FAIL
-
-  [detachedTextNode.appendData("foo"), with selected range on detachedTextNode from 1 to detachedTextNode.length]
-    expected: FAIL
-
-  [detachedTextNode.appendData("foo"), with selected range collapsed at (detachedTextNode, detachedTextNode.length)]
-    expected: FAIL
-
-  [detachedTextNode.appendData("foo"), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.appendData(""), with selected range on detachedTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedTextNode.appendData(""), with selected range collapsed at (detachedTextNode, 0)]
-    expected: FAIL
-
-  [detachedTextNode.appendData(""), with selected range collapsed at (detachedTextNode, 1)]
-    expected: FAIL
-
-  [detachedTextNode.appendData(""), with selected range on detachedTextNode from 0 to detachedTextNode.length]
-    expected: FAIL
-
-  [detachedTextNode.appendData(""), with selected range on detachedTextNode from 1 to detachedTextNode.length]
-    expected: FAIL
-
-  [detachedTextNode.appendData(""), with selected range collapsed at (detachedTextNode, detachedTextNode.length)]
-    expected: FAIL
-
-  [detachedTextNode.appendData(""), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData("foo"), with selected range on detachedForeignTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData("foo"), with selected range collapsed at (detachedForeignTextNode, 0)]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData("foo"), with selected range collapsed at (detachedForeignTextNode, 1)]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData("foo"), with selected range on detachedForeignTextNode from 0 to detachedForeignTextNode.length]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData("foo"), with selected range on detachedForeignTextNode from 1 to detachedForeignTextNode.length]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData("foo"), with selected range collapsed at (detachedForeignTextNode, detachedForeignTextNode.length)]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData("foo"), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData(""), with selected range on detachedForeignTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData(""), with selected range collapsed at (detachedForeignTextNode, 0)]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData(""), with selected range collapsed at (detachedForeignTextNode, 1)]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData(""), with selected range on detachedForeignTextNode from 0 to detachedForeignTextNode.length]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData(""), with selected range on detachedForeignTextNode from 1 to detachedForeignTextNode.length]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData(""), with selected range collapsed at (detachedForeignTextNode, detachedForeignTextNode.length)]
-    expected: FAIL
-
-  [detachedForeignTextNode.appendData(""), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData("foo"), with selected range on detachedXmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData("foo"), with selected range collapsed at (detachedXmlTextNode, 0)]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData("foo"), with selected range collapsed at (detachedXmlTextNode, 1)]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData("foo"), with selected range on detachedXmlTextNode from 0 to detachedXmlTextNode.length]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData("foo"), with selected range on detachedXmlTextNode from 1 to detachedXmlTextNode.length]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData("foo"), with selected range collapsed at (detachedXmlTextNode, detachedXmlTextNode.length)]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData("foo"), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData(""), with selected range on detachedXmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData(""), with selected range collapsed at (detachedXmlTextNode, 0)]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData(""), with selected range collapsed at (detachedXmlTextNode, 1)]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData(""), with selected range on detachedXmlTextNode from 0 to detachedXmlTextNode.length]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData(""), with selected range on detachedXmlTextNode from 1 to detachedXmlTextNode.length]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData(""), with selected range collapsed at (detachedXmlTextNode, detachedXmlTextNode.length)]
-    expected: FAIL
-
-  [detachedXmlTextNode.appendData(""), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [comment.appendData("foo"), with selected range on comment from 0 to 1]
-    expected: FAIL
-
-  [comment.appendData("foo"), with selected range collapsed at (comment, 0)]
-    expected: FAIL
-
-  [comment.appendData("foo"), with selected range collapsed at (comment, 1)]
-    expected: FAIL
-
-  [comment.appendData("foo"), with selected range on comment from 0 to comment.length]
-    expected: FAIL
-
-  [comment.appendData("foo"), with selected range on comment from 1 to comment.length]
-    expected: FAIL
-
-  [comment.appendData("foo"), with selected range collapsed at (comment, comment.length)]
-    expected: FAIL
-
-  [comment.appendData("foo"), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.appendData(""), with selected range on comment from 0 to 1]
-    expected: FAIL
-
-  [comment.appendData(""), with selected range collapsed at (comment, 0)]
-    expected: FAIL
-
-  [comment.appendData(""), with selected range collapsed at (comment, 1)]
-    expected: FAIL
-
-  [comment.appendData(""), with selected range on comment from 0 to comment.length]
-    expected: FAIL
-
-  [comment.appendData(""), with selected range on comment from 1 to comment.length]
-    expected: FAIL
-
-  [comment.appendData(""), with selected range collapsed at (comment, comment.length)]
-    expected: FAIL
-
-  [comment.appendData(""), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.appendData("foo"), with selected range on foreignComment from 0 to 1]
-    expected: FAIL
-
-  [foreignComment.appendData("foo"), with selected range collapsed at (foreignComment, 0)]
-    expected: FAIL
-
-  [foreignComment.appendData("foo"), with selected range collapsed at (foreignComment, 1)]
-    expected: FAIL
-
-  [foreignComment.appendData("foo"), with selected range on foreignComment from 0 to foreignComment.length]
-    expected: FAIL
-
-  [foreignComment.appendData("foo"), with selected range on foreignComment from 1 to foreignComment.length]
-    expected: FAIL
-
-  [foreignComment.appendData("foo"), with selected range collapsed at (foreignComment, foreignComment.length)]
-    expected: FAIL
-
-  [foreignComment.appendData("foo"), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.appendData(""), with selected range on foreignComment from 0 to 1]
-    expected: FAIL
-
-  [foreignComment.appendData(""), with selected range collapsed at (foreignComment, 0)]
-    expected: FAIL
-
-  [foreignComment.appendData(""), with selected range collapsed at (foreignComment, 1)]
-    expected: FAIL
-
-  [foreignComment.appendData(""), with selected range on foreignComment from 0 to foreignComment.length]
-    expected: FAIL
-
-  [foreignComment.appendData(""), with selected range on foreignComment from 1 to foreignComment.length]
-    expected: FAIL
-
-  [foreignComment.appendData(""), with selected range collapsed at (foreignComment, foreignComment.length)]
-    expected: FAIL
-
-  [foreignComment.appendData(""), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.appendData("foo"), with selected range on xmlComment from 0 to 1]
-    expected: FAIL
-
-  [xmlComment.appendData("foo"), with selected range collapsed at (xmlComment, 0)]
-    expected: FAIL
-
-  [xmlComment.appendData("foo"), with selected range collapsed at (xmlComment, 1)]
-    expected: FAIL
-
-  [xmlComment.appendData("foo"), with selected range on xmlComment from 0 to xmlComment.length]
-    expected: FAIL
-
-  [xmlComment.appendData("foo"), with selected range on xmlComment from 1 to xmlComment.length]
-    expected: FAIL
-
-  [xmlComment.appendData("foo"), with selected range collapsed at (xmlComment, xmlComment.length)]
-    expected: FAIL
-
-  [xmlComment.appendData("foo"), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.appendData(""), with selected range on xmlComment from 0 to 1]
-    expected: FAIL
-
-  [xmlComment.appendData(""), with selected range collapsed at (xmlComment, 0)]
-    expected: FAIL
-
-  [xmlComment.appendData(""), with selected range collapsed at (xmlComment, 1)]
-    expected: FAIL
-
-  [xmlComment.appendData(""), with selected range on xmlComment from 0 to xmlComment.length]
-    expected: FAIL
-
-  [xmlComment.appendData(""), with selected range on xmlComment from 1 to xmlComment.length]
-    expected: FAIL
-
-  [xmlComment.appendData(""), with selected range collapsed at (xmlComment, xmlComment.length)]
-    expected: FAIL
-
-  [xmlComment.appendData(""), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.appendData("foo"), with selected range on detachedComment from 0 to 1]
-    expected: FAIL
-
-  [detachedComment.appendData("foo"), with selected range collapsed at (detachedComment, 0)]
-    expected: FAIL
-
-  [detachedComment.appendData("foo"), with selected range collapsed at (detachedComment, 1)]
-    expected: FAIL
-
-  [detachedComment.appendData("foo"), with selected range on detachedComment from 0 to detachedComment.length]
-    expected: FAIL
-
-  [detachedComment.appendData("foo"), with selected range on detachedComment from 1 to detachedComment.length]
-    expected: FAIL
-
-  [detachedComment.appendData("foo"), with selected range collapsed at (detachedComment, detachedComment.length)]
-    expected: FAIL
-
-  [detachedComment.appendData("foo"), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.appendData(""), with selected range on detachedComment from 0 to 1]
-    expected: FAIL
-
-  [detachedComment.appendData(""), with selected range collapsed at (detachedComment, 0)]
-    expected: FAIL
-
-  [detachedComment.appendData(""), with selected range collapsed at (detachedComment, 1)]
-    expected: FAIL
-
-  [detachedComment.appendData(""), with selected range on detachedComment from 0 to detachedComment.length]
-    expected: FAIL
-
-  [detachedComment.appendData(""), with selected range on detachedComment from 1 to detachedComment.length]
-    expected: FAIL
-
-  [detachedComment.appendData(""), with selected range collapsed at (detachedComment, detachedComment.length)]
-    expected: FAIL
-
-  [detachedComment.appendData(""), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.appendData("foo"), with selected range on detachedForeignComment from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignComment.appendData("foo"), with selected range collapsed at (detachedForeignComment, 0)]
-    expected: FAIL
-
-  [detachedForeignComment.appendData("foo"), with selected range collapsed at (detachedForeignComment, 1)]
-    expected: FAIL
-
-  [detachedForeignComment.appendData("foo"), with selected range on detachedForeignComment from 0 to detachedForeignComment.length]
-    expected: FAIL
-
-  [detachedForeignComment.appendData("foo"), with selected range on detachedForeignComment from 1 to detachedForeignComment.length]
-    expected: FAIL
-
-  [detachedForeignComment.appendData("foo"), with selected range collapsed at (detachedForeignComment, detachedForeignComment.length)]
-    expected: FAIL
-
-  [detachedForeignComment.appendData("foo"), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.appendData(""), with selected range on detachedForeignComment from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignComment.appendData(""), with selected range collapsed at (detachedForeignComment, 0)]
-    expected: FAIL
-
-  [detachedForeignComment.appendData(""), with selected range collapsed at (detachedForeignComment, 1)]
-    expected: FAIL
-
-  [detachedForeignComment.appendData(""), with selected range on detachedForeignComment from 0 to detachedForeignComment.length]
-    expected: FAIL
-
-  [detachedForeignComment.appendData(""), with selected range on detachedForeignComment from 1 to detachedForeignComment.length]
-    expected: FAIL
-
-  [detachedForeignComment.appendData(""), with selected range collapsed at (detachedForeignComment, detachedForeignComment.length)]
-    expected: FAIL
-
-  [detachedForeignComment.appendData(""), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.appendData("foo"), with selected range on detachedXmlComment from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlComment.appendData("foo"), with selected range collapsed at (detachedXmlComment, 0)]
-    expected: FAIL
-
-  [detachedXmlComment.appendData("foo"), with selected range collapsed at (detachedXmlComment, 1)]
-    expected: FAIL
-
-  [detachedXmlComment.appendData("foo"), with selected range on detachedXmlComment from 0 to detachedXmlComment.length]
-    expected: FAIL
-
-  [detachedXmlComment.appendData("foo"), with selected range on detachedXmlComment from 1 to detachedXmlComment.length]
-    expected: FAIL
-
-  [detachedXmlComment.appendData("foo"), with selected range collapsed at (detachedXmlComment, detachedXmlComment.length)]
-    expected: FAIL
-
-  [detachedXmlComment.appendData("foo"), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.appendData(""), with selected range on detachedXmlComment from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlComment.appendData(""), with selected range collapsed at (detachedXmlComment, 0)]
-    expected: FAIL
-
-  [detachedXmlComment.appendData(""), with selected range collapsed at (detachedXmlComment, 1)]
-    expected: FAIL
-
-  [detachedXmlComment.appendData(""), with selected range on detachedXmlComment from 0 to detachedXmlComment.length]
-    expected: FAIL
-
-  [detachedXmlComment.appendData(""), with selected range on detachedXmlComment from 1 to detachedXmlComment.length]
-    expected: FAIL
-
-  [detachedXmlComment.appendData(""), with selected range collapsed at (detachedXmlComment, detachedXmlComment.length)]
-    expected: FAIL
-
-  [detachedXmlComment.appendData(""), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData(""), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.appendData("foo"), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-

tests/wpt/metadata/dom/ranges/Range-mutations-deleteData.html.ini

@@ -1,848 +0,0 @@
-[Range-mutations-deleteData.html]
-  type: testharness
-  [paras[0\].firstChild.deleteData(376, 2), with selected range on paras[0\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(0, 2), with selected range collapsed at (paras[0\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 2), with selected range collapsed at (paras[0\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(paras[0\].firstChild.length, 2), with selected range collapsed at (paras[0\].firstChild, paras[0\].firstChild.length)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 2), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(2, 2), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(3, 2), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(376, 0), with selected range on paras[0\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(0, 0), with selected range collapsed at (paras[0\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 0), with selected range collapsed at (paras[0\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(paras[0\].firstChild.length, 0), with selected range collapsed at (paras[0\].firstChild, paras[0\].firstChild.length)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 0), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(2, 0), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(3, 0), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(376, 631), with selected range on paras[0\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(0, 631), with selected range collapsed at (paras[0\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 631), with selected range collapsed at (paras[0\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(paras[0\].firstChild.length, 631), with selected range collapsed at (paras[0\].firstChild, paras[0\].firstChild.length)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 631), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(2, 631), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(3, 631), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(376, 2), with selected range on paras[1\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(0, 2), with selected range collapsed at (paras[1\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(1, 2), with selected range collapsed at (paras[1\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(paras[1\].firstChild.length, 2), with selected range collapsed at (paras[1\].firstChild, paras[1\].firstChild.length)]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(1, 2), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(2, 2), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(3, 2), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(376, 0), with selected range on paras[1\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(0, 0), with selected range collapsed at (paras[1\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(1, 0), with selected range collapsed at (paras[1\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(paras[1\].firstChild.length, 0), with selected range collapsed at (paras[1\].firstChild, paras[1\].firstChild.length)]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(1, 0), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(2, 0), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(3, 0), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(376, 631), with selected range on paras[1\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(0, 631), with selected range collapsed at (paras[1\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(1, 631), with selected range collapsed at (paras[1\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(paras[1\].firstChild.length, 631), with selected range collapsed at (paras[1\].firstChild, paras[1\].firstChild.length)]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(1, 631), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(2, 631), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.deleteData(3, 631), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(376, 2), with selected range on foreignTextNode from 0 to 1]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(0, 2), with selected range collapsed at (foreignTextNode, 0)]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(1, 2), with selected range collapsed at (foreignTextNode, 1)]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(foreignTextNode.length, 2), with selected range collapsed at (foreignTextNode, foreignTextNode.length)]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(1, 2), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(2, 2), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(3, 2), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(376, 0), with selected range on foreignTextNode from 0 to 1]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(0, 0), with selected range collapsed at (foreignTextNode, 0)]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(1, 0), with selected range collapsed at (foreignTextNode, 1)]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(foreignTextNode.length, 0), with selected range collapsed at (foreignTextNode, foreignTextNode.length)]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(1, 0), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(2, 0), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(3, 0), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(376, 631), with selected range on foreignTextNode from 0 to 1]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(0, 631), with selected range collapsed at (foreignTextNode, 0)]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(1, 631), with selected range collapsed at (foreignTextNode, 1)]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(foreignTextNode.length, 631), with selected range collapsed at (foreignTextNode, foreignTextNode.length)]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(1, 631), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(2, 631), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.deleteData(3, 631), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(376, 2), with selected range on xmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(0, 2), with selected range collapsed at (xmlTextNode, 0)]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(1, 2), with selected range collapsed at (xmlTextNode, 1)]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(xmlTextNode.length, 2), with selected range collapsed at (xmlTextNode, xmlTextNode.length)]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(1, 2), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(2, 2), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(3, 2), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(376, 0), with selected range on xmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(0, 0), with selected range collapsed at (xmlTextNode, 0)]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(1, 0), with selected range collapsed at (xmlTextNode, 1)]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(xmlTextNode.length, 0), with selected range collapsed at (xmlTextNode, xmlTextNode.length)]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(1, 0), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(2, 0), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(3, 0), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(376, 631), with selected range on xmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(0, 631), with selected range collapsed at (xmlTextNode, 0)]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(1, 631), with selected range collapsed at (xmlTextNode, 1)]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(xmlTextNode.length, 631), with selected range collapsed at (xmlTextNode, xmlTextNode.length)]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(1, 631), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(2, 631), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.deleteData(3, 631), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(376, 2), with selected range on detachedTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(0, 2), with selected range collapsed at (detachedTextNode, 0)]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(1, 2), with selected range collapsed at (detachedTextNode, 1)]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(detachedTextNode.length, 2), with selected range collapsed at (detachedTextNode, detachedTextNode.length)]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(1, 2), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(2, 2), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(3, 2), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(376, 0), with selected range on detachedTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(0, 0), with selected range collapsed at (detachedTextNode, 0)]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(1, 0), with selected range collapsed at (detachedTextNode, 1)]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(detachedTextNode.length, 0), with selected range collapsed at (detachedTextNode, detachedTextNode.length)]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(1, 0), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(2, 0), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(3, 0), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(376, 631), with selected range on detachedTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(0, 631), with selected range collapsed at (detachedTextNode, 0)]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(1, 631), with selected range collapsed at (detachedTextNode, 1)]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(detachedTextNode.length, 631), with selected range collapsed at (detachedTextNode, detachedTextNode.length)]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(1, 631), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(2, 631), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.deleteData(3, 631), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(376, 2), with selected range on detachedForeignTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(0, 2), with selected range collapsed at (detachedForeignTextNode, 0)]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(1, 2), with selected range collapsed at (detachedForeignTextNode, 1)]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(detachedForeignTextNode.length, 2), with selected range collapsed at (detachedForeignTextNode, detachedForeignTextNode.length)]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(1, 2), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(2, 2), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(3, 2), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(376, 0), with selected range on detachedForeignTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(0, 0), with selected range collapsed at (detachedForeignTextNode, 0)]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(1, 0), with selected range collapsed at (detachedForeignTextNode, 1)]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(detachedForeignTextNode.length, 0), with selected range collapsed at (detachedForeignTextNode, detachedForeignTextNode.length)]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(1, 0), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(2, 0), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(3, 0), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(376, 631), with selected range on detachedForeignTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(0, 631), with selected range collapsed at (detachedForeignTextNode, 0)]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(1, 631), with selected range collapsed at (detachedForeignTextNode, 1)]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(detachedForeignTextNode.length, 631), with selected range collapsed at (detachedForeignTextNode, detachedForeignTextNode.length)]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(1, 631), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(2, 631), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.deleteData(3, 631), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(376, 2), with selected range on detachedXmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(0, 2), with selected range collapsed at (detachedXmlTextNode, 0)]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(1, 2), with selected range collapsed at (detachedXmlTextNode, 1)]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(detachedXmlTextNode.length, 2), with selected range collapsed at (detachedXmlTextNode, detachedXmlTextNode.length)]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(1, 2), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(2, 2), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(3, 2), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(376, 0), with selected range on detachedXmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(0, 0), with selected range collapsed at (detachedXmlTextNode, 0)]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(1, 0), with selected range collapsed at (detachedXmlTextNode, 1)]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(detachedXmlTextNode.length, 0), with selected range collapsed at (detachedXmlTextNode, detachedXmlTextNode.length)]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(1, 0), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(2, 0), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(3, 0), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(376, 631), with selected range on detachedXmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(0, 631), with selected range collapsed at (detachedXmlTextNode, 0)]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(1, 631), with selected range collapsed at (detachedXmlTextNode, 1)]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(detachedXmlTextNode.length, 631), with selected range collapsed at (detachedXmlTextNode, detachedXmlTextNode.length)]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(1, 631), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(2, 631), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.deleteData(3, 631), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [comment.deleteData(376, 2), with selected range on comment from 0 to 1]
-    expected: FAIL
-
-  [comment.deleteData(0, 2), with selected range collapsed at (comment, 0)]
-    expected: FAIL
-
-  [comment.deleteData(1, 2), with selected range collapsed at (comment, 1)]
-    expected: FAIL
-
-  [comment.deleteData(comment.length, 2), with selected range collapsed at (comment, comment.length)]
-    expected: FAIL
-
-  [comment.deleteData(1, 2), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.deleteData(2, 2), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.deleteData(3, 2), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.deleteData(376, 0), with selected range on comment from 0 to 1]
-    expected: FAIL
-
-  [comment.deleteData(0, 0), with selected range collapsed at (comment, 0)]
-    expected: FAIL
-
-  [comment.deleteData(1, 0), with selected range collapsed at (comment, 1)]
-    expected: FAIL
-
-  [comment.deleteData(comment.length, 0), with selected range collapsed at (comment, comment.length)]
-    expected: FAIL
-
-  [comment.deleteData(1, 0), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.deleteData(2, 0), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.deleteData(3, 0), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.deleteData(376, 631), with selected range on comment from 0 to 1]
-    expected: FAIL
-
-  [comment.deleteData(0, 631), with selected range collapsed at (comment, 0)]
-    expected: FAIL
-
-  [comment.deleteData(1, 631), with selected range collapsed at (comment, 1)]
-    expected: FAIL
-
-  [comment.deleteData(comment.length, 631), with selected range collapsed at (comment, comment.length)]
-    expected: FAIL
-
-  [comment.deleteData(1, 631), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.deleteData(2, 631), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.deleteData(3, 631), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.deleteData(376, 2), with selected range on foreignComment from 0 to 1]
-    expected: FAIL
-
-  [foreignComment.deleteData(0, 2), with selected range collapsed at (foreignComment, 0)]
-    expected: FAIL
-
-  [foreignComment.deleteData(1, 2), with selected range collapsed at (foreignComment, 1)]
-    expected: FAIL
-
-  [foreignComment.deleteData(foreignComment.length, 2), with selected range collapsed at (foreignComment, foreignComment.length)]
-    expected: FAIL
-
-  [foreignComment.deleteData(1, 2), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.deleteData(2, 2), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.deleteData(3, 2), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.deleteData(376, 0), with selected range on foreignComment from 0 to 1]
-    expected: FAIL
-
-  [foreignComment.deleteData(0, 0), with selected range collapsed at (foreignComment, 0)]
-    expected: FAIL
-
-  [foreignComment.deleteData(1, 0), with selected range collapsed at (foreignComment, 1)]
-    expected: FAIL
-
-  [foreignComment.deleteData(foreignComment.length, 0), with selected range collapsed at (foreignComment, foreignComment.length)]
-    expected: FAIL
-
-  [foreignComment.deleteData(1, 0), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.deleteData(2, 0), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.deleteData(3, 0), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.deleteData(376, 631), with selected range on foreignComment from 0 to 1]
-    expected: FAIL
-
-  [foreignComment.deleteData(0, 631), with selected range collapsed at (foreignComment, 0)]
-    expected: FAIL
-
-  [foreignComment.deleteData(1, 631), with selected range collapsed at (foreignComment, 1)]
-    expected: FAIL
-
-  [foreignComment.deleteData(foreignComment.length, 631), with selected range collapsed at (foreignComment, foreignComment.length)]
-    expected: FAIL
-
-  [foreignComment.deleteData(1, 631), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.deleteData(2, 631), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.deleteData(3, 631), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.deleteData(376, 2), with selected range on xmlComment from 0 to 1]
-    expected: FAIL
-
-  [xmlComment.deleteData(0, 2), with selected range collapsed at (xmlComment, 0)]
-    expected: FAIL
-
-  [xmlComment.deleteData(1, 2), with selected range collapsed at (xmlComment, 1)]
-    expected: FAIL
-
-  [xmlComment.deleteData(xmlComment.length, 2), with selected range collapsed at (xmlComment, xmlComment.length)]
-    expected: FAIL
-
-  [xmlComment.deleteData(1, 2), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.deleteData(2, 2), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.deleteData(3, 2), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.deleteData(376, 0), with selected range on xmlComment from 0 to 1]
-    expected: FAIL
-
-  [xmlComment.deleteData(0, 0), with selected range collapsed at (xmlComment, 0)]
-    expected: FAIL
-
-  [xmlComment.deleteData(1, 0), with selected range collapsed at (xmlComment, 1)]
-    expected: FAIL
-
-  [xmlComment.deleteData(xmlComment.length, 0), with selected range collapsed at (xmlComment, xmlComment.length)]
-    expected: FAIL
-
-  [xmlComment.deleteData(1, 0), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.deleteData(2, 0), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.deleteData(3, 0), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.deleteData(376, 631), with selected range on xmlComment from 0 to 1]
-    expected: FAIL
-
-  [xmlComment.deleteData(0, 631), with selected range collapsed at (xmlComment, 0)]
-    expected: FAIL
-
-  [xmlComment.deleteData(1, 631), with selected range collapsed at (xmlComment, 1)]
-    expected: FAIL
-
-  [xmlComment.deleteData(xmlComment.length, 631), with selected range collapsed at (xmlComment, xmlComment.length)]
-    expected: FAIL
-
-  [xmlComment.deleteData(1, 631), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.deleteData(2, 631), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.deleteData(3, 631), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.deleteData(376, 2), with selected range on detachedComment from 0 to 1]
-    expected: FAIL
-
-  [detachedComment.deleteData(0, 2), with selected range collapsed at (detachedComment, 0)]
-    expected: FAIL
-
-  [detachedComment.deleteData(1, 2), with selected range collapsed at (detachedComment, 1)]
-    expected: FAIL
-
-  [detachedComment.deleteData(detachedComment.length, 2), with selected range collapsed at (detachedComment, detachedComment.length)]
-    expected: FAIL
-
-  [detachedComment.deleteData(1, 2), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.deleteData(2, 2), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.deleteData(3, 2), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.deleteData(376, 0), with selected range on detachedComment from 0 to 1]
-    expected: FAIL
-
-  [detachedComment.deleteData(0, 0), with selected range collapsed at (detachedComment, 0)]
-    expected: FAIL
-
-  [detachedComment.deleteData(1, 0), with selected range collapsed at (detachedComment, 1)]
-    expected: FAIL
-
-  [detachedComment.deleteData(detachedComment.length, 0), with selected range collapsed at (detachedComment, detachedComment.length)]
-    expected: FAIL
-
-  [detachedComment.deleteData(1, 0), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.deleteData(2, 0), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.deleteData(3, 0), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.deleteData(376, 631), with selected range on detachedComment from 0 to 1]
-    expected: FAIL
-
-  [detachedComment.deleteData(0, 631), with selected range collapsed at (detachedComment, 0)]
-    expected: FAIL
-
-  [detachedComment.deleteData(1, 631), with selected range collapsed at (detachedComment, 1)]
-    expected: FAIL
-
-  [detachedComment.deleteData(detachedComment.length, 631), with selected range collapsed at (detachedComment, detachedComment.length)]
-    expected: FAIL
-
-  [detachedComment.deleteData(1, 631), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.deleteData(2, 631), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.deleteData(3, 631), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(376, 2), with selected range on detachedForeignComment from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(0, 2), with selected range collapsed at (detachedForeignComment, 0)]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(1, 2), with selected range collapsed at (detachedForeignComment, 1)]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(detachedForeignComment.length, 2), with selected range collapsed at (detachedForeignComment, detachedForeignComment.length)]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(1, 2), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(2, 2), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(3, 2), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(376, 0), with selected range on detachedForeignComment from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(0, 0), with selected range collapsed at (detachedForeignComment, 0)]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(1, 0), with selected range collapsed at (detachedForeignComment, 1)]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(detachedForeignComment.length, 0), with selected range collapsed at (detachedForeignComment, detachedForeignComment.length)]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(1, 0), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(2, 0), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(3, 0), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(376, 631), with selected range on detachedForeignComment from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(0, 631), with selected range collapsed at (detachedForeignComment, 0)]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(1, 631), with selected range collapsed at (detachedForeignComment, 1)]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(detachedForeignComment.length, 631), with selected range collapsed at (detachedForeignComment, detachedForeignComment.length)]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(1, 631), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(2, 631), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.deleteData(3, 631), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(376, 2), with selected range on detachedXmlComment from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(0, 2), with selected range collapsed at (detachedXmlComment, 0)]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(1, 2), with selected range collapsed at (detachedXmlComment, 1)]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(detachedXmlComment.length, 2), with selected range collapsed at (detachedXmlComment, detachedXmlComment.length)]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(1, 2), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(2, 2), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(3, 2), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(376, 0), with selected range on detachedXmlComment from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(0, 0), with selected range collapsed at (detachedXmlComment, 0)]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(1, 0), with selected range collapsed at (detachedXmlComment, 1)]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(detachedXmlComment.length, 0), with selected range collapsed at (detachedXmlComment, detachedXmlComment.length)]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(1, 0), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(2, 0), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(3, 0), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(376, 631), with selected range on detachedXmlComment from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(0, 631), with selected range collapsed at (detachedXmlComment, 0)]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(1, 631), with selected range collapsed at (detachedXmlComment, 1)]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(detachedXmlComment.length, 631), with selected range collapsed at (detachedXmlComment, detachedXmlComment.length)]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(1, 631), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(2, 631), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.deleteData(3, 631), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 2), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 2), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 2), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 2), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(2, 2), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(3, 2), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(1, 2), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(2, 2), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-
-  [paras[0\].firstChild.deleteData(3, 2), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-

tests/wpt/metadata/dom/ranges/Range-mutations-insertBefore.html.ini

@@ -1,116 +0,0 @@
-[Range-mutations-insertBefore.html]
-  type: testharness
-  [testDiv.insertBefore(paras[0\], paras[1\]), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [testDiv.insertBefore(paras[0\], paras[1\]), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [testDiv.insertBefore(paras[0\], paras[1\]), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [testDiv.insertBefore(paras[0\], paras[1\]), with selected range on testDiv from 0 to 2]
-    expected: FAIL
-
-  [testDiv.insertBefore(paras[0\], paras[1\]), with selected range collapsed at (testDiv, 1)]
-    expected: FAIL
-
-  [testDiv.insertBefore(paras[0\], paras[1\]), with selected range on testDiv from 1 to 2]
-    expected: FAIL
-
-  [testDiv.insertBefore(paras[0\], paras[1\]), with selected range collapsed at (testDiv, 2)]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], paras[0\].firstChild), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], paras[0\].firstChild), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], paras[0\].firstChild), with selected range on testDiv from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], paras[0\].firstChild), with selected range on testDiv from 0 to 2]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], paras[0\].firstChild), with selected range collapsed at (testDiv, 1)]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], paras[0\].firstChild), with selected range on testDiv from 1 to 2]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], null), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], null), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], null), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], null), with selected range on testDiv from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], null), with selected range on testDiv from 0 to 2]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], null), with selected range collapsed at (testDiv, 1)]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[1\], null), with selected range on testDiv from 1 to 2]
-    expected: FAIL
-
-  [foreignDoc.insertBefore(detachedComment, foreignDoc.documentElement), with selected range collapsed at (foreignDoc, 0)]
-    expected: FAIL
-
-  [foreignDoc.insertBefore(detachedComment, foreignDoc.documentElement), with selected range on foreignDoc from 0 to 1]
-    expected: FAIL
-
-  [foreignDoc.insertBefore(detachedComment, foreignDoc.documentElement), with selected range on foreignDoc from 0 to 2]
-    expected: FAIL
-
-  [foreignDoc.insertBefore(detachedComment, foreignDoc.documentElement), with selected range collapsed at (foreignDoc, 1)]
-    expected: FAIL
-
-  [foreignDoc.insertBefore(detachedComment, foreignDoc.doctype), with selected range collapsed at (foreignDoc, 0)]
-    expected: FAIL
-
-  [foreignDoc.insertBefore(detachedComment, foreignDoc.doctype), with selected range on foreignDoc from 0 to 1]
-    expected: FAIL
-
-  [foreignDoc.insertBefore(detachedComment, foreignDoc.doctype), with selected range on foreignDoc from 0 to 2]
-    expected: FAIL
-
-  [foreignDoc.insertBefore(detachedComment, foreignDoc.doctype), with selected range collapsed at (foreignDoc, 1)]
-    expected: FAIL
-
-  [foreignDoc.insertBefore(detachedComment, null), with selected range on foreignDoc from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(xmlTextNode, paras[0\].firstChild), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].insertBefore(xmlTextNode, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(xmlTextNode, paras[0\].firstChild), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].insertBefore(paras[0\], paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(testDiv, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(document, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(foreignDoc, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].insertBefore(document.doctype, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-

tests/wpt/metadata/dom/ranges/Range-mutations-insertData.html.ini

@@ -1,575 +0,0 @@
-[Range-mutations-insertData.html]
-  type: testharness
-  [paras[0\].firstChild.insertData(376, "foo"), with selected range on paras[0\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(0, "foo"), with selected range collapsed at (paras[0\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(1, "foo"), with selected range collapsed at (paras[0\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(paras[0\].firstChild.length, "foo"), with selected range collapsed at (paras[0\].firstChild, paras[0\].firstChild.length)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(1, "foo"), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(2, "foo"), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(3, "foo"), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(376, ""), with selected range on paras[0\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(0, ""), with selected range collapsed at (paras[0\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(1, ""), with selected range collapsed at (paras[0\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(paras[0\].firstChild.length, ""), with selected range collapsed at (paras[0\].firstChild, paras[0\].firstChild.length)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(1, ""), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(2, ""), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(3, ""), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(376, "foo"), with selected range on paras[1\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(0, "foo"), with selected range collapsed at (paras[1\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(1, "foo"), with selected range collapsed at (paras[1\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(paras[1\].firstChild.length, "foo"), with selected range collapsed at (paras[1\].firstChild, paras[1\].firstChild.length)]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(1, "foo"), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(2, "foo"), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(3, "foo"), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(376, ""), with selected range on paras[1\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(0, ""), with selected range collapsed at (paras[1\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(1, ""), with selected range collapsed at (paras[1\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(paras[1\].firstChild.length, ""), with selected range collapsed at (paras[1\].firstChild, paras[1\].firstChild.length)]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(1, ""), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(2, ""), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.insertData(3, ""), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.insertData(376, "foo"), with selected range on foreignTextNode from 0 to 1]
-    expected: FAIL
-
-  [foreignTextNode.insertData(0, "foo"), with selected range collapsed at (foreignTextNode, 0)]
-    expected: FAIL
-
-  [foreignTextNode.insertData(1, "foo"), with selected range collapsed at (foreignTextNode, 1)]
-    expected: FAIL
-
-  [foreignTextNode.insertData(foreignTextNode.length, "foo"), with selected range collapsed at (foreignTextNode, foreignTextNode.length)]
-    expected: FAIL
-
-  [foreignTextNode.insertData(1, "foo"), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.insertData(2, "foo"), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.insertData(3, "foo"), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.insertData(376, ""), with selected range on foreignTextNode from 0 to 1]
-    expected: FAIL
-
-  [foreignTextNode.insertData(0, ""), with selected range collapsed at (foreignTextNode, 0)]
-    expected: FAIL
-
-  [foreignTextNode.insertData(1, ""), with selected range collapsed at (foreignTextNode, 1)]
-    expected: FAIL
-
-  [foreignTextNode.insertData(foreignTextNode.length, ""), with selected range collapsed at (foreignTextNode, foreignTextNode.length)]
-    expected: FAIL
-
-  [foreignTextNode.insertData(1, ""), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.insertData(2, ""), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.insertData(3, ""), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.insertData(376, "foo"), with selected range on xmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [xmlTextNode.insertData(0, "foo"), with selected range collapsed at (xmlTextNode, 0)]
-    expected: FAIL
-
-  [xmlTextNode.insertData(1, "foo"), with selected range collapsed at (xmlTextNode, 1)]
-    expected: FAIL
-
-  [xmlTextNode.insertData(xmlTextNode.length, "foo"), with selected range collapsed at (xmlTextNode, xmlTextNode.length)]
-    expected: FAIL
-
-  [xmlTextNode.insertData(1, "foo"), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.insertData(2, "foo"), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.insertData(3, "foo"), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.insertData(376, ""), with selected range on xmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [xmlTextNode.insertData(0, ""), with selected range collapsed at (xmlTextNode, 0)]
-    expected: FAIL
-
-  [xmlTextNode.insertData(1, ""), with selected range collapsed at (xmlTextNode, 1)]
-    expected: FAIL
-
-  [xmlTextNode.insertData(xmlTextNode.length, ""), with selected range collapsed at (xmlTextNode, xmlTextNode.length)]
-    expected: FAIL
-
-  [xmlTextNode.insertData(1, ""), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.insertData(2, ""), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.insertData(3, ""), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.insertData(376, "foo"), with selected range on detachedTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedTextNode.insertData(0, "foo"), with selected range collapsed at (detachedTextNode, 0)]
-    expected: FAIL
-
-  [detachedTextNode.insertData(1, "foo"), with selected range collapsed at (detachedTextNode, 1)]
-    expected: FAIL
-
-  [detachedTextNode.insertData(detachedTextNode.length, "foo"), with selected range collapsed at (detachedTextNode, detachedTextNode.length)]
-    expected: FAIL
-
-  [detachedTextNode.insertData(1, "foo"), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.insertData(2, "foo"), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.insertData(3, "foo"), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.insertData(376, ""), with selected range on detachedTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedTextNode.insertData(0, ""), with selected range collapsed at (detachedTextNode, 0)]
-    expected: FAIL
-
-  [detachedTextNode.insertData(1, ""), with selected range collapsed at (detachedTextNode, 1)]
-    expected: FAIL
-
-  [detachedTextNode.insertData(detachedTextNode.length, ""), with selected range collapsed at (detachedTextNode, detachedTextNode.length)]
-    expected: FAIL
-
-  [detachedTextNode.insertData(1, ""), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.insertData(2, ""), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.insertData(3, ""), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(376, "foo"), with selected range on detachedForeignTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(0, "foo"), with selected range collapsed at (detachedForeignTextNode, 0)]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(1, "foo"), with selected range collapsed at (detachedForeignTextNode, 1)]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(detachedForeignTextNode.length, "foo"), with selected range collapsed at (detachedForeignTextNode, detachedForeignTextNode.length)]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(1, "foo"), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(2, "foo"), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(3, "foo"), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(376, ""), with selected range on detachedForeignTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(0, ""), with selected range collapsed at (detachedForeignTextNode, 0)]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(1, ""), with selected range collapsed at (detachedForeignTextNode, 1)]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(detachedForeignTextNode.length, ""), with selected range collapsed at (detachedForeignTextNode, detachedForeignTextNode.length)]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(1, ""), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(2, ""), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.insertData(3, ""), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(376, "foo"), with selected range on detachedXmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(0, "foo"), with selected range collapsed at (detachedXmlTextNode, 0)]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(1, "foo"), with selected range collapsed at (detachedXmlTextNode, 1)]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(detachedXmlTextNode.length, "foo"), with selected range collapsed at (detachedXmlTextNode, detachedXmlTextNode.length)]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(1, "foo"), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(2, "foo"), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(3, "foo"), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(376, ""), with selected range on detachedXmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(0, ""), with selected range collapsed at (detachedXmlTextNode, 0)]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(1, ""), with selected range collapsed at (detachedXmlTextNode, 1)]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(detachedXmlTextNode.length, ""), with selected range collapsed at (detachedXmlTextNode, detachedXmlTextNode.length)]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(1, ""), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(2, ""), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.insertData(3, ""), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [comment.insertData(376, "foo"), with selected range on comment from 0 to 1]
-    expected: FAIL
-
-  [comment.insertData(0, "foo"), with selected range collapsed at (comment, 0)]
-    expected: FAIL
-
-  [comment.insertData(1, "foo"), with selected range collapsed at (comment, 1)]
-    expected: FAIL
-
-  [comment.insertData(comment.length, "foo"), with selected range collapsed at (comment, comment.length)]
-    expected: FAIL
-
-  [comment.insertData(1, "foo"), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.insertData(2, "foo"), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.insertData(3, "foo"), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.insertData(376, ""), with selected range on comment from 0 to 1]
-    expected: FAIL
-
-  [comment.insertData(0, ""), with selected range collapsed at (comment, 0)]
-    expected: FAIL
-
-  [comment.insertData(1, ""), with selected range collapsed at (comment, 1)]
-    expected: FAIL
-
-  [comment.insertData(comment.length, ""), with selected range collapsed at (comment, comment.length)]
-    expected: FAIL
-
-  [comment.insertData(1, ""), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.insertData(2, ""), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [comment.insertData(3, ""), with selected range on comment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.insertData(376, "foo"), with selected range on foreignComment from 0 to 1]
-    expected: FAIL
-
-  [foreignComment.insertData(0, "foo"), with selected range collapsed at (foreignComment, 0)]
-    expected: FAIL
-
-  [foreignComment.insertData(1, "foo"), with selected range collapsed at (foreignComment, 1)]
-    expected: FAIL
-
-  [foreignComment.insertData(foreignComment.length, "foo"), with selected range collapsed at (foreignComment, foreignComment.length)]
-    expected: FAIL
-
-  [foreignComment.insertData(1, "foo"), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.insertData(2, "foo"), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.insertData(3, "foo"), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.insertData(376, ""), with selected range on foreignComment from 0 to 1]
-    expected: FAIL
-
-  [foreignComment.insertData(0, ""), with selected range collapsed at (foreignComment, 0)]
-    expected: FAIL
-
-  [foreignComment.insertData(1, ""), with selected range collapsed at (foreignComment, 1)]
-    expected: FAIL
-
-  [foreignComment.insertData(foreignComment.length, ""), with selected range collapsed at (foreignComment, foreignComment.length)]
-    expected: FAIL
-
-  [foreignComment.insertData(1, ""), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.insertData(2, ""), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [foreignComment.insertData(3, ""), with selected range on foreignComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.insertData(376, "foo"), with selected range on xmlComment from 0 to 1]
-    expected: FAIL
-
-  [xmlComment.insertData(0, "foo"), with selected range collapsed at (xmlComment, 0)]
-    expected: FAIL
-
-  [xmlComment.insertData(1, "foo"), with selected range collapsed at (xmlComment, 1)]
-    expected: FAIL
-
-  [xmlComment.insertData(xmlComment.length, "foo"), with selected range collapsed at (xmlComment, xmlComment.length)]
-    expected: FAIL
-
-  [xmlComment.insertData(1, "foo"), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.insertData(2, "foo"), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.insertData(3, "foo"), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.insertData(376, ""), with selected range on xmlComment from 0 to 1]
-    expected: FAIL
-
-  [xmlComment.insertData(0, ""), with selected range collapsed at (xmlComment, 0)]
-    expected: FAIL
-
-  [xmlComment.insertData(1, ""), with selected range collapsed at (xmlComment, 1)]
-    expected: FAIL
-
-  [xmlComment.insertData(xmlComment.length, ""), with selected range collapsed at (xmlComment, xmlComment.length)]
-    expected: FAIL
-
-  [xmlComment.insertData(1, ""), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.insertData(2, ""), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [xmlComment.insertData(3, ""), with selected range on xmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.insertData(376, "foo"), with selected range on detachedComment from 0 to 1]
-    expected: FAIL
-
-  [detachedComment.insertData(0, "foo"), with selected range collapsed at (detachedComment, 0)]
-    expected: FAIL
-
-  [detachedComment.insertData(1, "foo"), with selected range collapsed at (detachedComment, 1)]
-    expected: FAIL
-
-  [detachedComment.insertData(detachedComment.length, "foo"), with selected range collapsed at (detachedComment, detachedComment.length)]
-    expected: FAIL
-
-  [detachedComment.insertData(1, "foo"), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.insertData(2, "foo"), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.insertData(3, "foo"), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.insertData(376, ""), with selected range on detachedComment from 0 to 1]
-    expected: FAIL
-
-  [detachedComment.insertData(0, ""), with selected range collapsed at (detachedComment, 0)]
-    expected: FAIL
-
-  [detachedComment.insertData(1, ""), with selected range collapsed at (detachedComment, 1)]
-    expected: FAIL
-
-  [detachedComment.insertData(detachedComment.length, ""), with selected range collapsed at (detachedComment, detachedComment.length)]
-    expected: FAIL
-
-  [detachedComment.insertData(1, ""), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.insertData(2, ""), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedComment.insertData(3, ""), with selected range on detachedComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(376, "foo"), with selected range on detachedForeignComment from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(0, "foo"), with selected range collapsed at (detachedForeignComment, 0)]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(1, "foo"), with selected range collapsed at (detachedForeignComment, 1)]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(detachedForeignComment.length, "foo"), with selected range collapsed at (detachedForeignComment, detachedForeignComment.length)]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(1, "foo"), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(2, "foo"), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(3, "foo"), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(376, ""), with selected range on detachedForeignComment from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(0, ""), with selected range collapsed at (detachedForeignComment, 0)]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(1, ""), with selected range collapsed at (detachedForeignComment, 1)]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(detachedForeignComment.length, ""), with selected range collapsed at (detachedForeignComment, detachedForeignComment.length)]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(1, ""), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(2, ""), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignComment.insertData(3, ""), with selected range on detachedForeignComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(376, "foo"), with selected range on detachedXmlComment from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(0, "foo"), with selected range collapsed at (detachedXmlComment, 0)]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(1, "foo"), with selected range collapsed at (detachedXmlComment, 1)]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(detachedXmlComment.length, "foo"), with selected range collapsed at (detachedXmlComment, detachedXmlComment.length)]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(1, "foo"), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(2, "foo"), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(3, "foo"), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(376, ""), with selected range on detachedXmlComment from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(0, ""), with selected range collapsed at (detachedXmlComment, 0)]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(1, ""), with selected range collapsed at (detachedXmlComment, 1)]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(detachedXmlComment.length, ""), with selected range collapsed at (detachedXmlComment, detachedXmlComment.length)]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(1, ""), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(2, ""), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlComment.insertData(3, ""), with selected range on detachedXmlComment from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(1, "foo"), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(1, "foo"), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(1, "foo"), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(1, "foo"), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(2, "foo"), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(3, "foo"), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(1, "foo"), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(2, "foo"), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-
-  [paras[0\].firstChild.insertData(3, "foo"), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-

tests/wpt/metadata/dom/ranges/Range-mutations-removeChild.html.ini

@@ -1,32 +0,0 @@
-[Range-mutations-removeChild.html]
-  type: testharness
-  [paras[0\].parentNode.removeChild(paras[0\]), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].parentNode.removeChild(paras[0\]), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].parentNode.removeChild(paras[0\]), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].parentNode.removeChild(paras[0\]), with selected range collapsed at (testDiv, 0)]
-    expected: FAIL
-
-  [paras[0\].parentNode.removeChild(paras[0\]), with selected range on testDiv from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].parentNode.removeChild(paras[0\]), with selected range collapsed at (testDiv, 1)]
-    expected: FAIL
-
-  [paras[0\].parentNode.removeChild(paras[0\]), with selected range on testDiv from 0 to 2]
-    expected: FAIL
-
-  [paras[0\].parentNode.removeChild(paras[0\]), with selected range on testDiv from 1 to 2]
-    expected: FAIL
-
-  [paras[0\].parentNode.removeChild(paras[0\]), with selected range collapsed at (testDiv, 2)]
-    expected: FAIL
-
-  [foreignDoc.documentElement.parentNode.removeChild(foreignDoc.documentElement), with selected range on foreignDoc from 0 to foreignDoc.childNodes.length]
-    expected: FAIL
-

tests/wpt/metadata/dom/ranges/Range-mutations-replaceChild.html.ini

@@ -1,92 +0,0 @@
-[Range-mutations-replaceChild.html]
-  type: testharness
-  [testDiv.replaceChild(paras[0\], paras[0\]), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [testDiv.replaceChild(paras[0\], paras[0\]), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [testDiv.replaceChild(paras[0\], paras[0\]), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [testDiv.replaceChild(paras[0\], paras[0\]), with selected range on testDiv from 0 to 2]
-    expected: FAIL
-
-  [testDiv.replaceChild(paras[0\], paras[0\]), with selected range collapsed at (testDiv, 1)]
-    expected: FAIL
-
-  [testDiv.replaceChild(paras[0\], paras[0\]), with selected range on testDiv from 1 to 2]
-    expected: FAIL
-
-  [testDiv.replaceChild(paras[0\], paras[0\]), with selected range collapsed at (testDiv, 2)]
-    expected: FAIL
-
-  [paras[0\].replaceChild(paras[1\], paras[0\].firstChild), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].replaceChild(paras[1\], paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].replaceChild(paras[1\], paras[0\].firstChild), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].replaceChild(paras[1\], paras[0\].firstChild), with selected range on testDiv from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].replaceChild(paras[1\], paras[0\].firstChild), with selected range on testDiv from 0 to 2]
-    expected: FAIL
-
-  [paras[0\].replaceChild(paras[1\], paras[0\].firstChild), with selected range collapsed at (testDiv, 1)]
-    expected: FAIL
-
-  [paras[0\].replaceChild(paras[1\], paras[0\].firstChild), with selected range on testDiv from 1 to 2]
-    expected: FAIL
-
-  [foreignDoc.replaceChild(detachedComment, foreignDoc.documentElement), with selected range collapsed at (foreignDoc, 0)]
-    expected: FAIL
-
-  [foreignDoc.replaceChild(detachedComment, foreignDoc.documentElement), with selected range on foreignDoc from 0 to 1]
-    expected: FAIL
-
-  [foreignDoc.replaceChild(detachedComment, foreignDoc.documentElement), with selected range on foreignDoc from 0 to 2]
-    expected: FAIL
-
-  [foreignDoc.replaceChild(detachedComment, foreignDoc.documentElement), with selected range collapsed at (foreignDoc, 1)]
-    expected: FAIL
-
-  [foreignDoc.replaceChild(detachedComment, foreignDoc.doctype), with selected range collapsed at (foreignDoc, 0)]
-    expected: FAIL
-
-  [foreignDoc.replaceChild(detachedComment, foreignDoc.doctype), with selected range on foreignDoc from 0 to 1]
-    expected: FAIL
-
-  [foreignDoc.replaceChild(detachedComment, foreignDoc.doctype), with selected range on foreignDoc from 0 to 2]
-    expected: FAIL
-
-  [foreignDoc.replaceChild(detachedComment, foreignDoc.doctype), with selected range collapsed at (foreignDoc, 1)]
-    expected: FAIL
-
-  [paras[0\].replaceChild(xmlTextNode, paras[0\].firstChild), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].replaceChild(xmlTextNode, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].replaceChild(xmlTextNode, paras[0\].firstChild), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].replaceChild(paras[0\], paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].replaceChild(testDiv, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].replaceChild(document, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].replaceChild(foreignDoc, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].replaceChild(document.doctype, paras[0\].firstChild), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-

tests/wpt/metadata/dom/ranges/Range-mutations-splitText.html.ini

@@ -1,176 +0,0 @@
-[Range-mutations-splitText.html]
-  type: testharness
-  [paras[0\].firstChild.splitText(376), with selected range on paras[0\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(0), with selected range collapsed at (paras[0\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(1), with selected range collapsed at (paras[0\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(paras[0\].firstChild.length), with selected range collapsed at (paras[0\].firstChild, paras[0\].firstChild.length)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(1), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(2), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(3), with selected range on paras[0\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.splitText(376), with selected range on paras[1\].firstChild from 0 to 1]
-    expected: FAIL
-
-  [paras[1\].firstChild.splitText(0), with selected range collapsed at (paras[1\].firstChild, 0)]
-    expected: FAIL
-
-  [paras[1\].firstChild.splitText(1), with selected range collapsed at (paras[1\].firstChild, 1)]
-    expected: FAIL
-
-  [paras[1\].firstChild.splitText(paras[1\].firstChild.length), with selected range collapsed at (paras[1\].firstChild, paras[1\].firstChild.length)]
-    expected: FAIL
-
-  [paras[1\].firstChild.splitText(1), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.splitText(2), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [paras[1\].firstChild.splitText(3), with selected range on paras[1\].firstChild from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.splitText(376), with selected range on foreignTextNode from 0 to 1]
-    expected: FAIL
-
-  [foreignTextNode.splitText(0), with selected range collapsed at (foreignTextNode, 0)]
-    expected: FAIL
-
-  [foreignTextNode.splitText(1), with selected range collapsed at (foreignTextNode, 1)]
-    expected: FAIL
-
-  [foreignTextNode.splitText(foreignTextNode.length), with selected range collapsed at (foreignTextNode, foreignTextNode.length)]
-    expected: FAIL
-
-  [foreignTextNode.splitText(1), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.splitText(2), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [foreignTextNode.splitText(3), with selected range on foreignTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.splitText(376), with selected range on xmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [xmlTextNode.splitText(0), with selected range collapsed at (xmlTextNode, 0)]
-    expected: FAIL
-
-  [xmlTextNode.splitText(1), with selected range collapsed at (xmlTextNode, 1)]
-    expected: FAIL
-
-  [xmlTextNode.splitText(xmlTextNode.length), with selected range collapsed at (xmlTextNode, xmlTextNode.length)]
-    expected: FAIL
-
-  [xmlTextNode.splitText(1), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.splitText(2), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [xmlTextNode.splitText(3), with selected range on xmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.splitText(376), with selected range on detachedTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedTextNode.splitText(0), with selected range collapsed at (detachedTextNode, 0)]
-    expected: FAIL
-
-  [detachedTextNode.splitText(1), with selected range collapsed at (detachedTextNode, 1)]
-    expected: FAIL
-
-  [detachedTextNode.splitText(detachedTextNode.length), with selected range collapsed at (detachedTextNode, detachedTextNode.length)]
-    expected: FAIL
-
-  [detachedTextNode.splitText(1), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.splitText(2), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedTextNode.splitText(3), with selected range on detachedTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.splitText(376), with selected range on detachedForeignTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedForeignTextNode.splitText(0), with selected range collapsed at (detachedForeignTextNode, 0)]
-    expected: FAIL
-
-  [detachedForeignTextNode.splitText(1), with selected range collapsed at (detachedForeignTextNode, 1)]
-    expected: FAIL
-
-  [detachedForeignTextNode.splitText(detachedForeignTextNode.length), with selected range collapsed at (detachedForeignTextNode, detachedForeignTextNode.length)]
-    expected: FAIL
-
-  [detachedForeignTextNode.splitText(1), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.splitText(2), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedForeignTextNode.splitText(3), with selected range on detachedForeignTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.splitText(376), with selected range on detachedXmlTextNode from 0 to 1]
-    expected: FAIL
-
-  [detachedXmlTextNode.splitText(0), with selected range collapsed at (detachedXmlTextNode, 0)]
-    expected: FAIL
-
-  [detachedXmlTextNode.splitText(1), with selected range collapsed at (detachedXmlTextNode, 1)]
-    expected: FAIL
-
-  [detachedXmlTextNode.splitText(detachedXmlTextNode.length), with selected range collapsed at (detachedXmlTextNode, detachedXmlTextNode.length)]
-    expected: FAIL
-
-  [detachedXmlTextNode.splitText(1), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.splitText(2), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [detachedXmlTextNode.splitText(3), with selected range on detachedXmlTextNode from 1 to 3]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(1), with selected range collapsed at (paras[0\], 0)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(1), with selected range on paras[0\] from 0 to 1]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(1), with selected range collapsed at (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(1), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(2), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(3), with selected range from (paras[0\].firstChild, 1) to (paras[0\], 1)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(1), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(2), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-
-  [paras[0\].firstChild.splitText(3), with selected range from (paras[0\], 0) to (paras[0\].firstChild, 3)]
-    expected: FAIL
-

tests/wpt/metadata/html/browsers/the-window-object/window-properties.https.html.ini

@@ -8,9 +8,6 @@
   [Window method: print]
     expected: FAIL
 
-  [Window method: getSelection]
-    expected: FAIL
-
   [Window readonly attribute: applicationCache]
     expected: FAIL
 

tests/wpt/metadata/selection/script-and-style-elements.html.ini

@@ -0,0 +1,5 @@
+[script-and-style-elements.html]
+
+  [Selection: STYLE and SCRIPT elements should be included in Selection.toString() if they are display!=none]
+    expected: FAIL
+

tests/wpt/mozilla/meta/MANIFEST.json

@@ -12328,6 +12328,24 @@
      {}
     ]
    ],
+   "mozilla/selectionchange/selectionchange_noop.html": [
+    [
+     "mozilla/selectionchange/selectionchange_noop.html",
+     {}
+    ]
+   ],
+   "mozilla/selectionchange/selectionchange_range.html": [
+    [
+     "mozilla/selectionchange/selectionchange_range.html",
+     {}
+    ]
+   ],
+   "mozilla/selectionchange/selectionchange_selection.html": [
+    [
+     "mozilla/selectionchange/selectionchange_selection.html",
+     {}
+    ]
+   ],
    "mozilla/sequence-hole.html": [
     [
      "mozilla/sequence-hole.html",
@@ -19072,7 +19090,7 @@
    "testharness"
   ],
   "mozilla/interfaces.html": [
-   "fc82a7e82e936811024cbefadaa9cc396511942b",
+   "bb6adbde0b3452e6ea8f1db44941a08dbe236774",
    "testharness"
   ],
   "mozilla/interfaces.js": [
@@ -19435,6 +19453,18 @@
    "3b49f149b651d77b174647916d9c11c818d2993b",
    "testharness"
   ],
+  "mozilla/selectionchange/selectionchange_noop.html": [
+   "9154a9196a6fd76f48c8a91acf45ba1e26a83442",
+   "testharness"
+  ],
+  "mozilla/selectionchange/selectionchange_range.html": [
+   "6a8b06682eea12b03fb3fbe4c5ccb93db7512324",
+   "testharness"
+  ],
+  "mozilla/selectionchange/selectionchange_selection.html": [
+   "a8f4150bfcefafa7b351d329fd6bc788943fd1a0",
+   "testharness"
+  ],
   "mozilla/sequence-hole.html": [
    "0021769859417ffeb4d656f7130370b628bfac7d",
    "testharness"

tests/wpt/mozilla/tests/mozilla/interfaces.html

@@ -212,6 +212,7 @@ test_interfaces([
   "Request",
   "Response",
   "Screen",
+  "Selection",
   "ShadowRoot",
   "StereoPannerNode",
   "Storage",

tests/wpt/mozilla/tests/mozilla/selectionchange/selectionchange_noop.html

@@ -0,0 +1,25 @@
+<html>
+<head>
+  <title>Test that selectionchange doesn't fire for bad reasons</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+</head>
+<body>
+<span id="abcd">abcd</span><span id="efgh">efgh</span><span id="ijkl">ijkl</span>
+<script>
+var t = async_test("things that don't queue selectionchange");
+document.onselectionchange = () => {
+  assert_unreached("A document should not see selectionchange events when the selection isn't changing");
+}
+var r = new Range();
+r.setStart(document.getElementById("abcd"), 1);
+r.setEnd(document.getElementById("ijkl"), 1);
+var s = document.getSelection();
+assert_throws_dom("IndexSizeError", () => { s.getRangeAt(0) });
+assert_throws_dom("NotFoundError", () => { s.removeRange(r) });
+
+// selectionchange event is asynchronous, so give tasks a chance to fire.
+setTimeout(() => { t.done(); }, 1);
+</script>
+</body>
+</html>

tests/wpt/mozilla/tests/mozilla/selectionchange/selectionchange_range.html

@@ -0,0 +1,50 @@
+<html>
+<head>
+  <title>Test that selectionchange fires when Range methods cause changes</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+</head>
+<body>
+<span id="abcd">abcd</span><span id="efgh">efgh</span><span id="ijkl">ijkl</span>
+<script>
+var t = async_test("Range methods on a Selection's range fire selectionchange");
+var r = new Range();
+var abcd = document.getElementById("abcd");
+var efgh = document.getElementById("efgh");
+var ijkl = document.getElementById("ijkl");
+r.setStart(abcd, 0);
+r.setEnd(ijkl, 1);
+var s = document.getSelection();
+s.addRange(r);
+// A task is now queued that will fire a selectionchange event,
+// so the following listener will be called soon, even though it wasn't
+// listening at the time we added the range.
+var step = 0;
+document.onselectionchange = () => {
+  t.step(() => {
+    switch(step++) {
+      case 0: r.setStart(ijkl, 1); break;
+      case 1: r.setStartAfter(efgh); break;
+      case 2: r.setStartBefore(abcd); break;
+      case 3: r.setEnd(abcd, 1); break;
+      case 4: r.setEndAfter(efgh); break;
+      case 5: r.setEndBefore(efgh); break;
+      case 6: r.collapse(); break;
+      case 7: r.selectNode(efgh); break;
+      case 8: r.selectNodeContents(abcd); break;
+      case 9: r.insertNode(efgh);
+      case 10: r.surroundContents(ijkl); break;
+      case 11: queueFinish(); break;
+      case 12: assert_unreached("Too many selectionchange events");
+    }
+  },"Step number "+step);
+}
+function queueFinish() {
+  // Finish slightly later than the last selectionchange task,
+  // so if there are any extra ones queued we have time to
+  // hit the assert_unreached.
+  setTimeout(() => { t.done(); }, 1);
+}
+</script>
+</body>
+</html>

tests/wpt/mozilla/tests/mozilla/selectionchange/selectionchange_selection.html

@@ -0,0 +1,51 @@
+<html>
+<head>
+  <title>Test that selectionchange fires when Selection methods cause changes</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+</head>
+<body>
+<span id="abcd">abcd</span><span id="efgh">efgh</span><span id="ijkl">ijkl</span>
+<script>
+var t = async_test("Selection methods fire selectionchange");
+var r = new Range();
+var abcd = document.getElementById("abcd");
+var efgh = document.getElementById("efgh");
+var ijkl = document.getElementById("ijkl");
+r.setStart(abcd, 0);
+r.setEnd(ijkl, 1);
+var s = document.getSelection();
+s.addRange(r);
+// A task is now queued that will fire a selectionchange event,
+// so the following listener will be called soon, even though it wasn't
+// listening at the time we added the range.
+var step = 0;
+document.onselectionchange = () => {
+  t.step(() => {
+    switch(step++) {
+      // order chosen so that s.type always changes between consecutive steps
+      case 0: assert_equals(s.type, "Range"); s.removeRange(r); break;
+      case 1: assert_equals(s.type, "None"); s.collapse(efgh, 0); break;
+      case 2: assert_equals(s.type, "Caret"); s.removeAllRanges(); break;
+      case 3: assert_equals(s.type, "None"); s.setPosition(efgh, 1); break;
+      case 4: assert_equals(s.type, "Caret"); s.extend(ijkl, 1); break;
+      case 5: assert_equals(s.type, "Range"); s.collapseToStart(); break;
+      case 6: assert_equals(s.type, "Caret"); s.setBaseAndExtent(abcd, 0, efgh, 0); break;
+      case 7: assert_equals(s.type, "Range"); s.collapseToEnd(); break;
+      case 8: assert_equals(s.type, "Caret"); s.empty(); break;
+      case 9: assert_equals(s.type, "None"); s.selectAllChildren(efgh); break;
+      case 10: assert_equals(s.type, "Range"); s.deleteFromDocument(); break;
+      case 11: assert_equals(s.type, "Caret"); queueFinish(); break;
+      case 12: assert_unreached("Too many selectionchange events");
+    }
+  },"Step number "+step);
+}
+function queueFinish() {
+  // Finish slightly later than the last selectionchange task,
+  // so if there are any extra ones queued we have time to
+  // hit the assert_unreached.
+  setTimeout(() => { t.done(); }, 1);
+}
+</script>
+</body>
+</html>